cmd/bnu/cu.c

/*
 * CDDL HEADER START
 *
 * The contents of this file are subject to the terms of the
 * Common Development and Distribution License, Version 1.0 only
 * (the "License").  You may not use this file except in compliance
 * with the License.
 *
 * You can obtain a copy of the license at usr/src/OPENSOLARIS.LICENSE
 * or http://www.opensolaris.org/os/licensing.
 * See the License for the specific language governing permissions
 * and limitations under the License.
 *
 * When distributing Covered Code, include this CDDL HEADER in each
 * file and include the License file at usr/src/OPENSOLARIS.LICENSE.
 * If applicable, add the following below this CDDL HEADER, with the
 * fields enclosed by brackets "[]" replaced with your own identifying
 * information: Portions Copyright [yyyy] [name of copyright owner]
 *
 * CDDL HEADER END
 */
/*
 * Copyright 2005 Sun Microsystems, Inc.  All rights reserved.
 * Use is subject to license terms.
 */

/*  Copyright (c) 1984, 1986, 1987, 1988, 1989 AT&T */
/*    All Rights Reserved   */

#pragma ident   "%Z%%M% %I% %E% SMI"


/*
 * cu [-cdevice] [-sspeed] [-lline] [-bbits] [-h] [-t] [-d] [-n]
 *      [-o|-e] [-L] [-C] telno | systemname [local-cmd]
 *
 *  legal baud rates: 300, 1200, 2400, 4800, 9600, 19200, 38400.
 *
 *  -c is used to specify which device will be used for making the
 *      call.  The device argument is compared to the Type (first)
 *      field in the Devices file, and only those records that
 *      match will be used to make the call.  Either -d or -t
 *      would be more intuitive options designations, but they
 *      are already in use.
 *  -l is for specifying a line unit from the file whose
 *      name is defined in /etc/uucp/Devices.
 *  -b is for forcing the number of bits per character processed on
 *      the connection. Valid values are '7' or '8'.
 *  -h is for half-duplex (local echoing).
 *  -t is for adding CR to LF on output to remote (for terminals).
 *  -d can be used  to get some tracing & diagnostics.
 *  -o or -e is for odd or even parity on transmission to remote.
 *  -n will request the phone number from the user.
 *  -L will cause cu to go through the login chat sequence in the
 *      Systems file.
 *  -C will cause cu to run the local command specified at the end
 *      of the command line, instead of entering interactive mode.
 *  Telno is a telephone number with `=' for secondary dial-tone.
 *  If "-l dev" is used, speed is taken from /etc/uucp/Devices.
 *  Only systemnames that are included in /etc/uucp/Systems may
 *  be used.
 *
 *  Escape with `~' at beginning of line:
 *
 *  ~.  quit,
 *
 *  ~![cmd]         execute shell (or 'cmd') locally,
 *
 *  ~$cmd           execute 'cmd' locally, stdout to remote,
 *
 *  ~%break (alias ~%b) transmit BREAK to remote,
 *  ~%cd [dir]      change directory to $HOME (or 'dir'),
 *  ~%debug (alias ~%d) toggles on/off the program debug trace,
 *  ~%divert        allow unsolicited diversions to files,
 *  ~%ifc (alias ~%nostop)  toggles on/off the DC3/DC1 input control,
 *  ~%ofc (alias ~%noostop) toggles on/off the DC3/DC1 output control,
 *      (certain remote systems cannot cope with DC3 or DC1).
 *  ~%old           recognize old style silent diversions,
 *  ~%put from [to]     put file from local to remote,
 *  ~%take from [to]    take file from remote to local,
 *
 *  ~l          dump communication line ioctl settings,
 *  ~t          dump terminal ioctl settings.
 *
 *  Silent diversions are enabled only for use with the ~%take
 *  command by default for security reasons. Unsolicited diversions
 *  may be enabled using the ~%divert toggle. The 'new-style'
 *  diversion syntax is "~[local]>:filename", and is terminaled
 *  by "~[local]>", where 'local' is the nodename of the local
 *  system. This enables ~%take to operate properly when cu
 *  is used over multiple hops. 'old-style' diversion syntax may
 *  be enabled using the ~%old toggle. ('old-style' diversion
 *  should be avoided!)
 *
 *  Cu no longer uses dial.c to reach the remote.  Instead, cu places
 *  a telephone call to a remote system through the uucp conn() routine
 *  when the user picks the systemname option or through altconn()--
 *  which bypasses /etc/uucp/Systems -- if a telno or direct
 *  line is chosen. The line termio attributes are set in fixline(),
 *  before the remote connection is made.  As a device-lockout semaphore
 *  mechanism, uucp creates an entry in /var/spool/locks whose name is
 *  LK.<MAJ>.<maj>.<min> where MAJ is the major device of the
 *  filesystem containing the device, and <maj> and <min> are the
 *  major and minor of the device.
 *  When cu terminates, for whatever reason, cleanup() must be
 *  called to "release" the device, and clean up entries from
 *  the locks directory.  Cu runs with uucp ownership, and thus provides
 *  extra insurance that lock files will not be left around.
 */

#include "uucp.h"
#include <locale.h>
#include <stropts.h>

#define MID BUFSIZ/2    /* mnemonic */
#define RUB '\177'      /* mnemonic */
#define XON '\21'       /* mnemonic */
#define XOFF    '\23'       /* mnemonic */
#define TTYIN   0       /* mnemonic */
#define TTYOUT  1       /* mnemonic */
#define TTYERR  2       /* mnemonic */
#define HUNGUP  2
#define YES 1       /* mnemonic */
#define NO  0       /* mnemonic */
#define IOERR   4       /* exit code */
#define MAXPATH 100
#define NPL 50

int Sflag=0;
int Cn;             /*fd for remote comm line */
jmp_buf Sjbuf;          /*needed by uucp routines*/

/*  io buffering    */
/*  Wiobuf contains, in effect, 3 write buffers (to remote, to tty  */
/*  stdout, and to tty stderr) and Riobuf contains 2 read buffers   */
/*  (from remote, from tty).  [WR]IOFD decides which one to use.    */
/*  [RW]iop holds current position in each.             */
#define WIOFD(fd)   (fd == TTYOUT ? 0 : (fd == Cn ? 1 : 2))
#define RIOFD(fd)   (fd == TTYIN ? 0 : 1)
#define WMASK(fd)   (fd == Cn ? line_mask : term_mask)
#define RMASK(fd)   (fd == Cn ? line_mask : term_mask)
#define WRIOBSZ 256
static char Riobuf[2*WRIOBSZ];
static char Wiobuf[3*WRIOBSZ];
static int Riocnt[2] = {0, 0};
static char *Riop[2];
static char *Wiop[3];

extern int optind;      /* variable in getopt() */

extern char
    *optarg;

static struct call Cucall;  /* call structure for altconn() */

static int Saved_tty;       /* was TCGETAW of _Tv0 successful?  */
static int Saved_termios;   /* was TCGETSW of _Tv0 successful?  */
static struct termio _Tv, _Tv0; /* for saving, changing TTY atributes */
static struct termios _Tv0s;    /* for saving, changing TTY atributes */
static struct termio _Lv;   /* attributes for the line to remote */
static struct termios _Lvs; /* attributes for the line to remote */
static char prompt[BUFSIZ]= "[";
static struct utsname utsn;
static int command_line_hups = 0;

static char filename[BUFSIZ] = "/dev/null";

static char
    _Cxc,           /* place into which we do character io*/
    _Tintr,         /* current input INTR */
    _Tquit,         /* current input QUIT */
    _Terase,        /* current input ERASE */
    _Tkill,         /* current input KILL */
    _Teol,          /* current secondary input EOL */
    _Myeof,         /* current input EOF */
    term_mask,      /* mask value for local terminal */
    line_mask;      /* mask value for remote line */
                /* either '0177' or '0377' */

int
    Echoe,          /* save users ECHOE bit */
    Echok,          /* save users ECHOK bit */
    Intrupt=NO,     /* interrupt indicator */
    Ifc=YES,        /* NO means remote can't XON/XOFF */
    Ofc=YES,        /* NO means local can't XON/XOFF */
    Rtn_code=0,     /* default return code */
    Divert=NO,      /* don't allow unsolicited redirection */
    OldStyle=NO,        /* don't handle old '~>:filename' syntax */
                /* this will be mandatory in SVR4.1 */
    Takeflag=NO,        /* indicates a ~%take is in progress */
    Dologin=NO,     /* go through the login chat sequence */
    Docmd=NO;       /* execute command instead of interactive cu */

EXTERN int          /* These are initialized in line.c */
    Terminal,       /* flag; remote is a terminal */
    Oddflag,        /* flag- odd parity option*/
    Evenflag,       /* flag- even parity option*/
    Duplex,         /* Unix= full duplex=YES; half = NO */
    term_8bit,      /* is terminal set for 8 bit processing */
    line_8bit;      /* is line set for 8 bit processing */

EXTERN int clear_hup();

pid_t
    Child,          /* pid for receive process */
    Shell;          /* pid for escape process */

static pid_t
    dofork();       /* fork and return pid */

static int
    r_char(),       /* local io routine */
    w_char(),       /* local io routine */
    wioflsh();

static void
    _onintrpt(),        /* interrupt routines */
    _rcvdead(),
    _quit(),
    _bye();

extern void cleanup();
extern void tdmp();
extern int conn(), altconn(), transmit(), tilda();

static void
    recfork(),
    sysname(),
    blckcnt(),
    _flush(),
    _shell(),
    _dopercen(),
    _receive(),
    _mode(),
    _w_str();

extern char *Myline;    /* flag to force the requested line to be used  */
extern char *Mytype;    /* flag to force requested line type to be used
             * rddev() will compare the string to the D_TYPE
             * (first) field of the Devices record and skip any
             * records where they are not equal. Mytype is set
             * to point to the argument of the -c option from
             * the command line. */
static char *P_USAGE= "Usage: %s [-dhtnLC] [-c device] [-s speed] [-l line] [-b 7|8]\n\t[-o | -e] telno | systemname [local-cmd]\n";
static char *P_CON_FAILED = "Connect failed: %s\r\n";
static char *P_Ct_OPEN = "Cannot open: %s\r\n";
static char *P_LINE_GONE = "Remote line gone\r\n";
static char *P_Ct_EXSH = "Can't execute shell\r\n";
static char *P_Ct_DIVERT = "Can't divert to %s\r\n";
static char *P_Ct_UNDIVERT = "Can't end diversion to %s\r\n";
static char *P_Bad_DIVERT = "Won't divert to %s. Unsolicited.\r\n";
static char *P_STARTWITH = "Use `~~' to start line with `~'\r\n";
static char *P_CNTAFTER = "File transmission interrupted after %ld bytes.\r\n";
static char *P_CNTLINES = "%d lines/";
static char *P_CNTCHAR = "%ld characters\r\n";
static char *P_FILEINTR = "File transmission interrupted\r\n";
static char *P_Ct_FK = "Can't fork -- try later\r\n";
static char *P_Ct_SPECIAL = "r\nCan't transmit special character `%#o'\r\n";
static char *P_TOOLONG = "\nLine too long\r\n";
static char *P_IOERR = "r\nIO error\r\n";
static char *P_USECMD = "Use `~$'cmd \r\n";
#ifdef forfutureuse
static char *P_USEPLUSCMD ="Use `~+'cmd \r\n";
#endif
#ifdef u3b
static char *P_NOTERMSTAT = "Can't get terminal status\r\n";
static char *P_3BCONSOLE = "Sorry, you can't cu from a 3B console\r\n";
#endif
static char *P_TELLENGTH = "Telno cannot exceed 58 digits!\r\n";

/***************************************************************
 *  main: get command line args, establish connection, and fork.
 *  Child invokes "receive" to read from remote & write to TTY.
 *  Main line invokes "transmit" to read TTY & write to remote.
 ***************************************************************/

int
main(argc, argv)
int argc;
char *argv[];
{
    extern void setservice();
    extern int sysaccess();
    char s[MAXPH];
    char *string;
    int i;
    int errflag=0;
    int lflag=0;
    int nflag=0;
    int systemname = 0;
    char vdisable;

    /* Set locale environment variables local definitions */
    (void) setlocale(LC_ALL, "");
#if !defined(TEXT_DOMAIN)   /* Should be defined by cc -D */
#define TEXT_DOMAIN "SYS_TEST"  /* Use this only if it wasn't */
#endif
    (void) textdomain(TEXT_DOMAIN);

    Riop[0] = &Riobuf[0];
    Riop[1] = &Riobuf[WRIOBSZ];
    Wiop[0] = &Wiobuf[0];
    Wiop[1] = &Wiobuf[WRIOBSZ];
    Wiop[2] = &Wiobuf[2*WRIOBSZ];

    Verbose = 1;        /*for uucp callers,  dialers feedback*/
    if ((string = strrchr(argv[0], '/')) != NULL)
    string++;
    else
    string = argv[0];
    if (strlcpy(Progname, string, NAMESIZE) >= NAMESIZE) {
    errno = ENAMETOOLONG;
    perror("cu");
    exit(1);
    }
    setservice(Progname);
    if ( sysaccess(EACCESS_SYSTEMS) != 0 ) {
    (void)fprintf(stderr,
         gettext("%s: Cannot read Systems files\n"), Progname);
    exit(1);
    }
    if ( sysaccess(EACCESS_DEVICES) != 0 ) {
    (void)fprintf(stderr,
         gettext("%s: Cannot read Devices files\n"), Progname);
    exit(1);
    }
    if ( sysaccess(EACCESS_DIALERS) != 0 ) {
    (void)fprintf(stderr,
        gettext("%s: Cannot read Dialers files\n"), Progname);
    exit(1);
    }

    Cucall.speed = "Any";   /*default speed*/
    Cucall.line = CNULL;
    Cucall.telno = CNULL;
    Cucall.type = CNULL;

/*Flags for -h, -t, -e, and -o options set here; corresponding line attributes*/
/*are set in fixline() in culine.c before remote connection is made    */

    while((i = getopt(argc, argv, "dhteons:l:c:b:LCH")) != EOF)
    switch(i) {
        case 'd':
        Debug = 9; /*turns on uucp debugging-level 9*/
        break;
        case 'h':
        Duplex  = NO;
        Ifc = NO;
        Ofc = NO;
        break;
        case 't':
        Terminal = YES;
        break;
        case 'e':
        if ( Oddflag ) {
            (void)fprintf(stderr,
            gettext("%s: Cannot have both even and odd parity\n"),
            argv[0]);
            exit(1);
        }
        Evenflag = 1;
        break;
        case 'o':
        if ( Evenflag ) {
            (void)fprintf(stderr,
            gettext("%s: Cannot have both even and odd parity\n"),
            argv[0]);
            exit(1);
        }
        Oddflag = 1;
        break;
        case 'n':
        nflag++;
        printf(gettext("Please enter the number: "));
        /* Read line from stdin, remove trailing newline, if any */
        if (fgets(s, sizeof(s), stdin) != NULL &&
            strchr(s, '\n') != NULL)
           s[strlen(s)-1] = '\0';
        break;
        case 's':
        Sflag++;
        Cucall.speed = optarg;
        break;
        case 'l':
        lflag++;
        Cucall.line = optarg;
        break;
        case 'c':
        Cucall.type = optarg;
        Mytype = optarg;
        break;
        case 'b':
        line_8bit = ((*optarg=='7') ? NO : ((*optarg=='8') ? YES : -1));
        if ( line_8bit == -1 ) {
            (void) fprintf(stderr,
            gettext("%s: b option value must be '7' or '8'\n"),
            argv[0]);
            exit(1);
        }
        break;
        case 'L':
        Dologin++;
        break;
        case 'C':
        Docmd++;
        break;
        case 'H':
        command_line_hups++;
        break;
        case '?':
        ++errflag;
    }

#ifdef  u3b
    {
    struct stat buff;
    if(fstat(TTYIN, &buff) < 0) {
    VERBOSE(gettext(P_NOTERMSTAT),"");
    exit(1);
    } else if ( (buff.st_mode & S_IFMT) == S_IFCHR && buff.st_rdev == 0 ) {
    VERBOSE(gettext(P_3BCONSOLE),"");
    exit(1);
    }
    }
#endif

    if((optind < argc && optind > 0) || (nflag && optind > 0)) {
    if(nflag)
        string=s;
    else
        string = strdup(argv[optind++]);
    Cucall.telno = string;
    if ( strlen(string) != strspn(string, "0123456789=-*#") ) {
        /* if it's not a legitimate telno, then it should be a systemname */
        if ( nflag ) {
        (void)fprintf(stderr, gettext("%s: Bad phone number %s\n"),
                argv[0], string);
        (void) fprintf(stderr, gettext("Phone numbers may contain "
            "only the digits 0 through 9 and the special\n"
            "characters =, -, * and #.\n"));
        exit(1);
        }
        systemname++;
    }
    } else
    if(Cucall.line == CNULL)   /*if none of above, must be direct */
        ++errflag;

    if(errflag) {
    VERBOSE(gettext(P_USAGE), argv[0]);
    exit(1);
    }

    if ((Cucall.telno != CNULL) &&
        (strlen(Cucall.telno) >= (size_t)(MAXPH - 1))) {
    VERBOSE(gettext(P_TELLENGTH),"");
    exit(0);
    }

    /* save initial tty state */
    if (!(Saved_termios = ( ioctl(TTYIN, TCGETS, &_Tv0s) >= 0 ))) {
    Saved_tty = ( ioctl(TTYIN, TCGETA, &_Tv0) == 0 );
    _Tv0s.c_lflag = _Tv0.c_lflag;
    _Tv0s.c_oflag = _Tv0.c_oflag;
    _Tv0s.c_iflag = _Tv0.c_iflag;
    _Tv0s.c_cflag = _Tv0.c_cflag;
    for(i = 0; i < NCC; i++)
        _Tv0s.c_cc[i] = _Tv0.c_cc[i];
    }

    if (Saved_termios || Saved_tty) {
    char *p;

    /*
     * We consider the terminal to be in 8 bit mode only if cs8 is set,
     * istrip is not set, and we're not in the "C" locale.  The "C"
     * locale is by definition 7 bit only.  This provides reasonable
     * compatibility when running in the "C" locale (currently the default)
     * and connecting to other systems, which are most often 7 bit systems.
     */
    term_8bit = ( (_Tv0s.c_cflag & CS8) && !(_Tv0s.c_iflag & ISTRIP) &&
      ((p = setlocale(LC_CTYPE, NULL)) != NULL) && (strcmp(p, "C") != 0) );
    if ( !Oddflag && !Evenflag )
        if (_Tv0s.c_cflag & PARENB)
        if (_Tv0s.c_cflag & PARODD)
            Oddflag = 1;
        else
            Evenflag = 1;
    }

    if (line_8bit == -1)
    line_8bit = term_8bit;

    term_mask = ( term_8bit ? 0377 : 0177 );
    line_mask = ( line_8bit ? 0377 : 0177 );

    /* if not set, use the POSIX disabled designation */
#ifdef _POSIX_VDISABLE
    vdisable = _POSIX_VDISABLE;
#else
    vdisable = fpathconf(TTYIN, _PC_VDISABLE);
#endif
    _Tintr = _Tv0s.c_cc[VINTR] ? _Tv0s.c_cc[VINTR] : vdisable;
    _Tquit = _Tv0s.c_cc[VQUIT] ? _Tv0s.c_cc[VQUIT] : vdisable;
    _Terase = _Tv0s.c_cc[VERASE] ? _Tv0s.c_cc[VERASE] : vdisable;
    _Tkill = _Tv0s.c_cc[VKILL] ? _Tv0s.c_cc[VKILL] : vdisable;
    _Teol = _Tv0s.c_cc[VEOL] ? _Tv0s.c_cc[VEOL] : vdisable;
    _Myeof = _Tv0s.c_cc[VEOF] ? _Tv0s.c_cc[VEOF] : '\04';
    Echoe = _Tv0s.c_lflag & ECHOE;
    Echok = _Tv0s.c_lflag & ECHOK;

    (void)signal(SIGHUP, cleanup);
    (void)signal(SIGQUIT, cleanup);
    (void)signal(SIGINT, cleanup);

/* place call to system; if "cu systemname", use conn() from uucp
   directly.  Otherwise, use altconn() which dummies in the
   Systems file line.
*/

    if(systemname) {
    if ( lflag )
        (void)fprintf(stderr,
            gettext("%s: Warning: -l flag ignored when system name used\n"),
            argv[0]);
    if ( Sflag )
        (void)fprintf(stderr,
            gettext("%s: Warning: -s flag ignored when system name used\n"),
            argv[0]);
    Cn = conn(string);
    if ( (Cn < 0) && (Cucall.type != CNULL) )
        Cn = altconn(&Cucall);
    } else
    Cn = altconn(&Cucall);

    if(Cn < 0) {
    VERBOSE(gettext(P_CON_FAILED),UERRORTEXT);
    cleanup(-Cn);
    } else {
    struct stat Cnsbuf;
    if ( fstat(Cn, &Cnsbuf) == 0 )
        Dev_mode = Cnsbuf.st_mode;
    else
        Dev_mode = R_DEVICEMODE;
    fchmod(Cn, M_DEVICEMODE);
    }

    if ((Docmd) && (argv[optind] == NULL)) {
        (void) fprintf(stderr,gettext("cu: local cmd is required, -C is ignored.\n"));
        VERBOSE(gettext(P_USAGE), argv[0]);
        Docmd=NO;
    }

    if (!Docmd) {
    Euid = geteuid();
    if((setuid(getuid()) < 0) || (setgid(getgid()) < 0)) {
        VERBOSE("Unable to setuid/gid\n%s", "");
        cleanup(101);
    }
    }

    if(Debug)
    tdmp(Cn);

    /* At this point succeeded in getting an open communication line    */
    /* Conn() takes care of closing the Systems file            */

    if (!Docmd) {
    (void)signal(SIGINT,_onintrpt);
    _mode(1);           /* put terminal in `raw' mode */
    VERBOSE("Connected\007\r\n%s", ""); /*bell!*/

    /* must catch signals before fork.  if not and if _receive()    */
    /* fails in just the right (wrong?) way, _rcvdead() can be  */
    /* called and do "kill(getppid(),SIGUSR1);" before parent   */
    /* has done calls to signal() after recfork().          */
    (void)signal(SIGUSR1, _bye);
    (void)signal(SIGHUP, cleanup);
    (void)signal(SIGQUIT, _onintrpt);

    sysname(&prompt[1]);    /* set up system name prompt */
    (void) strcat(prompt, "]");

    recfork();      /* checks for child == 0 */

    if(Child > 0) {
        /*
         * Because the child counts hangups for the -H flag,
         * and because we fork a new child when doing (e.g.)
         * ~%take, we assume the first child we fork has
         * processed all the hangups and we reset the count here.
         * We really should pass the remaining count back from
         * the child to the parent when we kill the child.
         */
        command_line_hups = 0;
        Rtn_code = transmit();
        _quit(Rtn_code);
        /*NOTREACHED*/
    }
    } else {
    /*
     * Fork a child to run the specified command,
     * wait for it to finish, and clean up.
     */
    Child = dofork();
    if (Child == 0) {
        close(0);
        close(1);
        dup(Cn);
        dup(Cn);
        close(Cn);
        setgid(getgid());
        setuid(getuid());
        execvp(argv[optind], &argv[optind]);
        exit(-1);
        /* NOTREACHED */
    }
    wait(0);
    /* XXX - should return wait status as our exit code */
    }
    cleanup(Cn);
    /*NOTREACHED*/
    return (0);
}

/*
 *  Kill the present child, if it exists, then fork a new one.
 */

static void
recfork()
{
    int ret, status;
    if (Child) {
    kill(Child, SIGKILL);
    while ( (ret = wait(&status)) != Child )
        if (ret == -1 && errno != EINTR)
        break;
    }
    Child = dofork();
    if(Child == 0) {
    (void)signal(SIGUSR1, SIG_DFL);
    (void)signal(SIGHUP, _rcvdead);
    (void)signal(SIGQUIT, SIG_IGN);
    (void)signal(SIGINT, SIG_IGN);

    _receive(); /* This should run until killed */
    /*NOTREACHED*/
    }
    return;
}

/***************************************************************
 *  transmit: copy stdin to remote fd, except:
 *  ~.  terminate
 *  ~!  local login-style shell
 *  ~!cmd   execute cmd locally
 *  ~$proc  execute proc locally, send output to line
 *  ~%cmd   execute builtin cmd (put, take, or break)
 ****************************************************************/
#ifdef forfutureuse
 /*****************************************************************
  * ~+proc  execute locally, with stdout to and stdin from line.
  ******************************************************************/
#endif

int
transmit()
{
    char b[BUFSIZ];
    char *p;
    int escape;
    int id = 0;  /* flag for systemname prompt on tilda escape */

    CDEBUG(4,"transmit started\n\r%s", "");

    /* In main loop, always waiting to read characters from */
    /* keyboard; writes characters to remote, or to TTYOUT  */
    /* on a tilda escape                    */

    for (;;) {
    p = b;
    while(r_char(TTYIN) == YES) {
        if(p == b)      /* Escape on leading  ~    */
        escape = (_Cxc == '~');
        if(p == b+1)    /* But not on leading ~~   */
        escape &= (_Cxc != '~');
        if(escape) {
         if(_Cxc == '\n' || _Cxc == '\r' || _Cxc == _Teol) {
            *p = '\0';
            if(tilda(b+1) == YES)
            return(0);
            id = 0;
            break;
        }
        if(_Cxc == _Tintr || _Cxc == _Tkill || _Cxc == _Tquit ||
            (Intrupt && _Cxc == '\0')) {
            if(_Cxc == _Tkill) {
            if(Echok)
                VERBOSE("\r\n%s", "");
            } else {
            _Cxc = '\r';
            if( w_char(Cn) == NO) {
                VERBOSE(gettext(P_LINE_GONE),"");
                return(IOERR);
            }
            id=0;
            }
            break;
        }
        if((p == b+1) && (_Cxc != _Terase) && (!id)) {
            id = 1;
            VERBOSE("%s", prompt);
        }
        if(_Cxc == _Terase) {
            p = (--p < b)? b:p;
            if(p > b)
            if(Echoe) {
                VERBOSE("\b \b%s", "");
            } else
                (void)w_char(TTYOUT);
        } else {
            (void)w_char(TTYOUT);
            if(p-b < BUFSIZ)
            *p++ = _Cxc;
            else {
            VERBOSE(gettext(P_TOOLONG),"");
            break;
            }
        }
    /*not a tilda escape command*/
        } else {
        if(Intrupt && _Cxc == '\0') {
            CDEBUG(4,"got break in transmit\n\r%s", "");
            Intrupt = NO;
            (*genbrk)(Cn);
            _flush();
            break;
        }
        if(w_char(Cn) == NO) {
            VERBOSE(gettext(P_LINE_GONE),"");
            return(IOERR);
        }
        if(Duplex == NO) {
            if((w_char(TTYERR) == NO) || (wioflsh(TTYERR) == NO))
            return(IOERR);
        }
        if ((_Cxc == _Tintr) || (_Cxc == _Tquit) ||
             ( (p==b) && (_Cxc == _Myeof) ) ) {
            CDEBUG(4,"got a tintr\n\r%s", "");
            _flush();
            break;
        }
        if(_Cxc == '\n' || _Cxc == '\r' ||
            _Cxc == _Teol || _Cxc == _Tkill) {
            id=0;
            Takeflag = NO;
            break;
        }
        p = (char*)0;
        }
    }
    }
}

/***************************************************************
 *  routine to halt input from remote and flush buffers
 ***************************************************************/
static void
_flush()
{
    (void)ioctl(TTYOUT, TCXONC, 0); /* stop tty output */
    (void)ioctl(Cn, TCFLSH, 0);     /* flush remote input */
    (void)ioctl(TTYOUT, TCFLSH, 1); /* flush tty output */
    (void)ioctl(TTYOUT, TCXONC, 1); /* restart tty output */
    if(Takeflag == NO) {
    return;     /* didn't interupt file transmission */
    }
    VERBOSE(gettext(P_FILEINTR),"");
    (void)sleep(3);
    _w_str("echo '\n~>\n';mesg y;stty echo\n");
    Takeflag = NO;
    return;
}

/**************************************************************
 *  command interpreter for escape lines
 **************************************************************/
int
tilda(cmd)
char    *cmd;
{

    VERBOSE("\r\n%s", "");
    CDEBUG(4,"call tilda(%s)\r\n", cmd);

    switch(cmd[0]) {
    case CSUSP:
    case CDSUSP:
        _mode(0);
        kill(cmd[0] == CDSUSP ? getpid() : (pid_t) 0, SIGTSTP);
        _mode(1);
        break;
    case '.':
        if(Cucall.telno == CNULL)
        if(cmd[1] != '.') {
            _w_str("\04\04\04\04\04");
            if (Child)
            kill(Child, SIGKILL);
            if (ioctl (Cn, TCGETS, &_Lvs) < 0) {
                (void) ioctl (Cn, TCGETA, &_Lv);
                /* speed to zero for hangup */
                _Lv.c_cflag = 0;
                (void) ioctl (Cn, TCSETAW, &_Lv);
            } else {
                /* speed to zero for hangup */
            _Lvs.c_cflag &= 0xffff0000;
            cfsetospeed(&_Lvs, B0);
                (void) ioctl (Cn, TCSETSW, &_Lvs);
            }
            (void) sleep (2);
        }
        return(YES);
    case '!':
        _shell(cmd);    /* local shell */
        VERBOSE("\r%c\r\n", *cmd);
        VERBOSE("(continue)%s", "");
        break;
    case '$':
        if(cmd[1] == '\0') {
        VERBOSE(gettext(P_USECMD),"");
        VERBOSE("(continue)%s", "");
        } else {
        _shell(cmd);    /*Local shell  */
        VERBOSE("\r%c\r\n", *cmd);
        }
        break;

#ifdef forfutureuse
    case '+':
        if(cmd[1] == '\0') {
        VERBOSE(gettext(P_USEPLUSCMD), "");
        VERBOSE("(continue)%s", "");
        } else {
        if (*cmd == '+')
              /* must suspend receive to give*/
              /*remote out to stdin of cmd */
            kill(Child, SIGKILL);
            _shell(cmd);    /* Local shell */
        if (*cmd == '+')
            recfork();
        VERBOSE("\r%c\r\n", *cmd);
        }
        break;
#endif
    case '%':
        _dopercen(++cmd);
        break;

    case 't':
        tdmp(TTYIN);
        VERBOSE("(continue)%s", "");
        break;
    case 'l':
        tdmp(Cn);
        VERBOSE("(continue)%s", "");
        break;

    default:
        VERBOSE(gettext(P_STARTWITH),"");
        VERBOSE("(continue)%s", "");
        break;
    }
    return(NO);
}

/***************************************************************
 *  The routine "shell" takes an argument starting with
 *  either "!" or "$", and terminated with '\0'.
 *  If $arg, arg is the name of a local shell file which
 *  is executed and its output is passed to the remote.
 *  If !arg, we escape to a local shell to execute arg
 *  with output to TTY, and if arg is null, escape to
 *  a local shell and blind the remote line.  In either
 *  case, '^D' will kill the escape status.
 **************************************************************/

#ifdef forfutureuse
/***************************************************************
 *  Another argument to the routine "shell" may be +.  If +arg,
 *  arg is the name of a local shell file which is executed with
 *  stdin from and stdout to the remote.
 **************************************************************/
#endif

static void
_shell(str)
char    *str;
{
    pid_t   fk, w_ret;
    void    (*xx)(), (*yy)();

    CDEBUG(4,"call _shell(%s)\r\n", str);
    fk = dofork();
    if(fk < 0)
    return;
    Shell = fk;
    _mode(0);   /* restore normal tty attributes */
    xx = signal(SIGINT, SIG_IGN);
    yy = signal(SIGQUIT, SIG_IGN);
    if(fk == 0) {
    char *shell;

    if( (shell = getenv("SHELL")) == NULL)
        /* use default if user's shell is not set */
        shell = SHELL;
    (void)close(TTYOUT);

    /***********************************************
     * Hook-up our "standard output"
     * to either the tty for '!' or the line
     * for '$'  as appropriate
     ***********************************************/
#ifdef forfutureuse

    /************************************************
     * Or to the line for '+'.
     **********************************************/
#endif

    (void)fcntl((*str == '!')? TTYERR:Cn,F_DUPFD,TTYOUT);

#ifdef forfutureuse
    /*************************************************
     * Hook-up "standard input" to the line for '+'.
     * **********************************************/
    if (*str == '+') {
        (void)close(TTYIN);
        (void)fcntl(Cn,F_DUPFD,TTYIN);
        }
#endif

    /***********************************************
     * Hook-up our "standard input"
     * to the tty for '!' and '$'.
     ***********************************************/

    (void)close(Cn);    /*parent still has Cn*/
    (void)signal(SIGINT, SIG_DFL);
    (void)signal(SIGHUP, SIG_DFL);
    (void)signal(SIGQUIT, SIG_DFL);
    (void)signal(SIGUSR1, SIG_DFL);
    if(*++str == '\0')
        (void)execl(shell,shell,(char*) 0,(char*) 0,(char *) 0);
    else
        (void)execl(shell,"sh","-c",str,(char *) 0);
    VERBOSE(gettext(P_Ct_EXSH),"");
    exit(0);
    }
    while ((w_ret = wait((int*)0)) != fk)
    if (w_ret == -1 && errno != EINTR)
        break;
    Shell = 0;
    (void)signal(SIGINT, xx);
    (void)signal(SIGQUIT, yy);
    _mode(1);
    return;
}


/***************************************************************
 *  This function implements the 'put', 'take', 'break',
 *  'ifc' (aliased to nostop) and 'ofc' (aliased to noostop)
 *  commands which are internal to cu.
 ***************************************************************/

static void
_dopercen(cmd)
char *cmd;
{
    char    *arg[5];
    char    *getpath;
    char    mypath[MAXPATH];
    int narg;

    blckcnt((long)(-1));

    CDEBUG(4,"call _dopercen(\"%s\")\r\n", cmd);

    arg[narg=0] = strtok(cmd, " \t\n");

    /* following loop breaks out the command and args */
    while((arg[++narg] = strtok((char*) NULL, " \t\n")) != NULL) {
    if(narg < 4)
        continue;
    else
        break;
    }

    /* ~%take file option */
    if(EQUALS(arg[0], "take")) {
    if(narg < 2 || narg > 3) {
        VERBOSE("usage: ~%%take from [to]\r\n%s", "");
        VERBOSE("(continue)%s", "");
        return;
    }
    if(narg == 2)
        arg[2] = arg[1];
    (void) strcpy(filename, arg[2]);
    recfork();  /* fork so child (receive) knows filename */

    /*
     * be sure that the remote file (arg[1]) exists before
     * you try to take it.   otherwise, the error message from
     * cat will wind up in the local file (arg[2])
     *
     * what we're doing is:
     *  stty -echo; \
     *  if test -r arg1
     *  then (echo '~[local]'>arg2; cat arg1; echo '~[local]'>)
     *  else echo can't open: arg1
     *  fi; \
     *  stty echo
     *
     */
    _w_str("stty -echo;if test -r ");
    _w_str(arg[1]);
    _w_str("; then (echo '~");
    _w_str(prompt);
    _w_str(">'");
    _w_str(arg[2]);
    _w_str(";cat ");
    _w_str(arg[1]);
    _w_str(";echo '~");
    _w_str(prompt);
    _w_str(">'); else echo cant\\'t open: ");
    _w_str(arg[1]);
    _w_str("; fi;stty echo\n");
    Takeflag = YES;
    return;
    }
    /* ~%put file option*/
    if(EQUALS(arg[0], "put")) {
    FILE    *file;
    char    ch, buf[BUFSIZ], spec[NCC+1], *b, *p, *q;
    int i, j, len, tc=0, lines=0;
    long    chars=0L;

    if(narg < 2 || narg > 3) {
        VERBOSE("usage: ~%%put from [to]\r\n%s", "");
        VERBOSE("(continue)%s", "");
        return;
    }
    if(narg == 2)
        arg[2] = arg[1];

    if((file = fopen(arg[1], "r")) == NULL) {
        VERBOSE(gettext(P_Ct_OPEN), arg[1]);
        VERBOSE("(continue)%s", "");
        return;
    }
    /*
     * if cannot write into file on remote machine, write into
     * /dev/null
     *
     * what we're doing is:
     *  stty -echo
     *  (cat - > arg2) || cat - > /dev/null
     *  stty echo
     */
    _w_str("stty -echo;(cat - >");
    _w_str(arg[2]);
    _w_str(")||cat - >/dev/null;stty echo\n");
    Intrupt = NO;
    for(i=0,j=0; i < NCC; ++i)
        if((ch=_Tv0s.c_cc[i]) != '\0')
        spec[j++] = ch;
    spec[j] = '\0';
    _mode(2);   /*accept interrupts from keyboard*/
    (void)sleep(5); /*hope that w_str info digested*/

    /* Read characters line by line into buf to write to    */
    /* remote with character and line count for blckcnt */
    while(Intrupt == NO &&
        fgets(b= &buf[MID],MID,file) != NULL) {
        /* worse case is each char must be escaped*/
        len = strlen(b);
        chars += len;       /* character count */
        p = b;
        while(q = strpbrk(p, spec)) {
        if(*q == _Tintr || *q == _Tquit || *q == _Teol) {
            VERBOSE(gettext(P_Ct_SPECIAL), *q);
            (void)strcpy(q, q+1);
            Intrupt = YES;
        } else {
            b = strncpy(b-1, b, q-b);
            *(q-1) = '\\';
        }
        p = q+1;
        }
        if((tc += len) >= MID) {
        (void)sleep(1);
        tc = len;
        }
        if(write(Cn, b, (unsigned)strlen(b)) < 0) {
        VERBOSE(gettext(P_IOERR),"");
        Intrupt = YES;
        break;
        }
        ++lines;        /* line count */
        blckcnt((long)chars);
    }
    _mode(1);
    blckcnt((long)(-2));        /* close */
    (void)fclose(file);
    if(Intrupt == YES) {
        Intrupt = NO;
        _w_str("\n");
        VERBOSE(gettext(P_CNTAFTER), ++chars);
    } else {
        VERBOSE(gettext(P_CNTLINES), lines);
        VERBOSE(gettext(P_CNTCHAR),chars);
    }
    (void)sleep(3);
    _w_str("\04");
    return;
    }

    /*  ~%b or ~%break  */
    if(EQUALS(arg[0], "b") || EQUALS(arg[0], "break")) {
    (*genbrk)(Cn);
    return;
    }
    /*  ~%d or ~%debug toggle  */
    if(EQUALS(arg[0], "d") || EQUALS(arg[0], "debug")) {
    if(Debug == 0)
        Debug = 9;
    else
        Debug = 0;
    VERBOSE("(continue)%s", "");
    return;
    }
    /*  ~%[ifc|nostop]  toggles start/stop input control  */
    if( EQUALS(arg[0], "ifc") || EQUALS(arg[0], "nostop") ) {
    (void)ioctl(Cn, TCGETA, &_Tv);
    Ifc = !Ifc;
    if(Ifc == YES)
        _Tv.c_iflag |= IXOFF;
    else
        _Tv.c_iflag &= ~IXOFF;
    (void)ioctl(Cn, TCSETAW, &_Tv);
    _mode(1);
    VERBOSE("(ifc %s)", (Ifc ? "enabled" : "disabled"));
    VERBOSE("(continue)%s", "");
    return;
    }
    /*  ~%[ofc|noostop]  toggles start/stop output control  */
    if( EQUALS(arg[0], "ofc") || EQUALS(arg[0], "noostop") ) {
    (void)ioctl(Cn, TCGETA, &_Tv);
    Ofc = !Ofc;
    if(Ofc == YES)
        _Tv.c_iflag |= IXON;
    else
        _Tv.c_iflag &= ~IXON;
    (void)ioctl(Cn, TCSETAW, &_Tv);
    _mode(1);
    VERBOSE("(ofc %s)", (Ofc ? "enabled" : "disabled"));
    VERBOSE("(continue)%s", "");
    return;
    }
    /*  ~%divert toggles unsolicited redirection security */
    if( EQUALS(arg[0], "divert") ) {
    Divert = !Divert;
    recfork();  /* fork a new child so it knows about change */
    VERBOSE("(unsolicited diversion %s)", (Divert ? "enabled" : "disabled"));
    VERBOSE("(continue)%s", "");
    return;
    }
    /*  ~%old toggles recognition of old-style '~>:filename' */
    if( EQUALS(arg[0], "old") ) {
    OldStyle = !OldStyle;
    recfork();  /* fork a new child so it knows about change */
    VERBOSE("(old-style diversion %s)", (OldStyle ? "enabled" : "disabled"));
    VERBOSE("(continue)%s", "");
    return;
    }
    /* Change local current directory */
    if(EQUALS(arg[0], "cd")) {
    if (narg < 2) {
        getpath = getenv("HOME");
        strlcpy(mypath, getpath, sizeof (mypath));
        if(chdir(mypath) < 0) {
        VERBOSE("Cannot change to %s\r\n", mypath);
        VERBOSE("(continue)%s", "");
        return;
        }
    } else if (chdir(arg[1]) < 0) {
        VERBOSE("Cannot change to %s\r\n", arg[1]);
        VERBOSE("(continue)%s", "");
        return;
    }
    recfork();  /* fork a new child so it knows about change */
    VERBOSE("(continue)%s", "");
    return;
    }

   if (arg[0] == (char *) NULL)
       arg[0] = "";

    VERBOSE("~%%%s unknown to cu\r\n", arg[0]);
    VERBOSE("(continue)%s", "");
    return;
}

/***************************************************************
 *  receive: read from remote line, write to fd=1 (TTYOUT)
 *  catch:
 *  ~>[>]:file
 *  .
 *  . stuff for file
 *  .
 *  ~>  (ends diversion)
 ***************************************************************/

static void
_receive()
{
    int silent = NO, file = -1;
    char *p;
    int tic;
    int for_me = NO;
    char    b[BUFSIZ];
    char    *b_p;
    long    count;
    int     line_ok = 1, rval;

    CDEBUG(4,"_receive started\r\n%s", "");

    b[0] = '\0';
    b_p = p = b;

    while(line_ok) {
    rval = r_char(Cn);
    if (rval == NO) {
        line_ok = 0;
        continue;
    }
    if (rval == HUNGUP) {
        if (command_line_hups > 0) {
        CDEBUG(4, "Ignoring device hangup\n%s", "");
        command_line_hups--;
        (void) setuid(Euid);    /* reacquire privileges */
        if (clear_hup(Cn) != SUCCESS) {
            DEBUG(4, "Unable to clear hup on device\n%s", "");
            line_ok = 0;
        }
        (void) setuid(getuid());  /* relinquish privileges */
        } else
        line_ok = 0;
        continue;
    }

    if(silent == NO)    /* ie., if not redirecting from screen */
        if(w_char(TTYOUT) == NO)
        _rcvdead(IOERR);    /* this will exit */
    /* remove CR's and fill inserted by remote */
    if(_Cxc == '\0' || _Cxc == RUB || _Cxc == '\r')
        continue;
    *p++ = _Cxc;
    if(_Cxc != '\n' && (p-b) < BUFSIZ)
        continue;
    /* ****************************************** */
    /* This code deals with ~%take file diversion */
    /* ****************************************** */
    if (b[0] == '~') {
        int    append;

        if (EQUALSN(&b[1],prompt,strlen(prompt))) {
        b_p = b + 1 + strlen(prompt);
        for_me = YES;
        } else {
        b_p = b + 1;
        for_me = NO;
        }
        if ( (for_me || OldStyle) && (*b_p == '>') ) {
        /* This is an acceptable '~[uname]>' line */
        b_p++;
        if ( (*b_p == '\n') && (silent == YES) ) {
            /* end of diversion */
            *b_p = '\0';
            (void) strcpy(filename, "/dev/null");
            if ( file >= 0 && close(file) ) {
            VERBOSE(gettext(P_Ct_UNDIVERT), b_p);
            perror(gettext("cu: close failed"));
            VERBOSE("%s","\r");
            }
            silent = NO;
            blckcnt((long)(-2));
            VERBOSE("%s\r\n", b);
            VERBOSE(gettext(P_CNTLINES), tic);
            VERBOSE(gettext(P_CNTCHAR), count);
            file = -1;
            p = b;
            continue;
        } else if (*b_p != '\n') {
            if ( *b_p == '>' ) {
            append = 1;
            b_p++;
            }
            if ( (for_me || (OldStyle && (*b_p == ':'))) && (silent == NO) ) {
            /* terminate filename string */
            *(p-1) = '\0';
            if ( *b_p == ':' )
                b_p++;
            if ( !EQUALS(filename, b_p) ) {
                if ( !Divert  || !EQUALS(filename, "/dev/null") ) {
                VERBOSE(gettext(P_Bad_DIVERT), b_p);
                (void) strcpy(filename, "/dev/null");
                append = 1;
                } else {
                (void) strcpy(filename, b_p);
                }
            }
            if ( append && ((file=open(filename,O_WRONLY)) >= 0) )
                (void)lseek(file, 0L, 2);
            else
                file = creat(filename, PUB_FILEMODE);
            if (file < 0) {
                VERBOSE(gettext(P_Ct_DIVERT), filename);
                perror(gettext("cu: open|creat failed"));
                VERBOSE("%s","\r");
                (void)sleep(5); /* 10 seemed too long*/
            }
            silent = YES;
            count = tic = 0;
            p = b;
            continue;
            }
        }
        }
    }
    /* Regular data, divert if appropriate */
    if ( silent == YES ) {
        if ( file >= 0)
        (void)write(file, b, (unsigned)(p-b));
        count += p-b;   /* tally char count */
        ++tic;      /* tally lines */
        blckcnt((long)count);
    }
    p = b;
    }
    /*
     * we used to tell of lost carrier here, but now
     * defer to _bye() so that escape processes are
     * not interrupted.
     */
    _rcvdead(IOERR);
    return;
}

/***************************************************************
 *  change the TTY attributes of the users terminal:
 *  0 means restore attributes to pre-cu status.
 *  1 means set `raw' mode for use during cu session.
 *  2 means like 1 but accept interrupts from the keyboard.
 ***************************************************************/
static void
_mode(arg)
{
    int i;

    CDEBUG(4,"call _mode(%d)\r\n", arg);
    if(arg == 0) {
    if ( Saved_termios )
        (void)ioctl(TTYIN, TCSETSW, &_Tv0s);
    else if ( Saved_tty ) {
        _Tv0.c_lflag = _Tv0s.c_lflag;
        _Tv0.c_oflag = _Tv0s.c_oflag;
        _Tv0.c_iflag = _Tv0s.c_iflag;
        _Tv0.c_cflag = _Tv0s.c_cflag;
        for(i = 0; i < NCC; i++)
            _Tv0.c_cc[i] = _Tv0s.c_cc[i];
        (void)ioctl(TTYIN, TCSETAW, &_Tv0);
    }
    } else {
    (void)ioctl(TTYIN, TCGETA, &_Tv);
    if(arg == 1) {
        _Tv.c_iflag &= ~(INLCR | ICRNL | IGNCR | IUCLC);
        if ( !term_8bit )
        _Tv.c_iflag |= ISTRIP;
        _Tv.c_oflag |= OPOST;
        _Tv.c_oflag &= ~(OLCUC | ONLCR | OCRNL | ONOCR | ONLRET);
        _Tv.c_lflag &= ~(ICANON | ISIG | ECHO);
        if(Ifc == NO)
        _Tv.c_iflag &= ~IXON;
        else
        _Tv.c_iflag |= IXON;
        if(Ofc == NO)
        _Tv.c_iflag &= ~IXOFF;
        else
        _Tv.c_iflag |= IXOFF;
        if(Terminal) {
        _Tv.c_oflag |= ONLCR;
        _Tv.c_iflag |= ICRNL;
        }
        _Tv.c_cc[VEOF] = '\01';
        _Tv.c_cc[VEOL] = '\0';
    }
    if(arg == 2) {
        _Tv.c_iflag |= IXON;
        _Tv.c_lflag |= ISIG;
    }
    (void)ioctl(TTYIN, TCSETAW, &_Tv);
    }
    return;
}


static pid_t
dofork()
{
    int i;
    pid_t x;

    for(i = 0; i < 6; ++i) {
    if((x = fork()) >= 0) {
        return(x);
    }
    }

    if(Debug) perror("dofork");

    VERBOSE(gettext(P_Ct_FK),"");
    return(x);
}

static int
r_char(fd)
{
    int rtn = 1, rfd;
    char *riobuf;

    /* find starting pos in correct buffer in Riobuf    */
    rfd = RIOFD(fd);
    riobuf = &Riobuf[rfd*WRIOBSZ];

    if (Riop[rfd] >= &riobuf[Riocnt[rfd]]) {
    /* empty read buffer - refill it    */

    /*  flush any waiting output    */
    if ( (wioflsh(Cn) == NO ) || (wioflsh(TTYOUT) == NO) )
        return(NO);

    while((rtn = read(fd, riobuf, WRIOBSZ)) < 0){
        if(errno == EINTR) {
        /* onintrpt() called asynchronously before this line */
        if(Intrupt == YES) {
            /* got a BREAK */
            _Cxc = '\0';
            return(YES);
        } else {
            /*a signal other than interrupt*/
            /*received during read*/
            continue;
        }
        } else {
        CDEBUG(4,"got read error, not EINTR\n\r%s", "");
        break;          /* something wrong */
        }
    }
    if (rtn > 0) {
        /* reset current position in buffer */
        /* and count of available chars     */
        Riop[rfd] = riobuf;
        Riocnt[rfd] = rtn;
    }
    }

    if ( rtn > 0 ) {
    _Cxc = *(Riop[rfd]++) & RMASK(fd);  /* mask off appropriate bits */
    return(YES);
    } else if (rtn == 0) {
    _Cxc = '\0';
    return (HUNGUP);
    } else {
    _Cxc = '\0';
    return(NO);
    }
}

static int
w_char(fd)
{
    int wfd;
    char *wiobuf;

    /* find starting pos in correct buffer in Wiobuf    */
    wfd = WIOFD(fd);
    wiobuf = &Wiobuf[wfd*WRIOBSZ];

    if (Wiop[wfd] >= &wiobuf[WRIOBSZ]) {
    /* full output buffer - flush it */
    if ( wioflsh(fd) == NO )
        return(NO);
    }
    *(Wiop[wfd]++) = _Cxc & WMASK(fd);  /* mask off appropriate bits */
    return(YES);
}

/* wioflsh  flush output buffer */
static int
wioflsh(fd)
int fd;
{
    int wfd;
    char *wiobuf;

    /* find starting pos in correct buffer in Wiobuf    */
    wfd = WIOFD(fd);
    wiobuf = &Wiobuf[wfd*WRIOBSZ];

    if (Wiop[wfd] > wiobuf) {
    /* there's something in the buffer */
    while(write(fd, wiobuf, (Wiop[wfd] - wiobuf)) < 0) {
        if(errno == EINTR) {
        if(Intrupt == YES) {
            VERBOSE("\ncu: Output blocked\r\n%s", "");
            _quit(IOERR);
        } else
            continue;   /* alarm went off */
        } else {
        Wiop[wfd] = wiobuf;
        return(NO);         /* bad news */
        }
    }
    }
    Wiop[wfd] = wiobuf;
    return(YES);
}


static void
_w_str(string)
char *string;
{
    int len;

    len = strlen(string);
    if ( write(Cn, string, (unsigned)len) != len )
    VERBOSE(gettext(P_LINE_GONE),"");
    return;
}

/* ARGSUSED */
static void
_onintrpt(sig)
int sig;
{
    (void)signal(SIGINT, _onintrpt);
    (void)signal(SIGQUIT, _onintrpt);
    Intrupt = YES;
    return;
}

static void
_rcvdead(arg)   /* this is executed only in the receive process */
int arg;
{
    CDEBUG(4,"call _rcvdead(%d)\r\n", arg);
    (void)kill(getppid(), SIGUSR1);
    exit((arg == SIGHUP)? SIGHUP: arg);
    /*NOTREACHED*/
}

static void
_quit(arg)  /* this is executed only in the parent process */
int arg;
{
    CDEBUG(4,"call _quit(%d)\r\n", arg);
    (void)kill(Child, SIGKILL);
    _bye(arg);
    /*NOTREACHED*/
}

static void
_bye(arg)   /* this is executed only in the parent proccess */
int arg;
{
    int status;
    pid_t obit;

    if ( Shell > 0 )
    while ((obit = wait(&status)) != Shell) {
        if (obit == -1 && errno != EINTR)
        break;
        /* _receive (Child) may have ended - check it out */
        if (obit == Child)
        Child = 0;
    }

    /* give user customary message after escape command returns */
    if (arg == SIGUSR1)
    VERBOSE("\r\nLost Carrier\r\n%s", "");

    CDEBUG(4,"call _bye(%d)\r\n", arg);

    (void)signal(SIGINT, SIG_IGN);
    (void)signal(SIGQUIT, SIG_IGN);
    /* if _receive() ended already, don't wait for it again */
    if ( Child != 0 )
    while ((obit = wait(&status)) != Child)
        if (obit == -1 && errno != EINTR)
        break;
    VERBOSE("\r\nDisconnected\007\r\n%s", "");
    cleanup((arg == SIGUSR1)? (status >>= 8): arg);
    /*NOTREACHED*/
}


void
cleanup(code)   /*this is executed only in the parent process*/
int code;   /*Closes device; removes lock files   */
{

    CDEBUG(4,"call cleanup(%d)\r\n", code);

    if (Docmd) {
    if (Child > 0)
        (void)kill(Child, SIGTERM);
    } else
    (void) setuid(Euid);
    if(Cn > 0) {
    fchmod(Cn, Dev_mode);
    fd_rmlock(Cn);
    (void)close(Cn);
    }


    rmlock((char*) NULL);   /* remove all lock files for this process */
    if (!Docmd)
    _mode(0);
    exit(code);     /* code=negative for signal causing disconnect*/
}


void
tdmp(arg)
int arg;
{

    struct termio xv;
    int i;

    VERBOSE("\rdevice status for fd=%d\r\n", arg);
    VERBOSE("F_GETFL=%o,", fcntl(arg, F_GETFL,1));
    if(ioctl(arg, TCGETA, &xv) < 0) {
    char    buf[100];
    i = errno;
    (void)snprintf(buf, sizeof (buf), gettext("\rtdmp for fd=%d"), arg);
    errno = i;
    perror(buf);
    return;
    }
    VERBOSE("iflag=`%o',", xv.c_iflag);
    VERBOSE("oflag=`%o',", xv.c_oflag);
    VERBOSE("cflag=`%o',", xv.c_cflag);
    VERBOSE("lflag=`%o',", xv.c_lflag);
    VERBOSE("line=`%o'\r\n", xv.c_line);
    VERBOSE("cc[0]=`%o',",  xv.c_cc[0]);
    for(i=1; i<8; ++i) {
    VERBOSE("[%d]=", i);
    VERBOSE("`%o',",xv.c_cc[i]);
    }
    VERBOSE("\r\n%s", "");
    return;
}


static void
sysname(name)
char * name;
{

    char *s;

    if(uname(&utsn) < 0)
    s = "Local";
    else
    s = utsn.nodename;

    strcpy(name, s);
    return;
}


static void
blckcnt(count)
long count;
{
    static long lcharcnt = 0;
    long c1, c2;
    int i;
    char c;

    if(count == (long) (-1)) {  /* initialization call */
    lcharcnt = 0;
    return;
    }
    c1 = lcharcnt/BUFSIZ;
    if(count != (long)(-2)) {   /* regular call */
    c2 = count/BUFSIZ;
    for(i = c1; i++ < c2;) {
        c = '0' + i%10;
        write(2, &c, 1);
        if(i%NPL == 0)
        write(2, "\n\r", 2);
    }
    lcharcnt = count;
    } else {
    c2 = (lcharcnt + BUFSIZ -1)/BUFSIZ;
    if(c1 != c2)
        write(2, "+\n\r", 3);
    else if(c2%NPL != 0)
        write(2, "\n\r", 2);
    lcharcnt = 0;
    }
    return;
}

/*VARARGS*/
/*ARGSUSED*/
void
assert (s1, s2, i1, s3, i2)
char *s1, *s2, *s3;
int i1, i2;
{ }     /* for ASSERT in gnamef.c */

/*ARGSUSED*/
void
logent (s1, s2)
char *s1, *s2;
{ }     /* so we can load ulockf() */