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
main(argc,argv)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
recfork()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
transmit()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
_flush()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
tilda(cmd)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
_shell(str)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
_dopercen(cmd)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
_receive()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
_mode(arg)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
dofork()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
r_char(fd)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
w_char(fd)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
wioflsh(fd)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
_w_str(string)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
_onintrpt(sig)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
_rcvdead(arg)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
_quit(arg)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
_bye(arg)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
cleanup(code)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
tdmp(arg)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
sysname(name)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
blckcnt(count)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
assert(s1,s2,i1,s3,i2)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
logent(s1,s2)1743 logent (s1, s2)
1744 char *s1, *s2;
1745 { } /* so we can load ulockf() */
1746