![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to cusub.c CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [MW Coherent from dump] / coherent / g / usr / lib / uucp / tay104 / unix|
Return to cusub.c CVS log | Up to [MW Coherent from dump] / coherent / g / usr / lib / uucp / tay104 / unix |
1.1 ! root 1: /* cusub.c ! 2: System dependent routines for cu. ! 3: ! 4: Copyright (C) 1992 Ian Lance Taylor ! 5: ! 6: This file is part of the Taylor UUCP package. ! 7: ! 8: This program is free software; you can redistribute it and/or ! 9: modify it under the terms of the GNU General Public License as ! 10: published by the Free Software Foundation; either version 2 of the ! 11: License, or (at your option) any later version. ! 12: ! 13: This program is distributed in the hope that it will be useful, but ! 14: WITHOUT ANY WARRANTY; without even the implied warranty of ! 15: MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU ! 16: General Public License for more details. ! 17: ! 18: You should have received a copy of the GNU General Public License ! 19: along with this program; if not, write to the Free Software ! 20: Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA. ! 21: ! 22: The author of the program may be contacted at [email protected] or ! 23: c/o Infinity Development Systems, P.O. Box 520, Waltham, MA 02254. ! 24: */ ! 25: ! 26: #include "uucp.h" ! 27: ! 28: #if USE_RCS_ID ! 29: const char cusub_rcsid[] = "$Id: cusub.c,v 1.1 93/07/30 08:02:24 bin Exp Locker: bin $"; ! 30: #endif ! 31: ! 32: #include "uudefs.h" ! 33: #include "uuconf.h" ! 34: #include "sysdep.h" ! 35: #include "system.h" ! 36: #include "cu.h" ! 37: #include "conn.h" ! 38: #include "prot.h" ! 39: ! 40: #include <errno.h> ! 41: ! 42: /* Get definitions for EAGAIN, EWOULDBLOCK and ENODATA. */ ! 43: #ifndef EAGAIN ! 44: #ifndef EWOULDBLOCK ! 45: #define EAGAIN (-1) ! 46: #define EWOULDBLOCK (-1) ! 47: #else /* defined (EWOULDBLOCK) */ ! 48: #define EAGAIN EWOULDBLOCK ! 49: #endif /* defined (EWOULDBLOCK) */ ! 50: #else /* defined (EAGAIN) */ ! 51: #ifndef EWOULDBLOCK ! 52: #define EWOULDBLOCK EAGAIN ! 53: #endif /* ! defined (EWOULDBLOCK) */ ! 54: #endif /* defined (EAGAIN) */ ! 55: ! 56: #ifndef ENODATA ! 57: #define ENODATA EAGAIN ! 58: #endif ! 59: ! 60: /* Local variables. */ ! 61: ! 62: /* The EOF character, as set by fsysdep_terminal_raw. */ ! 63: static char bSeof; ! 64: ! 65: /* The SUSP character, as set by fsysdep_terminal_raw. */ ! 66: static char bStstp; ! 67: ! 68: /* Local functions. */ ! 69: ! 70: static const char *zsport_line P((const struct uuconf_port *qport)); ! 71: static void uscu_child P((struct sconnection *qconn, int opipe)); ! 72: static RETSIGTYPE uscu_alarm P((int isig)); ! 73: static int cscu_escape P((char *pbcmd, const char *zlocalname)); ! 74: static RETSIGTYPE uscu_alarm_kill P((int isig)); ! 75: ! 76: /* Return the device name for a port, or NULL if none. */ ! 77: ! 78: static const char * ! 79: zsport_line (qport) ! 80: const struct uuconf_port *qport; ! 81: { ! 82: const char *zline; ! 83: ! 84: if (qport == NULL) ! 85: return NULL; ! 86: ! 87: switch (qport->uuconf_ttype) ! 88: { ! 89: default: ! 90: case UUCONF_PORTTYPE_STDIN: ! 91: return NULL; ! 92: case UUCONF_PORTTYPE_MODEM: ! 93: zline = qport->uuconf_u.uuconf_smodem.uuconf_zdevice; ! 94: break; ! 95: case UUCONF_PORTTYPE_DIRECT: ! 96: zline = qport->uuconf_u.uuconf_sdirect.uuconf_zdevice; ! 97: break; ! 98: case UUCONF_PORTTYPE_TCP: ! 99: case UUCONF_PORTTYPE_TLI: ! 100: return NULL; ! 101: } ! 102: ! 103: if (zline == NULL) ! 104: zline = qport->uuconf_zname; ! 105: return zline; ! 106: } ! 107: ! 108: /* Check whether the user has legitimate access to a port. */ ! 109: ! 110: boolean ! 111: fsysdep_port_access (qport) ! 112: struct uuconf_port *qport; ! 113: { ! 114: const char *zline; ! 115: char *zfree; ! 116: boolean fret; ! 117: ! 118: zline = zsport_line (qport); ! 119: if (zline == NULL) ! 120: return TRUE; ! 121: ! 122: zfree = NULL; ! 123: if (*zline != '/') ! 124: { ! 125: zfree = zbufalc (sizeof "/dev/" + strlen (zline)); ! 126: sprintf (zfree, "/dev/%s", zline); ! 127: zline = zfree; ! 128: } ! 129: ! 130: fret = access (zline, R_OK | W_OK) == 0; ! 131: ubuffree (zfree); ! 132: return fret; ! 133: } ! 134: ! 135: /* Return whether the given port is named by the given line. */ ! 136: ! 137: boolean ! 138: fsysdep_port_is_line (qport, zline) ! 139: struct uuconf_port *qport; ! 140: const char *zline; ! 141: { ! 142: const char *zpline; ! 143: char *zfree1, *zfree2; ! 144: boolean fret; ! 145: ! 146: zpline = zsport_line (qport); ! 147: if (zpline == NULL) ! 148: return FALSE; ! 149: ! 150: if (strcmp (zline, zpline) == 0) ! 151: return TRUE; ! 152: ! 153: zfree1 = NULL; ! 154: zfree2 = NULL; ! 155: if (*zline != '/') ! 156: { ! 157: zfree1 = zbufalc (sizeof "/dev/" + strlen (zline)); ! 158: sprintf (zfree1, "/dev/%s", zline); ! 159: zline = zfree1; ! 160: } ! 161: if (*zpline != '/') ! 162: { ! 163: zfree2 = zbufalc (sizeof "/dev/" + strlen (zpline)); ! 164: sprintf (zfree2, "/dev/%s", zpline); ! 165: zpline = zfree2; ! 166: } ! 167: ! 168: fret = strcmp (zline, zpline) == 0; ! 169: ubuffree (zfree1); ! 170: ubuffree (zfree2); ! 171: return fret; ! 172: } ! 173: ! 174: /* The cu program wants the system dependent layer to handle the ! 175: details of copying data from the communications port to the ! 176: terminal. This copying need only be done while executing ! 177: fsysdep_cu. On Unix, however, we set up a subprocess to do it all ! 178: the time. This subprocess must be controllable via the ! 179: fsysdep_cu_copy function. ! 180: ! 181: We keep a pipe open to the subprocess. When we want it to stop we ! 182: send it a signal, and then wait for it to write a byte to us over ! 183: the pipe. */ ! 184: ! 185: /* The subprocess pid. */ ! 186: static volatile pid_t iSchild; ! 187: ! 188: /* The pipe from the subprocess. */ ! 189: static int oSpipe; ! 190: ! 191: /* When we tell the child to stop, it sends this. */ ! 192: #define CHILD_STOPPED ('S') ! 193: ! 194: /* When we tell the child to start, it sends this. */ ! 195: #define CHILD_STARTED ('G') ! 196: ! 197: /* Initialize the subprocess, and have it start copying data. */ ! 198: ! 199: boolean ! 200: fsysdep_cu_init (qconn) ! 201: struct sconnection *qconn; ! 202: { ! 203: int ai[2]; ! 204: ! 205: /* Write out anything we may have buffered up during the chat ! 206: script. We do this before forking the child only to make it easy ! 207: to move the child into a separate executable. */ ! 208: while (iPrecend != iPrecstart) ! 209: { ! 210: char *z; ! 211: int c; ! 212: ! 213: z = abPrecbuf + iPrecstart; ! 214: if (iPrecend > iPrecstart) ! 215: c = iPrecend - iPrecstart; ! 216: else ! 217: c = CRECBUFLEN - iPrecstart; ! 218: ! 219: iPrecstart = (iPrecstart + c) % CRECBUFLEN; ! 220: ! 221: while (c > 0) ! 222: { ! 223: int cwrote; ! 224: ! 225: cwrote = write (1, z, c); ! 226: if (cwrote <= 0) ! 227: { ! 228: if (cwrote < 0) ! 229: ulog (LOG_ERROR, "write: %s", strerror (errno)); ! 230: else ! 231: ulog (LOG_ERROR, "Line disconnected"); ! 232: return FALSE; ! 233: } ! 234: c -= cwrote; ! 235: z += cwrote; ! 236: } ! 237: } ! 238: ! 239: if (pipe (ai) < 0) ! 240: { ! 241: ulog (LOG_ERROR, "pipe: %s", strerror (errno)); ! 242: return FALSE; ! 243: } ! 244: ! 245: iSchild = ixsfork (); ! 246: if (iSchild < 0) ! 247: { ! 248: ulog (LOG_ERROR, "fork: %s", strerror (errno)); ! 249: return FALSE; ! 250: } ! 251: ! 252: if (iSchild == 0) ! 253: { ! 254: (void) close (ai[0]); ! 255: uscu_child (qconn, ai[1]); ! 256: /*NOTREACHED*/ ! 257: } ! 258: ! 259: (void) close (ai[1]); ! 260: ! 261: oSpipe = ai[0]; ! 262: ! 263: return TRUE; ! 264: } ! 265: ! 266: /* Copy all data from the terminal to the communications port. If we ! 267: see an escape character following a newline character, read the ! 268: next character and return it. */ ! 269: ! 270: boolean ! 271: fsysdep_cu (qconn, pbcmd, zlocalname) ! 272: struct sconnection *qconn; ! 273: char *pbcmd; ! 274: const char *zlocalname; ! 275: { ! 276: boolean fstart; ! 277: char b; ! 278: int c; ! 279: ! 280: fstart = TRUE; ! 281: ! 282: while (TRUE) ! 283: { ! 284: if (fsysdep_catch ()) ! 285: usysdep_start_catch (); ! 286: else ! 287: { ! 288: ulog (LOG_ERROR, (const char *) NULL); ! 289: return FALSE; ! 290: } ! 291: ! 292: c = read (0, &b, 1); ! 293: ! 294: usysdep_end_catch (); ! 295: ! 296: if (c <= 0) ! 297: break; ! 298: ! 299: if (fstart && b == *zCuvar_escape) ! 300: { ! 301: c = cscu_escape (pbcmd, zlocalname); ! 302: if (c <= 0) ! 303: break; ! 304: if (*pbcmd != b) ! 305: { ! 306: write (1, pbcmd, 1); ! 307: ! 308: /* For Unix, we let the eof character be the same as ! 309: '.', and we let the suspend character (if any) be the ! 310: same as 'z'. */ ! 311: if (*pbcmd == bSeof) ! 312: *pbcmd = '.'; ! 313: if (*pbcmd == bStstp) ! 314: *pbcmd = 'z'; ! 315: return TRUE; ! 316: } ! 317: } ! 318: if (! fconn_write (qconn, &b, (size_t) 1)) ! 319: return FALSE; ! 320: fstart = strchr (zCuvar_eol, b) != NULL; ! 321: } ! 322: ! 323: if (c < 0) ! 324: { ! 325: if (errno != EINTR) ! 326: ulog (LOG_ERROR, "read: %s", strerror (errno)); ! 327: else ! 328: ulog (LOG_ERROR, (const char *) NULL); ! 329: return FALSE; ! 330: } ! 331: ! 332: /* I'm not sure what's best in this case. */ ! 333: ulog (LOG_ERROR, "End of file on terminal"); ! 334: return FALSE; ! 335: } ! 336: ! 337: /* A SIGALRM handler that sets fScu_alarm and optionally longjmps. */ ! 338: ! 339: volatile sig_atomic_t fScu_alarm; ! 340: ! 341: static RETSIGTYPE ! 342: uscu_alarm (isig) ! 343: int isig; ! 344: { ! 345: #if ! HAVE_SIGACTION && ! HAVE_SIGVEC && ! HAVE_SIGSET ! 346: (void) signal (isig, uscu_alarm); ! 347: #endif ! 348: ! 349: fScu_alarm = TRUE; ! 350: ! 351: #if HAVE_RESTARTABLE_SYSCALLS ! 352: if (fSjmp) ! 353: longjmp (sSjmp_buf, 1); ! 354: #endif ! 355: } ! 356: ! 357: /* We've just seen an escape character. We print the host name, ! 358: optionally after a 1 second delay. We read the next character from ! 359: the terminal and return it. The 1 second delay on the host name is ! 360: mostly to be fancy; it lets ~~ look smoother. */ ! 361: ! 362: static int ! 363: cscu_escape (pbcmd, zlocalname) ! 364: char *pbcmd; ! 365: const char *zlocalname; ! 366: { ! 367: CATCH_PROTECT int c; ! 368: ! 369: write (1, zCuvar_escape, 1); ! 370: ! 371: fScu_alarm = FALSE; ! 372: usset_signal (SIGALRM, uscu_alarm, TRUE, (boolean *) NULL); ! 373: ! 374: if (fsysdep_catch ()) ! 375: { ! 376: usysdep_start_catch (); ! 377: alarm (1); ! 378: } ! 379: ! 380: c = 0; ! 381: ! 382: while (TRUE) ! 383: { ! 384: if (fScu_alarm) ! 385: { ! 386: char b; ! 387: ! 388: fScu_alarm = FALSE; ! 389: b = '['; ! 390: write (1, &b, 1); ! 391: write (1, zlocalname, strlen (zlocalname)); ! 392: b = ']'; ! 393: write (1, &b, 1); ! 394: } ! 395: ! 396: if (c <= 0) ! 397: c = read (0, pbcmd, 1); ! 398: if (c >= 0 || errno != EINTR) ! 399: { ! 400: usysdep_end_catch (); ! 401: usset_signal (SIGALRM, SIG_IGN, TRUE, (boolean *) NULL); ! 402: alarm (0); ! 403: return c; ! 404: } ! 405: } ! 406: } ! 407: ! 408: /* A SIGALRM handler which does nothing but send a signal to the child ! 409: process and schedule another alarm. POSIX.1 permits kill and alarm ! 410: from a signal handler. The reference to static data may or may not ! 411: be permissible. */ ! 412: ! 413: static volatile sig_atomic_t iSsend_sig; ! 414: ! 415: static RETSIGTYPE ! 416: uscu_alarm_kill (isig) ! 417: int isig; ! 418: { ! 419: #if ! HAVE_SIGACTION && ! HAVE_SIGVEC && ! HAVE_SIGSET ! 420: (void) signal (isig, uscu_alarm_kill); ! 421: #endif ! 422: ! 423: (void) kill (iSchild, iSsend_sig); ! 424: ! 425: alarm (1); ! 426: } ! 427: ! 428: /* Start or stop copying data from the communications port to the ! 429: terminal. We send a signal to the child process to tell it what to ! 430: do. Unfortunately, there are race conditions in the child, so we ! 431: keep sending it a signal once a second until it responds. We send ! 432: SIGUSR1 to make it start copying, and SIGUSR2 to make it stop. */ ! 433: ! 434: boolean ! 435: fsysdep_cu_copy (fcopy) ! 436: boolean fcopy; ! 437: { ! 438: int ierr; ! 439: int c; ! 440: ! 441: usset_signal (SIGALRM, uscu_alarm_kill, TRUE, (boolean *) NULL); ! 442: if (fcopy) ! 443: iSsend_sig = SIGUSR1; ! 444: else ! 445: iSsend_sig = SIGUSR2; ! 446: ! 447: uscu_alarm_kill (SIGALRM); ! 448: ! 449: alarm (1); ! 450: ! 451: while (TRUE) ! 452: { ! 453: char b; ! 454: ! 455: c = read (oSpipe, &b, 1); ! 456: ! 457: #if DEBUG > 1 ! 458: if (c > 0) ! 459: DEBUG_MESSAGE1 (DEBUG_INCOMING, ! 460: "fsysdep_cu_copy: Got '%d'", b); ! 461: #endif ! 462: ! 463: if ((c < 0 && errno != EINTR) ! 464: || c == 0 ! 465: || (c > 0 && b == (fcopy ? CHILD_STARTED : CHILD_STOPPED))) ! 466: break; ! 467: ! 468: /* If none of the above conditions were true, then we either got ! 469: an EINTR error, in which case we probably timed out and the ! 470: SIGALRM handler resent the signal, or we read the wrong ! 471: character, in which case we will just read again from the ! 472: pipe. */ ! 473: } ! 474: ! 475: ierr = errno; ! 476: ! 477: usset_signal (SIGALRM, SIG_IGN, TRUE, (boolean *) NULL); ! 478: alarm (0); ! 479: ! 480: if (c > 0) ! 481: return TRUE; ! 482: ! 483: if (c == 0) ! 484: ulog (LOG_ERROR, "EOF on child pipe"); ! 485: else ! 486: ulog (LOG_ERROR, "read: %s", strerror (ierr)); ! 487: ! 488: return FALSE; ! 489: } ! 490: ! 491: /* Shut down cu by killing the child process. */ ! 492: ! 493: boolean ! 494: fsysdep_cu_finish () ! 495: { ! 496: (void) close (oSpipe); ! 497: ! 498: /* We hit the child with SIGTERM, give it two seconds to die, and ! 499: then send a SIGKILL. */ ! 500: if (kill (iSchild, SIGTERM) < 0) ! 501: { ! 502: /* Don't give an error if the child has already died. */ ! 503: if (errno != ESRCH) ! 504: ulog (LOG_ERROR, "kill: %s", strerror (errno)); ! 505: } ! 506: ! 507: usset_signal (SIGALRM, uscu_alarm_kill, TRUE, (boolean *) NULL); ! 508: iSsend_sig = SIGKILL; ! 509: alarm (2); ! 510: ! 511: (void) ixswait ((unsigned long) iSchild, "child"); ! 512: ! 513: usset_signal (SIGALRM, SIG_IGN, TRUE, (boolean *) NULL); ! 514: alarm (0); ! 515: ! 516: return TRUE; ! 517: } ! 518: ! 519: /* Code for the child process. */ ! 520: ! 521: /* This signal handler just records the signal. In this case we only ! 522: care about which signal we received most recently. */ ! 523: ! 524: static volatile sig_atomic_t iSchild_sig; ! 525: ! 526: static RETSIGTYPE ! 527: uscu_child_handler (isig) ! 528: int isig; ! 529: { ! 530: #if ! HAVE_SIGACTION && ! HAVE_SIGVEC && ! HAVE_SIGSET ! 531: (void) signal (isig, uscu_child_handler); ! 532: #endif ! 533: ! 534: iSchild_sig = isig; ! 535: ! 536: #if HAVE_RESTARTABLE_SYSCALLS ! 537: if (fSjmp) ! 538: longjmp (sSjmp_buf, 1); ! 539: #endif /* HAVE_RESTARTABLE_SYSCALLS */ ! 540: } ! 541: ! 542: /* The child process. This copies the port to the terminal, except ! 543: when it is stopped by a signal. It would be reasonable to write a ! 544: separate program for this, probably passing it the port on stdin. ! 545: This would reduce the memory requirements, since we wouldn't need a ! 546: second process holding all the configuration stuff, and also let it ! 547: work reasonably on 680x0 versions of MINIX. */ ! 548: ! 549: static void ! 550: uscu_child (qconn, opipe) ! 551: struct sconnection *qconn; ! 552: int opipe; ! 553: { ! 554: CATCH_PROTECT int oport; ! 555: CATCH_PROTECT boolean fstopped, fgot; ! 556: CATCH_PROTECT int cwrite; ! 557: CATCH_PROTECT char abbuf[1024]; ! 558: ! 559: /* It would be nice if we could just use fsserial_read, but that ! 560: will log signals that we don't want logged. There should be a ! 561: generic way to extract the file descriptor from the port. */ ! 562: if (qconn->qport == NULL) ! 563: oport = 0; ! 564: else ! 565: { ! 566: switch (qconn->qport->uuconf_ttype) ! 567: { ! 568: #if DEBUG > 0 ! 569: default: ! 570: ulog (LOG_FATAL, "uscu_child: Can't happen"); ! 571: oport = -1; ! 572: break; ! 573: #endif ! 574: case UUCONF_PORTTYPE_STDIN: ! 575: oport = 0; ! 576: break; ! 577: case UUCONF_PORTTYPE_MODEM: ! 578: case UUCONF_PORTTYPE_DIRECT: ! 579: case UUCONF_PORTTYPE_TCP: ! 580: case UUCONF_PORTTYPE_TLI: ! 581: oport = ((struct ssysdep_conn *) qconn->psysdep)->o; ! 582: break; ! 583: } ! 584: } ! 585: ! 586: usset_signal (SIGUSR1, uscu_child_handler, TRUE, (boolean *) NULL); ! 587: usset_signal (SIGUSR2, uscu_child_handler, TRUE, (boolean *) NULL); ! 588: usset_signal (SIGINT, SIG_IGN, TRUE, (boolean *) NULL); ! 589: usset_signal (SIGQUIT, SIG_IGN, TRUE, (boolean *) NULL); ! 590: usset_signal (SIGPIPE, SIG_DFL, TRUE, (boolean *) NULL); ! 591: usset_signal (SIGTERM, uscu_child_handler, TRUE, (boolean *) NULL); ! 592: ! 593: fstopped = FALSE; ! 594: fgot = FALSE; ! 595: iSchild_sig = 0; ! 596: cwrite = 0; ! 597: ! 598: if (fsysdep_catch ()) ! 599: usysdep_start_catch (); ! 600: ! 601: while (TRUE) ! 602: { ! 603: int isig; ! 604: int c; ! 605: ! 606: /* There is a race condition here between checking the signal ! 607: and receiving a new and possibly different one. This is ! 608: solved by having the parent resend the signal until it gets a ! 609: response. */ ! 610: isig = iSchild_sig; ! 611: iSchild_sig = 0; ! 612: if (isig != 0) ! 613: { ! 614: char b; ! 615: ! 616: if (isig == SIGTERM) ! 617: exit (EXIT_SUCCESS); ! 618: ! 619: if (isig == SIGUSR1) ! 620: { ! 621: fstopped = FALSE; ! 622: b = CHILD_STARTED; ! 623: } ! 624: else ! 625: { ! 626: fstopped = TRUE; ! 627: b = CHILD_STOPPED; ! 628: cwrite = 0; ! 629: } ! 630: ! 631: c = write (opipe, &b, 1); ! 632: ! 633: /* Apparently on some systems we can get EAGAIN here. */ ! 634: if (c < 0 && ! 635: (errno == EAGAIN || errno == EWOULDBLOCK || errno == ENODATA)) ! 636: c = 0; ! 637: ! 638: if (c <= 0) ! 639: { ! 640: /* Should we give an error message here? */ ! 641: (void) kill (getppid (), SIGHUP); ! 642: exit (EXIT_FAILURE); ! 643: } ! 644: } ! 645: ! 646: if (fstopped) ! 647: pause (); ! 648: else if (cwrite > 0) ! 649: { ! 650: char *zbuf; ! 651: ! 652: zbuf = abbuf; ! 653: while (cwrite > 0) ! 654: { ! 655: c = write (1, zbuf, cwrite); ! 656: ! 657: /* Apparently on some systems we can get EAGAIN here. */ ! 658: if (c < 0 && ! 659: (errno == EAGAIN ! 660: || errno == EWOULDBLOCK ! 661: || errno == ENODATA)) ! 662: c = 0; ! 663: ! 664: if (c < 0 && errno == EINTR) ! 665: break; ! 666: if (c <= 0) ! 667: { ! 668: /* Should we give an error message here? */ ! 669: (void) kill (getppid (), SIGHUP); ! 670: exit (EXIT_FAILURE); ! 671: } ! 672: cwrite -= c; ! 673: zbuf += c; ! 674: } ! 675: } ! 676: else ! 677: { ! 678: /* On some systems apparently read will return 0 until ! 679: something has been written to the port. We therefore ! 680: accept a 0 return until after we have managed to read ! 681: something. Setting errno to 0 apparently avoids a ! 682: problem on Coherent. */ ! 683: errno = 0; ! 684: c = read (oport, abbuf, sizeof abbuf); ! 685: ! 686: /* Apparently on some systems we can get EAGAIN here. */ ! 687: if (c < 0 && ! 688: (errno == EAGAIN || errno == EWOULDBLOCK || errno == ENODATA)) ! 689: c = 0; ! 690: ! 691: if ((c == 0 && fgot) ! 692: || (c < 0 && errno != EINTR)) ! 693: { ! 694: /* This can be a normal way to exit, depending on just ! 695: how the connection is dropped. */ ! 696: (void) kill (getppid (), SIGHUP); ! 697: exit (EXIT_SUCCESS); ! 698: } ! 699: if (c > 0) ! 700: { ! 701: fgot = TRUE; ! 702: cwrite = c; ! 703: } ! 704: } ! 705: } ! 706: } ! 707: ! 708: /* Terminal control routines. */ ! 709: ! 710: /* Whether file descriptor 0 is attached to a terminal or not. */ ! 711: static boolean fSterm; ! 712: ! 713: /* Whether we are doing local echoing. */ ! 714: static boolean fSlocalecho; ! 715: ! 716: /* The original state of the terminal. */ ! 717: static sterminal sSterm_orig; ! 718: ! 719: /* The new state of the terminal. */ ! 720: static sterminal sSterm_new; ! 721: ! 722: #if ! HAVE_BSD_TTY ! 723: #ifdef SIGTSTP ! 724: /* Whether SIGTSTP is being ignored. */ ! 725: static boolean fStstp_ignored; ! 726: #endif ! 727: #endif ! 728: ! 729: /* Set the terminal into raw mode. */ ! 730: ! 731: boolean ! 732: fsysdep_terminal_raw (flocalecho) ! 733: boolean flocalecho; ! 734: { ! 735: fSlocalecho = flocalecho; ! 736: ! 737: /* This defaults may be overriden below. */ ! 738: bSeof = '\004'; ! 739: bStstp = '\032'; ! 740: ! 741: if (! fgetterminfo (0, &sSterm_orig)) ! 742: { ! 743: fSterm = FALSE; ! 744: return TRUE; ! 745: } ! 746: ! 747: fSterm = TRUE; ! 748: ! 749: sSterm_new = sSterm_orig; ! 750: ! 751: #if HAVE_BSD_TTY ! 752: ! 753: /* We use CBREAK mode rather than RAW mode, because RAW mode turns ! 754: off all output processing, which we don't want to do. This means ! 755: that we have to disable the interrupt characters, which we do by ! 756: setting them to -1. */ ! 757: bSeof = sSterm_orig.stchars.t_eofc; ! 758: ! 759: sSterm_new.stchars.t_intrc = -1; ! 760: sSterm_new.stchars.t_quitc = -1; ! 761: sSterm_new.stchars.t_startc = -1; ! 762: sSterm_new.stchars.t_stopc = -1; ! 763: sSterm_new.stchars.t_eofc = -1; ! 764: sSterm_new.stchars.t_brkc = -1; ! 765: ! 766: bStstp = sSterm_orig.sltchars.t_suspc; ! 767: ! 768: sSterm_new.sltchars.t_suspc = -1; ! 769: sSterm_new.sltchars.t_dsuspc = -1; ! 770: sSterm_new.sltchars.t_rprntc = -1; ! 771: sSterm_new.sltchars.t_flushc = -1; ! 772: sSterm_new.sltchars.t_werasc = -1; ! 773: sSterm_new.sltchars.t_lnextc = -1; ! 774: ! 775: if (! flocalecho) ! 776: { ! 777: sSterm_new.stty.sg_flags |= (CBREAK | ANYP); ! 778: sSterm_new.stty.sg_flags &=~ (ECHO | CRMOD | TANDEM); ! 779: } ! 780: else ! 781: { ! 782: sSterm_new.stty.sg_flags |= (CBREAK | ANYP | ECHO); ! 783: sSterm_new.stty.sg_flags &=~ (CRMOD | TANDEM); ! 784: } ! 785: ! 786: #endif /* HAVE_BSD_TTY */ ! 787: ! 788: #if HAVE_SYSV_TERMIO ! 789: ! 790: bSeof = sSterm_new.c_cc[VEOF]; ! 791: if (! flocalecho) ! 792: sSterm_new.c_lflag &=~ (ICANON | ISIG | ECHO | ECHOE | ECHOK | ECHONL); ! 793: else ! 794: sSterm_new.c_lflag &=~ (ICANON | ISIG); ! 795: sSterm_new.c_iflag &=~ (INLCR | IGNCR | ICRNL); ! 796: sSterm_new.c_oflag &=~ (OPOST); ! 797: sSterm_new.c_cc[VMIN] = 1; ! 798: sSterm_new.c_cc[VTIME] = 0; ! 799: ! 800: #endif /* HAVE_SYSV_TERMIO */ ! 801: ! 802: #if HAVE_POSIX_TERMIOS ! 803: ! 804: bSeof = sSterm_new.c_cc[VEOF]; ! 805: bStstp = sSterm_new.c_cc[VSUSP]; ! 806: if (! flocalecho) ! 807: sSterm_new.c_lflag &=~ ! 808: (ICANON | IEXTEN | ISIG | ECHO | ECHOE | ECHOK | ECHONL); ! 809: else ! 810: sSterm_new.c_lflag &=~ (ICANON | IEXTEN | ISIG); ! 811: sSterm_new.c_iflag &=~ (INLCR | IGNCR | ICRNL); ! 812: sSterm_new.c_oflag &=~ (OPOST); ! 813: sSterm_new.c_cc[VMIN] = 1; ! 814: sSterm_new.c_cc[VTIME] = 0; ! 815: ! 816: #endif /* HAVE_POSIX_TERMIOS */ ! 817: ! 818: if (! fsetterminfo (0, &sSterm_new)) ! 819: { ! 820: ulog (LOG_ERROR, "Can't set terminal settings: %s", strerror (errno)); ! 821: return FALSE; ! 822: } ! 823: ! 824: return TRUE; ! 825: } ! 826: ! 827: /* Restore the terminal to its original setting. */ ! 828: ! 829: boolean ! 830: fsysdep_terminal_restore () ! 831: { ! 832: if (! fSterm) ! 833: return TRUE; ! 834: ! 835: if (! fsetterminfo (0, &sSterm_orig)) ! 836: { ! 837: ulog (LOG_ERROR, "Can't restore terminal: %s", strerror (errno)); ! 838: return FALSE; ! 839: } ! 840: return TRUE; ! 841: } ! 842: ! 843: /* Read a line from the terminal. This will be called after ! 844: fsysdep_terminal_raw has been called. */ ! 845: ! 846: char * ! 847: zsysdep_terminal_line (zprompt) ! 848: const char *zprompt; ! 849: { ! 850: CATCH_PROTECT size_t cbuf = 0; ! 851: CATCH_PROTECT char *zbuf = NULL; ! 852: CATCH_PROTECT size_t cgot = 0; ! 853: ! 854: if (zprompt != NULL && *zprompt != '\0') ! 855: (void) write (1, zprompt, strlen (zprompt)); ! 856: ! 857: /* Forgot about any previous SIGINT or SIGQUIT signals we may have ! 858: received. We don't worry about the race condition here, since we ! 859: can't get these signals from the terminal at the moment and it's ! 860: not too likely that somebody else will be sending them to us. */ ! 861: afSignal[INDEXSIG_SIGINT] = 0; ! 862: afSignal[INDEXSIG_SIGQUIT] = 0; ! 863: ! 864: if (! fsysdep_terminal_restore ()) ! 865: return NULL; ! 866: ! 867: if (fsysdep_catch ()) ! 868: { ! 869: usysdep_start_catch (); ! 870: cbuf = 0; ! 871: zbuf = NULL; ! 872: cgot = 0; ! 873: } ! 874: ! 875: while (TRUE) ! 876: { ! 877: char b; ! 878: int c; ! 879: ! 880: if (afSignal[INDEXSIG_SIGINT] ! 881: || afSignal[INDEXSIG_SIGQUIT]) ! 882: { ! 883: usysdep_end_catch (); ! 884: /* Make sure the signal is logged. */ ! 885: ulog (LOG_ERROR, (const char *) NULL); ! 886: /* Return an empty string. */ ! 887: cgot = 0; ! 888: break; ! 889: } ! 890: ! 891: /* There's a race here between checking the signals and calling ! 892: read. It just means that the user will have to hit ^C more ! 893: than once. */ ! 894: ! 895: c = read (0, &b, 1); ! 896: if (c < 0) ! 897: { ! 898: if (errno == EINTR) ! 899: continue; ! 900: usysdep_end_catch (); ! 901: ulog (LOG_ERROR, "read: %s", strerror (errno)); ! 902: (void) fsysdep_terminal_raw (fSlocalecho); ! 903: return NULL; ! 904: } ! 905: if (c == 0) ! 906: { ! 907: /* I'm not quite sure what to do here. */ ! 908: usysdep_end_catch (); ! 909: ulog (LOG_ERROR, "EOF on terminal"); ! 910: (void) fsysdep_terminal_raw (fSlocalecho); ! 911: return NULL; ! 912: } ! 913: ! 914: if (cgot >= cbuf) ! 915: { ! 916: char *znew; ! 917: ! 918: cbuf += 64; ! 919: znew = zbufalc (cbuf); ! 920: if (zbuf != NULL) ! 921: { ! 922: memcpy (znew, zbuf, cgot); ! 923: ubuffree (zbuf); ! 924: } ! 925: zbuf = znew; ! 926: } ! 927: ! 928: zbuf[cgot] = b; ! 929: ! 930: ++cgot; ! 931: ! 932: if (b == '\n') ! 933: { ! 934: usysdep_end_catch (); ! 935: break; ! 936: } ! 937: } ! 938: ! 939: if (cgot >= cbuf) ! 940: { ! 941: char *znew; ! 942: ! 943: ++cbuf; ! 944: znew = zbufalc (cbuf); ! 945: if (zbuf != NULL) ! 946: { ! 947: memcpy (znew, zbuf, cgot); ! 948: ubuffree (zbuf); ! 949: } ! 950: zbuf = znew; ! 951: } ! 952: ! 953: zbuf[cgot] = '\0'; ! 954: ! 955: if (! fsysdep_terminal_raw (fSlocalecho)) ! 956: return NULL; ! 957: ! 958: return zbuf; ! 959: } ! 960: ! 961: /* Write a line to the terminal with a trailing newline. */ ! 962: ! 963: boolean ! 964: fsysdep_terminal_puts (zline) ! 965: const char *zline; ! 966: { ! 967: char *zalc, *zprint; ! 968: size_t clen; ! 969: ! 970: if (zline == NULL) ! 971: { ! 972: zalc = zbufalc (2); ! 973: clen = 0; ! 974: } ! 975: else ! 976: { ! 977: clen = strlen (zline); ! 978: zalc = zbufalc (clen + 2); ! 979: memcpy (zalc, zline, clen); ! 980: } ! 981: ! 982: if (fSterm) ! 983: { ! 984: zalc[clen] = '\r'; ! 985: ++clen; ! 986: } ! 987: zalc[clen] = '\n'; ! 988: ++clen; ! 989: ! 990: zprint = zalc; ! 991: while (clen > 0) ! 992: { ! 993: int c; ! 994: ! 995: c = write (1, zprint, clen); ! 996: if (c <= 0) ! 997: { ! 998: ubuffree (zalc); ! 999: ulog (LOG_ERROR, "write: %s", strerror (errno)); ! 1000: return FALSE; ! 1001: } ! 1002: clen -= c; ! 1003: zprint += c; ! 1004: } ! 1005: ! 1006: ubuffree (zalc); ! 1007: ! 1008: return TRUE; ! 1009: } ! 1010: ! 1011: /* Allow or disallow signals from the terminal. */ ! 1012: ! 1013: boolean ! 1014: fsysdep_terminal_signals (faccept) ! 1015: boolean faccept; ! 1016: { ! 1017: #if HAVE_BSD_TTY ! 1018: ! 1019: if (faccept) ! 1020: { ! 1021: sSterm_new.stchars.t_intrc = sSterm_orig.stchars.t_intrc; ! 1022: sSterm_new.stchars.t_quitc = sSterm_orig.stchars.t_quitc; ! 1023: } ! 1024: else ! 1025: { ! 1026: sSterm_new.stchars.t_intrc = -1; ! 1027: sSterm_new.stchars.t_quitc = -1; ! 1028: } ! 1029: ! 1030: #else /* ! HAVE_BSD_TTY */ ! 1031: ! 1032: if (faccept) ! 1033: sSterm_new.c_lflag |= ISIG; ! 1034: else ! 1035: sSterm_new.c_lflag &=~ ISIG; ! 1036: ! 1037: #ifdef SIGTSTP ! 1038: /* We only want to get SIGINT and SIGQUIT, not SIGTSTP. This ! 1039: function will be called with faccept TRUE before it is called ! 1040: with faccept FALSE, so fStstp_ignored will be correctly ! 1041: initialized. */ ! 1042: if (faccept) ! 1043: usset_signal (SIGTSTP, SIG_IGN, FALSE, &fStstp_ignored); ! 1044: else if (! fStstp_ignored) ! 1045: usset_signal (SIGTSTP, SIG_DFL, TRUE, (boolean *) NULL); ! 1046: #endif ! 1047: ! 1048: #endif /* ! HAVE_BSD_TTY */ ! 1049: ! 1050: if (! fsetterminfo (0, &sSterm_new)) ! 1051: { ! 1052: ulog (LOG_ERROR, "Can't set terminal: %s", strerror (errno)); ! 1053: return FALSE; ! 1054: } ! 1055: ! 1056: return TRUE; ! 1057: } ! 1058: ! 1059: /* Start up a command, or possibly just a shell. Optionally attach ! 1060: stdin or stdout to the port. We attach directly to the port, ! 1061: rather than copying the data ourselves. */ ! 1062: ! 1063: boolean ! 1064: fsysdep_shell (qconn, zcmd, tcmd) ! 1065: struct sconnection *qconn; ! 1066: const char *zcmd; ! 1067: enum tshell_cmd tcmd; ! 1068: { ! 1069: const char *azargs[4]; ! 1070: int oread, owrite; ! 1071: int aidescs[3]; ! 1072: pid_t ipid; ! 1073: ! 1074: azargs[0] = "/bin/sh"; ! 1075: if (zcmd == NULL || *zcmd == '\0') ! 1076: azargs[1] = NULL; ! 1077: else ! 1078: { ! 1079: azargs[1] = "-c"; ! 1080: azargs[2] = zcmd; ! 1081: azargs[3] = NULL; ! 1082: } ! 1083: ! 1084: if (qconn->qport == NULL) ! 1085: { ! 1086: oread = 0; ! 1087: owrite = 1; ! 1088: } ! 1089: else ! 1090: { ! 1091: switch (qconn->qport->uuconf_ttype) ! 1092: { ! 1093: default: ! 1094: oread = owrite = -1; ! 1095: break; ! 1096: case UUCONF_PORTTYPE_STDIN: ! 1097: oread = 0; ! 1098: owrite = 1; ! 1099: break; ! 1100: case UUCONF_PORTTYPE_MODEM: ! 1101: case UUCONF_PORTTYPE_DIRECT: ! 1102: case UUCONF_PORTTYPE_TCP: ! 1103: case UUCONF_PORTTYPE_TLI: ! 1104: oread = owrite = ((struct ssysdep_conn *) qconn->psysdep)->o; ! 1105: break; ! 1106: } ! 1107: } ! 1108: ! 1109: aidescs[0] = 0; ! 1110: aidescs[1] = 1; ! 1111: aidescs[2] = 2; ! 1112: ! 1113: if (tcmd == SHELL_STDIN_FROM_PORT || tcmd == SHELL_STDIO_ON_PORT) ! 1114: aidescs[0] = oread; ! 1115: if (tcmd == SHELL_STDOUT_TO_PORT || tcmd == SHELL_STDIO_ON_PORT) ! 1116: aidescs[1] = owrite; ! 1117: ! 1118: ipid = ixsspawn (azargs, aidescs, FALSE, TRUE, (const char *) NULL, ! 1119: FALSE, FALSE, (const char *) NULL, ! 1120: (const char *) NULL, (const char *) NULL); ! 1121: if (ipid < 0) ! 1122: { ! 1123: ulog (LOG_ERROR, "ixsspawn (/bin/sh): %s", strerror (errno)); ! 1124: return FALSE; ! 1125: } ! 1126: ! 1127: return ixswait ((unsigned long) ipid, "shell") == 0; ! 1128: } ! 1129: ! 1130: /* Change directories. */ ! 1131: ! 1132: boolean ! 1133: fsysdep_chdir (zdir) ! 1134: const char *zdir; ! 1135: { ! 1136: if (zdir == NULL || *zdir == '\0') ! 1137: { ! 1138: zdir = getenv ("HOME"); ! 1139: if (zdir == NULL) ! 1140: { ! 1141: ulog (LOG_ERROR, "HOME not defined"); ! 1142: return FALSE; ! 1143: } ! 1144: } ! 1145: if (chdir (zdir) < 0) ! 1146: { ! 1147: ulog (LOG_ERROR, "chdir (%s): %s", zdir, strerror (errno)); ! 1148: return FALSE; ! 1149: } ! 1150: return TRUE; ! 1151: } ! 1152: ! 1153: /* Suspend the current process. */ ! 1154: ! 1155: boolean ! 1156: fsysdep_suspend () ! 1157: { ! 1158: #ifndef SIGTSTP ! 1159: return fsysdep_terminal_puts ("[process suspension not supported]"); ! 1160: #else ! 1161: return kill (getpid (), SIGTSTP) == 0; ! 1162: #endif ! 1163: }
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.