xref: /titanic_52/usr/src/cmd/bnu/cu.c (revision 462be471126495414a94f9fa35e16c02dc462c04)

/*
 * 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() */