![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to pk1.c CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [CSRG BSD Unix] / 42BSD / usr.bin / uucp|
Return to pk1.c CVS log | Up to [CSRG BSD Unix] / 42BSD / usr.bin / uucp |
1.1 root 1: #ifndef lint
2: static char sccsid[] = "@(#)pk1.c 5.1 (Berkeley) 7/2/83";
3: #endif
4:
5: extern char *malloc();
6:
7: #define USER 1
8: #include <stdio.h>
9: #ifdef SYSIII
10: #include <sys/types.h>
11: #endif
12: #include "pk.p"
13: #include <sys/param.h>
14: #include "pk.h"
15: #include <sys/buf.h>
16: #include <setjmp.h>
17: #include <signal.h>
18:
19:
20: #define PKMAXSTMSG 40
21: #define PKTIME 25
22: extern int Errorrate;
23: int Connodata = 0;
24: int Ntimeout = 0;
25: #define CONNODATA 10
26: #define NTIMEOUT 50
27: /*
28: * packet driver support routines
29: *
30: */
31:
32: struct pack *pklines[NPLINES];
33:
34: /*
35: * start initial synchronization.
36: */
37:
38: struct pack *
39: pkopen(ifn, ofn)
40: int ifn, ofn;
41: {
42: register struct pack *pk;
43: register char **bp;
44: register int i;
45:
46: if (++pkactive >= NPLINES)
47: return(NULL);
48: if ((pk = (struct pack *) malloc(sizeof (struct pack))) == NULL)
49: return(NULL);
50: pkzero((caddr_t) pk, sizeof (struct pack));
51: pk->p_ifn = ifn;
52: pk->p_ofn = ofn;
53: pk->p_xsize = pk->p_rsize = PACKSIZE;
54: pk->p_rwindow = pk->p_swindow = WINDOWS;
55: /* allocate input windows */
56: for (i = 0; i < pk->p_rwindow; i++) {
57: if ((bp = (char **) GETEPACK) == NULL)
58: break;
59: *bp = (char *) pk->p_ipool;
60: pk->p_ipool = bp;
61: }
62: if (i == 0)
63: return(NULL);
64: pk->p_rwindow = i;
65:
66: /* start synchronization */
67: pk->p_msg = pk->p_rmsg = M_INITA;
68: for (i = 0; i < NPLINES; i++) {
69: if (pklines[i] == NULL) {
70: pklines[i] = pk;
71: break;
72: }
73: }
74: if (i >= NPLINES)
75: return(NULL);
76: pkoutput(pk);
77:
78: for (i = 0; i < PKMAXSTMSG; i++) {
79: PKGETPKT(pk);
80: if ((pk->p_state & LIVE) != 0)
81: break;
82: }
83: if (i >= PKMAXSTMSG)
84: return(NULL);
85:
86: pkreset(pk);
87: return(pk);
88: }
89:
90:
91: /*
92: * input framing and block checking.
93: * frame layout for most devices is:
94: *
95: * S|K|X|Y|C|Z| ... data ... |
96: *
97: * where S == initial synch byte
98: * K == encoded frame size (indexes pksizes[])
99: * X, Y == block check bytes
100: * C == control byte
101: * Z == XOR of header (K^X^Y^C)
102: * data == 0 or more data bytes
103: *
104: */
105:
106: int pksizes[] = {
107: 1, 32, 64, 128, 256, 512, 1024, 2048, 4096, 1
108: };
109:
110: #define GETRIES 5
111: /*
112: * Pseudo-dma byte collection.
113: */
114:
115: pkgetpack(ipk)
116: struct pack *ipk;
117: {
118: int ret, k, tries;
119: register char *p;
120: register struct pack *pk;
121: register struct header *h;
122: unsigned short sum;
123: int ifn;
124: char **bp;
125: char hdchk;
126:
127: pk = PADDR;
128: if ((pk->p_state & DOWN) ||
129: Connodata > CONNODATA /* || Ntimeout > NTIMEOUT */)
130: pkfail();
131: ifn = pk->p_ifn;
132:
133: /* find HEADER */
134: for (tries = 0; tries < GETRIES; ) {
135: p = (caddr_t) &pk->p_ihbuf;
136: if ((ret = pkcget(ifn, p, 1)) < 0) {
137: /* set up retransmit or REJ */
138: tries++;
139: pk->p_msg |= pk->p_rmsg;
140: if (pk->p_msg == 0)
141: pk->p_msg |= M_RR;
142: if ((pk->p_state & LIVE) == LIVE)
143: pk->p_state |= RXMIT;
144: pkoutput(pk);
145: continue;
146: }
147: if (*p != SYN)
148: continue;
149: p++;
150: ret = pkcget(ifn, p, HDRSIZ - 1);
151: if (ret == -1)
152: continue;
153: break;
154: }
155: if (tries >= GETRIES) {
156: PKDEBUG(4, "tries = %d\n", tries);
157: pkfail();
158: }
159:
160: Connodata++;
161: h = (struct header * ) &pk->p_ihbuf;
162: p = (caddr_t) h;
163: hdchk = p[1] ^ p[2] ^ p[3] ^ p[4];
164: p += 2;
165: sum = (unsigned) *p++ & 0377;
166: sum |= (unsigned) *p << 8;
167: h->sum = sum;
168: PKDEBUG(7, "rec h->cntl %o\n", (unsigned) h->cntl);
169: k = h->ksize;
170: if (hdchk != h->ccntl) {
171: /* bad header */
172: PKDEBUG(7, "bad header %o,", hdchk);
173: PKDEBUG(7, "h->ccntl %o\n", h->ccntl);
174: return;
175: }
176: if (k == 9) {
177: if (((h->sum + h->cntl) & 0xffff) == CHECK) {
178: pkcntl(h->cntl, pk);
179: PKDEBUG(7, "state - %o\n", pk->p_state);
180: }
181: else {
182: /* bad header */
183: PKDEBUG(7, "bad header (k==9) %o\n", h->cntl);
184: pk->p_state |= BADFRAME;
185: }
186: return;
187: }
188: if (k && pksizes[k] == pk->p_rsize) {
189: pk->p_rpr = h->cntl & MOD8;
190: pksack(pk);
191: Connodata = 0;
192: bp = pk->p_ipool;
193: pk->p_ipool = (char **) *bp;
194: if (bp == NULL) {
195: PKDEBUG(7, "bp NULL %s\n", "");
196: return;
197: }
198: }
199: else {
200: return;
201: }
202: ret = pkcget(pk->p_ifn, (char *) bp, pk->p_rsize);
203: if (ret == 0)
204: pkdata(h->cntl, h->sum, pk, (char **) bp);
205: return;
206: }
207:
208:
209: pkdata(c, sum, pk, bp)
210: char c;
211: unsigned short sum;
212: register struct pack *pk;
213: char **bp;
214: {
215: register x;
216: int t;
217: char m;
218:
219: if (pk->p_state & DRAINO || !(pk->p_state & LIVE)) {
220: pk->p_msg |= pk->p_rmsg;
221: pkoutput(pk);
222: goto drop;
223: }
224: t = next[pk->p_pr];
225: for(x=pk->p_pr; x!=t; x = (x-1)&7) {
226: if (pk->p_is[x] == 0)
227: goto slot;
228: }
229: drop:
230: *bp = (char *)pk->p_ipool;
231: pk->p_ipool = bp;
232: return;
233:
234: slot:
235: m = mask[x];
236: pk->p_imap |= m;
237: pk->p_is[x] = c;
238: pk->p_isum[x] = sum;
239: pk->p_ib[x] = (char *)bp;
240: return;
241: }
242:
243:
244:
245: /*
246: * setup input transfers
247: */
248: pkrstart(pk)
249: {}
250:
251: #define PKMAXBUF 128
252: /*
253: * Start transmission on output device associated with pk.
254: * For asynch devices (t_line==1) framing is
255: * imposed. For devices with framing and crc
256: * in the driver (t_line==2) the transfer is
257: * passed on to the driver.
258: */
259: pkxstart(pk, cntl, x)
260: register struct pack *pk;
261: char cntl;
262: register x;
263: {
264: register char *p;
265: int ret;
266: short checkword;
267: char hdchk;
268:
269: p = (caddr_t) &pk->p_ohbuf;
270: *p++ = SYN;
271: if (x < 0) {
272: *p++ = hdchk = 9;
273: checkword = cntl;
274: }
275: else {
276: *p++ = hdchk = pk->p_lpsize;
277: checkword = pk->p_osum[x] ^ (unsigned)(cntl & 0377);
278: }
279: checkword = CHECK - checkword;
280: *p = checkword;
281: hdchk ^= *p++;
282: *p = checkword>>8;
283: hdchk ^= *p++;
284: *p = cntl;
285: hdchk ^= *p++;
286: *p = hdchk;
287: /* writes */
288: PKDEBUG(7, "send %o\n", (unsigned) cntl);
289: p = (caddr_t) & pk->p_ohbuf;
290: if (x < 0) {
291: #ifdef PROTODEBUG
292: GENERROR(p, HDRSIZ);
293: #endif
294: ret = write(pk->p_ofn, p, HDRSIZ);
295: PKASSERT(ret == HDRSIZ, "PKXSTART ret", "", ret);
296: }
297: else {
298: char buf[PKMAXBUF + HDRSIZ], *b;
299: int i;
300: for (i = 0, b = buf; i < HDRSIZ; i++)
301: *b++ = *p++;
302: for (i = 0, p = pk->p_ob[x]; i < pk->p_xsize; i++)
303: *b++ = *p++;
304: #ifdef PROTODEBUG
305: GENERROR(buf, pk->p_xsize + HDRSIZ);
306: #endif
307: ret = write(pk->p_ofn, buf, pk->p_xsize + HDRSIZ);
308: PKASSERT(ret == pk->p_xsize + HDRSIZ,
309: "PKXSTART ret", "", ret);
310: Connodata = 0;
311: }
312: if (pk->p_msg)
313: pkoutput(pk);
314: return;
315: }
316:
317:
318: pkmove(p1, p2, count, flag)
319: char *p1, *p2;
320: int count, flag;
321: {
322: register char *s, *d;
323: register int i;
324:
325: if (flag == B_WRITE) {
326: s = p2;
327: d = p1;
328: }
329: else {
330: s = p1;
331: d = p2;
332: }
333: for (i = 0; i < count; i++)
334: *d++ = *s++;
335: return;
336: }
337:
338:
339: /***
340: * pkcget(fn, b, n) get n characters from input
341: * char *b; - buffer for characters
342: * int fn; - file descriptor
343: * int n; - requested number of characters
344: *
345: * return codes:
346: * n - number of characters returned
347: * 0 - end of file
348: */
349:
350: jmp_buf Getjbuf;
351: cgalarm() { longjmp(Getjbuf, 1); }
352:
353: pkcget(fn, b, n)
354: int fn, n;
355: register char *b;
356: {
357: register int nchars, ret;
358:
359: if (setjmp(Getjbuf)) {
360: Ntimeout++;
361: PKDEBUG(4, "alarm %d\n", Ntimeout);
362: return(-1);
363: }
364: signal(SIGALRM, cgalarm);
365:
366: alarm(PKTIME);
367: for (nchars = 0; nchars < n; nchars += ret) {
368: ret = read(fn, b, n - nchars);
369: if (ret == 0) {
370: alarm(0);
371: return(-1);
372: }
373: PKASSERT(ret > 0, "PKCGET READ", "", ret);
374: b += ret;
375: }
376: alarm(0);
377: return(0);
378: }
379:
380:
381: #ifdef PROTODEBUG
382: generror(p, s)
383: char *p;
384: int s;
385: {
386: int r;
387: if (Errorrate != 0 && (rand() % Errorrate) == 0) {
388: r = rand() % s;
389: fprintf(stderr, "gen err at %o, (%o), ", r, (unsigned) *(p + r));
390: *(p + r) += 1;
391: }
392: return;
393: }
394:
395:
396: #endif
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.