![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to tio.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 tio.c CVS log | Up to [CSRG BSD Unix] / 43BSD / usr.bin / uucp |
1.1 root 1: #ifndef lint
2: static char sccsid[] = "@(#)tio.c 4.6 (Berkeley) 1/24/86";
3: #endif
4:
5: #include <signal.h>
6: #include "uucp.h"
7: #include <setjmp.h>
8: #include <sys/stat.h>
9:
10: extern int pkfail();
11: #define TPACKSIZE 512
12: #define TBUFSIZE 1024
13: #define min(a,b) (((a)<(b))?(a):(b))
14:
15: /*
16: * htonl is a function that converts a long from host
17: * order to network order
18: * ntohl is a function that converts a long from network
19: * order to host order
20: *
21: * network order is 0 1 2 3 (bytes in a long)
22: * host order on a vax is 3 2 1 0
23: * host order on a pdp11 is 1 0 3 2
24: * host order on a 68000 is 0 1 2 3
25: * most other machines are 0 1 2 3
26: */
27:
28: struct tbuf {
29: long t_nbytes;
30: char t_data[TBUFSIZE];
31: };
32:
33: extern jmp_buf Failbuf;
34:
35: twrmsg(type, str, fn)
36: char type;
37: register char *str;
38: {
39: char bufr[TBUFSIZE];
40: register char *s;
41: int len, i;
42:
43: if(setjmp(Failbuf))
44: return FAIL;
45: signal(SIGALRM, pkfail);
46: alarm(MAXMSGTIME);
47: bufr[0] = type;
48: s = &bufr[1];
49: while (*str)
50: *s++ = *str++;
51: *s = '\0';
52: if (*(--s) == '\n')
53: *s = '\0';
54: len = strlen(bufr) + 1;
55: if ((i = len % TPACKSIZE)) {
56: len = len + TPACKSIZE - i;
57: bufr[len - 1] = '\0';
58: }
59: twrblk(bufr, len, fn);
60: alarm(0);
61: return SUCCESS;
62: }
63:
64: trdmsg(str, fn)
65: register char *str;
66: {
67: int len, cnt = 0;
68:
69: if(setjmp(Failbuf))
70: return FAIL;
71: signal(SIGALRM, pkfail);
72: alarm(MAXMSGTIME);
73: for (;;) {
74: len = read(fn, str, TPACKSIZE);
75: if (len == 0)
76: continue;
77: if (len < 0) {
78: alarm(0);
79: return FAIL;
80: }
81: str += len;
82: cnt += len;
83: if (*(str - 1) == '\0' && (cnt % TPACKSIZE) == 0)
84: break;
85: }
86: alarm(0);
87: return SUCCESS;
88: }
89:
90: twrdata(fp1, fn)
91: FILE *fp1;
92: {
93: struct tbuf bufr;
94: register int len;
95: int ret, mil;
96: struct timeb t1, t2;
97: long bytes;
98: char text[TBUFSIZE];
99:
100: if(setjmp(Failbuf))
101: return FAIL;
102: signal(SIGALRM, pkfail);
103: bytes = 0L;
104: #ifdef USG
105: time(&t1.time);
106: t1.millitm = 0;
107: #else !USG
108: ftime(&t1);
109: #endif !USG
110: while ((len = read(fileno(fp1), bufr.t_data, TBUFSIZE)) > 0) {
111: bytes += len;
112: #if defined(vax) || defined(pdp11) || defined(ns32000)
113: bufr.t_nbytes = htonl((long)len);
114: #else !vax and !pdp11 and !ns32000
115: bufr.t_nbytes = len;
116: #endif !vax and !pdp11 and !ns32000
117: DEBUG(8,"twrdata sending %d bytes\n",len);
118: len += sizeof(long);
119: alarm(MAXMSGTIME);
120: ret = twrblk((char *)&bufr, len, fn);
121: alarm(0);
122: if (ret != len)
123: return FAIL;
124: if (len != TBUFSIZE+sizeof(long))
125: break;
126: }
127: bufr.t_nbytes = 0;
128: len = sizeof(long);
129: alarm(MAXMSGTIME);
130: ret = twrblk((char *)&bufr, len, fn);
131: alarm(0);
132: if (ret != len)
133: return FAIL;
134: #ifdef USG
135: time(&t2.time);
136: t2.millitm = 0;
137: #else !USG
138: ftime(&t2);
139: #endif !USG
140: Now = t2;
141: t2.time -= t1.time;
142: mil = t2.millitm - t1.millitm;
143: if (mil < 0) {
144: --t2.time;
145: mil += 1000;
146: }
147: sprintf(text, "sent data %ld bytes %ld.%02d secs",
148: bytes, (long)t2.time, mil/10);
149: sysacct(bytes, t2.time);
150: DEBUG(1, "%s\n", text);
151: syslog(text);
152: return SUCCESS;
153: }
154:
155: trddata(fn, fp2)
156: FILE *fp2;
157: {
158: register int len, nread;
159: char bufr[TBUFSIZE];
160: struct timeb t1, t2;
161: int mil;
162: long bytes, Nbytes;
163:
164: if(setjmp(Failbuf))
165: return FAIL;
166: signal(SIGALRM, pkfail);
167: #ifdef USG
168: time(&t1.time);
169: t1.millitm = 0;
170: #else !USG
171: ftime(&t1);
172: #endif !USG
173: bytes = 0L;
174: for (;;) {
175: alarm(MAXMSGTIME);
176: len = trdblk((char *)&Nbytes,sizeof Nbytes,fn);
177: alarm(0);
178: if (len != sizeof Nbytes)
179: return FAIL;
180: #if defined(vax) || defined(pdp11) || defined(ns32000)
181: Nbytes = ntohl(Nbytes);
182: #endif vax or pdp11 or ns32000
183: DEBUG(8,"trddata expecting %ld bytes\n",Nbytes);
184: nread = Nbytes;
185: if (nread == 0)
186: break;
187: alarm(MAXMSGTIME);
188: len = trdblk(bufr, nread, fn);
189: alarm(0);
190: if (len < 0) {
191: return FAIL;
192: }
193: bytes += len;
194: DEBUG(11,"trddata got %ld\n",bytes);
195: if (write(fileno(fp2), bufr, len) != len) {
196: alarm(0);
197: return FAIL;
198: }
199: }
200: #ifdef USG
201: time(&t2.time);
202: t2.millitm = 0;
203: #else !USG
204: ftime(&t2);
205: #endif !USG
206: Now = t2;
207: t2.time -= t1.time;
208: mil = t2.millitm - t1.millitm;
209: if (mil < 0) {
210: --t2.time;
211: mil += 1000;
212: }
213: sprintf(bufr, "received data %ld bytes %ld.%02d secs",
214: bytes, (long)t2.time, mil/10);
215: sysacct(bytes, t2.time - t1.time);
216: DEBUG(1, "%s\n", bufr);
217: syslog(bufr);
218: return SUCCESS;
219: }
220:
221: #if !defined(BSD4_2) && !defined(USG)
222: #define TC 1024
223: static int tc = TC;
224: #endif !BSD4_2 && !USG
225:
226: trdblk(blk, len, fn)
227: register int len;
228: char *blk;
229: {
230: register int i, ret;
231:
232: #if !defined(BSD4_2) && !defined(USG)
233: /* call ultouch occasionally */
234: if (--tc < 0) {
235: tc = TC;
236: ultouch();
237: }
238: #endif !BSD4_2 && !USG
239: for (i = 0; i < len; i += ret) {
240: ret = read(fn, blk, len - i);
241: if (ret < 0)
242: return FAIL;
243: blk += ret;
244: if (ret == 0)
245: return i;
246: }
247: return i;
248: }
249:
250:
251: twrblk(blk, len, fn)
252: register char *blk;
253: {
254: #if !defined(BSD4_2) && !defined(USG)
255: /* call ultouch occasionally */
256: if (--tc < 0) {
257: tc = TC;
258: ultouch();
259: }
260: #endif !BSD4_2 && !USG
261: return write(fn, blk, len);
262: }
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.