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

Comparing deliantra/server/socket/request.C (file contents):
Revision 1.36 by root, Thu Dec 14 04:30:33 2006 UTC vs.
Revision 1.40 by root, Fri Dec 15 04:21:29 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
         }
     }
   socket.current_x = ob->x;
   socket.current_y = ob->y;
+}
+/**
+ * RequestInfo is sort of a meta command. There is some specific
+ * request of information, but we call other functions to provide
+ * that information.
+ */
+void
+RequestInfo (char *buf, int len, client_socket * ns)
+{
+  char *params = NULL, *cp;
+  /* No match */
+  char bigbuf[MAX_BUF];
+  int slen;
+  /* Set up replyinfo before we modify any of the buffers - this is used
+   * if we don't find a match.
+   */
+  strcpy (bigbuf, "replyinfo ");
+  slen = strlen (bigbuf);
+  safe_strcat (bigbuf, buf, &slen, MAX_BUF);
+  /* find the first space, make it null, and update the
+   * params pointer.
+   */
+  for (cp = buf; *cp != '\0'; cp++)
+    if (*cp == ' ')
+      {
+        *cp = '\0';
+        params = cp + 1;
+        break;
+      }
+  if (!strcmp (buf, "image_info"))
+    send_image_info (ns, params);
+  else if (!strcmp (buf, "image_sums"))
+    send_image_sums (ns, params);
+  else if (!strcmp (buf, "skill_info"))
+    send_skill_info (ns, params);
+  else if (!strcmp (buf, "spell_paths"))
+    send_spell_paths (ns, params);
+  else
+    ns->send_packet (bigbuf, len);
 }
 void
 ExtCmd (char *buf, int len, player *pl)
 {
   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
   set_title (pl->ob, buf);
   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;
 }
                * 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;
     }
 }
 /**
     {
       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
               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);
             }
         }
     }
 }
   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)
           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.36 by root, Thu Dec 14 04:30:33 2006 UTC vs. Revision 1.40 by root, Fri Dec 15 04:21:29 2006 UTC

Diff Legend

Comparing deliantra/server/socket/request.C (file contents):
Revision 1.36 by root, Thu Dec 14 04:30:33 2006 UTC vs.
Revision 1.40 by root, Fri Dec 15 04:21:29 2006 UTC