dan
/
tor-android
1
0
Fork 0
Code Issues Pull Requests Releases Wiki Activity
tor-android/external/badvpn_dns/generated/bproto_bproto_test.h

1030 lines
31 KiB
C
Raw Normal View History

added badvpn as local folder
2015-01-25 11:08:34 +00:00
/*
DO NOT EDIT THIS FILE!
This file was automatically generated by the bproto generator.
*/
#include <stdint.h>
#include <string.h>
#include <misc/debug.h>
#include <misc/byteorder.h>
#include <bproto/BProto.h>
#define msg1_SIZEa (sizeof(struct BProto_header_s) + sizeof(struct BProto_uint16_s))
#define msg1_SIZEb (sizeof(struct BProto_header_s) + sizeof(struct BProto_uint32_s))
#define msg1_SIZEc (sizeof(struct BProto_header_s) + sizeof(struct BProto_uint64_s))
#define msg1_SIZEd (sizeof(struct BProto_header_s) + sizeof(struct BProto_uint16_s))
#define msg1_SIZEe (sizeof(struct BProto_header_s) + sizeof(struct BProto_uint8_s))
#define msg1_SIZEf(_len) (sizeof(struct BProto_header_s) + sizeof(struct BProto_data_header_s) + (_len))
#define msg1_SIZEg (sizeof(struct BProto_header_s) + sizeof(struct BProto_data_header_s) + (4))
typedef struct {
uint8_t *out;
int used;
int a_count;
int b_count;
int c_count;
int d_count;
int e_count;
int f_count;
int g_count;
} msg1Writer;
static void msg1Writer_Init (msg1Writer *o, uint8_t *out);
static int msg1Writer_Finish (msg1Writer *o);
static void msg1Writer_Adda (msg1Writer *o, uint16_t v);
static void msg1Writer_Addb (msg1Writer *o, uint32_t v);
static void msg1Writer_Addc (msg1Writer *o, uint64_t v);
static void msg1Writer_Addd (msg1Writer *o, uint16_t v);
static void msg1Writer_Adde (msg1Writer *o, uint8_t v);
static uint8_t * msg1Writer_Addf (msg1Writer *o, int len);
static uint8_t * msg1Writer_Addg (msg1Writer *o);
typedef struct {
uint8_t *buf;
int buf_len;
int a_start;
int a_span;
int a_pos;
int b_start;
int b_span;
int b_pos;
int c_start;
int c_span;
int c_pos;
int d_start;
int d_span;
int d_pos;
int e_start;
int e_span;
int e_pos;
int f_start;
int f_span;
int f_pos;
int g_start;
int g_span;
int g_pos;
} msg1Parser;
static int msg1Parser_Init (msg1Parser *o, uint8_t *buf, int buf_len);
static int msg1Parser_GotEverything (msg1Parser *o);
static int msg1Parser_Geta (msg1Parser *o, uint16_t *v);
static void msg1Parser_Reseta (msg1Parser *o);
static void msg1Parser_Forwarda (msg1Parser *o);
static int msg1Parser_Getb (msg1Parser *o, uint32_t *v);
static void msg1Parser_Resetb (msg1Parser *o);
static void msg1Parser_Forwardb (msg1Parser *o);
static int msg1Parser_Getc (msg1Parser *o, uint64_t *v);
static void msg1Parser_Resetc (msg1Parser *o);
static void msg1Parser_Forwardc (msg1Parser *o);
static int msg1Parser_Getd (msg1Parser *o, uint16_t *v);
static void msg1Parser_Resetd (msg1Parser *o);
static void msg1Parser_Forwardd (msg1Parser *o);
static int msg1Parser_Gete (msg1Parser *o, uint8_t *v);
static void msg1Parser_Resete (msg1Parser *o);
static void msg1Parser_Forwarde (msg1Parser *o);
static int msg1Parser_Getf (msg1Parser *o, uint8_t **data, int *data_len);
static void msg1Parser_Resetf (msg1Parser *o);
static void msg1Parser_Forwardf (msg1Parser *o);
static int msg1Parser_Getg (msg1Parser *o, uint8_t **data);
static void msg1Parser_Resetg (msg1Parser *o);
static void msg1Parser_Forwardg (msg1Parser *o);
void msg1Writer_Init (msg1Writer *o, uint8_t *out)
{
o->out = out;
o->used = 0;
o->a_count = 0;
o->b_count = 0;
o->c_count = 0;
o->d_count = 0;
o->e_count = 0;
o->f_count = 0;
o->g_count = 0;
}
int msg1Writer_Finish (msg1Writer *o)
{
ASSERT(o->used >= 0)
ASSERT(o->a_count == 1)
ASSERT(o->b_count >= 0 && o->b_count <= 1)
ASSERT(o->c_count >= 1)
ASSERT(o->d_count >= 0)
ASSERT(o->e_count == 1)
ASSERT(o->f_count == 1)
ASSERT(o->g_count == 1)
return o->used;
}
void msg1Writer_Adda (msg1Writer *o, uint16_t v)
{
ASSERT(o->used >= 0)
ASSERT(o->a_count == 0)
struct BProto_header_s header;
header.id = htol16(5);
header.type = htol16(BPROTO_TYPE_UINT16);
memcpy(o->out + o->used, &header, sizeof(header));
o->used += sizeof(struct BProto_header_s);
struct BProto_uint16_s data;
data.v = htol16(v);
memcpy(o->out + o->used, &data, sizeof(data));
o->used += sizeof(struct BProto_uint16_s);
o->a_count++;
}
void msg1Writer_Addb (msg1Writer *o, uint32_t v)
{
ASSERT(o->used >= 0)
ASSERT(o->b_count == 0)
struct BProto_header_s header;
header.id = htol16(6);
header.type = htol16(BPROTO_TYPE_UINT32);
memcpy(o->out + o->used, &header, sizeof(header));
o->used += sizeof(struct BProto_header_s);
struct BProto_uint32_s data;
data.v = htol32(v);
memcpy(o->out + o->used, &data, sizeof(data));
o->used += sizeof(struct BProto_uint32_s);
o->b_count++;
}
void msg1Writer_Addc (msg1Writer *o, uint64_t v)
{
ASSERT(o->used >= 0)
struct BProto_header_s header;
header.id = htol16(7);
header.type = htol16(BPROTO_TYPE_UINT64);
memcpy(o->out + o->used, &header, sizeof(header));
o->used += sizeof(struct BProto_header_s);
struct BProto_uint64_s data;
data.v = htol64(v);
memcpy(o->out + o->used, &data, sizeof(data));
o->used += sizeof(struct BProto_uint64_s);
o->c_count++;
}
void msg1Writer_Addd (msg1Writer *o, uint16_t v)
{
ASSERT(o->used >= 0)
struct BProto_header_s header;
header.id = htol16(8);
header.type = htol16(BPROTO_TYPE_UINT16);
memcpy(o->out + o->used, &header, sizeof(header));
o->used += sizeof(struct BProto_header_s);
struct BProto_uint16_s data;
data.v = htol16(v);
memcpy(o->out + o->used, &data, sizeof(data));
o->used += sizeof(struct BProto_uint16_s);
o->d_count++;
}
void msg1Writer_Adde (msg1Writer *o, uint8_t v)
{
ASSERT(o->used >= 0)
ASSERT(o->e_count == 0)
struct BProto_header_s header;
header.id = htol16(9);
header.type = htol16(BPROTO_TYPE_UINT8);
memcpy(o->out + o->used, &header, sizeof(header));
o->used += sizeof(struct BProto_header_s);
struct BProto_uint8_s data;
data.v = htol8(v);
memcpy(o->out + o->used, &data, sizeof(data));
o->used += sizeof(struct BProto_uint8_s);
o->e_count++;
}
uint8_t * msg1Writer_Addf (msg1Writer *o, int len)
{
ASSERT(o->used >= 0)
ASSERT(o->f_count == 0)
ASSERT(len >= 0 && len <= UINT32_MAX)
struct BProto_header_s header;
header.id = htol16(10);
header.type = htol16(BPROTO_TYPE_DATA);
memcpy(o->out + o->used, &header, sizeof(header));
o->used += sizeof(struct BProto_header_s);
struct BProto_data_header_s data;
data.len = htol32(len);
memcpy(o->out + o->used, &data, sizeof(data));
o->used += sizeof(struct BProto_data_header_s);
uint8_t *dest = (o->out + o->used);
o->used += len;
o->f_count++;
return dest;
}
uint8_t * msg1Writer_Addg (msg1Writer *o)
{
ASSERT(o->used >= 0)
ASSERT(o->g_count == 0)
struct BProto_header_s header;
header.id = htol16(11);
header.type = htol16(BPROTO_TYPE_CONSTDATA);
memcpy(o->out + o->used, &header, sizeof(header));
o->used += sizeof(struct BProto_header_s);
struct BProto_data_header_s data;
data.len = htol32(4);
memcpy(o->out + o->used, &data, sizeof(data));
o->used += sizeof(struct BProto_data_header_s);
uint8_t *dest = (o->out + o->used);
o->used += (4);
o->g_count++;
return dest;
}
int msg1Parser_Init (msg1Parser *o, uint8_t *buf, int buf_len)
{
ASSERT(buf_len >= 0)
o->buf = buf;
o->buf_len = buf_len;
o->a_start = o->buf_len;
o->a_span = 0;
o->a_pos = 0;
o->b_start = o->buf_len;
o->b_span = 0;
o->b_pos = 0;
o->c_start = o->buf_len;
o->c_span = 0;
o->c_pos = 0;
o->d_start = o->buf_len;
o->d_span = 0;
o->d_pos = 0;
o->e_start = o->buf_len;
o->e_span = 0;
o->e_pos = 0;
o->f_start = o->buf_len;
o->f_span = 0;
o->f_pos = 0;
o->g_start = o->buf_len;
o->g_span = 0;
o->g_pos = 0;
int a_count = 0;
int b_count = 0;
int c_count = 0;
int d_count = 0;
int e_count = 0;
int f_count = 0;
int g_count = 0;
int pos = 0;
int left = o->buf_len;
while (left > 0) {
int entry_pos = pos;
if (!(left >= sizeof(struct BProto_header_s))) {
return 0;
}
struct BProto_header_s header;
memcpy(&header, o->buf + pos, sizeof(header));
pos += sizeof(struct BProto_header_s);
left -= sizeof(struct BProto_header_s);
uint16_t type = ltoh16(header.type);
uint16_t id = ltoh16(header.id);
switch (type) {
case BPROTO_TYPE_UINT8: {
if (!(left >= sizeof(struct BProto_uint8_s))) {
return 0;
}
pos += sizeof(struct BProto_uint8_s);
left -= sizeof(struct BProto_uint8_s);
switch (id) {
case 9:
if (o->e_start == o->buf_len) {
o->e_start = entry_pos;
}
o->e_span = pos - o->e_start;
e_count++;
break;
default:
return 0;
}
} break;
case BPROTO_TYPE_UINT16: {
if (!(left >= sizeof(struct BProto_uint16_s))) {
return 0;
}
pos += sizeof(struct BProto_uint16_s);
left -= sizeof(struct BProto_uint16_s);
switch (id) {
case 5:
if (o->a_start == o->buf_len) {
o->a_start = entry_pos;
}
o->a_span = pos - o->a_start;
a_count++;
break;
case 8:
if (o->d_start == o->buf_len) {
o->d_start = entry_pos;
}
o->d_span = pos - o->d_start;
d_count++;
break;
default:
return 0;
}
} break;
case BPROTO_TYPE_UINT32: {
if (!(left >= sizeof(struct BProto_uint32_s))) {
return 0;
}
pos += sizeof(struct BProto_uint32_s);
left -= sizeof(struct BProto_uint32_s);
switch (id) {
case 6:
if (o->b_start == o->buf_len) {
o->b_start = entry_pos;
}
o->b_span = pos - o->b_start;
b_count++;
break;
default:
return 0;
}
} break;
case BPROTO_TYPE_UINT64: {
if (!(left >= sizeof(struct BProto_uint64_s))) {
return 0;
}
pos += sizeof(struct BProto_uint64_s);
left -= sizeof(struct BProto_uint64_s);
switch (id) {
case 7:
if (o->c_start == o->buf_len) {
o->c_start = entry_pos;
}
o->c_span = pos - o->c_start;
c_count++;
break;
default:
return 0;
}
} break;
case BPROTO_TYPE_DATA:
case BPROTO_TYPE_CONSTDATA:
{
if (!(left >= sizeof(struct BProto_data_header_s))) {
return 0;
}
struct BProto_data_header_s val;
memcpy(&val, o->buf + pos, sizeof(val));
pos += sizeof(struct BProto_data_header_s);
left -= sizeof(struct BProto_data_header_s);
uint32_t payload_len = ltoh32(val.len);
if (!(left >= payload_len)) {
return 0;
}
pos += payload_len;
left -= payload_len;
switch (id) {
case 10:
if (!(type == BPROTO_TYPE_DATA)) {
return 0;
}
if (o->f_start == o->buf_len) {
o->f_start = entry_pos;
}
o->f_span = pos - o->f_start;
f_count++;
break;
case 11:
if (!(type == BPROTO_TYPE_CONSTDATA)) {
return 0;
}
if (!(payload_len == (4))) {
return 0;
}
if (o->g_start == o->buf_len) {
o->g_start = entry_pos;
}
o->g_span = pos - o->g_start;
g_count++;
break;
default:
return 0;
}
} break;
default:
return 0;
}
}
if (!(a_count == 1)) {
return 0;
}
if (!(b_count <= 1)) {
return 0;
}
if (!(c_count >= 1)) {
return 0;
}
if (!(e_count == 1)) {
return 0;
}
if (!(f_count == 1)) {
return 0;
}
if (!(g_count == 1)) {
return 0;
}
return 1;
}
int msg1Parser_GotEverything (msg1Parser *o)
{
return (
o->a_pos == o->a_span
&&
o->b_pos == o->b_span
&&
o->c_pos == o->c_span
&&
o->d_pos == o->d_span
&&
o->e_pos == o->e_span
&&
o->f_pos == o->f_span
&&
o->g_pos == o->g_span
);
}
int msg1Parser_Geta (msg1Parser *o, uint16_t *v)
{
ASSERT(o->a_pos >= 0)
ASSERT(o->a_pos <= o->a_span)
int left = o->a_span - o->a_pos;
while (left > 0) {
ASSERT(left >= sizeof(struct BProto_header_s))
struct BProto_header_s header;
memcpy(&header, o->buf + o->a_start + o->a_pos, sizeof(header));
o->a_pos += sizeof(struct BProto_header_s);
left -= sizeof(struct BProto_header_s);
uint16_t type = ltoh16(header.type);
uint16_t id = ltoh16(header.id);
switch (type) {
case BPROTO_TYPE_UINT8: {
ASSERT(left >= sizeof(struct BProto_uint8_s))
o->a_pos += sizeof(struct BProto_uint8_s);
left -= sizeof(struct BProto_uint8_s);
} break;
case BPROTO_TYPE_UINT16: {
ASSERT(left >= sizeof(struct BProto_uint16_s))
struct BProto_uint16_s val;
memcpy(&val, o->buf + o->a_start + o->a_pos, sizeof(val));
o->a_pos += sizeof(struct BProto_uint16_s);
left -= sizeof(struct BProto_uint16_s);
if (id == 5) {
*v = ltoh16(val.v);
return 1;
}
} break;
case BPROTO_TYPE_UINT32: {
ASSERT(left >= sizeof(struct BProto_uint32_s))
o->a_pos += sizeof(struct BProto_uint32_s);
left -= sizeof(struct BProto_uint32_s);
} break;
case BPROTO_TYPE_UINT64: {
ASSERT(left >= sizeof(struct BProto_uint64_s))
o->a_pos += sizeof(struct BProto_uint64_s);
left -= sizeof(struct BProto_uint64_s);
} break;
case BPROTO_TYPE_DATA:
case BPROTO_TYPE_CONSTDATA:
{
ASSERT(left >= sizeof(struct BProto_data_header_s))
struct BProto_data_header_s val;
memcpy(&val, o->buf + o->a_start + o->a_pos, sizeof(val));
o->a_pos += sizeof(struct BProto_data_header_s);
left -= sizeof(struct BProto_data_header_s);
uint32_t payload_len = ltoh32(val.len);
ASSERT(left >= payload_len)
o->a_pos += payload_len;
left -= payload_len;
} break;
default:
ASSERT(0);
}
}
return 0;
}
void msg1Parser_Reseta (msg1Parser *o)
{
o->a_pos = 0;
}
void msg1Parser_Forwarda (msg1Parser *o)
{
o->a_pos = o->a_span;
}
int msg1Parser_Getb (msg1Parser *o, uint32_t *v)
{
ASSERT(o->b_pos >= 0)
ASSERT(o->b_pos <= o->b_span)
int left = o->b_span - o->b_pos;
while (left > 0) {
ASSERT(left >= sizeof(struct BProto_header_s))
struct BProto_header_s header;
memcpy(&header, o->buf + o->b_start + o->b_pos, sizeof(header));
o->b_pos += sizeof(struct BProto_header_s);
left -= sizeof(struct BProto_header_s);
uint16_t type = ltoh16(header.type);
uint16_t id = ltoh16(header.id);
switch (type) {
case BPROTO_TYPE_UINT8: {
ASSERT(left >= sizeof(struct BProto_uint8_s))
o->b_pos += sizeof(struct BProto_uint8_s);
left -= sizeof(struct BProto_uint8_s);
} break;
case BPROTO_TYPE_UINT16: {
ASSERT(left >= sizeof(struct BProto_uint16_s))
o->b_pos += sizeof(struct BProto_uint16_s);
left -= sizeof(struct BProto_uint16_s);
} break;
case BPROTO_TYPE_UINT32: {
ASSERT(left >= sizeof(struct BProto_uint32_s))
struct BProto_uint32_s val;
memcpy(&val, o->buf + o->b_start + o->b_pos, sizeof(val));
o->b_pos += sizeof(struct BProto_uint32_s);
left -= sizeof(struct BProto_uint32_s);
if (id == 6) {
*v = ltoh32(val.v);
return 1;
}
} break;
case BPROTO_TYPE_UINT64: {
ASSERT(left >= sizeof(struct BProto_uint64_s))
o->b_pos += sizeof(struct BProto_uint64_s);
left -= sizeof(struct BProto_uint64_s);
} break;
case BPROTO_TYPE_DATA:
case BPROTO_TYPE_CONSTDATA:
{
ASSERT(left >= sizeof(struct BProto_data_header_s))
struct BProto_data_header_s val;
memcpy(&val, o->buf + o->b_start + o->b_pos, sizeof(val));
o->b_pos += sizeof(struct BProto_data_header_s);
left -= sizeof(struct BProto_data_header_s);
uint32_t payload_len = ltoh32(val.len);
ASSERT(left >= payload_len)
o->b_pos += payload_len;
left -= payload_len;
} break;
default:
ASSERT(0);
}
}
return 0;
}
void msg1Parser_Resetb (msg1Parser *o)
{
o->b_pos = 0;
}
void msg1Parser_Forwardb (msg1Parser *o)
{
o->b_pos = o->b_span;
}
int msg1Parser_Getc (msg1Parser *o, uint64_t *v)
{
ASSERT(o->c_pos >= 0)
ASSERT(o->c_pos <= o->c_span)
int left = o->c_span - o->c_pos;
while (left > 0) {
ASSERT(left >= sizeof(struct BProto_header_s))
struct BProto_header_s header;
memcpy(&header, o->buf + o->c_start + o->c_pos, sizeof(header));
o->c_pos += sizeof(struct BProto_header_s);
left -= sizeof(struct BProto_header_s);
uint16_t type = ltoh16(header.type);
uint16_t id = ltoh16(header.id);
switch (type) {
case BPROTO_TYPE_UINT8: {
ASSERT(left >= sizeof(struct BProto_uint8_s))
o->c_pos += sizeof(struct BProto_uint8_s);
left -= sizeof(struct BProto_uint8_s);
} break;
case BPROTO_TYPE_UINT16: {
ASSERT(left >= sizeof(struct BProto_uint16_s))
o->c_pos += sizeof(struct BProto_uint16_s);
left -= sizeof(struct BProto_uint16_s);
} break;
case BPROTO_TYPE_UINT32: {
ASSERT(left >= sizeof(struct BProto_uint32_s))
o->c_pos += sizeof(struct BProto_uint32_s);
left -= sizeof(struct BProto_uint32_s);
} break;
case BPROTO_TYPE_UINT64: {
ASSERT(left >= sizeof(struct BProto_uint64_s))
struct BProto_uint64_s val;
memcpy(&val, o->buf + o->c_start + o->c_pos, sizeof(val));
o->c_pos += sizeof(struct BProto_uint64_s);
left -= sizeof(struct BProto_uint64_s);
if (id == 7) {
*v = ltoh64(val.v);
return 1;
}
} break;
case BPROTO_TYPE_DATA:
case BPROTO_TYPE_CONSTDATA:
{
ASSERT(left >= sizeof(struct BProto_data_header_s))
struct BProto_data_header_s val;
memcpy(&val, o->buf + o->c_start + o->c_pos, sizeof(val));
o->c_pos += sizeof(struct BProto_data_header_s);
left -= sizeof(struct BProto_data_header_s);
uint32_t payload_len = ltoh32(val.len);
ASSERT(left >= payload_len)
o->c_pos += payload_len;
left -= payload_len;
} break;
default:
ASSERT(0);
}
}
return 0;
}
void msg1Parser_Resetc (msg1Parser *o)
{
o->c_pos = 0;
}
void msg1Parser_Forwardc (msg1Parser *o)
{
o->c_pos = o->c_span;
}
int msg1Parser_Getd (msg1Parser *o, uint16_t *v)
{
ASSERT(o->d_pos >= 0)
ASSERT(o->d_pos <= o->d_span)
int left = o->d_span - o->d_pos;
while (left > 0) {
ASSERT(left >= sizeof(struct BProto_header_s))
struct BProto_header_s header;
memcpy(&header, o->buf + o->d_start + o->d_pos, sizeof(header));
o->d_pos += sizeof(struct BProto_header_s);
left -= sizeof(struct BProto_header_s);
uint16_t type = ltoh16(header.type);
uint16_t id = ltoh16(header.id);
switch (type) {
case BPROTO_TYPE_UINT8: {
ASSERT(left >= sizeof(struct BProto_uint8_s))
o->d_pos += sizeof(struct BProto_uint8_s);
left -= sizeof(struct BProto_uint8_s);
} break;
case BPROTO_TYPE_UINT16: {
ASSERT(left >= sizeof(struct BProto_uint16_s))
struct BProto_uint16_s val;
memcpy(&val, o->buf + o->d_start + o->d_pos, sizeof(val));
o->d_pos += sizeof(struct BProto_uint16_s);
left -= sizeof(struct BProto_uint16_s);
if (id == 8) {
*v = ltoh16(val.v);
return 1;
}
} break;
case BPROTO_TYPE_UINT32: {
ASSERT(left >= sizeof(struct BProto_uint32_s))
o->d_pos += sizeof(struct BProto_uint32_s);
left -= sizeof(struct BProto_uint32_s);
} break;
case BPROTO_TYPE_UINT64: {
ASSERT(left >= sizeof(struct BProto_uint64_s))
o->d_pos += sizeof(struct BProto_uint64_s);
left -= sizeof(struct BProto_uint64_s);
} break;
case BPROTO_TYPE_DATA:
case BPROTO_TYPE_CONSTDATA:
{
ASSERT(left >= sizeof(struct BProto_data_header_s))
struct BProto_data_header_s val;
memcpy(&val, o->buf + o->d_start + o->d_pos, sizeof(val));
o->d_pos += sizeof(struct BProto_data_header_s);
left -= sizeof(struct BProto_data_header_s);
uint32_t payload_len = ltoh32(val.len);
ASSERT(left >= payload_len)
o->d_pos += payload_len;
left -= payload_len;
} break;
default:
ASSERT(0);
}
}
return 0;
}
void msg1Parser_Resetd (msg1Parser *o)
{
o->d_pos = 0;
}
void msg1Parser_Forwardd (msg1Parser *o)
{
o->d_pos = o->d_span;
}
int msg1Parser_Gete (msg1Parser *o, uint8_t *v)
{
ASSERT(o->e_pos >= 0)
ASSERT(o->e_pos <= o->e_span)
int left = o->e_span - o->e_pos;
while (left > 0) {
ASSERT(left >= sizeof(struct BProto_header_s))
struct BProto_header_s header;
memcpy(&header, o->buf + o->e_start + o->e_pos, sizeof(header));
o->e_pos += sizeof(struct BProto_header_s);
left -= sizeof(struct BProto_header_s);
uint16_t type = ltoh16(header.type);
uint16_t id = ltoh16(header.id);
switch (type) {
case BPROTO_TYPE_UINT8: {
ASSERT(left >= sizeof(struct BProto_uint8_s))
struct BProto_uint8_s val;
memcpy(&val, o->buf + o->e_start + o->e_pos, sizeof(val));
o->e_pos += sizeof(struct BProto_uint8_s);
left -= sizeof(struct BProto_uint8_s);
if (id == 9) {
*v = ltoh8(val.v);
return 1;
}
} break;
case BPROTO_TYPE_UINT16: {
ASSERT(left >= sizeof(struct BProto_uint16_s))
o->e_pos += sizeof(struct BProto_uint16_s);
left -= sizeof(struct BProto_uint16_s);
} break;
case BPROTO_TYPE_UINT32: {
ASSERT(left >= sizeof(struct BProto_uint32_s))
o->e_pos += sizeof(struct BProto_uint32_s);
left -= sizeof(struct BProto_uint32_s);
} break;
case BPROTO_TYPE_UINT64: {
ASSERT(left >= sizeof(struct BProto_uint64_s))
o->e_pos += sizeof(struct BProto_uint64_s);
left -= sizeof(struct BProto_uint64_s);
} break;
case BPROTO_TYPE_DATA:
case BPROTO_TYPE_CONSTDATA:
{
ASSERT(left >= sizeof(struct BProto_data_header_s))
struct BProto_data_header_s val;
memcpy(&val, o->buf + o->e_start + o->e_pos, sizeof(val));
o->e_pos += sizeof(struct BProto_data_header_s);
left -= sizeof(struct BProto_data_header_s);
uint32_t payload_len = ltoh32(val.len);
ASSERT(left >= payload_len)
o->e_pos += payload_len;
left -= payload_len;
} break;
default:
ASSERT(0);
}
}
return 0;
}
void msg1Parser_Resete (msg1Parser *o)
{
o->e_pos = 0;
}
void msg1Parser_Forwarde (msg1Parser *o)
{
o->e_pos = o->e_span;
}
int msg1Parser_Getf (msg1Parser *o, uint8_t **data, int *data_len)
{
ASSERT(o->f_pos >= 0)
ASSERT(o->f_pos <= o->f_span)
int left = o->f_span - o->f_pos;
while (left > 0) {
ASSERT(left >= sizeof(struct BProto_header_s))
struct BProto_header_s header;
memcpy(&header, o->buf + o->f_start + o->f_pos, sizeof(header));
o->f_pos += sizeof(struct BProto_header_s);
left -= sizeof(struct BProto_header_s);
uint16_t type = ltoh16(header.type);
uint16_t id = ltoh16(header.id);
switch (type) {
case BPROTO_TYPE_UINT8: {
ASSERT(left >= sizeof(struct BProto_uint8_s))
o->f_pos += sizeof(struct BProto_uint8_s);
left -= sizeof(struct BProto_uint8_s);
} break;
case BPROTO_TYPE_UINT16: {
ASSERT(left >= sizeof(struct BProto_uint16_s))
o->f_pos += sizeof(struct BProto_uint16_s);
left -= sizeof(struct BProto_uint16_s);
} break;
case BPROTO_TYPE_UINT32: {
ASSERT(left >= sizeof(struct BProto_uint32_s))
o->f_pos += sizeof(struct BProto_uint32_s);
left -= sizeof(struct BProto_uint32_s);
} break;
case BPROTO_TYPE_UINT64: {
ASSERT(left >= sizeof(struct BProto_uint64_s))
o->f_pos += sizeof(struct BProto_uint64_s);
left -= sizeof(struct BProto_uint64_s);
} break;
case BPROTO_TYPE_DATA:
case BPROTO_TYPE_CONSTDATA:
{
ASSERT(left >= sizeof(struct BProto_data_header_s))
struct BProto_data_header_s val;
memcpy(&val, o->buf + o->f_start + o->f_pos, sizeof(val));
o->f_pos += sizeof(struct BProto_data_header_s);
left -= sizeof(struct BProto_data_header_s);
uint32_t payload_len = ltoh32(val.len);
ASSERT(left >= payload_len)
uint8_t *payload = o->buf + o->f_start + o->f_pos;
o->f_pos += payload_len;
left -= payload_len;
if (type == BPROTO_TYPE_DATA && id == 10) {
*data = payload;
*data_len = payload_len;
return 1;
}
} break;
default:
ASSERT(0);
}
}
return 0;
}
void msg1Parser_Resetf (msg1Parser *o)
{
o->f_pos = 0;
}
void msg1Parser_Forwardf (msg1Parser *o)
{
o->f_pos = o->f_span;
}
int msg1Parser_Getg (msg1Parser *o, uint8_t **data)
{
ASSERT(o->g_pos >= 0)
ASSERT(o->g_pos <= o->g_span)
int left = o->g_span - o->g_pos;
while (left > 0) {
ASSERT(left >= sizeof(struct BProto_header_s))
struct BProto_header_s header;
memcpy(&header, o->buf + o->g_start + o->g_pos, sizeof(header));
o->g_pos += sizeof(struct BProto_header_s);
left -= sizeof(struct BProto_header_s);
uint16_t type = ltoh16(header.type);
uint16_t id = ltoh16(header.id);
switch (type) {
case BPROTO_TYPE_UINT8: {
ASSERT(left >= sizeof(struct BProto_uint8_s))
o->g_pos += sizeof(struct BProto_uint8_s);
left -= sizeof(struct BProto_uint8_s);
} break;
case BPROTO_TYPE_UINT16: {
ASSERT(left >= sizeof(struct BProto_uint16_s))
o->g_pos += sizeof(struct BProto_uint16_s);
left -= sizeof(struct BProto_uint16_s);
} break;
case BPROTO_TYPE_UINT32: {
ASSERT(left >= sizeof(struct BProto_uint32_s))
o->g_pos += sizeof(struct BProto_uint32_s);
left -= sizeof(struct BProto_uint32_s);
} break;
case BPROTO_TYPE_UINT64: {
ASSERT(left >= sizeof(struct BProto_uint64_s))
o->g_pos += sizeof(struct BProto_uint64_s);
left -= sizeof(struct BProto_uint64_s);
} break;
case BPROTO_TYPE_DATA:
case BPROTO_TYPE_CONSTDATA:
{
ASSERT(left >= sizeof(struct BProto_data_header_s))
struct BProto_data_header_s val;
memcpy(&val, o->buf + o->g_start + o->g_pos, sizeof(val));
o->g_pos += sizeof(struct BProto_data_header_s);
left -= sizeof(struct BProto_data_header_s);
uint32_t payload_len = ltoh32(val.len);
ASSERT(left >= payload_len)
uint8_t *payload = o->buf + o->g_start + o->g_pos;
o->g_pos += payload_len;
left -= payload_len;
if (type == BPROTO_TYPE_CONSTDATA && id == 11) {
*data = payload;
return 1;
}
} break;
default:
ASSERT(0);
}
}
return 0;
}
void msg1Parser_Resetg (msg1Parser *o)
{
o->g_pos = 0;
}
void msg1Parser_Forwardg (msg1Parser *o)
{
o->g_pos = o->g_span;
}