Subversion Repositories planix.SVN

#include <u.h>

#include <libc.h>

#include <oventi.h>

#include "session.h"

struct {

	int version;

	char *s;

} vtVersions[] = {

	VtVersion02, "02",

	0, 0,

};

static char EBigString[] = "string too long";

static char EBigPacket[] = "packet too long";

static char ENullString[] = "missing string";

static char EBadVersion[] = "bad format in version string";

static Packet *vtRPC(VtSession *z, int op, Packet *p);

VtSession *

vtAlloc(void)

{

	VtSession *z;

	z = vtMemAllocZ(sizeof(VtSession));

	z->lk = vtLockAlloc();

//	z->inHash = vtSha1Alloc();

	z->inLock = vtLockAlloc();

	z->part = packetAlloc();

//	z->outHash = vtSha1Alloc();

	z->outLock = vtLockAlloc();

	z->fd = -1;

	z->uid = vtStrDup("anonymous");

	z->sid = vtStrDup("anonymous");

	return z;

}

void

vtReset(VtSession *z)

{

	vtLock(z->lk);

	z->cstate = VtStateAlloc;

	if(z->fd >= 0){

		vtFdClose(z->fd);

		z->fd = -1;

	}

	vtUnlock(z->lk);

}

int

vtConnected(VtSession *z)

{

	return z->cstate == VtStateConnected;

}

void

vtDisconnect(VtSession *z, int error)

{

	Packet *p;

	uchar *b;

vtDebug(z, "vtDisconnect\n");

	vtLock(z->lk);

	if(z->cstate == VtStateConnected && !error && z->vtbl == nil) {

		/* clean shutdown */

		p = packetAlloc();

		b = packetHeader(p, 2);

		b[0] = VtQGoodbye;

		b[1] = 0;

		vtSendPacket(z, p);

	}

	if(z->fd >= 0)

		vtFdClose(z->fd);

	z->fd = -1;

	z->cstate = VtStateClosed;

	vtUnlock(z->lk);

}

void

vtClose(VtSession *z)

{

	vtDisconnect(z, 0);

}

void

vtFree(VtSession *z)

{

	if(z == nil)

		return;

	vtLockFree(z->lk);

	vtSha1Free(z->inHash);

	vtLockFree(z->inLock);

	packetFree(z->part);

	vtSha1Free(z->outHash);

	vtLockFree(z->outLock);

	vtMemFree(z->uid);

	vtMemFree(z->sid);

	vtMemFree(z->vtbl);

	memset(z, 0, sizeof(VtSession));

	z->fd = -1;

	vtMemFree(z);

}

char *

vtGetUid(VtSession *s)

{

	return s->uid;

}

char *

vtGetSid(VtSession *z)

{

	return z->sid;

}

int

vtSetDebug(VtSession *z, int debug)

{

	int old;

	vtLock(z->lk);

	old = z->debug;

	z->debug = debug;

	vtUnlock(z->lk);

	return old;

}

int

vtSetFd(VtSession *z, int fd)

{

	vtLock(z->lk);

	if(z->cstate != VtStateAlloc) {

		vtSetError("bad state");

		vtUnlock(z->lk);

		return 0;

	}

	if(z->fd >= 0)

		vtFdClose(z->fd);

	z->fd = fd;

	vtUnlock(z->lk);

	return 1;

}

int

vtGetFd(VtSession *z)

{

	return z->fd;

}

int

vtSetCryptoStrength(VtSession *z, int c)

{

	if(z->cstate != VtStateAlloc) {

		vtSetError("bad state");

		return 0;

	}

	if(c != VtCryptoStrengthNone) {

		vtSetError("not supported yet");

		return 0;

	}

	return 1;

}

int

vtGetCryptoStrength(VtSession *s)

{

	return s->cryptoStrength;

}

int

vtSetCompression(VtSession *z, int fd)

{

	vtLock(z->lk);

	if(z->cstate != VtStateAlloc) {

		vtSetError("bad state");

		vtUnlock(z->lk);

		return 0;

	}

	z->fd = fd;

	vtUnlock(z->lk);

	return 1;

}

int

vtGetCompression(VtSession *s)

{

	return s->compression;

}

int

vtGetCrypto(VtSession *s)

{

	return s->crypto;

}

int

vtGetCodec(VtSession *s)

{

	return s->codec;

}

char *

vtGetVersion(VtSession *z)

{

	int v, i;

	v = z->version;

	if(v == 0)

		return "unknown";

	for(i=0; vtVersions[i].version; i++)

		if(vtVersions[i].version == v)

			return vtVersions[i].s;

	assert(0);

	return 0;

}

/* hold z->inLock */

static int

vtVersionRead(VtSession *z, char *prefix, int *ret)

{

	char c;

	char buf[VtMaxStringSize];

	char *q, *p, *pp;

	int i;

	q = prefix;

	p = buf;

	for(;;) {

		if(p >= buf + sizeof(buf)) {

			vtSetError(EBadVersion);

			return 0;

		}

		if(!vtFdReadFully(z->fd, (uchar*)&c, 1))

			return 0;

		if(z->inHash)

			vtSha1Update(z->inHash, (uchar*)&c, 1);

		if(c == '\n') {

			*p = 0;

			break;

		}

		if(c < ' ' || *q && c != *q) {

			vtSetError(EBadVersion);

			return 0;

		}

		*p++ = c;

		if(*q)

			q++;

	}

	vtDebug(z, "version string in: %s\n", buf);

	p = buf + strlen(prefix);

	for(;;) {

		for(pp=p; *pp && *pp != ':'  && *pp != '-'; pp++)

			;

		for(i=0; vtVersions[i].version; i++) {

			if(strlen(vtVersions[i].s) != pp-p)

				continue;

			if(memcmp(vtVersions[i].s, p, pp-p) == 0) {

				*ret = vtVersions[i].version;

				return 1;

			}

		}

		p = pp;

		if(*p != ':')

			return 0;

		p++;

	}	

}

Packet*

vtRecvPacket(VtSession *z)

{

	uchar buf[10], *b;

	int n;

	Packet *p;

	int size, len;

	if(z->cstate != VtStateConnected) {

		vtSetError("session not connected");

		return 0;

	}

	vtLock(z->inLock);

	p = z->part;

	/* get enough for head size */

	size = packetSize(p);

	while(size < 2) {

		b = packetTrailer(p, MaxFragSize);

		assert(b != nil);

		n = vtFdRead(z->fd, b, MaxFragSize);

		if(n <= 0)

			goto Err;

		size += n;

		packetTrim(p, 0, size);

	}

	if(!packetConsume(p, buf, 2))

		goto Err;

	len = (buf[0] << 8) | buf[1];

	size -= 2;

	while(size < len) {

		n = len - size;

		if(n > MaxFragSize)

			n = MaxFragSize;

		b = packetTrailer(p, n);

		if(!vtFdReadFully(z->fd, b, n))

			goto Err;

		size += n;

	}

	p = packetSplit(p, len);

	vtUnlock(z->inLock);

	return p;

Err:	

	vtUnlock(z->inLock);

	return nil;	

}

int

vtSendPacket(VtSession *z, Packet *p)

{

	IOchunk ioc;

	int n;

	uchar buf[2];

	/* add framing */

	n = packetSize(p);

	if(n >= (1<<16)) {

		vtSetError(EBigPacket);

		packetFree(p);

		return 0;

	}

	buf[0] = n>>8;

	buf[1] = n;

	packetPrefix(p, buf, 2);

	for(;;) {

		n = packetFragments(p, &ioc, 1, 0);

		if(n == 0)

			break;

		if(!vtFdWrite(z->fd, ioc.addr, ioc.len)) {

			packetFree(p);

			return 0;

		}

		packetConsume(p, nil, n);

	}

	packetFree(p);

	return 1;

}

int

vtGetString(Packet *p, char **ret)

{

	uchar buf[2];

	int n;

	char *s;

	if(!packetConsume(p, buf, 2))

		return 0;

	n = (buf[0]<<8) + buf[1];

	if(n > VtMaxStringSize) {

		vtSetError(EBigString);

		return 0;

	}

	s = vtMemAlloc(n+1);

	setmalloctag(s, getcallerpc(&p));

	if(!packetConsume(p, (uchar*)s, n)) {

		vtMemFree(s);

		return 0;

	}

	s[n] = 0;

	*ret = s;

	return 1;

}

int

vtAddString(Packet *p, char *s)

{

	uchar buf[2];

	int n;

	if(s == nil) {

		vtSetError(ENullString);

		return 0;

	}

	n = strlen(s);

	if(n > VtMaxStringSize) {

		vtSetError(EBigString);

		return 0;

	}

	buf[0] = n>>8;

	buf[1] = n;

	packetAppend(p, buf, 2);

	packetAppend(p, (uchar*)s, n);

	return 1;

}

int

vtConnect(VtSession *z, char *password)

{

	char buf[VtMaxStringSize], *p, *ep, *prefix;

	int i;

	USED(password);

	vtLock(z->lk);

	if(z->cstate != VtStateAlloc) {

		vtSetError("bad session state");

		vtUnlock(z->lk);

		return 0;

	}

	if(z->fd < 0){

		vtSetError("%s", z->fderror);

		vtUnlock(z->lk);

		return 0;

	}

	/* be a little anal */

	vtLock(z->inLock);

	vtLock(z->outLock);

	prefix = "venti-";

	p = buf;

	ep = buf + sizeof(buf);

	p = seprint(p, ep, "%s", prefix);

	p += strlen(p);

	for(i=0; vtVersions[i].version; i++) {

		if(i != 0)

			*p++ = ':';

		p = seprint(p, ep, "%s", vtVersions[i].s);

	}

	p = seprint(p, ep, "-libventi\n");

	assert(p-buf < sizeof(buf));

	if(z->outHash)

		vtSha1Update(z->outHash, (uchar*)buf, p-buf);

	if(!vtFdWrite(z->fd, (uchar*)buf, p-buf))

		goto Err;

	vtDebug(z, "version string out: %s", buf);

	if(!vtVersionRead(z, prefix, &z->version))

		goto Err;

	vtDebug(z, "version = %d: %s\n", z->version, vtGetVersion(z));

	vtUnlock(z->inLock);

	vtUnlock(z->outLock);

	z->cstate = VtStateConnected;

	vtUnlock(z->lk);

	if(z->vtbl)

		return 1;

	if(!vtHello(z))

		goto Err;

	return 1;	

Err:

	if(z->fd >= 0)

		vtFdClose(z->fd);

	z->fd = -1;

	vtUnlock(z->inLock);

	vtUnlock(z->outLock);

	z->cstate = VtStateClosed;

	vtUnlock(z->lk);

	return 0;	

}