encoder.c

#include <coms/coms.h>
#include "main-header.h"
#include <platform-header.h>
 
//#define CNWDEBUGCOM printf
 
#ifndef CNWDEBUGCOM
#define CNWDEBUGCOM(a, ...) noop()
#endif
 
 
int add_uint8(byte *buf, int bufsize, int *offset, uint32_t value) {
  if (bufsize - *offset < 2) {
    return 4;
  }
  buf[*offset] = value & 0xFF;
  *offset = *offset + 1;
  return 0;
}
 
int add_uint16(byte *buf, int bufsize, int *offset, uint32_t value) {
  if (bufsize - *offset < 3) {
    return 3;
  }
  int i;
 
  for (i = 0; i < 2; i++) {
    buf[*offset] = value & 0xFF;
    value = value >> 8;
    *offset = *offset + 1;
  }
  return 0;
}
 
 
int add_uint32(byte *buf, int bufsize, int *offset, uint32_t value) {
  if (bufsize - *offset < 5) {
    return 5;
  }
  int i;
 
  for (i = 0; i < 4; i++) {
    buf[*offset] = value & 0xFF;
    value = value >> 8;
    *offset = *offset + 1;
  }
  return 0;
}
 
 
int add_uint64(byte *buf, int bufsize, int *offset, uint64_t value) {
  if (bufsize - *offset < 9) {
    return 2;
  }
  int i;
 
  for (i = 0; i < 8; i++) {
    buf[*offset] = value & 0xFF;
    value = value >> 8;
    *offset = *offset + 1;
  }
  return 0;
}
/*
 * \brief  encode "com" into on-the-wire format. return 0 - ok, otherwise error. buf will not include '{' or '}'
 * bufsize will be set to the length of the command in buf.
 * buf will not be 'escaped'
 */
int encode(byte *buf, int *bufsize, struct command *com) {
  int err;
 
  CNWDEBUGCOM("-------- Encoding --------\n");
 
  if (*bufsize < 37) {
    return 1;
  }
  int offset = 0;
 
  buf[offset++] = 'b';
  buf[offset++] = 1;    // version
  buf[offset++] = 0;    //length, placeholder
  buf[offset++] = 0;    //length, placeholder
  buf[offset++] = 0;    //chksum, placeholder
  buf[offset++] = 0;    //chksum, placeholder
  if ((err = add_uint64(buf, *bufsize, &offset, (uint64_t)com->sender)) != 0) {
    return err;
  }
  if ((err = add_uint64(buf, *bufsize, &offset, (uint64_t)com->recipient)) != 0) {
    return err;
  }
  if ((err = add_uint64(buf, *bufsize, &offset, (uint64_t)com->target)) != 0) {
    return err;
  }
  if ((err = add_uint32(buf, *bufsize, &offset, (uint32_t)com->index)) != 0) {
    return err;
  }
  if ((err = add_uint8(buf, *bufsize, &offset, com->com)) != 0) {
    return err;
  }
  if ((err = add_uint8(buf, *bufsize, &offset, com->flags)) != 0) {
    return err;
  }
  if ((err = add_uint8(buf, *bufsize, &offset, com->argctr)) != 0) {
    return err;
  }
 
  // encode args
  int i;
 
  for (i = 0; i < com->argctr; i++) {
    byte *arg = (byte *)get_arg_new(com, i);
    if (arg == NULL) {
      return 8;
    }
    int argsize = get_arg_size_inmem(com, i); // length in memory. (this is normally same as "on-the-wire", except arrays are terminated with NUL
    int header = 0;
    if (arg[1] & (1 << 7)) {
      header = -1; // do not copy the NUL terminator, thus decrement length by one
    }
 
    if ((offset + argsize) >= *bufsize) {
      return 7;
    }
    int j;
    for (j = 0; j < argsize + header; j++) {
      buf[offset++] = arg[j];
    }
  }
  // args are encoded
 
  int temp = 2;
 
  add_uint16(buf, *bufsize, &temp, offset); // fix length
  uint16_t chk = 0;
 
  for (i = 0; i < offset; i++) {
    chk = chk + (chk ^ ((uint16_t)buf[i]));
  }
  add_uint16(buf, *bufsize, &temp, chk); // fix checksum
 
  *bufsize = offset;
  return 0;
}
 
int typesize(uint8_t type) {
  if ((type == 1) || (type == 5)) {
    return 1;
  }
  if ((type == 2) || (type = 6)) {
    return 2;
  }
  if ((type == 3) || (type = 7)) {
    return 4;
  }
  if ((type == 4) || (type = 8)) {
    return 8;
  }
  printf("WARNING - got a type %i\n", type);
  return 0;
}
 
// return total length (inc. type and array size) in bytes of field
int fieldlen(uint8_t fieldtype, uint8_t array_size) {
  uint8_t ts = typesize(fieldtype & ~(1 << 7));
 
  if (fieldtype & (1 << 7)) {
    return ts * array_size;     // type, num elements
  }
  return ts;                    // add fieldtype
}
// return total length (inc. type and array size) in bytes in memory (aka how many to skip to arrive at next field)
int fieldlen_inmem(uint8_t fieldtype, uint8_t array_size) {
  int t = fieldlen(fieldtype, array_size);
 
  if (fieldtype & (1 << 7)) {
    return t + 4;       // add fieldnum type,array,size+trailing 0
  }
  return t + 2;         // add fieldnum,fieldtype
}