pb_common.c

/* pb_common.c: Common support functions for pb_encode.c and pb_decode.c.
 *
 * 2014 Petteri Aimonen <jpa@kapsi.fi>
 */
 
#include "pb_common.h"
 
static bool load_descriptor_values(pb_field_iter_t *iter) {
  uint32_t word0;
  uint32_t data_offset;
  int_least8_t size_offset;
 
  if (iter->index >= iter->descriptor->field_count) {
    return false;
  }
 
  word0 = PB_PROGMEM_READU32(iter->descriptor->field_info[iter->field_info_index]);
  iter->type = (pb_type_t)((word0 >> 8) & 0xFF);
 
  switch (word0 & 3) {
  case 0: {
    /* 1-word format */
    iter->array_size = 1;
    iter->tag = (pb_size_t)((word0 >> 2) & 0x3F);
    size_offset = (int_least8_t)((word0 >> 24) & 0x0F);
    data_offset = (word0 >> 16) & 0xFF;
    iter->data_size = (pb_size_t)((word0 >> 28) & 0x0F);
    break;
  }
 
  case 1: {
    /* 2-word format */
    uint32_t word1 = PB_PROGMEM_READU32(iter->descriptor->field_info[iter->field_info_index + 1]);
 
    iter->array_size = (pb_size_t)((word0 >> 16) & 0x0FFF);
    iter->tag = (pb_size_t)(((word0 >> 2) & 0x3F) | ((word1 >> 28) << 6));
    size_offset = (int_least8_t)((word0 >> 28) & 0x0F);
    data_offset = word1 & 0xFFFF;
    iter->data_size = (pb_size_t)((word1 >> 16) & 0x0FFF);
    break;
  }
 
  case 2: {
    /* 4-word format */
    uint32_t word1 = PB_PROGMEM_READU32(iter->descriptor->field_info[iter->field_info_index + 1]);
    uint32_t word2 = PB_PROGMEM_READU32(iter->descriptor->field_info[iter->field_info_index + 2]);
    uint32_t word3 = PB_PROGMEM_READU32(iter->descriptor->field_info[iter->field_info_index + 3]);
 
    iter->array_size = (pb_size_t)(word0 >> 16);
    iter->tag = (pb_size_t)(((word0 >> 2) & 0x3F) | ((word1 >> 8) << 6));
    size_offset = (int_least8_t)(word1 & 0xFF);
    data_offset = word2;
    iter->data_size = (pb_size_t)word3;
    break;
  }
 
  default: {
    /* 8-word format */
    uint32_t word1 = PB_PROGMEM_READU32(iter->descriptor->field_info[iter->field_info_index + 1]);
    uint32_t word2 = PB_PROGMEM_READU32(iter->descriptor->field_info[iter->field_info_index + 2]);
    uint32_t word3 = PB_PROGMEM_READU32(iter->descriptor->field_info[iter->field_info_index + 3]);
    uint32_t word4 = PB_PROGMEM_READU32(iter->descriptor->field_info[iter->field_info_index + 4]);
 
    iter->array_size = (pb_size_t)word4;
    iter->tag = (pb_size_t)(((word0 >> 2) & 0x3F) | ((word1 >> 8) << 6));
    size_offset = (int_least8_t)(word1 & 0xFF);
    data_offset = word2;
    iter->data_size = (pb_size_t)word3;
    break;
  }
  }
 
  if (!iter->message) {
    /* Avoid doing arithmetic on null pointers, it is undefined */
    iter->pField = NULL;
    iter->pSize = NULL;
  } else {
    iter->pField = (char *)iter->message + data_offset;
 
    if (size_offset) {
      iter->pSize = (char *)iter->pField - size_offset;
    } else if (PB_HTYPE(iter->type) == PB_HTYPE_REPEATED &&
               (PB_ATYPE(iter->type) == PB_ATYPE_STATIC ||
                PB_ATYPE(iter->type) == PB_ATYPE_POINTER)) {
      /* Fixed count array */
      iter->pSize = &iter->array_size;
    } else {
      iter->pSize = NULL;
    }
 
    if (PB_ATYPE(iter->type) == PB_ATYPE_POINTER && iter->pField != NULL) {
      iter->pData = *(void **)iter->pField;
    } else {
      iter->pData = iter->pField;
    }
  }
 
  if (PB_LTYPE_IS_SUBMSG(iter->type)) {
    iter->submsg_desc = iter->descriptor->submsg_info[iter->submessage_index];
  } else {
    iter->submsg_desc = NULL;
  }
 
  return true;
}
 
static void advance_iterator(pb_field_iter_t *iter) {
  iter->index++;
 
  if (iter->index >= iter->descriptor->field_count) {
    /* Restart */
    iter->index = 0;
    iter->field_info_index = 0;
    iter->submessage_index = 0;
    iter->required_field_index = 0;
  } else {
    /* Increment indexes based on previous field type.
     * All field info formats have the following fields:
     * - lowest 2 bits tell the amount of words in the descriptor (2^n words)
     * - bits 2..7 give the lowest bits of tag number.
     * - bits 8..15 give the field type.
     */
    uint32_t prev_descriptor = PB_PROGMEM_READU32(iter->descriptor->field_info[iter->field_info_index]);
    pb_type_t prev_type = (prev_descriptor >> 8) & 0xFF;
    pb_size_t descriptor_len = (pb_size_t)(1 << (prev_descriptor & 3));
 
    /* Add to fields.
     * The cast to pb_size_t is needed to avoid -Wconversion warning.
     * Because the data is is constants from generator, there is no danger of overflow.
     */
    iter->field_info_index = (pb_size_t)(iter->field_info_index + descriptor_len);
    iter->required_field_index = (pb_size_t)(iter->required_field_index + (PB_HTYPE(prev_type) == PB_HTYPE_REQUIRED));
    iter->submessage_index = (pb_size_t)(iter->submessage_index + PB_LTYPE_IS_SUBMSG(prev_type));
  }
}
 
bool pb_field_iter_begin(pb_field_iter_t *iter, const pb_msgdesc_t *desc, void *message) {
  memset(iter, 0, sizeof(*iter));
 
  iter->descriptor = desc;
  iter->message = message;
 
  return load_descriptor_values(iter);
}
 
bool pb_field_iter_begin_extension(pb_field_iter_t *iter, pb_extension_t *extension) {
  const pb_msgdesc_t *msg = (const pb_msgdesc_t *)extension->type->arg;
  bool status;
 
  uint32_t word0 = PB_PROGMEM_READU32(msg->field_info[0]);
 
  if (PB_ATYPE(word0 >> 8) == PB_ATYPE_POINTER) {
    /* For pointer extensions, the pointer is stored directly
     * in the extension structure. This avoids having an extra
     * indirection. */
    status = pb_field_iter_begin(iter, msg, &extension->dest);
  } else {
    status = pb_field_iter_begin(iter, msg, extension->dest);
  }
 
  iter->pSize = &extension->found;
  return status;
}
 
bool pb_field_iter_next(pb_field_iter_t *iter) {
  advance_iterator(iter);
  (void)load_descriptor_values(iter);
  return iter->index != 0;
}
 
bool pb_field_iter_find(pb_field_iter_t *iter, uint32_t tag) {
  if (iter->tag == tag) {
    return true;     /* Nothing to do, correct field already. */
  } else if (tag > iter->descriptor->largest_tag) {
    return false;
  } else {
    pb_size_t start = iter->index;
    uint32_t fieldinfo;
 
    if (tag < iter->tag) {
      /* Fields are in tag number order, so we know that tag is between
       * 0 and our start position. Setting index to end forces
       * advance_iterator() call below to restart from beginning. */
      iter->index = iter->descriptor->field_count;
    }
 
    do{
      /* Advance iterator but don't load values yet */
      advance_iterator(iter);
 
      /* Do fast check for tag number match */
      fieldinfo = PB_PROGMEM_READU32(iter->descriptor->field_info[iter->field_info_index]);
 
      if (((fieldinfo >> 2) & 0x3F) == (tag & 0x3F)) {
        /* Good candidate, check further */
        (void)load_descriptor_values(iter);
 
        if (iter->tag == tag &&
            PB_LTYPE(iter->type) != PB_LTYPE_EXTENSION) {
          /* Found it */
          return true;
        }
      }
    } while (iter->index != start);
 
    /* Searched all the way back to start, and found nothing. */
    (void)load_descriptor_values(iter);
    return false;
  }
}
 
bool pb_field_iter_find_extension(pb_field_iter_t *iter) {
  if (PB_LTYPE(iter->type) == PB_LTYPE_EXTENSION) {
    return true;
  } else {
    pb_size_t start = iter->index;
    uint32_t fieldinfo;
 
    do{
      /* Advance iterator but don't load values yet */
      advance_iterator(iter);
 
      /* Do fast check for field type */
      fieldinfo = PB_PROGMEM_READU32(iter->descriptor->field_info[iter->field_info_index]);
 
      if (PB_LTYPE((fieldinfo >> 8) & 0xFF) == PB_LTYPE_EXTENSION) {
        return load_descriptor_values(iter);
      }
    } while (iter->index != start);
 
    /* Searched all the way back to start, and found nothing. */
    (void)load_descriptor_values(iter);
    return false;
  }
}
 
static void *pb_const_cast(const void *p) {
  /* Note: this casts away const, in order to use the common field iterator
   * logic for both encoding and decoding. The cast is done using union
   * to avoid spurious compiler warnings. */
  union {
    void *      p1;
    const void *p2;
  } t;
  t.p2 = p;
  return t.p1;
}
 
bool pb_field_iter_begin_const(pb_field_iter_t *iter, const pb_msgdesc_t *desc, const void *message) {
  return pb_field_iter_begin(iter, desc, pb_const_cast(message));
}
 
bool pb_field_iter_begin_extension_const(pb_field_iter_t *iter, const pb_extension_t *extension) {
  return pb_field_iter_begin_extension(iter, (pb_extension_t *)pb_const_cast(extension));
}
 
bool pb_default_field_callback(pb_istream_t *istream, pb_ostream_t *ostream, const pb_field_t *field) {
  if (field->data_size == sizeof(pb_callback_t)) {
    pb_callback_t *pCallback = (pb_callback_t *)field->pData;
 
    if (pCallback != NULL) {
      if (istream != NULL && pCallback->funcs.decode != NULL) {
        return pCallback->funcs.decode(istream, field, &pCallback->arg);
      }
 
      if (ostream != NULL && pCallback->funcs.encode != NULL) {
        return pCallback->funcs.encode(ostream, field, &pCallback->arg);
      }
    }
  }
 
  return true;   /* Success, but didn't do anything */
}
 
#ifdef PB_VALIDATE_UTF8
 
/* This function checks whether a string is valid UTF-8 text.
 *
 * Algorithm is adapted from https://www.cl.cam.ac.uk/~mgk25/ucs/utf8_check.c
 * Original copyright: Markus Kuhn <http://www.cl.cam.ac.uk/~mgk25/> 2005-03-30
 * Licensed under "Short code license", which allows use under MIT license or
 * any compatible with it.
 */
bool pb_validate_utf8(const char *str) {
  const pb_byte_t *s = (const pb_byte_t *)str;
 
  while (*s) {
    if (*s < 0x80) {
      /* 0xxxxxxx */
      s++;
    } else if ((s[0] & 0xe0) == 0xc0) {
      /* 110XXXXx 10xxxxxx */
      if ((s[1] & 0xc0) != 0x80 ||
          (s[0] & 0xfe) == 0xc0) {                            /* overlong? */
        return false;
      } else {
        s += 2;
      }
    } else if ((s[0] & 0xf0) == 0xe0) {
      /* 1110XXXX 10Xxxxxx 10xxxxxx */
      if ((s[1] & 0xc0) != 0x80 ||
          (s[2] & 0xc0) != 0x80 ||
          (s[0] == 0xe0 && (s[1] & 0xe0) == 0x80) ||    /* overlong? */
          (s[0] == 0xed && (s[1] & 0xe0) == 0xa0) ||    /* surrogate? */
          (s[0] == 0xef && s[1] == 0xbf &&
           (s[2] & 0xfe) == 0xbe)) {                    /* U+FFFE or U+FFFF? */
        return false;
      } else {
        s += 3;
      }
    } else if ((s[0] & 0xf8) == 0xf0) {
      /* 11110XXX 10XXxxxx 10xxxxxx 10xxxxxx */
      if ((s[1] & 0xc0) != 0x80 ||
          (s[2] & 0xc0) != 0x80 ||
          (s[3] & 0xc0) != 0x80 ||
          (s[0] == 0xf0 && (s[1] & 0xf0) == 0x80) ||            /* overlong? */
          (s[0] == 0xf4 && s[1] > 0x8f) || s[0] > 0xf4) {       /* > U+10FFFF? */
        return false;
      } else {
        s += 4;
      }
    } else {
      return false;
    }
  }
 
  return true;
}
 
#endif