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