![[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] / 43BSD / usr.bin / uucp|
Return to pk1.c CVS log | Up to [CSRG BSD Unix] / 43BSD / usr.bin / uucp |
1.1 root 1: #ifndef lint
2: static char sccsid[] = "@(#)pk1.c 5.9 (Berkeley) 5/30/86";
3: #endif
4:
5: #include <signal.h>
6: #include "uucp.h"
7: #include "pk.h"
8: #include <setjmp.h>
9: #ifdef BSD4_2
10: #include <sys/time.h>
11: #endif BSD4_2
12:
13: #ifdef VMS
14: #include <eunice/eunice.h>
15: #include <vms/iodef.h>
16: #include <vms/ssdef.h>
17: int iomask[2];
18: #endif VMS
19:
20: #define PKMAXSTMSG 40
21: #define MAXPKTIME 32 /* was 16 */
22: #define CONNODATA 10
23: #define MAXTIMEOUT 32
24:
25: extern int errno;
26: extern int Retries;
27: extern char *sys_errlist[];
28: extern jmp_buf Sjbuf;
29: extern char *malloc();
30:
31: int Connodata = 0;
32: int Ntimeout = 0;
33: int pktimeout = 4;
34: int pktimeskew = 2;
35: /*
36: * packet driver support routines
37: *
38: */
39:
40: extern struct pack *pklines[];
41:
42: /*
43: * start initial synchronization.
44: */
45:
46: struct pack *
47: pkopen(ifn, ofn)
48: int ifn, ofn;
49: {
50: register struct pack *pk;
51: register char **bp;
52: register int i;
53:
54: if ((pk = (struct pack *) malloc(sizeof (struct pack))) == NULL)
55: return NULL;
56: bzero((caddr_t) pk, sizeof (struct pack));
57: pk->p_ifn = ifn;
58: pk->p_ofn = ofn;
59: pk->p_xsize = pk->p_rsize = PACKSIZE;
60: pk->p_rwindow = pk->p_swindow = WINDOWS;
61: /* allocate input windows */
62: for (i = 0; i < pk->p_rwindow; i++) {
63: if ((bp = (char **) malloc((unsigned)pk->p_xsize)) == NULL)
64: break;
65: *bp = (char *) pk->p_ipool;
66: pk->p_ipool = bp;
67: }
68: if (i == 0) {
69: DEBUG(1, "pkopen: can't malloc i = 0\n", CNULL);
70: return NULL;
71: }
72: pk->p_rwindow = i;
73:
74: /* start synchronization */
75: pk->p_msg = pk->p_rmsg = M_INITA;
76: for (i = 0; i < NPLINES; i++) {
77: if (pklines[i] == NULL) {
78: pklines[i] = pk;
79: break;
80: }
81: }
82: if (i >= NPLINES) {
83: DEBUG(1,"pkopen: i>=NPLINES\n", CNULL);
84: return NULL;
85: }
86: pkoutput(pk);
87:
88: for (i = 0; i < PKMAXSTMSG; i++) {
89: pkgetpack(pk);
90: if ((pk->p_state & LIVE) != 0)
91: break;
92: }
93: if (i >= PKMAXSTMSG) {
94: DEBUG(1, "pkopen: i>= PKMAXSTMSG\n", CNULL);
95: return NULL;
96: }
97:
98: pkreset(pk);
99: return pk;
100: }
101:
102:
103: /*
104: * input framing and block checking.
105: * frame layout for most devices is:
106: *
107: * S|K|X|Y|C|Z| ... data ... |
108: *
109: * where S == initial synch byte
110: * K == encoded frame size (indexes pksizes[])
111: * X, Y == block check bytes
112: * C == control byte
113: * Z == XOR of header (K^X^Y^C)
114: * data == 0 or more data bytes
115: *
116: */
117:
118: int pksizes[] = {
119: 1, 32, 64, 128, 256, 512, 1024, 2048, 4096, 1
120: };
121:
122: #define GETRIES 10
123: /*
124: * Pseudo-dma byte collection.
125: */
126:
127: pkgetpack(pk)
128: register struct pack *pk;
129: {
130: int k, tries, noise;
131: register char *p;
132: register struct header *h;
133: unsigned short sum;
134: int ifn;
135: char **bp;
136: char hdchk;
137:
138: if ((pk->p_state & DOWN) || Connodata > CONNODATA || Ntimeout > MAXTIMEOUT)
139: pkfail();
140: ifn = pk->p_ifn;
141:
142: /* find HEADER */
143: for (tries = 0, noise = 0; tries < GETRIES; ) {
144: p = (caddr_t) &pk->p_ihbuf;
145: if (pkcget(ifn, p, 1) == SUCCESS) {
146: if (*p++ == SYN) {
147: if (pkcget(ifn, p, HDRSIZ-1) == SUCCESS)
148: break;
149: } else {
150: if (noise++ < 10 || noise < (3*pk->p_rsize))
151: continue;
152: }
153: DEBUG(4, "Noisy line - set up RXMIT\n", CNULL);
154: noise = 0;
155: }
156: /* set up retransmit or REJ */
157: tries++;
158: Retries++;
159: pk->p_msg |= pk->p_rmsg;
160: if (pk->p_msg == 0)
161: pk->p_msg |= M_RR;
162: if ((pk->p_state & LIVE) == LIVE)
163: pk->p_state |= RXMIT;
164: pkoutput(pk);
165: }
166: if (tries >= GETRIES) {
167: DEBUG(4, "tries = %d\n", tries);
168: pkfail();
169: }
170:
171: Connodata++;
172: h = (struct header *) &pk->p_ihbuf;
173: p = (caddr_t) h;
174: hdchk = p[1] ^ p[2] ^ p[3] ^ p[4];
175: p += 2;
176: sum = (unsigned) *p++ & 0377;
177: sum |= (unsigned) *p << 8;
178: h->sum = sum;
179: DEBUG(7, "rec h->cntl 0%o\n", h->cntl&0xff);
180: k = h->ksize;
181: if (hdchk != h->ccntl) {
182: /* bad header */
183: DEBUG(7, "bad header 0%o,", hdchk&0xff);
184: DEBUG(7, "h->ccntl 0%o\n", h->ccntl&0xff);
185: return;
186: }
187: if (k == 9) {
188: if (((h->sum + h->cntl) & 0xffff) == CHECK) {
189: pkcntl(h->cntl, pk);
190: DEBUG(7, "state - 0%o\n", pk->p_state);
191: } else {
192: /* bad header */
193: pk->p_state |= BADFRAME;
194: DEBUG(7, "bad header (k==9) 0%o\n", h->cntl&0xff);
195: }
196: return;
197: }
198: if (k && pksizes[k] == pk->p_rsize) {
199: pk->p_rpr = (h->cntl >> 3) & MOD8;
200: pksack(pk);
201: bp = pk->p_ipool;
202: if (bp == NULL) {
203: DEBUG(7, "bp NULL %s\n", "");
204: return;
205: }
206: pk->p_ipool = (char **) *bp;
207: Connodata = 0;
208: } else
209: return;
210:
211: if (pkcget(pk->p_ifn, (char *) bp, pk->p_rsize) == SUCCESS) {
212: pkdata(h->cntl, h->sum, pk, (char **) bp);
213: } else {
214: *bp = (char *)pk->p_ipool;
215: pk->p_ipool = bp;
216: }
217: }
218:
219: pkdata(c, sum, pk, bp)
220: char c;
221: unsigned short sum;
222: register struct pack *pk;
223: char **bp;
224: {
225: register x;
226: int t;
227: char m;
228:
229: if (pk->p_state & DRAINO || !(pk->p_state & LIVE)) {
230: pk->p_msg |= pk->p_rmsg;
231: pkoutput(pk);
232: goto drop;
233: }
234: t = next[pk->p_pr];
235: for(x=pk->p_pr; x!=t; x = (x-1)&7) {
236: if (pk->p_is[x] == 0)
237: goto slot;
238: }
239: drop:
240: *bp = (char *)pk->p_ipool;
241: pk->p_ipool = bp;
242: return;
243:
244: slot:
245: m = mask[x];
246: pk->p_imap |= m;
247: pk->p_is[x] = c;
248: pk->p_isum[x] = sum;
249: pk->p_ib[x] = (char *)bp;
250: }
251:
252: /*
253: * setup input transfers
254: */
255: #define PKMAXBUF 128
256: /*
257: * Start transmission on output device associated with pk.
258: * For asynch devices (t_line==1) framing is
259: * imposed. For devices with framing and crc
260: * in the driver (t_line==2) the transfer is
261: * passed on to the driver.
262: */
263: pkxstart(pk, cntl, x)
264: register struct pack *pk;
265: char cntl;
266: register x;
267: {
268: register char *p;
269: short checkword;
270: char hdchk;
271:
272: p = (caddr_t) &pk->p_ohbuf;
273: *p++ = SYN;
274: if (x < 0) {
275: *p++ = hdchk = 9;
276: checkword = cntl;
277: } else {
278: *p++ = hdchk = pk->p_lpsize;
279: checkword = pk->p_osum[x] ^ (unsigned)(cntl & 0377);
280: }
281: checkword = CHECK - checkword;
282: *p = checkword;
283: hdchk ^= *p++;
284: *p = checkword>>8;
285: hdchk ^= *p++;
286: *p = cntl;
287: hdchk ^= *p++;
288: *p = hdchk;
289: /* writes */
290: DEBUG(7, "send 0%o\n", cntl&0xff);
291: p = (caddr_t) & pk->p_ohbuf;
292: if (x < 0) {
293: if(write(pk->p_ofn, p, HDRSIZ) != HDRSIZ) {
294: alarm(0);
295: logent("PKXSTART write failed", sys_errlist[errno]);
296: longjmp(Sjbuf, 4);
297: }
298: } else {
299: char buf[PKMAXBUF + HDRSIZ + TAILSIZE], *b;
300: int i;
301: for (i = 0, b = buf; i < HDRSIZ; i++)
302: *b++ = *p++;
303: for (i = 0, p = pk->p_ob[x]; i < pk->p_xsize; i++)
304: *b++ = *p++;
305: #if TAILSIZE != 0
306: for (i = 0; i < TAILSIZE; i++)
307: *b++ = '\0';
308: #endif TAILSIZE
309: if (write(pk->p_ofn, buf, pk->p_xsize + HDRSIZ + TAILSIZE)
310: != (HDRSIZ + TAILSIZE + pk->p_xsize)) {
311: alarm(0);
312: logent("PKXSTART write failed", sys_errlist[errno]);
313: longjmp(Sjbuf, 5);
314: }
315: Connodata = 0;
316: }
317: if (pk->p_msg)
318: pkoutput(pk);
319: }
320:
321:
322: pkmove(p1, p2, count, flag)
323: char *p1, *p2;
324: int count, flag;
325: {
326: register char *s, *d;
327: register int i;
328:
329: if (flag == B_WRITE) {
330: s = p2;
331: d = p1;
332: } else {
333: s = p1;
334: d = p2;
335: }
336: for (i = 0; i < count; i++)
337: *d++ = *s++;
338: }
339:
340:
341: /*
342: * get n characters from input
343: *
344: * return codes:
345: * n - number of characters returned
346: * 0 - end of file
347: */
348:
349: jmp_buf Getjbuf;
350: cgalarm()
351: {
352: longjmp(Getjbuf, 1);
353: }
354:
355: pkcget(fn, b, n)
356: int fn;
357: register char *b;
358: register int n;
359: {
360: register int ret;
361: extern int linebaudrate;
362: #ifdef BSD4_2
363: long r, itime = 100000L; /* guess it's been 1/10th second since we
364: last read the line */
365: struct timeval tv;
366: #endif BSD4_2
367: #ifdef VMS
368: short iosb[4];
369: int SYS$QioW(); /* use this for long reads on vms */
370: #endif VMS
371:
372: if (setjmp(Getjbuf)) {
373: Ntimeout++;
374: DEBUG(4, "pkcget: alarm %d\n", pktimeout * 1000 + Ntimeout);
375: pktimeout += pktimeskew;
376: if (pktimeout > MAXPKTIME)
377: pktimeout = MAXPKTIME;
378: return FAIL;
379: }
380: signal(SIGALRM, cgalarm);
381:
382: alarm(pktimeout);
383: while (n > 0) {
384: #ifdef BSD4_2
385: if (linebaudrate > 0) {
386: r = n * 100000L;
387: r = r / linebaudrate;
388: r = (r * 100) - itime;
389: itime = 0;
390: /* we predict that more than 1/50th of a
391: second will go by before the read will
392: give back all that we want. */
393: if (r > 20000) {
394: tv.tv_sec = r / 1000000L;
395: tv.tv_usec = r % 1000000L;
396: DEBUG(11, "PKCGET stall for %d", tv.tv_sec);
397: DEBUG(11, ".%06d sec\n", tv.tv_usec);
398: (void) select (0, (int *)0, (int *)0, (int *)0, &tv);
399: }
400: }
401: #endif BSD4_2
402: #ifndef VMS
403: ret = read(fn, b, n);
404: #else VMS
405: _$Cancel_IO_On_Signal = FD_FAB_Pointer[fn];
406: ret = SYS$QioW(_$EFN,(FD_FAB_Pointer[fn]->fab).fab$l_stv,
407: IO$_READVBLK|IO$M_NOFILTR|IO$M_NOECHO,
408: iosb,0,0,b,n,0,
409: iomask,0,0);
410: _$Cancel_IO_On_Signal = 0;
411: if (ret == SS$_NORMAL)
412: ret = iosb[1]+iosb[3]; /* get length of transfer */
413: else
414: ret = 0;
415: #endif VMS
416: if (ret == 0) {
417: alarm(0);
418: return FAIL;
419: }
420: if (ret <= 0) {
421: alarm(0);
422: logent(sys_errlist[errno],"FAILED pkcget Read");
423: longjmp(Sjbuf, 6);
424: }
425: b += ret;
426: n -= ret;
427: }
428: alarm(0);
429: return SUCCESS;
430: }
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.