Reliable packet transport mechanism

Subversion-branch: /trunk/chocolate-doom
Subversion-revision: 279

5 files changed, 217 insertions, 16 deletions

diff --git a/src/net_client.c b/src/net_client.c
index eae95cc9..6ff437cb 100644
--- a/src/net_client.c
+++ b/src/net_client.c
@@ -1,7 +1,7 @@
 // Emacs style mode select   -*- C++ -*- 
 //-----------------------------------------------------------------------------
 //
-// $Id: net_client.c 278 2006-01-09 02:03:39Z fraggle $
+// $Id: net_client.c 279 2006-01-10 19:59:26Z fraggle $
 //
 // Copyright(C) 2005 Simon Howard
 //
@@ -21,6 +21,9 @@
 // 02111-1307, USA.
 //
 // $Log$
+// Revision 1.16  2006/01/10 19:59:25  fraggle
+// Reliable packet transport mechanism
+//
 // Revision 1.15  2006/01/09 02:03:39  fraggle
 // Send clients their player number, and indicate on the waiting screen
 // which client we are.
@@ -219,7 +222,7 @@ static void NET_CL_ParsePacket(net_packet_t *packet)
         return;
     }
 
-    if (NET_Conn_Packet(&client_connection, packet, packet_type))
+    if (NET_Conn_Packet(&client_connection, packet, &packet_type))
     {
         // Packet eaten by the common connection code
     }
diff --git a/src/net_common.c b/src/net_common.c
index a89b1bba..92c050e1 100644
--- a/src/net_common.c
+++ b/src/net_common.c
@@ -1,7 +1,7 @@
 // Emacs style mode select   -*- C++ -*- 
 //-----------------------------------------------------------------------------
 //
-// $Id: net_common.c 268 2006-01-08 04:52:26Z fraggle $
+// $Id: net_common.c 279 2006-01-10 19:59:26Z fraggle $
 //
 // Copyright(C) 2005 Simon Howard
 //
@@ -21,6 +21,9 @@
 // 02111-1307, USA.
 //
 // $Log$
+// Revision 1.4  2006/01/10 19:59:26  fraggle
+// Reliable packet transport mechanism
+//
 // Revision 1.3  2006/01/08 04:52:26  fraggle
 // Allow the server to reject clients
 //
@@ -36,6 +39,8 @@
 // Common code shared between the client and server
 //
 
+#include <stdlib.h>
+
 #include "doomdef.h"
 #include "i_system.h"
 
@@ -51,24 +56,40 @@
 
 #define KEEPALIVE_PERIOD 1
 
-// Initialise as a client connection
+// reliable packet that is guaranteed to reach its destination
 
-void NET_Conn_InitClient(net_connection_t *conn, net_addr_t *addr)
+struct net_reliable_packet_s 
+{
+    net_packet_t *packet;
+    int last_send_time;
+    int seq;
+    net_reliable_packet_t *next;
+};
+
+static void NET_Conn_Init(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;
+    conn->reliable_packets = NULL;
+    conn->reliable_send_seq = 0;
+    conn->reliable_recv_seq = 0;
+}
+
+// Initialise as a client connection
+
+void NET_Conn_InitClient(net_connection_t *conn, net_addr_t *addr)
+{
+    NET_Conn_Init(conn, addr);
+    conn->state = NET_CONN_STATE_CONNECTING;
 }
 
 // Initialise as a server connection
 
 void NET_Conn_InitServer(net_connection_t *conn, net_addr_t *addr)
 {
+    NET_Conn_Init(conn, addr);
     conn->state = NET_CONN_STATE_WAITING_ACK;
-    conn->last_send_time = -1;
-    conn->num_retries = 0;
-    conn->addr = addr;
 }
 
 // Send a packet to a connection
@@ -158,16 +179,117 @@ static void NET_Conn_ParseReject(net_connection_t *conn, net_packet_t *packet)
     }
 }
 
+static void NET_Conn_ParseReliableACK(net_connection_t *conn, net_packet_t *packet)
+{
+    unsigned int seq;
+
+    if (!NET_ReadInt8(packet, &seq))
+    {
+        return;
+    }
+
+    if (conn->reliable_packets == NULL)
+    {
+        return;
+    }
+            
+    // Is this an acknowledgement for the first packet in the list?
+
+    if (seq == ((conn->reliable_packets->seq + 1) & 0xff))
+    {
+        net_reliable_packet_t *rp;
+
+        // Discard it, then.
+        // Unlink from the list.
+
+        rp = conn->reliable_packets;
+        conn->reliable_packets = rp->next;
+        
+        NET_FreePacket(rp->packet);
+        free(rp);
+    }
+}
+
+// Process the header of a reliable packet
+//
+// Returns true if the packet should be discarded (incorrect sequence)
+
+static boolean NET_Conn_ReliablePacket(net_connection_t *conn, 
+                                       net_packet_t *packet)
+{
+    unsigned int seq;
+    net_packet_t *reply;
+    boolean result;
+
+    // Read the sequence number
+
+    if (!NET_ReadInt8(packet, &seq))
+    {
+        return true;
+    }
+
+    if (seq != (conn->reliable_recv_seq & 0xff))
+    {
+        // This is not the next expected packet in the sequence!
+        //
+        // Discard the packet.  If we were smart, we would use a proper
+        // sliding window protocol to do this, but I'm lazy.
+
+        result = true;
+    }
+    else
+    {
+        // Now we can receive the next packet in the sequence.
+
+        conn->reliable_recv_seq = (conn->reliable_recv_seq + 1) & 0xff;
+    
+        result = false;
+    }
+
+    // Send an acknowledgement
+
+    // Note: this is braindead.  It would be much more sensible to 
+    // include this in the next packet, rather than the overhead of
+    // sending a complete packet just for one byte of information.
+
+    reply = NET_NewPacket(10);
+
+    NET_WriteInt16(reply, NET_PACKET_TYPE_RELIABLE_ACK);
+    NET_WriteInt8(reply, conn->reliable_recv_seq & 0xff);
+
+    NET_Conn_SendPacket(conn, reply);
+
+    NET_FreePacket(reply);
+
+    return result;
+}
+
 // 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)
+                        unsigned int *packet_type)
 {
     conn->keepalive_recv_time = I_GetTimeMS();
+
+    // Is this a reliable packet?
+
+    if (*packet_type & NET_RELIABLE_PACKET)
+    {
+        if (NET_Conn_ReliablePacket(conn, packet)) 
+        {
+            // Invalid packet: eat it.
+
+            return true;
+        }
+
+        // Remove the reliable bit
+
+        *packet_type &= ~NET_RELIABLE_PACKET;
+    }
     
-    switch (packet_type)
+    switch (*packet_type)
     {
         case NET_PACKET_TYPE_ACK:
             NET_Conn_ParseACK(conn, packet);
@@ -184,6 +306,9 @@ boolean NET_Conn_Packet(net_connection_t *conn, net_packet_t *packet,
         case NET_PACKET_TYPE_REJECTED:
             NET_Conn_ParseReject(conn, packet);
             break;
+        case NET_PACKET_TYPE_RELIABLE_ACK:
+            NET_Conn_ParseReliableACK(conn, packet);
+            break;
         default:
             // Not a common packet
 
@@ -236,6 +361,21 @@ void NET_Conn_Run(net_connection_t *conn)
             NET_Conn_SendPacket(conn, packet);
             NET_FreePacket(packet);
         }
+
+        // Check the reliable packet list. Has the first packet in the
+        // list timed out?
+        //
+        // NB.  This is braindead, we have a fixed time of one second.
+
+        if (conn->reliable_packets != NULL
+         && (conn->reliable_packets->last_send_time < 0
+          || nowtime - conn->reliable_packets->last_send_time > 1000))
+        {
+            // Packet timed out, time to resend
+
+            NET_Conn_SendPacket(conn, conn->reliable_packets->packet);
+            conn->reliable_packets->last_send_time = nowtime;
+        }
     }
     else if (conn->state == NET_CONN_STATE_WAITING_ACK)
     {
@@ -310,5 +450,42 @@ void NET_Conn_Run(net_connection_t *conn)
     }
 }
 
+net_packet_t *NET_Conn_NewReliable(net_connection_t *conn, int packet_type)
+{
+    net_packet_t *packet;
+    net_reliable_packet_t *rp;
+    net_reliable_packet_t **listend;
+
+    // Generate a packet with the right header
+
+    packet = NET_NewPacket(100);
 
+    NET_WriteInt16(packet, packet_type | NET_RELIABLE_PACKET);
+
+    // write the low byte of the send sequence number
+    
+    NET_WriteInt8(packet, conn->reliable_send_seq & 0xff);
+
+    // Add to the list of reliable packets
+
+    rp = malloc(sizeof(net_reliable_packet_t));
+    rp->packet = packet;
+    rp->next = NULL;
+    rp->seq = conn->reliable_send_seq;
+    rp->last_send_time = -1;
+
+    for (listend = &conn->reliable_packets; 
+         *listend != NULL; 
+         listend = &((*listend)->next));
+
+    *listend = rp;
+
+    // Count along the sequence
+
+    conn->reliable_send_seq = (conn->reliable_send_seq + 1) & 0xff;
+
+    // Finished
+    
+    return packet;
+}
 
diff --git a/src/net_common.h b/src/net_common.h
index 530a0e0d..4f5605dc 100644
--- a/src/net_common.h
+++ b/src/net_common.h
@@ -1,7 +1,7 @@
 // Emacs style mode select   -*- C++ -*- 
 //-----------------------------------------------------------------------------
 //
-// $Id: net_common.h 264 2006-01-08 02:53:05Z fraggle $
+// $Id: net_common.h 279 2006-01-10 19:59:26Z fraggle $
 //
 // Copyright(C) 2005 Simon Howard
 //
@@ -21,6 +21,9 @@
 // 02111-1307, USA.
 //
 // $Log$
+// Revision 1.3  2006/01/10 19:59:26  fraggle
+// Reliable packet transport mechanism
+//
 // Revision 1.2  2006/01/08 02:53:05  fraggle
 // Send keepalives if the connection is not doing anything else.
 // Send all packets using a new NET_Conn_SendPacket to support this.
@@ -37,6 +40,7 @@
 #define NET_COMMON_H
 
 #include "net_defs.h"
+#include "net_packet.h"
 
 typedef enum 
 {
@@ -74,6 +78,8 @@ typedef enum
 
 #define MAX_RETRIES 5
 
+typedef struct net_reliable_packet_s net_reliable_packet_t;
+
 typedef struct 
 {
     net_connstate_t state;
@@ -82,6 +88,9 @@ typedef struct
     int num_retries;
     int keepalive_send_time;
     int keepalive_recv_time;
+    net_reliable_packet_t *reliable_packets;
+    int reliable_send_seq;
+    int reliable_recv_seq;
 } net_connection_t;
 
 
@@ -89,9 +98,10 @@ void NET_Conn_SendPacket(net_connection_t *conn, net_packet_t *packet);
 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);
+                        unsigned int *packet_type);
 void NET_Conn_Disconnect(net_connection_t *conn);
 void NET_Conn_Run(net_connection_t *conn);
+net_packet_t *NET_Conn_NewReliable(net_connection_t *conn, int packet_type);
 
 #endif /* #ifndef NET_COMMON_H */
 
diff --git a/src/net_defs.h b/src/net_defs.h
index ccaa3a08..6a8e20cb 100644
--- a/src/net_defs.h
+++ b/src/net_defs.h
@@ -1,7 +1,7 @@
 // Emacs style mode select   -*- C++ -*- 
 //-----------------------------------------------------------------------------
 //
-// $Id: net_defs.h 268 2006-01-08 04:52:26Z fraggle $
+// $Id: net_defs.h 279 2006-01-10 19:59:26Z fraggle $
 //
 // Copyright(C) 2005 Simon Howard
 //
@@ -21,6 +21,9 @@
 // 02111-1307, USA.
 //
 // $Log$
+// Revision 1.7  2006/01/10 19:59:26  fraggle
+// Reliable packet transport mechanism
+//
 // Revision 1.6  2006/01/08 04:52:26  fraggle
 // Allow the server to reject clients
 //
@@ -112,6 +115,10 @@ struct _net_addr_s
 
 #define NET_MAGIC_NUMBER 3436803284U
 
+// header field value indicating that the packet is a reliable packet
+
+#define NET_RELIABLE_PACKET (1 << 15)
+
 // packet types
 
 typedef enum 
@@ -125,6 +132,7 @@ typedef enum
     NET_PACKET_TYPE_GAMEDATA,
     NET_PACKET_TYPE_DISCONNECT,
     NET_PACKET_TYPE_DISCONNECT_ACK,
+    NET_PACKET_TYPE_RELIABLE_ACK,
 } net_packet_type_t;
 
 typedef struct 
diff --git a/src/net_server.c b/src/net_server.c
index 4ed2e2b3..0fb058a0 100644
--- a/src/net_server.c
+++ b/src/net_server.c
@@ -1,7 +1,7 @@
 // Emacs style mode select   -*- C++ -*- 
 //-----------------------------------------------------------------------------
 //
-// $Id: net_server.c 278 2006-01-09 02:03:39Z fraggle $
+// $Id: net_server.c 279 2006-01-10 19:59:26Z fraggle $
 //
 // Copyright(C) 2005 Simon Howard
 //
@@ -21,6 +21,9 @@
 // 02111-1307, USA.
 //
 // $Log$
+// Revision 1.19  2006/01/10 19:59:26  fraggle
+// Reliable packet transport mechanism
+//
 // Revision 1.18  2006/01/09 02:03:39  fraggle
 // Send clients their player number, and indicate on the waiting screen
 // which client we are.
@@ -408,7 +411,7 @@ static void NET_SV_Packet(net_packet_t *packet, net_addr_t *addr)
     {
         // Must come from a valid client; ignore otherwise
     }
-    else if (NET_Conn_Packet(&client->connection, packet, packet_type))
+    else if (NET_Conn_Packet(&client->connection, packet, &packet_type))
     {
         // Packet was eaten by the common connection code
     }