![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to protj.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 protj.c CVS log | Up to [MW Coherent from dump] / coherent / g / usr / lib / uucp / tay104 |
1.1 root 1: /* protj.c
2: The 'j' protocol.
3:
4: Copyright (C) 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 protj_rcsid[] = "$Id: protj.c,v 1.1 93/07/30 07:53:35 bin Exp Locker: bin $";
30: #endif
31:
32: #include <ctype.h>
33: #include <errno.h>
34:
35: #include "uudefs.h"
36: #include "conn.h"
37: #include "trans.h"
38: #include "system.h"
39: #include "prot.h"
40:
41: /* The 'j' protocol.
42:
43: The 'j' protocol is a wrapper around the 'i' protocol, which avoids
44: the use of certain characters, such as XON and XOFF.
45:
46: Each 'j' protocol packet begins with a '^' character, followed by a
47: two byte encoded size giving the total number of bytes in the
48: packet. The first byte is HIGH, the second byte is LOW, and the
49: number of bytes is (HIGH - 32) * 64 + (LOW - 32), where 32 <= HIGH
50: < 127 and 32 <= LOW < 96 (i.e., HIGH and LOW are printable ASCII
51: characters). This is followed by a '=' character. The next two
52: bytes are the number of data bytes in the packet, using the same
53: encoding. This is followed by a '@' character, and then that
54: number of data bytes. The remaining bytes in the packet are
55: indices of bytes which must be transformed, followed by a trailing
56: '~' character. The indices are encoded in the following overly
57: complex format.
58:
59: Each byte index is two bytes long. The first byte in the index is
60: INDEX-HIGH and the second is INDEX-LOW. If 32 <= INDEX-HIGH < 126,
61: the byte index refers to the byte at position (INDEX-HIGH - 32) *
62: 32 + INDEX-LOW % 32 in the actual data, where 32 <= INDEX-LOW <
63: 127. If 32 <= INDEX-LOW < 64, then 128 must be added to the
64: indexed byte. If 64 <= INDEX-LOW < 96, then the indexed byte must
65: be exclusive or'red with 32. If 96 <= INDEX-LOW < 127, both
66: operations must be performed. If INDEX-HIGH == 126, then the byte
67: index refers to the byte at position (INDEX-LOW - 32) * 32 + 31,
68: where 32 <= INDEX-LOW < 126. 128 must be added to the byte, and it
69: must be exclusive or'red with 32. This unfortunately requires a
70: special test (when encoding INDEX-LOW must be checked for 127; when
71: decoding INDEX-HIGH must be checked for 126). It does, however,
72: permit the byte indices field to consist exclusively of printable
73: ASCII characters.
74:
75: The maximum value for a byte index is (125 - 32) * 32 + 31 == 3007,
76: so the is the maximum number of data bytes permitted. Since it is
77: convenient to have each 'j' protocol packet correspond to each 'i'
78: protocol packet, we restrict the 'i' protocol accordingly.
79:
80: Note that this encoding method assumes that we can send all
81: printable ASCII characters. */
82:
83: /* The first byte of each packet. I just picked these values
84: randomly, trying to get characters that were perhaps slightly less
85: likely to appear in normal text. */
86: #define FIRST '\136'
87:
88: /* The fourth byte of each packet. */
89: #define FOURTH '\075'
90:
91: /* The seventh byte of each packet. */
92: #define SEVENTH '\100'
93:
94: /* The trailing byte of each packet. */
95: #define TRAILER '\176'
96:
97: /* The length of the header. */
98: #define CHDRLEN (7)
99:
100: /* Get a number of bytes encoded in a two byte length at the start of
101: a packet. */
102: #define CGETLENGTH(b1, b2) (((b1) - 32) * 64 + ((b2) - 32))
103:
104: /* Set the high and low bytes of a two byte length at the start of a
105: packet. */
106: #define ISETLENGTH_FIRST(i) ((i) / 64 + 32)
107: #define ISETLENGTH_SECOND(i) ((i) % 64 + 32)
108:
109: /* The maximum packet size we support, as determined by the byte
110: indices. */
111: #define IMAXPACKSIZE ((125 - 32) * 32 + 31)
112:
113: /* Amount to offset the bytes in the byte index by. */
114: #define INDEX_OFFSET (32)
115:
116: /* Maximum value of INDEX-LOW, before offsetting. */
117: #define INDEX_MAX_LOW (32)
118:
119: /* Maximum value of INDEX-HIGH, before offsetting. */
120: #define INDEX_MAX_HIGH (94)
121:
122: /* The set of characters to avoid. */
123: static char *zJavoid;
124:
125: /* The number of characters to avoid. */
126: static size_t cJavoid;
127:
128: /* A buffer used when sending data. */
129: static char *zJbuf;
130:
131: /* The end of the undecoded data in abPrecbuf. */
132: static int iJrecend;
133:
134: /* Local functions. */
135: static boolean fjsend_data P((struct sconnection *qconn, const char *zsend,
136: size_t csend, boolean fdoread));
137: static boolean fjreceive_data P((struct sconnection *qconn, size_t cneed,
138: size_t *pcrec, int ctimeout,
139: boolean freport));
140: static boolean fjprocess_data P((size_t *pcneed));
141:
142: /* Start the protocol. We first send over the list of characters to
143: avoid as an escape sequence, starting with FIRST and ending with
144: TRAILER. There is no error checking done on this string. */
145:
146: boolean
147: fjstart (qdaemon, pzlog)
148: struct sdaemon *qdaemon;
149: char **pzlog;
150: {
151: size_t clen;
152: char *zsend;
153: int b;
154: size_t cbuf, cgot;
155: char *zbuf;
156: int i;
157:
158: /* Send the characters we want to avoid to the other side. */
159: clen = strlen (zJavoid_parameter);
160: zsend = zbufalc (clen + 3);
161: zsend[0] = FIRST;
162: memcpy (zsend + 1, zJavoid_parameter, clen);
163: zsend[clen + 1] = TRAILER;
164: zsend[clen + 2] = '\0';
165: if (! fsend_data (qdaemon->qconn, zsend, clen + 2, TRUE))
166: {
167: ubuffree (zsend);
168: return FALSE;
169: }
170: ubuffree (zsend);
171:
172: /* Read the characters the other side wants to avoid. */
173: while ((b = breceive_char (qdaemon->qconn, cIsync_timeout, TRUE))
174: != FIRST)
175: {
176: if (b < 0)
177: {
178: if (b == -1)
179: ulog (LOG_ERROR, "Timed out in 'j' protocol startup");
180: return FALSE;
181: }
182: }
183:
184: cbuf = 20;
185: zbuf = zbufalc (cbuf);
186: cgot = 0;
187: while ((b = breceive_char (qdaemon->qconn, cIsync_timeout, TRUE))
188: != TRAILER)
189: {
190: if (b < 0)
191: {
192: ubuffree (zbuf);
193: if (b == -1)
194: ulog (LOG_ERROR, "Timed out in 'j' protocol startup");
195: return FALSE;
196: }
197: if (cgot + 1 >= cbuf)
198: {
199: char *znew;
200:
201: cbuf += 20;
202: znew = zbufalc (cbuf);
203: memcpy (znew, zbuf, cgot);
204: ubuffree (zbuf);
205: zbuf = znew;
206: }
207: zbuf[cgot] = b;
208: ++cgot;
209: }
210: zbuf[cgot] = '\0';
211:
212: /* Merge the local and remote avoid bytes into one list, translated
213: into bytes. */
214: cgot = cescape (zbuf);
215:
216: clen = strlen (zJavoid_parameter);
217: zJavoid = zbufalc (clen + cgot + 1);
218: memcpy (zJavoid, zJavoid_parameter, clen + 1);
219: cJavoid = cescape (zJavoid);
220:
221: for (i = 0; i < cgot; i++)
222: {
223: if (memchr (zJavoid, zbuf[i], cJavoid) == NULL)
224: {
225: zJavoid[cJavoid] = zbuf[i];
226: ++cJavoid;
227: }
228: }
229:
230: ubuffree (zbuf);
231:
232: /* We can't avoid ASCII printable characters, since the encoding
233: method assumes that they can always be sent. If it ever turns
234: out to be important, a different encoding method could be used,
235: perhaps keyed by a different FIRST character. */
236: if (cJavoid == 0)
237: {
238: ulog (LOG_ERROR, "No characters to avoid in 'j' protocol");
239: return FALSE;
240: }
241: for (i = 0; i < cJavoid; i++)
242: {
243: if (zJavoid[i] >= 32 && zJavoid[i] <= 126)
244: {
245: ulog (LOG_ERROR, "'j' protocol can't avoid character '\\%03o'",
246: zJavoid[i]);
247: return FALSE;
248: }
249: }
250:
251: /* If we are avoiding XON and XOFF, use XON/XOFF handshaking. */
252: if (memchr (zJavoid, '\021', cJavoid) != NULL
253: && memchr (zJavoid, '\023', cJavoid) != NULL)
254: {
255: if (! fconn_set (qdaemon->qconn, PARITYSETTING_NONE,
256: STRIPSETTING_EIGHTBITS, XONXOFF_ON))
257: return FALSE;
258: }
259:
260: /* Let the port settle. */
261: usysdep_sleep (2);
262:
263: /* Allocate a buffer we use when sending data. We will probably
264: never actually need one this big; if this code is ported to a
265: computer with small amounts of memory, this should be changed to
266: increase the buffer size as needed. */
267: zJbuf = zbufalc (CHDRLEN + IMAXPACKSIZE * 3 + 1);
268: zJbuf[0] = FIRST;
269: zJbuf[3] = FOURTH;
270: zJbuf[6] = SEVENTH;
271:
272: /* iJrecend is the end of the undecoded data, and iPrecend is the
273: end of the decoded data. At this point there is no decoded data,
274: and we must initialize the variables accordingly. */
275: iJrecend = iPrecend;
276: iPrecend = iPrecstart;
277:
278: /* Now do the 'i' protocol startup. */
279: return fijstart (qdaemon, pzlog, IMAXPACKSIZE, fjsend_data,
280: fjreceive_data);
281: }
282:
283: /* Shut down the protocol. */
284:
285: boolean
286: fjshutdown (qdaemon)
287: struct sdaemon *qdaemon;
288: {
289: boolean fret;
290:
291: fret = fishutdown (qdaemon);
292: ubuffree (zJavoid);
293: ubuffree (zJbuf);
294: return fret;
295: }
296:
297: /* Encode a packet of data and send it. This copies the data, which
298: is a waste of time, but calling fsend_data three times (for the
299: header, the body, and the trailer) would waste even more time. */
300:
301: static boolean
302: fjsend_data (qconn, zsend, csend, fdoread)
303: struct sconnection *qconn;
304: const char *zsend;
305: size_t csend;
306: boolean fdoread;
307: {
308: char *zput, *zindex;
309: const char *zfrom, *zend;
310: char bfirst, bsecond;
311: int iprecendhold;
312: boolean fret;
313:
314: zput = zJbuf + CHDRLEN;
315: zindex = zput + csend;
316: zfrom = zsend;
317: zend = zsend + csend;
318:
319: /* Optimize for the common case of avoiding two characters. */
320: bfirst = zJavoid[0];
321: if (cJavoid <= 1)
322: bsecond = bfirst;
323: else
324: bsecond = zJavoid[1];
325: while (zfrom < zend)
326: {
327: char b;
328: boolean f128, f32;
329: int i, ihigh, ilow;
330:
331: b = *zfrom++;
332: if (b != bfirst && b != bsecond)
333: {
334: int ca;
335: char *za;
336:
337: if (cJavoid <= 2)
338: {
339: *zput++ = b;
340: continue;
341: }
342:
343: ca = cJavoid - 2;
344: za = zJavoid + 2;
345: while (ca-- != 0)
346: if (*za++ == b)
347: break;
348:
349: if (ca < 0)
350: {
351: *zput++ = b;
352: continue;
353: }
354: }
355:
356: if ((b & 0x80) == 0)
357: f128 = FALSE;
358: else
359: {
360: b &=~ 0x80;
361: f128 = TRUE;
362: }
363: if (b >= 32 && b != 127)
364: f32 = FALSE;
365: else
366: {
367: b ^= 0x20;
368: f32 = TRUE;
369: }
370:
371: /* We must now put the byte index into the buffer. The byte
372: index is encoded similarly to the length of the actual data,
373: but the byte index also encodes the operations that must be
374: performed on the byte. The first byte in the index is the
375: most significant bits. If we only had to subtract 128 from
376: the byte, we use the second byte directly. If we had to xor
377: the byte with 32, we add 32 to the second byte index. If we
378: had to perform both operations, we add 64 to the second byte
379: index. However, if we had to perform both operations, and
380: the second byte index was 31, then after adding 64 and
381: offsetting by 32 we would come up with 127, which we are not
382: permitted to use. Therefore, in this special case we set the
383: first byte of the index to 126 and put the original first
384: byte into the second byte position instead. This is why we
385: could not permit the high byte of the length of the actual
386: data to be 126. We can get away with the switch because both
387: the value of the second byte index (31) and the operations to
388: perform (both) are known. */
389: i = zput - (zJbuf + CHDRLEN);
390: ihigh = i / INDEX_MAX_LOW;
391: ilow = i % INDEX_MAX_LOW;
392:
393: if (f128 && ! f32)
394: ;
395: else if (f32 && ! f128)
396: ilow += INDEX_MAX_LOW;
397: else
398: {
399: /* Both operations had to be performed. */
400: if (ilow != INDEX_MAX_LOW - 1)
401: ilow += 2 * INDEX_MAX_LOW;
402: else
403: {
404: ilow = ihigh;
405: ihigh = INDEX_MAX_HIGH;
406: }
407: }
408:
409: *zindex++ = ihigh + INDEX_OFFSET;
410: *zindex++ = ilow + INDEX_OFFSET;
411: *zput++ = b;
412: }
413:
414: *zindex++ = TRAILER;
415:
416: /* Set the lengths into the buffer. zJbuf[0,3,6] were set when
417: zJbuf was allocated, and are never changed thereafter. */
418: zJbuf[1] = ISETLENGTH_FIRST (zindex - zJbuf);
419: zJbuf[2] = ISETLENGTH_SECOND (zindex - zJbuf);
420: zJbuf[4] = ISETLENGTH_FIRST (csend);
421: zJbuf[5] = ISETLENGTH_SECOND (csend);
422:
423: /* Send the data over the line. We must preserve iPrecend as
424: discussed in fjreceive_data. */
425: iprecendhold = iPrecend;
426: iPrecend = iJrecend;
427: fret = fsend_data (qconn, zJbuf, (size_t) (zindex - zJbuf), fdoread);
428: iJrecend = iPrecend;
429: iPrecend = iprecendhold;
430:
431: /* Process any bytes that may have been placed in abPrecbuf. */
432: if (fret && iPrecend != iJrecend)
433: {
434: if (! fjprocess_data ((size_t *) NULL))
435: return FALSE;
436: }
437:
438: return fret;
439: }
440:
441: /* Receive and decode data. This is called by fiwait_for_packet. We
442: need to be able to return decoded data between iPrecstart and
443: iPrecend, while not losing any undecoded partial packets we may
444: have read. We use iJrecend as a pointer to the end of the
445: undecoded data, and set iPrecend for the decoded data. iPrecend
446: points to the start of the undecoded data. */
447:
448: static boolean
449: fjreceive_data (qconn, cineed, pcrec, ctimeout, freport)
450: struct sconnection *qconn;
451: size_t cineed;
452: size_t *pcrec;
453: int ctimeout;
454: boolean freport;
455: {
456: int iprecendstart;
457: size_t cjneed;
458: size_t crec;
459: int cnew;
460:
461: iprecendstart = iPrecend;
462:
463: /* Figure out how many bytes we need to decode the next packet. */
464: if (! fjprocess_data (&cjneed))
465: return FALSE;
466:
467: /* As we long as we read some data but don't have enough to decode a
468: packet, we try to read some more. We decrease the timeout each
469: time so that we will not wait forever if the connection starts
470: dribbling data. */
471: do
472: {
473: int iprecendhold;
474: size_t cneed;
475:
476: if (cjneed > cineed)
477: cneed = cjneed;
478: else
479: cneed = cineed;
480:
481: /* We are setting iPrecend to the end of the decoded data for
482: the 'i' protocol. When we do the actual read, we have to set
483: it to the end of the undecoded data so that any undecoded
484: data we have received is not overwritten. */
485: iprecendhold = iPrecend;
486: iPrecend = iJrecend;
487: if (! freceive_data (qconn, cneed, &crec, ctimeout, freport))
488: return FALSE;
489: iJrecend = iPrecend;
490: iPrecend = iprecendhold;
491:
492: /* Process any data we have received. This will set iPrecend to
493: the end of the new decoded data. */
494: if (! fjprocess_data (&cjneed))
495: return FALSE;
496:
497: cnew = iPrecend - iprecendstart;
498: if (cnew < 0)
499: cnew += CRECBUFLEN;
500:
501: if (cnew > cineed)
502: cineed = 0;
503: else
504: cineed -= cnew;
505:
506: --ctimeout;
507: }
508: while (cnew == 0 && crec > 0 && ctimeout > 0);
509:
510: DEBUG_MESSAGE1 (DEBUG_PROTO, "fjreceive_data: Got %d decoded bytes",
511: cnew);
512:
513: *pcrec = cnew;
514: return TRUE;
515: }
516:
517: /* Decode the data in the buffer, optionally returning the number of
518: bytes needed to complete the next packet. */
519:
520: static boolean
521: fjprocess_data (pcneed)
522: size_t *pcneed;
523: {
524: int istart;
525:
526: istart = iPrecend;
527: while (istart != iJrecend)
528: {
529: int i, iget;
530: char ab[CHDRLEN];
531: int cpacket, cdata, chave;
532: int iindex, iendindex;
533:
534: /* Find the next occurrence of FIRST. If we have to skip some
535: garbage bytes to get to it, zero them out (so they don't
536: confuse the 'i' protocol) and advance iPrecend. This will
537: save us from looking at them again. */
538: if (abPrecbuf[istart] != FIRST)
539: {
540: int cintro;
541: char *zintro;
542: size_t cskipped;
543:
544: cintro = iJrecend - istart;
545: if (cintro < 0)
546: cintro = CRECBUFLEN - istart;
547:
548: zintro = memchr (abPrecbuf + istart, FIRST, (size_t) cintro);
549: if (zintro == NULL)
550: {
551: bzero (abPrecbuf + istart, (size_t) cintro);
552: istart = (istart + cintro) % CRECBUFLEN;
553: iPrecend = istart;
554: continue;
555: }
556:
557: cskipped = zintro - (abPrecbuf + istart);
558: bzero (abPrecbuf + istart, cskipped);
559: istart += cskipped;
560: iPrecend = istart;
561: }
562:
563: for (i = 0, iget = istart;
564: i < CHDRLEN && iget != iJrecend;
565: ++i, iget = (iget + 1) % CRECBUFLEN)
566: ab[i] = abPrecbuf[iget];
567:
568: if (i < CHDRLEN)
569: {
570: if (pcneed != NULL)
571: *pcneed = CHDRLEN - i;
572: return TRUE;
573: }
574:
575: cpacket = CGETLENGTH (ab[1], ab[2]);
576: cdata = CGETLENGTH (ab[4], ab[5]);
577:
578: /* Make sure the header has the right magic characters, that the
579: data is not larger than the packet, and that we have an even
580: number of byte index characters. */
581: if (ab[3] != FOURTH
582: || ab[6] != SEVENTH
583: || cdata > cpacket - CHDRLEN - 1
584: || (cpacket - cdata - CHDRLEN - 1) % 2 == 1)
585: {
586: istart = (istart + 1) % CRECBUFLEN;
587: continue;
588: }
589:
590: chave = iJrecend - istart;
591: if (chave < 0)
592: chave += CRECBUFLEN;
593:
594: if (chave < cpacket)
595: {
596: if (pcneed != NULL)
597: *pcneed = cpacket - chave;
598: return TRUE;
599: }
600:
601: /* Figure out where the byte indices start and end. */
602: iindex = (istart + CHDRLEN + cdata) % CRECBUFLEN;
603: iendindex = (istart + cpacket - 1) % CRECBUFLEN;
604:
605: /* Make sure the magic trailer character is there. */
606: if (abPrecbuf[iendindex] != TRAILER)
607: {
608: istart = (istart + 1) % CRECBUFLEN;
609: continue;
610: }
611:
612: /* We have a packet to decode. The decoding process is simpler
613: than the encoding process, since all we have to do is examine
614: the byte indices. We zero out the byte indices as we go, so
615: that they will not confuse the 'i' protocol. */
616: while (iindex != iendindex)
617: {
618: int ihigh, ilow;
619: boolean f32, f128;
620: int iset;
621:
622: ihigh = abPrecbuf[iindex] - INDEX_OFFSET;
623: abPrecbuf[iindex] = 0;
624: iindex = (iindex + 1) % CRECBUFLEN;
625: ilow = abPrecbuf[iindex] - INDEX_OFFSET;
626: abPrecbuf[iindex] = 0;
627: iindex = (iindex + 1) % CRECBUFLEN;
628:
629: /* Now we must undo the encoding, by adding 128 and xoring
630: with 32 as appropriate. Which to do is encoded in the
631: low byte, except that if the high byte is the special
632: value 126, then the low byte is actually the high byte
633: and both operations are performed. */
634: f128 = TRUE;
635: f32 = TRUE;
636: if (ihigh == INDEX_MAX_HIGH)
637: iset = ilow * INDEX_MAX_LOW + INDEX_MAX_LOW - 1;
638: else
639: {
640: iset = ihigh * INDEX_MAX_LOW + ilow % INDEX_MAX_LOW;
641: if (ilow < INDEX_MAX_LOW)
642: f32 = FALSE;
643: else if (ilow < 2 * INDEX_MAX_LOW)
644: f128 = FALSE;
645: }
646:
647: /* Now iset is the index from the start of the data to the
648: byte to modify; adjust it to an index in abPrecbuf. */
649: iset = (istart + CHDRLEN + iset) % CRECBUFLEN;
650:
651: if (f128)
652: abPrecbuf[iset] |= 0x80;
653: if (f32)
654: abPrecbuf[iset] ^= 0x20;
655: }
656:
657: /* Zero out the header and trailer to avoid confusing the 'i'
658: protocol, and update iPrecend to the end of decoded data. */
659: for (i = 0, iget = istart;
660: i < CHDRLEN && iget != iJrecend;
661: ++i, iget = (iget + 1) % CRECBUFLEN)
662: abPrecbuf[iget] = 0;
663: abPrecbuf[iendindex] = 0;
664: iPrecend = (iendindex + 1) % CRECBUFLEN;
665: istart = iPrecend;
666: }
667:
668: if (pcneed != NULL)
669: *pcneed = CHDRLEN + 1;
670: return TRUE;
671: }
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.