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

Comparing deliantra/server/socket/request.C (file contents):
Revision 1.35 by root, Thu Dec 14 02:37:37 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
 }
 static void
 clear_map (player *pl)
 {
-  client_socket & 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)
 {
-  client_socket & 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, client_socket * ns)
   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 */
   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.
  * 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
  */
 #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
 }
 /**
       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.
       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;
 }
   uint8 eentrysize;
   uint16 ewhatstart, ewhatflag;
   uint8 extendedinfos;
   maptile *m;
-  client_socket &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.
     {
       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.
     {
       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.35 by root, Thu Dec 14 02:37:37 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.35 by root, Thu Dec 14 02:37:37 2006 UTC vs.
Revision 1.39 by root, Fri Dec 15 03:53:44 2006 UTC