dan@i10s7.ira.uka.de (Dan Mosedale) (05/17/91)
#! /bin/sh
# This is a shell archive. Remove anything before this line, then unpack
# it by saving it into a file and typing "sh file". To overwrite existing
# files, type "sh file -c". You can also feed this as standard input via
# unshar, or by typing "sh <file", e.g.. If this archive is complete, you
# will see the following message at the end:
# "End of archive 5 (of 9)."
# Contents: pf-bootstrap-v1.1a/tipx-p1/remcap.c
# pf-bootstrap-v1.1a/xmodem-3.9/getput.sysv.c
# pf-bootstrap-v1.1a/xmodem-3.9/send.c
# pf-bootstrap-v1.1a/xmodem-3.9/xmodem.1
# Wrapped by dan@nostromo on Fri May 17 02:31:42 1991
PATH=/bin:/usr/bin:/usr/ucb ; export PATH
if test -f 'pf-bootstrap-v1.1a/tipx-p1/remcap.c' -a "${1}" != "-c" ; then
echo shar: Will not clobber existing file \"'pf-bootstrap-v1.1a/tipx-p1/remcap.c'\"
else
echo shar: Extracting \"'pf-bootstrap-v1.1a/tipx-p1/remcap.c'\" \(8960 characters\)
sed "s/^X//" >'pf-bootstrap-v1.1a/tipx-p1/remcap.c' <<'END_OF_FILE'
X/*
X * Copyright (c) 1983 The Regents of the University of California.
X * All rights reserved.
X *
X * Redistribution and use in source and binary forms are permitted
X * provided that the above copyright notice and this paragraph are
X * duplicated in all such forms and that any documentation,
X * advertising materials, and other materials related to such
X * distribution and use acknowledge that the software was developed
X * by the University of California, Berkeley. The name of the
X * University may not be used to endorse or promote products derived
X * from this software without specific prior written permission.
X * THIS SOFTWARE IS PROVIDED ``AS IS'' AND WITHOUT ANY EXPRESS OR
X * IMPLIED WARRANTIES, INCLUDING, WITHOUT LIMITATION, THE IMPLIED
X * WARRANTIES OF MERCHANTIBILITY AND FITNESS FOR A PARTICULAR PURPOSE.
X */
X
X#ifndef lint
Xstatic char sccsid[] = "@(#)remcap.c 5.2 (Berkeley) 9/2/88";
X#endif /* not lint */
X
X/*
X * remcap - routines for dealing with the remote host data base
X *
X * derived from termcap
X */
X#include <sys/file.h>
X#include <ctype.h>
X
X#ifndef BUFSIZ
X#define BUFSIZ 1024
X#endif
X#define MAXHOP 32 /* max number of tc= indirections */
X#define SYSREMOTE "/etc/remote" /* system remote file */
X
X#define tgetent rgetent
X#define tnchktc rnchktc
X#define tnamatch rnamatch
X#define tgetnum rgetnum
X#define tgetflag rgetflag
X#define tgetstr rgetstr
X#define E_TERMCAP RM = SYSREMOTE
X#define V_TERMCAP "REMOTE"
X#define V_TERM "HOST"
X
Xchar *RM;
X
X/*
X * termcap - routines for dealing with the terminal capability data base
X *
X * BUG: Should use a "last" pointer in tbuf, so that searching
X * for capabilities alphabetically would not be a n**2/2
X * process when large numbers of capabilities are given.
X * Note: If we add a last pointer now we will screw up the
X * tc capability. We really should compile termcap.
X *
X * Essentially all the work here is scanning and decoding escapes
X * in string capabilities. We don't use stdio because the editor
X * doesn't, and because living w/o it is not hard.
X */
X
Xstatic char *tbuf;
Xstatic int hopcount; /* detect infinite loops in termcap, init 0 */
Xchar *tskip();
Xchar *tgetstr();
Xchar *tdecode();
Xchar *getenv();
Xstatic char *remotefile;
X
X/*
X * Get an entry for terminal name in buffer bp,
X * from the termcap file. Parse is very rudimentary;
X * we just notice escaped newlines.
X */
Xtgetent(bp, name)
X char *bp, *name;
X{
X char lbuf[BUFSIZ], *cp, *p;
X int rc1, rc2;
X
X remotefile = cp = getenv(V_TERMCAP);
X if (cp == (char *)0 || strcmp(cp, SYSREMOTE) == 0) {
X remotefile = cp = SYSREMOTE;
X return (getent(bp, name, cp));
X } else {
X if ((rc1 = getent(bp, name, cp)) != 1)
X *bp = '\0';
X remotefile = cp = SYSREMOTE;
X rc2 = getent(lbuf, name, cp);
X if (rc1 != 1 && rc2 != 1)
X return (rc2);
X if (rc2 == 1) {
X p = lbuf;
X if (rc1 == 1)
X while (*p++ != ':')
X ;
X if (strlen(bp) + strlen(p) > BUFSIZ) {
X write(2, "Remcap entry too long\n", 23);
X return (-1);
X }
X strcat(bp, p);
X }
X tbuf = bp;
X return (1);
X }
X}
X
Xgetent(bp, name, cp)
X char *bp, *name, *cp;
X{
X register int c;
X register int i = 0, cnt = 0;
X char ibuf[BUFSIZ], *cp2;
X int tf;
X
X tbuf = bp;
X tf = 0;
X /*
X * TERMCAP can have one of two things in it. It can be the
X * name of a file to use instead of /etc/termcap. In this
X * case it better start with a "/". Or it can be an entry to
X * use so we don't have to read the file. In this case it
X * has to already have the newlines crunched out.
X */
X if (cp && *cp) {
X if (*cp!='/') {
X cp2 = getenv(V_TERM);
X if (cp2 == (char *)0 || strcmp(name,cp2) == 0) {
X strcpy(bp,cp);
X return (tnchktc());
X } else
X tf = open(E_TERMCAP, O_RDONLY);
X } else
X tf = open(RM = cp, O_RDONLY);
X }
X if (tf == 0)
X tf = open(E_TERMCAP, O_RDONLY);
X if (tf < 0)
X return (-1);
X for (;;) {
X cp = bp;
X for (;;) {
X if (i == cnt) {
X cnt = read(tf, ibuf, BUFSIZ);
X if (cnt <= 0) {
X close(tf);
X return (0);
X }
X i = 0;
X }
X c = ibuf[i++];
X if (c == '\n') {
X if (cp > bp && cp[-1] == '\\') {
X cp--;
X continue;
X }
X break;
X }
X if (cp >= bp+BUFSIZ) {
X write(2,"Remcap entry too long\n", 23);
X break;
X } else
X *cp++ = c;
X }
X *cp = 0;
X
X /*
X * The real work for the match.
X */
X if (tnamatch(name)) {
X close(tf);
X return (tnchktc());
X }
X }
X}
X
X/*
X * tnchktc: check the last entry, see if it's tc=xxx. If so,
X * recursively find xxx and append that entry (minus the names)
X * to take the place of the tc=xxx entry. This allows termcap
X * entries to say "like an HP2621 but doesn't turn on the labels".
X * Note that this works because of the left to right scan.
X */
Xtnchktc()
X{
X register char *p, *q;
X char tcname[16]; /* name of similar terminal */
X char tcbuf[BUFSIZ];
X char *holdtbuf = tbuf;
X int l;
X
X p = tbuf + strlen(tbuf) - 2; /* before the last colon */
X while (*--p != ':')
X if (p<tbuf) {
X write(2, "Bad remcap entry\n", 18);
X return (0);
X }
X p++;
X /* p now points to beginning of last field */
X if (p[0] != 't' || p[1] != 'c')
X return (1);
X strcpy(tcname, p+3);
X q = tcname;
X while (*q && *q != ':')
X q++;
X *q = 0;
X if (++hopcount > MAXHOP) {
X write(2, "Infinite tc= loop\n", 18);
X return (0);
X }
X if (getent(tcbuf, tcname, remotefile) != 1) {
X if (strcmp(remotefile, SYSREMOTE) == 0)
X return (0);
X else if (getent(tcbuf, tcname, SYSREMOTE) != 1)
X return (0);
X }
X for (q = tcbuf; *q++ != ':'; )
X ;
X l = p - holdtbuf + strlen(q);
X if (l > BUFSIZ) {
X write(2, "Remcap entry too long\n", 23);
X q[BUFSIZ - (p-holdtbuf)] = 0;
X }
X strcpy(p, q);
X tbuf = holdtbuf;
X return (1);
X}
X
X/*
X * Tnamatch deals with name matching. The first field of the termcap
X * entry is a sequence of names separated by |'s, so we compare
X * against each such name. The normal : terminator after the last
X * name (before the first field) stops us.
X */
Xtnamatch(np)
X char *np;
X{
X register char *Np, *Bp;
X
X Bp = tbuf;
X if (*Bp == '#')
X return (0);
X for (;;) {
X for (Np = np; *Np && *Bp == *Np; Bp++, Np++)
X continue;
X if (*Np == 0 && (*Bp == '|' || *Bp == ':' || *Bp == 0))
X return (1);
X while (*Bp && *Bp != ':' && *Bp != '|')
X Bp++;
X if (*Bp == 0 || *Bp == ':')
X return (0);
X Bp++;
X }
X}
X
X/*
X * Skip to the next field. Notice that this is very dumb, not
X * knowing about \: escapes or any such. If necessary, :'s can be put
X * into the termcap file in octal.
X */
Xstatic char *
Xtskip(bp)
X register char *bp;
X{
X
X while (*bp && *bp != ':')
X bp++;
X if (*bp == ':')
X bp++;
X return (bp);
X}
X
X/*
X * Return the (numeric) option id.
X * Numeric options look like
X * li#80
X * i.e. the option string is separated from the numeric value by
X * a # character. If the option is not found we return -1.
X * Note that we handle octal numbers beginning with 0.
X */
Xtgetnum(id)
X char *id;
X{
X register int i, base;
X register char *bp = tbuf;
X
X for (;;) {
X bp = tskip(bp);
X if (*bp == 0)
X return (-1);
X if (*bp++ != id[0] || *bp == 0 || *bp++ != id[1])
X continue;
X if (*bp == '@')
X return (-1);
X if (*bp != '#')
X continue;
X bp++;
X base = 10;
X if (*bp == '0')
X base = 8;
X i = 0;
X while (isdigit(*bp))
X i *= base, i += *bp++ - '0';
X return (i);
X }
X}
X
X/*
X * Handle a flag option.
X * Flag options are given "naked", i.e. followed by a : or the end
X * of the buffer. Return 1 if we find the option, or 0 if it is
X * not given.
X */
Xtgetflag(id)
X char *id;
X{
X register char *bp = tbuf;
X
X for (;;) {
X bp = tskip(bp);
X if (!*bp)
X return (0);
X if (*bp++ == id[0] && *bp != 0 && *bp++ == id[1]) {
X if (!*bp || *bp == ':')
X return (1);
X else if (*bp == '@')
X return (0);
X }
X }
X}
X
X/*
X * Get a string valued option.
X * These are given as
X * cl=^Z
X * Much decoding is done on the strings, and the strings are
X * placed in area, which is a ref parameter which is updated.
X * No checking on area overflow.
X */
Xchar *
Xtgetstr(id, area)
X char *id, **area;
X{
X register char *bp = tbuf;
X
X for (;;) {
X bp = tskip(bp);
X if (!*bp)
X return (0);
X if (*bp++ != id[0] || *bp == 0 || *bp++ != id[1])
X continue;
X if (*bp == '@')
X return (0);
X if (*bp != '=')
X continue;
X bp++;
X return (tdecode(bp, area));
X }
X}
X
X/*
X * Tdecode does the grung work to decode the
X * string capability escapes.
X */
Xstatic char *
Xtdecode(str, area)
X register char *str;
X char **area;
X{
X register char *cp;
X register int c;
X register char *dp;
X int i;
X
X cp = *area;
X while ((c = *str++) && c != ':') {
X switch (c) {
X
X case '^':
X c = *str++ & 037;
X break;
X
X case '\\':
X dp = "E\033^^\\\\::n\nr\rt\tb\bf\f";
X c = *str++;
Xnextc:
X if (*dp++ == c) {
X c = *dp++;
X break;
X }
X dp++;
X if (*dp)
X goto nextc;
X if (isdigit(c)) {
X c -= '0', i = 2;
X do
X c <<= 3, c |= *str++ - '0';
X while (--i && isdigit(*str));
X break;
X }
X /* \x where x is not understood is passed as \x */
X /* to allow the handshake routine to do further */
X /* escape processing. */
X *cp++ = '\\';
X break;
X }
X *cp++ = c;
X }
X *cp++ = 0;
X str = *area;
X *area = cp;
X return (str);
X}
END_OF_FILE
if test 8960 -ne `wc -c <'pf-bootstrap-v1.1a/tipx-p1/remcap.c'`; then
echo shar: \"'pf-bootstrap-v1.1a/tipx-p1/remcap.c'\" unpacked with wrong size!
fi
# end of 'pf-bootstrap-v1.1a/tipx-p1/remcap.c'
fi
if test -f 'pf-bootstrap-v1.1a/xmodem-3.9/getput.sysv.c' -a "${1}" != "-c" ; then
echo shar: Will not clobber existing file \"'pf-bootstrap-v1.1a/xmodem-3.9/getput.sysv.c'\"
else
echo shar: Extracting \"'pf-bootstrap-v1.1a/xmodem-3.9/getput.sysv.c'\" \(11185 characters\)
sed "s/^X//" >'pf-bootstrap-v1.1a/xmodem-3.9/getput.sysv.c' <<'END_OF_FILE'
X/*
X * Contains system routines to get and put bytes, change tty modes, etc
X * Sys V version. UNTESTED!!!!!!
X */
X
X#include "xmodem.h"
X
X/*
X *
X * Get a byte from the specified file. Buffer the read so we don't
X * have to use a system call for each character.
X *
X */
Xgetbyte(fildes, ch) /* Buffered disk read */
Xint fildes;
Xchar *ch;
X
X {
X static char buf[BUFSIZ]; /* Remember buffer */
X static char *bufp = buf; /* Remember where we are in buffer */
X
X if (nbchr == 0) /* Buffer exausted; read some more */
X {
X if ((nbchr = read(fildes, buf, BUFSIZ)) < 0)
X error("File Read Error", TRUE);
X bufp = buf; /* Set pointer to start of array */
X }
X if (--nbchr >= 0)
X {
X *ch = *bufp++;
X return(0);
X }
X else
X {
X return(EOF);
X }
X }
X
X/* Count the number of newlines in a file so we know the REAL file size */
X
Xlong
Xcountnl(fd)
Xint fd;
X{
X char buf[BUFSIZ];
X char *bufp;
X long nltot = 0;
X int numchar;
X long lseek();
X
X while (numchar = read(fd, buf, BUFSIZ)) /* cycle through file */
X for (bufp=buf; numchar--; bufp++)
X if (*bufp == '\n')
X nltot++;
X
X (void) lseek (fd, 0l, 0); /* rewind file */
X if (DEBUG)
X fprintf(LOGFP, "DEBUG: countnl--%ld newlines counted\n", nltot);
X return (nltot);
X}
X
X/* CRC-16 constant array...
X from Usenet contribution by Mark G. Mendel, Network Systems Corp.
X (ihnp4!umn-cs!hyper!mark)
X*/
X
X/* crctab as calculated by initcrctab() */
Xunsigned short crctab[1<<B] = {
X 0x0000, 0x1021, 0x2042, 0x3063, 0x4084, 0x50a5, 0x60c6, 0x70e7,
X 0x8108, 0x9129, 0xa14a, 0xb16b, 0xc18c, 0xd1ad, 0xe1ce, 0xf1ef,
X 0x1231, 0x0210, 0x3273, 0x2252, 0x52b5, 0x4294, 0x72f7, 0x62d6,
X 0x9339, 0x8318, 0xb37b, 0xa35a, 0xd3bd, 0xc39c, 0xf3ff, 0xe3de,
X 0x2462, 0x3443, 0x0420, 0x1401, 0x64e6, 0x74c7, 0x44a4, 0x5485,
X 0xa56a, 0xb54b, 0x8528, 0x9509, 0xe5ee, 0xf5cf, 0xc5ac, 0xd58d,
X 0x3653, 0x2672, 0x1611, 0x0630, 0x76d7, 0x66f6, 0x5695, 0x46b4,
X 0xb75b, 0xa77a, 0x9719, 0x8738, 0xf7df, 0xe7fe, 0xd79d, 0xc7bc,
X 0x48c4, 0x58e5, 0x6886, 0x78a7, 0x0840, 0x1861, 0x2802, 0x3823,
X 0xc9cc, 0xd9ed, 0xe98e, 0xf9af, 0x8948, 0x9969, 0xa90a, 0xb92b,
X 0x5af5, 0x4ad4, 0x7ab7, 0x6a96, 0x1a71, 0x0a50, 0x3a33, 0x2a12,
X 0xdbfd, 0xcbdc, 0xfbbf, 0xeb9e, 0x9b79, 0x8b58, 0xbb3b, 0xab1a,
X 0x6ca6, 0x7c87, 0x4ce4, 0x5cc5, 0x2c22, 0x3c03, 0x0c60, 0x1c41,
X 0xedae, 0xfd8f, 0xcdec, 0xddcd, 0xad2a, 0xbd0b, 0x8d68, 0x9d49,
X 0x7e97, 0x6eb6, 0x5ed5, 0x4ef4, 0x3e13, 0x2e32, 0x1e51, 0x0e70,
X 0xff9f, 0xefbe, 0xdfdd, 0xcffc, 0xbf1b, 0xaf3a, 0x9f59, 0x8f78,
X 0x9188, 0x81a9, 0xb1ca, 0xa1eb, 0xd10c, 0xc12d, 0xf14e, 0xe16f,
X 0x1080, 0x00a1, 0x30c2, 0x20e3, 0x5004, 0x4025, 0x7046, 0x6067,
X 0x83b9, 0x9398, 0xa3fb, 0xb3da, 0xc33d, 0xd31c, 0xe37f, 0xf35e,
X 0x02b1, 0x1290, 0x22f3, 0x32d2, 0x4235, 0x5214, 0x6277, 0x7256,
X 0xb5ea, 0xa5cb, 0x95a8, 0x8589, 0xf56e, 0xe54f, 0xd52c, 0xc50d,
X 0x34e2, 0x24c3, 0x14a0, 0x0481, 0x7466, 0x6447, 0x5424, 0x4405,
X 0xa7db, 0xb7fa, 0x8799, 0x97b8, 0xe75f, 0xf77e, 0xc71d, 0xd73c,
X 0x26d3, 0x36f2, 0x0691, 0x16b0, 0x6657, 0x7676, 0x4615, 0x5634,
X 0xd94c, 0xc96d, 0xf90e, 0xe92f, 0x99c8, 0x89e9, 0xb98a, 0xa9ab,
X 0x5844, 0x4865, 0x7806, 0x6827, 0x18c0, 0x08e1, 0x3882, 0x28a3,
X 0xcb7d, 0xdb5c, 0xeb3f, 0xfb1e, 0x8bf9, 0x9bd8, 0xabbb, 0xbb9a,
X 0x4a75, 0x5a54, 0x6a37, 0x7a16, 0x0af1, 0x1ad0, 0x2ab3, 0x3a92,
X 0xfd2e, 0xed0f, 0xdd6c, 0xcd4d, 0xbdaa, 0xad8b, 0x9de8, 0x8dc9,
X 0x7c26, 0x6c07, 0x5c64, 0x4c45, 0x3ca2, 0x2c83, 0x1ce0, 0x0cc1,
X 0xef1f, 0xff3e, 0xcf5d, 0xdf7c, 0xaf9b, 0xbfba, 0x8fd9, 0x9ff8,
X 0x6e17, 0x7e36, 0x4e55, 0x5e74, 0x2e93, 0x3eb2, 0x0ed1, 0x1ef0
X };
X
X/* get a byte from data stream -- timeout if "seconds" elapses */
X
Xint timedout;
X
Xint
Xreadbyte(seconds)
Xint seconds;
X{
X int force_it();
X char c;
X signal(SIGALRM, force_it);
X
X timedout = 0;
X alarm(seconds);
X read(0, &c, 1);
X alarm(0);
X if (timedout)
X {
X if (DEBUG)
X fprintf(LOGFP, "DEBUG: readbyte TIMEOUT\n");
X return(TIMEOUT);
X }
X if (DEBUG)
X fprintf(LOGFP, "DEBUG: readbyte %02xh\n", c & 0xff);
X return(c & 0xff);
X}
X
Xint
Xforce_it()
X{
X timedout++;
X return;
X}
X
X
X/* flush input stream */
X
Xflushin()
X {
X/* No good way to do this without select */
X/* Perhaps....but we waste 1 second with every call!
X while (readbyte(1) != TIMEOUT)
X ;
X*/
X }
X
X/*
X get a buffer (length bufsize) from data stream -- timeout if "seconds" elapses.
X Read bunches of characters to save system overhead;
X Further process data while kernel is reading stream (calculating "checksum").
X Try to nap long enough so kernel collects 100 characters or so until we wake up
X unless TOOBUSY is set.
X*/
X
X
Xint
Xreadbuf(bufsize, seconds, tmode, amode, recvsectcnt, checksum, bufctr)
X
Xint bufsize, /* number of chars to be read */
Xseconds, /* timeout period for each read */
Xtmode, /* transmission mode: TRUE if text */
Xamode, /* transmission mode: TRUE if apple macintosh */
X*checksum, /* pointer to checksum value */
X*bufctr; /* length of actual data string in buffer */
Xlong recvsectcnt; /* running sector count (128 byte sectors) */
X
X{
X int force_it();
X int numread; /* number of chars read */
X int left; /* number of chars left to read */
X int recfin = 0; /* flag that EOF read */
X char inbuf[BBUFSIZ]; /* buffer for incoming packet */
X register unsigned char c; /* character being processed */
X register unsigned short chksm; /* working copy of checksum */
X register int bfctr; /* working copy of bufctr */
X int j; /* loop index */
X char *sectdisp();
X
X signal(SIGALRM, force_it);
X chksm = 0;
X bfctr = 0;
X
X for (left = bufsize; left > 0;) {
X
X /* read however many chars are waiting */
X timedout = 0;
X alarm(seconds);
X numread = read(0, inbuf, left);
X alarm(0);
X if (timedout)
X return(TIMEOUT);
X left -= numread;
X
X if (DEBUG)
X fprintf(LOGFP, "DEBUG: readbuf--read %d characters\n", numread);
X
X /* now process part of packet we just read */
X
X for (j = 0; j < numread; j++)
X {
X buff[bfctr] = c = inbuf[j] & 0xff;
X fileread++;
X
X if (CRCMODE) /* CRC */
X chksm = (chksm<<B) ^ crctab[(chksm>>(W-B)) ^ c];
X
X else /* checksum */
X chksm = ((chksm+c) & 0xff);
X
X if (CHECKLENGTH && fileread > filelength) /* past EOF ? */
X continue;
X
X if (tmode) /* text mode processing */
X {
X buff[bfctr] &= 0x7f; /* nuke bit 8 */
X if (c == CR || c == 0) /* skip CRs and nulls */
X continue;
X else if (c == CTRLZ) /* CP/M EOF char */
X {
X recfin = TRUE;
X continue;
X }
X else if (!recfin) /* don't increment if past EOF */
X bfctr++;
X }
X else if (amode) /* Apple macintosh text mode processing */
X {
X buff[bfctr] &= 0x7f; /* nuke bit 8 */
X if (c == 0) /* skip nulls */
X continue;
X else if (c == CR) /* translate CR to LF */
X buff[bfctr] = LF;
X else if (c == CTRLZ) /* CP/M EOF char */
X {
X recfin = TRUE;
X continue;
X }
X if (!recfin) /* don't increment if past EOF */
X bfctr++;
X }
X else /* binary */
X bfctr++;
X
X }
X
X /* go to sleep to save uneeded system calls while kernel
X is reading data from serial line, fudge constant from 10 to
X 9 to avoid sleeping too long
X */
X if (left && !TOOBUSY)
X sleep ((left<SLEEPNUM ? left:SLEEPNUM) * 9/ttyspeed);
X }
X
X if (CHECKLENGTH && fileread >= filelength)
X logitarg("File end from YMODEM length found in sector %s\n",
X sectdisp(recvsectcnt,bufsize,1));
X *checksum = chksm;
X *bufctr = bfctr;
X return(0);
X}
X
X/* send a byte to data stream */
X
Xsendbyte(data)
Xchar data;
X {
X if (DEBUG)
X fprintf(LOGFP, "DEBUG: sendbyte %02xh\n", data & 0xff);
X
X if (write(1, &data, 1) != 1) /* write the byte (assume it goes NOW; no flushing needed) */
X error ("Write error on stream", TRUE);
X return;
X }
X
X/* send a buffer to data stream */
X
Xwritebuf(buffer, nbytes)
Xchar *buffer;
Xint nbytes;
X {
X if (DEBUG)
X fprintf(LOGFP, "DEBUG: writebuf (%d bytes)\n", nbytes);
X
X if (write(1, buffer, nbytes) != nbytes) /* write the buffer (assume no TIOCFLUSH needed) */
X error ("Write error on stream", TRUE);
X return;
X }
X
X/* set and restore tty modes for XMODEM transfers */
X
Xstruct termio ttys;
Xstruct stat statbuf; /* for terminal message on/off control */
X
Xint wason; /* holds status of tty read write/modes */
Xchar *tty; /* current tty name */
X
X
Xsetmodes()
X {
X char *ttyname();
X struct termio ttysnew;
X
X extern onintr();
X
X sleep(2); /* let the output appear */
X if (ioctl(0,TCGETA,&ttys)<0) /* get tty params */
X error("Can't get TTY Parameters", TRUE);
X
X tty = ttyname(0); /* identify current tty */
X
X if (ioctl(0,TCGETA,&ttysnew)<0) /* get tty params */
X error("Can't get TTY Parameters", TRUE);
X ttysnew.c_cc[4] = 1; /* VMIN */
X ttysnew.c_cc[5] = 0; /* VTIME */
X ttysnew.c_iflag = 0;
X ttysnew.c_oflag = 0;
X ttysnew.c_lflag = 0;
X ttysnew.c_cflag &= ~CSIZE;
X ttysnew.c_cflag |= CS8;
X ttysnew.c_cflag &= ~PARENB;
X if (ioctl(0,TCSETA,&ttysnew)<0) /* set new paramters */
X error("Can't set new TTY Parameters", TRUE);
X
X if (stat(tty, &statbuf) < 0) /* get tty modes */
X {
X logit("Can't get your TTY Status\n");
X tlogit("Can't get your TTY Status\n");
X wason = FALSE;
X }
X else
X {
X if (statbuf.st_mode & 022)
X {
X if (chmod(tty, (int)statbuf.st_mode & ~022) < 0)
X {
X logit("Can't change TTY mode\n");
X tlogit("Can't change TTY mode\n");
X wason = FALSE;
X }
X else
X wason = TRUE;
X }
X else
X wason = FALSE;
X }
X
X
X /* set up signal catcher to restore tty state if we are KILLed */
X
X if (signal(SIGTERM, SIG_IGN) != SIG_IGN)
X signal(SIGTERM, onintr);
X }
X
X/* restore normal tty modes */
X
Xrestoremodes(errcall)
Xint errcall;
X {
X if (wason)
X if (chmod(tty, (int)statbuf.st_mode | 022) < 0)
X error("Can't change TTY mode", FALSE);
X if (ioctl(0,TCSETA,&ttys) < 0)
X { if (!errcall)
X error("RESET - Can't restore normal TTY Params", FALSE);
X else
X printf("RESET - Can't restore normal TTY Params\n");
X }
X if (signal(SIGTERM, SIG_IGN) != SIG_IGN)
X signal(SIGTERM, SIG_DFL);
X return;
X }
X
X
X
X
X/* signal catcher */
Xonintr()
X {
X error("Kill signal; bailing out", TRUE);
X }
X
X/* create string with a timestamp for log file */
X
Xchar *stamptime()
X{
X char *asctime(); /* stuff to get timestamp */
X struct tm *localtime(), *tp;
X long now;
X
X time(&now);
X tp = localtime(&now);
X return(asctime(tp));
X}
X
X
X
X/* get tty speed for time estimates */
X
Xgetspeed()
X {
X static int speedtbl[] = {0, 50, 75, 110, 134, 150, 200, 300, 600,
X 1200, 1800, 2400, 4800, 9600, 19200, 0};
X struct termio ttystemp;
X
X if (ioctl(0,TCGETA,&ttystemp) < 0) /* get tty structure */
X error("Can't get TTY parameters", FALSE);
X if ((ttystemp.c_cflag & 017) >= 0 && (ttystemp.c_cflag & 017) <= 14)
X {
X ttyspeed = speedtbl[ttystemp.c_cflag & 017];
X logitarg ("Line speed = %d bits per second\n", ttyspeed);
X }
X else
X {
X ttyspeed = 1200;
X logit ("Can't determine line speed; assuming 1200 bps\n");
X }
X }
X
X
X/* turn off keyboard stop signal so stray ^X don't put us in background */
X
Xstopsig()
X {
X }
END_OF_FILE
if test 11185 -ne `wc -c <'pf-bootstrap-v1.1a/xmodem-3.9/getput.sysv.c'`; then
echo shar: \"'pf-bootstrap-v1.1a/xmodem-3.9/getput.sysv.c'\" unpacked with wrong size!
fi
# end of 'pf-bootstrap-v1.1a/xmodem-3.9/getput.sysv.c'
fi
if test -f 'pf-bootstrap-v1.1a/xmodem-3.9/send.c' -a "${1}" != "-c" ; then
echo shar: Will not clobber existing file \"'pf-bootstrap-v1.1a/xmodem-3.9/send.c'\"
else
echo shar: Extracting \"'pf-bootstrap-v1.1a/xmodem-3.9/send.c'\" \(12219 characters\)
sed "s/^X//" >'pf-bootstrap-v1.1a/xmodem-3.9/send.c' <<'END_OF_FILE'
X/** send a file **/
X
X/*
X * Operation of this routine depends on on MDM7BAT and YMDMBAT flags.
X *
X * If "name" is NULL; close out the BATCH send.
X */
X
X#include "xmodem.h"
X
Xsfile(name)
Xchar *name;
X {
X
X char *sectdisp();
X time_t time();
X char *strcpy();
X char *unix_cpm();
X char *cpmify();
X long countnl();
X
X extern unsigned short crctab[1<<B]; /* CRC-16 constant values, see getput.c */
X
X register int bufctr, /* array index for data buffer */
X sectnum; /* packet number for packet header */
X
X register unsigned short checksum; /* checksum/crc */
X
X char blockbuf[BBUFSIZ+6]; /* holds packet as it is constructed */
X
X struct stat filestatbuf; /* file status info */
X
X int fd, /* file descriptor for file being transmitted */
X attempts, /* number of attempts made to transmit a packet */
X nlflag, /* flag that we have to send a LF in next packet */
X sendfin, /* flag that we are sending the last packet */
X closeout, /* flag that we are closing out batch send */
X startup, /* flag that we are starting batch send */
X tmode, /* TRUE for text mode */
X amode, /* TRUE for apple mode */
X filepack, /* TRUE when sending first packet */
X buf1024, /* TRUE when sending 1K packets */
X bbufcnt, /* array index for packet */
X firstchar, /* first character in protocol transaction */
X bufsize, /* packet size (128 or 1024) */
X sendresp; /* response char to sent block received from remote*/
X long sentsect; /* count of 128 byte sectors actually sent */
X long expsect; /* count of 128 byte sectors expected to be sent */
X time_t start; /* starting time of transfer */
X char c;
X
X nbchr = 0; /* clear buffered read char count */
X
X CRCMODE = FALSE; /* Receiver determines use of crc or checksum */
X YMODEMG = FALSE; /* Receiver determines use YMODEM-G */
X
X buf1024 = LONGPACK; /* set packet size flag to command line switch */
X
X closeout = FALSE; startup = TRUE; filepack = FALSE; /* indicate state of batch transfer */
X
X tmode = (XMITTYPE == 't') ? TRUE : FALSE; /* set text mode */
X amode = (XMITTYPE == 'a') ? TRUE : FALSE; /* set apple mode */
X
X /* Check on NULL file name */
X if (strcmp(name,"") == 0)
X {
X if (BATCH)
X closeout = TRUE;
X else
X {
X sendbyte(CAN); sendbyte(CAN); sendbyte(CAN);
X error("NULL file name in send", TRUE);
X }
X }
X
X if (!closeout) /* Are we closing down batch? */
X { /* no; let's send a file */
X logit("----\nXMODEM Send Function\n");
X tlogit("----\nXMODEM Send Function\n");
X
X if ((fd = open(name, 0)) < 0)
X {
X sendbyte(CAN); sendbyte(CAN); sendbyte(CAN);
X error("Can't open file for send", TRUE);
X }
X
X stat(name, &filestatbuf); /* get file status bytes */
X if (tmode) /* count up NLs */
X filestatbuf.st_size += countnl(fd);
X expsect = (filestatbuf.st_size/128) + 1;
X
X if (LOGFLAG)
X {
X fprintf(LOGFP, "File Name: %s\n", name);
X fprintf(LOGFP,"File Size %ldK, %ld Records, %ld Bytes\n",
X (filestatbuf.st_size/1024)+1, expsect, filestatbuf.st_size);
X projtime(expsect, LOGFP);
X }
X if (TIPFLAG)
X {
X fprintf(stderr, "File Name: %s\n", name);
X fprintf(stderr,"File Size %ldK, %ld Records, %ld Bytes\n",
X (filestatbuf.st_size/1024)+1, expsect, filestatbuf.st_size);
X projtime(expsect, stderr);
X }
X }
X else
X {
X logit("----\nXMODEM Send Function\n");
X logit("Closing down Batch Transmission\n");
X tlogit("Closing down Batch Transmission\n");
X }
X
X
X bufsize = buf1024 ? 1024 : 128; /* set sector size */
X if (buf1024 && !closeout)
X {
X logit("1K packet mode chosen on command line\n");
X tlogit("1K packet mode chosen on command line\n");
X }
X
X sendfin = nlflag = FALSE;
X attempts = 0;
X
X /* wait for and read startup character */
Xrestart:
X do
X {
X while (((firstchar=readbyte(1)) != NAK) && (firstchar != CRCCHR) && (firstchar != GCHR) && (firstchar != CAN))
X if (++attempts > NAKMAX)
X {
X if (MDM7BAT && startup)
X {
X sendbyte(ACK); sendbyte(EOT);
X }
X error("Remote System Not Responding", TRUE);
X }
X
X if ((firstchar & 0x7f) == CAN)
X if (readbyte(3) == CAN)
X error("Send Canceled by CAN-CAN",TRUE);
X
X if (firstchar == GCHR)
X {
X CRCMODE = TRUE;
X YMODEMG = TRUE;
X CANCAN = TRUE;
X if (!closeout)
X {
X logit("Receiver invoked YMODEM-G and CRC modes\n");
X tlogit("Receiver invoked YMODEM-G and CRC modes\n");
X }
X }
X if (firstchar == CRCCHR)
X {
X CRCMODE = TRUE;
X if (!closeout)
X {
X logit("Receiver invoked CRC mode\n");
X tlogit("Receiver invoked CRC mode\n");
X }
X if (readbyte(1) == KCHR)
X {
X buf1024 = TRUE;
X logit("Receiver invoked 1K packet mode\n");
X tlogit("Receiver invoked 1K packet mode\n");
X }
X }
X }
X while (firstchar != NAK && firstchar != CRCCHR && firstchar != GCHR);
X
X if (MDM7BAT && closeout) /* close out MODEM7 batch */
X {
X sendbyte(ACK); sendbyte (EOT);
X flushin(); readbyte(2); /* flush junk */
X return;
X }
X
X if (MDM7BAT && startup) /* send MODEM7 file name */
X {
X if (send_name(unix_cpm(name)) == -1)
X {
X attempts = 0;
X goto restart;
X }
X startup = FALSE;
X attempts = 0;
X goto restart;
X }
X
X sectnum = 1;
X
X if (YMDMBAT) /* Fudge for YMODEM transfer (to send name packet) */
X {
X sectnum = 0;
X bufsize = 128;
X filepack = TRUE;
X }
X
X attempts = sentsect = 0;
X start = time((time_t *) 0);
X
X do /* outer packet building/sending loop; loop till whole file is sent */
X {
X
X if (closeout && YMDMBAT && sectnum == 1) /* close out YMODEM */
X return;
X
X if (YMDMBAT && sectnum == 1) /* get set to send YMODEM data packets */
X {
X bufsize = buf1024 ? 1024 : 128;
X
X do /* establish handshaking again */
X {
X while (((firstchar=readbyte(2)) != CRCCHR) && (firstchar != GCHR) && (firstchar != NAK) && (firstchar != CAN))
X if (++attempts > ERRORMAX)
X error("YMODEM protocol botch, C or G expected", TRUE);
X if ((firstchar&0x7f) == CAN)
X if (readbyte(3) == CAN)
X error("Send Canceled by CAN-CAN", TRUE);
X }
X while ((firstchar != CRCCHR) && (firstchar != GCHR) && (firstchar != NAK));
X
X attempts = 0;
X }
X
X if ((bufsize == 1024) && (attempts > KSWMAX))
X {
X logit("Reducing packet size to 128 due to excessive errors\n");
X tlogit("Reducing packet size to 128 due to excessive errors\n");
X bufsize = 128;
X }
X
X if ((bufsize == 1024) && ((expsect - sentsect) < 8))
X {
X logit("Reducing packet size to 128 for tail end of file\n");
X tlogit("Reducing packet size to 128 for tail end of file\n");
X bufsize = 128;
X }
X
X if (sectnum > 0) /* data packet */
X {
X for (bufctr=0; bufctr < bufsize;)
X {
X if (nlflag)
X {
X buff[bufctr++] = LF; /* leftover newline */
X nlflag = FALSE;
X }
X if (getbyte(fd, &c) == EOF)
X {
X sendfin = TRUE; /* this is the last sector */
X if (!bufctr) /* if EOF on sector boundary */
X break; /* avoid sending extra sector */
X buff[bufctr++] = CTRLZ; /* pad with Ctrl-Z for CP/M EOF (even do for binary files) */
X continue;
X }
X
X if (tmode && c == LF) /* text mode & Unix newline? */
X {
X buff[bufctr++] = CR; /* insert carriage return */
X if (bufctr < bufsize)
X buff[bufctr++] = LF; /* insert LF */
X else
X nlflag = TRUE; /* insert on next sector */
X }
X else if (amode && c == LF) /* Apple mode & Unix newline? */
X buff[bufctr++] = CR; /* substitute CR */
X else
X buff[bufctr++] = c; /* copy the char without change */
X }
X
X if (!bufctr) /* if EOF on sector boundary */
X break; /* avoid sending empty sector */
X }
X
X else /* YMODEM filename packet */
X {
X for (bufctr=0; bufctr<1024; bufctr++) /* zero packet */
X buff[bufctr]=0;
X if (!closeout)
X {
X strcpy((char *)buff, cpmify(name));
X
X /* put in file name, length, mode, */
X /* dummy SN, files, bytes remaining and file type */
X {
X register char *p;
X p = (char *)buff + strlen(buff) + 1;
X sprintf(p, "%lu %lo %o 0 %d %ld 0", filestatbuf.st_size,
X filestatbuf.st_mtime, filestatbuf.st_mode,
X yfilesleft, ytotleft);
X if (DEBUG)
X fprintf(LOGFP, "DEBUG: YMODEM header information: %s %s\n", buff, p);
X }
X if (buff[125]) /* need to have long packet? */
X {
X bufsize = 1024;
X if (DEBUG)
X fprintf(LOGFP, "DEBUG: YMODEM header sent in 1024 byte packet\n");
X }
X buff[bufsize-2] = (expsect & 0xff); /* put in KMD kludge information */
X buff[bufsize-1] = ((expsect >> 8) & 0xff);
X
X /* update totals */
X ytotleft -= filestatbuf.st_size;
X if (--yfilesleft <= 0)
X ytotleft = 0;
X if (ytotleft < 0)
X ytotleft = 0;
X }
X }
X
X bbufcnt = 0; /* start building block to be sent */
X blockbuf[bbufcnt++] = (bufsize == 1024) ? STX : SOH; /* start of packet char */
X blockbuf[bbufcnt++] = sectnum; /* current sector # */
X blockbuf[bbufcnt++] = ~sectnum; /* and its complement */
X
X checksum = 0; /* initialize checksum */
X for (bufctr=0; bufctr < bufsize; bufctr++)
X {
X blockbuf[bbufcnt++] = buff[bufctr];
X
X if (CRCMODE)
X checksum = (checksum<<B) ^ crctab[(checksum>>(W-B)) ^ buff[bufctr]];
X
X else
X checksum = ((checksum+buff[bufctr]) & 0xff);
X }
X
X if (CRCMODE) /* put in CRC */
X {
X checksum &= 0xffff;
X blockbuf[bbufcnt++] = ((checksum >> 8) & 0xff);
X blockbuf[bbufcnt++] = (checksum & 0xff);
X }
X else /* put in checksum */
X blockbuf[bbufcnt++] = checksum;
X
X attempts = 0;
X
X do /* inner packet loop */
X {
X
X writebuf(blockbuf, bbufcnt); /* write the block */
X if (!YMODEMG)
X flushin(); /* purge anything in input queue */
X
X if (DEBUG)
X fprintf (LOGFP, "DEBUG: %d byte Packet %02xh (%02xh) sent, checksum %02xh %02xh\n",
X bbufcnt, blockbuf[1]&0xff, blockbuf[2]&0xff, blockbuf[bufsize+3]&0xff, blockbuf[bufsize+4]&0xff);
X
X attempts++;
X sendresp = (YMODEMG) ? ACK : readbyte(10); /* get response from remote (or fake it for YMODEM-G) */
X
X if (sendresp != ACK)
X {
X if (sendresp == TIMEOUT)
X {
X logitarg("Timeout on sector %s\n",sectdisp(sentsect,bufsize,1));
X tlogitarg("Timeout on sector %s\n",sectdisp(sentsect,bufsize,1));
X }
X if (sendresp == CAN)
X {
X if (CANCAN)
X {
X if (readbyte(3) == CAN)
X error("Send Canceled by CAN-CAN",TRUE);
X }
X else
X {
X logitarg("ignored CAN on sector %s\n",sectdisp(sentsect,bufsize,1));
X tlogitarg("ignored CAN on sector %s\n",sectdisp(sentsect,bufsize,1));
X }
X }
X else if (sendresp == NAK)
X {
X logitarg("NAK on sector %s\n",sectdisp(sentsect,bufsize,1));
X tlogitarg("NAK on sector %s\n",sectdisp(sentsect,bufsize,1));
X }
X else
X {
X logitarg("Non-ACK on sector %s\n",sectdisp(sentsect,bufsize,1));
X tlogitarg("Non-ACK on sector %s\n",sectdisp(sentsect,bufsize,1));
X }
X }
X }
X while((sendresp != ACK) && (attempts < ERRORMAX)); /* close of inner loop */
X
X sectnum++; /* increment to next sector number */
X if (!filepack)
X sentsect += (bufsize == 128) ? 1 : 8;
X filepack = FALSE;
X if (TIPFLAG && sentsect % 32 == 0)
X tlogitarg("Sector %s sent\n", sectdisp(sentsect,bufsize,0));
X }
X while (!sendfin && ( attempts < ERRORMAX)); /* end of outer loop */
X
X if (attempts >= ERRORMAX)
X {
X sendbyte(CAN); sendbyte(CAN); sendbyte(CAN); sendbyte(CAN); sendbyte(CAN);
X error ("Too many errors in transmission", TRUE);
X }
X
X sendbyte(EOT); /* send 1st EOT to close down transfer */
X attempts = 0;
X
X while ((readbyte(15) != ACK) && (attempts++ < EOTMAX)) /* wait for ACK of EOT */
X {
X if (attempts > 1)
X {
X logitarg("EOT not ACKed, try %d\n", attempts);
X tlogitarg("EOT not ACKed, try %d\n", attempts);
X }
X sendbyte(EOT);
X }
X
X if (attempts >= RETRYMAX)
X error("Remote System Not Responding on Completion", TRUE);
X
X close(fd);
X
X logit("Send Complete\n");
X tlogit("Send Complete\n");
X if (LOGFLAG)
X prtime(sentsect, time((time_t *) 0) - start, LOGFP);
X if (TIPFLAG)
X prtime(sentsect, time((time_t *) 0) - start, stderr);
X }
END_OF_FILE
if test 12219 -ne `wc -c <'pf-bootstrap-v1.1a/xmodem-3.9/send.c'`; then
echo shar: \"'pf-bootstrap-v1.1a/xmodem-3.9/send.c'\" unpacked with wrong size!
fi
# end of 'pf-bootstrap-v1.1a/xmodem-3.9/send.c'
fi
if test -f 'pf-bootstrap-v1.1a/xmodem-3.9/xmodem.1' -a "${1}" != "-c" ; then
echo shar: Will not clobber existing file \"'pf-bootstrap-v1.1a/xmodem-3.9/xmodem.1'\"
else
echo shar: Extracting \"'pf-bootstrap-v1.1a/xmodem-3.9/xmodem.1'\" \(10889 characters\)
sed "s/^X//" >'pf-bootstrap-v1.1a/xmodem-3.9/xmodem.1' <<'END_OF_FILE'
X.TH XMODEM LOCAL "November 2, 1990"
X.UC 4.2
X.SH NAME
Xxmodem \- Christensen protocol file transfer utility \- Version 3.9, November 1990
X.SH SYNOPSIS
X.B xmodem
X[\fBst|sb|sa|rt|rb|ra\fR][\fBygmkctdlxpwen\fR]
X[file...]
X.br
X.SH DESCRIPTION
XThe
X.I xmodem
Xprogram implements the Christensen (XMODEM) file transfer
Xprotocol for moving files between 4.2/4.3BSD Unix systems (and successors,
Xincluding Suns) and microcomputers.
XThe XMODEM/CRC protocol, the MODEM7 batch protocol, the XMODEM-1K
Xblock protocol, the YMODEM batch protocol and the YMODEM-G streaming protocol
Xare all supported by
X.IR xmodem .
XThe ZMODEM protocol is not supported.
XFor details of the XMODEM/YMODEM protocols,
Xsee the document edited by Chuck Forsberg titled
X.I
XXMODEM/YMODEM Protocol Reference.
X.sp
XOption Flags are case insensitive; the cluster of flags
Xmay be preceded by an optional "-"
Xcharacter.
X.PP
X.SH PARAMETERS
XExactly one of the following must be selected:
X.TP
X.B rb
XReceive Binary - files are placed on the Unix disk without conversion.
X.I Xmodem
Xwill silently destroy existing files of the same name.
X.TP
X.B rt
XReceive Text - files are converted from the CP/M and MS-DOS
Xformat of CR-LF pairs to the Unix convention of newline
Xcharacters only between lines.
XNull bytes are ignored and bit 8 of each character is stripped (which makes
XWordstar files much more readable).
XA CTRL-Z character is deemed to indicate the EOF location in the incoming
Xfile.
XThe resulting file
Xis acceptable to the Unix editors and compilers, and is usually slightly
Xsmaller than the original file.
X.I Xmodem
Xwill silently destroy existing files of the same name.
X.TP
X.B ra
XReceive Apple - same as rt save CR characters in the incoming file are
Xtranslated into Unix newline characters.
X.TP
X.B sb
XSend Binary - files are sent without conversion as they exist on the Unix disk.
X.TP
X.B st
XSend Text - newline characters in the file are converted to CR-LF pairs
Xin accord with the CP/M and MS-DOS conventions for text files. The file
X"grows" in this process.
X.TP
X.B sa
XSend Apple - same as st save newline characters are converted into CR
Xcharacters in accord with Apple Macintosh conventions for text files.
X.PP
X.SH OPTIONS
X.TP
X.B y
XSelect the YMODEM batch protocol for sending files; a list of files specified
Xon the command line will be sent in sequence. The YMODEM batch protocol is
Xused automatically for file reception if the sending program requests it.
XIf this flag is specified for a batch receive, (\fIxmodem rty\fR, for example),
Xthe transfer will never attempt to switch from CRC to checksum mode.
X.TP
X.B g
XSelect the YMODEM-G variant of YMODEM when receiving files. YMODEM-G is
Xautomatically invoked on transmit if the receiving program requests it.
XYMODEM-G is designed for "error-free" connections with proper flow control;
Xthe transmitting program blasts packets to the receiver as fast as it can
Xwithout waiting for acknowledgements. Any errors cause the entire file
Xtransfer to be aborted.
X.TP
X.B m
XSelect the MODEM7 batch protocol for sending files; a list of files specified
Xon the command line will be sent in sequence. The MODEM7 batch protocol is
Xused automatically for file reception if the sending program requests it.
XIf this flag is specified for a batch receive, (\fIxmodem rbm\fR, for example),
Xthe transfer starts in checksum mode rather than CRC mode. If both "m" and
X"c" are specified on a receive command, the initial "file-name" negotiations
Xare done using checksums while the file transfers are done using CRC-16.
X.TP
X.B k
XSelect the XMODEM-1K file transfer mode for sending files. Use of 1K packets on
Xlow-error lines increases throughput.
XHowever, over direct connections at 9600 bps to a busy host, 1K packets may
Xcause data overflows generating excessive retries.
X1K packets are automatically
Xused for file reception if the sending program requests it.
XIf this flag is specified with the YMODEM flag in a batch receive (\fIxmodem
Xrbyk\fR, for example), the program will attempt to use the "KMD/IMP" convention
Xto invoke 1K file transfers.
X.TP
X.B c
XSelect the CRC-16 error-checking protocol on receive. CRC mode is better at catching
Xtransmission errors that occur than the alternative checksum protocol.
XCRC mode is automatically selected for file
Xtransmission if the receiving modem program requests it.
X.TP
X.B t
XIndicates the Unix system is Too Busy and
X.I xmodem
Xshould fall back to a simpler I/O strategy than normal.
X.TP
X.B d
XDelete the
X.I xmodem.log
Xfile before file transfer is begun.
X.TP
X.B l
XDo NOT write to the log file. If logging is selected, a file
X.I xmodem.log
Xwill be created (or appended to), with entries for significant events, errors
Xand retries. This can be useful to see why things went wrong
Xwhen they do.
X.TP
X.B x
XToggle on debug mode. If debug mode is selected, copious and possibly
Xuseful debugging information will be placed in
X.IR xmodem.log .
X.TP
X.B p
XAssume that
X.I xmodem
Xis being invoked through SunOS tip (via the ~C command). Status and error
Xmessages will be sent to stderr, and hence to your screen, while the transfer
Xis in progress.
X.B Do
X.B not
Xuse this option unless you are using tip!
X.TP
X.B w
XWait 15 seconds before initiating the startup handshake. Useful if handshake
Xcharacters are trashing things you need to type.
X.TP
X.B e
XSuppress EOT verification.
XNormally,
X.I xmodem
Xtries to verify an EOT character (used to signify the end of file) by
XNAKing it and waiting for the EOT to be resent. This reliability feature
Xcan generate harmless error messages in some microcomputer file transfer
Xprograms; other programs refuse to work at all. To accomodate the latter
Xbrain-damaged programs, use the "e" option.
X.TP
X.B n
XAllow CAN-CAN aborts during mid-transfer. Normally, as a reliability feature,
XCAN-CAN aborts are only allowed at the beginning of a file transfer. If you
Xdon't like this feature, use the "n" flag.
X.SH "FILE NAMES"
XFiles transmitted using one of the batch modes
Xwill be stored on the remote machine under a CP/M-ified name (path names
Xstripped, limited
Xto eight characters plus a three character extension; ":" characters will
Xbe turned into "/" characters; all characters will be in monocase).
XFiles received using one of the batch modes
Xwill be stored under their transmitted names (except that any "/" characters
Xin the file name will be converted into ":" characters, all upper-case
Xcharacters will be translated into lower case and trailing dots will be
Xexpunged).
X.PP
XWhen a batch receive is requested,
X.I xmodem
Xtakes a wait and see attitude and can adapt to either batch protocol or even
Xa classic XMODEM transfer (note that CRC-16 mode is automatically set under
Xthese circumstances unless the b flag is specified).
XIf a classic, "non-batch" XMODEM file reception takes place,
Xthe received file is stored as
X.IR xmodem.in .
XFile names present on the command line for a batch receive are ignored.
X.SH NOTES
XRemember, CRC-16 error detection and YMODEM-G streaming must be invoked by
Xthe
X.B receiving
Xprogram while 1K blocksize must be invoked by the
X.B sending
Xprogram.
X.PP
XWhile waiting for the beginning of a file transfer,
X.I xmodem
Xtreats two CAN (CTRL-X) characters that are received within 3 seconds
Xas a request to abort. CAN characters will not cause an abort if received
Xin the midst of a file transfer (unless the "n" option was invoked).
X.PP
XIf 10 or more errors are detected during the transmission or reception of any
Xone packet, the transfer is aborted.
X.PP
XSqueezed, compressed, ZIPed or ARCed files must be transferred in binary mode,
Xeven if they contain text.
X.PP
XIf you use
X.I xmodem
Xover a
X.I rlogin
Xlink, you may have to use the form
X.IR "rlogin machine -8" .
X.PP
XIf an unexpected error occurs before a file is completely received, the
Xincomplete file is deleted.
X.PP
XFiles received using both binary and text mode in a YMODEM batch transfer
Xwill be truncated
Xto the file size specified in the YMODEM header (extra CR characters in the
Xincoming file are correctly handled). File sizes are included in
Xthe YMODEM header when sending both binary and text files. Thus files
Xtransferred via YMODEM should preserve their exact length.
XFile modification times are set for received files if present in the YMODEM
Xheader; they are included in the headers for transmitted files (watch for
Xtimezone problems, however).
X.PP
XThe "KMD/IMP" record count field in the YMODEM header is both set and read.
X.PP
X.I xmodem
Xcan be used through the SunOS
X.I tip
Xprogram to transfer files. Use
X.I tip
Xto establish a session on a remote computer. Enter the file transfer
Xcommand on the remote computer to send or receive files, then use the ~C
Xcommand which causes
X.I tip
Xto request a local command string and enter the appropriate
X.I xmodem
Xcommand. Use the "p" option on the local
X.I xmodem
Xcommand so you will see status reports on your screen.
XIf the
X.I xmodem
Xis running on the remote machine, use the "w" option there to halt the
Xinitiation of file-transfer handshaking for a bit to allow you to enter the ~C
Xcommand line without interference.
X.PP
XThe MODEM7 batch protocol is archaic and should only be used if YMODEM batch
Xprotocols are not available in your PC's communication program. If you must
Xuse MODEM7, you may have to specify the "m" option or, preferably, "cm"
Xwhen receiving files with
X.IR xmodem .
X.SH EXAMPLES
X.PP
XTo receive a text file transmitted from a micro (using CRC-16
Xerror-checking) and store it under the
Xname
X.IR file.name ,
Xuse the command line
X.RS
X.B "xmodem rtc file.name"
X.RE
XNote that if the transmitting program on the micro uses the 1K packet
Xprotocol and/or the YMODEM batch protocol,
X.I xmodem
Xdetects this automatically and takes appropriate action. Further
Xnote that if one of the batch protocols is used, the received file(s)
Xwill be stored under their own names and the name on the command line
X(if any) will be ignored. Finally, note that CRC-16 error checking is the
Xdefault. Thus, a generic command to receive files would be
X.RS
X.B "xmodem rt"
X.RE
X.PP
XTo send a set of text files to a microcomputer using 1K packets and the
XYMODEM batch protocol, use the command line
X.RS
X.B "xmodem styk *.txt"
X.RE
X.SH FILES
Xxmodem.log (if logging is enabled)
X.SH BUGS
XBatch mode could be smarter about bad file-names in the midst of a
Xbatch transmit/receive.
X.PP
XBatch mode could allow a mixture of binary and text files.
X.PP
XBare Carriage Return characters (i.e., those not immediately followed by a
XLine Feed character) are mishandled in a received file when using text mode.
XA file with "overstruck" lines will thus come out looking funny.
X.SH SEE ALSO
Xkermit(1), rz(1), sz(1)
X.SH AUTHOR
XSteve Grandi, National Optical Astronomy Observatories (grandi@noao.edu).
XBased on
X.I xmodem
Xby Brian Kantor, University of California at San Diego.
XThis, in turn, was based on
X.I umodem
Xby Lauren Weinstein, Richard Conn and others.
END_OF_FILE
if test 10889 -ne `wc -c <'pf-bootstrap-v1.1a/xmodem-3.9/xmodem.1'`; then
echo shar: \"'pf-bootstrap-v1.1a/xmodem-3.9/xmodem.1'\" unpacked with wrong size!
fi
# end of 'pf-bootstrap-v1.1a/xmodem-3.9/xmodem.1'
fi
echo shar: End of archive 5 \(of 9\).
cp /dev/null ark5isdone
MISSING=""
for I in 1 2 3 4 5 6 7 8 9 ; do
if test ! -f ark${I}isdone ; then
MISSING="${MISSING} ${I}"
fi
done
if test "${MISSING}" = "" ; then
echo You have unpacked all 9 archives.
rm -f ark[1-9]isdone ark[1-9][0-9]isdone
else
echo You still need to unpack the following archives:
echo " " ${MISSING}
fi
## End of shell archive.
exit 0