[ViewVC] Diff of: cvs/deliantra/server/socket/request.C

Comparing deliantra/server/socket/request.C (file contents):
Revision 1.34 by root, Thu Dec 14 01:59:10 2006 UTC vs.
Revision 1.39 by root, Fri Dec 15 03:53:44 2006 UTC

 #include <sys/time.h>
 #include <sys/socket.h>
 #include <netinet/in.h>
 #include <netdb.h>
-#ifdef HAVE_UNISTD_H
-# include <unistd.h>
+#include <unistd.h>
-#endif
-#ifdef HAVE_SYS_TIME_H
-# include <sys/time.h>
+#include <sys/time.h>
-#endif
 #include "sounds.h"
 /**
  * This table translates the attack numbers as used within the
   -1,                           /* life stealing */
   -1                            /* Disease - not fully done yet */
 };
 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;
   {
 }
 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)
     socket.send_packet ("newmap");
 /** check for map change and send new map data */
 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 */
   if (socket.current_map != ob->map)
     {
       buf += 8;
       // initial map and its origin
       maptile *map = pl->ob->map;
       sint16 dx, dy;
-      int mapx = pl->socket.mapx / 2 - pl->ob->x;
+      int mapx = pl->socket->mapx / 2 - pl->ob->x;
-      int mapy = pl->socket.mapy / 2 - pl->ob->y;
+      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)
         {
           int dir = *buf++;
         snprintf (bigbuf, MAX_BUF, "mapinfo %s nomap", token);
     }
   else
     snprintf (bigbuf, MAX_BUF, "mapinfo %s unsupported", token);
-  pl->socket.send_packet (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];
   /* run through the cmds of setup
  * This is what takes care of it.  We tell the client how things worked out.
  * I am not sure if this file is the best place for this function.  however,
  * 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))
     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.
-       */
-      ns->send_packet ("addme_success");
+    ns->send_packet ("addme_success");
-      socket_info.nconns--;
-      ns->status = Ns_Avail;
-    }
   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];
   int info, nextinfo;
 #define MSG_TYPE_MONUMENT        5
 #define MSG_TYPE_SCRIPTED_DIALOG 6*/
 /** 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];
   char command[50];
   int info, nextinfo, i, flag;
  * a piece of data from us that we know the client wants.  So
  * if we know the client wants it, might as well push it to the
  * client.
  */
 static void
-SendSmooth (NewSocket * ns, uint16 face)
+SendSmooth (client_socket * ns, uint16 face)
 {
   uint16 smoothface;
   /* If we can't find a face, return and set it so we won't try to send this
    * again.
   sl << "smooth "
      << uint16 (face)
      << uint16 (smoothface);
-  Send_With_Handling (ns, &sl);
+  ns->send_packet (sl);
 }
  /**
   * Tells client the picture it has to use
   * 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;
   facenbr = atoi (buf);
   SendSmooth (ns, facenbr);
  * etc.).  It is a lot like PlayerCmd above, but is called with the
  * 'ncom' method which gives more information back to the client so it
  * can throttle.
  */
 void
-NewPlayerCmd (uint8 * buf, int len, player *pl)
+NewPlayerCmd (char *buf, int len, player *pl)
 {
   int time, repeat;
   char command[MAX_BUF];
   int pktlen;
     {
       LOG (llevDebug, "Corrupt ncom command <%s> not long enough - discarding\n", buf);
       return;
     }
-  pktlen = net_uint16 (buf);
+  pktlen = net_uint16 ((uint8 *)buf);
-  repeat = net_uint32 (buf + 2);
+  repeat = net_uint32 ((uint8 *)buf + 2);
   /* -1 is special - no repeat, but don't update */
   if (repeat != -1)
     pl->count = repeat;
   if ((len - 4) >= MAX_BUF)
     len = MAX_BUF - 5;
   strncpy ((char *) command, (char *) buf + 6, len - 4);
-  command[len - 4] = '\0';
+  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;
-    }
   /* This should not happen anymore.    */
   if (pl->ob->speed_left < -1.0)
     LOG (llevError, "Player has negative time - shouldn't do command.\n");
   /* Send confirmation of command execution now */
   packet sl;
   sl << "comc " << uint16 (pktlen) << uint32 (time);
-  Send_With_Handling (&pl->socket, &sl);
+  pl->socket->send_packet (sl);
 }
 /** This is a reply to a previous query. */
 void
  * something older than the server.  If we assume the client will be
  * backwards compatible, having it be a later version should not be a
  * problem.
  */
 void
-VersionCmd (char *buf, int len, NewSocket * ns)
+VersionCmd (char *buf, int len, client_socket * ns)
 {
   char *cp;
   char version_warning[256];
   if (!buf)
 }
 /** sound related functions. */
 void
-SetSound (char *buf, int len, NewSocket * ns)
+SetSound (char *buf, int len, client_socket * ns)
 {
   ns->sound = atoi (buf);
 }
 /** client wants the map resent */
  */
 #if 0
   /* 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
 }
 /**
 /**
  * Asks the client to query the user.  This way, the client knows
  * 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 : "");
   ns->send_packet (buf);
       AddIfShort (pl->last_stats.Dex, pl->ob->stats.Dex, CS_STAT_DEX);
       AddIfShort (pl->last_stats.Con, pl->ob->stats.Con, CS_STAT_CON);
       AddIfShort (pl->last_stats.Cha, pl->ob->stats.Cha, CS_STAT_CHA);
     }
-  if (pl->socket.exp64)
+  if (pl->socket->exp64)
     {
       uint8 s;
       for (s = 0; s < NUM_SKILLS; s++)
         {
               pl->last_skill_exp[s] = pl->last_skill_ob[s]->stats.exp;
             }
         }
     }
-  if (pl->socket.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) }
   AddIfShort (pl->last_level, (char) pl->ob->level, CS_STAT_LEVEL);
   if (pl->run_on)
     flags |= SF_RUNON;
   AddIfShort (pl->last_flags, flags, CS_STAT_FLAGS);
-  if (pl->socket.sc_version < 1025)
+  if (pl->socket->sc_version < 1025)
     { AddIfShort (pl->last_resist[ATNR_PHYSICAL], pl->ob->resist[ATNR_PHYSICAL], CS_STAT_ARMOUR) }
   else
     {
       int i;
           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);
       AddIfInt (pl->last_path_denied, pl->ob->path_denied, CS_STAT_SPELL_DENY);
     }
   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.length () > 6)
-    Send_With_Handling (&pl->socket, &sl);
+    pl->socket->send_packet (sl);
 }
 /**
  * Tells the client that here is a player it should start using.
  */
   sl << uint32 (pl->ob->count)
      << uint32 (weight)
      << uint32 (pl->ob->face->number)
      << data8  (pl->ob->name);
-  Send_With_Handling (&pl->socket, &sl);
+  pl->socket->send_packet (sl);
   SET_FLAG (pl->ob, FLAG_CLIENT_SENT);
 }
 /**
  * Need to send an animation sequence to the client.
  * sent them the face yet (this can become quite costly in terms of
  * how much we are sending - on the other hand, this should only happen
  * 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)
 {
   int i;
   /* Do some checking on the anim_num we got.  Note that the animations
    * are added in contigous order, so if the number is in the valid
       if (!(ns->faces_sent[animations[anim_num].faces[i]] & NS_FACESENT_FACE))
         esrv_send_face (ns, animations[anim_num].faces[i], 0);
       sl << uint16 (animations[anim_num].faces[i]);   /* flags - not used right now */
     }
-  Send_With_Handling (ns, &sl);
+  ns->send_packet (sl);
   ns->anims_sent[anim_num] = 1;
 }
 /**
  * This adds face_num to a map cell at x,y.  If the client doesn't have
  * 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)
     {
       LOG (llevError, "Too many faces in map cell %d %d\n", x, y);
       return;
   struct LayerCell lcells[MAP_CLIENT_X * MAP_CLIENT_Y];
 };
 /** 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;
   if (ns->lastmap.cells[i][j].count != newmap->cells[i][j].count)
     return 1;
  * cnum is the client number, cur is the the buffer we put all of
  * this data into.  we return the end of the data.  layers is
  * 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;
   unsigned char *fcur;
   struct MapLayer layers[MAP_LAYERS];
  * needs to get sent - if so, it adds the data, sending the head
  * if needed, and returning 1.  If this no data needs to get
  * sent, it returns zero.
  */
 static int
-check_head (packet &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;
   if (heads[(ay * MAX_HEAD_POS + ax) * MAX_LAYERS + layer])
     face_num = heads[(ay * MAX_HEAD_POS + ax) * MAX_LAYERS + layer]->face->number;
  * the case, it seems to make more sense to have these layer values
  * actually match.
  */
 static int
-update_space (packet &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;
   int bx, by, i;
  * top layer (this matches what the GET_MAP_FACE and GET_MAP_FACE_OBJ
  * take.
  */
 static inline int
-update_smooth (packet &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; */
   ob = GET_MAP_FACE_OBJ (mp, mx, my, layer);
  * Returns the size of a data for a map square as returned by
  * mapextended. There are CLIENTMAPX*CLIENTMAPY*LAYERS entries
  * available.
  */
 int
-getExtendedMapInfoSize (NewSocket * ns)
+getExtendedMapInfoSize (client_socket * ns)
 {
   int result = 0;
   if (ns->ext_mapinfos)
     {
   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);
   packet sl;
   packet esl;
                * with no faces tells the client to blank out the
                * space.
                */
               got_one = 0;
               for (i = oldlen + 2; i < sl.length (); i++)
-                if (sl.buf[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.reset (oldlen + 2);
                   else
                   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.reset (oldlen);
             }
           else
             {
                   mask |= 0x8;
                   if (socket.extmap)
                     {
                       *last_ext |= 0x80;
-                      last_ext = sl.buf + sl.length ();
+                      last_ext = &sl[sl.length ()];
                       sl << uint8 (d);
                     }
                   else
                     sl << uint8 (255 - 64 * d);
                 }
                     {
                       lastcell.stat_hp = stat_hp;
                       mask |= 0x8;
                       *last_ext |= 0x80;
-                      last_ext = sl.buf + sl.length ();
+                      last_ext = &sl[sl.length ()];
                       sl << uint8 (5) << uint8 (stat_hp);
                       if (stat_width > 1)
                         {
                           *last_ext |= 0x80;
-                          last_ext = sl.buf + sl.length ();
+                          last_ext = &sl[sl.length ()];
                           sl << uint8 (6) << uint8 (stat_width);
                         }
                     }
                     {
                       lastcell.player = player;
                       mask |= 0x8;
                       *last_ext |= 0x80;
-                      last_ext = sl.buf + sl.length ();
+                      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.buf + sl.length ();
+                      last_ext = &sl[sl.length ()];
                       sl << uint8 (8) << uint8 (flags);
                     }
                 }
                * 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.reset (oldlen);
               if (emask & 0xf)
-                esl.buf[eoldlen + 1] = emask & 0xff;
+                esl[eoldlen + 1] = emask & 0xff;
               else
                 esl.reset (eoldlen);
             }                   /* else this is a viewable space */
         }                       /* for x loop */
     }                           /* for y loop */
         {
           /* 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.length () > estartlen)
-        Send_With_Handling (&socket, &esl);
+        socket.send_packet (esl);
     }
   if (sl.length () > startlen || socket.sent_scroll)
     {
-      Send_With_Handling (&socket, &sl);
+      socket.send_packet (sl);
       socket.sent_scroll = 0;
     }
 }
 /**
   if (pm == NULL || pm->in_memory != MAP_IN_MEMORY)
     return;
   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;
           m = pm;
           mflags = get_map_flags (m, &m, ax, ay, &ax, &ay);
 /*****************************************************************************/
 void
 send_plugin_custom_message (object *pl, char *buf)
 {
-  pl->contr->socket.send_packet (buf);
+  pl->contr->socket->send_packet (buf);
 }
 /**
  * This sends the skill number to name mapping.  We ignore
  * 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)
 {
   packet sl;
   sl << "replyinfo skill_info\n";
   for (int i = 1; i < NUM_SKILLS; i++)
     {
       LOG (llevError, "Buffer overflow in send_skill_info!\n");
       fatal (0);
     }
-  Send_With_Handling (ns, &sl);
+  ns->send_packet (sl);
 }
 /**
  * This sends the spell path to name mapping.  We ignore
  * 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)
 {
   packet sl;
   sl << "replyinfo spell_paths\n";
     {
       LOG (llevError, "Buffer overflow in send_spell_paths!\n");
       fatal (0);
     }
-  Send_With_Handling (ns, &sl);
+  ns->send_packet (sl);
 }
 /**
  * This looks for any spells the player may have that have changed their stats.
  * it then sends an updspell packet for each spell that has changed in this way
  */
 void
 esrv_update_spells (player *pl)
 {
-  if (!pl->socket.monitor_spells)
+  if (!pl->socket->monitor_spells)
     return;
   for (object *spell = pl->ob->inv; spell; spell = spell->below)
     {
       if (spell->type == SPELL)
               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);
-              Send_With_Handling (&pl->socket, &sl);
+              pl->socket->send_packet (sl);
             }
         }
     }
 }
 void
 esrv_remove_spell (player *pl, object *spell)
 {
-  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");
   packet sl;
   sl << "delspell "
      << uint32 (spell->count);
-  Send_With_Handling (&pl->socket, &sl);
+  pl->socket->send_packet (sl);
 }
 /* appends the spell *spell to the Socklist we will send the data to. */
 static void
 append_spell (player *pl, packet &sl, object *spell)
     {
       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;
   packet sl;
   sl << "addspell ";
           if (spell->type != SPELL)
             continue;
           if (sl.length () >= (MAXSOCKBUF - (26 + strlen (spell->name) + (spell->msg ? strlen (spell->msg) : 0))))
             {
-              Send_With_Handling (&pl->socket, &sl);
+              pl->socket->send_packet (sl);
               sl.reset ();
               sl << "addspell ";
             }
       LOG (llevError, "Buffer overflow in esrv_add_spells!\n");
       fatal (0);
     }
   /* finally, we can send the packet */
-  Send_With_Handling (&pl->socket, &sl);
+  pl->socket->send_packet (sl);
 }

Diff Legend

-–
+Removed lines
-+
+Added lines
-<
+Changed lines
->
+Changed lines

Comparing deliantra/server/socket/request.C (file contents): Revision 1.34 by root, Thu Dec 14 01:59:10 2006 UTC vs. Revision 1.39 by root, Fri Dec 15 03:53:44 2006 UTC

Diff Legend

Comparing deliantra/server/socket/request.C (file contents):
Revision 1.34 by root, Thu Dec 14 01:59:10 2006 UTC vs.
Revision 1.39 by root, Fri Dec 15 03:53:44 2006 UTC