![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to serial.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 serial.c CVS log | Up to [MW Coherent from dump] / coherent / g / usr / lib / uucp / tay104 / unix |
1.1 ! root 1: /* serial.c ! 2: The serial port communication routines for Unix. ! 3: ! 4: Copyright (C) 1991, 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 serial_rcsid[] = "$Id: serial.c,v 1.1 93/07/30 08:02:47 bin Exp Locker: bin $"; ! 30: #endif ! 31: ! 32: #include "uudefs.h" ! 33: #include "uuconf.h" ! 34: #include "system.h" ! 35: #include "conn.h" ! 36: #include "sysdep.h" ! 37: ! 38: #include <errno.h> ! 39: #include <ctype.h> ! 40: ! 41: #if HAVE_SYS_PARAM_H ! 42: #include <sys/param.h> ! 43: #endif ! 44: ! 45: #if HAVE_LIMITS_H ! 46: #include <limits.h> ! 47: #endif ! 48: ! 49: #if HAVE_TLI ! 50: #if HAVE_TIUSER_H ! 51: #include <tiuser.h> ! 52: #else /* ! HAVE_TIUSER_H */ ! 53: #if HAVE_XTI_H ! 54: #include <xti.h> ! 55: #endif /* HAVE_XTI_H */ ! 56: #endif /* ! HAVE_TIUSER_H */ ! 57: #endif /* HAVE_TLI */ ! 58: ! 59: #if HAVE_FCNTL_H ! 60: #include <fcntl.h> ! 61: #else ! 62: #if HAVE_SYS_FILE_H ! 63: #include <sys/file.h> ! 64: #endif ! 65: #endif ! 66: ! 67: #ifndef O_RDONLY ! 68: #define O_RDONLY 0 ! 69: #define O_WRONLY 1 ! 70: #define O_RDWR 2 ! 71: #endif ! 72: ! 73: #ifndef O_NOCTTY ! 74: #define O_NOCTTY 0 ! 75: #endif ! 76: ! 77: #ifndef FD_CLOEXEC ! 78: #define FD_CLOEXEC 1 ! 79: #endif ! 80: ! 81: #if HAVE_SYS_IOCTL_H ! 82: #include <sys/ioctl.h> ! 83: #endif ! 84: ! 85: #if HAVE_BSD_TTY ! 86: #include <sys/time.h> ! 87: #if HAVE_SYS_SELECT_H ! 88: #include <sys/select.h> ! 89: #endif ! 90: #endif ! 91: ! 92: #if HAVE_TIME_H ! 93: #if HAVE_SYS_TIME_AND_TIME_H || ! HAVE_BSD_TTY ! 94: #include <time.h> ! 95: #endif ! 96: #endif ! 97: ! 98: #if HAVE_STRIP_BUG && HAVE_BSD_TTY ! 99: #include <termio.h> ! 100: #endif ! 101: ! 102: #if HAVE_SVR4_LOCKFILES ! 103: /* Get the right definitions for major and minor. */ ! 104: #if MAJOR_IN_MKDEV ! 105: #include <sys/mkdev.h> ! 106: #endif /* MAJOR_IN_MKDEV */ ! 107: #if MAJOR_IN_SYSMACROS ! 108: #include <sys/sysmacros.h> ! 109: #endif /* MAJOR_IN_SYSMACROS */ ! 110: #if ! MAJOR_IN_MKDEV && ! MAJOR_IN_SYSMACROS ! 111: #ifndef major ! 112: #define major(i) (((i) >> 8) & 0xff) ! 113: #endif ! 114: #ifndef minor ! 115: #define minor(i) ((i) & 0xff) ! 116: #endif ! 117: #endif /* ! MAJOR_IN_MKDEV && ! MAJOR_IN_SYSMACROS */ ! 118: #endif /* HAVE_SVR4_LOCKFILES */ ! 119: ! 120: /* Get definitions for both O_NONBLOCK and O_NDELAY. */ ! 121: #ifndef O_NDELAY ! 122: #ifdef FNDELAY ! 123: #define O_NDELAY FNDELAY ! 124: #else /* ! defined (FNDELAY) */ ! 125: #define O_NDELAY 0 ! 126: #endif /* ! defined (FNDELAY) */ ! 127: #endif /* ! defined (O_NDELAY) */ ! 128: ! 129: #ifndef O_NONBLOCK ! 130: #ifdef FNBLOCK ! 131: #define O_NONBLOCK FNBLOCK ! 132: #else /* ! defined (FNBLOCK) */ ! 133: #define O_NONBLOCK 0 ! 134: #endif /* ! defined (FNBLOCK) */ ! 135: #endif /* ! defined (O_NONBLOCK) */ ! 136: ! 137: #if O_NDELAY == 0 && O_NONBLOCK == 0 ! 138: #error No way to do nonblocking I/O ! 139: #endif ! 140: ! 141: /* Get definitions for EAGAIN, EWOULDBLOCK and ENODATA. */ ! 142: #ifndef EAGAIN ! 143: #ifndef EWOULDBLOCK ! 144: #define EAGAIN (-1) ! 145: #define EWOULDBLOCK (-1) ! 146: #else /* defined (EWOULDBLOCK) */ ! 147: #define EAGAIN EWOULDBLOCK ! 148: #endif /* defined (EWOULDBLOCK) */ ! 149: #else /* defined (EAGAIN) */ ! 150: #ifndef EWOULDBLOCK ! 151: #define EWOULDBLOCK EAGAIN ! 152: #endif /* ! defined (EWOULDBLOCK) */ ! 153: #endif /* defined (EAGAIN) */ ! 154: ! 155: #ifndef ENODATA ! 156: #define ENODATA EAGAIN ! 157: #endif ! 158: ! 159: /* Make sure we have a definition for MAX_INPUT. */ ! 160: #ifndef MAX_INPUT ! 161: #define MAX_INPUT (256) ! 162: #endif ! 163: ! 164: /* If we have the TIOCSINUSE ioctl call, we use it to lock a terminal. ! 165: Otherwise, if we have the TIOCEXCL ioctl call, we have to open the ! 166: terminal before we know that it is unlocked. */ ! 167: #ifdef TIOCSINUSE ! 168: #define HAVE_TIOCSINUSE 1 ! 169: #else ! 170: #ifdef TIOCEXCL ! 171: #define HAVE_TIOCEXCL 1 ! 172: #endif ! 173: #endif ! 174: ! 175: #if HAVE_TLI ! 176: extern int t_errno; ! 177: extern char *t_errlist[]; ! 178: extern int t_nerr; ! 179: #endif ! 180: ! 181: /* Determine bits to clear for the various terminal control fields for ! 182: HAVE_SYSV_TERMIO and HAVE_POSIX_TERMIOS. */ ! 183: #if HAVE_SYSV_TERMIO ! 184: #define ICLEAR_IFLAG (IGNBRK | BRKINT | IGNPAR | PARMRK | INPCK \ ! 185: | ISTRIP | INLCR | IGNCR | ICRNL | IUCLC \ ! 186: | IXON | IXANY | IXOFF) ! 187: #define ICLEAR_OFLAG (OPOST | OLCUC | ONLCR | OCRNL | ONOCR | ONLRET \ ! 188: | OFILL | OFDEL | NLDLY | CRDLY | TABDLY | BSDLY \ ! 189: | VTDLY | FFDLY) ! 190: #define ICLEAR_CFLAG (CBAUD | CLOCAL | CSIZE | PARENB | PARODD) ! 191: #define ISET_CFLAG (CS8 | CREAD | HUPCL) ! 192: #define ICLEAR_LFLAG (ISIG | ICANON | XCASE | ECHO | ECHOE | ECHOK \ ! 193: | ECHONL | NOFLSH) ! 194: #endif ! 195: #if HAVE_POSIX_TERMIOS ! 196: #define ICLEAR_IFLAG (BRKINT | ICRNL | IGNBRK | IGNCR | IGNPAR \ ! 197: | INLCR | INPCK | ISTRIP | IXOFF | IXON \ ! 198: | PARMRK) ! 199: #define ICLEAR_OFLAG (OPOST) ! 200: #define ICLEAR_CFLAG (CLOCAL | CSIZE | PARENB | PARODD) ! 201: #define ISET_CFLAG (CS8 | CREAD | HUPCL) ! 202: #define ICLEAR_LFLAG (ECHO | ECHOE | ECHOK | ECHONL | ICANON | IEXTEN \ ! 203: | ISIG | NOFLSH | TOSTOP) ! 204: #endif ! 205: ! 206: /* Local functions. */ ! 207: ! 208: static RETSIGTYPE usalarm P((int isig)); ! 209: static boolean fsserial_init P((struct sconnection *qconn, ! 210: const struct sconncmds *qcmds, ! 211: const char *zdevice)); ! 212: static void usserial_free P((struct sconnection *qconn)); ! 213: static boolean fsserial_lockfile P((boolean flok, ! 214: const struct sconnection *)); ! 215: static boolean fsserial_lock P((struct sconnection *qconn, ! 216: boolean fin)); ! 217: static boolean fsserial_unlock P((struct sconnection *qconn)); ! 218: static boolean fsserial_open P((struct sconnection *qconn, long ibaud, ! 219: boolean fwait)); ! 220: static boolean fsstdin_open P((struct sconnection *qconn, long ibaud, ! 221: boolean fwait)); ! 222: static boolean fsmodem_open P((struct sconnection *qconn, long ibaud, ! 223: boolean fwait)); ! 224: static boolean fsdirect_open P((struct sconnection *qconn, long ibaud, ! 225: boolean fwait)); ! 226: static boolean fsblock P((struct ssysdep_conn *q, boolean fblock)); ! 227: static boolean fsserial_close P((struct ssysdep_conn *q)); ! 228: static boolean fsstdin_close P((struct sconnection *qconn, ! 229: pointer puuconf, ! 230: struct uuconf_dialer *qdialer, ! 231: boolean fsuccess)); ! 232: static boolean fsmodem_close P((struct sconnection *qconn, ! 233: pointer puuconf, ! 234: struct uuconf_dialer *qdialer, ! 235: boolean fsuccess)); ! 236: static boolean fsdirect_close P((struct sconnection *qconn, ! 237: pointer puuconf, ! 238: struct uuconf_dialer *qdialer, ! 239: boolean fsuccess)); ! 240: static boolean fsserial_reset P((struct sconnection *qconn)); ! 241: static boolean fsstdin_reset P((struct sconnection *qconn)); ! 242: static boolean fsstdin_read P((struct sconnection *qconn, ! 243: char *zbuf, size_t *pclen, size_t cmin, ! 244: int ctimeout, boolean freport)); ! 245: static boolean fsstdin_write P((struct sconnection *qconn, ! 246: const char *zwrite, size_t cwrite)); ! 247: static boolean fsserial_break P((struct sconnection *qconn)); ! 248: static boolean fsstdin_break P((struct sconnection *qconn)); ! 249: static boolean fsserial_set P((struct sconnection *qconn, ! 250: enum tparitysetting tparity, ! 251: enum tstripsetting tstrip, ! 252: enum txonxoffsetting txonxoff)); ! 253: static boolean fsstdin_set P((struct sconnection *qconn, ! 254: enum tparitysetting tparity, ! 255: enum tstripsetting tstrip, ! 256: enum txonxoffsetting txonxoff)); ! 257: static boolean fsmodem_carrier P((struct sconnection *qconn, ! 258: boolean fcarrier)); ! 259: static boolean fsrun_chat P((int oread, int owrite, char **pzprog)); ! 260: static boolean fsstdin_chat P((struct sconnection *qconn, ! 261: char **pzprog)); ! 262: static long isserial_baud P((struct sconnection *qconn)); ! 263: ! 264: /* The command table for standard input ports. */ ! 265: ! 266: static const struct sconncmds sstdincmds = ! 267: { ! 268: usserial_free, ! 269: NULL, /* pflock */ ! 270: NULL, /* pfunlock */ ! 271: fsstdin_open, ! 272: fsstdin_close, ! 273: fsstdin_reset, ! 274: NULL, /* pfdial */ ! 275: fsstdin_read, ! 276: fsstdin_write, ! 277: fsysdep_conn_io, ! 278: fsstdin_break, ! 279: fsstdin_set, ! 280: NULL, /* pfcarrier */ ! 281: fsstdin_chat, ! 282: isserial_baud ! 283: }; ! 284: ! 285: /* The command table for modem ports. */ ! 286: ! 287: static const struct sconncmds smodemcmds = ! 288: { ! 289: usserial_free, ! 290: fsserial_lock, ! 291: fsserial_unlock, ! 292: fsmodem_open, ! 293: fsmodem_close, ! 294: fsserial_reset, ! 295: fmodem_dial, ! 296: fsysdep_conn_read, ! 297: fsysdep_conn_write, ! 298: fsysdep_conn_io, ! 299: fsserial_break, ! 300: fsserial_set, ! 301: fsmodem_carrier, ! 302: fsysdep_conn_chat, ! 303: isserial_baud ! 304: }; ! 305: ! 306: /* The command table for direct ports. */ ! 307: ! 308: static const struct sconncmds sdirectcmds = ! 309: { ! 310: usserial_free, ! 311: fsserial_lock, ! 312: fsserial_unlock, ! 313: fsdirect_open, ! 314: fsdirect_close, ! 315: fsserial_reset, ! 316: NULL, /* pfdial */ ! 317: fsysdep_conn_read, ! 318: fsysdep_conn_write, ! 319: fsysdep_conn_io, ! 320: fsserial_break, ! 321: fsserial_set, ! 322: NULL, /* pfcarrier */ ! 323: fsysdep_conn_chat, ! 324: isserial_baud ! 325: }; ! 326: ! 327: /* If the system will let us set both O_NDELAY and O_NONBLOCK, we do ! 328: so. This is because some ancient drivers on some systems appear to ! 329: look for one but not the other. Some other systems will give an ! 330: EINVAL error if we attempt to set both, so we use a static global ! 331: to hold the value we want to set. If we get EINVAL, we change the ! 332: global and try again (if some system gives an error other than ! 333: EINVAL, the code will have to be modified). */ ! 334: static int iSunblock = O_NDELAY | O_NONBLOCK; ! 335: ! 336: /* This code handles SIGALRM. See the discussion above ! 337: fsysdep_conn_read. Normally we ignore SIGALRM, but the handler ! 338: will temporarily be set to this function, which should set fSalarm ! 339: and then either longjmp or schedule another SIGALRM. fSalarm is ! 340: never referred to outside of this file, but we don't make it static ! 341: to try to fool compilers which don't understand volatile. */ ! 342: ! 343: volatile sig_atomic_t fSalarm; ! 344: ! 345: static RETSIGTYPE ! 346: usalarm (isig) ! 347: int isig; ! 348: { ! 349: #if ! HAVE_SIGACTION && ! HAVE_SIGVEC && ! HAVE_SIGSET ! 350: (void) signal (isig, usalarm); ! 351: #endif ! 352: ! 353: fSalarm = TRUE; ! 354: ! 355: #if HAVE_RESTARTABLE_SYSCALLS ! 356: longjmp (sSjmp_buf, 1); ! 357: #else ! 358: alarm (1); ! 359: #endif ! 360: } ! 361: ! 362: /* We need a simple routine to block SIGINT, SIGQUIT, SIGTERM and ! 363: SIGPIPE and another to restore the original state. When these ! 364: functions are called (in fsysdep_modem_close) SIGHUP is being ! 365: ignored. The routines are isblocksigs, which returns a value of ! 366: type HELD_SIG_MASK and usunblocksigs which takes a single argument ! 367: of type HELD_SIG_MASK. */ ! 368: ! 369: #if HAVE_SIGPROCMASK ! 370: ! 371: /* Use the POSIX sigprocmask call. */ ! 372: ! 373: #define HELD_SIG_MASK sigset_t ! 374: ! 375: static sigset_t isblocksigs P((void)); ! 376: ! 377: static sigset_t ! 378: isblocksigs () ! 379: { ! 380: sigset_t sblock, sold; ! 381: ! 382: /* These expressions need an extra set of parentheses to avoid a bug ! 383: in SCO 3.2.2. */ ! 384: (void) (sigemptyset (&sblock)); ! 385: (void) (sigaddset (&sblock, SIGINT)); ! 386: (void) (sigaddset (&sblock, SIGQUIT)); ! 387: (void) (sigaddset (&sblock, SIGTERM)); ! 388: (void) (sigaddset (&sblock, SIGPIPE)); ! 389: ! 390: (void) sigprocmask (SIG_BLOCK, &sblock, &sold); ! 391: return sold; ! 392: } ! 393: ! 394: #define usunblocksigs(s) \ ! 395: ((void) sigprocmask (SIG_SETMASK, &(s), (sigset_t *) NULL)) ! 396: ! 397: #else /* ! HAVE_SIGPROCMASK */ ! 398: #if HAVE_SIGBLOCK ! 399: ! 400: /* Use the BSD sigblock and sigsetmask calls. */ ! 401: ! 402: #define HELD_SIG_MASK int ! 403: ! 404: #ifndef sigmask ! 405: #define sigmask(i) (1 << ((i) - 1)) ! 406: #endif ! 407: ! 408: #define isblocksigs() \ ! 409: sigblock (sigmask (SIGINT) | sigmask (SIGQUIT) \ ! 410: | sigmask (SIGTERM) | sigmask (SIGPIPE)) ! 411: ! 412: #define usunblocksigs(i) ((void) sigsetmask (i)) ! 413: ! 414: #else /* ! HAVE_SIGBLOCK */ ! 415: ! 416: #if HAVE_SIGHOLD ! 417: ! 418: /* Use the SVR3 sighold and sigrelse calls. */ ! 419: ! 420: #define HELD_SIG_MASK int ! 421: ! 422: static int isblocksigs P((void)); ! 423: ! 424: static int ! 425: isblocksigs () ! 426: { ! 427: sighold (SIGINT); ! 428: sighold (SIGQUIT); ! 429: sighold (SIGTERM); ! 430: sighold (SIGPIPE); ! 431: return 0; ! 432: } ! 433: ! 434: static void usunblocksigs P((int)); ! 435: ! 436: /*ARGSUSED*/ ! 437: static void ! 438: usunblocksigs (i) ! 439: int i; ! 440: { ! 441: sigrelse (SIGINT); ! 442: sigrelse (SIGQUIT); ! 443: sigrelse (SIGTERM); ! 444: sigrelse (SIGPIPE); ! 445: } ! 446: ! 447: #else /* ! HAVE_SIGHOLD */ ! 448: ! 449: /* We have no way to block signals. This system will suffer from a ! 450: race condition in fsysdep_modem_close. */ ! 451: ! 452: #define HELD_SIG_MASK int ! 453: ! 454: #define isblocksigs() 0 ! 455: ! 456: #define usunblocksigs(i) ! 457: ! 458: #endif /* ! HAVE_SIGHOLD */ ! 459: #endif /* ! HAVE_SIGBLOCK */ ! 460: #endif /* ! HAVE_SIGPROCMASK */ ! 461: ! 462: /* Initialize a connection for use on a serial port. */ ! 463: ! 464: static boolean ! 465: fsserial_init (qconn, qcmds, zdevice) ! 466: struct sconnection *qconn; ! 467: const struct sconncmds *qcmds; ! 468: const char *zdevice; ! 469: { ! 470: struct ssysdep_conn *q; ! 471: ! 472: q = (struct ssysdep_conn *) xmalloc (sizeof (struct ssysdep_conn)); ! 473: if (zdevice == NULL ! 474: && qconn->qport != NULL ! 475: && qconn->qport->uuconf_ttype != UUCONF_PORTTYPE_STDIN) ! 476: zdevice = qconn->qport->uuconf_zname; ! 477: if (zdevice == NULL) ! 478: q->zdevice = NULL; ! 479: else if (*zdevice == '/') ! 480: q->zdevice = zbufcpy (zdevice); ! 481: else ! 482: { ! 483: size_t clen; ! 484: ! 485: clen = strlen (zdevice); ! 486: q->zdevice = zbufalc (sizeof "/dev/" + clen); ! 487: memcpy (q->zdevice, "/dev/", sizeof "/dev/" - 1); ! 488: memcpy (q->zdevice + sizeof "/dev/" - 1, zdevice, clen); ! 489: q->zdevice[sizeof "/dev/" + clen - 1] = '\0'; ! 490: } ! 491: q->o = -1; ! 492: q->ftli = FALSE; ! 493: qconn->psysdep = (pointer) q; ! 494: qconn->qcmds = qcmds; ! 495: return TRUE; ! 496: } ! 497: ! 498: /* Initialize a connection for use on standard input. */ ! 499: ! 500: boolean ! 501: fsysdep_stdin_init (qconn) ! 502: struct sconnection *qconn; ! 503: { ! 504: return fsserial_init (qconn, &sstdincmds, (const char *) NULL); ! 505: } ! 506: ! 507: /* Initialize a connection for use on a modem port. */ ! 508: ! 509: boolean ! 510: fsysdep_modem_init (qconn) ! 511: struct sconnection *qconn; ! 512: { ! 513: return fsserial_init (qconn, &smodemcmds, ! 514: qconn->qport->uuconf_u.uuconf_smodem.uuconf_zdevice); ! 515: } ! 516: ! 517: /* Initialize a connection for use on a direct port. */ ! 518: ! 519: boolean ! 520: fsysdep_direct_init (qconn) ! 521: struct sconnection *qconn; ! 522: { ! 523: return fsserial_init (qconn, &sdirectcmds, ! 524: qconn->qport->uuconf_u.uuconf_sdirect.uuconf_zdevice); ! 525: } ! 526: ! 527: /* Free up a serial port. */ ! 528: ! 529: static void ! 530: usserial_free (qconn) ! 531: struct sconnection *qconn; ! 532: { ! 533: struct ssysdep_conn *qsysdep; ! 534: ! 535: qsysdep = (struct ssysdep_conn *) qconn->psysdep; ! 536: ubuffree (qsysdep->zdevice); ! 537: xfree ((pointer) qsysdep); ! 538: qconn->psysdep = NULL; ! 539: } ! 540: ! 541: /* This routine is used for both locking and unlocking. It is the ! 542: only routine which knows how to translate a device name into the ! 543: name of a lock file. If it can't figure out a name, it does ! 544: nothing and returns TRUE. */ ! 545: ! 546: static boolean ! 547: fsserial_lockfile (flok, qconn) ! 548: boolean flok; ! 549: const struct sconnection *qconn; ! 550: { ! 551: struct ssysdep_conn *qsysdep; ! 552: const char *z; ! 553: char *zalc; ! 554: boolean fret; ! 555: ! 556: qsysdep = (struct ssysdep_conn *) qconn->psysdep; ! 557: if (qconn->qport == NULL) ! 558: z = NULL; ! 559: else ! 560: z = qconn->qport->uuconf_zlockname; ! 561: zalc = NULL; ! 562: if (z == NULL) ! 563: { ! 564: #if ! HAVE_SVR4_LOCKFILES ! 565: { ! 566: const char *zbase; ! 567: size_t clen; ! 568: ! 569: zbase = strrchr (qsysdep->zdevice, '/') + 1; ! 570: clen = strlen (zbase); ! 571: zalc = zbufalc (sizeof "LCK.." + clen); ! 572: memcpy (zalc, "LCK..", sizeof "LCK.." - 1); ! 573: memcpy (zalc + sizeof "LCK.." - 1, zbase, clen + 1); ! 574: #if HAVE_SCO_LOCKFILES ! 575: { ! 576: char *zl; ! 577: ! 578: for (zl = zalc + sizeof "LCK.." - 1; *zl != '\0'; zl++) ! 579: if (isupper (*zl)) ! 580: *zl = tolower (*zl); ! 581: } ! 582: #endif ! 583: z = zalc; ! 584: } ! 585: #else /* ! HAVE_SVR4_LOCKFILES */ ! 586: #if HAVE_SVR4_LOCKFILES ! 587: { ! 588: struct stat s; ! 589: ! 590: if (stat (qsysdep->zdevice, &s) != 0) ! 591: { ! 592: ulog (LOG_ERROR, "stat (%s): %s", qsysdep->zdevice, ! 593: strerror (errno)); ! 594: return FALSE; ! 595: } ! 596: zalc = zbufalc (sizeof "LK.123.123.123"); ! 597: sprintf (zalc, "LK.%03d.%03d.%03d", major (s.st_dev), ! 598: major (s.st_rdev), minor (s.st_rdev)); ! 599: z = zalc; ! 600: } ! 601: #else /* ! HAVE_SVR4_LOCKFILES */ ! 602: z = strrchr (qsysdep->zdevice, '/') + 1; ! 603: #endif /* ! HAVE_SVR4_LOCKFILES */ ! 604: #endif /* ! HAVE_SVR4_LOCKFILES */ ! 605: } ! 606: ! 607: if (flok) ! 608: fret = fsdo_lock (z, FALSE, (boolean *) NULL); ! 609: else ! 610: fret = fsdo_unlock (z, FALSE); ! 611: ! 612: #if HAVE_COHERENT_LOCKFILES ! 613: if (fret) ! 614: { ! 615: if (flok) ! 616: { ! 617: if (lockttyexist (z+5)) ! 618: { ! 619: ulog (LOG_NORMAL, "%s: port already locked", z+5); ! 620: fret = FALSE; ! 621: } ! 622: else ! 623: fret = (fscoherent_disable_tty (z + 5, &qsysdep->zenable)); ! 624: } ! 625: else ! 626: { ! 627: fret = TRUE; ! 628: if (qsysdep->zenable != NULL) ! 629: { ! 630: const char *azargs[3]; ! 631: int aidescs[3]; ! 632: pid_t ipid; ! 633: ! 634: azargs[0] = "/etc/enable"; ! 635: azargs[1] = qsysdep->zenable; ! 636: azargs[2] = NULL; ! 637: aidescs[0] = SPAWN_NULL; ! 638: aidescs[1] = SPAWN_NULL; ! 639: aidescs[2] = SPAWN_NULL; ! 640: ! 641: ipid = ixsspawn (azargs, aidescs, TRUE, FALSE, ! 642: (const char *) NULL, TRUE, TRUE, ! 643: (const char *) NULL, (const char *) NULL, ! 644: (const char *) NULL); ! 645: if (ipid < 0) ! 646: { ! 647: ulog (LOG_ERROR, "ixsspawn (/etc/enable %s): %s", ! 648: qsysdep->zenable, strerror (errno)); ! 649: fret = FALSE; ! 650: } ! 651: else ! 652: { ! 653: if (ixswait ((unsigned long) ipid, (const char *) NULL) ! 654: == 0) ! 655: fret = TRUE; ! 656: else ! 657: fret = FALSE; ! 658: } ! 659: ubuffree (qsysdep->zenable); ! 660: qsysdep->zenable = NULL; ! 661: } ! 662: } ! 663: } ! 664: #endif /* HAVE_COHERENT_LOCKFILES */ ! 665: ! 666: ubuffree (zalc); ! 667: return fret; ! 668: } ! 669: ! 670: /* If we can mark a modem line in use, then when we lock a port we ! 671: must open it and mark it in use. We can't wait until the actual ! 672: open because we can't fail out if it is locked then. */ ! 673: ! 674: static boolean ! 675: fsserial_lock (qconn, fin) ! 676: struct sconnection *qconn; ! 677: boolean fin; ! 678: { ! 679: if (! fsserial_lockfile (TRUE, qconn)) ! 680: return FALSE; ! 681: ! 682: #if HAVE_TIOCSINUSE || HAVE_TIOCEXCL ! 683: /* Open the line and try to mark it in use. */ ! 684: { ! 685: struct ssysdep_conn *qsysdep; ! 686: int iflag; ! 687: ! 688: qsysdep = (struct ssysdep_conn *) qconn->psysdep; ! 689: ! 690: if (fin) ! 691: iflag = 0; ! 692: else ! 693: iflag = iSunblock; ! 694: ! 695: qsysdep->o = open (qsysdep->zdevice, O_RDWR | iflag); ! 696: if (qsysdep->o < 0) ! 697: { ! 698: #if O_NONBLOCK != 0 ! 699: if (! fin && iSunblock != O_NONBLOCK && errno == EINVAL) ! 700: { ! 701: iSunblock = O_NONBLOCK; ! 702: qsysdep->o = open (qsysdep->zdevice, ! 703: O_RDWR | O_NONBLOCK); ! 704: } ! 705: #endif ! 706: if (qsysdep->o < 0) ! 707: { ! 708: if (errno != EBUSY) ! 709: ulog (LOG_ERROR, "open (%s): %s", qsysdep->zdevice, ! 710: strerror (errno)); ! 711: (void) fsserial_lockfile (FALSE, qconn); ! 712: return FALSE; ! 713: } ! 714: } ! 715: ! 716: #if HAVE_TIOCSINUSE ! 717: /* If we can't mark it in use, return FALSE to indicate that the ! 718: lock failed. */ ! 719: if (ioctl (qsysdep->o, TIOCSINUSE, 0) < 0) ! 720: { ! 721: if (errno != EALREADY) ! 722: ulog (LOG_ERROR, "ioctl (TIOCSINUSE): %s", strerror (errno)); ! 723: #ifdef TIOCNOTTY ! 724: (void) ioctl (qsysdep->o, TIOCNOTTY, (char *) NULL); ! 725: #endif ! 726: (void) close (qsysdep->o); ! 727: qsysdep->o = -1; ! 728: (void) fsserial_lockfile (FALSE, qconn); ! 729: return FALSE; ! 730: } ! 731: #endif ! 732: ! 733: if (fcntl (qsysdep->o, F_SETFD, ! 734: fcntl (qsysdep->o, F_GETFD, 0) | FD_CLOEXEC) < 0) ! 735: { ! 736: ulog (LOG_ERROR, "fcntl (FD_CLOEXEC): %s", strerror (errno)); ! 737: #ifdef TIOCNOTTY ! 738: (void) ioctl (qsysdep->o, TIOCNOTTY, (char *) NULL); ! 739: #endif ! 740: (void) close (qsysdep->o); ! 741: qsysdep->o = -1; ! 742: (void) fsserial_lockfile (FALSE, qconn); ! 743: return FALSE; ! 744: } ! 745: ! 746: #ifdef TIOCSCTTY ! 747: /* On BSD 4.4, make it our controlling terminal. */ ! 748: (void) ioctl (qsysdep->o, TIOCSCTTY, 0); ! 749: #endif ! 750: } ! 751: #endif /* HAVE_TIOCSINUSE || HAVE_TIOCEXCL */ ! 752: ! 753: return TRUE; ! 754: } ! 755: ! 756: /* Unlock a modem or direct port. */ ! 757: ! 758: static boolean ! 759: fsserial_unlock (qconn) ! 760: struct sconnection *qconn; ! 761: { ! 762: boolean fret; ! 763: struct ssysdep_conn *qsysdep; ! 764: ! 765: fret = TRUE; ! 766: ! 767: /* The file may have been opened by fsserial_lock, so close it here ! 768: if necessary. */ ! 769: qsysdep = (struct ssysdep_conn *) qconn->psysdep; ! 770: if (qsysdep->o >= 0) ! 771: { ! 772: #ifdef TIOCNOTTY ! 773: (void) ioctl (qsysdep->o, TIOCNOTTY, (char *) NULL); ! 774: #endif ! 775: if (close (qsysdep->o) < 0) ! 776: { ! 777: ulog (LOG_ERROR, "close: %s", strerror (errno)); ! 778: fret = FALSE; ! 779: } ! 780: qsysdep->o = -1; ! 781: } ! 782: ! 783: if (! fsserial_lockfile (FALSE, qconn)) ! 784: fret = FALSE; ! 785: ! 786: return fret; ! 787: } ! 788: ! 789: /* Open a serial line. This sets the terminal settings. We begin in ! 790: seven bit mode and let the protocol change if necessary. */ ! 791: ! 792: #if HAVE_POSIX_TERMIOS ! 793: typedef speed_t baud_code; ! 794: #else ! 795: typedef int baud_code; ! 796: #endif ! 797: ! 798: static struct sbaud_table ! 799: { ! 800: baud_code icode; ! 801: long ibaud; ! 802: } asSbaud_table[] = ! 803: { ! 804: { B50, 50 }, ! 805: { B75, 75 }, ! 806: { B110, 110 }, ! 807: { B134, 134 }, ! 808: { B150, 150 }, ! 809: { B200, 200 }, ! 810: { B300, 300 }, ! 811: { B600, 600 }, ! 812: { B1200, 1200 }, ! 813: { B1800, 1800 }, ! 814: { B2400, 2400 }, ! 815: { B4800, 4800 }, ! 816: { B9600, 9600 }, ! 817: #ifdef B19200 ! 818: { B19200, 19200 }, ! 819: #else /* ! defined (B19200) */ ! 820: #ifdef EXTA ! 821: { EXTA, 19200 }, ! 822: #endif /* EXTA */ ! 823: #endif /* ! defined (B19200) */ ! 824: #ifdef B38400 ! 825: { B38400, 38400 }, ! 826: #else /* ! defined (B38400) */ ! 827: #ifdef EXTB ! 828: { EXTB, 38400 }, ! 829: #endif /* EXTB */ ! 830: #endif /* ! defined (B38400) */ ! 831: #ifdef B57600 ! 832: { B57600, 57600 }, ! 833: #endif ! 834: #ifdef B76800 ! 835: { B76800, 76800 }, ! 836: #endif ! 837: #ifdef B115200 ! 838: { B115200, 115200 }, ! 839: #endif ! 840: { B0, 0 } ! 841: }; ! 842: ! 843: #define CBAUD_TABLE (sizeof asSbaud_table / sizeof asSbaud_table[0]) ! 844: ! 845: #if HAVE_SYSV_TERMIO || HAVE_POSIX_TERMIOS ! 846: /* Hold the MIN value for the terminal to avoid setting it ! 847: unnecessarily. */ ! 848: static int cSmin; ! 849: #endif /* HAVE_SYSV_TERMIO || HAVE_POSIX_TERMIOS */ ! 850: ! 851: static boolean ! 852: fsserial_open (qconn, ibaud, fwait) ! 853: struct sconnection *qconn; ! 854: long ibaud; ! 855: boolean fwait; ! 856: { ! 857: struct ssysdep_conn *q; ! 858: baud_code ib; ! 859: ! 860: q = (struct ssysdep_conn *) qconn->psysdep; ! 861: ! 862: if (q->zdevice != NULL) ! 863: ulog_device (strrchr (q->zdevice, '/') + 1); ! 864: else ! 865: { ! 866: const char *zport; ! 867: boolean fdummy; ! 868: ! 869: #if DEBUG > 0 ! 870: if (qconn->qport != NULL && ! 871: qconn->qport->uuconf_ttype != UUCONF_PORTTYPE_STDIN) ! 872: ulog (LOG_FATAL, "fsserial_open: Can't happen"); ! 873: #endif ! 874: zport = zsysdep_port_name (&fdummy); ! 875: if (zport != NULL) ! 876: ulog_device (zport); ! 877: } ! 878: ! 879: ib = B0; ! 880: if (ibaud != 0) ! 881: { ! 882: int i; ! 883: ! 884: for (i = 0; i < CBAUD_TABLE; i++) ! 885: if (asSbaud_table[i].ibaud == ibaud) ! 886: break; ! 887: if (i >= CBAUD_TABLE) ! 888: { ! 889: ulog (LOG_ERROR, "Unsupported baud rate %ld", ibaud); ! 890: return FALSE; ! 891: } ! 892: ib = asSbaud_table[i].icode; ! 893: } ! 894: ! 895: /* The port may have already been opened by the locking routine. */ ! 896: if (q->o < 0) ! 897: { ! 898: int iflag; ! 899: ! 900: if (fwait) ! 901: iflag = 0; ! 902: else ! 903: iflag = iSunblock; ! 904: ! 905: q->o = open (q->zdevice, O_RDWR | iflag); ! 906: if (q->o < 0) ! 907: { ! 908: #if O_NONBLOCK != 0 ! 909: if (! fwait && iSunblock != O_NONBLOCK && errno == EINVAL) ! 910: { ! 911: iSunblock = O_NONBLOCK; ! 912: q->o = open (q->zdevice, O_RDWR | O_NONBLOCK); ! 913: } ! 914: #endif ! 915: if (q->o < 0) ! 916: { ! 917: ulog (LOG_ERROR, "open (%s): %s", q->zdevice, ! 918: strerror (errno)); ! 919: return FALSE; ! 920: } ! 921: } ! 922: ! 923: if (fcntl (q->o, F_SETFD, fcntl (q->o, F_GETFD, 0) | FD_CLOEXEC) < 0) ! 924: { ! 925: ulog (LOG_ERROR, "fcntl (FD_CLOEXEC): %s", strerror (errno)); ! 926: return FALSE; ! 927: } ! 928: ! 929: #ifdef TIOCSCTTY ! 930: /* On BSD 4.4, make it our controlling terminal. */ ! 931: (void) ioctl (q->o, TIOCSCTTY, 0); ! 932: #endif ! 933: } ! 934: ! 935: /* Get the port flags, and make sure the ports are blocking. */ ! 936: ! 937: q->iflags = fcntl (q->o, F_GETFL, 0); ! 938: if (q->iflags < 0) ! 939: { ! 940: ulog (LOG_ERROR, "fcntl: %s", strerror (errno)); ! 941: return FALSE; ! 942: } ! 943: q->istdout_flags = -1; ! 944: ! 945: if (! fgetterminfo (q->o, &q->sorig)) ! 946: { ! 947: q->fterminal = FALSE; ! 948: return TRUE; ! 949: } ! 950: ! 951: q->fterminal = TRUE; ! 952: ! 953: q->snew = q->sorig; ! 954: ! 955: #if HAVE_BSD_TTY ! 956: ! 957: q->snew.stty.sg_flags = RAW | ANYP; ! 958: if (ibaud == 0) ! 959: ib = q->snew.stty.sg_ospeed; ! 960: else ! 961: { ! 962: q->snew.stty.sg_ispeed = ib; ! 963: q->snew.stty.sg_ospeed = ib; ! 964: } ! 965: ! 966: /* We don't want to receive any interrupt characters. */ ! 967: q->snew.stchars.t_intrc = -1; ! 968: q->snew.stchars.t_quitc = -1; ! 969: q->snew.stchars.t_eofc = -1; ! 970: q->snew.stchars.t_brkc = -1; ! 971: q->snew.sltchars.t_suspc = -1; ! 972: q->snew.sltchars.t_rprntc = -1; ! 973: q->snew.sltchars.t_dsuspc = -1; ! 974: q->snew.sltchars.t_flushc = -1; ! 975: q->snew.sltchars.t_werasc = -1; ! 976: q->snew.sltchars.t_lnextc = -1; ! 977: ! 978: #ifdef NTTYDISC ! 979: /* We want to use the ``new'' terminal driver so that we can use the ! 980: local mode bits to control XON/XOFF. */ ! 981: { ! 982: int iparam; ! 983: ! 984: if (ioctl (q->o, TIOCGETD, &iparam) >= 0 ! 985: && iparam != NTTYDISC) ! 986: { ! 987: iparam = NTTYDISC; ! 988: (void) ioctl (q->o, TIOCSETD, &iparam); ! 989: } ! 990: } ! 991: #endif ! 992: ! 993: #ifdef TIOCHPCL ! 994: /* When the file is closed, hang up the line. This is a safety ! 995: measure in case the program crashes. */ ! 996: (void) ioctl (q->o, TIOCHPCL, 0); ! 997: #endif ! 998: ! 999: #ifdef TIOCFLUSH ! 1000: { ! 1001: int iparam; ! 1002: ! 1003: /* Flush pending input. */ ! 1004: #ifdef FREAD ! 1005: iparam = FREAD; ! 1006: #else ! 1007: iparam = 0; ! 1008: #endif ! 1009: (void) ioctl (q->o, TIOCFLUSH, &iparam); ! 1010: } ! 1011: #endif /* TIOCFLUSH */ ! 1012: ! 1013: #endif /* HAVE_BSD_TTY */ ! 1014: ! 1015: #if HAVE_SYSV_TERMIO ! 1016: ! 1017: if (ibaud == 0) ! 1018: ib = q->snew.c_cflag & CBAUD; ! 1019: ! 1020: q->snew.c_iflag &=~ ICLEAR_IFLAG; ! 1021: q->snew.c_oflag &=~ ICLEAR_OFLAG; ! 1022: q->snew.c_cflag &=~ ICLEAR_CFLAG; ! 1023: q->snew.c_cflag |= (ib | ISET_CFLAG); ! 1024: q->snew.c_lflag &=~ ICLEAR_LFLAG; ! 1025: cSmin = 1; ! 1026: q->snew.c_cc[VMIN] = cSmin; ! 1027: q->snew.c_cc[VTIME] = 0; ! 1028: ! 1029: #ifdef TCFLSH ! 1030: /* Flush pending input. */ ! 1031: (void) ioctl (q->o, TCFLSH, 0); ! 1032: #endif ! 1033: ! 1034: #endif /* HAVE_SYSV_TERMIO */ ! 1035: ! 1036: #if HAVE_POSIX_TERMIOS ! 1037: ! 1038: if (ibaud == 0) ! 1039: ib = cfgetospeed (&q->snew); ! 1040: ! 1041: q->snew.c_iflag &=~ ICLEAR_IFLAG; ! 1042: q->snew.c_oflag &=~ ICLEAR_OFLAG; ! 1043: q->snew.c_cflag &=~ ICLEAR_CFLAG; ! 1044: q->snew.c_cflag |= ISET_CFLAG; ! 1045: q->snew.c_lflag &=~ ICLEAR_LFLAG; ! 1046: cSmin = 1; ! 1047: q->snew.c_cc[VMIN] = cSmin; ! 1048: q->snew.c_cc[VTIME] = 0; ! 1049: ! 1050: (void) cfsetospeed (&q->snew, ib); ! 1051: (void) cfsetispeed (&q->snew, ib); ! 1052: ! 1053: /* Flush pending input. */ ! 1054: (void) tcflush (q->o, TCIFLUSH); ! 1055: ! 1056: #endif /* HAVE_POSIX_TERMIOS */ ! 1057: ! 1058: if (! fsetterminfo (q->o, &q->snew)) ! 1059: { ! 1060: ulog (LOG_ERROR, "Can't set terminal settings: %s", strerror (errno)); ! 1061: return FALSE; ! 1062: } ! 1063: ! 1064: if (ibaud != 0) ! 1065: q->ibaud = ibaud; ! 1066: else ! 1067: { ! 1068: int i; ! 1069: ! 1070: q->ibaud = (long) 1200; ! 1071: for (i = 0; i < CBAUD_TABLE; i++) ! 1072: { ! 1073: if (asSbaud_table[i].icode == ib) ! 1074: { ! 1075: q->ibaud = asSbaud_table[i].ibaud; ! 1076: break; ! 1077: } ! 1078: } ! 1079: ! 1080: DEBUG_MESSAGE1 (DEBUG_PORT, ! 1081: "fsserial_open: Baud rate is %ld", q->ibaud); ! 1082: } ! 1083: ! 1084: return TRUE; ! 1085: } ! 1086: ! 1087: /* Open a standard input port. The code alternates q->o between 0 and ! 1088: 1 as appropriate. It is always 0 before any call to fsblock. */ ! 1089: ! 1090: static boolean ! 1091: fsstdin_open (qconn, ibaud, fwait) ! 1092: struct sconnection *qconn; ! 1093: long ibaud; ! 1094: boolean fwait; ! 1095: { ! 1096: struct ssysdep_conn *q; ! 1097: ! 1098: q = (struct ssysdep_conn *) qconn->psysdep; ! 1099: q->o = 0; ! 1100: if (! fsserial_open (qconn, ibaud, fwait)) ! 1101: return FALSE; ! 1102: q->istdout_flags = fcntl (1, F_GETFL, 0); ! 1103: if (q->istdout_flags < 0) ! 1104: { ! 1105: ulog (LOG_ERROR, "fcntl: %s", strerror (errno)); ! 1106: return FALSE; ! 1107: } ! 1108: return TRUE; ! 1109: } ! 1110: ! 1111: /* Open a modem port. */ ! 1112: ! 1113: static boolean ! 1114: fsmodem_open (qconn, ibaud, fwait) ! 1115: struct sconnection *qconn; ! 1116: long ibaud; ! 1117: boolean fwait; ! 1118: { ! 1119: if (ibaud == (long) 0) ! 1120: ibaud = qconn->qport->uuconf_u.uuconf_smodem.uuconf_ibaud; ! 1121: return fsserial_open (qconn, ibaud, fwait); ! 1122: } ! 1123: ! 1124: /* Open a direct port. */ ! 1125: ! 1126: static boolean ! 1127: fsdirect_open (qconn, ibaud, fwait) ! 1128: struct sconnection *qconn; ! 1129: long ibaud; ! 1130: boolean fwait; ! 1131: { ! 1132: if (ibaud == (long) 0) ! 1133: ibaud = qconn->qport->uuconf_u.uuconf_sdirect.uuconf_ibaud; ! 1134: return fsserial_open (qconn, ibaud, fwait); ! 1135: } ! 1136: ! 1137: /* Change the blocking status of the port. We keep track of the ! 1138: current blocking status to avoid calling fcntl unnecessarily; fcntl ! 1139: turns out to be surprisingly expensive, at least on Ultrix. */ ! 1140: ! 1141: static boolean ! 1142: fsblock (qs, fblock) ! 1143: struct ssysdep_conn *qs; ! 1144: boolean fblock; ! 1145: { ! 1146: int iwant; ! 1147: int isys; ! 1148: ! 1149: if (fblock) ! 1150: iwant = qs->iflags &~ (O_NDELAY | O_NONBLOCK); ! 1151: else ! 1152: iwant = qs->iflags | iSunblock; ! 1153: ! 1154: if (iwant == qs->iflags) ! 1155: return TRUE; ! 1156: ! 1157: isys = fcntl (qs->o, F_SETFL, iwant); ! 1158: if (isys < 0) ! 1159: { ! 1160: #if O_NONBLOCK != 0 ! 1161: if (! fblock && iSunblock != O_NONBLOCK && errno == EINVAL) ! 1162: { ! 1163: iSunblock = O_NONBLOCK; ! 1164: iwant = qs->iflags | O_NONBLOCK; ! 1165: isys = fcntl (qs->o, F_SETFL, iwant); ! 1166: } ! 1167: #endif ! 1168: if (isys < 0) ! 1169: { ! 1170: ulog (LOG_ERROR, "fcntl: %s", strerror (errno)); ! 1171: return FALSE; ! 1172: } ! 1173: } ! 1174: ! 1175: qs->iflags = iwant; ! 1176: ! 1177: if (qs->istdout_flags >= 0) ! 1178: { ! 1179: if (fblock) ! 1180: iwant = qs->istdout_flags &~ (O_NDELAY | O_NONBLOCK); ! 1181: else ! 1182: iwant = qs->istdout_flags | iSunblock; ! 1183: ! 1184: if (fcntl (1, F_SETFL, iwant) < 0) ! 1185: { ! 1186: /* We don't bother to fix up iSunblock here, since we ! 1187: succeeded above. */ ! 1188: ulog (LOG_ERROR, "fcntl: %s", strerror (errno)); ! 1189: return FALSE; ! 1190: } ! 1191: ! 1192: qs->istdout_flags = iwant; ! 1193: } ! 1194: ! 1195: return TRUE; ! 1196: } ! 1197: ! 1198: /* Close a serial port. */ ! 1199: ! 1200: static boolean ! 1201: fsserial_close (q) ! 1202: struct ssysdep_conn *q; ! 1203: { ! 1204: if (q->o >= 0) ! 1205: { ! 1206: /* Use a 30 second timeout to avoid hanging while draining ! 1207: output. */ ! 1208: if (q->fterminal) ! 1209: { ! 1210: fSalarm = FALSE; ! 1211: ! 1212: if (fsysdep_catch ()) ! 1213: { ! 1214: usysdep_start_catch (); ! 1215: usset_signal (SIGALRM, usalarm, TRUE, (boolean *) NULL); ! 1216: (void) alarm (30); ! 1217: ! 1218: (void) fsetterminfodrain (q->o, &q->sorig); ! 1219: } ! 1220: ! 1221: usset_signal (SIGALRM, SIG_IGN, TRUE, (boolean *) NULL); ! 1222: (void) alarm (0); ! 1223: usysdep_end_catch (); ! 1224: ! 1225: /* If we timed out, use the non draining call. Hopefully ! 1226: this can't hang. */ ! 1227: if (fSalarm) ! 1228: (void) fsetterminfo (q->o, &q->sorig); ! 1229: } ! 1230: ! 1231: #ifdef TIOCNOTTY ! 1232: /* We don't want this as our controlling terminal any more, so ! 1233: get rid of it. This is necessary because we don't want to ! 1234: open /dev/tty, since that can confuse the serial port locking ! 1235: on some computers. */ ! 1236: (void) ioctl (q->o, TIOCNOTTY, (char *) NULL); ! 1237: #endif ! 1238: ! 1239: (void) close (q->o); ! 1240: q->o = -1; ! 1241: ! 1242: /* Sleep to give the terminal a chance to settle, in case we are ! 1243: about to call out again. */ ! 1244: sleep (2); ! 1245: } ! 1246: ! 1247: return TRUE; ! 1248: } ! 1249: ! 1250: /* Close a stdin port. */ ! 1251: ! 1252: /*ARGSUSED*/ ! 1253: static boolean ! 1254: fsstdin_close (qconn, puuconf, qdialer, fsuccess) ! 1255: struct sconnection *qconn; ! 1256: pointer puuconf; ! 1257: struct uuconf_dialer *qdialer; ! 1258: boolean fsuccess; ! 1259: { ! 1260: struct ssysdep_conn *qsysdep; ! 1261: ! 1262: qsysdep = (struct ssysdep_conn *) qconn->psysdep; ! 1263: (void) close (1); ! 1264: (void) close (2); ! 1265: qsysdep->o = 0; ! 1266: return fsserial_close (qsysdep); ! 1267: } ! 1268: ! 1269: /* Close a modem port. */ ! 1270: ! 1271: static boolean ! 1272: fsmodem_close (qconn, puuconf, qdialer, fsuccess) ! 1273: struct sconnection *qconn; ! 1274: pointer puuconf; ! 1275: struct uuconf_dialer *qdialer; ! 1276: boolean fsuccess; ! 1277: { ! 1278: struct ssysdep_conn *qsysdep; ! 1279: boolean fret; ! 1280: struct uuconf_dialer sdialer; ! 1281: const struct uuconf_chat *qchat; ! 1282: ! 1283: qsysdep = (struct ssysdep_conn *) qconn->psysdep; ! 1284: ! 1285: fret = TRUE; ! 1286: ! 1287: /* Figure out the dialer so that we can run the complete or abort ! 1288: chat scripts. */ ! 1289: if (qdialer == NULL) ! 1290: { ! 1291: if (qconn->qport->uuconf_u.uuconf_smodem.uuconf_pzdialer != NULL) ! 1292: { ! 1293: const char *zdialer; ! 1294: int iuuconf; ! 1295: ! 1296: zdialer = qconn->qport->uuconf_u.uuconf_smodem.uuconf_pzdialer[0]; ! 1297: iuuconf = uuconf_dialer_info (puuconf, zdialer, &sdialer); ! 1298: if (iuuconf == UUCONF_SUCCESS) ! 1299: qdialer = &sdialer; ! 1300: else ! 1301: { ! 1302: ulog_uuconf (LOG_ERROR, puuconf, iuuconf); ! 1303: fret = FALSE; ! 1304: } ! 1305: } ! 1306: else ! 1307: qdialer = qconn->qport->uuconf_u.uuconf_smodem.uuconf_qdialer; ! 1308: } ! 1309: ! 1310: /* Get the complete or abort chat script to use. */ ! 1311: qchat = NULL; ! 1312: if (qdialer != NULL) ! 1313: { ! 1314: if (fsuccess) ! 1315: qchat = &qdialer->uuconf_scomplete; ! 1316: else ! 1317: qchat = &qdialer->uuconf_sabort; ! 1318: } ! 1319: ! 1320: if (qchat != NULL ! 1321: && (qchat->uuconf_pzprogram != NULL ! 1322: || qchat->uuconf_pzchat != NULL)) ! 1323: { ! 1324: boolean fsighup_ignored; ! 1325: HELD_SIG_MASK smask; ! 1326: int i; ! 1327: sig_atomic_t afhold[INDEXSIG_COUNT]; ! 1328: ! 1329: /* We're no longer interested in carrier. */ ! 1330: (void) fsmodem_carrier (qconn, FALSE); ! 1331: ! 1332: /* The port I/O routines check whether any signal has been ! 1333: received, and abort if one has. While we are closing down ! 1334: the modem, we don't care if we received a signal in the past, ! 1335: but we do care if we receive a new signal (otherwise it would ! 1336: be difficult to kill a uucico which was closing down a ! 1337: modem). We never care if we get SIGHUP at this point. So we ! 1338: turn off SIGHUP, remember what signals we've already seen, ! 1339: and clear our notion of what signals we've seen. We have to ! 1340: block the signals while we remember and clear the array, ! 1341: since we might otherwise miss a signal which occurred between ! 1342: the copy and the clear (old systems can't block signals; they ! 1343: will just have to suffer the race). */ ! 1344: usset_signal (SIGHUP, SIG_IGN, FALSE, &fsighup_ignored); ! 1345: smask = isblocksigs (); ! 1346: for (i = 0; i < INDEXSIG_COUNT; i++) ! 1347: { ! 1348: afhold[i] = afSignal[i]; ! 1349: afSignal[i] = FALSE; ! 1350: } ! 1351: usunblocksigs (smask); ! 1352: ! 1353: if (! fchat (qconn, puuconf, qchat, (const struct uuconf_system *) NULL, ! 1354: (const struct uuconf_dialer *) NULL, (const char *) NULL, ! 1355: FALSE, qconn->qport->uuconf_zname, ! 1356: qsysdep->ibaud)) ! 1357: fret = FALSE; ! 1358: ! 1359: /* Restore the old signal array and the SIGHUP handler. It is ! 1360: not necessary to block signals here, since all we are doing ! 1361: is exactly what the signal handler itself would do if the ! 1362: signal occurred. */ ! 1363: for (i = 0; i < INDEXSIG_COUNT; i++) ! 1364: if (afhold[i]) ! 1365: afSignal[i] = TRUE; ! 1366: if (! fsighup_ignored) ! 1367: usset_signal (SIGHUP, ussignal, TRUE, (boolean *) NULL); ! 1368: } ! 1369: ! 1370: if (qdialer != NULL ! 1371: && qdialer == &sdialer) ! 1372: (void) uuconf_dialer_free (puuconf, &sdialer); ! 1373: ! 1374: #if ! HAVE_RESET_BUG ! 1375: /* Reset the terminal to make sure we drop DTR. It should be ! 1376: dropped when we close the descriptor, but that doesn't seem to ! 1377: happen on some systems. Use a 30 second timeout to avoid hanging ! 1378: while draining output. */ ! 1379: if (qsysdep->fterminal) ! 1380: { ! 1381: #if HAVE_BSD_TTY ! 1382: qsysdep->snew.stty.sg_ispeed = B0; ! 1383: qsysdep->snew.stty.sg_ospeed = B0; ! 1384: #endif ! 1385: #if HAVE_SYSV_TERMIO ! 1386: qsysdep->snew.c_cflag = (qsysdep->snew.c_cflag &~ CBAUD) | B0; ! 1387: #endif ! 1388: #if HAVE_POSIX_TERMIOS ! 1389: (void) cfsetospeed (&qsysdep->snew, B0); ! 1390: #endif ! 1391: ! 1392: fSalarm = FALSE; ! 1393: ! 1394: if (fsysdep_catch ()) ! 1395: { ! 1396: usysdep_start_catch (); ! 1397: usset_signal (SIGALRM, usalarm, TRUE, (boolean *) NULL); ! 1398: (void) alarm (30); ! 1399: ! 1400: (void) fsetterminfodrain (qsysdep->o, &qsysdep->snew); ! 1401: } ! 1402: ! 1403: usset_signal (SIGALRM, SIG_IGN, TRUE, (boolean *) NULL); ! 1404: (void) alarm (0); ! 1405: usysdep_end_catch (); ! 1406: ! 1407: /* Let the port settle. */ ! 1408: sleep (2); ! 1409: } ! 1410: #endif /* ! HAVE_RESET_BUG */ ! 1411: ! 1412: if (! fsserial_close (qsysdep)) ! 1413: fret = FALSE; ! 1414: ! 1415: return fret; ! 1416: } ! 1417: ! 1418: /* Close a direct port. */ ! 1419: ! 1420: /*ARGSUSED*/ ! 1421: static boolean ! 1422: fsdirect_close (qconn, puuconf, qdialer, fsuccess) ! 1423: struct sconnection *qconn; ! 1424: pointer puuconf; ! 1425: struct uuconf_dialer *qdialer; ! 1426: boolean fsuccess; ! 1427: { ! 1428: return fsserial_close ((struct ssysdep_conn *) qconn->psysdep); ! 1429: } ! 1430: ! 1431: /* Reset a serial port by hanging up. */ ! 1432: ! 1433: static boolean ! 1434: fsserial_reset (qconn) ! 1435: struct sconnection *qconn; ! 1436: { ! 1437: struct ssysdep_conn *q; ! 1438: sterminal sbaud; ! 1439: ! 1440: q = (struct ssysdep_conn *) qconn->psysdep; ! 1441: ! 1442: if (! q->fterminal) ! 1443: return TRUE; ! 1444: ! 1445: sbaud = q->snew; ! 1446: ! 1447: #if HAVE_BSD_TTY ! 1448: sbaud.stty.sg_ispeed = B0; ! 1449: sbaud.stty.sg_ospeed = B0; ! 1450: #endif ! 1451: #if HAVE_SYSV_TERMIO ! 1452: sbaud.c_cflag = (sbaud.c_cflag &~ CBAUD) | B0; ! 1453: #endif ! 1454: #if HAVE_POSIX_TERMIOS ! 1455: if (cfsetospeed (&sbaud, B0) < 0) ! 1456: { ! 1457: ulog (LOG_ERROR, "Can't set baud rate: %s", strerror (errno)); ! 1458: return FALSE; ! 1459: } ! 1460: #endif ! 1461: ! 1462: if (! fsetterminfodrain (q->o, &sbaud)) ! 1463: { ! 1464: ulog (LOG_ERROR, "Can't hangup terminal: %s", strerror (errno)); ! 1465: return FALSE; ! 1466: } ! 1467: ! 1468: /* Give the terminal a chance to settle. */ ! 1469: sleep (2); ! 1470: ! 1471: if (! fsetterminfo (q->o, &q->snew)) ! 1472: { ! 1473: ulog (LOG_ERROR, "Can't reopen terminal: %s", strerror (errno)); ! 1474: return FALSE; ! 1475: } ! 1476: ! 1477: return TRUE; ! 1478: } ! 1479: ! 1480: /* Reset a standard input port. */ ! 1481: ! 1482: static boolean ! 1483: fsstdin_reset (qconn) ! 1484: struct sconnection *qconn; ! 1485: { ! 1486: struct ssysdep_conn *qsysdep; ! 1487: ! 1488: qsysdep = (struct ssysdep_conn *) qconn->psysdep; ! 1489: qsysdep->o = 0; ! 1490: return fsserial_reset (qconn); ! 1491: } ! 1492: ! 1493: /* Begin dialing out on a modem port. This opens the dialer device if ! 1494: there is one. */ ! 1495: ! 1496: boolean ! 1497: fsysdep_modem_begin_dial (qconn, qdial) ! 1498: struct sconnection *qconn; ! 1499: struct uuconf_dialer *qdial; ! 1500: { ! 1501: struct ssysdep_conn *qsysdep; ! 1502: const char *z; ! 1503: ! 1504: qsysdep = (struct ssysdep_conn *) qconn->psysdep; ! 1505: ! 1506: #ifdef TIOCMODEM ! 1507: /* If we can tell the modem to obey modem control, do so. */ ! 1508: { ! 1509: int iperm; ! 1510: ! 1511: iperm = 0; ! 1512: (void) ioctl (qsysdep->o, TIOCMODEM, &iperm); ! 1513: } ! 1514: #endif /* TIOCMODEM */ ! 1515: ! 1516: /* If we supposed to toggle DTR, do so. */ ! 1517: ! 1518: if (qdial->uuconf_fdtr_toggle) ! 1519: { ! 1520: #ifdef TIOCCDTR ! 1521: (void) ioctl (qsysdep->o, TIOCCDTR, 0); ! 1522: sleep (2); ! 1523: (void) ioctl (qsysdep->o, TIOCSDTR, 0); ! 1524: #else /* ! defined (TIOCCDTR) */ ! 1525: (void) fconn_reset (qconn); ! 1526: #endif /* ! defined (TIOCCDTR) */ ! 1527: ! 1528: if (qdial->uuconf_fdtr_toggle_wait) ! 1529: sleep (2); ! 1530: } ! 1531: ! 1532: if (! fsmodem_carrier (qconn, FALSE)) ! 1533: return FALSE; ! 1534: ! 1535: /* Open the dial device if there is one. */ ! 1536: z = qconn->qport->uuconf_u.uuconf_smodem.uuconf_zdial_device; ! 1537: if (z != NULL) ! 1538: { ! 1539: char *zfree; ! 1540: int o; ! 1541: ! 1542: qsysdep->ohold = qsysdep->o; ! 1543: ! 1544: zfree = NULL; ! 1545: if (*z != '/') ! 1546: { ! 1547: zfree = zbufalc (sizeof "/dev/" + strlen (z)); ! 1548: sprintf (zfree, "/dev/%s", z); ! 1549: z = zfree; ! 1550: } ! 1551: ! 1552: o = open ((char *) z, O_RDWR | O_NOCTTY); ! 1553: if (o < 0) ! 1554: { ! 1555: ulog (LOG_ERROR, "open (%s): %s", z, strerror (errno)); ! 1556: ubuffree (zfree); ! 1557: return FALSE; ! 1558: } ! 1559: ubuffree (zfree); ! 1560: ! 1561: if (fcntl (o, F_SETFD, fcntl (o, F_GETFD, 0) | FD_CLOEXEC) < 0) ! 1562: { ! 1563: ulog (LOG_ERROR, "fcntl (FD_CLOEXEC): %s", strerror (errno)); ! 1564: (void) close (o); ! 1565: return FALSE; ! 1566: } ! 1567: ! 1568: qsysdep->o = o; ! 1569: } ! 1570: ! 1571: return TRUE; ! 1572: } ! 1573: ! 1574: /* Tell the port to require or not require carrier. On BSD this uses ! 1575: TIOCCAR and TIOCNCAR, which I assume are generally supported (it ! 1576: can also use the LNOMDM bit supported by IS68K Unix). On System V ! 1577: it resets or sets CLOCAL. We only require carrier if the port ! 1578: supports it. This will only be called with fcarrier TRUE if the ! 1579: dialer supports carrier. */ ! 1580: ! 1581: static boolean ! 1582: fsmodem_carrier (qconn, fcarrier) ! 1583: struct sconnection *qconn; ! 1584: boolean fcarrier; ! 1585: { ! 1586: register struct ssysdep_conn *q; ! 1587: ! 1588: q = (struct ssysdep_conn *) qconn->psysdep; ! 1589: ! 1590: if (! q->fterminal) ! 1591: return TRUE; ! 1592: ! 1593: if (fcarrier) ! 1594: { ! 1595: if (qconn->qport->uuconf_u.uuconf_smodem.uuconf_fcarrier) ! 1596: { ! 1597: #ifdef TIOCCAR ! 1598: /* Tell the modem to pay attention to carrier. */ ! 1599: if (ioctl (q->o, TIOCCAR, 0) < 0) ! 1600: { ! 1601: ulog (LOG_ERROR, "ioctl (TIOCCAR): %s", strerror (errno)); ! 1602: return FALSE; ! 1603: } ! 1604: #endif /* TIOCCAR */ ! 1605: ! 1606: #if HAVE_BSD_TTY ! 1607: #ifdef LNOMDM ! 1608: /* IS68K Unix uses a local LNOMDM bit. */ ! 1609: { ! 1610: int iparam; ! 1611: ! 1612: iparam = LNOMDM; ! 1613: if (ioctl (q->o, TIOCLBIC, &iparam) < 0) ! 1614: { ! 1615: ulog (LOG_ERROR, "ioctl (TIOCLBIC, LNOMDM): %s", ! 1616: strerror (errno)); ! 1617: return FALSE; ! 1618: } ! 1619: } ! 1620: #endif /* LNOMDM */ ! 1621: #endif /* HAVE_BSD_TTY */ ! 1622: ! 1623: #if HAVE_SYSV_TERMIO || HAVE_POSIX_TERMIOS ! 1624: /* Put the modem into nonlocal mode. */ ! 1625: q->snew.c_cflag &=~ CLOCAL; ! 1626: if (! fsetterminfo (q->o, &q->snew)) ! 1627: { ! 1628: ulog (LOG_ERROR, "Can't clear CLOCAL: %s", strerror (errno)); ! 1629: return FALSE; ! 1630: } ! 1631: #endif /* HAVE_SYSV_TERMIO || HAVE_POSIX_TERMIOS */ ! 1632: } ! 1633: } ! 1634: else ! 1635: { ! 1636: #ifdef TIOCNCAR ! 1637: /* Tell the modem to ignore carrier. */ ! 1638: if (ioctl (q->o, TIOCNCAR, 0) < 0) ! 1639: { ! 1640: ulog (LOG_ERROR, "ioctl (TIOCNCAR): %s", strerror (errno)); ! 1641: return FALSE; ! 1642: } ! 1643: #endif /* TIOCNCAR */ ! 1644: ! 1645: #if HAVE_BSD_TTY ! 1646: #ifdef LNOMDM ! 1647: /* IS68K Unix uses a local LNOMDM bit. */ ! 1648: { ! 1649: int iparam; ! 1650: ! 1651: iparam = LNOMDM; ! 1652: if (ioctl (q->o, TIOCLBIS, &iparam) < 0) ! 1653: { ! 1654: ulog (LOG_ERROR, "ioctl (TIOCLBIS, LNOMDM): %s", ! 1655: strerror (errno)); ! 1656: return FALSE; ! 1657: } ! 1658: } ! 1659: #endif /* LNOMDM */ ! 1660: #endif /* HAVE_BSD_TTY */ ! 1661: ! 1662: #if HAVE_SYSV_TERMIO || HAVE_POSIX_TERMIOS ! 1663: /* Put the modem into local mode (ignore carrier) to start the chat ! 1664: script. */ ! 1665: q->snew.c_cflag |= CLOCAL; ! 1666: if (! fsetterminfo (q->o, &q->snew)) ! 1667: { ! 1668: ulog (LOG_ERROR, "Can't set CLOCAL: %s", strerror (errno)); ! 1669: return FALSE; ! 1670: } ! 1671: ! 1672: #if HAVE_CLOCAL_BUG ! 1673: /* On SCO and AT&T UNIX PC you have to reopen the port. */ ! 1674: { ! 1675: int onew; ! 1676: ! 1677: onew = open (q->zdevice, O_RDWR); ! 1678: if (onew < 0) ! 1679: { ! 1680: ulog (LOG_ERROR, "open (%s): %s", q->zdevice, strerror (errno)); ! 1681: return FALSE; ! 1682: } ! 1683: ! 1684: if (fcntl (onew, F_SETFD, ! 1685: fcntl (onew, F_GETFD, 0) | FD_CLOEXEC) < 0) ! 1686: { ! 1687: ulog (LOG_ERROR, "fcntl (FD_CLOEXEC): %s", strerror (errno)); ! 1688: (void) close (onew); ! 1689: return FALSE; ! 1690: } ! 1691: ! 1692: (void) close (q->o); ! 1693: q->o = onew; ! 1694: } ! 1695: #endif /* HAVE_CLOCAL_BUG */ ! 1696: ! 1697: #endif /* HAVE_SYSV_TERMIO || HAVE_POSIX_TERMIOS */ ! 1698: } ! 1699: ! 1700: return TRUE; ! 1701: } ! 1702: ! 1703: /* Finish dialing out on a modem by closing any dialer device and waiting ! 1704: for carrier. */ ! 1705: ! 1706: boolean ! 1707: fsysdep_modem_end_dial (qconn, qdial) ! 1708: struct sconnection *qconn; ! 1709: struct uuconf_dialer *qdial; ! 1710: { ! 1711: struct ssysdep_conn *q; ! 1712: ! 1713: q = (struct ssysdep_conn *) qconn->psysdep; ! 1714: ! 1715: if (qconn->qport->uuconf_u.uuconf_smodem.uuconf_zdial_device != NULL) ! 1716: { ! 1717: (void) close (q->o); ! 1718: q->o = q->ohold; ! 1719: } ! 1720: ! 1721: if (qconn->qport->uuconf_u.uuconf_smodem.uuconf_fcarrier ! 1722: && qdial->uuconf_fcarrier) ! 1723: { ! 1724: /* Tell the port that we need carrier. */ ! 1725: if (! fsmodem_carrier (qconn, TRUE)) ! 1726: return FALSE; ! 1727: ! 1728: #ifdef TIOCWONLINE ! 1729: ! 1730: /* We know how to wait for carrier, so do so. */ ! 1731: ! 1732: /* If we already got a signal, just quit now. */ ! 1733: if (FGOT_QUIT_SIGNAL ()) ! 1734: return FALSE; ! 1735: ! 1736: /* This bit of code handles signals just like fsysdep_conn_read ! 1737: does. See that function for a longer explanation. */ ! 1738: ! 1739: /* Use fsysdep_catch to handle a longjmp from the signal ! 1740: handler. */ ! 1741: ! 1742: fSalarm = FALSE; ! 1743: ! 1744: if (fsysdep_catch ()) ! 1745: { ! 1746: /* Start catching SIGALRM; normally we ignore it. */ ! 1747: usysdep_start_catch (); ! 1748: usset_signal (SIGALRM, usalarm, TRUE, (boolean *) NULL); ! 1749: (void) alarm (qdial->uuconf_ccarrier_wait); ! 1750: ! 1751: /* We really don't care if we get an error, since that will ! 1752: probably just mean that TIOCWONLINE isn't supported in ! 1753: which case there's nothing we can do anyhow. If we get ! 1754: SIGINT we want to keep waiting for carrier, because ! 1755: SIGINT just means don't start any new sessions. We don't ! 1756: handle SIGINT correctly if we do a longjmp in the signal ! 1757: handler; too bad. */ ! 1758: while (ioctl (q->o, TIOCWONLINE, 0) < 0 ! 1759: && errno == EINTR) ! 1760: { ! 1761: /* Log the signal. */ ! 1762: ulog (LOG_ERROR, (const char *) NULL); ! 1763: if (FGOT_QUIT_SIGNAL () || fSalarm) ! 1764: break; ! 1765: } ! 1766: } ! 1767: ! 1768: /* Turn off the pending SIGALRM and ignore SIGALARM again. */ ! 1769: usset_signal (SIGALRM, SIG_IGN, TRUE, (boolean *) NULL); ! 1770: (void) alarm (0); ! 1771: usysdep_end_catch (); ! 1772: ! 1773: /* If we got a random signal, just return FALSE. */ ! 1774: if (FGOT_QUIT_SIGNAL ()) ! 1775: return FALSE; ! 1776: ! 1777: /* If we timed out, give an error. */ ! 1778: if (fSalarm) ! 1779: { ! 1780: ulog (LOG_ERROR, "Timed out waiting for carrier"); ! 1781: return FALSE; ! 1782: } ! 1783: ! 1784: #endif /* TIOCWONLINE */ ! 1785: } ! 1786: ! 1787: return TRUE; ! 1788: } ! 1789: ! 1790: /* Read data from a connection, with a timeout. This routine handles ! 1791: all types of connections, including TLI. ! 1792: ! 1793: This function should return when we have read cmin characters or ! 1794: the timeout has occurred. We have to work a bit to get Unix to do ! 1795: this efficiently on a terminal. The simple implementation ! 1796: schedules a SIGALRM signal and then calls read; if there is a ! 1797: single character available, the call to read will return ! 1798: immediately, so there must be a loop which terminates when the ! 1799: SIGALRM is delivered or the correct number of characters has been ! 1800: read. This can be very inefficient with a fast CPU or a low baud ! 1801: rate (or both!), since each call to read may return only one or two ! 1802: characters. ! 1803: ! 1804: Under POSIX or System V, we can specify a minimum number of ! 1805: characters to read, so there is no serious trouble. ! 1806: ! 1807: Under BSD, we figure out how many characters we have left to read, ! 1808: how long it will take for them to arrive at the current baud rate, ! 1809: and sleep that long. ! 1810: ! 1811: Doing this with a timeout and avoiding all possible race conditions ! 1812: get very hairy, though. Basically, we're going to schedule a ! 1813: SIGALRM for when the timeout expires. I don't really want to do a ! 1814: longjmp in the SIGALRM handler, though, because that may lose data. ! 1815: Therefore, I have the signal handler set a variable. However, this ! 1816: means that there will be a span of time between the time the code ! 1817: checks the variable and the time it calls the read system call; if ! 1818: the SIGALRM occurs during that time, the read might hang forever. ! 1819: To avoid this, the SIGALRM handler not only sets a global variable, ! 1820: it also schedules another SIGALRM for one second in the future ! 1821: (POSIX specifies that a signal handler is permitted to safely call ! 1822: alarm). To avoid getting a continual sequence of SIGALRM ! 1823: interrupts, we change the signal handler to ignore SIGALRM when ! 1824: we're about to exit the function. This means that every time we ! 1825: execute fsysdep_conn_read we make at least five system calls. It's ! 1826: the best I've been able to come up with, though. ! 1827: ! 1828: When fsysdep_conn_read finishes, there will be no SIGALRM scheduled ! 1829: and SIGALRM will be ignored. */ ! 1830: ! 1831: boolean ! 1832: fsysdep_conn_read (qconn, zbuf, pclen, cmin, ctimeout, freport) ! 1833: struct sconnection *qconn; ! 1834: char *zbuf; ! 1835: size_t *pclen; ! 1836: size_t cmin; ! 1837: int ctimeout; ! 1838: boolean freport; ! 1839: { ! 1840: CATCH_PROTECT size_t cwant; ! 1841: boolean fret; ! 1842: register struct ssysdep_conn * const q ! 1843: = (struct ssysdep_conn *) qconn->psysdep; ! 1844: ! 1845: cwant = *pclen; ! 1846: *pclen = 0; ! 1847: ! 1848: /* Guard against a bad timeout. We return TRUE when a timeout ! 1849: expires. It is possible to get a negative timeout here because ! 1850: the calling code does not check user supplied timeouts for ! 1851: plausibility. */ ! 1852: if (ctimeout <= 0) ! 1853: return TRUE; ! 1854: ! 1855: /* We want to do a blocking read. */ ! 1856: if (! fsblock (q, TRUE)) ! 1857: return FALSE; ! 1858: ! 1859: fSalarm = FALSE; ! 1860: ! 1861: /* We're going to set up an alarm signal to last for the entire ! 1862: read. If the read system call cannot be interrupted, the signal ! 1863: handler will do a longjmp causing fsysdep_catch (a macro) to ! 1864: return FALSE. We handle that here. If read can be interrupted, ! 1865: fsysdep_catch will be defined to TRUE. */ ! 1866: if (fsysdep_catch ()) ! 1867: { ! 1868: /* Prepare to catch SIGALRM and schedule the signal. */ ! 1869: usysdep_start_catch (); ! 1870: usset_signal (SIGALRM, usalarm, TRUE, (boolean *) NULL); ! 1871: alarm (ctimeout); ! 1872: } ! 1873: else ! 1874: { ! 1875: /* We caught a signal. We don't actually have to do anything, ! 1876: as all the appropriate checks are made at the start of the ! 1877: following loop. */ ! 1878: } ! 1879: ! 1880: fret = FALSE; ! 1881: ! 1882: while (TRUE) ! 1883: { ! 1884: int cgot; ! 1885: ! 1886: #if HAVE_SYSV_TERMIO || HAVE_POSIX_TERMIOS ! 1887: /* If we can tell the terminal not to return until we have a ! 1888: certain number of characters, do so. */ ! 1889: if (q->fterminal) ! 1890: { ! 1891: int csetmin; ! 1892: ! 1893: /* I'm not that confident about setting MIN to values larger ! 1894: than 127, although up to 255 would probably work. */ ! 1895: if (cmin < 127) ! 1896: csetmin = cmin; ! 1897: else ! 1898: csetmin = 127; ! 1899: ! 1900: if (csetmin != cSmin) ! 1901: { ! 1902: q->snew.c_cc[VMIN] = csetmin; ! 1903: while (! fsetterminfo (q->o, &q->snew)) ! 1904: { ! 1905: if (errno != EINTR ! 1906: || FGOT_QUIT_SIGNAL ()) ! 1907: { ! 1908: int ierr; ! 1909: ! 1910: /* We turn off the signal before reporting the ! 1911: error to minimize any problems with ! 1912: interrupted system calls. */ ! 1913: ierr = errno; ! 1914: usset_signal (SIGALRM, SIG_IGN, TRUE, (boolean *) NULL); ! 1915: alarm (0); ! 1916: usysdep_end_catch (); ! 1917: ulog (LOG_ERROR, "Can't set MIN for terminal: %s", ! 1918: strerror (ierr)); ! 1919: return FALSE; ! 1920: } ! 1921: ! 1922: if (fSalarm) ! 1923: { ! 1924: ulog (LOG_ERROR, ! 1925: "Timed out when setting MIN to %d; retrying", ! 1926: csetmin); ! 1927: fSalarm = FALSE; ! 1928: alarm (ctimeout); ! 1929: } ! 1930: } ! 1931: cSmin = csetmin; ! 1932: } ! 1933: } ! 1934: #endif /* HAVE_SYSV_TERMIO || HAVE_POSIX_TERMIOS */ ! 1935: ! 1936: /* If we've received a signal, get out now. */ ! 1937: if (FGOT_QUIT_SIGNAL ()) ! 1938: break; ! 1939: ! 1940: /* If we've already gotten a SIGALRM, get out with whatever ! 1941: we've accumulated. */ ! 1942: if (fSalarm) ! 1943: { ! 1944: fret = TRUE; ! 1945: break; ! 1946: } ! 1947: ! 1948: /* Right here is the race condition which we avoid by having the ! 1949: SIGALRM handler schedule another SIGALRM. */ ! 1950: #if HAVE_TLI ! 1951: if (q->ftli) ! 1952: { ! 1953: int iflags; ! 1954: ! 1955: cgot = t_rcv (q->o, zbuf, cwant, &iflags); ! 1956: if (cgot < 0 && t_errno != TSYSERR) ! 1957: { ! 1958: usset_signal (SIGALRM, SIG_IGN, TRUE, (boolean *) NULL); ! 1959: alarm (0); ! 1960: usysdep_end_catch (); ! 1961: ! 1962: if (freport) ! 1963: ulog (LOG_ERROR, "t_rcv: %s", ! 1964: (t_errno >= 0 && t_errno < t_nerr ! 1965: ? t_errlist[t_errno] ! 1966: : "unknown TLI error")); ! 1967: ! 1968: return FALSE; ! 1969: } ! 1970: } ! 1971: else ! 1972: #endif ! 1973: cgot = read (q->o, zbuf, cwant); ! 1974: ! 1975: /* If the read returned an error, check for signals. */ ! 1976: if (cgot < 0) ! 1977: { ! 1978: if (errno == EINTR) ! 1979: { ! 1980: /* Log the signal. */ ! 1981: ulog (LOG_ERROR, (const char *) NULL); ! 1982: } ! 1983: if (fSalarm) ! 1984: { ! 1985: fret = TRUE; ! 1986: break; ! 1987: } ! 1988: if (FGOT_QUIT_SIGNAL ()) ! 1989: break; ! 1990: } ! 1991: ! 1992: /* If read returned an error, get out. We just ignore EINTR ! 1993: here, since it must be from some signal we don't care about. ! 1994: If the read returned 0 then the line must have been hung up ! 1995: (normally we would have received SIGHUP, but we can't count ! 1996: on that). We turn off the signals before calling ulog to ! 1997: reduce problems with interrupted system calls. */ ! 1998: if (cgot <= 0) ! 1999: { ! 2000: if (cgot < 0 && errno == EINTR) ! 2001: cgot = 0; ! 2002: else ! 2003: { ! 2004: int ierr; ! 2005: ! 2006: ierr = errno; ! 2007: ! 2008: usset_signal (SIGALRM, SIG_IGN, TRUE, (boolean *) NULL); ! 2009: alarm (0); ! 2010: usysdep_end_catch (); ! 2011: ! 2012: if (freport) ! 2013: { ! 2014: if (cgot == 0) ! 2015: ulog (LOG_ERROR, "Line disconnected"); ! 2016: else ! 2017: ulog (LOG_ERROR, "read: %s", strerror (ierr)); ! 2018: } ! 2019: ! 2020: return FALSE; ! 2021: } ! 2022: } ! 2023: ! 2024: cwant -= cgot; ! 2025: if (cgot >= cmin) ! 2026: cmin = 0; ! 2027: else ! 2028: cmin -= cgot; ! 2029: zbuf += cgot; ! 2030: *pclen += cgot; ! 2031: ! 2032: /* If we have enough data, get out now. */ ! 2033: if (cmin == 0) ! 2034: { ! 2035: fret = TRUE; ! 2036: break; ! 2037: } ! 2038: ! 2039: #if HAVE_BSD_TTY ! 2040: /* We still want more data, so sleep long enough for the rest of ! 2041: it to arrive. We don't this for System V or POSIX because ! 2042: setting MIN is good enough (we can't sleep longer than it ! 2043: takes to get MAX_INPUT characters anyhow). ! 2044: ! 2045: The baud rate is approximately 10 times the number of ! 2046: characters which will arrive in one second, so the number of ! 2047: milliseconds to sleep == ! 2048: characters * (milliseconds / character) == ! 2049: characters * (1000 * (seconds / character)) == ! 2050: characters * (1000 * (1 / (baud / 10))) == ! 2051: characters * (10000 / baud) ! 2052: ! 2053: We arbitrarily reduce the sleep amount by 10 milliseconds to ! 2054: attempt to account for the amount of time it takes to set up ! 2055: the sleep. This is how long it takes to get half a character ! 2056: at 19200 baud. We then don't bother to sleep for less than ! 2057: 10 milliseconds. We don't sleep if the read was interrupted. ! 2058: ! 2059: We use select to sleep. It would be easy to use poll as ! 2060: well, but it's unlikely that any system with BSD ttys would ! 2061: have poll but not select. Using select avoids hassles with ! 2062: the pending SIGALRM; if it hits the select will be ! 2063: interrupted, and otherwise the select will not affect it. */ ! 2064: ! 2065: #if ! HAVE_SELECT ! 2066: #error This code requires select; feel free to extend it ! 2067: #endif ! 2068: ! 2069: if (q->fterminal && cmin > 1 && cgot > 0) ! 2070: { ! 2071: int csleepchars; ! 2072: int isleep; ! 2073: ! 2074: /* We don't try to read all the way up to MAX_INPUT, ! 2075: since that might drop a character. */ ! 2076: if (cmin <= MAX_INPUT - 10) ! 2077: csleepchars = cmin; ! 2078: else ! 2079: csleepchars = MAX_INPUT - 10; ! 2080: ! 2081: isleep = (int) (((long) csleepchars * 10000L) / q->ibaud); ! 2082: isleep -= 10; ! 2083: ! 2084: if (isleep > 10) ! 2085: { ! 2086: struct timeval s; ! 2087: ! 2088: s.tv_sec = isleep / 1000; ! 2089: s.tv_usec = (isleep % 1000) * 1000; ! 2090: ! 2091: /* Some versions of select take a pointer to an int, ! 2092: while some take a pointer to an fd_set. I just cast ! 2093: the arguments to a generic pointer, and assume that ! 2094: any machine which distinguishes int * from fd_set * ! 2095: (I would be amazed if there are any such machines) ! 2096: have an appropriate prototype somewhere or other. */ ! 2097: (void) select (0, (pointer) NULL, (pointer) NULL, ! 2098: (pointer) NULL, &s); ! 2099: ! 2100: /* Here either the select finished sleeping or we got a ! 2101: SIGALRM. If the latter occurred, fSalarm was set to ! 2102: TRUE; it will be checked at the top of the loop. */ ! 2103: } ! 2104: } ! 2105: #endif /* HAVE_BSD_TTY */ ! 2106: } ! 2107: ! 2108: /* Turn off the pending SIGALRM and return. */ ! 2109: ! 2110: usset_signal (SIGALRM, SIG_IGN, TRUE, (boolean *) NULL); ! 2111: alarm (0); ! 2112: usysdep_end_catch (); ! 2113: ! 2114: return fret; ! 2115: } ! 2116: ! 2117: /* Read from a stdin port. */ ! 2118: ! 2119: static boolean ! 2120: fsstdin_read (qconn, zbuf, pclen, cmin, ctimeout, freport) ! 2121: struct sconnection *qconn; ! 2122: char *zbuf; ! 2123: size_t *pclen; ! 2124: size_t cmin; ! 2125: int ctimeout; ! 2126: boolean freport; ! 2127: { ! 2128: struct ssysdep_conn *qsysdep; ! 2129: ! 2130: qsysdep = (struct ssysdep_conn *) qconn->psysdep; ! 2131: qsysdep->o = 0; ! 2132: return fsysdep_conn_read (qconn, zbuf, pclen, cmin, ctimeout, freport); ! 2133: } ! 2134: ! 2135: /* Write data to a connection. This routine handles all types of ! 2136: connections, including TLI. */ ! 2137: ! 2138: boolean ! 2139: fsysdep_conn_write (qconn, zwrite, cwrite) ! 2140: struct sconnection *qconn; ! 2141: const char *zwrite; ! 2142: size_t cwrite; ! 2143: { ! 2144: struct ssysdep_conn *q; ! 2145: int czero; ! 2146: ! 2147: q = (struct ssysdep_conn *) qconn->psysdep; ! 2148: ! 2149: /* We want blocking writes here. */ ! 2150: if (! fsblock (q, TRUE)) ! 2151: return FALSE; ! 2152: ! 2153: czero = 0; ! 2154: ! 2155: while (cwrite > 0) ! 2156: { ! 2157: int cdid; ! 2158: ! 2159: /* Loop until we don't get an interrupt. */ ! 2160: while (TRUE) ! 2161: { ! 2162: /* If we've received a signal, don't continue. */ ! 2163: if (FGOT_QUIT_SIGNAL ()) ! 2164: return FALSE; ! 2165: ! 2166: #if HAVE_TLI ! 2167: if (q->ftli) ! 2168: { ! 2169: cdid = t_snd (q->o, zwrite, cwrite, 0); ! 2170: if (cdid < 0 && t_errno != TSYSERR) ! 2171: { ! 2172: ulog (LOG_ERROR, "t_snd: %s", ! 2173: (t_errno >= 0 && t_errno < t_nerr ! 2174: ? t_errlist[t_errno] ! 2175: : "unknown TLI error")); ! 2176: return FALSE; ! 2177: } ! 2178: } ! 2179: else ! 2180: #endif ! 2181: cdid = write (q->o, zwrite, cwrite); ! 2182: ! 2183: if (cdid >= 0) ! 2184: break; ! 2185: if (errno != EINTR) ! 2186: break; ! 2187: ! 2188: /* We were interrupted by a signal. Log it. */ ! 2189: ulog (LOG_ERROR, (const char *) NULL); ! 2190: } ! 2191: ! 2192: if (cdid < 0) ! 2193: { ! 2194: if (errno != EAGAIN && errno != EWOULDBLOCK && errno != ENODATA) ! 2195: { ! 2196: ulog (LOG_ERROR, "write: %s", strerror (errno)); ! 2197: return FALSE; ! 2198: } ! 2199: cdid = 0; ! 2200: } ! 2201: ! 2202: if (cdid == 0) ! 2203: { ! 2204: /* On some systems write will return 0 if carrier is lost. ! 2205: If we fail to write anything ten times in a row, we ! 2206: assume that this has happened. This is hacked in like ! 2207: this because there seems to be no reliable way to tell ! 2208: exactly why the write returned 0. */ ! 2209: ++czero; ! 2210: if (czero >= 10) ! 2211: { ! 2212: ulog (LOG_ERROR, "Line disconnected"); ! 2213: return FALSE; ! 2214: } ! 2215: } ! 2216: else ! 2217: { ! 2218: czero = 0; ! 2219: ! 2220: cwrite -= cdid; ! 2221: zwrite += cdid; ! 2222: } ! 2223: } ! 2224: ! 2225: return TRUE; ! 2226: } ! 2227: ! 2228: /* Write to a stdin port. */ ! 2229: ! 2230: static boolean ! 2231: fsstdin_write (qconn, zwrite, cwrite) ! 2232: struct sconnection *qconn; ! 2233: const char *zwrite; ! 2234: size_t cwrite; ! 2235: { ! 2236: struct ssysdep_conn *qsysdep; ! 2237: ! 2238: qsysdep = (struct ssysdep_conn *) qconn->psysdep; ! 2239: qsysdep->o = 0; ! 2240: if (! fsblock (qsysdep, TRUE)) ! 2241: return FALSE; ! 2242: qsysdep->o = 1; ! 2243: return fsysdep_conn_write (qconn, zwrite, cwrite); ! 2244: } ! 2245: ! 2246: /* The fsysdep_conn_io routine is supposed to both read and write data ! 2247: until it has either filled its read buffer or written out all the ! 2248: data it was given. This lets us write out large packets without ! 2249: losing incoming data. It handles all types of connections, ! 2250: including TLI. */ ! 2251: ! 2252: boolean ! 2253: fsysdep_conn_io (qconn, zwrite, pcwrite, zread, pcread) ! 2254: struct sconnection *qconn; ! 2255: const char *zwrite; ! 2256: size_t *pcwrite; ! 2257: char *zread; ! 2258: size_t *pcread; ! 2259: { ! 2260: struct ssysdep_conn *q; ! 2261: size_t cwrite, cread; ! 2262: int czero; ! 2263: ! 2264: q = (struct ssysdep_conn *) qconn->psysdep; ! 2265: ! 2266: cwrite = *pcwrite; ! 2267: *pcwrite = 0; ! 2268: cread = *pcread; ! 2269: *pcread = 0; ! 2270: ! 2271: czero = 0; ! 2272: ! 2273: while (TRUE) ! 2274: { ! 2275: int cgot, cdid; ! 2276: size_t cdo; ! 2277: ! 2278: /* This used to always use nonblocking writes, but it turns out ! 2279: that some systems don't support them on terminals. ! 2280: ! 2281: The current algorithm is: ! 2282: loop: ! 2283: unblocked read ! 2284: if read buffer full, return ! 2285: if nothing to write, return ! 2286: if HAVE_UNBLOCKED_WRITES ! 2287: write all data ! 2288: else ! 2289: write up to SINGLE_WRITE bytes ! 2290: if all data written, return ! 2291: if no data written ! 2292: blocked write of up to SINGLE_WRITE bytes ! 2293: ! 2294: This algorithm should work whether the system supports ! 2295: unblocked writes on terminals or not. If the system supports ! 2296: unblocked writes but HAVE_UNBLOCKED_WRITES is 0, then it will ! 2297: call write more often than it needs to. If the system does ! 2298: not support unblocked writes but HAVE_UNBLOCKED_WRITES is 1, ! 2299: then the write may hang so long that incoming data is lost. ! 2300: This is actually possible at high baud rates on any system ! 2301: when a blocking write is done; there is no solution, except ! 2302: hardware handshaking. */ ! 2303: ! 2304: /* If we are running on standard input, we switch the file ! 2305: descriptors by hand. */ ! 2306: if (q->istdout_flags >= 0) ! 2307: q->o = 0; ! 2308: ! 2309: /* Do an unblocked read. */ ! 2310: if (! fsblock (q, FALSE)) ! 2311: return FALSE; ! 2312: ! 2313: /* Loop until we get something (error or data) other than an ! 2314: acceptable EINTR. */ ! 2315: while (TRUE) ! 2316: { ! 2317: /* If we've received a signal, don't continue. */ ! 2318: if (FGOT_QUIT_SIGNAL ()) ! 2319: return FALSE; ! 2320: ! 2321: #if HAVE_TLI ! 2322: if (q->ftli) ! 2323: { ! 2324: int iflags; ! 2325: ! 2326: cgot = t_rcv (q->o, zread, cread, &iflags); ! 2327: if (cgot < 0) ! 2328: { ! 2329: if (t_errno == TNODATA) ! 2330: errno = EAGAIN; ! 2331: else if (t_errno != TSYSERR) ! 2332: { ! 2333: ulog (LOG_ERROR, "t_rcv: %s", ! 2334: (t_errno >= 0 && t_errno < t_nerr ! 2335: ? t_errlist[t_errno] ! 2336: : "unknown TLI error")); ! 2337: return FALSE; ! 2338: } ! 2339: } ! 2340: } ! 2341: else ! 2342: #endif ! 2343: cgot = read (q->o, zread, cread); ! 2344: ! 2345: if (cgot >= 0) ! 2346: break; ! 2347: if (errno != EINTR) ! 2348: break; ! 2349: ! 2350: /* We got interrupted by a signal. Log it. */ ! 2351: ulog (LOG_ERROR, (const char *) NULL); ! 2352: } ! 2353: ! 2354: if (cgot < 0) ! 2355: { ! 2356: if (errno != EAGAIN && errno != EWOULDBLOCK && errno != ENODATA) ! 2357: { ! 2358: ulog (LOG_ERROR, "read: %s", strerror (errno)); ! 2359: return FALSE; ! 2360: } ! 2361: cgot = 0; ! 2362: } ! 2363: ! 2364: cread -= cgot; ! 2365: zread += cgot; ! 2366: *pcread += cgot; ! 2367: ! 2368: /* If we've filled the read buffer, or we have nothing left to ! 2369: write, return out. */ ! 2370: if (cread == 0 || cwrite == 0) ! 2371: return TRUE; ! 2372: ! 2373: /* The port is currently unblocked. Do a write. */ ! 2374: cdo = cwrite; ! 2375: ! 2376: #if ! HAVE_UNBLOCKED_WRITES ! 2377: if (q->fterminal && cdo > SINGLE_WRITE) ! 2378: cdo = SINGLE_WRITE; ! 2379: #endif ! 2380: ! 2381: if (q->istdout_flags >= 0) ! 2382: q->o = 1; ! 2383: ! 2384: /* Loop until we get something besides EINTR. */ ! 2385: while (TRUE) ! 2386: { ! 2387: /* If we've received a signal, don't continue. */ ! 2388: if (FGOT_QUIT_SIGNAL ()) ! 2389: return FALSE; ! 2390: ! 2391: #if HAVE_TLI ! 2392: if (q->ftli) ! 2393: { ! 2394: cdid = t_snd (q->o, zwrite, cdo, 0); ! 2395: if (cdid < 0) ! 2396: { ! 2397: if (t_errno == TFLOW) ! 2398: errno = EAGAIN; ! 2399: else if (t_errno != TSYSERR) ! 2400: { ! 2401: ulog (LOG_ERROR, "t_snd: %s", ! 2402: (t_errno >= 0 && t_errno < t_nerr ! 2403: ? t_errlist[t_errno] ! 2404: : "unknown TLI error")); ! 2405: return FALSE; ! 2406: } ! 2407: } ! 2408: } ! 2409: else ! 2410: #endif ! 2411: cdid = write (q->o, zwrite, cdo); ! 2412: ! 2413: if (cdid >= 0) ! 2414: break; ! 2415: if (errno != EINTR) ! 2416: break; ! 2417: ! 2418: /* We got interrupted by a signal. Log it. */ ! 2419: ulog (LOG_ERROR, (const char *) NULL); ! 2420: } ! 2421: ! 2422: if (cdid < 0) ! 2423: { ! 2424: if (errno != EAGAIN && errno != EWOULDBLOCK && errno != ENODATA) ! 2425: { ! 2426: ulog (LOG_ERROR, "write: %s", strerror (errno)); ! 2427: return FALSE; ! 2428: } ! 2429: cdid = 0; ! 2430: } ! 2431: ! 2432: if (cdid > 0) ! 2433: { ! 2434: /* We wrote some data. If we wrote everything, return out. ! 2435: Otherwise loop around and do another read. */ ! 2436: cwrite -= cdid; ! 2437: zwrite += cdid; ! 2438: *pcwrite += cdid; ! 2439: ! 2440: if (cwrite == 0) ! 2441: return TRUE; ! 2442: ! 2443: czero = 0; ! 2444: } ! 2445: else ! 2446: { ! 2447: /* We didn't write any data. Do a blocking write. */ ! 2448: ! 2449: if (q->istdout_flags >= 0) ! 2450: q->o = 0; ! 2451: ! 2452: if (! fsblock (q, TRUE)) ! 2453: return FALSE; ! 2454: ! 2455: cdo = cwrite; ! 2456: if (cdo > SINGLE_WRITE) ! 2457: cdo = SINGLE_WRITE; ! 2458: ! 2459: DEBUG_MESSAGE1 (DEBUG_PORT, ! 2460: "fsysdep_conn_io: Blocking write of %lud", ! 2461: (unsigned long) cdo); ! 2462: ! 2463: if (q->istdout_flags >= 0) ! 2464: q->o = 1; ! 2465: ! 2466: /* Loop until we get something besides EINTR. */ ! 2467: while (TRUE) ! 2468: { ! 2469: /* If we've received a signal, don't continue. */ ! 2470: if (FGOT_QUIT_SIGNAL ()) ! 2471: return FALSE; ! 2472: ! 2473: #if HAVE_TLI ! 2474: if (q->ftli) ! 2475: { ! 2476: cdid = t_snd (q->o, zwrite, cdo, 0); ! 2477: if (cdid < 0 && t_errno != TSYSERR) ! 2478: { ! 2479: ulog (LOG_ERROR, "t_snd: %s", ! 2480: (t_errno >= 0 && t_errno < t_nerr ! 2481: ? t_errlist[t_errno] ! 2482: : "unknown TLI error")); ! 2483: return FALSE; ! 2484: } ! 2485: } ! 2486: else ! 2487: #endif ! 2488: cdid = write (q->o, zwrite, cdo); ! 2489: ! 2490: if (cdid >= 0) ! 2491: break; ! 2492: if (errno != EINTR) ! 2493: break; ! 2494: ! 2495: /* We got interrupted by a signal. Log it. */ ! 2496: ulog (LOG_ERROR, (const char *) NULL); ! 2497: } ! 2498: ! 2499: if (cdid < 0) ! 2500: { ! 2501: ulog (LOG_ERROR, "write: %s", strerror (errno)); ! 2502: return FALSE; ! 2503: } ! 2504: ! 2505: if (cdid == 0) ! 2506: { ! 2507: /* On some systems write will return 0 if carrier is ! 2508: lost. If we fail to write anything ten times in a ! 2509: row, we assume that this has happened. This is ! 2510: hacked in like this because there seems to be no ! 2511: reliable way to tell exactly why the write returned ! 2512: 0. */ ! 2513: ++czero; ! 2514: if (czero >= 10) ! 2515: { ! 2516: ulog (LOG_ERROR, "Line disconnected"); ! 2517: return FALSE; ! 2518: } ! 2519: } ! 2520: else ! 2521: { ! 2522: cwrite -= cdid; ! 2523: zwrite += cdid; ! 2524: *pcwrite += cdid; ! 2525: czero = 0; ! 2526: } ! 2527: } ! 2528: } ! 2529: } ! 2530: ! 2531: /* Send a break character to a serial port. */ ! 2532: ! 2533: static boolean ! 2534: fsserial_break (qconn) ! 2535: struct sconnection *qconn; ! 2536: { ! 2537: struct ssysdep_conn *q; ! 2538: ! 2539: q = (struct ssysdep_conn *) qconn->psysdep; ! 2540: ! 2541: #if HAVE_BSD_TTY ! 2542: (void) ioctl (q->o, TIOCSBRK, 0); ! 2543: sleep (2); ! 2544: (void) ioctl (q->o, TIOCCBRK, 0); ! 2545: return TRUE; ! 2546: #endif /* HAVE_BSD_TTY */ ! 2547: #if HAVE_SYSV_TERMIO ! 2548: (void) ioctl (q->o, TCSBRK, 0); ! 2549: return TRUE; ! 2550: #endif /* HAVE_SYSV_TERMIO */ ! 2551: #if HAVE_POSIX_TERMIOS ! 2552: return tcsendbreak (q->o, 0) == 0; ! 2553: #endif /* HAVE_POSIX_TERMIOS */ ! 2554: } ! 2555: ! 2556: /* Send a break character to a stdin port. */ ! 2557: ! 2558: static boolean ! 2559: fsstdin_break (qconn) ! 2560: struct sconnection *qconn; ! 2561: { ! 2562: struct ssysdep_conn *qsysdep; ! 2563: ! 2564: qsysdep = (struct ssysdep_conn *) qconn->psysdep; ! 2565: qsysdep->o = 1; ! 2566: return fsserial_break (qconn); ! 2567: } ! 2568: ! 2569: /* Change the setting of a serial port. */ ! 2570: ! 2571: /*ARGSUSED*/ ! 2572: static boolean ! 2573: fsserial_set (qconn, tparity, tstrip, txonxoff) ! 2574: struct sconnection *qconn; ! 2575: enum tparitysetting tparity; ! 2576: enum tstripsetting tstrip; ! 2577: enum txonxoffsetting txonxoff; ! 2578: { ! 2579: register struct ssysdep_conn *q; ! 2580: boolean fchanged, fdo; ! 2581: int iset = 0; ! 2582: int iclear = 0; ! 2583: ! 2584: q = (struct ssysdep_conn *) qconn->psysdep; ! 2585: ! 2586: if (! q->fterminal) ! 2587: return TRUE; ! 2588: ! 2589: fchanged = FALSE; ! 2590: ! 2591: /* Set the parity for output characters. */ ! 2592: ! 2593: #if HAVE_BSD_TTY ! 2594: ! 2595: /* This will also cause parity detection on input characters. */ ! 2596: ! 2597: fdo = FALSE; ! 2598: switch (tparity) ! 2599: { ! 2600: case PARITYSETTING_DEFAULT: ! 2601: break; ! 2602: case PARITYSETTING_NONE: ! 2603: #if HAVE_PARITY_BUG ! 2604: /* The Sony NEWS mishandles this for some reason. */ ! 2605: iset = 0; ! 2606: iclear = ANYP; ! 2607: #else ! 2608: iset = ANYP; ! 2609: iclear = 0; ! 2610: #endif ! 2611: fdo = TRUE; ! 2612: break; ! 2613: case PARITYSETTING_EVEN: ! 2614: iset = EVENP; ! 2615: iclear = ODDP; ! 2616: fdo = TRUE; ! 2617: break; ! 2618: case PARITYSETTING_ODD: ! 2619: iset = ODDP; ! 2620: iclear = EVENP; ! 2621: fdo = TRUE; ! 2622: break; ! 2623: case PARITYSETTING_MARK: ! 2624: case PARITYSETTING_SPACE: ! 2625: /* Not supported. */ ! 2626: break; ! 2627: } ! 2628: ! 2629: if (fdo) ! 2630: { ! 2631: if ((q->snew.stty.sg_flags & iset) != iset ! 2632: || (q->snew.stty.sg_flags & iclear) != 0) ! 2633: { ! 2634: q->snew.stty.sg_flags |= iset; ! 2635: q->snew.stty.sg_flags &=~ iclear; ! 2636: fchanged = TRUE; ! 2637: } ! 2638: } ! 2639: ! 2640: #else /* ! HAVE_BSD_TTY */ ! 2641: ! 2642: fdo = FALSE; ! 2643: switch (tparity) ! 2644: { ! 2645: case PARITYSETTING_DEFAULT: ! 2646: break; ! 2647: case PARITYSETTING_NONE: ! 2648: iset = CS8; ! 2649: iclear = PARENB | PARODD | (CSIZE &~ CS8); ! 2650: fdo = TRUE; ! 2651: break; ! 2652: case PARITYSETTING_EVEN: ! 2653: iset = PARENB | CS7; ! 2654: iclear = PARODD | (CSIZE &~ CS7); ! 2655: fdo = TRUE; ! 2656: break; ! 2657: case PARITYSETTING_ODD: ! 2658: iset = PARENB | PARODD | CS7; ! 2659: iclear = CSIZE &~ CS7; ! 2660: fdo = TRUE; ! 2661: break; ! 2662: case PARITYSETTING_MARK: ! 2663: case PARITYSETTING_SPACE: ! 2664: /* Not supported. */ ! 2665: break; ! 2666: } ! 2667: ! 2668: if (fdo) ! 2669: { ! 2670: if ((q->snew.c_cflag & iset) != iset ! 2671: || (q->snew.c_cflag & iclear) != 0) ! 2672: { ! 2673: q->snew.c_cflag |= iset; ! 2674: q->snew.c_cflag &=~ iclear; ! 2675: fchanged = TRUE; ! 2676: } ! 2677: } ! 2678: ! 2679: #endif /* ! HAVE_BSD_TTY */ ! 2680: ! 2681: /* Set whether input characters are stripped to seven bits. */ ! 2682: ! 2683: #if HAVE_BSD_TTY ! 2684: ! 2685: #ifdef LPASS8 ! 2686: { ! 2687: int i; ! 2688: ! 2689: i = LPASS8; ! 2690: if (tstrip == STRIPSETTING_EIGHTBITS) ! 2691: { ! 2692: i = LPASS8; ! 2693: (void) ioctl (q->o, TIOCLBIS, &i); ! 2694: } ! 2695: else if (tstrip == STRIPSETTING_SEVENBITS) ! 2696: { ! 2697: i = LPASS8; ! 2698: (void) ioctl (q->o, TIOCLBIC, &i); ! 2699: } ! 2700: } ! 2701: #endif ! 2702: ! 2703: #else /* ! HAVE_BSD_TTY */ ! 2704: ! 2705: fdo = FALSE; ! 2706: switch (tstrip) ! 2707: { ! 2708: case STRIPSETTING_DEFAULT: ! 2709: break; ! 2710: case STRIPSETTING_EIGHTBITS: ! 2711: iset = 0; ! 2712: iclear = ISTRIP; ! 2713: fdo = TRUE; ! 2714: break; ! 2715: case STRIPSETTING_SEVENBITS: ! 2716: iset = ISTRIP; ! 2717: iclear = 0; ! 2718: fdo = TRUE; ! 2719: break; ! 2720: } ! 2721: ! 2722: if (fdo) ! 2723: { ! 2724: if ((q->snew.c_iflag & iset) != iset ! 2725: || (q->snew.c_iflag & iclear) != 0) ! 2726: { ! 2727: q->snew.c_iflag |= iset; ! 2728: q->snew.c_iflag &=~ iclear; ! 2729: fchanged = TRUE; ! 2730: } ! 2731: } ! 2732: ! 2733: #endif /* ! HAVE_BSD_TTY */ ! 2734: ! 2735: /* Set XON/XOFF handshaking. */ ! 2736: ! 2737: #if HAVE_BSD_TTY ! 2738: ! 2739: fdo = FALSE; ! 2740: switch (txonxoff) ! 2741: { ! 2742: case XONXOFF_DEFAULT: ! 2743: break; ! 2744: case XONXOFF_OFF: ! 2745: iset = RAW; ! 2746: iclear = TANDEM | CBREAK; ! 2747: fdo = TRUE; ! 2748: break; ! 2749: case XONXOFF_ON: ! 2750: iset = CBREAK | TANDEM; ! 2751: iclear = RAW; ! 2752: fdo = TRUE; ! 2753: break; ! 2754: } ! 2755: ! 2756: if (fdo) ! 2757: { ! 2758: if ((q->snew.stty.sg_flags & iset) != iset ! 2759: || (q->snew.stty.sg_flags & iclear) != 0) ! 2760: { ! 2761: q->snew.stty.sg_flags |= iset; ! 2762: q->snew.stty.sg_flags &=~ iclear; ! 2763: fchanged = TRUE; ! 2764: } ! 2765: } ! 2766: ! 2767: #else /* ! HAVE_BSD_TTY */ ! 2768: ! 2769: fdo = FALSE; ! 2770: switch (txonxoff) ! 2771: { ! 2772: case XONXOFF_DEFAULT: ! 2773: break; ! 2774: case XONXOFF_OFF: ! 2775: iset = 0; ! 2776: iclear = IXON | IXOFF; ! 2777: fdo = TRUE; ! 2778: break; ! 2779: case XONXOFF_ON: ! 2780: #ifdef CRTSCTS ! 2781: #if HAVE_POSIX_TERMIOS ! 2782: /* This is system dependent, but I haven't figured out a good ! 2783: way around it yet. If we are doing hardware flow control, we ! 2784: don't send XON/XOFF characters but we do recognize them. */ ! 2785: if ((q->snew.c_cflag & CRTSCTS) != 0) ! 2786: { ! 2787: iset = IXON; ! 2788: iclear = IXOFF; ! 2789: fdo = TRUE; ! 2790: break; ! 2791: } ! 2792: #endif /* HAVE_POSIX_TERMIOS */ ! 2793: #endif /* defined (CRTSCTS) */ ! 2794: iset = IXON | IXOFF; ! 2795: iclear = 0; ! 2796: fdo = TRUE; ! 2797: break; ! 2798: } ! 2799: ! 2800: if (fdo) ! 2801: { ! 2802: if ((q->snew.c_iflag & iset) != iset ! 2803: || (q->snew.c_iflag & iclear) != 0) ! 2804: { ! 2805: q->snew.c_iflag |= iset; ! 2806: q->snew.c_iflag &=~ iclear; ! 2807: fchanged = TRUE; ! 2808: } ! 2809: } ! 2810: ! 2811: #endif /* ! HAVE_BSD_TTY */ ! 2812: ! 2813: if (fchanged) ! 2814: { ! 2815: if (! fsetterminfodrain (q->o, &q->snew)) ! 2816: { ! 2817: ulog (LOG_ERROR, "Can't change terminal settings: %s", ! 2818: strerror (errno)); ! 2819: return FALSE; ! 2820: } ! 2821: } ! 2822: ! 2823: #if HAVE_BSD_TTY ! 2824: if (txonxoff == XONXOFF_ON ! 2825: && (q->snew.stty.sg_flags & ANYP) == ANYP) ! 2826: { ! 2827: int i; ! 2828: ! 2829: /* At least on Ultrix, we seem to have to set LLITOUT and ! 2830: LPASS8. This shouldn't foul things up anywhere else. As far ! 2831: as I can tell, this has to be done after setting the terminal ! 2832: into cbreak mode, not before. */ ! 2833: #ifndef LLITOUT ! 2834: #define LLITOUT 0 ! 2835: #endif ! 2836: #ifndef LPASS8 ! 2837: #define LPASS8 0 ! 2838: #endif ! 2839: #ifndef LAUTOFLOW ! 2840: #define LAUTOFLOW 0 ! 2841: #endif ! 2842: i = LLITOUT | LPASS8 | LAUTOFLOW; ! 2843: (void) ioctl (q->o, TIOCLBIS, &i); ! 2844: ! 2845: #if HAVE_STRIP_BUG ! 2846: /* Ultrix 4.0 has a peculiar problem: setting CBREAK always ! 2847: causes input characters to be stripped. I hope this does not ! 2848: apply to other BSD systems. It is possible to work around ! 2849: this by using the termio call. I wish this sort of stuff was ! 2850: not necessary!!! */ ! 2851: { ! 2852: struct termio s; ! 2853: ! 2854: if (ioctl (q->o, TCGETA, &s) >= 0) ! 2855: { ! 2856: s.c_iflag &=~ ISTRIP; ! 2857: (void) ioctl (q->o, TCSETA, &s); ! 2858: } ! 2859: } ! 2860: #endif /* HAVE_STRIP_BUG */ ! 2861: } ! 2862: #endif /* HAVE_BSD_TTY */ ! 2863: ! 2864: return TRUE; ! 2865: } ! 2866: ! 2867: /* Change settings of a stdin port. */ ! 2868: ! 2869: static boolean ! 2870: fsstdin_set (qconn, tparity, tstrip, txonxoff) ! 2871: struct sconnection *qconn; ! 2872: enum tparitysetting tparity; ! 2873: enum tstripsetting tstrip; ! 2874: enum txonxoffsetting txonxoff; ! 2875: { ! 2876: struct ssysdep_conn *qsysdep; ! 2877: ! 2878: qsysdep = (struct ssysdep_conn *) qconn->psysdep; ! 2879: qsysdep->o = 0; ! 2880: return fsserial_set (qconn, tparity, tstrip, txonxoff); ! 2881: } ! 2882: ! 2883: /* Run a chat program. */ ! 2884: ! 2885: static boolean ! 2886: fsrun_chat (oread, owrite, pzprog) ! 2887: int oread; ! 2888: int owrite; ! 2889: char **pzprog; ! 2890: { ! 2891: int aidescs[3]; ! 2892: FILE *e; ! 2893: pid_t ipid; ! 2894: char *z; ! 2895: size_t c; ! 2896: ! 2897: aidescs[0] = oread; ! 2898: aidescs[1] = owrite; ! 2899: aidescs[2] = SPAWN_READ_PIPE; ! 2900: ! 2901: /* Pass fkeepuid, fkeepenv and fshell as TRUE. This puts the ! 2902: responsibility of maintaing security on the chat program. */ ! 2903: ipid = ixsspawn ((const char **) pzprog, aidescs, TRUE, TRUE, ! 2904: (const char *) NULL, FALSE, TRUE, (const char *) NULL, ! 2905: (const char *) NULL, (const char *) NULL); ! 2906: if (ipid < 0) ! 2907: { ! 2908: ulog (LOG_ERROR, "ixsspawn (%s): %s", pzprog[0], strerror (errno)); ! 2909: return FALSE; ! 2910: } ! 2911: ! 2912: e = fdopen (aidescs[2], (char *) "r"); ! 2913: if (e == NULL) ! 2914: { ! 2915: ulog (LOG_ERROR, "fdopen: %s", strerror (errno)); ! 2916: (void) close (aidescs[2]); ! 2917: (void) kill (ipid, SIGKILL); ! 2918: (void) ixswait ((unsigned long) ipid, (const char *) NULL); ! 2919: return FALSE; ! 2920: } ! 2921: ! 2922: /* The FILE e now is attached to stderr of the program. Forward ! 2923: every line the program outputs to the log file. */ ! 2924: z = NULL; ! 2925: c = 0; ! 2926: while (getline (&z, &c, e) > 0) ! 2927: { ! 2928: size_t clen; ! 2929: ! 2930: clen = strlen (z); ! 2931: if (z[clen - 1] == '\n') ! 2932: z[clen - 1] = '\0'; ! 2933: if (*z != '\0') ! 2934: ulog (LOG_NORMAL, "chat: %s", z); ! 2935: } ! 2936: ! 2937: xfree ((pointer) z); ! 2938: (void) fclose (e); ! 2939: ! 2940: return ixswait ((unsigned long) ipid, "Chat program") == 0; ! 2941: } ! 2942: ! 2943: /* Run a chat program on a stdin port. */ ! 2944: ! 2945: /*ARGSUSED*/ ! 2946: static boolean ! 2947: fsstdin_chat (qconn, pzprog) ! 2948: struct sconnection *qconn; ! 2949: char **pzprog; ! 2950: { ! 2951: return fsrun_chat (0, 1, pzprog); ! 2952: } ! 2953: ! 2954: /* Run a chat program on any general type of connection. */ ! 2955: ! 2956: boolean ! 2957: fsysdep_conn_chat (qconn, pzprog) ! 2958: struct sconnection *qconn; ! 2959: char **pzprog; ! 2960: { ! 2961: struct ssysdep_conn *qsysdep; ! 2962: ! 2963: qsysdep = (struct ssysdep_conn *) qconn->psysdep; ! 2964: return fsrun_chat (qsysdep->o, qsysdep->o, pzprog); ! 2965: } ! 2966: ! 2967: /* Return baud rate of a serial port. */ ! 2968: ! 2969: static long ! 2970: isserial_baud (qconn) ! 2971: struct sconnection *qconn; ! 2972: { ! 2973: struct ssysdep_conn *qsysdep; ! 2974: ! 2975: qsysdep = (struct ssysdep_conn *) qconn->psysdep; ! 2976: return qsysdep->ibaud; ! 2977: }
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.