SCTPSocket.cpp

#include "SCTPSocket.h"
#include "TempFailure.h"

#include <vector>
#include <netinet/in.h>
#include <poll.h>

using namespace NET;

SCTPSocket::SCTPSocket( uint16_t numOutStreams /* = 10 */,
                        uint16_t maxInStreams /* = 65535 */,
                        uint16_t maxAttempts /* = 4 */,
                        uint16_t maxInitTimeout /* = 0 */)
: InternetSocket( STREAM, IPPROTO_SCTP)
{
	setInitValues( numOutStreams, maxInStreams, maxAttempts, maxInitTimeout);
}

SCTPSocket::SCTPSocket( Handle handle)
: InternetSocket( handle.release() )
{}

int SCTPSocket::bind( const std::vector<std::string>& localAddresses, unsigned short localPort /* = 0 */)
{
	size_t size = localAddresses.size();
	std::vector<sockaddr_in> dest(size);

	for( size_t i = 0; i < size; ++i)
		fillAddress( localAddresses[i], localPort, dest[i]);

	int ret = sctp_bindx( m_socket, reinterpret_cast<sockaddr*>(dest.data()), static_cast<int>(size), SCTP_BINDX_ADD_ADDR);
	if(ret < 0)
		throw SocketException("Set of local address and port failed (sctp_bindx)");
	return ret;
}

int SCTPSocket::connect( const std::vector<std::string>& foreignAddresses, unsigned short foreignPort /* = 0 */)
{
	size_t size = foreignAddresses.size();
	std::vector<sockaddr_in> dest(size);

	for( size_t i = 0; i < size; ++i)
		fillAddress( foreignAddresses[i], foreignPort, dest[i]);

	// TODO maybe save connection id for later use
	int ret = sctp_connectx( m_socket, reinterpret_cast<sockaddr*>(dest.data()), static_cast<int>(size), 0);
	if(ret < 0)
		throw SocketException("Connect failed (sctp_connectx)");

	m_peerDisconnected = false;
	return ret;
}

int SCTPSocket::state() const
{
	struct sctp_status status;
	socklen_t size = sizeof(status);
	if( getsockopt( m_socket, IPPROTO_SCTP, SCTP_STATUS, &status, &size) < 0)
		throw SocketException("SCTPSocket::state failed (getsockopt)");
	return status.sstat_state;
}

int SCTPSocket::notAckedData() const
{
	struct sctp_status status;
	socklen_t size = sizeof(status);
	if( getsockopt( m_socket, IPPROTO_SCTP, SCTP_STATUS, &status, &size) < 0)
		throw SocketException("SCTPSocket::notAckedData failed (getsockopt)");
	return status.sstat_unackdata;
}

int SCTPSocket::pendingData() const
{
	struct sctp_status status;
	socklen_t size = sizeof(status);
	if( getsockopt( m_socket, IPPROTO_SCTP, SCTP_STATUS, &status, &size) < 0)
		throw SocketException("SCTPSocket::pendingData failed (getsockopt)");
	return status.sstat_penddata;
}

unsigned SCTPSocket::inStreams() const
{
	struct sctp_status status;
	socklen_t size = sizeof(status);
	if( getsockopt( m_socket, IPPROTO_SCTP, SCTP_STATUS, &status, &size) < 0)
		throw SocketException("SCTPSocket::inStreams failed (getsockopt)");
	return status.sstat_instrms;
}

unsigned SCTPSocket::outStreams() const
{
	struct sctp_status status;
	socklen_t size = sizeof(status);
	if( getsockopt( m_socket, IPPROTO_SCTP, SCTP_STATUS, &status, &size) < 0)
		throw SocketException("SCTPSocket::outStreams failed (getsockopt)");
	return status.sstat_outstrms;
}

unsigned SCTPSocket::fragmentationPoint() const
{
	struct sctp_status status;
	socklen_t size = sizeof(status);
	if( getsockopt( m_socket, IPPROTO_SCTP, SCTP_STATUS, &status, &size) < 0)
		throw SocketException("SCTPSocket::fragmentationPoint failed (getsockopt)");
	return status.sstat_fragmentation_point;
}

std::string SCTPSocket::primaryAddress() const
{
	return std::string(); // TODO
}

int SCTPSocket::send( const void* data, size_t length, uint16_t stream, unsigned ttl /* = 0 */, unsigned context /* = 0 */,
                      unsigned ppid /* = 0 */, abortFlag abort /* = KEEPALIVE */, switchAddressFlag switchAddr /* = KEEP_PRIMARY */)
{
	int ret = sctp_sendmsg( m_socket, data, length, nullptr, 0, ppid, abort + switchAddr, stream, ttl, context);
	if( ret < 0)
		throw SocketException("SCTPSocket::send failed (sctp_sendmsg)");
	else if (static_cast<size_t>(ret) < length)
		throw SocketException("SCTP sent a fragemented packet!");
	return ret;
}

int SCTPSocket::sendUnordered( const void* data, size_t length, uint16_t stream, unsigned ttl /* = 0 */, unsigned context /* = 0 */,
                               unsigned ppid /* = 0 */, abortFlag abort /* = KEEPALIVE */,
                               switchAddressFlag switchAddr /* = KEEP_PRIMARY */)
{
	int ret = sctp_sendmsg( m_socket, data, length, nullptr, 0, ppid, abort + switchAddr + SCTP_UNORDERED, stream, ttl, context);
	if( ret < 0)
		throw SocketException("SCTPSocket::send failed (sctp_sendmsg)");
	else if (static_cast<size_t>(ret) < length)
		throw SocketException("SCTP sent a fragemented packet!");
	return ret;
}

int SCTPSocket::receive( void* data, size_t maxLen, uint16_t& stream)
{
	struct sctp_sndrcvinfo info;
	int ret;
	if( (ret = sctp_recvmsg( m_socket, data, maxLen, 0, 0, &info, 0)) < 0)
		throw SocketException("SCTPSocket::receive failed (sctp_recvmsg)");
	stream = info.sinfo_stream;
	return ret;
}

int SCTPSocket::receive( void* data, size_t maxLen, uint16_t& stream, receiveFlag& flag)
{
	struct sctp_sndrcvinfo info;
	int ret;
	if( (ret = sctp_recvmsg( m_socket, data, maxLen, 0, 0, &info, 0)) < 0)
		throw SocketException("SCTPSocket::receive failed (sctp_recvmsg)");
	stream = info.sinfo_stream;
	flag = static_cast<receiveFlag>(info.sinfo_flags);
	return ret;
}

int SCTPSocket::timedReceive( void* data, size_t maxLen, uint16_t& stream, int timeout)
{
	struct pollfd poll;
	poll.fd = m_socket;
	poll.events = POLLIN | POLLPRI | POLLRDHUP;

	int ret = TEMP_FAILURE_RETRY (::poll( &poll, 1, timeout));

	if( ret == 0) return 0;
	if( ret < 0) throw SocketException("SCTPSocket::timedReceive failed (poll)");

	if( poll.revents & POLLRDHUP)
		m_peerDisconnected = true;

	if( poll.revents & POLLIN || poll.revents & POLLPRI)
		return receive( data, maxLen, stream);

	return 0;
}

int SCTPSocket::timedReceive( void* data, size_t maxLen, uint16_t& stream, receiveFlag& flag, int timeout)
{
	struct pollfd poll;
	poll.fd = m_socket;
	poll.events = POLLIN | POLLPRI | POLLRDHUP;

	int ret = TEMP_FAILURE_RETRY (::poll( &poll, 1, timeout));

	if( ret == 0) return 0;
	if( ret < 0) throw SocketException("SCTPSocket::timedReceive failed (poll)");

	if( poll.revents & POLLRDHUP)
		m_peerDisconnected = true;

	if( poll.revents & POLLIN || poll.revents & POLLPRI)
		return receive( data, maxLen, stream, flag);

	return 0;
}

void SCTPSocket::listen( int backlog /* = 5 */)
{
	int ret = ::listen( m_socket, backlog);
	if( ret < 0)
		throw SocketException("listen failed, most likely another socket is already listening on the same port");
}

SCTPSocket::Handle SCTPSocket::accept() const
{
	int ret = ::accept( m_socket, 0, 0);
	if( ret < 0)
		throw SocketException("SCTPSocket::accept failed (accept)");
	return Handle(ret);
}

SCTPSocket::Handle SCTPSocket::timedAccept( int timeout) const
{
	struct pollfd poll;
	poll.fd = m_socket;
	poll.events = POLLIN;

	int ret = TEMP_FAILURE_RETRY (::poll( &poll, 1, timeout));

	if( ret == 0) return Handle();
	if( ret < 0) throw SocketException("SCTPSocket::timedAccept failed (poll)");

	ret = ::accept( m_socket, 0, 0);
	if( ret < 0)
		throw SocketException("SCTPSocket::timedAccept failed (accept)");
	return Handle(ret);
}

void SCTPSocket::setInitValues( uint16_t numOutStreams, uint16_t maxInStreams, uint16_t maxAttempts, uint16_t maxInitTimeout)
{
	struct sctp_initmsg init;
	init.sinit_num_ostreams = numOutStreams;
	init.sinit_max_instreams = maxInStreams;
	init.sinit_max_attempts = maxAttempts;
	init.sinit_max_init_timeo = maxInitTimeout;

	int ret = setsockopt( m_socket, IPPROTO_SCTP, SCTP_INITMSG, &init, sizeof(init));
	if( ret < 0)
		throw SocketException("SCTPSocket construction failed (setsockopt)");
}