shithub: riscv

ref: 9861f1a92b373a16939fd6f3c167e5dad9f253d3
dir: /sys/src/libventi/debugpacket.c/

#include <u.h>
#include <libc.h>
#include <venti.h>
#include <libsec.h>

#define MAGIC 0x54798314
#define NOTFREE(p)	assert((p)->magic == MAGIC)

struct Packet
{
	char *data;
	int len;
	void (*free)(void*);
	void *arg;
	int magic;
};

Packet*
packetalloc(void)
{
	Packet *p;
	
	p = vtmallocz(sizeof *p);
	p->free = vtfree;
	p->arg = nil;
	p->magic = MAGIC;
	return p;
}

void
packetappend(Packet *p, uchar *buf, int n)
{
	NOTFREE(p);
	if(n < 0)
		abort();
	if(p->free != vtfree)
		sysfatal("packetappend");
	p->data = vtrealloc(p->data, p->len+n);
	p->arg = p->data;
	memmove(p->data+p->len, buf, n);
	p->len += n;
}

uint
packetasize(Packet *p)
{
	NOTFREE(p);
	return p->len;
}

int
packetcmp(Packet *p, Packet *q)
{
	int i, len;
	
	NOTFREE(p);
	NOTFREE(q);
	len = p->len;
	if(len > q->len)
		len = q->len;
	if(len && (i=memcmp(p->data, q->data, len)) != 0)
		return i;
	if(p->len > len)
		return 1;
	if(q->len > len)
		return -1;
	return 0;
}

void
packetconcat(Packet *p, Packet *q)
{
	NOTFREE(p);
	NOTFREE(q);
	packetappend(p, q->data, q->len);
	if(q->free == vtfree)
		memset(q->data, 0xFE, q->len);
	q->free(q->arg);
	q->data = nil;
	q->len = 0;
}

int
packetconsume(Packet *p, uchar *buf, int n)
{
	NOTFREE(p);
	if(n < 0)
		abort();
	if(p->len < n)
		abort();
	memmove(buf, p->data, n);
	p->len -= n;
	memmove(p->data, p->data+n, p->len);
	return 0;
}

int
packetcopy(Packet *p, uchar *buf, int offset, int n)
{
	NOTFREE(p);
	if(offset < 0 || n < 0)
		abort();
	if(offset > p->len)
		abort();
	if(offset+n > p->len)
		n = p->len - offset;
	memmove(buf, p->data+offset, n);
	return 0;
}

Packet*
packetdup(Packet *p, int offset, int n)
{
	Packet *q;

	NOTFREE(p);
	if(offset < 0 || n < 0)
		abort();
	if(offset > p->len)
		abort();
	if(offset+n > p->len)
		n = p->len - offset;
	q = packetalloc();
	packetappend(q, p->data+offset, n);
	return q;
}

Packet*
packetforeign(uchar *buf, int n, void (*free)(void*), void *a)
{
	Packet *p;
	
	if(n < 0)
		abort();
	p = packetalloc();
	p->data = (char*)buf;
	p->len = n;
	p->free = free;
	p->arg = a;
	return p;
}

int
packetfragments(Packet *p, IOchunk *io, int nio, int offset)
{
	NOTFREE(p);
	if(offset < 0)
		abort();
	if(nio == 0)
		return 0;
	memset(io, 0, sizeof(io[0])*nio);
	if(offset >= p->len)
		return 0;
	io[0].addr = p->data + offset;
	io[0].len = p->len - offset;
	return p->len;
}

void
packetfree(Packet *p)
{
	NOTFREE(p);
	if(p->free == free)
		memset(p->data, 0xFE, p->len);
	p->free(p->arg);
	p->data = nil;
	p->len = 0;
	memset(p, 0xFB, sizeof *p);
	free(p);
}

uchar*
packetheader(Packet *p, int n)
{
	NOTFREE(p);
	if(n < 0)
		abort();
	if(n > p->len)
		abort();
	return p->data;
}

uchar*
packetpeek(Packet *p, uchar *buf, int offset, int n)
{
	NOTFREE(p);
	if(offset < 0 || n < 0)
		abort();
	if(offset+n > p->len)
		abort();
	return p->data+offset;
}

void
packetprefix(Packet *p, uchar *buf, int n)
{
	NOTFREE(p);
	if(n < 0)
		abort();
	if(p->free != free)
		sysfatal("packetappend");
	p->data = vtrealloc(p->data, p->len+n);
	p->arg = p->data;
	memmove(p->data+n, p->data, p->len);
	memmove(p->data, buf, n);
	p->len += n;
}

void
packetsha1(Packet *p, uchar d[20])
{
	NOTFREE(p);
	sha1((uchar*)p->data, p->len, d, nil);
}

uint
packetsize(Packet *p)
{
	NOTFREE(p);
	return p->len;
}

Packet*
packetsplit(Packet *p, int n)
{
	Packet *q;
	
	NOTFREE(p);
	q = packetalloc();
	q->data = vtmalloc(n);
	q->arg = q->data;
	q->free = vtfree;
	packetconsume(p, q->data, n);
	return q;
}

void
packetstats(void)
{
}

uchar*
packettrailer(Packet *p, int n)
{
	NOTFREE(p);
	if(n < 0)
		abort();
	if(n > p->len)
		abort();
	return p->data + p->len - n;
}

int
packettrim(Packet *p, int offset, int n)
{
	NOTFREE(p);
	if(offset < 0 || n < 0)
		abort();
	if(offset+n > p->len)
		abort();
	memmove(p->data+offset, p->data+offset+n, p->len-offset-n);
	p->len -= n;
	return 0;
}