| /* 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 |
| |
