common/dataio.c

   1 /**********************************************************************
   2  Freeciv - Copyright (C) 1996 - A Kjeldberg, L Gregersen, P Unold
   3    This program is free software; you can redistribute it and/or modify
   4    it under the terms of the GNU General Public License as published by
   5    the Free Software Foundation; either version 2, or (at your option)
   6    any later version.
   7
   8    This program is distributed in the hope that it will be useful,
   9    but WITHOUT ANY WARRANTY; without even the implied warranty of
  10    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  11    GNU General Public License for more details.
  12 ***********************************************************************/
  13
  14 /*
  15  * The DataIO module provides a system independent (endianess and
  16  * sizeof(int) independent) way to write and read data. It supports
  17  * multiple datas which are collected in a buffer. It provides
  18  * recognition of error cases like "not enough space" or "not enough
  19  * data".
  20  */
  21
  22 #ifdef HAVE_CONFIG_H
  23 #include <fc_config.h>
  24 #endif
  25
  26 #include <limits.h>
  27 #include <stdint.h>
  28 #include <stdio.h>
  29 #include <stdlib.h>
  30 #include <string.h>
  31
  32 #ifdef HAVE_SYS_TYPES_H
  33 #include <sys/types.h>
  34 #endif
  35 #ifdef HAVE_SYS_SOCKET_H
  36 #include <sys/socket.h>
  37 #endif
  38 #ifdef HAVE_NETINET_IN_H
  39 #include <netinet/in.h>
  40 #endif
  41 #ifdef HAVE_ARPA_INET_H
  42 #include <arpa/inet.h>
  43 #endif
  44 #ifdef HAVE_WINSOCK
  45 #include <winsock.h>
  46 #endif
  47
  48 /* utility */
  49 #include "bitvector.h"
  50 #include "capability.h"
  51 #include "log.h"
  52 #include "mem.h"
  53 #include "support.h"
  54
  55 /* common */
  56 #include "events.h"
  57 #include "player.h"
  58 #include "requirements.h"
  59 #include "tech.h"
  60 #include "worklist.h"
  61
  62 #include "dataio.h"
  63
  64 static bool get_conv(char *dst, size_t ndst, const char *src,
  65                      size_t nsrc);
  66
  67 static DIO_PUT_CONV_FUN put_conv_callback = NULL;
  68 static DIO_GET_CONV_FUN get_conv_callback = get_conv;
  69
  70 /**************************************************************************
  71   Sets string conversion callback to be used when putting text.
  72 **************************************************************************/
  73 void dio_set_put_conv_callback(DIO_PUT_CONV_FUN fun)
  74 {
  75   put_conv_callback = fun;
  76 }
  77
  78 /**************************************************************************
  79  Returns FALSE if the destination isn't large enough or the source was
  80  bad. This is default get_conv_callback.
  81 **************************************************************************/
  82 static bool get_conv(char *dst, size_t ndst, const char *src,
  83                      size_t nsrc)
  84 {
  85   size_t len = nsrc;            /* length to copy, not including null */
  86   bool ret = TRUE;
  87
  88   if (ndst > 0 && len >= ndst) {
  89     ret = FALSE;
  90     len = ndst - 1;
  91   }
  92
  93   memcpy(dst, src, len);
  94   dst[len] = '\0';
  95
  96   return ret;
  97 }
  98
  99 /**************************************************************************
 100   Sets string conversion callback to use when getting text.
 101 **************************************************************************/
 102 void dio_set_get_conv_callback(DIO_GET_CONV_FUN fun)
 103 {
 104   get_conv_callback = fun;
 105 }
 106
 107 /**************************************************************************
 108   Returns TRUE iff the output has size bytes available.
 109 **************************************************************************/
 110 static bool enough_space(struct data_out *dout, size_t size)
 111 {
 112   if (dout->current + size > dout->dest_size) {
 113     dout->too_short = TRUE;
 114     return FALSE;
 115   } else {
 116     dout->used = MAX(dout->used, dout->current + size);
 117     return TRUE;
 118   }
 119 }
 120
 121 /**************************************************************************
 122   Returns TRUE iff the input contains size unread bytes.
 123 **************************************************************************/
 124 static bool enough_data(struct data_in *din, size_t size)
 125 {
 126   return dio_input_remaining(din) >= size;
 127 }
 128
 129 /**************************************************************************
 130   Initializes the output to the given output buffer and the given
 131   buffer size.
 132 **************************************************************************/
 133 void dio_output_init(struct data_out *dout, void *destination,
 134                      size_t dest_size)
 135 {
 136   dout->dest = destination;
 137   dout->dest_size = dest_size;
 138   dout->current = 0;
 139   dout->used = 0;
 140   dout->too_short = FALSE;
 141 }
 142
 143 /**************************************************************************
 144   Return the maximum number of bytes used.
 145 **************************************************************************/
 146 size_t dio_output_used(struct data_out *dout)
 147 {
 148   return dout->used;
 149 }
 150
 151 /**************************************************************************
 152   Rewinds the stream so that the put-functions start from the
 153   beginning.
 154 **************************************************************************/
 155 void dio_output_rewind(struct data_out *dout)
 156 {
 157   dout->current = 0;
 158 }
 159
 160 /**************************************************************************
 161   Initializes the input to the given input buffer and the given
 162   number of valid input bytes.
 163 **************************************************************************/
 164 void dio_input_init(struct data_in *din, const void *src, size_t src_size)
 165 {
 166   din->src = src;
 167   din->src_size = src_size;
 168   din->current = 0;
 169 }
 170
 171 /**************************************************************************
 172   Rewinds the stream so that the get-functions start from the
 173   beginning.
 174 **************************************************************************/
 175 void dio_input_rewind(struct data_in *din)
 176 {
 177   din->current = 0;
 178 }
 179
 180 /**************************************************************************
 181   Return the number of unread bytes.
 182 **************************************************************************/
 183 size_t dio_input_remaining(struct data_in *din)
 184 {
 185   return din->src_size - din->current;
 186 }
 187
 188 /**************************************************************************
 189   Return the size of the data_type in bytes.
 190 **************************************************************************/
 191 size_t data_type_size(enum data_type type)
 192 {
 193   switch (type) {
 194   case DIOT_UINT8:
 195   case DIOT_SINT8:
 196     return 1;
 197   case DIOT_UINT16:
 198   case DIOT_SINT16:
 199     return 2;
 200   case DIOT_UINT32:
 201   case DIOT_SINT32:
 202     return 4;
 203   case DIOT_LAST:
 204     break;
 205   }
 206
 207   fc_assert_msg(FALSE, "data_type %d not handled.", type);
 208   return 0;
 209 }
 210
 211 /**************************************************************************
 212    Skips 'n' bytes.
 213 **************************************************************************/
 214 bool dio_input_skip(struct data_in *din, size_t size)
 215 {
 216   if (enough_data(din, size)) {
 217     din->current += size;
 218     return TRUE;
 219   } else {
 220     return FALSE;
 221   }
 222 }
 223
 224 /**************************************************************************
 225   Insert value using 8 bits. May overflow.
 226 **************************************************************************/
 227 void dio_put_uint8(struct data_out *dout, int value)
 228 {
 229   if (value < 0x00 || 0xff < value) {
 230     log_error("Trying to put %d into 8 bits", value);
 231   }
 232
 233   if (enough_space(dout, 1)) {
 234     uint8_t x = value;
 235
 236     FC_STATIC_ASSERT(sizeof(x) == 1, uint8_not_1_byte);
 237     memcpy(ADD_TO_POINTER(dout->dest, dout->current), &x, 1);
 238     dout->current++;
 239   }
 240 }
 241
 242 /**************************************************************************
 243   Insert value using 16 bits. May overflow.
 244 **************************************************************************/
 245 void dio_put_uint16(struct data_out *dout, int value)
 246 {
 247   if (value < 0x0000 || 0xffff < value) {
 248     log_error("Trying to put %d into 16 bits", value);
 249   }
 250
 251   if (enough_space(dout, 2)) {
 252     uint16_t x = htons(value);
 253
 254     FC_STATIC_ASSERT(sizeof(x) == 2, uint16_not_2_bytes);
 255     memcpy(ADD_TO_POINTER(dout->dest, dout->current), &x, 2);
 256     dout->current += 2;
 257   }
 258 }
 259
 260 /**************************************************************************
 261   Insert value using 32 bits. May overflow.
 262 **************************************************************************/
 263 void dio_put_uint32(struct data_out *dout, int value)
 264 {
 265   if (sizeof(value) > 4 && (value < 0x00000000 || 0xffffffff < value)) {
 266     log_error("Trying to put %d into 32 bits", value);
 267   }
 268
 269   if (enough_space(dout, 4)) {
 270     uint32_t x = htonl(value);
 271
 272     FC_STATIC_ASSERT(sizeof(x) == 4, uint32_not_4_bytes);
 273     memcpy(ADD_TO_POINTER(dout->dest, dout->current), &x, 4);
 274     dout->current += 4;
 275   }
 276 }
 277
 278 /**************************************************************************
 279   Insert value using 'size' bits. May overflow.
 280 **************************************************************************/
 281 void dio_put_type(struct data_out *dout, enum data_type type, int value)
 282 {
 283   switch (type) {
 284   case DIOT_UINT8:
 285     dio_put_uint8(dout, value);
 286     return;
 287   case DIOT_UINT16:
 288     dio_put_uint16(dout, value);
 289     return;
 290   case DIOT_UINT32:
 291     dio_put_uint32(dout, value);
 292     return;
 293   case DIOT_SINT8:
 294     dio_put_sint8(dout, value);
 295     return;
 296   case DIOT_SINT16:
 297     dio_put_sint16(dout, value);
 298     return;
 299   case DIOT_SINT32:
 300     dio_put_sint32(dout, value);
 301     return;
 302   case DIOT_LAST:
 303     break;
 304   }
 305
 306   fc_assert_msg(FALSE, "data_type %d not handled.", type);
 307 }
 308
 309 /**************************************************************************
 310   Insert value using 8 bits. May overflow.
 311 **************************************************************************/
 312 void dio_put_sint8(struct data_out *dout, int value)
 313 {
 314   dio_put_uint8(dout, 0 <= value ? value : value + 0x100);
 315 }
 316
 317 /**************************************************************************
 318   Insert value using 16 bits. May overflow.
 319 **************************************************************************/
 320 void dio_put_sint16(struct data_out *dout, int value)
 321 {
 322   dio_put_uint16(dout, 0 <= value ? value : value + 0x10000);
 323 }
 324
 325 /**************************************************************************
 326   Insert value using 32 bits. May overflow.
 327 **************************************************************************/
 328 void dio_put_sint32(struct data_out *dout, int value)
 329 {
 330 #if SIZEOF_INT == 4
 331   dio_put_uint32(dout, value);
 332 #else
 333   dio_put_uint32(dout, (0 <= value ? value : value + 0x100000000));
 334 #endif
 335 }
 336
 337 /**************************************************************************
 338   Insert value 0 or 1 using 8 bits.
 339 **************************************************************************/
 340 void dio_put_bool8(struct data_out *dout, bool value)
 341 {
 342   if (value != TRUE && value != FALSE) {
 343     log_error("Trying to put a non-boolean: %d", (int) value);
 344     value = FALSE;
 345   }
 346
 347   dio_put_uint8(dout, value ? 1 : 0);
 348 }
 349
 350 /**************************************************************************
 351   Insert value 0 or 1 using 32 bits.
 352 **************************************************************************/
 353 void dio_put_bool32(struct data_out *dout, bool value)
 354 {
 355   if (value != TRUE && value != FALSE) {
 356     log_error("Trying to put a non-boolean: %d", (int) value);
 357     value = FALSE;
 358   }
 359
 360   dio_put_uint32(dout, value ? 1 : 0);
 361 }
 362
 363 /**************************************************************************
 364   Insert a float number, which is multiplied by 'float_factor' before
 365   being encoded into a uint32.
 366 **************************************************************************/
 367 void dio_put_float(struct data_out *dout, float value, int float_factor)
 368 {
 369   dio_put_uint32(dout, value * float_factor);
 370 }
 371
 372 /**************************************************************************
 373   Insert number of values brefore stop_value using 8 bits. Then
 374   insert values using 8 bits for each. stop_value is not required to
 375   fit in 8 bits. Actual values may overflow.
 376 **************************************************************************/
 377 void dio_put_uint8_vec8(struct data_out *dout, int *values, int stop_value)
 378 {
 379   size_t count;
 380
 381   for (count = 0; values[count] != stop_value; count++) {
 382     /* nothing */
 383   }
 384
 385   if (enough_space(dout, 1 + count)) {
 386     size_t i;
 387
 388     dio_put_uint8(dout, count);
 389
 390     for (i = 0; i < count; i++) {
 391       dio_put_uint8(dout, values[i]);
 392     }
 393   }
 394 }
 395
 396 /**************************************************************************
 397   Insert number of values brefore stop_value using 8 bits. Then
 398   insert values using 16 bits for each. stop_value is not required to
 399   fit in 16 bits. Actual values may overflow.
 400 **************************************************************************/
 401 void dio_put_uint16_vec8(struct data_out *dout, int *values, int stop_value)
 402 {
 403   size_t count;
 404
 405   for (count = 0; values[count] != stop_value; count++) {
 406     /* nothing */
 407   }
 408
 409   if (enough_space(dout, 1 + 2 * count)) {
 410     size_t i;
 411
 412     dio_put_uint8(dout, count);
 413
 414     for (i = 0; i < count; i++) {
 415       dio_put_uint16(dout, values[i]);
 416     }
 417   }
 418 }
 419
 420 /**************************************************************************
 421   Insert block directly from memory.
 422 **************************************************************************/
 423 void dio_put_memory(struct data_out *dout, const void *value, size_t size)
 424 {
 425   if (enough_space(dout, size)) {
 426     memcpy(ADD_TO_POINTER(dout->dest, dout->current), value, size);
 427     dout->current += size;
 428   }
 429 }
 430
 431 /**************************************************************************
 432   Insert NULL-terminated string. Conversion callback is used if set.
 433 **************************************************************************/
 434 void dio_put_string(struct data_out *dout, const char *value)
 435 {
 436   if (put_conv_callback) {
 437     size_t length;
 438     char *buffer;
 439
 440     if ((buffer = (*put_conv_callback) (value, &length))) {
 441       dio_put_memory(dout, buffer, length + 1);
 442       free(buffer);
 443     }
 444   } else {
 445     dio_put_memory(dout, value, strlen(value) + 1);
 446   }
 447 }
 448
 449 /**************************************************************************
 450   Insert tech numbers from value array as 8 bit values until there is value
 451   A_LAST or MAX_NUM_TECH_LIST tech numbers have been inserted.
 452 **************************************************************************/
 453 void dio_put_tech_list(struct data_out *dout, const int *value)
 454 {
 455   int i;
 456
 457   for (i = 0; i < MAX_NUM_TECH_LIST; i++) {
 458     dio_put_uint8(dout, value[i]);
 459     if (value[i] == A_LAST) {
 460       break;
 461     }
 462   }
 463 }
 464
 465 /**************************************************************************
 466   Insert unit type numbers from value array as 8 bit values until there is
 467   value U_LAST or MAX_NUM_UNIT_LIST numbers have been inserted.
 468 **************************************************************************/
 469 void dio_put_unit_list(struct data_out *dout, const int *value)
 470 {
 471   int i;
 472
 473   for (i = 0; i < MAX_NUM_UNIT_LIST; i++) {
 474     dio_put_uint8(dout, value[i]);
 475     if (value[i] == U_LAST) {
 476       break;
 477     }
 478   }
 479 }
 480
 481 /**************************************************************************
 482   Insert building type numbers from value array as 8 bit values until there
 483   is value B_LAST or MAX_NUM_BUILDING_LIST numbers have been inserted.
 484 **************************************************************************/
 485 void dio_put_building_list(struct data_out *dout, const int *value)
 486 {
 487   int i;
 488
 489   for (i = 0; i < MAX_NUM_BUILDING_LIST; i++) {
 490     dio_put_uint8(dout, value[i]);
 491     if (value[i] == B_LAST) {
 492       break;
 493     }
 494   }
 495 }
 496
 497 /**************************************************************************
 498   Insert number of worklist items as 8 bit value and then insert
 499   8 bit kind and 8 bit number for each worklist item.
 500 **************************************************************************/
 501 void dio_put_worklist(struct data_out *dout, const struct worklist *pwl)
 502 {
 503   int i, length = worklist_length(pwl);
 504
 505   dio_put_uint8(dout, length);
 506   for (i = 0; i < length; i++) {
 507     const struct universal *pcp = &(pwl->entries[i]);
 508
 509     dio_put_uint8(dout, pcp->kind);
 510     dio_put_uint8(dout, universal_number(pcp));
 511   }
 512 }
 513
 514 /**************************************************************************
 515  Receive uint8 value to dest.
 516 **************************************************************************/
 517 bool dio_get_uint8(struct data_in *din, int *dest)
 518 {
 519   uint8_t x;
 520
 521   FC_STATIC_ASSERT(sizeof(x) == 1, uint8_not_byte);
 522
 523   if (!enough_data(din, 1)) {
 524     log_packet("Packet too short to read 1 byte");
 525
 526     return FALSE;
 527   }
 528
 529   memcpy(&x, ADD_TO_POINTER(din->src, din->current), 1);
 530   *dest = x;
 531   din->current++;
 532   return TRUE;
 533 }
 534
 535 /**************************************************************************
 536  Receive uint16 value to dest.
 537 **************************************************************************/
 538 bool dio_get_uint16(struct data_in *din, int *dest)
 539 {
 540   uint16_t x;
 541
 542   FC_STATIC_ASSERT(sizeof(x) == 2, uint16_not_2_bytes);
 543
 544   if (!enough_data(din, 2)) {
 545     log_packet("Packet too short to read 2 bytes");
 546
 547     return FALSE;
 548   }
 549
 550   memcpy(&x, ADD_TO_POINTER(din->src, din->current), 2);
 551   *dest = ntohs(x);
 552   din->current += 2;
 553   return TRUE;
 554 }
 555
 556 /**************************************************************************
 557  Receive uint32 value to dest.
 558 **************************************************************************/
 559 bool dio_get_uint32(struct data_in *din, int *dest)
 560 {
 561   uint32_t x;
 562
 563   FC_STATIC_ASSERT(sizeof(x) == 4, uint32_not_4_bytes);
 564
 565   if (!enough_data(din, 4)) {
 566     log_packet("Packet too short to read 4 bytes");
 567
 568     return FALSE;
 569   }
 570
 571   memcpy(&x, ADD_TO_POINTER(din->src, din->current), 4);
 572   *dest = ntohl(x);
 573   din->current += 4;
 574   return TRUE;
 575 }
 576
 577 /**************************************************************************
 578   Receive value using 'size' bits to dest.
 579 **************************************************************************/
 580 bool dio_get_type(struct data_in *din, enum data_type type, int *dest)
 581 {
 582   switch (type) {
 583   case DIOT_UINT8:
 584     return dio_get_uint8(din, dest);
 585   case DIOT_UINT16:
 586     return dio_get_uint16(din, dest);
 587   case DIOT_UINT32:
 588     return dio_get_uint32(din, dest);
 589   case DIOT_SINT8:
 590     return dio_get_sint8(din, dest);
 591   case DIOT_SINT16:
 592     return dio_get_sint16(din, dest);
 593   case DIOT_SINT32:
 594     return dio_get_sint32(din, dest);
 595   case DIOT_LAST:
 596     break;
 597   }
 598
 599   fc_assert_msg(FALSE, "data_type %d not handled.", type);
 600   return FALSE;
 601 }
 602
 603 /**************************************************************************
 604   Take boolean value from 8 bits.
 605 **************************************************************************/
 606 bool dio_get_bool8(struct data_in *din, bool *dest)
 607 {
 608   int ival;
 609
 610   if (!dio_get_uint8(din, &ival)) {
 611     return FALSE;
 612   }
 613
 614   if (ival != 0 && ival != 1) {
 615     log_packet("Got a bad boolean: %d", ival);
 616     return FALSE;
 617   }
 618
 619   *dest = (ival != 0);
 620   return TRUE;
 621 }
 622
 623 /**************************************************************************
 624   Take boolean value from 32 bits.
 625 **************************************************************************/
 626 bool dio_get_bool32(struct data_in *din, bool * dest)
 627 {
 628   int ival;
 629
 630   if (!dio_get_uint32(din, &ival)) {
 631     return FALSE;
 632   }
 633
 634   if (ival != 0 && ival != 1) {
 635     log_packet("Got a bad boolean: %d", ival);
 636     return FALSE;
 637   }
 638
 639   *dest = (ival != 0);
 640   return TRUE;
 641 }
 642
 643 /**************************************************************************
 644   Get a float number, which have been multiplied by 'float_factor' and
 645   encoded into a uint32 by dio_put_float().
 646 **************************************************************************/
 647 bool dio_get_float(struct data_in *din, float *dest, int float_factor)
 648 {
 649   int ival;
 650
 651   if (!dio_get_uint32(din, &ival)) {
 652     return FALSE;
 653   }
 654
 655   *dest = (float) ival / float_factor;
 656   return TRUE;
 657 }
 658
 659 /**************************************************************************
 660   Take value from 8 bits.
 661 **************************************************************************/
 662 bool dio_get_sint8(struct data_in *din, int *dest)
 663 {
 664   int tmp;
 665
 666   if (!dio_get_uint8(din, &tmp)) {
 667     return FALSE;
 668   }
 669
 670   if (tmp > 0x7f) {
 671     tmp -= 0x100;
 672   }
 673   *dest = tmp;
 674   return TRUE;
 675 }
 676
 677 /**************************************************************************
 678   Take value from 16 bits.
 679 **************************************************************************/
 680 bool dio_get_sint16(struct data_in *din, int *dest)
 681 {
 682   int tmp;
 683
 684   if (!dio_get_uint16(din, &tmp)) {
 685     return FALSE;
 686   }
 687
 688   if (tmp > 0x7fff) {
 689     tmp -= 0x10000;
 690   }
 691   *dest = tmp;
 692   return TRUE;
 693 }
 694
 695 /**************************************************************************
 696   Take value from 32 bits.
 697 **************************************************************************/
 698 bool dio_get_sint32(struct data_in *din, int *dest)
 699 {
 700   int tmp;
 701
 702   if (!dio_get_uint32(din, &tmp)) {
 703     return FALSE;
 704   }
 705
 706 #if SIZEOF_INT != 4
 707   if (tmp > 0x7fffffff) {
 708     tmp -= 0x100000000;
 709   }
 710 #endif
 711
 712   *dest = tmp;
 713   return TRUE;
 714 }
 715
 716 /**************************************************************************
 717   Take memory block directly.
 718 **************************************************************************/
 719 bool dio_get_memory(struct data_in *din, void *dest, size_t dest_size)
 720 {
 721   if (!enough_data(din, dest_size)) {
 722     log_packet("Got too short memory");
 723     return FALSE;
 724   }
 725
 726   memcpy(dest, ADD_TO_POINTER(din->src, din->current), dest_size);
 727   din->current += dest_size;
 728   return TRUE;
 729 }
 730
 731 /**************************************************************************
 732   Take string. Conversion callback is used.
 733 **************************************************************************/
 734 bool dio_get_string(struct data_in *din, char *dest, size_t max_dest_size)
 735 {
 736   char *c;
 737   size_t offset, remaining;
 738
 739   fc_assert(max_dest_size > 0);
 740
 741   if (!enough_data(din, 1)) {
 742     log_packet("Got a bad string");
 743     return FALSE;
 744   }
 745
 746   remaining = dio_input_remaining(din);
 747   c = ADD_TO_POINTER(din->src, din->current);
 748
 749   /* avoid using strlen (or strcpy) on an (unsigned char*)  --dwp */
 750   for (offset = 0; offset < remaining && c[offset] != '\0'; offset++) {
 751     /* nothing */
 752   }
 753
 754   if (offset >= remaining) {
 755     log_packet("Got a too short string");
 756     return FALSE;
 757   }
 758
 759   if (!(*get_conv_callback) (dest, max_dest_size, c, offset)) {
 760     log_packet("Got a bad encoded string");
 761     return FALSE;
 762   }
 763
 764   din->current += offset + 1;
 765   return TRUE;
 766 }
 767
 768 /**************************************************************************
 769   Take tech numbers until A_LAST encountered, or MAX_NUM_TECH_LIST techs
 770   retrieved.
 771 **************************************************************************/
 772 bool dio_get_tech_list(struct data_in *din, int *dest)
 773 {
 774   int i;
 775
 776   for (i = 0; i < MAX_NUM_TECH_LIST; i++) {
 777     if (!dio_get_uint8(din, &dest[i])) {
 778       log_packet("Got a too short tech list");
 779       return FALSE;
 780     }
 781     if (dest[i] == A_LAST) {
 782       break;
 783     }
 784   }
 785
 786   for (; i < MAX_NUM_TECH_LIST; i++) {
 787     dest[i] = A_LAST;
 788   }
 789
 790   return TRUE;
 791 }
 792
 793 /**************************************************************************
 794   Take unit type numbers until U_LAST encountered, or MAX_NUM_UNIT_LIST
 795   types retrieved.
 796 **************************************************************************/
 797 bool dio_get_unit_list(struct data_in *din, int *dest)
 798 {
 799   int i;
 800
 801   for (i = 0; i < MAX_NUM_UNIT_LIST; i++) {
 802     if (!dio_get_uint8(din, &dest[i])) {
 803       log_packet("Got a too short unit list");
 804       return FALSE;
 805     }
 806     if (dest[i] == U_LAST) {
 807       break;
 808     }
 809   }
 810
 811   for (; i < MAX_NUM_UNIT_LIST; i++) {
 812     dest[i] = U_LAST;
 813   }
 814
 815   return TRUE;
 816 }
 817
 818 /**************************************************************************
 819   Take building type numbers until B_LAST encountered, or
 820   MAX_NUM_BUILDING_LIST types retrieved.
 821 **************************************************************************/
 822 bool dio_get_building_list(struct data_in *din, int *dest)
 823 {
 824   int i;
 825
 826   for (i = 0; i < MAX_NUM_BUILDING_LIST; i++) {
 827     if (!dio_get_uint8(din, &dest[i])) {
 828       log_packet("Got a too short building list");
 829       return FALSE;
 830     }
 831     if (dest[i] == B_LAST) {
 832       break;
 833     }
 834   }
 835
 836   for (; i < MAX_NUM_BUILDING_LIST; i++) {
 837     dest[i] = B_LAST;
 838   }
 839
 840   return TRUE;
 841 }
 842
 843 /**************************************************************************
 844   Take worklist item count and then kind and number for each item, and
 845   put them to provided worklist.
 846 **************************************************************************/
 847 bool dio_get_worklist(struct data_in *din, struct worklist *pwl)
 848 {
 849   int i, length;
 850
 851   worklist_init(pwl);
 852
 853   if (!dio_get_uint8(din, &length)) {
 854     log_packet("Got a bad worklist");
 855     return FALSE;
 856   }
 857
 858   for (i = 0; i < length; i++) {
 859     int identifier;
 860     int kind;
 861
 862     if (!dio_get_uint8(din, &kind)
 863         || !dio_get_uint8(din, &identifier)) {
 864       log_packet("Got a too short worklist");
 865       return FALSE;
 866     }
 867
 868     /*
 869      * FIXME: the value returned by universal_by_number() should be checked!
 870      */
 871     worklist_append(pwl, universal_by_number(kind, identifier));
 872   }
 873
 874   return TRUE;
 875 }
 876
 877 /**************************************************************************
 878   Take vector of 8 bit values and insert stop_value after them. stop_value
 879   does not need to fit in 8 bits.
 880 **************************************************************************/
 881 bool dio_get_uint8_vec8(struct data_in *din, int **values, int stop_value)
 882 {
 883   int count, inx;
 884   int *vec;
 885
 886   if (!dio_get_uint8(din, &count)) {
 887     return FALSE;
 888   }
 889
 890   vec = fc_calloc(count + 1, sizeof(*vec));
 891   for (inx = 0; inx < count; inx++) {
 892     if (!dio_get_uint8(din, vec + inx)) {
 893       free (vec);
 894       return FALSE;
 895     }
 896   }
 897   vec[inx] = stop_value;
 898   *values = vec;
 899
 900   return TRUE;
 901 }
 902
 903 /**************************************************************************
 904  Receive vector of uint6 values.
 905 **************************************************************************/
 906 bool dio_get_uint16_vec8(struct data_in *din, int **values, int stop_value)
 907 {
 908   int count, inx;
 909   int *vec;
 910
 911   if (!dio_get_uint8(din, &count)) {
 912     return FALSE;
 913   }
 914
 915   vec = fc_calloc(count + 1, sizeof(*vec));
 916   for (inx = 0; inx < count; inx++) {
 917     if (!dio_get_uint16(din, vec + inx)) {
 918       free (vec);
 919       return FALSE;
 920     }
 921   }
 922   vec[inx] = stop_value;
 923   *values = vec;
 924
 925   return TRUE;
 926 }
 927
 928 /**************************************************************************
 929   De-serialize a requirement.
 930 **************************************************************************/
 931 bool dio_get_requirement(struct data_in *din, struct requirement *preq)
 932 {
 933   int type, range, value;
 934   bool survives, negated;
 935
 936   if (!dio_get_uint8(din, &type)
 937       || !dio_get_sint32(din, &value)
 938       || !dio_get_uint8(din, &range)
 939       || !dio_get_bool8(din, &survives)
 940       || !dio_get_bool8(din, &negated)) {
 941     log_packet("Got a bad requirement");
 942     return FALSE;
 943   }
 944
 945   /*
 946    * FIXME: the value returned by req_from_values() should be checked!
 947    */
 948   *preq = req_from_values(type, range, survives, negated, value);
 949
 950   return TRUE;
 951 }
 952
 953 /**************************************************************************
 954   Serialize a requirement.
 955 **************************************************************************/
 956 void dio_put_requirement(struct data_out *dout, const struct requirement *preq)
 957 {
 958   int type, range, value;
 959   bool survives, negated;
 960
 961   req_get_values(preq, &type, &range, &survives, &negated, &value);
 962
 963   dio_put_uint8(dout, type);
 964   dio_put_sint32(dout, value);
 965   dio_put_uint8(dout, range);
 966   dio_put_bool8(dout, survives);
 967   dio_put_bool8(dout, negated);
 968 }