TCPClientSocket::TCPClientSocket(const char* destination, Bit16u port) {
#ifdef NATIVESOCKETS
nativetcpstruct=0;
#endif
sendbuffer=0;
isopen = false;
if(!SDLNetInited) {
if(SDLNet_Init()==-1) {
LOG_MSG("SDLNet_Init failed: %s\n", SDLNet_GetError());
return;
}
SDLNetInited = true;
}
mysock=0;
listensocketset=0;
IPaddress openip;
//Ancient versions of SDL_net had this as char*. People still appear to be using this one.
if (!SDLNet_ResolveHost(&openip,const_cast<char*>(destination),port)) {
listensocketset = SDLNet_AllocSocketSet(1);
if(!listensocketset) return;
mysock = SDLNet_TCP_Open(&openip);
if(!mysock) return;
SDLNet_TCP_AddSocket(listensocketset, mysock);
isopen=true;
}
}
bool TCPConnectionServer::StartServer( )
{
if (!isServer )
{
std::cout << "TCPConnection.cpp@" << __LINE__ << " Not in server mode, can't start server" << std::endl;
return false;
}
bool quit = false;
while ( !quit )
{
if ( AcceptConnection() )
{
std::cout << "TCPConnection.cpp@" << __LINE__ << "Accepted connection...\n";
if ( SetServerSocket() )
{
SDLNet_TCP_AddSocket( socketSet, serverSocket[ serverSocket.size() - 1] );
quit = true;
return true;
}
}
SDL_Delay( 20 );
}
return false;
}
TCPClientSocket::TCPClientSocket(TCPsocket source) {
#ifdef NATIVESOCKETS
nativetcpstruct=0;
#endif
sendbuffer=0;
isopen = false;
if(!SDLNetInited) {
if(SDLNet_Init()==-1) {
LOG_MSG("SDLNet_Init failed: %s\n", SDLNet_GetError());
return;
}
SDLNetInited = true;
}
mysock=0;
listensocketset=0;
if(source!=0) {
mysock = source;
listensocketset = SDLNet_AllocSocketSet(1);
if(!listensocketset) return;
SDLNet_TCP_AddSocket(listensocketset, source);
isopen=true;
}
}
bool NetClient::connecttoserver()
{
//if(SDLNet_ResolveHost(&ip, game_values.hostaddress, 12521) == -1)
//if(SDLNet_ResolveHost(&ip, "10.115.8.222", 12521) == -1)
//if(SDLNet_ResolveHost(&ip, "10.115.5.65", 12521) == -1)
if(SDLNet_ResolveHost(&ip, "192.168.0.2", 12521) == -1)
//if(SDLNet_ResolveHost(&ip, "127.0.0.1", 12521) == -1)
{
printf("SDLNet_ResolveHost: %s\n", SDLNet_GetError());
return false;
}
tcpsock = SDLNet_TCP_Open(&ip);
if(!tcpsock) {
printf("SDLNet_TCP_Open: %s\n", SDLNet_GetError());
return false;
}
/* Allocate the socket set for polling the network */
socketset = SDLNet_AllocSocketSet(1);
if (socketset == NULL) {
printf("Couldn't create socket set: %s\n", SDLNet_GetError());
return false;
}
SDLNet_TCP_AddSocket(socketset, tcpsock);
return true;
}
int game_host::waitForClient_test()
{
cout << "waiting for first player to connect...\n";
while(!(player1sd = SDLNet_TCP_Accept(sd))) //wait for first connection, with 50ms delay to keep CPU down
SDL_Delay(50);
string ipMess = "";
while(SDLNet_UDP_Recv(p1UDPsock, UDPpack1) == 0)
SDL_Delay(5);
SDLNet_UDP_Bind(p1UDPsock,10,&(UDPpack1->address));
cout << this->recieveMessagep1() << "\n"; //on successful connect, client sends a message
SDLNet_TCP_AddSocket(socketset, player1sd); //could error check here
this->player1ip = SDLNet_TCP_GetPeerAddress(player1sd);
//SDLNet_ResolveHost(&(UDPpack1->address), cl.c_str(), port);
//player2ip->host = SDLNet_TCP_GetPeerAddress(player1sd)->host;
//player2ip->port = port;
//UDPpack1->address = *player1ip;
sendtoP1_test("1SIG:START");
cout << "client connected, continuing...\n";
return 1;
}
/* Setup TCP Server, and wait for a single
* client to connect */
int setup_server(unsigned port) {
#if !defined(PSP) && !defined(EMSCRIPTEN) && !defined(DREAMCAST) && !defined(THREE_DS)
is_server = 1;
log_message(LOG_INFO, "Starting server on port %u\n",port);
//SDL_INIT(SDL_INIT_EVERYTHING);
SDLNet_Init();
IPaddress ip;
SDLNet_ResolveHost(&ip, NULL, port);
server = SDLNet_TCP_Open(&ip);
log_message(LOG_INFO, "Waiting for client to connect\n");
while (client == NULL) {
client = SDLNet_TCP_Accept(server);
SDL_Delay(1000);
}
const char * message = "Welcome to GB server";
SDLNet_TCP_Send(client, message, strlen(message) + 1);
log_message(LOG_INFO, "Client successfully connected\n");
socketset = SDLNet_AllocSocketSet(1);
SDLNet_TCP_AddSocket(socketset, client);
connection_up = 1;
return 1;
#endif
return 0;
}
void new_connection(TCPsocket sock) {
TCPsocket tmp;
struct socket_node *socket;
IPaddress *ip;
/* accept the connection temporarily */
tmp = SDLNet_TCP_Accept(sock);
if (!tmp)
do_error(SDLNet_GetError());
/* are we full or game already started? */
if (get_active_players() + 1 > NUM_PLAYERS || current_turn)
SDLNet_TCP_Close(tmp);
else {
/* nope! */
socket = new_socket(SOCKET_CLIENT);
socket->sock = tmp;
if (SDLNet_TCP_AddSocket(sockset, tmp) < 0)
do_error(SDLNet_GetError());
ip = SDLNet_TCP_GetPeerAddress(tmp);
if (!ip)
do_error(SDLNet_GetError());
if (SDLNet_ResolveIP(ip))
strcpy(socket->host, SDLNet_ResolveIP(ip));
else
sprintf(socket->host, "Unknown IP");
join_player(socket); /* add player to game */
}
}
bool IRC::connect(const std::string &serverName, int serverPort, const std::string &nick)
{
disconnect();
IPaddress ip;
socketSet = SDLNet_AllocSocketSet(1);
if (SDLNet_ResolveHost(&ip, (char *)serverName.c_str(), serverPort)==-1)
{
fprintf(stderr, "YOG : ResolveHost: %s\n", SDLNet_GetError());
return false;
}
socket = SDLNet_TCP_Open(&ip);
if (!socket)
{
fprintf(stderr, "YOG : TCP_Open: %s\n", SDLNet_GetError());
return false;
}
SDLNet_TCP_AddSocket(socketSet, socket);
// Here we change the nick on yog for the IRC
// changing from nick = "nick" to YOGnick = "YOGnick"
this->nick = "[YOG]" + nick;
sendString("USER " + this->nick + " undef undef " + PACKAGE_TARNAME + "-" + PACKAGE_VERSION);
sendString("NICK " + this->nick);
return true;
}
void accept_connections()
{
if (SDLNet_SocketReady(serversock))
{
TCPsocket client = SDLNet_TCP_Accept(serversock);
if (client)
{
clients.push_back(new ClientConnection(clients.size()+1, client));
std::stringstream out;
out << "version 0" << std::endl;
out << "your_id " << clients.size() << std::endl;
std::string str = out.str();
SDLNet_TCP_Send(client, const_cast<char*>(str.c_str()), str.length()+1);
IPaddress* ip = SDLNet_TCP_GetPeerAddress(client);
const char* host;
if((host = SDLNet_ResolveIP(ip)) != 0)
std::cout << "# Got client connection from " << host << " " << ip->port << std::endl;
else
std::cout << "# Got client connection from " << ip->host << " " << ip->port << std::endl;
int numused = SDLNet_TCP_AddSocket(socketset, client);
if (numused == -1) {
printf("SDLNet_AddSocket: %s\n", SDLNet_GetError());
// perhaps you need to restart the set and make it bigger...
}
else
{
std::cout << "# Sockets used: " << numused << std::endl;
}
}
}
}
int TCP_RECEIVEOBJ::connect()
{
sock=0;
if(SDLNet_ResolveHost(&ip, host, PORT) == -1)
{
strcpy(szdata, "SDLNet_ResolveHost: "); strcat(szdata, SDLNet_GetError());
report_error(szdata); return(FALSE);
}
sock = SDLNet_TCP_Open(&ip);
if(!sock)
{
strcpy(szdata, "SDLNet_TCP_Open: "); strcat(szdata, SDLNet_GetError());
report_error(szdata);return(FALSE);
}
set = SDLNet_AllocSocketSet(1);
if(!set)
{
strcpy(szdata,"SDLNet_AllocSocketSet: "); strcat(szdata, SDLNet_GetError());
report_error(szdata);return(FALSE);
}
if (SDLNet_TCP_AddSocket(set, sock) == -1)
{
strcpy(szdata,"SDLNet_TCP_AddSocket: ");strcat(szdata, SDLNet_GetError());
report_error(szdata);return(FALSE);
}
if (!sock) return(FALSE);
cout<<"connected.";
return(TRUE);
}
void Connection::makeSet(int max){
ScopedMutexLock(pimpl_->dataAccess);
// remove from old group
if( pimpl_->group && pimpl_->userSocket ){
SDLNet_TCP_DelSocket(pimpl_->group, pimpl_->userSocket);
}
// if internal set was used, destroy it
if( pimpl_->createdSet ) {
SDLNet_FreeSocketSet(pimpl_->group);
pimpl_->group = NULL;
pimpl_->createdSet = false;
}
//create new set
pimpl_->group = SDLNet_AllocSocketSet(max);
if( pimpl_->group == NULL ){
std::cerr << __FILE__ << " " << __LINE__ << ": " << "SDLNet_AllocSocketSet(" << max << "): " << SDLNet_GetError() << std::endl;
exit(EXIT_FAILURE);
} else {
// add self to new group
if( pimpl_->userSocket ){
SDLNet_TCP_AddSocket(pimpl_->group, pimpl_->userSocket);
}
pimpl_->createdSet = 1;
}
}
/**************************************
* CLIENT
*************************************/
int BomberNetClient::connectClient(SDL_Surface * vout_buf) {
errorCode = 0;
IPaddress serverIP;
fprintf(stderr, "%s\n", GameConfig::Instance().getIpString());
viewer = new ClientViewer(vout_buf);
startKeystateThread();
SDLNet_ResolveHost(&serverIP, GameConfig::Instance().getIpString(), GameConfig::Instance().getPortValue());
if (serverIP.host == INADDR_NONE) {
fprintf(stderr, "Couldn't resolve hostname\n");
cleanup();
} else {
/* If we fail, it's okay, the GUI shows the problem */
tcpsock = SDLNet_TCP_Open(&serverIP);
if (tcpsock == NULL) {
fprintf(stderr, "Connect failed\n");
cleanup();
return 1;
} else {
fprintf(stderr, "Connection established !\n");
socketset = SDLNet_AllocSocketSet(1);
SDLNet_TCP_AddSocket(socketset, tcpsock);
alive = true;
net_thread = SDL_CreateThread(net_thread_main, "tcp client thread", tcpsock);
return 0;
}
}
return 2;
}
void
ServerConnection::connect(const char* hostname, Uint16 port)
{
IPaddress ip;
if(SDLNet_ResolveHost(&ip, hostname, port) == -1)
{
printf("SDLNet_ResolveHost: %s\n", SDLNet_GetError());
exit(1);
}
tcpsock = SDLNet_TCP_Open(&ip);
if(!tcpsock)
{
printf("SDLNet_TCP_Open: %s %s:%d\n", SDLNet_GetError(), hostname, port);
exit(2);
}
else
{
std::string line = "client_version 1\n";
SDLNet_TCP_Send(tcpsock, const_cast<char*>(line.c_str()), line.length());
socketset = SDLNet_AllocSocketSet(1);
SDLNet_TCP_AddSocket(socketset, tcpsock);
}
}
/* Setup TCP Client, and attempt to connect
* to the server */
int setup_client(unsigned port) {
#if !defined(PSP) && !defined(EMSCRIPTEN) && !defined(DREAMCAST) && !defined(THREE_DS)
is_client = 1;
log_message(LOG_INFO, "Attempting to connect to server on port %u\n",port);
//SDL_INIT(SDL_INIT_EVERYTHING);
SDLNet_Init();
IPaddress ip;
//TODO, for now always connect to localhost, fix for any specified ip in
//the future
SDLNet_ResolveHost(&ip, "localhost", port);
client = SDLNet_TCP_Open(&ip);
socketset = SDLNet_AllocSocketSet(1);
char buf[100];
int i = SDLNet_TCP_Recv(client, buf, 100);
for (int j = 0; j < i; j++) {
printf("%c",buf[j]);
}
printf("\n");
SDLNet_TCP_AddSocket(socketset, client);
connection_up = 1;
return 1;
#endif
return 0;
}
bool NetServer::startserver()
{
socketset = SDLNet_AllocSocketSet(MAXCLIENTS + 1);
if (socketset == NULL) {
printf("Couldn't create socket set: %s\n", SDLNet_GetError());
return false;
}
SDLNet_ResolveHost(&ip, NULL, 12521);
printf("Server IP: %x:%d\n", ip.host, ip.port);
tcpsock = SDLNet_TCP_Open(&ip);
if (tcpsock == NULL) {
cleanup();
printf("Couldn't create server socket: %s\n", SDLNet_GetError());
return false;
}
SDLNet_TCP_AddSocket(socketset, tcpsock);
return true;
}
Socket::Socket(TCPsocket sock) : error(false), sock(sock) {
set = SDLNet_AllocSocketSet(1);
if (set == NULL)
error = true;
else
SDLNet_TCP_AddSocket(set, sock);
}
void Users::process(){
int n = SDLNet_CheckSockets(set, 0);
if (n < 1) return;
if (SDLNet_SocketReady(sock)){
printf("new user...\n");
TCPsocket newuser = SDLNet_TCP_Accept(sock);
printf("Accepted...\n");
User *u = new User(newuser);
push_back(u);
SDLNet_TCP_AddSocket(set,newuser);
}
User *u;
for( iterator i = begin(); i != end(); i++ ){
u = *i;
if (SDLNet_SocketReady(u->sock)){
int len;
char buf[MAXLEN];
if ((len = readLine(u->sock,buf,sizeof(buf))) > 0){
fprintf(stderr,"got len=%d text from '%s': '%s'\n",len,u->name,buf);
handle_command(buf,u);
} else {
printf("dead connection\n");
SDLNet_TCP_DelSocket(set, u->sock);
SDLNet_TCP_Close(u->sock);
i = erase(i);
}
}
}
}
/* create a socket set that has the server socket and all the client sockets */
SDLNet_SocketSet create_sockset()
{
static SDLNet_SocketSet set=NULL;
int i;
if(set)
SDLNet_FreeSocketSet(set);
set=SDLNet_AllocSocketSet(num_clients+1);
if(!set) {
printf("SDLNet_AllocSocketSet: %s\n", SDLNet_GetError());
exit(1); /*most of the time this is a major error, but do what you want. */
}
SDLNet_TCP_AddSocket(set,server);
for(i=0;i<num_clients;i++)
SDLNet_TCP_AddSocket(set,clients[i].sock);
return(set);
}
Connection::Connection(SDLNet_SocketSet& newGroup, TCPsocket& newUserSocket) : pimpl_(new ConnectionImpl){
++pimpl_->refCount;
pimpl_->group = newGroup;
pimpl_->userSocket = newUserSocket;
if( newGroup && newUserSocket ){
SDLNet_TCP_AddSocket(pimpl_->group, pimpl_->userSocket);
}
}
void Users::connect(Universe *_u){
u = _u;
SDLNet_Init();
SDLNet_ResolveHost(&ip,NULL,port);
sock = SDLNet_TCP_Open(&ip);
set = SDLNet_AllocSocketSet(10);
SDLNet_TCP_AddSocket(set,sock);
}
Connection* Connection_create(const char* ip, Uint16 port)
{
Connection* self = (Connection*)calloc(1, sizeof(Connection));
if(!self)
{
return NULL;
}
if(SDLNet_ResolveHost(&self->address, ip, port))
{
Connection_destroy(&self);
return NULL;
}
if(!(self->socket = SDLNet_TCP_Open(&self->address)))
{
Connection_destroy(&self);
return NULL;
}
if(!(self->socket_set = SDLNet_AllocSocketSet(1)))
{
Connection_destroy(&self);
return NULL;
}
if(SDLNet_TCP_AddSocket(self->socket_set, self->socket) == -1)
{
Connection_destroy(&self);
return NULL;
}
if(SDLNet_CheckSockets(self->socket_set, 5000) == 1)
{
Uint8 message = Connection_recv_flag(self);
if(message == CONNECTED)
{
Uint8 buffer[6] = {0};
Connection_recv_data(self, buffer, 6);
self->local_address.host = SDLNet_Read32(buffer);
self->local_address.port = SDLNet_Read16(buffer + 4);
printf("Successfully connected to server\n");
return self;
}
else if(message == FULL)
{
printf("Server is full\n");
}
}
else
{
printf("Server is not responding\n");
}
Connection_destroy(&self);
return NULL;
}
void NetServer::handleserver()
{
int which;
unsigned char data;
TCPsocket newsock = SDLNet_TCP_Accept(tcpsock);
if (newsock == NULL)
return;
/* Look for unconnected person slot */
for (which = 0; which < MAXCLIENTS; ++which) {
if (!clients[which].sock) {
break;
}
}
if (which == MAXCLIENTS) {
/* Look for inactive person slot */
for (which = 0; which < MAXCLIENTS; ++which) {
if (clients[which].sock && !clients[which].active) {
/* Kick them out.. */
data = NET_MSG_REJECT;
SDLNet_TCP_Send(clients[which].sock, &data, 1);
SDLNet_TCP_DelSocket(socketset, clients[which].sock);
SDLNet_TCP_Close(clients[which].sock);
numclients--;
#ifdef _DEBUG
printf("Killed inactive socket %d\n", which);
#endif
break;
}
}
}
if (which == MAXCLIENTS) {
/* No more room... */
data = NET_MSG_REJECT;
SDLNet_TCP_Send(newsock, &data, 1);
SDLNet_TCP_Close(newsock);
#ifdef _DEBUG
printf("Connection refused -- server full\n");
#endif
} else {
/* Add socket as an inactive person */
clients[which].sock = newsock;
clients[which].peer = *SDLNet_TCP_GetPeerAddress(newsock);
SDLNet_TCP_AddSocket(socketset, clients[which].sock);
numclients++;
#ifdef _DEBUG
printf("New inactive socket %d\n", which);
#endif
}
}
static __inline__ int snTCPAddSocket(TCPsocket s)
{
int val = 0;
lockSDLNet();
val = SDLNet_TCP_AddSocket(socketSet, s);
unlockSDLNet();
return val;
}
bool CSocketSet::addSocketToSet(TCPsocket sock)
{
assert(m_socketSet);
assert(sock);
if (SDLNet_TCP_AddSocket(m_socketSet, sock) == -1)
return false;
return true;
}
void connect(Uint16 port)
{
IPaddress ip;
if(SDLNet_ResolveHost(&ip,NULL,port)==-1) {
printf("SDLNet_ResolveHost: %s\n", SDLNet_GetError());
exit(1);
}
serversock = SDLNet_TCP_Open(&ip);
if(!serversock) {
printf("SDLNet_TCP_Open: %s\n", SDLNet_GetError());
exit(2);
}
socketset = SDLNet_AllocSocketSet(32);
if (!socketset) {
printf("SDLNet_AllocSocketSet: %s\n", SDLNet_GetError());
exit(1); //most of the time this is a major error, but do what you want.
}
SDLNet_TCP_AddSocket(socketset, serversock);
while(true)
{
int num = 0;
if ((num = SDLNet_CheckSockets(socketset, 10000)) == -1)
{
printf("SDLNet_CheckSockets: %s\n", SDLNet_GetError());
//most of the time this is a system error, where perror might help you.
perror("SDLNet_CheckSockets");
}
else
{
accept_connections();
for(int i = 0; i < int(clients.size()); ++i)
{
if (clients[i])
clients[i]->update();
}
for(int i = 0; i < int(clients.size()); ++i)
{
if (clients[i] && clients[i]->is_invalid())
{
std::cout << "# client " << clients[i]->id << " got disconnected" << std::endl;
SDLNet_TCP_DelSocket(socketset, clients[i]->tcpsock);
SDLNet_TCP_Close(clients[i]->tcpsock);
delete clients[i];
clients[i] = 0;
}
}
}
}
}
/**
* @brief Asignador de la estructura m_Socket
*
* @param the_sdl_socket Copia de una estructura TCPsocket para realizar la copia.
*
* Si la estructura #m_Socket no es nula, liberará el espacio que ocupa y cerrará el puerto asignado. Acto seguido,
* realizará la asignación de #m_Socket con el parámetro the_sdl_socket. Si algo ha fallado, SDL_net generará un error.
*/
void CTcpSocket::SetSocket (TCPsocket the_sdl_socket) {
if (!(m_Socket == NULL)) {
SDLNet_TCP_DelSocket(set,m_Socket);
SDLNet_TCP_Close (m_Socket);
}
m_Socket = the_sdl_socket;
if(SDLNet_TCP_AddSocket(set,m_Socket)==-1) {
std::cerr << "SDLNet_TCP_AddSocket: " << SDLNet_GetError() << std::endl;
m_Socket = NULL;
}
}
int game_host::waitForClients()
{
cout << "waiting for first player to connect...\n";
while(!(player1sd = SDLNet_TCP_Accept(sd))) //wait for first connection, with 50ms delay to keep CPU down
SDL_Delay(50);
string ipMess = "";
while(SDLNet_UDP_Recv(p1UDPsock, UDPpack1) == 0)
SDL_Delay(5);
SDLNet_UDP_Bind(p1UDPsock,10,&(UDPpack1->address));
cout << this->recieveMessagep1() << "\n"; //client sends its IP
SDLNet_TCP_AddSocket(socketset, player1sd); //could error check here
this->player1ip = SDLNet_TCP_GetPeerAddress(player1sd);
//UDPpack1->address.port = player1ip.port;
//UDPpack1->address.host = player1ip.host;
cout << "waiting for second player to connect...\n";
while(!(player2sd = SDLNet_TCP_Accept(sd)))
SDL_Delay(50);
while(!SDLNet_UDP_Recv(p1UDPsock, UDPpack2))
SDL_Delay(5);
SDLNet_UDP_Bind(p1UDPsock,10,&(UDPpack2->address));
//cout << this->recieveMessagep2() << "\n";
SDLNet_TCP_AddSocket(socketset, player2sd); //could error check here as well
player2ip = SDLNet_TCP_GetPeerAddress(player2sd);
//UDPpack2->address.port = player2ip.port;
//UDPpack2->address.host = player2ip.host;
if(SDLNet_TCP_Send(player1sd, "1SIG:START", 16 /* buff.length()+1*/) < 16)
{
cout << "Message to client 1 failed to send...\n";
return -1;
}
if(SDLNet_TCP_Send(player2sd, "2SIG:START", 16 /*buff.length()+1*/) < 16)
{
cout << "Message to client 2 failed to send...\n";
return -1;
}
cout << "both clients connected, continuing...\n";
return 1;
}
// Creates a socket set that has the server socket and all the client sockets
SDLNet_SocketSet Server::create_sockset()
{
static SDLNet_SocketSet set = NULL;
if(set)
SDLNet_FreeSocketSet(set);
set = SDLNet_AllocSocketSet(num_clients + 1);
if(!set)
{
std::cerr << "SDLNet_AllocSocketSet: " << SDLNet_GetError()
<< std::endl;
return 0;
}
SDLNet_TCP_AddSocket(set, server);
typedef std::map< std::string, TCPsocket >::iterator it_type;
for (it_type i = clients.begin(); i != clients.end(); i++)
{
SDLNet_TCP_AddSocket(set, i->second);
}
return set;
}
//-------------------------------------------------------------------------------------
SDLNet_SocketSet GalactiCombatServer::createSockSet()
{
if(verbose) std::cout << "Entering createSockSet" << std::endl;
static SDLNet_SocketSet set = NULL;
if(set) SDLNet_FreeSocketSet(set);
set = SDLNet_AllocSocketSet(clients.size() + 1);
if(!set)
{
std::cerr << "SDLNet_AllocSocketSet done goofed: " << SDLNet_GetError() << std::endl;
exit(1);
}
SDLNet_TCP_AddSocket(set, TCPServerSock);
for(int i = 0; i < clients.size(); i++)
if(SDLNet_TCP_AddSocket(set, clients[i]->sock) == -1)
std::cerr<<"SDLNet_TCP_AddSocket done goofed: "<<SDLNet_GetError()<<std::endl;
// SDLNet_UDP_AddSocket(set, UDPServerSock); //TODO: Uncomment when working on UDP.
if(verbose) std::cout << "Exiting createSockSet" << std::endl << std::endl;
return set;
}
connection accept_connection()
{
if(!server_socket) {
return 0;
}
// A connection isn't considered 'accepted' until it has sent its initial handshake.
// The initial handshake is a 4 byte value, which is 0 for a new connection,
// or the handle of the connection if it's trying to recover a lost connection.
/**
* A list of all the sockets which have connected,
* but haven't had their initial handshake received.
*/
static std::vector<TCPsocket> pending_sockets;
static SDLNet_SocketSet pending_socket_set = 0;
const TCPsocket sock = SDLNet_TCP_Accept(server_socket);
if(sock) {
DBG_NW << "received connection. Pending handshake...\n";
if(pending_socket_set == 0) {
pending_socket_set = SDLNet_AllocSocketSet(32);
}
if(pending_socket_set != 0) {
int res = SDLNet_TCP_AddSocket(pending_socket_set,sock);
if (res != -1) {
pending_sockets.push_back(sock);
} else {
ERR_NW << "Pending socket set is full! Disconnecting " << sock << " connection\n";
ERR_NW << "SDLNet_GetError() is " << SDLNet_GetError() << "\n";
SDLNet_TCP_Close(sock);
}
} else {
ERR_NW << "Error in SDLNet_AllocSocketSet\n";
}
}
if(pending_socket_set == 0) {
return 0;
}
const int set_res = SDLNet_CheckSockets(pending_socket_set,0);
if(set_res <= 0) {
return 0;
}
return accept_connection_pending(pending_sockets, pending_socket_set);
}
