usr/src/cmd/bnu/cu.c

   1 /*
   2  * CDDL HEADER START
   3  *
   4  * The contents of this file are subject to the terms of the
   5  * Common Development and Distribution License, Version 1.0 only
   6  * (the "License").  You may not use this file except in compliance
   7  * with the License.
   8  *
   9  * You can obtain a copy of the license at usr/src/OPENSOLARIS.LICENSE
  10  * or http://www.opensolaris.org/os/licensing.
  11  * See the License for the specific language governing permissions
  12  * and limitations under the License.
  13  *
  14  * When distributing Covered Code, include this CDDL HEADER in each
  15  * file and include the License file at usr/src/OPENSOLARIS.LICENSE.
  16  * If applicable, add the following below this CDDL HEADER, with the
  17  * fields enclosed by brackets "[]" replaced with your own identifying
  18  * information: Portions Copyright [yyyy] [name of copyright owner]
  19  *
  20  * CDDL HEADER END
  21  */
  22 /*
  23  * Copyright 2005 Sun Microsystems, Inc.  All rights reserved.
  24  * Use is subject to license terms.
  25  */
  26
  27 /*      Copyright (c) 1984, 1986, 1987, 1988, 1989 AT&T */
  28 /*        All Rights Reserved   */
  29
  30 #pragma ident   "%Z%%M% %I%     %E% SMI"
  31
  32
  33 /*
  34  * cu [-cdevice] [-sspeed] [-lline] [-bbits] [-h] [-t] [-d] [-n]
  35  *              [-o|-e] [-L] [-C] telno | systemname [local-cmd]
  36  *
  37  *      legal baud rates: 300, 1200, 2400, 4800, 9600, 19200, 38400.
  38  *
  39  *      -c is used to specify which device will be used for making the
  40  *              call.  The device argument is compared to the Type (first)
  41  *              field in the Devices file, and only those records that
  42  *              match will be used to make the call.  Either -d or -t
  43  *              would be more intuitive options designations, but they
  44  *              are already in use.
  45  *      -l is for specifying a line unit from the file whose
  46  *              name is defined in /etc/uucp/Devices.
  47  *      -b is for forcing the number of bits per character processed on
  48  *              the connection. Valid values are '7' or '8'.
  49  *      -h is for half-duplex (local echoing).
  50  *      -t is for adding CR to LF on output to remote (for terminals).
  51  *      -d can be used  to get some tracing & diagnostics.
  52  *      -o or -e is for odd or even parity on transmission to remote.
  53  *      -n will request the phone number from the user.
  54  *      -L will cause cu to go through the login chat sequence in the
  55  *              Systems file.
  56  *      -C will cause cu to run the local command specified at the end
  57  *              of the command line, instead of entering interactive mode.
  58  *      Telno is a telephone number with `=' for secondary dial-tone.
  59  *      If "-l dev" is used, speed is taken from /etc/uucp/Devices.
  60  *      Only systemnames that are included in /etc/uucp/Systems may
  61  *      be used.
  62  *
  63  *      Escape with `~' at beginning of line:
  64  *
  65  *      ~.      quit,
  66  *
  67  *      ~![cmd]                 execute shell (or 'cmd') locally,
  68  *
  69  *      ~$cmd                   execute 'cmd' locally, stdout to remote,
  70  *
  71  *      ~%break (alias ~%b)     transmit BREAK to remote,
  72  *      ~%cd [dir]              change directory to $HOME (or 'dir'),
  73  *      ~%debug (alias ~%d)     toggles on/off the program debug trace,
  74  *      ~%divert                allow unsolicited diversions to files,
  75  *      ~%ifc (alias ~%nostop)  toggles on/off the DC3/DC1 input control,
  76  *      ~%ofc (alias ~%noostop) toggles on/off the DC3/DC1 output control,
  77  *              (certain remote systems cannot cope with DC3 or DC1).
  78  *      ~%old                   recognize old style silent diversions,
  79  *      ~%put from [to]         put file from local to remote,
  80  *      ~%take from [to]        take file from remote to local,
  81  *
  82  *      ~l                      dump communication line ioctl settings,
  83  *      ~t                      dump terminal ioctl settings.
  84  *
  85  *      Silent diversions are enabled only for use with the ~%take
  86  *      command by default for security reasons. Unsolicited diversions
  87  *      may be enabled using the ~%divert toggle. The 'new-style'
  88  *      diversion syntax is "~[local]>:filename", and is terminaled
  89  *      by "~[local]>", where 'local' is the nodename of the local
  90  *      system. This enables ~%take to operate properly when cu
  91  *      is used over multiple hops. 'old-style' diversion syntax may
  92  *      be enabled using the ~%old toggle. ('old-style' diversion
  93  *      should be avoided!)
  94  *
  95  *      Cu no longer uses dial.c to reach the remote.  Instead, cu places
  96  *      a telephone call to a remote system through the uucp conn() routine
  97  *      when the user picks the systemname option or through altconn()--
  98  *      which bypasses /etc/uucp/Systems -- if a telno or direct
  99  *      line is chosen. The line termio attributes are set in fixline(),
 100  *      before the remote connection is made.  As a device-lockout semaphore
 101  *      mechanism, uucp creates an entry in /var/spool/locks whose name is
 102  *      LK.<MAJ>.<maj>.<min> where MAJ is the major device of the
 103  *      filesystem containing the device, and <maj> and <min> are the
 104  *      major and minor of the device.
 105  *      When cu terminates, for whatever reason, cleanup() must be
 106  *      called to "release" the device, and clean up entries from
 107  *      the locks directory.  Cu runs with uucp ownership, and thus provides
 108  *      extra insurance that lock files will not be left around.
 109  */
 110
 111 #include "uucp.h"
 112 #include <locale.h>
 113 #include <stropts.h>
 114
 115 #define MID     BUFSIZ/2        /* mnemonic */
 116 #define RUB     '\177'          /* mnemonic */
 117 #define XON     '\21'           /* mnemonic */
 118 #define XOFF    '\23'           /* mnemonic */
 119 #define TTYIN   0               /* mnemonic */
 120 #define TTYOUT  1               /* mnemonic */
 121 #define TTYERR  2               /* mnemonic */
 122 #define HUNGUP  2
 123 #define YES     1               /* mnemonic */
 124 #define NO      0               /* mnemonic */
 125 #define IOERR   4               /* exit code */
 126 #define MAXPATH 100
 127 #define NPL     50
 128
 129 int Sflag=0;
 130 int Cn;                         /*fd for remote comm line */
 131 jmp_buf Sjbuf;                  /*needed by uucp routines*/
 132
 133 /*      io buffering    */
 134 /*      Wiobuf contains, in effect, 3 write buffers (to remote, to tty  */
 135 /*      stdout, and to tty stderr) and Riobuf contains 2 read buffers   */
 136 /*      (from remote, from tty).  [WR]IOFD decides which one to use.    */
 137 /*      [RW]iop holds current position in each.                         */
 138 #define WIOFD(fd)       (fd == TTYOUT ? 0 : (fd == Cn ? 1 : 2))
 139 #define RIOFD(fd)       (fd == TTYIN ? 0 : 1)
 140 #define WMASK(fd)       (fd == Cn ? line_mask : term_mask)
 141 #define RMASK(fd)       (fd == Cn ? line_mask : term_mask)
 142 #define WRIOBSZ 256
 143 static char Riobuf[2*WRIOBSZ];
 144 static char Wiobuf[3*WRIOBSZ];
 145 static int Riocnt[2] = {0, 0};
 146 static char *Riop[2];
 147 static char *Wiop[3];
 148
 149 extern int optind;              /* variable in getopt() */
 150
 151 extern char
 152         *optarg;
 153
 154 static struct call Cucall;      /* call structure for altconn() */
 155
 156 static int Saved_tty;           /* was TCGETAW of _Tv0 successful?      */
 157 static int Saved_termios;       /* was TCGETSW of _Tv0 successful?      */
 158 static struct termio _Tv, _Tv0; /* for saving, changing TTY atributes */
 159 static struct termios _Tv0s;    /* for saving, changing TTY atributes */
 160 static struct termio _Lv;       /* attributes for the line to remote */
 161 static struct termios _Lvs;     /* attributes for the line to remote */
 162 static char prompt[BUFSIZ]= "[";
 163 static struct utsname utsn;
 164 static int command_line_hups = 0;
 165
 166 static char filename[BUFSIZ] = "/dev/null";
 167
 168 static char
 169         _Cxc,                   /* place into which we do character io*/
 170         _Tintr,                 /* current input INTR */
 171         _Tquit,                 /* current input QUIT */
 172         _Terase,                /* current input ERASE */
 173         _Tkill,                 /* current input KILL */
 174         _Teol,                  /* current secondary input EOL */
 175         _Myeof,                 /* current input EOF */
 176         term_mask,              /* mask value for local terminal */
 177         line_mask;              /* mask value for remote line */
 178                                 /* either '0177' or '0377' */
 179
 180 int
 181         Echoe,                  /* save users ECHOE bit */
 182         Echok,                  /* save users ECHOK bit */
 183         Intrupt=NO,             /* interrupt indicator */
 184         Ifc=YES,                /* NO means remote can't XON/XOFF */
 185         Ofc=YES,                /* NO means local can't XON/XOFF */
 186         Rtn_code=0,             /* default return code */
 187         Divert=NO,              /* don't allow unsolicited redirection */
 188         OldStyle=NO,            /* don't handle old '~>:filename' syntax */
 189                                 /* this will be mandatory in SVR4.1 */
 190         Takeflag=NO,            /* indicates a ~%take is in progress */
 191         Dologin=NO,             /* go through the login chat sequence */
 192         Docmd=NO;               /* execute command instead of interactive cu */
 193
 194 EXTERN int                      /* These are initialized in line.c */
 195         Terminal,               /* flag; remote is a terminal */
 196         Oddflag,                /* flag- odd parity option*/
 197         Evenflag,               /* flag- even parity option*/
 198         Duplex,                 /* Unix= full duplex=YES; half = NO */
 199         term_8bit,              /* is terminal set for 8 bit processing */
 200         line_8bit;              /* is line set for 8 bit processing */
 201
 202 EXTERN int clear_hup();
 203
 204 pid_t
 205         Child,                  /* pid for receive process */
 206         Shell;                  /* pid for escape process */
 207
 208 static pid_t
 209         dofork();               /* fork and return pid */
 210
 211 static int
 212         r_char(),               /* local io routine */
 213         w_char(),               /* local io routine */
 214         wioflsh();
 215
 216 static void
 217         _onintrpt(),            /* interrupt routines */
 218         _rcvdead(),
 219         _quit(),
 220         _bye();
 221
 222 extern void     cleanup();
 223 extern void     tdmp();
 224 extern int conn(), altconn(), transmit(), tilda();
 225
 226 static void
 227         recfork(),
 228         sysname(),
 229         blckcnt(),
 230         _flush(),
 231         _shell(),
 232         _dopercen(),
 233         _receive(),
 234         _mode(),
 235         _w_str();
 236
 237 extern char *Myline;    /* flag to force the requested line to be used  */
 238 extern char *Mytype;    /* flag to force requested line type to be used
 239                          * rddev() will compare the string to the D_TYPE
 240                          * (first) field of the Devices record and skip any
 241                          * records where they are not equal. Mytype is set
 242                          * to point to the argument of the -c option from
 243                          * the command line. */
 244 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";
 245 static char *P_CON_FAILED = "Connect failed: %s\r\n";
 246 static char *P_Ct_OPEN = "Cannot open: %s\r\n";
 247 static char *P_LINE_GONE = "Remote line gone\r\n";
 248 static char *P_Ct_EXSH = "Can't execute shell\r\n";
 249 static char *P_Ct_DIVERT = "Can't divert to %s\r\n";
 250 static char *P_Ct_UNDIVERT = "Can't end diversion to %s\r\n";
 251 static char *P_Bad_DIVERT = "Won't divert to %s. Unsolicited.\r\n";
 252 static char *P_STARTWITH = "Use `~~' to start line with `~'\r\n";
 253 static char *P_CNTAFTER = "File transmission interrupted after %ld bytes.\r\n";
 254 static char *P_CNTLINES = "%d lines/";
 255 static char *P_CNTCHAR = "%ld characters\r\n";
 256 static char *P_FILEINTR = "File transmission interrupted\r\n";
 257 static char *P_Ct_FK = "Can't fork -- try later\r\n";
 258 static char *P_Ct_SPECIAL = "r\nCan't transmit special character `%#o'\r\n";
 259 static char *P_TOOLONG = "\nLine too long\r\n";
 260 static char *P_IOERR = "r\nIO error\r\n";
 261 static char *P_USECMD = "Use `~$'cmd \r\n";
 262 #ifdef forfutureuse
 263 static char *P_USEPLUSCMD ="Use `~+'cmd \r\n";
 264 #endif
 265 #ifdef u3b
 266 static char *P_NOTERMSTAT = "Can't get terminal status\r\n";
 267 static char *P_3BCONSOLE = "Sorry, you can't cu from a 3B console\r\n";
 268 #endif
 269 static char *P_TELLENGTH = "Telno cannot exceed 58 digits!\r\n";
 270
 271 /***************************************************************
 272  *      main: get command line args, establish connection, and fork.
 273  *      Child invokes "receive" to read from remote & write to TTY.
 274  *      Main line invokes "transmit" to read TTY & write to remote.
 275  ***************************************************************/
 276
 277 int
 278 main(argc, argv)
 279 int argc;
 280 char *argv[];
 281 {
 282     extern void setservice();
 283     extern int sysaccess();
 284     char s[MAXPH];
 285     char *string;
 286     int i;
 287     int errflag=0;
 288     int lflag=0;
 289     int nflag=0;
 290     int systemname = 0;
 291     char vdisable;
 292
 293     /* Set locale environment variables local definitions */
 294     (void) setlocale(LC_ALL, "");
 295 #if !defined(TEXT_DOMAIN)       /* Should be defined by cc -D */
 296 #define TEXT_DOMAIN "SYS_TEST"  /* Use this only if it wasn't */
 297 #endif
 298     (void) textdomain(TEXT_DOMAIN);
 299
 300     Riop[0] = &Riobuf[0];
 301     Riop[1] = &Riobuf[WRIOBSZ];
 302     Wiop[0] = &Wiobuf[0];
 303     Wiop[1] = &Wiobuf[WRIOBSZ];
 304     Wiop[2] = &Wiobuf[2*WRIOBSZ];
 305
 306     Verbose = 1;                /*for uucp callers,  dialers feedback*/
 307     if ((string = strrchr(argv[0], '/')) != NULL)
 308         string++;
 309     else
 310         string = argv[0];
 311     if (strlcpy(Progname, string, NAMESIZE) >= NAMESIZE) {
 312         errno = ENAMETOOLONG;
 313         perror("cu");
 314         exit(1);
 315     }
 316     setservice(Progname);
 317     if ( sysaccess(EACCESS_SYSTEMS) != 0 ) {
 318         (void)fprintf(stderr,
 319              gettext("%s: Cannot read Systems files\n"), Progname);
 320         exit(1);
 321     }
 322     if ( sysaccess(EACCESS_DEVICES) != 0 ) {
 323         (void)fprintf(stderr,
 324              gettext("%s: Cannot read Devices files\n"), Progname);
 325         exit(1);
 326     }
 327     if ( sysaccess(EACCESS_DIALERS) != 0 ) {
 328         (void)fprintf(stderr,
 329             gettext("%s: Cannot read Dialers files\n"), Progname);
 330         exit(1);
 331     }
 332
 333     Cucall.speed = "Any";       /*default speed*/
 334     Cucall.line = CNULL;
 335     Cucall.telno = CNULL;
 336     Cucall.type = CNULL;
 337
 338 /*Flags for -h, -t, -e, and -o options set here; corresponding line attributes*/
 339 /*are set in fixline() in culine.c before remote connection is made        */
 340
 341     while((i = getopt(argc, argv, "dhteons:l:c:b:LCH")) != EOF)
 342         switch(i) {
 343             case 'd':
 344                 Debug = 9; /*turns on uucp debugging-level 9*/
 345                 break;
 346             case 'h':
 347                 Duplex  = NO;
 348                 Ifc = NO;
 349                 Ofc = NO;
 350                 break;
 351             case 't':
 352                 Terminal = YES;
 353                 break;
 354             case 'e':
 355                 if ( Oddflag ) {
 356                     (void)fprintf(stderr,
 357                         gettext("%s: Cannot have both even and odd parity\n"),
 358                         argv[0]);
 359                     exit(1);
 360                 }
 361                 Evenflag = 1;
 362                 break;
 363             case 'o':
 364                 if ( Evenflag ) {
 365                     (void)fprintf(stderr,
 366                         gettext("%s: Cannot have both even and odd parity\n"),
 367                         argv[0]);
 368                     exit(1);
 369                 }
 370                 Oddflag = 1;
 371                 break;
 372             case 'n':
 373                 nflag++;
 374                 printf(gettext("Please enter the number: "));
 375                 /* Read line from stdin, remove trailing newline, if any */
 376                 if (fgets(s, sizeof(s), stdin) != NULL &&
 377                         strchr(s, '\n') != NULL)
 378                    s[strlen(s)-1] = '\0';
 379                 break;
 380             case 's':
 381                 Sflag++;
 382                 Cucall.speed = optarg;
 383                 break;
 384             case 'l':
 385                 lflag++;
 386                 Cucall.line = optarg;
 387                 break;
 388             case 'c':
 389                 Cucall.type = optarg;
 390                 Mytype = optarg;
 391                 break;
 392             case 'b':
 393                 line_8bit = ((*optarg=='7') ? NO : ((*optarg=='8') ? YES : -1));
 394                 if ( line_8bit == -1 ) {
 395                     (void) fprintf(stderr,
 396                         gettext("%s: b option value must be '7' or '8'\n"),
 397                         argv[0]);
 398                     exit(1);
 399                 }
 400                 break;
 401             case 'L':
 402                 Dologin++;
 403                 break;
 404             case 'C':
 405                 Docmd++;
 406                 break;
 407             case 'H':
 408                 command_line_hups++;
 409                 break;
 410             case '?':
 411                 ++errflag;
 412         }
 413
 414 #ifdef  u3b
 415     {
 416     struct stat buff;
 417     if(fstat(TTYIN, &buff) < 0) {
 418         VERBOSE(gettext(P_NOTERMSTAT),"");
 419         exit(1);
 420     } else if ( (buff.st_mode & S_IFMT) == S_IFCHR && buff.st_rdev == 0 ) {
 421         VERBOSE(gettext(P_3BCONSOLE),"");
 422         exit(1);
 423         }
 424     }
 425 #endif
 426
 427     if((optind < argc && optind > 0) || (nflag && optind > 0)) {
 428         if(nflag)
 429             string=s;
 430         else
 431             string = strdup(argv[optind++]);
 432         Cucall.telno = string;
 433         if ( strlen(string) != strspn(string, "0123456789=-*#") ) {
 434             /* if it's not a legitimate telno, then it should be a systemname */
 435             if ( nflag ) {
 436                 (void)fprintf(stderr, gettext("%s: Bad phone number %s\n"),
 437                                 argv[0], string);
 438                 (void) fprintf(stderr, gettext("Phone numbers may contain "
 439                     "only the digits 0 through 9 and the special\n"
 440                     "characters =, -, * and #.\n"));
 441                 exit(1);
 442             }
 443             systemname++;
 444         }
 445     } else
 446         if(Cucall.line == CNULL)   /*if none of above, must be direct */
 447             ++errflag;
 448
 449     if(errflag) {
 450         VERBOSE(gettext(P_USAGE), argv[0]);
 451         exit(1);
 452     }
 453
 454     if ((Cucall.telno != CNULL) &&
 455                 (strlen(Cucall.telno) >= (size_t)(MAXPH - 1))) {
 456         VERBOSE(gettext(P_TELLENGTH),"");
 457         exit(0);
 458     }
 459
 460     /* save initial tty state */
 461     if (!(Saved_termios = ( ioctl(TTYIN, TCGETS, &_Tv0s) >= 0 ))) {
 462         Saved_tty = ( ioctl(TTYIN, TCGETA, &_Tv0) == 0 );
 463         _Tv0s.c_lflag = _Tv0.c_lflag;
 464         _Tv0s.c_oflag = _Tv0.c_oflag;
 465         _Tv0s.c_iflag = _Tv0.c_iflag;
 466         _Tv0s.c_cflag = _Tv0.c_cflag;
 467         for(i = 0; i < NCC; i++)
 468                 _Tv0s.c_cc[i] = _Tv0.c_cc[i];
 469     }
 470
 471     if (Saved_termios || Saved_tty) {
 472         char *p;
 473
 474         /*
 475          * We consider the terminal to be in 8 bit mode only if cs8 is set,
 476          * istrip is not set, and we're not in the "C" locale.  The "C"
 477          * locale is by definition 7 bit only.  This provides reasonable
 478          * compatibility when running in the "C" locale (currently the default)
 479          * and connecting to other systems, which are most often 7 bit systems.
 480          */
 481         term_8bit = ( (_Tv0s.c_cflag & CS8) && !(_Tv0s.c_iflag & ISTRIP) &&
 482           ((p = setlocale(LC_CTYPE, NULL)) != NULL) && (strcmp(p, "C") != 0) );
 483         if ( !Oddflag && !Evenflag )
 484             if (_Tv0s.c_cflag & PARENB)
 485                 if (_Tv0s.c_cflag & PARODD)
 486                     Oddflag = 1;
 487                 else
 488                     Evenflag = 1;
 489     }
 490
 491     if (line_8bit == -1)
 492         line_8bit = term_8bit;
 493
 494     term_mask = ( term_8bit ? 0377 : 0177 );
 495     line_mask = ( line_8bit ? 0377 : 0177 );
 496
 497     /* if not set, use the POSIX disabled designation */
 498 #ifdef _POSIX_VDISABLE
 499     vdisable = _POSIX_VDISABLE;
 500 #else
 501     vdisable = fpathconf(TTYIN, _PC_VDISABLE);
 502 #endif
 503     _Tintr = _Tv0s.c_cc[VINTR] ? _Tv0s.c_cc[VINTR] : vdisable;
 504     _Tquit = _Tv0s.c_cc[VQUIT] ? _Tv0s.c_cc[VQUIT] : vdisable;
 505     _Terase = _Tv0s.c_cc[VERASE] ? _Tv0s.c_cc[VERASE] : vdisable;
 506     _Tkill = _Tv0s.c_cc[VKILL] ? _Tv0s.c_cc[VKILL] : vdisable;
 507     _Teol = _Tv0s.c_cc[VEOL] ? _Tv0s.c_cc[VEOL] : vdisable;
 508     _Myeof = _Tv0s.c_cc[VEOF] ? _Tv0s.c_cc[VEOF] : '\04';
 509     Echoe = _Tv0s.c_lflag & ECHOE;
 510     Echok = _Tv0s.c_lflag & ECHOK;
 511
 512     (void)signal(SIGHUP, cleanup);
 513     (void)signal(SIGQUIT, cleanup);
 514     (void)signal(SIGINT, cleanup);
 515
 516 /* place call to system; if "cu systemname", use conn() from uucp
 517    directly.  Otherwise, use altconn() which dummies in the
 518    Systems file line.
 519 */
 520
 521     if(systemname) {
 522         if ( lflag )
 523             (void)fprintf(stderr,
 524                 gettext("%s: Warning: -l flag ignored when system name used\n"),
 525                 argv[0]);
 526         if ( Sflag )
 527             (void)fprintf(stderr,
 528                 gettext("%s: Warning: -s flag ignored when system name used\n"),
 529                 argv[0]);
 530         Cn = conn(string);
 531         if ( (Cn < 0) && (Cucall.type != CNULL) )
 532             Cn = altconn(&Cucall);
 533     } else
 534         Cn = altconn(&Cucall);
 535
 536     if(Cn < 0) {
 537         VERBOSE(gettext(P_CON_FAILED),UERRORTEXT);
 538         cleanup(-Cn);
 539     } else {
 540         struct stat Cnsbuf;
 541         if ( fstat(Cn, &Cnsbuf) == 0 )
 542             Dev_mode = Cnsbuf.st_mode;
 543         else
 544             Dev_mode = R_DEVICEMODE;
 545         fchmod(Cn, M_DEVICEMODE);
 546     }
 547
 548     if ((Docmd) && (argv[optind] == NULL)) {
 549         (void) fprintf(stderr,gettext("cu: local cmd is required, -C is ignored.\n"));
 550         VERBOSE(gettext(P_USAGE), argv[0]);
 551         Docmd=NO;
 552     }
 553
 554     if (!Docmd) {
 555         Euid = geteuid();
 556         if((setuid(getuid()) < 0) || (setgid(getgid()) < 0)) {
 557             VERBOSE("Unable to setuid/gid\n%s", "");
 558             cleanup(101);
 559         }
 560     }
 561
 562     if(Debug)
 563         tdmp(Cn);
 564
 565     /* At this point succeeded in getting an open communication line    */
 566     /* Conn() takes care of closing the Systems file                    */
 567
 568     if (!Docmd) {
 569         (void)signal(SIGINT,_onintrpt);
 570         _mode(1);                       /* put terminal in `raw' mode */
 571         VERBOSE("Connected\007\r\n%s", "");     /*bell!*/
 572
 573         /* must catch signals before fork.  if not and if _receive()    */
 574         /* fails in just the right (wrong?) way, _rcvdead() can be      */
 575         /* called and do "kill(getppid(),SIGUSR1);" before parent       */
 576         /* has done calls to signal() after recfork().                  */
 577         (void)signal(SIGUSR1, _bye);
 578         (void)signal(SIGHUP, cleanup);
 579         (void)signal(SIGQUIT, _onintrpt);
 580
 581         sysname(&prompt[1]);    /* set up system name prompt */
 582         (void) strcat(prompt, "]");
 583
 584         recfork();              /* checks for child == 0 */
 585
 586         if(Child > 0) {
 587             /*
 588              * Because the child counts hangups for the -H flag,
 589              * and because we fork a new child when doing (e.g.)
 590              * ~%take, we assume the first child we fork has
 591              * processed all the hangups and we reset the count here.
 592              * We really should pass the remaining count back from
 593              * the child to the parent when we kill the child.
 594              */
 595             command_line_hups = 0;
 596             Rtn_code = transmit();
 597             _quit(Rtn_code);
 598             /*NOTREACHED*/
 599         }
 600     } else {
 601         /*
 602          * Fork a child to run the specified command,
 603          * wait for it to finish, and clean up.
 604          */
 605         Child = dofork();
 606         if (Child == 0) {
 607             close(0);
 608             close(1);
 609             dup(Cn);
 610             dup(Cn);
 611             close(Cn);
 612             setgid(getgid());
 613             setuid(getuid());
 614             execvp(argv[optind], &argv[optind]);
 615             exit(-1);
 616             /* NOTREACHED */
 617         }
 618         wait(0);
 619         /* XXX - should return wait status as our exit code */
 620     }
 621     cleanup(Cn);
 622     /*NOTREACHED*/
 623         return (0);
 624 }
 625
 626 /*
 627  *      Kill the present child, if it exists, then fork a new one.
 628  */
 629
 630 static void
 631 recfork()
 632 {
 633     int ret, status;
 634     if (Child) {
 635         kill(Child, SIGKILL);
 636         while ( (ret = wait(&status)) != Child )
 637             if (ret == -1 && errno != EINTR)
 638                 break;
 639     }
 640     Child = dofork();
 641     if(Child == 0) {
 642         (void)signal(SIGUSR1, SIG_DFL);
 643         (void)signal(SIGHUP, _rcvdead);
 644         (void)signal(SIGQUIT, SIG_IGN);
 645         (void)signal(SIGINT, SIG_IGN);
 646
 647         _receive();     /* This should run until killed */
 648         /*NOTREACHED*/
 649     }
 650     return;
 651 }
 652
 653 /***************************************************************
 654  *      transmit: copy stdin to remote fd, except:
 655  *      ~.      terminate
 656  *      ~!      local login-style shell
 657  *      ~!cmd   execute cmd locally
 658  *      ~$proc  execute proc locally, send output to line
 659  *      ~%cmd   execute builtin cmd (put, take, or break)
 660  ****************************************************************/
 661 #ifdef forfutureuse
 662  /*****************************************************************
 663   *     ~+proc  execute locally, with stdout to and stdin from line.
 664   ******************************************************************/
 665 #endif
 666
 667 int
 668 transmit()
 669 {
 670     char b[BUFSIZ];
 671     char *p;
 672     int escape;
 673     int id = 0;  /* flag for systemname prompt on tilda escape */
 674
 675     CDEBUG(4,"transmit started\n\r%s", "");
 676
 677     /* In main loop, always waiting to read characters from     */
 678     /* keyboard; writes characters to remote, or to TTYOUT      */
 679     /* on a tilda escape                                        */
 680
 681     for (;;) {
 682         p = b;
 683         while(r_char(TTYIN) == YES) {
 684             if(p == b)          /* Escape on leading  ~    */
 685                 escape = (_Cxc == '~');
 686             if(p == b+1)        /* But not on leading ~~   */
 687                 escape &= (_Cxc != '~');
 688             if(escape) {
 689                  if(_Cxc == '\n' || _Cxc == '\r' || _Cxc == _Teol) {
 690                     *p = '\0';
 691                     if(tilda(b+1) == YES)
 692                         return(0);
 693                     id = 0;
 694                     break;
 695                 }
 696                 if(_Cxc == _Tintr || _Cxc == _Tkill || _Cxc == _Tquit ||
 697                         (Intrupt && _Cxc == '\0')) {
 698                     if(_Cxc == _Tkill) {
 699                         if(Echok)
 700                             VERBOSE("\r\n%s", "");
 701                     } else {
 702                         _Cxc = '\r';
 703                         if( w_char(Cn) == NO) {
 704                             VERBOSE(gettext(P_LINE_GONE),"");
 705                             return(IOERR);
 706                         }
 707                         id=0;
 708                     }
 709                     break;
 710                 }
 711                 if((p == b+1) && (_Cxc != _Terase) && (!id)) {
 712                     id = 1;
 713                     VERBOSE("%s", prompt);
 714                 }
 715                 if(_Cxc == _Terase) {
 716                     p = (--p < b)? b:p;
 717                     if(p > b)
 718                         if(Echoe) {
 719                             VERBOSE("\b \b%s", "");
 720                         } else
 721                             (void)w_char(TTYOUT);
 722                 } else {
 723                     (void)w_char(TTYOUT);
 724                     if(p-b < BUFSIZ)
 725                         *p++ = _Cxc;
 726                     else {
 727                         VERBOSE(gettext(P_TOOLONG),"");
 728                         break;
 729                     }
 730                 }
 731     /*not a tilda escape command*/
 732             } else {
 733                 if(Intrupt && _Cxc == '\0') {
 734                     CDEBUG(4,"got break in transmit\n\r%s", "");
 735                     Intrupt = NO;
 736                     (*genbrk)(Cn);
 737                     _flush();
 738                     break;
 739                 }
 740                 if(w_char(Cn) == NO) {
 741                     VERBOSE(gettext(P_LINE_GONE),"");
 742                     return(IOERR);
 743                 }
 744                 if(Duplex == NO) {
 745                     if((w_char(TTYERR) == NO) || (wioflsh(TTYERR) == NO))
 746                         return(IOERR);
 747                 }
 748                 if ((_Cxc == _Tintr) || (_Cxc == _Tquit) ||
 749                      ( (p==b) && (_Cxc == _Myeof) ) ) {
 750                     CDEBUG(4,"got a tintr\n\r%s", "");
 751                     _flush();
 752                     break;
 753                 }
 754                 if(_Cxc == '\n' || _Cxc == '\r' ||
 755                     _Cxc == _Teol || _Cxc == _Tkill) {
 756                     id=0;
 757                     Takeflag = NO;
 758                     break;
 759                 }
 760                 p = (char*)0;
 761             }
 762         }
 763     }
 764 }
 765
 766 /***************************************************************
 767  *      routine to halt input from remote and flush buffers
 768  ***************************************************************/
 769 static void
 770 _flush()
 771 {
 772     (void)ioctl(TTYOUT, TCXONC, 0);     /* stop tty output */
 773     (void)ioctl(Cn, TCFLSH, 0);         /* flush remote input */
 774     (void)ioctl(TTYOUT, TCFLSH, 1);     /* flush tty output */
 775     (void)ioctl(TTYOUT, TCXONC, 1);     /* restart tty output */
 776     if(Takeflag == NO) {
 777         return;         /* didn't interupt file transmission */
 778     }
 779     VERBOSE(gettext(P_FILEINTR),"");
 780     (void)sleep(3);
 781     _w_str("echo '\n~>\n';mesg y;stty echo\n");
 782     Takeflag = NO;
 783     return;
 784 }
 785
 786 /**************************************************************
 787  *      command interpreter for escape lines
 788  **************************************************************/
 789 int
 790 tilda(cmd)
 791 char    *cmd;
 792 {
 793
 794     VERBOSE("\r\n%s", "");
 795     CDEBUG(4,"call tilda(%s)\r\n", cmd);
 796
 797     switch(cmd[0]) {
 798         case CSUSP:
 799         case CDSUSP:
 800             _mode(0);
 801             kill(cmd[0] == CDSUSP ? getpid() : (pid_t) 0, SIGTSTP);
 802             _mode(1);
 803             break;
 804         case '.':
 805             if(Cucall.telno == CNULL)
 806                 if(cmd[1] != '.') {
 807                     _w_str("\04\04\04\04\04");
 808                     if (Child)
 809                         kill(Child, SIGKILL);
 810                     if (ioctl (Cn, TCGETS, &_Lvs) < 0) {
 811                         (void) ioctl (Cn, TCGETA, &_Lv);
 812                         /* speed to zero for hangup */
 813                         _Lv.c_cflag = 0;
 814                         (void) ioctl (Cn, TCSETAW, &_Lv);
 815                     } else {
 816                         /* speed to zero for hangup */
 817                         _Lvs.c_cflag &= 0xffff0000;
 818                         cfsetospeed(&_Lvs, B0);
 819                         (void) ioctl (Cn, TCSETSW, &_Lvs);
 820                     }
 821                     (void) sleep (2);
 822                 }
 823             return(YES);
 824         case '!':
 825             _shell(cmd);        /* local shell */
 826             VERBOSE("\r%c\r\n", *cmd);
 827             VERBOSE("(continue)%s", "");
 828             break;
 829         case '$':
 830             if(cmd[1] == '\0') {
 831                 VERBOSE(gettext(P_USECMD),"");
 832                 VERBOSE("(continue)%s", "");
 833             } else {
 834                 _shell(cmd);    /*Local shell  */
 835                 VERBOSE("\r%c\r\n", *cmd);
 836             }
 837             break;
 838
 839 #ifdef forfutureuse
 840         case '+':
 841             if(cmd[1] == '\0') {
 842                 VERBOSE(gettext(P_USEPLUSCMD), "");
 843                 VERBOSE("(continue)%s", "");
 844             } else {
 845                 if (*cmd == '+')
 846                           /* must suspend receive to give*/
 847                           /*remote out to stdin of cmd */
 848                     kill(Child, SIGKILL);
 849                     _shell(cmd);        /* Local shell */
 850                 if (*cmd == '+')
 851                     recfork();
 852                 VERBOSE("\r%c\r\n", *cmd);
 853             }
 854             break;
 855 #endif
 856         case '%':
 857             _dopercen(++cmd);
 858             break;
 859
 860         case 't':
 861             tdmp(TTYIN);
 862             VERBOSE("(continue)%s", "");
 863             break;
 864         case 'l':
 865             tdmp(Cn);
 866             VERBOSE("(continue)%s", "");
 867             break;
 868
 869         default:
 870             VERBOSE(gettext(P_STARTWITH),"");
 871             VERBOSE("(continue)%s", "");
 872             break;
 873     }
 874     return(NO);
 875 }
 876
 877 /***************************************************************
 878  *      The routine "shell" takes an argument starting with
 879  *      either "!" or "$", and terminated with '\0'.
 880  *      If $arg, arg is the name of a local shell file which
 881  *      is executed and its output is passed to the remote.
 882  *      If !arg, we escape to a local shell to execute arg
 883  *      with output to TTY, and if arg is null, escape to
 884  *      a local shell and blind the remote line.  In either
 885  *      case, '^D' will kill the escape status.
 886  **************************************************************/
 887
 888 #ifdef forfutureuse
 889 /***************************************************************
 890  *      Another argument to the routine "shell" may be +.  If +arg,
 891  *      arg is the name of a local shell file which is executed with
 892  *      stdin from and stdout to the remote.
 893  **************************************************************/
 894 #endif
 895
 896 static void
 897 _shell(str)
 898 char    *str;
 899 {
 900     pid_t       fk, w_ret;
 901     void        (*xx)(), (*yy)();
 902
 903     CDEBUG(4,"call _shell(%s)\r\n", str);
 904     fk = dofork();
 905     if(fk < 0)
 906         return;
 907     Shell = fk;
 908     _mode(0);   /* restore normal tty attributes */
 909     xx = signal(SIGINT, SIG_IGN);
 910     yy = signal(SIGQUIT, SIG_IGN);
 911     if(fk == 0) {
 912         char *shell;
 913
 914         if( (shell = getenv("SHELL")) == NULL)
 915             /* use default if user's shell is not set */
 916             shell = SHELL;
 917         (void)close(TTYOUT);
 918
 919         /***********************************************
 920          * Hook-up our "standard output"
 921          * to either the tty for '!' or the line
 922          * for '$'  as appropriate
 923          ***********************************************/
 924 #ifdef forfutureuse
 925
 926         /************************************************
 927          * Or to the line for '+'.
 928          **********************************************/
 929 #endif
 930
 931         (void)fcntl((*str == '!')? TTYERR:Cn,F_DUPFD,TTYOUT);
 932
 933 #ifdef forfutureuse
 934         /*************************************************
 935          * Hook-up "standard input" to the line for '+'.
 936          * **********************************************/
 937         if (*str == '+') {
 938             (void)close(TTYIN);
 939             (void)fcntl(Cn,F_DUPFD,TTYIN);
 940             }
 941 #endif
 942
 943         /***********************************************
 944          * Hook-up our "standard input"
 945          * to the tty for '!' and '$'.
 946          ***********************************************/
 947
 948         (void)close(Cn);        /*parent still has Cn*/
 949         (void)signal(SIGINT, SIG_DFL);
 950         (void)signal(SIGHUP, SIG_DFL);
 951         (void)signal(SIGQUIT, SIG_DFL);
 952         (void)signal(SIGUSR1, SIG_DFL);
 953         if(*++str == '\0')
 954             (void)execl(shell,shell,(char*) 0,(char*) 0,(char *) 0);
 955         else
 956             (void)execl(shell,"sh","-c",str,(char *) 0);
 957         VERBOSE(gettext(P_Ct_EXSH),"");
 958         exit(0);
 959     }
 960     while ((w_ret = wait((int*)0)) != fk)
 961         if (w_ret == -1 && errno != EINTR)
 962             break;
 963     Shell = 0;
 964     (void)signal(SIGINT, xx);
 965     (void)signal(SIGQUIT, yy);
 966     _mode(1);
 967     return;
 968 }
 969
 970
 971 /***************************************************************
 972  *      This function implements the 'put', 'take', 'break',
 973  *      'ifc' (aliased to nostop) and 'ofc' (aliased to noostop)
 974  *      commands which are internal to cu.
 975  ***************************************************************/
 976
 977 static void
 978 _dopercen(cmd)
 979 char *cmd;
 980 {
 981     char        *arg[5];
 982     char        *getpath;
 983     char        mypath[MAXPATH];
 984     int narg;
 985
 986     blckcnt((long)(-1));
 987
 988     CDEBUG(4,"call _dopercen(\"%s\")\r\n", cmd);
 989
 990     arg[narg=0] = strtok(cmd, " \t\n");
 991
 992     /* following loop breaks out the command and args */
 993     while((arg[++narg] = strtok((char*) NULL, " \t\n")) != NULL) {
 994         if(narg < 4)
 995             continue;
 996         else
 997             break;
 998     }
 999
1000     /* ~%take file option */
1001     if(EQUALS(arg[0], "take")) {
1002         if(narg < 2 || narg > 3) {
1003             VERBOSE("usage: ~%%take from [to]\r\n%s", "");
1004             VERBOSE("(continue)%s", "");
1005             return;
1006         }
1007         if(narg == 2)
1008             arg[2] = arg[1];
1009         (void) strcpy(filename, arg[2]);
1010         recfork();      /* fork so child (receive) knows filename */
1011
1012         /*
1013          * be sure that the remote file (arg[1]) exists before
1014          * you try to take it.   otherwise, the error message from
1015          * cat will wind up in the local file (arg[2])
1016          *
1017          * what we're doing is:
1018          *      stty -echo; \
1019          *      if test -r arg1
1020          *      then (echo '~[local]'>arg2; cat arg1; echo '~[local]'>)
1021          *      else echo can't open: arg1
1022          *      fi; \
1023          *      stty echo
1024          *
1025          */
1026         _w_str("stty -echo;if test -r ");
1027         _w_str(arg[1]);
1028         _w_str("; then (echo '~");
1029         _w_str(prompt);
1030         _w_str(">'");
1031         _w_str(arg[2]);
1032         _w_str(";cat ");
1033         _w_str(arg[1]);
1034         _w_str(";echo '~");
1035         _w_str(prompt);
1036         _w_str(">'); else echo cant\\'t open: ");
1037         _w_str(arg[1]);
1038         _w_str("; fi;stty echo\n");
1039         Takeflag = YES;
1040         return;
1041     }
1042     /* ~%put file option*/
1043     if(EQUALS(arg[0], "put")) {
1044         FILE    *file;
1045         char    ch, buf[BUFSIZ], spec[NCC+1], *b, *p, *q;
1046         int     i, j, len, tc=0, lines=0;
1047         long    chars=0L;
1048
1049         if(narg < 2 || narg > 3) {
1050             VERBOSE("usage: ~%%put from [to]\r\n%s", "");
1051             VERBOSE("(continue)%s", "");
1052             return;
1053         }
1054         if(narg == 2)
1055             arg[2] = arg[1];
1056
1057         if((file = fopen(arg[1], "r")) == NULL) {
1058             VERBOSE(gettext(P_Ct_OPEN), arg[1]);
1059             VERBOSE("(continue)%s", "");
1060             return;
1061         }
1062         /*
1063          * if cannot write into file on remote machine, write into
1064          * /dev/null
1065          *
1066          * what we're doing is:
1067          *      stty -echo
1068          *      (cat - > arg2) || cat - > /dev/null
1069          *      stty echo
1070          */
1071         _w_str("stty -echo;(cat - >");
1072         _w_str(arg[2]);
1073         _w_str(")||cat - >/dev/null;stty echo\n");
1074         Intrupt = NO;
1075         for(i=0,j=0; i < NCC; ++i)
1076             if((ch=_Tv0s.c_cc[i]) != '\0')
1077                 spec[j++] = ch;
1078         spec[j] = '\0';
1079         _mode(2);       /*accept interrupts from keyboard*/
1080         (void)sleep(5); /*hope that w_str info digested*/
1081
1082         /* Read characters line by line into buf to write to    */
1083         /* remote with character and line count for blckcnt     */
1084         while(Intrupt == NO &&
1085                 fgets(b= &buf[MID],MID,file) != NULL) {
1086             /* worse case is each char must be escaped*/
1087             len = strlen(b);
1088             chars += len;               /* character count */
1089             p = b;
1090             while(q = strpbrk(p, spec)) {
1091                 if(*q == _Tintr || *q == _Tquit || *q == _Teol) {
1092                     VERBOSE(gettext(P_Ct_SPECIAL), *q);
1093                     (void)strcpy(q, q+1);
1094                     Intrupt = YES;
1095                 } else {
1096                     b = strncpy(b-1, b, q-b);
1097                     *(q-1) = '\\';
1098                 }
1099                 p = q+1;
1100             }
1101             if((tc += len) >= MID) {
1102                 (void)sleep(1);
1103                 tc = len;
1104             }
1105             if(write(Cn, b, (unsigned)strlen(b)) < 0) {
1106                 VERBOSE(gettext(P_IOERR),"");
1107                 Intrupt = YES;
1108                 break;
1109             }
1110             ++lines;            /* line count */
1111             blckcnt((long)chars);
1112         }
1113         _mode(1);
1114         blckcnt((long)(-2));            /* close */
1115         (void)fclose(file);
1116         if(Intrupt == YES) {
1117             Intrupt = NO;
1118             _w_str("\n");
1119             VERBOSE(gettext(P_CNTAFTER), ++chars);
1120         } else {
1121             VERBOSE(gettext(P_CNTLINES), lines);
1122             VERBOSE(gettext(P_CNTCHAR),chars);
1123         }
1124         (void)sleep(3);
1125         _w_str("\04");
1126         return;
1127     }
1128
1129         /*  ~%b or ~%break  */
1130     if(EQUALS(arg[0], "b") || EQUALS(arg[0], "break")) {
1131         (*genbrk)(Cn);
1132         return;
1133     }
1134         /*  ~%d or ~%debug toggle  */
1135     if(EQUALS(arg[0], "d") || EQUALS(arg[0], "debug")) {
1136         if(Debug == 0)
1137             Debug = 9;
1138         else
1139             Debug = 0;
1140         VERBOSE("(continue)%s", "");
1141         return;
1142     }
1143         /*  ~%[ifc|nostop]  toggles start/stop input control  */
1144     if( EQUALS(arg[0], "ifc") || EQUALS(arg[0], "nostop") ) {
1145         (void)ioctl(Cn, TCGETA, &_Tv);
1146         Ifc = !Ifc;
1147         if(Ifc == YES)
1148             _Tv.c_iflag |= IXOFF;
1149         else
1150             _Tv.c_iflag &= ~IXOFF;
1151         (void)ioctl(Cn, TCSETAW, &_Tv);
1152         _mode(1);
1153         VERBOSE("(ifc %s)", (Ifc ? "enabled" : "disabled"));
1154         VERBOSE("(continue)%s", "");
1155         return;
1156     }
1157         /*  ~%[ofc|noostop]  toggles start/stop output control  */
1158     if( EQUALS(arg[0], "ofc") || EQUALS(arg[0], "noostop") ) {
1159         (void)ioctl(Cn, TCGETA, &_Tv);
1160         Ofc = !Ofc;
1161         if(Ofc == YES)
1162             _Tv.c_iflag |= IXON;
1163         else
1164             _Tv.c_iflag &= ~IXON;
1165         (void)ioctl(Cn, TCSETAW, &_Tv);
1166         _mode(1);
1167         VERBOSE("(ofc %s)", (Ofc ? "enabled" : "disabled"));
1168         VERBOSE("(continue)%s", "");
1169         return;
1170     }
1171         /*  ~%divert toggles unsolicited redirection security */
1172     if( EQUALS(arg[0], "divert") ) {
1173         Divert = !Divert;
1174         recfork();      /* fork a new child so it knows about change */
1175         VERBOSE("(unsolicited diversion %s)", (Divert ? "enabled" : "disabled"));
1176         VERBOSE("(continue)%s", "");
1177         return;
1178     }
1179         /*  ~%old toggles recognition of old-style '~>:filename' */
1180     if( EQUALS(arg[0], "old") ) {
1181         OldStyle = !OldStyle;
1182         recfork();      /* fork a new child so it knows about change */
1183         VERBOSE("(old-style diversion %s)", (OldStyle ? "enabled" : "disabled"));
1184         VERBOSE("(continue)%s", "");
1185         return;
1186     }
1187         /* Change local current directory */
1188     if(EQUALS(arg[0], "cd")) {
1189         if (narg < 2) {
1190             getpath = getenv("HOME");
1191             strlcpy(mypath, getpath, sizeof (mypath));
1192             if(chdir(mypath) < 0) {
1193                 VERBOSE("Cannot change to %s\r\n", mypath);
1194                 VERBOSE("(continue)%s", "");
1195                 return;
1196             }
1197         } else if (chdir(arg[1]) < 0) {
1198             VERBOSE("Cannot change to %s\r\n", arg[1]);
1199             VERBOSE("(continue)%s", "");
1200             return;
1201         }
1202         recfork();      /* fork a new child so it knows about change */
1203         VERBOSE("(continue)%s", "");
1204         return;
1205     }
1206
1207    if (arg[0] == (char *) NULL)
1208        arg[0] = "";
1209
1210     VERBOSE("~%%%s unknown to cu\r\n", arg[0]);
1211     VERBOSE("(continue)%s", "");
1212     return;
1213 }
1214
1215 /***************************************************************
1216  *      receive: read from remote line, write to fd=1 (TTYOUT)
1217  *      catch:
1218  *      ~>[>]:file
1219  *      .
1220  *      . stuff for file
1221  *      .
1222  *      ~>      (ends diversion)
1223  ***************************************************************/
1224
1225 static void
1226 _receive()
1227 {
1228     int silent = NO, file = -1;
1229     char *p;
1230     int tic;
1231     int for_me = NO;
1232     char        b[BUFSIZ];
1233     char        *b_p;
1234     long        count;
1235     int         line_ok = 1, rval;
1236
1237     CDEBUG(4,"_receive started\r\n%s", "");
1238
1239     b[0] = '\0';
1240     b_p = p = b;
1241
1242     while(line_ok) {
1243         rval = r_char(Cn);
1244         if (rval == NO) {
1245             line_ok = 0;
1246             continue;
1247         }
1248         if (rval == HUNGUP) {
1249             if (command_line_hups > 0) {
1250                 CDEBUG(4, "Ignoring device hangup\n%s", "");
1251                 command_line_hups--;
1252                 (void) setuid(Euid);    /* reacquire privileges */
1253                 if (clear_hup(Cn) != SUCCESS) {
1254                     DEBUG(4, "Unable to clear hup on device\n%s", "");
1255                     line_ok = 0;
1256                 }
1257                 (void) setuid(getuid());  /* relinquish privileges */
1258             } else
1259                 line_ok = 0;
1260             continue;
1261         }
1262
1263         if(silent == NO)    /* ie., if not redirecting from screen */
1264             if(w_char(TTYOUT) == NO)
1265                 _rcvdead(IOERR);    /* this will exit */
1266         /* remove CR's and fill inserted by remote */
1267         if(_Cxc == '\0' || _Cxc == RUB || _Cxc == '\r')
1268             continue;
1269         *p++ = _Cxc;
1270         if(_Cxc != '\n' && (p-b) < BUFSIZ)
1271             continue;
1272         /* ****************************************** */
1273         /* This code deals with ~%take file diversion */
1274         /* ****************************************** */
1275         if (b[0] == '~') {
1276             int    append;
1277
1278             if (EQUALSN(&b[1],prompt,strlen(prompt))) {
1279                 b_p = b + 1 + strlen(prompt);
1280                 for_me = YES;
1281             } else {
1282                 b_p = b + 1;
1283                 for_me = NO;
1284             }
1285             if ( (for_me || OldStyle) && (*b_p == '>') ) {
1286                 /* This is an acceptable '~[uname]>' line */
1287                 b_p++;
1288                 if ( (*b_p == '\n') && (silent == YES) ) {
1289                     /* end of diversion */
1290                     *b_p = '\0';
1291                     (void) strcpy(filename, "/dev/null");
1292                     if ( file >= 0 && close(file) ) {
1293                         VERBOSE(gettext(P_Ct_UNDIVERT), b_p);
1294                         perror(gettext("cu: close failed"));
1295                         VERBOSE("%s","\r");
1296                     }
1297                     silent = NO;
1298                     blckcnt((long)(-2));
1299                     VERBOSE("%s\r\n", b);
1300                     VERBOSE(gettext(P_CNTLINES), tic);
1301                     VERBOSE(gettext(P_CNTCHAR), count);
1302                     file = -1;
1303                     p = b;
1304                     continue;
1305                 } else if (*b_p != '\n') {
1306                     if ( *b_p == '>' ) {
1307                         append = 1;
1308                         b_p++;
1309                     }
1310                     if ( (for_me || (OldStyle && (*b_p == ':'))) && (silent == NO) ) {
1311                         /* terminate filename string */
1312                         *(p-1) = '\0';
1313                         if ( *b_p == ':' )
1314                             b_p++;
1315                         if ( !EQUALS(filename, b_p) ) {
1316                             if ( !Divert  || !EQUALS(filename, "/dev/null") ) {
1317                                 VERBOSE(gettext(P_Bad_DIVERT), b_p);
1318                                 (void) strcpy(filename, "/dev/null");
1319                                 append = 1;
1320                             } else {
1321                                 (void) strcpy(filename, b_p);
1322                             }
1323                         }
1324                         if ( append && ((file=open(filename,O_WRONLY)) >= 0) )
1325                             (void)lseek(file, 0L, 2);
1326                         else
1327                             file = creat(filename, PUB_FILEMODE);
1328                         if (file < 0) {
1329                             VERBOSE(gettext(P_Ct_DIVERT), filename);
1330                             perror(gettext("cu: open|creat failed"));
1331                             VERBOSE("%s","\r");
1332                             (void)sleep(5); /* 10 seemed too long*/
1333                         }
1334                         silent = YES;
1335                         count = tic = 0;
1336                         p = b;
1337                         continue;
1338                     }
1339                 }
1340             }
1341         }
1342         /* Regular data, divert if appropriate */
1343         if ( silent == YES ) {
1344             if ( file >= 0)
1345                 (void)write(file, b, (unsigned)(p-b));
1346             count += p-b;       /* tally char count */
1347             ++tic;              /* tally lines */
1348             blckcnt((long)count);
1349         }
1350         p = b;
1351     }
1352     /*
1353      * we used to tell of lost carrier here, but now
1354      * defer to _bye() so that escape processes are
1355      * not interrupted.
1356      */
1357     _rcvdead(IOERR);
1358     return;
1359 }
1360
1361 /***************************************************************
1362  *      change the TTY attributes of the users terminal:
1363  *      0 means restore attributes to pre-cu status.
1364  *      1 means set `raw' mode for use during cu session.
1365  *      2 means like 1 but accept interrupts from the keyboard.
1366  ***************************************************************/
1367 static void
1368 _mode(arg)
1369 {
1370     int i;
1371
1372     CDEBUG(4,"call _mode(%d)\r\n", arg);
1373     if(arg == 0) {
1374         if ( Saved_termios )
1375                 (void)ioctl(TTYIN, TCSETSW, &_Tv0s);
1376         else if ( Saved_tty ) {
1377                 _Tv0.c_lflag = _Tv0s.c_lflag;
1378                 _Tv0.c_oflag = _Tv0s.c_oflag;
1379                 _Tv0.c_iflag = _Tv0s.c_iflag;
1380                 _Tv0.c_cflag = _Tv0s.c_cflag;
1381                 for(i = 0; i < NCC; i++)
1382                         _Tv0.c_cc[i] = _Tv0s.c_cc[i];
1383                 (void)ioctl(TTYIN, TCSETAW, &_Tv0);
1384         }
1385     } else {
1386         (void)ioctl(TTYIN, TCGETA, &_Tv);
1387         if(arg == 1) {
1388             _Tv.c_iflag &= ~(INLCR | ICRNL | IGNCR | IUCLC);
1389             if ( !term_8bit )
1390                 _Tv.c_iflag |= ISTRIP;
1391             _Tv.c_oflag |= OPOST;
1392             _Tv.c_oflag &= ~(OLCUC | ONLCR | OCRNL | ONOCR | ONLRET);
1393             _Tv.c_lflag &= ~(ICANON | ISIG | ECHO);
1394             if(Ifc == NO)
1395                 _Tv.c_iflag &= ~IXON;
1396             else
1397                 _Tv.c_iflag |= IXON;
1398             if(Ofc == NO)
1399                 _Tv.c_iflag &= ~IXOFF;
1400             else
1401                 _Tv.c_iflag |= IXOFF;
1402             if(Terminal) {
1403                 _Tv.c_oflag |= ONLCR;
1404                 _Tv.c_iflag |= ICRNL;
1405             }
1406             _Tv.c_cc[VEOF] = '\01';
1407             _Tv.c_cc[VEOL] = '\0';
1408         }
1409         if(arg == 2) {
1410             _Tv.c_iflag |= IXON;
1411             _Tv.c_lflag |= ISIG;
1412         }
1413         (void)ioctl(TTYIN, TCSETAW, &_Tv);
1414     }
1415     return;
1416 }
1417
1418
1419 static pid_t
1420 dofork()
1421 {
1422     int i;
1423     pid_t x;
1424
1425     for(i = 0; i < 6; ++i) {
1426         if((x = fork()) >= 0) {
1427             return(x);
1428         }
1429     }
1430
1431     if(Debug) perror("dofork");
1432
1433     VERBOSE(gettext(P_Ct_FK),"");
1434     return(x);
1435 }
1436
1437 static int
1438 r_char(fd)
1439 {
1440     int rtn = 1, rfd;
1441     char *riobuf;
1442
1443     /* find starting pos in correct buffer in Riobuf    */
1444     rfd = RIOFD(fd);
1445     riobuf = &Riobuf[rfd*WRIOBSZ];
1446
1447     if (Riop[rfd] >= &riobuf[Riocnt[rfd]]) {
1448         /* empty read buffer - refill it        */
1449
1450         /*      flush any waiting output        */
1451         if ( (wioflsh(Cn) == NO ) || (wioflsh(TTYOUT) == NO) )
1452             return(NO);
1453
1454         while((rtn = read(fd, riobuf, WRIOBSZ)) < 0){
1455             if(errno == EINTR) {
1456                 /* onintrpt() called asynchronously before this line */
1457                 if(Intrupt == YES) {
1458                     /* got a BREAK */
1459                     _Cxc = '\0';
1460                     return(YES);
1461                 } else {
1462                     /*a signal other than interrupt*/
1463                     /*received during read*/
1464                     continue;
1465                 }
1466             } else {
1467                 CDEBUG(4,"got read error, not EINTR\n\r%s", "");
1468                 break;                  /* something wrong */
1469             }
1470         }
1471         if (rtn > 0) {
1472             /* reset current position in buffer */
1473             /* and count of available chars             */
1474             Riop[rfd] = riobuf;
1475             Riocnt[rfd] = rtn;
1476         }
1477     }
1478
1479     if ( rtn > 0 ) {
1480         _Cxc = *(Riop[rfd]++) & RMASK(fd);      /* mask off appropriate bits */
1481         return(YES);
1482     } else if (rtn == 0) {
1483         _Cxc = '\0';
1484         return (HUNGUP);
1485     } else {
1486         _Cxc = '\0';
1487         return(NO);
1488     }
1489 }
1490
1491 static int
1492 w_char(fd)
1493 {
1494     int wfd;
1495     char *wiobuf;
1496
1497     /* find starting pos in correct buffer in Wiobuf    */
1498     wfd = WIOFD(fd);
1499     wiobuf = &Wiobuf[wfd*WRIOBSZ];
1500
1501     if (Wiop[wfd] >= &wiobuf[WRIOBSZ]) {
1502         /* full output buffer - flush it */
1503         if ( wioflsh(fd) == NO )
1504             return(NO);
1505     }
1506     *(Wiop[wfd]++) = _Cxc & WMASK(fd);  /* mask off appropriate bits */
1507     return(YES);
1508 }
1509
1510 /* wioflsh      flush output buffer     */
1511 static int
1512 wioflsh(fd)
1513 int fd;
1514 {
1515     int wfd;
1516     char *wiobuf;
1517
1518     /* find starting pos in correct buffer in Wiobuf    */
1519     wfd = WIOFD(fd);
1520     wiobuf = &Wiobuf[wfd*WRIOBSZ];
1521
1522     if (Wiop[wfd] > wiobuf) {
1523         /* there's something in the buffer */
1524         while(write(fd, wiobuf, (Wiop[wfd] - wiobuf)) < 0) {
1525             if(errno == EINTR) {
1526                 if(Intrupt == YES) {
1527                     VERBOSE("\ncu: Output blocked\r\n%s", "");
1528                     _quit(IOERR);
1529                 } else
1530                     continue;   /* alarm went off */
1531             } else {
1532                 Wiop[wfd] = wiobuf;
1533                 return(NO);                     /* bad news */
1534             }
1535         }
1536     }
1537     Wiop[wfd] = wiobuf;
1538     return(YES);
1539 }
1540
1541
1542 static void
1543 _w_str(string)
1544 char *string;
1545 {
1546     int len;
1547
1548     len = strlen(string);
1549     if ( write(Cn, string, (unsigned)len) != len )
1550         VERBOSE(gettext(P_LINE_GONE),"");
1551     return;
1552 }
1553
1554 /* ARGSUSED */
1555 static void
1556 _onintrpt(sig)
1557 int sig;
1558 {
1559     (void)signal(SIGINT, _onintrpt);
1560     (void)signal(SIGQUIT, _onintrpt);
1561     Intrupt = YES;
1562     return;
1563 }
1564
1565 static void
1566 _rcvdead(arg)   /* this is executed only in the receive process */
1567 int arg;
1568 {
1569     CDEBUG(4,"call _rcvdead(%d)\r\n", arg);
1570     (void)kill(getppid(), SIGUSR1);
1571     exit((arg == SIGHUP)? SIGHUP: arg);
1572     /*NOTREACHED*/
1573 }
1574
1575 static void
1576 _quit(arg)      /* this is executed only in the parent process */
1577 int arg;
1578 {
1579     CDEBUG(4,"call _quit(%d)\r\n", arg);
1580     (void)kill(Child, SIGKILL);
1581     _bye(arg);
1582     /*NOTREACHED*/
1583 }
1584
1585 static void
1586 _bye(arg)       /* this is executed only in the parent proccess */
1587 int arg;
1588 {
1589     int status;
1590     pid_t obit;
1591
1592     if ( Shell > 0 )
1593         while ((obit = wait(&status)) != Shell) {
1594             if (obit == -1 && errno != EINTR)
1595                 break;
1596             /* _receive (Child) may have ended - check it out */
1597             if (obit == Child)
1598                 Child = 0;
1599         }
1600
1601     /* give user customary message after escape command returns */
1602     if (arg == SIGUSR1)
1603         VERBOSE("\r\nLost Carrier\r\n%s", "");
1604
1605     CDEBUG(4,"call _bye(%d)\r\n", arg);
1606
1607     (void)signal(SIGINT, SIG_IGN);
1608     (void)signal(SIGQUIT, SIG_IGN);
1609     /* if _receive() ended already, don't wait for it again */
1610     if ( Child != 0 )
1611         while ((obit = wait(&status)) != Child)
1612             if (obit == -1 && errno != EINTR)
1613                 break;
1614     VERBOSE("\r\nDisconnected\007\r\n%s", "");
1615     cleanup((arg == SIGUSR1)? (status >>= 8): arg);
1616     /*NOTREACHED*/
1617 }
1618
1619
1620
1621 void
1622 cleanup(code)   /*this is executed only in the parent process*/
1623 int code;       /*Closes device; removes lock files       */
1624 {
1625
1626     CDEBUG(4,"call cleanup(%d)\r\n", code);
1627
1628     if (Docmd) {
1629         if (Child > 0)
1630             (void)kill(Child, SIGTERM);
1631     } else
1632         (void) setuid(Euid);
1633     if(Cn > 0) {
1634         fchmod(Cn, Dev_mode);
1635         fd_rmlock(Cn);
1636         (void)close(Cn);
1637     }
1638
1639
1640     rmlock((char*) NULL);       /* remove all lock files for this process */
1641     if (!Docmd)
1642         _mode(0);
1643     exit(code);         /* code=negative for signal causing disconnect*/
1644 }
1645
1646
1647
1648 void
1649 tdmp(arg)
1650 int arg;
1651 {
1652
1653     struct termio xv;
1654     int i;
1655
1656     VERBOSE("\rdevice status for fd=%d\r\n", arg);
1657     VERBOSE("F_GETFL=%o,", fcntl(arg, F_GETFL,1));
1658     if(ioctl(arg, TCGETA, &xv) < 0) {
1659         char    buf[100];
1660         i = errno;
1661         (void)snprintf(buf, sizeof (buf), gettext("\rtdmp for fd=%d"), arg);
1662         errno = i;
1663         perror(buf);
1664         return;
1665     }
1666     VERBOSE("iflag=`%o',", xv.c_iflag);
1667     VERBOSE("oflag=`%o',", xv.c_oflag);
1668     VERBOSE("cflag=`%o',", xv.c_cflag);
1669     VERBOSE("lflag=`%o',", xv.c_lflag);
1670     VERBOSE("line=`%o'\r\n", xv.c_line);
1671     VERBOSE("cc[0]=`%o',",  xv.c_cc[0]);
1672     for(i=1; i<8; ++i) {
1673         VERBOSE("[%d]=", i);
1674         VERBOSE("`%o',",xv.c_cc[i]);
1675     }
1676     VERBOSE("\r\n%s", "");
1677     return;
1678 }
1679
1680
1681
1682 static void
1683 sysname(name)
1684 char * name;
1685 {
1686
1687     char *s;
1688
1689     if(uname(&utsn) < 0)
1690         s = "Local";
1691     else
1692         s = utsn.nodename;
1693
1694     strcpy(name, s);
1695     return;
1696 }
1697
1698
1699 static void
1700 blckcnt(count)
1701 long count;
1702 {
1703     static long lcharcnt = 0;
1704     long c1, c2;
1705     int i;
1706     char c;
1707
1708     if(count == (long) (-1)) {  /* initialization call */
1709         lcharcnt = 0;
1710         return;
1711     }
1712     c1 = lcharcnt/BUFSIZ;
1713     if(count != (long)(-2)) {   /* regular call */
1714         c2 = count/BUFSIZ;
1715         for(i = c1; i++ < c2;) {
1716             c = '0' + i%10;
1717             write(2, &c, 1);
1718             if(i%NPL == 0)
1719                 write(2, "\n\r", 2);
1720         }
1721         lcharcnt = count;
1722     } else {
1723         c2 = (lcharcnt + BUFSIZ -1)/BUFSIZ;
1724         if(c1 != c2)
1725             write(2, "+\n\r", 3);
1726         else if(c2%NPL != 0)
1727             write(2, "\n\r", 2);
1728         lcharcnt = 0;
1729     }
1730     return;
1731 }
1732
1733 /*VARARGS*/
1734 /*ARGSUSED*/
1735 void
1736 assert (s1, s2, i1, s3, i2)
1737 char *s1, *s2, *s3;
1738 int i1, i2;
1739 { }             /* for ASSERT in gnamef.c */
1740
1741 /*ARGSUSED*/
1742 void
1743 logent (s1, s2)
1744 char *s1, *s2;
1745 { }             /* so we can load ulockf() */