![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to fio.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 fio.c CVS log | Up to [CSRG BSD Unix] / 43BSD / usr.bin / uucp |
1.1 root 1: #ifndef lint
2: static char sccsid[] = "@(#)fio.c 5.3 (Berkeley) 10/9/85";
3: #endif
4:
5: /*
6: * flow control protocol.
7: *
8: * This protocol relies on flow control of the data stream.
9: * It is meant for working over links that can (almost) be
10: * guaranteed to be errorfree, specifically X.25/PAD links.
11: * A sumcheck is carried out over a whole file only. If a
12: * transport fails the receiver can request retransmission(s).
13: * This protocol uses a 7-bit datapath only, so it can be
14: * used on links that are not 8-bit transparent.
15: *
16: * When using this protocol with an X.25 PAD:
17: * Although this protocol uses no control chars except CR,
18: * control chars NULL and ^P are used before this protocol
19: * is started; since ^P is the default char for accessing
20: * PAD X.28 command mode, be sure to disable that access
21: * (PAD par 1). Also make sure both flow control pars
22: * (5 and 12) are set. The CR used in this proto is meant
23: * to trigger packet transmission, hence par 3 should be
24: * set to 2; a good value for the Idle Timer (par 4) is 10.
25: * All other pars should be set to 0.
26: *
27: * Normally a calling site will take care of setting the
28: * local PAD pars via an X.28 command and those of the remote
29: * PAD via an X.29 command, unless the remote site has a
30: * special channel assigned for this protocol with the proper
31: * par settings.
32: *
33: * Additional comments for hosts with direct X.25 access:
34: * - the global variable IsTcpIp, when set, excludes the ioctl's,
35: * so the same binary can run on X.25 and non-X.25 hosts;
36: * - reads are done in small chunks, which can be smaller than
37: * the packet size; your X.25 driver must support that.
38: *
39: *
40: * Author:
41: * Piet Beertema, CWI, Amsterdam, Sep 1984
42: * Modified for X.25 hosts:
43: * Robert Elz, Melbourne Univ, Mar 1985
44: */
45:
46: #include "uucp.h"
47: #include <signal.h>
48: #ifdef USG
49: #include <termio.h>
50: #else !USG
51: #include <sgtty.h>
52: #endif !USG
53: #include <setjmp.h>
54:
55: #define FIBUFSIZ 256 /* for X.25 interfaces: set equal to packet size,
56: * but see comment above
57: */
58:
59: #define FOBUFSIZ 256 /* for X.25 interfaces: set equal to packet size;
60: * otherwise make as large as feasible to reduce
61: * number of write system calls
62: */
63:
64: #ifndef MAXMSGLEN
65: #define MAXMSGLEN BUFSIZ
66: #endif MAXMSGLEN
67:
68: static int fchksum;
69: static jmp_buf Ffailbuf;
70:
71: static
72: falarm()
73: {
74: signal(SIGALRM, falarm);
75: longjmp(Ffailbuf, 1);
76: }
77:
78: static int (*fsig)();
79:
80: #ifndef USG
81: #define TCGETA TIOCGETP
82: #define TCSETA TIOCSETP
83: #define termio sgttyb
84: #endif USG
85:
86: fturnon()
87: {
88: int ret;
89: struct termio ttbuf;
90:
91: if (!IsTcpIp) {
92: ioctl(Ifn, TCGETA, &ttbuf);
93: #ifdef USG
94: ttbuf.c_iflag = IXOFF|IXON|ISTRIP;
95: ttbuf.c_cc[VMIN] = FIBUFSIZ > 64 ? 64 : FIBUFSIZ;
96: ttbuf.c_cc[VTIME] = 5;
97: #else !USG
98: ttbuf.sg_flags = ANYP|CBREAK|TANDEM;
99: #endif USG
100: ret = ioctl(Ifn, TCSETA, &ttbuf);
101: ASSERT(ret >= 0, "STTY FAILED", "", ret);
102: }
103: fsig = signal(SIGALRM, falarm);
104: /* give the other side time to perform its ioctl;
105: * otherwise it may flush out the first data this
106: * side is about to send.
107: */
108: sleep(2);
109: return SUCCESS;
110: }
111:
112: fturnoff()
113: {
114: (void) signal(SIGALRM, fsig);
115: return SUCCESS;
116: }
117:
118: fwrmsg(type, str, fn)
119: register char *str;
120: int fn;
121: char type;
122: {
123: register char *s;
124: char bufr[MAXMSGLEN];
125:
126: s = bufr;
127: *s++ = type;
128: while (*str)
129: *s++ = *str++;
130: if (*(s-1) == '\n')
131: s--;
132: *s++ = '\r';
133: *s = 0;
134: (void) write(fn, bufr, s - bufr);
135: return SUCCESS;
136: }
137:
138: frdmsg(str, fn)
139: register char *str;
140: register int fn;
141: {
142: register char *smax;
143:
144: if (setjmp(Ffailbuf))
145: return FAIL;
146: smax = str + MAXMSGLEN - 1;
147: (void) alarm(2*MAXMSGTIME);
148: for (;;) {
149: if (read(fn, str, 1) <= 0)
150: goto msgerr;
151: *str &= 0177;
152: if (*str == '\r')
153: break;
154: if (*str < ' ') {
155: continue;
156: }
157: if (str++ >= smax)
158: goto msgerr;
159: }
160: *str = '\0';
161: (void) alarm(0);
162: return SUCCESS;
163: msgerr:
164: (void) alarm(0);
165: return FAIL;
166: }
167:
168: fwrdata(fp1, fn)
169: FILE *fp1;
170: int fn;
171: {
172: register int alen, ret;
173: register char *obp;
174: char ack, ibuf[MAXMSGLEN];
175: int flen, mil, retries = 0;
176: long abytes, fbytes;
177: struct timeb t1, t2;
178:
179: ret = FAIL;
180: retry:
181: fchksum = 0xffff;
182: abytes = fbytes = 0L;
183: ack = '\0';
184: #ifdef USG
185: time(&t1.time);
186: t1.millitm = 0;
187: #else !USG
188: ftime(&t1);
189: #endif !USG
190: do {
191: alen = fwrblk(fn, fp1, &flen);
192: fbytes += flen;
193: if (alen <= 0) {
194: abytes -= alen;
195: goto acct;
196: }
197: abytes += alen;
198: } while (!feof(fp1) && !ferror(fp1));
199: DEBUG(8, "\nchecksum: %04x\n", fchksum);
200: if (frdmsg(ibuf, fn) != FAIL) {
201: if ((ack = ibuf[0]) == 'G')
202: ret = SUCCESS;
203: DEBUG(4, "ack - '%c'\n", ack);
204: }
205: acct:
206: #ifdef USG
207: time(&t2.time);
208: t2.millitm = 0;
209: #else !USG
210: ftime(&t2);
211: #endif !USG
212: Now = t2;
213: t2.time -= t1.time;
214: mil = t2.millitm - t1.millitm;
215: if (mil < 0) {
216: --t2.time;
217: mil += 1000;
218: }
219: sprintf(ibuf, "sent data %ld bytes %ld.%02d secs",
220: fbytes, (long)t2.time, mil / 10);
221: sysacct(abytes, t2.time);
222: if (retries > 0)
223: sprintf(&ibuf[strlen(ibuf)], ", %d retries", retries);
224: DEBUG(1, "%s\n", ibuf);
225: syslog(ibuf);
226: if (ack == 'R') {
227: DEBUG(4, "RETRY:\n", 0);
228: fseek(fp1, 0L, 0);
229: retries++;
230: goto retry;
231: }
232: #ifdef SYSACCT
233: if (ret == FAIL)
234: sysaccf(NULL); /* force accounting */
235: #endif SYSACCT
236: return ret;
237: }
238:
239: /* max. attempts to retransmit a file: */
240: #define MAXRETRIES (fbytes < 10000L ? 2 : 1)
241:
242: frddata(fn, fp2)
243: register int fn;
244: register FILE *fp2;
245: {
246: register int flen;
247: register char eof;
248: char ibuf[FIBUFSIZ];
249: int ret, mil, retries = 0;
250: long alen, abytes, fbytes;
251: struct timeb t1, t2;
252:
253: ret = FAIL;
254: retry:
255: fchksum = 0xffff;
256: abytes = fbytes = 0L;
257: #ifdef USG
258: time(&t1.time);
259: t1.millitm = 0;
260: #else !USG
261: ftime(&t1);
262: #endif !USG
263: do {
264: flen = frdblk(ibuf, fn, &alen);
265: abytes += alen;
266: if (flen < 0)
267: goto acct;
268: if (eof = flen > FIBUFSIZ)
269: flen -= FIBUFSIZ + 1;
270: fbytes += flen;
271: if (fwrite(ibuf, sizeof (char), flen, fp2) != flen)
272: goto acct;
273: } while (!eof);
274: ret = SUCCESS;
275: acct:
276: #ifdef USG
277: time(&t2.time);
278: t2.millitm = 0;
279: #else !USG
280: ftime(&t2);
281: #endif !USG
282: Now = t2;
283: t2.time -= t1.time;
284: mil = t2.millitm - t1.millitm;
285: if (mil < 0) {
286: --t2.time;
287: mil += 1000;
288: }
289: sprintf(ibuf, "received data %ld bytes %ld.%02d secs",
290: fbytes, (long)t2.time, mil/10);
291: if (retries > 0)
292: sprintf(&ibuf[strlen(ibuf)]," %d retries", retries);
293: sysacct(abytes, t2.time);
294: DEBUG(1, "%s\n", ibuf);
295: syslog(ibuf);
296: if (ret == FAIL) {
297: if (retries++ < MAXRETRIES) {
298: DEBUG(8, "send ack: 'R'\n", 0);
299: fwrmsg('R', "", fn);
300: fseek(fp2, 0L, 0);
301: DEBUG(4, "RETRY:\n", 0);
302: goto retry;
303: }
304: DEBUG(8, "send ack: 'Q'\n", 0);
305: fwrmsg('Q', "", fn);
306: #ifdef SYSACCT
307: sysaccf(NULL); /* force accounting */
308: #endif SYSACCT
309: }
310: else {
311: DEBUG(8, "send ack: 'G'\n", 0);
312: fwrmsg('G', "", fn);
313: }
314: return ret;
315: }
316:
317: static
318: frdbuf(blk, len, fn)
319: register char *blk;
320: register int len;
321: register int fn;
322: {
323: static int ret = FIBUFSIZ / 2;
324:
325: if (setjmp(Ffailbuf))
326: return FAIL;
327: (void) alarm(MAXMSGTIME);
328: ret = read(fn, blk, len);
329: alarm(0);
330: return ret <= 0 ? FAIL : ret;
331: }
332:
333: #if !defined(BSD4_2) && !defined(USG)
334: /* call ultouch every TC calls to either frdblk or fwrblk */
335: #define TC 20
336: static int tc = TC;
337: #endif !defined(BSD4_2) && !defined(USG)
338:
339: /* Byte conversion:
340: *
341: * from pre to
342: * 000-037 172 100-137
343: * 040-171 040-171
344: * 172-177 173 072-077
345: * 200-237 174 100-137
346: * 240-371 175 040-171
347: * 372-377 176 072-077
348: */
349:
350: static
351: fwrblk(fn, fp, lenp)
352: int fn;
353: register FILE *fp;
354: int *lenp;
355: {
356: register char *op;
357: register int c, sum, nl, len;
358: char obuf[FOBUFSIZ + 8];
359: int ret;
360:
361: #if !defined(BSD4_2) && !defined(USG)
362: /* call ultouch occasionally */
363: if (--tc < 0) {
364: tc = TC;
365: ultouch();
366: }
367: #endif !defined(BSD4_2) && !defined(USG)
368: op = obuf;
369: nl = 0;
370: len = 0;
371: sum = fchksum;
372: while ((c = getc(fp)) != EOF) {
373: len++;
374: if (sum & 0x8000) {
375: sum <<= 1;
376: sum++;
377: } else
378: sum <<= 1;
379: sum += c;
380: sum &= 0xffff;
381: if (c & 0200) {
382: c &= 0177;
383: if (c < 040) {
384: *op++ = '\174';
385: *op++ = c + 0100;
386: } else
387: if (c <= 0171) {
388: *op++ = '\175';
389: *op++ = c;
390: }
391: else {
392: *op++ = '\176';
393: *op++ = c - 0100;
394: }
395: nl += 2;
396: } else {
397: if (c < 040) {
398: *op++ = '\172';
399: *op++ = c + 0100;
400: nl += 2;
401: } else
402: if (c <= 0171) {
403: *op++ = c;
404: nl++;
405: } else {
406: *op++ = '\173';
407: *op++ = c - 0100;
408: nl += 2;
409: }
410: }
411: if (nl >= FOBUFSIZ - 1) {
412: /*
413: * peek at next char, see if it will fit
414: */
415: c = getc(fp);
416: if (c == EOF)
417: break;
418: (void) ungetc(c, fp);
419: if (nl >= FOBUFSIZ || c < 040 || c > 0171)
420: goto writeit;
421: }
422: }
423: /*
424: * At EOF - append checksum, there is space for it...
425: */
426: sprintf(op, "\176\176%04x\r", sum);
427: nl += strlen(op);
428: writeit:
429: *lenp = len;
430: fchksum = sum;
431: DEBUG(8, "%d/", len);
432: DEBUG(8, "%d,", nl);
433: ret = write(fn, obuf, nl);
434: return ret == nl ? nl : ret < 0 ? 0 : -ret;
435: }
436:
437: static
438: frdblk(ip, fn, rlen)
439: register char *ip;
440: int fn;
441: long *rlen;
442: {
443: register char *op, c;
444: register int sum, len, nl;
445: char buf[5], *erbp = ip;
446: int i;
447: static char special = 0;
448:
449: #if !defined(BSD4_2) && !defined(USG)
450: /* call ultouch occasionally */
451: if (--tc < 0) {
452: tc = TC;
453: ultouch();
454: }
455: #endif !defined(BSD4_2) && !defined(USG)
456: if ((len = frdbuf(ip, FIBUFSIZ, fn)) == FAIL) {
457: *rlen = 0;
458: goto dcorr;
459: }
460: *rlen = len;
461: DEBUG(8, "%d/", len);
462: op = ip;
463: nl = 0;
464: sum = fchksum;
465: do {
466: if ((*ip &= 0177) >= '\172') {
467: if (special) {
468: DEBUG(8, "%d", nl);
469: special = 0;
470: op = buf;
471: if (*ip++ != '\176' || (i = --len) > 5)
472: goto dcorr;
473: while (i--)
474: *op++ = *ip++ & 0177;
475: while (len < 5) {
476: i = frdbuf(&buf[len], 5 - len, fn);
477: if (i == FAIL) {
478: len = FAIL;
479: goto dcorr;
480: }
481: DEBUG(8, ",%d", i);
482: len += i;
483: *rlen += i;
484: while (i--)
485: *op++ &= 0177;
486: }
487: if (buf[4] != '\r')
488: goto dcorr;
489: sscanf(buf, "%4x", &fchksum);
490: DEBUG(8, "\nchecksum: %04x\n", sum);
491: if (fchksum == sum)
492: return FIBUFSIZ + 1 + nl;
493: else {
494: DEBUG(8, "\n", 0);
495: DEBUG(4, "Bad checksum\n", 0);
496: return FAIL;
497: }
498: }
499: special = *ip++;
500: } else {
501: if (*ip < '\040') {
502: /* error: shouldn't get control chars */
503: goto dcorr;
504: }
505: switch (special) {
506: case 0:
507: c = *ip++;
508: break;
509: case '\172':
510: c = *ip++ - 0100;
511: break;
512: case '\173':
513: c = *ip++ + 0100;
514: break;
515: case '\174':
516: c = *ip++ + 0100;
517: break;
518: case '\175':
519: c = *ip++ + 0200;
520: break;
521: case '\176':
522: c = *ip++ + 0300;
523: break;
524: }
525: *op++ = c;
526: if (sum & 0x8000) {
527: sum <<= 1;
528: sum++;
529: } else
530: sum <<= 1;
531: sum += c & 0377;
532: sum &= 0xffff;
533: special = 0;
534: nl++;
535: }
536: } while (--len);
537: fchksum = sum;
538: DEBUG(8, "%d,", nl);
539: return nl;
540: dcorr:
541: DEBUG(8, "\n", 0);
542: DEBUG(4, "Data corrupted\n", 0);
543: while (len != FAIL) {
544: if ((len = frdbuf(erbp, FIBUFSIZ, fn)) != FAIL)
545: *rlen += len;
546: }
547: return FAIL;
548: }
549:
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.