std::string Message::encode(){ std::string buffer; std::map<int, std::string>::const_iterator it; for(it=fields.begin(); it!=fields.end(); it++){ int tag = it->first; if(tag == 8 || tag == 9 || tag == 10){ continue; } const std::string &val = it->second; buffer.append(encode_field(tag, val)); } body_len_ = (int)buffer.size(); std::string header; header.append(encode_field(8, this->version())); header.append(encode_field(9, str(body_len_))); checksum_ = 0; for(int i=0; i<(int)header.size(); i++){ unsigned char byte = (unsigned char)header[i]; checksum_ += byte; } for(int i=0; i<(int)buffer.size(); i++){ unsigned char byte = (unsigned char)buffer[i]; checksum_ += byte; } checksum_ %= 256; char buf[4]; snprintf(buf, sizeof(buf), "%03d", checksum_); buffer.append(encode_field(10, buf)); return header + buffer; }
std::string Message::encode() const{ std::string buffer; buffer.append(encode_field(0, this->type())); std::map<int, std::string>::const_iterator it; for(it=fields_.begin(); it!=fields_.end(); it++){ int tag = it->first; if(tag == 0){ continue; } const std::string &val = it->second; buffer.append(encode_field(tag, val)); } buffer[buffer.size()-1] = sim::MSG_END_BYTE; return buffer; }
int add_field(char *buf, int buf_len, const char *field_name, const char *val) { int dummy_idx = 0; int i = 0; int rv; /* skip to the end, ignoring crc (don't want to further corrupt partially * corrupt data) */ while(i < buf_len) { uint8_t field_len = buf[i]; if(field_len == 0xff) break; /* skip past `field_len' bytes, 2 byte CRC field, and 1 byte len * field */ i += field_len + 3; } rv = encode_field(buf + i, buf_len - i, &dummy_idx, field_name, val); if(rv < 0) return rv; return 0; }
/* Default handler for extension fields. Expects to have a pb_field_t * pointer in the extension->type->arg field. */ static bool checkreturn default_extension_encoder(pb_ostream_t *stream, const pb_extension_t *extension) { const pb_field_t *field = (const pb_field_t*)extension->type->arg; if (PB_ATYPE(field->type) == PB_ATYPE_POINTER) { /* For pointer extensions, the pointer is stored directly * in the extension structure. This avoids having an extra * indirection. */ return encode_field(stream, field, &extension->dest); } else { return encode_field(stream, field, extension->dest); } }
std::string encode_text(str_ref v, bool add_quote_class) { std::string r; r.reserve(v.size() << 1); while (v) { str_ref line = read_until(v, '\n'); r += add_quote_class && boost::istarts_with(line, "> ") ? "<span class=quote>" + encode_field(line) + "</span>" : encode_field(line); r += "<br>"; } return r; }
static inline void fill_fpga_metadata_page(uint8_t *metadata, size_t actual_bitstream_len) { char len_str[10]; int idx = 0; memset(len_str, 0, sizeof(len_str)); memset(metadata, 0xff, BLADERF_FLASH_PAGE_SIZE); snprintf(len_str, sizeof(len_str), "%u", (unsigned int)actual_bitstream_len); encode_field((char *)metadata, BLADERF_FLASH_PAGE_SIZE, &idx, "LEN", len_str); }
std::string encode_text(const std::string& v, const std::string& local_domain_url, bool add_span) { std::string r; r.reserve(v.length() << 1); for (size_t i = 0; i < v.length(); ) { size_t p = v.find('\n', i); if (p == std::string::npos) p = v.length(); std::string line = v.substr(i, p - i); line = encode_field(line, local_domain_url); r += add_span && boost::istarts_with(line, "> ") ? "<span class=quote>" + line + "</span>" : line; r += "<br>"; i = p + 1; } return r; }
bool checkreturn pb_encode(pb_ostream_t *stream, const pb_field_t fields[], const void *src_struct) { pb_field_iter_t iter; if (!pb_field_iter_begin(&iter, fields, remove_const(src_struct))) return true; /* Empty message type */ do { if (PB_LTYPE(iter.pos->type) == PB_LTYPE_EXTENSION) { /* Special case for the extension field placeholder */ if (!encode_extension_field(stream, iter.pos, iter.pData)) return false; } else { /* Regular field */ if (!encode_field(stream, iter.pos, iter.pData)) return false; } } while (pb_field_iter_next(&iter)); return true; }
bool checkreturn pb_encode(pb_ostream_t *stream, const pb_field_t fields[], const void *src_struct) { const pb_field_t *field = fields; const void *pData = src_struct; size_t prev_size = 0; while (field->tag != 0) { pData = (const char*)pData + prev_size + field->data_offset; prev_size = field->data_size; /* Special case for static arrays */ if (PB_ATYPE(field->type) == PB_ATYPE_STATIC && PB_HTYPE(field->type) == PB_HTYPE_REPEATED) { prev_size *= field->array_size; } if (PB_LTYPE(field->type) == PB_LTYPE_EXTENSION) { /* Special case for the extension field placeholder */ if (!encode_extension_field(stream, field, pData)) return false; } else { /* Regular field */ if (!encode_field(stream, field, pData)) return false; } field++; } return true; }
string bbformat(str_ref s) { string d; str_ref a0; while (1) { switch (get_next(s, a0)) { case bb_literal: d += encode_field(a0, true); break; case bb_none: break; case bb_bold: d += "<b>"; break; case bb_bold_close: d += "</b>"; break; case bb_center: d += "<center>"; break; case bb_center_close: d += "</center>"; break; case bb_color: d += "<font color=\"" + encode_field(a0) + "\">"; // escape a0 break; case bb_color_close: d += "</font>"; break; case bb_quote: if (a0) d += "<b>" + encode_field(a0) + " wrote:</b>"; d += "<blockquote class=bq>"; break; case bb_quote_close: d += "</blockquote>"; break; case bb_strike: d += "<s>"; break; case bb_strike_close: d += "</s>"; break; case bb_underline: d += "<u>"; break; case bb_underline_close: d += "</u>"; break; case bb_url: d += encode_field(a0, true) + " "; break; case bb_video: d += encode_field(a0, true) + " "; break; case bb_unknown: d += "[" + encode_field(a0) + "]"; break; case bb_end: return d; default: assert(false); } } }
bool perf_object_t::encode(xml_document_t& doc, xml_element_t& xml_val) const { do { if (!__skip_bool_val && !encode_field(bool_val, "bool_val", doc, xml_val)) break; if (!__skip_int8_val && !encode_field(int8_val, "int8_val", doc, xml_val)) break; if (!__skip_uint8_val && !encode_field(uint8_val, "uint8_val", doc, xml_val)) break; if (!__skip_int16_val && !encode_field(int16_val, "int16_val", doc, xml_val)) break; if (!__skip_uint16_val && !encode_field(uint16_val, "uint16_val", doc, xml_val)) break; if (!__skip_int32_val && !encode_field(int32_val, "int32_val", doc, xml_val)) break; if (!__skip_uint32_val && !encode_field(uint32_val, "uint32_val", doc, xml_val)) break; if (!__skip_int64_val && !encode_field(int64_val, "int64_val", doc, xml_val)) break; if (!__skip_uint64_val && !encode_field(uint64_val, "uint64_val", doc, xml_val)) break; if (!__skip_float_val && !encode_field(float_val, "float_val", doc, xml_val)) break; if (!__skip_double_val && !encode_field(double_val, "double_val", doc, xml_val)) break; if (!__skip_str_val && !encode_field(str_val, "str_val", doc, xml_val)) break; if (!__skip_vec_val && !encode_field(vec_val, "vec_val", doc, xml_val)) break; if (!__skip_dict_val && !encode_field(dict_val, "dict_val", doc, xml_val)) break; return true; } while (0); return false; }
bool sample_struct_t::encode(xml_document_t& doc, xml_element_t& xml_val) const { do { if (!__skip_bool_val && !encode_field(bool_val, "bool_val", doc, xml_val)) break; if (!__skip_str_val && !encode_field(str_val, "str_val", doc, xml_val)) break; if (!__skip_int_val && !encode_field(int_val, "int_val", doc, xml_val)) break; if (!__skip_uint_val && !encode_field(uint_val, "uint_val", doc, xml_val)) break; if (!__skip_double_val && !encode_field(double_val, "double_val", doc, xml_val)) break; if (!__skip_char_val && !encode_field(char_val, "char_val", doc, xml_val)) break; if (!__skip_uchar_val && !encode_field(uchar_val, "uchar_val", doc, xml_val)) break; if (!__skip_short_val && !encode_field(short_val, "short_val", doc, xml_val)) break; if (!__skip_ushort_val && !encode_field(ushort_val, "ushort_val", doc, xml_val)) break; if (!__skip_int64_val && !encode_field(int64_val, "int64_val", doc, xml_val)) break; if (!__skip_uint64_val && !encode_field(uint64_val, "uint64_val", doc, xml_val)) break; if (!__skip_float_val && !encode_field(float_val, "float_val", doc, xml_val)) break; if (!__skip_vec_val && !encode_field(vec_val, "vec_val", doc, xml_val)) break; if (!__skip_str_map_val && !encode_field(str_map_val, "str_map_val", doc, xml_val)) break; return true; } while (0); return false; }
/* Default handler for extension fields. Expects to have a pb_field_t * pointer in the extension->type->arg field. */ static bool checkreturn default_extension_encoder(pb_ostream_t *stream, const pb_extension_t *extension) { const pb_field_t *field = (const pb_field_t*)extension->type->arg; return encode_field(stream, field, extension->dest); }
int bladerf_flash_fpga(struct bladerf *dev, const char *fpga_file) { int status; char fpga_len[10]; uint8_t *buf, *buf_padded, *ver; size_t buf_size, buf_size_padded; int hp_idx = 0; if (strcmp("X", fpga_file) == 0) { printf("Disabling FPGA flash auto-load\n"); return (dev->fn->erase_flash(dev, flash_from_sectors(4), BLADERF_FLASH_SECTOR_SIZE) != BLADERF_FLASH_SECTOR_SIZE); } status = file_read_buffer(fpga_file, &buf, &buf_size); if (status == 0) { if ((getenv("BLADERF_SKIP_FPGA_SIZE_CHECK") == 0) && (buf_size < (1 * 1024 * 1024) || (buf_size > (5 * 1024 * 1024)))) { log_info("Detected potentially invalid firmware file.\n"); log_info("Define BLADERF_SKIP_FPGA_SIZE_CHECK in your evironment " "to skip this check.\n"); status = BLADERF_ERR_INVAL; } else { const size_t page_size = BLADERF_FLASH_SECTOR_SIZE; size_t buf_size_padding = page_size - (buf_size % page_size); /* Pad firmare data out to a flash page size */ buf_size_padded = buf_size + buf_size_padding + page_size; buf_padded = (uint8_t*)realloc(buf, buf_size_padded); if (buf_padded == NULL) { status = BLADERF_ERR_MEM; } else { buf = buf_padded; memset(buf + buf_size, 0xFF, buf_size_padded - buf_size - BLADERF_FLASH_SECTOR_SIZE); memmove(&buf[BLADERF_FLASH_PAGE_SIZE], buf, buf_size_padded - BLADERF_FLASH_SECTOR_SIZE); snprintf(fpga_len, 9, "%d", (int)buf_size); memset(buf, 0xff, BLADERF_FLASH_PAGE_SIZE); encode_field((char *)buf, BLADERF_FLASH_PAGE_SIZE, &hp_idx, "LEN", fpga_len); if (status == 0) { status = dev->fn->erase_flash(dev, flash_from_sectors(4), (uint32_t)buf_size_padded); } if (status >= 0) { status = dev->fn->write_flash(dev, flash_from_pages(1024), buf, (uint32_t)buf_size_padded); } ver = (uint8_t *)malloc(buf_size_padded); if (!ver) status = BLADERF_ERR_MEM; if (status >= 0) { status = dev->fn->read_flash(dev, flash_from_pages(1024), ver, (uint32_t)buf_size_padded); } if ((size_t)status == buf_size_padded) { status = memcmp(buf, ver, buf_size_padded); } free(ver); } } free(buf); } return status; }