bool Socket::CreateAndConnectTCPSocket(const AdressImplementation& p_connectAdress)
{
// Create Socket
CreateTCPSocket();
// Connect to adress
return ConnectTCPSocket(p_connectAdress);
}
void TCPClient::Init()
{
CreateTCPSocket();
SetReceiveTimeout(this->_tcp_socket);
SetSendTimeout(this->_tcp_socket);
Connect();
cout << "Connected to " << this->address << ":" << this->port << endl;
}
void Socket::CreateWaitingTCPSocket(const AdressImplementation& p_myAdress, const uint8_t& p_maxConnections)
{
// Create Socket
CreateTCPSocket();
// Set adress and bind socket to port
BindSocket(p_myAdress);
// Set socket to nonblocking
SetNonBlocking();
// Set socket to listening with max number of connections to port
listen(m_socketHandle, p_maxConnections);
}
void DoClientConnect( const char *pIP )
{
#if defined( USE_MPI )
int argc = 1;
char *testargv[1] = { "-nounc" };
char **argv = testargv;
if ( MPI_Init( &argc, &argv ) )
{
assert( false );
}
MPI_Comm_rank( MPI_COMM_WORLD, &myProcId );
int nProcs;
MPI_Comm_size( MPI_COMM_WORLD, &nProcs );
if ( nProcs != 2 )
{
assert( false );
}
#else
// Try to connect, or listen.
ITCPSocket *pTCPSocket = CreateTCPSocket();
if ( !pTCPSocket->BindToAny( 0 ) )
{
assert( false );
}
CIPAddr addr;
if ( !ConvertStringToIPAddr( pIP, &addr ) )
{
assert( false );
}
addr.port = g_iPortNum;
printf( "Client connecting to %d.%d.%d.%d:%d\n", addr.ip[0], addr.ip[1], addr.ip[2], addr.ip[3], addr.port );
if ( !TCPSocket_Connect( pTCPSocket, &addr, 50000 ) )
{
assert( false );
}
printf( "Client connected...\n ");
g_pSocket = pTCPSocket;
#endif
}
Server::Server(unsigned int port)
{
this->port = port;
_udp_socket = CreateUDPSocket();
CreateTCPSocket();
Bind(_udp_socket);
Bind(this->_tcp_socket);
SetSendTimeout(this->_tcp_socket);
SetReceiveTimeout(_udp_socket, GetTimeout(100));
Listen();
FD_ZERO(&this->clientsSet);
FD_ZERO(&this->serverSet);
FD_SET(this->_tcp_socket, &this->serverSet);
FD_SET(_udp_socket, &this->serverSet);
std::cout << "Server started at port: " << this->port << std::endl;
}
static Socket* tcpsock_accept(Socket *sock, struct sockaddr *addr, size_t *addrlenptr)
{
TCPSocket *tcpsock = (TCPSocket*) sock;
if (tcpsock->state != TCP_LISTENING)
{
ERRNO = EINVAL;
return NULL;
};
if (addrlenptr != NULL)
{
if ((*addrlenptr) < INET_SOCKADDR_LEN)
{
ERRNO = EINVAL;
return NULL;
};
};
int count = semWaitGen(&tcpsock->semConnWaiting, 1, SEM_W_FILE(sock->fp->oflags), sock->options[GSO_RCVTIMEO]);
if (count < 0)
{
ERRNO = -count;
return NULL;
};
// a connection is pending, create the socket.
// TODO: there is a race condition where we remove the pending connection from the list,
// and another SYN arrives before we add the socket to the list, causing another connection
// request to be created. We must work on that somehow.
Socket *client = CreateTCPSocket();
client->domain = sock->domain;
client->type = SOCK_STREAM;
client->proto = IPPROTO_TCP;
memset(client->options, 0, 8*GSO_COUNT);
TCPSocket *tcpclient = (TCPSocket*) client;
semWait(&tcpsock->lock);
TCPPending *pend = tcpsock->firstPending;
tcpsock->firstPending = pend->next;
semSignal(&tcpsock->lock);
semWait(&tcpclient->lock);
memcpy(&tcpclient->sockname, &pend->local, sizeof(struct sockaddr));
memcpy(&tcpclient->peername, &pend->peer, sizeof(struct sockaddr));
tcpclient->state = TCP_ESTABLISHED;
tcpclient->nextSeqNo = (uint32_t) getRandom();
tcpclient->nextAckNo = pend->ackno;
tcpclient->currentOut = CreateOutbound(&tcpclient->sockname, &tcpclient->peername, 0);
tcpclient->expectedAck = tcpclient->nextSeqNo;
TCPSegment *syn = tcpclient->currentOut->segment;
if (sock->domain == AF_INET)
{
syn->srcport = ((struct sockaddr_in*)&pend->local)->sin_port;
syn->dstport = ((struct sockaddr_in*)&pend->peer)->sin_port;
}
else
{
syn->srcport = ((struct sockaddr_in6*)&pend->local)->sin6_port;
syn->dstport = ((struct sockaddr_in6*)&pend->peer)->sin6_port;
};
syn->seqno = htonl(tcpclient->nextSeqNo-1);
syn->ackno = htonl(pend->ackno);
syn->dataOffsetNS = 0x50;
syn->flags = TCP_SYN | TCP_ACK;
syn->winsz = htons(TCP_BUFFER_SIZE);
ChecksumOutbound(tcpclient->currentOut);
KernelThreadParams pars;
memset(&pars, 0, sizeof(KernelThreadParams));
pars.stackSize = DEFAULT_STACK_SIZE;
pars.name = "TCP Thread";
tcpclient->thread = CreateKernelThread(tcpThread, &pars, tcpclient);
semSignal(&tcpclient->lock);
semSignal(&tcpclient->semConnected);
if (addrlenptr != NULL) *addrlenptr = INET_SOCKADDR_LEN;
if (addr != NULL)
{
memcpy(addr, &pend->peer, INET_SOCKADDR_LEN);
};
kfree(pend);
return client;
};
