--- deliantra/server/socket/request.C	2006/09/19 10:12:50	1.22
+++ deliantra/server/socket/request.C	2006/12/15 03:53:44	1.39
@@ -43,9 +43,6 @@
  * mapcellchanged, compactlayer, compactstack, perform the map compressing
  * operations
  *
- * esrv_map_doneredraw finishes the map update, and ships across the
- * map updates. 
- *
  */
 
 #include <global.h>
@@ -59,21 +56,14 @@
 /* This block is basically taken from socket.c - I assume if it works there,
  * it should work here.
  */
-#ifndef WIN32                   /* ---win32 exclude unix headers */
-# include <sys/types.h>
-# include <sys/time.h>
-# include <sys/socket.h>
-# include <netinet/in.h>
-# include <netdb.h>
-#endif /* win32 */
-
-#ifdef HAVE_UNISTD_H
-# include <unistd.h>
-#endif
+#include <sys/types.h>
+#include <sys/time.h>
+#include <sys/socket.h>
+#include <netinet/in.h>
+#include <netdb.h>
 
-#ifdef HAVE_SYS_TIME_H
-# include <sys/time.h>
-#endif
+#include <unistd.h>
+#include <sys/time.h>
 
 #include "sounds.h"
 
@@ -100,16 +90,16 @@
 };
 
 static void
-socket_map_scroll (NewSocket * ns, int dx, int dy)
+socket_map_scroll (client_socket * ns, int dx, int dy)
 {
   struct Map newmap;
   int x, y, mx, my;
 
   {
-    char buf[MAXSOCKBUF];
+    packet sl;
 
-    sprintf (buf, "map_scroll %d %d", dx, dy);
-    Write_String_To_Socket (ns, buf, strlen (buf));
+    sl.printf ("map_scroll %d %d", dx, dy);
+    ns->send_packet (sl);
   }
 
   /* If we are using the Map1aCmd, we may in fact send
@@ -139,19 +129,13 @@
       for (y = 0; y < my; y++)
         {
           if (x >= ns->mapx || y >= ns->mapy)
-            {
-              /* clear cells outside the viewable area */
-              memset (&newmap.cells[x][y], 0, sizeof (struct MapCell));
-            }
+            /* clear cells outside the viewable area */
+            memset (&newmap.cells[x][y], 0, sizeof (struct MapCell));
           else if ((x + dx) < 0 || (x + dx) >= ns->mapx || (y + dy) < 0 || (y + dy) >= ns->mapy)
-            {
-              /* clear newly visible tiles within the viewable area */
-              memset (&(newmap.cells[x][y]), 0, sizeof (struct MapCell));
-            }
+            /* clear newly visible tiles within the viewable area */
+            memset (&(newmap.cells[x][y]), 0, sizeof (struct MapCell));
           else
-            {
-              memcpy (&(newmap.cells[x][y]), &(ns->lastmap.cells[x + dx][y + dy]), sizeof (struct MapCell));
-            }
+            memcpy (&(newmap.cells[x][y]), &(ns->lastmap.cells[x + dx][y + dy]), sizeof (struct MapCell));
         }
     }
 
@@ -166,12 +150,12 @@
 static void
 clear_map (player *pl)
 {
-  NewSocket & socket = pl->socket;
+  client_socket &socket = *pl->socket;
 
   memset (&socket.lastmap, 0, sizeof (socket.lastmap));
 
   if (socket.newmapcmd == 1)
-    Write_String_To_Socket (&socket, "newmap", 6);
+    socket.send_packet ("newmap");
 
   socket.update_look = 1;
   socket.look_position = 0;
@@ -181,7 +165,7 @@
 static void
 check_map_change (player *pl)
 {
-  NewSocket & socket = pl->socket;
+  client_socket &socket = *pl->socket;
   object *ob = pl->ob;
   char buf[MAX_BUF];            /* eauugggh */
 
@@ -212,7 +196,7 @@
           else
             snprintf (buf, MAX_BUF, "mapinfo current");
 
-          Write_String_To_Socket (&socket, buf, strlen (buf));
+          socket.send_packet (buf);
         }
     }
   else if (socket.current_x != ob->x || socket.current_y != ob->y)
@@ -262,8 +246,8 @@
       // initial map and its origin
       maptile *map = pl->ob->map;
       sint16 dx, dy;
-      int mapx = pl->socket.mapx / 2 - pl->ob->x;
-      int mapy = pl->socket.mapy / 2 - pl->ob->y;
+      int mapx = pl->socket->mapx / 2 - pl->ob->x;
+      int mapy = pl->socket->mapy / 2 - pl->ob->y;
       int max_distance = 8;     // limit maximum path length to something generous
 
       while (*buf && map && max_distance)
@@ -324,12 +308,12 @@
   else
     snprintf (bigbuf, MAX_BUF, "mapinfo %s unsupported", token);
 
-  Write_String_To_Socket (&pl->socket, bigbuf, strlen (bigbuf));
+  pl->socket->send_packet (bigbuf);
 }
 
 /** This is the Setup cmd - easy first implementation */
 void
-SetUp (char *buf, int len, NewSocket * ns)
+SetUp (char *buf, int len, client_socket * ns)
 {
   int s, slen;
   char *cmd, *param, cmdback[HUGE_BUF];
@@ -341,16 +325,19 @@
    * The client then must sort this out
    */
 
-  LOG (llevInfo, "Get SetupCmd:: %s\n", buf);
+  //LOG (llevInfo, "Get SetupCmd:: %s\n", buf);
+
   strcpy (cmdback, "setup");
-  for (s = 0; s < len;)
+  for (s = 0; s < len; )
     {
-
       cmd = &buf[s];
 
       /* find the next space, and put a null there */
-      for (; buf[s] && buf[s] != ' '; s++);
+      for (; buf[s] && buf[s] != ' '; s++)
+        ; 
+
       buf[s++] = 0;
+
       while (buf[s] == ' ')
         s++;
 
@@ -359,8 +346,11 @@
 
       param = &buf[s];
 
-      for (; buf[s] && buf[s] != ' '; s++);
+      for (; buf[s] && buf[s] != ' '; s++)
+        ;
+
       buf[s++] = 0;
+
       while (buf[s] == ' ')
         s++;
 
@@ -531,8 +521,9 @@
           safe_strcat (cmdback, "FALSE", &slen, HUGE_BUF);
         }
     }                           /* for processing all the setup commands */
+
   LOG (llevInfo, "SendBack SetupCmd:: %s\n", cmdback);
-  Write_String_To_Socket (ns, cmdback, strlen (cmdback));
+  ns->send_packet (cmdback);
 }
 
 /**
@@ -542,32 +533,22 @@
  * it either has to be here or init_sockets needs to be exported.
  */
 void
-AddMeCmd (char *buf, int len, NewSocket * ns)
+AddMeCmd (char *buf, int len, client_socket * ns)
 {
   Settings oldsettings;
 
   oldsettings = settings;
   if (ns->status != Ns_Add || add_player (ns))
-    {
-      Write_String_To_Socket (ns, "addme_failed", 12);
-    }
+    ns->send_packet ("addme_failed");
   else
-    {
-      /* Basically, the add_player copies the socket structure into
-       * the player structure, so this one (which is from init_sockets)
-       * is not needed anymore.  The write below should still work, as the
-       * stuff in ns is still relevant.
-       */
-      Write_String_To_Socket (ns, "addme_success", 13);
-      socket_info.nconns--;
-      ns->status = Ns_Avail;
-    }
+    ns->send_packet ("addme_success");
+
   settings = oldsettings;
 }
 
 /** Reply to ExtendedInfos command */
 void
-ToggleExtendedInfos (char *buf, int len, NewSocket * ns)
+ToggleExtendedInfos (char *buf, int len, client_socket * ns)
 {
   char cmdback[MAX_BUF];
   char command[50];
@@ -615,7 +596,7 @@
       strcat (cmdback, "smoothing");
     }
 
-  Write_String_To_Socket (ns, cmdback, strlen (cmdback));
+  ns->send_packet (cmdback);
 }
 
 /*
@@ -628,7 +609,7 @@
 
 /** Reply to ExtendedInfos command */
 void
-ToggleExtendedText (char *buf, int len, NewSocket * ns)
+ToggleExtendedText (char *buf, int len, client_socket * ns)
 {
   char cmdback[MAX_BUF];
   char temp[10];
@@ -678,7 +659,7 @@
         strcat (cmdback, temp);
       }
 
-  Write_String_To_Socket (ns, cmdback, strlen (cmdback));
+  ns->send_packet (cmdback);
 }
 
 /**
@@ -689,11 +670,9 @@
  * client.
  */
 static void
-SendSmooth (NewSocket * ns, uint16 face)
+SendSmooth (client_socket * ns, uint16 face)
 {
   uint16 smoothface;
-  unsigned char reply[MAX_BUF];
-  SockList sl;
 
   /* If we can't find a face, return and set it so we won't try to send this
    * again.
@@ -711,12 +690,13 @@
 
   ns->faces_sent[face] |= NS_FACESENT_SMOOTH;
 
-  sl.buf = reply;
-  strcpy ((char *) sl.buf, "smooth ");
-  sl.len = strlen ((char *) sl.buf);
-  SockList_AddShort (&sl, face);
-  SockList_AddShort (&sl, smoothface);
-  Send_With_Handling (ns, &sl);
+  packet sl;
+
+  sl << "smooth "
+     << uint16 (face)
+     << uint16 (smoothface);
+
+  ns->send_packet (sl);
 }
 
  /**
@@ -724,7 +704,7 @@
   * to smooth a picture number given as argument.
   */
 void
-AskSmooth (char *buf, int len, NewSocket * ns)
+AskSmooth (char *buf, int len, client_socket * ns)
 {
   uint16 facenbr;
 
@@ -732,10 +712,6 @@
   SendSmooth (ns, facenbr);
 }
 
-
-
-
-
 /**
  * This handles the general commands from the client (ie, north, fire, cast,
  * etc.)
@@ -795,12 +771,11 @@
  * can throttle.
  */
 void
-NewPlayerCmd (uint8 * buf, int len, player *pl)
+NewPlayerCmd (char *buf, int len, player *pl)
 {
   int time, repeat;
-  short packet;
-  unsigned char command[MAX_BUF];
-  SockList sl;
+  char command[MAX_BUF];
+  int pktlen;
 
   if (len < 7)
     {
@@ -808,35 +783,23 @@
       return;
     }
 
-  packet = GetShort_String (buf);
-  repeat = GetInt_String (buf + 2);
+  pktlen = net_uint16 ((uint8 *)buf);
+  repeat = net_uint32 ((uint8 *)buf + 2);
+
   /* -1 is special - no repeat, but don't update */
   if (repeat != -1)
-    {
-      pl->count = repeat;
-    }
+    pl->count = repeat;
+
   if ((len - 4) >= MAX_BUF)
     len = MAX_BUF - 5;
 
   strncpy ((char *) command, (char *) buf + 6, len - 4);
-  command[len - 4] = '\0';
-
-  /* The following should never happen with a proper or honest client.
-   * Therefore, the error message doesn't have to be too clear - if 
-   * someone is playing with a hacked/non working client, this gives them
-   * an idea of the problem, but they deserve what they get
-   */
-  if (pl->state != ST_PLAYING)
-    {
-      new_draw_info_format (NDI_UNIQUE, 0, pl->ob, "You can not issue commands - state is not ST_PLAYING (%s)", buf);
-      return;
-    }
+  command[len - 4] = 0;
 
   /* This should not happen anymore.    */
   if (pl->ob->speed_left < -1.0)
-    {
-      LOG (llevError, "Player has negative time - shouldn't do command.\n");
-    }
+    LOG (llevError, "Player has negative time - shouldn't do command.\n");
+
   /* In c_new.c */
   execute_newserver_command (pl->ob, (char *) command);
   /* Perhaps something better should be done with a left over count.
@@ -846,17 +809,16 @@
    */
   pl->count = 0;
 
-  /* Send confirmation of command execution now */
-  sl.buf = command;
-  strcpy ((char *) sl.buf, "comc ");
-  sl.len = 5;
-  SockList_AddShort (&sl, packet);
   if (FABS (pl->ob->speed) < 0.001)
     time = MAX_TIME * 100;
   else
     time = (int) (MAX_TIME / FABS (pl->ob->speed));
-  SockList_AddInt (&sl, time);
-  Send_With_Handling (&pl->socket, &sl);
+
+  /* Send confirmation of command execution now */
+
+  packet sl;
+  sl << "comc " << uint16 (pktlen) << uint32 (time);
+  pl->socket->send_packet (sl);
 }
 
 
@@ -933,7 +895,7 @@
  * problem.
  */
 void
-VersionCmd (char *buf, int len, NewSocket * ns)
+VersionCmd (char *buf, int len, client_socket * ns)
 {
   char *cp;
   char version_warning[256];
@@ -978,11 +940,11 @@
        * requiing this minimal value reduces complexity of that code, and it
        * has been around for a long time.
        */
-      if (!strcmp (" CF DX CLIENT", cp) || ns->sc_version < 1024)
+      if (ns->sc_version < 1026)
         {
           sprintf (version_warning, "drawinfo %d %s", NDI_RED,
                    "**** VERSION WARNING ****\n**** CLIENT IS TOO OLD!! UPDATE THE CLIENT!! ****");
-          Write_String_To_Socket (ns, version_warning, strlen (version_warning));
+          ns->send_packet (version_warning);
         }
 
     }
@@ -991,7 +953,7 @@
 /** sound related functions. */
 
 void
-SetSound (char *buf, int len, NewSocket * ns)
+SetSound (char *buf, int len, client_socket * ns)
 {
   ns->sound = atoi (buf);
 }
@@ -1011,7 +973,7 @@
   /* Okay, this is MAJOR UGLY. but the only way I know how to
    * clear the "cache"
    */
-  memset (&pl->socket.lastmap, 0, sizeof (struct Map));
+  memset (&pl->socket->lastmap, 0, sizeof (struct Map));
   draw_client_map (pl->ob);
 #endif
 }
@@ -1059,45 +1021,37 @@
  * it needs to send something back (vs just printing out a message)
  */
 void
-send_query (NewSocket * ns, uint8 flags, char *text)
+send_query (client_socket * ns, uint8 flags, char *text)
 {
   char buf[MAX_BUF];
 
   sprintf (buf, "query %d %s", flags, text ? text : "");
-  Write_String_To_Socket (ns, buf, strlen (buf));
+  ns->send_packet (buf);
 }
 
 #define AddIfInt64(Old,New,Type) if (Old != New) {\
                         Old = New; \
-                        SockList_AddChar(&sl, Type); \
-                        SockList_AddInt64(&sl, New); \
+                        sl << uint8 (Type) << uint64 (New); \
                        }
 
 #define AddIfInt(Old,New,Type) if (Old != New) {\
                         Old = New; \
-                        SockList_AddChar(&sl, Type); \
-                        SockList_AddInt(&sl, New); \
+                        sl << uint8 (Type) << uint32 (New); \
                        }
 
 #define AddIfShort(Old,New,Type) if (Old != New) {\
                         Old = New; \
-                        SockList_AddChar(&sl, Type); \
-                        SockList_AddShort(&sl, New); \
+                        sl << uint8 (Type) << uint16 (New); \
                        }
 
 #define AddIfFloat(Old,New,Type) if (Old != New) {\
                         Old = New; \
-                        SockList_AddChar(&sl, Type); \
-                        SockList_AddInt(&sl,(long)(New*FLOAT_MULTI));\
+                        sl << uint8 (Type) << uint32 (New*FLOAT_MULTI); \
                         }
 
 #define AddIfString(Old,New,Type) if (Old == NULL || strcmp(Old,New)) {\
-                        if (Old) free(Old);\
-                        Old = strdup_local(New);\
-                        SockList_AddChar(&sl, Type); \
-                        SockList_AddChar(&sl, ( char )strlen(New)); \
-                        strcpy((char*)sl.buf + sl.len, New); \
-                        sl.len += strlen(New); \
+                        free(Old); Old = strdup (New);\
+                        sl << uint8 (Type) << data8 (New); \
                         }
 
 /**
@@ -1109,13 +1063,11 @@
 void
 esrv_update_stats (player *pl)
 {
-  SockList sl;
   char buf[MAX_BUF];
   uint16 flags;
 
-  sl.buf = (unsigned char *) malloc (MAXSOCKBUF);
-  strcpy ((char *) sl.buf, "stats ");
-  sl.len = strlen ((char *) sl.buf);
+  packet sl;
+  sl << "stats ";
 
   if (pl->ob != NULL)
     {
@@ -1134,7 +1086,7 @@
       AddIfShort (pl->last_stats.Cha, pl->ob->stats.Cha, CS_STAT_CHA);
     }
 
-  if (pl->socket.exp64)
+  if (pl->socket->exp64)
     {
       uint8 s;
 
@@ -1142,22 +1094,22 @@
         {
           if (pl->last_skill_ob[s] && pl->last_skill_exp[s] != pl->last_skill_ob[s]->stats.exp)
             {
-
               /* Always send along the level if exp changes.  This is only
                * 1 extra byte, but keeps processing simpler.
                */
-              SockList_AddChar (&sl, (char) (s + CS_STAT_SKILLINFO));
-              SockList_AddChar (&sl, (char) pl->last_skill_ob[s]->level);
-              SockList_AddInt64 (&sl, pl->last_skill_ob[s]->stats.exp);
+              sl << uint8 (s + CS_STAT_SKILLINFO)
+                 << uint8 (pl->last_skill_ob[s]->level)
+                 << uint64 (pl->last_skill_ob[s]->stats.exp);
+
               pl->last_skill_exp[s] = pl->last_skill_ob[s]->stats.exp;
             }
         }
     }
 
-  if (pl->socket.exp64)
-    AddIfInt64 (pl->last_stats.exp, pl->ob->stats.exp, CS_STAT_EXP64);
+  if (pl->socket->exp64)
+    { AddIfInt64 (pl->last_stats.exp, pl->ob->stats.exp, CS_STAT_EXP64) }
   else
-    AddIfInt (pl->last_stats.exp, (int) pl->ob->stats.exp, CS_STAT_EXP);
+    { AddIfInt (pl->last_stats.exp, (int) pl->ob->stats.exp, CS_STAT_EXP) }
 
   AddIfShort (pl->last_level, (char) pl->ob->level, CS_STAT_LEVEL);
   AddIfShort (pl->last_stats.wc, pl->ob->stats.wc, CS_STAT_WC);
@@ -1177,8 +1129,8 @@
 
   AddIfShort (pl->last_flags, flags, CS_STAT_FLAGS);
 
-  if (pl->socket.sc_version < 1025)
-    AddIfShort (pl->last_resist[ATNR_PHYSICAL], pl->ob->resist[ATNR_PHYSICAL], CS_STAT_ARMOUR);
+  if (pl->socket->sc_version < 1025)
+    { AddIfShort (pl->last_resist[ATNR_PHYSICAL], pl->ob->resist[ATNR_PHYSICAL], CS_STAT_ARMOUR) }
   else
     {
       int i;
@@ -1188,11 +1140,12 @@
           /* Skip ones we won't send */
           if (atnr_cs_stat[i] == -1)
             continue;
+
           AddIfShort (pl->last_resist[i], pl->ob->resist[i], (char) atnr_cs_stat[i]);
         }
     }
 
-  if (pl->socket.monitor_spells)
+  if (pl->socket->monitor_spells)
     {
       AddIfInt (pl->last_path_attuned, pl->ob->path_attuned, CS_STAT_SPELL_ATTUNE);
       AddIfInt (pl->last_path_repelled, pl->ob->path_repelled, CS_STAT_SPELL_REPEL);
@@ -1200,50 +1153,35 @@
     }
 
   rangetostring (pl->ob, buf);  /* we want use the new fire & run system in new client */
-  AddIfString (pl->socket.stats.range, buf, CS_STAT_RANGE);
+  AddIfString (pl->socket->stats.range, buf, CS_STAT_RANGE);
   set_title (pl->ob, buf);
-  AddIfString (pl->socket.stats.title, buf, CS_STAT_TITLE);
+  AddIfString (pl->socket->stats.title, buf, CS_STAT_TITLE);
 
   /* Only send it away if we have some actual data */
-  if (sl.len > 6)
-    {
-#ifdef ESRV_DEBUG
-      LOG (llevDebug, "Sending stats command, %d bytes long.\n", sl.len);
-#endif
-      Send_With_Handling (&pl->socket, &sl);
-    }
-  free (sl.buf);
+  if (sl.length () > 6)
+    pl->socket->send_packet (sl);
 }
 
-
 /**
  * Tells the client that here is a player it should start using.
  */
 void
 esrv_new_player (player *pl, uint32 weight)
 {
-  SockList sl;
-
   pl->last_weight = weight;
 
-  sl.buf = (unsigned char *) malloc (MAXSOCKBUF);
+  packet sl;
+  sl << "player ";
 
-  strcpy ((char *) sl.buf, "player ");
-  sl.len = strlen ((char *) sl.buf);
-  SockList_AddInt (&sl, pl->ob->count);
-  SockList_AddInt (&sl, weight);
-  SockList_AddInt (&sl, pl->ob->face->number);
-
-  SockList_AddChar (&sl, (char) strlen (pl->ob->name));
-  strcpy ((char *) sl.buf + sl.len, pl->ob->name);
-  sl.len += strlen (pl->ob->name);
+  sl << uint32 (pl->ob->count)
+     << uint32 (weight)
+     << uint32 (pl->ob->face->number)
+     << data8  (pl->ob->name);
 
-  Send_With_Handling (&pl->socket, &sl);
-  free (sl.buf);
+  pl->socket->send_packet (sl);
   SET_FLAG (pl->ob, FLAG_CLIENT_SENT);
 }
 
-
 /**
  * Need to send an animation sequence to the client.
  * We will send appropriate face commands to the client if we haven't
@@ -1252,9 +1190,8 @@
  * when the player logs in and picks stuff up.
  */
 void
-esrv_send_animation (NewSocket * ns, short anim_num)
+esrv_send_animation (client_socket * ns, short anim_num)
 {
-  SockList sl;
   int i;
 
   /* Do some checking on the anim_num we got.  Note that the animations
@@ -1267,11 +1204,12 @@
       return;
     }
 
-  sl.buf = (unsigned char *) malloc (MAXSOCKBUF);
-  strcpy ((char *) sl.buf, "anim ");
-  sl.len = 5;
-  SockList_AddShort (&sl, anim_num);
-  SockList_AddShort (&sl, 0);   /* flags - not used right now */
+  packet sl;
+
+  sl << "anim "
+     << uint16 (anim_num)
+     << uint16 (0); /* flags - not used right now */
+
   /* Build up the list of faces.  Also, send any information (ie, the
    * the face itself) down to the client.
    */
@@ -1279,10 +1217,11 @@
     {
       if (!(ns->faces_sent[animations[anim_num].faces[i]] & NS_FACESENT_FACE))
         esrv_send_face (ns, animations[anim_num].faces[i], 0);
-      SockList_AddShort (&sl, animations[anim_num].faces[i]);   /* flags - not used right now */
+      sl << uint16 (animations[anim_num].faces[i]);   /* flags - not used right now */
     }
-  Send_With_Handling (ns, &sl);
-  free (sl.buf);
+
+  ns->send_packet (sl);
+
   ns->anims_sent[anim_num] = 1;
 }
 
@@ -1298,7 +1237,7 @@
  * the face yet, we will also send it.
  */
 static void
-esrv_map_setbelow (NewSocket * ns, int x, int y, short face_num, struct Map *newmap)
+esrv_map_setbelow (client_socket * ns, int x, int y, short face_num, struct Map *newmap)
 {
   if (newmap->cells[x][y].count >= MAP_LAYERS)
     {
@@ -1306,8 +1245,10 @@
       return;
       abort ();
     }
+
   newmap->cells[x][y].faces[newmap->cells[x][y].count] = face_num;
   newmap->cells[x][y].count++;
+
   if (!(ns->faces_sent[face_num] & NS_FACESENT_FACE))
     esrv_send_face (ns, face_num, 0);
 }
@@ -1326,7 +1267,7 @@
 
 /** Checkes if map cells have changed */
 static int
-mapcellchanged (NewSocket * ns, int i, int j, struct Map *newmap)
+mapcellchanged (client_socket * ns, int i, int j, struct Map *newmap)
 {
   int k;
 
@@ -1349,7 +1290,7 @@
  * how many layers of data we should back.
  */
 static uint8 *
-compactlayer (NewSocket * ns, unsigned char *cur, int numlayers, struct Map *newmap)
+compactlayer (client_socket * ns, unsigned char *cur, int numlayers, struct Map *newmap)
 {
   int x, y, k;
   int face;
@@ -1419,42 +1360,6 @@
   return cur;
 }
 
-static void
-esrv_map_doneredraw (NewSocket * ns, struct Map *newmap)
-{
-  static long frames, bytes, tbytes, tframes;
-  char *cur;
-  SockList sl;
-
-
-  sl.buf = (unsigned char *) malloc (MAXSOCKBUF);
-  strcpy ((char *) sl.buf, "map ");
-  sl.len = strlen ((char *) sl.buf);
-
-  cur = (char *) compactlayer (ns, (unsigned char *) sl.buf + sl.len, MAP_LAYERS, newmap);
-  sl.len = cur - (char *) sl.buf;
-
-/*    LOG(llevDebug, "Sending map command.\n");*/
-
-  if (sl.len > (int) strlen ("map ") || ns->sent_scroll)
-    {
-      /* All of this is just accounting stuff */
-      if (tframes > 100)
-        tframes = tbytes = 0;
-
-      tframes++;
-      frames++;
-      tbytes += sl.len;
-      bytes += sl.len;
-      memcpy (&ns->lastmap, newmap, sizeof (struct Map));
-      Send_With_Handling (ns, &sl);
-      ns->sent_scroll = 0;
-    }
-
-  free (sl.buf);
-}
-
-
 /** Clears a map cell */
 static void
 map_clearcell (struct MapCell *cell, int face0, int face1, int face2, int count)
@@ -1462,9 +1367,10 @@
   cell->faces[0] = face0;
   cell->faces[1] = face1;
   cell->faces[2] = face2;
-  cell->count = count;
-  cell->stat_hp = 0;
-  cell->player = 0;
+  cell->count    = count;
+  cell->stat_hp  = 0;
+  cell->flags    = 0;
+  cell->player   = 0;
 }
 
 #define MAX_HEAD_POS	MAX(MAX_CLIENT_X, MAX_CLIENT_Y)
@@ -1502,7 +1408,7 @@
  * sent, it returns zero.
  */
 static int
-check_head (SockList & sl, NewSocket & ns, int ax, int ay, int layer)
+check_head (packet &sl, client_socket &ns, int ax, int ay, int layer)
 {
   short face_num;
 
@@ -1513,9 +1419,10 @@
 
   if (face_num != ns.lastmap.cells[ax][ay].faces[layer])
     {
-      SockList_AddShort (&sl, face_num);
+      sl << uint16 (face_num);
       if (face_num && !(ns.faces_sent[face_num] & NS_FACESENT_FACE))
         esrv_send_face (&ns, face_num, 0);
+
       heads[(ay * MAX_HEAD_POS + ax) * MAX_LAYERS + layer] = NULL;
       ns.lastmap.cells[ax][ay].faces[layer] = face_num;
       return 1;
@@ -1545,7 +1452,7 @@
  */
 
 static int
-update_space (SockList * sl, NewSocket * ns, maptile *mp, int mx, int my, int sx, int sy, int layer)
+update_space (packet &sl, client_socket &ns, maptile *mp, int mx, int my, int sx, int sy, int layer)
 {
   object *ob, *head;
   uint16 face_num;
@@ -1554,7 +1461,6 @@
   /* If there is a multipart object stored away, treat that as more important.
    * If not, then do the normal processing.
    */
-
   head = heads[(sy * MAX_HEAD_POS + sx) * MAX_LAYERS + layer];
 
   /* Check to see if this head is part of the set of objects
@@ -1729,22 +1635,22 @@
    * we already sent for a lower layer.  In that case, don't send
    * this one.
    */
-  if (face_num && layer + 1 < MAP_LAYERS && ns->lastmap.cells[sx][sy].faces[layer + 1] == face_num)
-    {
-      face_num = 0;
-    }
+  if (face_num && layer + 1 < MAP_LAYERS && ns.lastmap.cells[sx][sy].faces[layer + 1] == face_num)
+    face_num = 0;
 
   /* We've gotten what face we want to use for the object.  Now see if
    * if it has changed since we last sent it to the client.
    */
-  if (ns->lastmap.cells[sx][sy].faces[layer] != face_num)
+  if (ns.lastmap.cells[sx][sy].faces[layer] != face_num)
     {
-      ns->lastmap.cells[sx][sy].faces[layer] = face_num;
-      if (!(ns->faces_sent[face_num] & NS_FACESENT_FACE))
-        esrv_send_face (ns, face_num, 0);
-      SockList_AddShort (sl, face_num);
+      ns.lastmap.cells[sx][sy].faces[layer] = face_num;
+      if (!(ns.faces_sent[face_num] & NS_FACESENT_FACE))
+        esrv_send_face (&ns, face_num, 0);
+
+      sl << uint16 (face_num);
       return 1;
     }
+
   /* Nothing changed */
   return 0;
 }
@@ -1769,7 +1675,7 @@
  */
 
 static inline int
-update_smooth (SockList * sl, NewSocket * ns, maptile *mp, int mx, int my, int sx, int sy, int layer)
+update_smooth (packet &sl, client_socket &ns, maptile *mp, int mx, int my, int sx, int sy, int layer)
 {
   object *ob;
   int smoothlevel;              /* old face_num; */
@@ -1784,8 +1690,8 @@
   else
     {
       smoothlevel = ob->smoothlevel;
-      if (smoothlevel && !(ns->faces_sent[ob->face->number] & NS_FACESENT_SMOOTH))
-        SendSmooth (ns, ob->face->number);
+      if (smoothlevel && !(ns.faces_sent[ob->face->number] & NS_FACESENT_SMOOTH))
+        SendSmooth (&ns, ob->face->number);
     }                           /* else not already head object or blank face */
 
   /* We've gotten what face we want to use for the object.  Now see if
@@ -1795,12 +1701,14 @@
     smoothlevel = 255;
   else if (smoothlevel < 0)
     smoothlevel = 0;
-  if (ns->lastmap.cells[sx][sy].smooth[layer] != smoothlevel)
+
+  if (ns.lastmap.cells[sx][sy].smooth[layer] != smoothlevel)
     {
-      ns->lastmap.cells[sx][sy].smooth[layer] = smoothlevel;
-      SockList_AddChar (sl, (uint8) (smoothlevel & 0xFF));
+      ns.lastmap.cells[sx][sy].smooth[layer] = smoothlevel;
+      sl << uint8 (smoothlevel);
       return 1;
     }
+
   /* Nothing changed */
   return 0;
 }
@@ -1811,7 +1719,7 @@
  * available.
  */
 int
-getExtendedMapInfoSize (NewSocket * ns)
+getExtendedMapInfoSize (client_socket * ns)
 {
   int result = 0;
 
@@ -1851,41 +1759,39 @@
   int x, y, ax, ay, d, startlen, max_x, max_y, oldlen;
   sint16 nx, ny;
   int estartlen, eoldlen;
-  SockList sl;
-  SockList esl;                 /*For extended Map info */
   uint16 mask, emask;
   uint8 eentrysize;
   uint16 ewhatstart, ewhatflag;
   uint8 extendedinfos;
   maptile *m;
 
-  NewSocket & socket = pl->contr->socket;
+  client_socket &socket = *pl->contr->socket;
 
   check_map_change (pl->contr);
 
-  sl.buf = (unsigned char *) malloc (MAXSOCKBUF);
-  if (socket.mapmode == Map1Cmd)
-    strcpy ((char *) sl.buf, "map1 ");
-  else
-    strcpy ((char *) sl.buf, "map1a ");
-  sl.len = strlen ((char *) sl.buf);
-  startlen = sl.len;
+  packet sl;
+  packet esl;
+
+  sl << (socket.mapmode == Map1Cmd ? "map1 " : "map1a ");
+  startlen = sl.length ();
+
   /*Extendedmapinfo structure initialisation */
   if (socket.ext_mapinfos)
     {
-      esl.buf = (unsigned char *) malloc (MAXSOCKBUF);
-      strcpy ((char *) esl.buf, "mapextended ");
-      esl.len = strlen ((char *) esl.buf);
       extendedinfos = EMI_NOREDRAW;
+
       if (socket.EMI_smooth)
         extendedinfos |= EMI_SMOOTH;
-      ewhatstart = esl.len;
+
+      ewhatstart = esl.length ();
       ewhatflag = extendedinfos;        /*The EMI_NOREDRAW bit
                                            could need to be taken away */
-      SockList_AddChar (&esl, extendedinfos);
       eentrysize = getExtendedMapInfoSize (&socket);
-      SockList_AddChar (&esl, eentrysize);
-      estartlen = esl.len;
+      esl << "mapextended "
+          << uint8 (extendedinfos)
+          << uint8 (eentrysize);
+
+      estartlen = esl.length ();
     }
   else
     {
@@ -1894,6 +1800,7 @@
       ewhatflag = 0;
       estartlen = 0;
     }
+
   /* Init data to zero */
   memset (heads, 0, sizeof (object *) * MAX_HEAD_POS * MAX_HEAD_POS * MAX_LAYERS);
 
@@ -1907,6 +1814,7 @@
    */
   max_x = pl->x + (socket.mapx + 1) / 2;
   max_y = pl->y + (socket.mapy + 1) / 2;
+
   if (socket.mapmode == Map1aCmd)
     {
       max_x += MAX_HEAD_OFFSET;
@@ -1931,16 +1839,13 @@
             {
               int i, got_one;
 
-              oldlen = sl.len;
+              oldlen = sl.length ();
 
-              SockList_AddShort (&sl, mask);
+              sl << uint16 (mask);
 
-              if (check_head (sl, socket, ax, ay, 2))
-                mask |= 0x4;
-              if (check_head (sl, socket, ax, ay, 1))
-                mask |= 0x2;
-              if (check_head (sl, socket, ax, ay, 0))
-                mask |= 0x1;
+              if (check_head (sl, socket, ax, ay, 2)) mask |= 0x4;
+              if (check_head (sl, socket, ax, ay, 1)) mask |= 0x2;
+              if (check_head (sl, socket, ax, ay, 0)) mask |= 0x1;
 
               /* If all we are doing is sending 0 (blank) faces, we don't
                * actually need to send that - just the coordinates
@@ -1948,30 +1853,27 @@
                * space.
                */
               got_one = 0;
-              for (i = oldlen + 2; i < sl.len; i++)
-                {
-                  if (sl.buf[i])
-                    got_one = 1;
-                }
+              for (i = oldlen + 2; i < sl.length (); i++)
+                if (sl[i])
+                  got_one = 1;
 
               if (got_one && (mask & 0xf))
-                {
-                  sl.buf[oldlen + 1] = mask & 0xff;
-                }
+                sl[oldlen + 1] = mask & 0xff;
               else
                 {               /*either all faces blank, either no face at all */
                   if (mask & 0xf)       /*at least 1 face, we know it's blank, only send coordinates */
-                    sl.len = oldlen + 2;
+                    sl.reset (oldlen + 2);
                   else
-                    sl.len = oldlen;
+                    sl.reset (oldlen);
                 }
+
               /*What concerns extendinfos, nothing to be done for now
                * (perhaps effects layer later)
                */
               continue;         /* don't do processing below */
             }
 
-          MapCell & lastcell = socket.lastmap.cells[ax][ay];
+          MapCell &lastcell = socket.lastmap.cells[ax][ay];
 
           d = pl->contr->blocked_los[ax][ay];
 
@@ -1981,6 +1883,7 @@
           nx = x;
           ny = y;
           m = get_map_from_coord (pl->map, &nx, &ny);
+
           if (!m)
             {
               /* space is out of map.  Update space and clear values
@@ -1989,7 +1892,7 @@
                */
               if (lastcell.count != -1)
                 {
-                  SockList_AddShort (&sl, mask);
+                  sl << uint16 (mask);
                   map_clearcell (&lastcell, 0, 0, 0, -1);
                 }
             }
@@ -2001,45 +1904,39 @@
                * reason.  Still may need to send the head for this space.
                */
 
-              oldlen = sl.len;
+              oldlen = sl.length ();
+
+              sl << uint16 (mask);
 
-              SockList_AddShort (&sl, mask);
               if (lastcell.count != -1)
                 need_send = 1;
+
               count = -1;
 
               if (socket.mapmode == Map1aCmd && have_head (ax, ay))
                 {
                   /* Now check to see if any heads need to be sent */
 
-                  if (check_head (sl, socket, ax, ay, 2))
-                    mask |= 0x4;
-                  if (check_head (sl, socket, ax, ay, 1))
-                    mask |= 0x2;
-                  if (check_head (sl, socket, ax, ay, 0))
-                    mask |= 0x1;
+                  if (check_head (sl, socket, ax, ay, 2)) mask |= 0x4;
+                  if (check_head (sl, socket, ax, ay, 1)) mask |= 0x2;
+                  if (check_head (sl, socket, ax, ay, 0)) mask |= 0x1;
 
                   lastcell.count = count;
-
                 }
               else
                 {
-                  struct MapCell *cell = &lastcell;
-
                   /* properly clear a previously sent big face */
-                  if (cell->faces[0] != 0 || cell->faces[1] != 0 || cell->faces[2] != 0)
+                  if (lastcell.faces[0] != 0 || lastcell.faces[1] != 0 || lastcell.faces[2] != 0
+                      || lastcell.stat_hp || lastcell.flags || lastcell.player)
                     need_send = 1;
+
                   map_clearcell (&lastcell, 0, 0, 0, count);
                 }
 
               if ((mask & 0xf) || need_send)
-                {
-                  sl.buf[oldlen + 1] = mask & 0xff;
-                }
+                sl[oldlen + 1] = mask & 0xff;
               else
-                {
-                  sl.len = oldlen;
-                }
+                sl.reset (oldlen);
             }
           else
             {
@@ -2051,20 +1948,20 @@
                * need to send is, then form the packet after that,
                * we presume that we will in fact form a packet, and update
                * the bits by what we do actually send.  If we send nothing,
-               * we just back out sl.len to the old value, and no harm
+               * we just back out sl.length () to the old value, and no harm
                * is done.
                * I think this is simpler than doing a bunch of checks to see
                * what if anything we need to send, setting the bits, then
                * doing those checks again to add the real data.
                */
-              oldlen = sl.len;
+              oldlen = sl.length ();
               mask = (ax & 0x3f) << 10 | (ay & 0x3f) << 4;
-              eoldlen = esl.len;
+              eoldlen = esl.length ();
               emask = (ax & 0x3f) << 10 | (ay & 0x3f) << 4;
-              SockList_AddShort (&sl, mask);
+              sl << uint16 (mask);
 
               if (socket.ext_mapinfos)
-                SockList_AddShort (&esl, emask);
+                esl << uint16 (emask);
 
               unsigned char dummy;
               unsigned char *last_ext = &dummy;
@@ -2077,11 +1974,11 @@
                   if (socket.extmap)
                     {
                       *last_ext |= 0x80;
-                      last_ext = sl.buf + sl.len;
-                      SockList_AddChar (&sl, d);
+                      last_ext = &sl[sl.length ()];
+                      sl << uint8 (d);
                     }
                   else
-                    SockList_AddChar (&sl, 255 - 64 * d);
+                    sl << uint8 (255 - 64 * d);
                 }
 
               lastcell.count = d;
@@ -2090,7 +1987,8 @@
                 {
                   uint8 stat_hp = 0;
                   uint8 stat_width = 0;
-                  tag_t player = 0;
+                  uint8 flags = 0;
+                  UUID player = 0;
 
                   // send hp information, if applicable
                   if (object *op = GET_MAP_FACE_OBJ (m, nx, ny, 0))
@@ -2107,6 +2005,9 @@
                             }
                         }
 
+                      if (op->msg && op->msg[0] == '@')
+                        flags |= 1;
+
                       if (op->type == PLAYER && op != pl)
                         player = op->count;
                     }
@@ -2117,16 +2018,16 @@
 
                       mask |= 0x8;
                       *last_ext |= 0x80;
-                      last_ext = sl.buf + sl.len;
-                      SockList_AddChar (&sl, 5);
-                      SockList_AddChar (&sl, stat_hp);
+                      last_ext = &sl[sl.length ()];
+
+                      sl << uint8 (5) << uint8 (stat_hp);
 
                       if (stat_width > 1)
                         {
                           *last_ext |= 0x80;
-                          last_ext = sl.buf + sl.len;
-                          SockList_AddChar (&sl, 6);
-                          SockList_AddChar (&sl, stat_width);
+                          last_ext = &sl[sl.length ()];
+
+                          sl << uint8 (6) << uint8 (stat_width);
                         }
                     }
 
@@ -2136,27 +2037,37 @@
 
                       mask |= 0x8;
                       *last_ext |= 0x80;
-                      last_ext = sl.buf + sl.len;
-                      SockList_AddChar (&sl, 0x47);
-                      SockList_AddChar (&sl, 4);
-                      SockList_AddInt (&sl, player);
+                      last_ext = &sl[sl.length ()];
+
+                      sl << uint8 (0x47) << uint8 (8) << (uint64)player;
+                    }
+
+                  if (lastcell.flags != flags)
+                    {
+                      lastcell.flags = flags;
+
+                      mask |= 0x8;
+                      *last_ext |= 0x80;
+                      last_ext = &sl[sl.length ()];
+
+                      sl << uint8 (8) << uint8 (flags);
                     }
                 }
 
               /* Floor face */
-              if (update_space (&sl, &socket, m, nx, ny, ax, ay, 2))
+              if (update_space (sl, socket, m, nx, ny, ax, ay, 2))
                 mask |= 0x4;
 
               if (socket.EMI_smooth)
-                if (update_smooth (&esl, &socket, m, nx, ny, ax, ay, 2))
+                if (update_smooth (esl, socket, m, nx, ny, ax, ay, 2))
                   emask |= 0x4;
 
               /* Middle face */
-              if (update_space (&sl, &socket, m, nx, ny, ax, ay, 1))
+              if (update_space (sl, socket, m, nx, ny, ax, ay, 1))
                 mask |= 0x2;
 
               if (socket.EMI_smooth)
-                if (update_smooth (&esl, &socket, m, nx, ny, ax, ay, 1))
+                if (update_smooth (esl, socket, m, nx, ny, ax, ay, 1))
                   emask |= 0x2;
 
               if (nx == pl->x && ny == pl->y && pl->invisible & (pl->invisible < 50 ? 4 : 1))
@@ -2165,43 +2076,38 @@
                     {
                       lastcell.faces[0] = pl->face->number;
                       mask |= 0x1;
+
                       if (!(socket.faces_sent[pl->face->number] & NS_FACESENT_FACE))
                         esrv_send_face (&socket, pl->face->number, 0);
-                      SockList_AddShort (&sl, pl->face->number);
+
+                      sl << uint16 (pl->face->number);
                     }
                 }
-              /* Top face */
               else
                 {
-                  if (update_space (&sl, &socket, m, nx, ny, ax, ay, 0))
+                  /* Top face */
+                  if (update_space (sl, socket, m, nx, ny, ax, ay, 0))
                     mask |= 0x1;
+
                   if (socket.EMI_smooth)
-                    if (update_smooth (&esl, &socket, m, nx, ny, ax, ay, 0))
-                      {
-                        emask |= 0x1;
-                      }
+                    if (update_smooth (esl, socket, m, nx, ny, ax, ay, 0))
+                      emask |= 0x1;
                 }
+
               /* Check to see if we are in fact sending anything for this
                * space by checking the mask.  If so, update the mask.
                * if not, reset the len to that from before adding the mask
                * value, so we don't send those bits.
                */
               if (mask & 0xf)
-                {
-                  sl.buf[oldlen + 1] = mask & 0xff;
-                }
+                sl[oldlen + 1] = mask & 0xff;
               else
-                {
-                  sl.len = oldlen;
-                }
+                sl.reset (oldlen);
+
               if (emask & 0xf)
-                {
-                  esl.buf[eoldlen + 1] = emask & 0xff;
-                }
+                esl[eoldlen + 1] = emask & 0xff;
               else
-                {
-                  esl.len = eoldlen;
-                }
+                esl.reset (eoldlen);
             }                   /* else this is a viewable space */
         }                       /* for x loop */
     }                           /* for y loop */
@@ -2209,28 +2115,24 @@
   /* Verify that we in fact do need to send this */
   if (socket.ext_mapinfos)
     {
-      if (!(sl.len > startlen || socket.sent_scroll))
+      if (!(sl.length () > startlen || socket.sent_scroll))
         {
           /* No map data will follow, so don't say the client
            * it doesn't need draw!
            */
           ewhatflag &= (~EMI_NOREDRAW);
-          esl.buf[ewhatstart + 1] = ewhatflag & 0xff;
+          esl[ewhatstart + 1] = ewhatflag & 0xff;
         }
 
-      if (esl.len > estartlen)
-        Send_With_Handling (&socket, &esl);
-
-      free (esl.buf);
+      if (esl.length () > estartlen)
+        socket.send_packet (esl);
     }
 
-  if (sl.len > startlen || socket.sent_scroll)
+  if (sl.length () > startlen || socket.sent_scroll)
     {
-      Send_With_Handling (&socket, &sl);
+      socket.send_packet (sl);
       socket.sent_scroll = 0;
     }
-
-  free (sl.buf);
 }
 
 /**
@@ -2264,9 +2166,9 @@
 
   memset (&newmap, 0, sizeof (struct Map));
 
-  for (j = (pl->y - pl->contr->socket.mapy / 2); j < (pl->y + (pl->contr->socket.mapy + 1) / 2); j++)
+  for (j = (pl->y - pl->contr->socket->mapy / 2); j < (pl->y + (pl->contr->socket->mapy + 1) / 2); j++)
     {
-      for (i = (pl->x - pl->contr->socket.mapx / 2); i < (pl->x + (pl->contr->socket.mapx + 1) / 2); i++)
+      for (i = (pl->x - pl->contr->socket->mapx / 2); i < (pl->x + (pl->contr->socket->mapx + 1) / 2); i++)
         {
           ax = i;
           ay = j;
@@ -2291,72 +2193,8 @@
       pl->contr->do_los = 0;
     }
 
-  if (pl->contr->socket.mapmode == Map1Cmd || pl->contr->socket.mapmode == Map1aCmd)
-    {
-      /* Big maps need a different drawing mechanism to work */
-      draw_client_map1 (pl);
-      return;
-    }
-
-  if (pl->invisible & (pl->invisible < 50 ? 4 : 1))
-    {
-      esrv_map_setbelow (&pl->contr->socket, pl->contr->socket.mapx / 2, pl->contr->socket.mapy / 2, pl->face->number, &newmap);
-    }
-
-  /* j and i are the y and x coordinates of the real map (which is 
-   * basically some number of spaces around the player)
-   * ax and ay are values from within the viewport (ie, 0, 0 is upper
-   * left corner) and are thus disconnected from the map values.
-   * Subtract 1 from the max values so that we properly handle cases where
-   * player has specified an even map.  Otherwise, we try to send them too
-   * much, ie, if mapx is 10, we would try to send from -5 to 5, which is actually
-   * 11 spaces.  Now, we would send from -5 to 4, which is properly.  If mapx is
-   * odd, this still works fine.
-   */
-  ay = 0;
-  for (j = pl->y - pl->contr->socket.mapy / 2; j <= pl->y + (pl->contr->socket.mapy - 1) / 2; j++, ay++)
-    {
-      ax = 0;
-      for (i = pl->x - pl->contr->socket.mapx / 2; i <= pl->x + (pl->contr->socket.mapx - 1) / 2; i++, ax++)
-        {
-
-          d = pl->contr->blocked_los[ax][ay];
-          /* note the out_of_map and d>3 checks are both within the same
-           * negation check.
-           */
-          nx = i;
-          ny = j;
-          m = get_map_from_coord (pm, &nx, &ny);
-          if (m && d < 4)
-            {
-              face = GET_MAP_FACE (m, nx, ny, 0);
-              floor2 = GET_MAP_FACE (m, nx, ny, 1);
-              floor = GET_MAP_FACE (m, nx, ny, 2);
-
-              /* If all is blank, send a blank face. */
-              if ((!face || face == blank_face) && (!floor2 || floor2 == blank_face) && (!floor || floor == blank_face))
-                {
-                  esrv_map_setbelow (&pl->contr->socket, ax, ay, blank_face->number, &newmap);
-                }
-              else
-                {               /* actually have something interesting */
-                  /* send the darkness mask, if any. */
-                  if (d && pl->contr->socket.darkness)
-                    esrv_map_setbelow (&pl->contr->socket, ax, ay, dark_faces[d - 1]->number, &newmap);
-
-                  if (face && face != blank_face)
-                    esrv_map_setbelow (&pl->contr->socket, ax, ay, face->number, &newmap);
-                  if (floor2 && floor2 != blank_face)
-                    esrv_map_setbelow (&pl->contr->socket, ax, ay, floor2->number, &newmap);
-                  if (floor && floor != blank_face)
-                    esrv_map_setbelow (&pl->contr->socket, ax, ay, floor->number, &newmap);
-                }
-            }                   /* Is a valid space */
-        }
-    }
-  esrv_map_doneredraw (&pl->contr->socket, &newmap);
-
-  check_map_change (pl->contr);
+  /* Big maps need a different drawing mechanism to work */
+  draw_client_map1 (pl);
 }
 
 
@@ -2372,7 +2210,7 @@
 void
 send_plugin_custom_message (object *pl, char *buf)
 {
-  cs_write_string (&pl->contr->socket, buf, strlen (buf));
+  pl->contr->socket->send_packet (buf);
 }
 
 /**
@@ -2380,25 +2218,21 @@
  * the params - we always send the same info no matter what.
  */
 void
-send_skill_info (NewSocket * ns, char *params)
+send_skill_info (client_socket *ns, char *params)
 {
-  SockList sl;
-  int i;
+  packet sl;
+  sl << "replyinfo skill_info\n";
 
-  sl.buf = (unsigned char *) malloc (MAXSOCKBUF);
-  strcpy ((char *) sl.buf, "replyinfo skill_info\n");
-  for (i = 1; i < NUM_SKILLS; i++)
-    {
-      sprintf ((char *) sl.buf + strlen ((char *) sl.buf), "%d:%s\n", i + CS_STAT_SKILLINFO, &skill_names[i]);
-    }
-  sl.len = strlen ((char *) sl.buf);
-  if (sl.len >= MAXSOCKBUF)
+  for (int i = 1; i < NUM_SKILLS; i++)
+    sl.printf ("%d:%s\n", i + CS_STAT_SKILLINFO, &skill_names[i]);
+
+  if (sl.length () >= MAXSOCKBUF)
     {
       LOG (llevError, "Buffer overflow in send_skill_info!\n");
       fatal (0);
     }
-  Send_With_Handling (ns, &sl);
-  free (sl.buf);
+
+  ns->send_packet (sl);
 }
 
 /**
@@ -2406,23 +2240,22 @@
  * the params - we always send the same info no matter what.
  */
 void
-send_spell_paths (NewSocket * ns, char *params)
+send_spell_paths (client_socket * ns, char *params)
 {
-  SockList sl;
-  int i;
+  packet sl;
 
-  sl.buf = (unsigned char *) malloc (MAXSOCKBUF);
-  strcpy ((char *) sl.buf, "replyinfo spell_paths\n");
-  for (i = 0; i < NRSPELLPATHS; i++)
-    sprintf ((char *) sl.buf + strlen ((char *) sl.buf), "%d:%s\n", 1 << i, spellpathnames[i]);
-  sl.len = strlen ((char *) sl.buf);
-  if (sl.len >= MAXSOCKBUF)
+  sl << "replyinfo spell_paths\n";
+
+  for (int i = 0; i < NRSPELLPATHS; i++)
+    sl.printf ("%d:%s\n", 1 << i, spellpathnames[i]);
+
+  if (sl.length () >= MAXSOCKBUF)
     {
       LOG (llevError, "Buffer overflow in send_spell_paths!\n");
       fatal (0);
     }
-  Send_With_Handling (ns, &sl);
-  free (sl.buf);
+
+  ns->send_packet (sl);
 }
 
 /**
@@ -2432,48 +2265,47 @@
 void
 esrv_update_spells (player *pl)
 {
-  SockList sl;
-  int flags = 0;
-  object *spell;
-
-  if (!pl->socket.monitor_spells)
+  if (!pl->socket->monitor_spells)
     return;
-  for (spell = pl->ob->inv; spell != NULL; spell = spell->below)
+
+  for (object *spell = pl->ob->inv; spell; spell = spell->below)
     {
       if (spell->type == SPELL)
         {
+          int flags = 0;
+
           /* check if we need to update it */
           if (spell->last_sp != SP_level_spellpoint_cost (pl->ob, spell, SPELL_MANA))
             {
               spell->last_sp = SP_level_spellpoint_cost (pl->ob, spell, SPELL_MANA);
               flags |= UPD_SP_MANA;
             }
+
           if (spell->last_grace != SP_level_spellpoint_cost (pl->ob, spell, SPELL_GRACE))
             {
               spell->last_grace = SP_level_spellpoint_cost (pl->ob, spell, SPELL_GRACE);
               flags |= UPD_SP_GRACE;
             }
+
           if (spell->last_eat != spell->stats.dam + SP_level_dam_adjust (pl->ob, spell))
             {
               spell->last_eat = spell->stats.dam + SP_level_dam_adjust (pl->ob, spell);
               flags |= UPD_SP_DAMAGE;
             }
-          if (flags != 0)
+
+          if (flags)
             {
-              sl.buf = (unsigned char *) malloc (MAXSOCKBUF);
-              strcpy ((char *) sl.buf, "updspell ");
-              sl.len = strlen ((char *) sl.buf);
-              SockList_AddChar (&sl, flags);
-              SockList_AddInt (&sl, spell->count);
-              if (flags & UPD_SP_MANA)
-                SockList_AddShort (&sl, spell->last_sp);
-              if (flags & UPD_SP_GRACE)
-                SockList_AddShort (&sl, spell->last_grace);
-              if (flags & UPD_SP_DAMAGE)
-                SockList_AddShort (&sl, spell->last_eat);
-              flags = 0;
-              Send_With_Handling (&pl->socket, &sl);
-              free (sl.buf);
+              packet sl;
+
+              sl << "updspell "
+                 << uint8 (flags)
+                 << uint32 (spell->count);
+
+              if (flags & UPD_SP_MANA  ) sl << uint16 (spell->last_sp);
+              if (flags & UPD_SP_GRACE ) sl << uint16 (spell->last_grace);
+              if (flags & UPD_SP_DAMAGE) sl << uint16 (spell->last_eat);
+
+              pl->socket->send_packet (sl);
             }
         }
     }
@@ -2482,26 +2314,26 @@
 void
 esrv_remove_spell (player *pl, object *spell)
 {
-  SockList sl;
-
-  if (!pl->socket.monitor_spells)
+  if (!pl->socket->monitor_spells)
     return;
+
   if (!pl || !spell || spell->env != pl->ob)
     {
       LOG (llevError, "Invalid call to esrv_remove_spell");
       return;
     }
-  sl.buf = (unsigned char *) malloc (MAXSOCKBUF);
-  strcpy ((char *) sl.buf, "delspell ");
-  sl.len = strlen ((char *) sl.buf);
-  SockList_AddInt (&sl, spell->count);
-  Send_With_Handling (&pl->socket, &sl);
-  free (sl.buf);
+
+  packet sl;
+
+  sl << "delspell "
+     << uint32 (spell->count);
+
+  pl->socket->send_packet (sl);
 }
 
 /* appends the spell *spell to the Socklist we will send the data to. */
 static void
-append_spell (player *pl, SockList * sl, object *spell)
+append_spell (player *pl, packet &sl, object *spell)
 {
   int len, i, skill = 0;
 
@@ -2510,17 +2342,11 @@
       LOG (llevError, "item number %d is a spell with no name.\n", spell->count);
       return;
     }
-  SockList_AddInt (sl, spell->count);
-  SockList_AddShort (sl, spell->level);
-  SockList_AddShort (sl, spell->casting_time);
+
   /* store costs and damage in the object struct, to compare to later */
-  spell->last_sp = SP_level_spellpoint_cost (pl->ob, spell, SPELL_MANA);
+  spell->last_sp    = SP_level_spellpoint_cost (pl->ob, spell, SPELL_MANA);
   spell->last_grace = SP_level_spellpoint_cost (pl->ob, spell, SPELL_GRACE);
-  spell->last_eat = spell->stats.dam + SP_level_dam_adjust (pl->ob, spell);
-  /* send the current values */
-  SockList_AddShort (sl, spell->last_sp);
-  SockList_AddShort (sl, spell->last_grace);
-  SockList_AddShort (sl, spell->last_eat);
+  spell->last_eat   = spell->stats.dam + SP_level_dam_adjust (pl->ob, spell);
 
   /* figure out which skill it uses, if it uses one */
   if (spell->skill)
@@ -2532,27 +2358,19 @@
             break;
           }
     }
-  SockList_AddChar (sl, skill);
 
-  SockList_AddInt (sl, spell->path_attuned);
-  SockList_AddInt (sl, (spell->face) ? spell->face->number : 0);
-
-  len = strlen (spell->name);
-  SockList_AddChar (sl, (char) len);
-  memcpy (sl->buf + sl->len, spell->name, len);
-  sl->len += len;
-
-  if (!spell->msg)
-    {
-      SockList_AddShort (sl, 0);
-    }
-  else
-    {
-      len = strlen (spell->msg);
-      SockList_AddShort (sl, len);
-      memcpy (sl->buf + sl->len, spell->msg, len);
-      sl->len += len;
-    }
+  /* send the current values */
+  sl << uint32 (spell->count)
+     << uint16 (spell->level)
+     << uint16 (spell->casting_time)
+     << uint16 (spell->last_sp)
+     << uint16 (spell->last_grace)
+     << uint16 (spell->last_eat)
+     << uint8  (skill)
+     << uint32 (spell->path_attuned)
+     << uint32 (spell->face ? spell->face->number : 0)
+     << data8  (spell->name)
+     << data16 (spell->msg);
 }
 
 /**
@@ -2562,18 +2380,19 @@
 void
 esrv_add_spells (player *pl, object *spell)
 {
-  SockList sl;
-
   if (!pl)
     {
       LOG (llevError, "esrv_add_spells, tried to add a spell to a NULL player");
       return;
     }
-  if (!pl->socket.monitor_spells)
+
+  if (!pl->socket->monitor_spells)
     return;
-  sl.buf = (unsigned char *) malloc (MAXSOCKBUF);
-  strcpy ((char *) sl.buf, "addspell ");
-  sl.len = strlen ((char *) sl.buf);
+
+  packet sl;
+
+  sl << "addspell ";
+
   if (!spell)
     {
       for (spell = pl->ob->inv; spell != NULL; spell = spell->below)
@@ -2593,13 +2412,16 @@
            */
           if (spell->type != SPELL)
             continue;
-          if (sl.len >= (MAXSOCKBUF - (26 + strlen (spell->name) + (spell->msg ? strlen (spell->msg) : 0))))
+
+          if (sl.length () >= (MAXSOCKBUF - (26 + strlen (spell->name) + (spell->msg ? strlen (spell->msg) : 0))))
             {
-              Send_With_Handling (&pl->socket, &sl);
-              strcpy ((char *) sl.buf, "addspell ");
-              sl.len = strlen ((char *) sl.buf);
+              pl->socket->send_packet (sl);
+
+              sl.reset ();
+              sl << "addspell ";
             }
-          append_spell (pl, &sl, spell);
+
+          append_spell (pl, sl, spell);
         }
     }
   else if (spell->type != SPELL)
@@ -2608,13 +2430,15 @@
       return;
     }
   else
-    append_spell (pl, &sl, spell);
-  if (sl.len >= MAXSOCKBUF)
+    append_spell (pl, sl, spell);
+
+  if (sl.length () >= MAXSOCKBUF)
     {
       LOG (llevError, "Buffer overflow in esrv_add_spells!\n");
       fatal (0);
     }
+
   /* finally, we can send the packet */
-  Send_With_Handling (&pl->socket, &sl);
-  free (sl.buf);
+  pl->socket->send_packet (sl);
 }
+