diff options
| -rw-r--r-- | src/Makefile.am | 3 | ||||
| -rw-r--r-- | src/net_client.c | 228 | ||||
| -rw-r--r-- | src/net_common.c | 272 | ||||
| -rw-r--r-- | src/net_common.h | 90 | ||||
| -rw-r--r-- | src/net_server.c | 299 |
5 files changed, 482 insertions, 410 deletions
diff --git a/src/Makefile.am b/src/Makefile.am index 22425ff7..c34bba53 100644 --- a/src/Makefile.am +++ b/src/Makefile.am @@ -57,7 +57,8 @@ m_misc.c m_misc.h \ mmus2mid.c mmus2mid.h \ m_random.c m_random.h \ m_swap.c m_swap.h \ -net_client.c \ +net_client.c net_client.h \ +net_common.c net_common.h \ net_defs.h \ net_gui.c net_gui.h \ net_io.c net_io.h \ diff --git a/src/net_client.c b/src/net_client.c index 7628530e..68906cb1 100644 --- a/src/net_client.c +++ b/src/net_client.c @@ -1,7 +1,7 @@ // Emacs style mode select -*- C++ -*- //----------------------------------------------------------------------------- // -// $Id: net_client.c 262 2006-01-07 20:08:11Z fraggle $ +// $Id: net_client.c 263 2006-01-08 00:10:48Z fraggle $ // // Copyright(C) 2005 Simon Howard // @@ -21,6 +21,10 @@ // 02111-1307, USA. // // $Log$ +// Revision 1.10 2006/01/08 00:10:47 fraggle +// Move common connection code into net_common.c, shared by server +// and client code. +// // Revision 1.9 2006/01/07 20:08:11 fraggle // Send player name and address in the waiting data packets. Display these // on the waiting screen, and improve the waiting screen appearance. @@ -63,6 +67,7 @@ #include "doomstat.h" #include "i_system.h" #include "net_client.h" +#include "net_common.h" #include "net_defs.h" #include "net_gui.h" #include "net_io.h" @@ -71,10 +76,6 @@ typedef enum { - // sent a syn, not received an ack yet - - CLIENT_STATE_CONNECTING, - // waiting for the game to start CLIENT_STATE_WAITING_START, @@ -83,23 +84,17 @@ typedef enum CLIENT_STATE_IN_GAME, - // in disconnect state: sent DISCONNECT, waiting for DISCONNECT_ACK reply - - CLIENT_STATE_DISCONNECTING, - - // successfully disconnected - - CLIENT_STATE_DISCONNECTED, } net_clientstate_t; +static net_connection_t client_connection; static net_clientstate_t client_state; static net_addr_t *server_addr; static net_context_t *client_context; static int last_send_time; -// if TRUE, we are connected to a server +// TRUE if the client code is in use -boolean net_client_connected = false; +boolean net_client_connected; // if TRUE, this client is the controller of the game @@ -179,69 +174,6 @@ static void NET_CL_ParseWaitingData(net_packet_t *packet) } } -// Received an ACK - -static void NET_CL_ParseACK(net_packet_t *packet) -{ - net_packet_t *reply; - - // send an ACK back - - reply = NET_NewPacket(10); - NET_WriteInt16(reply, NET_PACKET_TYPE_ACK); - NET_SendPacket(server_addr, reply); - NET_FreePacket(reply); - - // set the client state if we havent already - - if (client_state == CLIENT_STATE_CONNECTING) - { - client_state = CLIENT_STATE_WAITING_START; - } -} - -// parse a DISCONNECT packet - -static void NET_CL_ParseDisconnect(net_packet_t *packet) -{ - net_packet_t *reply; - - // construct a DISCONNECT_ACK reply packet - - reply = NET_NewPacket(10); - NET_WriteInt16(reply, NET_PACKET_TYPE_DISCONNECT_ACK); - - // send the reply several times, in case of packet loss - - NET_SendPacket(server_addr, reply); - NET_SendPacket(server_addr, reply); - NET_SendPacket(server_addr, reply); - NET_FreePacket(reply); - - client_state = CLIENT_STATE_DISCONNECTED; - - //I_Error("Disconnected from server.\n"); - fprintf(stderr, "Disconnected from server.\n"); - - // Now what? - - NET_CL_Disconnect(); -} - -// parse a DISCONNECT_ACK packet - -static void NET_CL_ParseDisconnectACK(net_packet_t *packet) -{ - if (client_state == CLIENT_STATE_DISCONNECTING) - { - // successfully disconnected from the server. - - client_state = CLIENT_STATE_DISCONNECTED; - - // now what? - } -} - // parse a received packet static void NET_CL_ParsePacket(net_packet_t *packet) @@ -253,97 +185,27 @@ static void NET_CL_ParsePacket(net_packet_t *packet) return; } - switch (packet_type) - { - case NET_PACKET_TYPE_ACK: - - // received an acknowledgement to the SYN we sent - - NET_CL_ParseACK(packet); - break; - - case NET_PACKET_TYPE_WAITING_DATA: - - NET_CL_ParseWaitingData(packet); - break; - - case NET_PACKET_TYPE_GAMESTART: - break; - - case NET_PACKET_TYPE_GAMEDATA: - break; - - case NET_PACKET_TYPE_DISCONNECT: - NET_CL_ParseDisconnect(packet); - break; - - case NET_PACKET_TYPE_DISCONNECT_ACK: - NET_CL_ParseDisconnectACK(packet); - break; - - default: - break; - } -} - -// called when we are in the "connecting" state - -static void NET_CL_Connecting(void) -{ - net_packet_t *packet; - - // send a SYN packet every second - - if (last_send_time < 0 || I_GetTimeMS() - last_send_time > 1000) + if (NET_Conn_Packet(&client_connection, packet, packet_type)) { - // construct a SYN packet - - packet = NET_NewPacket(10); - - // packet type - - NET_WriteInt16(packet, NET_PACKET_TYPE_SYN); - - // magic number - - NET_WriteInt32(packet, NET_MAGIC_NUMBER); - - // send to the server - - NET_SendPacket(server_addr, packet); - - NET_FreePacket(packet); - - last_send_time = I_GetTimeMS(); + // Packet eaten by the common connection code } -} - -// Called when we are in the "disconnecting" state, disconnecting from -// the server. - -static void NET_CL_Disconnecting(void) -{ - net_packet_t *packet; - - // send a DISCONNECT packet every second - - if (last_send_time < 0 || I_GetTimeMS() - last_send_time > 1000) + else { - // construct packet - - packet = NET_NewPacket(10); - - // packet type - - NET_WriteInt16(packet, NET_PACKET_TYPE_DISCONNECT); - - // send to the server + switch (packet_type) + { + case NET_PACKET_TYPE_WAITING_DATA: + NET_CL_ParseWaitingData(packet); + break; - NET_SendPacket(server_addr, packet); + case NET_PACKET_TYPE_GAMESTART: + break; - NET_FreePacket(packet); + case NET_PACKET_TYPE_GAMEDATA: + break; - last_send_time = I_GetTimeMS(); + default: + break; + } } } @@ -372,19 +234,12 @@ void NET_CL_Run(void) NET_FreePacket(packet); } - // send packets as needed + // Run the common connection code to send any packets as needed - switch (client_state) - { - case CLIENT_STATE_CONNECTING: - NET_CL_Connecting(); - break; - case CLIENT_STATE_DISCONNECTING: - NET_CL_Disconnecting(); - break; - default: - break; - } + NET_Conn_Run(&client_connection); + + net_waiting_for_start = client_connection.state == NET_CONN_STATE_CONNECTED + && client_state == CLIENT_STATE_WAITING_START; } // connect to a server @@ -410,16 +265,18 @@ boolean NET_CL_Connect(net_addr_t *addr) NET_AddModule(client_context, addr->module); net_client_connected = true; - net_waiting_for_start = true; + + // Initialise connection + + NET_Conn_InitClient(&client_connection, addr); // try to connect - client_state = CLIENT_STATE_CONNECTING; last_send_time = -1; start_time = I_GetTimeMS(); - while (client_state == CLIENT_STATE_CONNECTING) + while (client_connection.state == NET_CONN_STATE_CONNECTING) { // time out after 5 seconds @@ -442,10 +299,12 @@ boolean NET_CL_Connect(net_addr_t *addr) I_Sleep(10); } - if (client_state != CLIENT_STATE_CONNECTING) + if (client_connection.state == NET_CONN_STATE_CONNECTED) { // connected ok! + client_state = CLIENT_STATE_WAITING_START; + return true; } else @@ -469,23 +328,18 @@ void NET_CL_Disconnect(void) return; } - // set the client into the DISCONNECTING state - - if (client_state != CLIENT_STATE_DISCONNECTED) - { - client_state = CLIENT_STATE_DISCONNECTING; - last_send_time = -1; - } + NET_Conn_Disconnect(&client_connection); start_time = I_GetTimeMS(); - while (client_state != CLIENT_STATE_DISCONNECTED) + while (client_connection.state != NET_CONN_STATE_DISCONNECTED + && client_connection.state != NET_CONN_STATE_DISCONNECTED_SLEEP) { if (I_GetTimeMS() - start_time > 5000) { // time out after 5 seconds - client_state = CLIENT_STATE_DISCONNECTED; + client_state = NET_CONN_STATE_DISCONNECTED; fprintf(stderr, "NET_CL_Disconnect: Timeout while disconnecting from server\n"); break; diff --git a/src/net_common.c b/src/net_common.c new file mode 100644 index 00000000..27d82965 --- /dev/null +++ b/src/net_common.c @@ -0,0 +1,272 @@ +// Emacs style mode select -*- C++ -*- +//----------------------------------------------------------------------------- +// +// $Id: net_common.c 263 2006-01-08 00:10:48Z fraggle $ +// +// Copyright(C) 2005 Simon Howard +// +// This program is free software; you can redistribute it and/or +// modify it under the terms of the GNU General Public License +// as published by the Free Software Foundation; either version 2 +// of the License, or (at your option) any later version. +// +// This program is distributed in the hope that it will be useful, +// but WITHOUT ANY WARRANTY; without even the implied warranty of +// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the +// GNU General Public License for more details. +// +// You should have received a copy of the GNU General Public License +// along with this program; if not, write to the Free Software +// Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA +// 02111-1307, USA. +// +// $Log$ +// Revision 1.1 2006/01/08 00:10:48 fraggle +// Move common connection code into net_common.c, shared by server +// and client code. +// +// +// Common code shared between the client and server +// + +#include "doomdef.h" +#include "i_system.h" + +#include "net_common.h" +#include "net_io.h" +#include "net_packet.h" + +// Initialise as a client connection + +void NET_Conn_InitClient(net_connection_t *conn, net_addr_t *addr) +{ + conn->state = NET_CONN_STATE_CONNECTING; + conn->last_send_time = -1; + conn->num_retries = 0; + conn->addr = addr; +} + +// Initialise as a server connection + +void NET_Conn_InitServer(net_connection_t *conn, net_addr_t *addr) +{ + conn->state = NET_CONN_STATE_WAITING_ACK; + conn->last_send_time = -1; + conn->num_retries = 0; + conn->addr = addr; +} + +// parse an ACK packet from a client + +static void NET_Conn_ParseACK(net_connection_t *conn, net_packet_t *packet) +{ + net_packet_t *reply; + + if (conn->state == NET_CONN_STATE_CONNECTING) + { + // We are a client + + // received a response from the server to our SYN + + conn->state = NET_CONN_STATE_CONNECTED; + + // We must send an ACK reply to the server's ACK + + reply = NET_NewPacket(10); + NET_WriteInt16(reply, NET_PACKET_TYPE_ACK); + NET_SendPacket(conn->addr, reply); + NET_FreePacket(reply); + } + + if (conn->state == NET_CONN_STATE_WAITING_ACK) + { + // We are a server + + // Client is connected + + conn->state = NET_CONN_STATE_CONNECTED; + } +} + +static void NET_Conn_ParseDisconnect(net_connection_t *conn, net_packet_t *packet) +{ + net_packet_t *reply; + + // Other end wants to disconnect + // Send a DISCONNECT_ACK reply. + + reply = NET_NewPacket(10); + NET_WriteInt16(reply, NET_PACKET_TYPE_DISCONNECT_ACK); + NET_SendPacket(conn->addr, reply); + NET_FreePacket(reply); + + conn->last_send_time = I_GetTimeMS(); + + conn->state = NET_CONN_STATE_DISCONNECTED_SLEEP; +} + +// Parse a DISCONNECT_ACK packet + +static void NET_Conn_ParseDisconnectACK(net_connection_t *conn, + net_packet_t *packet) +{ + + if (conn->state == NET_CONN_STATE_DISCONNECTING) + { + // We have received an acknowledgement to our disconnect + // request. We have been disconnected successfully. + + conn->state = NET_CONN_STATE_DISCONNECTED; + conn->last_send_time = -1; + } +} + +// Process a packet received by the server +// +// Returns true if eaten by common code + +boolean NET_Conn_Packet(net_connection_t *conn, net_packet_t *packet, + int packet_type) +{ + //printf("Conn: %s: %i\n", NET_AddrToString(addr), packet_type); + + switch (packet_type) + { + case NET_PACKET_TYPE_ACK: + NET_Conn_ParseACK(conn, packet); + break; + case NET_PACKET_TYPE_DISCONNECT: + NET_Conn_ParseDisconnect(conn, packet); + break; + case NET_PACKET_TYPE_DISCONNECT_ACK: + NET_Conn_ParseDisconnectACK(conn, packet); + break; + default: + // Not a common packet + + return false; + } + + // We found a packet that we found interesting, and ate it. + + return true; +} + +void NET_Conn_Disconnect(net_connection_t *conn) +{ + if (conn->state != NET_CONN_STATE_DISCONNECTED + && conn->state != NET_CONN_STATE_DISCONNECTING + && conn->state != NET_CONN_STATE_DISCONNECTED_SLEEP) + { + conn->state = NET_CONN_STATE_DISCONNECTING; + conn->last_send_time = -1; + conn->num_retries = 0; + } +} + +void NET_Conn_Run(net_connection_t *conn) +{ + net_packet_t *packet; + + if (conn->state == NET_CONN_STATE_CONNECTING) + { + if (conn->last_send_time < 0 + || I_GetTimeMS() - conn->last_send_time > 1000) + { + // It has been a second since the last SYN was sent, and no + // reply. + + if (conn->num_retries < MAX_RETRIES) + { + // send another SYN + + packet = NET_NewPacket(10); + NET_WriteInt16(packet, NET_PACKET_TYPE_SYN); + NET_WriteInt32(packet, NET_MAGIC_NUMBER); + NET_SendPacket(conn->addr, packet); + NET_FreePacket(packet); + conn->last_send_time = I_GetTimeMS(); + + ++conn->num_retries; + } + else + { + conn->state = NET_CONN_STATE_DISCONNECTED; + } + } + } + else if (conn->state == NET_CONN_STATE_WAITING_ACK) + { + if (conn->last_send_time < 0 + || I_GetTimeMS() - conn->last_send_time > 1000) + { + // it has been a second since the last ACK was sent, and + // still no reply. + + if (conn->num_retries < MAX_RETRIES) + { + // send another ACK + + packet = NET_NewPacket(10); + NET_WriteInt16(packet, NET_PACKET_TYPE_ACK); + NET_SendPacket(conn->addr, packet); + NET_FreePacket(packet); + conn->last_send_time = I_GetTimeMS(); + + ++conn->num_retries; + } + else + { + // no more retries allowed. + + conn->state = NET_CONN_STATE_DISCONNECTED; + } + } + } + else if (conn->state == NET_CONN_STATE_DISCONNECTING) + { + // Waiting for a reply to our DISCONNECT request. + + if (conn->last_send_time < 0 + || I_GetTimeMS() - conn->last_send_time > 1000) + { + // it has been a second since the last disconnect packet + // was sent, and still no reply. + + if (conn->num_retries < MAX_RETRIES) + { + // send another disconnect + + packet = NET_NewPacket(10); + NET_WriteInt16(packet, NET_PACKET_TYPE_DISCONNECT); + NET_SendPacket(conn->addr, packet); + NET_FreePacket(packet); + conn->last_send_time = I_GetTimeMS(); + + ++conn->num_retries; + } + else + { + // No more retries allowed. + // Force disconnect. + + conn->state = NET_CONN_STATE_DISCONNECTED; + } + } + } + else if (conn->state == NET_CONN_STATE_DISCONNECTED_SLEEP) + { + // We are disconnected, waiting in case we need to send + // a DISCONNECT_ACK to the server again. + + if (I_GetTimeMS() - conn->last_send_time > 5000) + { + // Idle for 5 seconds, switch state + + conn->state = NET_CONN_STATE_DISCONNECTED; + } + } +} + + + diff --git a/src/net_common.h b/src/net_common.h new file mode 100644 index 00000000..f24c6cec --- /dev/null +++ b/src/net_common.h @@ -0,0 +1,90 @@ +// Emacs style mode select -*- C++ -*- +//----------------------------------------------------------------------------- +// +// $Id: net_common.h 263 2006-01-08 00:10:48Z fraggle $ +// +// Copyright(C) 2005 Simon Howard +// +// This program is free software; you can redistribute it and/or +// modify it under the terms of the GNU General Public License +// as published by the Free Software Foundation; either version 2 +// of the License, or (at your option) any later version. +// +// This program is distributed in the hope that it will be useful, +// but WITHOUT ANY WARRANTY; without even the implied warranty of +// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the +// GNU General Public License for more details. +// +// You should have received a copy of the GNU General Public License +// along with this program; if not, write to the Free Software +// Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA +// 02111-1307, USA. +// +// $Log$ +// Revision 1.1 2006/01/08 00:10:48 fraggle +// Move common connection code into net_common.c, shared by server +// and client code. +// +// +// Common code shared between the client and server +// + +#ifndef NET_COMMON_H +#define NET_COMMON_H + +#include "net_defs.h" + +typedef enum +{ + // sending syn packets, waiting for an ACK reply + // (client side) + + NET_CONN_STATE_CONNECTING, + + // received a syn, sent an ack, waiting for an ack reply + // (server side) + + NET_CONN_STATE_WAITING_ACK, + + // successfully connected + + NET_CONN_STATE_CONNECTED, + + // sent a DISCONNECT packet, waiting for a DISCONNECT_ACK reply + + NET_CONN_STATE_DISCONNECTING, + + // client successfully disconnected + + NET_CONN_STATE_DISCONNECTED, + + // We are disconnected, but in a sleep state, waiting for several + // seconds. This is in case the DISCONNECT_ACK we sent failed + // to arrive, and we need to send another one. We keep this as + // a valid connection for a few seconds until we are sure that + // the other end has successfully disconnected as well. + + NET_CONN_STATE_DISCONNECTED_SLEEP, + +} net_connstate_t; + +#define MAX_RETRIES 5 + +typedef struct +{ + net_connstate_t state; + net_addr_t *addr; + int last_send_time; + int num_retries; +} net_connection_t; + + +void NET_Conn_InitClient(net_connection_t *conn, net_addr_t *addr); +void NET_Conn_InitServer(net_connection_t *conn, net_addr_t *addr); +boolean NET_Conn_Packet(net_connection_t *conn, net_packet_t *packet, + int packet_type); +void NET_Conn_Disconnect(net_connection_t *conn); +void NET_Conn_Run(net_connection_t *conn); + +#endif /* #ifndef NET_COMMON_H */ + diff --git a/src/net_server.c b/src/net_server.c index b50d7035..82427b0b 100644 --- a/src/net_server.c +++ b/src/net_server.c @@ -1,7 +1,7 @@ // Emacs style mode select -*- C++ -*- //----------------------------------------------------------------------------- // -// $Id: net_server.c 262 2006-01-07 20:08:11Z fraggle $ +// $Id: net_server.c 263 2006-01-08 00:10:48Z fraggle $ // // Copyright(C) 2005 Simon Howard // @@ -21,6 +21,10 @@ // 02111-1307, USA. // // $Log$ +// Revision 1.12 2006/01/08 00:10:48 fraggle +// Move common connection code into net_common.c, shared by server +// and client code. +// // Revision 1.11 2006/01/07 20:08:11 fraggle // Send player name and address in the waiting data packets. Display these // on the waiting screen, and improve the waiting screen appearance. @@ -71,6 +75,7 @@ #include "doomstat.h" #include "i_system.h" #include "net_client.h" +#include "net_common.h" #include "net_defs.h" #include "net_io.h" #include "net_loop.h" @@ -78,53 +83,35 @@ #include "net_server.h" #include "net_sdl.h" -typedef enum +typedef enum { - // received a syn, sent an ack, waiting for an ack reply - - CLIENT_STATE_WAITING_ACK, - - // waiting for a game to start - - CLIENT_STATE_WAITING_START, - - // in game - - CLIENT_STATE_IN_GAME, - - // sent a DISCONNECT packet, waiting for a DISCONNECT_ACK reply + // waiting for the game to start - CLIENT_STATE_DISCONNECTING, + SERVER_WAITING_START, - // client successfully disconnected + // in a game - CLIENT_STATE_DISCONNECTED, -} net_clientstate_t; - -#define MAX_RETRIES 5 + SERVER_IN_GAME, +} net_server_state_t; typedef struct { boolean active; - net_clientstate_t state; net_addr_t *addr; + net_connection_t connection; int last_send_time; - int num_retries; } net_client_t; +static net_server_state_t server_state; static boolean server_initialised = false; static net_client_t clients[MAXNETNODES]; static net_context_t *server_context; static void NET_SV_DisconnectClient(net_client_t *client) { - if (client->active - && client->state != CLIENT_STATE_DISCONNECTING - && client->state != CLIENT_STATE_DISCONNECTED) + if (client->active) { - client->state = CLIENT_STATE_DISCONNECTING; - client->num_retries = 0; - client->last_send_time = -1; + NET_Conn_Disconnect(&client->connection); } } @@ -133,10 +120,8 @@ static boolean ClientConnected(net_client_t *client) // Check that the client is properly connected: ie. not in the // process of connecting or disconnecting - return client->active - && client->state != CLIENT_STATE_DISCONNECTING - && client->state != CLIENT_STATE_DISCONNECTED - && client->state != CLIENT_STATE_WAITING_ACK; + return client->active + && client->connection.state == NET_CONN_STATE_CONNECTED; } // returns the number of clients connected @@ -233,9 +218,6 @@ static void NET_SV_ParseSYN(net_packet_t *packet, if (!clients[i].active) { client = &clients[i]; - client->active = true; - client->addr = addr; - client->state = CLIENT_STATE_DISCONNECTED; break; } } @@ -245,99 +227,32 @@ static void NET_SV_ParseSYN(net_packet_t *packet, return; } } - - // Set into the correct state if necessary - // Allow immediate reconnects from clients which just disconnected. - - if (client->state == CLIENT_STATE_DISCONNECTED) + else { - client->state = CLIENT_STATE_WAITING_ACK; - client->num_retries = 0; - } + // If this is a recently-disconnected client, deactivate + // to allow immediate reconnection - if (client->state == CLIENT_STATE_WAITING_ACK) - { - // force an acknowledgement - - client->last_send_time = -1; + if (client->connection.state == NET_CONN_STATE_DISCONNECTED) + { + client->active = false; + } } -} -// parse an ACK packet from a client + // New client? -static void NET_SV_ParseACK(net_packet_t *packet, net_client_t *client) -{ - if (client == NULL) - { - return; - } - - if (client->state == CLIENT_STATE_WAITING_ACK) + if (!client->active) { - // now waiting for the game to start - - client->state = CLIENT_STATE_WAITING_START; - - // force a waiting data packet to be sent immediately - + // Activate, initialise connection + client->active = true; + NET_Conn_InitServer(&client->connection, addr); + client->addr = addr; client->last_send_time = -1; } -} -static void NET_SV_ParseDisconnect(net_packet_t *packet, net_client_t *client) -{ - net_packet_t *reply; - - // sanity check - - if (client == NULL) + if (client->connection.state == NET_CONN_STATE_WAITING_ACK) { - return; - } - - // This client wants to disconnect from the server. - // Send a DISCONNECT_ACK reply. - - reply = NET_NewPacket(10); - NET_WriteInt16(reply, NET_PACKET_TYPE_DISCONNECT_ACK); - NET_SendPacket(client->addr, reply); - NET_FreePacket(reply); - - client->last_send_time = I_GetTimeMS(); - - // Do not set to inactive immediately. Instead, set to the - // DISCONNECTED state. This is in case our acknowledgement is - // not received and another must be sent. - // - // After a few seconds, the client will get properly removed - // and cleaned up from the clients list. - - client->state = CLIENT_STATE_DISCONNECTED; - - //printf("SV: %s: client disconnected\n", NET_AddrToString(client->addr)); -} - -// Parse a DISCONNECT_ACK packet - -static void NET_SV_ParseDisconnectACK(net_packet_t *packet, - net_client_t *client) -{ - // Sanity check - - if (client == NULL) - { - return; - } - - if (client->state == CLIENT_STATE_DISCONNECTING) - { - // We have received an acknowledgement to our disconnect - // request. Client has been disconnected successfully. - - // Place into the DISCONNECTED state to allow for cleanup. - - client->state = CLIENT_STATE_DISCONNECTED; - client->last_send_time = -1; + // force an acknowledgement + client->connection.last_send_time = -1; } } @@ -361,30 +276,31 @@ static void NET_SV_Packet(net_packet_t *packet, net_addr_t *addr) return; } - //printf("SV: %s: %i\n", NET_AddrToString(addr), packet_type); - - switch (packet_type) + if (packet_type == NET_PACKET_TYPE_SYN) + { + NET_SV_ParseSYN(packet, client, addr); + } + else if (client == NULL) { - case NET_PACKET_TYPE_SYN: - NET_SV_ParseSYN(packet, client, addr); - break; - case NET_PACKET_TYPE_ACK: - NET_SV_ParseACK(packet, client); - break; - case NET_PACKET_TYPE_GAMESTART: - break; - case NET_PACKET_TYPE_GAMEDATA: - break; - case NET_PACKET_TYPE_DISCONNECT: - NET_SV_ParseDisconnect(packet, client); - break; - case NET_PACKET_TYPE_DISCONNECT_ACK: - NET_SV_ParseDisconnectACK(packet, client); - break; - default: - // unknown packet type - - break; + // Must come from a valid client; ignore otherwise + } + else if (NET_Conn_Packet(&client->connection, packet, packet_type)) + { + // Packet was eaten by the common connection code + } + else + { + //printf("SV: %s: %i\n", NET_AddrToString(addr), packet_type); + + switch (packet_type) + { + case NET_PACKET_TYPE_GAMESTART: + break; + default: + // unknown packet type + + break; + } } // If this address is not in the list of clients, be sure to @@ -439,48 +355,34 @@ static void NET_SV_SendWaitingData(net_client_t *client) NET_SendPacket(client->addr, packet); NET_FreePacket(packet); - - // update time - - client->last_send_time = I_GetTimeMS(); } // Perform any needed action on a client static void NET_SV_RunClient(net_client_t *client) { - net_packet_t *packet; + // Run common code - if (client->state == CLIENT_STATE_WAITING_ACK) - { - if (client->last_send_time < 0 - || I_GetTimeMS() - client->last_send_time > 1000) - { - // it has been a second since the last ACK was sent, and - // still no reply. - - if (client->num_retries < MAX_RETRIES) - { - // send another ACK + NET_Conn_Run(&client->connection); + + // Is this client disconnected? - packet = NET_NewPacket(10); - NET_WriteInt16(packet, NET_PACKET_TYPE_ACK); - NET_SendPacket(client->addr, packet); - NET_FreePacket(packet); - client->last_send_time = I_GetTimeMS(); + if (client->connection.state == NET_CONN_STATE_DISCONNECTED) + { + // deactivate and free back - ++client->num_retries; - } - else - { - // no more retries allowed. + client->active = false; + NET_FreeAddress(client->addr); + } + + if (!ClientConnected(client)) + { + // client has not yet finished connecting - client->active = false; - NET_FreeAddress(client->addr); - } - } + return; } - else if (client->state == CLIENT_STATE_WAITING_START) + + if (server_state == SERVER_WAITING_START) { // Waiting for the game to start @@ -490,55 +392,7 @@ static void NET_SV_RunClient(net_client_t *client) || I_GetTimeMS() - client->last_send_time > 1000) { NET_SV_SendWaitingData(client); - } - } - else if (client->state == CLIENT_STATE_DISCONNECTING) - { - // Waiting for a reply to our DISCONNECT request. - - if (client->last_send_time < 0 - || I_GetTimeMS() - client->last_send_time > 1000) - { - // it has been a second since the last disconnect packet - // was sent, and still no reply. - - if (client->num_retries < MAX_RETRIES) - { - // send another disconnect - - packet = NET_NewPacket(10); - NET_WriteInt16(packet, NET_PACKET_TYPE_DISCONNECT); - NET_SendPacket(client->addr, packet); - NET_FreePacket(packet); - client->last_send_time = I_GetTimeMS(); - - ++client->num_retries; - } - else - { - // No more retries allowed. - // Force disconnect. - - client->active = false; - NET_FreeAddress(client->addr); - } - } - - } - else if (client->state == CLIENT_STATE_DISCONNECTED) - { - // Client has disconnected. - // - // See NET_SV_ParseDisconnect() above. - - // Remove from the list after five seconds - - if (client->last_send_time < 0 - || I_GetTimeMS() - client->last_send_time > 5000) - { - //printf("SV: %s: deactivated\n", NET_AddrToString(client->addr)); - client->active = false; - NET_FreeAddress(client->addr); + client->last_send_time = I_GetTimeMS(); } } } @@ -564,6 +418,7 @@ void NET_SV_Init(void) clients[i].active = false; } + server_state = SERVER_WAITING_START; server_initialised = true; } |