[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.42 by root, Sat Dec 16 03:08:26 2006 UTC

  */
 #include <global.h>
 #include <sproto.h>
-#include <newclient.h>
-#include <newserver.h>
 #include <living.h>
 #include <commands.h>
 /* This block is basically taken from socket.c - I assume if it works there,
  * it should work here.
 #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 (client_socket * ns, int dx, int dy)
+socket_map_scroll (client * ns, int dx, int dy)
 {
   struct Map newmap;
   int x, y, mx, my;
-  {
-    packet sl;
-    sl.printf ("map_scroll %d %d", dx, dy);
+  ns->send_packet_printf ("map_scroll %d %d", dx, dy);
-    ns->send_packet (sl);
-  }
   /* If we are using the Map1aCmd, we may in fact send
    * head information that is outside the viewable map.
    * So set the mx,my to the max value we want to
    * look for.  Removed code to do so - it caused extra
 }
 static void
 clear_map (player *pl)
 {
-  client_socket &socket = *pl->socket;
+  client &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 = *pl->socket;
   object *ob = pl->ob;
   char buf[MAX_BUF];            /* eauugggh */
   if (socket.current_map != ob->map)
     {
         }
     }
   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 * 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)
 {
   pl->socket->send_packet (bigbuf);
 }
 /** This is the Setup cmd - easy first implementation */
 void
-SetUp (char *buf, int len, client_socket * ns)
+SetUp (char *buf, int len, client * 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, client_socket * ns)
+AddMeCmd (char *buf, int len, client * ns)
 {
   Settings oldsettings;
   oldsettings = settings;
   if (ns->status != Ns_Add || add_player (ns))
   settings = oldsettings;
 }
 /** Reply to ExtendedInfos command */
 void
-ToggleExtendedInfos (char *buf, int len, client_socket * ns)
+ToggleExtendedInfos (char *buf, int len, client * 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, client_socket * ns)
+ToggleExtendedText (char *buf, int len, client * 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 (client_socket * ns, uint16 face)
+SendSmooth (client * 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, client_socket * ns)
+AskSmooth (char *buf, int len, client * 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, client_socket * ns)
+VersionCmd (char *buf, int len, client * ns)
 {
   char *cp;
   char version_warning[256];
   if (!buf)
   cp = strchr (cp + 1, ' ');
   if (cp)
     {
       LOG (llevDebug, "CS: connection from client of type <%s>, ip %s\n", cp, ns->host);
-      snprintf (ns->client, sizeof (ns->client), "%s", cp + 1);
+      assign (ns->version, cp + 1);
-      /* This is first implementation - i skip all beta DX clients with it
-       * Add later stuff here for other clients
-       */
-      /* these are old dxclients */
-      /* Version 1024 added support for singular + plural name values -
-       * requiing this minimal value reduces complexity of that code, and it
-       * has been around for a long time.
-       */
       if (ns->sc_version < 1026)
         {
           sprintf (version_warning, "drawinfo %d %s", NDI_RED,
                    "**** VERSION WARNING ****\n**** CLIENT IS TOO OLD!! UPDATE THE CLIENT!! ****");
           ns->send_packet (version_warning);
     }
 }
 /** sound related functions. */
 void
-SetSound (char *buf, int len, client_socket * ns)
+SetSound (char *buf, int len, client * ns)
 {
   ns->sound = atoi (buf);
 }
 /** client wants the map resent */
 /**
  * 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 (client_socket * ns, uint8 flags, char *text)
+send_query (client * ns, uint8 flags, char *text)
 {
   char buf[MAX_BUF];
   sprintf (buf, "query %d %s", flags, text ? text : "");
   ns->send_packet (buf);
   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.
  * 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 (client_socket * ns, short anim_num)
+esrv_send_animation (client * 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 (client_socket * ns, int x, int y, short face_num, struct Map *newmap)
+esrv_map_setbelow (client * 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 (client_socket * ns, int i, int j, struct Map *newmap)
+mapcellchanged (client * 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 (client_socket * ns, unsigned char *cur, int numlayers, struct Map *newmap)
+compactlayer (client * 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, client_socket &ns, int ax, int ay, int layer)
+check_head (packet &sl, client &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, client_socket &ns, maptile *mp, int mx, int my, int sx, int sy, int layer)
+update_space (packet &sl, client &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, client_socket &ns, maptile *mp, int mx, int my, int sx, int sy, int layer)
+update_smooth (packet &sl, client &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 (client_socket * ns)
+getExtendedMapInfoSize (client * ns)
 {
   int result = 0;
   if (ns->ext_mapinfos)
     {
   uint8 eentrysize;
   uint16 ewhatstart, ewhatflag;
   uint8 extendedinfos;
   maptile *m;
-  client_socket &socket = *pl->contr->socket;
+  client &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;
     }
 }
 /**
 /**
  * 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 (client_socket *ns, char *params)
+send_skill_info (client *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 (client_socket * ns, char *params)
+send_spell_paths (client * 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
               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.42 by root, Sat Dec 16 03:08:26 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.42 by root, Sat Dec 16 03:08:26 2006 UTC