uint8_t *p;

	struct bincode_state binstat;

	p = buf;
	dump_buf("hashed", p, hashed_len);

	binstat.avail = hashed_len;
	binstat.buf = buf;
	dump_buf("hashed", buf, hashed_len);

	hashed.version = bincode_getu64(&p);

	hashed.version = bincode_getu64(&binstat);

	len = bincode_getu64(&p);

	len = bincode_getu64(&binstat);

	hashed.header.message = bincode_getstr(&p, len);

	hashed.header.message = bincode_getstr(&binstat, len);

	if (*p++) {
		len = bincode_getu64(&p);
		hashed.header.description = bincode_getstr(&p, len);

	if (bincode_getu8(&binstat)) {
		len = bincode_getu64(&binstat);
		hashed.header.description = bincode_getstr(&binstat, len);

	len = bincode_getu64(&p);

	len = bincode_getu64(&binstat);

	hashed.header.timestamp = bincode_getstr(&p, len);

	hashed.header.timestamp = bincode_getstr(&binstat, len);

 */
/**
 * This approach could simplify signatures a bit (in the sense of changing to a
 * single pointer again). It would also allow adding some bounds checking that
 * we aren't trying to read more data than available in the buffer. Maybe a case
 * for "if (unlikely(s->len - s->count < sizeof(type)))" ?

struct bincode_state {
	size_t avail;	/* bytes still available */
	uint8_t *buf;
};

uint16_t bincode_getu16(uint8_t **);
uint32_t bincode_getu32(uint8_t **);
uint64_t bincode_getu64(uint8_t **);

uint8_t bincode_getu8(struct bincode_state *);
uint16_t bincode_getu16(struct bincode_state *);
uint32_t bincode_getu32(struct bincode_state *);
uint64_t bincode_getu64(struct bincode_state *);

char *bincode_getstr(uint8_t **, size_t);

char *bincode_getstr(struct bincode_state *, size_t);

uint8_t
bincode_getu8(struct bincode_state *s)
{
	uint8_t ret;

	ret = s->buf[0];

	s->avail -= sizeof(uint8_t);
	return ret;
}

bincode_getu16(uint8_t **bp)

bincode_getu16(struct bincode_state *s)

	b = *bp;

	b = s->buf;

	*bp += sizeof(uint16_t);

	s->avail -= sizeof(uint16_t);

bincode_getu32(uint8_t **bp)

bincode_getu32(struct bincode_state *s)

	b = *bp;

	b = s->buf;

	*bp += sizeof(uint32_t);

	s->avail -= sizeof(uint32_t);

bincode_getu64(uint8_t **bp)

bincode_getu64(struct bincode_state *s)

	b = *bp;

	b = s->buf;

	*bp += sizeof(uint64_t);

	s->avail -= sizeof(uint64_t);

bincode_getstr(uint8_t **b, size_t len)

bincode_getstr(struct bincode_state *s, size_t len)

	uint8_t *b;

	b = s->buf;

	memcpy(str, *b, len);

	memcpy(str, b, len);

	*b += len;

	s->avail -= len;