Subversion Repositories planix.SVN

#pragma	lib	"liboventi.a"

#pragma	src	"/sys/src/liboventi"

typedef struct VtSession	VtSession;

typedef struct VtSha1		VtSha1;

typedef struct Packet		Packet;

typedef struct VtLock 		VtLock;

typedef struct VtRendez		VtRendez;

typedef struct VtRoot		VtRoot;

typedef struct VtEntry		VtEntry;

typedef struct VtServerVtbl	VtServerVtbl;

#pragma incomplete VtSession

#pragma incomplete VtSha1

#pragma incomplete Packet

#pragma incomplete VtLock

#pragma incomplete VtRendez

enum {

	VtScoreSize	= 20, /* Venti */

	VtMaxLumpSize	= 56*1024,

	VtPointerDepth	= 7,	

	VtEntrySize	= 40,

	VtRootSize 	= 300,

	VtMaxStringSize	= 1000,

	VtAuthSize 	= 1024,  /* size of auth group - in bits - must be multiple of 8 */

	MaxFragSize 	= 9*1024,

	VtMaxFileSize	= (1ULL<<48) - 1,

	VtRootVersion	= 2,

};

/* crypto strengths */

enum {

	VtCryptoStrengthNone,

	VtCryptoStrengthAuth,

	VtCryptoStrengthWeak,

	VtCryptoStrengthStrong,

};

/* crypto suites */

enum {

	VtCryptoNone,

	VtCryptoSSL3,

	VtCryptoTLS1,

	VtCryptoMax

};

/* codecs */

enum {

	VtCodecNone,

	VtCodecDeflate,

	VtCodecThwack,

	VtCodecMax

};

/* Lump Types */

enum {

	VtErrType,		/* illegal */

	VtRootType,

	VtDirType,

	VtPointerType0,

	VtPointerType1,

	VtPointerType2,

	VtPointerType3,

	VtPointerType4,

	VtPointerType5,

	VtPointerType6,

	VtPointerType7,		/* not used */

	VtPointerType8,		/* not used */

	VtPointerType9,		/* not used */

	VtDataType,

	VtMaxType

};

/* Dir Entry flags */

enum {

	VtEntryActive = (1<<0),		/* entry is in use */

	VtEntryDir = (1<<1),		/* a directory */

	VtEntryDepthShift = 2,		/* shift for pointer depth */

	VtEntryDepthMask = (0x7<<2),	/* mask for pointer depth */

	VtEntryLocal = (1<<5),		/* used for local storage: should not be set for Venti blocks */

	VtEntryNoArchive = (1<<6),	/* used for local storage: should not be set for Venti blocks */

};

struct VtRoot {

	ushort version;

	char name[128];

	char type[128];

	uchar score[VtScoreSize];	/* to a Dir block */

	ushort blockSize;		/* maximum block size */

	uchar prev[VtScoreSize];	/* last root block */

};

struct VtEntry {

	ulong gen;			/* generation number */

	ushort psize;			/* pointer block size */

	ushort dsize;			/* data block size */

	uchar depth;			/* unpacked from flags */

	uchar flags;

	uvlong size;

	uchar score[VtScoreSize];

};

struct VtServerVtbl {

	Packet *(*read)(VtSession*, uchar score[VtScoreSize], int type, int n);

	int (*write)(VtSession*, uchar score[VtScoreSize], int type, Packet *p);

	void (*closing)(VtSession*, int clean);

	void (*sync)(VtSession*);

};

/* versions */

enum {

	/* experimental versions */

	VtVersion01 = 1,

	VtVersion02,

};

/* score of zero length block */

extern uchar vtZeroScore[VtScoreSize];	

/* both sides */

void vtAttach(void);

void vtDetach(void);

void vtClose(VtSession *s);

void vtFree(VtSession *s);

char *vtGetUid(VtSession *s);

char *vtGetSid(VtSession *s);

int vtSetDebug(VtSession *s, int);

int vtGetDebug(VtSession *s);

int vtSetFd(VtSession *s, int fd);

int vtGetFd(VtSession *s);

int vtConnect(VtSession *s, char *password);

int vtSetCryptoStrength(VtSession *s, int);

int vtGetCryptoStrength(VtSession *s);

int vtSetCompression(VtSession *s, int);

int vtGetCompression(VtSession *s);

int vtGetCrypto(VtSession *s);

int vtGetCodec(VtSession *s);

char *vtGetVersion(VtSession *s);

char *vtGetError(void);

int vtErrFmt(Fmt *fmt);

void vtDebug(VtSession*, char *, ...);

void vtDebugMesg(VtSession *z, Packet *p, char *s);

/* internal */

VtSession *vtAlloc(void);

void vtReset(VtSession*);

int vtAddString(Packet*, char*);

int vtGetString(Packet*, char**);

int vtSendPacket(VtSession*, Packet*);

Packet *vtRecvPacket(VtSession*);

void vtDisconnect(VtSession*, int);

int vtHello(VtSession*);

/* client side */

VtSession *vtClientAlloc(void);

VtSession *vtDial(char *server, int canfail);

int vtRedial(VtSession*, char *server);

VtSession *vtStdioServer(char *server);

int vtPing(VtSession *s);

int vtSetUid(VtSession*, char *uid);

int vtRead(VtSession*, uchar score[VtScoreSize], int type, uchar *buf, int n);

int vtWrite(VtSession*, uchar score[VtScoreSize], int type, uchar *buf, int n);

Packet *vtReadPacket(VtSession*, uchar score[VtScoreSize], int type, int n);

int vtWritePacket(VtSession*, uchar score[VtScoreSize], int type, Packet *p);

int vtSync(VtSession *s);

int vtZeroExtend(int type, uchar *buf, int n, int nn);

int vtZeroTruncate(int type, uchar *buf, int n);

int vtParseScore(char*, uint, uchar[VtScoreSize]);

void vtRootPack(VtRoot*, uchar*);

int vtRootUnpack(VtRoot*, uchar*);

void vtEntryPack(VtEntry*, uchar*, int index);

int vtEntryUnpack(VtEntry*, uchar*, int index);

/* server side */

VtSession *vtServerAlloc(VtServerVtbl*);

int vtSetSid(VtSession *s, char *sid);

int vtExport(VtSession *s);

/* sha1 */

VtSha1* vtSha1Alloc(void);

void vtSha1Free(VtSha1*);

void vtSha1Init(VtSha1*);

void vtSha1Update(VtSha1*, uchar *, int n);

void vtSha1Final(VtSha1*, uchar sha1[VtScoreSize]);

void vtSha1(uchar score[VtScoreSize], uchar *, int);

int vtSha1Check(uchar score[VtScoreSize], uchar *, int);

int vtScoreFmt(Fmt *fmt);

/* Packet */

Packet *packetAlloc(void);

void packetFree(Packet*);

Packet *packetForeign(uchar *buf, int n, void (*free)(void *a), void *a);

Packet *packetDup(Packet*, int offset, int n);

Packet *packetSplit(Packet*, int n);

int packetConsume(Packet*, uchar *buf, int n);

int packetTrim(Packet*, int offset, int n);

uchar *packetHeader(Packet*, int n);

uchar *packetTrailer(Packet*, int n);

int packetPrefix(Packet*, uchar *buf, int n);

int packetAppend(Packet*, uchar *buf, int n);

int packetConcat(Packet*, Packet*);

uchar *packetPeek(Packet*, uchar *buf, int offset, int n);

int packetCopy(Packet*, uchar *buf, int offset, int n);

int packetFragments(Packet*, IOchunk*, int nio, int offset);

int packetSize(Packet*);

int packetAllocatedSize(Packet*);

void packetSha1(Packet*, uchar sha1[VtScoreSize]);

int packetCompact(Packet*);

int packetCmp(Packet*, Packet*);

void packetStats(void);

/* portability stuff - should be a seperate library */

void vtMemFree(void *);

void *vtMemAlloc(int);

void *vtMemAllocZ(int);

void *vtMemRealloc(void *p, int);

void *vtMemBrk(int n);

char *vtStrDup(char *);

void vtFatal(char *, ...);

char *vtGetError(void);

char *vtSetError(char *, ...);

char *vtOSError(void);

/* locking/threads */

int vtThread(void (*f)(void*), void *rock);

void vtThreadSetName(char*);

VtLock *vtLockAlloc(void);

/* void vtLockInit(VtLock**); */

void vtLock(VtLock*);

int vtCanLock(VtLock*);

void vtRLock(VtLock*);

int vtCanRLock(VtLock*);

void vtUnlock(VtLock*);

void vtRUnlock(VtLock*);

void vtLockFree(VtLock*);

VtRendez *vtRendezAlloc(VtLock*);

void vtRendezFree(VtRendez*);

int vtSleep(VtRendez*);

int vtWakeup(VtRendez*);

int vtWakeupAll(VtRendez*);

/* fd functions - really network (socket) functions */

void vtFdClose(int);

int vtFdRead(int, uchar*, int);

int vtFdReadFully(int, uchar*, int);

int vtFdWrite(int, uchar*, int);

/*

 * formatting

 * other than noted, these formats all ignore

 * the width and precision arguments, and all flags

 *

 * V	a venti score

 * R	venti error

 */

#pragma	varargck	type	"V"		uchar*

#pragma	varargck	type	"R"		void

#pragma	varargck	argpos	vtSetError	1