//------------------------------------------------------------------------------------- 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; }
// 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; }
void TCPConnection::Close() { logger->Log( __FILE__, __LINE__, "Closing connection.." ); if ( !isConnected ) { logger->Log( __FILE__, __LINE__, "Can't close : not connected" ); return; } if ( isServer ) { SDLNet_TCP_DelSocket( socketSet, serverSocket ); SDLNet_TCP_Close( serverSocket ); SDLNet_FreeSocketSet( socketSet ); } else { SDLNet_TCP_Close( tcpSocket ); } isConnected = false; }
CHostSocket::CHostSocket( Uint32 port ) : log("TcpSocketHost", CXmlSettings::Inst()->GetLoggerSettings()->logLevel) { CIPAddress iplistener(port); if (!iplistener.ReadyForUse()) { _socket = NULL; log << WARN << "IPaddress not ready for use" << endl; } else { IPaddress ipHost = iplistener.GetIPAddress(); if (!(_socket = SDLNet_TCP_Open(&ipHost))) { SDLNet_FreeSocketSet(_socketSet); log << ERRORX << "SDLNet_TCP_Open: " << SDLNet_GetError() << endl; } else { log << INFO << "Listening for clients on port: " << port << endl; } } }
void connect_to_server() { IPaddress ip; if(this_version_is_invalid)return; if(set) { SDLNet_FreeSocketSet(set); set=0; } if(my_socket) { SDLNet_TCP_Close(my_socket); my_socket=0; } log_to_console(c_red1,connect_to_server_str); draw_scene(); // update the screen set=SDLNet_AllocSocketSet(1); if(!set) { char str[120]; sprintf(str,"SDLNet_AllocSocketSet: %s\n", SDLNet_GetError()); log_error(str); SDLNet_Quit(); SDL_Quit(); exit(4); //most of the time this is a major error, but do what you want. } if(SDLNet_ResolveHost(&ip,server_address,port)==-1) { log_to_console(c_red2,failed_resolve); return; } my_socket=SDLNet_TCP_Open(&ip); if(!my_socket) { //check to see if the player is a moron... if(server_address[0]=='1' && server_address[1]=='9' && server_address[2]=='2' && server_address[3]=='.' && server_address[4]=='1' && server_address[5]=='6' && server_address[6]=='8') { log_to_console(c_red1,license_check); log_to_console(c_red1,alt_x_quit); } else { log_to_console(c_red1,failed_connect); log_to_console(c_red1,reconnect_str); log_to_console(c_red1,alt_x_quit); } return; } if(SDLNet_TCP_AddSocket(set,my_socket)==-1) { char str[120]; sprintf(str,"SDLNet_TCP_AddSocket: %s\n",SDLNet_GetError()); log_error(str); SDLNet_Quit(); SDL_Quit(); exit(2); } disconnected=0; //ask for the opening screen if(!previously_logged_in) { Uint8 str[1]; str[0]=SEND_OPENING_SCREEN; my_tcp_send(my_socket,str,1); } else { yourself=-1; you_sit=0; destroy_all_actors(); send_login_info(); } //send the current version to the server send_version_to_server(&ip); last_heart_beat=cur_time; hide_window(trade_win); }
ClientConnection::~ClientConnection() { SDLNet_TCP_Close(_client_socket); SDLNet_FreeSocketSet(_socket_set); }
TCP_Socket::~TCP_Socket() { SDLNet_TCP_DelSocket(sockset, sock); SDLNet_FreeSocketSet(sockset); SDLNet_TCP_Close(sock); }
static __inline__ void snFreeSocketSet(SDLNet_SocketSet ss) { lockSDLNet(); SDLNet_FreeSocketSet(ss); unlockSDLNet(); }
void TcpNet::freeSocketSet(const TcpNet::SocketSet set) { SDLNet_FreeSocketSet(set); }
void Server::startListen(ConnectionData * data){ int ready = 0; TCPsocket newSocket = NULL; SDLNet_SocketSet set = NULL; Client* newClient = NULL; set = SDLNet_AllocSocketSet(1); if(!set) { std::cerr << "SDLNet_AllocSocketSet: " << SDLNet_GetError() << std::endl; exit(0); } SDLNet_TCP_AddSocket(set, data->socket); if(myMapManager->loadXMLMap(MAP_TESTING)){ std::ostringstream tmp; tmp << "Loaded XML Map -> " << MAP_TESTING << ".xml"; myConsole.printMsg(tmp); } else{ std::ostringstream tmp; tmp << "Failed to load Map -> " << MAP_TESTING << ".xml"; myConsole.printMsg(tmp, CONSOLE_ERROR); return; } if(myMapManager->loadBinTMap(MAP_T)){ std::ostringstream tmp; tmp << "Loaded Terrain Map -> " << MAP_T; myConsole.printMsg(tmp); } else{ std::ostringstream tmp; tmp << "Failed to load Map -> " << MAP_T; myConsole.printMsg(tmp, CONSOLE_ERROR); return; } myGamefsm.Start(); // Starts the game state machine. while(!initialized){ // Wait for the server to be initialized SDL_Delay(100); } // Now the server is up and running, inform the user. myConsole.printMsg("Server is now running!"); // Main server loop. Here we accept new connections. while(!exit_request){ ready = SDLNet_CheckSockets(set, (Uint32) 50); if(ready==-1){ std::cout << "SDLNet_CheckSockets: " << SDLNet_GetError() << std::endl; break; } if(!ready) continue; if(SDLNet_SocketReady(data->socket)){ newSocket=SDLNet_TCP_Accept(data->socket); if (newSocket){ newClient = new Client(newSocket, this); //addClient(newClient); #ifdef TESTPHASE myConsole.printMsg("Connection received, authenticating it..."); //std::cout << std::endl << "<Server> Now " << this->mClients.size() << " clients are connected." << std::endl; #endif } } } SDLNet_FreeSocketSet(set); // Since the server is exiting do the same with the game FSM. myGamefsm.Stop(); SDL_Thread* tmpThread = myGamefsm.getThread(); if (tmpThread != NULL) // If necessary wait for the GameFSM to finish. SDL_WaitThread(tmpThread, NULL); myConsole.printMsg("Server is now quitting, good bye!"); }
//----------------------------------------------------------------------------- int main(int argc, char** argv) { if(SDL_Init(SDL_INIT_TIMER|SDL_INIT_EVENTS) != 0) { fprintf(stderr, "ER: SDL_Init: %s\n", SDL_GetError()); exit(-1); } if(SDLNet_Init() == -1) { fprintf(stderr, "ER: SDLNet_Init: %s\n", SDLNet_GetError()); exit(-1); } IPaddress ip; if(SDLNet_ResolveHost(&ip, NULL, 8099) == -1) { fprintf(stderr, "ER: SDLNet_ResolveHost: %s\n", SDLNet_GetError()); exit(-1); } sockets[SERVER_SOCKET] = SDLNet_TCP_Open(&ip); if(sockets[SERVER_SOCKET] == NULL) { fprintf(stderr, "ER: SDLNet_TCP_Open: %s\n", SDLNet_GetError()); exit(-1); } socket_set = SDLNet_AllocSocketSet(MAX_SOCKETS); if(socket_set == NULL) { fprintf(stderr, "ER: SDLNet_AllocSocketSet: %s\n", SDLNet_GetError()); exit(-1); } if(SDLNet_TCP_AddSocket(socket_set, sockets[SERVER_SOCKET]) == -1) { fprintf(stderr, "ER: SDLNet_TCP_AddSocket: %s\n", SDLNet_GetError()); exit(-1); } int running = 1; while(running) { int num_rdy = SDLNet_CheckSockets(socket_set, 1000); if(num_rdy <= 0) { // NOTE: none of the sockets are ready int ind; for(ind=0; ind<MAX_SOCKETS; ++ind) { if(!clients[ind].in_use) continue; /* if(clients[ind].questing && (SDL_GetTicks()-clients[ind].timer_wood)>WOOD_WAIT_TIME ) { clients[ind].questing = 0; clients[ind].amt_wood += 4; char msg[0xFF] = "> quest complete\n\r"; SendData(ind, msg, (strlen(msg)+1)); } */ clients[ind].amt_wood += 4; /* uint16_t length = 0; uint8_t data[MAX_PACKET]; memcpy(data+length, &clients[ind].amt_wood, sizeof(uint8_t)); length += sizeof(uint8_t); SendData(ind, data, length, FLAG_WOOD_UPDATE); */ } } else { int ind; for(ind=0; (ind<MAX_SOCKETS) && num_rdy; ++ind) { if(sockets[ind] == NULL) continue; if(!SDLNet_SocketReady(sockets[ind])) continue; if(ind == SERVER_SOCKET) { int got_socket = AcceptSocket(next_ind); if(!got_socket) { num_rdy--; continue; } // NOTE: get a new index int chk_count; for(chk_count=0; chk_count<MAX_SOCKETS; ++chk_count) { if(sockets[(next_ind+chk_count)%MAX_SOCKETS] == NULL) break; } next_ind = (next_ind+chk_count)%MAX_SOCKETS; printf("DB: new connection (next_ind = %d)\n", next_ind); num_rdy--; } else { uint8_t* data; uint16_t flag; uint16_t length; data = RecvData(ind, &length, &flag); if(data == NULL) { num_rdy--; continue; } switch(flag) { case FLAG_WOOD_UPDATE: { uint16_t offset = 0; uint8_t send_data[MAX_PACKET]; memcpy(send_data+offset, &clients[ind].amt_wood, sizeof(uint8_t)); offset += sizeof(uint8_t); SendData(ind, send_data, offset, FLAG_WOOD_UPDATE); } break; } /* uint8_t* data; int length; data = RecvData(ind, &length); if(data == NULL) { num_rdy--; continue; } int i; for(i=0; i<length; ++i) { if(data[i] == '\n') data[i] = '\0'; if(data[i] == '\r') data[i] = '\0'; } // TEMP: add a NULL terminator data = (uint8_t*) realloc(data, (length+1)); data[length] = '\0'; int was_processed = 0; if(!strcmp(data, "exit")) { was_processed = 1; running = 0; } else if(!strcmp(data, "quit")) { was_processed = 1; CloseSocket(ind); } else if(!strcmp(data, "get data")) { was_processed = 1; char msg[0xFF] = {}; sprintf(msg, "> wood: %d\n\r", clients[ind].amt_wood); //SendData(ind, msg, (strlen(msg)+1)); } else if(!strcmp(data, "quest")) { was_processed = 1; if(!clients[ind].questing) { clients[ind].questing = 1; clients[ind].timer_wood = SDL_GetTicks(); char msg[0xFF] = "> started quest\n\r"; //SendData(ind, msg, (strlen(msg)+1)); } else { char msg[0xFF] = "> currently running quest\n\r"; //SendData(ind, msg, (strlen(msg)+1)); } } if(was_processed) printf("PR: %s\n", data); free(data); */ num_rdy--; } } } } int i; for(i=0; i<MAX_SOCKETS; ++i) { if(sockets[i] == NULL) continue; CloseSocket(i); } SDLNet_FreeSocketSet(socket_set); SDLNet_Quit(); SDL_Quit(); return 0; }
/*! * main loop. Accept contribution from clients and dispatch digest of * the frame to all clients */ void serve_dispatch (global_option_type * global_option) { global_status_type global_status; int client_index; /* * Initialize global_status fields */ global_status.frame_number = 1; global_status.number_identified_players = 0; global_status.number_allocation_request = 0; #if defined(GTK) gtk_stop_asked = 0; #endif for (client_index = 0; client_index < MAX_NUMBER_PLAYER; client_index++) { global_status.player_status[client_index] = UNIDENTIFIED; } global_status.server_socket = SDLNet_UDP_Open (global_option->server_port); if (global_status.server_socket == NULL) { printf_screen ("Couldn't open UDP socket on port %d.\nCheck privileges and availability.\n", global_option->server_port); return; } /* global_status.server_socket is ready to serve our needs :) */ global_status.current_packet = SDLNet_AllocPacket (CLIENT_PACKET_SIZE); if (global_status.current_packet == NULL) { SDLNet_UDP_Close (global_status.server_socket); printf_screen ("Failed to allocate a buffer for receiving client packets (size: %d bytes) (Not enough memory ?)", CLIENT_PACKET_SIZE); return; } global_status.digest_packet = SDLNet_AllocPacket (SERVER_PACKET_SIZE); if (global_status.digest_packet == NULL) { SDLNet_UDP_Close (global_status.server_socket); SDLNet_FreePacket (global_status.digest_packet); printf_screen ("Failed to allocate a buffer for sending packets (size: %d bytes) (Not enough memory ?)", SERVER_PACKET_SIZE); return; } /* Allocate enough space for a single socket */ global_status.server_socket_set = SDLNet_AllocSocketSet (1); if (global_status.server_socket_set == NULL) { SDLNet_UDP_Close (global_status.server_socket); SDLNet_FreePacket (global_status.current_packet); SDLNet_FreePacket (global_status.digest_packet); printf_screen ("Couldn't allocate a socket set (not enough memory ?).\n"); return; } if (SDLNet_UDP_AddSocket (global_status.server_socket_set, global_status.server_socket) != 1) { SDLNet_UDP_Close (global_status.server_socket); SDLNet_FreePacket (global_status.current_packet); SDLNet_FreePacket (global_status.digest_packet); SDLNet_FreeSocketSet (global_status.server_socket_set); printf_screen ("Error when adding socket to socket set.\n"); return; } /* Identification loop */ /* * We're expecting identification packets until we've filled all slots, then * we can proceed to the real meat */ for (;;) { int number_ready_socket; #if defined(DEBUG) printf_screen ("Waiting for identification\n"); #endif if (read_incoming_server_packet (&global_status)) { identify_client (&global_status, global_option); if (count_remaining_slot (&global_status, global_option) == 0) { /* Perfect, we've finished the identification of all slots */ break; } printf_screen("%d slots open.\n", count_remaining_slot (&global_status, global_option)); /* Going back to the identification loop */ continue; } #if defined(GTK) gtk_iteration = GTK_SERVER_SOCKET_RATIO; do { number_ready_socket = SDLNet_CheckSockets (global_status.server_socket_set, SERVER_SOCKET_TIMEOUT / GTK_SERVER_SOCKET_RATIO); while (gtk_events_pending()) { if (gtk_main_iteration()) { gtk_stop_asked = 1; } } } while ( (number_ready_socket == 0) && (--gtk_iteration != 0) && !gtk_stop_asked); #else number_ready_socket = SDLNet_CheckSockets (global_status.server_socket_set, SERVER_SOCKET_TIMEOUT); #endif if (gtk_stop_asked) { break; } if (number_ready_socket == -1) { printf_screen ("Error in socket waiting (disconnection ?).\n"); break; } if (number_ready_socket == 1) { #if defined(DEBUG) printf_screen ("Got a packet\n"); #endif /* We're awaiting a packet in the server socket */ if (read_incoming_server_packet (&global_status)) { /* * If we haven't identified all clients yet, we're trying to use the current packet * to improve our knowledge of the typography */ identify_client (&global_status, global_option); if (count_remaining_slot (&global_status, global_option) == 0) { /* Perfect, we've finished the identification of all slots */ break; } printf_screen("%d slots open.\n", count_remaining_slot (&global_status, global_option)); } } } if (!gtk_stop_asked) { printf_screen ("Identification finished\n"); #if defined(DEBUG) for (client_index = 0; client_index < MAX_NUMBER_PLAYER; client_index++) { printf_screen ("Mapping[%d] = { { 0x%08X, %d }, %d }\n", client_index, global_status.input_mapping[client_index].address.host, global_status.input_mapping[client_index].address.port, global_status.input_mapping[client_index].remote_input_device); } #endif switch (global_option->type_server) { case LAN_PROTOCOL_TYPE: serve_clients_lan_protocol(&global_status, global_option); break; case INTERNET_PROTOCOL_TYPE: serve_clients_internet_protocol(&global_status, global_option); break; default: printf_screen("Internal error, unknown internal server type : %d\n", global_option->type_server); break; } } // gtk_stop_asked /* * Free resources */ SDLNet_FreePacket (global_status.current_packet); SDLNet_FreePacket (global_status.digest_packet); SDLNet_FreeSocketSet (global_status.server_socket_set); SDLNet_UDP_Close (global_status.server_socket); global_status.server_socket = NULL; }
void Network::receive() { SDLNet_SocketSet set; if (!(set = SDLNet_AllocSocketSet(1))) { setError("Error in SDLNet_AllocSocketSet(): " + std::string(SDLNet_GetError())); return; } if (SDLNet_TCP_AddSocket(set, mSocket) == -1) { setError("Error in SDLNet_AddSocket(): " + std::string(SDLNet_GetError())); } while (mState == CONNECTED) { // TODO Try to get this to block all the time while still being able // to escape the loop int numReady = SDLNet_CheckSockets(set, (static_cast<uint32_t>(500))); int ret; switch (numReady) { case -1: logger->log1("Error: SDLNet_CheckSockets"); // FALLTHROUGH case 0: break; case 1: // Receive data from the socket SDL_mutexP(mMutex); ret = SDLNet_TCP_Recv(mSocket, mInBuffer + mInSize, BUFFER_SIZE - mInSize); if (!ret) { // We got disconnected mState = IDLE; logger->log1("Disconnected."); } else if (ret < 0) { setError(_("Connection to server terminated. ") + std::string(SDLNet_GetError())); } else { // DEBUGLOG("Receive " + toString(ret) + " bytes"); mInSize += ret; if (mToSkip) { if (mInSize >= mToSkip) { mInSize -= mToSkip; memmove(mInBuffer, mInBuffer + mToSkip, mInSize); mToSkip = 0; } else { mToSkip -= mInSize; mInSize = 0; } } } SDL_mutexV(mMutex); break; default: // more than one socket is ready.. // this should not happen since we only listen once socket. std::stringstream errorStream; errorStream << "Error in SDLNet_TCP_Recv(), " << numReady << " sockets are ready: " << SDLNet_GetError(); setError(errorStream.str()); break; } } if (SDLNet_TCP_DelSocket(set, mSocket) == -1) logger->log("Error in SDLNet_DelSocket(): %s", SDLNet_GetError()); SDLNet_FreeSocketSet(set); }
//----------------------------------------------------------------------------- int main(int argc, char *argv[]) { libInit(); // NOTE: open socket file descriptor serverFD = SDLNet_UDP_Open(3490); if(!serverFD) { fprintf(stderr, "SDLNet_UDP_Open: %s\n", SDLNet_GetError()); libQuit(); return -1; } // NOTE: setup a socket set socketSet = SDLNet_AllocSocketSet(1); SDLNet_UDP_AddSocket(socketSet, serverFD); printf("\nServer open on port: %d\n\n", 3490); // NOTE: initialize the player manager plManager = initPlayerManager("diamond_collector.db"); /* LISTEN FOR PACKETS */ for(;;) { // NOTE: wait for a connection int n = SDLNet_CheckSockets(socketSet, 0); if(n==-1) { fprintf(stderr, "SDLNet_CheckSockets: %s\n", SDLNet_GetError()); break; } if(!n) { // NOTE: if the server doesn't have anything to do then run through // a few regular routines switch(serverState) { case 0x00: { if((time(NULL)-lastTimePingsWentOut)>20) { // NOTE: if the server is idle in its freetime then start sending out // ping packets for the client to respond to serverState = 0x01; lastTimePingsWentOut = time(NULL); } } break; case 0x01: { if(waitingForPong) { if(!plManager->pl_indMask[nodeToPing][playerToPing]) { playerToPing++; waitingForPong = SDL_FALSE; } else if((time(NULL)-timeOfPing)>120) { // NOTE: if we hear nothing back after 5 secs then disconnect the player DB_Player *pl = &plManager->pl_dbInfo[nodeToPing][playerToPing]; printf("player %s didn't respond to ping logging them out.\n", pl->username); // NOTE: set the player state and log the player out pl->state = 0x00; // NOTE: send a packet out to everyone on this node // letting them know that the player is leaving. UDPpacket _packet = {}; /* - flag (1) 0x05 - id (4) ====== (5) */ _packet.maxlen = 0x05; // 5 bytes _packet.data = (uint8_t *)malloc(0x05); uint8_t offset = 0; memset(_packet.data+offset, 0x05, 1); offset += 1; memcpy(_packet.data+offset, &pl->id, 4); offset += 4; // NOTE: set the packet length to the offset point _packet.len = offset; // NOTE: send the packet out to everyone but the player disconnecting int i; for(i=0; i<PLAYER_MAX; i++) { if(!plManager->pl_indMask[pl->node][i]) continue; _packet.address.host = plManager->pl_dbInfo[pl->node][i].host; _packet.address.port = plManager->pl_dbInfo[pl->node][i].port; if(!SDLNet_UDP_Send(serverFD, -1, &_packet)) fprintf(stderr, "SDLNet_UDP_Send: %s\n", SDLNet_GetError()); } // NOTE: free the packet free(_packet.data); // NOTE: save the new player state pl_save(plManager, pl); if(pl_removePlayer(plManager, pl) != -1) { printf("Logout success!\n"); } else { // NOTE: player was never in the players array should // probably log this sort of thing } playerToPing++; waitingForPong = SDL_FALSE; } else { // TODO: keep sending the ping packet } } else { // NOTE: make sure there are people on this node - else go to the // next node int n = pl_numOnNode(plManager, nodeToPing); if(n <= 0) { nodeToPing++; playerToPing = 0; if(nodeToPing==NODE_MAX) { nodeToPing = 0; serverState = 0x00; } break; } // NOTE: if there isn't a player at this point in the pool then // go to the next point in the pool if(!plManager->pl_indMask[nodeToPing][playerToPing]) { playerToPing++; if(playerToPing == PLAYER_MAX) { nodeToPing++; playerToPing = 0; if(nodeToPing == NODE_MAX) { nodeToPing = 0; serverState = 0x00; } } break; } // NOTE: get the player and send out the ping DB_Player *pl = &plManager->pl_dbInfo[nodeToPing][playerToPing]; // NOTE: send a ping packet uint8_t flag = 0x0A; UDPpacket _packet = {}; _packet.data = &flag; _packet.len = 1; _packet.maxlen = 1; _packet.address.host = pl->host; _packet.address.port = pl->port; if(!SDLNet_UDP_Send(serverFD, -1, &_packet)) fprintf(stderr, "SDLNet_UDP_Send: %s\n", SDLNet_GetError()); timeOfPing = time(NULL); waitingForPong = SDL_TRUE; } } break; } continue; } // NOTE: does the server have packets waiting? if(SDLNet_SocketReady(serverFD)) { // NOTE: setup a packet which is big enough to store any client message UDPpacket packet; // NOTE: allocate space for packet packet.maxlen = 0xAA; // 170 bytes packet.data = (uint8_t *)malloc(0xAA); // NOTE: get the packet int recv = SDLNet_UDP_Recv(serverFD, &packet); if(!recv) { free(packet.data); continue; } // NOTE: read the flag for packet identity uint8_t flag = 0; uint32_t offset = 0; memcpy(&flag, packet.data, 1); offset += 1; // NOTE: process the packet switch(flag) { case 0x01: { net_login(plManager, &packet, &offset); } break; case 0x02: { net_logout(plManager, &packet, &offset); } break; case 0x07: { net_moveUp(plManager, &packet, &offset); } break; case 0x08: { net_moveDown(plManager, &packet, &offset); } break; case 0x09: { net_moveLeft(plManager, &packet, &offset); } break; case 0x0A: { net_moveRight(plManager, &packet, &offset); } break; case 0x0B: { net_sendOutPlInfo(plManager, &packet, &offset); } break; case 0x0C: { // NOTE: get the player which is logged in on the incoming address DB_Player *pl = pl_getDBInfo(plManager, packet.address); if(pl == NULL) break; // NOTE: need to make sure the pong is from the right player int ind = pl_getIndex(plManager, pl); // NOTE: player responding with a pong packet if(ind==playerToPing) { playerToPing++; waitingForPong = SDL_FALSE; } } break; case 0x0D: { net_sendOutNodeInfo(plManager, &packet, &offset); } break; } // NOTE: free the packet when done processing free(packet.data); } } // NOTE: free the player manager freePlayerManager(plManager); // NOTE: free socketset SDLNet_FreeSocketSet(socketSet); // NOTE: close the socket file descriptor SDLNet_UDP_Close(serverFD); libQuit(); return 0; }
Socket::~Socket() { SDLNet_TCP_Close(sock); if (set != NULL) SDLNet_FreeSocketSet(set); }