673 lines
19 KiB
C
673 lines
19 KiB
C
/* protj.c
|
||
The 'j' protocol.
|
||
|
||
Copyright (C) 1992, 1994 Ian Lance Taylor
|
||
|
||
This file is part of the Taylor UUCP package.
|
||
|
||
This program is free software; you can redistribute it and/or
|
||
modify it under the terms of the GNU General Public License as
|
||
published by the Free Software Foundation; either version 2 of the
|
||
License, or (at your option) any later version.
|
||
|
||
This program is distributed in the hope that it will be useful, but
|
||
WITHOUT ANY WARRANTY; without even the implied warranty of
|
||
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
|
||
General Public License for more details.
|
||
|
||
You should have received a copy of the GNU General Public License
|
||
along with this program; if not, write to the Free Software
|
||
Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
|
||
|
||
The author of the program may be contacted at ian@airs.com or
|
||
c/o Cygnus Support, 48 Grove Street, Somerville, MA 02144.
|
||
*/
|
||
|
||
#include "uucp.h"
|
||
|
||
#if USE_RCS_ID
|
||
const char protj_rcsid[] = "$Id$";
|
||
#endif
|
||
|
||
#include <ctype.h>
|
||
#include <errno.h>
|
||
|
||
#include "uudefs.h"
|
||
#include "uuconf.h"
|
||
#include "conn.h"
|
||
#include "trans.h"
|
||
#include "system.h"
|
||
#include "prot.h"
|
||
|
||
/* The 'j' protocol.
|
||
|
||
The 'j' protocol is a wrapper around the 'i' protocol, which avoids
|
||
the use of certain characters, such as XON and XOFF.
|
||
|
||
Each 'j' protocol packet begins with a '^' character, followed by a
|
||
two byte encoded size giving the total number of bytes in the
|
||
packet. The first byte is HIGH, the second byte is LOW, and the
|
||
number of bytes is (HIGH - 32) * 64 + (LOW - 32), where 32 <= HIGH
|
||
< 127 and 32 <= LOW < 96 (i.e., HIGH and LOW are printable ASCII
|
||
characters). This is followed by a '=' character. The next two
|
||
bytes are the number of data bytes in the packet, using the same
|
||
encoding. This is followed by a '@' character, and then that
|
||
number of data bytes. The remaining bytes in the packet are
|
||
indices of bytes which must be transformed, followed by a trailing
|
||
'~' character. The indices are encoded in the following overly
|
||
complex format.
|
||
|
||
Each byte index is two bytes long. The first byte in the index is
|
||
INDEX-HIGH and the second is INDEX-LOW. If 32 <= INDEX-HIGH < 126,
|
||
the byte index refers to the byte at position (INDEX-HIGH - 32) *
|
||
32 + INDEX-LOW % 32 in the actual data, where 32 <= INDEX-LOW <
|
||
127. If 32 <= INDEX-LOW < 64, then 128 must be added to the
|
||
indexed byte. If 64 <= INDEX-LOW < 96, then the indexed byte must
|
||
be exclusive or'red with 32. If 96 <= INDEX-LOW < 127, both
|
||
operations must be performed. If INDEX-HIGH == 126, then the byte
|
||
index refers to the byte at position (INDEX-LOW - 32) * 32 + 31,
|
||
where 32 <= INDEX-LOW < 126. 128 must be added to the byte, and it
|
||
must be exclusive or'red with 32. This unfortunately requires a
|
||
special test (when encoding INDEX-LOW must be checked for 127; when
|
||
decoding INDEX-HIGH must be checked for 126). It does, however,
|
||
permit the byte indices field to consist exclusively of printable
|
||
ASCII characters.
|
||
|
||
The maximum value for a byte index is (125 - 32) * 32 + 31 == 3007,
|
||
so the is the maximum number of data bytes permitted. Since it is
|
||
convenient to have each 'j' protocol packet correspond to each 'i'
|
||
protocol packet, we restrict the 'i' protocol accordingly.
|
||
|
||
Note that this encoding method assumes that we can send all
|
||
printable ASCII characters. */
|
||
|
||
/* The first byte of each packet. I just picked these values
|
||
randomly, trying to get characters that were perhaps slightly less
|
||
likely to appear in normal text. */
|
||
#define FIRST '\136'
|
||
|
||
/* The fourth byte of each packet. */
|
||
#define FOURTH '\075'
|
||
|
||
/* The seventh byte of each packet. */
|
||
#define SEVENTH '\100'
|
||
|
||
/* The trailing byte of each packet. */
|
||
#define TRAILER '\176'
|
||
|
||
/* The length of the header. */
|
||
#define CHDRLEN (7)
|
||
|
||
/* Get a number of bytes encoded in a two byte length at the start of
|
||
a packet. */
|
||
#define CGETLENGTH(b1, b2) (((b1) - 32) * 64 + ((b2) - 32))
|
||
|
||
/* Set the high and low bytes of a two byte length at the start of a
|
||
packet. */
|
||
#define ISETLENGTH_FIRST(i) ((i) / 64 + 32)
|
||
#define ISETLENGTH_SECOND(i) ((i) % 64 + 32)
|
||
|
||
/* The maximum packet size we support, as determined by the byte
|
||
indices. */
|
||
#define IMAXPACKSIZE ((125 - 32) * 32 + 31)
|
||
|
||
/* Amount to offset the bytes in the byte index by. */
|
||
#define INDEX_OFFSET (32)
|
||
|
||
/* Maximum value of INDEX-LOW, before offsetting. */
|
||
#define INDEX_MAX_LOW (32)
|
||
|
||
/* Maximum value of INDEX-HIGH, before offsetting. */
|
||
#define INDEX_MAX_HIGH (94)
|
||
|
||
/* The set of characters to avoid. */
|
||
static char *zJavoid;
|
||
|
||
/* The number of characters to avoid. */
|
||
static size_t cJavoid;
|
||
|
||
/* A buffer used when sending data. */
|
||
static char *zJbuf;
|
||
|
||
/* The end of the undecoded data in abPrecbuf. */
|
||
static int iJrecend;
|
||
|
||
/* Local functions. */
|
||
static boolean fjsend_data P((struct sconnection *qconn, const char *zsend,
|
||
size_t csend, boolean fdoread));
|
||
static boolean fjreceive_data P((struct sconnection *qconn, size_t cneed,
|
||
size_t *pcrec, int ctimeout,
|
||
boolean freport));
|
||
static boolean fjprocess_data P((size_t *pcneed));
|
||
|
||
/* Start the protocol. We first send over the list of characters to
|
||
avoid as an escape sequence, starting with FIRST and ending with
|
||
TRAILER. There is no error checking done on this string. */
|
||
|
||
boolean
|
||
fjstart (qdaemon, pzlog)
|
||
struct sdaemon *qdaemon;
|
||
char **pzlog;
|
||
{
|
||
size_t clen;
|
||
char *zsend;
|
||
int b;
|
||
size_t cbuf, cgot;
|
||
char *zbuf;
|
||
int i;
|
||
|
||
/* Send the characters we want to avoid to the other side. */
|
||
clen = strlen (zJavoid_parameter);
|
||
zsend = zbufalc (clen + 3);
|
||
zsend[0] = FIRST;
|
||
memcpy (zsend + 1, zJavoid_parameter, clen);
|
||
zsend[clen + 1] = TRAILER;
|
||
zsend[clen + 2] = '\0';
|
||
if (! fsend_data (qdaemon->qconn, zsend, clen + 2, TRUE))
|
||
{
|
||
ubuffree (zsend);
|
||
return FALSE;
|
||
}
|
||
ubuffree (zsend);
|
||
|
||
/* Read the characters the other side wants to avoid. */
|
||
while ((b = breceive_char (qdaemon->qconn, cIsync_timeout, TRUE))
|
||
!= FIRST)
|
||
{
|
||
if (b < 0)
|
||
{
|
||
if (b == -1)
|
||
ulog (LOG_ERROR, "Timed out in 'j' protocol startup");
|
||
return FALSE;
|
||
}
|
||
}
|
||
|
||
cbuf = 20;
|
||
zbuf = zbufalc (cbuf);
|
||
cgot = 0;
|
||
while ((b = breceive_char (qdaemon->qconn, cIsync_timeout, TRUE))
|
||
!= TRAILER)
|
||
{
|
||
if (b < 0)
|
||
{
|
||
ubuffree (zbuf);
|
||
if (b == -1)
|
||
ulog (LOG_ERROR, "Timed out in 'j' protocol startup");
|
||
return FALSE;
|
||
}
|
||
if (cgot + 1 >= cbuf)
|
||
{
|
||
char *znew;
|
||
|
||
cbuf += 20;
|
||
znew = zbufalc (cbuf);
|
||
memcpy (znew, zbuf, cgot);
|
||
ubuffree (zbuf);
|
||
zbuf = znew;
|
||
}
|
||
zbuf[cgot] = b;
|
||
++cgot;
|
||
}
|
||
zbuf[cgot] = '\0';
|
||
|
||
/* Merge the local and remote avoid bytes into one list, translated
|
||
into bytes. */
|
||
cgot = cescape (zbuf);
|
||
|
||
clen = strlen (zJavoid_parameter);
|
||
zJavoid = zbufalc (clen + cgot + 1);
|
||
memcpy (zJavoid, zJavoid_parameter, clen + 1);
|
||
cJavoid = cescape (zJavoid);
|
||
|
||
for (i = 0; i < cgot; i++)
|
||
{
|
||
if (memchr (zJavoid, zbuf[i], cJavoid) == NULL)
|
||
{
|
||
zJavoid[cJavoid] = zbuf[i];
|
||
++cJavoid;
|
||
}
|
||
}
|
||
|
||
ubuffree (zbuf);
|
||
|
||
/* We can't avoid ASCII printable characters, since the encoding
|
||
method assumes that they can always be sent. If it ever turns
|
||
out to be important, a different encoding method could be used,
|
||
perhaps keyed by a different FIRST character. */
|
||
if (cJavoid == 0)
|
||
{
|
||
ulog (LOG_ERROR, "No characters to avoid in 'j' protocol");
|
||
return FALSE;
|
||
}
|
||
for (i = 0; i < cJavoid; i++)
|
||
{
|
||
if (zJavoid[i] >= 32 && zJavoid[i] <= 126)
|
||
{
|
||
ulog (LOG_ERROR, "'j' protocol can't avoid character '\\%03o'",
|
||
zJavoid[i]);
|
||
return FALSE;
|
||
}
|
||
}
|
||
|
||
/* If we are avoiding XON and XOFF, use XON/XOFF handshaking. */
|
||
if (memchr (zJavoid, '\021', cJavoid) != NULL
|
||
&& memchr (zJavoid, '\023', cJavoid) != NULL)
|
||
{
|
||
if (! fconn_set (qdaemon->qconn, PARITYSETTING_NONE,
|
||
STRIPSETTING_EIGHTBITS, XONXOFF_ON))
|
||
return FALSE;
|
||
}
|
||
|
||
/* Let the port settle. */
|
||
usysdep_sleep (2);
|
||
|
||
/* Allocate a buffer we use when sending data. We will probably
|
||
never actually need one this big; if this code is ported to a
|
||
computer with small amounts of memory, this should be changed to
|
||
increase the buffer size as needed. */
|
||
zJbuf = zbufalc (CHDRLEN + IMAXPACKSIZE * 3 + 1);
|
||
zJbuf[0] = FIRST;
|
||
zJbuf[3] = FOURTH;
|
||
zJbuf[6] = SEVENTH;
|
||
|
||
/* iJrecend is the end of the undecoded data, and iPrecend is the
|
||
end of the decoded data. At this point there is no decoded data,
|
||
and we must initialize the variables accordingly. */
|
||
iJrecend = iPrecend;
|
||
iPrecend = iPrecstart;
|
||
|
||
/* Now do the 'i' protocol startup. */
|
||
return fijstart (qdaemon, pzlog, IMAXPACKSIZE, fjsend_data,
|
||
fjreceive_data);
|
||
}
|
||
|
||
/* Shut down the protocol. */
|
||
|
||
boolean
|
||
fjshutdown (qdaemon)
|
||
struct sdaemon *qdaemon;
|
||
{
|
||
boolean fret;
|
||
|
||
fret = fishutdown (qdaemon);
|
||
ubuffree (zJavoid);
|
||
ubuffree (zJbuf);
|
||
return fret;
|
||
}
|
||
|
||
/* Encode a packet of data and send it. This copies the data, which
|
||
is a waste of time, but calling fsend_data three times (for the
|
||
header, the body, and the trailer) would waste even more time. */
|
||
|
||
static boolean
|
||
fjsend_data (qconn, zsend, csend, fdoread)
|
||
struct sconnection *qconn;
|
||
const char *zsend;
|
||
size_t csend;
|
||
boolean fdoread;
|
||
{
|
||
char *zput, *zindex;
|
||
const char *zfrom, *zend;
|
||
char bfirst, bsecond;
|
||
int iprecendhold;
|
||
boolean fret;
|
||
|
||
zput = zJbuf + CHDRLEN;
|
||
zindex = zput + csend;
|
||
zfrom = zsend;
|
||
zend = zsend + csend;
|
||
|
||
/* Optimize for the common case of avoiding two characters. */
|
||
bfirst = zJavoid[0];
|
||
if (cJavoid <= 1)
|
||
bsecond = bfirst;
|
||
else
|
||
bsecond = zJavoid[1];
|
||
while (zfrom < zend)
|
||
{
|
||
char b;
|
||
boolean f128, f32;
|
||
int i, ihigh, ilow;
|
||
|
||
b = *zfrom++;
|
||
if (b != bfirst && b != bsecond)
|
||
{
|
||
int ca;
|
||
char *za;
|
||
|
||
if (cJavoid <= 2)
|
||
{
|
||
*zput++ = b;
|
||
continue;
|
||
}
|
||
|
||
ca = cJavoid - 2;
|
||
za = zJavoid + 2;
|
||
while (ca-- != 0)
|
||
if (*za++ == b)
|
||
break;
|
||
|
||
if (ca < 0)
|
||
{
|
||
*zput++ = b;
|
||
continue;
|
||
}
|
||
}
|
||
|
||
if ((b & 0x80) == 0)
|
||
f128 = FALSE;
|
||
else
|
||
{
|
||
b &=~ 0x80;
|
||
f128 = TRUE;
|
||
}
|
||
if (b >= 32 && b != 127)
|
||
f32 = FALSE;
|
||
else
|
||
{
|
||
b ^= 0x20;
|
||
f32 = TRUE;
|
||
}
|
||
|
||
/* We must now put the byte index into the buffer. The byte
|
||
index is encoded similarly to the length of the actual data,
|
||
but the byte index also encodes the operations that must be
|
||
performed on the byte. The first byte in the index is the
|
||
most significant bits. If we only had to subtract 128 from
|
||
the byte, we use the second byte directly. If we had to xor
|
||
the byte with 32, we add 32 to the second byte index. If we
|
||
had to perform both operations, we add 64 to the second byte
|
||
index. However, if we had to perform both operations, and
|
||
the second byte index was 31, then after adding 64 and
|
||
offsetting by 32 we would come up with 127, which we are not
|
||
permitted to use. Therefore, in this special case we set the
|
||
first byte of the index to 126 and put the original first
|
||
byte into the second byte position instead. This is why we
|
||
could not permit the high byte of the length of the actual
|
||
data to be 126. We can get away with the switch because both
|
||
the value of the second byte index (31) and the operations to
|
||
perform (both) are known. */
|
||
i = zput - (zJbuf + CHDRLEN);
|
||
ihigh = i / INDEX_MAX_LOW;
|
||
ilow = i % INDEX_MAX_LOW;
|
||
|
||
if (f128 && ! f32)
|
||
;
|
||
else if (f32 && ! f128)
|
||
ilow += INDEX_MAX_LOW;
|
||
else
|
||
{
|
||
/* Both operations had to be performed. */
|
||
if (ilow != INDEX_MAX_LOW - 1)
|
||
ilow += 2 * INDEX_MAX_LOW;
|
||
else
|
||
{
|
||
ilow = ihigh;
|
||
ihigh = INDEX_MAX_HIGH;
|
||
}
|
||
}
|
||
|
||
*zindex++ = ihigh + INDEX_OFFSET;
|
||
*zindex++ = ilow + INDEX_OFFSET;
|
||
*zput++ = b;
|
||
}
|
||
|
||
*zindex++ = TRAILER;
|
||
|
||
/* Set the lengths into the buffer. zJbuf[0,3,6] were set when
|
||
zJbuf was allocated, and are never changed thereafter. */
|
||
zJbuf[1] = ISETLENGTH_FIRST (zindex - zJbuf);
|
||
zJbuf[2] = ISETLENGTH_SECOND (zindex - zJbuf);
|
||
zJbuf[4] = ISETLENGTH_FIRST (csend);
|
||
zJbuf[5] = ISETLENGTH_SECOND (csend);
|
||
|
||
/* Send the data over the line. We must preserve iPrecend as
|
||
discussed in fjreceive_data. */
|
||
iprecendhold = iPrecend;
|
||
iPrecend = iJrecend;
|
||
fret = fsend_data (qconn, zJbuf, (size_t) (zindex - zJbuf), fdoread);
|
||
iJrecend = iPrecend;
|
||
iPrecend = iprecendhold;
|
||
|
||
/* Process any bytes that may have been placed in abPrecbuf. */
|
||
if (fret && iPrecend != iJrecend)
|
||
{
|
||
if (! fjprocess_data ((size_t *) NULL))
|
||
return FALSE;
|
||
}
|
||
|
||
return fret;
|
||
}
|
||
|
||
/* Receive and decode data. This is called by fiwait_for_packet. We
|
||
need to be able to return decoded data between iPrecstart and
|
||
iPrecend, while not losing any undecoded partial packets we may
|
||
have read. We use iJrecend as a pointer to the end of the
|
||
undecoded data, and set iPrecend for the decoded data. iPrecend
|
||
points to the start of the undecoded data. */
|
||
|
||
static boolean
|
||
fjreceive_data (qconn, cineed, pcrec, ctimeout, freport)
|
||
struct sconnection *qconn;
|
||
size_t cineed;
|
||
size_t *pcrec;
|
||
int ctimeout;
|
||
boolean freport;
|
||
{
|
||
int iprecendstart;
|
||
size_t cjneed;
|
||
size_t crec;
|
||
int cnew;
|
||
|
||
iprecendstart = iPrecend;
|
||
|
||
/* Figure out how many bytes we need to decode the next packet. */
|
||
if (! fjprocess_data (&cjneed))
|
||
return FALSE;
|
||
|
||
/* As we long as we read some data but don't have enough to decode a
|
||
packet, we try to read some more. We decrease the timeout each
|
||
time so that we will not wait forever if the connection starts
|
||
dribbling data. */
|
||
do
|
||
{
|
||
int iprecendhold;
|
||
size_t cneed;
|
||
|
||
if (cjneed > cineed)
|
||
cneed = cjneed;
|
||
else
|
||
cneed = cineed;
|
||
|
||
/* We are setting iPrecend to the end of the decoded data for
|
||
the 'i' protocol. When we do the actual read, we have to set
|
||
it to the end of the undecoded data so that any undecoded
|
||
data we have received is not overwritten. */
|
||
iprecendhold = iPrecend;
|
||
iPrecend = iJrecend;
|
||
if (! freceive_data (qconn, cneed, &crec, ctimeout, freport))
|
||
return FALSE;
|
||
iJrecend = iPrecend;
|
||
iPrecend = iprecendhold;
|
||
|
||
/* Process any data we have received. This will set iPrecend to
|
||
the end of the new decoded data. */
|
||
if (! fjprocess_data (&cjneed))
|
||
return FALSE;
|
||
|
||
cnew = iPrecend - iprecendstart;
|
||
if (cnew < 0)
|
||
cnew += CRECBUFLEN;
|
||
|
||
if (cnew > cineed)
|
||
cineed = 0;
|
||
else
|
||
cineed -= cnew;
|
||
|
||
--ctimeout;
|
||
}
|
||
while (cnew == 0 && crec > 0 && ctimeout > 0);
|
||
|
||
DEBUG_MESSAGE1 (DEBUG_PROTO, "fjreceive_data: Got %d decoded bytes",
|
||
cnew);
|
||
|
||
*pcrec = cnew;
|
||
return TRUE;
|
||
}
|
||
|
||
/* Decode the data in the buffer, optionally returning the number of
|
||
bytes needed to complete the next packet. */
|
||
|
||
static boolean
|
||
fjprocess_data (pcneed)
|
||
size_t *pcneed;
|
||
{
|
||
int istart;
|
||
|
||
istart = iPrecend;
|
||
while (istart != iJrecend)
|
||
{
|
||
int i, iget;
|
||
char ab[CHDRLEN];
|
||
int cpacket, cdata, chave;
|
||
int iindex, iendindex;
|
||
|
||
/* Find the next occurrence of FIRST. If we have to skip some
|
||
garbage bytes to get to it, zero them out (so they don't
|
||
confuse the 'i' protocol) and advance iPrecend. This will
|
||
save us from looking at them again. */
|
||
if (abPrecbuf[istart] != FIRST)
|
||
{
|
||
int cintro;
|
||
char *zintro;
|
||
size_t cskipped;
|
||
|
||
cintro = iJrecend - istart;
|
||
if (cintro < 0)
|
||
cintro = CRECBUFLEN - istart;
|
||
|
||
zintro = memchr (abPrecbuf + istart, FIRST, (size_t) cintro);
|
||
if (zintro == NULL)
|
||
{
|
||
bzero (abPrecbuf + istart, (size_t) cintro);
|
||
istart = (istart + cintro) % CRECBUFLEN;
|
||
iPrecend = istart;
|
||
continue;
|
||
}
|
||
|
||
cskipped = zintro - (abPrecbuf + istart);
|
||
bzero (abPrecbuf + istart, cskipped);
|
||
istart += cskipped;
|
||
iPrecend = istart;
|
||
}
|
||
|
||
for (i = 0, iget = istart;
|
||
i < CHDRLEN && iget != iJrecend;
|
||
++i, iget = (iget + 1) % CRECBUFLEN)
|
||
ab[i] = abPrecbuf[iget];
|
||
|
||
if (i < CHDRLEN)
|
||
{
|
||
if (pcneed != NULL)
|
||
*pcneed = CHDRLEN - i;
|
||
return TRUE;
|
||
}
|
||
|
||
cpacket = CGETLENGTH (ab[1], ab[2]);
|
||
cdata = CGETLENGTH (ab[4], ab[5]);
|
||
|
||
/* Make sure the header has the right magic characters, that the
|
||
data is not larger than the packet, and that we have an even
|
||
number of byte index characters. */
|
||
if (ab[3] != FOURTH
|
||
|| ab[6] != SEVENTH
|
||
|| cdata > cpacket - CHDRLEN - 1
|
||
|| (cpacket - cdata - CHDRLEN - 1) % 2 == 1)
|
||
{
|
||
istart = (istart + 1) % CRECBUFLEN;
|
||
continue;
|
||
}
|
||
|
||
chave = iJrecend - istart;
|
||
if (chave < 0)
|
||
chave += CRECBUFLEN;
|
||
|
||
if (chave < cpacket)
|
||
{
|
||
if (pcneed != NULL)
|
||
*pcneed = cpacket - chave;
|
||
return TRUE;
|
||
}
|
||
|
||
/* Figure out where the byte indices start and end. */
|
||
iindex = (istart + CHDRLEN + cdata) % CRECBUFLEN;
|
||
iendindex = (istart + cpacket - 1) % CRECBUFLEN;
|
||
|
||
/* Make sure the magic trailer character is there. */
|
||
if (abPrecbuf[iendindex] != TRAILER)
|
||
{
|
||
istart = (istart + 1) % CRECBUFLEN;
|
||
continue;
|
||
}
|
||
|
||
/* We have a packet to decode. The decoding process is simpler
|
||
than the encoding process, since all we have to do is examine
|
||
the byte indices. We zero out the byte indices as we go, so
|
||
that they will not confuse the 'i' protocol. */
|
||
while (iindex != iendindex)
|
||
{
|
||
int ihigh, ilow;
|
||
boolean f32, f128;
|
||
int iset;
|
||
|
||
ihigh = abPrecbuf[iindex] - INDEX_OFFSET;
|
||
abPrecbuf[iindex] = 0;
|
||
iindex = (iindex + 1) % CRECBUFLEN;
|
||
ilow = abPrecbuf[iindex] - INDEX_OFFSET;
|
||
abPrecbuf[iindex] = 0;
|
||
iindex = (iindex + 1) % CRECBUFLEN;
|
||
|
||
/* Now we must undo the encoding, by adding 128 and xoring
|
||
with 32 as appropriate. Which to do is encoded in the
|
||
low byte, except that if the high byte is the special
|
||
value 126, then the low byte is actually the high byte
|
||
and both operations are performed. */
|
||
f128 = TRUE;
|
||
f32 = TRUE;
|
||
if (ihigh == INDEX_MAX_HIGH)
|
||
iset = ilow * INDEX_MAX_LOW + INDEX_MAX_LOW - 1;
|
||
else
|
||
{
|
||
iset = ihigh * INDEX_MAX_LOW + ilow % INDEX_MAX_LOW;
|
||
if (ilow < INDEX_MAX_LOW)
|
||
f32 = FALSE;
|
||
else if (ilow < 2 * INDEX_MAX_LOW)
|
||
f128 = FALSE;
|
||
}
|
||
|
||
/* Now iset is the index from the start of the data to the
|
||
byte to modify; adjust it to an index in abPrecbuf. */
|
||
iset = (istart + CHDRLEN + iset) % CRECBUFLEN;
|
||
|
||
if (f128)
|
||
abPrecbuf[iset] |= 0x80;
|
||
if (f32)
|
||
abPrecbuf[iset] ^= 0x20;
|
||
}
|
||
|
||
/* Zero out the header and trailer to avoid confusing the 'i'
|
||
protocol, and update iPrecend to the end of decoded data. */
|
||
for (i = 0, iget = istart;
|
||
i < CHDRLEN && iget != iJrecend;
|
||
++i, iget = (iget + 1) % CRECBUFLEN)
|
||
abPrecbuf[iget] = 0;
|
||
abPrecbuf[iendindex] = 0;
|
||
iPrecend = (iendindex + 1) % CRECBUFLEN;
|
||
istart = iPrecend;
|
||
}
|
||
|
||
if (pcneed != NULL)
|
||
*pcneed = CHDRLEN + 1;
|
||
return TRUE;
|
||
}
|