Subversion Repositories planix.SVN

#include <u.h>

#include <libc.h>

#include <oventi.h>

#include "session.h"

static char EAuthState[] = "bad authentication state";

static char ENotServer[] = "not a server session";

static char EVersion[] = "incorrect version number";

static char EProtocolBotch[] = "venti protocol botch";

VtSession *

vtServerAlloc(VtServerVtbl *vtbl)

{

	VtSession *z = vtAlloc();

	z->vtbl = vtMemAlloc(sizeof(VtServerVtbl));

	setmalloctag(z->vtbl, getcallerpc(&vtbl));

	*z->vtbl = *vtbl;

	return z;

}

static int

srvHello(VtSession *z, char *version, char *uid, int , uchar *, int , uchar *, int )

{

	vtLock(z->lk);

	if(z->auth.state != VtAuthHello) {

		vtSetError(EAuthState);

		goto Err;

	}

	if(strcmp(version, vtGetVersion(z)) != 0) {

		vtSetError(EVersion);

		goto Err;

	}

	vtMemFree(z->uid);

	z->uid = vtStrDup(uid);

	z->auth.state = VtAuthOK;

	vtUnlock(z->lk);

	return 1;

Err:

	z->auth.state = VtAuthFailed;

	vtUnlock(z->lk);

	return 0;

}

static int

dispatchHello(VtSession *z, Packet **pkt)

{

	char *version, *uid;

	uchar *crypto, *codec;

	uchar buf[10];

	int ncrypto, ncodec, cryptoStrength;

	int ret;

	Packet *p;

	p = *pkt;

	version = nil;	

	uid = nil;

	crypto = nil;

	codec = nil;

	ret = 0;

	if(!vtGetString(p, &version))

		goto Err;

	if(!vtGetString(p, &uid))

		goto Err;

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

		goto Err;

	cryptoStrength = buf[0];

	ncrypto = buf[1];

	crypto = vtMemAlloc(ncrypto);

	if(!packetConsume(p, crypto, ncrypto))

		goto Err;

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

		goto Err;

	ncodec = buf[0];

	codec = vtMemAlloc(ncodec);

	if(!packetConsume(p, codec, ncodec))

		goto Err;

	if(packetSize(p) != 0) {

		vtSetError(EProtocolBotch);

		goto Err;

	}

	if(!srvHello(z, version, uid, cryptoStrength, crypto, ncrypto, codec, ncodec)) {

		packetFree(p);

		*pkt = nil;

	} else {

		if(!vtAddString(p, vtGetSid(z)))

			goto Err;

		buf[0] = vtGetCrypto(z);

		buf[1] = vtGetCodec(z);

		packetAppend(p, buf, 2);

	}

	ret = 1;

Err:

	vtMemFree(version);

	vtMemFree(uid);

	vtMemFree(crypto);

	vtMemFree(codec);

	return ret;

}

static int

dispatchRead(VtSession *z, Packet **pkt)

{

	Packet *p;

	int type, n;

	uchar score[VtScoreSize], buf[4];

	p = *pkt;

	if(!packetConsume(p, score, VtScoreSize))

		return 0;

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

		return 0;

	type = buf[0];

	n = (buf[2]<<8) | buf[3];

	if(packetSize(p) != 0) {

		vtSetError(EProtocolBotch);

		return 0;

	}

	packetFree(p);

	*pkt = (*z->vtbl->read)(z, score, type, n);

	return 1;

}

static int

dispatchWrite(VtSession *z, Packet **pkt)

{

	Packet *p;

	int type;

	uchar score[VtScoreSize], buf[4];

	p = *pkt;

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

		return 0;

	type = buf[0];

	if(!(z->vtbl->write)(z, score, type, p)) {

		*pkt = 0;

	} else {

		*pkt = packetAlloc();

		packetAppend(*pkt, score, VtScoreSize);

	}

	return 1;

}

static int

dispatchSync(VtSession *z, Packet **pkt)

{

	(z->vtbl->sync)(z);

	if(packetSize(*pkt) != 0) {

		vtSetError(EProtocolBotch);

		return 0;

	}

	return 1;

}

int

vtExport(VtSession *z)

{

	Packet *p;

	uchar buf[10], *hdr;

	int op, tid, clean;

	if(z->vtbl == nil) {

		vtSetError(ENotServer);

		return 0;

	}

	/* fork off slave */

	switch(rfork(RFNOWAIT|RFMEM|RFPROC)){

	case -1:

		vtOSError();

		return 0;

	case 0:

		break;

	default:

		return 1;

	}

	p = nil;

	clean = 0;

	vtAttach();

	if(!vtConnect(z, nil))

		goto Exit;

	vtDebug(z, "server connected!\n");

if(0)	vtSetDebug(z, 1);

	for(;;) {

		p = vtRecvPacket(z);

		if(p == nil) {

			break;

		}

		vtDebug(z, "server recv: ");

		vtDebugMesg(z, p, "\n");

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

			vtSetError(EProtocolBotch);

			break;

		}

		op = buf[0];

		tid = buf[1];

		switch(op) {

		default:

			vtSetError(EProtocolBotch);

			goto Exit;

		case VtQPing:

			break;

		case VtQGoodbye:

			clean = 1;

			goto Exit;

		case VtQHello:

			if(!dispatchHello(z, &p))

				goto Exit;

			break;

		case VtQRead:

			if(!dispatchRead(z, &p))

				goto Exit;

			break;

		case VtQWrite:

			if(!dispatchWrite(z, &p))

				goto Exit;

			break;

		case VtQSync:

			if(!dispatchSync(z, &p))

				goto Exit;

			break;

		}

		if(p != nil) {

			hdr = packetHeader(p, 2);

			hdr[0] = op+1;

			hdr[1] = tid;

		} else {

			p = packetAlloc();

			hdr = packetHeader(p, 2);

			hdr[0] = VtRError;

			hdr[1] = tid;

			if(!vtAddString(p, vtGetError()))

				goto Exit;

		}

		vtDebug(z, "server send: ");

		vtDebugMesg(z, p, "\n");

		if(!vtSendPacket(z, p)) {

			p = nil;

			goto Exit;

		}

	}

Exit:

	if(p != nil)

		packetFree(p);

	if(z->vtbl->closing)

		z->vtbl->closing(z, clean);

	vtClose(z);

	vtFree(z);

	vtDetach();

	exits(0);

	return 0;	/* never gets here */

}