![[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] / 43BSDReno / usr.bin / uucp|
Return to fio.c CVS log | Up to [CSRG BSD Unix] / 43BSDReno / usr.bin / uucp |
1.1 root 1: #ifndef lint
2: static char sccsid[] = "@(#)fio.c 5.6 (Berkeley) 6/29/90";
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 4096 /* for X.25 interfaces: set equal to packet size,
56: * but see comment above
57: */
58:
59: #define FOBUFSIZ 4096 /* 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: extern long Bytes_Sent, Bytes_Received;
72:
73: static
74: falarm()
75: {
76: signal(SIGALRM, falarm);
77: longjmp(Ffailbuf, 1);
78: }
79:
80: static void (*fsig)();
81:
82: #ifndef USG
83: #define TCGETA TIOCGETP
84: #define TCSETAF TIOCSETP
85: #define termio sgttyb
86: #endif USG
87: static struct termio ttbuf;
88:
89: fturnon()
90: {
91: int ttbuf_flags;
92:
93: if (!IsTcpIp) {
94: ioctl(Ifn, TCGETA, &ttbuf);
95: #ifdef USG
96: ttbuf_flags = ttbuf.c_iflag;
97: ttbuf.c_iflag = IXOFF|IXON|ISTRIP;
98: ttbuf.c_cc[VMIN] = FIBUFSIZ > 64 ? 64 : FIBUFSIZ;
99: ttbuf.c_cc[VTIME] = 5;
100: if (ioctl(Ifn, TCSETAF, &ttbuf) < 0) {
101: syslog(LOG_ERR, "ioctl(TCSETAF) failed: %m");
102: cleanup(FAIL);
103: }
104: ttbuf.c_iflag = ttbuf_flags;
105: #else !USG
106: ttbuf_flags = ttbuf.sg_flags;
107: ttbuf.sg_flags = ANYP|CBREAK;
108: if (ioctl(Ifn, TCSETAF, &ttbuf) < 0) {
109: syslog(LOG_ERR, "ioctl(TCSETAF) failed: %m");
110: cleanup(FAIL);
111: }
112: /* this is two seperate ioctls to set the x.29 params */
113: ttbuf.sg_flags |= TANDEM;
114: if (ioctl(Ifn, TCSETAF, &ttbuf) < 0) {
115: syslog(LOG_ERR, "ioctl(TCSETAF) failed: %m");
116: cleanup(FAIL);
117: }
118: ttbuf.sg_flags = ttbuf_flags;
119: #endif USG
120: }
121: fsig = signal(SIGALRM, falarm);
122: /* give the other side time to perform its ioctl;
123: * otherwise it may flush out the first data this
124: * side is about to send.
125: */
126: sleep(2);
127: return SUCCESS;
128: }
129:
130: fturnoff()
131: {
132: if (!IsTcpIp)
133: ioctl(Ifn, TCSETAF, &ttbuf);
134: (void) signal(SIGALRM, fsig);
135: sleep(2);
136: return SUCCESS;
137: }
138:
139: fwrmsg(type, str, fn)
140: register char *str;
141: int fn;
142: char type;
143: {
144: register char *s;
145: char bufr[MAXMSGLEN];
146:
147: s = bufr;
148: *s++ = type;
149: while (*str)
150: *s++ = *str++;
151: if (*(s-1) == '\n')
152: s--;
153: *s++ = '\r';
154: *s = 0;
155: (void) write(fn, bufr, s - bufr);
156: return SUCCESS;
157: }
158:
159: frdmsg(str, fn)
160: register char *str;
161: register int fn;
162: {
163: register char *smax;
164:
165: if (setjmp(Ffailbuf))
166: return FAIL;
167: smax = str + MAXMSGLEN - 1;
168: (void) alarm(2*MAXMSGTIME);
169: for (;;) {
170: if (read(fn, str, 1) <= 0)
171: goto msgerr;
172: *str &= 0177;
173: if (*str == '\r')
174: break;
175: if (*str < ' ') {
176: continue;
177: }
178: if (str++ >= smax)
179: goto msgerr;
180: }
181: *str = '\0';
182: (void) alarm(0);
183: return SUCCESS;
184: msgerr:
185: (void) alarm(0);
186: return FAIL;
187: }
188:
189: fwrdata(fp1, fn)
190: FILE *fp1;
191: int fn;
192: {
193: register int alen, ret;
194: char ack, ibuf[MAXMSGLEN];
195: int flen, mil, retries = 0;
196: long abytes, fbytes;
197: struct timeb t1, t2;
198: float ft;
199:
200: ret = FAIL;
201: retry:
202: fchksum = 0xffff;
203: abytes = fbytes = 0L;
204: ack = '\0';
205: #ifdef USG
206: time(&t1.time);
207: t1.millitm = 0;
208: #else !USG
209: ftime(&t1);
210: #endif !USG
211: do {
212: alen = fwrblk(fn, fp1, &flen);
213: fbytes += flen;
214: if (alen <= 0) {
215: abytes -= alen;
216: goto acct;
217: }
218: abytes += alen;
219: } while (!feof(fp1) && !ferror(fp1));
220: DEBUG(8, "\nchecksum: %04x\n", fchksum);
221: if (frdmsg(ibuf, fn) != FAIL) {
222: if ((ack = ibuf[0]) == 'G')
223: ret = SUCCESS;
224: DEBUG(4, "ack - '%c'\n", ack);
225: }
226: acct:
227: #ifdef USG
228: time(&t2.time);
229: t2.millitm = 0;
230: #else !USG
231: ftime(&t2);
232: #endif !USG
233: Now = t2;
234: t2.time -= t1.time;
235: mil = t2.millitm - t1.millitm;
236: if (mil < 0) {
237: --t2.time;
238: mil += 1000;
239: }
240: ft = (float)t2.time + (float)mil/1000.;
241: sprintf(ibuf, "sent data %ld bytes %.2f secs %ld bps",
242: fbytes, ft, (long)((float)fbytes*8./ft));
243: sysacct(abytes, t2.time);
244: Bytes_Sent += fbytes;
245: if (retries > 0)
246: sprintf(&ibuf[strlen(ibuf)], ", %d retries", retries);
247: DEBUG(1, "%s\n", ibuf);
248: log_xferstats(ibuf);
249: if (ack == 'R') {
250: DEBUG(4, "RETRY:\n", 0);
251: fseek(fp1, 0L, 0);
252: retries++;
253: goto retry;
254: }
255: #ifdef SYSACCT
256: if (ret == FAIL)
257: sysaccf(NULL); /* force accounting */
258: #endif SYSACCT
259: return ret;
260: }
261:
262: /* max. attempts to retransmit a file: */
263: #define MAXRETRIES (fbytes < 10000L ? 2 : 1)
264:
265: frddata(fn, fp2)
266: register int fn;
267: register FILE *fp2;
268: {
269: register int flen;
270: register char eof;
271: char ibuf[FIBUFSIZ];
272: int ret, mil, retries = 0;
273: long alen, abytes, fbytes;
274: struct timeb t1, t2;
275: float ft;
276:
277: ret = FAIL;
278: retry:
279: fchksum = 0xffff;
280: abytes = fbytes = 0L;
281: #ifdef USG
282: time(&t1.time);
283: t1.millitm = 0;
284: #else !USG
285: ftime(&t1);
286: #endif !USG
287: do {
288: flen = frdblk(ibuf, fn, &alen);
289: abytes += alen;
290: if (flen < 0)
291: goto acct;
292: if (eof = flen > FIBUFSIZ)
293: flen -= FIBUFSIZ + 1;
294: fbytes += flen;
295: if (fwrite(ibuf, sizeof (char), flen, fp2) != flen)
296: goto acct;
297: } while (!eof);
298: ret = SUCCESS;
299: acct:
300: #ifdef USG
301: time(&t2.time);
302: t2.millitm = 0;
303: #else !USG
304: ftime(&t2);
305: #endif !USG
306: Now = t2;
307: t2.time -= t1.time;
308: mil = t2.millitm - t1.millitm;
309: if (mil < 0) {
310: --t2.time;
311: mil += 1000;
312: }
313: ft = (float)t2.time + (float)mil/1000.;
314: sprintf(ibuf, "received data %ld bytes %.2f secs %ld bps",
315: fbytes, ft, (long)((float)fbytes*8./ft));
316: if (retries > 0)
317: sprintf(&ibuf[strlen(ibuf)]," %d retries", retries);
318: sysacct(abytes, t2.time);
319: Bytes_Received += fbytes;
320: DEBUG(1, "%s\n", ibuf);
321: log_xferstats(ibuf);
322: if (ret == FAIL) {
323: if (retries++ < MAXRETRIES) {
324: DEBUG(8, "send ack: 'R'\n", 0);
325: fwrmsg('R', "", fn);
326: fseek(fp2, 0L, 0);
327: DEBUG(4, "RETRY:\n", 0);
328: goto retry;
329: }
330: DEBUG(8, "send ack: 'Q'\n", 0);
331: fwrmsg('Q', "", fn);
332: #ifdef SYSACCT
333: sysaccf(NULL); /* force accounting */
334: #endif SYSACCT
335: }
336: else {
337: DEBUG(8, "send ack: 'G'\n", 0);
338: fwrmsg('G', "", fn);
339: }
340: return ret;
341: }
342:
343: static
344: frdbuf(blk, len, fn)
345: register char *blk;
346: register int len;
347: register int fn;
348: {
349: static int ret = FIBUFSIZ / 2;
350:
351: if (setjmp(Ffailbuf))
352: return FAIL;
353: (void) alarm(MAXMSGTIME);
354: ret = read(fn, blk, len);
355: alarm(0);
356: return ret <= 0 ? FAIL : ret;
357: }
358:
359: #if !defined(BSD4_2) && !defined(USG)
360: /* call ultouch every TC calls to either frdblk or fwrblk */
361: #define TC 20
362: static int tc = TC;
363: #endif !defined(BSD4_2) && !defined(USG)
364:
365: /* Byte conversion:
366: *
367: * from pre to
368: * 000-037 172 100-137
369: * 040-171 040-171
370: * 172-177 173 072-077
371: * 200-237 174 100-137
372: * 240-371 175 040-171
373: * 372-377 176 072-077
374: */
375:
376: static
377: fwrblk(fn, fp, lenp)
378: int fn;
379: register FILE *fp;
380: int *lenp;
381: {
382: register char *op;
383: register int c, sum, nl, len;
384: char obuf[FOBUFSIZ + 8];
385: int ret;
386:
387: #if !defined(BSD4_2) && !defined(USG)
388: /* call ultouch occasionally */
389: if (--tc < 0) {
390: tc = TC;
391: ultouch();
392: }
393: #endif !defined(BSD4_2) && !defined(USG)
394: op = obuf;
395: nl = 0;
396: len = 0;
397: sum = fchksum;
398: while ((c = getc(fp)) != EOF) {
399: len++;
400: if (sum & 0x8000) {
401: sum <<= 1;
402: sum++;
403: } else
404: sum <<= 1;
405: sum += c;
406: sum &= 0xffff;
407: if (c & 0200) {
408: c &= 0177;
409: if (c < 040) {
410: *op++ = '\174';
411: *op++ = c + 0100;
412: } else
413: if (c <= 0171) {
414: *op++ = '\175';
415: *op++ = c;
416: }
417: else {
418: *op++ = '\176';
419: *op++ = c - 0100;
420: }
421: nl += 2;
422: } else {
423: if (c < 040) {
424: *op++ = '\172';
425: *op++ = c + 0100;
426: nl += 2;
427: } else
428: if (c <= 0171) {
429: *op++ = c;
430: nl++;
431: } else {
432: *op++ = '\173';
433: *op++ = c - 0100;
434: nl += 2;
435: }
436: }
437: if (nl >= FOBUFSIZ - 1) {
438: /*
439: * peek at next char, see if it will fit
440: */
441: c = getc(fp);
442: if (c == EOF)
443: break;
444: (void) ungetc(c, fp);
445: if (nl >= FOBUFSIZ || c < 040 || c > 0171)
446: goto writeit;
447: }
448: }
449: /*
450: * At EOF - append checksum, there is space for it...
451: */
452: sprintf(op, "\176\176%04x\r", sum);
453: nl += strlen(op);
454: writeit:
455: *lenp = len;
456: fchksum = sum;
457: DEBUG(8, "%d/", len);
458: DEBUG(8, "%d,", nl);
459: ret = write(fn, obuf, nl);
460: return ret == nl ? nl : ret < 0 ? 0 : -ret;
461: }
462:
463: static
464: frdblk(ip, fn, rlen)
465: register char *ip;
466: int fn;
467: long *rlen;
468: {
469: register char *op, c;
470: register int sum, len, nl;
471: char buf[5], *erbp = ip;
472: int i;
473: static char special = 0;
474:
475: #if !defined(BSD4_2) && !defined(USG)
476: /* call ultouch occasionally */
477: if (--tc < 0) {
478: tc = TC;
479: ultouch();
480: }
481: #endif !defined(BSD4_2) && !defined(USG)
482: if ((len = frdbuf(ip, FIBUFSIZ, fn)) == FAIL) {
483: *rlen = 0;
484: goto dcorr;
485: }
486: *rlen = len;
487: DEBUG(8, "%d/", len);
488: op = ip;
489: nl = 0;
490: sum = fchksum;
491: do {
492: if ((*ip &= 0177) >= '\172') {
493: if (special) {
494: DEBUG(8, "%d", nl);
495: special = 0;
496: op = buf;
497: if (*ip++ != '\176' || (i = --len) > 5)
498: goto dcorr;
499: while (i--)
500: *op++ = *ip++ & 0177;
501: while (len < 5) {
502: i = frdbuf(&buf[len], 5 - len, fn);
503: if (i == FAIL) {
504: len = FAIL;
505: goto dcorr;
506: }
507: DEBUG(8, ",%d", i);
508: len += i;
509: *rlen += i;
510: while (i--)
511: *op++ &= 0177;
512: }
513: if (buf[4] != '\r')
514: goto dcorr;
515: sscanf(buf, "%4x", &fchksum);
516: DEBUG(8, "\nchecksum: %04x\n", sum);
517: if (fchksum == sum)
518: return FIBUFSIZ + 1 + nl;
519: else {
520: DEBUG(8, "\n", 0);
521: DEBUG(4, "Bad checksum\n", 0);
522: return FAIL;
523: }
524: }
525: special = *ip++;
526: } else {
527: if (*ip < '\040') {
528: /* error: shouldn't get control chars */
529: goto dcorr;
530: }
531: switch (special) {
532: case 0:
533: c = *ip++;
534: break;
535: case '\172':
536: c = *ip++ - 0100;
537: break;
538: case '\173':
539: c = *ip++ + 0100;
540: break;
541: case '\174':
542: c = *ip++ + 0100;
543: break;
544: case '\175':
545: c = *ip++ + 0200;
546: break;
547: case '\176':
548: c = *ip++ + 0300;
549: break;
550: }
551: *op++ = c;
552: if (sum & 0x8000) {
553: sum <<= 1;
554: sum++;
555: } else
556: sum <<= 1;
557: sum += c & 0377;
558: sum &= 0xffff;
559: special = 0;
560: nl++;
561: }
562: } while (--len);
563: fchksum = sum;
564: DEBUG(8, "%d,", nl);
565: return nl;
566: dcorr:
567: DEBUG(8, "\n", 0);
568: DEBUG(4, "Data corrupted\n", 0);
569: while (len != FAIL) {
570: if ((len = frdbuf(erbp, FIBUFSIZ, fn)) != FAIL)
571: *rlen += len;
572: }
573: return FAIL;
574: }
575:
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.