badvpn/generated/bproto_msgproto.h

/*
    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 msg_SIZEtype (sizeof(struct BProto_header_s) + sizeof(struct BProto_uint16_s))
#define msg_SIZEpayload(_len) (sizeof(struct BProto_header_s) + sizeof(struct BProto_data_header_s) + (_len))

typedef struct {
    uint8_t *out;
    int used;
    int type_count;
    int payload_count;
} msgWriter;

static void msgWriter_Init (msgWriter *o, uint8_t *out);
static int msgWriter_Finish (msgWriter *o);
static void msgWriter_Addtype (msgWriter *o, uint16_t v);
static uint8_t * msgWriter_Addpayload (msgWriter *o, int len);

typedef struct {
    uint8_t *buf;
    int buf_len;
    int type_start;
    int type_span;
    int type_pos;
    int payload_start;
    int payload_span;
    int payload_pos;
} msgParser;

static int msgParser_Init (msgParser *o, uint8_t *buf, int buf_len);
static int msgParser_GotEverything (msgParser *o);
static int msgParser_Gettype (msgParser *o, uint16_t *v);
static void msgParser_Resettype (msgParser *o);
static void msgParser_Forwardtype (msgParser *o);
static int msgParser_Getpayload (msgParser *o, uint8_t **data, int *data_len);
static void msgParser_Resetpayload (msgParser *o);
static void msgParser_Forwardpayload (msgParser *o);

void msgWriter_Init (msgWriter *o, uint8_t *out)
{
    o->out = out;
    o->used = 0;
    o->type_count = 0;
    o->payload_count = 0;
}

int msgWriter_Finish (msgWriter *o)
{
    ASSERT(o->used >= 0)
    ASSERT(o->type_count == 1)
    ASSERT(o->payload_count == 1)

    return o->used;
}

void msgWriter_Addtype (msgWriter *o, uint16_t v)
{
    ASSERT(o->used >= 0)
    ASSERT(o->type_count == 0)
    

    struct BProto_header_s header;
    header.id = htol16(1);
    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->type_count++;
}

uint8_t * msgWriter_Addpayload (msgWriter *o, int len)
{
    ASSERT(o->used >= 0)
    ASSERT(o->payload_count == 0)
    ASSERT(len >= 0 && len <= UINT32_MAX)

    struct BProto_header_s header;
    header.id = htol16(2);
    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->payload_count++;

    return dest;
}

int msgParser_Init (msgParser *o, uint8_t *buf, int buf_len)
{
    ASSERT(buf_len >= 0)

    o->buf = buf;
    o->buf_len = buf_len;
    o->type_start = o->buf_len;
    o->type_span = 0;
    o->type_pos = 0;
    o->payload_start = o->buf_len;
    o->payload_span = 0;
    o->payload_pos = 0;

    int type_count = 0;
    int payload_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) {
                    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 1:
                        if (o->type_start == o->buf_len) {
                            o->type_start = entry_pos;
                        }
                        o->type_span = pos - o->type_start;
                        type_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) {
                    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) {
                    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 2:
                        if (!(type == BPROTO_TYPE_DATA)) {
                            return 0;
                        }
                        if (o->payload_start == o->buf_len) {
                            o->payload_start = entry_pos;
                        }
                        o->payload_span = pos - o->payload_start;
                        payload_count++;
                        break;
                    default:
                        return 0;
                }
            } break;
            default:
                return 0;
        }
    }

    if (!(type_count == 1)) {
        return 0;
    }
    if (!(payload_count == 1)) {
        return 0;
    }

    return 1;
}

int msgParser_GotEverything (msgParser *o)
{
    return (
        o->type_pos == o->type_span
        &&
        o->payload_pos == o->payload_span
    );
}

int msgParser_Gettype (msgParser *o, uint16_t *v)
{
    ASSERT(o->type_pos >= 0)
    ASSERT(o->type_pos <= o->type_span)

    int left = o->type_span - o->type_pos;

    while (left > 0) {
        ASSERT(left >= sizeof(struct BProto_header_s))
        struct BProto_header_s header;
        memcpy(&header, o->buf + o->type_start + o->type_pos, sizeof(header));
        o->type_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->type_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->type_start + o->type_pos, sizeof(val));
                o->type_pos += sizeof(struct BProto_uint16_s);
                left -= sizeof(struct BProto_uint16_s);

                if (id == 1) {
                    *v = ltoh16(val.v);
                    return 1;
                }
            } break;
            case BPROTO_TYPE_UINT32: {
                ASSERT(left >= sizeof(struct BProto_uint32_s))
                o->type_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->type_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->type_start + o->type_pos, sizeof(val));
                o->type_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->type_pos += payload_len;
                left -= payload_len;
            } break;
            default:
                ASSERT(0);
        }
    }

    return 0;
}

void msgParser_Resettype (msgParser *o)
{
    o->type_pos = 0;
}

void msgParser_Forwardtype (msgParser *o)
{
    o->type_pos = o->type_span;
}

int msgParser_Getpayload (msgParser *o, uint8_t **data, int *data_len)
{
    ASSERT(o->payload_pos >= 0)
    ASSERT(o->payload_pos <= o->payload_span)

    int left = o->payload_span - o->payload_pos;

    while (left > 0) {
        ASSERT(left >= sizeof(struct BProto_header_s))
        struct BProto_header_s header;
        memcpy(&header, o->buf + o->payload_start + o->payload_pos, sizeof(header));
        o->payload_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->payload_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->payload_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->payload_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->payload_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->payload_start + o->payload_pos, sizeof(val));
                o->payload_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->payload_start + o->payload_pos;
                o->payload_pos += payload_len;
                left -= payload_len;

                if (type == BPROTO_TYPE_DATA && id == 2) {
                    *data = payload;
                    *data_len = payload_len;
                    return 1;
                }
            } break;
            default:
                ASSERT(0);
        }
    }

    return 0;
}

void msgParser_Resetpayload (msgParser *o)
{
    o->payload_pos = 0;
}

void msgParser_Forwardpayload (msgParser *o)
{
    o->payload_pos = o->payload_span;
}

#define msg_youconnect_SIZEaddr(_len) (sizeof(struct BProto_header_s) + sizeof(struct BProto_data_header_s) + (_len))
#define msg_youconnect_SIZEkey(_len) (sizeof(struct BProto_header_s) + sizeof(struct BProto_data_header_s) + (_len))
#define msg_youconnect_SIZEpassword (sizeof(struct BProto_header_s) + sizeof(struct BProto_uint64_s))

typedef struct {
    uint8_t *out;
    int used;
    int addr_count;
    int key_count;
    int password_count;
} msg_youconnectWriter;

static void msg_youconnectWriter_Init (msg_youconnectWriter *o, uint8_t *out);
static int msg_youconnectWriter_Finish (msg_youconnectWriter *o);
static uint8_t * msg_youconnectWriter_Addaddr (msg_youconnectWriter *o, int len);
static uint8_t * msg_youconnectWriter_Addkey (msg_youconnectWriter *o, int len);
static void msg_youconnectWriter_Addpassword (msg_youconnectWriter *o, uint64_t v);

typedef struct {
    uint8_t *buf;
    int buf_len;
    int addr_start;
    int addr_span;
    int addr_pos;
    int key_start;
    int key_span;
    int key_pos;
    int password_start;
    int password_span;
    int password_pos;
} msg_youconnectParser;

static int msg_youconnectParser_Init (msg_youconnectParser *o, uint8_t *buf, int buf_len);
static int msg_youconnectParser_GotEverything (msg_youconnectParser *o);
static int msg_youconnectParser_Getaddr (msg_youconnectParser *o, uint8_t **data, int *data_len);
static void msg_youconnectParser_Resetaddr (msg_youconnectParser *o);
static void msg_youconnectParser_Forwardaddr (msg_youconnectParser *o);
static int msg_youconnectParser_Getkey (msg_youconnectParser *o, uint8_t **data, int *data_len);
static void msg_youconnectParser_Resetkey (msg_youconnectParser *o);
static void msg_youconnectParser_Forwardkey (msg_youconnectParser *o);
static int msg_youconnectParser_Getpassword (msg_youconnectParser *o, uint64_t *v);
static void msg_youconnectParser_Resetpassword (msg_youconnectParser *o);
static void msg_youconnectParser_Forwardpassword (msg_youconnectParser *o);

void msg_youconnectWriter_Init (msg_youconnectWriter *o, uint8_t *out)
{
    o->out = out;
    o->used = 0;
    o->addr_count = 0;
    o->key_count = 0;
    o->password_count = 0;
}

int msg_youconnectWriter_Finish (msg_youconnectWriter *o)
{
    ASSERT(o->used >= 0)
    ASSERT(o->addr_count >= 1)
    ASSERT(o->key_count >= 0 && o->key_count <= 1)
    ASSERT(o->password_count >= 0 && o->password_count <= 1)

    return o->used;
}

uint8_t * msg_youconnectWriter_Addaddr (msg_youconnectWriter *o, int len)
{
    ASSERT(o->used >= 0)
    
    ASSERT(len >= 0 && len <= UINT32_MAX)

    struct BProto_header_s header;
    header.id = htol16(1);
    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->addr_count++;

    return dest;
}

uint8_t * msg_youconnectWriter_Addkey (msg_youconnectWriter *o, int len)
{
    ASSERT(o->used >= 0)
    ASSERT(o->key_count == 0)
    ASSERT(len >= 0 && len <= UINT32_MAX)

    struct BProto_header_s header;
    header.id = htol16(2);
    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->key_count++;

    return dest;
}

void msg_youconnectWriter_Addpassword (msg_youconnectWriter *o, uint64_t v)
{
    ASSERT(o->used >= 0)
    ASSERT(o->password_count == 0)
    

    struct BProto_header_s header;
    header.id = htol16(3);
    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->password_count++;
}

int msg_youconnectParser_Init (msg_youconnectParser *o, uint8_t *buf, int buf_len)
{
    ASSERT(buf_len >= 0)

    o->buf = buf;
    o->buf_len = buf_len;
    o->addr_start = o->buf_len;
    o->addr_span = 0;
    o->addr_pos = 0;
    o->key_start = o->buf_len;
    o->key_span = 0;
    o->key_pos = 0;
    o->password_start = o->buf_len;
    o->password_span = 0;
    o->password_pos = 0;

    int addr_count = 0;
    int key_count = 0;
    int password_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) {
                    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) {
                    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) {
                    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 3:
                        if (o->password_start == o->buf_len) {
                            o->password_start = entry_pos;
                        }
                        o->password_span = pos - o->password_start;
                        password_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 1:
                        if (!(type == BPROTO_TYPE_DATA)) {
                            return 0;
                        }
                        if (o->addr_start == o->buf_len) {
                            o->addr_start = entry_pos;
                        }
                        o->addr_span = pos - o->addr_start;
                        addr_count++;
                        break;
                    case 2:
                        if (!(type == BPROTO_TYPE_DATA)) {
                            return 0;
                        }
                        if (o->key_start == o->buf_len) {
                            o->key_start = entry_pos;
                        }
                        o->key_span = pos - o->key_start;
                        key_count++;
                        break;
                    default:
                        return 0;
                }
            } break;
            default:
                return 0;
        }
    }

    if (!(addr_count >= 1)) {
        return 0;
    }
    if (!(key_count <= 1)) {
        return 0;
    }
    if (!(password_count <= 1)) {
        return 0;
    }

    return 1;
}

int msg_youconnectParser_GotEverything (msg_youconnectParser *o)
{
    return (
        o->addr_pos == o->addr_span
        &&
        o->key_pos == o->key_span
        &&
        o->password_pos == o->password_span
    );
}

int msg_youconnectParser_Getaddr (msg_youconnectParser *o, uint8_t **data, int *data_len)
{
    ASSERT(o->addr_pos >= 0)
    ASSERT(o->addr_pos <= o->addr_span)

    int left = o->addr_span - o->addr_pos;

    while (left > 0) {
        ASSERT(left >= sizeof(struct BProto_header_s))
        struct BProto_header_s header;
        memcpy(&header, o->buf + o->addr_start + o->addr_pos, sizeof(header));
        o->addr_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->addr_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->addr_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->addr_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->addr_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->addr_start + o->addr_pos, sizeof(val));
                o->addr_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->addr_start + o->addr_pos;
                o->addr_pos += payload_len;
                left -= payload_len;

                if (type == BPROTO_TYPE_DATA && id == 1) {
                    *data = payload;
                    *data_len = payload_len;
                    return 1;
                }
            } break;
            default:
                ASSERT(0);
        }
    }

    return 0;
}

void msg_youconnectParser_Resetaddr (msg_youconnectParser *o)
{
    o->addr_pos = 0;
}

void msg_youconnectParser_Forwardaddr (msg_youconnectParser *o)
{
    o->addr_pos = o->addr_span;
}

int msg_youconnectParser_Getkey (msg_youconnectParser *o, uint8_t **data, int *data_len)
{
    ASSERT(o->key_pos >= 0)
    ASSERT(o->key_pos <= o->key_span)

    int left = o->key_span - o->key_pos;

    while (left > 0) {
        ASSERT(left >= sizeof(struct BProto_header_s))
        struct BProto_header_s header;
        memcpy(&header, o->buf + o->key_start + o->key_pos, sizeof(header));
        o->key_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->key_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->key_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->key_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->key_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->key_start + o->key_pos, sizeof(val));
                o->key_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->key_start + o->key_pos;
                o->key_pos += payload_len;
                left -= payload_len;

                if (type == BPROTO_TYPE_DATA && id == 2) {
                    *data = payload;
                    *data_len = payload_len;
                    return 1;
                }
            } break;
            default:
                ASSERT(0);
        }
    }

    return 0;
}

void msg_youconnectParser_Resetkey (msg_youconnectParser *o)
{
    o->key_pos = 0;
}

void msg_youconnectParser_Forwardkey (msg_youconnectParser *o)
{
    o->key_pos = o->key_span;
}

int msg_youconnectParser_Getpassword (msg_youconnectParser *o, uint64_t *v)
{
    ASSERT(o->password_pos >= 0)
    ASSERT(o->password_pos <= o->password_span)

    int left = o->password_span - o->password_pos;

    while (left > 0) {
        ASSERT(left >= sizeof(struct BProto_header_s))
        struct BProto_header_s header;
        memcpy(&header, o->buf + o->password_start + o->password_pos, sizeof(header));
        o->password_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->password_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->password_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->password_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->password_start + o->password_pos, sizeof(val));
                o->password_pos += sizeof(struct BProto_uint64_s);
                left -= sizeof(struct BProto_uint64_s);

                if (id == 3) {
                    *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->password_start + o->password_pos, sizeof(val));
                o->password_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->password_pos += payload_len;
                left -= payload_len;
            } break;
            default:
                ASSERT(0);
        }
    }

    return 0;
}

void msg_youconnectParser_Resetpassword (msg_youconnectParser *o)
{
    o->password_pos = 0;
}

void msg_youconnectParser_Forwardpassword (msg_youconnectParser *o)
{
    o->password_pos = o->password_span;
}

#define msg_youconnect_addr_SIZEname(_len) (sizeof(struct BProto_header_s) + sizeof(struct BProto_data_header_s) + (_len))
#define msg_youconnect_addr_SIZEaddr(_len) (sizeof(struct BProto_header_s) + sizeof(struct BProto_data_header_s) + (_len))

typedef struct {
    uint8_t *out;
    int used;
    int name_count;
    int addr_count;
} msg_youconnect_addrWriter;

static void msg_youconnect_addrWriter_Init (msg_youconnect_addrWriter *o, uint8_t *out);
static int msg_youconnect_addrWriter_Finish (msg_youconnect_addrWriter *o);
static uint8_t * msg_youconnect_addrWriter_Addname (msg_youconnect_addrWriter *o, int len);
static uint8_t * msg_youconnect_addrWriter_Addaddr (msg_youconnect_addrWriter *o, int len);

typedef struct {
    uint8_t *buf;
    int buf_len;
    int name_start;
    int name_span;
    int name_pos;
    int addr_start;
    int addr_span;
    int addr_pos;
} msg_youconnect_addrParser;

static int msg_youconnect_addrParser_Init (msg_youconnect_addrParser *o, uint8_t *buf, int buf_len);
static int msg_youconnect_addrParser_GotEverything (msg_youconnect_addrParser *o);
static int msg_youconnect_addrParser_Getname (msg_youconnect_addrParser *o, uint8_t **data, int *data_len);
static void msg_youconnect_addrParser_Resetname (msg_youconnect_addrParser *o);
static void msg_youconnect_addrParser_Forwardname (msg_youconnect_addrParser *o);
static int msg_youconnect_addrParser_Getaddr (msg_youconnect_addrParser *o, uint8_t **data, int *data_len);
static void msg_youconnect_addrParser_Resetaddr (msg_youconnect_addrParser *o);
static void msg_youconnect_addrParser_Forwardaddr (msg_youconnect_addrParser *o);

void msg_youconnect_addrWriter_Init (msg_youconnect_addrWriter *o, uint8_t *out)
{
    o->out = out;
    o->used = 0;
    o->name_count = 0;
    o->addr_count = 0;
}

int msg_youconnect_addrWriter_Finish (msg_youconnect_addrWriter *o)
{
    ASSERT(o->used >= 0)
    ASSERT(o->name_count == 1)
    ASSERT(o->addr_count == 1)

    return o->used;
}

uint8_t * msg_youconnect_addrWriter_Addname (msg_youconnect_addrWriter *o, int len)
{
    ASSERT(o->used >= 0)
    ASSERT(o->name_count == 0)
    ASSERT(len >= 0 && len <= UINT32_MAX)

    struct BProto_header_s header;
    header.id = htol16(1);
    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->name_count++;

    return dest;
}

uint8_t * msg_youconnect_addrWriter_Addaddr (msg_youconnect_addrWriter *o, int len)
{
    ASSERT(o->used >= 0)
    ASSERT(o->addr_count == 0)
    ASSERT(len >= 0 && len <= UINT32_MAX)

    struct BProto_header_s header;
    header.id = htol16(2);
    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->addr_count++;

    return dest;
}

int msg_youconnect_addrParser_Init (msg_youconnect_addrParser *o, uint8_t *buf, int buf_len)
{
    ASSERT(buf_len >= 0)

    o->buf = buf;
    o->buf_len = buf_len;
    o->name_start = o->buf_len;
    o->name_span = 0;
    o->name_pos = 0;
    o->addr_start = o->buf_len;
    o->addr_span = 0;
    o->addr_pos = 0;

    int name_count = 0;
    int addr_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) {
                    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) {
                    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) {
                    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) {
                    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 1:
                        if (!(type == BPROTO_TYPE_DATA)) {
                            return 0;
                        }
                        if (o->name_start == o->buf_len) {
                            o->name_start = entry_pos;
                        }
                        o->name_span = pos - o->name_start;
                        name_count++;
                        break;
                    case 2:
                        if (!(type == BPROTO_TYPE_DATA)) {
                            return 0;
                        }
                        if (o->addr_start == o->buf_len) {
                            o->addr_start = entry_pos;
                        }
                        o->addr_span = pos - o->addr_start;
                        addr_count++;
                        break;
                    default:
                        return 0;
                }
            } break;
            default:
                return 0;
        }
    }

    if (!(name_count == 1)) {
        return 0;
    }
    if (!(addr_count == 1)) {
        return 0;
    }

    return 1;
}

int msg_youconnect_addrParser_GotEverything (msg_youconnect_addrParser *o)
{
    return (
        o->name_pos == o->name_span
        &&
        o->addr_pos == o->addr_span
    );
}

int msg_youconnect_addrParser_Getname (msg_youconnect_addrParser *o, uint8_t **data, int *data_len)
{
    ASSERT(o->name_pos >= 0)
    ASSERT(o->name_pos <= o->name_span)

    int left = o->name_span - o->name_pos;

    while (left > 0) {
        ASSERT(left >= sizeof(struct BProto_header_s))
        struct BProto_header_s header;
        memcpy(&header, o->buf + o->name_start + o->name_pos, sizeof(header));
        o->name_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->name_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->name_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->name_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->name_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->name_start + o->name_pos, sizeof(val));
                o->name_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->name_start + o->name_pos;
                o->name_pos += payload_len;
                left -= payload_len;

                if (type == BPROTO_TYPE_DATA && id == 1) {
                    *data = payload;
                    *data_len = payload_len;
                    return 1;
                }
            } break;
            default:
                ASSERT(0);
        }
    }

    return 0;
}

void msg_youconnect_addrParser_Resetname (msg_youconnect_addrParser *o)
{
    o->name_pos = 0;
}

void msg_youconnect_addrParser_Forwardname (msg_youconnect_addrParser *o)
{
    o->name_pos = o->name_span;
}

int msg_youconnect_addrParser_Getaddr (msg_youconnect_addrParser *o, uint8_t **data, int *data_len)
{
    ASSERT(o->addr_pos >= 0)
    ASSERT(o->addr_pos <= o->addr_span)

    int left = o->addr_span - o->addr_pos;

    while (left > 0) {
        ASSERT(left >= sizeof(struct BProto_header_s))
        struct BProto_header_s header;
        memcpy(&header, o->buf + o->addr_start + o->addr_pos, sizeof(header));
        o->addr_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->addr_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->addr_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->addr_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->addr_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->addr_start + o->addr_pos, sizeof(val));
                o->addr_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->addr_start + o->addr_pos;
                o->addr_pos += payload_len;
                left -= payload_len;

                if (type == BPROTO_TYPE_DATA && id == 2) {
                    *data = payload;
                    *data_len = payload_len;
                    return 1;
                }
            } break;
            default:
                ASSERT(0);
        }
    }

    return 0;
}

void msg_youconnect_addrParser_Resetaddr (msg_youconnect_addrParser *o)
{
    o->addr_pos = 0;
}

void msg_youconnect_addrParser_Forwardaddr (msg_youconnect_addrParser *o)
{
    o->addr_pos = o->addr_span;
}

#define msg_seed_SIZEseed_id (sizeof(struct BProto_header_s) + sizeof(struct BProto_uint16_s))
#define msg_seed_SIZEkey(_len) (sizeof(struct BProto_header_s) + sizeof(struct BProto_data_header_s) + (_len))
#define msg_seed_SIZEiv(_len) (sizeof(struct BProto_header_s) + sizeof(struct BProto_data_header_s) + (_len))

typedef struct {
    uint8_t *out;
    int used;
    int seed_id_count;
    int key_count;
    int iv_count;
} msg_seedWriter;

static void msg_seedWriter_Init (msg_seedWriter *o, uint8_t *out);
static int msg_seedWriter_Finish (msg_seedWriter *o);
static void msg_seedWriter_Addseed_id (msg_seedWriter *o, uint16_t v);
static uint8_t * msg_seedWriter_Addkey (msg_seedWriter *o, int len);
static uint8_t * msg_seedWriter_Addiv (msg_seedWriter *o, int len);

typedef struct {
    uint8_t *buf;
    int buf_len;
    int seed_id_start;
    int seed_id_span;
    int seed_id_pos;
    int key_start;
    int key_span;
    int key_pos;
    int iv_start;
    int iv_span;
    int iv_pos;
} msg_seedParser;

static int msg_seedParser_Init (msg_seedParser *o, uint8_t *buf, int buf_len);
static int msg_seedParser_GotEverything (msg_seedParser *o);
static int msg_seedParser_Getseed_id (msg_seedParser *o, uint16_t *v);
static void msg_seedParser_Resetseed_id (msg_seedParser *o);
static void msg_seedParser_Forwardseed_id (msg_seedParser *o);
static int msg_seedParser_Getkey (msg_seedParser *o, uint8_t **data, int *data_len);
static void msg_seedParser_Resetkey (msg_seedParser *o);
static void msg_seedParser_Forwardkey (msg_seedParser *o);
static int msg_seedParser_Getiv (msg_seedParser *o, uint8_t **data, int *data_len);
static void msg_seedParser_Resetiv (msg_seedParser *o);
static void msg_seedParser_Forwardiv (msg_seedParser *o);

void msg_seedWriter_Init (msg_seedWriter *o, uint8_t *out)
{
    o->out = out;
    o->used = 0;
    o->seed_id_count = 0;
    o->key_count = 0;
    o->iv_count = 0;
}

int msg_seedWriter_Finish (msg_seedWriter *o)
{
    ASSERT(o->used >= 0)
    ASSERT(o->seed_id_count == 1)
    ASSERT(o->key_count == 1)
    ASSERT(o->iv_count == 1)

    return o->used;
}

void msg_seedWriter_Addseed_id (msg_seedWriter *o, uint16_t v)
{
    ASSERT(o->used >= 0)
    ASSERT(o->seed_id_count == 0)
    

    struct BProto_header_s header;
    header.id = htol16(1);
    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->seed_id_count++;
}

uint8_t * msg_seedWriter_Addkey (msg_seedWriter *o, int len)
{
    ASSERT(o->used >= 0)
    ASSERT(o->key_count == 0)
    ASSERT(len >= 0 && len <= UINT32_MAX)

    struct BProto_header_s header;
    header.id = htol16(2);
    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->key_count++;

    return dest;
}

uint8_t * msg_seedWriter_Addiv (msg_seedWriter *o, int len)
{
    ASSERT(o->used >= 0)
    ASSERT(o->iv_count == 0)
    ASSERT(len >= 0 && len <= UINT32_MAX)

    struct BProto_header_s header;
    header.id = htol16(3);
    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->iv_count++;

    return dest;
}

int msg_seedParser_Init (msg_seedParser *o, uint8_t *buf, int buf_len)
{
    ASSERT(buf_len >= 0)

    o->buf = buf;
    o->buf_len = buf_len;
    o->seed_id_start = o->buf_len;
    o->seed_id_span = 0;
    o->seed_id_pos = 0;
    o->key_start = o->buf_len;
    o->key_span = 0;
    o->key_pos = 0;
    o->iv_start = o->buf_len;
    o->iv_span = 0;
    o->iv_pos = 0;

    int seed_id_count = 0;
    int key_count = 0;
    int iv_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) {
                    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 1:
                        if (o->seed_id_start == o->buf_len) {
                            o->seed_id_start = entry_pos;
                        }
                        o->seed_id_span = pos - o->seed_id_start;
                        seed_id_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) {
                    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) {
                    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 2:
                        if (!(type == BPROTO_TYPE_DATA)) {
                            return 0;
                        }
                        if (o->key_start == o->buf_len) {
                            o->key_start = entry_pos;
                        }
                        o->key_span = pos - o->key_start;
                        key_count++;
                        break;
                    case 3:
                        if (!(type == BPROTO_TYPE_DATA)) {
                            return 0;
                        }
                        if (o->iv_start == o->buf_len) {
                            o->iv_start = entry_pos;
                        }
                        o->iv_span = pos - o->iv_start;
                        iv_count++;
                        break;
                    default:
                        return 0;
                }
            } break;
            default:
                return 0;
        }
    }

    if (!(seed_id_count == 1)) {
        return 0;
    }
    if (!(key_count == 1)) {
        return 0;
    }
    if (!(iv_count == 1)) {
        return 0;
    }

    return 1;
}

int msg_seedParser_GotEverything (msg_seedParser *o)
{
    return (
        o->seed_id_pos == o->seed_id_span
        &&
        o->key_pos == o->key_span
        &&
        o->iv_pos == o->iv_span
    );
}

int msg_seedParser_Getseed_id (msg_seedParser *o, uint16_t *v)
{
    ASSERT(o->seed_id_pos >= 0)
    ASSERT(o->seed_id_pos <= o->seed_id_span)

    int left = o->seed_id_span - o->seed_id_pos;

    while (left > 0) {
        ASSERT(left >= sizeof(struct BProto_header_s))
        struct BProto_header_s header;
        memcpy(&header, o->buf + o->seed_id_start + o->seed_id_pos, sizeof(header));
        o->seed_id_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->seed_id_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->seed_id_start + o->seed_id_pos, sizeof(val));
                o->seed_id_pos += sizeof(struct BProto_uint16_s);
                left -= sizeof(struct BProto_uint16_s);

                if (id == 1) {
                    *v = ltoh16(val.v);
                    return 1;
                }
            } break;
            case BPROTO_TYPE_UINT32: {
                ASSERT(left >= sizeof(struct BProto_uint32_s))
                o->seed_id_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->seed_id_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->seed_id_start + o->seed_id_pos, sizeof(val));
                o->seed_id_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->seed_id_pos += payload_len;
                left -= payload_len;
            } break;
            default:
                ASSERT(0);
        }
    }

    return 0;
}

void msg_seedParser_Resetseed_id (msg_seedParser *o)
{
    o->seed_id_pos = 0;
}

void msg_seedParser_Forwardseed_id (msg_seedParser *o)
{
    o->seed_id_pos = o->seed_id_span;
}

int msg_seedParser_Getkey (msg_seedParser *o, uint8_t **data, int *data_len)
{
    ASSERT(o->key_pos >= 0)
    ASSERT(o->key_pos <= o->key_span)

    int left = o->key_span - o->key_pos;

    while (left > 0) {
        ASSERT(left >= sizeof(struct BProto_header_s))
        struct BProto_header_s header;
        memcpy(&header, o->buf + o->key_start + o->key_pos, sizeof(header));
        o->key_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->key_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->key_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->key_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->key_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->key_start + o->key_pos, sizeof(val));
                o->key_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->key_start + o->key_pos;
                o->key_pos += payload_len;
                left -= payload_len;

                if (type == BPROTO_TYPE_DATA && id == 2) {
                    *data = payload;
                    *data_len = payload_len;
                    return 1;
                }
            } break;
            default:
                ASSERT(0);
        }
    }

    return 0;
}

void msg_seedParser_Resetkey (msg_seedParser *o)
{
    o->key_pos = 0;
}

void msg_seedParser_Forwardkey (msg_seedParser *o)
{
    o->key_pos = o->key_span;
}

int msg_seedParser_Getiv (msg_seedParser *o, uint8_t **data, int *data_len)
{
    ASSERT(o->iv_pos >= 0)
    ASSERT(o->iv_pos <= o->iv_span)

    int left = o->iv_span - o->iv_pos;

    while (left > 0) {
        ASSERT(left >= sizeof(struct BProto_header_s))
        struct BProto_header_s header;
        memcpy(&header, o->buf + o->iv_start + o->iv_pos, sizeof(header));
        o->iv_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->iv_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->iv_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->iv_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->iv_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->iv_start + o->iv_pos, sizeof(val));
                o->iv_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->iv_start + o->iv_pos;
                o->iv_pos += payload_len;
                left -= payload_len;

                if (type == BPROTO_TYPE_DATA && id == 3) {
                    *data = payload;
                    *data_len = payload_len;
                    return 1;
                }
            } break;
            default:
                ASSERT(0);
        }
    }

    return 0;
}

void msg_seedParser_Resetiv (msg_seedParser *o)
{
    o->iv_pos = 0;
}

void msg_seedParser_Forwardiv (msg_seedParser *o)
{
    o->iv_pos = o->iv_span;
}

#define msg_confirmseed_SIZEseed_id (sizeof(struct BProto_header_s) + sizeof(struct BProto_uint16_s))

typedef struct {
    uint8_t *out;
    int used;
    int seed_id_count;
} msg_confirmseedWriter;

static void msg_confirmseedWriter_Init (msg_confirmseedWriter *o, uint8_t *out);
static int msg_confirmseedWriter_Finish (msg_confirmseedWriter *o);
static void msg_confirmseedWriter_Addseed_id (msg_confirmseedWriter *o, uint16_t v);

typedef struct {
    uint8_t *buf;
    int buf_len;
    int seed_id_start;
    int seed_id_span;
    int seed_id_pos;
} msg_confirmseedParser;

static int msg_confirmseedParser_Init (msg_confirmseedParser *o, uint8_t *buf, int buf_len);
static int msg_confirmseedParser_GotEverything (msg_confirmseedParser *o);
static int msg_confirmseedParser_Getseed_id (msg_confirmseedParser *o, uint16_t *v);
static void msg_confirmseedParser_Resetseed_id (msg_confirmseedParser *o);
static void msg_confirmseedParser_Forwardseed_id (msg_confirmseedParser *o);

void msg_confirmseedWriter_Init (msg_confirmseedWriter *o, uint8_t *out)
{
    o->out = out;
    o->used = 0;
    o->seed_id_count = 0;
}

int msg_confirmseedWriter_Finish (msg_confirmseedWriter *o)
{
    ASSERT(o->used >= 0)
    ASSERT(o->seed_id_count == 1)

    return o->used;
}

void msg_confirmseedWriter_Addseed_id (msg_confirmseedWriter *o, uint16_t v)
{
    ASSERT(o->used >= 0)
    ASSERT(o->seed_id_count == 0)
    

    struct BProto_header_s header;
    header.id = htol16(1);
    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->seed_id_count++;
}

int msg_confirmseedParser_Init (msg_confirmseedParser *o, uint8_t *buf, int buf_len)
{
    ASSERT(buf_len >= 0)

    o->buf = buf;
    o->buf_len = buf_len;
    o->seed_id_start = o->buf_len;
    o->seed_id_span = 0;
    o->seed_id_pos = 0;

    int seed_id_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) {
                    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 1:
                        if (o->seed_id_start == o->buf_len) {
                            o->seed_id_start = entry_pos;
                        }
                        o->seed_id_span = pos - o->seed_id_start;
                        seed_id_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) {
                    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) {
                    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) {
                    default:
                        return 0;
                }
            } break;
            default:
                return 0;
        }
    }

    if (!(seed_id_count == 1)) {
        return 0;
    }

    return 1;
}

int msg_confirmseedParser_GotEverything (msg_confirmseedParser *o)
{
    return (
        o->seed_id_pos == o->seed_id_span
    );
}

int msg_confirmseedParser_Getseed_id (msg_confirmseedParser *o, uint16_t *v)
{
    ASSERT(o->seed_id_pos >= 0)
    ASSERT(o->seed_id_pos <= o->seed_id_span)

    int left = o->seed_id_span - o->seed_id_pos;

    while (left > 0) {
        ASSERT(left >= sizeof(struct BProto_header_s))
        struct BProto_header_s header;
        memcpy(&header, o->buf + o->seed_id_start + o->seed_id_pos, sizeof(header));
        o->seed_id_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->seed_id_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->seed_id_start + o->seed_id_pos, sizeof(val));
                o->seed_id_pos += sizeof(struct BProto_uint16_s);
                left -= sizeof(struct BProto_uint16_s);

                if (id == 1) {
                    *v = ltoh16(val.v);
                    return 1;
                }
            } break;
            case BPROTO_TYPE_UINT32: {
                ASSERT(left >= sizeof(struct BProto_uint32_s))
                o->seed_id_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->seed_id_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->seed_id_start + o->seed_id_pos, sizeof(val));
                o->seed_id_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->seed_id_pos += payload_len;
                left -= payload_len;
            } break;
            default:
                ASSERT(0);
        }
    }

    return 0;
}

void msg_confirmseedParser_Resetseed_id (msg_confirmseedParser *o)
{
    o->seed_id_pos = 0;
}

void msg_confirmseedParser_Forwardseed_id (msg_confirmseedParser *o)
{
    o->seed_id_pos = o->seed_id_span;
}