dataio_raw.c

Go to the documentation of this file.

/***********************************************************************
 Freeciv - Copyright (C) 1996 - A Kjeldberg, L Gregersen, P Unold
   This program is free software; you can redistribute it and/or modify
   it under the terms of the GNU General Public License as published by
   the Free Software Foundation; either version 2, or (at your option)
   any later version.
 
   This program is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
   GNU General Public License for more details.
***********************************************************************/
 
/*
 * The DataIO module provides a system independent (endianness and
 * sizeof(int) independent) way to write and read data. It supports
 * multiple datas which are collected in a buffer. It provides
 * recognition of error cases like "not enough space" or "not enough
 * data".
 */
 
#ifdef HAVE_CONFIG_H
#include <fc_config.h>
#endif
 
#include "fc_prehdrs.h"
 
#include <limits.h>
#include <math.h>
#include <stdint.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
 
#ifdef FREECIV_HAVE_SYS_TYPES_H
#include <sys/types.h>
#endif
#ifdef HAVE_SYS_SOCKET_H
#include <sys/socket.h>
#endif
#ifdef HAVE_NETINET_IN_H
#include <netinet/in.h>
#endif
#ifdef HAVE_ARPA_INET_H
#include <arpa/inet.h>
#endif
 
/* utility */
#include "bitvector.h"
#include "capability.h"
#include "log.h"
#include "mem.h"
#include "support.h"
 
/* common */
#include "events.h"
#include "player.h"
#include "requirements.h"
#include "tech.h"
#include "worklist.h"
 
/* common/aicore */
#include "cm.h"
 
#include "dataio.h"
 
static bool get_conv(char *dst, size_t ndst, const char *src,
                     size_t nsrc);
 
static DIO_PUT_CONV_FUN put_conv_callback = nullptr;
static DIO_GET_CONV_FUN get_conv_callback = get_conv;
 
/* Uncomment to make field range tests to asserts, fatal with -F */
/* #define FIELD_RANGE_ASSERT */
 
#if defined(FREECIV_TESTMATIC) && !defined(FIELD_RANGE_ASSERT)
#define FIELD_RANGE_ASSERT
#endif
 
#ifdef FIELD_RANGE_ASSERT
/* Do log_error() first, so we get its output even if
 * fc_assert() is fatal.
 * fc_assert() before the _action_ might fix
 * what we should find out to fail. */
#define FIELD_RANGE_TEST(_test_, _action_, _format_, ...) \
  if (_test_) {                                           \
    log_error(_format_, ## __VA_ARGS__);                  \
    fc_assert(!(_test_));                                 \
    _action_                                              \
  }
#else  /* FIELD_RANGE_ASSERT */
#define FIELD_RANGE_TEST(_test_, _action_, _format_, ...) \
  if (_test_) {                                           \
    log_error(_format_, ## __VA_ARGS__);                  \
    _action_                                              \
  }
#endif /* FIELD_RANGE_ASSERT */
 
/**********************************************************************/
void dio_set_put_conv_callback(DIO_PUT_CONV_FUN fun)
{
  put_conv_callback = fun;
}
 
/**********************************************************************/
static bool get_conv(char *dst, size_t ndst, const char *src,
                     size_t nsrc)
{
  size_t len = nsrc;            /* Length to copy, not including null */
  bool ret = TRUE;
 
  if (ndst > 0 && len >= ndst) {
    ret = FALSE;
    len = ndst - 1;
  }
 
  memcpy(dst, src, len);
  dst[len] = '\0';
 
  return ret;
}
 
/**********************************************************************/
void dio_set_get_conv_callback(DIO_GET_CONV_FUN fun)
{
  get_conv_callback = fun;
}
 
/**********************************************************************/
bool dataio_get_conv_callback(char *dst, size_t ndst, const char *src,
                              size_t nsrc)
{
  return get_conv_callback(dst, ndst, src, nsrc);
}
 
/**********************************************************************/
static bool enough_space(struct raw_data_out *d_out, size_t size)
{
  if (d_out->current + size > d_out->dest_size) {
    d_out->too_short = TRUE;
 
    return FALSE;
  } else {
    d_out->used = MAX(d_out->used, d_out->current + size);
 
    return TRUE;
  }
}
 
/**********************************************************************/
static bool enough_data(struct data_in *din, size_t size)
{
  return dio_input_remaining(din) >= size;
}
 
/**********************************************************************/
void dio_output_init(struct raw_data_out *d_out, void *destination,
                     size_t dest_size)
{
  d_out->dest = destination;
  d_out->dest_size = dest_size;
  d_out->current = 0;
  d_out->used = 0;
  d_out->too_short = FALSE;
}
 
/**********************************************************************/
size_t dio_output_used(struct raw_data_out *d_out)
{
  return d_out->used;
}
 
/**********************************************************************/
void dio_output_rewind(struct raw_data_out *d_out)
{
  d_out->current = 0;
}
 
/**********************************************************************/
void dio_input_init(struct data_in *din, const void *src, size_t src_size)
{
  din->src = src;
  din->src_size = src_size;
  din->current = 0;
}
 
/**********************************************************************/
void dio_input_rewind(struct data_in *din)
{
  din->current = 0;
}
 
/**********************************************************************/
size_t dio_input_remaining(struct data_in *din)
{
  return din->src_size - din->current;
}
 
/**********************************************************************/
size_t data_type_size(enum data_type type)
{
  switch (type) {
  case DIOT_UINT8:
  case DIOT_SINT8:
    return 1;
  case DIOT_UINT16:
  case DIOT_SINT16:
    return 2;
  case DIOT_UINT32:
  case DIOT_SINT32:
    return 4;
  case DIOT_LAST:
    break;
  }
 
  fc_assert_msg(FALSE, "data_type %d not handled.", type);
  return 0;
}
 
/**********************************************************************/
bool dio_input_skip(struct data_in *din, size_t size)
{
  if (enough_data(din, size)) {
    din->current += size;
    return TRUE;
  } else {
    return FALSE;
  }
}
 
/**********************************************************************/
int dio_put_uint8_raw(struct raw_data_out *d_out, int value)
{
  uint8_t x = value;
 
  FC_STATIC_ASSERT(sizeof(x) == 1, uint8_not_1_byte);
 
  FIELD_RANGE_TEST((int) x != value, ,
                   "Trying to put %d into 8 bits; "
                   "it will result %d at receiving side.",
                   value, (int) x);
 
  if (enough_space(d_out, 1)) {
    memcpy(ADD_TO_POINTER(d_out->dest, d_out->current), &x, 1);
    d_out->current++;
  }
 
  return 0;
}
 
/**********************************************************************/
int dio_put_uint16_raw(struct raw_data_out *d_out, int value)
{
  uint16_t x = htons(value);
 
  FC_STATIC_ASSERT(sizeof(x) == 2, uint16_not_2_bytes);
 
  FIELD_RANGE_TEST((int) ntohs(x) != value, ,
                   "Trying to put %d into 16 bits; "
                   "it will result %d at receiving side.",
                   value, (int) ntohs(x));
 
  if (enough_space(d_out, 2)) {
    memcpy(ADD_TO_POINTER(d_out->dest, d_out->current), &x, 2);
    d_out->current += 2;
  }
 
  return 0;
}
 
/**********************************************************************/
int dio_put_uint32_raw(struct raw_data_out *d_out, int value)
{
  uint32_t x = htonl(value);
 
  FC_STATIC_ASSERT(sizeof(x) == 4, uint32_not_4_bytes);
 
  FIELD_RANGE_TEST((int) ntohl(x) != value, ,
                   "Trying to put %d into 32 bits; "
                   "it will result %d at receiving side.",
                   value, (int) ntohl(x));
 
  if (enough_space(d_out, 4)) {
    memcpy(ADD_TO_POINTER(d_out->dest, d_out->current), &x, 4);
    d_out->current += 4;
  }
 
  return 0;
}
 
/**********************************************************************/
int dio_put_type_raw(struct raw_data_out *d_out, enum data_type type,
                     int value)
{
  switch (type) {
  case DIOT_UINT8:
    return dio_put_uint8_raw(d_out, value);
  case DIOT_UINT16:
    return dio_put_uint16_raw(d_out, value);
  case DIOT_UINT32:
    return dio_put_uint32_raw(d_out, value);
  case DIOT_SINT8:
    return dio_put_sint8_raw(d_out, value);
  case DIOT_SINT16:
    return dio_put_sint16_raw(d_out, value);
  case DIOT_SINT32:
    return dio_put_sint32_raw(d_out, value);
  case DIOT_LAST:
    break;
  }
 
  fc_assert_msg(FALSE, "data_type %d not handled.", type);
 
  return -1;
}
 
/**********************************************************************/
int dio_put_sint8_raw(struct raw_data_out *d_out, int value)
{
  return dio_put_uint8_raw(d_out, 0 <= value ? value : value + 0x100);
}
 
/**********************************************************************/
int dio_put_sint16_raw(struct raw_data_out *d_out, int value)
{
  return dio_put_uint16_raw(d_out, 0 <= value ? value : value + 0x10000);
}
 
/**********************************************************************/
int dio_put_sint32_raw(struct raw_data_out *d_out, int value)
{
#if SIZEOF_INT == 4
  return dio_put_uint32_raw(d_out, value);
#else
  return dio_put_uint32_raw(d_out, (0 <= value ? value : value + 0x100000000));
#endif
}
 
/**********************************************************************/
int dio_put_bool8_raw(struct raw_data_out *d_out, bool value)
{
  FIELD_RANGE_TEST(value != TRUE && value != FALSE,
                   value = (value != FALSE);,
                   "Trying to put a non-boolean: %d", (int) value);
 
  return dio_put_uint8_raw(d_out, value ? 1 : 0);
}
 
/**********************************************************************/
int dio_put_bool32_raw(struct raw_data_out *d_out, bool value)
{
  FIELD_RANGE_TEST(value != TRUE && value != FALSE,
                   value = (value != FALSE);,
                   "Trying to put a non-boolean: %d",
                   (int) value);
 
  return dio_put_uint32_raw(d_out, value ? 1 : 0);
}
 
/**********************************************************************/
int dio_put_ufloat_raw(struct raw_data_out *d_out, float value,
                       int float_factor)
{
  uint32_t v = value * float_factor;
 
  FIELD_RANGE_TEST(fabsf((float) v / float_factor - value) > 1.1 / float_factor, ,
                   "Trying to put %f with factor %d in 32 bits; "
                   "it will result %f at receiving side, having error of %f units.",
                   value, float_factor, (float) v / float_factor,
                   fabsf((float) v / float_factor - value) * float_factor);
 
  return dio_put_uint32_raw(d_out, v);
}
 
/**********************************************************************/
int dio_put_sfloat_raw(struct raw_data_out *d_out, float value,
                       int float_factor)
{
  int32_t v = value * float_factor;
 
  FIELD_RANGE_TEST(fabsf((float) v / float_factor - value) > 1.1 / float_factor, ,
                   "Trying to put %f with factor %d in 32 bits; "
                   "it will result %f at receiving side, having error of %f units.",
                   value, float_factor, (float) v / float_factor,
                   fabsf((float) v / float_factor - value) * float_factor);
 
  return dio_put_sint32_raw(d_out, v);
}
 
/**********************************************************************/
int dio_put_uint8_vec8_raw(struct raw_data_out *d_out, int *values,
                           int stop_value)
{
  size_t count;
  int e = 0;
 
  for (count = 0; values[count] != stop_value; count++) {
    /* nothing */
  }
 
  if (enough_space(d_out, 1 + count)) {
    size_t i;
 
    e |= dio_put_uint8_raw(d_out, count);
 
    for (i = 0; i < count; i++) {
      e |= dio_put_uint8_raw(d_out, values[i]);
    }
  }
 
  return e;
}
 
/**********************************************************************/
int dio_put_uint16_vec8_raw(struct raw_data_out *d_out, int *values,
                            int stop_value)
{
  size_t count;
  int e = 0;
 
  for (count = 0; values[count] != stop_value; count++) {
    /* nothing */
  }
 
  if (enough_space(d_out, 1 + 2 * count)) {
    size_t i;
 
    e |= dio_put_uint8_raw(d_out, count);
 
    for (i = 0; i < count; i++) {
      e |= dio_put_uint16_raw(d_out, values[i]);
    }
  }
 
  return e;
}
 
/**********************************************************************/
int dio_put_memory_raw(struct raw_data_out *d_out, const void *value,
                       size_t size)
{
  if (enough_space(d_out, size)) {
    memcpy(ADD_TO_POINTER(d_out->dest, d_out->current), value, size);
    d_out->current += size;
  }
 
  return 0;
}
 
/**********************************************************************/
int dio_put_string_raw(struct raw_data_out *d_out, const char *value)
{
  if (put_conv_callback) {
    size_t length;
    char *buffer;
    int e = 0;
 
    if ((buffer = (*put_conv_callback) (value, &length))) {
      e = dio_put_memory_raw(d_out, buffer, length + 1);
      free(buffer);
    }
 
    return e;
  } else {
    return dio_put_memory_raw(d_out, value, strlen(value) + 1);
  }
}
 
/**********************************************************************/
int dio_put_cm_parameter_raw(struct raw_data_out *d_out,
                             const struct cm_parameter *param)
{
  int i;
  int e = 0;
 
  for (i = 0; i < O_LAST; i++) {
    e |= dio_put_sint16_raw(d_out, param->minimal_surplus[i]);
  }
 
  e |= dio_put_bool8_raw(d_out, param->max_growth);
  e |= dio_put_bool8_raw(d_out, param->require_happy);
  e |= dio_put_bool8_raw(d_out, param->allow_disorder);
  e |= dio_put_bool8_raw(d_out, param->allow_specialists);
 
  for (i = 0; i < O_LAST; i++) {
    e |= dio_put_uint16_raw(d_out, param->factor[i]);
  }
 
  e |= dio_put_uint16_raw(d_out, param->happy_factor);
 
  return e;
}
 
/**********************************************************************/
int dio_put_unit_order_raw(struct raw_data_out *d_out,
                           const struct unit_order *order)
{
  int e = 0;
 
  e |= dio_put_uint8_raw(d_out, order->order);
  e |= dio_put_uint8_raw(d_out, order->activity);
  e |= dio_put_sint32_raw(d_out, order->target);
  e |= dio_put_sint16_raw(d_out, order->sub_target);
  e |= dio_put_uint8_raw(d_out, order->action);
  e |= dio_put_sint8_raw(d_out, order->dir);
 
  return e;
}
 
/**********************************************************************/
int dio_put_worklist_raw(struct raw_data_out *d_out, const struct worklist *pwl)
{
  int i, length = worklist_length(pwl);
  int e = 0;
 
  e |= dio_put_uint8_raw(d_out, length);
  for (i = 0; i < length; i++) {
    const struct universal *pcp = &(pwl->entries[i]);
 
    e |= dio_put_uint8_raw(d_out, pcp->kind);
    e |= dio_put_uint8_raw(d_out, universal_number(pcp));
  }
 
  return e;
}
 
/**********************************************************************/
bool dio_get_uint8_raw(struct data_in *din, int *dest)
{
  uint8_t x;
 
  FC_STATIC_ASSERT(sizeof(x) == 1, uint8_not_byte);
 
  if (!enough_data(din, 1)) {
    log_packet("Packet too short to read 1 byte");
 
    return FALSE;
  }
 
  memcpy(&x, ADD_TO_POINTER(din->src, din->current), 1);
  *dest = x;
  din->current++;
  return TRUE;
}
 
/**********************************************************************/
bool dio_get_uint16_raw(struct data_in *din, int *dest)
{
  uint16_t x;
 
  FC_STATIC_ASSERT(sizeof(x) == 2, uint16_not_2_bytes);
 
  if (!enough_data(din, 2)) {
    log_packet("Packet too short to read 2 bytes");
 
    return FALSE;
  }
 
  memcpy(&x, ADD_TO_POINTER(din->src, din->current), 2);
  *dest = ntohs(x);
  din->current += 2;
  return TRUE;
}
 
/**********************************************************************/
bool dio_get_uint32_raw(struct data_in *din, int *dest)
{
  uint32_t x;
 
  FC_STATIC_ASSERT(sizeof(x) == 4, uint32_not_4_bytes);
 
  if (!enough_data(din, 4)) {
    log_packet("Packet too short to read 4 bytes");
 
    return FALSE;
  }
 
  memcpy(&x, ADD_TO_POINTER(din->src, din->current), 4);
  *dest = ntohl(x);
  din->current += 4;
  return TRUE;
}
 
/**********************************************************************/
bool dio_get_type_raw(struct data_in *din, enum data_type type, int *dest)
{
  switch (type) {
  case DIOT_UINT8:
    return dio_get_uint8_raw(din, dest);
  case DIOT_UINT16:
    return dio_get_uint16_raw(din, dest);
  case DIOT_UINT32:
    return dio_get_uint32_raw(din, dest);
  case DIOT_SINT8:
    return dio_get_sint8_raw(din, dest);
  case DIOT_SINT16:
    return dio_get_sint16_raw(din, dest);
  case DIOT_SINT32:
    return dio_get_sint32_raw(din, dest);
  case DIOT_LAST:
    break;
  }
 
  fc_assert_msg(FALSE, "data_type %d not handled.", type);
  return FALSE;
}
 
/**********************************************************************/
bool dio_get_bool8_raw(struct data_in *din, bool *dest)
{
  int ival;
 
  if (!dio_get_uint8_raw(din, &ival)) {
    return FALSE;
  }
 
  if (ival != 0 && ival != 1) {
    log_packet("Got a bad boolean: %d", ival);
    return FALSE;
  }
 
  *dest = (ival != 0);
  return TRUE;
}
 
/**********************************************************************/
bool dio_get_bool32_raw(struct data_in *din, bool * dest)
{
  int ival;
 
  if (!dio_get_uint32_raw(din, &ival)) {
    return FALSE;
  }
 
  if (ival != 0 && ival != 1) {
    log_packet("Got a bad boolean: %d", ival);
    return FALSE;
  }
 
  *dest = (ival != 0);
  return TRUE;
}
 
/**********************************************************************/
bool dio_get_ufloat_raw(struct data_in *din, float *dest, int float_factor)
{
  int ival;
 
  if (!dio_get_uint32_raw(din, &ival)) {
    return FALSE;
  }
 
  *dest = (float) ival / float_factor;
  return TRUE;
}
 
/**********************************************************************/
bool dio_get_sfloat_raw(struct data_in *din, float *dest, int float_factor)
{
  int ival;
 
  if (!dio_get_sint32_raw(din, &ival)) {
    return FALSE;
  }
 
  *dest = (float) ival / float_factor;
  return TRUE;
}
 
/**********************************************************************/
bool dio_get_sint8_raw(struct data_in *din, int *dest)
{
  int tmp;
 
  if (!dio_get_uint8_raw(din, &tmp)) {
    return FALSE;
  }
 
  if (tmp > 0x7f) {
    tmp -= 0x100;
  }
  *dest = tmp;
  return TRUE;
}
 
/**********************************************************************/
bool dio_get_sint16_raw(struct data_in *din, int *dest)
{
  int tmp;
 
  if (!dio_get_uint16_raw(din, &tmp)) {
    return FALSE;
  }
 
  if (tmp > 0x7fff) {
    tmp -= 0x10000;
  }
  *dest = tmp;
  return TRUE;
}
 
/**********************************************************************/
bool dio_get_sint32_raw(struct data_in *din, int *dest)
{
  int tmp;
 
  if (!dio_get_uint32_raw(din, &tmp)) {
    return FALSE;
  }
 
#if SIZEOF_INT != 4
  if (tmp > 0x7fffffff) {
    tmp -= 0x100000000;
  }
#endif
 
  *dest = tmp;
  return TRUE;
}
 
/**********************************************************************/
bool dio_get_memory_raw(struct data_in *din, void *dest, size_t dest_size)
{
  if (!enough_data(din, dest_size)) {
    log_packet("Got too short memory");
    return FALSE;
  }
 
  memcpy(dest, ADD_TO_POINTER(din->src, din->current), dest_size);
  din->current += dest_size;
  return TRUE;
}
 
/**********************************************************************/
bool dio_get_string_raw(struct data_in *din, char *dest, size_t max_dest_size)
{
  char *c;
  size_t offset, remaining;
 
  fc_assert(max_dest_size > 0);
 
  if (!enough_data(din, 1)) {
    log_packet("Got a bad string");
    return FALSE;
  }
 
  remaining = dio_input_remaining(din);
  c = ADD_TO_POINTER(din->src, din->current);
 
  /* avoid using strlen (or strcpy) on an (unsigned char*)  --dwp */
  for (offset = 0; offset < remaining && c[offset] != '\0'; offset++) {
    /* nothing */
  }
 
  if (offset >= remaining) {
    log_packet("Got a too short string");
    return FALSE;
  }
 
  if (!(*get_conv_callback) (dest, max_dest_size, c, offset)) {
    log_packet("Got a bad encoded string");
    return FALSE;
  }
 
  din->current += offset + 1;
  return TRUE;
}
 
/**********************************************************************/
bool dio_get_cm_parameter_raw(struct data_in *din,
                              struct cm_parameter *param)
{
  int i;
 
  for (i = 0; i < O_LAST; i++) {
    if (!dio_get_sint16_raw(din, &param->minimal_surplus[i])) {
      log_packet("Got a bad cm_parameter");
      return FALSE;
    }
  }
 
  if (!dio_get_bool8_raw(din, &param->max_growth)
      || !dio_get_bool8_raw(din, &param->require_happy)
      || !dio_get_bool8_raw(din, &param->allow_disorder)
      || !dio_get_bool8_raw(din, &param->allow_specialists)) {
    log_packet("Got a bad cm_parameter");
    return FALSE;
  }
 
  for (i = 0; i < O_LAST; i++) {
    if (!dio_get_uint16_raw(din, &param->factor[i])) {
      log_packet("Got a bad cm_parameter");
      return FALSE;
    }
  }
 
  if (!dio_get_uint16_raw(din, &param->happy_factor)) {
    log_packet("Got a bad cm_parameter");
    return FALSE;
  }
 
  return TRUE;
}
 
/**********************************************************************/
bool dio_get_unit_order_raw(struct data_in *din, struct unit_order *order)
{
  /* These fields are enums */
  int iorder, iactivity, idir;
 
  if (!dio_get_uint8_raw(din, &iorder)
      || !dio_get_uint8_raw(din, &iactivity)
      || !dio_get_sint32_raw(din, &order->target)
      || !dio_get_sint16_raw(din, &order->sub_target)
      || !dio_get_uint8_raw(din, &order->action)
      || !dio_get_sint8_raw(din, &idir)) {
    log_packet("Got a bad unit_order");
    return FALSE;
  }
 
  order->order = iorder;
  order->activity = iactivity;
  order->dir = idir;
 
  return TRUE;
}
 
/**********************************************************************/
bool dio_get_worklist_raw(struct data_in *din, struct worklist *pwl)
{
  int i, length;
 
  worklist_init(pwl);
 
  if (!dio_get_uint8_raw(din, &length)) {
    log_packet("Got a bad worklist");
    return FALSE;
  }
 
  for (i = 0; i < length; i++) {
    int identifier;
    int kind;
    struct universal univ;
 
    if (!dio_get_uint8_raw(din, &kind)
        || !dio_get_uint8_raw(din, &identifier)) {
      log_packet("Got a too short worklist");
      return FALSE;
    }
 
    /*
     * FIXME: the value returned by universal_by_number() should be checked!
     */
    univ = universal_by_number(kind, identifier);
    worklist_append(pwl, &univ);
  }
 
  return TRUE;
}
 
/**********************************************************************/
bool dio_get_uint8_vec8_raw(struct data_in *din, int **values, int stop_value)
{
  int count, inx;
  int *vec;
 
  if (!dio_get_uint8_raw(din, &count)) {
    return FALSE;
  }
 
  vec = fc_calloc(count + 1, sizeof(*vec));
  for (inx = 0; inx < count; inx++) {
    if (!dio_get_uint8_raw(din, vec + inx)) {
      free (vec);
      return FALSE;
    }
  }
  vec[inx] = stop_value;
  *values = vec;
 
  return TRUE;
}
 
/**********************************************************************/
bool dio_get_uint16_vec8_raw(struct data_in *din, int **values, int stop_value)
{
  int count, inx;
  int *vec;
 
  if (!dio_get_uint8_raw(din, &count)) {
    return FALSE;
  }
 
  vec = fc_calloc(count + 1, sizeof(*vec));
  for (inx = 0; inx < count; inx++) {
    if (!dio_get_uint16_raw(din, vec + inx)) {
      free (vec);
      return FALSE;
    }
  }
  vec[inx] = stop_value;
  *values = vec;
 
  return TRUE;
}
 
/**********************************************************************/
bool dio_get_action_probability_raw(struct data_in *din,
                                    struct act_prob *aprob)
{
  int min, max;
 
  if (!dio_get_uint8_raw(din, &min)
      || !dio_get_uint8_raw(din, &max)) {
    log_packet("Got a bad action probability");
    return FALSE;
  }
 
  aprob->min = min;
  aprob->max = max;
 
  return TRUE;
}
 
/**********************************************************************/
int dio_put_action_probability_raw(struct raw_data_out *d_out,
                                   const struct act_prob *aprob)
{
  int e = 0;
 
  e |= dio_put_uint8_raw(d_out, aprob->min);
  e |= dio_put_uint8_raw(d_out, aprob->max);
 
  return e;
}
 
/**********************************************************************/
bool dio_get_requirement_raw(struct data_in *din, struct requirement *preq)
{
  int type, range, value;
  bool survives, present, quiet;
 
  if (!dio_get_uint8_raw(din, &type)
      || !dio_get_sint32_raw(din, &value)
      || !dio_get_uint8_raw(din, &range)
      || !dio_get_bool8_raw(din, &survives)
      || !dio_get_bool8_raw(din, &present)
      || !dio_get_bool8_raw(din, &quiet)) {
    log_packet("Got a bad requirement");
    return FALSE;
  }
 
  /*
   * FIXME: the value returned by req_from_values() should be checked!
   */
  *preq = req_from_values(type, range, survives, present, quiet, value);
 
  return TRUE;
}
 
/**********************************************************************/
int dio_put_requirement_raw(struct raw_data_out *d_out,
                            const struct requirement *preq)
{
  int type, range, value;
  bool survives, present, quiet;
  int e = 0;
 
  req_get_values(preq, &type, &range, &survives, &present, &quiet, &value);
 
  e |= dio_put_uint8_raw(d_out, type);
  e |= dio_put_sint32_raw(d_out, value);
  e |= dio_put_uint8_raw(d_out, range);
  e |= dio_put_bool8_raw(d_out, survives);
  e |= dio_put_bool8_raw(d_out, present);
  e |= dio_put_bool8_raw(d_out, quiet);
 
  return e;
}
 
/**********************************************************************/
struct plocation *plocation_field_new(char *name)
{
  struct plocation *out = fc_malloc(sizeof(*out));
 
  out->kind = PADR_FIELD;
  out->name = name;
  out->sub_location = nullptr;
 
  return out;
}
 
/**********************************************************************/
struct plocation *plocation_elem_new(int number)
{
  struct plocation *out = fc_malloc(sizeof(*out));
 
  out->kind = PADR_ELEMENT;
  out->number = number;
  out->sub_location = nullptr;
 
  return out;
}
 
/**********************************************************************/
const char *plocation_name(const struct plocation *loc)
{
  static char locname[10];
 
  if (loc == nullptr) {
    return "No location";
  }
 
  switch (loc->kind) {
  case PADR_FIELD:
    return loc->name;
  case PADR_ELEMENT:
    fc_snprintf(locname, sizeof(locname), SIZE_T_PRINTF, loc->number);
    return locname;
  }
 
  return "Illegal location";
}