/* proty.c The 'y' protocol. Copyright (C) 1994, 1995 Jorge Cwik and 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. */ #include "uucp.h" #if USE_RCS_ID const char proty_id[] = "$Id: proty.c,v 1.4 1995/06/21 19:15:40 ian Rel $"; #endif #include "uudefs.h" #include "uuconf.h" #include "conn.h" #include "trans.h" #include "system.h" #include "prot.h" /* The 'y' protocol, and this implementation, was written and designed by Jorge Cwik . Some of the routines, and the coding style in general, were taken verbatim or adapted from other Taylor UUCP modules. Mark Delany made the initial testings and helped in portability issues. This protocol does not perform any kind of error correction or flow control. It does do error checking. It does not require an end to end reliable link. It is recommended for error-free (also called semi-reliable) connections as provided by error correcting modems. It needs an eight bit clean channel and some kind of flow control at the lower layers, typically RTS/CTS hardware flow control. The flow of the file transmission is completely unidirectional. There are no ACKs or NAKs outside file boundaries. This makes it very suitable for half duplex modulations (like PEP) and connections with very long delays, like multihop satellite links. */ /* This protocol uses 16 bit little-endian ints in the packet header. */ #define FROMLITTLE(p) (((p)[0] & 0xff) + (((p)[1] & 0xff) << 8)) #define TOLITTLE(p, i) ((p)[0] = (i) & 0xff, (p)[1] = ((i) >> 8) & 0xff) /* The buffer and packet size we use. */ #define CYBUFSIZE (1024) #define IYPACKSIZE (1024) /* The offset in the buffer to the data. */ #define CYFRAMELEN (6) /* Offsets in a packet header. */ #define YFRAME_SEQ_OFF (0) #define YFRAME_LEN_OFF (2) #define YFRAME_CTL_OFF (2) #define YFRAME_CHK_OFF (4) /* Offsets in a packet header viewed as an array of shorts. */ #define YFRAME_SEQ (0) #define YFRAME_LEN (1) #define YFRAME_CTL (1) #define YFRAME_CHK (2) /* The default timeout. */ #define CYTIMEOUT (60) /* Control packet types. */ #define YPKT_ACK (0xFFFE) #define YPKT_ERR (0xFFFD) #define YPKT_BAD (0xFFFC) /* The protocol version number. */ #define Y_VERSION (1) /* When the protocol starts up, it transmit the following information: 1 byte version 1 byte packet size 2 byte flags (none currently defined) Future revision may expand the structure as long as these members keep their current offset. */ #define Y_INIT_HDR_LEN (4) #define Y_INIT_HDR_VERSION_OFF (0) #define Y_INIT_HDR_PKTSIZE_OFF (1) #define Y_INIT_HDR_FLAGS_OFF (2) /* The initialization length of the lowest accepted version. */ #define MIN_Y_SYNC (4) /* Not strictly needed, but I would not want to accept a 32k sync pkt. */ #define MAX_Y_SYNC IYPACKSIZE /* Local and remote packet sizes (we actually use the same value for both). */ static size_t iYlocal_packsize = IYPACKSIZE; static size_t iYremote_packsize = IYPACKSIZE; /* Local and remote packet sequence numbers. */ static unsigned short iYlocal_pktnum; static unsigned short iYremote_pktnum; /* The timeout. */ static int cYtimeout = CYTIMEOUT; /* Transmitter buffer. */ static char *zYbuf; /* Protocol parameters. */ struct uuconf_cmdtab asYproto_params[] = { { "timeout", UUCONF_CMDTABTYPE_INT, (pointer) &cYtimeout, NULL }, { "packet-size", UUCONF_CMDTABTYPE_INT, (pointer) &iYlocal_packsize, NULL }, { NULL, 0, NULL, NULL } }; /* Local functions. */ static boolean fywait_for_packet P((struct sdaemon *qdaemon, boolean *pfexit)); static unsigned short iychecksum P((const char *z, size_t c)); static unsigned short iychecksum2 P((const char *zfirst, size_t cfirst, const char *zsecond, size_t csecond)); static boolean fywait_for_header P((struct sdaemon *qdaemon, unsigned short header[3], int timeout)); static boolean fysend_pkt P((struct sdaemon *qdaemon, const void *zdata, size_t cdata)); static boolean fysend_control P((struct sdaemon *qdaemon, int itype)); static boolean fyread_data P((struct sdaemon *qdaemon, size_t clen, int timeout)); /* Exchange sync packets at protocol startup. */ static boolean fyxchg_syncs (qdaemon) struct sdaemon *qdaemon; { char inithdr[Y_INIT_HDR_LEN]; unsigned short header[3]; unsigned short ichk; size_t clen, cfirst; int rpktsize; /* Send our configuration. We could use only one array (for local and remote). But this is safer in case the code changes and depend on separate ones. */ inithdr[Y_INIT_HDR_VERSION_OFF] = Y_VERSION; inithdr[Y_INIT_HDR_PKTSIZE_OFF] = iYlocal_packsize >> 8; TOLITTLE (inithdr + Y_INIT_HDR_FLAGS_OFF, 0); if (! fysend_pkt (qdaemon, inithdr, Y_INIT_HDR_LEN)) return FALSE; if (! fywait_for_header (qdaemon, header, cYtimeout)) return FALSE; DEBUG_MESSAGE0 (DEBUG_UUCP_PROTO, "fyxchg_syncs: Got sync header"); clen = header[YFRAME_LEN]; if (clen < MIN_Y_SYNC || clen > MAX_Y_SYNC) { ulog (LOG_ERROR, "Bad 'y' protocol sync packet length"); return FALSE; } /* It may be better to integrate this code with fywait_for_packet. */ if (! fyread_data (qdaemon, clen, cYtimeout)) return FALSE; cfirst = CRECBUFLEN - iPrecstart; ichk = iychecksum2 (abPrecbuf + iPrecstart, cfirst, abPrecbuf, clen - cfirst); rpktsize = BUCHAR (abPrecbuf[(iPrecstart + 1) % CRECBUFLEN]); /* Future versions of the protocol may need to check and react according to the version number. */ if (rpktsize == 0 || header[YFRAME_CHK] != ichk) { ulog (LOG_ERROR, "Bad 'y' protocol sync packet"); return FALSE; } iYremote_packsize = rpktsize << 8; /* Some may want to do this different and in effect the protocol support this. But I like the idea that the packet size would be the same in both directions. This allows the caller to select both packet sizes without changing the configuration at the server. */ if (iYremote_packsize > iYlocal_packsize) iYremote_packsize = iYlocal_packsize; iPrecstart = (iPrecstart + clen) % CRECBUFLEN; return TRUE; } /* Start the protocol. */ boolean fystart (qdaemon, pzlog) struct sdaemon *qdaemon; char **pzlog; { *pzlog = NULL; /* This should force, or at least enable if available, RTS/CTS hardware flow control !! */ /* The 'y' protocol requires an eight bit clean link */ if (! fconn_set (qdaemon->qconn, PARITYSETTING_NONE, STRIPSETTING_EIGHTBITS, XONXOFF_OFF)) return FALSE; iYlocal_pktnum = iYremote_pktnum = 0; /* Only multiple of 256 sizes are allowed */ iYlocal_packsize &= ~0xff; if (iYlocal_packsize < 256 || iYlocal_packsize > (16*1024)) iYlocal_packsize = IYPACKSIZE; /* Exhange SYNC packets */ if (! fyxchg_syncs (qdaemon)) { /* Restore defaults */ cYtimeout = CYTIMEOUT; iYlocal_packsize = IYPACKSIZE; return FALSE; } zYbuf = (char *) xmalloc (CYBUFSIZE + CYFRAMELEN); return TRUE; } /* Shutdown the protocol. */ boolean fyshutdown (qdaemon) struct sdaemon *qdaemon; { xfree ((pointer) zYbuf); zYbuf = NULL; cYtimeout = CYTIMEOUT; iYlocal_packsize = IYPACKSIZE; return TRUE; } /* Send a command string. We send packets containing the string until the entire string has been sent, including the zero terminator. */ /*ARGSUSED*/ boolean fysendcmd (qdaemon, z, ilocal, iremote) struct sdaemon *qdaemon; const char *z; int ilocal; int iremote; { size_t clen; DEBUG_MESSAGE1 (DEBUG_UUCP_PROTO, "fysendcmd: Sending command \"%s\"", z); clen = strlen (z) + 1; while (clen > 0) { size_t csize; csize = clen; if (csize > iYremote_packsize) csize = iYremote_packsize; if (! fysend_pkt (qdaemon, z, csize)) return FALSE; z += csize; clen -= csize; } return TRUE; } /* Get space to be filled with data. We always use zYbuf, which was allocated from the heap. */ char * zygetspace (qdaemon, pclen) struct sdaemon *qdaemon; size_t *pclen; { *pclen = iYremote_packsize; return zYbuf + CYFRAMELEN; } /* Send out a data packet. */ boolean fysenddata (qdaemon, zdata, cdata, ilocal, iremote, ipos) struct sdaemon *qdaemon; char *zdata; size_t cdata; int ilocal; int iremote; long ipos; { #if DEBUG > 0 if (cdata > iYremote_packsize) ulog (LOG_FATAL, "fysend_packet: Packet size too large"); #endif TOLITTLE (zYbuf + YFRAME_SEQ_OFF, iYlocal_pktnum); ++iYlocal_pktnum; TOLITTLE (zYbuf + YFRAME_LEN_OFF, cdata); TOLITTLE (zYbuf + YFRAME_CHK_OFF, iychecksum (zdata, cdata)); /* We pass FALSE to fsend_data since we don't expect the other side to be sending us anything just now. */ return fsend_data (qdaemon->qconn, zYbuf, cdata + CYFRAMELEN, FALSE); } /* Wait for data to come in and process it until we've finished a command or a file. */ boolean fywait (qdaemon) struct sdaemon *qdaemon; { boolean fexit = FALSE; while (! fexit) { if (! fywait_for_packet (qdaemon, &fexit)) return FALSE; } return TRUE; } /* File level routines We could handle this inside the other public routines, but this is cleaner and better for future expansions */ boolean fyfile (qdaemon, qtrans, fstart, fsend, cbytes, pfhandled) struct sdaemon *qdaemon; struct stransfer *qtrans; boolean fstart; boolean fsend; long cbytes; boolean *pfhandled; { unsigned short header[3]; *pfhandled = FALSE; if (! fstart) { if (fsend) { /* It is critical that the timeout here would be long enough. We have just sent a full file without any kind of flow control at the protocol level. The traffic may be buffered in many places of the link, and the remote may take a while until cathing up. */ if (! fywait_for_header (qdaemon, header, cYtimeout * 2)) return FALSE; if (header[YFRAME_CTL] != (unsigned short) YPKT_ACK) { DEBUG_MESSAGE1 (DEBUG_PROTO | DEBUG_ABNORMAL, "fyfile: Error from remote: 0x%04X", header[1]); ulog (LOG_ERROR, "Received 'y' protocol error from remote"); return FALSE; } } else { /* This is technically not requireed. But I've put this in the protocol to allow easier expansions. */ return fysend_control (qdaemon, YPKT_ACK); } } return TRUE; } /* Send a control packet, not used during the normal file transmission. */ static boolean fysend_control (qdaemon, itype) struct sdaemon *qdaemon; int itype; { char header[CYFRAMELEN]; TOLITTLE (header + YFRAME_SEQ_OFF, iYlocal_pktnum); iYlocal_pktnum++; TOLITTLE (header + YFRAME_CTL_OFF, itype); TOLITTLE (header + YFRAME_CHK_OFF, 0); return fsend_data (qdaemon->qconn, header, CYFRAMELEN, FALSE); } /* Private function to send a packet. This one doesn't need the data to be in the buffer provided by zygetspace. I've found it worth for avoiding memory copies. Somebody may want to do it otherwise */ static boolean fysend_pkt (qdaemon, zdata, cdata) struct sdaemon *qdaemon; const void *zdata; size_t cdata; { char header[CYFRAMELEN]; TOLITTLE (header + YFRAME_SEQ_OFF, iYlocal_pktnum); iYlocal_pktnum++; TOLITTLE (header + YFRAME_LEN_OFF, cdata); TOLITTLE (header + YFRAME_CHK_OFF, iychecksum (zdata, cdata)); if (! fsend_data (qdaemon->qconn, header, CYFRAMELEN, FALSE)) return FALSE; return fsend_data (qdaemon->qconn, zdata, cdata, FALSE); } /* Wait until enough data arrived from the comm line. This protocol doesn't need to perform any kind of action while waiting. */ static boolean fyread_data (qdaemon, clen, timeout) struct sdaemon *qdaemon; size_t clen; int timeout; { int cinbuf; size_t crec; cinbuf = iPrecend - iPrecstart; if (cinbuf < 0) cinbuf += CRECBUFLEN; if (cinbuf < clen) { if (! freceive_data (qdaemon->qconn, clen - cinbuf, &crec, timeout, TRUE)) return FALSE; cinbuf += crec; if (cinbuf < clen) { if (! freceive_data (qdaemon->qconn, clen - cinbuf, &crec, timeout, TRUE)) return FALSE; } cinbuf += crec; if (cinbuf < clen) { ulog (LOG_ERROR, "Timed out waiting for data"); return FALSE; } } return TRUE; } /* Receive a remote packet header, check for correct sequence number. */ static boolean fywait_for_header (qdaemon, header, timeout) struct sdaemon *qdaemon; unsigned short header[3]; int timeout; { if (! fyread_data (qdaemon, CYFRAMELEN, timeout)) return FALSE; /* Somebody may want to optimize this in a portable way. I'm not sure it's worth, but the output by gcc for the portable construct is so bad (even with optimization), that I couldn't resist. */ if (iPrecstart <= (CRECBUFLEN - CYFRAMELEN)) { header[0] = FROMLITTLE (abPrecbuf + iPrecstart); header[1] = FROMLITTLE (abPrecbuf + iPrecstart + 2); header[2] = FROMLITTLE (abPrecbuf + iPrecstart + 4); } else { register int i, j; for (i = j = 0; j < CYFRAMELEN; i++, j += 2) { header[i] = (((abPrecbuf[(iPrecstart + j + 1) % CRECBUFLEN] & 0xff) << 8) + (abPrecbuf[(iPrecstart + j) % CRECBUFLEN] & 0xff)); } } iPrecstart = (iPrecstart + CYFRAMELEN) % CRECBUFLEN; DEBUG_MESSAGE3 (DEBUG_UUCP_PROTO, "fywait_for_header: Got header: 0x%04X, 0x%04X, 0x%04X", header[0], header[1], header[2]); if (header[YFRAME_SEQ] != iYremote_pktnum++) { ulog (LOG_ERROR, "Incorrect 'y' packet sequence"); fysend_control (qdaemon, YPKT_BAD); return FALSE; } return TRUE; } /* Receive a remote data packet */ static boolean fywait_for_packet (qdaemon, pfexit) struct sdaemon *qdaemon; boolean *pfexit; { unsigned short header[3], ichk; size_t clen, cfirst; if (! fywait_for_header (qdaemon, header, cYtimeout)) return FALSE; clen = header[YFRAME_LEN]; if (clen == 0 && pfexit != NULL) { /* I Suppose the pointers could be NULL ??? */ return fgot_data (qdaemon, abPrecbuf, 0, abPrecbuf, 0, -1, -1, (long) -1, TRUE, pfexit); } if (clen & 0x8000) { DEBUG_MESSAGE1 (DEBUG_PROTO | DEBUG_ABNORMAL, "fywait_for_packet: Error from remote: 0x%04X", header[YFRAME_CTL]); ulog (LOG_ERROR, "Remote error packet"); return FALSE; } /* This is really not neccessary. But if this check is removed, take in mind that the packet may be up to 32k long. */ if (clen > iYlocal_packsize) { ulog (LOG_ERROR, "Packet too large"); return FALSE; } if (! fyread_data (qdaemon, clen, cYtimeout)) return FALSE; cfirst = CRECBUFLEN - iPrecstart; if (cfirst > clen) cfirst = clen; if (cfirst == clen) ichk = iychecksum (abPrecbuf + iPrecstart, clen); else ichk = iychecksum2 (abPrecbuf + iPrecstart, cfirst, abPrecbuf, clen - cfirst); if (header[YFRAME_CHK] != ichk) { DEBUG_MESSAGE2 (DEBUG_PROTO | DEBUG_ABNORMAL, "fywait_for_packet: Bad checksum 0x%x != 0x%x", header[YFRAME_CHK], ichk); fysend_control (qdaemon, YPKT_ERR); ulog (LOG_ERROR, "Checksum error"); return FALSE; } if (pfexit != NULL && ! fgot_data (qdaemon, abPrecbuf + iPrecstart, cfirst, abPrecbuf, clen - cfirst, -1, -1, (long) -1, TRUE, pfexit)) return FALSE; iPrecstart = (iPrecstart + clen) % CRECBUFLEN; return TRUE; } /* Compute 16 bit checksum */ #ifdef __GNUC__ #ifdef __i386__ #define I386_ASM #endif #endif #ifdef I386_ASM #define ROTATE(i) \ asm ("rolw $1,%0" : "=g" (i) : "g" (i)) #else #define ROTATE(i) i += i + ((i & 0x8000) >> 15) #endif static unsigned short iychecksum (z, c) register const char *z; register size_t c; { register unsigned short ichk; ichk = 0xffff; while (c-- > 0) { ROTATE (ichk); ichk += BUCHAR (*z++); } return ichk; } static unsigned short iychecksum2 (zfirst, cfirst, zsecond, csecond) const char *zfirst; size_t cfirst; const char *zsecond; size_t csecond; { register unsigned short ichk; register const char *z; register size_t c; z = zfirst; c = cfirst + csecond; ichk = 0xffff; while (c-- > 0) { ROTATE (ichk); ichk += BUCHAR (*z++); /* If the first buffer has been finished, switch to the second. */ if (--cfirst == 0) z = zsecond; } return ichk; }