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