Crossfire Client, Trunk  R20507
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 {
1068  LOG(LOG_INFO, "common::SetupCmd",
1069  "Got setup for a command we don't understand: %s %s",
1070  cmd, param);
1071  }
1072  }
1073 }
1074 
1083 void AddMeFail(char *data, int len)
1084 {
1085  (void)data; /* __UNUSED__ */
1086  (void)len; /* __UNUSED__ */
1087 
1088  LOG(LOG_INFO, "common::AddMeFail", "addme_failed received.");
1089  return;
1090 }
1091 
1099 void AddMeSuccess(char *data, int len)
1100 {
1101  (void)data; /* __UNUSED__ */
1102  (void)len; /* __UNUSED__ */
1103 
1105  LOG(LOG_DEBUG, "common::AddMeSuccess", "addme_success received.");
1106  return;
1107 }
1108 
1114 void GoodbyeCmd(char *data, int len)
1115 {
1116  (void)data; /* __UNUSED__ */
1117  (void)len; /* __UNUSED__ */
1118 
1119  /* This could probably be greatly improved - I am not sure if anything
1120  * needs to be saved here, but it should be possible to reconnect to the
1121  * server or a different server without having to rerun the client.
1122  */
1123  LOG(LOG_WARNING, "common::GoodbyeCmd", "Received goodbye command from server - exiting");
1124  exit(0);
1125 }
1126 
1128 
1134 void AnimCmd(unsigned char *data, int len)
1135 {
1136  short anum;
1137  int i, j;
1138 
1139  anum = GetShort_String(data);
1140  if (anum < 0 || anum > MAXANIM) {
1141  LOG(LOG_WARNING, "common::AnimCmd", "animation number invalid: %d", anum);
1142  return;
1143  }
1144 
1145  animations[anum].flags = GetShort_String(data+2);
1146  animations[anum].num_animations = (len-4)/2;
1147  if (animations[anum].num_animations < 1) {
1148  LOG(LOG_WARNING, "common::AnimCmd", "num animations invalid: %d",
1149  animations[anum].num_animations);
1150  return;
1151  }
1152  animations[anum].faces = g_malloc(sizeof(guint16)*animations[anum].num_animations);
1153  for (i = 4, j = 0; i < len; i += 2, j++) {
1154  animations[anum].faces[j] = GetShort_String(data+i);
1155  }
1156 
1157  if (j != animations[anum].num_animations) {
1158  LOG(LOG_WARNING, "common::AnimCmd",
1159  "Calculated animations does not equal stored animations? (%d!=%d)",
1160  j, animations[anum].num_animations);
1161  }
1162 
1163  animations[anum].speed = 0;
1164  animations[anum].speed_left = 0;
1165  animations[anum].phase = 0;
1166 
1167  LOG(LOG_DEBUG, "common::AnimCmd", "Received animation %d, %d faces", anum, animations[anum].num_animations);
1168 }
1169 
1179 void SmoothCmd(unsigned char *data, int len)
1180 {
1181  guint16 faceid;
1182  guint16 smoothing;
1183 
1184  /* len is unused. We should check that we don't have an invalid short
1185  * command. Hence, the compiler warning is valid.
1186  */
1187 
1188  faceid = GetShort_String(data);
1189  smoothing = GetShort_String(data+2);
1190  addsmooth(faceid, smoothing);
1191 }
1192 
1199 void DrawInfoCmd(char *data, int len)
1200 {
1201  int color = atoi(data);
1202  char *buf;
1203 
1204  (void)len; /* __UNUSED__ */
1205 
1206  buf = strchr(data, ' ');
1207  if (!buf) {
1208  LOG(LOG_WARNING, "common::DrawInfoCmd", "got no data");
1209  buf = "";
1210  } else {
1211  buf++;
1212  }
1214 }
1215 
1217 
1223 void setTextManager(int type, ExtTextManager callback)
1224 {
1225  TextManager *current = firstTextManager;
1226 
1227  while (current != NULL) {
1228  if (current->type == type) {
1229  current->callback = callback;
1230  return;
1231  }
1232  current = current->next;
1233  }
1234  current = g_malloc(sizeof(TextManager));
1235  current->type = type;
1236  current->callback = callback;
1237  current->next = firstTextManager;
1238  firstTextManager = current;
1239 }
1240 
1246 {
1247  TextManager *current = firstTextManager;
1248  while (current != NULL) {
1249  if (current->type == type) {
1250  return current->callback;
1251  }
1252  current = current->next;
1253  }
1254  return NULL;
1255 }
1256 
1263 void DrawExtInfoCmd(char *data, int len)
1264 {
1265  int color;
1266  int type, subtype;
1267  char *buf = data;
1268  int wordCount = 3;
1269  ExtTextManager fnct;
1270 
1271  while (wordCount > 0) {
1272  while (buf[0] == ' ') {
1273  buf++;
1274  }
1275  wordCount--;
1276  while (buf[0] != ' ') {
1277  if (buf[0] == '\0') {
1278  LOG(LOG_WARNING,
1279  "common::DrawExtInfoCmd", "Data is missing %d parameters %s",
1280  wordCount,
1281  data);
1282  return;
1283  } else {
1284  buf++;
1285  }
1286  }
1287  if (buf[0] == ' ') {
1288  buf++; /*remove trailing space to send clean data to callback */
1289  }
1290  }
1291  wordCount = sscanf(data, "%d %d %d", &color, &type, &subtype);
1292  if (wordCount != 3) {
1293  LOG(LOG_WARNING,
1294  "common::DrawExtInfoCmd", "Wrong parameters received. Could only parse %d out of 3 int in %s",
1295  wordCount,
1296  data);
1297  return;
1298  }
1299  fnct = getTextManager(type);
1300  if (fnct == NULL) {
1301  LOG(LOG_WARNING,
1302  "common::DrawExtInfoCmd", "Server send us a type %d but i can't find any callback for it",
1303  type);
1304  return;
1305  }
1306  fnct(color, type, subtype, buf);
1307 }
1308 
1315 void use_skill(int skill_id)
1316 {
1317  int i = 0;
1318  int next;
1319  int prev = last_used_skills[0];
1320 
1321  if(last_used_skills[0] == skill_id) {
1322  return;
1323  }
1324 
1325  do {
1326  next = last_used_skills[i+1];
1327  last_used_skills[i+1] = prev;
1328  prev = next;
1329  ++i;
1330  } while(next != skill_id && next >= 0);
1331  last_used_skills[0] = skill_id;
1332 }
1333 
1340 void StatsCmd(unsigned char *data, int len)
1341 {
1342  int i = 0, c, redraw = 0;
1343  gint64 last_exp;
1344 
1345  while (i < len) {
1346  c = data[i++];
1347  if (c >= CS_STAT_RESIST_START && c <= CS_STAT_RESIST_END) {
1349  i += 2;
1350  cpl.stats.resist_change = 1;
1351  } else if (c >= CS_STAT_SKILLINFO && c < (CS_STAT_SKILLINFO+CS_NUM_SKILLS)) {
1352  /* We track to see if the exp has gone from 0 to some total value
1353  * - we do this because the draw logic currently only draws skills
1354  * where the player has exp. We need to communicate to the draw
1355  * function that it should draw all the players skills. Using
1356  * redraw is a little overkill, because a lot of the data may not
1357  * be changing. OTOH, such a transition should only happen
1358  * rarely, not not be a very big deal.
1359  */
1360  cpl.stats.skill_level[c-CS_STAT_SKILLINFO] = data[i++];
1361  last_exp = cpl.stats.skill_exp[c-CS_STAT_SKILLINFO];
1364  if (last_exp == 0 && cpl.stats.skill_exp[c-CS_STAT_SKILLINFO]) {
1365  redraw = 1;
1366  }
1367  i += 8;
1368  } else {
1369  switch (c) {
1370  case CS_STAT_HP:
1371  cpl.stats.hp = GetShort_String(data+i);
1372  i += 2;
1373  break;
1374  case CS_STAT_MAXHP:
1375  cpl.stats.maxhp = GetShort_String(data+i);
1376  i += 2;
1377  break;
1378  case CS_STAT_SP:
1379  cpl.stats.sp = GetShort_String(data+i);
1380  i += 2;
1381  break;
1382  case CS_STAT_MAXSP:
1383  cpl.stats.maxsp = GetShort_String(data+i);
1384  i += 2;
1385  break;
1386  case CS_STAT_GRACE:
1387  cpl.stats.grace = GetShort_String(data+i);
1388  i += 2;
1389  break;
1390  case CS_STAT_MAXGRACE:
1391  cpl.stats.maxgrace = GetShort_String(data+i);
1392  i += 2;
1393  break;
1394  case CS_STAT_STR:
1395  cpl.stats.Str = GetShort_String(data+i);
1396  i += 2;
1397  break;
1398  case CS_STAT_INT:
1399  cpl.stats.Int = GetShort_String(data+i);
1400  i += 2;
1401  break;
1402  case CS_STAT_POW:
1403  cpl.stats.Pow = GetShort_String(data+i);
1404  i += 2;
1405  break;
1406  case CS_STAT_WIS:
1407  cpl.stats.Wis = GetShort_String(data+i);
1408  i += 2;
1409  break;
1410  case CS_STAT_DEX:
1411  cpl.stats.Dex = GetShort_String(data+i);
1412  i += 2;
1413  break;
1414  case CS_STAT_CON:
1415  cpl.stats.Con = GetShort_String(data+i);
1416  i += 2;
1417  break;
1418  case CS_STAT_CHA:
1419  cpl.stats.Cha = GetShort_String(data+i);
1420  i += 2;
1421  break;
1422  case CS_STAT_EXP:
1423  cpl.stats.exp = GetInt_String(data+i);
1424  i += 4;
1425  break;
1426  case CS_STAT_EXP64:
1427  cpl.stats.exp = GetInt64_String(data+i);
1428  i += 8;
1429  break;
1430  case CS_STAT_LEVEL:
1431  cpl.stats.level = GetShort_String(data+i);
1432  i += 2;
1433  break;
1434  case CS_STAT_WC:
1435  cpl.stats.wc = GetShort_String(data+i);
1436  i += 2;
1437  break;
1438  case CS_STAT_AC:
1439  cpl.stats.ac = GetShort_String(data+i);
1440  i += 2;
1441  break;
1442  case CS_STAT_DAM:
1443  cpl.stats.dam = GetShort_String(data+i);
1444  i += 2;
1445  break;
1446  case CS_STAT_ARMOUR:
1447  cpl.stats.resists[0] = GetShort_String(data+i);
1448  i += 2;
1449  break;
1450  case CS_STAT_SPEED:
1451  cpl.stats.speed = GetInt_String(data+i);
1452  i += 4;
1453  break;
1454  case CS_STAT_FOOD:
1455  cpl.stats.food = GetShort_String(data+i);
1456  i += 2;
1457  break;
1458  case CS_STAT_WEAP_SP:
1459  cpl.stats.weapon_sp = GetInt_String(data+i);
1460  i += 4;
1461  break;
1462  case CS_STAT_SPELL_ATTUNE:
1463  cpl.stats.attuned = GetInt_String(data+i);
1464  i += 4;
1465  cpl.spells_updated = 1;
1466  break;
1467  case CS_STAT_SPELL_REPEL:
1468  cpl.stats.repelled = GetInt_String(data+i);
1469  i += 4;
1470  cpl.spells_updated = 1;
1471  break;
1472  case CS_STAT_SPELL_DENY:
1473  cpl.stats.denied = GetInt_String(data+i);
1474  i += 4;
1475  cpl.spells_updated = 1;
1476  break;
1477 
1478  case CS_STAT_FLAGS:
1479  cpl.stats.flags = GetShort_String(data+i);
1480  i += 2;
1481  break;
1482  case CS_STAT_WEIGHT_LIM:
1484  i += 4;
1485  /* Mark weight limit changes to update the client inventory window */
1486  cpl.ob->inv_updated = 1;
1487  break;
1488 
1489  case CS_STAT_RANGE: {
1490  int rlen = data[i++];
1491  strncpy(cpl.range, (const char*)data+i, rlen);
1492  cpl.range[rlen] = '\0';
1493  i += rlen;
1494  break;
1495  }
1496 
1497  case CS_STAT_TITLE: {
1498  int rlen = data[i++];
1499  strncpy(cpl.title, (const char*)data+i, rlen);
1500  cpl.title[rlen] = '\0';
1501  i += rlen;
1502  break;
1503  }
1504 
1505  default:
1506  LOG(LOG_WARNING, "common::StatsCmd", "Unknown stat number %d", c);
1507  break;
1508  }
1509  }
1510  }
1511 
1512  if (i > len) {
1513  LOG(LOG_WARNING, "common::StatsCmd", "got stats overflow, processed %d bytes out of %d", i, len);
1514  }
1515  draw_stats(redraw);
1517 #ifdef HAVE_LUA
1518  script_lua_stats();
1519 #endif
1520 }
1521 
1528 void handle_query(char *data, int len)
1529 {
1530  char *buf, *cp;
1531  guint8 flags = atoi(data);
1532 
1533  (void)len; /* __UNUSED__ */
1534 
1535  if (flags&CS_QUERY_HIDEINPUT) { /* No echo */
1536  cpl.no_echo = 1;
1537  } else {
1538  cpl.no_echo = 0;
1539  }
1540 
1541  /* Let the window system know this may have changed */
1542  x_set_echo();
1543 
1544  /* The actual text is optional */
1545  buf = strchr(data, ' ');
1546  if (buf) {
1547  buf++;
1548  }
1549 
1550  /* If we just get passed an empty string, why draw this? */
1551  if (buf) {
1552  cp = buf;
1553  while ((buf = strchr(buf, '\n')) != NULL) {
1554  *buf++ = '\0';
1555  draw_ext_info(
1557  cp = buf;
1558  }
1559  /* Yes/no - don't do anything with it now */
1560  if (flags&CS_QUERY_YESNO) {
1561  }
1562 
1563  /* One character response expected */
1564  if (flags&CS_QUERY_SINGLECHAR) {
1566  } else {
1568  }
1569 
1570  if (cp) {
1571  draw_prompt(cp);
1572  }
1573  }
1574 
1575  LOG(LOG_DEBUG, "common::handle_query", "Received query. Input state now %d", cpl.input_state);
1576 }
1577 
1584 void send_reply(const char *text)
1585 {
1586  cs_print_string(csocket.fd, "reply %s", text);
1587 
1588  /* Let the window system know that the (possibly hidden) query is over. */
1589  cpl.no_echo = 0;
1590  x_set_echo();
1591 }
1592 
1601 void PlayerCmd(unsigned char *data, int len)
1602 {
1603  char name[MAX_BUF];
1604  int tag, weight, face, i = 0, nlen;
1605 
1607  tag = GetInt_String(data);
1608  i += 4;
1609  weight = GetInt_String(data+i);
1610  i += 4;
1611  face = GetInt_String(data+i);
1612  i += 4;
1613  nlen = data[i++];
1614  memcpy(name, (const char*)data+i, nlen);
1615  name[nlen] = '\0';
1616  i += nlen;
1617 
1618  if (i != len) {
1619  LOG(LOG_WARNING, "common::PlayerCmd", "lengths do not match (%d!=%d)", len, i);
1620  }
1621  new_player(tag, name, weight, face);
1622 }
1623 
1629 {
1630  if (!op) {
1631  return;
1632  }
1633 
1634  if (op->open) {
1635  open_container(op);
1636  cpl.container = op;
1637  } else if (op->was_open) {
1638  close_container(op);
1639  cpl.container = NULL;
1640  }
1641 }
1642 
1650 static void common_item_command(guint8 *data, int len)
1651 {
1652 
1653  int weight, loc, tag, face, flags, pos = 0, nlen, anim, nrof, type;
1654  guint8 animspeed;
1655  char name[MAX_BUF];
1656 
1657  loc = GetInt_String(data);
1658  pos += 4;
1659 
1660  if (pos == len) {
1661  LOG(LOG_WARNING, "common::common_item_command", "Got location with no other data");
1662  return;
1663  } else if (loc < 0) { /* Delete following items */
1664  LOG(LOG_WARNING, "common::common_item_command", "Got location with negative value (%d)", loc);
1665  return;
1666  } else {
1667  while (pos < len) {
1668  tag = GetInt_String(data+pos);
1669  pos += 4;
1670  flags = GetInt_String(data+pos);
1671  pos += 4;
1672  weight = GetInt_String(data+pos);
1673  pos += 4;
1674  face = GetInt_String(data+pos);
1675  pos += 4;
1676  nlen = data[pos++];
1677  memcpy(name, (char*)data+pos, nlen);
1678  pos += nlen;
1679  name[nlen] = '\0';
1680  anim = GetShort_String(data+pos);
1681  pos += 2;
1682  animspeed = data[pos++];
1683  nrof = GetInt_String(data+pos);
1684  pos += 4;
1685  type = GetShort_String(data+pos);
1686  pos += 2;
1687  update_item(tag, loc, name, weight, face, flags, anim, animspeed, nrof, type);
1688  item_actions(locate_item(tag));
1689  }
1690  if (pos > len) {
1691  LOG(LOG_WARNING, "common::common_item_cmd", "Overread buffer: %d > %d", pos, len);
1692  }
1693  }
1694 }
1695 
1701 void Item2Cmd(unsigned char *data, int len)
1702 {
1703  common_item_command(data, len);
1704 }
1705 
1712 void UpdateItemCmd(unsigned char *data, int len)
1713 {
1714  int weight, loc, tag, face, sendflags, flags, pos = 0, nlen, anim;
1715  guint32 nrof;
1716  char name[MAX_BUF];
1717  item *ip;
1718  guint8 animspeed;
1719 
1720  sendflags = data[0];
1721  pos += 1;
1722  tag = GetInt_String(data+pos);
1723  pos += 4;
1724  ip = locate_item(tag);
1725  if (!ip) {
1726  /*
1727  fprintf(stderr, "Got update_item command for item we don't have (%d)\n", tag);
1728  */
1729  return;
1730  }
1731 
1732  /* Copy all of these so we can pass the values to update_item and don't
1733  * need to figure out which ones were modified by this function.
1734  */
1735  *name = '\0';
1736  loc = ip->env ? ip->env->tag : 0;
1737  weight = ip->weight*1000;
1738  face = ip->face;
1739  flags = ip->flagsval;
1740  anim = ip->animation_id;
1741  animspeed = ip->anim_speed;
1742  nrof = ip->nrof;
1743 
1744  if (sendflags&UPD_LOCATION) {
1745  loc = GetInt_String(data+pos);
1746  LOG(LOG_WARNING, "common::UpdateItemCmd", "Got tag of unknown object (%d) for new location", loc);
1747  pos += 4;
1748  }
1749  if (sendflags&UPD_FLAGS) {
1750  flags = GetInt_String(data+pos);
1751  pos += 4;
1752  }
1753  if (sendflags&UPD_WEIGHT) {
1754  weight = GetInt_String(data+pos);
1755  pos += 4;
1756  }
1757  if (sendflags&UPD_FACE) {
1758  face = GetInt_String(data+pos);
1759  pos += 4;
1760  }
1761  if (sendflags&UPD_NAME) {
1762  nlen = data[pos++];
1763  memcpy(name, (char*)data+pos, nlen);
1764  pos += nlen;
1765  name[nlen] = '\0';
1766  }
1767  if (pos > len) {
1768  LOG(LOG_WARNING, "common::UpdateItemCmd", "Overread buffer: %d > %d", pos, len);
1769  return; /* We have bad data, probably don't want to store it then */
1770  }
1771  if (sendflags&UPD_ANIM) {
1772  anim = GetShort_String(data+pos);
1773  pos += 2;
1774  }
1775  if (sendflags&UPD_ANIMSPEED) {
1776  animspeed = data[pos++];
1777  }
1778  if (sendflags&UPD_NROF) {
1779  nrof = (guint32)GetInt_String(data+pos);
1780  pos += 4;
1781  }
1782  /* update_item calls set_item_values which will then set the list redraw
1783  * flag, so we don't need to do an explicit redraw here. Actually,
1784  * calling update_item is a little bit of overkill, since we already
1785  * determined some of the values in this function.
1786  */
1787  update_item(tag, loc, name, weight, face, flags, anim, animspeed, nrof, ip->type);
1788  item_actions(locate_item(tag));
1789 }
1790 
1796 void DeleteItem(unsigned char *data, int len)
1797 {
1798  int pos = 0, tag;
1799 
1800  while (pos < len) {
1801  item *op;
1802 
1803  tag = GetInt_String(data+pos);
1804  pos += 4;
1805  op = locate_item(tag);
1806  if (op != NULL) {
1807  remove_item(op);
1808  } else {
1809  LOG(LOG_WARNING, "common::DeleteItem", "Cannot find tag %d", tag);
1810  }
1811  }
1812  if (pos > len) {
1813  LOG(LOG_WARNING, "common::DeleteItem", "Overread buffer: %d > %d", pos, len);
1814  }
1815 }
1816 
1822 void DeleteInventory(unsigned char *data, int len)
1823 {
1824  int tag;
1825  item *op;
1826 
1827  (void)len; /* __UNUSED__ */
1828 
1829  tag = atoi((const char*)data);
1830  op = locate_item(tag);
1831  if (op != NULL) {
1833  } else {
1834  LOG(LOG_WARNING, "common::DeleteInventory", "Invalid tag: %d", tag);
1835  }
1836 }
1837 
1838 /****************************************************************************/
1839 
1850 void AddspellCmd(unsigned char *data, int len)
1851 {
1852  guint8 nlen;
1853  guint16 mlen, pos = 0;
1854  Spell *newspell, *tmp;
1855 
1856  while (pos < len) {
1857  newspell = calloc(1, sizeof(Spell));
1858 
1859  /* Get standard spell information (spellmon 1)
1860  */
1861  newspell->tag = GetInt_String(data+pos);
1862  pos += 4;
1863  newspell->level = GetShort_String(data+pos);
1864  pos += 2;
1865  newspell->time = GetShort_String(data+pos);
1866  pos += 2;
1867  newspell->sp = GetShort_String(data+pos);
1868  pos += 2;
1869  newspell->grace = GetShort_String(data+pos);
1870  pos += 2;
1871  newspell->dam = GetShort_String(data+pos);
1872  pos += 2;
1873  newspell->skill_number = GetChar_String(data+pos);
1874  pos += 1;
1875  newspell->path = GetInt_String(data+pos);
1876  pos += 4;
1877  newspell->face = GetInt_String(data+pos);
1878  pos += 4;
1879  nlen = GetChar_String(data+pos);
1880  pos += 1;
1881  strncpy(newspell->name, (char*)data+pos, nlen);
1882  pos += nlen;
1883  newspell->name[nlen] = '\0'; /* To ensure we are null terminated */
1884  mlen = GetShort_String(data+pos);
1885  pos += 2;
1886  strncpy(newspell->message, (char*)data+pos, mlen);
1887  pos += mlen;
1888  newspell->message[mlen] = '\0'; /* To ensure we are null terminated */
1889 
1890  if (spellmon_level < 2) {
1891 
1892  /* The server is not sending spellmon 2 extended information, so
1893  * initialize the spell data fields as unused/empty.
1894  */
1895  newspell->usage = 0;
1896  newspell->requirements[0] = '\0';
1897 
1898  } else if (pos < len) {
1899 
1900  /* The server is sending extended spell information (spellmon 2) so
1901  * process it.
1902  */
1903  newspell->usage = GetChar_String(data+pos);
1904  pos += 1;
1905  nlen = GetChar_String(data+pos);
1906  pos += 1;
1907  strncpy(newspell->requirements, (char*) data+pos, nlen);
1908  pos += nlen;
1909  newspell->requirements[nlen] = '\0'; /* Ensure null-termination */
1910  }
1911 
1912  /* Compute the derived spell information.
1913  */
1914  newspell->skill = skill_names[newspell->skill_number-CS_STAT_SKILLINFO];
1915 
1916  /* Add the spell to the player struct.
1917  */
1918  if (!cpl.spelldata) {
1919  cpl.spelldata = newspell;
1920  } else {
1921  for (tmp = cpl.spelldata; tmp->next; tmp = tmp->next)
1922  ;
1923  tmp->next = newspell;
1924  }
1925  /* Check to see if there are more spells to add.
1926  */
1927  }
1928  if (pos > len) {
1929  LOG(LOG_WARNING, "common::AddspellCmd", "Overread buffer: %d > %d", pos, len);
1930  }
1931  cpl.spells_updated = 1;
1932 }
1933 
1934 void UpdspellCmd(unsigned char *data, int len) {
1935  int flags, pos = 0;
1936  guint32 tag;
1937  Spell *tmp;
1938 
1939  if (!cpl.spelldata) {
1940  LOG(LOG_WARNING, "common::UpdspellCmd", "I know no spells to update");
1941  return;
1942  }
1943 
1944  flags = GetChar_String(data+pos);
1945  pos += 1;
1946  tag = GetInt_String(data+pos);
1947  pos += 4;
1948  for (tmp = cpl.spelldata; tmp && tmp->tag != tag; tmp = tmp->next)
1949  ;
1950  if (!tmp) {
1951  LOG(LOG_WARNING, "common::UpdspellCmd", "Invalid tag: %d", tag);
1952  return;
1953  }
1954  if (flags&UPD_SP_MANA) {
1955  tmp->sp = GetShort_String(data+pos);
1956  pos += 2;
1957  }
1958  if (flags&UPD_SP_GRACE) {
1959  tmp->grace = GetShort_String(data+pos);
1960  pos += 2;
1961  }
1962  if (flags&UPD_SP_DAMAGE) {
1963  tmp->dam = GetShort_String(data+pos);
1964  pos += 2;
1965  }
1966  if (pos > len) {
1967  LOG(LOG_WARNING, "common::UpdspellCmd", "Overread buffer: %d > %d", pos, len);
1968  }
1969  cpl.spells_updated = 1;
1970 }
1971 
1972 void DeleteSpell(unsigned char *data, int len) {
1973  guint32 tag;
1974  Spell *tmp, *target;
1975 
1976  if (!cpl.spelldata) {
1977  LOG(LOG_WARNING, "common::DeleteSpell", "I know no spells to delete");
1978  return;
1979  }
1980 
1981  tag = GetInt_String(data);
1982  /* Special case: the first spell is the one removed */
1983  if (cpl.spelldata->tag == tag) {
1984  target = cpl.spelldata;
1985  if (target->next) {
1986  cpl.spelldata = target->next;
1987  } else {
1988  cpl.spelldata = NULL;
1989  }
1990  free(target);
1991  return;
1992  }
1993 
1994  for (tmp = cpl.spelldata; tmp->next && tmp->next->tag != tag; tmp = tmp->next)
1995  ;
1996  if (!tmp->next) {
1997  LOG(LOG_WARNING, "common::DeleteSpell", "Invalid tag: %d", tag);
1998  return;
1999  }
2000  target = tmp->next;
2001  if (target->next) {
2002  tmp->next = target->next;
2003  } else {
2004  tmp->next = NULL;
2005  }
2006  free(target);
2007  cpl.spells_updated = 1;
2008 }
2009 
2010 /****************************************************************************/
2011  /* EndOf SCSpellCommands
2014  */
2015 
2026 void NewmapCmd(unsigned char *data, int len)
2027 {
2028  (void)data; /* __UNUSED__ */
2029  (void)len; /* __UNUSED__ */
2030 
2031  mapdata_newmap();
2032 }
2033 
2034 /* This is the common processing block for the map1 and map1a protocol
2035  * commands. The map1a mieks minor extensions and are easy to deal with
2036  * inline (in fact, this code doesn't even care what rev is - just certain
2037  * bits will only bet set when using the map1a command. rev is 0 for map1, 1
2038  * for map1a. It conceivable that there could be future revisions.
2039  */
2040 
2041 /* NUM_LAYERS should only be used for the map1{a} which only has a few layers.
2042  * Map2 has 10 layers. However, some of the map1 logic requires this to be
2043  * set right.
2044  */
2045 #define NUM_LAYERS (MAP1_LAYERS-1)
2046 
2052 void Map2Cmd(unsigned char *data, int len)
2053 {
2054  int mask, x, y, pos = 0, space_len, value;
2055  guint8 type;
2056 
2057  /* Not really using map1 protocol, but some draw logic differs from the
2058  * original draw logic, and map2 is closest.
2059  */
2060  while (pos < len) {
2061  mask = GetShort_String(data+pos);
2062  pos += 2;
2063  x = ((mask>>10)&0x3f)-MAP2_COORD_OFFSET;
2064  y = ((mask>>4)&0x3f)-MAP2_COORD_OFFSET;
2065 
2066  /* This is a scroll then. Go back and fetch another coordinate */
2067  if (mask&0x1) {
2068  mapdata_scroll(x, y);
2069  continue;
2070  }
2071 
2072  if (x<0) {
2073  LOG(LOG_WARNING, "commands.c::Map2Cmd", "got negative x!");
2074  x = 0;
2075  } else if (x >= MAX_VIEW) {
2076  LOG(LOG_WARNING, "commands.c::Map2Cmd", "got x >= MAX_VIEW!");
2077  x = MAX_VIEW - 1;
2078  }
2079 
2080  if (y<0) {
2081  LOG(LOG_WARNING, "commands.c::Map2Cmd", "got negative y!");
2082  y = 0;
2083  } else if (y >= MAX_VIEW) {
2084  LOG(LOG_WARNING, "commands.c::Map2Cmd", "got y >= MAX_VIEW!");
2085  y = MAX_VIEW - 1;
2086  }
2087 
2088  assert(0 <= x && x < MAX_VIEW);
2089  assert(0 <= y && y < MAX_VIEW);
2090  /* Clearing old cell data as needed (was in mapdata_set_face_layer()
2091  * before however that caused darkness to only work if sent after the
2092  * layers).
2093  */
2094  mapdata_clear_old(x, y);
2095 
2096  /* Inner loop is for the data on the space itself */
2097  while (pos < len) {
2098  type = data[pos++];
2099  /* type == 255 means nothing more for this space */
2100  if (type == 255) {
2102  break;
2103  }
2104  space_len = type>>5;
2105  type &= 0x1f;
2106  /* Clear the space */
2107  if (type == MAP2_TYPE_CLEAR) {
2108  mapdata_clear_space(x, y);
2109  continue;
2110  } else if (type == MAP2_TYPE_DARKNESS) {
2111  value = data[pos++];
2112  mapdata_set_darkness(x, y, value);
2113  continue;
2114  } else if (type >= MAP2_LAYER_START && type < MAP2_LAYER_START+MAXLAYERS) {
2115  int layer, opt;
2116 
2117  /* This is face information for a layer. */
2118  layer = type&0xf;
2119 
2120  if (layer < 0) {
2121  LOG(LOG_WARNING, "commands.c::Map2Cmd", "got negative layer!");
2122  layer = 0;
2123  } else if (layer >= MAXLAYERS) {
2124  LOG(LOG_WARNING, "commands.c::Map2Cmd", "got layer >= MAXLAYERS!");
2125  layer = MAXLAYERS - 1;
2126  }
2127  assert(0 <= layer && layer < MAXLAYERS);
2128 
2129  /* This is the face */
2130  value = GetShort_String(data+pos);
2131  pos += 2;
2132  if (!(value&FACE_IS_ANIM)) {
2133  mapdata_set_face_layer(x, y, value, layer);
2134  }
2135 
2136  if (space_len > 2) {
2137  opt = data[pos++];
2138  if (value&FACE_IS_ANIM) {
2139  /* Animation speed */
2140  mapdata_set_anim_layer(x, y, value, opt, layer);
2141  } else {
2142  /* Smooth info */
2143  mapdata_set_smooth(x, y, opt, layer);
2144  }
2145  }
2146  /* Currently, if 4 bytes, must be a smooth byte */
2147  if (space_len > 3) {
2148  opt = data[pos++];
2149  mapdata_set_smooth(x, y, opt, layer);
2150  }
2151  continue;
2152  } /* if image layer */
2153  } /* while pos<len inner loop for space */
2154  } /* While pos<len outer loop */
2155  mapupdatesent = 0;
2156  display_map_doneupdate(FALSE, FALSE);
2157 }
2158 
2165 void map_scrollCmd(char *data, int len)
2166 {
2167  int dx, dy;
2168  char *buf;
2169 
2170  (void)len; /* __UNUSED__ */
2171 
2172  dx = atoi(data);
2173  buf = strchr(data, ' ');
2174  if (!buf) {
2175  LOG(LOG_WARNING, "common::map_scrollCmd", "Got short packet.");
2176  return;
2177  }
2178  buf++;
2179  dy = atoi(buf);
2180 
2181  mapdata_scroll(dx, dy);
2182  display_map_doneupdate(FALSE, TRUE);
2183 }
2184 
2195 int ExtSmooth(unsigned char *data, int len, int x, int y, int layer)
2196 {
2197  static int dx[8] = { 0, 1, 1, 1, 0, -1, -1, -1, };
2198  static int dy[8] = { -1, -1, 0, 1, 1, 1, 0, -1, };
2199  int i, rx, ry;
2200  int newsm;
2201 
2202  if (len < 1) {
2203  return 0;
2204  }
2205 
2206  x += pl_pos.x;
2207  y += pl_pos.y;
2208  newsm = GetChar_String(data);
2209 
2210  if (mapdata_cell(x, y)->smooth[layer] != newsm) {
2211  for (i = 0; i < 8; i++) {
2212  rx = x+dx[i];
2213  ry = y+dy[i];
2214  if (!mapdata_contains(rx, ry)) {
2215  continue;
2216  }
2217  mapdata_cell(x, y)->need_resmooth = 1;
2218  }
2219  }
2220  mapdata_cell(x, y)->smooth[layer] = newsm;
2221  return 1;/*Cause smooth infos only use 1 byte*/
2222 }
2223 
2233 void MapExtendedCmd(unsigned char *data, int len)
2234 {
2235  int mask, x, y, pos = 0, layer;
2236  int noredraw = 0;
2237  int hassmooth = 0;
2238  int entrysize;
2239  int startpackentry;
2240 
2241  mapupdatesent = 1;
2242  mask = GetChar_String(data+pos);
2243  pos += 1;
2244  if (mask&EMI_NOREDRAW) {
2245  noredraw = 1;
2246  }
2247  if (mask&EMI_SMOOTH) {
2248  hassmooth = 1;
2249  }
2250  while (mask&EMI_HASMOREBITS) {
2251  /*There may be bits we ignore about*/
2252  mask = GetChar_String(data+pos);
2253  pos += 1;
2254  }
2255  entrysize = GetChar_String(data+pos);
2256  pos = pos+1;
2257 
2258  while (pos+entrysize+2 <= len) {
2259  mask = GetShort_String(data+pos);
2260  pos += 2;
2261  x = (mask>>10)&0x3f;
2262  y = (mask>>4)&0x3f;
2263  for (layer = NUM_LAYERS; layer >= 0; layer--) {
2264  if (mask&(1<<layer)) {
2265  /*handle an entry*/
2266  if (pos+entrysize > len) { /*erroneous packet*/
2267  break;
2268  }
2269  startpackentry = pos;
2270  /* If you had extended infos to the server, this is where, in
2271  * the client, you may add your code
2272  */
2273  if (hassmooth) {
2274  pos = pos+ExtSmooth(data+pos, len-pos, x, y, NUM_LAYERS-layer);
2275  }
2276  /* Continue with other if you add new extended infos to server
2277  *
2278  * Now point to the next data
2279  */
2280  pos = startpackentry+entrysize;
2281  }
2282  }
2283  }
2284  if (!noredraw) {
2285  display_map_doneupdate(FALSE, FALSE);
2286  mapupdatesent = 0;
2287  }
2288 }
2289 
2295 void MagicMapCmd(unsigned char *data, int len)
2296 {
2297  unsigned char *cp;
2298  int i;
2299 
2300  /* First, extract the size/position information. */
2301  if (sscanf((const char*)data, "%hd %hd %hd %hd", &cpl.mmapx, &cpl.mmapy, &cpl.pmapx, &cpl.pmapy) != 4) {
2302  LOG(LOG_WARNING, "common::MagicMapCmd", "Was not able to properly extract magic map size, pos");
2303  return;
2304  }
2305 
2306  if (cpl.mmapx == 0 || cpl.mmapy == 0) {
2307  LOG(LOG_WARNING, "common::MagicMapCmd", "empty map");
2308  return;
2309  }
2310 
2311  /* Now we need to find the start of the actual data. There are 4 space
2312  * characters we need to skip over.
2313  */
2314  for (cp = data, i = 0; i < 4 && cp < data+len; cp++) {
2315  if (*cp == ' ') {
2316  i++;
2317  }
2318  }
2319  if (i != 4) {
2320  LOG(LOG_WARNING, "common::MagicMapCmd", "Was unable to find start of magic map data");
2321  return;
2322  }
2323  i = len-(cp-data); /* This should be the number of bytes left */
2324  if (i != cpl.mmapx*cpl.mmapy) {
2325  LOG(LOG_WARNING, "common::MagicMapCmd", "Magic map size mismatch. Have %d bytes, should have %d",
2326  i, cpl.mmapx*cpl.mmapy);
2327  return;
2328  }
2329  free(cpl.magicmap);
2330  cpl.magicmap = g_malloc(cpl.mmapx*cpl.mmapy);
2331  /* Order the server puts it in should be just fine. Note that the only
2332  * requirement that this works is that magicmap by 8 bits, being that is
2333  * the size specified in the protocol and what the server sends us.
2334  */
2335  memcpy(cpl.magicmap, cp, cpl.mmapx*cpl.mmapy);
2336  draw_magic_map();
2337 }
2338  /* EndOf SCMapCommands
2341  */
2342 
2348 void SinkCmd(unsigned char *data, int len)
2349 {
2350 }
2351 
2359 void TickCmd(guint8 *data, int len)
2360 {
2361 
2362  tick = GetInt_String(data);
2363 
2364  /* Up to the specific client to decide what to do */
2365  client_tick(tick);
2366 }
2367 
2376 void PickupCmd(guint8 *data, int len)
2377 {
2378  guint32 pickup = GetInt_String(data);
2379  client_pickup(pickup);
2380 }
2381 
2390 void FailureCmd(char *buf, int len)
2391 {
2392  char *cp;
2393 
2394  /* The format of the buffer is 'command error message'. We need to
2395  * extract the failed command, and then pass in the error message to the
2396  * appropriate handler. So find the space, set it to null. in that way,
2397  * buf is now just the failure command, and cp is the message.
2398  */
2399  cp = strchr(buf,' ');
2400  if (!cp) {
2401  return;
2402  }
2403 
2404  *cp = 0;
2405  cp++;
2406 
2407  if (!strcmp(buf,"accountlogin")) {
2409  } else if (!strcmp(buf,"accountnew")) {
2411  } else if (!strcmp(buf,"accountaddplayer")) {
2413  } else if (!strcmp(buf,"createplayer")) {
2415  } else if (!strcmp(buf, "accountpw")) {
2417  } else
2418  /* This really is an error - if this happens it menas the server
2419  * failed to process a request that the client made - the client
2420  * should be able to handle failures for all request types it makes.
2421  * But this is also a problem in that it means that the server is
2422  * waiting for a correct response, and if we do not display anything,
2423  * the player is unlikely to know this.
2424  */
2425  LOG(LOG_ERROR, "common::FailureCmd", "Got a failure response we can not handle: %s:%s",
2426  buf, cp);
2427 }
2428 
2432 void AccountPlayersCmd(char *buf, int len) {
2433  int level, pos, flen, faceno;
2434  char name[MAX_BUF], class[MAX_BUF], race[MAX_BUF],
2435  face[MAX_BUF], party[MAX_BUF], map[MAX_BUF];
2436 
2437  /* This is called first so it can clear out the existing data store.
2438  */
2440 
2441  level=0;
2442  name[0]=0;
2443  class[0]=0;
2444  race[0]=0;
2445  face[0]=0;
2446  party[0]=0;
2447  map[0]=0;
2448  faceno=0;
2449 
2450  pos=1;
2451  while (pos < len) {
2452  flen = buf[pos];
2453  /* flen == 0 is to note that we got end of character data */
2454  if (flen == 0) {
2455  update_character_choose(name, class, race, face, party, map, level, faceno);
2456  /* Blank all the values - it is no sure thing that the next
2457  * character will fill all these in.
2458  */
2459  level=0;
2460  name[0]=0;
2461  class[0]=0;
2462  race[0]=0;
2463  face[0]=0;
2464  party[0]=0;
2465  map[0]=0;
2466  faceno=0;
2467  pos++;
2468  continue;
2469  }
2470  pos++;
2471  if ((pos +flen) > len || flen>=MAX_BUF) {
2472  LOG(LOG_ERROR,"commands.c:AccountPlayerCmd", "data overran buffer");
2473  return;
2474  }
2475  switch (buf[pos]) {
2476  case ACL_NAME:
2477  strncpy(name, buf + pos +1, flen-1);
2478  name[flen-1] = 0;
2479  break;
2480 
2481  case ACL_CLASS:
2482  strncpy(class, buf + pos +1, flen-1);
2483  class[flen-1] = 0;
2484  break;
2485 
2486  case ACL_RACE:
2487  strncpy(race, buf + pos +1, flen-1);
2488  race[flen-1] = 0;
2489  break;
2490 
2491  case ACL_FACE:
2492  strncpy(face, buf + pos +1, flen-1);
2493  face[flen-1] = 0;
2494  break;
2495 
2496  case ACL_PARTY:
2497  strncpy(party, buf + pos +1, flen-1);
2498  party[flen-1] = 0;
2499  break;
2500 
2501  case ACL_MAP:
2502  strncpy(map, buf + pos +1, flen-1);
2503  map[flen-1] = 0;
2504  break;
2505 
2506  case ACL_LEVEL:
2507  level = GetShort_String((unsigned char *)buf + pos + 1);
2508  break;
2509  case ACL_FACE_NUM:
2510  faceno = GetShort_String((unsigned char *)buf + pos + 1);
2511  break;
2512  }
2513  pos += flen;
2514  }
2515 }
2516 
float weight
Definition: item.h:61
void PickupCmd(guint8 *data, int len)
Server gives us current player&#39;s pickup.
Definition: commands.c:2376
#define CS_STAT_AC
Definition: newclient.h:100
gint16 grace
Spell points for using prayers.
Definition: client.h:266
void free_all_race_class_info(Race_Class_Info *data, int num_entries)
This function clears the data from the Race_Class_Info array.
Definition: commands.c:420
#define ACL_CLASS
Definition: newclient.h:197
void DeleteItem(unsigned char *data, int len)
Definition: commands.c:1796
gint8 wc
Weapon Class.
Definition: client.h:259
void handle_query(char *data, int len)
Prompts the user for input.
Definition: commands.c:1528
int num_races
Definition: commands.c:87
char * news
Definition: commands.c:82
void SetupCmd(char *buf, int len)
Received a response to a setup from the server.
Definition: commands.c:901
struct Stat_Mapping stat_mapping[NUM_NEW_CHAR_STATS]
Definition: commands.c:118
#define INFO_MAP_ARCH_NAME
Definitions for the requestion/replyinfo map data.
Definition: newclient.h:673
gint32 weapon_sp
Weapon speed (displayed in client as a float)
Definition: client.h:276
GSocketConnection * fd
Definition: client.h:120
int stat_maximum
Definition: commands.c:95
char ** value_arch
Definition: client.h:598
char * choice_desc
Definition: client.h:596
guint32 tick
Definition: client.c:61
guint16 level
The casting level of the spell.
Definition: client.h:301
int num_values
Definition: client.h:597
gint16 use_config[CONFIG_NUMS]
Definition: init.c:40
#define CS_STAT_INT
Definition: newclient.h:92
void create_new_character_failure(char *message)
Pop up a dialog window with the error from the server.
Definition: account.c:152
char * description
Definition: client.h:614
item * locate_item(gint32 tag)
Definition: item.c:300
#define UPD_ANIM
Definition: newclient.h:294
void DrawInfoCmd(char *data, int len)
Draws a string in the info window.
Definition: commands.c:1199
void TickCmd(guint8 *data, int len)
Got a tick from the server.
Definition: commands.c:2359
void mapdata_set_check_space(int x, int y)
Definition: mapdata.c:675
void mapdata_clear_space(int x, int y)
Definition: mapdata.c:633
void set_weight_limit(guint32 wlim)
No reason to divide by 1000 everytime we do the display, so do it once and store it here...
Definition: inventory.c:621
#define ACL_FACE_NUM
Definition: newclient.h:203
gint64 skill_exp[MAX_SKILL]
Experience points for skills.
Definition: client.h:290
guint8 num_animations
Number of animations.
Definition: client.h:100
char * motd
Definition: commands.c:82
void account_add_character_failure(char *message)
Handles a failure from the server - pretty basic - just throw up the message and let the user try aga...
Definition: account.c:291
void choose_character_init(void)
Called when we get the accountplayers command from the server (indirectly via AccountPlayersCmd).
Definition: account.c:439
#define UPD_SP_GRACE
updspell command flag value.
Definition: newclient.h:300
#define EMI_SMOOTH
Data about smoothing.
Definition: newclient.h:352
void reset_player_data()
Reset player experience data.
Definition: init.c:226
guint16 inv_updated
Definition: item.h:75
#define ACL_LEVEL
Definition: newclient.h:199
void setTextManager(int type, ExtTextManager callback)
Definition: commands.c:1223
#define MAX_SKILL
How many skill types server supports/client will get sent to it.
Definition: client.h:84
void AddMeFail(char *data, int len)
Handles when the server says we can&#39;t be added.
Definition: commands.c:1083
gint16 maxsp
Maximum spell points.
Definition: client.h:265
item * ob
Player object.
Definition: client.h:336
short GetShort_String(const unsigned char *data)
Definition: newsocket.c:172
int stat_min
Definition: commands.c:94
Animations animations[MAXANIM]
Definition: commands.c:1127
struct item_struct * env
Definition: item.h:53
guint16 dam
Damage done by spell though the meaning is spell dependent and actual damage may depend on how the sp...
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:1182
Warning that something might not work.
Definition: client.h:443
guint16 sp
Mana per cast; may be zero.
Definition: client.h:303
struct MapCell * mapdata_cell(int x, int y)
Get the stored map cell at the given map coordinate.
Definition: mapdata.c:119
gint32 speed
Speed (is displayed as a float)
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:815
guint16 mmapy
size of magic map
Definition: client.h:360
#define MSG_TYPE_CLIENT_QUERY
handle_query() and prompts
Definition: newclient.h:662
void ReplyInfoCmd(unsigned char *buf, int len)
Handles the response from a &#39;requestinfo&#39; command.
Definition: commands.c:774
char * rules
Definition: commands.c:82
char GetChar_String(const unsigned char *data)
Definition: newsocket.c:130
void close_container(item *op)
Open and close_container are now no-ops - since these are now drawn inline as treestores, we don&#39;t need to update what we are drawing were.
Definition: inventory.c:573
#define CS_STAT_DEX
Definition: newclient.h:94
guint16 smooth[MAXLAYERS]
Definition: mapdata.h:53
ClientSocket csocket
Definition: client.c:69
#define INFO_MAP_NAME
Proper name of this entry.
Definition: newclient.h:674
char * description
Definition: client.h:605
Face_Information face_info
Definition: image.c:169
static void get_starting_map_info(unsigned char *data, int len)
This processes the replyinfo starting_map_info.
Definition: commands.c:172
#define MSG_TYPE_CLIENT
Client originated Messages.
Definition: newclient.h:395
guint16 time
Casting time in server ticks.
Definition: client.h:302
void MapExtendedCmd(unsigned char *data, int len)
Handle MapExtended command Warning! if you add commands to extended, take care that the &#39;layer&#39; argum...
Definition: commands.c:2233
Stats stats
Player stats.
Definition: client.h:349
#define NUM_NEW_CHAR_STATS
Definition: client.h:569
static int spellmon_level
Keeps track of what spellmon command is supported by the server.
Definition: commands.c:85
#define ACL_FACE
Definition: newclient.h:200
Contains external calls that the common area makes callbacks to.
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
Description of this map.
Definition: newclient.h:675
char ** value_desc
Definition: client.h:599
#define NDI_BLACK
Definition: newclient.h:221
guint8 usage
Spellmon 2 data.
Definition: client.h:322
gint8 Con
Constitution.
Definition: client.h:254
void DeleteInventory(unsigned char *data, int len)
Definition: commands.c:1822
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
Magic map data.
Definition: client.h:363
guint32 nrof
Definition: item.h:60
char * skill_names[MAX_SKILL]
Definition: client.c:50
void mapdata_newmap(void)
Clears the map view.
Definition: mapdata.c:975
void FailureCmd(char *buf, int len)
Handles a failure return from the server.
Definition: commands.c:2390
#define MSG_TYPE_CLIENT_SERVER
Server configuration issues.
Definition: newclient.h:660
void Item2Cmd(unsigned char *data, int len)
Definition: commands.c:1701
int stat_points
Definition: commands.c:93
#define CS_STAT_WEIGHT_LIM
Definition: newclient.h:112
guint64 * exp_table
Definition: client.c:64
static void common_item_command(guint8 *data, int len)
Parses the data sent to us from the server.
Definition: commands.c:1650
For classes & races, the server can present some number of choices, eg, the character gets to choose ...
Definition: client.h:594
#define EMI_HASMOREBITS
Indicates the bitfield continue un next byte There may be several on contiguous bytes.
Definition: newclient.h:358
void addsmooth(guint16 face, guint16 smooth_face)
Referenced from common/commands.c.
Definition: image.c:403
guint32 path
The bitmask of paths this spell belongs to.
Definition: client.h:315
#define CS_STAT_EXP64
Definition: newclient.h:113
void map_scrollCmd(char *data, int len)
Scrolls the map on the client by some amount.
Definition: commands.c:2165
static int rc_compar(const Race_Class_Info *a, const Race_Class_Info *b)
Used for bsearch searching.
Definition: commands.c:405
guint16 type
Definition: item.h:80
void mapdata_set_anim_layer(int x, int y, guint16 anim, guint8 anim_speed, int layer)
Definition: mapdata.c:846
void draw_stats(int redraw)
Draws the stats window.
Definition: stats.c:554
#define CS_STAT_WC
Definition: newclient.h:99
void AccountPlayersCmd(char *buf, int len)
This handles the accountplayers command.
Definition: commands.c:2432
void LOG(LogLevel level, const char *origin, const char *format,...)
Log messages of a certain importance to stderr.
Definition: misc.c:109
void client_disconnect()
Closes the connection to the server.
Definition: client.c:180
#define NDI_RED
Definition: newclient.h:224
char * public_name
Definition: client.h:613
guint32 resist_change
Resistant value change flag.
Definition: client.h:288
guint32 repelled
Spell paths to which the player is repelled.
Definition: client.h:282
int ExtSmooth(unsigned char *data, int len, int x, int y, int layer)
Extract smoothing infos from an extendedmapinfo packet part data is located at the beginning of the s...
Definition: commands.c:2195
void Map2Cmd(unsigned char *data, int len)
Definition: commands.c:2052
guint16 grace
Grace per cast; may be zero.
Definition: client.h:304
void UpdspellCmd(unsigned char *data, int len)
Definition: commands.c:1934
void update_login_info(int type)
This is called from ReplyInfoCmd when it gets a response from news/motd/rules.
Definition: account.c:1241
gint8 ac
Armour Class.
Definition: client.h:260
void SinkCmd(unsigned char *data, int len)
Definition: commands.c:2348
#define INFO_NEWS
Definition: client.h:633
void x_set_echo(void)
Definition: keys.c:1686
guint8 cs_value
Definition: client.h:579
#define CS_QUERY_YESNO
Yes/no question.
Definition: newclient.h:66
int num_classes
Definition: commands.c:90
TextManager * firstTextManager
Definition: commands.c:1216
static gboolean redraw(gpointer data)
Redraw the map.
Definition: main.c:128
void display_map_doneupdate(int redraw, int notice)
This is called after the map has been all digested.
Definition: map.c:493
void NewmapCmd(unsigned char *data, int len)
Definition: commands.c:2026
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)
This gets data and adds it to the list store.
Definition: account.c:572
ExtTextManager callback
Definition: client.h:49
void new_char_window_update_info()
We have gotten some new information from the server, so we need to update the information - race/clas...
Definition: create_char.c:633
gint8 Str
Strength.
Definition: client.h:252
guint8 speed
Definition: client.h:104
void SmoothCmd(unsigned char *data, int len)
Receives the smooth mapping from the server.
Definition: commands.c:1179
void(* ExtTextManager)(int flag, int type, int subtype, char *message)
Definition: client.h:45
int num_rc_choice
Definition: client.h:607
void get_image_info(guint8 *data, int len)
Takes the data from a replyinfo image_info and breaks it down.
Definition: image.c:706
#define ASSERT_LEN(function, curpos, buflen)
Definition: commands.c:76
void draw_message_window(int redraw)
Updates the stats pane - hp, sp, etc labels.
Definition: stats.c:459
#define CS_STAT_RESIST_END
End of resistances (inclusive)
Definition: newclient.h:142
#define CS_STAT_LEVEL
Definition: newclient.h:98
guint8 rc_offset
Definition: client.h:580
#define UPD_SP_DAMAGE
updspell command flag value.
Definition: newclient.h:301
void use_skill(int skill_id)
Maintain the last_used_skills LRU list for displaying the recently used skills first.
Definition: commands.c:1315
gint8 Wis
Wisdom.
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:1628
gint8 level
Experience level.
Definition: client.h:261
void UpdateItemCmd(unsigned char *data, int len)
Updates some attributes of an item.
Definition: commands.c:1712
void mapdata_clear_old(int x, int y)
Definition: mapdata.c:787
Client_Player cpl
Player object.
Definition: client.c:68
item * container
open container
Definition: client.h:339
static const char *const short_stat_name[NUM_STATS]
Short name of stats.
Definition: commands.c:107
Race_Class_Info * races
Definition: commands.c:98
char * choice_name
Definition: client.h:595
guint16 was_open
Definition: item.h:74
static void get_new_char_info(unsigned char *data, int len)
This is process the newcharinfo requestinfo.
Definition: commands.c:247
#define CONFIG_MAPHEIGHT
Definition: client.h:204
guint8 need_resmooth
Definition: mapdata.h:57
static void get_skill_info(char *data, int len)
Definition: commands.c:732
void StatsCmd(unsigned char *data, int len)
Updates the local copy of the stats and displays it.
Definition: commands.c:1340
#define CS_QUERY_SINGLECHAR
Single character response expected.
Definition: newclient.h:67
guint32 flagsval
Definition: item.h:79
gint8 Pow
Power.
Definition: client.h:258
char message[10000]
This is huge, the packets can&#39;t be much bigger than this anyway.
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:641
#define MAX_BUF
Definition: client.h:40
guint8 skill_number
The index in the skill arrays, plus CS_STAT_SKILLINFO.
Definition: client.h:309
void get_image_sums(char *data, int len)
This gets a block of checksums from the server.
Definition: image.c:802
#define INFO_MOTD
Definition: client.h:634
void AddspellCmd(unsigned char *data, int len)
Definition: commands.c:1850
#define CONFIG_CACHE
Definition: client.h:189
gint16 food
Quantity food in stomach.
Definition: client.h:269
#define UPD_FLAGS
Definition: newclient.h:290
void free_all_starting_map_info()
This function clears the data from the Race_Class_Info array.
Definition: commands.c:134
#define CS_STAT_CHA
Definition: newclient.h:96
gint8 Dex
Dexterity.
Definition: client.h:253
guint32 tag
Unique ID number for a spell so updspell etc can operate on it.
Definition: client.h:299
guint16 animation_id
Definition: item.h:63
void new_player(long tag, char *name, long weight, long face)
Initialize player object using information from the server.
Definition: player.c:41
void account_creation_failure(char *message)
Handles a failure from the server - pretty basic - just throw up the message and let the user try aga...
Definition: account.c:725
#define UPD_SP_MANA
updspell command flag value.
Definition: newclient.h:299
gint64 GetInt64_String(const unsigned char *data)
The reverse of SockList_AddInt, but on strings instead.
Definition: newsocket.c:154
void client_tick(guint32 tick)
X11 client doesn&#39;t care about this.
Definition: main.c:156
#define UPD_WEIGHT
Definition: newclient.h:291
guint16 pmapy
Where the player is on the magic map.
Definition: client.h:361
void send_reply(const char *text)
Sends a reply to the server.
Definition: commands.c:1584
#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)
This is a little wrapper function that does some bounds checking and then calls process_race_info() t...
Definition: commands.c:648
struct RC_Choice * rc_choice
Definition: client.h:608
guint8 anim_speed
Definition: item.h:64
#define CS_STAT_FOOD
Definition: newclient.h:104
char * arch_name
Definition: client.h:603
gint16 resists[30]
Resistant values.
Definition: client.h:287
#define CS_STAT_EXP
No longer used.
Definition: newclient.h:97
#define FACE_IS_ANIM
Definition: newclient.h:321
bool mapdata_contains(int x, int y)
Determine whether the map data contains the given cell.
Definition: mapdata.c:126
int last_used_skills[MAX_SKILL+1]
maps position to skill id with trailing zero as stop mark.
Definition: client.c:55
void GoodbyeCmd(char *data, int len)
Definition: commands.c:1114
struct Spell_struct * next
Definition: client.h:295
int starting_map_number
Definition: commands.c:96
guint16 flags
Contains fire on/run on flags.
Definition: client.h:286
#define UPD_ANIMSPEED
Definition: newclient.h:295
gint64 exp
Experience.
Definition: client.h:268
gint32 face
A face ID that may be used to show a graphic representation of the spell.
Definition: client.h:319
static void get_class_info(unsigned char *data, int len)
This is a little wrapper function that does some bounds checking and then calls process_race_info() t...
Definition: commands.c:679
gint16 skill_level[MAX_SKILL]
Level of known skills.
Definition: client.h:289
void starting_map_update_info()
We have gotten starting map information from the server - now update the combo boxes.
Definition: create_char.c:753
Warning that something definitely didn&#39;t work.
Definition: client.h:444
guint32 weight_limit
Carrying weight limit.
Definition: client.h:291
void script_lua_stats(void)
void AddMeSuccess(char *data, int len)
This is really a throwaway command - there really isn&#39;t any reason to send addme_success commands...
Definition: commands.c:1099
void client_pickup(guint32 pickup)
We get pickup information from server, update our status.
Definition: pickup.c:630
guint16 open
Definition: item.h:73
Spell * spelldata
List of spells known.
Definition: client.h:350
gint16 dam
How much damage this object does for each hit.
Definition: client.h:272
guint32 spells_updated
Whether or not spells updated.
Definition: client.h:353
#define MAXLAYERS
The protocol supports 10 layers, so set MAXLAYERS accordingly.
Definition: mapdata.h:6
#define INFO_RULES
Definition: client.h:635
#define EMI_NOREDRAW
< Take extended information into account but do not redraw.
Definition: newclient.h:348
#define MAP2_TYPE_DARKNESS
Definition: newclient.h:43
void AnimCmd(unsigned char *data, int len)
Definition: commands.c:1134
The usage of the stat_mapping is to simplify the code and make it easier to expand.
Definition: client.h:577
char name[256]
One length byte plus data.
Definition: client.h:296
void mapdata_scroll(int dx, int dy)
Scrolls the map view.
Definition: mapdata.c:902
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)
We must extract color, type, subtype and dispatch to callback.
Definition: commands.c:1263
#define NUM_LAYERS
Definition: commands.c:2045
gint8 stat_adj[NUM_NEW_CHAR_STATS]
Definition: client.h:606
static ExtTextManager getTextManager(int type)
Definition: commands.c:1245
void start_login(int method)
Starts the login process.
Definition: account.c:1330
#define UPD_FACE
Definition: newclient.h:292
gint8 Int
Intelligence.
Definition: client.h:257
struct TextManager * next
Definition: client.h:50
void hide_all_login_windows(void)
Hides all the login related windows.
Definition: account.c:102
void PlayerCmd(unsigned char *data, int len)
Gets the player information.
Definition: commands.c:1601
gint16 sp
Spell points for casting spells.
Definition: client.h:264
char * arch_name
Definition: client.h:612
void draw_ext_info(int orig_color, int type, int subtype, const char *message)
A message processor that accepts messages along with meta information color and type.
Definition: info.c:932
void remove_item_inventory(item *op)
Definition: item.c:393
#define MAP2_COORD_OFFSET
How much the x,y coordinates in the map2 are off from actual upper left corner.
Definition: newclient.h:32
void DeleteSpell(unsigned char *data, int len)
Definition: commands.c:1972
static void process_race_class_info(unsigned char *data, int len, Race_Class_Info *rci)
This extracts the data from a replyinfo race_info/class_info request.
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
CS_NUM_SKILLS does not match how many skills there really are - instead, it is used as a range of val...
Definition: newclient.h:175
char * public_name
Definition: client.h:604
#define CS_STAT_TITLE
Definition: newclient.h:107
int used_classes
Definition: commands.c:91
Input_State input_state
What the input state is.
Definition: client.h:341
char range[MAX_BUF]
Range attack chosen.
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
Maximum hit points.
Definition: client.h:263
char title[MAX_BUF]
Title of character.
Definition: client.h:351
void resize_map_window(int x, int y)
Resize_map_window is a NOOP for the time being - not sure if it will in fact need to do something...
Definition: map.c:371
Includes various dependencies header files needed by most everything.
int cs_print_string(GSocketConnection *fd, const char *str,...)
Send a printf-formatted packet to the socket.
Definition: newsocket.c:245
int used_races
Definition: commands.c:88
char * name
Definition: image.c:39
#define MSG_TYPE_CLIENT_COMMAND
DrawInfoCmd()
Definition: newclient.h:661
void open_container(item *op)
Definition: inventory.c:581
#define CS_STAT_RESIST_START
Start of resistances (inclusive)
Definition: newclient.h:141
#define MAX_VIEW
Maximum size of view area a server could support.
Definition: mapdata.h:11
#define CS_QUERY_HIDEINPUT
Hide input being entered.
Definition: newclient.h:68
gint16 hp
Hit Points.
Definition: client.h:262
#define CS_STAT_POW
Definition: newclient.h:108
gint16 face
Definition: item.h:62
char requirements[256]
Spellmon 2 data.
Definition: client.h:327
guint32 no_echo
If TRUE, don&#39;t echo keystrokes.
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)
Draws a prompt.
Definition: keys.c:1695
void MagicMapCmd(unsigned char *data, int len)
Definition: commands.c:2295
Useful debugging information.
Definition: client.h:441
gint8 Cha
Charisma.
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)
The reverse of SockList_AddInt, but on strings instead.
Definition: newsocket.c:142
#define ACL_NAME
Definition: newclient.h:196
#define CS_STAT_MAXGRACE
Definition: newclient.h:110
void mapdata_set_size(int viewx, int viewy)
Sets the current display size.
Definition: mapdata.c:614
guint16 exp_table_max
Definition: client.c:63
#define MAP2_LAYER_START
Definition: newclient.h:53
void account_login_failure(char *message)
Handles a failure from the server - pretty basic - just throw up the message and let the user try aga...
Definition: account.c:910
Minor, non-harmful issues.
Definition: client.h:442
#define CS_STAT_SKILLINFO
CS_STAT_SKILLINFO is used as the starting index point.
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:730
PlayerPosition pl_pos
Definition: map.c:37
guint32 attuned
Spell paths to which the player is 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
Pointer to the skill name, derived from the skill number.
Definition: client.h:313
gint16 maxgrace
Maximum spell points.
Definition: client.h:267
guint32 denied
Spell paths denied to the player.
Definition: client.h:285
void mapdata_set_smooth(int x, int y, int smooth, int layer)
Definition: mapdata.c:753