int Peer::addSocket(const int port)
{
Print("adding socket...\n");
int oldSize = sockets.size();
// if client only, port should be 0 (will open first avaliable port)
UDPsocket socket = SDLNet_UDP_Open(port);
if (!socket)
{
Print("SDLNet_UDP_Open: %s\n", SDLNet_GetError());
}
sockets.push_back(socket);
if (oldSize == sockets.size()) {
//print("socket error (SDLNet_UDP_Open)")
//Print("SDLNet_UDP_Open: %s\n", SDLNet_GetError());
return 0;
}
//SEG FAULT LOCATED
if (sockets.size())
{
//WATCH IS ALLOCATED NOW
int numused = SDLNet_UDP_AddSocket(watch, sockets.back());
if (numused == -1)
{
Print("SDLNet_UDP_AddSocket: %s\n", SDLNet_GetError());
}
return 1;
}
return 0;
}
static boolean NET_OpenSocket(void)
{
memset(clientaddress, 0, sizeof (clientaddress));
//CONS_Printf("SDL_Net Code starting up\n");
I_NetSend = NET_Send;
I_NetGet = NET_Get;
I_NetCloseSocket = NET_CloseSocket;
I_NetFreeNodenum = NET_FreeNodenum;
I_NetMakeNode = NET_NetMakeNode;
//I_NetCanSend = NET_CanSend;
// build the socket but close it first
NET_CloseSocket();
mysocket = NET_Socket();
if (!mysocket)
return false;
// for select
myset = SDLNet_AllocSocketSet(1);
if (!myset)
{
CONS_Printf("SDL_Net: %s",SDLNet_GetError());
return false;
}
if (SDLNet_UDP_AddSocket(myset,mysocket) == -1)
{
CONS_Printf("SDL_Net: %s",SDLNet_GetError());
return false;
}
return true;
}
void sock_init( sock_t* s, int port )
{
s->sset = SDLNet_AllocSocketSet(1);
s->sock = SDLNet_UDP_Open( port ); assert( s->sock );
int rez = SDLNet_UDP_AddSocket( s->sset, s->sock); assert( rez != -1 );
s->bytes_recv = 0;
s->bytes_sent = 0;
}
static __inline__ int snUDPAddSocket(UDPsocket s)
{
int val = 0;
lockSDLNet();
val = SDLNet_UDP_AddSocket(socketSet, s);
unlockSDLNet();
return val;
}
void I_WaitForPacket(int ms)
{
SDLNet_SocketSet ss = SDLNet_AllocSocketSet(1);
SDLNet_UDP_AddSocket(ss, udp_socket);
SDLNet_CheckSockets(ss,ms);
SDLNet_FreeSocketSet(ss);
#if (defined _WIN32 && !defined PRBOOM_SERVER)
I_UpdateConsole();
#endif
}
void I_WaitForPacket(int ms)
{
SDLNet_SocketSet ss = SDLNet_AllocSocketSet(1);
SDLNet_UDP_AddSocket(ss, udp_socket);
SDLNet_CheckSockets(ss,ms);
SDLNet_FreeSocketSet(ss);
// build script doesn't allow this
//#if (defined _WIN32 && !defined PRBOOM_SERVER)
// I_UpdateConsole();
//#endif
}
// Most of this function by ZZZ.
// Incoming port number should be in network byte order.
OSErr NetDDPOpenSocket(short *ioPortNumber, PacketHandlerProcPtr packetHandler)
{
//fdprintf("NetDDPOpenSocket\n");
assert(packetHandler);
// Allocate packet buffer (this is Christian's part)
assert(!sUDPPacketBuffer);
sUDPPacketBuffer = SDLNet_AllocPacket(ddpMaxData);
if (sUDPPacketBuffer == NULL)
return -1;
//PORTGUESS
// Open socket (SDLNet_Open seems to like port in host byte order)
// NOTE: only SDLNet_UDP_Open wants port in host byte order. All other uses of port in SDL_net
// are in network byte order.
sSocket = SDLNet_UDP_Open(SDL_SwapBE16(*ioPortNumber));
if (sSocket == NULL) {
SDLNet_FreePacket(sUDPPacketBuffer);
sUDPPacketBuffer = NULL;
return -1;
}
// Set up socket set
sSocketSet = SDLNet_AllocSocketSet(1);
SDLNet_UDP_AddSocket(sSocketSet, sSocket);
// Set up receiver
sKeepListening = true;
sPacketHandler = packetHandler;
sReceivingThread = SDL_CreateThread(receive_thread_function, "NetDDPOpenSocket_ReceivingThread", NULL);
// Set receiving thread priority very high
bool theResult = BoostThreadPriority(sReceivingThread);
if(theResult == false)
fdprintf("warning: BoostThreadPriority() failed; network performance may suffer\n");
//PORTGUESS but we should generally keep port in network order, I think?
// We really ought to return the "real" port we bound to in *ioPortNumber...
// for now we just hand back whatever they handed us.
//*ioPortNumber = *ioPortNumber;
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;
}
//-----------------------------------------------------------------------------
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;
}
int FCEUD_NetworkConnect(void)
{
IPaddress rip;
SDLNet_Init();
int netplay =1;
if(netplay==1) /* Be a server. */
{
TCPsocket tmp;
Uint16 p=LocalPortUDP;
SDLNet_ResolveHost(&rip,NULL,LocalPortTCP);
UDPSocket=SDLNet_UDP_Open(p);
tmp=SDLNet_TCP_Open(&rip);
Socket=SDLNet_TCP_Accept(tmp);
memcpy(&rip,SDLNet_TCP_GetPeerAddress(Socket),sizeof(IPaddress));
{
Uint32 buf[12];
uint32 player=1;
magic=SDL_GetTicks();
SDLNet_Write32(buf,uport);
SDLNet_Write32(buf+4,1);
SDLNet_Write32(buf+8,magic);
SDLNet_TCP_Send(Socket, buf, 12);
/* Get the UDP port the client is waiting for data on. */
SDLNet_TCP_Recv(Socket, buf, 2);
RemotePortUDP=de32(buf);
}
}
else /* Be a client */
{
SDLNet_ResolveHost(&rip,ServerHost,RemotePortTCP);
Socket=SDLNet_TCP_Open(&rip);
{
Uint16 p=LocalPortUDP;
uint8 buf[12];
UDPSocket=SDLNet_UDP_Open(p);
/* Now, tell the server what local UDP port it should send to. */
en32(buf,p);
SDLNet_TCP_Send(Socket, buf, 4);
/* Get the UDP port from the server we should send data to. */
SDLNet_TCP_Recv(Socket, buf, 12);
RemotePortUDP=de32(buf);
magic=de32(buf+8);
}
set=SDLNet_AllocSocketSet(1);
SDLNet_TCP_AddSocket(set,Socket);
SDLNet_UDP_AddSocket(set,UDPSocket);
} // End client connect code.
rip.port=RemotePortUDP;
SDLNet_UDP_Bind(UDPSocket, 0, &rip);
}