![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to prote.c CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [MW Coherent from dump] / coherent / g / usr / lib / uucp / tay104|
Return to prote.c CVS log | Up to [MW Coherent from dump] / coherent / g / usr / lib / uucp / tay104 |
1.1 root 1: /* prote.c
2: The 'e' protocol.
3:
4: Copyright (C) 1991, 1992 Ian Lance Taylor
5:
6: This file is part of the Taylor UUCP package.
7:
8: This program is free software; you can redistribute it and/or
9: modify it under the terms of the GNU General Public License as
10: published by the Free Software Foundation; either version 2 of the
11: License, or (at your option) any later version.
12:
13: This program is distributed in the hope that it will be useful, but
14: WITHOUT ANY WARRANTY; without even the implied warranty of
15: MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
16: General Public License for more details.
17:
18: You should have received a copy of the GNU General Public License
19: along with this program; if not, write to the Free Software
20: Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
21:
22: The author of the program may be contacted at [email protected] or
23: c/o Infinity Development Systems, P.O. Box 520, Waltham, MA 02254.
24: */
25:
26: #include "uucp.h"
27:
28: #if USE_RCS_ID
29: const char prote_rcsid[] = "$Id: prote.c,v 1.1 93/07/30 07:53:17 bin Exp Locker: bin $";
30: #endif
31:
32: #include "uudefs.h"
33: #include "uuconf.h"
34: #include "conn.h"
35: #include "trans.h"
36: #include "system.h"
37: #include "prot.h"
38:
39: /* This implementation is based on my implementation of the 't'
40: protocol, which is fairly similar. The main difference between the
41: protocols seems to be that 't' breaks the file into packets and
42: transmits the size of the packet with each packet, whereas 'e'
43: sends the size of the entire file and then sends all the data in a
44: single enormous packet.
45:
46: The 'e' protocol does no error checking whatsoever and thus
47: requires an end-to-end verified eight bit communication line, such
48: as is provided by TCP. Using it with a modem is inadvisable, since
49: errors can occur between the modem and the computer. */
50:
51: /* The buffer size we use. */
52: #define CEBUFSIZE (CRECBUFLEN / 2)
53:
54: /* The size of the initial file size message. */
55: #define CEFRAMELEN (20)
56:
57: /* A pointer to the buffer we will use. */
58: static char *zEbuf;
59:
60: /* True if we are receiving a file. */
61: static boolean fEfile;
62:
63: /* The number of bytes we have left to send or receive. */
64: static long cEbytes;
65:
66: /* The timeout we use. */
67: static int cEtimeout = 120;
68:
69: struct uuconf_cmdtab asEproto_params[] =
70: {
71: { "timeout", UUCONF_CMDTABTYPE_INT, (pointer) &cEtimeout, NULL },
72: { NULL, 0, NULL, NULL }
73: };
74:
75: /* Local function. */
76:
77: static boolean feprocess_data P((struct sdaemon *qdaemon, boolean *pfexit,
78: size_t *pcneed));
79:
80: /* Start the protocol. */
81:
82: boolean
83: festart (qdaemon, pzlog)
84: struct sdaemon *qdaemon;
85: char **pzlog;
86: {
87: *pzlog = NULL;
88: if (! fconn_set (qdaemon->qconn, PARITYSETTING_NONE,
89: STRIPSETTING_EIGHTBITS, XONXOFF_OFF))
90: return FALSE;
91: zEbuf = (char *) xmalloc (CEBUFSIZE);
92: fEfile = FALSE;
93: usysdep_sleep (2);
94: return TRUE;
95: }
96:
97: /* Stop the protocol. */
98:
99: /*ARGSUSED*/
100: boolean
101: feshutdown (qdaemon)
102: struct sdaemon *qdaemon;
103: {
104: xfree ((pointer) zEbuf);
105: zEbuf = NULL;
106: cEtimeout = 120;
107: return TRUE;
108: }
109:
110: /* Send a command string. We send everything up to and including the
111: null byte. */
112:
113: /*ARGSUSED*/
114: boolean
115: fesendcmd (qdaemon, z, ilocal, iremote)
116: struct sdaemon *qdaemon;
117: const char *z;
118: int ilocal;
119: int iremote;
120: {
121: DEBUG_MESSAGE1 (DEBUG_UUCP_PROTO, "fesendcmd: Sending command \"%s\"", z);
122:
123: return fsend_data (qdaemon->qconn, z, strlen (z) + 1, TRUE);
124: }
125:
126: /* Get space to be filled with data. We provide a buffer which has
127: 20 bytes at the start available to hold the length. */
128:
129: /*ARGSUSED*/
130: char *
131: zegetspace (qdaemon, pclen)
132: struct sdaemon *qdaemon;
133: size_t *pclen;
134: {
135: *pclen = CEBUFSIZE;
136: return zEbuf;
137: }
138:
139: /* Send out some data. We are allowed to modify the 20 bytes
140: preceding the buffer. This allows us to send the entire block with
141: header bytes in a single call. */
142:
143: /*ARGSIGNORED*/
144: boolean
145: fesenddata (qdaemon, zdata, cdata, ilocal, iremote, ipos)
146: struct sdaemon *qdaemon;
147: char *zdata;
148: size_t cdata;
149: int ilocal;
150: int iremote;
151: long ipos;
152: {
153: #if DEBUG > 0
154: /* Keep track of the number of bytes we send out to make sure it all
155: adds up. */
156: cEbytes -= cdata;
157: if (cEbytes < 0)
158: {
159: ulog (LOG_ERROR, "Protocol 'e' internal error");
160: return FALSE;
161: }
162: #endif
163:
164: /* We pass FALSE to fsend_data since we don't expect the other side
165: to be sending us anything just now. */
166: return fsend_data (qdaemon->qconn, zdata, cdata, FALSE);
167: }
168:
169: /* Process data and return the amount we need in *pfneed. */
170:
171: static boolean
172: feprocess_data (qdaemon, pfexit, pcneed)
173: struct sdaemon *qdaemon;
174: boolean *pfexit;
175: size_t *pcneed;
176: {
177: int cinbuf, cfirst, clen;
178:
179: *pfexit = FALSE;
180:
181: cinbuf = iPrecend - iPrecstart;
182: if (cinbuf < 0)
183: cinbuf += CRECBUFLEN;
184:
185: if (! fEfile)
186: {
187: /* We are not receiving a file. Commands continue up to a null
188: byte. */
189: while (cinbuf > 0)
190: {
191: char *pnull;
192:
193: cfirst = CRECBUFLEN - iPrecstart;
194: if (cfirst > cinbuf)
195: cfirst = cinbuf;
196:
197: pnull = memchr (abPrecbuf + iPrecstart, '\0', (size_t) cfirst);
198: if (pnull != NULL)
199: cfirst = pnull - (abPrecbuf + iPrecstart) + 1;
200:
201: DEBUG_MESSAGE1 (DEBUG_PROTO,
202: "feprocess_data: Got %d command bytes",
203: cfirst);
204:
205: if (! fgot_data (qdaemon, abPrecbuf + iPrecstart,
206: (size_t) cfirst, (const char *) NULL, (size_t) 0,
207: -1, -1, (long) -1, TRUE, pfexit))
208: return FALSE;
209:
210: iPrecstart = (iPrecstart + cfirst) % CRECBUFLEN;
211:
212: if (*pfexit)
213: return TRUE;
214:
215: cinbuf = iPrecend - iPrecstart;
216: if (cinbuf < 0)
217: cinbuf += CRECBUFLEN;
218: }
219:
220: if (pcneed != NULL)
221: *pcneed = 1;
222:
223: return TRUE;
224: }
225:
226: /* Here we are receiving a file. We want cEbytes in total. If we
227: don't have cEbytes yet, we have to get it first. */
228:
229: if (cEbytes == -1)
230: {
231: char ab[CEFRAMELEN + 1];
232:
233: if (cinbuf < CEFRAMELEN)
234: {
235: if (pcneed != NULL)
236: *pcneed = CEFRAMELEN - cinbuf;
237: return TRUE;
238: }
239:
240: cfirst = CRECBUFLEN - iPrecstart;
241: if (cfirst >= CEFRAMELEN)
242: memcpy (ab, abPrecbuf + iPrecstart, (size_t) CEFRAMELEN);
243: else
244: {
245: memcpy (ab, abPrecbuf + iPrecstart, (size_t) cfirst);
246: memcpy (ab + cfirst, abPrecbuf, (size_t) CEFRAMELEN - cfirst);
247: }
248:
249: ab[CEFRAMELEN] = '\0';
250: cEbytes = strtol (ab, (char **) NULL, 10);
251:
252: iPrecstart = (iPrecstart + CEFRAMELEN) % CRECBUFLEN;
253:
254: cinbuf = iPrecend - iPrecstart;
255: if (cinbuf < 0)
256: cinbuf += CRECBUFLEN;
257: }
258:
259: /* Here we can read real data for the file. */
260:
261: while (cinbuf > 0)
262: {
263: clen = cinbuf;
264: if ((long) clen > cEbytes)
265: clen = (int) cEbytes;
266:
267: cfirst = CRECBUFLEN - iPrecstart;
268: if (cfirst > clen)
269: cfirst = clen;
270:
271: DEBUG_MESSAGE1 (DEBUG_PROTO,
272: "feprocess_data: Got %d data bytes",
273: clen);
274:
275: if (! fgot_data (qdaemon, abPrecbuf + iPrecstart,
276: (size_t) cfirst, abPrecbuf, (size_t) (clen - cfirst),
277: -1, -1, (long) -1, TRUE, pfexit))
278: return FALSE;
279:
280: iPrecstart = (iPrecstart + clen) % CRECBUFLEN;
281: cEbytes -= clen;
282:
283: if (cEbytes == 0)
284: {
285: if (! fgot_data (qdaemon, abPrecbuf, (size_t) 0,
286: (const char *) NULL, (size_t) 0,
287: -1, -1, (long) -1, TRUE, pfexit))
288: return FALSE;
289: if (*pfexit)
290: return TRUE;
291: }
292:
293: cinbuf -= clen;
294: }
295:
296: if (pcneed != NULL)
297: {
298: if (cEbytes > CRECBUFLEN / 2)
299: *pcneed = CRECBUFLEN / 2;
300: else
301: *pcneed = (int) cEbytes;
302: }
303:
304: return TRUE;
305: }
306:
307: /* Wait for data to come in and process it until we've reached the end
308: of a command or a file. */
309:
310: boolean
311: fewait (qdaemon)
312: struct sdaemon *qdaemon;
313: {
314: while (TRUE)
315: {
316: boolean fexit;
317: size_t cneed, crec;
318:
319: if (! feprocess_data (qdaemon, &fexit, &cneed))
320: return FALSE;
321: if (fexit)
322: return TRUE;
323:
324: if (! freceive_data (qdaemon->qconn, cneed, &crec, cEtimeout, TRUE))
325: return FALSE;
326:
327: if (crec == 0)
328: {
329: ulog (LOG_ERROR, "Timed out waiting for data");
330: return FALSE;
331: }
332: }
333: }
334:
335: /* File level routine, to handle transferring the amount of data and
336: to set fEfile correctly. */
337:
338: boolean
339: fefile (qdaemon, qtrans, fstart, fsend, cbytes, pfhandled)
340: struct sdaemon *qdaemon;
341: struct stransfer *qtrans;
342: boolean fstart;
343: boolean fsend;
344: long cbytes;
345: boolean *pfhandled;
346: {
347: *pfhandled = FALSE;
348:
349: if (fstart)
350: {
351: if (fsend)
352: {
353: char ab[CEFRAMELEN];
354:
355: DEBUG_MESSAGE1 (DEBUG_PROTO,
356: "Protocol 'e' starting to send %ld bytes",
357: cbytes);
358:
359: bzero (ab, (size_t) CEFRAMELEN);
360: sprintf (ab, "%ld", cbytes);
361: if (! fsend_data (qdaemon->qconn, ab, (size_t) CEFRAMELEN, TRUE))
362: return FALSE;
363: cEbytes = cbytes;
364: }
365: else
366: {
367: cEbytes = -1;
368: fEfile = TRUE;
369: }
370: }
371: else
372: {
373: if (! fsend)
374: fEfile = FALSE;
375: #if DEBUG > 0
376: if (cEbytes != 0)
377: {
378: ulog (LOG_ERROR,
379: "Protocol 'e' internal error: %ld bytes left over",
380: cEbytes);
381: return FALSE;
382: }
383: #endif
384: }
385:
386: return TRUE;
387: }
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.