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