plan 9 kernel history: overview | file list | diff list

1999/1016/port/devsdp.c (diff list | history)

1999/1015/sys/src/9/port/devsdp.c:65,701999/1016/sys/src/9/port/devsdp.c:65,71 (short | long | prev | next)
1999/0929    
	ulong	inMissing; 
	ulong	inDup; 
	ulong	inReorder; 
1999/1016    
	ulong	inBadComp; 
1999/0929    
	ulong	inBadAuth; 
	ulong	inBadSeq; 
}; 
1999/1015/sys/src/9/port/devsdp.c:94,1001999/1016/sys/src/9/port/devsdp.c:95,101
1999/0907    
	int		(*auth)(OneWay*, uchar *buf, int len); 
1999/0902    
 
	void	*compstate; 
1999/1015    
	int		(*comp)(OneWay*, int subtype, Block **); 
1999/1016    
	int		(*comp)(Conv*, int subtype, ulong seq, Block **); 
1999/0901    
}; 
 
1999/0907    
// conv states 
1999/1015/sys/src/9/port/devsdp.c:170,1751999/1016/sys/src/9/port/devsdp.c:171,181
1999/1015    
}; 
 
enum { 
1999/1016    
	ThwackU, 
	ThwackC, 
}; 
 
enum { 
1999/0909    
	ConOpenRequest, 
1999/0906    
	ConOpenAck, 
1999/0910    
	ConOpenAckAck, 
1999/1015/sys/src/9/port/devsdp.c:191,1961999/1016/sys/src/9/port/devsdp.c:197,203
1999/0929    
	uchar	inMissing[4]; 
	uchar	inDup[4]; 
	uchar	inReorder[4]; 
1999/1016    
	uchar	inBadComp[4]; 
1999/0929    
	uchar	inBadAuth[4]; 
	uchar	inBadSeq[4]; 
}; 
1999/1015/sys/src/9/port/devsdp.c:258,2641999/1016/sys/src/9/port/devsdp.c:265,271
1999/0907    
static Block *conviput(Conv *c, Block *b, int control); 
1999/1015    
static void conviconnect(Conv *c, int op, Block *b); 
static void convicontrol(Conv *c, int op, Block *b); 
static Block *convicomp(Conv *c, int op, Block *b); 
1999/1016    
static Block *convicomp(Conv *c, int op, ulong, Block *b); 
1999/0929    
static void writecontrol(Conv *c, void *p, int n, int wait); 
1999/0907    
static Block *readcontrol(Conv *c, int n); 
static Block *readdata(Conv *c, int n); 
1999/1015/sys/src/9/port/devsdp.c:748,7571999/1016/sys/src/9/port/devsdp.c:755,760
1999/0902    
	c->ref++; 
1999/0906    
	c->state = CInit; 
1999/1001    
	c->in.window = ~0; 
	c->in.compstate = malloc(sizeof(Unthwack)); 
	unthwackinit(c->in.compstate); 
	c->out.compstate = malloc(sizeof(Thwack)); 
	thwackinit(c->out.compstate); 
1999/0907    
	strncpy(c->owner, up->user, sizeof(c->owner)); 
1999/0901    
	c->perm = 0660; 
	qunlock(c); 
1999/1015/sys/src/9/port/devsdp.c:955,9721999/1016/sys/src/9/port/devsdp.c:958,966
1999/0910    
			free(c->channame); 
			c->channame = nil; 
		} 
1999/1001    
		if(c->ciphername) { 
			free(c->ciphername); 
			c->ciphername = nil; 
		} 
		if(c->authname) { 
			free(c->authname); 
			c->authname = nil; 
		} 
			if(c->compname) { 
			free(c->compname); 
			c->compname = nil; 
		} 
1999/1016    
		c->ciphername = nil; 
		c->authname = nil; 
		c->compname = nil; 
1999/1001    
	strcpy(c->owner, "network"); 
1999/0907    
		c->perm = 0660; 
		c->dialid = 0; 
1999/1015/sys/src/9/port/devsdp.c:1049,10541999/1016/sys/src/9/port/devsdp.c:1043,1049
1999/0929    
	p += snprint(p, ep-p, "inMissing: %ld\n", stats->inMissing); 
	p += snprint(p, ep-p, "inDup: %ld\n", stats->inDup); 
	p += snprint(p, ep-p, "inReorder: %ld\n", stats->inReorder); 
1999/1016    
	p += snprint(p, ep-p, "inBadComp: %ld\n", stats->inBadComp); 
1999/0929    
	p += snprint(p, ep-p, "inBadAuth: %ld\n", stats->inBadAuth); 
	p += snprint(p, ep-p, "inBadSeq: %ld\n", stats->inBadSeq); 
	USED(p); 
1999/1015/sys/src/9/port/devsdp.c:1079,10841999/1016/sys/src/9/port/devsdp.c:1074,1080
1999/0929    
	hnputl(ack->inMissing, s->inMissing); 
	hnputl(ack->inDup, s->inDup); 
	hnputl(ack->inReorder, s->inReorder); 
1999/1016    
	hnputl(ack->inBadComp, s->inBadComp); 
1999/0929    
	hnputl(ack->inBadAuth, s->inBadAuth); 
	hnputl(ack->inBadSeq, s->inBadSeq); 
1999/1015    
	convoput(c, TControl, ControlAck, b); 
1999/1015/sys/src/9/port/devsdp.c:1101,11071999/1016/sys/src/9/port/devsdp.c:1097,1103
1999/0907    
	} 
	 
1999/1015    
	type = b->rp[0] >> 4; 
	subtype = type & 0xf; 
1999/1016    
	subtype = b->rp[0] & 0xf; 
1999/1015    
	b->rp += 1; 
1999/0907    
	if(type == TConnect) { 
1999/1015    
		conviconnect(c, subtype, b); 
1999/1015/sys/src/9/port/devsdp.c:1186,11941999/1016/sys/src/9/port/devsdp.c:1182,1192
1999/1015    
	case TCompData: 
1999/1001    
		c->lstats.inDataPackets++; 
		c->lstats.inCompDataBytes += BLEN(b); 
1999/1015    
		b = convicomp(c, subtype, b); 
		if(b == nil); 
1999/1016    
		b = convicomp(c, subtype, seq, b); 
		if(b == nil) { 
			c->lstats.inBadComp++; 
1999/1015    
			return nil; 
1999/1016    
		} 
1999/1001    
		c->lstats.inDataBytes += BLEN(b); 
		if(control) 
			break; 
1999/1015/sys/src/9/port/devsdp.c:1362,13671999/1016/sys/src/9/port/devsdp.c:1360,1366
1999/1015    
		c->rstats.inMissing = nhgetl(ack->inMissing); 
		c->rstats.inDup = nhgetl(ack->inDup); 
		c->rstats.inReorder = nhgetl(ack->inReorder); 
1999/1016    
		c->rstats.inBadComp = nhgetl(ack->inBadComp); 
1999/1015    
		c->rstats.inBadAuth = nhgetl(ack->inBadAuth); 
		c->rstats.inBadSeq = nhgetl(ack->inBadSeq); 
		freeb(b); 
1999/1015/sys/src/9/port/devsdp.c:1374,13861999/1016/sys/src/9/port/devsdp.c:1373,1385
1999/1015    
} 
 
static Block* 
convicomp(Conv *c, int subtype, Block *b) 
1999/1016    
convicomp(Conv *c, int subtype, ulong seq, Block *b) 
1999/1015    
{ 
	if(c->in.comp == nil) { 
		freeb(b); 
		return nil; 
	} 
	if((*c->in.comp)(&c->in, subtype, &b) < 0) 
1999/1016    
	if(!(*c->in.comp)(c, subtype, seq, &b)) 
1999/1015    
		return nil; 
	return b; 
} 
1999/1015/sys/src/9/port/devsdp.c:1624,16291999/1016/sys/src/9/port/devsdp.c:1623,1630
1999/0915    
writedata(Conv *c, Block *b) 
{ 
1999/1015    
	int n; 
1999/1016    
	ulong seq; 
	int subtype; 
1999/0915    
 
	qlock(c); 
	if(waserror()) { 
1999/1015/sys/src/9/port/devsdp.c:1641,16471999/1016/sys/src/9/port/devsdp.c:1642,1651
1999/0930    
	c->lstats.outDataBytes += n; 
1999/1001    
 
1999/1015    
	if(c->out.comp != nil) { 
		int subtype = (*c->out.comp)(&c->out, 0, &b); 
1999/1016    
		// must generate same value as convoput 
		seq = (c->out.seq + 1) & (SeqMax-1); 
 
		subtype = (*c->out.comp)(c, 0, seq, &b); 
1999/1001    
		c->lstats.outCompDataBytes += BLEN(b); 
1999/1015    
		convoput(c, TCompData, subtype, b); 
	} else 
1999/1015/sys/src/9/port/devsdp.c:1751,17641999/1016/sys/src/9/port/devsdp.c:1755,1764
1999/1015    
	} 
} 
 
                 
static void 
cipherfree(Conv *c) 
{ 
	if(c->ciphername) { 
		free(c->ciphername); 
		c->ciphername = nil; 
	} 
1999/1016    
	c->ciphername = nil; 
1999/1015    
	if(c->in.cipherstate) { 
		free(c->in.cipherstate); 
		c->in.cipherstate = nil; 
1999/1015/sys/src/9/port/devsdp.c:1773,17821999/1016/sys/src/9/port/devsdp.c:1773,1779
1999/1015    
static void 
authfree(Conv *c) 
{ 
	if(c->authname) { 
		free(c->authname); 
		c->authname = nil; 
	} 
1999/1016    
	c->authname = nil; 
1999/1015    
	if(c->in.authstate) { 
		free(c->in.authstate); 
		c->in.authstate = nil; 
1999/1015/sys/src/9/port/devsdp.c:1791,18001999/1016/sys/src/9/port/devsdp.c:1788,1794
1999/1015    
static void 
compfree(Conv *c) 
{ 
	if(c->compname) { 
		free(c->compname); 
		c->compname = nil; 
	} 
1999/1016    
	c->compname = nil; 
1999/1015    
	if(c->in.compstate) { 
		free(c->in.compstate); 
		c->in.compstate = nil; 
1999/1015/sys/src/9/port/devsdp.c:1806,18121999/1016/sys/src/9/port/devsdp.c:1800,1805
1999/1015    
	c->in.comp = nil; 
} 
 
                 
static void 
nullcipherinit(Conv *c, char *, int) 
{ 
1999/1015/sys/src/9/port/devsdp.c:1863,18701999/1016/sys/src/9/port/devsdp.c:1856,1862
1999/1015    
	int i; 
 
	cipherfree(c); 
	c->ciphername = malloc(strlen(name)+1); 
	strcpy(c->ciphername, name); 
1999/1016    
	c->ciphername = name; 
1999/1015    
	 
	if(n > sizeof(key)) 
		n = sizeof(key); 
1999/1015/sys/src/9/port/devsdp.c:1894,18991999/1016/sys/src/9/port/devsdp.c:1886,1892
1999/1015    
static void 
rc4cipherinit(Conv *c, char *name, int keylen) 
{ 
1999/1016    
	cipherfree(c); 
1999/1015    
} 
 
static void 
1999/1015/sys/src/9/port/devsdp.c:1955,19621999/1016/sys/src/9/port/devsdp.c:1948,1954
1999/1015    
{ 
	authfree(c); 
 
	c->authname = malloc(strlen(name)+1); 
	strcpy(c->authname, name); 
1999/1016    
	c->authname = name; 
1999/1015    
 
	if(keylen > 16) 
		keylen = 16; 
1999/1015/sys/src/9/port/devsdp.c:1977,20401999/1016/sys/src/9/port/devsdp.c:1969,2054
1999/1015    
} 
 
static void 
nullcompinit(Conv *c, char *name, int keylen) 
1999/1016    
nullcompinit(Conv *c, char*, int) 
1999/1015    
{ 
1999/1016    
	compfree(c); 
1999/1015    
} 
 
static void 
thwackcompinit(Conv *c, char *name, int keylen) 
1999/1016    
static int 
thwackcomp(Conv *c, int, ulong seq, Block **bp) 
1999/1015    
{ 
1999/1016    
	Block *b, *bb; 
	int nn; 
 
	// add ack info 
	b = padblock(*bp, 4); 
	b->rp[0] = (c->in.window>>1) & 0xff; 
	b->rp[1] = c->in.seq>>16; 
	b->rp[2] = c->in.seq>>8; 
	b->rp[3] = c->in.seq; 
 
	bb = allocb(BLEN(b)); 
	nn = thwack(c->out.compstate, bb->wp, b->rp, BLEN(b), seq); 
	if(nn < 0) { 
		freeb(bb); 
		*bp = b; 
		return ThwackU; 
	} else { 
		bb->wp += nn; 
		freeb(b); 
		*bp = bb; 
		return ThwackC; 
	} 
1999/1015    
} 
 
1999/1016    
static int 
thwackuncomp(Conv *c, int subtype, ulong seq, Block **bp) 
{ 
	Block *b, *bb; 
	ulong mask; 
	ulong mseq; 
	int n; 
1999/1015    
 
#ifdef XXX 
	case TThwackU: 
1999/1016    
	switch(subtype) { 
	default: 
		return 0; 
	case ThwackU: 
		b = *bp; 
1999/1015    
		mask = b->rp[0]; 
		mseq = (b->rp[1]<<16) | (b->rp[2]<<8) | b->rp[3]; 
		b->rp += 4; 
		thwackack(c->out.compstate, mseq, mask); 
		c->lstats.inDataBytes += BLEN(b); 
		if(control) 
			break; 
		return b; 
	case TThwackC: 
		c->lstats.inDataPackets++; 
		c->lstats.inCompDataBytes += BLEN(b); 
		bb = b; 
1999/1016    
		return 1; 
	case ThwackC: 
		bb = *bp; 
1999/1015    
		b = allocb(ThwMaxBlock); 
		n = unthwack(c->in.compstate, b->wp, ThwMaxBlock, bb->rp, BLEN(bb), seq); 
		freeb(bb); 
		if(n < 0) 
			break; 
1999/1016    
		if(n < 0) { 
print("unthwack failed: %r!\n"); 
			freeb(b); 
			return 0; 
		} 
1999/1015    
		b->wp += n; 
		mask = b->rp[0]; 
		mseq = (b->rp[1]<<16) | (b->rp[2]<<8) | b->rp[3]; 
		thwackack(c->out.compstate, mseq, mask); 
		b->rp += 4; 
		c->lstats.inDataBytes += BLEN(b); 
		if(control) 
			break; 
		return b; 
1999/1016    
		*bp = b; 
		return 1; 
1999/1015    
	} 
	b = padblock(b, 4); 
	b->rp[0] = (c->in.window>>1) & 0xff; 
	b->rp[1] = c->in.seq>>16; 
	b->rp[2] = c->in.seq>>8; 
	b->rp[3] = c->in.seq; 
1999/1016    
} 
1999/1015    
 
	// must generate same value as convoput 
	seq = (c->out.seq + 1) & (SeqMax-1); 
1999/1016    
static void 
thwackcompinit(Conv *c, char *name, int keylen) 
{ 
	compfree(c); 
1999/1015    
 
	bb = allocb(BLEN(b)); 
	nn = thwack(c->out.compstate, bb->wp, b->rp, BLEN(b), seq); 
	if(nn < 0) { 
		c->lstats.outCompDataBytes += BLEN(b); 
		convoput(c, TThwackU, b); 
		freeb(bb); 
	} else { 
		c->lstats.outCompDataBytes += nn; 
		bb->wp += nn; 
		convoput(c, TThwackC, bb); 
		freeb(b); 
	} 
#endif 
1999/1016    
	c->compname = name; 
	c->in.compstate = malloc(sizeof(Unthwack)); 
	unthwackinit(c->in.compstate); 
	c->out.compstate = malloc(sizeof(Thwack)); 
	thwackinit(c->out.compstate); 
	c->in.comp = thwackuncomp; 
	c->out.comp = thwackcomp; 
} 


source code copyright © 1990-2005 Lucent Technologies; see license
Plan 9 distribution
comments to russ cox (rsc@swtch.com)