[unix-history] / usr / src / cmd / uucp / pk0.c

#define USER	1
#include <stdio.h>
#include <sys/pk.p>
#include <sys/param.h>
#include <sys/pk.h>
#include <sys/buf.h>

/*
 * packet driver
 */

char next[8]	={ 1,2,3,4,5,6,7,0};	/* packet sequence numbers */
char mask[8]	={ 1,2,4,010,020,040,0100,0200 };

struct pack *pklines[NPLINES];


/*
 * receive control messages
 */
pkcntl(c, pk)
register struct pack *pk;
{
register cntl, val;

	val = c & MOD8;
	cntl = (c>>3) & MOD8;

	if ( ! ISCNTL(c) ) {
		fprintf(stderr, "not cntl\n");
		return;
	}

	if (pk->p_mode & 02)
		fprintf(stderr, "%o ",c);
	switch(cntl) {

	case INITB:
		val++;
		pk->p_xsize = pksizes[val];
		pk->p_lpsize = val;
		pk->p_bits = DTOM(pk->p_xsize);
		if (pk->p_state & LIVE) {
			pk->p_msg |= M_INITC;
			break;
		}
		pk->p_state |= INITb;
		if ((pk->p_state & INITa)==0) {
			break;
		}
		pk->p_rmsg &= ~M_INITA;
		pk->p_msg |= M_INITC;
		break;

	case INITC:
		if ((pk->p_state&INITab)==INITab) {
			pk->p_state = LIVE;
			WAKEUP(&pk->p_state);
			pk->p_rmsg &= ~M_INITB;
		} else
			pk->p_msg |= M_INITB;
		if (val)
			pk->p_swindow = val;
		break;
	case INITA:
		if (val==0 && pk->p_state&LIVE) {
			fprintf(stderr, "alloc change not implemented\n");
			break;
		}
		if (val) {
			pk->p_state |= INITa;
			pk->p_msg |= M_INITB;
			pk->p_rmsg |= M_INITB;
			pk->p_swindow = val;
		}
		break;
	case RJ:
		pk->p_state |= RXMIT;
		pk->p_msg |= M_RR;
	case RR:
		pk->p_rpr = val;
		if (pksack(pk)==0) {
			WAKEUP(&pk->p_ps);
		}
		break;
	case SRJ:
		fprintf(stderr, "srj not implemented\n");
		break;
	case CLOSE:
		pk->p_state = DOWN+RCLOSE;
		SIGNAL;
		WAKEUP(&pk->p_pr);
		WAKEUP(&pk->p_ps);
		WAKEUP(&pk->p_state);
		return;
	}
out:
	if (pk->p_msg)
		pkoutput(pk);
}


pkaccept(pk)
register struct pack *pk;
{
register x,seq;
char m, cntl, *p, imask, **bp;
int bad,accept,skip,s,t,h,cc;
unsigned short sum;

	bad = accept = skip = 0;
	/*
	 * wait for input
	 */
	LOCK;
	x = next[pk->p_pr];
	while ((imask=pk->p_imap) == 0 && pk->p_rcount==0) {
		PKGETPKT(pk);
		SLEEP(&pk->p_pr, PKIPRI);
	}
	pk->p_imap = 0;
	UNLOCK;


	/*
	 * determine input window in m.
	 */
	t = (~(-1<<pk->p_rwindow)) <<x;
	m = t;
	m |= t>>8;


	/*
	 * mark newly accepted input buffers
	 */
	for(x=0; x<8; x++) {

		if ((imask & mask[x]) == 0)
			continue;

		if (((cntl=pk->p_is[x])&0200)==0) {
			bad++;
free:
			bp = (char **)pk->p_ib[x];
			LOCK;
			*bp = (char *)pk->p_ipool;
			pk->p_ipool = bp;
			pk->p_is[x] = 0;
			UNLOCK;
			continue;
		}

		pk->p_is[x] = ~(B_COPY+B_MARK);
		sum = (unsigned)chksum(pk->p_ib[x], pk->p_rsize) ^ (unsigned)cntl;
		sum += pk->p_isum[x];
		if (sum == CHECK) {
			seq = (cntl>>3) & MOD8;
			if (m & mask[seq]) {
				if (pk->p_is[seq] & (B_COPY | B_MARK)) {
				dup:
					pk->p_msg |= M_RR;
					skip++;
					goto free;
				}
				if (x != seq) {
					LOCK;
					p = pk->p_ib[x];
					pk->p_ib[x] = pk->p_ib[seq];
					pk->p_is[x] = pk->p_is[seq];
					pk->p_ib[seq] = p;
					UNLOCK;
				}
				pk->p_is[seq] = B_MARK;
				accept++;
				cc = 0;
				if (cntl&B_SHORT) {
					pk->p_is[seq] = B_MARK+B_SHORT;
					p = pk->p_ib[seq];
					cc = (unsigned)*p++;
					if (cc & 0200) {
						cc &= 0177;
						cc |= *p << 7;
					}
				}
				pk->p_isum[seq] = pk->p_rsize - cc;
			} else {
				goto dup;
			}
		} else {
			bad++;
			goto free;
		}
	}

	/*
	 * scan window again turning marked buffers into
	 * COPY buffers and looking for missing sequence
	 * numbers.
	 */
	accept = 0;
	for(x=next[pk->p_pr],t=h= -1; m & mask[x]; x = next[x]) {
		if (pk->p_is[x] & B_MARK)
			pk->p_is[x] |= B_COPY;
	/*  hole code 
		if (pk->p_is[x] & B_COPY) {
			if (h<0 && t>=0)
				h = x;
		} else {
			if (t<0)
				t = x;
		}
	*/
		if (pk->p_is[x] & B_COPY) {
			if (t >= 0) {
				bp = (char **)pk->p_ib[x];
				LOCK;
				*bp = (char *)pk->p_ipool;
				pk->p_ipool = bp;
				pk->p_is[x] = 0;
				UNLOCK;
				skip++;
			} else 
				accept++;
		} else {
			if (t<0)
				t = x;
		}
	}

	if (bad) {
		pk->p_msg |= M_RJ;
	}

	if (skip) {
		pk->p_msg |= M_RR;
	}

	pk->p_rcount = accept;
	return(accept);
}


pkread(S)
SDEF;
{
register struct pack *pk;
register x,s;
int is,cc,xfr,count;
char *cp, **bp;

	pk = PADDR;
	xfr = 0;
	count = 0;
	while (pkaccept(pk)==0);


	while (UCOUNT) {

		x = next[pk->p_pr];
		is = pk->p_is[x];

		if (is & B_COPY) {
			cc = MIN(pk->p_isum[x], UCOUNT);
			if (cc==0 && xfr) {
				break;
			}
			if (is & B_RESID)
				cp = pk->p_rptr;
			else {
				cp = pk->p_ib[x];
				if (is & B_SHORT) {
					if (*cp++ & 0200)
						*cp++;
				}
			}
			IOMOVE(cp,cc,B_READ);
			count += cc;
			xfr++;
			pk->p_isum[x] -= cc;
			if (pk->p_isum[x] == 0) {
				pk->p_pr = x;
				bp = (char **)pk->p_ib[x];
				LOCK;
				*bp = (char *)pk->p_ipool;
				pk->p_ipool = bp;
				pk->p_is[x] = 0;
				pk->p_rcount--;
				UNLOCK;
				pk->p_msg |= M_RR;
			} else {
				pk->p_rptr = cp+cc;
				pk->p_is[x] |= B_RESID;
			}
			if (cc==0)
				break;
		} else
			break;
	}
	pkoutput(pk);
	return(count);
}


pkwrite(S)
SDEF;
{
register struct pack *pk;
register x;
int partial;
caddr_t cp;
int cc, s, fc, count;
int pktimeout();

	pk = PADDR;
	if (pk->p_state&DOWN || !pk->p_state&LIVE) {
		SETERROR;
		return(-1);
	}

	count = UCOUNT;
	do {
		LOCK;
		while (pk->p_xcount>=pk->p_swindow)  {
			pkoutput(pk);
			PKGETPKT(pk);
			SLEEP(&pk->p_ps,PKOPRI);
		}
		x = next[pk->p_pscopy];
		while (pk->p_os[x]!=B_NULL)  {
			PKGETPKT(pk);
			SLEEP(&pk->p_ps,PKOPRI);
		}
		pk->p_os[x] = B_MARK;
		pk->p_pscopy = x;
		pk->p_xcount++;
		UNLOCK;

		cp = pk->p_ob[x] = GETEPACK;
		partial = 0;
		if ((int)UCOUNT < pk->p_xsize) {
			cc = UCOUNT;
			fc = pk->p_xsize - cc;
			*cp = fc&0177;
			if (fc > 127) {
				*cp++ |= 0200;
				*cp++ = fc>>7;
			} else
				cp++;
			partial = B_SHORT;
		} else
			cc = pk->p_xsize;
		IOMOVE(cp,cc,B_WRITE);
		pk->p_osum[x] = chksum(pk->p_ob[x], pk->p_xsize);
		pk->p_os[x] = B_READY+partial;
		pkoutput(pk);
	} while (UCOUNT);

	return(count);
}

pksack(pk)
register struct pack *pk;
{
register x, i;

	i = 0;
	for(x=pk->p_ps; x!=pk->p_rpr; ) {
		x = next[x];
		if (pk->p_os[x]&B_SENT) {
			i++;
			pk->p_os[x] = B_NULL;
			pk->p_state &= ~WAITO;
			pk->p_xcount--;
			FREEPACK(pk->p_ob[x], pk->p_bits);
			pk->p_ps = x;
			WAKEUP(&pk->p_ps);
		}
	}
	return(i);
}


pkoutput(pk)
register struct pack *pk;
{
register x,rx;
int s;
char bstate;
int i;
SDEF;
int flag;

	flag = 0;
	ISYSTEM;
	LOCK;
	if (pk->p_obusy++ || OBUSY) {
		pk->p_obusy--;
		UNLOCK;
		return;
	}
	UNLOCK;


	/*
	 * find seq number and buffer state
	 * of next output packet
	 */
	if (pk->p_state&RXMIT)  {
		pk->p_nxtps = next[pk->p_rpr];
		flag++;
	}
	x = pk->p_nxtps;
	bstate = pk->p_os[x];


	/*
	 * Send control packet if indicated
	 */
	if (pk->p_msg) {
		if (pk->p_msg & ~M_RR || !(bstate&B_READY) ) {
			x = pk->p_msg;
			for(i=0; i<8; i++) 
				if (x&1)
					break; else
				x >>= 1;
			x = i;
			x <<= 3;
			switch(i) {
			case CLOSE:
				break;
			case RJ:
			case RR:
				x += pk->p_pr;
				break;
			case SRJ:
				break;
			case INITB:
				x += pksize(pk->p_rsize);
				break;
			case INITC:
				x += pk->p_rwindow;
				break;
			case INITA:
				x += pk->p_rwindow;
				break;
			}

			pk->p_msg &= ~mask[i];
			pkxstart(pk, x, -1);
			goto out;
		}
	}


	/*
	 * Don't send data packets if line is marked dead.
	 */
	if (pk->p_state&DOWN) {
		WAKEUP(&pk->p_ps);
		goto out;
	}
	/*
	 * Start transmission (or retransmission) of data packets.
	 */
	if (bstate & (B_READY|B_SENT)) {
		char seq;

		bstate |= B_SENT;
		seq = x;
		pk->p_nxtps = next[x];

		x = 0200+pk->p_pr+(seq<<3);
		if (bstate & B_SHORT)
			x |= 0100;
		pkxstart(pk, x, seq);
		pk->p_os[seq] = bstate;
		pk->p_state &= ~RXMIT;
		pk->p_nout++;
		goto out;
	}
	/*
	 * enable timeout if there's nothing to send
	 * and transmission buffers are languishing
	 */
	if (pk->p_xcount) {
		pk->p_timer = 2;
		pk->p_state |= WAITO;
	} else
		pk->p_state &= ~WAITO;
	WAKEUP(&pk->p_ps);
out:
	pk->p_obusy = 0;
}


/*
 * shut down line by
 *	ignoring new input
 *	letting output drain
 *	releasing space and turning off line discipline
 */
pkclose(S)
SDEF;
{
register struct pack *pk;
register i,s,rbits;
char **bp;
int rcheck;
char *p;


	pk = PADDR;
	pk->p_state |= DRAINO;


	/*
	 * try to flush output
	 */
	i = 0;
	LOCK;
	pk->p_timer = 2;
	while (pk->p_xcount && pk->p_state&LIVE) {
		if (pk->p_state&(RCLOSE+DOWN) || ++i > 2)
			break;
		pkoutput(pk);
		SLEEP(&pk->p_ps,PKOPRI);
	}
	pk->p_timer = 0;
	pk->p_state |= DOWN;
	UNLOCK;


	/*
	 * try to exchange CLOSE messages
	 */
	i = 0;
	while ((pk->p_state&RCLOSE)==0 && i<2) {
		pk->p_msg = M_CLOSE;
		pk->p_timer = 2;
		pkoutput(pk);
		SLEEP(&pk->p_ps, PKOPRI);
		i++;
	}


	for(i=0;i<NPLINES;i++)
		if (pklines[i]==pk)  {
			pklines[i] = NULL;
		}
	TURNOFF;


	/*
	 * free space
	 */
	rbits = DTOM(pk->p_rsize);
	rcheck = 0;
	for (i=0;i<8;i++) {
		if (pk->p_os[i]!=B_NULL) {
			FREEPACK(pk->p_ob[i],pk->p_bits);
			pk->p_xcount--;
		}
		if (pk->p_is[i]!=B_NULL)  {
			FREEPACK(pk->p_ib[i],rbits);
			rcheck++;
		}
	}
	LOCK;
	while (pk->p_ipool != NULL) {
		bp = pk->p_ipool;
		pk->p_ipool = (char **)*bp;
		rcheck++;
		FREEPACK(bp, rbits);
	}
	UNLOCK;
	if (rcheck  != pk->p_rwindow) {
		fprintf(stderr, "r short %d want %d\n",rcheck,pk->p_rwindow);
		fprintf(stderr, "rcount = %d\n",pk->p_rcount);
		fprintf(stderr, "xcount = %d\n",pk->p_xcount);
	}
	FREEPACK((caddr_t)pk, npbits);
}


pkreset(pk)
register struct pack *pk;
{

	pk->p_ps = pk->p_pr =  pk->p_rpr = 0;
	pk->p_nxtps = 1;
}

chksum(s,n)
register char *s;
register n;
{
	register short sum;
	register unsigned t;
	register x;

	sum = -1;
	x = 0;

	do {
		if (sum<0) {
			sum <<= 1;
			sum++;
		} else
			sum <<= 1;
		t = sum;
		sum += (unsigned)*s++;
		x += sum^n;
		if ((unsigned)sum <= t) {
			sum ^= x;
		}
	} while (--n > 0);

	return(sum);
}

pkline(pk)
register struct pack *pk;
{
register i;
	for(i=0;i<NPLINES;i++) {
		if (pklines[i]==pk)
			return(i);
	}
	return(-i);
}

pkzero(s,n)
register char *s;
register n;
{
	while (n--)
		*s++ = 0;
}

pksize(n)
register n;
{
register k;

	n >>= 5;
	for(k=0; n >>= 1; k++);
	return(k);
}
Commit	Line	Data
5ebb3437 GC	1	#define USER 1
	2	#include <stdio.h>
	3	#include <sys/pk.p>
	4	#include <sys/param.h>
	5	#include <sys/pk.h>
	6	#include <sys/buf.h>
	7
	8	/*
	9	* packet driver
	10	*/
	11
	12	char next[8] ={ 1,2,3,4,5,6,7,0}; /* packet sequence numbers */
	13	char mask[8] ={ 1,2,4,010,020,040,0100,0200 };
	14
	15	struct pack *pklines[NPLINES];
	16
	17
	18
	19	/*
	20	* receive control messages
	21	*/
	22	pkcntl(c, pk)
	23	register struct pack *pk;
	24	{
	25	register cntl, val;
	26
	27	val = c & MOD8;
	28	cntl = (c>>3) & MOD8;
	29
	30	if ( ! ISCNTL(c) ) {
	31	fprintf(stderr, "not cntl\n");
	32	return;
	33	}
	34
	35	if (pk->p_mode & 02)
	36	fprintf(stderr, "%o ",c);
	37	switch(cntl) {
	38
	39	case INITB:
	40	val++;
	41	pk->p_xsize = pksizes[val];
	42	pk->p_lpsize = val;
	43	pk->p_bits = DTOM(pk->p_xsize);
	44	if (pk->p_state & LIVE) {
	45	pk->p_msg \|= M_INITC;
	46	break;
	47	}
	48	pk->p_state \|= INITb;
	49	if ((pk->p_state & INITa)==0) {
	50	break;
	51	}
	52	pk->p_rmsg &= ~M_INITA;
	53	pk->p_msg \|= M_INITC;
	54	break;
	55
	56	case INITC:
	57	if ((pk->p_state&INITab)==INITab) {
	58	pk->p_state = LIVE;
	59	WAKEUP(&pk->p_state);
	60	pk->p_rmsg &= ~M_INITB;
	61	} else
	62	pk->p_msg \|= M_INITB;
	63	if (val)
	64	pk->p_swindow = val;
65	break;
66	case INITA:
67	if (val==0 && pk->p_state&LIVE) {
68	fprintf(stderr, "alloc change not implemented\n");
69	break;
70	}
71	if (val) {
72	pk->p_state \|= INITa;
73	pk->p_msg \|= M_INITB;
74	pk->p_rmsg \|= M_INITB;
75	pk->p_swindow = val;
76	}
77	break;
78	case RJ:
79	pk->p_state \|= RXMIT;
80	pk->p_msg \|= M_RR;
81	case RR:
82	pk->p_rpr = val;
83	if (pksack(pk)==0) {
84	WAKEUP(&pk->p_ps);
85	}
86	break;
87	case SRJ:
88	fprintf(stderr, "srj not implemented\n");
89	break;
90	case CLOSE:
91	pk->p_state = DOWN+RCLOSE;
92	SIGNAL;
93	WAKEUP(&pk->p_pr);
94	WAKEUP(&pk->p_ps);
95	WAKEUP(&pk->p_state);
96	return;
97	}
98	out:
99	if (pk->p_msg)
100	pkoutput(pk);
101	}
102
103
104
105	pkaccept(pk)
106	register struct pack *pk;
107	{
108	register x,seq;
109	char m, cntl, p, imask, *bp;
110	int bad,accept,skip,s,t,h,cc;
111	unsigned short sum;
112
113	bad = accept = skip = 0;
114	/*
115	* wait for input
116	*/
117	LOCK;
118	x = next[pk->p_pr];
119	while ((imask=pk->p_imap) == 0 && pk->p_rcount==0) {
120	PKGETPKT(pk);
121	SLEEP(&pk->p_pr, PKIPRI);
122	}
123	pk->p_imap = 0;
124	UNLOCK;
125
126
127	/*
128	* determine input window in m.
129	*/
130	t = (~(-1<<pk->p_rwindow)) <<x;
131	m = t;
132	m \|= t>>8;
133
134
135	/*
136	* mark newly accepted input buffers
137	*/
138	for(x=0; x<8; x++) {
139
140	if ((imask & mask[x]) == 0)
141	continue;
142
143	if (((cntl=pk->p_is[x])&0200)==0) {
144	bad++;
145	free:
146	bp = (char **)pk->p_ib[x];
147	LOCK;
148	bp = (char )pk->p_ipool;
149	pk->p_ipool = bp;
150	pk->p_is[x] = 0;
151	UNLOCK;
152	continue;
153	}
154
155	pk->p_is[x] = ~(B_COPY+B_MARK);
156	sum = (unsigned)chksum(pk->p_ib[x], pk->p_rsize) ^ (unsigned)cntl;
157	sum += pk->p_isum[x];
158	if (sum == CHECK) {
159	seq = (cntl>>3) & MOD8;
160	if (m & mask[seq]) {
161	if (pk->p_is[seq] & (B_COPY \| B_MARK)) {
162	dup:
163	pk->p_msg \|= M_RR;
164	skip++;
165	goto free;
166	}
167	if (x != seq) {
168	LOCK;
169	p = pk->p_ib[x];
170	pk->p_ib[x] = pk->p_ib[seq];
171	pk->p_is[x] = pk->p_is[seq];
172	pk->p_ib[seq] = p;
173	UNLOCK;
174	}
175	pk->p_is[seq] = B_MARK;
176	accept++;
177	cc = 0;
178	if (cntl&B_SHORT) {
179	pk->p_is[seq] = B_MARK+B_SHORT;
180	p = pk->p_ib[seq];
181	cc = (unsigned)*p++;
182	if (cc & 0200) {
183	cc &= 0177;
184	cc \|= *p << 7;
185	}
186	}
187	pk->p_isum[seq] = pk->p_rsize - cc;
188	} else {
189	goto dup;
190	}
191	} else {
192	bad++;
193	goto free;
194	}
195	}
196
197	/*
198	* scan window again turning marked buffers into
199	* COPY buffers and looking for missing sequence
200	* numbers.
201	*/
202	accept = 0;
203	for(x=next[pk->p_pr],t=h= -1; m & mask[x]; x = next[x]) {
204	if (pk->p_is[x] & B_MARK)
205	pk->p_is[x] \|= B_COPY;
206	/* hole code
207	if (pk->p_is[x] & B_COPY) {
208	if (h<0 && t>=0)
209	h = x;
210	} else {
211	if (t<0)
212	t = x;
213	}
214	*/
215	if (pk->p_is[x] & B_COPY) {
216	if (t >= 0) {
217	bp = (char **)pk->p_ib[x];
218	LOCK;
219	bp = (char )pk->p_ipool;
220	pk->p_ipool = bp;
221	pk->p_is[x] = 0;
222	UNLOCK;
223	skip++;
224	} else
225	accept++;
226	} else {
227	if (t<0)
228	t = x;
229	}
230	}
231
232	if (bad) {
233	pk->p_msg \|= M_RJ;
234	}
235
236	if (skip) {
237	pk->p_msg \|= M_RR;
238	}
239
240	pk->p_rcount = accept;
241	return(accept);
242	}
243
244
245	pkread(S)
246	SDEF;
247	{
248	register struct pack *pk;
249	register x,s;
250	int is,cc,xfr,count;
251	char cp, *bp;
252
253	pk = PADDR;
254	xfr = 0;
255	count = 0;
256	while (pkaccept(pk)==0);
257
258
259	while (UCOUNT) {
260
261	x = next[pk->p_pr];
262	is = pk->p_is[x];
263
264	if (is & B_COPY) {
265	cc = MIN(pk->p_isum[x], UCOUNT);
266	if (cc==0 && xfr) {
267	break;
268	}
269	if (is & B_RESID)
270	cp = pk->p_rptr;
271	else {
272	cp = pk->p_ib[x];
273	if (is & B_SHORT) {
274	if (*cp++ & 0200)
275	*cp++;
276	}
277	}
278	IOMOVE(cp,cc,B_READ);
279	count += cc;
280	xfr++;
281	pk->p_isum[x] -= cc;
282	if (pk->p_isum[x] == 0) {
283	pk->p_pr = x;
284	bp = (char **)pk->p_ib[x];
285	LOCK;
286	bp = (char )pk->p_ipool;
287	pk->p_ipool = bp;
288	pk->p_is[x] = 0;
289	pk->p_rcount--;
290	UNLOCK;
291	pk->p_msg \|= M_RR;
292	} else {
293	pk->p_rptr = cp+cc;
294	pk->p_is[x] \|= B_RESID;
295	}
296	if (cc==0)
297	break;
298	} else
299	break;
300	}
301	pkoutput(pk);
302	return(count);
303	}
304
305
306
307
308	pkwrite(S)
309	SDEF;
310	{
311	register struct pack *pk;
312	register x;
313	int partial;
314	caddr_t cp;
315	int cc, s, fc, count;
316	int pktimeout();
317
318	pk = PADDR;
319	if (pk->p_state&DOWN \|\| !pk->p_state&LIVE) {
320	SETERROR;
321	return(-1);
322	}
323
324	count = UCOUNT;
325	do {
326	LOCK;
327	while (pk->p_xcount>=pk->p_swindow) {
328	pkoutput(pk);
329	PKGETPKT(pk);
330	SLEEP(&pk->p_ps,PKOPRI);
331	}
332	x = next[pk->p_pscopy];
333	while (pk->p_os[x]!=B_NULL) {
334	PKGETPKT(pk);
335	SLEEP(&pk->p_ps,PKOPRI);
336	}
337	pk->p_os[x] = B_MARK;
338	pk->p_pscopy = x;
339	pk->p_xcount++;
340	UNLOCK;
341
342	cp = pk->p_ob[x] = GETEPACK;
343	partial = 0;
344	if ((int)UCOUNT < pk->p_xsize) {
345	cc = UCOUNT;
346	fc = pk->p_xsize - cc;
347	*cp = fc&0177;
348	if (fc > 127) {
349	*cp++ \|= 0200;
350	*cp++ = fc>>7;
351	} else
352	cp++;
353	partial = B_SHORT;
354	} else
355	cc = pk->p_xsize;
356	IOMOVE(cp,cc,B_WRITE);
357	pk->p_osum[x] = chksum(pk->p_ob[x], pk->p_xsize);
358	pk->p_os[x] = B_READY+partial;
359	pkoutput(pk);
360	} while (UCOUNT);
361
362	return(count);
363	}
364
365	pksack(pk)
366	register struct pack *pk;
367	{
368	register x, i;
369
370	i = 0;
371	for(x=pk->p_ps; x!=pk->p_rpr; ) {
372	x = next[x];
373	if (pk->p_os[x]&B_SENT) {
374	i++;
375	pk->p_os[x] = B_NULL;
376	pk->p_state &= ~WAITO;
377	pk->p_xcount--;
378	FREEPACK(pk->p_ob[x], pk->p_bits);
379	pk->p_ps = x;
380	WAKEUP(&pk->p_ps);
381	}
382	}
383	return(i);
384	}
385
386
387
388	pkoutput(pk)
389	register struct pack *pk;
390	{
391	register x,rx;
392	int s;
393	char bstate;
394	int i;
395	SDEF;
396	int flag;
397
398	flag = 0;
399	ISYSTEM;
400	LOCK;
401	if (pk->p_obusy++ \|\| OBUSY) {
402	pk->p_obusy--;
403	UNLOCK;
404	return;
405	}
406	UNLOCK;
407
408
409	/*
410	* find seq number and buffer state
411	* of next output packet
412	*/
413	if (pk->p_state&RXMIT) {
414	pk->p_nxtps = next[pk->p_rpr];
415	flag++;
416	}
417	x = pk->p_nxtps;
418	bstate = pk->p_os[x];
419
420
421	/*
422	* Send control packet if indicated
423	*/
424	if (pk->p_msg) {
425	if (pk->p_msg & ~M_RR \|\| !(bstate&B_READY) ) {
426	x = pk->p_msg;
427	for(i=0; i<8; i++)
428	if (x&1)
429	break; else
430	x >>= 1;
431	x = i;
432	x <<= 3;
433	switch(i) {
434	case CLOSE:
435	break;
436	case RJ:
437	case RR:
438	x += pk->p_pr;
439	break;
440	case SRJ:
441	break;
442	case INITB:
443	x += pksize(pk->p_rsize);
444	break;
445	case INITC:
446	x += pk->p_rwindow;
447	break;
448	case INITA:
449	x += pk->p_rwindow;
450	break;
451	}
452
453	pk->p_msg &= ~mask[i];
454	pkxstart(pk, x, -1);
455	goto out;
456	}
457	}
458
459
460	/*
461	* Don't send data packets if line is marked dead.
462	*/
463	if (pk->p_state&DOWN) {
464	WAKEUP(&pk->p_ps);
465	goto out;
466	}
467	/*
468	* Start transmission (or retransmission) of data packets.
469	*/
470	if (bstate & (B_READY\|B_SENT)) {
471	char seq;
472
473	bstate \|= B_SENT;
474	seq = x;
475	pk->p_nxtps = next[x];
476
477	x = 0200+pk->p_pr+(seq<<3);
478	if (bstate & B_SHORT)
479	x \|= 0100;
480	pkxstart(pk, x, seq);
481	pk->p_os[seq] = bstate;
482	pk->p_state &= ~RXMIT;
483	pk->p_nout++;
484	goto out;
485	}
486	/*
487	* enable timeout if there's nothing to send
488	* and transmission buffers are languishing
489	*/
490	if (pk->p_xcount) {
491	pk->p_timer = 2;
492	pk->p_state \|= WAITO;
493	} else
494	pk->p_state &= ~WAITO;
495	WAKEUP(&pk->p_ps);
496	out:
497	pk->p_obusy = 0;
498	}
499
500
501	/*
502	* shut down line by
503	* ignoring new input
504	* letting output drain
505	* releasing space and turning off line discipline
506	*/
507	pkclose(S)
508	SDEF;
509	{
510	register struct pack *pk;
511	register i,s,rbits;
512	char **bp;
513	int rcheck;
514	char *p;
515
516
517	pk = PADDR;
518	pk->p_state \|= DRAINO;
519
520
521	/*
522	* try to flush output
523	*/
524	i = 0;
525	LOCK;
526	pk->p_timer = 2;
527	while (pk->p_xcount && pk->p_state&LIVE) {
528	if (pk->p_state&(RCLOSE+DOWN) \|\| ++i > 2)
529	break;
530	pkoutput(pk);
531	SLEEP(&pk->p_ps,PKOPRI);
532	}
533	pk->p_timer = 0;
534	pk->p_state \|= DOWN;
535	UNLOCK;
536
537
538	/*
539	* try to exchange CLOSE messages
540	*/
541	i = 0;
542	while ((pk->p_state&RCLOSE)==0 && i<2) {
543	pk->p_msg = M_CLOSE;
544	pk->p_timer = 2;
545	pkoutput(pk);
546	SLEEP(&pk->p_ps, PKOPRI);
547	i++;
548	}
549
550
551	for(i=0;i<NPLINES;i++)
552	if (pklines[i]==pk) {
553	pklines[i] = NULL;
554	}
555	TURNOFF;
556
557
558	/*
559	* free space
560	*/
561	rbits = DTOM(pk->p_rsize);
562	rcheck = 0;
563	for (i=0;i<8;i++) {
564	if (pk->p_os[i]!=B_NULL) {
565	FREEPACK(pk->p_ob[i],pk->p_bits);
566	pk->p_xcount--;
567	}
568	if (pk->p_is[i]!=B_NULL) {
569	FREEPACK(pk->p_ib[i],rbits);
570	rcheck++;
571	}
572	}
573	LOCK;
574	while (pk->p_ipool != NULL) {
575	bp = pk->p_ipool;
576	pk->p_ipool = (char *)bp;
577	rcheck++;
578	FREEPACK(bp, rbits);
579	}
580	UNLOCK;
581	if (rcheck != pk->p_rwindow) {
582	fprintf(stderr, "r short %d want %d\n",rcheck,pk->p_rwindow);
583	fprintf(stderr, "rcount = %d\n",pk->p_rcount);
584	fprintf(stderr, "xcount = %d\n",pk->p_xcount);
585	}
586	FREEPACK((caddr_t)pk, npbits);
587	}
588
589
590
591	pkreset(pk)
592	register struct pack *pk;
593	{
594
595	pk->p_ps = pk->p_pr = pk->p_rpr = 0;
596	pk->p_nxtps = 1;
597	}
598
599	chksum(s,n)
600	register char *s;
601	register n;
602	{
603	register short sum;
604	register unsigned t;
605	register x;
606
607	sum = -1;
608	x = 0;
609
610	do {
611	if (sum<0) {
612	sum <<= 1;
613	sum++;
614	} else
615	sum <<= 1;
616	t = sum;
617	sum += (unsigned)*s++;
618	x += sum^n;
619	if ((unsigned)sum <= t) {
620	sum ^= x;
621	}
622	} while (--n > 0);
623
624	return(sum);
625	}
626
627	pkline(pk)
628	register struct pack *pk;
629	{
630	register i;
631	for(i=0;i<NPLINES;i++) {
632	if (pklines[i]==pk)
633	return(i);
634	}
635	return(-i);
636	}
637
638	pkzero(s,n)
639	register char *s;
640	register n;
641	{
642	while (n--)
643	*s++ = 0;
644	}
645
646	pksize(n)
647	register n;
648	{
649	register k;
650
651	n >>= 5;
652	for(k=0; n >>= 1; k++);
653	return(k);
654	}