WebSVN – planix.SVN – Blame – /os/branches/planix-v0/sys/src/9/port/devsdp.c

Rev	Author	Line No.	Line
2	-	1	`#include "u.h"`
		2	`#include "../port/lib.h"`
		3	`#include "mem.h"`
		4	`#include "dat.h"`
		5	`#include "fns.h"`
		6	`#include "../port/netif.h"`
		7	`#include "../port/error.h"`
		8
		9	`#include <libsec.h>`
		10	`#include "../port/thwack.h"`
		11
		12	`/*`
		13	`* sdp - secure datagram protocol`
		14	`*/`
		15
		16	`typedef struct Sdp Sdp;`
		17	`typedef struct Conv Conv;`
		18	`typedef struct OneWay OneWay;`
		19	`typedef struct Stats Stats;`
		20	`typedef struct AckPkt AckPkt;`
		21	`typedef struct Algorithm Algorithm;`
		22	`typedef struct CipherRc4 CipherRc4;`
		23
		24	`enum`
		25	`{`
		26	`Qtopdir= 1, /* top level directory */`
		27
		28	`Qsdpdir, /* sdp directory */`
		29	`Qclone,`
		30	`Qlog,`
		31
		32	`Qconvdir, /* directory per conversation */`
		33	`Qctl,`
		34	`Qdata, /* unreliable packet channel */`
		35	`Qcontrol, /* reliable control channel */`
		36	`Qstatus,`
		37	`Qstats,`
		38	`Qrstats,`
		39
		40	`MaxQ,`
		41
		42	`Maxconv= 256, // power of 2`
		43	`Nfs= 4, // number of file systems`
		44	`MaxRetries= 12,`
		45	`KeepAlive = 300, // keep alive in seconds - should probably be about 60 but is higher to avoid linksys bug`
		46	`SecretLength= 32, // a secret per direction`
		47	`SeqMax = (1<<24),`
		48	`SeqWindow = 32,`
		49	`NCompStats = 8,`
		50	`};`
		51
		52	`#define TYPE(x) (((ulong)(x).path) & 0xff)`
		53	`#define CONV(x) ((((ulong)(x).path) >> 8)&(Maxconv-1))`
		54	`#define QID(x, y) (((x)<<8) \| (y))`
		55
		56	`struct Stats`
		57	`{`
		58	`ulong outPackets;`
		59	`ulong outDataPackets;`
		60	`ulong outDataBytes;`
		61	`ulong outCompDataBytes;`
		62	`ulong outCompBytes;`
		63	`ulong outCompStats[NCompStats];`
		64	`ulong inPackets;`
		65	`ulong inDataPackets;`
		66	`ulong inDataBytes;`
		67	`ulong inCompDataBytes;`
		68	`ulong inMissing;`
		69	`ulong inDup;`
		70	`ulong inReorder;`
		71	`ulong inBadComp;`
		72	`ulong inBadAuth;`
		73	`ulong inBadSeq;`
		74	`ulong inBadOther;`
		75	`};`
		76
		77	`struct OneWay`
		78	`{`
		79	`Rendez statsready;`
		80
		81	`ulong seqwrap; // number of wraps of the sequence number`
		82	`ulong seq;`
		83	`ulong window;`
		84
		85	`uchar secret[SecretLength];`
		86
		87	`QLock controllk;`
		88	`Rendez controlready;`
		89	`Block *controlpkt; // control channel`
		90	`ulong controlseq;`
		91
		92	`void *cipherstate; // state cipher`
		93	`int cipherivlen; // initial vector length`
		94	`int cipherblklen; // block length`
		95	`int (cipher)(OneWay, uchar *buf, int len);`
		96
		97	`void *authstate; // auth state`
		98	`int authlen; // auth data length in bytes`
		99	`int (auth)(OneWay, uchar *buf, int len);`
		100
		101	`void *compstate;`
		102	`int (comp)(Conv, int subtype, ulong seq, Block **);`
		103	`};`
		104
		105	`// conv states`
		106	`enum {`
		107	`CFree,`
		108	`CInit,`
		109	`CDial,`
		110	`CAccept,`
		111	`COpen,`
		112	`CLocalClose,`
		113	`CRemoteClose,`
		114	`CClosed,`
		115	`};`
		116
		117	`struct Conv {`
		118	`QLock;`
		119	`Sdp *sdp;`
		120	`int id;`
		121
		122	`int ref; // holds conv up`
		123
		124	`int state;`
		125
		126	`int dataopen; // ref count of opens on Qdata`
		127	`int controlopen; // ref count of opens on Qcontrol`
		128	`int reader; // reader proc has been started`
		129
		130	`Stats lstats;`
		131	`Stats rstats;`
		132
		133	`ulong lastrecv; // time last packet was received`
		134	`ulong timeout;`
		135	`int retries;`
		136
		137	`// the following pair uniquely define conversation on this port`
		138	`ulong dialid;`
		139	`ulong acceptid;`
		140
		141	`QLock readlk; // protects readproc`
		142	`Proc *readproc;`
		143
		144	`Chan *chan; // packet channel`
		145	`char *channame;`
		146
		147	`char owner[KNAMELEN]; /* protections */`
		148	`int perm;`
		149
		150	`Algorithm *auth;`
		151	`Algorithm *cipher;`
		152	`Algorithm *comp;`
		153
		154	`int drop;`
		155
		156	`OneWay in;`
		157	`OneWay out;`
		158	`};`
		159
		160	`struct Sdp {`
		161	`QLock;`
		162	`Log;`
		163	`int nconv;`
		164	`Conv *conv[Maxconv];`
		165	`int ackproc;`
		166	`};`
		167
		168	`enum {`
		169	`TConnect,`
		170	`TControl,`
		171	`TData,`
		172	`TCompData,`
		173	`};`
		174
		175	`enum {`
		176	`ControlMesg,`
		177	`ControlAck,`
		178	`};`
		179
		180	`enum {`
		181	`ThwackU,`
		182	`ThwackC,`
		183	`};`
		184
		185	`enum {`
		186	`ConOpenRequest,`
		187	`ConOpenAck,`
		188	`ConOpenAckAck,`
		189	`ConClose,`
		190	`ConCloseAck,`
		191	`ConReset,`
		192	`};`
		193
		194	`struct AckPkt`
		195	`{`
		196	`uchar cseq[4];`
		197	`uchar outPackets[4];`
		198	`uchar outDataPackets[4];`
		199	`uchar outDataBytes[4];`
		200	`uchar outCompDataBytes[4];`
		201	`uchar outCompStats[4*NCompStats];`
		202	`uchar inPackets[4];`
		203	`uchar inDataPackets[4];`
		204	`uchar inDataBytes[4];`
		205	`uchar inCompDataBytes[4];`
		206	`uchar inMissing[4];`
		207	`uchar inDup[4];`
		208	`uchar inReorder[4];`
		209	`uchar inBadComp[4];`
		210	`uchar inBadAuth[4];`
		211	`uchar inBadSeq[4];`
		212	`uchar inBadOther[4];`
		213	`};`
		214
		215	`struct Algorithm`
		216	`{`
		217	`char *name;`
		218	`int keylen; // in bytes`
		219	`void (init)(Conv);`
		220	`};`
		221
		222	`enum {`
		223	`RC4forward = 1010241024, // maximum skip forward`
		224	`RC4back = 100*1024, // maximum look back`
		225	`};`
		226
		227	`struct CipherRc4`
		228	`{`
		229	`ulong cseq; // current byte sequence number`
		230	`RC4state current;`
		231
		232	`int ovalid; // old is valid`
		233	`ulong lgseq; // last good sequence`
		234	`ulong oseq; // old byte sequence number`
		235	`RC4state old;`
		236	`};`
		237
		238	`static Dirtab sdpdirtab[]={`
		239	`"log", {Qlog}, 0, 0666,`
		240	`"clone", {Qclone}, 0, 0666,`
		241	`};`
		242
		243	`static Dirtab convdirtab[]={`
		244	`"ctl", {Qctl}, 0, 0666,`
		245	`"data", {Qdata}, 0, 0666,`
		246	`"control", {Qcontrol}, 0, 0666,`
		247	`"status", {Qstatus}, 0, 0444,`
		248	`"stats", {Qstats}, 0, 0444,`
		249	`"rstats", {Qrstats}, 0, 0444,`
		250	`};`
		251
		252	`static int m2p[] = {`
		253	`[OREAD] 4,`
		254	`[OWRITE] 2,`
		255	`[ORDWR] 6`
		256	`};`
		257
		258	`enum {`
		259	`Logcompress= (1<<0),`
		260	`Logauth= (1<<1),`
		261	`Loghmac= (1<<2),`
		262	`};`
		263
		264	`static Logflag logflags[] =`
		265	`{`
		266	`{ "compress", Logcompress, },`
		267	`{ "auth", Logauth, },`
		268	`{ "hmac", Loghmac, },`
		269	`{ nil, 0, },`
		270	`};`
		271
		272	`static Dirtab *dirtab[MaxQ];`
		273	`static Sdp sdptab[Nfs];`
		274	`static char *convstatename[] = {`
		275	`[CFree] "Free",`
		276	`[CInit] "Init",`
		277	`[CDial] "Dial",`
		278	`[CAccept] "Accept",`
		279	`[COpen] "Open",`
		280	`[CLocalClose] "LocalClose",`
		281	`[CRemoteClose] "RemoteClose",`
		282	`[CClosed] "Closed",`
		283	`};`
		284
		285	`static int sdpgen(Chan c, char, Dirtab, int, int s, Dir dp);`
		286	`static Conv sdpclone(Sdp sdp);`
		287	`static void sdpackproc(void *a);`
		288	`static void onewaycleanup(OneWay *ow);`
		289	`static int readready(void *a);`
		290	`static int controlread();`
		291	`static void convsetstate(Conv *c, int state);`
		292	`static Block readcontrol(Conv c, int n);`
		293	`static void writecontrol(Conv c, void p, int n, int wait);`
		294	`static Block readdata(Conv c, int n);`
		295	`static long writedata(Conv c, Block b);`
		296	`static void convderef(Conv *c);`
		297	`static Block conviput(Conv c, Block *b, int control);`
		298	`static void conviconnect(Conv c, int op, Block b);`
		299	`static void convicontrol(Conv c, int op, Block b);`
		300	`static Block convicomp(Conv c, int op, ulong, Block *b);`
		301	`static void convoput(Conv c, int type, int subtype, Block b);`
		302	`static void convoconnect(Conv *c, int op, ulong dialid, ulong acceptid);`
		303	`static void convopenchan(Conv c, char path);`
		304	`static void convstats(Conv c, int local, char buf, int n);`
		305	`static void convreader(void *a);`
		306
		307	`static void setalg(Conv c, char name, Algorithm tab, Algorithm *);`
		308	`static void setsecret(OneWay cc, char secret);`
		309
		310	`static void nullcipherinit(Conv*c);`
		311	`static void descipherinit(Conv*c);`
		312	`static void rc4cipherinit(Conv*c);`
		313	`static void nullauthinit(Conv*c);`
		314	`static void shaauthinit(Conv*c);`
		315	`static void md5authinit(Conv*c);`
		316	`static void nullcompinit(Conv*c);`
		317	`static void thwackcompinit(Conv*c);`
		318
		319	`static Algorithm cipheralg[] =`
		320	`{`
		321	`"null", 0, nullcipherinit,`
		322	`"des_56_cbc", 7, descipherinit,`
		323	`"rc4_128", 16, rc4cipherinit,`
		324	`"rc4_256", 32, rc4cipherinit,`
		325	`nil, 0, nil,`
		326	`};`
		327
		328	`static Algorithm authalg[] =`
		329	`{`
		330	`"null", 0, nullauthinit,`
		331	`"hmac_sha1_96", 16, shaauthinit,`
		332	`"hmac_md5_96", 16, md5authinit,`
		333	`nil, 0, nil,`
		334	`};`
		335
		336	`static Algorithm compalg[] =`
		337	`{`
		338	`"null", 0, nullcompinit,`
		339	`"thwack", 0, thwackcompinit,`
		340	`nil, 0, nil,`
		341	`};`
		342
		343
		344	`static void`
		345	`sdpinit(void)`
		346	`{`
		347	`int i;`
		348	`Dirtab *dt;`
		349
		350	`// setup dirtab with non directory entries`
		351	`for(i=0; i<nelem(sdpdirtab); i++) {`
		352	`dt = sdpdirtab + i;`
		353	`dirtab[TYPE(dt->qid)] = dt;`
		354	`}`
		355
		356	`for(i=0; i<nelem(convdirtab); i++) {`
		357	`dt = convdirtab + i;`
		358	`dirtab[TYPE(dt->qid)] = dt;`
		359	`}`
		360
		361	`}`
		362
		363	`static Chan*`
		364	`sdpattach(char* spec)`
		365	`{`
		366	`Chan *c;`
		367	`int dev;`
		368	`char buf[100];`
		369	`Sdp *sdp;`
		370	`int start;`
		371
		372	`dev = atoi(spec);`
		373	`if(dev<0 \|\| dev >= Nfs)`
		374	`error("bad specification");`
		375
		376	`c = devattach('E', spec);`
		377	`c->qid = (Qid){QID(0, Qtopdir), 0, QTDIR};`
		378	`c->dev = dev;`
		379
		380	`sdp = sdptab + dev;`
		381	`qlock(sdp);`
		382	`start = sdp->ackproc == 0;`
		383	`sdp->ackproc = 1;`
		384	`qunlock(sdp);`
		385
		386	`if(start) {`
		387	`snprint(buf, sizeof(buf), "sdpackproc%d", dev);`
		388	`kproc(buf, sdpackproc, sdp);`
		389	`}`
		390
		391	`return c;`
		392	`}`
		393
		394	`static Walkqid*`
		395	`sdpwalk(Chan c, Chan nc, char **name, int nname)`
		396	`{`
		397	`return devwalk(c, nc, name, nname, 0, 0, sdpgen);`
		398	`}`
		399
		400	`static int`
		401	`sdpstat(Chan* c, uchar* db, int n)`
		402	`{`
		403	`return devstat(c, db, n, nil, 0, sdpgen);`
		404	`}`
		405
		406	`static Chan*`
		407	`sdpopen(Chan* ch, int omode)`
		408	`{`
		409	`int perm;`
		410	`Sdp *sdp;`
		411	`Conv *c;`
		412
		413	`omode &= 3;`
		414	`perm = m2p[omode];`
		415	`USED(perm);`
		416
		417	`sdp = sdptab + ch->dev;`
		418
		419	`switch(TYPE(ch->qid)) {`
		420	`default:`
		421	`break;`
		422	`case Qtopdir:`
		423	`case Qsdpdir:`
		424	`case Qconvdir:`
		425	`if(omode != OREAD)`
		426	`error(Eperm);`
		427	`break;`
		428	`case Qlog:`
		429	`logopen(sdp);`
		430	`break;`
		431	`case Qclone:`
		432	`c = sdpclone(sdp);`
		433	`if(c == nil)`
		434	`error(Enodev);`
		435	`ch->qid.path = QID(c->id, Qctl);`
		436	`break;`
		437	`case Qdata:`
		438	`case Qctl:`
		439	`case Qstatus:`
		440	`case Qcontrol:`
		441	`case Qstats:`
		442	`case Qrstats:`
		443	`c = sdp->conv[CONV(ch->qid)];`
		444	`qlock(c);`
		445	`if(waserror()) {`
		446	`qunlock(c);`
		447	`nexterror();`
		448	`}`
		449	`if((perm & (c->perm>>6)) != perm)`
		450	`if(strcmp(up->user, c->owner) != 0 \|\| (perm & c->perm) != perm)`
		451	`error(Eperm);`
		452
		453	`c->ref++;`
		454	`if(TYPE(ch->qid) == Qdata) {`
		455	`c->dataopen++;`
		456	`// kill reader if Qdata is opened for the first time`
		457	`if(c->dataopen == 1)`
		458	`if(c->readproc != nil)`
		459	`postnote(c->readproc, 1, "interrupt", 0);`
		460	`} else if(TYPE(ch->qid) == Qcontrol) {`
		461	`c->controlopen++;`
		462	`}`
		463	`qunlock(c);`
		464	`poperror();`
		465	`break;`
		466	`}`
		467	`ch->mode = openmode(omode);`
		468	`ch->flag \|= COPEN;`
		469	`ch->offset = 0;`
		470	`return ch;`
		471	`}`
		472
		473	`static void`
		474	`sdpclose(Chan* ch)`
		475	`{`
		476	`Sdp *sdp = sdptab + ch->dev;`
		477	`Conv *c;`
		478
		479	`if(!(ch->flag & COPEN))`
		480	`return;`
		481	`switch(TYPE(ch->qid)) {`
		482	`case Qlog:`
		483	`logclose(sdp);`
		484	`break;`
		485	`case Qctl:`
		486	`case Qstatus:`
		487	`case Qstats:`
		488	`case Qrstats:`
		489	`c = sdp->conv[CONV(ch->qid)];`
		490	`qlock(c);`
		491	`convderef(c);`
		492	`qunlock(c);`
		493	`break;`
		494
		495	`case Qdata:`
		496	`c = sdp->conv[CONV(ch->qid)];`
		497	`qlock(c);`
		498	`c->dataopen--;`
		499	`convderef(c);`
		500	`if(c->dataopen == 0)`
		501	`if(c->reader == 0)`
		502	`if(c->chan != nil)`
		503	`if(!waserror()) {`
		504	`kproc("convreader", convreader, c);`
		505	`c->reader = 1;`
		506	`c->ref++;`
		507	`poperror();`
		508	`}`
		509	`qunlock(c);`
		510	`break;`
		511
		512	`case Qcontrol:`
		513	`c = sdp->conv[CONV(ch->qid)];`
		514	`qlock(c);`
		515	`c->controlopen--;`
		516	`convderef(c);`
		517	`if(c->controlopen == 0 && c->ref != 0) {`
		518	`switch(c->state) {`
		519	`default:`
		520	`convsetstate(c, CClosed);`
		521	`break;`
		522	`case CAccept:`
		523	`case COpen:`
		524	`convsetstate(c, CLocalClose);`
		525	`break;`
		526	`}`
		527	`}`
		528	`qunlock(c);`
		529	`break;`
		530	`}`
		531	`}`
		532
		533	`static long`
		534	`sdpread(Chan ch, void a, long n, vlong off)`
		535	`{`
		536	`char buf[256];`
		537	`char *s;`
		538	`Sdp *sdp = sdptab + ch->dev;`
		539	`Conv *c;`
		540	`Block *b;`
		541	`int rv;`
		542
		543	`USED(off);`
		544	`switch(TYPE(ch->qid)) {`
		545	`default:`
		546	`error(Eperm);`
		547	`case Qtopdir:`
		548	`case Qsdpdir:`
		549	`case Qconvdir:`
		550	`return devdirread(ch, a, n, 0, 0, sdpgen);`
		551	`case Qlog:`
		552	`return logread(sdp, a, off, n);`
		553	`case Qstatus:`
		554	`c = sdp->conv[CONV(ch->qid)];`
		555	`qlock(c);`
		556	`n = readstr(off, a, n, convstatename[c->state]);`
		557	`qunlock(c);`
		558	`return n;`
		559	`case Qctl:`
		560	`snprint(buf, sizeof buf, "%lud", CONV(ch->qid));`
		561	`return readstr(off, a, n, buf);`
		562	`case Qcontrol:`
		563	`b = readcontrol(sdp->conv[CONV(ch->qid)], n);`
		564	`if(b == nil)`
		565	`return 0;`
		566	`if(BLEN(b) < n)`
		567	`n = BLEN(b);`
		568	`memmove(a, b->rp, n);`
		569	`freeb(b);`
		570	`return n;`
		571	`case Qdata:`
		572	`b = readdata(sdp->conv[CONV(ch->qid)], n);`
		573	`if(b == nil)`
		574	`return 0;`
		575	`if(BLEN(b) < n)`
		576	`n = BLEN(b);`
		577	`memmove(a, b->rp, n);`
		578	`freeb(b);`
		579	`return n;`
		580	`case Qstats:`
		581	`case Qrstats:`
		582	`c = sdp->conv[CONV(ch->qid)];`
		583	`s = smalloc(1000);`
		584	`convstats(c, TYPE(ch->qid) == Qstats, s, 1000);`
		585	`rv = readstr(off, a, n, s);`
		586	`free(s);`
		587	`return rv;`
		588	`}`
		589	`}`
		590
		591	`static Block*`
		592	`sdpbread(Chan* ch, long n, ulong offset)`
		593	`{`
		594	`Sdp *sdp = sdptab + ch->dev;`
		595
		596	`if(TYPE(ch->qid) != Qdata)`
		597	`return devbread(ch, n, offset);`
		598	`return readdata(sdp->conv[CONV(ch->qid)], n);`
		599	`}`
		600
		601
		602	`static long`
		603	`sdpwrite(Chan ch, void a, long n, vlong off)`
		604	`{`
		605	`Sdp *sdp = sdptab + ch->dev;`
		606	`Cmdbuf *cb;`
		607	`char *arg0;`
		608	`char *p;`
		609	`Conv *c;`
		610	`Block *b;`
		611
		612	`USED(off);`
		613	`switch(TYPE(ch->qid)) {`
		614	`default:`
		615	`error(Eperm);`
		616	`case Qctl:`
		617	`c = sdp->conv[CONV(ch->qid)];`
		618	`cb = parsecmd(a, n);`
		619	`qlock(c);`
		620	`if(waserror()) {`
		621	`qunlock(c);`
		622	`free(cb);`
		623	`nexterror();`
		624	`}`
		625	`if(cb->nf == 0)`
		626	`error("short write");`
		627	`arg0 = cb->f[0];`
		628	`if(strcmp(arg0, "accept") == 0) {`
		629	`if(cb->nf != 2)`
		630	`error("usage: accept file");`
		631	`convopenchan(c, cb->f[1]);`
		632	`} else if(strcmp(arg0, "dial") == 0) {`
		633	`if(cb->nf != 2)`
		634	`error("usage: dial file");`
		635	`convopenchan(c, cb->f[1]);`
		636	`convsetstate(c, CDial);`
		637	`} else if(strcmp(arg0, "drop") == 0) {`
		638	`if(cb->nf != 2)`
		639	`error("usage: drop permil");`
		640	`c->drop = atoi(cb->f[1]);`
		641	`} else if(strcmp(arg0, "cipher") == 0) {`
		642	`if(cb->nf != 2)`
		643	`error("usage: cipher alg");`
		644	`setalg(c, cb->f[1], cipheralg, &c->cipher);`
		645	`} else if(strcmp(arg0, "auth") == 0) {`
		646	`if(cb->nf != 2)`
		647	`error("usage: auth alg");`
		648	`setalg(c, cb->f[1], authalg, &c->auth);`
		649	`} else if(strcmp(arg0, "comp") == 0) {`
		650	`if(cb->nf != 2)`
		651	`error("usage: comp alg");`
		652	`setalg(c, cb->f[1], compalg, &c->comp);`
		653	`} else if(strcmp(arg0, "insecret") == 0) {`
		654	`if(cb->nf != 2)`
		655	`error("usage: insecret secret");`
		656	`setsecret(&c->in, cb->f[1]);`
		657	`if(c->cipher)`
		658	`c->cipher->init(c);`
		659	`if(c->auth)`
		660	`c->auth->init(c);`
		661	`} else if(strcmp(arg0, "outsecret") == 0) {`
		662	`if(cb->nf != 2)`
		663	`error("usage: outsecret secret");`
		664	`setsecret(&c->out, cb->f[1]);`
		665	`if(c->cipher)`
		666	`c->cipher->init(c);`
		667	`if(c->auth)`
		668	`c->auth->init(c);`
		669	`} else`
		670	`error("unknown control request");`
		671	`poperror();`
		672	`qunlock(c);`
		673	`free(cb);`
		674	`return n;`
		675	`case Qlog:`
		676	`cb = parsecmd(a, n);`
		677	`p = logctl(sdp, cb->nf, cb->f, logflags);`
		678	`free(cb);`
		679	`if(p != nil)`
		680	`error(p);`
		681	`return n;`
		682	`case Qcontrol:`
		683	`writecontrol(sdp->conv[CONV(ch->qid)], a, n, 0);`
		684	`return n;`
		685	`case Qdata:`
		686	`b = allocb(n);`
		687	`memmove(b->wp, a, n);`
		688	`b->wp += n;`
		689	`return writedata(sdp->conv[CONV(ch->qid)], b);`
		690	`}`
		691	`}`
		692
		693	`long`
		694	`sdpbwrite(Chan ch, Block bp, ulong offset)`
		695	`{`
		696	`Sdp *sdp = sdptab + ch->dev;`
		697
		698	`if(TYPE(ch->qid) != Qdata)`
		699	`return devbwrite(ch, bp, offset);`
		700	`return writedata(sdp->conv[CONV(ch->qid)], bp);`
		701	`}`
		702
		703	`static int`
		704	`sdpgen(Chan c, char, Dirtab, int, int s, Dir dp)`
		705	`{`
		706	`Sdp *sdp = sdptab + c->dev;`
		707	`int type = TYPE(c->qid);`
		708	`Dirtab *dt;`
		709	`Qid qid;`
		710
		711	`if(s == DEVDOTDOT){`
		712	`switch(TYPE(c->qid)){`
		713	`case Qtopdir:`
		714	`case Qsdpdir:`
		715	`snprint(up->genbuf, sizeof(up->genbuf), "#E%ld", c->dev);`
		716	`mkqid(&qid, Qtopdir, 0, QTDIR);`
		717	`devdir(c, qid, up->genbuf, 0, eve, 0555, dp);`
		718	`break;`
		719	`case Qconvdir:`
		720	`snprint(up->genbuf, sizeof(up->genbuf), "%d", s);`
		721	`mkqid(&qid, Qsdpdir, 0, QTDIR);`
		722	`devdir(c, qid, up->genbuf, 0, eve, 0555, dp);`
		723	`break;`
		724	`default:`
		725	`panic("sdpwalk %llux", c->qid.path);`
		726	`}`
		727	`return 1;`
		728	`}`
		729
		730	`switch(type) {`
		731	`default:`
		732	`// non directory entries end up here`
		733	`if(c->qid.type & QTDIR)`
		734	`panic("sdpgen: unexpected directory");`
		735	`if(s != 0)`
		736	`return -1;`
		737	`dt = dirtab[TYPE(c->qid)];`
		738	`if(dt == nil)`
		739	`panic("sdpgen: unknown type: %lud", TYPE(c->qid));`
		740	`devdir(c, c->qid, dt->name, dt->length, eve, dt->perm, dp);`
		741	`return 1;`
		742	`case Qtopdir:`
		743	`if(s != 0)`
		744	`return -1;`
		745	`mkqid(&qid, QID(0, Qsdpdir), 0, QTDIR);`
		746	`devdir(c, qid, "sdp", 0, eve, 0555, dp);`
		747	`return 1;`
		748	`case Qsdpdir:`
		749	`if(s<nelem(sdpdirtab)) {`
		750	`dt = sdpdirtab+s;`
		751	`devdir(c, dt->qid, dt->name, dt->length, eve, dt->perm, dp);`
		752	`return 1;`
		753	`}`
		754	`s -= nelem(sdpdirtab);`
		755	`if(s >= sdp->nconv)`
		756	`return -1;`
		757	`mkqid(&qid, QID(s, Qconvdir), 0, QTDIR);`
		758	`snprint(up->genbuf, sizeof(up->genbuf), "%d", s);`
		759	`devdir(c, qid, up->genbuf, 0, eve, 0555, dp);`
		760	`return 1;`
		761	`case Qconvdir:`
		762	`if(s>=nelem(convdirtab))`
		763	`return -1;`
		764	`dt = convdirtab+s;`
		765	`mkqid(&qid, QID(CONV(c->qid),TYPE(dt->qid)), 0, QTFILE);`
		766	`devdir(c, qid, dt->name, dt->length, eve, dt->perm, dp);`
		767	`return 1;`
		768	`}`
		769	`}`
		770
		771	`static Conv*`
		772	`sdpclone(Sdp *sdp)`
		773	`{`
		774	`Conv c, pp, *ep;`
		775
		776	`c = nil;`
		777	`ep = sdp->conv + nelem(sdp->conv);`
		778	`qlock(sdp);`
		779	`if(waserror()) {`
		780	`qunlock(sdp);`
		781	`nexterror();`
		782	`}`
		783	`for(pp = sdp->conv; pp < ep; pp++) {`
		784	`c = *pp;`
		785	`if(c == nil){`
		786	`c = malloc(sizeof(Conv));`
		787	`if(c == nil)`
		788	`error(Enomem);`
		789	`memset(c, 0, sizeof(Conv));`
		790	`qlock(c);`
		791	`c->sdp = sdp;`
		792	`c->id = pp - sdp->conv;`
		793	`*pp = c;`
		794	`sdp->nconv++;`
		795	`break;`
		796	`}`
		797	`if(c->ref == 0 && canqlock(c)){`
		798	`if(c->ref == 0)`
		799	`break;`
		800	`qunlock(c);`
		801	`}`
		802	`}`
		803	`poperror();`
		804	`qunlock(sdp);`
		805
		806	`if(pp >= ep)`
		807	`return nil;`
		808
		809	`assert(c->state == CFree);`
		810	`// set ref to 2 - 1 ref for open - 1 ref for channel state`
		811	`c->ref = 2;`
		812	`c->state = CInit;`
		813	`c->in.window = ~0;`
		814	`strncpy(c->owner, up->user, sizeof(c->owner));`
		815	`c->perm = 0660;`
		816	`qunlock(c);`
		817
		818	`return c;`
		819	`}`
		820
		821	`// assume c is locked`
		822	`static void`
		823	`convretryinit(Conv *c)`
		824	`{`
		825	`c->retries = 0;`
		826	`// +2 to avoid rounding effects.`
		827	`c->timeout = TK2SEC(m->ticks) + 2;`
		828	`}`
		829
		830	`// assume c is locked`
		831	`static int`
		832	`convretry(Conv *c, int reset)`
		833	`{`
		834	`c->retries++;`
		835	`if(c->retries > MaxRetries) {`
		836	`if(reset)`
		837	`convoconnect(c, ConReset, c->dialid, c->acceptid);`
		838	`convsetstate(c, CClosed);`
		839	`return 0;`
		840	`}`
		841	`c->timeout = TK2SEC(m->ticks) + (c->retries+1);`
		842	`return 1;`
		843	`}`
		844
		845	`// assumes c is locked`
		846	`static void`
		847	`convtimer(Conv *c, ulong sec)`
		848	`{`
		849	`Block *b;`
		850
		851	`if(c->timeout > sec)`
		852	`return;`
		853
		854	`switch(c->state) {`
		855	`case CInit:`
		856	`break;`
		857	`case CDial:`
		858	`if(convretry(c, 1))`
		859	`convoconnect(c, ConOpenRequest, c->dialid, 0);`
		860	`break;`
		861	`case CAccept:`
		862	`if(convretry(c, 1))`
		863	`convoconnect(c, ConOpenAck, c->dialid, c->acceptid);`
		864	`break;`
		865	`case COpen:`
		866	`b = c->out.controlpkt;`
		867	`if(b != nil) {`
		868	`if(convretry(c, 1))`
		869	`convoput(c, TControl, ControlMesg, copyblock(b, blocklen(b)));`
		870	`break;`
		871	`}`
		872
		873	`c->timeout = c->lastrecv + KeepAlive;`
		874	`if(c->timeout > sec)`
		875	`break;`
		876	`// keepalive - randomly spaced between KeepAlive and 2*KeepAlive`
		877	`if(c->timeout + KeepAlive > sec && nrand(c->lastrecv + 2*KeepAlive - sec) > 0)`
		878	`break;`
		879	`// can not use writecontrol`
		880	`b = allocb(4);`
		881	`c->out.controlseq++;`
		882	`hnputl(b->wp, c->out.controlseq);`
		883	`b->wp += 4;`
		884	`c->out.controlpkt = b;`
		885	`convretryinit(c);`
		886	`if(!waserror()) {`
		887	`convoput(c, TControl, ControlMesg, copyblock(b, blocklen(b)));`
		888	`poperror();`
		889	`}`
		890	`break;`
		891	`case CLocalClose:`
		892	`if(convretry(c, 0))`
		893	`convoconnect(c, ConClose, c->dialid, c->acceptid);`
		894	`break;`
		895	`case CRemoteClose:`
		896	`case CClosed:`
		897	`break;`
		898	`}`
		899	`}`
		900
		901
		902	`static void`
		903	`sdpackproc(void *a)`
		904	`{`
		905	`Sdp *sdp = a;`
		906	`ulong sec;`
		907	`int i;`
		908	`Conv *c;`
		909
		910	`for(;;) {`
		911	`tsleep(&up->sleep, return0, 0, 1000);`
		912	`sec = TK2SEC(m->ticks);`
		913	`qlock(sdp);`
		914	`for(i=0; i<sdp->nconv; i++) {`
		915	`c = sdp->conv[i];`
		916	`if(c->ref == 0)`
		917	`continue;`
		918	`qunlock(sdp);`
		919	`qlock(c);`
		920	`if(c->ref > 0 && !waserror()) {`
		921	`convtimer(c, sec);`
		922	`poperror();`
		923	`}`
		924	`qunlock(c);`
		925	`qlock(sdp);`
		926	`}`
		927	`qunlock(sdp);`
		928	`}`
		929	`}`
		930
		931	`Dev sdpdevtab = {`
		932	`'E',`
		933	`"sdp",`
		934
		935	`devreset,`
		936	`sdpinit,`
		937	`devshutdown,`
		938	`sdpattach,`
		939	`sdpwalk,`
		940	`sdpstat,`
		941	`sdpopen,`
		942	`devcreate,`
		943	`sdpclose,`
		944	`sdpread,`
		945	`devbread,`
		946	`sdpwrite,`
		947	`devbwrite,`
		948	`devremove,`
		949	`devwstat,`
		950	`};`
		951
		952	`// assume hold lock on c`
		953	`static void`
		954	`convsetstate(Conv *c, int state)`
		955	`{`
		956
		957	`if(0)print("convsetstate %d: %s -> %s\n", c->id, convstatename[c->state], convstatename[state]);`
		958
		959	`switch(state) {`
		960	`default:`
		961	`panic("setstate: bad state: %d", state);`
		962	`case CDial:`
		963	`assert(c->state == CInit);`
		964	`c->dialid = (rand()<<16) + rand();`
		965	`convretryinit(c);`
		966	`convoconnect(c, ConOpenRequest, c->dialid, 0);`
		967	`break;`
		968	`case CAccept:`
		969	`assert(c->state == CInit);`
		970	`c->acceptid = (rand()<<16) + rand();`
		971	`convretryinit(c);`
		972	`convoconnect(c, ConOpenAck, c->dialid, c->acceptid);`
		973	`break;`
		974	`case COpen:`
		975	`assert(c->state == CDial \|\| c->state == CAccept);`
		976	`c->lastrecv = TK2SEC(m->ticks);`
		977	`if(c->state == CDial) {`
		978	`convretryinit(c);`
		979	`convoconnect(c, ConOpenAckAck, c->dialid, c->acceptid);`
		980	`hnputl(c->in.secret, c->acceptid);`
		981	`hnputl(c->in.secret+4, c->dialid);`
		982	`hnputl(c->out.secret, c->dialid);`
		983	`hnputl(c->out.secret+4, c->acceptid);`
		984	`} else {`
		985	`hnputl(c->in.secret, c->dialid);`
		986	`hnputl(c->in.secret+4, c->acceptid);`
		987	`hnputl(c->out.secret, c->acceptid);`
		988	`hnputl(c->out.secret+4, c->dialid);`
		989	`}`
		990	`setalg(c, "hmac_md5_96", authalg, &c->auth);`
		991	`break;`
		992	`case CLocalClose:`
		993	`assert(c->state == CAccept \|\| c->state == COpen);`
		994	`convretryinit(c);`
		995	`convoconnect(c, ConClose, c->dialid, c->acceptid);`
		996	`break;`
		997	`case CRemoteClose:`
		998	`wakeup(&c->in.controlready);`
		999	`wakeup(&c->out.controlready);`
		1000	`break;`
		1001	`case CClosed:`
		1002	`wakeup(&c->in.controlready);`
		1003	`wakeup(&c->out.controlready);`
		1004	`if(c->readproc)`
		1005	`postnote(c->readproc, 1, "interrupt", 0);`
		1006	`if(c->state != CClosed)`
		1007	`convderef(c);`
		1008	`break;`
		1009	`}`
		1010	`c->state = state;`
		1011	`}`
		1012
		1013
		1014	`//assumes c is locked`
		1015	`static void`
		1016	`convderef(Conv *c)`
		1017	`{`
		1018	`c->ref--;`
		1019	`if(c->ref > 0) {`
		1020	`return;`
		1021	`}`
		1022	`assert(c->ref == 0);`
		1023	`assert(c->dataopen == 0);`
		1024	`assert(c->controlopen == 0);`
		1025	`if(0)print("convderef: %d: ref == 0!\n", c->id);`
		1026	`c->state = CFree;`
		1027	`if(c->chan) {`
		1028	`cclose(c->chan);`
		1029	`c->chan = nil;`
		1030	`}`
		1031	`if(c->channame) {`
		1032	`free(c->channame);`
		1033	`c->channame = nil;`
		1034	`}`
		1035	`c->cipher = nil;`
		1036	`c->auth = nil;`
		1037	`c->comp = nil;`
		1038	`strcpy(c->owner, "network");`
		1039	`c->perm = 0660;`
		1040	`c->dialid = 0;`
		1041	`c->acceptid = 0;`
		1042	`c->timeout = 0;`
		1043	`c->retries = 0;`
		1044	`c->drop = 0;`
		1045	`onewaycleanup(&c->in);`
		1046	`onewaycleanup(&c->out);`
		1047	`memset(&c->lstats, 0, sizeof(Stats));`
		1048	`memset(&c->rstats, 0, sizeof(Stats));`
		1049	`}`
		1050
		1051	`static void`
		1052	`onewaycleanup(OneWay *ow)`
		1053	`{`
		1054	`if(ow->controlpkt)`
		1055	`freeb(ow->controlpkt);`
		1056	`if(ow->authstate)`
		1057	`free(ow->authstate);`
		1058	`if(ow->cipherstate)`
		1059	`free(ow->cipherstate);`
		1060	`if(ow->compstate)`
		1061	`free(ow->compstate);`
		1062	`memset(ow, 0, sizeof(OneWay));`
		1063	`}`
		1064
		1065
		1066	`// assumes conv is locked`
		1067	`static void`
		1068	`convopenchan(Conv c, char path)`
		1069	`{`
		1070	`if(c->state != CInit \|\| c->chan != nil)`
		1071	`error("already connected");`
		1072	`c->chan = namec(path, Aopen, ORDWR, 0);`
		1073	`c->channame = smalloc(strlen(path)+1);`
		1074	`strcpy(c->channame, path);`
		1075	`if(waserror()) {`
		1076	`cclose(c->chan);`
		1077	`c->chan = nil;`
		1078	`free(c->channame);`
		1079	`c->channame = nil;`
		1080	`nexterror();`
		1081	`}`
		1082	`kproc("convreader", convreader, c);`
		1083
		1084	`assert(c->reader == 0 && c->ref > 0);`
		1085	`// after kproc in case it fails`
		1086	`c->reader = 1;`
		1087	`c->ref++;`
		1088
		1089	`poperror();`
		1090	`}`
		1091
		1092	`static void`
		1093	`convstats(Conv c, int local, char buf, int n)`
		1094	`{`
		1095	`Stats *stats;`
		1096	`char p, ep;`
		1097	`int i;`
		1098
		1099	`if(local) {`
		1100	`stats = &c->lstats;`
		1101	`} else {`
		1102	`if(!waserror()) {`
		1103	`writecontrol(c, 0, 0, 1);`
		1104	`poperror();`
		1105	`}`
		1106	`stats = &c->rstats;`
		1107	`}`
		1108
		1109	`qlock(c);`
		1110	`p = buf;`
		1111	`ep = buf + n;`
		1112	`p += snprint(p, ep-p, "outPackets: %lud\n", stats->outPackets);`
		1113	`p += snprint(p, ep-p, "outDataPackets: %lud\n", stats->outDataPackets);`
		1114	`p += snprint(p, ep-p, "outDataBytes: %lud\n", stats->outDataBytes);`
		1115	`p += snprint(p, ep-p, "outCompDataBytes: %lud\n", stats->outCompDataBytes);`
		1116	`for(i=0; i<NCompStats; i++) {`
		1117	`if(stats->outCompStats[i] == 0)`
		1118	`continue;`
		1119	`p += snprint(p, ep-p, "outCompStats[%d]: %lud\n", i, stats->outCompStats[i]);`
		1120	`}`
		1121	`p += snprint(p, ep-p, "inPackets: %lud\n", stats->inPackets);`
		1122	`p += snprint(p, ep-p, "inDataPackets: %lud\n", stats->inDataPackets);`
		1123	`p += snprint(p, ep-p, "inDataBytes: %lud\n", stats->inDataBytes);`
		1124	`p += snprint(p, ep-p, "inCompDataBytes: %lud\n", stats->inCompDataBytes);`
		1125	`p += snprint(p, ep-p, "inMissing: %lud\n", stats->inMissing);`
		1126	`p += snprint(p, ep-p, "inDup: %lud\n", stats->inDup);`
		1127	`p += snprint(p, ep-p, "inReorder: %lud\n", stats->inReorder);`
		1128	`p += snprint(p, ep-p, "inBadComp: %lud\n", stats->inBadComp);`
		1129	`p += snprint(p, ep-p, "inBadAuth: %lud\n", stats->inBadAuth);`
		1130	`p += snprint(p, ep-p, "inBadSeq: %lud\n", stats->inBadSeq);`
		1131	`p += snprint(p, ep-p, "inBadOther: %lud\n", stats->inBadOther);`
		1132	`USED(p);`
		1133	`qunlock(c);`
		1134	`}`
		1135
		1136	`// c is locked`
		1137	`static void`
		1138	`convack(Conv *c)`
		1139	`{`
		1140	`Block *b;`
		1141	`AckPkt *ack;`
		1142	`Stats *s;`
		1143	`int i;`
		1144
		1145	`b = allocb(sizeof(AckPkt));`
		1146	`ack = (AckPkt*)b->wp;`
		1147	`b->wp += sizeof(AckPkt);`
		1148	`s = &c->lstats;`
		1149	`hnputl(ack->cseq, c->in.controlseq);`
		1150	`hnputl(ack->outPackets, s->outPackets);`
		1151	`hnputl(ack->outDataPackets, s->outDataPackets);`
		1152	`hnputl(ack->outDataBytes, s->outDataBytes);`
		1153	`hnputl(ack->outCompDataBytes, s->outCompDataBytes);`
		1154	`for(i=0; i<NCompStats; i++)`
		1155	`hnputl(ack->outCompStats+i*4, s->outCompStats[i]);`
		1156	`hnputl(ack->inPackets, s->inPackets);`
		1157	`hnputl(ack->inDataPackets, s->inDataPackets);`
		1158	`hnputl(ack->inDataBytes, s->inDataBytes);`
		1159	`hnputl(ack->inCompDataBytes, s->inCompDataBytes);`
		1160	`hnputl(ack->inMissing, s->inMissing);`
		1161	`hnputl(ack->inDup, s->inDup);`
		1162	`hnputl(ack->inReorder, s->inReorder);`
		1163	`hnputl(ack->inBadComp, s->inBadComp);`
		1164	`hnputl(ack->inBadAuth, s->inBadAuth);`
		1165	`hnputl(ack->inBadSeq, s->inBadSeq);`
		1166	`hnputl(ack->inBadOther, s->inBadOther);`
		1167	`convoput(c, TControl, ControlAck, b);`
		1168	`}`
		1169
		1170
		1171	`// assume we hold lock for c`
		1172	`static Block *`
		1173	`conviput(Conv c, Block b, int control)`
		1174	`{`
		1175	`int type, subtype;`
		1176	`ulong seq, seqwrap;`
		1177	`long seqdiff;`
		1178	`int pad;`
		1179
		1180	`c->lstats.inPackets++;`
		1181
		1182	`if(BLEN(b) < 4) {`
		1183	`c->lstats.inBadOther++;`
		1184	`freeb(b);`
		1185	`return nil;`
		1186	`}`
		1187
		1188	`type = b->rp[0] >> 4;`
		1189	`subtype = b->rp[0] & 0xf;`
		1190	`b->rp += 1;`
		1191	`if(type == TConnect) {`
		1192	`conviconnect(c, subtype, b);`
		1193	`return nil;`
		1194	`}`
		1195
		1196	`switch(c->state) {`
		1197	`case CInit:`
		1198	`case CDial:`
		1199	`c->lstats.inBadOther++;`
		1200	`convoconnect(c, ConReset, c->dialid, c->acceptid);`
		1201	`convsetstate(c, CClosed);`
		1202	`break;`
		1203	`case CAccept:`
		1204	`case CRemoteClose:`
		1205	`case CLocalClose:`
		1206	`c->lstats.inBadOther++;`
		1207	`freeb(b);`
		1208	`return nil;`
		1209	`}`
		1210
		1211	`seq = (b->rp[0]<<16) + (b->rp[1]<<8) + b->rp[2];`
		1212	`b->rp += 3;`
		1213
		1214	`seqwrap = c->in.seqwrap;`
		1215	`seqdiff = seq - c->in.seq;`
		1216	`if(seqdiff < -(SeqMax*3/4)) {`
		1217	`seqwrap++;`
		1218	`seqdiff += SeqMax;`
		1219	`} else if(seqdiff > SeqMax*3/4) {`
		1220	`seqwrap--;`
		1221	`seqdiff -= SeqMax;`
		1222	`}`
		1223
		1224	`if(seqdiff <= 0) {`
		1225	`if(seqdiff <= -SeqWindow) {`
		1226	`if(0)print("old sequence number: %ld (%ld %ld)\n", seq, c->in.seqwrap, seqdiff);`
		1227	`c->lstats.inBadSeq++;`
		1228	`freeb(b);`
		1229	`return nil;`
		1230	`}`
		1231
		1232	`if(c->in.window & (1<<-seqdiff)) {`
		1233	`if(0)print("dup sequence number: %ld (%ld %ld)\n", seq, c->in.seqwrap, seqdiff);`
		1234	`c->lstats.inDup++;`
		1235	`freeb(b);`
		1236	`return nil;`
		1237	`}`
		1238
		1239	`c->lstats.inReorder++;`
		1240	`}`
		1241
		1242	`// ok the sequence number looks ok`
		1243	`if(0) print("coniput seq=%ulx\n", seq);`
		1244	`if(c->in.auth != 0) {`
		1245	`if(!(*c->in.auth)(&c->in, b->rp-4, BLEN(b)+4)) {`
		1246	`if(0)print("bad auth %ld\n", BLEN(b)+4);`
		1247	`c->lstats.inBadAuth++;`
		1248	`freeb(b);`
		1249	`return nil;`
		1250	`}`
		1251	`b->wp -= c->in.authlen;`
		1252	`}`
		1253
		1254	`if(c->in.cipher != 0) {`
		1255	`if(!(*c->in.cipher)(&c->in, b->rp, BLEN(b))) {`
		1256	`if(0)print("bad cipher\n");`
		1257	`c->lstats.inBadOther++;`
		1258	`freeb(b);`
		1259	`return nil;`
		1260	`}`
		1261	`b->rp += c->in.cipherivlen;`
		1262	`if(c->in.cipherblklen > 1) {`
		1263	`pad = b->wp[-1];`
		1264	`if(pad > BLEN(b)) {`
		1265	`if(0)print("pad too big\n");`
		1266	`c->lstats.inBadOther++;`
		1267	`freeb(b);`
		1268	`return nil;`
		1269	`}`
		1270	`b->wp -= pad;`
		1271	`}`
		1272	`}`
		1273
		1274	`// ok the packet is good`
		1275	`if(seqdiff > 0) {`
		1276	`while(seqdiff > 0 && c->in.window != 0) {`
		1277	`if((c->in.window & (1<<(SeqWindow-1))) == 0) {`
		1278	`c->lstats.inMissing++;`
		1279	`}`
		1280	`c->in.window <<= 1;`
		1281	`seqdiff--;`
		1282	`}`
		1283	`if(seqdiff > 0) {`
		1284	`c->lstats.inMissing += seqdiff;`
		1285	`seqdiff = 0;`
		1286	`}`
		1287	`c->in.seq = seq;`
		1288	`c->in.seqwrap = seqwrap;`
		1289	`}`
		1290	`c->in.window \|= 1<<-seqdiff;`
		1291	`c->lastrecv = TK2SEC(m->ticks);`
		1292
		1293	`switch(type) {`
		1294	`case TControl:`
		1295	`convicontrol(c, subtype, b);`
		1296	`return nil;`
		1297	`case TData:`
		1298	`c->lstats.inDataPackets++;`
		1299	`c->lstats.inDataBytes += BLEN(b);`
		1300	`if(control)`
		1301	`break;`
		1302	`return b;`
		1303	`case TCompData:`
		1304	`c->lstats.inDataPackets++;`
		1305	`c->lstats.inCompDataBytes += BLEN(b);`
		1306	`b = convicomp(c, subtype, seq, b);`
		1307	`if(b == nil) {`
		1308	`c->lstats.inBadComp++;`
		1309	`return nil;`
		1310	`}`
		1311	`c->lstats.inDataBytes += BLEN(b);`
		1312	`if(control)`
		1313	`break;`
		1314	`return b;`
		1315	`}`
		1316	`if(0)print("dropping packet id=%d: type=%d n=%ld control=%d\n", c->id, type, BLEN(b), control);`
		1317	`c->lstats.inBadOther++;`
		1318	`freeb(b);`
		1319	`return nil;`
		1320	`}`
		1321
		1322	`// assume hold conv lock`
		1323	`static void`
		1324	`conviconnect(Conv c, int subtype, Block b)`
		1325	`{`
		1326	`ulong dialid;`
		1327	`ulong acceptid;`
		1328
		1329	`if(BLEN(b) != 8) {`
		1330	`freeb(b);`
		1331	`return;`
		1332	`}`
		1333	`dialid = nhgetl(b->rp);`
		1334	`acceptid = nhgetl(b->rp + 4);`
		1335	`freeb(b);`
		1336
		1337	`if(0)print("sdp: conviconnect: %s: %d %uld %uld\n", convstatename[c->state], subtype, dialid, acceptid);`
		1338
		1339	`if(subtype == ConReset) {`
		1340	`convsetstate(c, CClosed);`
		1341	`return;`
		1342	`}`
		1343
		1344	`switch(c->state) {`
		1345	`default:`
		1346	`panic("unknown state: %d", c->state);`
		1347	`case CInit:`
		1348	`break;`
		1349	`case CDial:`
		1350	`if(dialid != c->dialid)`
		1351	`goto Reset;`
		1352	`break;`
		1353	`case CAccept:`
		1354	`case COpen:`
		1355	`case CLocalClose:`
		1356	`case CRemoteClose:`
		1357	`if(dialid != c->dialid`
		1358	`\|\| subtype != ConOpenRequest && acceptid != c->acceptid)`
		1359	`goto Reset;`
		1360	`break;`
		1361	`case CClosed:`
		1362	`goto Reset;`
		1363	`}`
		1364
		1365	`switch(subtype) {`
		1366	`case ConOpenRequest:`
		1367	`switch(c->state) {`
		1368	`case CInit:`
		1369	`c->dialid = dialid;`
		1370	`convsetstate(c, CAccept);`
		1371	`return;`
		1372	`case CAccept:`
		1373	`case COpen:`
		1374	`// duplicate ConOpenRequest that we ignore`
		1375	`return;`
		1376	`}`
		1377	`break;`
		1378	`case ConOpenAck:`
		1379	`switch(c->state) {`
		1380	`case CDial:`
		1381	`c->acceptid = acceptid;`
		1382	`convsetstate(c, COpen);`
		1383	`return;`
		1384	`case COpen:`
		1385	`// duplicate that we have to ack`
		1386	`convoconnect(c, ConOpenAckAck, acceptid, dialid);`
		1387	`return;`
		1388	`}`
		1389	`break;`
		1390	`case ConOpenAckAck:`
		1391	`switch(c->state) {`
		1392	`case CAccept:`
		1393	`convsetstate(c, COpen);`
		1394	`return;`
		1395	`case COpen:`
		1396	`case CLocalClose:`
		1397	`case CRemoteClose:`
		1398	`// duplicate that we ignore`
		1399	`return;`
		1400	`}`
		1401	`break;`
		1402	`case ConClose:`
		1403	`switch(c->state) {`
		1404	`case COpen:`
		1405	`convoconnect(c, ConCloseAck, dialid, acceptid);`
		1406	`convsetstate(c, CRemoteClose);`
		1407	`return;`
		1408	`case CRemoteClose:`
		1409	`// duplicate ConClose`
		1410	`convoconnect(c, ConCloseAck, dialid, acceptid);`
		1411	`return;`
		1412	`}`
		1413	`break;`
		1414	`case ConCloseAck:`
		1415	`switch(c->state) {`
		1416	`case CLocalClose:`
		1417	`convsetstate(c, CClosed);`
		1418	`return;`
		1419	`}`
		1420	`break;`
		1421	`}`
		1422	`Reset:`
		1423	`// invalid connection message - reset to sender`
		1424	`if(1)print("sdp: invalid conviconnect - sending reset\n");`
		1425	`convoconnect(c, ConReset, dialid, acceptid);`
		1426	`convsetstate(c, CClosed);`
		1427	`}`
		1428
		1429	`static void`
		1430	`convicontrol(Conv c, int subtype, Block b)`
		1431	`{`
		1432	`ulong cseq;`
		1433	`AckPkt *ack;`
		1434	`int i;`
		1435
		1436	`if(BLEN(b) < 4)`
		1437	`return;`
		1438	`cseq = nhgetl(b->rp);`
		1439
		1440	`switch(subtype){`
		1441	`case ControlMesg:`
		1442	`if(cseq == c->in.controlseq) {`
		1443	`if(0)print("duplicate control packet: %ulx\n", cseq);`
		1444	`// duplicate control packet`
		1445	`freeb(b);`
		1446	`if(c->in.controlpkt == nil)`
		1447	`convack(c);`
		1448	`return;`
		1449	`}`
		1450
		1451	`if(cseq != c->in.controlseq+1)`
		1452	`return;`
		1453	`c->in.controlseq = cseq;`
		1454	`b->rp += 4;`
		1455	`if(BLEN(b) == 0) {`
		1456	`// just a ping`
		1457	`freeb(b);`
		1458	`convack(c);`
		1459	`} else {`
		1460	`c->in.controlpkt = b;`
		1461	`if(0) print("recv %ld size=%ld\n", cseq, BLEN(b));`
		1462	`wakeup(&c->in.controlready);`
		1463	`}`
		1464	`return;`
		1465	`case ControlAck:`
		1466	`if(cseq != c->out.controlseq)`
		1467	`return;`
		1468	`if(BLEN(b) < sizeof(AckPkt))`
		1469	`return;`
		1470	`ack = (AckPkt*)(b->rp);`
		1471	`c->rstats.outPackets = nhgetl(ack->outPackets);`
		1472	`c->rstats.outDataPackets = nhgetl(ack->outDataPackets);`
		1473	`c->rstats.outDataBytes = nhgetl(ack->outDataBytes);`
		1474	`c->rstats.outCompDataBytes = nhgetl(ack->outCompDataBytes);`
		1475	`for(i=0; i<NCompStats; i++)`
		1476	`c->rstats.outCompStats[i] = nhgetl(ack->outCompStats + 4*i);`
		1477	`c->rstats.inPackets = nhgetl(ack->inPackets);`
		1478	`c->rstats.inDataPackets = nhgetl(ack->inDataPackets);`
		1479	`c->rstats.inDataBytes = nhgetl(ack->inDataBytes);`
		1480	`c->rstats.inCompDataBytes = nhgetl(ack->inCompDataBytes);`
		1481	`c->rstats.inMissing = nhgetl(ack->inMissing);`
		1482	`c->rstats.inDup = nhgetl(ack->inDup);`
		1483	`c->rstats.inReorder = nhgetl(ack->inReorder);`
		1484	`c->rstats.inBadComp = nhgetl(ack->inBadComp);`
		1485	`c->rstats.inBadAuth = nhgetl(ack->inBadAuth);`
		1486	`c->rstats.inBadSeq = nhgetl(ack->inBadSeq);`
		1487	`c->rstats.inBadOther = nhgetl(ack->inBadOther);`
		1488	`freeb(b);`
		1489	`freeb(c->out.controlpkt);`
		1490	`c->out.controlpkt = nil;`
		1491	`c->timeout = c->lastrecv + KeepAlive;`
		1492	`wakeup(&c->out.controlready);`
		1493	`return;`
		1494	`}`
		1495	`}`
		1496
		1497	`static Block*`
		1498	`convicomp(Conv c, int subtype, ulong seq, Block b)`
		1499	`{`
		1500	`if(c->in.comp == nil) {`
		1501	`freeb(b);`
		1502	`return nil;`
		1503	`}`
		1504	`if(!(*c->in.comp)(c, subtype, seq, &b))`
		1505	`return nil;`
		1506	`return b;`
		1507	`}`
		1508
		1509	`// c is locked`
		1510	`static void`
		1511	`convwriteblock(Conv c, Block b)`
		1512	`{`
		1513	`// simulated errors`
		1514	`if(c->drop && nrand(c->drop) == 0)`
		1515	`return;`
		1516
		1517	`if(waserror()) {`
		1518	`convsetstate(c, CClosed);`
		1519	`nexterror();`
		1520	`}`
		1521	`devtab[c->chan->type]->bwrite(c->chan, b, 0);`
		1522	`poperror();`
		1523	`}`
		1524
		1525
		1526	`// assume hold conv lock`
		1527	`static void`
		1528	`convoput(Conv c, int type, int subtype, Block b)`
		1529	`{`
		1530	`int pad;`
		1531
		1532	`c->lstats.outPackets++;`
		1533	`/* Make room for sdp trailer */`
		1534	`if(c->out.cipherblklen > 1)`
		1535	`pad = c->out.cipherblklen - (BLEN(b) + c->out.cipherivlen) % c->out.cipherblklen;`
		1536	`else`
		1537	`pad = 0;`
		1538
		1539	`b = padblock(b, -(pad+c->out.authlen));`
		1540
		1541	`if(pad) {`
		1542	`memset(b->wp, 0, pad-1);`
		1543	`b->wp[pad-1] = pad;`
		1544	`b->wp += pad;`
		1545	`}`
		1546
		1547	`/* Make space to fit sdp header */`
		1548	`b = padblock(b, 4 + c->out.cipherivlen);`
		1549	`b->rp[0] = (type << 4) \| subtype;`
		1550	`c->out.seq++;`
		1551	`if(c->out.seq == (1<<24)) {`
		1552	`c->out.seq = 0;`
		1553	`c->out.seqwrap++;`
		1554	`}`
		1555	`b->rp[1] = c->out.seq>>16;`
		1556	`b->rp[2] = c->out.seq>>8;`
		1557	`b->rp[3] = c->out.seq;`
		1558
		1559	`if(c->out.cipher)`
		1560	`(*c->out.cipher)(&c->out, b->rp+4, BLEN(b)-4);`
		1561
		1562	`// auth`
		1563	`if(c->out.auth) {`
		1564	`b->wp += c->out.authlen;`
		1565	`(*c->out.auth)(&c->out, b->rp, BLEN(b));`
		1566	`}`
		1567
		1568	`convwriteblock(c, b);`
		1569	`}`
		1570
		1571	`// assume hold conv lock`
		1572	`static void`
		1573	`convoconnect(Conv *c, int op, ulong dialid, ulong acceptid)`
		1574	`{`
		1575	`Block *b;`
		1576
		1577	`c->lstats.outPackets++;`
		1578	`assert(c->chan != nil);`
		1579	`b = allocb(9);`
		1580	`b->wp[0] = (TConnect << 4) \| op;`
		1581	`hnputl(b->wp+1, dialid);`
		1582	`hnputl(b->wp+5, acceptid);`
		1583	`b->wp += 9;`
		1584
		1585	`if(!waserror()) {`
		1586	`convwriteblock(c, b);`
		1587	`poperror();`
		1588	`}`
		1589	`}`
		1590
		1591	`static Block *`
		1592	`convreadblock(Conv *c, int n)`
		1593	`{`
		1594	`Block *b;`
		1595	`Chan *ch;`
		1596
		1597	`qlock(&c->readlk);`
		1598	`if(waserror()) {`
		1599	`c->readproc = nil;`
		1600	`qunlock(&c->readlk);`
		1601	`nexterror();`
		1602	`}`
		1603	`qlock(c);`
		1604	`if(c->state == CClosed) {`
		1605	`qunlock(c);`
		1606	`error("closed");`
		1607	`}`
		1608	`c->readproc = up;`
		1609	`ch = c->chan;`
		1610	`assert(c->ref > 0);`
		1611	`qunlock(c);`
		1612
		1613	`b = devtab[ch->type]->bread(ch, n, 0);`
		1614	`c->readproc = nil;`
		1615	`poperror();`
		1616	`qunlock(&c->readlk);`
		1617
		1618	`return b;`
		1619	`}`
		1620
		1621	`static int`
		1622	`readready(void *a)`
		1623	`{`
		1624	`Conv *c = a;`
		1625
		1626	`return c->in.controlpkt != nil \|\| (c->state == CClosed) \|\| (c->state == CRemoteClose);`
		1627	`}`
		1628
		1629	`static Block *`
		1630	`readcontrol(Conv *c, int n)`
		1631	`{`
		1632	`Block *b;`
		1633
		1634	`USED(n);`
		1635
		1636	`qlock(&c->in.controllk);`
		1637	`if(waserror()) {`
		1638	`qunlock(&c->in.controllk);`
		1639	`nexterror();`
		1640	`}`
		1641	`qlock(c); // this lock is not held during the sleep below`
		1642
		1643	`for(;;) {`
		1644	`if(c->chan == nil \|\| c->state == CClosed) {`
		1645	`qunlock(c);`
		1646	`if(0)print("readcontrol: return error - state = %s\n", convstatename[c->state]);`
		1647	`error("conversation closed");`
		1648	`}`
		1649
		1650	`if(c->in.controlpkt != nil)`
		1651	`break;`
		1652
		1653	`if(c->state == CRemoteClose) {`
		1654	`qunlock(c);`
		1655	`if(0)print("readcontrol: return nil - state = %s\n", convstatename[c->state]);`
		1656	`poperror();`
		1657	`return nil;`
		1658	`}`
		1659	`qunlock(c);`
		1660	`sleep(&c->in.controlready, readready, c);`
		1661	`qlock(c);`
		1662	`}`
		1663
		1664	`convack(c);`
		1665
		1666	`b = c->in.controlpkt;`
		1667	`c->in.controlpkt = nil;`
		1668	`qunlock(c);`
		1669	`poperror();`
		1670	`qunlock(&c->in.controllk);`
		1671	`return b;`
		1672	`}`
		1673
		1674
		1675	`static int`
		1676	`writeready(void *a)`
		1677	`{`
		1678	`Conv *c = a;`
		1679
		1680	`return c->out.controlpkt == nil \|\| (c->state == CClosed) \|\| (c->state == CRemoteClose);`
		1681	`}`
		1682
		1683	`// c is locked`
		1684	`static void`
		1685	`writewait(Conv *c)`
		1686	`{`
		1687	`for(;;) {`
		1688	`if(c->state == CFree \|\| c->state == CInit \|\|`
		1689	`c->state == CClosed \|\| c->state == CRemoteClose)`
		1690	`error("conversation closed");`
		1691
		1692	`if(c->state == COpen && c->out.controlpkt == nil)`
		1693	`break;`
		1694
		1695	`qunlock(c);`
		1696	`if(waserror()) {`
		1697	`qlock(c);`
		1698	`nexterror();`
		1699	`}`
		1700	`sleep(&c->out.controlready, writeready, c);`
		1701	`poperror();`
		1702	`qlock(c);`
		1703	`}`
		1704	`}`
		1705
		1706	`static void`
		1707	`writecontrol(Conv c, void p, int n, int wait)`
		1708	`{`
		1709	`Block *b;`
		1710
		1711	`qlock(&c->out.controllk);`
		1712	`qlock(c);`
		1713	`if(waserror()) {`
		1714	`qunlock(c);`
		1715	`qunlock(&c->out.controllk);`
		1716	`nexterror();`
		1717	`}`
		1718	`writewait(c);`
		1719	`b = allocb(4+n);`
		1720	`c->out.controlseq++;`
		1721	`hnputl(b->wp, c->out.controlseq);`
		1722	`memmove(b->wp+4, p, n);`
		1723	`b->wp += 4+n;`
		1724	`c->out.controlpkt = b;`
		1725	`convretryinit(c);`
		1726	`convoput(c, TControl, ControlMesg, copyblock(b, blocklen(b)));`
		1727	`if(wait)`
		1728	`writewait(c);`
		1729	`poperror();`
		1730	`qunlock(c);`
		1731	`qunlock(&c->out.controllk);`
		1732	`}`
		1733
		1734	`static Block *`
		1735	`readdata(Conv *c, int n)`
		1736	`{`
		1737	`Block *b;`
		1738	`int nn;`
		1739
		1740	`for(;;) {`
		1741
		1742	`// some slack for tunneling overhead`
		1743	`nn = n + 100;`
		1744
		1745	`// make sure size is big enough for control messages`
		1746	`if(nn < 1000)`
		1747	`nn = 1000;`
		1748	`b = convreadblock(c, nn);`
		1749	`if(b == nil)`
		1750	`return nil;`
		1751	`qlock(c);`
		1752	`if(waserror()) {`
		1753	`qunlock(c);`
		1754	`return nil;`
		1755	`}`
		1756	`b = conviput(c, b, 0);`
		1757	`poperror();`
		1758	`qunlock(c);`
		1759	`if(b != nil) {`
		1760	`if(BLEN(b) > n)`
		1761	`b->wp = b->rp + n;`
		1762	`return b;`
		1763	`}`
		1764	`}`
		1765	`}`
		1766
		1767	`static long`
		1768	`writedata(Conv c, Block b)`
		1769	`{`
		1770	`int n;`
		1771	`ulong seq;`
		1772	`int subtype;`
		1773
		1774	`qlock(c);`
		1775	`if(waserror()) {`
		1776	`qunlock(c);`
		1777	`nexterror();`
		1778	`}`
		1779
		1780	`if(c->state != COpen) {`
		1781	`freeb(b);`
		1782	`error("conversation not open");`
		1783	`}`
		1784
		1785	`n = BLEN(b);`
		1786	`c->lstats.outDataPackets++;`
		1787	`c->lstats.outDataBytes += n;`
		1788
		1789	`if(c->out.comp != nil) {`
		1790	`// must generate same value as convoput`
		1791	`seq = (c->out.seq + 1) & (SeqMax-1);`
		1792
		1793	`subtype = (*c->out.comp)(c, 0, seq, &b);`
		1794	`c->lstats.outCompDataBytes += BLEN(b);`
		1795	`convoput(c, TCompData, subtype, b);`
		1796	`} else`
		1797	`convoput(c, TData, 0, b);`
		1798
		1799	`poperror();`
		1800	`qunlock(c);`
		1801	`return n;`
		1802	`}`
		1803
		1804	`static void`
		1805	`convreader(void *a)`
		1806	`{`
		1807	`Conv *c = a;`
		1808	`Block *b;`
		1809
		1810	`qlock(c);`
		1811	`assert(c->reader == 1);`
		1812	`while(c->dataopen == 0 && c->state != CClosed) {`
		1813	`qunlock(c);`
		1814	`b = nil;`
		1815	`if(!waserror()) {`
		1816	`b = convreadblock(c, 2000);`
		1817	`poperror();`
		1818	`}`
		1819	`qlock(c);`
		1820	`if(b == nil) {`
		1821	`if(strcmp(up->errstr, Eintr) != 0) {`
		1822	`convsetstate(c, CClosed);`
		1823	`break;`
		1824	`}`
		1825	`} else if(!waserror()) {`
		1826	`conviput(c, b, 1);`
		1827	`poperror();`
		1828	`}`
		1829	`}`
		1830	`c->reader = 0;`
		1831	`convderef(c);`
		1832	`qunlock(c);`
		1833	`pexit("hangup", 1);`
		1834	`}`
		1835
		1836
		1837	`/* ciphers, authenticators, and compressors */`
		1838
		1839	`static void`
		1840	`setalg(Conv c, char name, Algorithm alg, Algorithm *p)`
		1841	`{`
		1842	`for(; alg->name; alg++)`
		1843	`if(strcmp(name, alg->name) == 0)`
		1844	`break;`
		1845	`if(alg->name == nil)`
		1846	`error("unknown algorithm");`
		1847
		1848	`*p = alg;`
		1849	`alg->init(c);`
		1850	`}`
		1851
		1852	`static void`
		1853	`setsecret(OneWay ow, char secret)`
		1854	`{`
		1855	`char *p;`
		1856	`int i, c;`
		1857
		1858	`i = 0;`
		1859	`memset(ow->secret, 0, sizeof(ow->secret));`
		1860	`for(p=secret; *p; p++) {`
		1861	`if(i >= sizeof(ow->secret)*2)`
		1862	`break;`
		1863	`c = *p;`
		1864	`if(c >= '0' && c <= '9')`
		1865	`c -= '0';`
		1866	`else if(c >= 'a' && c <= 'f')`
		1867	`c -= 'a'-10;`
		1868	`else if(c >= 'A' && c <= 'F')`
		1869	`c -= 'A'-10;`
		1870	`else`
		1871	`error("bad character in secret");`
		1872	`if((i&1) == 0)`
		1873	`c <<= 4;`
		1874	`ow->secret[i>>1] \|= c;`
		1875	`i++;`
		1876	`}`
		1877	`}`
		1878
		1879	`static void`
		1880	`setkey(uchar key, int n, OneWay ow, char *prefix)`
		1881	`{`
		1882	`uchar ibuf[SHA1dlen], obuf[MD5dlen], salt[10];`
		1883	`int i, round = 0;`
		1884
		1885	`while(n > 0){`
		1886	`for(i=0; i<round+1; i++)`
		1887	`salt[i] = 'A'+round;`
		1888	`sha1((uchar*)prefix, strlen(prefix), ibuf, sha1(salt, round+1, nil, nil));`
		1889	`md5(ibuf, SHA1dlen, obuf, md5(ow->secret, sizeof(ow->secret), nil, nil));`
		1890	`i = (n<MD5dlen) ? n : MD5dlen;`
		1891	`memmove(key, obuf, i);`
		1892	`key += i;`
		1893	`n -= i;`
		1894	`if(++round > sizeof salt)`
		1895	`panic("setkey: you ask too much");`
		1896	`}`
		1897	`}`
		1898
		1899	`static void`
		1900	`cipherfree(Conv *c)`
		1901	`{`
		1902	`if(c->in.cipherstate) {`
		1903	`free(c->in.cipherstate);`
		1904	`c->in.cipherstate = nil;`
		1905	`}`
		1906	`if(c->out.cipherstate) {`
		1907	`free(c->out.cipherstate);`
		1908	`c->out.cipherstate = nil;`
		1909	`}`
		1910	`c->in.cipher = nil;`
		1911	`c->in.cipherblklen = 0;`
		1912	`c->out.cipherblklen = 0;`
		1913	`c->in.cipherivlen = 0;`
		1914	`c->out.cipherivlen = 0;`
		1915	`}`
		1916
		1917	`static void`
		1918	`authfree(Conv *c)`
		1919	`{`
		1920	`if(c->in.authstate) {`
		1921	`free(c->in.authstate);`
		1922	`c->in.authstate = nil;`
		1923	`}`
		1924	`if(c->out.authstate) {`
		1925	`free(c->out.authstate);`
		1926	`c->out.authstate = nil;`
		1927	`}`
		1928	`c->in.auth = nil;`
		1929	`c->in.authlen = 0;`
		1930	`c->out.authlen = 0;`
		1931	`}`
		1932
		1933	`static void`
		1934	`compfree(Conv *c)`
		1935	`{`
		1936	`if(c->in.compstate) {`
		1937	`free(c->in.compstate);`
		1938	`c->in.compstate = nil;`
		1939	`}`
		1940	`if(c->out.compstate) {`
		1941	`free(c->out.compstate);`
		1942	`c->out.compstate = nil;`
		1943	`}`
		1944	`c->in.comp = nil;`
		1945	`}`
		1946
		1947	`static void`
		1948	`nullcipherinit(Conv *c)`
		1949	`{`
		1950	`cipherfree(c);`
		1951	`}`
		1952
		1953	`static int`
		1954	`desencrypt(OneWay ow, uchar p, int n)`
		1955	`{`
		1956	`uchar pp, ip, eip, ep;`
		1957	`DESstate *ds = ow->cipherstate;`
		1958
		1959	`if(n < 8 \|\| (n & 0x7 != 0))`
		1960	`return 0;`
		1961	`ep = p + n;`
		1962	`memmove(p, ds->ivec, 8);`
		1963	`for(p += 8; p < ep; p += 8){`
		1964	`pp = p;`
		1965	`ip = ds->ivec;`
		1966	`for(eip = ip+8; ip < eip; )`
		1967	`pp++ ^= ip++;`
		1968	`block_cipher(ds->expanded, p, 0);`
		1969	`memmove(ds->ivec, p, 8);`
		1970	`}`
		1971	`return 1;`
		1972	`}`
		1973
		1974	`static int`
		1975	`desdecrypt(OneWay ow, uchar p, int n)`
		1976	`{`
		1977	`uchar tmp[8];`
		1978	`uchar tp, ip, eip, ep;`
		1979	`DESstate *ds = ow->cipherstate;`
		1980
		1981	`if(n < 8 \|\| (n & 0x7 != 0))`
		1982	`return 0;`
		1983	`ep = p + n;`
		1984	`memmove(ds->ivec, p, 8);`
		1985	`p += 8;`
		1986	`while(p < ep){`
		1987	`memmove(tmp, p, 8);`
		1988	`block_cipher(ds->expanded, p, 1);`
		1989	`tp = tmp;`
		1990	`ip = ds->ivec;`
		1991	`for(eip = ip+8; ip < eip; ){`
		1992	`p++ ^= ip;`
		1993	`ip++ = tp++;`
		1994	`}`
		1995	`}`
		1996	`return 1;`
		1997	`}`
		1998
		1999	`static void`
		2000	`descipherinit(Conv *c)`
		2001	`{`
		2002	`uchar key[8];`
		2003	`uchar ivec[8];`
		2004	`int i;`
		2005	`int n = c->cipher->keylen;`
		2006
		2007	`cipherfree(c);`
		2008
		2009	`if(n > sizeof(key))`
		2010	`n = sizeof(key);`
		2011
		2012	`/* in */`
		2013	`memset(key, 0, sizeof(key));`
		2014	`setkey(key, n, &c->in, "cipher");`
		2015	`memset(ivec, 0, sizeof(ivec));`
		2016	`c->in.cipherblklen = 8;`
		2017	`c->in.cipherivlen = 8;`
		2018	`c->in.cipher = desdecrypt;`
		2019	`c->in.cipherstate = smalloc(sizeof(DESstate));`
		2020	`setupDESstate(c->in.cipherstate, key, ivec);`
		2021
		2022	`/* out */`
		2023	`memset(key, 0, sizeof(key));`
		2024	`setkey(key, n, &c->out, "cipher");`
		2025	`for(i=0; i<8; i++)`
		2026	`ivec[i] = nrand(256);`
		2027	`c->out.cipherblklen = 8;`
		2028	`c->out.cipherivlen = 8;`
		2029	`c->out.cipher = desencrypt;`
		2030	`c->out.cipherstate = smalloc(sizeof(DESstate));`
		2031	`setupDESstate(c->out.cipherstate, key, ivec);`
		2032	`}`
		2033
		2034	`static int`
		2035	`rc4encrypt(OneWay ow, uchar p, int n)`
		2036	`{`
		2037	`CipherRc4 *cr = ow->cipherstate;`
		2038
		2039	`if(n < 4)`
		2040	`return 0;`
		2041
		2042	`hnputl(p, cr->cseq);`
		2043	`p += 4;`
		2044	`n -= 4;`
		2045	`rc4(&cr->current, p, n);`
		2046	`cr->cseq += n;`
		2047	`return 1;`
		2048	`}`
		2049
		2050	`static int`
		2051	`rc4decrypt(OneWay ow, uchar p, int n)`
		2052	`{`
		2053	`CipherRc4 *cr = ow->cipherstate;`
		2054	`RC4state tmpstate;`
		2055	`ulong seq;`
		2056	`long d, dd;`
		2057
		2058	`if(n < 4)`
		2059	`return 0;`
		2060
		2061	`seq = nhgetl(p);`
		2062	`p += 4;`
		2063	`n -= 4;`
		2064	`d = seq-cr->cseq;`
		2065	`if(d == 0) {`
		2066	`rc4(&cr->current, p, n);`
		2067	`cr->cseq += n;`
		2068	`if(cr->ovalid) {`
		2069	`dd = cr->cseq - cr->lgseq;`
		2070	`if(dd > RC4back)`
		2071	`cr->ovalid = 0;`
		2072	`}`
		2073	`} else if(d > 0) {`
		2074	`//print("missing packet: %uld %ld\n", seq, d);`
		2075	`// this link is hosed`
		2076	`if(d > RC4forward)`
		2077	`return 0;`
		2078	`cr->lgseq = seq;`
		2079	`if(!cr->ovalid) {`
		2080	`cr->ovalid = 1;`
		2081	`cr->oseq = cr->cseq;`
		2082	`memmove(&cr->old, &cr->current, sizeof(RC4state));`
		2083	`}`
		2084	`rc4skip(&cr->current, d);`
		2085	`rc4(&cr->current, p, n);`
		2086	`cr->cseq = seq+n;`
		2087	`} else {`
		2088	`//print("reordered packet: %uld %ld\n", seq, d);`
		2089	`dd = seq - cr->oseq;`
		2090	`if(!cr->ovalid \|\| -d > RC4back \|\| dd < 0)`
		2091	`return 0;`
		2092	`memmove(&tmpstate, &cr->old, sizeof(RC4state));`
		2093	`rc4skip(&tmpstate, dd);`
		2094	`rc4(&tmpstate, p, n);`
		2095	`return 1;`
		2096	`}`
		2097
		2098	`// move old state up`
		2099	`if(cr->ovalid) {`
		2100	`dd = cr->cseq - RC4back - cr->oseq;`
		2101	`if(dd > 0) {`
		2102	`rc4skip(&cr->old, dd);`
		2103	`cr->oseq += dd;`
		2104	`}`
		2105	`}`
		2106
		2107	`return 1;`
		2108	`}`
		2109
		2110	`static void`
		2111	`rc4cipherinit(Conv *c)`
		2112	`{`
		2113	`uchar key[32];`
		2114	`CipherRc4 *cr;`
		2115	`int n;`
		2116
		2117	`cipherfree(c);`
		2118
		2119	`n = c->cipher->keylen;`
		2120	`if(n > sizeof(key))`
		2121	`n = sizeof(key);`
		2122
		2123	`/* in */`
		2124	`memset(key, 0, sizeof(key));`
		2125	`setkey(key, n, &c->in, "cipher");`
		2126	`c->in.cipherblklen = 1;`
		2127	`c->in.cipherivlen = 4;`
		2128	`c->in.cipher = rc4decrypt;`
		2129	`cr = smalloc(sizeof(CipherRc4));`
		2130	`memset(cr, 0, sizeof(*cr));`
		2131	`setupRC4state(&cr->current, key, n);`
		2132	`c->in.cipherstate = cr;`
		2133
		2134	`/* out */`
		2135	`memset(key, 0, sizeof(key));`
		2136	`setkey(key, n, &c->out, "cipher");`
		2137	`c->out.cipherblklen = 1;`
		2138	`c->out.cipherivlen = 4;`
		2139	`c->out.cipher = rc4encrypt;`
		2140	`cr = smalloc(sizeof(CipherRc4));`
		2141	`memset(cr, 0, sizeof(*cr));`
		2142	`setupRC4state(&cr->current, key, n);`
		2143	`c->out.cipherstate = cr;`
		2144	`}`
		2145
		2146	`static void`
		2147	`nullauthinit(Conv *c)`
		2148	`{`
		2149	`authfree(c);`
		2150	`}`
		2151
		2152	`static void`
		2153	`shaauthinit(Conv *c)`
		2154	`{`
		2155	`authfree(c);`
		2156	`}`
		2157
		2158	`static void`
		2159	`seanq_hmac_md5(uchar hash[MD5dlen], ulong wrap, uchar t, long tlen, uchar key, long klen)`
		2160	`{`
		2161	`uchar ipad[65], opad[65], wbuf[4];`
		2162	`int i;`
		2163	`DigestState *digest;`
		2164	`uchar innerhash[MD5dlen];`
		2165
		2166	`for(i=0; i<64; i++){`
		2167	`ipad[i] = 0x36;`
		2168	`opad[i] = 0x5c;`
		2169	`}`
		2170	`ipad[64] = opad[64] = 0;`
		2171	`for(i=0; i<klen; i++){`
		2172	`ipad[i] ^= key[i];`
		2173	`opad[i] ^= key[i];`
		2174	`}`
		2175	`hnputl(wbuf, wrap);`
		2176	`digest = md5(ipad, 64, nil, nil);`
		2177	`digest = md5(wbuf, sizeof(wbuf), nil, digest);`
		2178	`md5(t, tlen, innerhash, digest);`
		2179	`digest = md5(opad, 64, nil, nil);`
		2180	`md5(innerhash, MD5dlen, hash, digest);`
		2181	`}`
		2182
		2183	`static int`
		2184	`md5auth(OneWay ow, uchar t, int tlen)`
		2185	`{`
		2186	`uchar hash[MD5dlen];`
		2187	`int r;`
		2188
		2189	`if(tlen < ow->authlen)`
		2190	`return 0;`
		2191	`tlen -= ow->authlen;`
		2192
		2193	`memset(hash, 0, MD5dlen);`
		2194	`seanq_hmac_md5(hash, ow->seqwrap, t, tlen, (uchar*)ow->authstate, 16);`
		2195	`r = memcmp(t+tlen, hash, ow->authlen) == 0;`
		2196	`memmove(t+tlen, hash, ow->authlen);`
		2197	`return r;`
		2198	`}`
		2199
		2200	`static void`
		2201	`md5authinit(Conv *c)`
		2202	`{`
		2203	`int keylen;`
		2204
		2205	`authfree(c);`
		2206
		2207	`keylen = c->auth->keylen;`
		2208	`if(keylen > 16)`
		2209	`keylen = 16;`
		2210
		2211	`/* in */`
		2212	`c->in.authstate = smalloc(16);`
		2213	`memset(c->in.authstate, 0, 16);`
		2214	`setkey(c->in.authstate, keylen, &c->in, "auth");`
		2215	`c->in.authlen = 12;`
		2216	`c->in.auth = md5auth;`
		2217
		2218	`/* out */`
		2219	`c->out.authstate = smalloc(16);`
		2220	`memset(c->out.authstate, 0, 16);`
		2221	`setkey(c->out.authstate, keylen, &c->out, "auth");`
		2222	`c->out.authlen = 12;`
		2223	`c->out.auth = md5auth;`
		2224	`}`
		2225
		2226	`static void`
		2227	`nullcompinit(Conv *c)`
		2228	`{`
		2229	`compfree(c);`
		2230	`}`
		2231
		2232	`static int`
		2233	`thwackcomp(Conv c, int, ulong seq, Block *bp)`
		2234	`{`
		2235	`Block b, bb;`
		2236	`int nn;`
		2237	`ulong ackseq;`
		2238	`uchar mask;`
		2239
		2240	`// add ack info`
		2241	`b = padblock(*bp, 4);`
		2242
		2243	`ackseq = unthwackstate(c->in.compstate, &mask);`
		2244	`b->rp[0] = mask;`
		2245	`b->rp[1] = ackseq>>16;`
		2246	`b->rp[2] = ackseq>>8;`
		2247	`b->rp[3] = ackseq;`
		2248
		2249	`bb = allocb(BLEN(b));`
		2250	`nn = thwack(c->out.compstate, bb->wp, b->rp, BLEN(b), seq, c->lstats.outCompStats);`
		2251	`if(nn < 0) {`
		2252	`freeb(bb);`
		2253	`*bp = b;`
		2254	`return ThwackU;`
		2255	`} else {`
		2256	`bb->wp += nn;`
		2257	`freeb(b);`
		2258	`*bp = bb;`
		2259	`return ThwackC;`
		2260	`}`
		2261	`}`
		2262
		2263	`static int`
		2264	`thwackuncomp(Conv c, int subtype, ulong seq, Block *bp)`
		2265	`{`
		2266	`Block b, bb;`
		2267	`ulong mask;`
		2268	`ulong mseq;`
		2269	`int n;`
		2270
		2271	`switch(subtype) {`
		2272	`default:`
		2273	`return 0;`
		2274	`case ThwackU:`
		2275	`b = *bp;`
		2276	`mask = b->rp[0];`
		2277	`mseq = (b->rp[1]<<16) \| (b->rp[2]<<8) \| b->rp[3];`
		2278	`b->rp += 4;`
		2279	`thwackack(c->out.compstate, mseq, mask);`
		2280	`return 1;`
		2281	`case ThwackC:`
		2282	`bb = *bp;`
		2283	`b = allocb(ThwMaxBlock);`
		2284	`n = unthwack(c->in.compstate, b->wp, ThwMaxBlock, bb->rp, BLEN(bb), seq);`
		2285	`freeb(bb);`
		2286	`*bp = nil;`
		2287	`if(n < 0) {`
		2288	`if(0)print("unthwack failed: %d\n", n);`
		2289	`freeb(b);`
		2290	`return 0;`
		2291	`}`
		2292	`b->wp += n;`
		2293	`mask = b->rp[0];`
		2294	`mseq = (b->rp[1]<<16) \| (b->rp[2]<<8) \| b->rp[3];`
		2295	`thwackack(c->out.compstate, mseq, mask);`
		2296	`b->rp += 4;`
		2297	`*bp = b;`
		2298	`return 1;`
		2299	`}`
		2300	`}`
		2301
		2302	`static void`
		2303	`thwackcompinit(Conv *c)`
		2304	`{`
		2305	`compfree(c);`
		2306
		2307	`c->in.compstate = malloc(sizeof(Unthwack));`
		2308	`if(c->in.compstate == nil)`
		2309	`error(Enomem);`
		2310	`unthwackinit(c->in.compstate);`
		2311	`c->out.compstate = malloc(sizeof(Thwack));`
		2312	`if(c->out.compstate == nil)`
		2313	`error(Enomem);`
		2314	`thwackinit(c->out.compstate);`
		2315	`c->in.comp = thwackuncomp;`
		2316	`c->out.comp = thwackcomp;`
		2317	`}`

Subversion Repositories planix.SVN

(root)/os/branches/planix-v0/sys/src/9/port/devsdp.c – Rev 9