Crossfire Client, Trunk  R20996
commands.c
Go to the documentation of this file.
1 /*
2  * Crossfire -- cooperative multi-player graphical RPG and adventure game
3  *
4  * Copyright (c) 1999-2013 Mark Wedel and the Crossfire Development Team
5  * Copyright (c) 1992 Frank Tore Johansen
6  *
7  * Crossfire is free software and comes with ABSOLUTELY NO WARRANTY. You are
8  * welcome to redistribute it under certain conditions. For details, please
9  * see COPYING and LICENSE.
10  *
11  * The authors can be reached via e-mail at <crossfire@metalforge.org>.
12  */
13 
55 int mapupdatesent = 0;
56 
57 #include "client.h"
58 
59 #include <assert.h>
60 #include <ctype.h>
61 #include <errno.h>
62 
63 #include "external.h"
64 #include "mapdata.h"
65 
66 /* In general, the data from the server should not do bad
67  * things like this, but checking for it makes it easier
68  * to find bugs. Often this is called within a loop
69  * that of iterating over the length of the buffer, hence
70  * the break. Note that this may not prevent crashes,
71  * but at least we generate a message.
72  * Note that curpos & buflen may be string pointers or
73  * may be integers - as long as both are the same
74  * (both integers or both char *) it will work.
75  */
76 #define ASSERT_LEN(function, curpos, buflen) \
77  if (curpos > buflen) { \
78  LOG(LOG_WARNING, function, "Data goes beyond length of buffer (%d>%d)", curpos, buflen); \
79  break; \
80 }
81 
82 char *news=NULL, *motd=NULL, *rules=NULL;
83 
85 static int spellmon_level = 0;
86 
87 int num_races = 0; /* Number of different races server has */
88 int used_races = 0; /* How many races we have filled in */
89 
90 int num_classes = 0; /* Same as race data above, but for classes */
91 int used_classes = 0;
92 
93 int stat_points; /* Number of stat points for new characters */
94 int stat_min; /* Minimum stat for new characters */
95 int stat_maximum; /* Maximum stat for new characters */
96 int starting_map_number = 0; /* Number of starting maps */
97 
100 
101 /* Best I can tell, none of this stat information is stored anyplace
102  * else in the server - MSW 2010-07-28
103  */
104 
105 #define NUM_STATS 7
106 
107 static const char *const short_stat_name[NUM_STATS] = {
108  "Str", "Dex", "Con",
109  "Wis", "Cha", "Int",
110  "Pow"
111 };
112 
113 /* Note that the label_cs and label_rs will be in this same
114  * order, eg, label_cs[0] will be strength, label_cs[1] will
115  * be con. However, this order can be changed, so it should
116  * not be assumed that label_cs[1] will always be con.
117  */
119  {"str", CS_STAT_STR, 0},
120  {"con", CS_STAT_CON, 1},
121  {"dex", CS_STAT_DEX, 2},
122  {"int", CS_STAT_INT, 3},
123  {"wis", CS_STAT_WIS, 4},
124  {"pow", CS_STAT_POW, 5},
125  {"cha", CS_STAT_CHA, 6}
126 };
127 
135 {
136  int i;
137 
138  if (!starting_map_info) {
139  return;
140  }
141 
142  /* Because we are going free the array storage itself, there is no reason
143  * to clear the data[i].. values.
144  */
145  for (i=0; i<starting_map_number; i++) {
146  if (starting_map_info[i].arch_name) {
147  free(starting_map_info[i].arch_name);
148  }
149  if (starting_map_info[i].public_name) {
150  free(starting_map_info[i].public_name);
151  }
152  if (starting_map_info[i].description) {
153  free(starting_map_info[i].description);
154  }
155  }
156 
157  free(starting_map_info);
158  starting_map_info=NULL;
159  starting_map_number = 0;
160 }
161 
172 static void get_starting_map_info(unsigned char *data, int len) {
173  int pos, type, length, map_entry=-1;
174  char *cp;
175 
176  pos = 0;
177  while (pos < len) {
178  type = data[pos];
179  pos++;
180 
181  /* Right now, all the data is length prefixed strings, so
182  * the only real difference is where we store the data
183  */
184 
185  length = GetShort_String(data + pos);
186  pos += 2;
187 
188  if ((length+pos) > len) {
189  LOG(LOG_WARNING, "common::get_starting_map_info",
190  "Length of data is greater than buffer (%d>%d)", length + pos, len);
191  return;
192  }
193 
194  cp = g_malloc(length+1);
195  strncpy(cp, (char *)data + pos, length);
196  cp[length] = 0;
197 
198  pos += length;
199 
200  /* If it is the arch name, it is a new entry, so we allocate
201  * space and clear it. This isn't most efficient, but at
202  * the same time, I don't see there being many maps.
203  * Note: If g_realloc is given a null pointer (which starting_map_info
204  * will be after free or first load), g_realloc just acts as g_malloc.
205  */
206  if (type == INFO_MAP_ARCH_NAME) {
207  map_entry++;
208  starting_map_info = g_realloc(starting_map_info,
209  (map_entry + 1) * sizeof(Starting_Map_Info));
210 
211  if (starting_map_info == NULL) {
212  LOG(LOG_ERROR, "get_starting_map_info",
213  "Could not allocate memory: %s", strerror(errno));
214  exit(EXIT_FAILURE);
215  }
216 
217  memset(&starting_map_info[map_entry], 0, sizeof(Starting_Map_Info));
218  starting_map_info[map_entry].arch_name = cp;
219  } else if (type == INFO_MAP_NAME) {
220  starting_map_info[map_entry].public_name = cp;
221  } else if (type == INFO_MAP_DESCRIPTION) {
222  starting_map_info[map_entry].description = cp;
223  } else {
224  /* Could be this is old client - but we can skip over
225  * this bad data so long as the length byte is valid.
226  */
227  LOG(LOG_WARNING, "common::get_starting_map_info",
228  "Unknown type: %d\n", type);
229  }
230  }
231  starting_map_number = map_entry;
233 }
234 
247 static void get_new_char_info(unsigned char *data, int len) {
248  int olen=0, llen;
249 
250  /* We reset these values - if the user is switching between
251  * servers before restarting the client, these may have
252  * different values.
253  */
254  stat_points = 0;
255  stat_min = 0;
256  stat_maximum = 0;
257 
258  while (olen < len) {
259  char datatype, *cp;
260 
261  /* Where this line ends in the total buffer */
262  llen = olen + GetChar_String(data + olen);
263 
264  /* By protocol convention, this should already be NULL,
265  * but we ensure it is. If the server has not included the
266  * null byte, we are overwriting some real data here, but
267  * the client will probably get an error at that point -
268  * if the server is not following the protocol, we really
269  * can't trust any of the data we get from it.
270  */
271  data[llen] = 0;
272 
273  if (llen > len) {
274  LOG(LOG_WARNING, "common::get_new_char_info",
275  "Length of line is greater than buffer (%d>%d)", llen, len);
276  return;
277  }
278  olen++;
279  datatype = GetChar_String(data+olen); /* Type value */
280  olen++;
281  /* First skip all the spaces */
282  while (olen <= len) {
283  if (!isspace(data[olen])) {
284  break;
285  }
286  olen++;
287  }
288  if (olen > len) {
289  LOG(LOG_WARNING, "common::get_new_char_info",
290  "Overran length of buffer (%d>%d)", olen, len);
291  return;
292  }
293 
294  cp = (char *)data + olen;
295  /* Go until we find another space */
296  while (olen <= len) {
297  if (isspace(data[olen])) {
298  break;
299  }
300  olen++;
301  }
302  data[olen] = 0; /* Null terminate the string */
303  olen++;
304  if (olen > len) {
305  LOG(LOG_WARNING, "common::get_new_char_info",
306  "Overran length of buffer (%d>%d)", olen, len);
307  return;
308  }
309  /* At this point, cp points to the string portion (variable name)
310  * of the line, with data+olen is the start of the next string
311  * (variable value).
312  */
313  if (!g_ascii_strcasecmp(cp,"points")) {
314  stat_points = atoi((char *)data + olen);
315  olen = llen + 1;
316  continue;
317  } else if (!g_ascii_strcasecmp(cp,"statrange")) {
318  if (sscanf((char *)data + olen, "%d %d", &stat_min, &stat_maximum) != 2) {
319  LOG(LOG_WARNING, "common::get_new_char_info",
320  "Unable to process statrange line (%s)", data + olen);
321  }
322  /* Either way, we go onto the next line */
323  olen = llen + 1;
324  continue;
325  } else if (!g_ascii_strcasecmp(cp,"statname")) {
326  /* The checking we do here is somewhat basic:
327  * 1) That we understand all the stat names that the server sends us
328  * 2) That we get the correct number of stats.
329  * Note that if the server sends us the same stat name twice, eg
330  * Str Str Dex Con ..., that will screw up this logic, but to a
331  * great extent, we have to trust that server is sending us correct
332  * information - sending the same stat twice does not follow that.
333  */
334  int i, matches=0;
335 
336  while (olen < llen) {
337  for (i=0; i < NUM_STATS; i++) {
338  if (!g_ascii_strncasecmp((char *)data + olen,
339  short_stat_name[i], strlen(short_stat_name[i]))) {
340  matches++;
341  olen += strlen(short_stat_name[i]) + 1;
342  break;
343  }
344  }
345  if (i == NUM_STATS) {
346  LOG(LOG_WARNING, "common::get_new_char_info",
347  "Unable to find matching stat name (%s)", data + olen);
348  break;
349  }
350  }
351  if (matches != NUM_STATS) {
352  LOG(LOG_WARNING, "common::get_new_char_info",
353  "Did not get correct number of stats (%d!=%d)", matches, NUM_STATS);
354  }
355  olen = llen + 1;
356  continue;
357  } else if (!g_ascii_strcasecmp(cp,"race") || !g_ascii_strcasecmp(cp,"class")) {
358  if (g_ascii_strcasecmp((char *)data + olen, "requestinfo")) {
359  LOG(LOG_WARNING, "common::get_new_char_info",
360  "Got unexpected value for %s: %s", cp, data+olen);
361  }
362  olen = llen + 1;
363  continue;
364  } else if (!g_ascii_strcasecmp(cp,"startingmap")) {
365  if (g_ascii_strcasecmp((char *)data + olen, "requestinfo")) {
366  LOG(LOG_WARNING, "common::get_new_char_info",
367  "Got unexpected value for %s: %s", cp, data+olen);
368  } else {
369  cs_print_string(csocket.fd, "requestinfo startingmap");
371  }
372  olen = llen + 1;
373  continue;
374  } else {
375  if (datatype == 'V' || datatype == 'R') {
376  LOG(LOG_WARNING, "common::get_new_char_info",
377  "Got unsupported string from server, type %c, value %s", datatype, cp);
378  /* pop up error here */
379  } else {
380  /* pop up warning here */
381  }
382  olen = llen + 1;
383  }
384  }
385  if (stat_min == 0 || stat_maximum == 0 || stat_points == 0) {
386  /* this needs to be handled better, but I'm not sure how -
387  * we could fall back to legacy character creation mode,
388  * but that will go away at some point - in a sense, if the
389  * server is not sending us values, that is a broken/non comformant
390  * server - best we could perhaps do is throw up a window saying
391  * this client is not compatible with the server.
392  */
393  LOG(LOG_ERROR, "common::get_new_char_info",
394  "Processed all newcharinfo yet have 0 value: stat_min=%d, stat_maximum=%d, stat_points=%d",
396  } else {
398  }
399 }
400 
401 
405 static int rc_compar(const Race_Class_Info *a, const Race_Class_Info *b)
406 {
407  return g_ascii_strcasecmp(a->public_name, b->public_name);
408 }
409 
420 void free_all_race_class_info(Race_Class_Info *data, int num_entries)
421 {
422  int i;
423 
424  /* Because we are going free the array storage itself, there is no reason
425  * to clear the data[i].. values.
426  */
427  for (i=0; i<num_entries; i++) {
428  int j;
429 
430  if (data[i].arch_name) {
431  free(data[i].arch_name);
432  }
433  if (data[i].public_name) {
434  free(data[i].public_name);
435  }
436  if (data[i].description) {
437  free(data[i].description);
438  }
439 
440  for (j=0; j<data[i].num_rc_choice; j++) {
441  int k;
442 
443  for (k=0; k<data[i].rc_choice[j].num_values; k++) {
444  free(data[i].rc_choice[j].value_arch[k]);
445  free(data[i].rc_choice[j].value_desc[k]);
446  }
447  free(data[i].rc_choice[j].value_arch);
448  free(data[i].rc_choice[j].value_desc);
449  free(data[i].rc_choice[j].choice_name);
450  free(data[i].rc_choice[j].choice_desc);
451  }
452  }
453 
454  free(data);
455  data=NULL;
456 }
457 
469 static void process_race_class_info(unsigned char *data, int len, Race_Class_Info *rci) {
470  char *cp = (char *)data, *nl;
471 
472  /* First thing is to process the remaining bit of the requestinfo line,
473  * which is the archetype name for this race/class
474  */
475  nl = strchr(cp, '\n');
476  if (nl) {
477  *nl=0;
478  rci->arch_name = g_strdup(cp);
479  cp = nl+1;
480  } else {
481  LOG(LOG_WARNING, "common::process_race_class_info", "Did not find archetype name");
482  return;
483  }
484 
485  /* Now we process the rest of the data - we look for a word the describes
486  * the data to follow. cp is a pointer to the data we are processing. nl
487  * is used to store temporary values.
488  */
489  do {
490  nl = strchr(cp, ' ');
491  /* If we did not find a space, may just mean we have reached the end
492  * of the data - could be a stray character, etc
493  */
494  if (!nl) {
495  break;
496  }
497 
498  if (nl) {
499  *nl = 0;
500  nl++;
501  }
502  if (!strcmp(cp, "name")) {
503  /* We get a name. The string is not NULL terminated, but the
504  * length is transmitted. So get the length, allocate a string
505  * large enough for that + NULL terminator, and copy string in,
506  * making sure to put terminator in place. also make sure we
507  * update cp beyond this block of data.
508  */
509  int namelen;
510 
511  namelen = GetChar_String((unsigned char *)nl);
512  ASSERT_LEN("common::process_race_class_info",
513  (unsigned char *)nl + namelen, data + len);
514  nl++;
515  rci->public_name = g_malloc(namelen+1);
516  strncpy(rci->public_name, nl, namelen);
517  rci->public_name[namelen] = 0;
518  cp = nl + namelen;
519  } else if (!strcmp(cp, "stats")) {
520  cp = nl;
521  /* This loop goes through the stat values - *cp points to the stat
522  * value - if 0, no more stats, hence the check here.
523  */
524  while (cp < (char *)data + len && *cp != 0) {
525  int i;
526 
527  for (i=0; i < NUM_NEW_CHAR_STATS; i++)
528  if (stat_mapping[i].cs_value == *cp) {
529  break;
530  }
531 
532  if (i == NUM_NEW_CHAR_STATS) {
533  /* Just return with what we have */
534  LOG(LOG_WARNING, "common::process_race_class_info",
535  "Unknown stat value: %d", cp);
536  return;
537  }
538  rci->stat_adj[stat_mapping[i].rc_offset] =
539  GetShort_String((unsigned char *)cp + 1);
540  cp += 3;
541  }
542  cp++; /* Skip over 0 terminator */
543  } else if (!strcmp(cp, "msg")) {
544  /* This is really exactly same as name processing above, except
545  * length is 2 bytes in this case.
546  */
547  int msglen;
548 
549  msglen = GetShort_String((unsigned char *)nl);
550  ASSERT_LEN("common::process_race_class_info",
551  (unsigned char *)nl + msglen, data + len);
552  nl+=2;
553  rci->description = g_malloc(msglen+1);
554  strncpy(rci->description, nl, msglen);
555  rci->description[msglen] = 0;
556  cp = nl + msglen;
557  } else if (!strcmp(cp, "choice")) {
558  int oc = rci->num_rc_choice, clen;
559 
560  rci->num_rc_choice++;
561  /* rc_choice may be null, but g_realloc still works there */
562  rci->rc_choice = g_realloc(rci->rc_choice, sizeof(struct RC_Choice) * rci->num_rc_choice);
563  memset(&rci->rc_choice[oc], 0, sizeof(struct RC_Choice));
564 
565  cp = nl;
566 
567  /* First is the coice string we return */
568  clen = GetChar_String((unsigned char *)cp);
569  cp++;
570  ASSERT_LEN("common::process_race_class_info",
571  (unsigned char *)cp + clen, data + len);
572  rci->rc_choice[oc].choice_name = g_malloc(clen+1);
573  strncpy(rci->rc_choice[oc].choice_name, cp, clen);
574  rci->rc_choice[oc].choice_name[clen] = 0;
575  cp += clen;
576 
577  /* Next is the description */
578  clen = GetChar_String((unsigned char *)cp);
579  cp++;
580  ASSERT_LEN("common::process_race_class_info",
581  (unsigned char *)cp + clen, data + len);
582  rci->rc_choice[oc].choice_desc = g_malloc(clen+1);
583  strncpy(rci->rc_choice[oc].choice_desc, cp, clen);
584  rci->rc_choice[oc].choice_desc[clen] = 0;
585  cp += clen;
586 
587  /* Now is a series of archetype/description pairs */
588  while (1) {
589  int vn;
590 
591  clen = GetChar_String((unsigned char *)cp);
592  cp++;
593  if (!clen) {
594  break; /* 0 length is end of data */
595  }
596  vn = rci->rc_choice[oc].num_values;
597  rci->rc_choice[oc].num_values++;
598  rci->rc_choice[oc].value_arch = g_realloc(rci->rc_choice[oc].value_arch,
599  sizeof(char*) * rci->rc_choice[oc].num_values);
600  rci->rc_choice[oc].value_desc = g_realloc(rci->rc_choice[oc].value_desc,
601  sizeof(char*) * rci->rc_choice[oc].num_values);
602 
603  ASSERT_LEN("common::process_race_class_info",
604  (unsigned char *)cp + clen, data + len);
605  rci->rc_choice[oc].value_arch[vn] = g_malloc(clen+1);
606  strncpy(rci->rc_choice[oc].value_arch[vn], cp, clen);
607  rci->rc_choice[oc].value_arch[vn][clen] = 0;
608  cp += clen;
609 
610  clen = GetChar_String((unsigned char *)cp);
611  cp++;
612  ASSERT_LEN("common::process_race_class_info",
613  (unsigned char *)cp + clen, data + len);
614  rci->rc_choice[oc].value_desc[vn] = g_malloc(clen+1);
615  strncpy(rci->rc_choice[oc].value_desc[vn], cp, clen);
616  rci->rc_choice[oc].value_desc[vn][clen] = 0;
617  cp += clen;
618  }
619  } else {
620  /* Got some keyword we did not understand. Because we do not know
621  * about it, we do not know how to skip it over - the data could
622  * very well contain spaces or other markers we look for.
623  */
624  LOG(LOG_WARNING, "common::process_race_class_info", "Got unknown keyword: %s", cp);
625  break;
626  }
627  } while ((unsigned char *)cp < data + len);
628 
629  /* The display code expects all of these to have a description -
630  * rather than add checks there for NULL values, simpler to
631  * just set things to an empty value.
632  */
633  if (!rci->description) {
634  rci->description = g_strdup("");
635  }
636 
637 }
638 
648 static void get_race_info(unsigned char *data, int len) {
649  /* This should not happen - the client is only requesting race info for
650  * races it has received - and it knows how many of those it has.
651  */
652  if (used_races >= num_races) {
653  LOG(LOG_ERROR, "common::get_race_info",
654  "used races exceed num races, %d>=%d", used_races, num_races);
655  return;
656  }
657 
658  process_race_class_info(data, len, &races[used_races]);
659  used_races++;
660 
661  if (used_races == num_races) {
662  qsort(races, used_races, sizeof(Race_Class_Info),
663  (int (*)(const void *, const void *))rc_compar);
664 
666  }
667 }
668 
679 static void get_class_info(unsigned char *data, int len) {
680  /* This should not happen - the client is only requesting race info for
681  * classes it has received - and it knows how many of those it has.
682  */
683  if (used_classes >= num_classes) {
684  LOG(LOG_ERROR, "common::get_race_info",
685  "used classes exceed num classes, %d>=%d", used_classes, num_classes);
686  return;
687  }
688 
690  used_classes++;
691 
692  if (used_classes == num_classes) {
693  qsort(classes, used_classes, sizeof(Race_Class_Info),
694  (int (*)(const void *, const void *))rc_compar);
695 
697  }
698 }
699 
705 static void get_exp_info(const unsigned char *data, int len)
706 {
707  int pos, level;
708 
709  if (len < 2) {
710  LOG(LOG_ERROR, "common::get_exp_info", "no max level info from server provided");
711  return;
712  }
713 
715  pos = 2;
716  exp_table = calloc(exp_table_max, sizeof(guint64));
717  for (level = 1; level <= exp_table_max && pos < len; level++) {
718  exp_table[level] = GetInt64_String(data+pos);
719  pos += 8;
720  }
721  if (level != exp_table_max) {
722  LOG(LOG_ERROR, "common::get_exp_info",
723  "Incomplete table sent - got %d entries, wanted %d", level, exp_table_max);
724  }
725 }
726 
732 static void get_skill_info(char *data, int len)
733 {
734  char *cp, *nl, *sn;
735  int val;
736 
737  cp = data;
738  do {
739  nl = strchr(cp, '\n');
740  if (nl) {
741  *nl = 0;
742  nl++;
743  }
744  sn = strchr(cp, ':');
745  if (!sn) {
746  LOG(LOG_WARNING, "common::get_skill_info", "corrupt line: /%s/", cp);
747  return;
748  }
749 
750  *sn = 0;
751  sn++;
752  val = atoi(cp);
753  val -= CS_STAT_SKILLINFO;
754 
755  /* skill_names[MAX_SKILL] is the declaration, so check against that */
756  if (val < 0 || val >= MAX_SKILL) {
757  LOG(LOG_WARNING, "common::get_skill_info", "invalid skill number %d", val);
758  return;
759  }
760 
761  free(skill_names[val]);
762  skill_names[val] = g_strdup(sn);
763  cp = nl;
764  } while (cp < data+len);
765 }
766 
774 void ReplyInfoCmd(unsigned char *buf, int len) {
775  unsigned char *cp;
776  int i;
777 
778  /* Covers a bug in the server in that it could send a replyinfo with no
779  * parameters
780  */
781  if (!buf) {
782  return;
783  }
784 
785  for (i = 0; i < len; i++) {
786  /* Either a space or newline represents a break */
787  if (*(buf+i) == ' ' || *(buf+i) == '\n') {
788  break;
789  }
790  }
791  if (i >= len) {
792  /* Don't print buf, as it may contain binary data */
793  /* Downgrade this to DEBUG - if the client issued an unsupported
794  * requestinfo info to the server, we'll end up here - this could be
795  * normal behaviour
796  */
797  LOG(LOG_DEBUG, "common::ReplyInfoCmd", "Never found a space in the replyinfo");
798  return;
799  }
800 
801  /* Null out the space and put cp beyond it */
802  cp = buf+i;
803  *cp++ = '\0';
804  if (!strcmp((char*)buf, "image_info")) {
805  get_image_info(cp, len-i-1); /* Located in common/image.c */
806  } else if (!strcmp((char*)buf, "image_sums")) {
807  get_image_sums((char*)cp, len-i-1); /* Located in common/image.c */
808  } else if (!strcmp((char*)buf, "skill_info")) {
809  get_skill_info((char*)cp, len-i-1); /* Located in common/commands.c */
810  } else if (!strcmp((char*)buf, "exp_table")) {
811  get_exp_info(cp, len-i-1); /* Located in common/commands.c */
812  } else if (!strcmp((char*)buf, "motd")) {
813  if (motd) {
814  free((char*)motd);
815  }
816  motd = g_strdup((char *)cp);
818  } else if (!strcmp((char*)buf, "news")) {
819  if (news) {
820  free((char*)news);
821  }
822  news = g_strdup((char *)cp);
824  } else if (!strcmp((char*)buf, "rules")) {
825  if (rules) {
826  free((char*)rules);
827  }
828  rules = g_strdup((char *)cp);
830  } else if (!strcmp((char*)buf, "race_list")) {
831  unsigned char *cp1;
832  for (cp1=cp; *cp !=0; cp++) {
833  if (*cp == '|') {
834  *cp++ = '\0';
835  /* The first separator has no data, so only send request to
836  * server if this is not null.
837  */
838  if (*cp1!='\0') {
839  cs_print_string(csocket.fd, "requestinfo race_info %s", cp1);
840  num_races++;
841  }
842  cp1 = cp;
843  }
844  }
845  if (*cp1!='\0') {
846  cs_print_string(csocket.fd, "requestinfo race_info %s", cp1);
847  num_races++;
848  }
849  if (races) {
851  num_races=0;
852  used_races=0;
853  }
854  races = calloc(num_races, sizeof(Race_Class_Info));
855 
856  } else if (!strcmp((char*)buf, "class_list")) {
857  unsigned char *cp1;
858  for (cp1=cp; *cp !=0; cp++) {
859  if (*cp == '|') {
860  *cp++ = '\0';
861  /* The first separator has no data, so only send request to
862  * server if this is not null.
863  */
864  if (*cp1!='\0') {
865  cs_print_string(csocket.fd, "requestinfo class_info %s", cp1);
866  num_classes++;
867  }
868  cp1 = cp;
869  }
870  }
871  /* last race isn't followed by a | */
872  if (*cp1 != '\0') {
873  cs_print_string(csocket.fd, "requestinfo class_info %s", cp1);
874  num_classes++;
875  }
876  if (classes) {
878  num_classes=0;
879  used_classes=0;
880  }
881  classes = calloc(num_classes, sizeof(Race_Class_Info));
882  } else if (!strcmp((char*)buf, "race_info")) {
883  get_race_info(cp, len -i -1);
884  } else if (!strcmp((char*)buf, "class_info")) {
885  get_class_info(cp, len -i -1);
886  } else if (!strcmp((char*)buf, "newcharinfo")) {
887  get_new_char_info(cp, len -i -1);
888  } else if (!strcmp((char*)buf, "startingmap")) {
889  get_starting_map_info(cp, len -i -1);
890  }
891 }
892 
901 void SetupCmd(char *buf, int len)
902 {
903  int s;
904  char *cmd, *param;
905 
906  /* Process the setup commands.
907  * Syntax is setup <cmdname1> <parameter> <cmdname2> <parameter> ...
908  *
909  * The server sends the status of the cmd back, or a FALSE if the cmd is
910  * unknown. The client then must sort this out.
911  */
912 
913  LOG(LOG_DEBUG, "common::SetupCmd", "%s", buf);
914  for (s = 0; ; ) {
915  if (s >= len) { /* Ugly, but for secure...*/
916  break;
917  }
918 
919  cmd = &buf[s];
920 
921  /* Find the next space, and put a null there */
922  for (; buf[s] && buf[s] != ' '; s++)
923  ;
924  buf[s++] = 0;
925  while (buf[s] == ' ') {
926  s++;
927  }
928  if (s >= len) {
929  break;
930  }
931 
932  param = &buf[s];
933 
934  for (; buf[s] && buf[s] != ' '; s++)
935  ;
936  buf[s++] = 0;
937  while (s < len && buf[s] == ' ') {
938  s++;
939  }
940 
941  /* What is done with the returned data depends on what the server
942  * returns. In some cases the client may fall back to other methods,
943  * report an error, or try another setup command.
944  */
945  if (!strcmp(cmd, "sound2")) {
946  /* No parsing needed, but we don't want a warning about unknown
947  * setup option below.
948  */
949  } else if (!strcmp(cmd, "sound")) {
950  /* No, this should not be !strcmp()... */
951  } else if (!strcmp(cmd, "mapsize")) {
952  int x, y = 0;
953  char *cp, tmpbuf[MAX_BUF];
954 
955  if (!g_ascii_strcasecmp(param, "false")) {
957  "Server only supports standard sized maps (11x11)");
958  /* Do this because we may have been playing on a big server
959  * before */
963  resize_map_window(use_config[CONFIG_MAPWIDTH], use_config[CONFIG_MAPHEIGHT]);
964  continue;
965  }
966  x = atoi(param);
967  for (cp = param; *cp != 0; cp++) {
968  if (*cp == 'x' || *cp == 'X') {
969  y = atoi(cp+1);
970  break;
971  }
972  }
973  /* A size larger than what the server supports was requested.
974  * Reduce the size to server maximum, and re-send the setup
975  * command. Update our want sizes, and tell the player what is
976  * going on.
977  */
979  if (use_config[CONFIG_MAPWIDTH] > x) {
981  }
982  if (use_config[CONFIG_MAPHEIGHT] > y) {
984  }
987  "setup mapsize %dx%d", use_config[CONFIG_MAPWIDTH], use_config[CONFIG_MAPHEIGHT]);
988  snprintf(tmpbuf, sizeof(tmpbuf), "Server supports a max mapsize of %d x %d - requesting a %d x %d mapsize",
989  x, y, use_config[CONFIG_MAPWIDTH], use_config[CONFIG_MAPHEIGHT]);
991  tmpbuf);
992  } else if (use_config[CONFIG_MAPWIDTH] == x && use_config[CONFIG_MAPHEIGHT] == y) {
994  resize_map_window(use_config[CONFIG_MAPWIDTH], use_config[CONFIG_MAPHEIGHT]);
995  } else {
996  /* The request was not bigger than what server supports, and
997  * not the same size, so what is the problem? Tell the user
998  * that something is wrong.
999  */
1000  snprintf(tmpbuf, sizeof(tmpbuf), "Unable to set mapsize on server - we wanted %d x %d, server returned %d x %d",
1002  draw_ext_info(
1004  }
1005  } else if (!strcmp(cmd, "darkness")) {
1006  /* Older servers might not support this setup command.
1007  */
1008  if (!strcmp(param, "FALSE")) {
1009  LOG(LOG_WARNING, "common::SetupCmd", "Server returned FALSE for setup command %s", cmd);
1010  }
1011  } else if (!strcmp(cmd, "spellmon")) {
1012 
1013  /* Older servers might not support this setup command or all of
1014  * the extensions.
1015  *
1016  * Spellmon 2 was added to the protocol in January 2010 to send an
1017  * additional spell information string with casting requirements
1018  * including required items, if the spell needs arguments passed
1019  * (like text for rune of marking), etc.
1020  *
1021  * To use the new feature, "setup spellmon 1 spellmon 2" is sent,
1022  * and if "spellmon 1 spellmon FALSE" is returned then the server
1023  * doesn't accept 2 - sending spellmon 2 to a server that does not
1024  * support it is not problematic, so the spellmon 1 command will
1025  * still be handled correctly by the server. If the server sends
1026  * "spellmon 1 spellmon 2" then the extended mode is in effect.
1027  *
1028  * It is not particularly important for the player to know what
1029  * level of command is accepted by the server. The extra features
1030  * will simply not be functionally available.
1031  */
1032  if (!strcmp(param, "FALSE")) {
1033  LOG(LOG_INFO, "common::SetupCmd", "Server returned FALSE for a %s setup command", cmd);
1034  } else {
1035  spellmon_level = atoi(param);
1036  }
1037  } else if (!strcmp(cmd, "facecache")) {
1038  use_config[CONFIG_CACHE] = atoi(param);
1039  } else if (!strcmp(cmd, "faceset")) {
1040  if (!strcmp(param, "FALSE")) {
1042  "Server does not support other image sets, will use default");
1043  face_info.faceset = 0;
1044  }
1045  } else if (!strcmp(cmd, "map2cmd")) {
1046  if (!strcmp(param, "FALSE")) {
1048  "Server does not support map2cmd!");
1050  "This server is too old to support this client!");
1052  }
1053  } else if (!strcmp(cmd, "want_pickup")) {
1054  /* Nothing special to do as this is info pushed from server and
1055  * not having it isn't that bad.
1056  */
1057  } else if (!strcmp(cmd, "loginmethod")) {
1058  int method = atoi(param);
1059 
1060  /* If the server supports new login, start the process. Pass what
1061  * version the server supports so client can do appropriate
1062  * work
1063  */
1064  if (method) {
1065  start_login(method);
1066  }
1067  } else if (!strcmp(cmd, "newmapcmd")) {
1068  // if server doesn't support newmapcmd, too bad
1069  } else if (!strcmp(cmd, "tick")) {
1070  // Ticks drive the redraw loop via client_tick(), so we really
1071  // do need ticks. To support servers without ticks, add a timer
1072  // callback via g_timeout_add() that calls client_tick().
1073  if (!strcmp(param, "FALSE")) {
1075  "Server does not support tick!");
1077  "This server is too old to support this client!");
1079  }
1080  } else {
1081  LOG(LOG_INFO, "common::SetupCmd",
1082  "Got setup for a command we don't understand: %s %s",
1083  cmd, param);
1084  }
1085  }
1086 }
1087 
1096 void AddMeFail(char *data, int len)
1097 {
1098  (void)data; /* __UNUSED__ */
1099  (void)len; /* __UNUSED__ */
1100 
1101  LOG(LOG_INFO, "common::AddMeFail", "addme_failed received.");
1102  return;
1103 }
1104 
1112 void AddMeSuccess(char *data, int len)
1113 {
1114  (void)data; /* __UNUSED__ */
1115  (void)len; /* __UNUSED__ */
1116 
1118  show_main_client();
1119  LOG(LOG_DEBUG, "common::AddMeSuccess", "addme_success received.");
1120  return;
1121 }
1122 
1128 void GoodbyeCmd(char *data, int len)
1129 {
1130  (void)data; /* __UNUSED__ */
1131  (void)len; /* __UNUSED__ */
1132 
1133  /* This could probably be greatly improved - I am not sure if anything
1134  * needs to be saved here, but it should be possible to reconnect to the
1135  * server or a different server without having to rerun the client.
1136  */
1137  LOG(LOG_WARNING, "common::GoodbyeCmd", "Received goodbye command from server - exiting");
1138  exit(0);
1139 }
1140 
1142 
1148 void AnimCmd(unsigned char *data, int len)
1149 {
1150  short anum;
1151  int i, j;
1152 
1153  anum = GetShort_String(data);
1154  if (anum < 0 || anum > MAXANIM) {
1155  LOG(LOG_WARNING, "common::AnimCmd", "animation number invalid: %d", anum);
1156  return;
1157  }
1158 
1159  animations[anum].flags = GetShort_String(data+2);
1160  animations[anum].num_animations = (len-4)/2;
1161  if (animations[anum].num_animations < 1) {
1162  LOG(LOG_WARNING, "common::AnimCmd", "num animations invalid: %d",
1163  animations[anum].num_animations);
1164  return;
1165  }
1166  animations[anum].faces = g_malloc(sizeof(guint16)*animations[anum].num_animations);
1167  for (i = 4, j = 0; i < len; i += 2, j++) {
1168  animations[anum].faces[j] = GetShort_String(data+i);
1169  }
1170 
1171  if (j != animations[anum].num_animations) {
1172  LOG(LOG_WARNING, "common::AnimCmd",
1173  "Calculated animations does not equal stored animations? (%d!=%d)",
1174  j, animations[anum].num_animations);
1175  }
1176 
1177  animations[anum].speed = 0;
1178  animations[anum].speed_left = 0;
1179  animations[anum].phase = 0;
1180 
1181  LOG(LOG_DEBUG, "common::AnimCmd", "Received animation %d, %d faces", anum, animations[anum].num_animations);
1182 }
1183 
1193 void SmoothCmd(unsigned char *data, int len)
1194 {
1195  guint16 faceid;
1196  guint16 smoothing;
1197 
1198  /* len is unused. We should check that we don't have an invalid short
1199  * command. Hence, the compiler warning is valid.
1200  */
1201 
1202  faceid = GetShort_String(data);
1203  smoothing = GetShort_String(data+2);
1204  addsmooth(faceid, smoothing);
1205 }
1206 
1213 void DrawInfoCmd(char *data, int len)
1214 {
1215  int color = atoi(data);
1216  char *buf;
1217 
1218  (void)len; /* __UNUSED__ */
1219 
1220  buf = strchr(data, ' ');
1221  if (!buf) {
1222  LOG(LOG_WARNING, "common::DrawInfoCmd", "got no data");
1223  buf = "";
1224  } else {
1225  buf++;
1226  }
1228 }
1229 
1231 
1237 void setTextManager(int type, ExtTextManager callback)
1238 {
1239  TextManager *current = firstTextManager;
1240 
1241  while (current != NULL) {
1242  if (current->type == type) {
1243  current->callback = callback;
1244  return;
1245  }
1246  current = current->next;
1247  }
1248  current = g_malloc(sizeof(TextManager));
1249  current->type = type;
1250  current->callback = callback;
1251  current->next = firstTextManager;
1252  firstTextManager = current;
1253 }
1254 
1260 {
1261  TextManager *current = firstTextManager;
1262  while (current != NULL) {
1263  if (current->type == type) {
1264  return current->callback;
1265  }
1266  current = current->next;
1267  }
1268  return NULL;
1269 }
1270 
1277 void DrawExtInfoCmd(char *data, int len)
1278 {
1279  int color;
1280  int type, subtype;
1281  char *buf = data;
1282  int wordCount = 3;
1283  ExtTextManager fnct;
1284 
1285  while (wordCount > 0) {
1286  while (buf[0] == ' ') {
1287  buf++;
1288  }
1289  wordCount--;
1290  while (buf[0] != ' ') {
1291  if (buf[0] == '\0') {
1292  LOG(LOG_WARNING,
1293  "common::DrawExtInfoCmd", "Data is missing %d parameters %s",
1294  wordCount,
1295  data);
1296  return;
1297  } else {
1298  buf++;
1299  }
1300  }
1301  if (buf[0] == ' ') {
1302  buf++; /*remove trailing space to send clean data to callback */
1303  }
1304  }
1305  wordCount = sscanf(data, "%d %d %d", &color, &type, &subtype);
1306  if (wordCount != 3) {
1307  LOG(LOG_WARNING,
1308  "common::DrawExtInfoCmd", "Wrong parameters received. Could only parse %d out of 3 int in %s",
1309  wordCount,
1310  data);
1311  return;
1312  }
1313  fnct = getTextManager(type);
1314  if (fnct == NULL) {
1315  LOG(LOG_WARNING,
1316  "common::DrawExtInfoCmd", "Server send us a type %d but i can't find any callback for it",
1317  type);
1318  return;
1319  }
1320  fnct(color, type, subtype, buf);
1321 }
1322 
1329 void use_skill(int skill_id)
1330 {
1331  int i = 0;
1332  int next;
1333  int prev = last_used_skills[0];
1334 
1335  if(last_used_skills[0] == skill_id) {
1336  return;
1337  }
1338 
1339  do {
1340  next = last_used_skills[i+1];
1341  last_used_skills[i+1] = prev;
1342  prev = next;
1343  ++i;
1344  } while(next != skill_id && next >= 0);
1345  last_used_skills[0] = skill_id;
1346 }
1347 
1354 void StatsCmd(unsigned char *data, int len)
1355 {
1356  int i = 0, c, redraw = 0;
1357  gint64 last_exp;
1358 
1359  while (i < len) {
1360  c = data[i++];
1361  if (c >= CS_STAT_RESIST_START && c <= CS_STAT_RESIST_END) {
1363  i += 2;
1364  cpl.stats.resist_change = 1;
1365  } else if (c >= CS_STAT_SKILLINFO && c < (CS_STAT_SKILLINFO+CS_NUM_SKILLS)) {
1366  /* We track to see if the exp has gone from 0 to some total value
1367  * - we do this because the draw logic currently only draws skills
1368  * where the player has exp. We need to communicate to the draw
1369  * function that it should draw all the players skills. Using
1370  * redraw is a little overkill, because a lot of the data may not
1371  * be changing. OTOH, such a transition should only happen
1372  * rarely, not not be a very big deal.
1373  */
1374  cpl.stats.skill_level[c-CS_STAT_SKILLINFO] = data[i++];
1375  last_exp = cpl.stats.skill_exp[c-CS_STAT_SKILLINFO];
1378  if (last_exp == 0 && cpl.stats.skill_exp[c-CS_STAT_SKILLINFO]) {
1379  redraw = 1;
1380  }
1381  i += 8;
1382  } else {
1383  switch (c) {
1384  case CS_STAT_HP:
1385  cpl.stats.hp = GetShort_String(data+i);
1386  i += 2;
1387  break;
1388  case CS_STAT_MAXHP:
1389  cpl.stats.maxhp = GetShort_String(data+i);
1390  i += 2;
1391  break;
1392  case CS_STAT_SP:
1393  cpl.stats.sp = GetShort_String(data+i);
1394  i += 2;
1395  break;
1396  case CS_STAT_MAXSP:
1397  cpl.stats.maxsp = GetShort_String(data+i);
1398  i += 2;
1399  break;
1400  case CS_STAT_GRACE:
1401  cpl.stats.grace = GetShort_String(data+i);
1402  i += 2;
1403  break;
1404  case CS_STAT_MAXGRACE:
1405  cpl.stats.maxgrace = GetShort_String(data+i);
1406  i += 2;
1407  break;
1408  case CS_STAT_STR:
1409  cpl.stats.Str = GetShort_String(data+i);
1410  i += 2;
1411  break;
1412  case CS_STAT_INT:
1413  cpl.stats.Int = GetShort_String(data+i);
1414  i += 2;
1415  break;
1416  case CS_STAT_POW:
1417  cpl.stats.Pow = GetShort_String(data+i);
1418  i += 2;
1419  break;
1420  case CS_STAT_WIS:
1421  cpl.stats.Wis = GetShort_String(data+i);
1422  i += 2;
1423  break;
1424  case CS_STAT_DEX:
1425  cpl.stats.Dex = GetShort_String(data+i);
1426  i += 2;
1427  break;
1428  case CS_STAT_CON:
1429  cpl.stats.Con = GetShort_String(data+i);
1430  i += 2;
1431  break;
1432  case CS_STAT_CHA:
1433  cpl.stats.Cha = GetShort_String(data+i);
1434  i += 2;
1435  break;
1436  case CS_STAT_EXP:
1437  cpl.stats.exp = GetInt_String(data+i);
1438  i += 4;
1439  break;
1440  case CS_STAT_EXP64:
1441  cpl.stats.exp = GetInt64_String(data+i);
1442  i += 8;
1443  break;
1444  case CS_STAT_LEVEL:
1445  cpl.stats.level = GetShort_String(data+i);
1446  i += 2;
1447  break;
1448  case CS_STAT_WC:
1449  cpl.stats.wc = GetShort_String(data+i);
1450  i += 2;
1451  break;
1452  case CS_STAT_AC:
1453  cpl.stats.ac = GetShort_String(data+i);
1454  i += 2;
1455  break;
1456  case CS_STAT_DAM:
1457  cpl.stats.dam = GetShort_String(data+i);
1458  i += 2;
1459  break;
1460  case CS_STAT_ARMOUR:
1461  cpl.stats.resists[0] = GetShort_String(data+i);
1462  i += 2;
1463  break;
1464  case CS_STAT_SPEED:
1465  cpl.stats.speed = GetInt_String(data+i);
1466  i += 4;
1467  break;
1468  case CS_STAT_FOOD:
1469  cpl.stats.food = GetShort_String(data+i);
1470  i += 2;
1471  break;
1472  case CS_STAT_WEAP_SP:
1473  cpl.stats.weapon_sp = GetInt_String(data+i);
1474  i += 4;
1475  break;
1476  case CS_STAT_SPELL_ATTUNE:
1477  cpl.stats.attuned = GetInt_String(data+i);
1478  i += 4;
1479  cpl.spells_updated = 1;
1480  break;
1481  case CS_STAT_SPELL_REPEL:
1482  cpl.stats.repelled = GetInt_String(data+i);
1483  i += 4;
1484  cpl.spells_updated = 1;
1485  break;
1486  case CS_STAT_SPELL_DENY:
1487  cpl.stats.denied = GetInt_String(data+i);
1488  i += 4;
1489  cpl.spells_updated = 1;
1490  break;
1491 
1492  case CS_STAT_FLAGS:
1493  cpl.stats.flags = GetShort_String(data+i);
1494  i += 2;
1495  break;
1496  case CS_STAT_WEIGHT_LIM:
1498  i += 4;
1499  /* Mark weight limit changes to update the client inventory window */
1500  cpl.ob->inv_updated = 1;
1501  break;
1502 
1503  case CS_STAT_RANGE: {
1504  int rlen = data[i++];
1505  strncpy(cpl.range, (const char*)data+i, rlen);
1506  cpl.range[rlen] = '\0';
1507  i += rlen;
1508  break;
1509  }
1510 
1511  case CS_STAT_TITLE: {
1512  int rlen = data[i++];
1513  strncpy(cpl.title, (const char*)data+i, rlen);
1514  cpl.title[rlen] = '\0';
1515  i += rlen;
1516  break;
1517  }
1518 
1519  default:
1520  LOG(LOG_WARNING, "common::StatsCmd", "Unknown stat number %d", c);
1521  break;
1522  }
1523  }
1524  }
1525 
1526  if (i > len) {
1527  LOG(LOG_WARNING, "common::StatsCmd", "got stats overflow, processed %d bytes out of %d", i, len);
1528  }
1529  draw_stats(redraw);
1531 #ifdef HAVE_LUA
1532  script_lua_stats();
1533 #endif
1534 }
1535 
1542 void handle_query(char *data, int len)
1543 {
1544  char *buf, *cp;
1545  guint8 flags = atoi(data);
1546 
1547  (void)len; /* __UNUSED__ */
1548 
1549  if (flags&CS_QUERY_HIDEINPUT) { /* No echo */
1550  cpl.no_echo = 1;
1551  } else {
1552  cpl.no_echo = 0;
1553  }
1554 
1555  /* Let the window system know this may have changed */
1556  x_set_echo();
1557 
1558  /* The actual text is optional */
1559  buf = strchr(data, ' ');
1560  if (buf) {
1561  buf++;
1562  }
1563 
1564  /* If we just get passed an empty string, why draw this? */
1565  if (buf) {
1566  cp = buf;
1567  while ((buf = strchr(buf, '\n')) != NULL) {
1568  *buf++ = '\0';
1569  draw_ext_info(
1571  cp = buf;
1572  }
1573  /* Yes/no - don't do anything with it now */
1574  if (flags&CS_QUERY_YESNO) {
1575  }
1576 
1577  /* One character response expected */
1578  if (flags&CS_QUERY_SINGLECHAR) {
1580  } else {
1582  }
1583 
1584  if (cp) {
1585  draw_prompt(cp);
1586  }
1587  }
1588 
1589  LOG(LOG_DEBUG, "common::handle_query", "Received query. Input state now %d", cpl.input_state);
1590 }
1591 
1598 void send_reply(const char *text)
1599 {
1600  cs_print_string(csocket.fd, "reply %s", text);
1601 
1602  /* Let the window system know that the (possibly hidden) query is over. */
1603  cpl.no_echo = 0;
1604  x_set_echo();
1605 }
1606 
1615 void PlayerCmd(unsigned char *data, int len)
1616 {
1617  char name[MAX_BUF];
1618  int tag, weight, face, i = 0, nlen;
1619 
1621  tag = GetInt_String(data);
1622  i += 4;
1623  weight = GetInt_String(data+i);
1624  i += 4;
1625  face = GetInt_String(data+i);
1626  i += 4;
1627  nlen = data[i++];
1628  memcpy(name, (const char*)data+i, nlen);
1629  name[nlen] = '\0';
1630  i += nlen;
1631 
1632  if (i != len) {
1633  LOG(LOG_WARNING, "common::PlayerCmd", "lengths do not match (%d!=%d)", len, i);
1634  }
1635  new_player(tag, name, weight, face);
1636 }
1637 
1643 {
1644  if (!op) {
1645  return;
1646  }
1647 
1648  if (op->open) {
1649  open_container(op);
1650  cpl.container = op;
1651  } else if (op->was_open) {
1652  close_container(op);
1653  cpl.container = NULL;
1654  }
1655 }
1656 
1663 void Item2Cmd(unsigned char *data, int len) {
1664  int weight, loc, tag, face, flags, pos = 0, nlen, anim, nrof, type;
1665  guint8 animspeed;
1666  char name[MAX_BUF];
1667 
1668  loc = GetInt_String(data);
1669  pos += 4;
1670 
1671  if (pos == len) {
1672  LOG(LOG_WARNING, "common::common_item_command", "Got location with no other data");
1673  return;
1674  } else if (loc < 0) { /* Delete following items */
1675  LOG(LOG_WARNING, "common::common_item_command", "Got location with negative value (%d)", loc);
1676  return;
1677  } else {
1678  while (pos < len) {
1679  tag = GetInt_String(data+pos);
1680  pos += 4;
1681  flags = GetInt_String(data+pos);
1682  pos += 4;
1683  weight = GetInt_String(data+pos);
1684  pos += 4;
1685  face = GetInt_String(data+pos);
1686  pos += 4;
1687  nlen = data[pos++];
1688  memcpy(name, (char*)data+pos, nlen);
1689  pos += nlen;
1690  name[nlen] = '\0';
1691  anim = GetShort_String(data+pos);
1692  pos += 2;
1693  animspeed = data[pos++];
1694  nrof = GetInt_String(data+pos);
1695  pos += 4;
1696  type = GetShort_String(data+pos);
1697  pos += 2;
1698  update_item(tag, loc, name, weight, face, flags, anim, animspeed, nrof, type);
1699  item_actions(locate_item(tag));
1700  }
1701  if (pos > len) {
1702  LOG(LOG_WARNING, "common::common_item_cmd", "Overread buffer: %d > %d", pos, len);
1703  }
1704  }
1705 }
1706 
1713 void UpdateItemCmd(unsigned char *data, int len)
1714 {
1715  int weight, loc, tag, face, sendflags, flags, pos = 0, nlen, anim;
1716  guint32 nrof;
1717  char name[MAX_BUF];
1718  item *ip;
1719  guint8 animspeed;
1720 
1721  sendflags = data[0];
1722  pos += 1;
1723  tag = GetInt_String(data+pos);
1724  pos += 4;
1725  ip = locate_item(tag);
1726  if (!ip) {
1727  /*
1728  fprintf(stderr, "Got update_item command for item we don't have (%d)\n", tag);
1729  */
1730  return;
1731  }
1732 
1733  /* Copy all of these so we can pass the values to update_item and don't
1734  * need to figure out which ones were modified by this function.
1735  */
1736  *name = '\0';
1737  loc = ip->env ? ip->env->tag : 0;
1738  weight = ip->weight*1000;
1739  face = ip->face;
1740  flags = ip->flagsval;
1741  anim = ip->animation_id;
1742  animspeed = ip->anim_speed;
1743  nrof = ip->nrof;
1744 
1745  if (sendflags&UPD_LOCATION) {
1746  loc = GetInt_String(data+pos);
1747  LOG(LOG_WARNING, "common::UpdateItemCmd", "Got tag of unknown object (%d) for new location", loc);
1748  pos += 4;
1749  }
1750  if (sendflags&UPD_FLAGS) {
1751  flags = GetInt_String(data+pos);
1752  pos += 4;
1753  }
1754  if (sendflags&UPD_WEIGHT) {
1755  weight = GetInt_String(data+pos);
1756  pos += 4;
1757  }
1758  if (sendflags&UPD_FACE) {
1759  face = GetInt_String(data+pos);
1760  pos += 4;
1761  }
1762  if (sendflags&UPD_NAME) {
1763  nlen = data[pos++];
1764  memcpy(name, (char*)data+pos, nlen);
1765  pos += nlen;
1766  name[nlen] = '\0';
1767  }
1768  if (pos > len) {
1769  LOG(LOG_WARNING, "common::UpdateItemCmd", "Overread buffer: %d > %d", pos, len);
1770  return; /* We have bad data, probably don't want to store it then */
1771  }
1772  if (sendflags&UPD_ANIM) {
1773  anim = GetShort_String(data+pos);
1774  pos += 2;
1775  }
1776  if (sendflags&UPD_ANIMSPEED) {
1777  animspeed = data[pos++];
1778  }
1779  if (sendflags&UPD_NROF) {
1780  nrof = (guint32)GetInt_String(data+pos);
1781  pos += 4;
1782  }
1783  /* update_item calls set_item_values which will then set the list redraw
1784  * flag, so we don't need to do an explicit redraw here. Actually,
1785  * calling update_item is a little bit of overkill, since we already
1786  * determined some of the values in this function.
1787  */
1788  update_item(tag, loc, name, weight, face, flags, anim, animspeed, nrof, ip->type);
1789  item_actions(locate_item(tag));
1790 }
1791 
1797 void DeleteItem(unsigned char *data, int len)
1798 {
1799  int pos = 0, tag;
1800 
1801  while (pos < len) {
1802  item *op;
1803 
1804  tag = GetInt_String(data+pos);
1805  pos += 4;
1806  op = locate_item(tag);
1807  if (op != NULL) {
1808  remove_item(op);
1809  } else {
1810  LOG(LOG_WARNING, "common::DeleteItem", "Cannot find tag %d", tag);
1811  }
1812  }
1813  if (pos > len) {
1814  LOG(LOG_WARNING, "common::DeleteItem", "Overread buffer: %d > %d", pos, len);
1815  }
1816 }
1817 
1823 void DeleteInventory(unsigned char *data, int len)
1824 {
1825  int tag;
1826  item *op;
1827 
1828  (void)len; /* __UNUSED__ */
1829 
1830  tag = atoi((const char*)data);
1831  op = locate_item(tag);
1832  if (op != NULL) {
1834  } else {
1835  LOG(LOG_WARNING, "common::DeleteInventory", "Invalid tag: %d", tag);
1836  }
1837 }
1838 
1842 static void rstrip(char buf[static 1], size_t len) {
1843  for (size_t i = len - 1; i > 0; i--) {
1844  if (buf[i] == '\n' || buf[i] == ' ') {
1845  buf[i] = '\0';
1846  } else {
1847  return;
1848  }
1849  }
1850 }
1851 
1852 /****************************************************************************/
1853 
1864 void AddspellCmd(unsigned char *data, int len)
1865 {
1866  guint8 nlen;
1867  guint16 mlen, pos = 0;
1868  Spell *newspell, *tmp;
1869 
1870  while (pos < len) {
1871  newspell = calloc(1, sizeof(Spell));
1872 
1873  /* Get standard spell information (spellmon 1)
1874  */
1875  newspell->tag = GetInt_String(data+pos);
1876  pos += 4;
1877  newspell->level = GetShort_String(data+pos);
1878  pos += 2;
1879  newspell->time = GetShort_String(data+pos);
1880  pos += 2;
1881  newspell->sp = GetShort_String(data+pos);
1882  pos += 2;
1883  newspell->grace = GetShort_String(data+pos);
1884  pos += 2;
1885  newspell->dam = GetShort_String(data+pos);
1886  pos += 2;
1887  newspell->skill_number = GetChar_String(data+pos);
1888  pos += 1;
1889  newspell->path = GetInt_String(data+pos);
1890  pos += 4;
1891  newspell->face = GetInt_String(data+pos);
1892  pos += 4;
1893  nlen = GetChar_String(data+pos);
1894  pos += 1;
1895  strncpy(newspell->name, (char*)data+pos, nlen);
1896  pos += nlen;
1897  newspell->name[nlen] = '\0'; /* To ensure we are null terminated */
1898  mlen = GetShort_String(data+pos);
1899  pos += 2;
1900  strncpy(newspell->message, (char*)data+pos, mlen);
1901  pos += mlen;
1902  newspell->message[mlen] = '\0'; /* To ensure we are null terminated */
1903  rstrip(newspell->message, mlen);
1904 
1905  if (spellmon_level < 2) {
1906 
1907  /* The server is not sending spellmon 2 extended information, so
1908  * initialize the spell data fields as unused/empty.
1909  */
1910  newspell->usage = 0;
1911  newspell->requirements[0] = '\0';
1912 
1913  } else if (pos < len) {
1914 
1915  /* The server is sending extended spell information (spellmon 2) so
1916  * process it.
1917  */
1918  newspell->usage = GetChar_String(data+pos);
1919  pos += 1;
1920  nlen = GetChar_String(data+pos);
1921  pos += 1;
1922  strncpy(newspell->requirements, (char*) data+pos, nlen);
1923  pos += nlen;
1924  newspell->requirements[nlen] = '\0'; /* Ensure null-termination */
1925  }
1926 
1927  /* Compute the derived spell information.
1928  */
1929  newspell->skill = skill_names[newspell->skill_number-CS_STAT_SKILLINFO];
1930 
1931  /* Add the spell to the player struct.
1932  */
1933  if (!cpl.spelldata) {
1934  cpl.spelldata = newspell;
1935  } else {
1936  for (tmp = cpl.spelldata; tmp->next; tmp = tmp->next)
1937  ;
1938  tmp->next = newspell;
1939  }
1940  /* Check to see if there are more spells to add.
1941  */
1942  }
1943  if (pos > len) {
1944  LOG(LOG_WARNING, "common::AddspellCmd", "Overread buffer: %d > %d", pos, len);
1945  }
1946  cpl.spells_updated = 1;
1947 }
1948 
1949 void UpdspellCmd(unsigned char *data, int len) {
1950  int flags, pos = 0;
1951  guint32 tag;
1952  Spell *tmp;
1953 
1954  if (!cpl.spelldata) {
1955  LOG(LOG_WARNING, "common::UpdspellCmd", "I know no spells to update");
1956  return;
1957  }
1958 
1959  flags = GetChar_String(data+pos);
1960  pos += 1;
1961  tag = GetInt_String(data+pos);
1962  pos += 4;
1963  for (tmp = cpl.spelldata; tmp && tmp->tag != tag; tmp = tmp->next)
1964  ;
1965  if (!tmp) {
1966  LOG(LOG_WARNING, "common::UpdspellCmd", "Invalid tag: %d", tag);
1967  return;
1968  }
1969  if (flags&UPD_SP_MANA) {
1970  tmp->sp = GetShort_String(data+pos);
1971  pos += 2;
1972  }
1973  if (flags&UPD_SP_GRACE) {
1974  tmp->grace = GetShort_String(data+pos);
1975  pos += 2;
1976  }
1977  if (flags&UPD_SP_DAMAGE) {
1978  tmp->dam = GetShort_String(data+pos);
1979  pos += 2;
1980  }
1981  if (pos > len) {
1982  LOG(LOG_WARNING, "common::UpdspellCmd", "Overread buffer: %d > %d", pos, len);
1983  }
1984  cpl.spells_updated = 1;
1985 }
1986 
1987 void DeleteSpell(unsigned char *data, int len) {
1988  guint32 tag;
1989  Spell *tmp, *target;
1990 
1991  if (!cpl.spelldata) {
1992  LOG(LOG_WARNING, "common::DeleteSpell", "I know no spells to delete");
1993  return;
1994  }
1995 
1996  tag = GetInt_String(data);
1997  /* Special case: the first spell is the one removed */
1998  if (cpl.spelldata->tag == tag) {
1999  target = cpl.spelldata;
2000  if (target->next) {
2001  cpl.spelldata = target->next;
2002  } else {
2003  cpl.spelldata = NULL;
2004  }
2005  free(target);
2006  return;
2007  }
2008 
2009  for (tmp = cpl.spelldata; tmp->next && tmp->next->tag != tag; tmp = tmp->next)
2010  ;
2011  if (!tmp->next) {
2012  LOG(LOG_WARNING, "common::DeleteSpell", "Invalid tag: %d", tag);
2013  return;
2014  }
2015  target = tmp->next;
2016  if (target->next) {
2017  tmp->next = target->next;
2018  } else {
2019  tmp->next = NULL;
2020  }
2021  free(target);
2022  cpl.spells_updated = 1;
2023 }
2024 
2025 /****************************************************************************/
2026  /* EndOf SCSpellCommands
2029  */
2030 
2041 void NewmapCmd(unsigned char *data, int len)
2042 {
2043  (void)data; /* __UNUSED__ */
2044  (void)len; /* __UNUSED__ */
2045 
2046  mapdata_newmap();
2047 }
2048 
2049 /* This is the common processing block for the map1 and map1a protocol
2050  * commands. The map1a mieks minor extensions and are easy to deal with
2051  * inline (in fact, this code doesn't even care what rev is - just certain
2052  * bits will only bet set when using the map1a command. rev is 0 for map1, 1
2053  * for map1a. It conceivable that there could be future revisions.
2054  */
2055 
2056 /* NUM_LAYERS should only be used for the map1{a} which only has a few layers.
2057  * Map2 has 10 layers. However, some of the map1 logic requires this to be
2058  * set right.
2059  */
2060 #define NUM_LAYERS (MAP1_LAYERS-1)
2061 
2067 void Map2Cmd(unsigned char *data, int len)
2068 {
2069  int mask, x, y, pos = 0, space_len, value;
2070  guint8 type;
2071 
2072  /* Not really using map1 protocol, but some draw logic differs from the
2073  * original draw logic, and map2 is closest.
2074  */
2075  while (pos < len) {
2076  mask = GetShort_String(data+pos);
2077  pos += 2;
2078  x = ((mask>>10)&0x3f)-MAP2_COORD_OFFSET;
2079  y = ((mask>>4)&0x3f)-MAP2_COORD_OFFSET;
2080 
2081  /* This is a scroll then. Go back and fetch another coordinate */
2082  if (mask&0x1) {
2083  mapdata_scroll(x, y);
2084  continue;
2085  }
2086 
2087  if (x<0) {
2088  LOG(LOG_WARNING, "commands.c::Map2Cmd", "got negative x!");
2089  x = 0;
2090  } else if (x >= MAX_VIEW) {
2091  LOG(LOG_WARNING, "commands.c::Map2Cmd", "got x >= MAX_VIEW!");
2092  x = MAX_VIEW - 1;
2093  }
2094 
2095  if (y<0) {
2096  LOG(LOG_WARNING, "commands.c::Map2Cmd", "got negative y!");
2097  y = 0;
2098  } else if (y >= MAX_VIEW) {
2099  LOG(LOG_WARNING, "commands.c::Map2Cmd", "got y >= MAX_VIEW!");
2100  y = MAX_VIEW - 1;
2101  }
2102 
2103  assert(0 <= x && x < MAX_VIEW);
2104  assert(0 <= y && y < MAX_VIEW);
2105  /* Clearing old cell data as needed (was in mapdata_set_face_layer()
2106  * before however that caused darkness to only work if sent after the
2107  * layers).
2108  */
2109  mapdata_clear_old(x, y);
2110 
2111  /* Inner loop is for the data on the space itself */
2112  while (pos < len) {
2113  type = data[pos++];
2114  /* type == 255 means nothing more for this space */
2115  if (type == 255) {
2117  break;
2118  }
2119  space_len = type>>5;
2120  type &= 0x1f;
2121  /* Clear the space */
2122  if (type == MAP2_TYPE_CLEAR) {
2123  mapdata_clear_space(x, y);
2124  continue;
2125  } else if (type == MAP2_TYPE_DARKNESS) {
2126  value = data[pos++];
2127  mapdata_set_darkness(x, y, value);
2128  continue;
2129  } else if (type >= MAP2_LAYER_START && type < MAP2_LAYER_START+MAXLAYERS) {
2130  int layer, opt;
2131 
2132  /* This is face information for a layer. */
2133  layer = type&0xf;
2134 
2135  if (layer < 0) {
2136  LOG(LOG_WARNING, "commands.c::Map2Cmd", "got negative layer!");
2137  layer = 0;
2138  } else if (layer >= MAXLAYERS) {
2139  LOG(LOG_WARNING, "commands.c::Map2Cmd", "got layer >= MAXLAYERS!");
2140  layer = MAXLAYERS - 1;
2141  }
2142  assert(0 <= layer && layer < MAXLAYERS);
2143 
2144  /* This is the face */
2145  value = GetShort_String(data+pos);
2146  pos += 2;
2147  if (!(value&FACE_IS_ANIM)) {
2148  mapdata_set_face_layer(x, y, value, layer);
2149  }
2150 
2151  if (space_len > 2) {
2152  opt = data[pos++];
2153  if (value&FACE_IS_ANIM) {
2154  /* Animation speed */
2155  mapdata_set_anim_layer(x, y, value, opt, layer);
2156  } else {
2157  /* Smooth info */
2158  mapdata_set_smooth(x, y, opt, layer);
2159  }
2160  }
2161  /* Currently, if 4 bytes, must be a smooth byte */
2162  if (space_len > 3) {
2163  opt = data[pos++];
2164  mapdata_set_smooth(x, y, opt, layer);
2165  }
2166  continue;
2167  } /* if image layer */
2168  } /* while pos<len inner loop for space */
2169  } /* While pos<len outer loop */
2170  mapupdatesent = 0;
2171  display_map_doneupdate(FALSE, FALSE);
2172 }
2173 
2180 void map_scrollCmd(char *data, int len)
2181 {
2182  int dx, dy;
2183  char *buf;
2184 
2185  (void)len; /* __UNUSED__ */
2186 
2187  dx = atoi(data);
2188  buf = strchr(data, ' ');
2189  if (!buf) {
2190  LOG(LOG_WARNING, "common::map_scrollCmd", "Got short packet.");
2191  return;
2192  }
2193  buf++;
2194  dy = atoi(buf);
2195 
2196  mapdata_scroll(dx, dy);
2197  display_map_doneupdate(FALSE, TRUE);
2198 }
2199 
2210 int ExtSmooth(unsigned char *data, int len, int x, int y, int layer)
2211 {
2212  static int dx[8] = { 0, 1, 1, 1, 0, -1, -1, -1, };
2213  static int dy[8] = { -1, -1, 0, 1, 1, 1, 0, -1, };
2214  int i, rx, ry;
2215  int newsm;
2216 
2217  if (len < 1) {
2218  return 0;
2219  }
2220 
2221  x += pl_pos.x;
2222  y += pl_pos.y;
2223  newsm = GetChar_String(data);
2224 
2225  if (mapdata_cell(x, y)->smooth[layer] != newsm) {
2226  for (i = 0; i < 8; i++) {
2227  rx = x+dx[i];
2228  ry = y+dy[i];
2229  if (!mapdata_contains(rx, ry)) {
2230  continue;
2231  }
2232  mapdata_cell(x, y)->need_resmooth = 1;
2233  }
2234  }
2235  mapdata_cell(x, y)->smooth[layer] = newsm;
2236  return 1;/*Cause smooth infos only use 1 byte*/
2237 }
2238 
2248 void MapExtendedCmd(unsigned char *data, int len)
2249 {
2250  int mask, x, y, pos = 0, layer;
2251  int noredraw = 0;
2252  int hassmooth = 0;
2253  int entrysize;
2254  int startpackentry;
2255 
2256  mapupdatesent = 1;
2257  mask = GetChar_String(data+pos);
2258  pos += 1;
2259  if (mask&EMI_NOREDRAW) {
2260  noredraw = 1;
2261  }
2262  if (mask&EMI_SMOOTH) {
2263  hassmooth = 1;
2264  }
2265  while (mask&EMI_HASMOREBITS) {
2266  /*There may be bits we ignore about*/
2267  mask = GetChar_String(data+pos);
2268  pos += 1;
2269  }
2270  entrysize = GetChar_String(data+pos);
2271  pos = pos+1;
2272 
2273  while (pos+entrysize+2 <= len) {
2274  mask = GetShort_String(data+pos);
2275  pos += 2;
2276  x = (mask>>10)&0x3f;
2277  y = (mask>>4)&0x3f;
2278  for (layer = NUM_LAYERS; layer >= 0; layer--) {
2279  if (mask&(1<<layer)) {
2280  /*handle an entry*/
2281  if (pos+entrysize > len) { /*erroneous packet*/
2282  break;
2283  }
2284  startpackentry = pos;
2285  /* If you had extended infos to the server, this is where, in
2286  * the client, you may add your code
2287  */
2288  if (hassmooth) {
2289  pos = pos+ExtSmooth(data+pos, len-pos, x, y, NUM_LAYERS-layer);
2290  }
2291  /* Continue with other if you add new extended infos to server
2292  *
2293  * Now point to the next data
2294  */
2295  pos = startpackentry+entrysize;
2296  }
2297  }
2298  }
2299  if (!noredraw) {
2300  display_map_doneupdate(FALSE, FALSE);
2301  mapupdatesent = 0;
2302  }
2303 }
2304 
2310 void MagicMapCmd(unsigned char *data, int len)
2311 {
2312  unsigned char *cp;
2313  int i;
2314 
2315  /* First, extract the size/position information. */
2316  if (sscanf((const char*)data, "%hd %hd %hd %hd", &cpl.mmapx, &cpl.mmapy, &cpl.pmapx, &cpl.pmapy) != 4) {
2317  LOG(LOG_WARNING, "common::MagicMapCmd", "Was not able to properly extract magic map size, pos");
2318  return;
2319  }
2320 
2321  if (cpl.mmapx == 0 || cpl.mmapy == 0) {
2322  LOG(LOG_WARNING, "common::MagicMapCmd", "empty map");
2323  return;
2324  }
2325 
2326  /* Now we need to find the start of the actual data. There are 4 space
2327  * characters we need to skip over.
2328  */
2329  for (cp = data, i = 0; i < 4 && cp < data+len; cp++) {
2330  if (*cp == ' ') {
2331  i++;
2332  }
2333  }
2334  if (i != 4) {
2335  LOG(LOG_WARNING, "common::MagicMapCmd", "Was unable to find start of magic map data");
2336  return;
2337  }
2338  i = len-(cp-data); /* This should be the number of bytes left */
2339  if (i != cpl.mmapx*cpl.mmapy) {
2340  LOG(LOG_WARNING, "common::MagicMapCmd", "Magic map size mismatch. Have %d bytes, should have %d",
2341  i, cpl.mmapx*cpl.mmapy);
2342  return;
2343  }
2344  free(cpl.magicmap);
2345  cpl.magicmap = g_malloc(cpl.mmapx*cpl.mmapy);
2346  /* Order the server puts it in should be just fine. Note that the only
2347  * requirement that this works is that magicmap by 8 bits, being that is
2348  * the size specified in the protocol and what the server sends us.
2349  */
2350  memcpy(cpl.magicmap, cp, cpl.mmapx*cpl.mmapy);
2351  draw_magic_map();
2352 }
2353  /* EndOf SCMapCommands
2356  */
2357 
2363 void SinkCmd(unsigned char *data, int len)
2364 {
2365 }
2366 
2374 void TickCmd(guint8 *data, int len)
2375 {
2376  /* Up to the specific client to decide what to do */
2377  client_tick(GetInt_String(data));
2378 }
2379 
2388 void PickupCmd(guint8 *data, int len)
2389 {
2390  guint32 pickup = GetInt_String(data);
2391  client_pickup(pickup);
2392 }
2393 
2402 void FailureCmd(char *buf, int len)
2403 {
2404  char *cp;
2405 
2406  /* The format of the buffer is 'command error message'. We need to
2407  * extract the failed command, and then pass in the error message to the
2408  * appropriate handler. So find the space, set it to null. in that way,
2409  * buf is now just the failure command, and cp is the message.
2410  */
2411  cp = strchr(buf,' ');
2412  if (!cp) {
2413  return;
2414  }
2415 
2416  *cp = 0;
2417  cp++;
2418 
2419  if (!strcmp(buf,"accountlogin")) {
2421  } else if (!strcmp(buf,"accountnew")) {
2423  } else if (!strcmp(buf,"accountaddplayer")) {
2425  } else if (!strcmp(buf,"createplayer")) {
2427  } else if (!strcmp(buf, "accountpw")) {
2429  } else
2430  /* This really is an error - if this happens it menas the server
2431  * failed to process a request that the client made - the client
2432  * should be able to handle failures for all request types it makes.
2433  * But this is also a problem in that it means that the server is
2434  * waiting for a correct response, and if we do not display anything,
2435  * the player is unlikely to know this.
2436  */
2437  LOG(LOG_ERROR, "common::FailureCmd", "Got a failure response we can not handle: %s:%s",
2438  buf, cp);
2439 }
2440 
2444 void AccountPlayersCmd(char *buf, int len) {
2445  int level, pos, flen, faceno;
2446  char name[MAX_BUF], class[MAX_BUF], race[MAX_BUF],
2447  face[MAX_BUF], party[MAX_BUF], map[MAX_BUF];
2448 
2449  /* This is called first so it can clear out the existing data store.
2450  */
2452 
2453  level=0;
2454  name[0]=0;
2455  class[0]=0;
2456  race[0]=0;
2457  face[0]=0;
2458  party[0]=0;
2459  map[0]=0;
2460  faceno=0;
2461 
2462  pos=1;
2463  while (pos < len) {
2464  flen = buf[pos];
2465  /* flen == 0 is to note that we got end of character data */
2466  if (flen == 0) {
2467  update_character_choose(name, class, race, face, party, map, level, faceno);
2468  /* Blank all the values - it is no sure thing that the next
2469  * character will fill all these in.
2470  */
2471  level=0;
2472  name[0]=0;
2473  class[0]=0;
2474  race[0]=0;
2475  face[0]=0;
2476  party[0]=0;
2477  map[0]=0;
2478  faceno=0;
2479  pos++;
2480  continue;
2481  }
2482  pos++;
2483  if ((pos +flen) > len || flen>=MAX_BUF) {
2484  LOG(LOG_ERROR,"commands.c:AccountPlayerCmd", "data overran buffer");
2485  return;
2486  }
2487  switch (buf[pos]) {
2488  case ACL_NAME:
2489  strncpy(name, buf + pos +1, flen-1);
2490  name[flen-1] = 0;
2491  break;
2492 
2493  case ACL_CLASS:
2494  strncpy(class, buf + pos +1, flen-1);
2495  class[flen-1] = 0;
2496  break;
2497 
2498  case ACL_RACE:
2499  strncpy(race, buf + pos +1, flen-1);
2500  race[flen-1] = 0;
2501  break;
2502 
2503  case ACL_FACE:
2504  strncpy(face, buf + pos +1, flen-1);
2505  face[flen-1] = 0;
2506  break;
2507 
2508  case ACL_PARTY:
2509  strncpy(party, buf + pos +1, flen-1);
2510  party[flen-1] = 0;
2511  break;
2512 
2513  case ACL_MAP:
2514  strncpy(map, buf + pos +1, flen-1);
2515  map[flen-1] = 0;
2516  break;
2517 
2518  case ACL_LEVEL:
2519  level = GetShort_String((unsigned char *)buf + pos + 1);
2520  break;
2521  case ACL_FACE_NUM:
2522  faceno = GetShort_String((unsigned char *)buf + pos + 1);
2523  break;
2524  }
2525  pos += flen;
2526  }
2527 }
2528 
float weight
Definition: item.h:61
void PickupCmd(guint8 *data, int len)
Definition: commands.c:2388
#define CS_STAT_AC
Definition: newclient.h:100
gint16 grace
Definition: client.h:266
void free_all_race_class_info(Race_Class_Info *data, int num_entries)
Definition: commands.c:420
#define ACL_CLASS
Definition: newclient.h:197
void DeleteItem(unsigned char *data, int len)
Definition: commands.c:1797
gint8 wc
Definition: client.h:259
void handle_query(char *data, int len)
Definition: commands.c:1542
int num_races
Definition: commands.c:87
char * news
Definition: commands.c:82
void SetupCmd(char *buf, int len)
Definition: commands.c:901
struct Stat_Mapping stat_mapping[NUM_NEW_CHAR_STATS]
Definition: commands.c:118
#define INFO_MAP_ARCH_NAME
Definition: newclient.h:673
gint32 weapon_sp
Definition: client.h:276
GSocketConnection * fd
Definition: client.h:120
int stat_maximum
Definition: commands.c:95
char ** value_arch
Definition: client.h:597
char * choice_desc
Definition: client.h:595
guint16 level
Definition: client.h:301
void mapdata_set_smooth(int x, int y, guint8 smooth, int layer)
Definition: mapdata.c:759
int num_values
Definition: client.h:596
gint16 use_config[CONFIG_NUMS]
Definition: init.c:40
#define CS_STAT_INT
Definition: newclient.h:92
void create_new_character_failure(char *message)
Definition: account.c:145
char * description
Definition: client.h:613
item * locate_item(gint32 tag)
Definition: item.c:300
#define UPD_ANIM
Definition: newclient.h:294
void DrawInfoCmd(char *data, int len)
Definition: commands.c:1213
void TickCmd(guint8 *data, int len)
Definition: commands.c:2374
void mapdata_set_check_space(int x, int y)
Definition: mapdata.c:681
void mapdata_clear_space(int x, int y)
Definition: mapdata.c:639
void set_weight_limit(guint32 wlim)
Definition: inventory.c:617
#define ACL_FACE_NUM
Definition: newclient.h:203
gint64 skill_exp[MAX_SKILL]
Definition: client.h:290
guint8 num_animations
Definition: client.h:100
char * motd
Definition: commands.c:82
void account_add_character_failure(char *message)
Definition: account.c:284
void choose_character_init(void)
Definition: account.c:423
#define UPD_SP_GRACE
Definition: newclient.h:300
#define EMI_SMOOTH
Definition: newclient.h:352
void reset_player_data()
Definition: init.c:226
guint16 inv_updated
Definition: item.h:76
#define ACL_LEVEL
Definition: newclient.h:199
void setTextManager(int type, ExtTextManager callback)
Definition: commands.c:1237
#define MAX_SKILL
Definition: client.h:84
void AddMeFail(char *data, int len)
Definition: commands.c:1096
gint16 maxsp
Definition: client.h:265
item * ob
Definition: client.h:336
short GetShort_String(const unsigned char *data)
Definition: newsocket.c:175
int stat_min
Definition: commands.c:94
Animations animations[MAXANIM]
Definition: commands.c:1141
struct item_struct * env
Definition: item.h:53
guint16 dam
Definition: client.h:305
#define NUM_STATS
Definition: commands.c:105
#define CS_STAT_SPEED
Definition: newclient.h:103
void account_change_password_failure(char *message)
Definition: account.c:1127
Warning that something might not work.
Definition: client.h:443
guint16 sp
Definition: client.h:303
guint8 smooth[MAXLAYERS]
Definition: mapdata.h:59
struct MapCell * mapdata_cell(int x, int y)
Definition: mapdata.c:116
gint32 speed
Definition: client.h:275
#define MAP2_TYPE_CLEAR
Definition: newclient.h:42
void mapdata_set_face_layer(int x, int y, gint16 face, int layer)
Definition: mapdata.c:821
guint16 mmapy
Definition: client.h:360
#define MSG_TYPE_CLIENT_QUERY
Definition: newclient.h:662
void ReplyInfoCmd(unsigned char *buf, int len)
Definition: commands.c:774
char * rules
Definition: commands.c:82
char GetChar_String(const unsigned char *data)
Definition: newsocket.c:133
void close_container(item *op)
Definition: inventory.c:571
#define CS_STAT_DEX
Definition: newclient.h:94
ClientSocket csocket
Definition: client.c:67
#define INFO_MAP_NAME
Definition: newclient.h:674
char * description
Definition: client.h:604
Face_Information face_info
Definition: image.c:169
static void get_starting_map_info(unsigned char *data, int len)
Definition: commands.c:172
#define MSG_TYPE_CLIENT
Definition: newclient.h:395
guint16 time
Definition: client.h:302
void MapExtendedCmd(unsigned char *data, int len)
Definition: commands.c:2248
Stats stats
Definition: client.h:349
#define NUM_NEW_CHAR_STATS
Definition: client.h:568
static int spellmon_level
Definition: commands.c:85
#define ACL_FACE
Definition: newclient.h:200
int mapupdatesent
Definition: commands.c:55
guint16 pmapx
Definition: client.h:361
#define CS_STAT_MAXSP
Definition: newclient.h:90
#define CS_STAT_WIS
Definition: newclient.h:93
#define INFO_MAP_DESCRIPTION
Definition: newclient.h:675
char ** value_desc
Definition: client.h:598
#define NDI_BLACK
Definition: newclient.h:221
guint8 usage
Definition: client.h:322
gint8 Con
Definition: client.h:254
void DeleteInventory(unsigned char *data, int len)
Definition: commands.c:1823
int type
Definition: client.h:48
#define CS_STAT_FLAGS
Definition: newclient.h:111
#define ACL_MAP
Definition: newclient.h:202
gint32 tag
Definition: item.h:59
guint8 * magicmap
Definition: client.h:363
guint32 nrof
Definition: item.h:60
char * skill_names[MAX_SKILL]
Definition: client.c:50
void mapdata_newmap(void)
Definition: mapdata.c:987
void FailureCmd(char *buf, int len)
Definition: commands.c:2402
#define MSG_TYPE_CLIENT_SERVER
Definition: newclient.h:660
void Item2Cmd(unsigned char *data, int len)
Definition: commands.c:1663
int stat_points
Definition: commands.c:93
#define CS_STAT_WEIGHT_LIM
Definition: newclient.h:112
guint64 * exp_table
Definition: client.c:62
#define EMI_HASMOREBITS
Definition: newclient.h:358
void addsmooth(guint16 face, guint16 smooth_face)
Definition: image.c:393
guint32 path
Definition: client.h:315
#define CS_STAT_EXP64
Definition: newclient.h:113
void map_scrollCmd(char *data, int len)
Definition: commands.c:2180
static int rc_compar(const Race_Class_Info *a, const Race_Class_Info *b)
Definition: commands.c:405
guint16 type
Definition: item.h:81
void mapdata_set_anim_layer(int x, int y, guint16 anim, guint8 anim_speed, int layer)
Definition: mapdata.c:852
void draw_stats(int redraw)
Definition: stats.c:554
#define CS_STAT_WC
Definition: newclient.h:99
void AccountPlayersCmd(char *buf, int len)
Definition: commands.c:2444
void LOG(LogLevel level, const char *origin, const char *format,...)
Definition: misc.c:111
void client_disconnect()
Definition: client.c:178
#define NDI_RED
Definition: newclient.h:224
char * public_name
Definition: client.h:612
guint32 resist_change
Definition: client.h:288
guint32 repelled
Definition: client.h:282
int ExtSmooth(unsigned char *data, int len, int x, int y, int layer)
Definition: commands.c:2210
void Map2Cmd(unsigned char *data, int len)
Definition: commands.c:2067
guint16 grace
Definition: client.h:304
void UpdspellCmd(unsigned char *data, int len)
Definition: commands.c:1949
void update_login_info(int type)
Definition: account.c:1178
gint8 ac
Definition: client.h:260
void SinkCmd(unsigned char *data, int len)
Definition: commands.c:2363
#define INFO_NEWS
Definition: client.h:632
void x_set_echo(void)
Definition: keys.c:1701
guint8 cs_value
Definition: client.h:578
#define CS_QUERY_YESNO
Definition: newclient.h:66
int num_classes
Definition: commands.c:90
TextManager * firstTextManager
Definition: commands.c:1230
static gboolean redraw(gpointer data)
Definition: main.c:111
void display_map_doneupdate(int redraw, int notice)
Definition: map.c:488
void NewmapCmd(unsigned char *data, int len)
Definition: commands.c:2041
void update_character_choose(const char *name, const char *class, const char *race, const char *face, const char *party, const char *map, int level, int faceno)
Definition: account.c:549
ExtTextManager callback
Definition: client.h:49
void new_char_window_update_info()
Definition: create_char.c:633
gint8 Str
Definition: client.h:252
guint8 speed
Definition: client.h:104
void SmoothCmd(unsigned char *data, int len)
Definition: commands.c:1193
void(* ExtTextManager)(int flag, int type, int subtype, char *message)
Definition: client.h:45
int num_rc_choice
Definition: client.h:606
void get_image_info(guint8 *data, int len)
Definition: image.c:706
#define ASSERT_LEN(function, curpos, buflen)
Definition: commands.c:76
void draw_message_window(int redraw)
Definition: stats.c:459
#define CS_STAT_RESIST_END
Definition: newclient.h:142
#define CS_STAT_LEVEL
Definition: newclient.h:98
guint8 rc_offset
Definition: client.h:579
#define UPD_SP_DAMAGE
Definition: newclient.h:301
void use_skill(int skill_id)
Definition: commands.c:1329
gint8 Wis
Definition: client.h:255
#define CS_STAT_WEAP_SP
Definition: newclient.h:105
guint16 mmapx
Definition: client.h:360
void item_actions(item *op)
Definition: commands.c:1642
gint8 level
Definition: client.h:261
void UpdateItemCmd(unsigned char *data, int len)
Definition: commands.c:1713
void mapdata_clear_old(int x, int y)
Definition: mapdata.c:793
Client_Player cpl
Definition: client.c:66
item * container
Definition: client.h:339
static const char *const short_stat_name[NUM_STATS]
Definition: commands.c:107
Race_Class_Info * races
Definition: commands.c:98
char * choice_name
Definition: client.h:594
guint16 was_open
Definition: item.h:75
static void get_new_char_info(unsigned char *data, int len)
Definition: commands.c:247
static void rstrip(char buf[static 1], size_t len)
Definition: commands.c:1842
#define CONFIG_MAPHEIGHT
Definition: client.h:204
guint8 need_resmooth
Definition: mapdata.h:63
static void get_skill_info(char *data, int len)
Definition: commands.c:732
void StatsCmd(unsigned char *data, int len)
Definition: commands.c:1354
#define CS_QUERY_SINGLECHAR
Definition: newclient.h:67
guint32 flagsval
Definition: item.h:80
gint8 Pow
Definition: client.h:258
char message[10000]
Definition: client.h:297
void update_item(int tag, int loc, char *name, int weight, int face, int flags, int anim, int animspeed, guint32 nrof, int type)
Definition: item.c:645
#define MAX_BUF
Definition: client.h:40
guint8 skill_number
Definition: client.h:309
void get_image_sums(char *data, int len)
Definition: image.c:802
#define INFO_MOTD
Definition: client.h:633
void AddspellCmd(unsigned char *data, int len)
Definition: commands.c:1864
#define CONFIG_CACHE
Definition: client.h:189
gint16 food
Definition: client.h:269
#define UPD_FLAGS
Definition: newclient.h:290
void free_all_starting_map_info()
Definition: commands.c:134
#define CS_STAT_CHA
Definition: newclient.h:96
gint8 Dex
Definition: client.h:253
guint32 tag
Definition: client.h:299
guint16 animation_id
Definition: item.h:63
void new_player(long tag, char *name, long weight, long face)
Definition: player.c:43
void account_creation_failure(char *message)
Definition: account.c:694
#define UPD_SP_MANA
Definition: newclient.h:299
gint64 GetInt64_String(const unsigned char *data)
Definition: newsocket.c:157
void client_tick(guint32 tick)
Definition: main.c:130
#define UPD_WEIGHT
Definition: newclient.h:291
guint16 pmapy
Definition: client.h:361
void send_reply(const char *text)
Definition: commands.c:1598
#define CS_STAT_SPELL_REPEL
Definition: newclient.h:115
#define CS_STAT_STR
Definition: newclient.h:91
static void get_race_info(unsigned char *data, int len)
Definition: commands.c:648
struct RC_Choice * rc_choice
Definition: client.h:607
guint8 anim_speed
Definition: item.h:64
#define CS_STAT_FOOD
Definition: newclient.h:104
char * arch_name
Definition: client.h:602
gint16 resists[30]
Definition: client.h:287
#define CS_STAT_EXP
Definition: newclient.h:97
#define FACE_IS_ANIM
Definition: newclient.h:321
bool mapdata_contains(int x, int y)
Definition: mapdata.c:123
int last_used_skills[MAX_SKILL+1]
Definition: client.c:55
void GoodbyeCmd(char *data, int len)
Definition: commands.c:1128
struct Spell_struct * next
Definition: client.h:295
int starting_map_number
Definition: commands.c:96
guint16 flags
Definition: client.h:286
#define UPD_ANIMSPEED
Definition: newclient.h:295
gint64 exp
Definition: client.h:268
gint32 face
Definition: client.h:319
static void get_class_info(unsigned char *data, int len)
Definition: commands.c:679
gint16 skill_level[MAX_SKILL]
Definition: client.h:289
void starting_map_update_info()
Definition: create_char.c:753
Warning that something definitely didn&#39;t work.
Definition: client.h:444
guint32 weight_limit
Definition: client.h:291
void script_lua_stats(void)
void AddMeSuccess(char *data, int len)
Definition: commands.c:1112
void client_pickup(guint32 pickup)
Definition: pickup.c:630
guint16 open
Definition: item.h:74
Spell * spelldata
Definition: client.h:350
gint16 dam
Definition: client.h:272
guint32 spells_updated
Definition: client.h:353
#define MAXLAYERS
Definition: mapdata.h:6
#define INFO_RULES
Definition: client.h:634
#define EMI_NOREDRAW
Definition: newclient.h:348
#define MAP2_TYPE_DARKNESS
Definition: newclient.h:43
void AnimCmd(unsigned char *data, int len)
Definition: commands.c:1148
char name[256]
Definition: client.h:296
void mapdata_scroll(int dx, int dy)
Definition: mapdata.c:914
guint16 flags
Definition: client.h:99
static void get_exp_info(const unsigned char *data, int len)
Definition: commands.c:705
#define UPD_NROF
Definition: newclient.h:296
#define CS_STAT_SP
Definition: newclient.h:89
void DrawExtInfoCmd(char *data, int len)
Definition: commands.c:1277
#define NUM_LAYERS
Definition: commands.c:2060
gint8 stat_adj[NUM_NEW_CHAR_STATS]
Definition: client.h:605
static ExtTextManager getTextManager(int type)
Definition: commands.c:1259
void start_login(int method)
Definition: account.c:1267
#define UPD_FACE
Definition: newclient.h:292
gint8 Int
Definition: client.h:257
struct TextManager * next
Definition: client.h:50
void hide_all_login_windows(void)
Definition: account.c:99
void PlayerCmd(unsigned char *data, int len)
Definition: commands.c:1615
gint16 sp
Definition: client.h:264
char * arch_name
Definition: client.h:611
void draw_ext_info(int orig_color, int type, int subtype, const char *message)
Definition: info.c:932
void remove_item_inventory(item *op)
Definition: item.c:393
#define MAP2_COORD_OFFSET
Definition: newclient.h:32
void DeleteSpell(unsigned char *data, int len)
Definition: commands.c:1987
static void process_race_class_info(unsigned char *data, int len, Race_Class_Info *rci)
Definition: commands.c:469
guint16 * faces
Definition: client.h:107
#define UPD_LOCATION
Definition: newclient.h:289
#define ACL_PARTY
Definition: newclient.h:201
#define CS_STAT_ARMOUR
Definition: newclient.h:102
guint8 speed_left
Definition: client.h:105
#define UPD_NAME
Definition: newclient.h:293
#define CS_STAT_DAM
Definition: newclient.h:101
#define CS_NUM_SKILLS
Definition: newclient.h:175
char * public_name
Definition: client.h:603
#define CS_STAT_TITLE
Definition: newclient.h:107
int used_classes
Definition: commands.c:91
Input_State input_state
Definition: client.h:341
char range[MAX_BUF]
Definition: client.h:352
Race_Class_Info * classes
Definition: commands.c:98
#define ACL_RACE
Definition: newclient.h:198
#define CS_STAT_SPELL_DENY
Definition: newclient.h:116
#define CS_STAT_HP
Definition: newclient.h:87
void draw_magic_map(void)
Definition: magicmap.c:24
gint16 maxhp
Definition: client.h:263
char title[MAX_BUF]
Definition: client.h:351
void resize_map_window(int x, int y)
Definition: map.c:371
int cs_print_string(GSocketConnection *fd, const char *str,...)
Definition: newsocket.c:248
int used_races
Definition: commands.c:88
#define MSG_TYPE_CLIENT_COMMAND
Definition: newclient.h:661
void open_container(item *op)
Definition: inventory.c:578
#define CS_STAT_RESIST_START
Definition: newclient.h:141
#define MAX_VIEW
Definition: mapdata.h:11
#define CS_QUERY_HIDEINPUT
Definition: newclient.h:68
gint16 hp
Definition: client.h:262
#define CS_STAT_POW
Definition: newclient.h:108
gint16 face
Definition: item.h:62
char requirements[256]
Definition: client.h:327
guint32 no_echo
Definition: client.h:358
#define CS_STAT_RANGE
Definition: newclient.h:106
#define MAXANIM
Definition: client.h:86
#define CS_STAT_MAXHP
Definition: newclient.h:88
void draw_prompt(const char *str)
Definition: keys.c:1710
void MagicMapCmd(unsigned char *data, int len)
Definition: commands.c:2310
Useful debugging information.
Definition: client.h:441
gint8 Cha
Definition: client.h:256
#define CS_STAT_CON
Definition: newclient.h:95
#define CS_STAT_SPELL_ATTUNE
Definition: newclient.h:114
int GetInt_String(const unsigned char *data)
Definition: newsocket.c:145
#define ACL_NAME
Definition: newclient.h:196
#define CS_STAT_MAXGRACE
Definition: newclient.h:110
void mapdata_set_size(int viewx, int viewy)
Definition: mapdata.c:619
guint16 exp_table_max
Definition: client.c:61
#define MAP2_LAYER_START
Definition: newclient.h:53
void account_login_failure(char *message)
Definition: account.c:870
Minor, non-harmful issues.
Definition: client.h:442
void show_main_client(void)
Definition: main.c:412
#define CS_STAT_SKILLINFO
Definition: newclient.h:168
void remove_item(item *op)
Definition: item.c:331
void mapdata_set_darkness(int x, int y, int darkness)
Definition: mapdata.c:736
PlayerPosition pl_pos
Definition: map.c:37
guint32 attuned
Definition: client.h:279
#define CS_STAT_GRACE
Definition: newclient.h:109
guint8 phase
Definition: client.h:106
#define CONFIG_MAPWIDTH
Definition: client.h:203
static item * map
Definition: item.c:28
Starting_Map_Info * starting_map_info
Definition: commands.c:99
char * skill
Definition: client.h:313
gint16 maxgrace
Definition: client.h:267
guint32 denied
Definition: client.h:285