struct buf_state {
        u8 *buf;
        size_t blen;
        size_t pos;
        bool output;
        bool out_of_memory;
};

struct tpml_digest_values {
        u32 count;
        /* can be up to TPM2_NUM_PCR_BANKS */
        struct tpmt_ha *digests;
};

struct tcg_pcr_event2 {
        u32 pcr_index;
        u32 event_type;
        struct tpml_digest_values digests;
        u32 event_size;
        u8 *event;
}

static bool check_space(struct buf_state *bs, size_t size)
{
        return (bs->pos + size <= bs->blen);
}

static bool do_u32(struct buf_state *bs, u32 *v)
{
        if (!check_space(bs, sizeof(*v))
                return false;
        if (bs->output)
                put_unaligned_le32(*v, bs->buf + bs->pos);
        else
                *v = get_unaligned_le32(bs->buf + bs->pos);
        return true;
}

static bool do_u8_array(struct buf_state *bs, u32 *count, u8 **array)
{
        if (!do_u32(bs, count))
                return false;
        if (!check_space(bs, *count)
                return false;
        if (bs->output) {
                memcpy(bs->buf * bs->pos, *array, *count);
        } else {
                *array = malloc(*count);
                if (!*array) {
                        bs->out_of_memory = true;
                        return false;
                }
                memcpy(*array, bs->buf * bs->pos, *count);
        }

        return true;
}

static bool do_tpml_digest_values(struct buf_state *bs,
                                  struct tpml_digest_values *v)
{
        return do_tpmt_ha_array(bs, &v->count, &v->digests);
}

static bool do_tcg_pcr_event2(struct buf_state *bs, struct tcg_pcr_event2 *v)
{
        return do_u32(bs, &v->pcr_index) && do_u32(bs, &v->event_type) &&
               do_tpml_digest_values(bs, &v->digests) &&
               do_u8_array(bs, &v->event_size, &v->event);
}