![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to ckutio.c CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [MW Coherent from dump] / coherent / e / bin / ckermit|
Return to ckutio.c CVS log | Up to [MW Coherent from dump] / coherent / e / bin / ckermit |
1.1 ! root 1: char *ckxv = "UNIX Communications support, 5A(0102), 23 Nov 92"; ! 2: ! 3: /* C K U T I O */ ! 4: ! 5: /* C-Kermit interrupt, terminal control & i/o functions for UNIX */ ! 6: ! 7: /* ! 8: Author: Frank da Cruz ([email protected], [email protected]), ! 9: Columbia University Center for Computing Activities. ! 10: First released January 1985. ! 11: Copyright (C) 1985, 1992, Trustees of Columbia University in the City of New ! 12: York. Permission is granted to any individual or institution to use this ! 13: software as long as it is not sold for profit. This copyright notice must be ! 14: retained. This software may not be included in commercial products without ! 15: written permission of Columbia University. ! 16: */ ! 17: ! 18: /* Includes */ ! 19: ! 20: #include "ckcdeb.h" /* This moved to here. */ ! 21: #include <errno.h> /* System error numbers */ ! 22: #ifdef __386BSD__ ! 23: #define ENOTCONN 57 ! 24: #endif /* __386BSD__ */ ! 25: ! 26: #include "ckcnet.h" /* Symbols for network types. */ ! 27: ! 28: /* ! 29: The directory-related includes are here because we need to test some ! 30: file-system-related symbols to find out which system we're being compiled ! 31: under. For example, MAXNAMLEN is defined in BSD4.2 but not 4.1. ! 32: */ ! 33: #ifdef SDIRENT /* Directory bits... */ ! 34: #define DIRENT ! 35: #endif /* SDIRENT */ ! 36: ! 37: #ifdef XNDIR ! 38: #include <sys/ndir.h> ! 39: #else /* !XNDIR */ ! 40: #ifdef NDIR ! 41: #include <ndir.h> ! 42: #else /* !NDIR, !XNDIR */ ! 43: #ifdef RTU ! 44: #include "/usr/lib/ndir.h" ! 45: #else /* !RTU, !NDIR, !XNDIR */ ! 46: #ifdef DIRENT ! 47: #ifdef SDIRENT ! 48: #include <sys/dirent.h> ! 49: #else ! 50: #include <dirent.h> ! 51: #endif /* SDIRENT */ ! 52: #else /* !RTU, !NDIR, !XNDIR, !DIRENT, i.e. all others */ ! 53: #include <sys/dir.h> ! 54: #endif /* DIRENT */ ! 55: #endif /* RTU */ ! 56: #endif /* NDIR */ ! 57: #endif /* XNDIR */ ! 58: ! 59: /* Definition of HZ, used in msleep() */ ! 60: ! 61: #ifdef MIPS ! 62: #define HZ ( 1000 / CLOCK_TICK ) ! 63: #else ! 64: #ifdef ATTSV ! 65: #ifndef NAP ! 66: #ifndef TRS16 ! 67: #include <sys/param.h> ! 68: #else ! 69: #define HZ ( 1000 / CLOCK_TICK ) ! 70: #endif /* TRS16 */ ! 71: #ifdef NAPHACK ! 72: #define nap(x) (void)syscall(3112, (x)) ! 73: #define NAP ! 74: #endif /* NAPHACK */ ! 75: #endif /* NAP */ ! 76: #endif /* ATTSV */ ! 77: #endif /* MIPS */ ! 78: ! 79: #ifdef M_UNIX ! 80: #undef NGROUPS_MAX /* Prevent multiple definition warnings */ ! 81: #endif /* M_UNIX */ ! 82: ! 83: #include <signal.h> /* Signals */ ! 84: ! 85: /* For setjmp and longjmp */ ! 86: ! 87: #ifndef ZILOG ! 88: #include <setjmp.h> ! 89: #else ! 90: #include <setret.h> ! 91: #endif /* ZILOG */ ! 92: ! 93: /* Maximum length for the name of a tty device */ ! 94: ! 95: #ifndef DEVNAMLEN ! 96: #define DEVNAMLEN 25 ! 97: #endif ! 98: ! 99: #ifdef NETCONN ! 100: #undef DEVNAMLEN ! 101: #define DEVNAMLEN 50 /* longer field for host:service */ ! 102: #endif /* NETCONN */ ! 103: ! 104: /* ! 105: The following test differentiates between 4.1 BSD and 4.2 & later. ! 106: If you have a 4.1BSD system with the DIRENT library, this test could ! 107: mistakenly diagnose 4.2BSD and then later enable the use of system calls ! 108: that aren't defined. If indeed there are such systems, we can use some ! 109: other way of testing for 4.1BSD, or add yet another compile-time switch. ! 110: */ ! 111: #ifdef BSD4 ! 112: #ifdef MAXNAMLEN ! 113: #ifndef FT21 ! 114: #ifndef FT18 /* Except for Fortune. */ ! 115: #define BSD42 ! 116: #endif /* FT18 */ ! 117: #endif /* FT21 */ ! 118: #endif /* MAXNAMLEN */ ! 119: #endif /* BSD4 */ ! 120: /* ! 121: Minix support added by Charles Hedrick, ! 122: Rutgers University: [email protected] ! 123: Minix also has V7 enabled. ! 124: */ ! 125: #ifdef MINIX ! 126: #define TANDEM 0 ! 127: #define MYREAD ! 128: #include <limits.h> ! 129: #endif /* MINIX */ ! 130: ! 131: #include "ckuver.h" /* Version herald */ ! 132: char *ckxsys = HERALD; ! 133: ! 134: /* UUCP lock file name definition */ ! 135: ! 136: #ifndef NOUUCP ! 137: ! 138: /* Name of UUCP tty device lock file */ ! 139: ! 140: #ifdef ACUCNTRL ! 141: #define LCKDIR ! 142: #endif /* ACUCNTRL */ ! 143: /* ! 144: LOCK_DIR is the name of the lockfile directory. ! 145: If LOCK_DIR is already defined (e.g. on command line), we don't change it. ! 146: PIDSTRING means use ASCII string to represent pid in lockfile. ! 147: */ ! 148: #ifndef LOCK_DIR ! 149: #ifdef BSD44 ! 150: #define LOCK_DIR "/var/spool/uucp"; ! 151: #else ! 152: #ifdef DGUX430 ! 153: #define LOCK_DIR "/var/spool/locks"; ! 154: #else ! 155: #ifdef RTAIX /* IBM RT PC AIX 2.2.1 */ ! 156: #define PIDSTRING ! 157: #define LOCK_DIR "/etc/locks"; ! 158: #else ! 159: #ifdef AIXRS ! 160: #define PIDSTRING ! 161: #define LOCK_DIR "/etc/locks"; ! 162: #else ! 163: #ifdef ISIII ! 164: #define LOCK_DIR "/etc/locks"; ! 165: #else ! 166: #ifdef HDBUUCP ! 167: #define PIDSTRING ! 168: #ifdef M_SYS5 /* wht@n4hgf - SCO */ ! 169: #define LOCK_DIR "/usr/spool/uucp"; ! 170: #else ! 171: #ifdef M_UNIX ! 172: #define LOCK_DIR "/usr/spool/uucp"; ! 173: #else ! 174: #ifdef SVR4 ! 175: #define LOCK_DIR "/var/spool/locks"; ! 176: #ifndef LOCKF ! 177: #define LOCKF /* Use lockf() too in SVR4 */ ! 178: #endif /* LOCKF */ ! 179: #else ! 180: #ifdef SUNOS4 ! 181: #define LOCK_DIR "/var/spool/locks"; ! 182: #else ! 183: #define LOCK_DIR "/usr/spool/locks"; ! 184: #endif /* SUNOS4 */ ! 185: #endif /* SVR4 */ ! 186: #endif /* M_UNIX */ ! 187: #endif /* M_SYS5 */ ! 188: #else ! 189: #ifdef LCKDIR ! 190: #define LOCK_DIR "/usr/spool/uucp/LCK"; ! 191: #else ! 192: #define LOCK_DIR "/usr/spool/uucp"; ! 193: #endif /* LCKDIR */ ! 194: #endif /* HDBUUCP */ ! 195: #endif /* ISIII */ ! 196: #endif /* AIXRS */ ! 197: #endif /* RTAIX */ ! 198: #endif /* DGUX430 */ ! 199: #endif /* BSD44 */ ! 200: #endif /* !LOCK_DIR (outside ifndef) */ ! 201: ! 202: #endif /* !NOUUCP */ ! 203: ! 204: #ifdef ATTSV ! 205: #define MYREAD ! 206: #endif /* ATTSV */ ! 207: ! 208: #ifdef ATT7300 ! 209: #ifndef MYREAD ! 210: #define MYREAD ! 211: #endif /* MYREAD */ ! 212: /* bits for attmodem: internal modem in use, restart getty */ ! 213: #define ISMODEM 1 ! 214: #define DOGETY 512 ! 215: #endif /* ATT7300 */ ! 216: ! 217: #ifdef BSD42 ! 218: #define MYREAD ! 219: #endif /* BSD42 */ ! 220: ! 221: #ifdef POSIX ! 222: #define MYREAD ! 223: #endif /* POSIX */ ! 224: ! 225: /* ! 226: Variables available to outside world: ! 227: ! 228: dftty -- Pointer to default tty name string, like "/dev/tty". ! 229: dfloc -- 0 if dftty is console, 1 if external line. ! 230: dfprty -- Default parity ! 231: dfflow -- Default flow control ! 232: ckxech -- Flag for who echoes console typein: ! 233: 1 - The program (system echo is turned off) ! 234: 0 - The system (or front end, or terminal). ! 235: functions that want to do their own echoing should check this flag ! 236: before doing so. ! 237: ! 238: flfnam -- Name of lock file, including its path, e.g., ! 239: "/usr/spool/uucp/LCK..cul0" or "/etc/locks/tty77" ! 240: lkflfn -- Name of link to lock file, including its paths ! 241: haslock -- Flag set if this kermit established a uucp lock. ! 242: backgrd -- Flag indicating program executing in background ( & on ! 243: end of shell command). Used to ignore INT and QUIT signals. ! 244: rtu_bug -- Set by stptrap(). RTU treats ^Z as EOF (but only when we handle ! 245: SIGTSTP) ! 246: ! 247: Functions for assigned communication line (either external or console tty): ! 248: ! 249: sysinit() -- System dependent program initialization ! 250: syscleanup() -- System dependent program shutdown ! 251: ttopen(ttname,local,mdmtyp,timo) -- Open the named tty for exclusive access. ! 252: ttclos() -- Close & reset the tty, releasing any access lock. ! 253: ttsspd(cps) -- Set the transmission speed of the tty. ! 254: ttgspd() -- Get (read) the the transmission speed of the tty. ! 255: ttpkt(speed,flow,parity) -- Put the tty in packet mode and set the speed. ! 256: ttvt(speed,flow) -- Put the tty in virtual terminal mode. ! 257: or in DIALING or CONNECTED modem control state. ! 258: ttres() -- Restore original tty modes. ! 259: ttscarr(carrier) -- Set carrier control mode, on/off/auto. ! 260: ttinl(dest,max,timo) -- Timed read line from the tty. ! 261: ttinc(timo) -- Timed read character from tty. ! 262: myread() -- Raw mode bulk buffer read, gives subsequent ! 263: chars one at a time and simulates FIONREAD. ! 264: myunrd(c) -- Places c back in buffer to be read (one only) ! 265: ttchk() -- See how many characters in tty input buffer. ! 266: ttxin(n,buf) -- Read n characters from tty (untimed). ! 267: ttol(string,length) -- Write a string to the tty. ! 268: ttoc(c) -- Write a character to the tty. ! 269: ttflui() -- Flush tty input buffer. ! 270: ttsndb() -- Send BREAK signal. ! 271: ttsndlb() -- Send Long BREAK signal. ! 272: ! 273: ttlock(ttname) -- "Lock" tty device against uucp collisions. ! 274: ttunlck() -- Unlock tty device. ! 275: ! 276: For ATT7300/Unix PC, System V: ! 277: attdial(ttname,speed,telnbr) -- dials ATT7300/Unix PC internal modem ! 278: offgetty(ttname) -- Turns off getty(1m) for comms line ! 279: ongetty(ttname) -- Restores getty() to comms line ! 280: */ ! 281: ! 282: /* ! 283: Functions for console terminal: ! 284: ! 285: congm() -- Get console terminal modes. ! 286: concb(esc) -- Put the console in single-character wakeup mode with no echo. ! 287: conbin(esc) -- Put the console in binary (raw) mode. ! 288: conres() -- Restore the console to mode obtained by congm(). ! 289: conoc(c) -- Unbuffered output, one character to console. ! 290: conol(s) -- Unbuffered output, null-terminated string to the console. ! 291: conola(s) -- Unbuffered output, array of strings to the console. ! 292: conxo(n,s) -- Unbuffered output, n characters to the console. ! 293: conchk() -- Check if characters available at console (bsd 4.2). ! 294: Check if escape char (^\) typed at console (System III/V). ! 295: coninc(timo) -- Timed get a character from the console. ! 296: congks(timo) -- Timed get keyboard scan code. ! 297: conint() -- Enable terminal interrupts on the console if not background. ! 298: connoi() -- Disable terminal interrupts on the console if not background. ! 299: ! 300: Time functions ! 301: ! 302: msleep(m) -- Millisecond sleep ! 303: ztime(&s) -- Return pointer to date/time string ! 304: rtimer() -- Reset timer ! 305: gtimer() -- Get elapsed time since last call to rtimer() ! 306: */ ! 307: ! 308: /* Conditional Includes */ ! 309: ! 310: /* Whether to include <sys/file.h> */ ! 311: ! 312: #ifdef RTU /* RTU doesn't */ ! 313: #define NOFILEH ! 314: #endif /* RTU */ ! 315: ! 316: #ifdef CIE /* CIE does. */ ! 317: #undef NOFILEH ! 318: #endif /* CIE */ ! 319: ! 320: #ifdef BSD41 /* 4.1 BSD doesn't */ ! 321: #define NOFILEH ! 322: #endif /* BSD41 */ ! 323: ! 324: #ifdef is68k /* is68k (whatever that is) */ ! 325: #define NOFILEH ! 326: #endif /* is68k */ ! 327: ! 328: #ifdef MINIX /* MINIX */ ! 329: #define NOFILEH ! 330: #endif /* MINIX */ ! 331: ! 332: #ifdef COHERENT /* Coherent */ ! 333: #define NOFILEH ! 334: #endif /* COHERENT */ ! 335: ! 336: #ifndef NOFILEH /* Now include if selected. */ ! 337: #include <sys/file.h> ! 338: #endif /* NOFILEH */ ! 339: ! 340: /* POSIX */ ! 341: ! 342: #ifdef BSD44ORPOSIX /* POSIX uses termios.h */ ! 343: #define TERMIOS ! 344: #ifdef bsdi ! 345: #ifndef NCCS ! 346: #define NCCS 20 ! 347: #endif /* NCCS */ ! 348: #endif /* bsdi */ ! 349: #include <termios.h> ! 350: #ifndef BSD44 /* Really POSIX */ ! 351: #define NOSYSIOCTLH /* No ioctl's allowed. */ ! 352: #undef ultrix /* Turn off any ultrix features. */ ! 353: #endif /* BSD44 */ ! 354: #endif /* POSIX */ ! 355: ! 356: /* System III, System V */ ! 357: ! 358: #ifdef ATTSV ! 359: #ifndef BSD44 ! 360: #include <termio.h> ! 361: #endif /* BSD44 */ ! 362: #ifdef SVR4 /* Sys V R4 and later */ ! 363: #ifdef TERMIOX ! 364: /* Need this for termiox structure, RTS/CTS and DTR/CD flow control */ ! 365: #include <termiox.h> ! 366: struct termiox rctsx; ! 367: #else ! 368: #ifdef STERMIOX ! 369: #include <sys/termiox.h> ! 370: struct termiox rctsx; ! 371: #endif /* STERMIOX */ ! 372: #endif /* TERMIOX */ ! 373: #endif /* SVR4 */ ! 374: #endif /* ATTSV */ ! 375: ! 376: #ifdef MINIX /* MINIX uses ioctl's */ ! 377: #define NOSYSIOCTLH /* but has no <sys/ioctl.h> */ ! 378: #endif /* MINIX */ ! 379: ! 380: /* Others */ ! 381: ! 382: #ifndef NOSYSIOCTLH /* Others use ioctl() */ ! 383: #ifdef SUN4S5 ! 384: /* ! 385: This is to get rid of cpp warning messages that occur because all of ! 386: these symbols are defined by both termios.h and ioctl.h on the SUN. ! 387: */ ! 388: #undef ECHO ! 389: #undef NL0 ! 390: #undef NL1 ! 391: #undef TAB0 ! 392: #undef TAB1 ! 393: #undef TAB2 ! 394: #undef XTABS ! 395: #undef CR0 ! 396: #undef CR1 ! 397: #undef CR2 ! 398: #undef CR3 ! 399: #undef FF0 ! 400: #undef FF1 ! 401: #undef BS0 ! 402: #undef BS1 ! 403: #undef TOSTOP ! 404: #undef FLUSHO ! 405: #undef PENDIN ! 406: #undef NOFLSH ! 407: #endif /* SUN4S5 */ ! 408: #include <sys/ioctl.h> ! 409: #endif /* NOSYSIOCTLH */ ! 410: ! 411: /* Whether to include <fcntl.h> */ ! 412: ! 413: #ifndef is68k /* Only a few don't have this one. */ ! 414: #ifndef BSD41 ! 415: #ifndef FT21 ! 416: #ifndef FT18 ! 417: #include <fcntl.h> ! 418: #endif /* FT18 */ ! 419: #endif /* FT21 */ ! 420: #endif /* BSD41 */ ! 421: #endif /* not is68k */ ! 422: ! 423: #ifdef ATT7300 /* Unix PC, internal modem dialer */ ! 424: #include <sys/phone.h> ! 425: #endif /* ATT7300 */ ! 426: ! 427: #ifdef HPUX /* HP-UX variations. */ ! 428: #define HPUXJOBCTL ! 429: #include <sys/modem.h> /* HP-UX modem signals */ ! 430: #ifdef hp9000s500 /* Model 500 */ ! 431: #undef HPUXJOBCTL ! 432: #endif /* hp9000s500 */ ! 433: #ifdef HPUXPRE65 ! 434: #undef HPUXJOBCTL ! 435: typedef int mflag; ! 436: #endif /* HPUXPRE65 */ ! 437: #ifdef HPUXJOBCTL ! 438: #include <sys/bsdtty.h> /* HP-UX Berkeley tty support */ ! 439: #endif /* HPUXJOBCTL */ ! 440: #endif /* HPUX */ ! 441: ! 442: /* BSD, V7, Coherent, Minix, et al. */ ! 443: ! 444: #ifdef SVORPOSIX /* Sys V or POSIX */ ! 445: #ifdef BSD44 ! 446: #include <sys/time.h> ! 447: #endif /* BSD44 */ ! 448: #ifdef AIXRS ! 449: #include <sys/time.h> ! 450: #endif /* AIXRS */ ! 451: #ifdef NOIEXTEN /* This is broken on some systems */ ! 452: #undef IEXTEN /* like Convex/OS 9.1 */ ! 453: #endif /* NOIEXTEN */ ! 454: #ifndef IEXTEN /* Turn off ^O/^V processing. */ ! 455: #define IEXTEN 0 /* Needed, at least, on BSDI. */ ! 456: #endif /* IEXTEN */ ! 457: #else /* Not AT&T Sys V or POSIX */ ! 458: #include <sgtty.h> /* So we use <sgtty.h> */ ! 459: #ifndef PROVX1 /* Now <sys/time.h> ... */ ! 460: #ifndef V7 ! 461: #ifndef BSD41 ! 462: #ifndef COHERENT ! 463: #include <sys/time.h> /* Clock info (for break generation) */ ! 464: #endif /* COHERENT */ ! 465: #endif /* BSD41 */ ! 466: #endif /* V7 */ ! 467: #endif /* PROVX1 */ ! 468: #endif /* SVORPOSIX */ ! 469: ! 470: #ifdef OSF /* DEC OSF/1 1.0 */ ! 471: #include <sys/timeb.h> ! 472: #endif /* OSF */ ! 473: ! 474: #ifdef BSD41 /* BSD 4.1 */ ! 475: #include <sys/timeb.h> ! 476: #endif /* BSD41 */ ! 477: ! 478: #ifdef FT21 /* For:Pro 2.1 */ ! 479: #include <sys/timeb.h> ! 480: #endif /* FT21 */ ! 481: ! 482: #ifdef BSD29 /* BSD 2.9 */ ! 483: #include <sys/timeb.h> ! 484: #endif /* BSD29 */ ! 485: ! 486: #ifdef TOWER1 ! 487: #include <sys/timeb.h> /* Clock info for NCR Tower */ ! 488: #endif /* TOWER1 */ ! 489: ! 490: #ifdef COHERENT ! 491: #include <sys/timeb.h> /* Clock info for NCR Tower */ ! 492: #endif /* COHERENT */ ! 493: ! 494: #ifdef aegis ! 495: #include "/sys/ins/base.ins.c" ! 496: #include "/sys/ins/error.ins.c" ! 497: #include "/sys/ins/ios.ins.c" ! 498: #include "/sys/ins/sio.ins.c" ! 499: #include "/sys/ins/pad.ins.c" ! 500: #include "/sys/ins/time.ins.c" ! 501: #include "/sys/ins/pfm.ins.c" ! 502: #include "/sys/ins/pgm.ins.c" ! 503: #include "/sys/ins/ec2.ins.c" ! 504: #include "/sys/ins/type_uids.ins.c" ! 505: #include <default_acl.h> ! 506: #undef TIOCEXCL ! 507: #undef FIONREAD ! 508: #endif /* aegis */ ! 509: ! 510: #ifdef sxaE50 /* PFU Compact A SX/A TISP V10/L50 */ ! 511: #undef FIONREAD ! 512: #endif /* sxaE50 */ ! 513: ! 514: /* The following #defines are catch-alls for those systems */ ! 515: /* that didn't have or couldn't find <file.h>... */ ! 516: ! 517: #ifndef FREAD ! 518: #define FREAD 0x01 ! 519: #endif /* FREAD */ ! 520: ! 521: #ifndef FWRITE ! 522: #define FWRITE 0x10 ! 523: #endif /* FWRITE */ ! 524: ! 525: #ifndef O_RDONLY ! 526: #define O_RDONLY 000 ! 527: #endif /* O_RDONLY */ ! 528: ! 529: /* Declarations */ ! 530: ! 531: #ifdef _POSIX_SOURCE /* This includes MINIX */ ! 532: #ifndef AIXRS ! 533: #include <time.h> ! 534: #endif /* AIXRS */ ! 535: #ifdef __GNUC__ ! 536: #ifdef XENIX ! 537: /* ! 538: Because Xenix <time.h> doesn't declare time() if we're using gcc. ! 539: */ ! 540: time_t time(); ! 541: #endif /* XENIX */ ! 542: #endif /* __GNUC__ */ ! 543: #else ! 544: time_t time(); /* All Unixes should have this... */ ! 545: #endif /* _POSIX_SOURCE */ ! 546: ! 547: /* Special stuff for V7 input buffer peeking */ ! 548: ! 549: #ifdef V7 ! 550: int kmem[2] = { -1, -1}; ! 551: char *initrawq(), *qaddr[2]={0,0}; ! 552: #define CON 0 ! 553: #define TTY 1 ! 554: #endif /* V7 */ ! 555: ! 556: /* dftty is the device name of the default device for file transfer */ ! 557: /* dfloc is 0 if dftty is the user's console terminal, 1 if an external line */ ! 558: ! 559: #ifndef DFTTY ! 560: #ifdef PROVX1 ! 561: char *dftty = "/dev/com1.dout"; /* Only example so far of a system */ ! 562: char *dfmdm = "none"; ! 563: int dfloc = 1; /* that goes in local mode by default */ ! 564: #else ! 565: char *dftty = CTTNAM; /* Remote by default, use normal */ ! 566: char *dfmdm = "none"; ! 567: int dfloc = 0; /* controlling terminal name. */ ! 568: #endif /* PROVX1 */ ! 569: #else ! 570: char *dftty = DFTTY; /* Default location specified on */ ! 571: char *dfmdm = "none"; /* command line. */ ! 572: int dfloc = 1; /* controlling terminal name. */ ! 573: #endif /* DFTTY */ ! 574: ! 575: #ifdef RTU ! 576: int rtu_bug = 0; /* set to 1 when returning from SIGTSTP */ ! 577: #endif /* RTU */ ! 578: ! 579: int dfprty = 0; /* Default parity (0 = none) */ ! 580: int ttprty = 0; /* The parity that is in use. */ ! 581: int ttpflg = 0; /* Parity not sensed yet. */ ! 582: static int ttpmsk = 0377; /* Parity stripping mask. */ ! 583: int ttmdm = 0; /* Modem in use. */ ! 584: int ttcarr = CAR_AUT; /* Carrier handling mode. */ ! 585: int dfflow = FLO_XONX; /* Default is Xon/Xoff */ ! 586: int backgrd = 0; /* Assume in foreground (no '&' ) */ ! 587: #ifdef ultrix ! 588: int iniflags = 0; /* fcntl flags for ttyfd */ ! 589: #endif /* ultrix */ ! 590: int fdflag = 0; /* Flag for redirected stdio */ ! 591: int ttfdflg = 0; /* Open File descriptor was given */ ! 592: int tvtflg = 0; /* Flag that ttvt has been called */ ! 593: long ttspeed = -1; /* For saving speed */ ! 594: int ttflow = -9; /* For saving flow */ ! 595: int ttld = -1; /* Line discipline */ ! 596: ! 597: #ifdef sony_news ! 598: static int km_con = -1; /* Kanji mode for console tty */ ! 599: static int km_ext = -1; /* Kanji mode for external device */ ! 600: #endif /* sony_news */ ! 601: ! 602: extern int ttnproto; /* Defined in ckcnet.c */ ! 603: extern int ttnet; /* Defined in ckcnet.c */ ! 604: ! 605: int ckxech = 0; /* 0 if system normally echoes console characters, else 1 */ ! 606: ! 607: /* Declarations of variables global within this module */ ! 608: ! 609: static time_t tcount; /* Elapsed time counter */ ! 610: static SIGTYP (*saval)() = NULL; /* For saving alarm() handler */ ! 611: ! 612: /* ! 613: BREAKNULS is defined for systems that simulate sending a BREAK signal ! 614: by sending a bunch of NUL characters at low speed. ! 615: */ ! 616: #ifdef PROVX1 ! 617: #ifndef BREAKNULS ! 618: #define BREAKNULS ! 619: #endif /* BREAKNULS */ ! 620: #endif /* PROVX1 */ ! 621: ! 622: #ifdef V7 ! 623: #ifndef BREAKNULS ! 624: #define BREAKNULS ! 625: #endif /* BREAKNULS */ ! 626: #endif /* V7 */ ! 627: ! 628: #ifdef BREAKNULS ! 629: static char /* A string of nulls */ ! 630: *brnuls = "\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0"; ! 631: #endif /* BREAKNULS */ ! 632: ! 633: static jmp_buf sjbuf; /* Longjump buffers */ ! 634: #ifdef V7 ! 635: static jmp_buf jjbuf; ! 636: #endif /* V7 */ ! 637: ! 638: /* static */ /* (Not static any more) */ ! 639: int ttyfd = -1; /* TTY file descriptor */ ! 640: ! 641: int telnetfd = 0; /* File descriptor is for telnet */ ! 642: int x25fd = 0; /* File descriptor is for X.25 */ ! 643: ! 644: static int lkf = 0, /* Line lock flag */ ! 645: cgmf = 0, /* Flag that console modes saved */ ! 646: xlocal = 0, /* Flag for tty local or remote */ ! 647: curcarr = 0; /* Carrier mode: require/ignore. */ ! 648: ! 649: static int netconn = 0; /* 1 if network connection active */ ! 650: ! 651: static char escchr; /* Escape or attn character */ ! 652: ! 653: #ifdef AIXRS ! 654: static struct timeval tv; /* For getting time, from sys/time.h */ ! 655: static struct timezone tz; ! 656: #else ! 657: #ifdef BSD44 ! 658: static struct timeval tv; /* For getting time, from sys/time.h */ ! 659: static struct timezone tz; ! 660: #else ! 661: #ifdef BSD42 ! 662: static struct timeval tv; /* For getting time, from sys/time.h */ ! 663: static struct timezone tz; ! 664: #ifdef OSF ! 665: static struct timeb ftp; /* And from sys/timeb.h */ ! 666: #endif /* OSF */ ! 667: #endif /* BSD42 */ ! 668: #endif /* BSD44 */ ! 669: #endif /* AIXRS */ ! 670: ! 671: #ifdef BSD29 ! 672: static long xclock; /* For getting time from sys/time.h */ ! 673: static struct timeb ftp; /* And from sys/timeb.h */ ! 674: #endif /* BSD29 */ ! 675: ! 676: #ifdef BSD41 ! 677: static long xclock; /* For getting time from sys/time.h */ ! 678: static struct timeb ftp; /* And from sys/timeb.h */ ! 679: #endif /* BSD41 */ ! 680: ! 681: #ifdef FT21 ! 682: static long xclock; /* For getting time from sys/time.h */ ! 683: static struct timeb ftp; /* And from sys/timeb.h */ ! 684: #endif /* FT21 */ ! 685: ! 686: #ifdef TOWER1 ! 687: static long xclock; /* For getting time from sys/time.h */ ! 688: static struct timeb ftp; /* And from sys/timeb.h */ ! 689: #endif /* TOWER1 */ ! 690: ! 691: #ifdef COHERENT ! 692: static long xclock; /* For getting time from sys/time.h */ ! 693: static struct timeb ftp; /* And from sys/timeb.h */ ! 694: #endif /* COHERENT */ ! 695: ! 696: #ifdef V7 ! 697: static long xclock; ! 698: #endif /* V7 */ ! 699: ! 700: /* sgtty/termio information... */ ! 701: ! 702: #ifdef BSD44ORPOSIX /* POSIX or BSD44 */ ! 703: static struct termios ! 704: ttold, ttraw, tttvt, ttcur, ! 705: ccold, ccraw, cccbrk; ! 706: #else /* BSD, V7, etc */ ! 707: #ifdef ATTSV ! 708: static struct termio ttold = {0}; /* Init'd for word alignment, */ ! 709: static struct termio ttraw = {0}; /* which is important for some */ ! 710: static struct termio tttvt = {0}; /* systems, like Zilog... */ ! 711: static struct termio ttcur = {0}; ! 712: static struct termio ccold = {0}; ! 713: static struct termio ccraw = {0}; ! 714: static struct termio cccbrk = {0}; ! 715: #else ! 716: static struct sgttyb /* sgtty info... */ ! 717: ttold, ttraw, tttvt, ttcur, /* for communication line */ ! 718: ccold, ccraw, cccbrk; /* and for console */ ! 719: #ifdef TIOCGETC ! 720: #ifdef MINIX ! 721: static struct sgttyb tchold, tchnoi; /* Special chars */ ! 722: #else ! 723: static struct tchars tchold, tchnoi; ! 724: #endif /* MINIX */ ! 725: static int tcharf; ! 726: #endif /* TIOCGETC */ ! 727: #ifdef TIOCGLTC ! 728: #ifdef MINIX ! 729: static struct sgttyb ltchold, ltchnoi; ! 730: #else ! 731: static struct ltchars ltchold, ltchnoi; ! 732: #endif /* MINIX */ ! 733: static int ltcharf; ! 734: #endif /* TIOCGLTC */ ! 735: int lmodef = 0; /* Local modes */ ! 736: int lmode = 0; ! 737: #endif /* ATTSV */ ! 738: #endif /* BSD44ORPOSIX */ ! 739: ! 740: #ifdef PROVX1 ! 741: static struct sgttyb ttbuf; ! 742: #endif /* PROVX1 */ ! 743: ! 744: #ifdef ultrix ! 745: /* do we really need this? */ ! 746: static struct sgttyb vanilla; ! 747: #endif /* ultrix */ ! 748: ! 749: #ifdef ATT7300 ! 750: static int attmodem = 0; /* ATT7300 internal-modem status */ ! 751: struct updata dialer = {0}; /* Condition dialer for data call */ ! 752: #endif /* ATT7300 */ ! 753: ! 754: char flfnam[80]; /* uucp lock file path name */ ! 755: #ifdef RTAIX ! 756: char lkflfn[80]; /* and possible link to it */ ! 757: #endif /* RTAIX */ ! 758: int haslock = 0; /* =1 if this kermit locked uucp */ ! 759: ! 760: #ifdef SVORPOSIX ! 761: static int conesc = 0; /* set to 1 if esc char (^\) typed */ ! 762: #else ! 763: #ifdef V7 ! 764: static int conesc = 0; ! 765: #else ! 766: #ifdef C70 ! 767: static int conesc = 0; ! 768: #endif /* C70 */ ! 769: #endif /* V7 */ ! 770: #endif /* ATTSV */ ! 771: ! 772: static char ttnmsv[DEVNAMLEN]; /* Copy of open path for tthang */ ! 773: ! 774: #ifdef aegis ! 775: static status_$t st; /* error status return value */ ! 776: static short concrp = 0; /* true if console is CRP pad */ ! 777: #define CONBUFSIZ 10 ! 778: static char conbuf[CONBUFSIZ]; /* console readahead buffer */ ! 779: static int conbufn = 0; /* # chars in readahead buffer */ ! 780: static char *conbufp; /* next char in readahead buffer */ ! 781: static uid_$t ttyuid; /* tty type uid */ ! 782: static uid_$t conuid; /* stdout type uid */ ! 783: ! 784: /* APOLLO Aegis main() ! 785: * establish acl usage and cleanup handling ! 786: * this makes sure that CRP pads ! 787: * get restored to a usable mode ! 788: */ ! 789: main(argc,argv) int argc; char **argv; { ! 790: status_$t status; ! 791: pfm_$cleanup_rec dirty; ! 792: ! 793: PID_T pid = getpid(); ! 794: ! 795: /* acl usage according to invoking environment */ ! 796: default_acl(USE_DEFENV); ! 797: ! 798: /* establish a cleanup continuation */ ! 799: status = pfm_$cleanup(dirty); ! 800: if (status.all != pfm_$cleanup_set) { ! 801: /* only handle faults for the original process */ ! 802: if (pid == getpid() && status.all > pgm_$max_severity) { ! 803: /* blew up in main process */ ! 804: status_$t quo; ! 805: pfm_$cleanup_rec clean; ! 806: ! 807: /* restore the console in any case */ ! 808: conres(); ! 809: ! 810: /* attempt a clean exit */ ! 811: debug(F101, "cleanup fault status", "", status.all); ! 812: ! 813: /* doexit(), then send status to continuation */ ! 814: quo = pfm_$cleanup(clean); ! 815: if (quo.all == pfm_$cleanup_set) ! 816: doexit(pgm_$program_faulted,-1); ! 817: else if (quo.all > pgm_$max_severity) ! 818: pfm_$signal(quo); /* blew up in doexit() */ ! 819: } ! 820: /* send to the original continuation */ ! 821: pfm_$signal(status); ! 822: /*NOTREACHED*/ ! 823: } ! 824: return(ckcmai(argc, argv)); ! 825: } ! 826: #endif /* aegis */ ! 827: ! 828: /* ANSI-style prototypes for internal functions. */ ! 829: /* Functions used outside this module are prototyped in ckcker.h. */ ! 830: ! 831: #ifdef apollo ! 832: _PROTOTYP( SIGTYP timerh, () ); ! 833: _PROTOTYP( SIGTYP cctrap, () ); ! 834: _PROTOTYP( SIGTYP esctrp, () ); ! 835: _PROTOTYP( SIGTYP sig_ign, () ); ! 836: #else ! 837: _PROTOTYP( SIGTYP timerh, (int) ); ! 838: _PROTOTYP( SIGTYP cctrap, (int) ); ! 839: _PROTOTYP( SIGTYP esctrp, (int) ); ! 840: #endif /* apollo */ ! 841: _PROTOTYP( int do_open, (char *) ); ! 842: _PROTOTYP( int ttrpid, (char *) ); ! 843: _PROTOTYP( static int ttlock, (char *) ); ! 844: _PROTOTYP( static int ttunlck, (void) ); ! 845: _PROTOTYP( int mygetbuf, (void) ); ! 846: _PROTOTYP( int myfillbuf, (void) ); ! 847: _PROTOTYP( VOID conbgt, (int) ); ! 848: #ifdef ACUCNTRL ! 849: _PROTOTYP( VOID acucntrl, (char *, char *) ); ! 850: #endif /* ACUCNTRL */ ! 851: ! 852: #ifdef BSD44ORPOSIX ! 853: _PROTOTYP( int carrctl, (struct termios *, int) ); ! 854: #else ! 855: #ifdef ATTSV ! 856: _PROTOTYP( int carrctl, (struct termio *, int) ); ! 857: #else ! 858: _PROTOTYP( int carrctl, (struct sgttyb *, int) ); ! 859: #endif /* ATTSV */ ! 860: #endif /* BSD44ORPOSIX */ ! 861: ! 862: #ifdef ATT7300 ! 863: _PROTOTYP( int attdial, (char *, long, char *) ); ! 864: _PROTOTYP( int offgetty, (char *) ); ! 865: _PROTOTYP( int ongetty, (char *) ); ! 866: #endif /* ATT7300 */ ! 867: ! 868: #ifdef CK_ANSIC ! 869: static char * ! 870: xxlast(char *s, char c) ! 871: #else ! 872: static char * ! 873: xxlast(s,c) char *s; char c; ! 874: #endif /* CK_ANSIC */ ! 875: /* xxlast */ { /* Last occurrence of character c in string s. */ ! 876: int i; ! 877: for (i = (int)strlen(s); i > 0; i--) ! 878: if ( s[i-1] == c ) return( s + (i - 1) ); ! 879: return(NULL); ! 880: } ! 881: ! 882: /* Timeout handler for communication line input functions */ ! 883: ! 884: SIGTYP ! 885: timerh(foo) int foo; { ! 886: ttimoff(); ! 887: longjmp(sjbuf,1); ! 888: } ! 889: ! 890: /* Control-C trap for communication line input functions */ ! 891: ! 892: int cc_int; /* Flag */ ! 893: SIGTYP (* occt)(); /* For saving old SIGINT handler */ ! 894: ! 895: SIGTYP ! 896: cctrap(foo) int foo; { /* Needs arg for ANSI C */ ! 897: cc_int = 1; /* signal() prototype. */ ! 898: return; ! 899: } ! 900: ! 901: /* S Y S I N I T -- System-dependent program initialization. */ ! 902: ! 903: int ! 904: sysinit() { ! 905: int x; ! 906: ! 907: conbgt(0); /* See if we're in the background */ ! 908: #ifndef __386BSD__ ! 909: /* ! 910: 386BSD doesn't allow opening /dev/tty if Kermit is running setuid. ! 911: */ ! 912: congm(); /* Get console modes */ ! 913: #endif /* __386BSD__ */ ! 914: signal(SIGALRM,SIG_IGN); /* Ignore alarms */ ! 915: ! 916: #ifdef ultrix ! 917: gtty(0,&vanilla); /* Get sgtty info */ ! 918: iniflags = fcntl(0,F_GETFL,0); /* Get flags */ ! 919: #else ! 920: #ifdef AUX ! 921: set42sig(); /* Don't ask! ([email protected]) */ ! 922: #endif /* AUX */ ! 923: #endif /* ultrix */ ! 924: ! 925: /* Initialize the setuid package. */ ! 926: /* Change to the user's real user and group id. */ ! 927: /* If this can't be done, don't run at all. */ ! 928: ! 929: if (x = priv_ini()) { ! 930: if (x | 1) fprintf(stderr,"Fatal: setuid failure.\n"); ! 931: if (x | 2) fprintf(stderr,"Fatal: setgid failure.\n"); ! 932: if (x | 4) fprintf(stderr,"Fatal: C-Kermit setuid to root!\n"); ! 933: exit(1); ! 934: } ! 935: #ifdef __386BSD__ ! 936: /* ! 937: 386BSD... OK, now we have changed into ourselves, so can open /dev/tty. ! 938: */ ! 939: congm(); /* Get console modes */ ! 940: #endif /* __386BSD__ */ ! 941: return(0); ! 942: } ! 943: ! 944: /* S Y S C L E A N U P -- System-dependent program cleanup. */ ! 945: ! 946: int ! 947: syscleanup() { ! 948: #ifdef ultrix ! 949: stty(0,&vanilla); /* Get sgtty info */ ! 950: fcntl(0,F_SETFL,iniflags); /* Restore flags */ ! 951: #endif /* ultrix */ ! 952: /* No need to call anything in the suid package here, right? */ ! 953: return(0); ! 954: } ! 955: ! 956: /* T T O P E N -- Open a tty for exclusive access. */ ! 957: ! 958: /* ! 959: Call with: ! 960: ttname: character string - device name or network host name. ! 961: lcl: ! 962: If called with lcl < 0, sets value of lcl as follows: ! 963: 0: the terminal named by ttname is the job's controlling terminal. ! 964: 1: the terminal named by ttname is not the job's controlling terminal. ! 965: But watch out: if a line is already open, or if requested line can't ! 966: be opened, then lcl remains (and is returned as) -1. ! 967: modem: ! 968: Less than zero: ttname is a network host name. ! 969: Zero or greater: ttname is a terminal device name. ! 970: Zero means a local connection (don't use modem signals). ! 971: Positive means use modem signals. ! 972: timo: ! 973: 0 = no timer. ! 974: nonzero = number of seconds to wait for open() to return before timing out. ! 975: ! 976: Returns: ! 977: 0 on success ! 978: -5 if device is in use ! 979: -4 if access to device is denied ! 980: -3 if access to lock directory denied ! 981: -2 upon timeout waiting for device to open ! 982: -1 on other error ! 983: */ ! 984: static int ttotmo = 0; /* Timeout flag */ ! 985: /* Flag kept here to avoid being clobbered by longjmp. */ ! 986: ! 987: int ! 988: ttopen(ttname,lcl,modem,timo) char *ttname; int *lcl, modem, timo; { ! 989: ! 990: #ifdef BSD44 ! 991: #define ctermid(x) strcpy(x,"") ! 992: #else ! 993: #ifdef SVORPOSIX ! 994: #ifndef CIE ! 995: extern char *ctermid(); /* Wish they all had this! */ ! 996: #else /* CIE Regulus */ ! 997: #define ctermid(x) strcpy(x,"") ! 998: #endif /* CIE */ ! 999: #endif /* SVORPOSIX */ ! 1000: #endif /* BSD44 */ ! 1001: ! 1002: char *x; /* what's this ? */ ! 1003: ! 1004: #ifndef MINIX ! 1005: extern char* ttyname(); ! 1006: #endif /* MINIX */ ! 1007: char cname[DEVNAMLEN+4]; ! 1008: ! 1009: #ifndef pdp11 ! 1010: #define NAMEFD /* Feature to allow name to be an open file descriptor */ ! 1011: #endif /* pdp11 */ ! 1012: ! 1013: #ifdef NAMEFD ! 1014: char *p; ! 1015: ! 1016: debug(F101,"ttopen telnetfd","",telnetfd); ! 1017: #endif /* NAMEFD */ ! 1018: ! 1019: debug(F111,"ttopen entry modem",ttname,modem); ! 1020: debug(F101," ttyfd","",ttyfd); ! 1021: debug(F101," lcl","",*lcl); ! 1022: ! 1023: #ifdef MAXNAMLEN ! 1024: debug(F100,"ttopen MAXNAMLEN defined","",0); ! 1025: #else ! 1026: debug(F100,"ttopen MAXNAMLEN *NOT* defined","",0); ! 1027: #endif ! 1028: ! 1029: #ifdef BSD4 ! 1030: debug(F100,"ttopen BSD4 defined","",0); ! 1031: #else ! 1032: debug(F100,"ttopen BSD4 *NOT* defined","",0); ! 1033: #endif ! 1034: ! 1035: #ifdef BSD42 ! 1036: debug(F100,"ttopen BSD42 defined","",0); ! 1037: #else ! 1038: debug(F100,"ttopen BSD42 *NOT* defined","",0); ! 1039: #endif /* BSD42 */ ! 1040: ! 1041: #ifdef MYREAD ! 1042: debug(F100,"ttopen MYREAD defined","",0); ! 1043: #else ! 1044: debug(F100,"ttopen MYREAD *NOT* defined","",0); ! 1045: #endif /* MYREAD */ ! 1046: ! 1047: ! 1048: if (ttyfd > -1) { /* if device already opened */ ! 1049: if (strncmp(ttname,ttnmsv,DEVNAMLEN)) /* are new & old names equal? */ ! 1050: ttclos(ttyfd); /* no, close old ttname, open new */ ! 1051: else /* else same, ignore this call, */ ! 1052: return(0); /* and return. */ ! 1053: } ! 1054: ! 1055: #ifdef NETCONN ! 1056: if (modem < 0) { /* modem < 0 = special code for net */ ! 1057: int x; ! 1058: ttmdm = modem; ! 1059: modem = -modem; /* Positive network type number */ ! 1060: fdflag = 0; /* Stdio not redirected. */ ! 1061: netconn = 1; /* And it's a network connection */ ! 1062: debug(F111,"ttopen net",ttname,modem); ! 1063: #ifdef NAMEFD ! 1064: for (p = ttname; isdigit(*p); p++) ; /* Check for all digits */ ! 1065: if (*p == '\0' && (telnetfd || x25fd)) { /* Avoid X.121 addresses */ ! 1066: ttyfd = atoi(ttname); /* Is there a way to test it's open? */ ! 1067: ttfdflg = 1; /* We got an open file descriptor */ ! 1068: debug(F111,"ttopen got open network fd",ttname,ttyfd); ! 1069: strncpy(ttnmsv,ttname,DEVNAMLEN); /* Remember the "name". */ ! 1070: x = 1; /* Return code is "good". */ ! 1071: if (telnetfd) { ! 1072: ttnet = NET_TCPB; ! 1073: ttnproto = NP_TELNET; ! 1074: #ifdef SUNX25 ! 1075: } else if (x25fd) { ! 1076: ttnet = NET_SX25; ! 1077: ttnproto = NP_NONE; ! 1078: #endif /* SUNX25 */ ! 1079: } ! 1080: } else { /* Host name or address given */ ! 1081: #endif /* NAMEFD */ ! 1082: x = netopen(ttname, lcl, modem); /* (see ckcnet.h) */ ! 1083: if (x > -1) { ! 1084: strncpy(ttnmsv,ttname,DEVNAMLEN); ! 1085: } else netconn = 0; ! 1086: #ifdef NAMEFD ! 1087: } ! 1088: #endif /* NAMEFD */ ! 1089: ! 1090: #ifdef sony_news /* Sony NEWS */ ! 1091: if (ioctl(ttyfd,TIOCKGET,&km_ext) < 0) { /* Get Kanji mode */ ! 1092: perror("ttopen error getting Kanji mode (network)"); ! 1093: debug(F111,"ttopen error getting Kanji mode","network",0); ! 1094: km_ext = -1; /* Make sure this stays undefined. */ ! 1095: } ! 1096: #endif /* sony_news */ ! 1097: ! 1098: xlocal = *lcl = 1; /* Network connections are local. */ ! 1099: debug(F101,"ttopen net x","",x); ! 1100: ! 1101: if (x > -1 && !x25fd) ! 1102: x = tn_ini(); /* Initialize TELNET protocol */ ! 1103: return(x); ! 1104: } else { /* Terminal device */ ! 1105: #endif /* NETCONN */ ! 1106: ! 1107: #ifdef NAMEFD ! 1108: /* ! 1109: This code lets you give Kermit an open file descriptor for a serial ! 1110: communication device, rather than a device name. Kermit assumes that the ! 1111: line is already open, locked, conditioned with the right parameters, etc. ! 1112: */ ! 1113: for (p = ttname; isdigit(*p); p++) ; /* Check for all digits */ ! 1114: if (*p == '\0') { ! 1115: ttyfd = atoi(ttname); /* Is there a way to test it's open? */ ! 1116: debug(F111,"ttopen got open fd",ttname,ttyfd); ! 1117: strncpy(ttnmsv,ttname,DEVNAMLEN); /* Remember the "name". */ ! 1118: xlocal = *lcl = 1; /* Assume it's local. */ ! 1119: netconn = 0; /* Assume it's not a network. */ ! 1120: tvtflg = 0; /* Might need to initialize modes. */ ! 1121: ttmdm = modem; /* Remember modem type. */ ! 1122: fdflag = 0; /* Stdio not redirected. */ ! 1123: ttfdflg = 1; /* Flag we were opened this way. */ ! 1124: ! 1125: #ifdef sony_news /* Sony NEWS */ ! 1126: /* Get device Kanji mode */ ! 1127: if (ioctl(ttyfd,TIOCKGET,&km_ext) < 0) { ! 1128: perror("ttopen error getting Kanji mode"); ! 1129: debug(F101,"ttopen error getting Kanji mode","",0); ! 1130: km_ext = -1; /* Make sure this stays undefined. */ ! 1131: } ! 1132: #endif /* sony_news */ ! 1133: return(0); /* Return success */ ! 1134: } ! 1135: #endif /* NAMEFD */ ! 1136: #ifdef NETCONN ! 1137: } ! 1138: #endif /* NETCONN */ ! 1139: ! 1140: /* Here we have to open a serial device of the given name. */ ! 1141: ! 1142: occt = signal(SIGINT, cctrap); /* Set Control-C trap, save old one */ ! 1143: ! 1144: tvtflg = 0; /* Flag for use by ttvt(). */ ! 1145: /* 0 = ttvt not called yet for this device */ ! 1146: ! 1147: fdflag = (!isatty(0) || !isatty(1)); /* Flag for stdio redirected */ ! 1148: debug(F101,"ttopen fdflag","",fdflag); ! 1149: ! 1150: ttmdm = modem; /* Make this available to other fns */ ! 1151: xlocal = *lcl; /* Make this available to other fns */ ! 1152: ! 1153: /* Code for handling bidirectional tty lines goes here. */ ! 1154: /* Use specified method for turning off logins and suppressing getty. */ ! 1155: ! 1156: #ifdef ACUCNTRL ! 1157: /* Should put call to priv_on() here, but that would be very risky! */ ! 1158: acucntrl("disable",ttname); /* acucntrl() program. */ ! 1159: /* and priv_off() here... */ ! 1160: #else ! 1161: #ifdef ATT7300 ! 1162: if ((attmodem & DOGETY) == 0) /* offgetty() program. */ ! 1163: attmodem |= offgetty(ttname); /* Remember response. */ ! 1164: #endif /* ATT7300 */ ! 1165: #endif /* ACUCNTRL */ ! 1166: ! 1167: /* ! 1168: In the following section, we open the tty device for read/write. ! 1169: If a modem has been specified via "set modem" prior to "set line" ! 1170: then the O_NDELAY parameter is used in the open, provided this symbol ! 1171: is defined (e.g. in fcntl.h), so that the program does not hang waiting ! 1172: for carrier (which in most cases won't be present because a connection ! 1173: has not been dialed yet). O_NDELAY is removed later on in ttopen(). It ! 1174: would make more sense to first determine if the line is local before ! 1175: doing this, but because ttyname() requires a file descriptor, we have ! 1176: to open it first. See do_open(). ! 1177: ! 1178: Now open the device using the desired treatment of carrier. ! 1179: If carrier is REQUIRED, then open could hang forever, so an optional ! 1180: timer is provided. If carrier is not required, the timer should never ! 1181: go off, and should do no harm... ! 1182: */ ! 1183: ttotmo = 0; /* Flag no timeout */ ! 1184: if (timo > 0) { ! 1185: int xx; ! 1186: saval = signal(SIGALRM,timerh); /* Timed, set up timer. */ ! 1187: xx = alarm(timo); /* Timed open() */ ! 1188: debug(F101,"ttopen alarm","",xx); ! 1189: if (setjmp(sjbuf)) { ! 1190: ttotmo = 1; /* Flag timeout. */ ! 1191: } else ttyfd = do_open(ttname); ! 1192: ttimoff(); ! 1193: debug(F111,"ttopen","modem",modem); ! 1194: debug(F101," ttyfd","",ttyfd); ! 1195: debug(F101," alarm return","",ttotmo); ! 1196: } else ttyfd = do_open(ttname); ! 1197: debug(F111,"ttopen ttyfd",ttname,ttyfd); ! 1198: if (ttyfd < 0) { /* If couldn't open, fail. */ ! 1199: #ifdef ATT7300 ! 1200: if (attmodem & DOGETY) /* was getty(1m) running before us? */ ! 1201: ongetty(ttnmsv); /* yes, restart on tty line */ ! 1202: attmodem &= ~DOGETY; /* no phone in use, getty restored */ ! 1203: #else ! 1204: #if ACUCNTRL ! 1205: /* Should put call to priv_on() here, but that would be risky! */ ! 1206: acucntrl("enable",ttname); /* acucntrl() program. */ ! 1207: /* and priv_off() here... */ ! 1208: #endif /* ACUNTRL */ ! 1209: #endif /* ATT7300 */ ! 1210: ! 1211: signal(SIGINT,occt); /* Put old Ctrl-C trap back. */ ! 1212: if (errno == EACCES) { /* Device is protected against user */ ! 1213: perror(ttname); /* Print message */ ! 1214: debug(F111,"ttopen tty access denied",ttname,errno); ! 1215: return(-4); ! 1216: } else return(ttotmo ? -2 : -1); ! 1217: } ! 1218: ! 1219: /* Make sure it's a real tty. */ ! 1220: if (!isatty(ttyfd)) { ! 1221: fprintf(stderr,"%s is not a tty!\n",ttname); ! 1222: debug(F110,"ttopen not a tty",ttname,0); ! 1223: close(ttyfd); ! 1224: ttyfd = -1; ! 1225: signal(SIGINT,occt); ! 1226: return(-1); ! 1227: } ! 1228: ! 1229: #ifdef aegis ! 1230: /* Apollo C runtime claims that console pads are tty devices, which ! 1231: * is reasonable, but they aren't any good for packet transfer. */ ! 1232: ios_$inq_type_uid((short)ttyfd, ttyuid, st); ! 1233: if (st.all != status_$ok) { ! 1234: fprintf(stderr, "problem getting tty object type: "); ! 1235: error_$print(st); ! 1236: } else if (ttyuid != sio_$uid) { /* reject non-SIO lines */ ! 1237: close(ttyfd); ttyfd = -1; ! 1238: errno = ENOTTY; perror(ttname); ! 1239: signal(SIGINT,occt); ! 1240: return(-1); ! 1241: } ! 1242: #endif /* aegis */ ! 1243: ! 1244: strncpy(ttnmsv,ttname,DEVNAMLEN); /* Keep copy of name locally. */ ! 1245: ! 1246: /* Caller wants us to figure out if line is controlling tty */ ! 1247: ! 1248: if (*lcl < 0) { ! 1249: int x0 = 0, x1 = 0; ! 1250: if (strcmp(ttname,CTTNAM) == 0) { /* "/dev/tty" always remote */ ! 1251: xlocal = 0; ! 1252: debug(F111," ttname=CTTNAM",ttname,xlocal); ! 1253: ! 1254: /* If any of 0, 1, or 2 not redirected, we can use ttyname() to get */ ! 1255: /* the name of the controlling terminal... */ ! 1256: ! 1257: /* ! 1258: Warning: on some UNIX systems (SVR4?), ttyname() reportedly opens /dev but ! 1259: never closes it. If it is called often enough, we run out of file ! 1260: descriptors and subsequent open()'s of other devices or files can fail. ! 1261: */ ! 1262: ! 1263: } else if ((x0 = isatty(0)) || (x1 = isatty(1)) || isatty(2)) { ! 1264: #ifndef MINIX ! 1265: if (x0) ! 1266: x = ttyname(0); /* and compare it with the */ ! 1267: else if (x1) /* tty device name. */ ! 1268: x = ttyname(1); ! 1269: else x = ttyname(2); ! 1270: strncpy(cname,x,DEVNAMLEN); /* (copy from internal static buf) */ ! 1271: debug(F110," cname",x,0); ! 1272: x = ttyname(ttyfd); /* Gat real name of ttname. */ ! 1273: xlocal = (strncmp(x,cname,DEVNAMLEN) == 0) ? 0 : 1; /* Compare. */ ! 1274: debug(F111," ttyname",x,xlocal); ! 1275: #else ! 1276: xlocal = 1; /* Can't do this test in MINIX */ ! 1277: #endif /* MINIX */ ! 1278: } else { /* Else, if stdin redirected... */ ! 1279: #ifdef SVORPOSIX ! 1280: /* System V provides nice ctermid() function to get name of controlling tty */ ! 1281: ctermid(cname); /* Get name of controlling terminal */ ! 1282: debug(F110," ctermid",cname,0); ! 1283: x = ttyname(ttyfd); /* Compare with name of comm line. */ ! 1284: xlocal = (strncmp(x,cname,DEVNAMLEN) == 0) ? 0 : 1; ! 1285: debug(F111," ttyname",x,xlocal); ! 1286: #else ! 1287: /* Just assume local */ ! 1288: xlocal = 1; ! 1289: #endif /* SVORPOSIX */ ! 1290: debug(F101," redirected stdin","",xlocal); ! 1291: } ! 1292: } ! 1293: ! 1294: #ifndef NOFDZERO ! 1295: /* Note, the following code was added so that Unix "idle-line" snoopers */ ! 1296: /* would not think Kermit was idle when it was transferring files, and */ ! 1297: /* maybe log people out. */ ! 1298: if (xlocal == 0) { /* Remote mode */ ! 1299: if (fdflag == 0) { /* Standard i/o is not redirected */ ! 1300: debug(F100,"ttopen setting ttyfd = 0","",0); ! 1301: close(ttyfd); /* Use file descriptor 0 */ ! 1302: ttyfd = 0; ! 1303: } else { /* Standard i/o is redirected */ ! 1304: debug(F101,"ttopen stdio redirected","",ttyfd); ! 1305: } ! 1306: } ! 1307: #endif /* NOFDZERO */ ! 1308: ! 1309: /* Now check if line is locked -- if so fail, else lock for ourselves */ ! 1310: /* Note: After having done this, don't forget to delete the lock if you */ ! 1311: /* leave ttopen() with an error condition. */ ! 1312: ! 1313: lkf = 0; /* Check lock */ ! 1314: if (xlocal > 0) { ! 1315: int xx; int xpid; ! 1316: if ((xx = ttlock(ttname)) < 0) { /* Can't lock it. */ ! 1317: debug(F111,"ttopen ttlock fails",ttname,xx); ! 1318: close(ttyfd); /* Close the device. */ ! 1319: ttyfd = -1; /* Erase its file descriptor. */ ! 1320: signal(SIGINT,occt); /* Put old SIGINT back. */ ! 1321: if (xx == -2) { /* If lockfile says tty is in use, */ ! 1322: char *p = malloc(200); /* print an ls -l listing */ ! 1323: if (p) { /* if we can get space... */ ! 1324: sprintf(p,"/bin/ls -l %s",flfnam); ! 1325: zsyscmd(p); /* Get listing. */ ! 1326: free(p); /* free the space */ ! 1327: xpid = ttrpid(flfnam); /* Try to read pid from lockfile */ ! 1328: priv_off(); /* Turn privs back off. */ ! 1329: if (xpid > -1) printf("pid = %d\n",xpid); /* show pid */ ! 1330: } ! 1331: return(-5); /* Code for device in use */ ! 1332: } else return(-3); /* Access denied */ ! 1333: } else lkf = 1; ! 1334: } ! 1335: ! 1336: /* Got the line, now set the desired value for local. */ ! 1337: ! 1338: if (*lcl != 0) *lcl = xlocal; ! 1339: ! 1340: /* Some special stuff for v7... */ ! 1341: ! 1342: #ifdef V7 ! 1343: #ifndef MINIX ! 1344: if (kmem[TTY] < 0) { /* If open, then skip this. */ ! 1345: qaddr[TTY] = initrawq(ttyfd); /* Init the queue. */ ! 1346: if ((kmem[TTY] = open("/dev/kmem", 0)) < 0) { ! 1347: fprintf(stderr, "Can't read /dev/kmem in ttopen.\n"); ! 1348: perror("/dev/kmem"); ! 1349: exit(1); ! 1350: } ! 1351: } ! 1352: #endif /* !MINIX */ ! 1353: #endif /* V7 */ ! 1354: ! 1355: /* No failure returns after this point */ ! 1356: ! 1357: #ifdef ultrix ! 1358: #ifdef TIOCSINUSE ! 1359: if (xlocal && ioctl(ttyfd, TIOCSINUSE, NULL) < 0) { ! 1360: fprintf(stderr, "Can't set in-use flag on modem.\n"); ! 1361: perror("TIOCSINUSE"); ! 1362: } ! 1363: #endif /* TIOCSINUSE */ ! 1364: #endif /* ultrix */ ! 1365: ! 1366: /* Get tty device settings */ ! 1367: ! 1368: #ifdef BSD44ORPOSIX /* POSIX */ ! 1369: tcgetattr(ttyfd,&ttold); ! 1370: debug(F101,"ttopen tcgetattr ttold.c_lflag","",ttold.c_lflag); ! 1371: tcgetattr(ttyfd,&ttraw); ! 1372: tcgetattr(ttyfd,&tttvt); ! 1373: #else /* BSD, V7, and all others */ ! 1374: #ifdef ATTSV /* AT&T UNIX */ ! 1375: ioctl(ttyfd,TCGETA,&ttold); ! 1376: debug(F101,"ttopen ioctl TCGETA ttold.c_lflag","",ttold.c_lflag); ! 1377: ioctl(ttyfd,TCGETA,&ttraw); ! 1378: ioctl(ttyfd,TCGETA,&tttvt); ! 1379: #else ! 1380: gtty(ttyfd,&ttold); ! 1381: debug(F101,"ttopen gtty ttold.sg_flags","",ttold.sg_flags); ! 1382: ! 1383: #ifdef sony_news /* Sony NEWS */ ! 1384: if (ioctl(ttyfd,TIOCKGET,&km_ext) < 0) { /* Get console Kanji mode */ ! 1385: perror("ttopen error getting Kanji mode"); ! 1386: debug(F101,"ttopen error getting Kanji mode","",0); ! 1387: km_ext = -1; /* Make sure this stays undefined. */ ! 1388: } ! 1389: #endif /* sony_news */ ! 1390: ! 1391: #ifdef TIOCGETC ! 1392: tcharf = 0; /* In remote mode, also get */ ! 1393: if (xlocal == 0) { /* special characters */ ! 1394: if (ioctl(ttyfd,TIOCGETC,&tchold) < 0) { ! 1395: debug(F100,"ttopen TIOCGETC failed","",0); ! 1396: } else { ! 1397: tcharf = 1; /* It worked. */ ! 1398: ioctl(ttyfd,TIOCGETC,&tchnoi); /* Get another copy */ ! 1399: debug(F100,"ttopen TIOCGETC ok","",0); ! 1400: } ! 1401: } ! 1402: #else ! 1403: debug(F100,"ttopen TIOCGETC not defined","",0); ! 1404: #endif /* TIOCGETC */ ! 1405: ! 1406: #ifdef TIOCGLTC ! 1407: ltcharf = 0; /* In remote mode, also get */ ! 1408: if (xlocal == 0) { /* local special characters */ ! 1409: if (ioctl(ttyfd,TIOCGLTC,<chold) < 0) { ! 1410: debug(F100,"ttopen TIOCGLTC failed","",0); ! 1411: } else { ! 1412: ltcharf = 1; /* It worked. */ ! 1413: ioctl(ttyfd,TIOCGLTC,<chnoi); /* Get another copy */ ! 1414: debug(F100,"ttopen TIOCGLTC ok","",0); ! 1415: } ! 1416: } ! 1417: #else ! 1418: debug(F100,"ttopen TIOCGLTC not defined","",0); ! 1419: #endif /* TIOCGLTC */ ! 1420: ! 1421: #ifdef TIOCLGET ! 1422: lmodef = 0; ! 1423: if (ioctl(ttyfd,TIOCLGET,&lmode) < 0) { ! 1424: debug(F100,"ttopen TIOCLGET failed","",0); ! 1425: } else { ! 1426: lmodef = 1; ! 1427: debug(F100,"ttopen TIOCLGET ok","",0); ! 1428: } ! 1429: #endif /* TIOCLGET */ ! 1430: ! 1431: gtty(ttyfd,&ttraw); /* And a copy of it for packets*/ ! 1432: gtty(ttyfd,&tttvt); /* And one for virtual tty service */ ! 1433: ! 1434: #endif /* ATTSV */ ! 1435: #endif /* BSD44ORPOSIX */ ! 1436: ! 1437: ! 1438: /* Section for changing line discipline. It's restored in ttres(). */ ! 1439: ! 1440: #ifdef BSD41 ! 1441: /* For 4.1BSD only, force "old" tty driver, new one botches TANDEM. */ ! 1442: { int k; ! 1443: ioctl(ttyfd, TIOCGETD, &ttld); /* Get and save line discipline */ ! 1444: debug(F101,"4.1bsd line discipline","",ttld); ! 1445: k = OTTYDISC; /* Switch to "old" discipline */ ! 1446: k = ioctl(ttyfd, TIOCSETD, &k); ! 1447: debug(F101,"4.1bsd tiocsetd","",k); ! 1448: } ! 1449: #endif /* BSD41 */ ! 1450: ! 1451: #ifdef aegis ! 1452: /* This was previously done before the last two TCGETA or gtty above, ! 1453: * in both the ATTSV and not-ATTSV case. If it is not okay to have only ! 1454: * one copy if it here instead, give us a shout! ! 1455: */ ! 1456: sio_$control((short)ttyfd, sio_$raw_nl, false, st); ! 1457: if (xlocal) { /* ignore breaks from local line */ ! 1458: sio_$control((short)ttyfd, sio_$int_enable, false, st); ! 1459: sio_$control((short)ttyfd, sio_$quit_enable, false, st); ! 1460: } ! 1461: #endif /* aegis */ ! 1462: ! 1463: #ifdef VXVE ! 1464: ttraw.c_line = 0; /* STTY line 0 for VX/VE */ ! 1465: tttvt.c_line = 0; /* STTY line 0 for VX/VE */ ! 1466: ioctl(ttyfd,TCSETA,&ttraw); ! 1467: #endif /* vxve */ ! 1468: ! 1469: /* If O_NDELAY was used during open(), then remove it now. */ ! 1470: ! 1471: #ifdef O_NDELAY ! 1472: if (fcntl(ttyfd, F_GETFL, 0) & O_NDELAY) { ! 1473: ! 1474: #ifndef aegis ! 1475: if (fcntl(ttyfd,F_SETFL, fcntl(ttyfd, F_GETFL, 0) & ~O_NDELAY) < 0 ) ! 1476: perror("Can't unset O_NDELAY"); ! 1477: #endif /* aegis */ ! 1478: /* Some systems, notably Xenix (don't know how common this is in ! 1479: * other systems), need special treatment to get rid of the O_NDELAY ! 1480: * behaviour on read() with respect to carrier presence (i.e. read() ! 1481: * returning 0 when carrier absent), even though the above fcntl() ! 1482: * is enough to make read() wait for input when carrier is present. ! 1483: * This magic, in turn, requires CLOCAL for working when the carrier ! 1484: * is absent. But if xlocal == 0, presumably you already have CLOCAL ! 1485: * or you have a carrier, otherwise you wouldn't be running this. ! 1486: */ ! 1487: #ifdef ATTSV ! 1488: #ifdef BSD44 ! 1489: tcsetattr(ttyfd, TCSADRAIN, &ttraw); ! 1490: #else ! 1491: if (xlocal) { ! 1492: ttraw.c_cflag |= CLOCAL; ! 1493: ioctl(ttyfd, TCSETA, &ttraw); ! 1494: } ! 1495: #endif /* BSD44 */ ! 1496: #endif /* ATTSV */ ! 1497: #ifndef SCO3R2 ! 1498: #ifndef OXOS ! 1499: /* Reportedly lets uugetty grab the device in SCO UNIX 3.2 / XENIX 2.3 */ ! 1500: close( priv_opn(ttname, O_RDWR) ); /* Magic to force change. */ ! 1501: #endif /* OXOS */ ! 1502: #endif /* SCO3R2 */ ! 1503: } ! 1504: #endif /* O_NDELAY */ ! 1505: ! 1506: /* Instruct the system how to treat the carrier, and set a few other tty ! 1507: * parameters. ! 1508: * ! 1509: * This also undoes the temporary setting of CLOCAL that may have been done ! 1510: * for the close(open()) above (except in Xenix). Also throw in ~ECHO, to ! 1511: * prevent the other end of the line from sitting there talking to itself, ! 1512: * producing garbage when the user performs a connect. ! 1513: * ! 1514: * SCO Xenix unfortunately seems to ignore the actual state of CLOCAL. ! 1515: * Now it thinks CLOCAL is always on. It seems the only real solution for ! 1516: * Xenix is to switch between the lower and upper case device names. ! 1517: * ! 1518: * This section may at some future time expand into setting a complete ! 1519: * collection of tty parameters, or call a function shared with ttpkt()/ ! 1520: * ttvt() that does so. On the other hand, the initial parameters are not ! 1521: * that important, since ttpkt() or ttvt() should always fix that before ! 1522: * any communication is done. Well, we'll see... ! 1523: */ ! 1524: if (xlocal) { ! 1525: curcarr = -2; ! 1526: carrctl(&ttraw, ttcarr == CAR_ON); ! 1527: ! 1528: #ifdef SVORPOSIX ! 1529: ttraw.c_lflag &= ~ECHO; ! 1530: ttold.c_lflag &= ~ECHO; ! 1531: #ifdef BSD44ORPOSIX ! 1532: tcsetattr(ttyfd, TCSADRAIN, &ttraw); ! 1533: #else ! 1534: ioctl(ttyfd, TCSETA, &ttraw); ! 1535: #endif /* BSD44ORPOSIX */ ! 1536: ! 1537: #else /* BSD, etc */ ! 1538: ttraw.sg_flags &= ~ECHO; ! 1539: ttold.sg_flags &= ~ECHO; ! 1540: stty(ttyfd,&ttraw); ! 1541: #endif /* SVORPOSIX */ ! 1542: /* ttflui(); This fails for some reason */ ! 1543: } ! 1544: ! 1545: /* Get current speed */ ! 1546: ! 1547: ttspeed = ttgspd(); ! 1548: debug(F101,"ttopen ttspeed","",ttspeed); ! 1549: ! 1550: /* Done, make entries in debug log, restore Ctrl-C trap, and return. */ ! 1551: ! 1552: debug(F101,"ttopen, ttyfd","",ttyfd); ! 1553: debug(F101," lcl","",*lcl); ! 1554: debug(F111," lock file",flfnam,lkf); ! 1555: signal(SIGINT,occt); ! 1556: return(0); ! 1557: } ! 1558: ! 1559: ! 1560: /* D O _ O P E N -- Do the right kind of open() call for the tty. */ ! 1561: ! 1562: int ! 1563: do_open(ttname) char *ttname; { ! 1564: ! 1565: #ifndef O_NDELAY /* O_NDELAY not defined */ ! 1566: return(priv_opn(ttname,2)); ! 1567: #else /* O_NDELAY defined */ ! 1568: ! 1569: #ifdef ATT7300 ! 1570: /* ! 1571: Open comms line without waiting for carrier so initial call does not hang ! 1572: because state of "modem" is likely unknown at the initial call -jrd. ! 1573: If this is needed for the getty stuff to work, and the open would not work ! 1574: without O_NDELAY when getty is still on, then this special case is ok. ! 1575: Otherwise, get rid of it. -ske ! 1576: */ ! 1577: return(priv_opn(ttname, O_RDWR | O_NDELAY)); ! 1578: ! 1579: #else /* !ATT7300 */ ! 1580: ! 1581: /* Normal case. Use O_NDELAY according to SET CARRIER. See ttscarr(). */ ! 1582: ! 1583: return(priv_opn(ttname, O_RDWR | ((ttcarr != CAR_ON) ? O_NDELAY : 0) )); ! 1584: ! 1585: #endif /* !ATT7300 */ ! 1586: #endif /* O_NDELAY */ ! 1587: } ! 1588: ! 1589: /* T T C L O S -- Close the TTY, releasing any lock. */ ! 1590: ! 1591: int ! 1592: ttclos(foo) int foo; { /* Arg req'd for signal() prototype */ ! 1593: int x = 0; ! 1594: ! 1595: debug(F101,"ttclos ttyfd","",ttyfd); ! 1596: if (ttyfd < 0) return(0); /* Wasn't open. */ ! 1597: ! 1598: if (ttfdflg) return(0); /* If we got ttyfd from another */ ! 1599: /* process, don't close it. */ ! 1600: tvtflg = 0; ! 1601: #ifdef NETCONN ! 1602: if (netconn) { /* Network connection. */ ! 1603: debug(F100,"ttclos closing net","",0); ! 1604: netclos(); /* Close it. */ ! 1605: netconn = 0; ! 1606: return(0); ! 1607: } ! 1608: #endif /* NETCONN */ ! 1609: #ifdef FT21 ! 1610: if (xlocal) ioctl(ttyfd,TIOCHPCL, NULL); ! 1611: #endif /* FT21 */ ! 1612: #ifdef ultrix ! 1613: if (xlocal) ioctl(ttyfd, TIOCNCAR, NULL); ! 1614: #endif /* ultrix */ ! 1615: if (xlocal) { ! 1616: debug(F100,"ttclos about to call ttunlck","",0); ! 1617: if (ttunlck()) /* Release uucp-style lock */ ! 1618: fprintf(stderr,"Warning, problem releasing lock\r\n"); ! 1619: debug(F100,"ttclos about to call ttres","",0); ! 1620: } ! 1621: if (ttyfd > 0) { ! 1622: int xx; ! 1623: saval = signal(SIGALRM,timerh); /* Enable timer interrupt. */ ! 1624: xx = alarm(5); /* Allow 5 seconds for this. */ ! 1625: debug(F101,"ttclos alarm","",xx); ! 1626: if (setjmp(sjbuf)) { /* Timer went off? */ ! 1627: x = -1; ! 1628: } else { /* What we're really trying to do */ ! 1629: if (xlocal) { ! 1630: tthang(); /* Hang up first, then... */ ! 1631: ttres(); /* reset device modes. */ ! 1632: } ! 1633: debug(F101,"ttclos about to call close","",ttyfd); ! 1634: close(ttyfd); /* Close the device. */ ! 1635: x = 1; ! 1636: } ! 1637: ttimoff(); /* Turn off timer. */ ! 1638: if (x < 0) { ! 1639: fprintf(stderr,"?Timed out closing device: %s\n",ttnmsv); ! 1640: debug(F100,"ttclos timed out","",0); ! 1641: } ! 1642: } ! 1643: ttyfd = -1; /* Invalidate the file descriptor. */ ! 1644: #ifdef sony_news ! 1645: km_ext = -1; /* Invalidate device's Kanji-mode */ ! 1646: #endif /* sony_news */ ! 1647: ! 1648: /* For bidirectional lines, restore getty if it was there before. */ ! 1649: ! 1650: #ifdef ACUCNTRL /* 4.3BSD acucntrl() method. */ ! 1651: acucntrl("enable",ttnmsv); /* Enable getty on the device. */ ! 1652: #else ! 1653: #ifdef ATT7300 /* ATT UNIX PC (3B1, 7300) method. */ ! 1654: if (attmodem & DOGETY) /* Was getty(1m) running before us? */ ! 1655: ongetty(ttnmsv); /* Yes, restart getty on tty line */ ! 1656: attmodem &= ~DOGETY; /* No phone in use, getty restored */ ! 1657: #endif /* ATT7300 */ ! 1658: #endif /* System-dependent getty-restoring methods */ ! 1659: ! 1660: debug(F100,"ttclos done","",0); ! 1661: return(0); ! 1662: } ! 1663: ! 1664: /* T T H A N G -- Hangup phone line or network connection. */ ! 1665: /* ! 1666: Returns: ! 1667: 0 if it does nothing. ! 1668: 1 if it believes that it hung up successfully. ! 1669: -1 if it believes that the hangup attempt failed. ! 1670: */ ! 1671: ! 1672: #define HUPTIME 500 /* Milliseconds for hangup */ ! 1673: ! 1674: int ! 1675: tthang() { ! 1676: int x = 0; /* Sometimes used as return code. */ ! 1677: #ifndef POSIX ! 1678: int z; /* worker */ ! 1679: #endif /* POSIX */ ! 1680: ! 1681: #ifdef SVORPOSIX /* AT&T, POSIX, HPUX declarations. */ ! 1682: int spdsav; /* for saving speed */ ! 1683: int spdsavi; ! 1684: #ifdef HPUX ! 1685: mflag dtr_down = 00000000000, ! 1686: modem_rtn; ! 1687: mflag modem_sav; ! 1688: char modem_state[64]; ! 1689: #endif /* HPUX */ ! 1690: int flags; /* fcntl flags */ ! 1691: unsigned short ttc_save; ! 1692: #endif /* SVORPOSIX */ ! 1693: ! 1694: if (ttyfd < 0) return(0); /* Don't do this if not open */ ! 1695: if (xlocal < 1) return(0); /* Don't do this if not local */ ! 1696: ! 1697: #ifdef NETCONN ! 1698: if (netconn) /* Network connection. */ ! 1699: return((netclos() < 0) ? -1 : 1); /* Just close it. */ ! 1700: #endif /* NETCONN */ ! 1701: ! 1702: /* From here down, we handle real tty devices. */ ! 1703: ! 1704: #ifdef BSD44ORPOSIX ! 1705: /* Should add some error checking here... */ ! 1706: debug(F100,"tthang POSIX style","",0); ! 1707: spdsav = cfgetospeed(&ttcur); /* Get current speed */ ! 1708: spdsavi = cfgetispeed(&ttcur); /* Get current speed */ ! 1709: cfsetospeed(&ttcur,B0); /* Replace by 0 */ ! 1710: cfsetispeed(&ttcur,B0); ! 1711: if (tcsetattr(ttyfd,TCSADRAIN,&ttcur) == -1) ! 1712: debug(F100,"tthang tcsetattr fails","",errno); ! 1713: msleep(HUPTIME); /* Sleep */ ! 1714: cfsetospeed(&ttcur,spdsav); /* Restore previous speed */ ! 1715: cfsetispeed(&ttcur,spdsavi); ! 1716: tcsetattr(ttyfd,TCSADRAIN,&ttcur); ! 1717: return(1); ! 1718: ! 1719: #else /* BSD44ORPOSIX */ ! 1720: ! 1721: #ifdef aegis /* Apollo Aegis */ ! 1722: sio_$control((short)ttyfd, sio_$dtr, false, st); /* DTR down */ ! 1723: msleep(HUPTIME); /* pause */ ! 1724: sio_$control((short)ttyfd, sio_$dtr, true, st); /* DTR up */ ! 1725: return(1); ! 1726: #endif /* aegis */ ! 1727: ! 1728: #ifdef ANYBSD /* Any BSD version. */ ! 1729: debug(F100,"tthang BSD style","",0); ! 1730: if (ioctl(ttyfd,TIOCCDTR,0) < 0) { /* Clear DTR. */ ! 1731: debug(F101,"tthang TIOCCDTR fails","",errno); ! 1732: return(-1); ! 1733: } ! 1734: msleep(HUPTIME); /* For about 1/2 sec */ ! 1735: errno = 0; ! 1736: x = ioctl(ttyfd,TIOCSDTR,0); /* Restore DTR */ ! 1737: if (x < 0) { ! 1738: /* ! 1739: For some reason, this tends to fail with "no such device or address" ! 1740: but the operation still works, probably because of the close/open ! 1741: later on. So let's not scare the user unnecessarily here. ! 1742: */ ! 1743: debug(F101,"tthang TIOCSDTR errno","",errno); /* Log the error */ ! 1744: x = 1; /* Pretend we succeeded */ ! 1745: } else if (x == 0) x = 1; /* Success */ ! 1746: #ifdef COMMENT ! 1747: #ifdef FT21 ! 1748: ioctl(ttyfd, TIOCSAVEMODES, 0); ! 1749: ioctl(ttyfd, TIOCHPCL, 0); ! 1750: close(ttyfd); /* Yes, must do this twice */ ! 1751: if ((ttyfd = open(ttnmsv,2)) < 0) /* on Fortune computers... */ ! 1752: return(-1); /* (but why?) */ ! 1753: else x = 1; ! 1754: #endif /* FT21 */ ! 1755: #endif /* COMMENT */ ! 1756: close(do_open(ttnmsv)); /* Clear i/o error condition */ ! 1757: errno = 0; ! 1758: #ifdef COMMENT ! 1759: /* This is definitely dangerous. Why was it here? */ ! 1760: z = ttvt(ttspeed,ttflow); /* Restore modes. */ ! 1761: debug(F101,"tthang ttvt returns","",z); ! 1762: return(z < 0 ? -1 : 1); ! 1763: #else ! 1764: return(x); ! 1765: #endif /* COMMENT */ ! 1766: #endif /* ANYBSD */ ! 1767: ! 1768: #ifdef ATTSV ! 1769: /* AT&T UNIX section, includes HP-UX and generic AT&T System III/V... */ ! 1770: ! 1771: #ifdef HPUX ! 1772: /* Hewlett Packard allows explicit manipulation of modem signals. */ ! 1773: ! 1774: #ifdef COMMENT ! 1775: /* Old way... */ ! 1776: debug(F100,"tthang HP-UX style","",0); ! 1777: if (ioctl(ttyfd,MCSETAF,&dtr_down) < 0) /* lower DTR */ ! 1778: return(-1); /* oops, can't. */ ! 1779: msleep(HUPTIME); /* Pause half a second. */ ! 1780: x = 1; /* Set return code */ ! 1781: if (ioctl(ttyfd,MCGETA,&modem_rtn) > -1) { /* Get line status. */ ! 1782: if ((modem_rtn & MDCD) != 0) /* Check if CD is low. */ ! 1783: x = -1; /* CD didn't drop, fail. */ ! 1784: } else x = -1; ! 1785: ! 1786: /* Even if above calls fail, RTS & DTR should be turned back on. */ ! 1787: modem_rtn = MRTS | MDTR; ! 1788: if (ioctl(ttyfd,MCSETAF,&modem_rtn) < 0) x = -1; ! 1789: return(x); ! 1790: #else ! 1791: /* New way, from Hellmuth Michaelis */ ! 1792: debug(F100,"tthang HP-UX style, HPUXDEBUG","",0); ! 1793: if (ioctl(ttyfd,MCGETA,&modem_rtn) == -1) { /* Get current status. */ ! 1794: debug(F100,"tthang HP-UX: can't get modem lines, NO HANGUP!","",0); ! 1795: return(-1); ! 1796: } ! 1797: sprintf(modem_state,"%#lx",modem_rtn); ! 1798: debug(F110,"tthang HP-UX: modem lines got = ",modem_state,0); ! 1799: modem_sav = modem_rtn; /* save line status */ ! 1800: modem_rtn &= ~MDTR; /* DTR bit down */ ! 1801: sprintf(modem_state,"%#lx",modem_rtn); ! 1802: debug(F110,"tthang HP-UX: modem lines lowered DTR = ",modem_state,0); ! 1803: if (ioctl(ttyfd,MCSETAF,&modem_rtn) < 0) { /* lower DTR */ ! 1804: debug(F100,"tthang HP-UX: can't lower DTR!","",0); ! 1805: return(-1); /* oops, can't. */ ! 1806: } ! 1807: msleep(HUPTIME); /* Pause half a second. */ ! 1808: x = 1; /* Set return code */ ! 1809: if (ioctl(ttyfd,MCGETA,&modem_rtn) > -1) { /* Get line status. */ ! 1810: sprintf(modem_state,"%#lx",modem_rtn); ! 1811: debug(F110,"tthang HP-UX: modem lines got = ",modem_state,0); ! 1812: if ((modem_rtn & MDCD) != 0) { /* Check if CD is low. */ ! 1813: debug(F100,"tthang HP-UX: DCD didn't get down!","",0); ! 1814: x = -1; /* CD didn't drop, fail. */ ! 1815: } else { ! 1816: debug(F100,"tthang HP-UX: DCD down!","",0); ! 1817: } ! 1818: } else { ! 1819: x = -1; ! 1820: debug(F100,"tthang HP-UX: can't get DCD status !","",0); ! 1821: } ! 1822: ! 1823: /* Even if above calls fail, RTS & DTR should be turned back on. */ ! 1824: ! 1825: modem_sav |= (MRTS | MDTR); ! 1826: if (ioctl(ttyfd,MCSETAF,&modem_sav) < 0) { ! 1827: x = -1; ! 1828: debug(F100,"tthang HP-UX: can't set saved state |=(RTS | DTR)","",0); ! 1829: } else { ! 1830: sprintf(modem_state,"%#lx",modem_sav); ! 1831: debug(F110,"tthang HP-UX: final modem lines = ",modem_state,0); ! 1832: } ! 1833: return(x); ! 1834: #endif /* COMMENT */ ! 1835: ! 1836: #else /* AT&T but not HP-UX */ ! 1837: ! 1838: /* SVID for AT&T System V R3 defines ioctl's for handling modem signals. */ ! 1839: /* It is not known how many, if any, systems actually implement them, */ ! 1840: /* so we include them here in ifdef's. */ ! 1841: ! 1842: #ifndef _IBMR2 ! 1843: /* ! 1844: No modem-signal twiddling for IBM RT PC or RS/6000. ! 1845: In AIX 3.1 and earlier, the ioctl() call is broken. ! 1846: This code could be activated for AIX 3.1 with PTF 2006 or later ! 1847: (e.g. AIX 3.2), but close/open does the job too, so why bother. ! 1848: */ ! 1849: #ifdef TIOCMBIS /* Bit Set */ ! 1850: #ifdef TIOCMBIC /* Bit Clear */ ! 1851: #ifdef TIOCM_DTR /* DTR */ ! 1852: ! 1853: /* Clear DTR, sleep 300 msec, turn it back on. */ ! 1854: /* If any of the ioctl's return failure, go on to the next section. */ ! 1855: ! 1856: z = TIOCM_DTR; /* Code for DTR. */ ! 1857: #ifdef TIOCM_RTS /* Lower RTS too if symbol is known. */ ! 1858: z |= TIOCM_RTS; ! 1859: #endif /* TIOCM_RTS */ ! 1860: ! 1861: debug(F101,"tthang TIOCM signal mask","",z); ! 1862: if (ioctl(ttyfd,TIOCMBIC,&z) > -1) { /* Try to lower DTR. */ ! 1863: debug(F100,"tthang TIOCMBIC ok","",0); ! 1864: msleep(HUPTIME); /* Pause half a second. */ ! 1865: if (ioctl(ttyfd,TIOCMBIS,&z) > -1) { /* Try to turn it back on. */ ! 1866: debug(F100,"tthang TIOCMBIS ok","",0); ! 1867: #ifndef CLSOPN ! 1868: return(1); /* Success, done. */ ! 1869: #endif /* CLSOPN */ ! 1870: } else { /* Couldn't raise, continue. */ ! 1871: debug(F101,"tthang TIOCMBIS errno","",errno); ! 1872: } ! 1873: } else { /* Couldn't lower, continue. */ ! 1874: debug(F101,"tthang TIOCMBIC errno","",errno); ! 1875: } ! 1876: #endif /* TIOCM_DTR */ ! 1877: #endif /* TIOCMBIC */ ! 1878: #endif /* TIOCMBIS */ ! 1879: #endif /* _IBMR2 */ ! 1880: /* ! 1881: General AT&T UNIX case, not HPUX. The following code is highly suspect. No ! 1882: two AT&T-based systems seem to do this the same way. The object is simply ! 1883: to turn off DTR and then turn it back on. SVID says the universal method ! 1884: for turning off DTR is to set the speed to zero, and this does seem to do ! 1885: the trick in all cases. But neither SVID nor any known man pages say how to ! 1886: turn DTR back on again. Some variants, like most Xenix implementations, ! 1887: raise DTR again when the speed is restored to a nonzero value. Others ! 1888: require the device to be closed and opened again, but this is risky because ! 1889: getty could seize the device during the instant it is closed. ! 1890: */ ! 1891: ! 1892: /* Return code for ioctl failures... */ ! 1893: #ifdef ATT6300 ! 1894: x = 1; /* ATT6300 doesn't want to fail... */ ! 1895: #else ! 1896: x = -1; ! 1897: #endif /* ATT6300 */ ! 1898: ! 1899: debug(F100,"tthang get settings","",0); ! 1900: if (ioctl(ttyfd,TCGETA,&ttcur) < 0) /* Get current settings. */ ! 1901: return(x); /* Fail if this doesn't work. */ ! 1902: if ((flags = fcntl(ttyfd,F_GETFL,0)) < 0) /* Get device flags. */ ! 1903: return(x); ! 1904: ttc_save = ttcur.c_cflag; /* Remember current speed. */ ! 1905: spdsav = ttc_save & CBAUD; ! 1906: debug(F101,"tthang speed","",spdsav); ! 1907: ! 1908: #ifdef O_NDELAY ! 1909: debug(F100,"tthang turning O_NDELAY on","",0); ! 1910: fcntl(ttyfd, F_SETFL, flags | O_NDELAY); /* Activate O_NDELAY */ ! 1911: #endif /* O_NDELAY */ ! 1912: ! 1913: #ifdef ATT7300 /* This is the way it is SUPPOSED to work */ ! 1914: ttcur.c_cflag &= ~CBAUD; /* Change the speed to zero. */ ! 1915: #else ! 1916: #ifdef RTAIX ! 1917: ttcur.c_cflag &= ~CBAUD; /* Change the speed to zero. */ ! 1918: #else /* This way really works but may be dangerous */ ! 1919: #ifdef u3b2 ! 1920: ttcur.c_cflag = ~(CBAUD|CLOCAL); /* Special for AT&T 3B2s */ ! 1921: /* (CLOCAL must be OFF) */ ! 1922: #else ! 1923: #ifdef SCO3R2 /* SCO UNIX 3.2 */ ! 1924: /* ! 1925: This is complete nonsense, but an SCO user claimed this change made ! 1926: hanging up work. Comments from other SCO UNIX 3.2 users would be ! 1927: appreciated. ! 1928: */ ! 1929: ttcur.c_cflag = CBAUD|B0; ! 1930: #else /* None of the above. */ ! 1931: ttcur.c_cflag = CLOCAL|HUPCL; /* Change all but these to zero */ ! 1932: /* (CLOCAL must be ON) */ ! 1933: #endif /* SCO3R2 */ ! 1934: #endif /* u3b2 */ ! 1935: #endif /* RTAIX */ ! 1936: #endif /* ATT7300 */ ! 1937: ! 1938: #ifdef COMMENT ! 1939: /* and if none of those work, try one of these... */ ! 1940: ttcur.c_cflag = 0; ! 1941: ttcur.c_cflag = CLOCAL; ! 1942: ttcur.c_cflag &= ~(CBAUD|HUPCL); ! 1943: ttcur.c_cflag &= ~(CBAUD|CREAD); ! 1944: ttcur.c_cflag &= ~(CBAUD|CREAD|HUPCL); ! 1945: /* or other combinations */ ! 1946: #endif /* COMMENT */ ! 1947: ! 1948: #ifdef TCXONC ! 1949: debug(F100,"tthang TCXONC","",0); ! 1950: ioctl(ttyfd, TCXONC, 1); ! 1951: #endif /* TCXONC */ ! 1952: ! 1953: #ifdef TIOCSTART ! 1954: debug(F100,"tthang TIOCSTART","",0); ! 1955: ioctl(ttyfd, TIOCSTART, 0); ! 1956: #endif /* TIOCSTART */ ! 1957: ! 1958: if (ioctl(ttyfd,TCSETAF,&ttcur) < 0) { /* Fail if we can't. */ ! 1959: fcntl(ttyfd, F_SETFL, flags); /* Restore flags */ ! 1960: return(-1); /* before returning. */ ! 1961: } ! 1962: msleep(300); /* Give modem time to notice. */ ! 1963: ! 1964: /* Now, even though it doesn't say this in SVID or any man page, we have */ ! 1965: /* to close and reopen the device. This is not necessary for all systems, */ ! 1966: /* but it's impossible to predict which ones need it and which ones don't. */ ! 1967: ! 1968: #ifdef ATT7300 ! 1969: /* ! 1970: Special handling for ATT 7300 UNIX PC and 3B1, which have "phone" ! 1971: related ioctl's for their internal modems. attmodem has getty status and ! 1972: modem-in-use bit. Reportedly the ATT7300/3B1 PIOCDISC call is necessary, ! 1973: but also ruins the file descriptor, and no other phone(7) ioctl call can fix ! 1974: it. Whateverit does, it seems to escape detection with PIOCGETA and TCGETA. ! 1975: The only way to undo the damage is to close the fd and then reopen it. ! 1976: */ ! 1977: if (attmodem & ISMODEM) { ! 1978: debug(F100,"tthang attmodem close/open","",0); ! 1979: ioctl(ttyfd,PIOCUNHOLD,&dialer); /* Return call to handset. */ ! 1980: ioctl(ttyfd,PIOCDISC,&dialer); /* Disconnect phone. */ ! 1981: close(ttyfd); /* Close and reopen the fd. */ ! 1982: ttyfd = priv_opn(ttnmsv, O_RDWR | O_NDELAY); ! 1983: attmodem &= ~ISMODEM; /* Phone no longer in use. */ ! 1984: } ! 1985: #else /* !ATT7300 */ ! 1986: /* It seems we have to close and open the device for other AT&T systems */ ! 1987: /* too, and this is the place to do it. The following code does the */ ! 1988: /* famous close(open(...)) magic by default. If that doesn't work for you, */ ! 1989: /* then try uncommenting the following statement or putting -DCLSOPN in */ ! 1990: /* the makefile CFLAGS. */ ! 1991: ! 1992: /* #define CLSOPN */ ! 1993: ! 1994: #ifndef SCO32 /* Not needed by, and harmful to, SCO UNIX 3.2 / Xenix 2.3 */ ! 1995: ! 1996: #ifdef O_NDELAY ! 1997: #define OPENFLGS O_RDWR | O_NDELAY ! 1998: #else ! 1999: #define OPENFLGS O_RDWR ! 2000: #endif ! 2001: ! 2002: #ifndef CLSOPN ! 2003: /* This method is used by default, i.e. unless CLSOPN is defined. */ ! 2004: /* It is thought to be safer because there is no window where getty */ ! 2005: /* can seize control of the device. The drawback is that it might not work. */ ! 2006: ! 2007: debug(F101,"tthang close(open()), OPENFLGS","",OPENFLGS); ! 2008: close(priv_opn(ttnmsv, OPENFLGS)); ! 2009: ! 2010: #else ! 2011: /* This method is used if you #define CLSOPN. It is more likely to work */ ! 2012: /* than the previous method, but it's also more dangerous. */ ! 2013: ! 2014: debug(F101,"tthang close/open, OPENFLGS","",OPENFLGS); ! 2015: close(ttyfd); ! 2016: msleep(10); ! 2017: ttyfd = priv_opn(ttnmsv, OPENFLGS); /* Open it again */ ! 2018: #endif /* CLSOPN */ ! 2019: #undef OPENFLGS ! 2020: ! 2021: #endif /* SCO32 */ ! 2022: #endif /* ATT7300 */ ! 2023: ! 2024: /* Now put all flags & modes back the way we found them. */ ! 2025: /* (Does the order of ioctl & fcntl matter ? ) */ ! 2026: ! 2027: debug(F100,"tthang restore settings","",0); ! 2028: ttcur.c_cflag = ttc_save; /* Get old speed back. */ ! 2029: if (ioctl(ttyfd,TCSETAF,&ttcur) < 0) /* ioctl parameters. */ ! 2030: return(-1); ! 2031: #ifdef O_NDELAY ! 2032: /* ! 2033: This is required for IBM RT and RS/6000, probably helps elsewhere too (?). ! 2034: After closing a modem line, the modem will probably not be asserting ! 2035: carrier any more, so we should not require carrier any more. If this ! 2036: causes trouble on non-IBM UNIXes, change the #ifdef to use _IBMR2 rather ! 2037: than O_NDELAY. ! 2038: */ ! 2039: flags &= ~O_NDELAY; /* Don't require carrier on reopen */ ! 2040: #endif /* O_NDELAY */ ! 2041: if (fcntl(ttyfd,F_SETFL,flags) < 0) /* fcntl parameters */ ! 2042: return(-1); ! 2043: ! 2044: return(1); ! 2045: #endif /* not HPUX */ ! 2046: #endif /* ATTSV */ ! 2047: #endif /* BSD44ORPOSIX */ ! 2048: } ! 2049: ! 2050: /* ! 2051: Major change in 5A(174). We used to use LPASS8, if it was defined, to ! 2052: allow 8-bit data and Xon/Xoff flow control at the same time. But this ! 2053: LPASS8 business seems to have been causing trouble for everybody but me! ! 2054: For example, Annex terminal servers, commonly used with Encore computers, ! 2055: do not support LPASS8 even though the Encore itself does. Ditto for many ! 2056: other terminal servers, TELNET connections, rlogin connections, etc etc. ! 2057: Now, reportedly, even vanilla 4.3 BSD systems can't do this right on their ! 2058: serial lines, even though LPASS8 is a feature of 4.3BSD. So let's turn it ! 2059: off for everybody. That means we goes back to using raw mode, with no ! 2060: flow control. Phooey. ! 2061: ! 2062: NOTE: This must be done before the first reference to LPASS8 in this file, ! 2063: and after the last #include statment. ! 2064: */ ! 2065: #ifdef LPASS8 ! 2066: #undef LPASS8 ! 2067: #endif /* LPASS8 */ ! 2068: ! 2069: /* T T R E S -- Restore terminal to "normal" mode. */ ! 2070: ! 2071: /* [email protected]: There are two choices for what this function should do. ! 2072: * (1) Restore the tty to current "normal" mode, with carrier treatment ! 2073: * according to ttcarr, to be used after every kermit command. (2) Restore ! 2074: * the tty to the state it was in before kermit opened it. These choices ! 2075: * conflict, since ttold can't hold both choices of tty parameters. ttres() ! 2076: * is currently being called as in choice (1), but ttold basically holds ! 2077: * the initial parameters, as in (2), and the description at the beginning ! 2078: * of this file says (2). ! 2079: * ! 2080: * I don't think restoring tty parameters after all kermit commands makes ! 2081: * much of a difference. Restoring them upon exit from kermit may be of ! 2082: * some use in some cases (when the line is not restored automatically on ! 2083: * close, by the operating system). ! 2084: * ! 2085: * I can't choose which one it should be, so I haven't changed it. It ! 2086: * probably works as it is, too. It would probably even work even with ! 2087: * ttres() entirely deleted... ! 2088: * ! 2089: * (from fdc: Actually, this function operates in remote mode too, so ! 2090: * it restores the console (command) terminal to whatever mode it was ! 2091: * in before packet operations began, so that commands work right again.) ! 2092: */ ! 2093: int ! 2094: ttres() { /* Restore the tty to normal. */ ! 2095: int x; ! 2096: ! 2097: if (ttyfd < 0) return(-1); /* Not open. */ ! 2098: ! 2099: if (ttfdflg) return(0); /* Don't mess with terminal modes if */ ! 2100: /* we got ttyfd from another process */ ! 2101: #ifdef NETCONN ! 2102: if (netconn) return (0); /* Network connection, do nothing */ ! 2103: #endif /* NETCONN */ ! 2104: ! 2105: /* Real terminal device, so restore its original modes */ ! 2106: ! 2107: #ifdef BSD44ORPOSIX /* For POSIX like this */ ! 2108: x = tcsetattr(ttyfd,TCSADRAIN,&ttold); ! 2109: #else /* For all others... */ ! 2110: #ifdef ATTSV /* For AT&T versions... */ ! 2111: x = ioctl(ttyfd,TCSETAW,&ttold); /* Restore tty modes this way. */ ! 2112: #else ! 2113: msleep(HUPTIME); /* This replaces sleep(1)... */ ! 2114: /* Put back sleep(1) if tty is */ ! 2115: /* messed up after close. */ ! 2116: ! 2117: /* Here we restore the modes for BSD */ ! 2118: ! 2119: #ifdef LPASS8 /* Undo "pass8" if it were done */ ! 2120: if (lmodef) { ! 2121: if (ioctl(ttyfd,TIOCLSET,&lmode) < 0) ! 2122: debug(F100,"ttres TIOCLSET failed","",0); ! 2123: else ! 2124: debug(F100,"ttres TIOCLSET ok","",0); ! 2125: } ! 2126: #endif /* LPASS8 */ ! 2127: ! 2128: #ifdef CK_DTRCTS /* Undo hardware flow if it were done */ ! 2129: if (lmodef) { ! 2130: if (ioctl(ttyfd,TIOCLSET,&lmode) < 0) ! 2131: debug(F100,"ttres TIOCLSET failed","",0); ! 2132: else ! 2133: debug(F100,"ttres TIOCLSET ok","",0); ! 2134: } ! 2135: #endif /* CK_DTRCTS */ ! 2136: ! 2137: #ifdef TIOCGETC /* Put back special characters */ ! 2138: if (tcharf && (xlocal == 0)) { ! 2139: if (ioctl(ttyfd,TIOCSETC,&tchold) < 0) ! 2140: debug(F100,"ttres TIOCSETC failed","",0); ! 2141: else ! 2142: debug(F100,"ttres TIOCSETC ok","",0); ! 2143: } ! 2144: #endif /* TIOCGETC */ ! 2145: ! 2146: #ifdef TIOCGLTC /* Put back local special characters */ ! 2147: if (ltcharf && (xlocal == 0)) { ! 2148: if (ioctl(ttyfd,TIOCSLTC,<chold) < 0) ! 2149: debug(F100,"ttres TIOCSLTC failed","",0); ! 2150: else ! 2151: debug(F100,"ttres TIOCSLTC ok","",0); ! 2152: } ! 2153: #endif /* TIOCGLTC */ ! 2154: ! 2155: x = stty(ttyfd,&ttold); /* restore tty modes the old way. */ ! 2156: ! 2157: #endif /* ATTSV */ ! 2158: #endif /* BSD44ORPOSIX */ ! 2159: ! 2160: debug(F101,"ttres tty modes restore","",x); ! 2161: if (x < 0) debug(F101,"ttres errno","",errno); ! 2162: ! 2163: #ifdef BSD41 ! 2164: if (ttld > -1) { /* Put back line discipline */ ! 2165: x = ioctl(ttyfd, TIOCSETD, &ttld); ! 2166: debug(F101,"ttres line discipline restore","",x); ! 2167: if (x < 0) debug(F101,"...ioctl errno","",errno); ! 2168: ttld = -1; ! 2169: } ! 2170: #endif /* BSD41 */ ! 2171: ! 2172: #ifdef sony_news ! 2173: x = xlocal ? km_ext : km_con; /* Restore Kanji mode. */ ! 2174: if (x != -1) { /* Make sure we know original modes. */ ! 2175: if (ioctl(ttyfd,TIOCKSET, &x) < 0) { ! 2176: perror("ttres can't set Kanji mode"); ! 2177: debug(F101,"ttres error setting Kanji mode","",x); ! 2178: return(-1); ! 2179: } ! 2180: } ! 2181: debug(F100,"ttres set Kanji mode ok","",0); ! 2182: #endif /* sony_news */ ! 2183: ! 2184: tvtflg = 0; /* Invalidate terminal mode settings */ ! 2185: return(x); ! 2186: } ! 2187: ! 2188: /* T T R P I D -- Read pid from lockfile "name" (used by ttlock) */ ! 2189: ! 2190: int ! 2191: ttrpid(name) char *name; { ! 2192: int x, fd, pid; ! 2193: ! 2194: fd = open(name,O_RDONLY); /* Try to open lockfile. */ ! 2195: if (fd > 0) { ! 2196: ! 2197: #ifdef PIDSTRING ! 2198: char buf[12]; ! 2199: x = read(fd, buf, 11); /* For HDP UUCP, read pid string */ ! 2200: if (x < 0) return(-1); ! 2201: buf[11] = '\0'; ! 2202: if (x == 11) ! 2203: x = sscanf(buf,"%d",&pid); /* Get the integer pid from it. */ ! 2204: #else ! 2205: x = read(fd, (char *)&pid, sizeof(pid)); /* Else read integer pid */ ! 2206: #endif /* PIDSTRING */ ! 2207: ! 2208: if (x < 0) pid = -1; /* Return any errors. */ ! 2209: close(fd); /* Close the lockfile. */ ! 2210: } else pid = -1; ! 2211: return(pid); ! 2212: } ! 2213: ! 2214: /* T T L O C K */ ! 2215: ! 2216: /* ! 2217: This function attempts to coordinate use of the communication device with ! 2218: other copies of Kermit and any other program that follows the UUCP ! 2219: device-locking conventions, which, unfortunately, vary among different UNIX ! 2220: implementations. The idea is to look for a file of a certain name, the ! 2221: "lockfile", in a certain directory. If such a file is found, then the line ! 2222: is presumed to be in use, and Kermit should not use it. If no such file is ! 2223: found, Kermit attempts to create one so that other programs will not use the ! 2224: same line at the same time. Because the lockfile and/or the directory it's ! 2225: in might lack write permission for the person running Kermit, Kermit could ! 2226: find itself running setuid to uucp or other user that does have the ! 2227: necessary permissions. At startup, Kermit has changed its effective uid to ! 2228: the user's real uid, and so ttlock() must switch back to the original ! 2229: effective uid in order to create the lockfile, and then back again to the ! 2230: real uid to prevent unauthorized access to other directories or files owned ! 2231: by the user the program is setuid to. ! 2232: ! 2233: Totally rewritten for C-Kermit 5A to eliminate windows of vulnerability, ! 2234: based on suggestions from Warren Tucker. Call with pointer to name of ! 2235: tty device. Returns: ! 2236: ! 2237: 0 on success ! 2238: -1 on failure ! 2239: ! 2240: Note: Once privileges are turned on using priv_on(), it is essential that ! 2241: they are turned off again before this function returns. ! 2242: */ ! 2243: #ifdef SVR4 /* Lockfile uses device numbers. */ ! 2244: #ifndef LFDEVNO /* Define this for SVR4 */ ! 2245: #ifndef AIXRS /* But not for RS/6000 AIX 3.2 */ ! 2246: #define LFDEVNO /* If anybody else needs it, */ ! 2247: #endif /* AIXRS */ ! 2248: #endif /* LFDEVNO */ /* define it here or on CC */ ! 2249: #endif /* SVR4 */ /* command line. */ ! 2250: ! 2251: #ifdef LFDEVNO ! 2252: #include <sys/stat.h> /* For major() & minor() macros. */ ! 2253: /* Should be in <sys/types.h>. */ ! 2254: #ifndef major /* If we didn't find it */ ! 2255: #ifdef SVR4 /* then for Sys V R4 */ ! 2256: #include <sys/mkdev.h> /* look here */ ! 2257: #else /* or for Sunos versions */ ! 2258: #ifdef SUNOS4 /* ... */ ! 2259: #include <sys/sysmacros.h> /* look here */ ! 2260: #else /* Otherwise take a chance: */ ! 2261: #define major(dev) ( (int) ( ((unsigned)(dev) >> 8) & 0xff)) ! 2262: #define minor(dev) ( (int) ( (dev) & 0xff)) ! 2263: #endif /* SUNOS4 */ ! 2264: #endif /* SVR4 */ ! 2265: #endif /* major */ ! 2266: #endif /* LFDEVNO */ ! 2267: /* ! 2268: Note for RS/6000: routines ttylock(devicename), ttyunlock(devicename), ! 2269: and ttylocked(devicename) from the standard library (libc.a) could be ! 2270: used here instead. It's not clear whether there is any advantage in this. ! 2271: */ ! 2272: static int ! 2273: ttlock(ttdev) char *ttdev; { ! 2274: int x; ! 2275: ! 2276: #ifdef MINIX ! 2277: char *buf; ! 2278: #endif /* MINIX */ ! 2279: ! 2280: #ifdef NOUUCP ! 2281: strcpy(flfnam,"NOLOCK"); ! 2282: haslock = 1; ! 2283: return(0); ! 2284: #else /* !NOUUCP */ ! 2285: int lockfd; /* File descriptor for lock file. */ ! 2286: PID_T pid; /* Process id of this process. */ ! 2287: int fpid; /* pid found in existing lockfile. */ ! 2288: int tries; /* How many times we've tried... */ ! 2289: #ifdef LFDEVNO ! 2290: struct stat devbuf; /* For device numbers (SVR4). */ ! 2291: #endif /* LFDEVNO */ ! 2292: ! 2293: #ifdef PIDSTRING ! 2294: char pid_str[12]; /* My pid in string format. */ ! 2295: #endif /* PIDSTRING */ ! 2296: ! 2297: char *device, *devname; ! 2298: ! 2299: #define LFNAML 50 /* Max length for lock file name. */ ! 2300: char lockfil[LFNAML]; /* Lock file name */ ! 2301: #ifdef RTAIX ! 2302: char lklockf[LFNAML]; /* Name for link to lock file */ ! 2303: #endif /* RTAIX */ ! 2304: char tmpnam[LFNAML+30]; /* Temporary lockfile name. */ ! 2305: char *lockdir = LOCK_DIR; /* Defined near top of this file, */ ! 2306: /* or on cc command line. */ ! 2307: ! 2308: haslock = 0; /* Not locked yet. */ ! 2309: *flfnam = '\0'; /* Lockfile name is empty. */ ! 2310: pid = getpid(); /* Get id of this process. */ ! 2311: ! 2312: /* Construct name of lockfile and temporary file */ ! 2313: ! 2314: /* device = name of tty device without the path, e.g. "ttyh8" */ ! 2315: /* lockfil = name of lock file, without path, e.g. "LCK..ttyh8" */ ! 2316: ! 2317: device = ((devname = xxlast(ttdev,'/')) != NULL ? devname+1 : ttdev); ! 2318: ! 2319: #ifdef ISIII /* Interactive System III, PC/IX */ ! 2320: strcpy(lockfil, device); ! 2321: #else ! 2322: #ifdef LFDEVNO /* Lockfilename has device numbers. */ ! 2323: if (stat(ttdev,&devbuf) < 0) ! 2324: return(-1); ! 2325: sprintf(lockfil,"LK.%03d.%03d.%03d", ! 2326: major(devbuf.st_dev), /* inode */ ! 2327: major(devbuf.st_rdev), /* major device number */ ! 2328: minor(devbuf.st_rdev)); /* minor device number */ ! 2329: ! 2330: #else /* Others... */ ! 2331: #ifdef PTX /* Dynix PTX */ ! 2332: if (device != &ttdev[5] && strncmp(ttdev,"/dev/",5)==0) { ! 2333: sprintf(lockfil,"LCK..%.3s%s", &ttdev[5], device); ! 2334: } else ! 2335: #endif /* PTX */ ! 2336: sprintf(lockfil,"LCK..%s", device); ! 2337: #ifdef M_XENIX /* SCO Xenix */ ! 2338: { int x; char c; ! 2339: x = (int)strlen(lockfil) - 1; /* Get last letter of device name. */ ! 2340: if (x > 0) { /* If it's uppercase, lower it. */ ! 2341: c = lockfil[x]; ! 2342: if (c >= 'A' && c <= 'Z') lockfil[x] += ('a' - 'A'); ! 2343: } ! 2344: } ! 2345: #endif /* M_XENIX */ ! 2346: #ifdef RTAIX ! 2347: strcpy(lklockf,device); ! 2348: #endif /* RTAIX */ ! 2349: #endif /* LFDEVNO */ ! 2350: #endif /* ISIII */ ! 2351: ! 2352: /* flfnam = full lockfile pathname, e.g. "/usr/spool/uucp/LCK..ttyh8" */ ! 2353: /* tmpnam = temporary unique, e.g. "/usr/spool/uucp/LTMP..pid" */ ! 2354: ! 2355: sprintf(flfnam,"%s/%s",lockdir,lockfil); ! 2356: #ifdef RTAIX ! 2357: sprintf(lkflfn,"%s/%s",lockdir,lklockf); ! 2358: #endif /* RTAIX */ ! 2359: sprintf(tmpnam,"%s/LTMP.%05d",lockdir,(int) pid); ! 2360: debug(F110,"ttlock flfnam",flfnam,0); ! 2361: debug(F110,"ttlock tmpnam",tmpnam,0); ! 2362: ! 2363: priv_on(); /* Turn on privileges if possible. */ ! 2364: lockfd = creat(tmpnam, 0444); /* Try to create temp lock file. */ ! 2365: if (lockfd < 0) { /* Create failed. */ ! 2366: debug(F111,"ttlock creat failed",tmpnam,errno); ! 2367: if (errno == ENOENT) { ! 2368: perror(lockdir); ! 2369: printf("UUCP not installed or Kermit misconfigured\n"); ! 2370: } else { ! 2371: perror(lockdir); ! 2372: unlink(tmpnam); /* Get rid of the temporary file. */ ! 2373: } ! 2374: priv_off(); /* Turn off privileges!!! */ ! 2375: return(-1); /* Return failure code. */ ! 2376: } ! 2377: /* Now write the pid into the temp lockfile in the appropriate format */ ! 2378: ! 2379: #ifdef PIDSTRING /* For Honey DanBer UUCP, */ ! 2380: sprintf(pid_str,"%10d\n", (int) pid); /* Write pid as decimal string. */ ! 2381: write(lockfd, pid_str, 11); ! 2382: debug(F111,"ttlock hdb pid string",pid_str,(int) pid); ! 2383: #else /* Others use integer pid */ ! 2384: write(lockfd, (char *)&pid, sizeof(pid) ); ! 2385: debug(F111,"ttlock pid","",(int) pid); ! 2386: #endif /* PIDSTRING */ ! 2387: ! 2388: /* Now try to rename the temp file to the real lock file name. */ ! 2389: /* This will fail if a lock file of that name already exists. */ ! 2390: ! 2391: close(lockfd); /* Close the temp lockfile. */ ! 2392: chmod(tmpnam,0444); /* Permission for a valid lock. */ ! 2393: tries = 0; ! 2394: while (!haslock && tries++ < 2) { ! 2395: haslock = (link(tmpnam,flfnam) == 0); /* Create a link to it. */ ! 2396: if (haslock) { /* If we got the lockfile */ ! 2397: #ifdef RTAIX ! 2398: link(flfnam,lkflfn); ! 2399: #endif /* RTAIX */ ! 2400: #ifdef LOCKF ! 2401: /* ! 2402: Advisory file locking works on SVR4, so we use it. In fact, it is ! 2403: necessary in some cases, e.g. when SLIP is involved. ! 2404: */ ! 2405: while ( lockf(ttyfd, F_TLOCK, 0L) != 0 ) { ! 2406: debug(F111, "ttlock: lockf returns errno", "", errno); ! 2407: if ( (++tries >= 3) || (errno != EAGAIN) ) { ! 2408: x = unlink(flfnam); /* remove the lockfile */ ! 2409: debug(F111,"ttlock unlink",flfnam,x); ! 2410: haslock = 0; ! 2411: break; ! 2412: } ! 2413: sleep(2); ! 2414: } ! 2415: if (haslock) /* If we got an advisory lock */ ! 2416: #endif /* LOCKF */ ! 2417: break; /* We're done. */ ! 2418: ! 2419: } else { /* We didn't create a new lockfile. */ ! 2420: if ((fpid = ttrpid(flfnam)) > -1) { /* Read pid from old one. */ ! 2421: if (fpid > 0) { ! 2422: debug(F101,"ttlock fpid","",fpid); ! 2423: errno = 0; /* See if process still exists. */ ! 2424: x = kill((PID_T) fpid,0); ! 2425: debug(F101,"ttlock kill","",x); ! 2426: debug(F101,"ttlock kill errno","",errno); ! 2427: if (x < 0 && errno == ESRCH) { /* pid is invalid */ ! 2428: debug(F111,"ttlock removing stale lock",flfnam, ! 2429: fpid); ! 2430: if (!backgrd) ! 2431: printf( ! 2432: "Removing stale lock %s (pid %d terminated)\n", ! 2433: flfnam,fpid); ! 2434: x = unlink(flfnam); /* remove the lockfile. */ ! 2435: debug(F111,"ttlock unlink",flfnam,x); ! 2436: continue; /* and go back and try again. */ ! 2437: } else if ((x < 0 && errno == EPERM) || x == 0) { ! 2438: unlink(tmpnam); /* Delete the tempfile */ ! 2439: debug(F101,"ttlock found tty locked","",fpid); ! 2440: priv_off(); /* Turn off privs */ ! 2441: return(-2); /* Code for device is in use. */ ! 2442: } ! 2443: } else { ! 2444: debug(F101,"ttlock can't get fpid","",fpid); ! 2445: break; ! 2446: } ! 2447: } else break; /* Couldn't read pid from old file */ ! 2448: } ! 2449: } ! 2450: unlink(tmpnam); /* Unlink (remove) the temp file. */ ! 2451: priv_off(); /* Turn off privs */ ! 2452: return(haslock ? 0 : -1); /* Return link's return code. */ ! 2453: #endif /* !NOUUCP */ ! 2454: } ! 2455: ! 2456: /* T T U N L O C K */ ! 2457: ! 2458: static int ! 2459: ttunlck() { /* Remove UUCP lockfile. */ ! 2460: #ifndef NOUUCP ! 2461: if (haslock && *flfnam) { ! 2462: priv_on(); /* Turn privileges on. */ ! 2463: unlink(flfnam); /* Remove the lockfile. */ ! 2464: #ifdef RTAIX ! 2465: unlink(lkflfn); /* Remove other lockfile */ ! 2466: #endif /* RTAIX */ ! 2467: #ifdef LOCKF ! 2468: (void) lockf(ttyfd, F_ULOCK, 0L); /* Remove advisory lock */ ! 2469: #endif /* LOCKF */ ! 2470: *flfnam = '\0'; /* Erase the name. */ ! 2471: priv_off(); /* Turn privileges off. */ ! 2472: } ! 2473: #endif /* !NOUUCP */ ! 2474: return(0); ! 2475: } ! 2476: ! 2477: /* 4.3BSD-style UUCP line direction control (Stan Barber, Rice U) */ ! 2478: ! 2479: #ifdef ACUCNTRL ! 2480: VOID ! 2481: acucntrl(flag,ttname) char *flag, *ttname; { ! 2482: char x[DEVNAMLEN+32], *device, *devname; ! 2483: ! 2484: if (strcmp(ttname,CTTNAM) == 0 || xlocal == 0) /* If not local, */ ! 2485: return; /* just return. */ ! 2486: device = ((devname = xxlast(ttname,'/')) != NULL ? devname+1 : ttname); ! 2487: if (strncmp(device,"LCK..",4) == 0) device += 5; ! 2488: sprintf(x,"/usr/lib/uucp/acucntrl %s %s",flag,device); ! 2489: debug(F110,"called ",x,0); ! 2490: zsyscmd(x); ! 2491: } ! 2492: #endif /* ACUCNTRL */ ! 2493: ! 2494: /* ! 2495: T T H F L O W -- Set hardware flow control. ! 2496: */ ! 2497: static int ! 2498: tthflow(flow) int flow; { ! 2499: int x = 0; /* Return code */ ! 2500: ! 2501: /* There is no hardware flow control in POSIX. */ ! 2502: ! 2503: /* ! 2504: For SunOS 4.0 and later in the BSD environment ... ! 2505: ! 2506: The declarations are copied and interpreted from the System V header files, ! 2507: so we don't actually have to pull in all the System V junk when building ! 2508: C-Kermit for SunOS in the BSD environment, which would be dangerous because ! 2509: having those symbols defined would cause us to take the wrong paths through ! 2510: the code. The code in this section is used in both the BSD and Sys V SunOS ! 2511: versions. ! 2512: */ ! 2513: #ifdef SUNOS41 ! 2514: /* ! 2515: In SunOS 4.1 and later, we use the POSIX calls rather than ioctl calls ! 2516: because GNU CC uses different formats for the _IOxxx macros than regular CC; ! 2517: the POSIX forms work for both. But the POSIX calls are not available in ! 2518: SunOS 4.0. ! 2519: */ ! 2520: #define CRTSCTS 0x80000000 /* RTS/CTS flow control */ ! 2521: #define TCSANOW 0 /* Do it now */ ! 2522: ! 2523: struct termios { ! 2524: unsigned long c_iflag; /* Input modes */ ! 2525: unsigned long c_oflag; /* Output modes */ ! 2526: unsigned long c_cflag; /* Control modes */ ! 2527: unsigned long c_lflag; /* Line discipline modes */ ! 2528: char c_line; ! 2529: CHAR c_cc[17]; ! 2530: }; ! 2531: struct termios temp; ! 2532: ! 2533: _PROTOTYP( int tcgetattr, (int, struct termios *) ); ! 2534: _PROTOTYP( int tcsetattr, (int, int, struct termios *) ); ! 2535: ! 2536: /* ! 2537: When CRTSCTS is set, SunOS won't do output unless both CTS and CD are ! 2538: asserted. So we don't set CRTSCTS unless CD is up. This should be OK, ! 2539: since we don't need RTS/CTS during dialing, and after dialing is complete, ! 2540: we should have CD. If not, we still communicate, but without RTS/CTS. ! 2541: */ ! 2542: int mflags; /* Modem signal flags */ ! 2543: if (ioctl(ttyfd,TIOCMGET,&mflags) > -1 && /* Get modem signals */ ! 2544: (mflags & TIOCM_CAR)) { /* Check for CD */ ! 2545: debug(F100,"tthflow SunOS has CD","",0); ! 2546: if (tcgetattr(ttyfd, &temp) > -1 && /* Get device attributes */ ! 2547: !(temp.c_cflag & CRTSCTS)) { /* Check for RTS/CTS */ ! 2548: temp.c_cflag |= CRTSCTS; /* Not there, add it */ ! 2549: x = tcsetattr(ttyfd,TCSANOW,&temp); ! 2550: } ! 2551: } else debug(F100,"tthflow SunOS no CD","",0); ! 2552: #else ! 2553: #ifdef SUNOS4 ! 2554: /* ! 2555: SunOS 4.0 (and maybe earlier?). This code is dangerous because it ! 2556: prevents compilation with GNU gcc, which uses different formats for the ! 2557: _IORxxx macros than regular cc. SunOS 4.1 and later can use the POSIX ! 2558: routines in the #else part of this clause, which work for both cc and gcc. ! 2559: */ ! 2560: #define TCGETS _IOR(T, 8, struct termios) /* Get modes into termios struct */ ! 2561: #define TCSETS _IOW(T, 9, struct termios) /* Set modes from termios struct */ ! 2562: #define CRTSCTS 0x80000000 /* RTS/CTS flow control */ ! 2563: ! 2564: struct termios { ! 2565: unsigned long c_iflag; /* Input modes */ ! 2566: unsigned long c_oflag; /* Output modes */ ! 2567: unsigned long c_cflag; /* Control modes */ ! 2568: unsigned long c_lflag; /* Line discipline modes */ ! 2569: char c_line; ! 2570: CHAR c_cc[17]; ! 2571: }; ! 2572: struct termios temp; ! 2573: ! 2574: if (ioctl(ttyfd,TCGETS,&temp) > -1) { /* Get current terminal modes. */ ! 2575: temp.c_cflag |= CRTSCTS; /* Add RTS/CTS to them. */ ! 2576: x = ioctl(ttyfd,TCSETS,&temp); /* Set them again. */ ! 2577: } ! 2578: #else /* Not SunOS 4.0 or later */ ! 2579: #ifdef ATTSV ! 2580: if (flow == FLO_RTSC) { ! 2581: /* RTS/CTS Flow control... */ ! 2582: #ifdef RTSXOFF ! 2583: /* This is the preferred way, according to SVID R4 */ ! 2584: if (ioctl(ttyfd,TCGETX,&rctsx) > -1) { ! 2585: rctsx.x_hflag |= RTSXOFF | CTSXON; ! 2586: x = ioctl(ttyfd,TCSETX,&rctsx); ! 2587: } ! 2588: #endif /* RTSXOFF */ ! 2589: } ! 2590: if (flow == FLO_DTRC) { ! 2591: /* DTR/CD Flow control... */ ! 2592: #ifdef DTRXOFF ! 2593: /* This is straight out of SVID R4 */ ! 2594: if (ioctl(ttyfd,TCGETX,&rctsx) > -1) { ! 2595: rctsx.x_hflag |= DTRXOFF | CDXON; ! 2596: x = ioctl(ttyfd,TCSETX,&rctsx); ! 2597: } ! 2598: #endif /* DTRXOFF */ ! 2599: } ! 2600: #else /* not System V */ ! 2601: #ifdef CK_DTRCTS ! 2602: x = LDODTR | LDOCTS; /* Found only on UTEK? */ ! 2603: if (flow == FLO_DTRT) { /* Use hardware flow control */ ! 2604: if (lmodef) { ! 2605: x = ioctl(ttyfd,TIOCLBIS,&x); ! 2606: if (x < 0) { ! 2607: debug(F100,"hardflow TIOCLBIS error","",0); ! 2608: } else { ! 2609: lmodef++; ! 2610: debug(F100,"hardflow TIOCLBIS ok","",0); ! 2611: } ! 2612: } ! 2613: } else { ! 2614: if (lmodef) { ! 2615: x = ioctl(ttyfd,TIOCLBIC,&x); ! 2616: if (x < 0) { ! 2617: debug(F100,"hardflow TIOCLBIC error","",0); ! 2618: } else { ! 2619: lmodef++; ! 2620: debug(F100,"hardflow TIOCLBIC ok","",0); ! 2621: } ! 2622: } ! 2623: } ! 2624: #endif /* CK_DTRCTS */ ! 2625: #endif /* ATTSV */ ! 2626: #endif /* SUNOS4 */ ! 2627: #endif /* SUNOS41 */ ! 2628: return(x); ! 2629: } ! 2630: ! 2631: /* T T P K T -- Condition the communication line for packets */ ! 2632: /* or for modem dialing */ ! 2633: ! 2634: /* ! 2635: If called with speed > -1, also set the speed. ! 2636: Returns 0 on success, -1 on failure. ! 2637: ! 2638: NOTE: the "xflow" parameter is supposed to be the currently selected ! 2639: type of flow control, but for historical reasons, this parameter is also ! 2640: used to indicate that we are dialing. Therefore, when the true flow ! 2641: control setting is needed, we access the external variable "flow", rather ! 2642: than trusting our "xflow" argument. ! 2643: */ ! 2644: int ! 2645: #ifdef CK_ANSIC ! 2646: ttpkt(long speed, int xflow, int parity) ! 2647: #else ! 2648: ttpkt(speed,xflow,parity) long speed; int xflow, parity; ! 2649: #endif /* CK_ANSIC */ ! 2650: /* ttpkt */ { ! 2651: int s2; ! 2652: int s = -1; ! 2653: #ifndef SVORPOSIX ! 2654: int x; ! 2655: #endif /* SVORPOSIX */ ! 2656: extern int flow; /* REAL flow-control setting */ ! 2657: ! 2658: if (ttyfd < 0) return(-1); /* Not open. */ ! 2659: ! 2660: debug(F101,"ttpkt parity","",parity); ! 2661: debug(F101,"ttpkt xflow","",xflow); ! 2662: debug(F101,"ttpkt speed","",(int) speed); ! 2663: ! 2664: ttprty = parity; /* Let other tt functions see these. */ ! 2665: ttpflg = 0; /* Parity not sensed yet */ ! 2666: ttpmsk = ttprty ? 0177 : 0377; /* Parity stripping mask */ ! 2667: ttspeed = speed; /* Make global copy for this module */ ! 2668: ! 2669: #ifdef NETCONN /* Nothing to do for telnet */ ! 2670: if (netconn) return (0); ! 2671: #endif /* NETCONN */ ! 2672: ! 2673: if (ttfdflg && !isatty(ttyfd)) return(0); ! 2674: ! 2675: #ifndef SVORPOSIX /* Berkeley, V7, etc. */ ! 2676: #ifdef LPASS8 ! 2677: /* ! 2678: For some reason, with BSD terminal drivers, you can't set FLOW to XON/XOFF ! 2679: after having previously set it to NONE without closing and reopening the ! 2680: device. Unless there's something I overlooked below... ! 2681: */ ! 2682: if (ttflow == FLO_NONE && flow == FLO_XONX && xlocal == 0) { ! 2683: debug(F101,"ttpkt executing horrible flow kludge","",0); ! 2684: ttclos(0); /* Close it */ ! 2685: x = 0; ! 2686: ttopen(ttnmsv,&x,ttmdm,0); /* Open it again */ ! 2687: } ! 2688: #endif /* LPASS8 */ ! 2689: #endif /* SVORPOSIX */ ! 2690: ! 2691: if (xflow != FLO_DIAL && xflow != FLO_DIAX) ! 2692: ttflow = xflow; /* Now make this available too. */ ! 2693: ! 2694: if (xlocal) { ! 2695: s2 = (int) (speed / 10L); /* Convert bps to cps */ ! 2696: s = ttsspd(s2); /* Check and set the speed */ ! 2697: debug(F101,"ttpkt carrier","",xflow); ! 2698: carrctl(&ttraw, xflow != FLO_DIAL /* Carrier control */ ! 2699: && (ttcarr == CAR_ON)); ! 2700: tvtflg = 0; /* So ttvt() will work next time */ ! 2701: } ! 2702: ! 2703: #ifndef SVORPOSIX /* BSD section */ ! 2704: if (flow == FLO_RTSC || /* Hardware flow control */ ! 2705: flow == FLO_DTRC || ! 2706: flow == FLO_DTRT) { ! 2707: tthflow(flow); ! 2708: debug(F100,"ttpkt hard flow, TANDEM off, RAW on","",0); ! 2709: ttraw.sg_flags &= ~TANDEM; /* Don't ask for it. */ ! 2710: ttraw.sg_flags |= RAW; ! 2711: } else if (flow == FLO_NONE) { /* No Xon/Xoff flow control */ ! 2712: debug(F100,"ttpkt no flow, TANDEM off, RAW on","",0); ! 2713: ttraw.sg_flags &= ~TANDEM; /* Don't ask for it. */ ! 2714: ttraw.sg_flags |= RAW; ! 2715: /* NOTE: We should also turn off hardware flow control here! */ ! 2716: } else if (flow == FLO_KEEP) { /* Keep device's original setting */ ! 2717: debug(F100,"ttpkt keeping original TANDEM","",0); ! 2718: ttraw.sg_flags &= ~TANDEM; ! 2719: ttraw.sg_flags |= (ttold.sg_flags & TANDEM); ! 2720: /* NOTE: We should also handle hardware flow control here! */ ! 2721: } ! 2722: ! 2723: /* SET FLOW XON/XOFF is in effect, or SET FLOW KEEP resulted in Xon/Xoff */ ! 2724: ! 2725: if ((flow == FLO_XONX) || (ttraw.sg_flags & TANDEM)) { ! 2726: debug(F100,"ttpkt turning on TANDEM","",0); ! 2727: ttraw.sg_flags |= TANDEM; /* So ask for it. */ ! 2728: ! 2729: #ifdef LPASS8 /* Can pass 8-bit data through? */ ! 2730: /* If the LPASS8 local mode is available, then flow control can always */ ! 2731: /* be used, even if parity is none and we are transferring 8-bit data. */ ! 2732: /* But we only need to do all this if Xon/Xoff is requested. */ ! 2733: /* BUT... this tends not to work through IP or LAT connections, terminal */ ! 2734: /* servers, telnet, rlogin, etc, so it is currently disabled. */ ! 2735: x = LPASS8; /* If LPASS8 defined, then */ ! 2736: debug(F100,"ttpkt executing LPASS8 code","",0); ! 2737: if (lmodef) { /* TIOCLBIS must be too. */ ! 2738: x = ioctl(ttyfd,TIOCLBIS,&x); /* Try to set LPASS8. */ ! 2739: if (x < 0) { ! 2740: debug(F100,"ttpkt TIOCLBIS error","",0); ! 2741: } else { ! 2742: lmodef++; ! 2743: debug(F100,"ttpkt TIOCLBIS ok","",0); ! 2744: } ! 2745: } ! 2746: /* ! 2747: But if we use LPASS8 mode, we must explicitly turn off ! 2748: terminal interrupts of all kinds. ! 2749: */ ! 2750: #ifdef TIOCGETC /* Not rawmode, */ ! 2751: if (tcharf && (xlocal == 0)) { /* must turn off */ ! 2752: tchnoi.t_intrc = -1; /* interrupt character */ ! 2753: tchnoi.t_quitc = -1; /* and quit character. */ ! 2754: tchnoi.t_startc = 17; /* Make sure xon */ ! 2755: tchnoi.t_stopc = 19; /* and xoff not ignored. */ ! 2756: #ifndef NOBRKC ! 2757: tchnoi.t_eofc = -1; /* eof character. */ ! 2758: tchnoi.t_brkc = -1; /* brk character. */ ! 2759: #endif /* NOBRKC */ ! 2760: if (ioctl(ttyfd,TIOCSETC,&tchnoi) < 0) { ! 2761: debug(F100,"ttpkt TIOCSETC failed","",0); ! 2762: } else { ! 2763: tcharf = 1; ! 2764: debug(F100,"ttpkt TIOCSETC ok","",0); ! 2765: } ! 2766: #ifdef COMMENT ! 2767: /* only for paranoid debugging */ ! 2768: if (tcharf) { ! 2769: struct tchars foo; ! 2770: char tchbuf[100]; ! 2771: ioctl(0,TIOCGETC,&foo); ! 2772: sprintf(tchbuf, ! 2773: "intr=%d,quit=%d, start=%d, stop=%d, eof=%d, brk=%d", ! 2774: foo.t_intrc, foo.t_quitc, foo.t_startc, ! 2775: foo.t_stopc, foo.t_eofc, foo.t_brkc); ! 2776: debug(F110,"ttpkt chars",tchbuf,0); ! 2777: } ! 2778: #endif /* COMMENT */ ! 2779: } ! 2780: ttraw.sg_flags |= CBREAK; /* Needed for unknown reason */ ! 2781: #endif /* TIOCGETC */ ! 2782: ! 2783: /* Prevent suspend during packet mode */ ! 2784: #ifdef TIOCGLTC /* Not rawmode, */ ! 2785: if (ltcharf && (xlocal == 0)) { /* must turn off */ ! 2786: ltchnoi.t_suspc = -1; /* suspend character */ ! 2787: ltchnoi.t_dsuspc = -1; /* and delayed suspend character */ ! 2788: if (ioctl(ttyfd,TIOCSLTC,&tchnoi) < 0) { ! 2789: debug(F100,"ttpkt TIOCSLTC failed","",0); ! 2790: } else { ! 2791: ltcharf = 1; ! 2792: debug(F100,"ttpkt TIOCSLTC ok","",0); ! 2793: } ! 2794: } ! 2795: #endif /* TIOCGLTC */ ! 2796: ! 2797: #else /* LPASS8 not defined */ ! 2798: ! 2799: /* Previously, BSD-based implementations always */ ! 2800: /* used rawmode for packets. Now, we use rawmode only if parity is NONE. */ ! 2801: /* This allows the flow control requested above to actually work, but only */ ! 2802: /* if the user asks for parity (which also means they get 8th-bit quoting). */ ! 2803: ! 2804: if (parity) { /* If parity, */ ! 2805: ttraw.sg_flags &= ~RAW; /* use cooked mode */ ! 2806: #ifdef COMMENT ! 2807: /* WHY??? */ ! 2808: if (xlocal) ! 2809: #endif /* COMMENT */ ! 2810: ttraw.sg_flags |= CBREAK; ! 2811: debug(F101,"ttpkt cooked, cbreak, parity","",parity); ! 2812: #ifdef TIOCGETC /* Not rawmode, */ ! 2813: if (tcharf && (xlocal == 0)) { /* must turn off */ ! 2814: tchnoi.t_intrc = -1; /* interrupt character */ ! 2815: tchnoi.t_quitc = -1; /* and quit character. */ ! 2816: tchnoi.t_startc = 17; /* Make sure xon */ ! 2817: tchnoi.t_stopc = 19; /* and xoff not ignored. */ ! 2818: #ifndef NOBRKC ! 2819: tchnoi.t_eofc = -1; /* eof character. */ ! 2820: tchnoi.t_brkc = -1; /* brk character. */ ! 2821: #endif /* NOBRKC */ ! 2822: if (ioctl(ttyfd,TIOCSETC,&tchnoi) < 0) { ! 2823: debug(F100,"ttpkt TIOCSETC failed","",0); ! 2824: } else { ! 2825: tcharf = 1; ! 2826: debug(F100,"ttpkt TIOCSETC ok","",0); ! 2827: } ! 2828: } ! 2829: #endif /* TIOCGETC */ ! 2830: #ifdef TIOCGLTC /* Not rawmode, */ ! 2831: /* Prevent suspend during packet mode */ ! 2832: if (ltcharf && (xlocal == 0)) { /* must turn off */ ! 2833: ltchnoi.t_suspc = -1; /* suspend character */ ! 2834: ltchnoi.t_dsuspc = -1; /* and delayed suspend character */ ! 2835: if (ioctl(ttyfd,TIOCSLTC,&tchnoi) < 0) { ! 2836: debug(F100,"ttpkt TIOCSLTC failed","",0); ! 2837: } else { ! 2838: ltcharf = 1; ! 2839: debug(F100,"ttpkt TIOCSLTC ok","",0); ! 2840: } ! 2841: } ! 2842: #endif /* TIOCGLTC */ ! 2843: } else { /* If no parity, */ ! 2844: ttraw.sg_flags |= RAW; /* must use 8-bit raw mode. */ ! 2845: debug(F101,"ttpkt setting rawmode, parity","",parity); ! 2846: } ! 2847: #endif /* LPASS8 */ ! 2848: } /* End of Xon/Xoff section */ ! 2849: ! 2850: /* Don't echo, don't map CR to CRLF on output, don't fool with case */ ! 2851: #ifdef LCASE ! 2852: ttraw.sg_flags &= ~(ECHO|CRMOD|LCASE); ! 2853: #else ! 2854: ttraw.sg_flags &= ~(ECHO|CRMOD); ! 2855: #endif /* LCASE */ ! 2856: ! 2857: #ifdef TOWER1 ! 2858: ttraw.sg_flags &= ~ANYP; /* Must set this on old Towers */ ! 2859: #endif /* TOWER1 */ ! 2860: ! 2861: if (stty(ttyfd,&ttraw) < 0) return(-1); /* Set the new modes. */ ! 2862: debug(F100,"ttpkt stty ok","",0); ! 2863: ! 2864: #ifdef sony_news ! 2865: x = xlocal ? km_ext : km_con; /* Put line in ASCII mode. */ ! 2866: if (x != -1) { /* Make sure we know original modes. */ ! 2867: x &= ~KM_TTYPE; ! 2868: x |= KM_ASCII; ! 2869: if (ioctl(ttyfd,TIOCKSET, &x) < 0) { ! 2870: perror("ttpkt can't set ASCII mode"); ! 2871: debug(F101,"ttpkt error setting ASCII mode","",x); ! 2872: return(-1); ! 2873: } ! 2874: } ! 2875: debug(F100,"ttpkt set ASCII mode ok","",0); ! 2876: #endif /* sony_news */ ! 2877: ! 2878: if (xlocal == 0) /* Turn this off so we can read */ ! 2879: signal(SIGINT,SIG_IGN); /* Ctrl-C chars typed at console */ ! 2880: ! 2881: tvtflg = 0; /* So ttvt() will work next time */ ! 2882: return(0); ! 2883: ! 2884: #endif /* Not ATTSV or POSIX */ ! 2885: ! 2886: /* AT&T UNIX and POSIX */ ! 2887: ! 2888: #ifdef SVORPOSIX ! 2889: if (flow == FLO_XONX) /* Xon/Xoff */ ! 2890: ttraw.c_iflag |= (IXON|IXOFF); ! 2891: else if (flow == FLO_NONE) /* None */ ! 2892: /* NOTE: We should also turn off hardware flow control here! */ ! 2893: ttraw.c_iflag &= ~(IXON|IXOFF); ! 2894: else if (flow == FLO_KEEP) { /* Keep */ ! 2895: ttraw.c_iflag &= ~(IXON|IXOFF); /* Turn off Xon/Xoff flags */ ! 2896: ttraw.c_iflag |= (ttold.c_iflag & (IXON|IXOFF)); /* OR in old ones */ ! 2897: /* NOTE: We should also handle hardware flow control here! */ ! 2898: } else if (flow == FLO_RTSC || /* Hardware */ ! 2899: flow == FLO_DTRC || ! 2900: flow == FLO_DTRT) ! 2901: tthflow(flow); ! 2902: ! 2903: ttraw.c_lflag &= ~(ICANON|ECHO); ! 2904: ttraw.c_lflag &= ~ISIG; /* Do NOT check for interrupt chars */ ! 2905: ttraw.c_lflag &= ~IEXTEN; /* Turn off ^O/^V processing */ ! 2906: ttraw.c_lflag |= NOFLSH; /* Don't flush */ ! 2907: ttraw.c_iflag |= (BRKINT|IGNPAR); ! 2908: #ifdef ATTSV ! 2909: #ifdef BSD44 ! 2910: ttraw.c_iflag &= ~(IGNBRK|INLCR|IGNCR|ICRNL|INPCK|ISTRIP|IXANY); ! 2911: #else ! 2912: ttraw.c_iflag &= ~(IGNBRK|INLCR|IGNCR|ICRNL|IUCLC|INPCK|ISTRIP|IXANY); ! 2913: #endif /* BSD44 */ ! 2914: #else /* POSIX */ ! 2915: ttraw.c_iflag &= ~(IGNBRK|INLCR|IGNCR|ICRNL|INPCK|ISTRIP); ! 2916: #endif /* ATTSV */ ! 2917: ttraw.c_oflag &= ~OPOST; ! 2918: ttraw.c_cflag &= ~(CSIZE|PARENB); ! 2919: ttraw.c_cflag |= (CS8|CREAD|HUPCL); ! 2920: #ifdef IX370 ! 2921: ttraw.c_cc[4] = 48; /* So Series/1 doesn't interrupt on every char */ ! 2922: ttraw.c_cc[5] = 1; ! 2923: #else ! 2924: #ifndef VEOF /* for DGUX this is VEOF, not VMIN */ ! 2925: ttraw.c_cc[4] = 1; /* [VMIN] return max of this many characters or */ ! 2926: #else ! 2927: #ifdef VMIN ! 2928: ttraw.c_cc[VMIN] = 1; ! 2929: #endif /* VMIN */ ! 2930: #endif /* VEOF */ ! 2931: #ifndef VEOL /* for DGUX this is VEOL, not VTIME */ ! 2932: ttraw.c_cc[5] = 0; /* [VTIME] when this many secs/10 expire w/no input */ ! 2933: #else ! 2934: #ifdef VTIME ! 2935: ttraw.c_cc[VTIME] = 0; ! 2936: #endif /* VTIME */ ! 2937: #endif /* VEOL */ ! 2938: #endif /* IX370 */ ! 2939: ! 2940: #ifdef VINTR /* Turn off interrupt character */ ! 2941: if (xlocal == 0) /* so ^C^C can break us out of */ ! 2942: ttraw.c_cc[VINTR] = 0; /* packet mode. */ ! 2943: #endif /* VINTR */ ! 2944: ! 2945: #ifdef BSD44ORPOSIX ! 2946: if (xlocal && (s > 0)) { ! 2947: cfsetispeed(&ttraw,s); ! 2948: cfsetospeed(&ttraw,s); ! 2949: } ! 2950: if (tcsetattr(ttyfd,TCSADRAIN,&ttraw) < 0) return(-1); ! 2951: #else /* ATTSV */ ! 2952: if (xlocal && (s > 0)) { /* set speed */ ! 2953: ttraw.c_cflag &= ~CBAUD; ! 2954: ttraw.c_cflag |= s; ! 2955: } ! 2956: if (ioctl(ttyfd,TCSETAW,&ttraw) < 0) return(-1); /* set new modes . */ ! 2957: #endif /* BSD44ORPOSIX */ ! 2958: tvtflg = 0; ! 2959: return(0); ! 2960: #endif /* ATTSV */ ! 2961: } ! 2962: ! 2963: /* T T V T -- Condition communication line for use as virtual terminal */ ! 2964: ! 2965: int ! 2966: #ifdef CK_ANSIC ! 2967: ttvt(long speed, int flow) ! 2968: #else ! 2969: ttvt(speed,flow) long speed; int flow; ! 2970: #endif /* CK_ANSIC */ ! 2971: /* ttvt */ { ! 2972: int s, s2; ! 2973: ! 2974: debug(F101,"ttvt ttyfd","",ttyfd); ! 2975: debug(F101,"ttvt tvtflg","",tvtflg); ! 2976: debug(F101,"ttvt speed","",speed); ! 2977: if (ttyfd < 0) return(-1); /* Not open. */ ! 2978: #ifdef NETCONN ! 2979: if (netconn) { ! 2980: tvtflg = 1; /* Network connections */ ! 2981: return(0); /* require no special setup */ ! 2982: } ! 2983: #endif /* NETCONN */ ! 2984: ! 2985: if (tvtflg != 0 && speed == ttspeed && flow == ttflow && ttcarr == curcarr) ! 2986: return(0); /* Already been called. */ ! 2987: ! 2988: if (ttfdflg && !isatty(ttyfd)) return(0); ! 2989: ! 2990: if (xlocal) { /* For external lines... */ ! 2991: s2 = (int) (speed / 10L); ! 2992: s = ttsspd(s2); /* Check/set the speed */ ! 2993: carrctl(&tttvt, flow != FLO_DIAL /* Do carrier control */ ! 2994: && (ttcarr == CAR_ON || (ttcarr == CAR_AUT && ttmdm != 0))); ! 2995: } else s = s2 = -1; ! 2996: ! 2997: #ifndef SVORPOSIX ! 2998: /* Berkeley, V7, etc */ ! 2999: if (flow == FLO_RTSC || /* Hardware flow control */ ! 3000: flow == FLO_DTRC || ! 3001: flow == FLO_DTRT) ! 3002: tthflow(flow); ! 3003: if (flow == FLO_XONX) { /* No Xon/Xoff flow control */ ! 3004: tttvt.sg_flags |= TANDEM; /* Ask for it. */ ! 3005: } else if (flow == FLO_KEEP) { ! 3006: tttvt.sg_flags &= ~TANDEM; ! 3007: tttvt.sg_flags |= (ttold.sg_flags & TANDEM); ! 3008: /* NOTE: We should also handle hardware flow control here! */ ! 3009: } else if (flow == FLO_NONE) { ! 3010: tttvt.sg_flags &= ~TANDEM; /* Don't ask for it. */ ! 3011: /* NOTE: We should also turn off hardware flow control here! */ ! 3012: } ! 3013: tttvt.sg_flags |= RAW; /* Raw mode in all cases */ ! 3014: #ifdef TOWER1 ! 3015: tttvt.sg_flags &= ~(ECHO|ANYP); /* No echo or parity */ ! 3016: #else ! 3017: tttvt.sg_flags &= ~ECHO; /* No echo */ ! 3018: #endif /* TOWER1 */ ! 3019: ! 3020: if (stty(ttyfd,&tttvt) < 0) /* Set the new modes */ ! 3021: return(-1); ! 3022: ! 3023: #else /* It is ATTSV or POSIX */ ! 3024: ! 3025: if (flow == FLO_RTSC || /* Hardware flow control */ ! 3026: flow == FLO_DTRC || ! 3027: flow == FLO_DTRT) ! 3028: tthflow(flow); ! 3029: else if (flow == FLO_XONX) /* Software flow control */ ! 3030: tttvt.c_iflag |= (IXON|IXOFF); /* On if requested. */ ! 3031: else if (flow == FLO_KEEP) { ! 3032: tttvt.c_iflag &= ~(IXON|IXOFF); /* Turn off Xon/Xoff flags */ ! 3033: tttvt.c_iflag |= (ttold.c_iflag & (IXON|IXOFF)); /* OR in old ones */ ! 3034: /* NOTE: We should also handle hardware flow control here! */ ! 3035: } else if (flow == FLO_NONE) /* Off if NONE or hardware */ ! 3036: tttvt.c_iflag &= ~(IXON|IXOFF); /* requested. */ ! 3037: ! 3038: tttvt.c_lflag &= ~(ISIG|ICANON|ECHO|IEXTEN); ! 3039: tttvt.c_iflag |= (IGNBRK|IGNPAR); ! 3040: #ifdef ATTSV ! 3041: #ifdef BSD44 ! 3042: tttvt.c_iflag &= ~(INLCR|IGNCR|ICRNL|BRKINT|INPCK|ISTRIP|IXANY); ! 3043: #else ! 3044: tttvt.c_iflag &= ~(INLCR|IGNCR|ICRNL|IUCLC|BRKINT|INPCK|ISTRIP|IXANY); ! 3045: #endif /* BSD44 */ ! 3046: #else /* POSIX */ ! 3047: tttvt.c_iflag &= ~(INLCR|IGNCR|ICRNL|BRKINT|INPCK|ISTRIP); ! 3048: #endif /* ATTSV */ ! 3049: tttvt.c_oflag &= ~OPOST; ! 3050: tttvt.c_cflag &= ~(CSIZE|PARENB); ! 3051: tttvt.c_cflag |= (CS8|CREAD|HUPCL); ! 3052: #ifndef VEOF /* DGUX termio has VEOF at entry 4, see comment above */ ! 3053: tttvt.c_cc[4] = 1; ! 3054: #else ! 3055: #ifdef VMIN ! 3056: tttvt.c_cc[VMIN] = 1; ! 3057: #endif /* VMIN */ ! 3058: #endif /* VEOF */ ! 3059: #ifndef VEOL /* DGUX termio has VEOL at entry 5, see comment above */ ! 3060: tttvt.c_cc[5] = 0; ! 3061: #else ! 3062: #ifdef VTIME ! 3063: tttvt.c_cc[VTIME] = 0; ! 3064: #endif /* VTIME */ ! 3065: #endif /* VEOL */ ! 3066: ! 3067: #ifdef BSD44ORPOSIX ! 3068: if (xlocal && (s > 0)) { ! 3069: cfsetispeed(&tttvt,s); ! 3070: cfsetospeed(&tttvt,s); ! 3071: } ! 3072: if (tcsetattr(ttyfd,TCSADRAIN,&tttvt) < 0) return(-1); ! 3073: #else /* ATTSV */ ! 3074: if (s > 0) { /* Set speed */ ! 3075: tttvt.c_cflag &= ~CBAUD; ! 3076: tttvt.c_cflag |= s; ! 3077: } ! 3078: if (ioctl(ttyfd,TCSETAW,&tttvt) < 0) return(-1); /* set new modes . */ ! 3079: #endif /* BSD44ORPOSIX */ ! 3080: #endif /* ATTSV */ ! 3081: ! 3082: ttspeed = speed; /* Done, remember how we were */ ! 3083: ttflow = flow; /* called, so we can decide how to */ ! 3084: tvtflg = 1; /* respond next time. */ ! 3085: ! 3086: debug(F101,"ttvt done","",tvtflg); ! 3087: return(0); ! 3088: } ! 3089: ! 3090: /* T T S S P D -- Checks and sets transmission rate. */ ! 3091: ! 3092: /* Call with speed in characters (not bits!) per second. */ ! 3093: /* Returns internal speed code if successful, -1 otherwise. */ ! 3094: ! 3095: int ! 3096: ttsspd(cps) int cps; { ! 3097: int s, s2; ! 3098: ! 3099: debug(F101,"ttsspd","",cps); ! 3100: ! 3101: #ifdef NETCONN ! 3102: if (netconn) return (0); ! 3103: #endif /* NETCONN */ ! 3104: ! 3105: if (cps < 0) return(-1); ! 3106: s = s2 = -1; ! 3107: ! 3108: /* First check that the given speed is valid. */ ! 3109: ! 3110: switch (cps) { ! 3111: #ifndef MINIX ! 3112: case 0: s = B0; break; ! 3113: case 5: s = B50; break; ! 3114: case 7: s = B75; break; ! 3115: #endif ! 3116: case 11: s = B110; break; ! 3117: #ifndef MINIX ! 3118: case 15: s = B150; break; ! 3119: case 20: s = B200; break; ! 3120: #endif ! 3121: case 30: s = B300; break; ! 3122: #ifndef MINIX ! 3123: case 60: s = B600; break; ! 3124: #endif ! 3125: case 120: s = B1200; break; ! 3126: #ifndef MINIX ! 3127: case 180: s = B1800; break; ! 3128: #endif ! 3129: case 240: s = B2400; break; ! 3130: case 480: s = B4800; break; ! 3131: #ifndef MINIX ! 3132: case 888: s = B75; s2 = B1200; break; /* 888 = 75/1200 split speed */ ! 3133: #endif ! 3134: case 960: s = B9600; break; ! 3135: #ifdef B19200 ! 3136: case 1920: s = B19200; break; ! 3137: #else ! 3138: #ifdef EXTA ! 3139: case 1920: s = EXTA; break; ! 3140: #endif ! 3141: #endif ! 3142: #ifdef B38400 ! 3143: case 3840: s = B38400; break; ! 3144: #else ! 3145: #ifdef EXTB ! 3146: case 3840: s = EXTB; break; ! 3147: #endif ! 3148: #endif ! 3149: default: ! 3150: return(-1); ! 3151: } ! 3152: /* Actually set the speed */ ! 3153: ! 3154: if (ttyfd > -1 && s > -1 && xlocal != 0) { ! 3155: if (s2 == -1) s2 = s; ! 3156: ! 3157: #ifdef BSD44ORPOSIX ! 3158: if (tcgetattr(ttyfd,&ttcur) < 0) return(-1); ! 3159: cfsetospeed(&ttcur,s); ! 3160: cfsetispeed(&ttcur,s2); ! 3161: cfsetospeed(&ttraw,s); ! 3162: cfsetispeed(&ttraw,s2); ! 3163: cfsetospeed(&tttvt,s); ! 3164: cfsetispeed(&tttvt,s2); ! 3165: cfsetospeed(&ttold,s); ! 3166: cfsetispeed(&ttold,s2); ! 3167: if (tcsetattr(ttyfd,TCSADRAIN,&ttcur) < 0) return(-1); ! 3168: #else ! 3169: #ifdef ATTSV ! 3170: if (cps == 888) return(-1); /* No split speeds, sorry. */ ! 3171: if (ioctl(ttyfd,TCGETA,&ttcur) < 0) return(-1); ! 3172: ttcur.c_cflag &= ~CBAUD; ! 3173: ttcur.c_cflag |= s; ! 3174: tttvt.c_cflag &= ~CBAUD; ! 3175: tttvt.c_cflag |= s; ! 3176: ttraw.c_cflag &= ~CBAUD; ! 3177: ttraw.c_cflag |= s; ! 3178: ttold.c_cflag &= ~CBAUD; ! 3179: ttold.c_cflag |= s; ! 3180: if (ioctl(ttyfd,TCSETAW,&ttcur) < 0) return(-1); ! 3181: #else ! 3182: if (gtty(ttyfd,&ttcur) < 0) return(-1); ! 3183: ttcur.sg_ospeed = s; ttcur.sg_ispeed = s2; ! 3184: tttvt.sg_ospeed = s; tttvt.sg_ispeed = s2; ! 3185: ttraw.sg_ospeed = s; ttraw.sg_ispeed = s2; ! 3186: ttold.sg_ospeed = s; ttold.sg_ispeed = s2; ! 3187: if (stty(ttyfd,&ttcur) < 0) return(-1); ! 3188: #endif /* ATTSV */ ! 3189: #endif /* BSD44ORPOSIX */ ! 3190: } ! 3191: return(s); ! 3192: } ! 3193: ! 3194: /* T T G S P D - Get speed of currently selected tty line */ ! 3195: ! 3196: /* ! 3197: Unreliable. After SET LINE, it returns an actual speed, but not the real ! 3198: speed. Apparently it always returns the line's nominal speed, from ! 3199: /etc/ttytab. Even if you SET SPEED to something else, this function might ! 3200: not notice. ! 3201: */ ! 3202: long ! 3203: ttgspd() { /* Get current tty speed */ ! 3204: int s; long ss; ! 3205: char temp[12]; ! 3206: ! 3207: #ifdef NETCONN ! 3208: if (netconn) return(-1); /* -1 if network connection */ ! 3209: #endif /* NETCONN */ ! 3210: ! 3211: if (ttyfd < 0) { ! 3212: #ifdef BSD44ORPOSIX ! 3213: s = cfgetospeed(&ccold); ! 3214: #else ! 3215: #ifdef ATTSV ! 3216: s = ccold.c_cflag & CBAUD; ! 3217: #else ! 3218: s = ccold.sg_ospeed; /* (obtained by congm()) */ ! 3219: #endif /* ATTSV */ ! 3220: #endif /* BSD44ORPOSIX */ ! 3221: ! 3222: } else { ! 3223: #ifdef BSD44ORPOSIX ! 3224: if (tcgetattr(ttyfd,&ttcur) < 0) return(-1); ! 3225: s = cfgetospeed(&ttcur); ! 3226: #else ! 3227: #ifdef ATTSV ! 3228: if (ioctl(ttyfd,TCGETA,&ttcur) < 0) return(-1); ! 3229: s = ttcur.c_cflag & CBAUD; ! 3230: #else ! 3231: if (gtty(ttyfd,&ttcur) < 0) return(-1); ! 3232: s = ttcur.sg_ospeed; ! 3233: #endif /* ATTSV */ ! 3234: #endif /* BSD44ORPOSIX */ ! 3235: } ! 3236: debug(F101,"ttgspd ttyfd","",ttyfd); ! 3237: debug(F101,"ttgspd code","",s); ! 3238: switch (s) { ! 3239: #ifdef B0 ! 3240: case B0: ss = 0L; break; ! 3241: #endif /* B0 */ ! 3242: ! 3243: #ifndef MINIX ! 3244: /* ! 3245: MINIX defines the Bxx symbols to be bps/100, so B50==B75, B110==B134==B150, ! 3246: etc, making for many "duplicate case in switch" errors, which are fatal. ! 3247: */ ! 3248: #ifdef B50 ! 3249: case B50: ss = 50L; break; ! 3250: #endif ! 3251: #ifdef B75 ! 3252: case B75: ss = 75L; break; ! 3253: #endif ! 3254: #endif /* MINIX */ ! 3255: ! 3256: #ifdef B110 ! 3257: case B110: ss = 110L; break; ! 3258: #endif ! 3259: ! 3260: #ifndef MINIX ! 3261: #ifdef B134 ! 3262: case B134: ss = 134L; break; ! 3263: #endif ! 3264: #ifdef B150 ! 3265: case B150: ss = 150L; break; ! 3266: #endif ! 3267: #endif /* MINIX */ ! 3268: ! 3269: #ifdef B200 ! 3270: case B200: ss = 200L; break; ! 3271: #endif ! 3272: ! 3273: #ifdef B300 ! 3274: case B300: ss = 300L; break; ! 3275: #endif ! 3276: #ifdef B600 ! 3277: case B600: ss = 600L; break; ! 3278: #endif ! 3279: #ifdef B1200 ! 3280: case B1200: ss = 1200L; break; ! 3281: #endif ! 3282: #ifdef B1800 ! 3283: case B1800: ss = 1800L; break; ! 3284: #endif ! 3285: #ifdef B2400 ! 3286: case B2400: ss = 2400L; break; ! 3287: #endif ! 3288: #ifdef B4800 ! 3289: case B4800: ss = 4800L; break; ! 3290: #endif ! 3291: #ifdef B9600 ! 3292: case B9600: ss = 9600L; break; ! 3293: #endif ! 3294: #ifdef B19200 ! 3295: case B19200: ss = 19200L; break; ! 3296: #else ! 3297: #ifdef EXTA ! 3298: case EXTA: ss = 19200L; break; ! 3299: #endif ! 3300: #endif ! 3301: ! 3302: #ifndef MINIX ! 3303: #ifdef B38400 ! 3304: case B38400: ss = 38400L; break; ! 3305: #else ! 3306: #ifdef EXTB ! 3307: case EXTB: ss = 38400L; break; ! 3308: #endif ! 3309: #endif ! 3310: #endif /* MINIX */ ! 3311: ! 3312: default: ! 3313: ss = -1; break; ! 3314: } ! 3315: sprintf(temp,"%ld",ss); ! 3316: debug(F110,"speed",temp,0); ! 3317: return(ss); ! 3318: } ! 3319: ! 3320: /* ckumyr.c by Kristoffer Eriksson, [email protected], 15 Mar 1990. */ ! 3321: ! 3322: #ifdef COHERENT ! 3323: #ifdef FIONREAD ! 3324: #undef FIONREAD ! 3325: #endif ! 3326: #define FIONREAD TIOCQUERY ! 3327: #define PEEKTYPE int ! 3328: #else ! 3329: #define PEEKTYPE long ! 3330: #endif /* COHERENT */ ! 3331: ! 3332: #ifdef MYREAD ! 3333: ! 3334: /* Private buffer for myread() and its companions. Not for use by anything ! 3335: * else. ttflui() is allowed to reset them to initial values. ttchk() is ! 3336: * allowed to read my_count. ! 3337: * ! 3338: * my_item is an index into mybuf[]. Increment it *before* reading mybuf[]. ! 3339: * ! 3340: * A global parity mask variable could be useful too. We could use it to ! 3341: * let myread() strip the parity on its own, instead of stripping sign ! 3342: * bits as it does now. ! 3343: */ ! 3344: #define MYBUFLEN 256 ! 3345: #ifdef SUNX25 ! 3346: /* ! 3347: On X.25 connections, there is an extra control byte at the beginning. ! 3348: */ ! 3349: static CHAR x25buf[MYBUFLEN+1]; /* Communication device input buffer */ ! 3350: static CHAR *mybuf = x25buf+1; ! 3351: #else ! 3352: static CHAR mybuf[MYBUFLEN]; ! 3353: #endif /* SUNX25 */ ! 3354: ! 3355: static int my_count = 0; /* Number of chars still in mybuf */ ! 3356: static int my_item = -1; /* Last index read from mybuf[] */ ! 3357: ! 3358: /* myread() -- Efficient read of one character from communications line. ! 3359: * ! 3360: * Uses a private buffer to minimize the number of expensive read() system ! 3361: * calls. Essentially performs the equivalent of read() of 1 character, which ! 3362: * is then returned. By reading all available input from the system buffers ! 3363: * to the private buffer in one chunk, and then working from this buffer, the ! 3364: * number of system calls is reduced in any case where more than one character ! 3365: * arrives during the processing of the previous chunk, for instance high ! 3366: * baud rates or network type connections where input arrives in packets. ! 3367: * If the time needed for a read() system call approaches the time for more ! 3368: * than one character to arrive, then this mechanism automatically compensates ! 3369: * for that by performing bigger read()s less frequently. If the system load ! 3370: * is high, the same mechanism compensates for that too. ! 3371: * ! 3372: * myread() is a macro that returns the next character from the buffer. If the ! 3373: * buffer is empty, mygetbuf() is called. See mygetbuf() for possible error ! 3374: * returns. ! 3375: * ! 3376: * This should be efficient enough for any one-character-at-a-time loops. ! 3377: * For even better efficiency you might use memcpy()/bcopy() or such between ! 3378: * buffers (since they are often better optimized for copying), but it may not ! 3379: * be worth it if you have to take an extra pass over the buffer to strip ! 3380: * parity and check for CTRL-C anyway. ! 3381: * ! 3382: * Note that if you have been using myread() from another program module, you ! 3383: * may have some trouble accessing this macro version and the private variables ! 3384: * it uses. In that case, just add a function in this module, that invokes the ! 3385: * macro. ! 3386: */ ! 3387: #define myread() (--my_count < 0 ? mygetbuf() : 255 & (int)mybuf[++my_item]) ! 3388: ! 3389: /* Specification: Push back up to one character onto myread()'s queue. ! 3390: * ! 3391: * This implementation: Push back characters into mybuf. At least one character ! 3392: * must have been read through myread() before myunrd() may be used. After ! 3393: * EOF or read error, again, myunrd() can not be used. Sometimes more than ! 3394: * one character can be pushed back, but only one character is guaranteed. ! 3395: * Since a previous myread() must have read its character out of mybuf[], ! 3396: * that guarantees that there is space for at least one character. If push ! 3397: * back was really needed after EOF, a small addition could provide that. ! 3398: * ! 3399: * myunrd() is currently not called from anywhere inside kermit... ! 3400: */ ! 3401: #ifdef NOTUSED ! 3402: myunrd(ch) CHAR ch; { ! 3403: if (my_item >= 0) { ! 3404: mybuf[my_item--] = ch; ! 3405: ++my_count; ! 3406: } ! 3407: } ! 3408: #endif ! 3409: ! 3410: /* mygetbuf() -- Fill buffer for myread() and return first character. ! 3411: * ! 3412: * This function is what myread() uses when it can't get the next character ! 3413: * directly from its buffer. First, it calls a system dependent myfillbuf() ! 3414: * to read at least one new character into the buffer, and then it returns ! 3415: * the first character just as myread() would have done. This function also ! 3416: * is responsible for all error conditions that myread() can indicate. ! 3417: * ! 3418: * Returns: When OK => a positive character, 0 or greater. ! 3419: * When EOF => -2. ! 3420: * When error => -3, error code in errno. ! 3421: * ! 3422: * Older myread()s additionally returned -1 to indicate that there was nothing ! 3423: * to read, upon which the caller would call myread() again until it got ! 3424: * something. The new myread()/mygetbuf() always gets something. If it ! 3425: * doesn't, then make it do so! Any program that actually depends on the old ! 3426: * behaviour will break. ! 3427: * ! 3428: * The older version also used to return -2 both for EOF and other errors, ! 3429: * and used to set errno to 9999 on EOF. The errno stuff is gone, EOF and ! 3430: * other errors now return different results, although Kermit currently never ! 3431: * checks to see which it was. It just disconnects in both cases. ! 3432: * ! 3433: * Kermit lets the user use the quit key to perform some special commands ! 3434: * during file transfer. This causes read(), and thus also mygetbuf(), to ! 3435: * finish without reading anything and return the EINTR error. This should ! 3436: * be checked by the caller. Mygetbuf() could retry the read() on EINTR, ! 3437: * but if there is nothing to read, this could delay Kermit's reaction to ! 3438: * the command, and make Kermit appear unresponsive. ! 3439: * ! 3440: * The debug() call should be removed for optimum performance. ! 3441: */ ! 3442: int ! 3443: mygetbuf() { ! 3444: my_count = myfillbuf(); ! 3445: debug(F101, "myfillbuf read", "", my_count); ! 3446: if (my_count <= 0) ! 3447: return(my_count < 0 ? -3 : -2); ! 3448: --my_count; ! 3449: return(255 & (int)mybuf[my_item = 0]); ! 3450: } ! 3451: ! 3452: /* myfillbuf(): ! 3453: * System-dependent read() into mybuf[], as many characters as possible. ! 3454: * ! 3455: * Returns: OK => number of characters read, always more than zero. ! 3456: * EOF => 0 ! 3457: * Error => -1, error code in errno. ! 3458: * ! 3459: * If there is input available in the system's buffers, all of it should be ! 3460: * read into mybuf[] and the function return immediately. If no input is ! 3461: * available, it should wait for a character to arrive, and return with that ! 3462: * one in mybuf[] as soon as possible. It may wait somewhat past the first ! 3463: * character, but be aware that any such delay lengthens the packet turnaround ! 3464: * time during kermit file transfers. Should never return with zero characters ! 3465: * unless EOF or irrecoverable read error. ! 3466: * ! 3467: * Correct functioning depends on the correct tty parameters being used. ! 3468: * Better control of current parameters is required than may have been the ! 3469: * case in older Kermit releases. For instance, O_NDELAY (or equivalent) can ! 3470: * no longer be sometimes off and sometimes on like it used to, unless a ! 3471: * special myfillbuf() is written to handle that. Otherwise the ordinary ! 3472: * myfillbuf()s may think they have come to EOF. ! 3473: * ! 3474: * If your system has a facility to directly perform the functioning of ! 3475: * myfillbuf(), then use it. If the system can tell you how many characters ! 3476: * are available in its buffers, then read that amount (but not less than 1). ! 3477: * If the system can return a special indication when you try to read without ! 3478: * anything to read, while allowing you to read all there is when there is ! 3479: * something, you may loop until there is something to read, but probably that ! 3480: * is not good for the system load. ! 3481: */ ! 3482: ! 3483: #ifdef SVORPOSIX ! 3484: /* This is for System III/V with VMIN>0, VTIME=0 and O_NDELAY off, ! 3485: * and CLOCAL set any way you like. This way, read() will do exactly ! 3486: * what is required by myfillbuf(): If there is data in the buffers ! 3487: * of the O.S., all available data is read into mybuf, up to the size ! 3488: * of mybuf. If there is none, the first character to arrive is ! 3489: * awaited and returned. ! 3490: */ ! 3491: int ! 3492: myfillbuf() { ! 3493: #ifdef sxaE50 ! 3494: /* From S. Dezawa at Fujifilm in Japan. I don't know why this is */ ! 3495: /* necessary for the sxa E50, but it is. */ ! 3496: return read(ttyfd, mybuf, 255); ! 3497: #else ! 3498: /* sizeof(mybuf) should be MYBUFL == 256 */ ! 3499: return read(ttyfd, mybuf, sizeof(mybuf)); ! 3500: #endif /* sxaE50 */ ! 3501: } ! 3502: ! 3503: #else /* not AT&T or POSIX */ ! 3504: ! 3505: #ifdef aegis ! 3506: /* This is quoted from the old myread(). The semantics seem to be ! 3507: * alright, but maybe errno would not need to be set even when ! 3508: * there is no error? I don't know aegis. ! 3509: */ ! 3510: int ! 3511: myfillbuf() { ! 3512: int count; ! 3513: ! 3514: count = ios_$get((short)ttyfd, ios_$cond_opt, mybuf, 256L, st); ! 3515: errno = EIO; ! 3516: if (st.all == ios_$get_conditional_failed) /* get at least one */ ! 3517: inbufc = ios_$get((short)ttyfd, 0, mybuf, 1L, st); ! 3518: if (st.all == ios_$end_of_file) ! 3519: return(0); ! 3520: else if (st.all != status_$ok) { ! 3521: errno = EIO; ! 3522: return(-1); ! 3523: } ! 3524: return(count); ! 3525: } ! 3526: #else /* !aegis */ ! 3527: ! 3528: #ifdef FIONREAD ! 3529: /* This is for systems with FIONREAD. FIONREAD returns the number ! 3530: * of characters available for reading. If none are available, wait ! 3531: * until something arrives, otherwise return all there is. ! 3532: */ ! 3533: int ! 3534: myfillbuf() { ! 3535: PEEKTYPE avail; ! 3536: int x; ! 3537: ! 3538: #ifdef SUNX25 ! 3539: /* ! 3540: SunLink X.25 support in this routine from Stefaan A. Eeckels, Eurostat (CEC). ! 3541: Depends on SunOS having FIONREAD, not because we use it, but just so this ! 3542: code is grouped correctly within the #ifdefs. Let's hope Solaris keeps it. ! 3543: ! 3544: We call x25xin() instead of read() so that Q-Bit packets, which contain ! 3545: X.25 service-level information (e.g. PAD parameter changes), can be processed ! 3546: transparently to the upper-level code. This is a blocking read, and so ! 3547: we depend on higher-level code (such as ttinc()) to set any necessary alarms. ! 3548: */ ! 3549: extern int nettype; ! 3550: if (netconn && nettype == NET_SX25) { ! 3551: while ((x = x25xin(sizeof(x25buf), x25buf)) < 1) ; ! 3552: return(x - 1); /* "-1" compensates for extra status byte */ ! 3553: } ! 3554: #endif /* SUNX25 */ ! 3555: ! 3556: x = ioctl(ttyfd, FIONREAD, &avail); ! 3557: if (x < 0) { ! 3558: debug(F101,"myfillbuf FIONREAD","",x); ! 3559: debug(F101,"myfillbuf errno","",errno); ! 3560: } ! 3561: if (x < 0 || avail == 0) ! 3562: avail = 1; ! 3563: ! 3564: if (avail > MYBUFLEN) ! 3565: avail = MYBUFLEN; ! 3566: ! 3567: return(read(ttyfd, mybuf, (int) avail)); ! 3568: } ! 3569: ! 3570: #else /* !FIONREAD */ ! 3571: /* Add other systems here, between #ifdef and #else, e.g. NETCONN. */ ! 3572: /* When there is no other possibility, read 1 character at a time. */ ! 3573: int ! 3574: myfillbuf() { ! 3575: return read(ttyfd, mybuf, 1); ! 3576: } ! 3577: ! 3578: #endif /* !FIONREAD */ ! 3579: #endif /* !aegis */ ! 3580: #endif /* !ATTSV */ ! 3581: ! 3582: #endif /* MYREAD */ ! 3583: ! 3584: /* T T F L U I -- Flush tty input buffer */ ! 3585: ! 3586: int ! 3587: ttflui() { ! 3588: #ifdef BSD44 ! 3589: int n; ! 3590: #endif /* BSD44 */ ! 3591: #ifndef SVORPOSIX ! 3592: int n; ! 3593: #endif /* SVORPOSIX */ ! 3594: ! 3595: #ifdef MYREAD ! 3596: /* ! 3597: Flush internal MYREAD buffer *FIRST*, in all cases. ! 3598: */ ! 3599: my_count = 0; /* Reset count to zero */ ! 3600: my_item = -1; /* And buffer index to -1 */ ! 3601: #endif /* MYREAD */ ! 3602: ! 3603: #ifdef NETCONN ! 3604: /* ! 3605: Network flush is done specially, in the network support module. ! 3606: */ ! 3607: if (netconn) return(netflui()); ! 3608: #endif /* NETCONN */ ! 3609: ! 3610: debug(F101,"ttflui ttyfd","",ttyfd); ! 3611: if (ttyfd < 0) return(-1); ! 3612: ! 3613: #ifdef aegis ! 3614: sio_$control((short)ttyfd, sio_$flush_in, true, st); ! 3615: if (st.all != status_$ok) { ! 3616: fprintf(stderr, "flush failed: "); error_$print(st); ! 3617: } else { /* sometimes the flush doesn't work */ ! 3618: for (;;) { ! 3619: char buf[256]; ! 3620: /* eat all the characters that shouldn't be available */ ! 3621: ios_$get((short)ttyfd, ios_$cond_opt, buf, 256L, st); /* (void) */ ! 3622: if (st.all == ios_$get_conditional_failed) break; ! 3623: fprintf(stderr, "flush failed(2): "); error_$print(st); ! 3624: } ! 3625: } ! 3626: #else ! 3627: #ifdef BSD44 /* 4.4 BSD */ ! 3628: n = FREAD; /* Specify read queue */ ! 3629: debug(F101,"ttflui BSD44 flush","",ttyfd); ! 3630: ioctl(ttyfd,TIOCFLUSH,&n); ! 3631: ioctl(ttyfd,TCSAFLUSH,&n); ! 3632: #else ! 3633: #ifdef POSIX /* POSIX */ ! 3634: tcflush(ttyfd,TCIFLUSH); ! 3635: #else ! 3636: #ifdef ATTSV /* System V */ ! 3637: #ifndef VXVE ! 3638: ioctl(ttyfd,TCFLSH,0); ! 3639: #endif /* VXVE */ ! 3640: #else /* Not BSD44, POSIX, or Sys V */ ! 3641: #ifdef TIOCFLUSH /* Those with TIOCFLUSH defined */ ! 3642: #ifdef ANYBSD /* Berkeley */ ! 3643: n = FREAD; /* Specify read queue */ ! 3644: debug(F101,"ttflui anybsd flush","",ttyfd); ! 3645: ioctl(ttyfd,TIOCFLUSH,&n); ! 3646: #else /* Others (V7, etc) */ ! 3647: ioctl(ttyfd,TIOCFLUSH,0); ! 3648: #endif /* ANYBSD */ ! 3649: #else /* All others... */ ! 3650: /* ! 3651: No system call (that we know about) for input buffer flushing. ! 3652: So see how many there are and read them in a loop, using ttinc(). ! 3653: ttinc() is buffered, so we're not getting charged with a system call ! 3654: per character, just a function call. ! 3655: */ ! 3656: if ((n = ttchk()) > 0) { ! 3657: debug(F101,"ttflui reading","",n); ! 3658: while ((n--) && ttinc(0) > 1) ; ! 3659: } ! 3660: #endif /* TIOCFLUSH */ ! 3661: #endif /* ATTSV */ ! 3662: #endif /* POSIX */ ! 3663: #endif /* BSD44 */ ! 3664: #endif /* aegis */ ! 3665: return(0); ! 3666: } ! 3667: ! 3668: int ! 3669: ttfluo() { /* Flush output buffer */ ! 3670: #ifdef POSIX ! 3671: return(tcflush(ttyfd,TCOFLUSH)); ! 3672: #else ! 3673: return(0); /* (dummy for now) */ ! 3674: #endif /* POSIX */ ! 3675: ! 3676: } ! 3677: ! 3678: /* Interrupt Functions */ ! 3679: ! 3680: /* Set up terminal interrupts on console terminal */ ! 3681: ! 3682: #ifdef SVORPOSIX ! 3683: SIGTYP ! 3684: esctrp(foo) int foo; { /* trap console escapes (^\) */ ! 3685: signal(SIGQUIT,SIG_IGN); /* ignore until trapped */ ! 3686: conesc = 1; ! 3687: debug(F101,"esctrp caught SIGQUIT","",conesc); ! 3688: } ! 3689: #endif /* SVORPOSIX */ ! 3690: ! 3691: #ifdef V7 ! 3692: SIGTYP ! 3693: esctrp(foo) int foo; { /* trap console escapes (^\) */ ! 3694: signal(SIGQUIT,SIG_IGN); /* ignore until trapped */ ! 3695: conesc = 1; ! 3696: debug(F101,"esctrp caught SIGQUIT","",conesc); ! 3697: } ! 3698: #endif ! 3699: ! 3700: #ifdef C70 ! 3701: SIGTYP ! 3702: esctrp(foo) int foo; { /* trap console escapes (^\) */ ! 3703: conesc = 1; ! 3704: signal(SIGQUIT,SIG_IGN); /* ignore until trapped */ ! 3705: } ! 3706: #endif ! 3707: ! 3708: /* C O N B G T -- Background Test */ ! 3709: ! 3710: static int jc = 0; /* 0 = no job control */ ! 3711: ! 3712: /* ! 3713: Call with flag == 1 to prevent signal test, which can not be expected ! 3714: to work during file transfer, when SIGINT probably *is* set to SIG_IGN. ! 3715: ! 3716: Call with flag == 0 to use the signal test, but only if the process-group ! 3717: test fails, as it does on some UNIX systems, where getpgrp() is buggy, ! 3718: requires an argument when the man page says it doesn't, or vice versa. ! 3719: ! 3720: If flag == 0 and the process-group test fails, then we determine background ! 3721: status simply (but not necessarily reliably) from isatty(). ! 3722: ! 3723: conbgt() sets the global backgrd = 1 if we appear to be in the background, ! 3724: and to 0 if we seem to be in the foreground. conbgt() is highly prone to ! 3725: misbehavior. ! 3726: */ ! 3727: VOID ! 3728: conbgt(flag) int flag; { ! 3729: int x = -1, /* process group or SIGINT test */ ! 3730: y = 0; /* isatty() test */ ! 3731: /* ! 3732: Check for background operation, even if not running on real tty, so that ! 3733: background flag can be set correctly. If background status is detected, ! 3734: then Kermit will not issue its interactive prompt or most messages. ! 3735: If your prompt goes away, you can blame (and fix?) this function. ! 3736: */ ! 3737: ! 3738: /* Use process-group test if possible. */ ! 3739: ! 3740: #ifdef POSIX /* We can do it in POSIX */ ! 3741: #define PGROUP_T ! 3742: #else ! 3743: #ifdef BSD4 /* and in BSD 4.x. */ ! 3744: #define PGROUP_T ! 3745: #else ! 3746: #ifdef HPUXJOBCTL /* and in most HP-UX's */ ! 3747: #define PGROUP_T ! 3748: #else ! 3749: #ifdef TIOCGPGRP /* and anyplace that has this ioctl. */ ! 3750: #define PGROUP_T ! 3751: #endif /* TIOCGPGRP */ ! 3752: #endif /* HPUXJOBCTL */ ! 3753: #endif /* BSD4 */ ! 3754: #endif /* POSIX */ ! 3755: ! 3756: #ifdef MIPS /* Except if it doesn't work... */ ! 3757: #undef PGROUP_T ! 3758: #endif /* MIPS */ ! 3759: ! 3760: #ifdef PGROUP_T ! 3761: /* ! 3762: Semi-reliable process-group test. Check whether this process's group is ! 3763: the same as the controlling terminal's process group. This works if the ! 3764: getpgrp() call doesn't lie (as it does in the SUNOS System V environment). ! 3765: */ ! 3766: PID_T mypgrp = (PID_T)0; /* Kermit's process group */ ! 3767: PID_T ctpgrp = (PID_T)0; /* The terminal's process group */ ! 3768: #ifndef _POSIX_SOURCE ! 3769: /* ! 3770: The getpgrp() prototype is obtained from system header files for POSIX ! 3771: and Sys V R4 compilations. Other systems, who knows. Some complain about ! 3772: a duplicate declaration here, others don't, so it's safer to leave it in ! 3773: if we don't know for certain. ! 3774: */ ! 3775: #ifndef SVR4 ! 3776: #ifndef PS2AIX10 ! 3777: extern PID_T getpgrp(); ! 3778: #endif /* PS2AIX10 */ ! 3779: #endif /* SVR4 */ ! 3780: #endif /* _POSIX_SOURCE */ ! 3781: ! 3782: /* Get my process group. */ ! 3783: ! 3784: #ifdef SVR3 /* Maybe this should be ATTSV? */ ! 3785: /* This function is not described in SVID R2 */ ! 3786: mypgrp = getpgrp(); ! 3787: debug(F101,"ATTSV conbgt process group","",(int) mypgrp); ! 3788: #else ! 3789: #ifdef POSIX ! 3790: mypgrp = getpgrp(); ! 3791: debug(F101,"POSIX conbgt process group","",(int) mypgrp); ! 3792: #else /* BSD, V7, etc */ ! 3793: mypgrp = getpgrp(0); ! 3794: debug(F101,"BSD conbgt process group","",(int) mypgrp); ! 3795: #endif /* POSIX */ ! 3796: #endif /* SVR3 */ ! 3797: ! 3798: /* Now get controlling tty's process group */ ! 3799: #ifdef BSD44ORPOSIX ! 3800: ctpgrp = tcgetpgrp(1); /* The POSIX way */ ! 3801: debug(F101,"POSIX conbgt terminal process group","",(int) ctpgrp); ! 3802: #else ! 3803: ioctl(1, TIOCGPGRP, &ctpgrp); /* Or the BSD way */ ! 3804: debug(F101,"non-POSIX conbgt terminal process group","",(int) ctpgrp); ! 3805: #endif /* BSD44ORPOSIX */ ! 3806: ! 3807: if ((mypgrp > (PID_T) 0) && (ctpgrp > (PID_T) 0)) ! 3808: x = (mypgrp == ctpgrp) ? 0 : 1; /* If they differ, then background. */ ! 3809: else x = -1; /* If error, remember. */ ! 3810: debug(F101,"conbgt process group test","",x); ! 3811: #endif /* PGROUP_T */ ! 3812: ! 3813: /* Try to see if job control is available */ ! 3814: ! 3815: #ifdef NOJC /* User override */ ! 3816: jc = 0; /* No job control allowed */ ! 3817: debug(F111,"NOJC","jc",jc); ! 3818: #else ! 3819: #ifdef BSD44 ! 3820: jc = 1; ! 3821: #else ! 3822: #ifdef SVR4ORPOSIX /* POSIX actually tells us */ ! 3823: debug(F100,"SVR4ORPOSIX jc test...","",0); ! 3824: #ifdef _SC_JOB_CONTROL ! 3825: #ifdef bsdi ! 3826: jc = 1; ! 3827: #else ! 3828: #ifdef __386BSD__ ! 3829: jc = 1; ! 3830: #else ! 3831: jc = sysconf(_SC_JOB_CONTROL); /* Whatever system says */ ! 3832: debug(F111,"sysconf(_SC_JOB_CONTROL)","jc",jc); ! 3833: #endif /* __386BSD__ */ ! 3834: #endif /* bsdi */ ! 3835: #else ! 3836: #ifdef _POSIX_JOB_CONTROL ! 3837: jc = 1; /* By definition */ ! 3838: debug(F111,"_POSIX_JOB_CONTROL is defined","jc",jc); ! 3839: #else ! 3840: jc = 0; /* Assume job control not allowed */ ! 3841: debug(F111,"SVR4ORPOSIX _SC/POSIX_JOB_CONTROL not defined","jc",jc); ! 3842: #endif /* _POSIX_JOB_CONTROL */ ! 3843: #endif /* _SC_JOB_CONTROL */ ! 3844: #else ! 3845: #ifdef BSD4 ! 3846: jc = 1; /* Job control allowed */ ! 3847: debug(F111,"BSD job control","jc",jc); ! 3848: #else ! 3849: #ifdef SVR3JC ! 3850: jc = 1; /* JC allowed */ ! 3851: debug(F111,"SVR3 job control","jc",jc); ! 3852: #else ! 3853: jc = 0; /* JC not allowed */ ! 3854: debug(F111,"job control catch-all","jc",jc); ! 3855: #endif /* SVR3JC */ ! 3856: #endif /* BSD4 */ ! 3857: #endif /* SVR4ORPOSIX */ ! 3858: #endif /* BSD44 */ ! 3859: #endif /* NOJC */ ! 3860: debug(F101,"conbgt jc","",jc); ! 3861: ! 3862: /* ! 3863: Another background test. ! 3864: Test if SIGINT (terminal interrupt) is set to SIG_IGN (ignore), ! 3865: which is done by the shell (sh) if the program is started with '&'. ! 3866: Unfortunately, this is NOT done by csh or ksh so watch out! ! 3867: Note, it's safe to set SIGINT to SIG_IGN here, because further down ! 3868: we always set it to something else. ! 3869: */ ! 3870: if (x < 0 && !flag) { /* Didn't get good results above... */ ! 3871: ! 3872: SIGTYP (*osigint)(); ! 3873: ! 3874: osigint = signal(SIGINT,SIG_IGN); /* What is SIGINT set to? */ ! 3875: x = (osigint == SIG_IGN) ? 1 : 0; /* SIG_IGN? */ ! 3876: debug(F101,"conbgt osigint","",(int) osigint); ! 3877: debug(F101,"conbgt signal test","",x); ! 3878: } ! 3879: ! 3880: /* Also check to see if we're running with redirected stdio. */ ! 3881: /* This is not really background operation, but we want to act as though */ ! 3882: /* it were. */ ! 3883: ! 3884: y = (isatty(0) && isatty(1)) ? 1 : 0; ! 3885: debug(F101,"conbgt isatty test","",y); ! 3886: ! 3887: #ifdef BSD29 ! 3888: /* The process group and/or signal test doesn't work under these... */ ! 3889: backgrd = !y; ! 3890: #else ! 3891: #ifdef sxaE50 ! 3892: backgrd = !y; ! 3893: #else ! 3894: #ifdef MINIX ! 3895: backgrd = !y; ! 3896: #else ! 3897: if (x > -1) ! 3898: backgrd = (x || !y) ? 1 : 0; ! 3899: else backgrd = !y; ! 3900: #endif /* BSD29 */ ! 3901: #endif /* sxaE50 */ ! 3902: #endif /* MINIX */ ! 3903: debug(F101,"conbgt backgrd","",backgrd); ! 3904: } ! 3905: ! 3906: /* C O N I N T -- Console Interrupt setter */ ! 3907: ! 3908: /* ! 3909: First arg is pointer to function to handle SIGTERM & SIGINT (like Ctrl-C). ! 3910: Second arg is pointer to function to handle SIGTSTP (suspend). ! 3911: */ ! 3912: ! 3913: VOID /* Set terminal interrupt traps. */ ! 3914: #ifdef CK_ANSIC ! 3915: #ifdef apollo ! 3916: conint(f,s) SIGTYP (*f)(), (*s)(); ! 3917: #else ! 3918: conint(SIGTYP (*f)(int), SIGTYP (*s)(int)) ! 3919: #endif /* apollo */ ! 3920: #else ! 3921: conint(f,s) SIGTYP (*f)(), (*s)(); ! 3922: #endif /* CK_ANSIC */ ! 3923: /* conint */ { ! 3924: ! 3925: conbgt(0); /* Do background test. */ ! 3926: ! 3927: /* Set the desired handlers for hangup and software termination. */ ! 3928: ! 3929: signal(SIGTERM,f); /* Software termination */ ! 3930: ! 3931: #ifdef COMMENT ! 3932: /* ! 3933: Prior to edit 184, we used to trap SIGHUP here. That is clearly wrong; ! 3934: on some systems, it would leave the user's process on the terminal after ! 3935: the phone hung up. But the trap was here for a reason: most likely some ! 3936: UNIX systems (init, getty, or login) fail to properly restore the terminal ! 3937: modes after regaining control of a hung-up-upon login terminal. Therefore ! 3938: removing this trap is likely to cause problems too. A more sensible ! 3939: approach would be to use a special handler for HANGUP, which would restore ! 3940: the terminal modes and then exit(). But that could leave zombie processes ! 3941: around (like the lower CONNECT fork, or any fork started by zxcmd()), but ! 3942: there is probably no clean, portable, reliable way for Kermit to kill all ! 3943: its forks. So we just exit() and hope that UNIX fixes the terminal modes ! 3944: before the next person tries to log in. ! 3945: */ ! 3946: signal(SIGHUP,f); /* Hangup */ ! 3947: #endif /* COMMENT */ ! 3948: ! 3949: /* Now handle keyboard stop, quit, and interrupt signals. */ ! 3950: /* Check if invoked in background -- if so signals set to be ignored. */ ! 3951: /* However, if running under a job control shell, don't ignore them. */ ! 3952: /* We won't be getting any, as we aren't in the terminal's process group. */ ! 3953: ! 3954: debug(F101,"conint backgrd","",backgrd); ! 3955: debug(F101,"conint jc","",jc); ! 3956: ! 3957: if (backgrd && !jc) { /* In background, ignore signals */ ! 3958: debug(F101,"conint background ignoring signals, jc","",jc); ! 3959: #ifdef SIGTSTP ! 3960: signal(SIGTSTP,SIG_IGN); /* Keyboard stop */ ! 3961: #endif /* SIGTSTP */ ! 3962: signal(SIGQUIT,SIG_IGN); /* Keyboard quit */ ! 3963: signal(SIGINT,SIG_IGN); /* Keyboard interrupt */ ! 3964: } else { /* Else in foreground or suspended */ ! 3965: debug(F101,"conint foreground catching signals, jc","",jc); ! 3966: signal(SIGINT,f); /* Catch terminal interrupt */ ! 3967: ! 3968: #ifdef SIGTSTP /* Keyboard stop (suspend) */ ! 3969: debug(F101,"conint SIGSTSTP","",(int) s); ! 3970: if (s == NULL) s = SIG_DFL; ! 3971: #ifdef NOJC /* No job control allowed. */ ! 3972: signal(SIGTSTP,SIG_IGN); ! 3973: #else /* Job control allowed */ ! 3974: if (jc) /* if available. */ ! 3975: signal(SIGTSTP,s); ! 3976: else ! 3977: signal(SIGTSTP,SIG_IGN); ! 3978: #endif /* NOJC */ ! 3979: #endif /* SIGTSTP */ ! 3980: ! 3981: #ifdef SVORPOSIX ! 3982: signal(SIGQUIT,esctrp); /* Quit signal, Sys III/V. */ ! 3983: if (conesc) conesc = 0; /* Clear out pending escapes */ ! 3984: #else ! 3985: #ifdef V7 ! 3986: signal(SIGQUIT,esctrp); /* V7 like Sys III/V */ ! 3987: if (conesc) conesc = 0; ! 3988: #else ! 3989: #ifdef aegis ! 3990: signal(SIGQUIT,f); /* Apollo, catch it like others. */ ! 3991: #else ! 3992: signal(SIGQUIT,SIG_IGN); /* Others, ignore like 4D & earlier. */ ! 3993: #endif /* aegis */ ! 3994: #endif /* V7 */ ! 3995: #endif /* SVORPOSIX */ ! 3996: } ! 3997: } ! 3998: ! 3999: ! 4000: /* C O N N O I -- Reset console terminal interrupts */ ! 4001: ! 4002: SIGTYP /* Dummy function to ignore signals */ ! 4003: #ifdef CK_ANSIC ! 4004: sig_ign(int foo) ! 4005: #else ! 4006: sig_ign(foo) int foo; ! 4007: #endif /* CK_ANSIC */ ! 4008: /* sig_IGN */ { /* Just like the real one, but has */ ! 4009: } /* different address. */ ! 4010: ! 4011: VOID ! 4012: connoi() { /* Console-no-interrupts */ ! 4013: ! 4014: debug(F100,"connoi","",0); ! 4015: #ifdef SIGTSTP ! 4016: signal(SIGTSTP,SIG_DFL); ! 4017: #endif /* SIGTSTP */ ! 4018: /* Note the locally defined replacement for SIG_IGN that is used here */ ! 4019: /* for the SIGINT setting. This is done so that the Sys V background */ ! 4020: /* test -- (signal(SIGINT,SIG_IGN) == SIG_IGN) -- can work. If we use */ ! 4021: /* the real SIG_IGN here, then conint will always decide that this */ ! 4022: /* program is running in the background! */ ! 4023: ! 4024: signal(SIGINT,sig_ign); /* <--- note! */ ! 4025: ! 4026: signal(SIGHUP,SIG_DFL); ! 4027: signal(SIGQUIT,SIG_IGN); ! 4028: signal(SIGTERM,SIG_IGN); ! 4029: } ! 4030: ! 4031: /* I N I T R A W Q -- Set up to read /dev/kmem for character count. */ ! 4032: ! 4033: #ifdef V7 ! 4034: /* ! 4035: Used in Version 7 to simulate Berkeley's FIONREAD ioctl call. This ! 4036: eliminates blocking on a read, because we can read /dev/kmem to get the ! 4037: number of characters available for raw input. If your system can't ! 4038: or you won't let the world read /dev/kmem then you must figure out a ! 4039: different way to do the counting of characters available, or else replace ! 4040: this by a dummy function that always returns 0. ! 4041: */ ! 4042: /* ! 4043: * Call this routine as: initrawq(tty) ! 4044: * where tty is the file descriptor of a terminal. It will return ! 4045: * (as a char *) the kernel-mode memory address of the rawq character ! 4046: * count, which may then be read. It has the side-effect of flushing ! 4047: * input on the terminal. ! 4048: */ ! 4049: /* ! 4050: * John Mackin, Physiology Dept., University of Sydney (Australia) ! 4051: * ...!decvax!mulga!physiol.su.oz!john ! 4052: * ! 4053: * Permission is hereby granted to do anything with this code, as ! 4054: * long as this comment is retained unmodified and no commercial ! 4055: * advantage is gained. ! 4056: */ ! 4057: #ifndef MINIX ! 4058: #ifndef COHERENT ! 4059: #include <a.out.h> ! 4060: #include <sys/proc.h> ! 4061: #endif /* COHERENT */ ! 4062: #endif /* MINIX */ ! 4063: ! 4064: #ifdef COHERENT ! 4065: #include <l.out.h> ! 4066: #include <sys/proc.h> ! 4067: #endif /* COHERENT */ ! 4068: ! 4069: char * ! 4070: initrawq(tty) int tty; { ! 4071: #ifdef MINIX ! 4072: return(0); ! 4073: #else ! 4074: #ifdef UTS24 ! 4075: return(0); ! 4076: #else ! 4077: #ifdef BSD29 ! 4078: return(0); ! 4079: #else ! 4080: long lseek(); ! 4081: static struct nlist nl[] = { ! 4082: {PROCNAME}, ! 4083: {NPROCNAME}, ! 4084: {""} ! 4085: }; ! 4086: static struct proc *pp; ! 4087: char *qaddr, *p, c; ! 4088: int m; ! 4089: PID_T pid, me; ! 4090: NPTYPE xproc; /* Its type is defined in makefile. */ ! 4091: int catch(); ! 4092: ! 4093: me = getpid(); ! 4094: if ((m = open("/dev/kmem", 0)) < 0) err("kmem"); ! 4095: nlist(BOOTNAME, nl); ! 4096: if (nl[0].n_type == 0) err("proc array"); ! 4097: ! 4098: if (nl[1].n_type == 0) err("nproc"); ! 4099: ! 4100: lseek(m, (long)(nl[1].n_value), 0); ! 4101: read (m, &xproc, sizeof(xproc)); ! 4102: saval = signal(SIGALRM, catch); ! 4103: if ((pid = fork()) == 0) { ! 4104: while(1) ! 4105: read(tty, &c, 1); ! 4106: } ! 4107: alarm(2); ! 4108: ! 4109: if(setjmp(jjbuf) == 0) { ! 4110: while(1) ! 4111: read(tty, &c, 1); ! 4112: } ! 4113: signal(SIGALRM, SIG_DFL); ! 4114: ! 4115: #ifdef DIRECT ! 4116: pp = (struct proc *) nl[0].n_value; ! 4117: #else ! 4118: if (lseek(m, (long)(nl[0].n_value), 0) < 0L) err("seek"); ! 4119: if (read(m, &pp, sizeof(pp)) != sizeof(pp)) err("no read of proc ptr"); ! 4120: #endif ! 4121: lseek(m, (long)(nl[1].n_value), 0); ! 4122: read(m, &xproc, sizeof(xproc)); ! 4123: ! 4124: if (lseek(m, (long)pp, 0) < 0L) err("Can't seek to proc"); ! 4125: if ((p = malloc(xproc * sizeof(struct proc))) == NULL) err("malloc"); ! 4126: if (read(m,p,xproc * sizeof(struct proc)) != xproc*sizeof(struct proc)) ! 4127: err("read proc table"); ! 4128: for (pp = (struct proc *)p; xproc > 0; --xproc, ++pp) { ! 4129: if (pp -> p_pid == (short) pid) goto iout; ! 4130: } ! 4131: err("no such proc"); ! 4132: ! 4133: iout: ! 4134: close(m); ! 4135: qaddr = (char *)(pp -> p_wchan); ! 4136: free (p); ! 4137: kill(pid, SIGKILL); ! 4138: wait((WAIT_T)0); /* Destroy the ZOMBIEs! */ ! 4139: return (qaddr); ! 4140: #endif ! 4141: #endif ! 4142: #endif ! 4143: } ! 4144: ! 4145: /* More V7-support functions... */ ! 4146: ! 4147: static VOID ! 4148: err(s) char *s; { ! 4149: char buf[200]; ! 4150: ! 4151: sprintf(buf, "fatal error in initrawq: %s", s); ! 4152: perror(buf); ! 4153: doexit(1,-1); ! 4154: } ! 4155: ! 4156: static VOID ! 4157: catch(foo) int foo; { ! 4158: longjmp(jjbuf, -1); ! 4159: } ! 4160: ! 4161: ! 4162: /* G E N B R K -- Simulate a modem break. */ ! 4163: ! 4164: #ifdef MINIX ! 4165: #define BSPEED B110 ! 4166: #else ! 4167: #define BSPEED B150 ! 4168: #endif /* MINIX */ ! 4169: ! 4170: VOID ! 4171: genbrk(fn,msec) int fn, msec; { ! 4172: struct sgttyb ttbuf; ! 4173: int ret, sospeed, x, y; ! 4174: ! 4175: ret = ioctl(fn, TIOCGETP, &ttbuf); ! 4176: sospeed = ttbuf.sg_ospeed; ! 4177: ttbuf.sg_ospeed = BSPEED; ! 4178: ret = ioctl(fn, TIOCSETP, &ttbuf); ! 4179: y = (int)strlen(brnuls); ! 4180: x = ( BSPEED * 100 ) / msec; ! 4181: if (x > y) x = y; ! 4182: ret = write(fn, brnuls, (( BSPEED * 100 ) / msec )); ! 4183: ttbuf.sg_ospeed = sospeed; ! 4184: ret = ioctl(fn, TIOCSETP, &ttbuf); ! 4185: ret = write(fn, "@", 1); ! 4186: return; ! 4187: } ! 4188: #endif /* V7 */ ! 4189: ! 4190: /* T T C H K -- Tell how many characters are waiting in tty input buffer */ ! 4191: ! 4192: /* Some callers of this want to know whether there is something to read ! 4193: * either in the system buffers or in our private buffers (and mostly don't ! 4194: * care how many characters, just whether it's more than zero or not), while ! 4195: * some others would be better off with the number of characters in our ! 4196: * private buffers only. ! 4197: * ! 4198: * Some systems can say how many characters there are in the system buffers. ! 4199: * Others can not. For those that can't, the number in the private buffers ! 4200: * will have to do (or should we put the tty into O_NDELAY-mode and try to ! 4201: * read one character?). If the system can tell whether there is zero or ! 4202: * more than zero characters, we can return 1 in the latter case even if the ! 4203: * private buffer is empty. (That is good for sliding windows.) ! 4204: */ ! 4205: int ! 4206: ttchk() { ! 4207: int x; ! 4208: PEEKTYPE n = 0; ! 4209: ! 4210: #ifdef COMMENT ! 4211: /* ! 4212: This was REALLY slowing TELNET connections down! Just do the regular ! 4213: ttyfd-based stuff here. Let the VMS version call nettchk if it has to... ! 4214: FIONREAD definitely works for TELNET, at least on the NeXT and SUNOS. ! 4215: */ ! 4216: #ifdef NETCONN ! 4217: if (netconn) return(nettchk()); ! 4218: #endif /* NETCONN */ ! 4219: #endif /* COMMENT */ ! 4220: ! 4221: #ifdef FIONREAD ! 4222: x = ioctl(ttyfd, FIONREAD, &n); /* Berkeley and maybe some others */ ! 4223: debug(F101,"ttchk FIONREAD return code","",x); ! 4224: debug(F101,"ttchk FIONREAD count","",n); ! 4225: if (x < 0) n = 0; ! 4226: #else ! 4227: #ifdef V7 ! 4228: #ifdef MINIX ! 4229: return(0); ! 4230: #else ! 4231: lseek(kmem[TTY], (long) qaddr[TTY], 0); /* 7th Edition Unix */ ! 4232: x = read(kmem[TTY], &n, sizeof(int)); ! 4233: if (x != sizeof(int)) n = 0; ! 4234: #endif /* MINIX */ ! 4235: #else ! 4236: #ifdef PROVX1 ! 4237: x = ioctl(ttyfd, TIOCQCNT, &ttbuf); /* Pro/3xx Venix V.1 */ ! 4238: n = ttbuf.sg_ispeed & 0377; ! 4239: if (x < 0) n = 0; ! 4240: #else ! 4241: #ifdef RDCHK ! 4242: /* ! 4243: Last resort for systems without FIONREAD or equivalent, but with ! 4244: something like rdchk(), like XENIX. ! 4245: */ ! 4246: if (my_count == 0 && rdchk(ttyfd) > 0) n = 1; ! 4247: debug(F101,"ttchk rdchk","",n); ! 4248: #endif /* RDCHK */ ! 4249: #endif /* PROVX1 */ ! 4250: #endif /* V7 */ ! 4251: #endif /* FIONREAD */ ! 4252: ! 4253: #ifdef MYREAD ! 4254: /* ! 4255: For myread() users, add the contents of myread()'s private buffer. ! 4256: Sometimes, this is all there is to construct a result of ttchk() on. ! 4257: */ ! 4258: if (my_count > 0) ! 4259: n += my_count; ! 4260: #endif /* MYREAD */ ! 4261: ! 4262: debug(F101,"ttchk returns","",n); ! 4263: return(n); ! 4264: } ! 4265: ! 4266: /* T T X I N -- Get n characters from tty input buffer */ ! 4267: ! 4268: /* Returns number of characters actually gotten, or -1 on failure */ ! 4269: ! 4270: /* Intended for use only when it is known that n characters are actually */ ! 4271: /* Available in the input buffer. */ ! 4272: ! 4273: int ! 4274: ttxin(n,buf) int n; CHAR *buf; { ! 4275: register int x, c; ! 4276: ! 4277: debug(F101,"ttxin n","",n); ! 4278: if (n < 1) return(0); ! 4279: ttpmsk = (ttprty) ? 0177 : 0377; /* Parity stripping mask. */ ! 4280: ! 4281: #ifdef SUNX25 ! 4282: if (netconn && (ttnet == NET_SX25)) /* X.25 connection */ ! 4283: return(x25xin(n,buf)); ! 4284: #endif /* SUNX25 */ ! 4285: ! 4286: #ifdef MYREAD ! 4287: debug(F101,"ttxin MYREAD","",0); ! 4288: c = -2; ! 4289: for( x = 0; (x > -1) && (x < n) && (c = myread()) >= 0; ) ! 4290: buf[x++] = c & ttpmsk; ! 4291: if (c < 0) { ! 4292: debug(F101,"ttxin myread returns","",c); ! 4293: if (c == -3) x = -1; ! 4294: } ! 4295: #else ! 4296: x = read(ttyfd,buf,n); ! 4297: for (c = 0; c < n; c++) buf[c] &= ttpmsk; ! 4298: debug(F101," x","",x); ! 4299: #endif /* MYREAD */ ! 4300: if (x > 0) buf[x] = '\0'; ! 4301: if (x < 0) x = -1; ! 4302: return(x); ! 4303: } ! 4304: ! 4305: /* T T O L -- Write string s, length n, to communication device. */ ! 4306: /* ! 4307: Returns: ! 4308: >= 0 on success, number of characters actually written. ! 4309: -1 on failure. ! 4310: */ ! 4311: #define TTOLMAXT 5 ! 4312: int ! 4313: ttol(s,n) int n; CHAR *s; { ! 4314: int x, len, tries; ! 4315: ! 4316: if (ttyfd < 0) return(-1); /* Not open? */ ! 4317: debug(F101,"ttol n","",n); ! 4318: tries = TTOLMAXT; /* Allow up to this many tries */ ! 4319: len = n; /* Remember original length */ ! 4320: ! 4321: while (n > 0 && tries-- > 0) { /* Be persistent */ ! 4322: debug(F101,"ttol try","",TTOLMAXT - tries); ! 4323: x = write(ttyfd,s,n); /* Write string to device */ ! 4324: if (x == n) { /* Worked? */ ! 4325: debug(F101,"ttol ok","",x); /* OK */ ! 4326: return(len); /* Done */ ! 4327: } else if (x < 0) { /* No, got error? */ ! 4328: debug(F101,"ttol failed","",errno); ! 4329: return(-1); ! 4330: } else { /* No error, so partial success */ ! 4331: debug(F101,"ttol partial","",x); ! 4332: s += x; /* Point to part not written yet */ ! 4333: n -= x; /* Adjust length */ ! 4334: if (x > 0) msleep(100); /* Wait 100 msec */ ! 4335: } /* Go back and try again */ ! 4336: } ! 4337: return(n < 1 ? len : -1); /* Too many tries */ ! 4338: } ! 4339: ! 4340: ! 4341: ! 4342: /* T T O C -- Output a character to the communication line */ ! 4343: ! 4344: /* ! 4345: This function should only be used for interactive, character-mode operations, ! 4346: like terminal connection, script execution, dialer i/o, where the overhead ! 4347: of the signals and alarms does not create a bottleneck. ! 4348: */ ! 4349: int ! 4350: #ifdef CK_ANSIC ! 4351: ttoc(char c) ! 4352: #else ! 4353: ttoc(c) char c; ! 4354: #endif /* CK_ANSIC */ ! 4355: /* ttoc */ { ! 4356: #define TTOC_TMO 15 /* Timeout in case we get stuck */ ! 4357: int xx; ! 4358: c &= 0xff; ! 4359: /* debug(F101,"ttoc","",(CHAR) c); */ ! 4360: if (ttyfd < 0) return(-1); /* Check for not open. */ ! 4361: saval = signal(SIGALRM,timerh); /* Enable timer interrupt */ ! 4362: xx = alarm(TTOC_TMO); /* for this many seconds. */ ! 4363: if (xx < 0) xx = 0; /* Save old alarm value. */ ! 4364: /* debug(F101,"ttoc alarm","",xx); */ ! 4365: if (setjmp(sjbuf)) { /* Timer went off? */ ! 4366: ttimoff(); /* Yes, cancel this alarm. */ ! 4367: if (xx - TTOC_TMO > 0) alarm(xx - TTOC_TMO); /* Restore previous one */ ! 4368: /* debug(F100,"ttoc timeout","",0); */ ! 4369: #ifdef NETCONN ! 4370: if (!netconn) { ! 4371: #endif /* NETCONN */ ! 4372: debug(F101,"ttoc timeout","",c); ! 4373: if (ttflow == FLO_XONX) { ! 4374: int x = 0, y; ! 4375: debug(F101,"ttoc flow","",ttflow); /* Maybe we're xoff'd */ ! 4376: #ifdef POSIX ! 4377: y = tcflow(ttyfd,TCOON); /* POSIX way to unstick. */ ! 4378: debug(F100,"ttoc tcflow","",y); ! 4379: #else ! 4380: #ifdef BSD4 /* Berkeley way to do it. */ ! 4381: #ifdef TIOCSTART ! 4382: /* .... Used to be "ioctl(ttyfd, TIOCSTART, 0);". Who knows? */ ! 4383: y = ioctl(ttyfd, TIOCSTART, &x); ! 4384: debug(F101,"ttoc TIOCSTART","",y); ! 4385: #endif /* TIOCSTART */ ! 4386: #endif /* BSD4 */ ! 4387: /* Is there a Sys V way to do this? */ ! 4388: #endif /* POSIX */ ! 4389: } ! 4390: #ifdef NETCONN ! 4391: } ! 4392: #endif /* NETCONN */ ! 4393: return(-1); /* Return failure code. */ ! 4394: } else { ! 4395: if (write(ttyfd,&c,1) < 1) { /* Try to write the character. */ ! 4396: ttimoff(); /* Failed, turn off the alarm. */ ! 4397: alarm(xx); /* Restore previous alarm. */ ! 4398: debug(F101,"ttoc error","",errno); /* Log the error, */ ! 4399: return(-1); /* and return the error code. */ ! 4400: } ! 4401: } ! 4402: ttimoff(); /* Success, turn off the alarm. */ ! 4403: alarm(xx); /* Restore previous alarm. */ ! 4404: return(0); /* Return good code. */ ! 4405: } ! 4406: ! 4407: /* T T I N L -- Read a record (up to break character) from comm line. */ ! 4408: /* ! 4409: Reads up to "max" characters from the communication line, terminating on: ! 4410: ! 4411: (a) the packet length field if the "turn" argument is zero, or ! 4412: (b) on the packet-end character (eol) if the "turn" argument is nonzero ! 4413: (c) two Ctrl-C's in a row ! 4414: ! 4415: and returns the number of characters read upon success, or if "max" was ! 4416: exceeded or the timeout interval expired before (a) or (b), returns -1. ! 4417: ! 4418: The characters that were input are copied into "dest" with their parity bits ! 4419: stripped if parity was selected. Returns the number of characters read. ! 4420: Characters after the eol are available upon the next call to this function. ! 4421: ! 4422: The idea is to minimize the number of system calls per packet, and also to ! 4423: minimize timeouts. This function is the inner loop of the program and must ! 4424: be as efficient as possible. The current strategy is to use myread(). ! 4425: ! 4426: WARNING: this function calls parchk(), which is defined in another module. ! 4427: Normally, ckutio.c does not depend on code from any other module, but there ! 4428: is an exception in this case because all the other ck?tio.c modules also ! 4429: need to call parchk(), so it's better to have it defined in a common place. ! 4430: ! 4431: Since this function has grown to have its fingers so deeply into the ! 4432: protocol, it is slated for removal: rpack() will take care of everything. ! 4433: */ ! 4434: #ifdef CTRLC ! 4435: #undef CTRLC ! 4436: #endif /* CTRLC */ ! 4437: #define CTRLC '\03' ! 4438: /* ! 4439: We have four different declarations here because: ! 4440: (a) to allow Kermit to be built without the automatic parity sensing feature ! 4441: (b) one of each type for ANSI C, one for non-ANSI. ! 4442: */ ! 4443: int ! 4444: #ifdef PARSENSE ! 4445: #ifdef CK_ANSIC ! 4446: ttinl(CHAR *dest, int max,int timo, CHAR eol, CHAR start, int turn) ! 4447: #else ! 4448: ttinl(dest,max,timo,eol,start,turn) int max,timo,turn; CHAR *dest, eol, start; ! 4449: #endif /* CK_ANSIC */ ! 4450: #else /* not PARSENSE */ ! 4451: #ifdef CK_ANSIC ! 4452: ttinl(CHAR *dest, int max,int timo, CHAR eol) ! 4453: #else ! 4454: ttinl(dest,max,timo,eol) int max,timo; CHAR *dest, eol; ! 4455: #endif /* __SDTC__ */ ! 4456: #endif /* PARSENSE */ ! 4457: /* ttinl */ { ! 4458: ! 4459: #ifndef MYREAD ! 4460: CHAR ch; ! 4461: #endif /* MYREAD */ ! 4462: #ifdef PARSENSE ! 4463: int pktlen = -1; ! 4464: int lplen = 0; ! 4465: int havelen = 0; ! 4466: #endif /* PARSENSE */ ! 4467: ! 4468: if (ttyfd < 0) return(-1); /* Not open. */ ! 4469: ! 4470: debug(F101,"ttinl max","",max); ! 4471: debug(F101,"ttinl timo","",timo); ! 4472: ! 4473: *dest = '\0'; /* Clear destination buffer */ ! 4474: if (timo < 0) timo = 0; /* Safety */ ! 4475: if (timo) { /* Don't time out if timo == 0 */ ! 4476: int xx; ! 4477: saval = signal(SIGALRM,timerh); /* Enable timer interrupt */ ! 4478: xx = alarm(timo); /* Set it. */ ! 4479: debug(F101,"ttinl alarm","",xx); ! 4480: } ! 4481: if (setjmp(sjbuf)) { /* Timer went off? */ ! 4482: debug(F100,"ttinl timout","",0); /* Get here on timeout. */ ! 4483: /* debug(F110," with",(char *) dest,0); */ ! 4484: ttimoff(); /* Turn off timer */ ! 4485: return(-1); /* and return error code. */ ! 4486: } else { ! 4487: register int i, m, n; /* local variables */ ! 4488: int ccn = 0; ! 4489: #ifdef PARSENSE ! 4490: int flag = 0; ! 4491: ! 4492: debug(F000,"ttinl start","",start); ! 4493: flag = 0; /* Start of packet flag */ ! 4494: #endif /* PARSENSE */ ! 4495: ! 4496: ttpmsk = m = (ttprty) ? 0177 : 0377; /* Set parity stripping mask. */ ! 4497: ! 4498: #ifdef COMMENT ! 4499: /* ! 4500: No longer needed. ! 4501: */ ! 4502: #ifdef SUNX25 ! 4503: if (netconn && (ttnet == NET_SX25)) ! 4504: #ifdef PARSENSE ! 4505: return(x25inl(dest,max,timo,eol,start)); ! 4506: #else ! 4507: return(x25inl(dest,max,timo,eol)); ! 4508: #endif /* PARSENSE */ ! 4509: #endif /* SUNX25 */ ! 4510: #endif /* COMMENT */ ! 4511: ! 4512: /* Now read into destination, stripping parity and looking for the */ ! 4513: /* the packet terminator, and also for two Ctrl-C's typed in a row. */ ! 4514: ! 4515: i = 0; /* Destination index */ ! 4516: debug(F101,"ttinl eol","",eol); ! 4517: ! 4518: #ifdef MYREAD ! 4519: while (i < max-1) { ! 4520: /* debug(F101,"ttinl i","",i); */ ! 4521: if ((n = myread()) < 0) { ! 4522: debug(F101,"ttinl myread failure, n","",n); ! 4523: debug(F101,"ttinl myread errno,","",errno); ! 4524: /* Don't let EINTR break packets. */ ! 4525: if (n == -3 && errno == EINTR && i > 0) { ! 4526: debug(F101,"ttinl myread i","",i); ! 4527: continue; ! 4528: } ! 4529: break; ! 4530: } ! 4531: #else ! 4532: while ((i < max-1) && (n = read(ttyfd, &ch, 1)) > 0) { ! 4533: n = ch; ! 4534: #endif /* MYREAD */ ! 4535: ! 4536: /* debug(F101,"ttinl char","", (n & ttpmsk)); */ ! 4537: ! 4538: #ifdef PARSENSE ! 4539: /* ! 4540: Figure out what the length is supposed to be in case the packet ! 4541: has no terminator (as with Honeywell GCOS-8 Kermit). ! 4542: */ ! 4543: #ifndef xunchar ! 4544: #define xunchar(ch) (((ch) - 32 ) & 0xFF ) /* Character to number */ ! 4545: #endif /* xunchar */ ! 4546: if ((flag == 0) && ((n & 0x7f) == start)) flag = 1; ! 4547: if (flag) dest[i++] = n & ttpmsk; ! 4548: /* ! 4549: If we have not been instructed to wait for a turnaround character, we ! 4550: can go by the packet length field. If turn != 0, we must wait for the ! 4551: end of line (eol) character before returning. ! 4552: */ ! 4553: if (i == 2) { ! 4554: pktlen = xunchar(dest[1]); ! 4555: havelen = (pktlen > 1); ! 4556: debug(F101,"ttinl length","",pktlen); ! 4557: } else if (i == 5 && pktlen == 0) { ! 4558: lplen = xunchar(dest[4]); ! 4559: } else if (i == 6 && pktlen == 0) { ! 4560: pktlen = lplen * 95 + xunchar(dest[5]) + 5; ! 4561: havelen = 1; ! 4562: debug(F101,"ttinl length","",pktlen); ! 4563: } ! 4564: #else ! 4565: dest[i++] = n & ttpmsk; ! 4566: #endif /* PARSENSE */ ! 4567: if ((n & 0x7f) == CTRLC) { /* Check for ^C^C */ ! 4568: if (++ccn > 1) { /* If we got 2 in a row, bail out. */ ! 4569: if (timo) { /* Clear timer. */ ! 4570: ttimoff(); ! 4571: } ! 4572: fprintf(stderr,"^C...\r\n"); /* Echo Ctrl-C */ ! 4573: return(-2); ! 4574: } ! 4575: } else ccn = 0; /* Not ^C, so reset ^C counter, */ ! 4576: ! 4577: #ifdef PARSENSE ! 4578: if (flag == 0) { ! 4579: debug(F101,"ttinl skipping","",n); ! 4580: continue; ! 4581: } ! 4582: #endif /* PARSENSE */ ! 4583: ! 4584: /* Check for end of packet */ ! 4585: ! 4586: if (((n & 0x7f) == eol) ! 4587: #ifdef PARSENSE ! 4588: || (!turn && havelen && (i > pktlen+1)) ! 4589: #endif /* PARSENSE */ ! 4590: ) { ! 4591: #ifndef PARSENSE ! 4592: debug(F101,"ttinl got eol","",eol); ! 4593: dest[i] = '\0'; /* Yes, terminate the string, */ ! 4594: /* debug(F101,"ttinl i","",i); */ ! 4595: #else ! 4596: if ((n & 0x7f) != eol) { ! 4597: debug(F101,"ttinl EOP length","",pktlen); ! 4598: debug(F101,"ttinl i","",i); ! 4599: } else debug(F101,"ttinl got eol","",eol); ! 4600: dest[i] = '\0'; /* Terminate the string, */ ! 4601: /* Parity checked yet? */ ! 4602: if (ttpflg++ == 0 && ttprty == 0) { ! 4603: if ((ttprty = parchk(dest,start,i)) > 0) { /* No, check. */ ! 4604: int j; ! 4605: debug(F101,"ttinl senses parity","",ttprty); ! 4606: debug(F110,"ttinl packet before",dest,0); ! 4607: ttpmsk = 0x7f; ! 4608: for (j = 0; j < i; j++) ! 4609: dest[j] &= 0x7f; /* Strip parity from packet */ ! 4610: debug(F110,"ttinl packet after ",dest,0); ! 4611: } else ttprty = 0; /* restore if parchk error */ ! 4612: } ! 4613: #endif /* PARSENSE */ ! 4614: if (timo) { /* Turn off timer. */ ! 4615: ttimoff(); ! 4616: } ! 4617: debug(F111,"ttinl got", dest,i); ! 4618: return(i); ! 4619: } ! 4620: } /* end of while() */ ! 4621: ttimoff(); ! 4622: return(-1); ! 4623: } ! 4624: } ! 4625: ! 4626: /* T T I N C -- Read a character from the communication line */ ! 4627: /* ! 4628: On success, returns the character that was read, >= 0. ! 4629: On failure, returns -1 or other negative myread error code. ! 4630: */ ! 4631: int ! 4632: ttinc(timo) int timo; { ! 4633: ! 4634: int n = 0; ! 4635: #ifndef MYREAD ! 4636: CHAR ch = 0; ! 4637: #endif /* MYREAD */ ! 4638: ! 4639: if (ttyfd < 0) return(-1); /* Not open. */ ! 4640: if (timo <= 0) { /* Untimed. */ ! 4641: #ifdef MYREAD ! 4642: /* comm line failure returns -1 thru myread, so no &= 0377 */ ! 4643: n = myread(); /* Wait for a character... */ ! 4644: /* debug(F101,"ttinc MYREAD n","",n); */ ! 4645: return(n < 0 ? n : n & ttpmsk); ! 4646: #else ! 4647: while ((n = read(ttyfd,&ch,1)) == 0) /* Wait for a character. */ ! 4648: /* Shouldn't have to loop in ver 5A. */ ! 4649: #ifdef NETCONN ! 4650: if (netconn) { /* Special handling for net */ ! 4651: netclos(); /* If read() returns 0 it means */ ! 4652: netconn = 0; /* the connection has dropped. */ ! 4653: errno = ENOTCONN; ! 4654: return(-2); ! 4655: } ! 4656: #endif /* NETCONN */ ! 4657: ; ! 4658: /* debug(F000,"ttinc","",ch); */ ! 4659: return( (n < 1) ? -3 : (ch & ttpmsk) ); ! 4660: #endif /* MYREAD */ ! 4661: } else { /* Timed read */ ! 4662: int xx; ! 4663: saval = signal(SIGALRM,timerh); /* Set up handler, save old one. */ ! 4664: xx = alarm(timo); /* Set alarm, save old one. */ ! 4665: /* debug(F101,"ttinc alarm","",xx); */ ! 4666: if (setjmp(sjbuf)) { /* Timer expired */ ! 4667: n = -1; /* set flag */ ! 4668: } else { ! 4669: #ifdef MYREAD ! 4670: n = myread(); /* If managing own buffer... */ ! 4671: /* debug(F101,"ttinc myread","",n); */ ! 4672: #else ! 4673: n = read(ttyfd,&ch,1); /* Otherwise call the system. */ ! 4674: /* debug(F101,"ttinc read","",n); */ ! 4675: if (n > 0) ! 4676: n = ch & 255; ! 4677: else ! 4678: n = (n < 0) ? -3 : -2; /* Special return codes. */ ! 4679: #endif /* MYREAD */ ! 4680: } ! 4681: ttimoff(); /* Turn off the timer */ ! 4682: /* #ifdef COMMENT */ ! 4683: if (n == -1) xx -= timo; /* and restore any previous alarm */ ! 4684: if (xx < 0) xx = 0; /* adjusted by timeout interval */ ! 4685: alarm(xx); /* if timer expired. */ ! 4686: /* #endif */ /* COMMENT */ ! 4687: #ifdef NETCONN ! 4688: if (netconn) { ! 4689: if (n == -2) { /* read() returns 0 */ ! 4690: netclos(); /* on network read failure */ ! 4691: netconn = 0; ! 4692: errno = ENOTCONN; ! 4693: } ! 4694: } ! 4695: #endif /* NETCONN */ ! 4696: return( (n < 0) ? n : (n & ttpmsk) ); /* Return masked char or neg. */ ! 4697: } ! 4698: } ! 4699: ! 4700: /* S N D B R K -- Send a BREAK signal of the given duration */ ! 4701: ! 4702: static int ! 4703: #ifdef CK_ANSIC ! 4704: sndbrk(int msec) { /* Argument is milliseconds */ ! 4705: #else ! 4706: sndbrk(msec) int msec; { ! 4707: #endif /* CK_ANSIC */ ! 4708: #ifndef POSIX ! 4709: int x, n; ! 4710: #endif /* POSIX */ ! 4711: ! 4712: #ifdef ANYBSD ! 4713: #define BSDBREAK ! 4714: #endif /* ANYBSD */ ! 4715: ! 4716: #ifdef BSD44 ! 4717: #define BSDBREAK ! 4718: #endif /* BSD44 */ ! 4719: ! 4720: #ifdef COHERENT ! 4721: #define BSDBREAK ! 4722: #endif /* COHERENT */ ! 4723: ! 4724: #ifdef PROVX1 ! 4725: char spd; ! 4726: #endif /* PROVX1 */ ! 4727: ! 4728: debug(F101,"ttsndb ttyfd","",ttyfd); ! 4729: if (ttyfd < 0) return(-1); /* Not open. */ ! 4730: ! 4731: #ifdef NETCONN ! 4732: if (netconn) /* Send network BREAK */ ! 4733: return(netbreak()); ! 4734: #endif /* NETCONN */ ! 4735: ! 4736: if (msec < 1 || msec > 5000) return(-1); /* Bad argument */ ! 4737: ! 4738: #ifdef POSIX /* Easy in POSIX */ ! 4739: return(tcsendbreak(ttyfd,msec / 375)); ! 4740: #else ! 4741: #ifdef PROVX1 ! 4742: gtty(ttyfd,&ttbuf); /* Get current tty flags */ ! 4743: spd = ttbuf.sg_ospeed; /* Save speed */ ! 4744: ttbuf.sg_ospeed = B50; /* Change to 50 baud */ ! 4745: stty(ttyfd,&ttbuf); /* ... */ ! 4746: n = (int)strlen(brnuls); /* Send the right number of nulls */ ! 4747: x = msec / 91; ! 4748: if (x > n) x = n; ! 4749: write(ttyfd,brnuls,n); ! 4750: ttbuf.sg_ospeed = spd; /* Restore speed */ ! 4751: stty(ttyfd,&ttbuf); /* ... */ ! 4752: return(0); ! 4753: #else ! 4754: #ifdef aegis ! 4755: sio_$control((short)ttyfd, sio_$send_break, msec, st); ! 4756: return(0); ! 4757: #else ! 4758: #ifdef BSDBREAK ! 4759: n = FWRITE; /* Flush output queue. */ ! 4760: /* Watch out for int vs long problems in &n arg! */ ! 4761: ioctl(ttyfd,TIOCFLUSH,&n); /* Ignore any errors.. */ ! 4762: if (ioctl(ttyfd,TIOCSBRK,(char *)0) < 0) { /* Turn on BREAK */ ! 4763: perror("Can't send BREAK"); ! 4764: return(-1); ! 4765: } ! 4766: x = msleep(msec); /* Sleep for so many milliseconds */ ! 4767: if (ioctl(ttyfd,TIOCCBRK,(char *)0) < 0) { /* Turn off BREAK */ ! 4768: perror("BREAK stuck!!!"); ! 4769: doexit(BAD_EXIT,-1); /* Get out, closing the line. */ ! 4770: /* with bad exit status */ ! 4771: } ! 4772: return(x); ! 4773: #else ! 4774: #ifdef ATTSV ! 4775: /* ! 4776: No way to send a long BREAK in Sys V, so send a bunch of regular ones. ! 4777: (Actually, Sys V R4 is *supposed* to have the POSIX tcsendbreak() function, ! 4778: but there's no way for this code to know for sure.) ! 4779: */ ! 4780: x = msec / 275; ! 4781: for (n = 0; n < x; n++) { ! 4782: if (ioctl(ttyfd,TCSBRK,(char *)0) < 0) { ! 4783: perror("Can't send BREAK"); ! 4784: return(-1); ! 4785: } ! 4786: } ! 4787: return(0); ! 4788: #else ! 4789: #ifdef V7 ! 4790: return(genbrk(ttyfd,250)); /* Simulate a BREAK */ ! 4791: #endif /* V7 */ ! 4792: #endif /* BSDBREAK */ ! 4793: #endif /* ATTSV */ ! 4794: #endif /* aegis */ ! 4795: #endif /* PROVX1 */ ! 4796: #endif /* POSIX */ ! 4797: } ! 4798: ! 4799: /* T T S N D B -- Send a BREAK signal */ ! 4800: ! 4801: int ! 4802: ttsndb() { ! 4803: return(sndbrk(275)); ! 4804: } ! 4805: ! 4806: /* T T S N D L B -- Send a Long BREAK signal */ ! 4807: ! 4808: int ! 4809: ttsndlb() { ! 4810: return(sndbrk(1500)); ! 4811: } ! 4812: ! 4813: /* M S L E E P -- Millisecond version of sleep(). */ ! 4814: ! 4815: /* ! 4816: Call with number of milliseconds (thousandths of seconds) to sleep. ! 4817: Intended only for small intervals. For big ones, just use sleep(). ! 4818: Highly system-dependent. ! 4819: Returns 0 always, even if it didn't work. ! 4820: */ ! 4821: ! 4822: /* Define MSLFTIME for systems that must use an ftime() loop. */ ! 4823: #ifdef ANYBSD /* For pre-4.2 BSD versions */ ! 4824: #ifndef BSD4 ! 4825: #define MSLFTIME ! 4826: #endif /* BSD4 */ ! 4827: #endif /* ANYBSD */ ! 4828: ! 4829: #ifdef TOWER1 /* NCR Tower OS 1.0 */ ! 4830: #define MSLFTIME ! 4831: #endif /* TOWER1 */ ! 4832: ! 4833: #ifdef COHERENT /* Coherent */ ! 4834: #ifndef _I386 ! 4835: #define MSLFTIME ! 4836: #endif /* _I386 */ ! 4837: #endif /* COHERENT */ ! 4838: ! 4839: int ! 4840: msleep(m) int m; { ! 4841: ! 4842: #ifndef USLEEP ! 4843: #ifdef SUNOS4 /* Systems that have usleep() */ ! 4844: #define USLEEP ! 4845: #endif /* SUNOS4 */ ! 4846: #ifdef SUN4S5 ! 4847: #define USLEEP ! 4848: #endif /* SUN4S5 */ ! 4849: #ifdef NEXT ! 4850: #define USLEEP ! 4851: #endif /* NEXT*/ ! 4852: #endif /* USLEEP */ ! 4853: ! 4854: #ifdef AIXRS /* RS/6000 can do select() */ ! 4855: #define BSD42 ! 4856: #endif /* AIXRS */ ! 4857: ! 4858: #ifndef SELECT ! 4859: #ifdef BSD44 ! 4860: #define SELECT ! 4861: #endif /* BSD44 */ ! 4862: #ifdef BSD42 ! 4863: #define SELECT ! 4864: #endif /* BSD42 */ ! 4865: #endif /* SELECT */ ! 4866: ! 4867: #ifdef SELECT ! 4868: /* BSD 4.2 & above can do it with select()... */ ! 4869: int t1; ! 4870: if (m <= 0) return(0); ! 4871: if (m >= 1000) { /* Catch big arguments. */ ! 4872: sleep(m/1000); ! 4873: m = m % 1000; ! 4874: if (m < 10) return(0); ! 4875: } ! 4876: if (gettimeofday(&tv, &tz) < 0) return(-1); /* Get current time. */ ! 4877: t1 = tv.tv_sec; /* Seconds */ ! 4878: tv.tv_sec = 0; /* Use select() */ ! 4879: tv.tv_usec = m * 1000L; ! 4880: #ifdef BSD44 ! 4881: select( 0, (fd_set *)0, (fd_set *)0, (fd_set *)0, &tv ); ! 4882: #else ! 4883: #ifdef BSD43 ! 4884: select( 0, (fd_set *)0, (fd_set *)0, (fd_set *)0, &tv ); ! 4885: #else ! 4886: select( 0, (int *)0, (int *)0, (int *)0, &tv ); ! 4887: #endif /* BSD43 */ ! 4888: #endif /* BSD44 */ ! 4889: return(0); ! 4890: ! 4891: #else /* Not SELECT */ ! 4892: ! 4893: #ifdef USLEEP ! 4894: /* ! 4895: "This routine is implemented using setitimer(2); it requires eight ! 4896: system calls...". In other words, it might take 5 minutes to sleep ! 4897: for 100 milliseconds... ! 4898: */ ! 4899: if (m >= 1000) { /* Catch big arguments. */ ! 4900: sleep(m/1000); ! 4901: m = m % 1000; ! 4902: if (m < 10) return(0); ! 4903: } ! 4904: usleep((unsigned int)(m * 1000)); ! 4905: return(0); ! 4906: #else ! 4907: #ifdef aegis ! 4908: time_$clock_t dur; ! 4909: ! 4910: dur.c2.high16 = 0; ! 4911: dur.c2.low32 = 250 * m; /* one millisecond = 250 four microsecond ticks */ ! 4912: time_$wait(time_$relative, dur, st); ! 4913: return(0); ! 4914: #else ! 4915: #ifdef PROVX1 ! 4916: if (m <= 0) return(0); ! 4917: sleep(-((m * 60 + 500) / 1000)); ! 4918: return(0); ! 4919: #else ! 4920: #ifdef NAP ! 4921: nap((long)m); ! 4922: return(0); ! 4923: #else ! 4924: #ifdef ATTSV ! 4925: #ifndef BSD44 ! 4926: extern long times(); /* Or #include <times.h> ? */ ! 4927: #endif /* BSD44 */ ! 4928: long t1, t2, tarray[4]; ! 4929: int t3; ! 4930: ! 4931: #ifdef COMMENT ! 4932: /* This better be picked up in ckcdeb.h... */ ! 4933: char *getenv(); ! 4934: #endif /* COMMENT */ ! 4935: char *cp = getenv("HZ"); ! 4936: int CLOCK_TICK; ! 4937: int hertz; ! 4938: ! 4939: if (cp && (hertz = atoi(cp))) { ! 4940: CLOCK_TICK = 1000 / hertz; ! 4941: } else { /* probably single user mode */ ! 4942: #ifdef HZ ! 4943: CLOCK_TICK = 1000 / HZ; ! 4944: #else ! 4945: static warned = 0; ! 4946: /* HZ always exists in, for instance, SCO Xenix, so you don't have to ! 4947: * make special #ifdefs for XENIX here, like in ver 4F. Also, if you ! 4948: * have Xenix, you have should have nap(), so the best is to use -DNAP ! 4949: * in the makefile. Most systems have HZ. ! 4950: */ ! 4951: CLOCK_TICK = 17; /* 1/60 sec */ ! 4952: if (!warned) { ! 4953: printf("warning: environment variable HZ bad... using HZ=%d\r\n", ! 4954: 1000 / CLOCK_TICK); ! 4955: warned = 1; ! 4956: } ! 4957: #endif /* !HZ */ ! 4958: } ! 4959: ! 4960: if (m <= 0) return(0); ! 4961: if (m >= 1000) { /* Catch big arguments. */ ! 4962: sleep(m/1000); ! 4963: m = m % 1000; ! 4964: if (m < 10) return(0); ! 4965: } ! 4966: if ((t1 = times(tarray)) < 0) return(-1); ! 4967: while (1) { ! 4968: if ((t2 = times(tarray)) < 0) return(-1); ! 4969: t3 = ((int)(t2 - t1)) * CLOCK_TICK; ! 4970: if (t3 > m) return(t3); ! 4971: } ! 4972: #else /* Not ATTSV */ ! 4973: #ifdef MSLFTIME /* Use ftime() loop... */ ! 4974: int t1, t3 = 0; ! 4975: if (m <= 0) return(0); ! 4976: if (m >= 1000) { /* Catch big arguments. */ ! 4977: sleep(m/1000); ! 4978: m = m % 1000; ! 4979: if (m < 10) return(0); ! 4980: } ! 4981: if (ftime(&ftp) < 0) return(-1); /* Get base time. */ ! 4982: t1 = ((ftp.time & 0xff) * 1000) + ftp.millitm; ! 4983: while (1) { ! 4984: ftime(&ftp); /* Get current time and compare. */ ! 4985: t3 = (((ftp.time & 0xff) * 1000) + ftp.millitm) - t1; ! 4986: if (t3 > m) return(0); ! 4987: } ! 4988: #else ! 4989: /* This includes true POSIX, which has no way to do this. */ ! 4990: if (m >= 1000) { /* Catch big arguments. */ ! 4991: sleep(m/1000); ! 4992: m = m % 1000; ! 4993: if (m < 10) return(0); ! 4994: } ! 4995: if (m > 0) while (m > 0) m--; /* Just a dumb busy loop */ ! 4996: return(0); ! 4997: #endif /* MSLFTIME */ ! 4998: #endif /* ATTSV */ ! 4999: #endif /* NAP */ ! 5000: #endif /* PROVX1 */ ! 5001: #endif /* aegis */ ! 5002: #endif /* SELECT */ ! 5003: #endif /* USLEEP */ ! 5004: } ! 5005: ! 5006: /* R T I M E R -- Reset elapsed time counter */ ! 5007: ! 5008: VOID ! 5009: rtimer() { ! 5010: tcount = time( (time_t *) 0 ); ! 5011: } ! 5012: ! 5013: ! 5014: /* G T I M E R -- Get current value of elapsed time counter in seconds */ ! 5015: ! 5016: int ! 5017: gtimer() { ! 5018: int x; ! 5019: x = (int) (time( (time_t *) 0 ) - tcount); ! 5020: debug(F101,"gtimer","",x); ! 5021: return( (x < 0) ? 0 : x ); ! 5022: } ! 5023: ! 5024: ! 5025: /* Z T I M E -- Return date/time string */ ! 5026: ! 5027: VOID ! 5028: ztime(s) char **s; { ! 5029: ! 5030: #undef ZTIMEV7 /* Which systems need to use */ ! 5031: #ifdef COHERENT /* old UNIX Version 7 way... */ ! 5032: #define ZTIMEV7 ! 5033: #endif /* COHERENT */ ! 5034: #ifdef TOWER1 ! 5035: #define ZTIMEV7 ! 5036: #endif /* TOWER1 */ ! 5037: #ifdef ANYBSD ! 5038: #ifndef BSD42 ! 5039: #define ZTIMEV7 ! 5040: #endif /* BSD42 */ ! 5041: #endif /* ANYBSD */ ! 5042: #ifdef V7 ! 5043: #ifndef MINIX ! 5044: #define ZTIMEV7 ! 5045: #endif /* MINIX */ ! 5046: #endif /* V7 */ ! 5047: #ifdef POSIX ! 5048: #define ZTIMEV7 ! 5049: #endif /* POSIX */ ! 5050: ! 5051: #ifdef ATTSV /* AT&T way */ ! 5052: /* extern long time(); */ /* Theoretically these should */ ! 5053: char *ctime(); /* already been dcl'd in <time.h> */ ! 5054: long clock_storage; ! 5055: clock_storage = time( (long *) 0 ); ! 5056: *s = ctime( &clock_storage ); ! 5057: #else ! 5058: #ifdef PROVX1 /* Venix 1.0 way */ ! 5059: int utime[2]; ! 5060: time(utime); ! 5061: *s = ctime(utime); ! 5062: #else ! 5063: #ifdef BSD42 /* 4.2BSD way */ ! 5064: char *asctime(); ! 5065: struct tm *localtime(); ! 5066: struct tm *tp; ! 5067: gettimeofday(&tv, &tz); ! 5068: time(&tv.tv_sec); ! 5069: tp = localtime(&tv.tv_sec); ! 5070: *s = asctime(tp); ! 5071: #else ! 5072: #ifdef MINIX /* MINIX way */ ! 5073: #ifdef COMMENT ! 5074: extern long time(); /* Already got these from <time.h> */ ! 5075: extern char *ctime(); ! 5076: #endif /* COMMENT */ ! 5077: time_t utime[2]; ! 5078: time(utime); ! 5079: *s = ctime(utime); ! 5080: #else ! 5081: #ifdef ZTIMEV7 /* The regular way */ ! 5082: char *asctime(); ! 5083: struct tm *localtime(); ! 5084: struct tm *tp; ! 5085: long xclock; ! 5086: time(&xclock); ! 5087: tp = localtime(&xclock); ! 5088: *s = asctime(tp); ! 5089: #else /* Catch-all for others... */ ! 5090: *s = "Ddd Mmm 00 00:00:00 0000\n" /* Return dummy in asctime() format */ ! 5091: #endif /* ZTIMEV7 */ ! 5092: #endif /* MINIX */ ! 5093: #endif /* BSD42 */ ! 5094: #endif /* PROVX1 */ ! 5095: #endif /* SVORPOSIX */ ! 5096: } ! 5097: ! 5098: /* C O N G M -- Get console terminal modes. */ ! 5099: ! 5100: /* ! 5101: Saves initial console mode, and establishes variables for switching ! 5102: between current (presumably normal) mode and other modes. ! 5103: Should be called when program starts, but only after establishing ! 5104: whether program is in the foreground or background. ! 5105: Returns 1 if it got the modes OK, 0 if it did nothing, -1 on error. ! 5106: */ ! 5107: int ! 5108: congm() { ! 5109: int fd; ! 5110: if (backgrd || !isatty(0)) { /* If in background. */ ! 5111: cgmf = -1; /* Don't bother, modes are garbage. */ ! 5112: return(-1); ! 5113: } ! 5114: if (cgmf > 0) return(0); /* Already did this. */ ! 5115: debug(F100,"congm getting modes","",0); /* Need to do it. */ ! 5116: #ifdef aegis ! 5117: ios_$inq_type_uid(ios_$stdin, conuid, st); ! 5118: if (st.all != status_$ok) { ! 5119: fprintf(stderr, "problem getting stdin objtype: "); ! 5120: error_$print(st); ! 5121: } ! 5122: concrp = (conuid == mbx_$uid); ! 5123: conbufn = 0; ! 5124: #endif /* aegis */ ! 5125: ! 5126: if ((fd = open(CTTNAM,2)) < 0) { /* Open controlling terminal */ ! 5127: fprintf(stderr,"Error opening %s\n", CTTNAM); ! 5128: perror("congm"); ! 5129: return(-1); ! 5130: } ! 5131: #ifdef BSD44ORPOSIX ! 5132: if (tcgetattr(fd,&ccold) < 0) return(-1); ! 5133: if (tcgetattr(fd,&cccbrk) < 0) return(-1); ! 5134: if (tcgetattr(fd,&ccraw) < 0) return(-1); ! 5135: #else ! 5136: #ifdef ATTSV ! 5137: if (ioctl(fd,TCGETA,&ccold) < 0) return(-1); ! 5138: if (ioctl(fd,TCGETA,&cccbrk) < 0) return(-1); ! 5139: if (ioctl(fd,TCGETA,&ccraw) < 0) return(-1); ! 5140: #ifdef VXVE ! 5141: cccbrk.c_line = 0; /* STTY line 0 for CDC VX/VE */ ! 5142: if (ioctl(fd,TCSETA,&cccbrk) < 0) return(-1); ! 5143: ccraw.c_line = 0; /* STTY line 0 for CDC VX/VE */ ! 5144: if (ioctl(fd,TCSETA,&ccraw) < 0) return(-1); ! 5145: #endif /* VXVE */ ! 5146: #else ! 5147: if (gtty(fd,&ccold) < 0) return(-1); ! 5148: if (gtty(fd,&cccbrk) < 0) return(-1); ! 5149: if (gtty(fd,&ccraw) < 0) return(-1); ! 5150: #endif /* ATTSV */ ! 5151: #endif /* BSD44ORPOSIX */ ! 5152: #ifdef sony_news /* Sony NEWS */ ! 5153: if (ioctl(fd,TIOCKGET,&km_con) < 0) { /* Get console Kanji mode */ ! 5154: perror("congm error getting Kanji mode"); ! 5155: debug(F101,"congm error getting Kanji mode","",0); ! 5156: km_con = -1; /* Make sure this stays undefined. */ ! 5157: return(-1); ! 5158: } ! 5159: #endif /* sony_news */ ! 5160: close(fd); ! 5161: cgmf = 1; /* Flag that we got them. */ ! 5162: return(1); ! 5163: } ! 5164: ! 5165: ! 5166: /* C O N C B -- Put console in cbreak mode. */ ! 5167: ! 5168: /* Returns 0 if ok, -1 if not */ ! 5169: ! 5170: int ! 5171: #ifdef CK_ANSIC ! 5172: concb(char esc) ! 5173: #else ! 5174: concb(esc) char esc; ! 5175: #endif /* CK_ANSIC */ ! 5176: /* concb */ { ! 5177: int x; ! 5178: if (cgmf < 1) return(0); /* Console modes not available yet */ ! 5179: if (ttfdflg && ttyfd >= 0 && ttyfd < 3) ! 5180: return(0); ! 5181: debug(F101,"concb backgrd","",backgrd); ! 5182: if (!isatty(0)) return(0); /* Only for real ttys */ ! 5183: debug(F100,"concb isatty","",0); ! 5184: if (backgrd) return(0); /* Do nothing if in background. */ ! 5185: escchr = esc; /* Make this available to other fns */ ! 5186: ckxech = 1; /* Program can echo characters */ ! 5187: #ifdef aegis ! 5188: conbufn = 0; ! 5189: if (concrp) return(write(1, "\035\002", 2)); ! 5190: if (conuid == input_pad_$uid) {pad_$raw(ios_$stdin, st); return(0);} ! 5191: #endif ! 5192: #ifndef SVORPOSIX /* BSD, V7, etc */ ! 5193: cccbrk.sg_flags |= CBREAK; /* Set to character wakeup, */ ! 5194: cccbrk.sg_flags &= ~ECHO; /* no echo. */ ! 5195: x = stty(0,&cccbrk); ! 5196: #else /* Sys V and POSIX */ ! 5197: cccbrk.c_lflag &= ~(ICANON|ECHO|IEXTEN); ! 5198: #ifndef VINTR ! 5199: cccbrk.c_cc[0] = 003; /* interrupt char is control-c */ ! 5200: #else ! 5201: cccbrk.c_cc[VINTR] = 003; ! 5202: #endif /* VINTR */ ! 5203: #ifndef VQUIT ! 5204: cccbrk.c_cc[1] = escchr; /* escape during packet modes */ ! 5205: #else ! 5206: cccbrk.c_cc[VQUIT] = escchr; ! 5207: #endif /* VQUIT */ ! 5208: #ifndef VEOF ! 5209: cccbrk.c_cc[4] = 1; ! 5210: #else ! 5211: #ifdef VMIN ! 5212: cccbrk.c_cc[VMIN] = 1; ! 5213: #endif /* VMIN */ ! 5214: #endif /* VEOF */ ! 5215: #ifdef ZILOG ! 5216: cccbrk.c_cc[5] = 0; ! 5217: #else ! 5218: #ifndef VEOL ! 5219: cccbrk.c_cc[5] = 1; ! 5220: #else ! 5221: #ifdef VTIME ! 5222: cccbrk.c_cc[VTIME] = 1; ! 5223: #endif /* VTIME */ ! 5224: #endif /* VEOL */ ! 5225: #endif /* ZILOG */ ! 5226: #ifdef BSD44ORPOSIX /* Set new modes */ ! 5227: x = tcsetattr(0,TCSADRAIN,&cccbrk); ! 5228: #else /* ATTSV */ /* or the POSIX way */ ! 5229: x = ioctl(0,TCSETAW,&cccbrk); /* the Sys V way */ ! 5230: #endif /* BSD44ORPOSIX */ ! 5231: #endif /* SVORPOSIX */ ! 5232: ! 5233: #ifndef aegis ! 5234: #ifndef NOSETBUF ! 5235: if (x > -1) setbuf(stdout,NULL); /* Make console unbuffered. */ ! 5236: #endif /* NOSETBUF */ ! 5237: #endif /* aegis */ ! 5238: ! 5239: #ifdef V7 ! 5240: #ifndef MINIX ! 5241: if (kmem[CON] < 0) { ! 5242: qaddr[CON] = initrawq(0); ! 5243: if((kmem[CON] = open("/dev/kmem", 0)) < 0) { ! 5244: fprintf(stderr, "Can't read /dev/kmem in concb.\n"); ! 5245: perror("/dev/kmem"); ! 5246: exit(1); ! 5247: } ! 5248: } ! 5249: #endif /* MINIX */ ! 5250: #endif /* V7 */ ! 5251: debug(F101,"concb returns","",x); ! 5252: return(x); ! 5253: } ! 5254: ! 5255: /* C O N B I N -- Put console in binary mode */ ! 5256: ! 5257: /* Returns 0 if ok, -1 if not */ ! 5258: ! 5259: int ! 5260: #ifdef CK_ANSIC ! 5261: conbin(char esc) ! 5262: #else ! 5263: conbin(esc) char esc; ! 5264: #endif /* CK_ANSIC */ ! 5265: /* conbin */ { ! 5266: if (!isatty(0)) return(0); /* only for real ttys */ ! 5267: congm(); /* Get modes if necessary. */ ! 5268: debug(F100,"conbin","",0); ! 5269: escchr = esc; /* Make this available to other fns */ ! 5270: ckxech = 1; /* Program can echo characters */ ! 5271: #ifdef aegis ! 5272: conbufn = 0; ! 5273: if (concrp) return(write(1, "\035\002", 2)); ! 5274: if (conuid == input_pad_$uid) ! 5275: pad_$raw(ios_$stdin, st); ! 5276: return(0) ! 5277: #endif /* aegis */ ! 5278: ! 5279: #ifdef SVORPOSIX ! 5280: ccraw.c_lflag &= ~(ISIG|ICANON|ECHO|IEXTEN); ! 5281: ccraw.c_iflag |= (BRKINT|IGNPAR); ! 5282: #ifdef ATTSV ! 5283: #ifdef BSD44 ! 5284: ccraw.c_iflag &= ~(IGNBRK|INLCR|IGNCR|ICRNL|IXON|IXANY|IXOFF ! 5285: |INPCK|ISTRIP); ! 5286: #else ! 5287: ccraw.c_iflag &= ~(IGNBRK|INLCR|IGNCR|ICRNL|IUCLC|IXON|IXANY|IXOFF ! 5288: |INPCK|ISTRIP); ! 5289: #endif /* BSD44 */ ! 5290: #else /* POSIX */ ! 5291: ccraw.c_iflag &= ~(IGNBRK|INLCR|IGNCR|ICRNL|IXON|IXOFF|INPCK|ISTRIP); ! 5292: #endif /* ATTSV */ ! 5293: ccraw.c_oflag &= ~OPOST; ! 5294: #ifdef ATT7300 ! 5295: ccraw.c_cflag = CLOCAL | B9600 | CS8 | CREAD | HUPCL; ! 5296: #endif /* ATT7300 */ ! 5297: /*** Kermit used to put the console in 8-bit raw mode, but some users have ! 5298: *** pointed out that this should not be done, since some sites actually ! 5299: *** use terminals with parity settings on their Unix systems, and if we ! 5300: *** override the current settings and stop doing parity, then their terminals ! 5301: *** will display blotches for characters whose parity is wrong. Therefore, ! 5302: *** the following two lines are commented out (Larry Afrin, Clemson U): ! 5303: *** ! 5304: *** ccraw.c_cflag &= ~(PARENB|CSIZE); ! 5305: *** ccraw.c_cflag |= (CS8|CREAD); ! 5306: *** ! 5307: *** Sys III/V sites that have trouble with this can restore these lines. ! 5308: ***/ ! 5309: #ifndef VINTR ! 5310: ccraw.c_cc[0] = 003; /* Interrupt char is Ctrl-C */ ! 5311: #else ! 5312: ccraw.c_cc[VINTR] = 003; ! 5313: #endif /* VINTR */ ! 5314: #ifndef VQUIT ! 5315: ccraw.c_cc[1] = escchr; /* Escape during packet mode */ ! 5316: #else ! 5317: ccraw.c_cc[VQUIT] = escchr; ! 5318: #endif /* VQUIT */ ! 5319: #ifndef VEOF ! 5320: ccraw.c_cc[4] = 1; ! 5321: #else ! 5322: #ifdef VMIN ! 5323: ccraw.c_cc[VMIN] = 1; ! 5324: #endif ! 5325: #endif /* VEOF */ ! 5326: ! 5327: #ifdef ZILOG ! 5328: ccraw.c_cc[5] = 0; ! 5329: #else ! 5330: #ifndef VEOL ! 5331: ccraw.c_cc[5] = 1; ! 5332: #else ! 5333: #ifdef VTIME ! 5334: ccraw.c_cc[VTIME] = 1; ! 5335: #endif /* VTIME */ ! 5336: #endif /* VEOL */ ! 5337: #endif /* ZILOG */ ! 5338: ! 5339: #ifdef BSD44ORPOSIX ! 5340: return(tcsetattr(0,TCSADRAIN,&ccraw)); ! 5341: #else ! 5342: return(ioctl(0,TCSETAW,&ccraw)); /* Set new modes. */ ! 5343: #endif /* BSD44ORPOSIX */ ! 5344: ! 5345: #else /* Berkeley, etc. */ ! 5346: ccraw.sg_flags |= (RAW|TANDEM); /* Set rawmode, XON/XOFF (ha) */ ! 5347: ccraw.sg_flags &= ~(ECHO|CRMOD); /* Set char wakeup, no echo */ ! 5348: return(stty(0,&ccraw)); ! 5349: #endif /* SVORPOSIX */ ! 5350: } ! 5351: ! 5352: ! 5353: /* C O N R E S -- Restore the console terminal */ ! 5354: ! 5355: int ! 5356: conres() { ! 5357: debug(F101,"conres cgmf","",cgmf); ! 5358: if (cgmf < 1) return(0); /* Do nothing if modes unchanged */ ! 5359: if (!isatty(0)) return(0); /* only for real ttys */ ! 5360: debug(F100,"conres isatty ok","",0); ! 5361: ckxech = 0; /* System should echo chars */ ! 5362: ! 5363: #ifdef aegis ! 5364: conbufn = 0; ! 5365: if (concrp) return(write(1, "\035\001", 2)); ! 5366: if (conuid == input_pad_$uid) ! 5367: pad_$cooked(ios_$stdin, st); ! 5368: return(0); ! 5369: #endif /* aegis */ ! 5370: ! 5371: #ifdef BSD44ORPOSIX ! 5372: debug(F100,"conres restoring tcsetattr","",0); ! 5373: return(tcsetattr(0,TCSADRAIN,&ccold)); ! 5374: #else ! 5375: #ifdef ATTSV ! 5376: debug(F100,"conres restoring ioctl","",0); ! 5377: return(ioctl(0,TCSETAW,&ccold)); ! 5378: #else /* BSD, V7, and friends */ ! 5379: #ifdef sony_news /* Sony NEWS */ ! 5380: if (km_con != -1) ! 5381: ioctl(0,TIOCKSET,&km_con); /* Restore console Kanji mode */ ! 5382: #endif /* sony_news */ ! 5383: msleep(300); ! 5384: debug(F100,"conres restoring stty","",0); ! 5385: return(stty(0,&ccold)); ! 5386: #endif /* ATTSV */ ! 5387: #endif /* BSD44ORPOSIX */ ! 5388: } ! 5389: ! 5390: /* C O N O C -- Output a character to the console terminal */ ! 5391: ! 5392: int ! 5393: #ifdef CK_ANSIC ! 5394: conoc(char c) ! 5395: #else ! 5396: conoc(c) char c; ! 5397: #endif /* CK_ANSIC */ ! 5398: /* conoc */ { ! 5399: return(write(1,&c,1)); ! 5400: } ! 5401: ! 5402: /* C O N X O -- Write x characters to the console terminal */ ! 5403: ! 5404: int ! 5405: conxo(x,s) int x; char *s; { ! 5406: return(write(1,s,x)); ! 5407: } ! 5408: ! 5409: /* C O N O L -- Write a line to the console terminal */ ! 5410: ! 5411: int ! 5412: conol(s) char *s; { ! 5413: int len; ! 5414: len = (int)strlen(s); ! 5415: return(write(1,s,len)); ! 5416: } ! 5417: ! 5418: /* C O N O L A -- Write an array of lines to the console terminal */ ! 5419: ! 5420: int ! 5421: conola(s) char *s[]; { ! 5422: int i; ! 5423: for (i=0 ; *s[i] ; i++) if (conol(s[i]) < 0) return(-1);; ! 5424: return(0); ! 5425: } ! 5426: ! 5427: /* C O N O L L -- Output a string followed by CRLF */ ! 5428: ! 5429: int ! 5430: conoll(s) char *s; { ! 5431: conol(s); ! 5432: return(write(1,"\r\n",2)); ! 5433: } ! 5434: ! 5435: /* C O N C H K -- Return how many characters available at console */ ! 5436: ! 5437: int ! 5438: conchk() { ! 5439: int x; PEEKTYPE n; ! 5440: ! 5441: if (backgrd || !isatty(0)) return(0); ! 5442: #ifdef PROVX1 ! 5443: x = ioctl(0, TIOCQCNT, &ttbuf); ! 5444: n = ttbuf.sg_ispeed & 0377; ! 5445: return((x < 0) ? 0 : n); ! 5446: #else ! 5447: #ifdef aegis ! 5448: if (conbufn > 0) return(conbufn); /* use old count if nonzero */ ! 5449: ! 5450: /* read in more characters */ ! 5451: conbufn = ios_$get(ios_$stdin, ! 5452: ios_$cond_opt, conbuf, (long)sizeof(conbuf), st); ! 5453: if (st.all != status_$ok) conbufn = 0; ! 5454: conbufp = conbuf; ! 5455: return(conbufn); ! 5456: #else ! 5457: #ifdef V7 ! 5458: #ifdef MINIX ! 5459: return(0); ! 5460: #else ! 5461: lseek(kmem[CON], (long) qaddr[CON], 0); ! 5462: x = read(kmem[CON], &n, sizeof(int)); ! 5463: return((x == sizeof(int))? n: 0); ! 5464: #endif /* MINIX */ ! 5465: #else ! 5466: #ifdef SVORPOSIX ! 5467: if (conesc) { /* Escape typed */ ! 5468: debug(F100,"conchk returns conesc","",conesc); ! 5469: conesc = 0; ! 5470: signal(SIGQUIT,esctrp); /* Restore escape */ ! 5471: return(1); ! 5472: } ! 5473: return(0); ! 5474: #else ! 5475: #ifdef C70 ! 5476: if (conesc) { /* Escape typed */ ! 5477: conesc = 0; ! 5478: signal(SIGQUIT,esctrp); /* Restore escape */ ! 5479: return(1); ! 5480: } ! 5481: return(0); ! 5482: #else ! 5483: #ifdef FIONREAD ! 5484: /* ! 5485: Reportedly, this can cause C-Kermit to be suspended on certain OS's, ! 5486: such as Olivetti X/OS, when called if Kermit is really in the background. ! 5487: Hence the change at the top of this routine to return 0 if the backgrd ! 5488: flag is set. ! 5489: */ ! 5490: x = ioctl(0, FIONREAD, &n); /* BSD and maybe some others */ ! 5491: debug(F101,"conchk","",n); ! 5492: return((x < 0) ? 0 : n); ! 5493: #else ! 5494: return(0); /* Others can't do. */ ! 5495: #endif ! 5496: #endif ! 5497: #endif ! 5498: #endif ! 5499: #endif ! 5500: #endif ! 5501: } ! 5502: ! 5503: /* C O N I N C -- Get a character from the console */ ! 5504: /* ! 5505: Call with timo > 0 to do a timed read, timo == 0 to do an untimed blocking ! 5506: read. Upon success, returns the character. Upon failure, returns -1. ! 5507: A timed read that does not complete within the timeout period returns -1. ! 5508: */ ! 5509: int ! 5510: coninc(timo) int timo; { ! 5511: int n = 0; CHAR ch; ! 5512: int xx; ! 5513: #ifdef aegis /* Apollo Aegis only... */ ! 5514: debug(F101,"coninc timo","",timo); ! 5515: fflush(stdout); ! 5516: if (conchk() > 0) { ! 5517: --conbufn; ! 5518: return(*conbufp++ & 0377); ! 5519: } ! 5520: #endif /* aegis */ ! 5521: ! 5522: if (timo <= 0 ) { /* Untimed, blocking read. */ ! 5523: while (1) { /* Keep trying till we get one. */ ! 5524: n = read(0, &ch, 1); /* Read a character. */ ! 5525: if (n == 0) continue; /* Shouldn't happen. */ ! 5526: if (n > 0) /* If read was successful, */ ! 5527: return(ch & 0377); /* return the character. */ ! 5528: ! 5529: /* Come here if read() returned an error. */ ! 5530: ! 5531: debug(F101, "coninc(0) errno","",errno); /* Log the error. */ ! 5532: #ifdef SVORPOSIX ! 5533: #ifdef CIE /* CIE Regulus has no EINTR symbol? */ ! 5534: #ifndef EINTR ! 5535: #define EINTR 4 ! 5536: #endif /* EINTR */ ! 5537: #endif /* CIE */ ! 5538: /* ! 5539: This routine is used for several different purposes. In CONNECT mode, it is ! 5540: used to do an untimed, blocking read from the keyboard in the lower CONNECT ! 5541: fork. During local-mode file transfer, it reads a character from the ! 5542: console to interrupt the file transfer (like A for a status report, X to ! 5543: cancel a file, etc). Obviously, we don't want the reads in the latter case ! 5544: to be blocking, or the file transfer would stop until the user typed ! 5545: something. Unfortunately, System V does not allow the console device input ! 5546: buffer to be sampled nondestructively (e.g. by conchk()), so a kludge is ! 5547: used instead. During local-mode file transfer, the SIGQUIT signal is armed ! 5548: and trapped by esctrp(), and this routine pretends to have read the quit ! 5549: character from the keyboard normally. But, kludge or no kludge, the read() ! 5550: issued by this command, under System V only, can fail if a signal -- ANY ! 5551: signal -- is caught while the read is pending. This can occur not only when ! 5552: the user types the quit character, but also during telnet negotiations, when ! 5553: the lower CONNECT fork signals the upper one about an echoing mode change. ! 5554: When this happens, we have to post the read() again. This is apparently not ! 5555: a problem in BSD-based UNIX versions. ! 5556: */ ! 5557: if (errno == EINTR) /* Read interrupted. */ ! 5558: if (conesc) { /* If by SIGQUIT, */ ! 5559: conesc = 0; /* the conesc variable is set, */ ! 5560: return(escchr); /* so return the escape character. */ ! 5561: } else continue; /* By other signal, try again. */ ! 5562: #else ! 5563: /* ! 5564: This might be dangerous, but let's do this on non-System V versions too, ! 5565: since at least one SunOS 4.1.2 user complains of immediate disconnections ! 5566: upon first making a TELNET connection. ! 5567: */ ! 5568: if (errno == EINTR) /* Read interrupted. */ ! 5569: continue; ! 5570: #endif /* SVORPOSIX */ ! 5571: return(-1); /* Error */ ! 5572: } ! 5573: } ! 5574: ! 5575: if (timo <= 0) ! 5576: /* This should never happen */ ! 5577: debug(F100,"coninc HORRIBLE ERROR","",0); ! 5578: ! 5579: /* Timed read... */ ! 5580: ! 5581: saval = signal(SIGALRM,timerh); /* Set up timeout handler. */ ! 5582: xx = alarm(timo); /* Set the alarm. */ ! 5583: debug(F101,"coninc alarm","",xx); ! 5584: if (setjmp(sjbuf)) /* The read() timed out. */ ! 5585: n = -2; /* Code for timeout. */ ! 5586: else ! 5587: n = read(0, &ch, 1); ! 5588: ttimoff(); /* Turn off timer */ ! 5589: if (n > 0) /* Got character OK. */ ! 5590: return(ch & 0377); /* Return it. */ ! 5591: ! 5592: /* ! 5593: Read returned an error. Same deal as above, but without the loop. ! 5594: */ ! 5595: debug(F101, "coninc(timo) n","",n); ! 5596: debug(F101, "coninc(timo) errno","",errno); ! 5597: #ifdef SVORPOSIX ! 5598: if (n == -1 && errno == EINTR && conesc != 0) { ! 5599: conesc = 0; ! 5600: return(escchr); /* User entered escape character. */ ! 5601: } else /* n == 0 shouldn't happen. */ ! 5602: #endif /* SVORPOSIX */ ! 5603: return(-1); ! 5604: } ! 5605: ! 5606: /* C O N G K S -- Console Get Keyboard Scancode */ ! 5607: ! 5608: #ifndef congks ! 5609: /* ! 5610: This function needs to be filled in with the various system-dependent ! 5611: system calls used by SUNOS, NeXT OS, Xenix, Aviion, etc, to read a full ! 5612: keyboard scan code. For now, it's a dummy. ! 5613: */ ! 5614: int ! 5615: congks(timo) int timo; { ! 5616: return(coninc(timo)); ! 5617: } ! 5618: #endif /* congks */ ! 5619: ! 5620: #ifdef ATT7300 ! 5621: ! 5622: /* A T T D I A L -- Dial up the remote system using internal modem ! 5623: * Purpose: to open and dial a number on the internal modem available on the ! 5624: * ATT7300 UNIX PC. Written by Joe Doupnik. Superceeds version written by ! 5625: * Richard E. Hill, Dickinson, TX. which employed dial(3c). ! 5626: * Uses information in <sys/phone.h> and our status int attmodem. ! 5627: */ ! 5628: attdial(ttname,speed,telnbr) char *ttname,*telnbr; long speed; { ! 5629: char *telnum; ! 5630: int ttclos(); ! 5631: ! 5632: attmodem &= ~ISMODEM; /* modem not in use yet */ ! 5633: /* Ensure O_NDELAY is set, else i/o traffic hangs */ ! 5634: /* We turn this flag off once the dial is complete */ ! 5635: fcntl(ttyfd, F_SETFL, fcntl(ttyfd, F_GETFL, 0) | O_NDELAY); ! 5636: ! 5637: /* Condition line, check availability & DATA mode, turn on speaker */ ! 5638: if (ioctl(ttyfd,PIOCOFFHOOK, &dialer) == -1) { ! 5639: printf("cannot access phone\n"); ! 5640: ttclos(0); ! 5641: return (-2); ! 5642: } ! 5643: ioctl(ttyfd,PIOCGETP,&dialer); /* get phone dialer parameters */ ! 5644: ! 5645: if (dialer.c_lineparam & VOICE) { /* phone must be in DATA mode */ ! 5646: printf(" Should not dial with modem in VOICE mode.\n"); ! 5647: printf(" Exit Kermit, switch to DATA and retry call.\n"); ! 5648: ttclos(0); ! 5649: return (-2); ! 5650: } ! 5651: #ifdef ATTTONED /* Old way, tone dialing only. */ ! 5652: dialer.c_lineparam = DATA | DTMF; /* Dial with tones, */ ! 5653: dialer.c_lineparam &= ~PULSE; /* not with pulses. */ ! 5654: #else ! 5655: /* Leave current pulse/tone state alone. */ ! 5656: /* But what about DATA? Add it back if you have trouble. */ ! 5657: /* sys/phone says you get DATA automatically by opening device RDWR */ ! 5658: #endif ! 5659: dialer.c_waitdialtone = 5; /* wait 5 sec for dialtone */ ! 5660: #ifdef COMMENT ! 5661: dialer.c_feedback = SPEAKERON|NORMSPK|RINGON; /* control speaker */ ! 5662: #else ! 5663: /* sys/phone says RINGON used only for incoming voice calls */ ! 5664: dialer.c_feedback &= ~(SOFTSPK|LOUDSPK); ! 5665: dialer.c_feedback |= SPEAKERON|NORMSPK; ! 5666: #endif ! 5667: dialer.c_waitflash = 500; /* 0.5 sec flash hook */ ! 5668: if(ioctl(ttyfd,PIOCSETP,&dialer) == -1) { /* set phone parameters */ ! 5669: printf("Cannot set modem characteristics\n"); ! 5670: ttclos(0); ! 5671: return (-2); ! 5672: } ! 5673: ioctl(ttyfd,PIOCRECONN,0); /* Turns on speaker for pulse */ ! 5674: ! 5675: #ifdef COMMENT ! 5676: fprintf(stderr,"Phone line status. line_par:%o dialtone_wait:%o \ ! 5677: line_status:%o feedback:%o\n", ! 5678: dialer.c_lineparam, dialer.c_waitdialtone, ! 5679: dialer.c_linestatus, dialer.c_feedback); ! 5680: #endif ! 5681: ! 5682: attmodem |= ISMODEM; /* modem is now in-use */ ! 5683: sleep(1); ! 5684: for (telnum = telnbr; *telnum != '\0'; telnum++) /* dial number */ ! 5685: #ifdef ATTTONED ! 5686: /* Tone dialing only */ ! 5687: if (ioctl(ttyfd,PIOCDIAL,telnum) != 0) { ! 5688: perror("Error in dialing"); ! 5689: ttclos(0); ! 5690: return(-2); ! 5691: } ! 5692: #else /* Allow Pulse or Tone dialing */ ! 5693: switch (*telnum) { ! 5694: case 't': case 'T': case '%': /* Tone dialing requested */ ! 5695: dialer.c_lineparam |= DTMF; ! 5696: dialer.c_lineparam &= ~PULSE; ! 5697: if (ioctl(ttyfd,PIOCSETP,&dialer) == -1) { ! 5698: printf("Cannot set modem to tone dialing\n"); ! 5699: ttclos(0); ! 5700: return(-2); ! 5701: } ! 5702: break; ! 5703: case 'd': case 'D': case 'p': case 'P': case '^': ! 5704: dialer.c_lineparam |= PULSE; ! 5705: dialer.c_lineparam &= ~DTMF; ! 5706: if (ioctl(ttyfd,PIOCSETP,&dialer) == -1) { ! 5707: printf("Cannot set modem to pulse dialing\n"); ! 5708: ttclos(0); ! 5709: return(-2); ! 5710: } ! 5711: break; ! 5712: default: ! 5713: if (ioctl(ttyfd,PIOCDIAL,telnum) != 0) { ! 5714: perror("Dialing error"); ! 5715: ttclos(0); ! 5716: return(-2); ! 5717: } ! 5718: break; ! 5719: } ! 5720: #endif ! 5721: ! 5722: ioctl(ttyfd,PIOCDIAL,"@"); /* terminator for data call */ ! 5723: do { /* wait for modems to Connect */ ! 5724: if (ioctl(ttyfd,PIOCGETP,&dialer) != 0) { /* get params */ ! 5725: perror("Cannot get modems to connect"); ! 5726: ttclos(0); ! 5727: return(-2); ! 5728: } ! 5729: } while ((dialer.c_linestatus & MODEMCONNECTED) == 0); ! 5730: /* Turn off O_NDELAY flag now. */ ! 5731: fcntl(ttyfd, F_SETFL, fcntl(ttyfd, F_GETFL, 0) & ~O_NDELAY); ! 5732: signal(SIGHUP, ttclos); /* hangup on loss of carrier */ ! 5733: return(0); /* return success */ ! 5734: } ! 5735: ! 5736: /* ! 5737: Offgetty, ongetty functions. These function get the 'getty(1m)' off ! 5738: and restore it to the indicated line. Shell's return codes are: ! 5739: 0: Can't do it. Probably a user logged on. ! 5740: 1: No need. No getty on that line. ! 5741: 2: Done, you should restore the getty when you're done. ! 5742: DOGETY System(3), however, returns them as 0, 256, 512, respectively. ! 5743: Thanks to Kevin O'Gorman, Anarm Software Systems. ! 5744: ! 5745: getoff.sh looks like: geton.sh looks like: ! 5746: setgetty $1 0 setgetty $1 1 ! 5747: err=$? exit $? ! 5748: sleep 2 ! 5749: exit $err ! 5750: */ ! 5751: ! 5752: /* O F F G E T T Y -- Turn off getty(1m) for the communications tty line ! 5753: * and get status so it can be restarted after the line is hung up. ! 5754: */ ! 5755: int ! 5756: offgetty(ttname) char *ttname; { ! 5757: char temp[30]; ! 5758: while (*ttname != '\0') ttname++; /* seek terminator of path */ ! 5759: ttname -= 3; /* get last 3 chars of name */ ! 5760: sprintf(temp,"/usr/bin/getoff.sh %s",ttname); ! 5761: return(zsyscmd(temp)); ! 5762: } ! 5763: ! 5764: /* O N G E T T Y -- Turn on getty(1m) for the communications tty line */ ! 5765: ! 5766: int ! 5767: ongetty(ttname) char *ttname; { ! 5768: char temp[30]; ! 5769: while (*ttname != '\0') ttname++; /* comms tty path name */ ! 5770: ttname -= 3; ! 5771: sprintf(temp,"/usr/bin/geton.sh %s",ttname); ! 5772: return(zsyscmd(temp)); ! 5773: } ! 5774: #endif /* ATT7300 */ ! 5775: ! 5776: /* T T S C A R R -- Set ttcarr variable, controlling carrier handling. ! 5777: * ! 5778: * 0 = Off: Always ignore carrier. E.g. you can connect without carrier. ! 5779: * 1 = On: Heed carrier, except during dialing. Carrier loss gives disconnect. ! 5780: * 2 = Auto: For "modem direct": The same as "Off". ! 5781: * For real modem types: Heed carrier during connect, but ignore ! 5782: * it anytime else. Compatible with pre-5A C-Kermit versions. ! 5783: * ! 5784: * As you can see, this setting does not affect dialing, which always ignores ! 5785: * carrier (unless there is some special exception for some modem type). It ! 5786: * does affect ttopen() if it is set before ttopen() is used. This setting ! 5787: * takes effect on the next call to ttopen()/ttpkt()/ttvt(). And they are ! 5788: * (or should be) always called before any communications is tried, which ! 5789: * means that, practically speaking, the effect is immediate. ! 5790: * ! 5791: * Of course, nothing of this applies to remote mode (xlocal = 0). ! 5792: * ! 5793: * Someone has yet to uncover how to manipulate the carrier in the BSD ! 5794: * environment (or any non-termio using environment). Until that time, this ! 5795: * will simply be a no-op for BSD. ! 5796: * ! 5797: * Note that in previous versions, the carrier was most often left unchanged ! 5798: * in ttpkt()/ttvt() unless they were called with FLO_DIAL or FLO_DIAX. This ! 5799: * has changed. Now it is controlled by ttcarr in conjunction with these ! 5800: * modes. ! 5801: */ ! 5802: int ! 5803: ttscarr(carrier) int carrier; { ! 5804: ttcarr = carrier; ! 5805: debug(F101, "ttscarr","",ttcarr); ! 5806: return(ttcarr); ! 5807: } ! 5808: ! 5809: /* C A R R C T L -- Set tty modes for carrier treatment. ! 5810: * ! 5811: * Sets the appropriate bits in a termio or sgttyb struct for carrier control ! 5812: * (actually, there are no bits in sgttyb for that), or performs any other ! 5813: * operations needed to control this on the current system. The function does ! 5814: * not do the actual TCSETA or stty, since often we want to set other bits too ! 5815: * first. Don't call this function when xlocal is 0, or the tty is not opened. ! 5816: * ! 5817: * We don't know how to do anything like carrier control on non-ATTSV systems, ! 5818: * except, apparently, ultrix. See above. It is also known that this doesn't ! 5819: * have much effect on a Xenix system. For Xenix, one should switch back and ! 5820: * forth between the upper and lower case device files. Maybe later. ! 5821: * Presently, Xenix will stick to the mode it was opened with. ! 5822: * ! 5823: * carrier: 0 = ignore carrier, 1 = require carrier. ! 5824: * The current state is saved in curcarr, and checked to save labour. ! 5825: */ ! 5826: #ifdef SVORPOSIX ! 5827: int ! 5828: #ifdef BSD44ORPOSIX ! 5829: carrctl(ttpar, carrier) struct termios *ttpar; int carrier; ! 5830: #else /* ATTSV */ ! 5831: carrctl(ttpar, carrier) struct termio *ttpar; int carrier; ! 5832: #endif /* BSD44ORPOSIX */ ! 5833: /* carrctl */ { ! 5834: debug(F101, "carrctl","",carrier); ! 5835: if (carrier) ! 5836: ttpar->c_cflag &= ~CLOCAL; ! 5837: else ! 5838: ttpar->c_cflag |= CLOCAL; ! 5839: return(0); ! 5840: } ! 5841: #else /* Berkeley, V7, et al... */ ! 5842: int ! 5843: carrctl(ttpar, carrier) struct sgttyb *ttpar; int carrier; { ! 5844: #ifdef ultrix ! 5845: int temp = 0; ! 5846: #endif /* ultrix */ ! 5847: #ifdef OXOS ! 5848: int modem_status, lnohang = LNOHANG; ! 5849: #endif /* OXOS */ ! 5850: debug(F101, "carrctl","",carrier); ! 5851: if (carrier == curcarr) ! 5852: return(0); ! 5853: curcarr = carrier; ! 5854: #ifdef ultrix ! 5855: if (carrier) { ! 5856: ioctl(ttyfd, TIOCMODEM, &temp); ! 5857: ioctl(ttyfd, TIOCHPCL, 0); ! 5858: } else { ! 5859: /* (According to the manuals, TIOCNCAR should be preferred */ ! 5860: /* over TIOCNMODEM...) */ ! 5861: ioctl(ttyfd, TIOCNMODEM, &temp); ! 5862: } ! 5863: #endif /* ultrix */ ! 5864: #ifdef OXOS ! 5865: /* ! 5866: From Fulvio Marino at Olivetti. This code allows CONNECT to work even ! 5867: if DCD/RTS are down, if "carrier" is set appropriately. ! 5868: */ ! 5869: if (ioctl(ttyfd, TIOCMODG, &modem_status) == 0) { ! 5870: if (carrier) { ! 5871: /* enable carrier detect */ ! 5872: modem_status |= TIOCM_CAR; ! 5873: } else { ! 5874: /* disable carrier detect */ ! 5875: modem_status &= ~TIOCM_CAR; ! 5876: } ! 5877: (void)ioctl(ttyfd, TIOCMODS, &modem_status); ! 5878: } ! 5879: if (carrier) { ! 5880: /* Send hangup when carrier drops */ ! 5881: (void)ioctl(ttyfd, TIOCLBIC, &lnohang); ! 5882: /* hang up the phone */ ! 5883: (void)ioctl(ttyfd, TIOCHPCL, NULL); ! 5884: } else { ! 5885: /* Don't send hangup when carrier drops */ ! 5886: (void)ioctl(ttyfd, TIOCLBIS, &lnohang); ! 5887: } ! 5888: #endif /* OXOS */ ! 5889: return(0); ! 5890: } ! 5891: #endif /* SVORPOSIX */ ! 5892: ! 5893: ! 5894: /* T T G M D M -- Get modem signals */ ! 5895: /* ! 5896: Looks for RS-232 modem signals, and returns those that are on in as its ! 5897: return value, in a bit mask composed of the BM_xxx values defined in ckcdeb.h. ! 5898: Returns: ! 5899: -3 Not implemented ! 5900: -2 if the communication device does not have modem control (e.g. telnet) ! 5901: -1 on error. ! 5902: >= 0 on success, with a bit mask containing the modem signals that are on. ! 5903: */ ! 5904: ! 5905: /* ! 5906: Define the symbol K_MDMCTL if we have Sys V R3 / 4.3 BSD style ! 5907: modem control, namely the TIOCMGET ioctl. ! 5908: */ ! 5909: ! 5910: #ifdef BSD43 ! 5911: #define K_MDMCTL ! 5912: #endif ! 5913: ! 5914: #ifdef SUNOS4 ! 5915: #define K_MDMCTL ! 5916: #endif ! 5917: ! 5918: #ifdef TIOCMGET ! 5919: #define K_MDMCTL ! 5920: #endif ! 5921: ! 5922: int ! 5923: ttgmdm() { ! 5924: ! 5925: #ifdef HPUX /* HPUX has its own way */ ! 5926: ! 5927: /* ! 5928: NOTE: I don't have an HPUX man page, and so I'm only guessing at the ! 5929: right names for these symbols. Somebody with HPUX please let me know ! 5930: what corrections are needed. ! 5931: */ ! 5932: ! 5933: int x, y, z; ! 5934: ! 5935: if (netconn) return(-2); /* No modem signals for network */ ! 5936: if (xlocal) /* Get modem signals */ ! 5937: x = ioctl(ttyfd,MCGETA,&y); ! 5938: else ! 5939: x = ioctl(0,MCGETA,&y); ! 5940: if (x < 0) return(-1); ! 5941: debug(F101,"ttgmdm","",y); ! 5942: ! 5943: z = 0; /* Initialize return value */ ! 5944: ! 5945: /* Now set bits for each modem signal that is reported to be on. */ ! 5946: ! 5947: #ifdef MCTS ! 5948: /* Clear To Send */ ! 5949: if (y & MCTS) z |= BM_CTS; ! 5950: #endif ! 5951: #ifdef MDSR ! 5952: /* Data Set Ready */ ! 5953: if (y & MDSR) z |= BM_DSR; ! 5954: #endif ! 5955: #ifdef MDCD ! 5956: /* Carrier */ ! 5957: if (y & MDCD) z |= BM_DCD; ! 5958: #endif ! 5959: #ifdef MRNG ! 5960: /* Ring Indicate */ ! 5961: if (y & MRNG) z |= BM_RNG; ! 5962: #endif ! 5963: #ifdef MDTR ! 5964: /* Data Terminal Ready */ ! 5965: if (y & MDTR) z |= BM_DTR; ! 5966: #endif ! 5967: #ifdef MRTS ! 5968: /* Request To Send */ ! 5969: if (y & MRTS) z |= BM_RTS; ! 5970: #endif ! 5971: return(z); ! 5972: ! 5973: #else /* ! HPUX */ ! 5974: ! 5975: #ifdef K_MDMCTL ! 5976: /* ! 5977: Note, <sys/ttycom> might have already been included by by <sys/ioctl.h>. ! 5978: Hence the following ifndef on a symbol which is defined there. ! 5979: */ ! 5980: #ifndef TIOCMGET ! 5981: #include <sys/ttycom.h> ! 5982: #endif /* TIOCMGET */ ! 5983: ! 5984: int x, y, z; ! 5985: ! 5986: if (netconn) return(-2); /* Network, no modem signals. */ ! 5987: if (xlocal) ! 5988: x = ioctl(ttyfd,TIOCMGET,&y); /* Get modem signals. */ ! 5989: else ! 5990: x = ioctl(0,TIOCMGET,&y); ! 5991: if (x < 0) return(-1); ! 5992: debug(F101,"ttgmdm","",y); ! 5993: ! 5994: z = 0; /* Initialize return value. */ ! 5995: #ifdef TIOCM_CTS ! 5996: /* Clear To Send */ ! 5997: if (y & TIOCM_CTS) z |= BM_CTS; ! 5998: #endif ! 5999: #ifdef TIOCM_DSR ! 6000: /* Data Set Ready */ ! 6001: if (y & TIOCM_DSR) z |= BM_DSR; ! 6002: #endif ! 6003: #ifdef TIOCM_CAR ! 6004: /* Carrier */ ! 6005: if (y & TIOCM_CAR) z |= BM_DCD; ! 6006: #endif ! 6007: #ifdef TIOCM_RNG ! 6008: /* Ring Indicate */ ! 6009: if (y & TIOCM_RNG) z |= BM_RNG; ! 6010: #endif ! 6011: #ifdef TIOCM_DTR ! 6012: /* Data Terminal Ready */ ! 6013: if (y & TIOCM_DTR) z |= BM_DTR; ! 6014: #endif ! 6015: #ifdef TIOCM_RTS ! 6016: /* Request To Send */ ! 6017: if (y & TIOCM_RTS) z |= BM_RTS; ! 6018: #endif ! 6019: return(z); ! 6020: #else ! 6021: if (netconn) return(-2); ! 6022: return(-3); ! 6023: ! 6024: #endif /* K_MDMCTL */ ! 6025: #endif /* HPUX */ ! 6026: } ! 6027: ! 6028: /* P S U S P E N D -- Put this process in the background. */ ! 6029: ! 6030: /* ! 6031: Call with flag nonzero if suspending is allowed, zero if not allowed. ! 6032: Returns 0 on apparent success, -1 on failure (flag was zero, or ! 6033: kill() returned an error code. ! 6034: */ ! 6035: int ! 6036: psuspend(flag) int flag; { ! 6037: ! 6038: #ifdef RTU ! 6039: extern int rtu_bug; ! 6040: #endif /* RTU */ ! 6041: ! 6042: if (flag == 0) return(-1); ! 6043: ! 6044: #ifdef NOJC ! 6045: return(-1); ! 6046: #else ! 6047: #ifdef SIGTSTP ! 6048: /* ! 6049: The big question here is whether job control is *really* supported. ! 6050: There's no way Kermit can know for sure. The fact that SIGTSTP is ! 6051: defined does not guarantee the Unix kernel supports it, and the fact ! 6052: that the Unix kernel supports it doesn't guarantee that the user's ! 6053: shell (or other process that invoked Kermit) supports it. ! 6054: */ ! 6055: #ifdef RTU ! 6056: rtu_bug = 1; ! 6057: #endif /* RTU */ ! 6058: if (kill(0,SIGSTOP) < 0 ! 6059: #ifdef OXOS ! 6060: /* ! 6061: Because "kill(myself,SIGSTOP)" can't be caught, blocked, or ignored..." ! 6062: */ ! 6063: && kill(getpid(),SIGSTOP) < 0 ! 6064: #else ! 6065: #ifdef MIPS ! 6066: /* Let's try this for MIPS too. */ ! 6067: && kill(getpid(),SIGSTOP) < 0 ! 6068: #endif /* MIPS */ ! 6069: #endif /* OXOS */ ! 6070: ) { /* If job control, suspend the job */ ! 6071: perror("suspend"); ! 6072: debug(F101,"psuspend error","",errno); ! 6073: return(-1); ! 6074: } ! 6075: debug(F100,"psuspend ok","",0); ! 6076: return(0); ! 6077: #else ! 6078: return(-1); ! 6079: #endif /* SIGTSTP */ ! 6080: #endif /* NOJC */ ! 6081: } ! 6082: ! 6083: /* ! 6084: setuid package, by Kristoffer Eriksson, with contributions from Dean ! 6085: Long and fdc. ! 6086: */ ! 6087: ! 6088: #ifndef _POSIX_SOURCE ! 6089: #ifndef SUNOS4 ! 6090: #ifndef NEXT ! 6091: #ifndef PS2AIX10 ! 6092: extern UID_T getuid(), geteuid(), getreuid(); ! 6093: extern GID_T getgid(), getegid(), getregid(); ! 6094: #endif /* PS2AIX10 */ ! 6095: #endif /* NEXT */ ! 6096: #endif /* SUNOS4 */ ! 6097: #endif /* _POSIX_SOURCE */ ! 6098: ! 6099: /* ! 6100: Subject: Set-user-id ! 6101: To: [email protected] (Frank da Cruz) ! 6102: Date: Sat, 21 Apr 90 4:48:25 MES ! 6103: From: Kristoffer Eriksson <[email protected]> ! 6104: ! 6105: This is a set of functions to be used in programs that may be run set-user-id ! 6106: and/or set-group-id. They handle both the case where the program is not run ! 6107: with such privileges (nothing special happens then), and the case where one ! 6108: or both of these set-id modes are used. The program is made to run with the ! 6109: user's real user and group ids most of the time, except for when more ! 6110: privileges are needed. Don't set-user-id to "root". ! 6111: ! 6112: This works on System V and POSIX. In BSD, it depends on the ! 6113: "saved-set-user-id" feature. ! 6114: */ ! 6115: ! 6116: #define UID_ROOT 0 /* Root user and group ids */ ! 6117: #define GID_ROOT 0 ! 6118: ! 6119: /* ! 6120: The following construction automatically defines the symbol SETREUID for ! 6121: Unix versions based on Berkeley Unix 4.2 or later. If this symbol is ! 6122: defined, then this program will use getreuid() and getregid() calls in ! 6123: preference to getuid() and getgid(), which in Berkeley-based Unixes do ! 6124: not allow arbitrary switching back and forth of real & effective uid. ! 6125: This construction also allows -DSETREUID to be put on the cc command line ! 6126: for any system that has and wants to use setre[ug]id(). It also prevents ! 6127: automatic definition of SETREUID if -DNOSETREU is included on the cc ! 6128: command line (or otherwise defined). ! 6129: */ ! 6130: #ifdef FT18 /* None of this for Fortune. */ ! 6131: #define NOSETREU ! 6132: #endif /* FT18 */ ! 6133: ! 6134: #ifdef ANYBSD ! 6135: #ifndef BSD29 ! 6136: #ifndef BSD41 ! 6137: #ifndef SETREUID ! 6138: #ifndef NOSETREU ! 6139: #define SETREUID ! 6140: #endif /* NOSETREU */ ! 6141: #endif /* SETREUID */ ! 6142: #endif /* !BSD41 */ ! 6143: #endif /* !BSD29 */ ! 6144: #endif /* ANYBSD */ ! 6145: ! 6146: /* Variables for user and group IDs. */ ! 6147: ! 6148: static UID_T realuid = (UID_T) -1, privuid = (UID_T) -1; ! 6149: static GID_T realgid = (GID_T) -1, privgid = (GID_T) -1; ! 6150: ! 6151: ! 6152: /* P R I V _ I N I -- Initialize privileges package */ ! 6153: ! 6154: /* Called as early as possible in a set-uid or set-gid program to store the ! 6155: * set-to uid and/or gid and step down to the users real uid and gid. The ! 6156: * stored id's can be temporarily restored (allowed in System V) during ! 6157: * operations that require the privilege. Most of the time, the program ! 6158: * should execute in unpriviliged state, to not impose any security threat. ! 6159: * ! 6160: * Note: Don't forget that access() always uses the real id:s to determine ! 6161: * file access, even with privileges restored. ! 6162: * ! 6163: * Returns an error mask, with error values or:ed together: ! 6164: * 1 if setuid() fails, ! 6165: * 2 if setgid() fails, and ! 6166: * 4 if the program is set-user-id to "root", which can't be handled. ! 6167: * ! 6168: * Only the return value 0 indicates real success. In case of failure, ! 6169: * those privileges that could be reduced have been, at least, but the ! 6170: * program should be aborted none-the-less. ! 6171: * ! 6172: * Also note that these functions do not expect the uid or gid to change ! 6173: * without their knowing. It may work if it is only done temporarily, but ! 6174: * you're on your own. ! 6175: */ ! 6176: int ! 6177: priv_ini() { ! 6178: int err = 0; ! 6179: ! 6180: /* Save real ID:s. */ ! 6181: realuid = getuid(); ! 6182: realgid = getgid(); ! 6183: ! 6184: /* Save current effective ID:s, those set to at program exec. */ ! 6185: privuid = geteuid(); ! 6186: privgid = getegid(); ! 6187: ! 6188: /* If running set-uid, go down to real uid, otherwise remember that ! 6189: * no privileged uid is available. ! 6190: * ! 6191: * Exceptions: ! 6192: * ! 6193: * 1) If the real uid is already "root" and the set-uid uid (the ! 6194: * initial effective uid) is not "root", then we would have trouble ! 6195: * if we went "down" to "root" here, and then temporarily back to the ! 6196: * set-uid uid (not "root") and then again tried to become "root". I ! 6197: * think the "saved set-uid" is lost when changing uid from effective ! 6198: * uid "root", which changes all uid, not only the effective uid. But ! 6199: * in this situation, we can simply go to "root" and stay there all ! 6200: * the time. That should give sufficient privilege (understatement!), ! 6201: * and give the right uids for subprocesses. ! 6202: * ! 6203: * 2) If the set-uid (the initial effective uid) is "root", and we ! 6204: * change uid to the real uid, we can't change it back to "root" when ! 6205: * we need the privilege, for the same reason as in 1). Thus, we can't ! 6206: * handle programs that are set-user-id to "root" at all. The program ! 6207: * should be aborted. Use some other uid. "root" is probably to ! 6208: * privileged for such things, anyway. (The uid is reverted to the ! 6209: * real uid until abortion.) ! 6210: * ! 6211: * These two exceptions have the effect that the "root" uid will never ! 6212: * be one of the two uids that are being switched between, which also ! 6213: * means we don't have to check for such cases in the switching ! 6214: * functions. ! 6215: * ! 6216: * Note that exception 1) is handled by these routines (by constantly ! 6217: * running with uid "root", while exception 2) is a serious error, and ! 6218: * is not provided for at all in the switching functions. ! 6219: */ ! 6220: if (realuid == privuid) ! 6221: privuid = (UID_T) -1; /* Not running set-user-id. */ ! 6222: ! 6223: /* If running set-gid, go down to real gid, otherwise remember that ! 6224: * no privileged gid is available. ! 6225: * ! 6226: * There are no exception like there is for the user id, since there ! 6227: * is no group id that is privileged in the manner of uid "root". ! 6228: * There could be equivalent problems for group changing if the ! 6229: * program sometimes ran with uid "root" and sometimes not, but ! 6230: * that is already avoided as explained above. ! 6231: * ! 6232: * Thus we can expect always to be able to switch to the "saved set- ! 6233: * gid" when we want, and back to the real gid again. You may also ! 6234: * draw the conclusion that set-gid provides for fewer hassles than ! 6235: * set-uid. ! 6236: */ ! 6237: ! 6238: if (realgid == privgid) /* If not running set-user-id, */ ! 6239: privgid = (GID_T) -1; /* remember it this way. */ ! 6240: ! 6241: err = priv_off(); /* Turn off setuid privilege. */ ! 6242: ! 6243: if (privuid == UID_ROOT) /* If setuid to root, */ ! 6244: err |= 4; /* return this error. */ ! 6245: ! 6246: if (realuid == UID_ROOT) /* If real id is root, */ ! 6247: privuid = (UID_T) -1; /* stay root at all times. */ ! 6248: ! 6249: return(err); ! 6250: } ! 6251: ! 6252: ! 6253: /* Macros for hiding the differences in UID/GID setting between various Unix ! 6254: * systems. These macros should always be called with both the privileged ID ! 6255: * and the non-privileged ID. The one in the second argument, will become the ! 6256: * effective ID. The one in the first argument will be retained for later ! 6257: * retrieval. ! 6258: */ ! 6259: #ifdef SETREUID ! 6260: #ifdef SAVEDUID ! 6261: /* On BSD systems with the saved-UID feature, we just juggle the effective ! 6262: * UID back and forth, and leave the real UID at its true value. The kernel ! 6263: * allows switching to both the current real UID, the effective UID, and the ! 6264: * UID which the program is set-UID to. The saved set-UID always holds the ! 6265: * privileged UID for us, and the real UID will always be the non-privileged, ! 6266: * and we can freely choose one of them for the effective UID at any time. ! 6267: */ ! 6268: #define switchuid(hidden,active) setreuid( (UID_T) -1, active) ! 6269: #define switchgid(hidden,active) setregid( (GID_T) -1, active) ! 6270: ! 6271: #else /* SETREUID,!SAVEDUID */ ! 6272: ! 6273: /* On systems with setreXid() but without the saved-UID feature, notably ! 6274: * BSD 4.2, we swap the real and effective UIDs each time. It's ! 6275: * the effective UID that we are interrested in, but we have to retain the ! 6276: * unused UID somewhere to enable us to restore it later, and that we do this ! 6277: * in the real UID. The kernel only allows switching to either the current ! 6278: * real or the effective UID, unless you're "root". ! 6279: */ ! 6280: #define switchuid(hidden,active) setreuid(hidden,active) ! 6281: #define switchgid(hidden,active) setregid(hidden,active) ! 6282: #endif ! 6283: ! 6284: #else /* !SETREUID, !SAVEDUID */ ! 6285: ! 6286: /* On System V and POSIX, the only thing we can change is the effective UID ! 6287: * (unless the current effective UID is "root", but initsuid() avoids that for ! 6288: * us). The kernel allows switching to the current real UID or to the saved ! 6289: * set-UID. These are always set to the non-privileged UID and the privileged ! 6290: * UID, respectively, and we only change the effective UID. This breaks if ! 6291: * the current effective UID is "root", though, because for "root" setuid/gid ! 6292: * becomes more powerful, which is why initsuid() treats "root" specially. ! 6293: * Note: That special treatment maybe could be ignored for BSD? Note: For ! 6294: * systems that don't fit any of these three cases, we simply can't support ! 6295: * set-UID. ! 6296: */ ! 6297: #define switchuid(hidden,active) setuid(active) ! 6298: #define switchgid(hidden,active) setgid(active) ! 6299: #endif /* SETREUID */ ! 6300: ! 6301: ! 6302: /* P R I V _ O N -- Turn on the setuid and/or setgid */ ! 6303: ! 6304: /* Go to the privileged uid (gid) that the program is set-user-id ! 6305: * (set-group-id) to, unless the program is running unprivileged. ! 6306: * If setuid() fails, return value will be 1. If getuid() fails it ! 6307: * will be 2. Return immediately after first failure, and the function ! 6308: * tries to restore any partial work done. Returns 0 on success. ! 6309: * Group id is changed first, since it is less serious than user id. ! 6310: */ ! 6311: int ! 6312: priv_on() { ! 6313: if (privgid != (GID_T) -1) ! 6314: if (switchgid(realgid,privgid)) ! 6315: return(2); ! 6316: ! 6317: if (privuid != (UID_T) -1) ! 6318: if (switchuid(realuid,privuid)) { ! 6319: if (privgid != (GID_T) -1) ! 6320: switchgid(privgid,realgid); ! 6321: return(1); ! 6322: } ! 6323: return(0); ! 6324: } ! 6325: ! 6326: /* P R I V _ O F F -- Turn on the real uid and gid */ ! 6327: ! 6328: /* Return to the unprivileged uid (gid) after an temporary visit to ! 6329: * privileged status, unless the program is running without set-user-id ! 6330: * (set-group-id). Returns 1 for failure in setuid() and 2 for failure ! 6331: * in setgid() or:ed together. The functions tries to return both uid ! 6332: * and gid to unprivileged state, regardless of errors. Returns 0 on ! 6333: * success. ! 6334: */ ! 6335: int ! 6336: priv_off() { ! 6337: int err = 0; ! 6338: ! 6339: if (privuid != (UID_T) -1) ! 6340: if (switchuid(privuid,realuid)) ! 6341: err |= 1; ! 6342: ! 6343: if (privgid != (GID_T) -1) ! 6344: if (switchgid(privgid,realgid)) ! 6345: err |= 2; ! 6346: ! 6347: return(err); ! 6348: } ! 6349: ! 6350: /* Turn off privilege permanently. No going back. This is necessary before ! 6351: * a fork() on BSD43 machines that don't save the setUID or setGID, because ! 6352: * we swap the real and effective ids, and we don't want to let the forked ! 6353: * process swap them again and get the privilege back. It will work on other ! 6354: * machines too, such that you can rely on its effect always being the same, ! 6355: * for instance, even when you're in priv_on() state when this is called. ! 6356: * (Well, that part about "permanent" is on System V only true if you follow ! 6357: * this with a call to exec(), but that's what we want it for anyway.) ! 6358: * Added by Dean Long -- [email protected] ! 6359: */ ! 6360: int ! 6361: priv_can() { ! 6362: ! 6363: #ifdef SETREUID ! 6364: int err = 0; ! 6365: if (privuid != (UID_T) -1) ! 6366: if (setreuid(realuid,realuid)) ! 6367: err |= 1; ! 6368: ! 6369: if (privgid != (GID_T) -1) ! 6370: if (setregid(realgid,realgid)) ! 6371: err |= 2; ! 6372: ! 6373: return(err); ! 6374: ! 6375: #else ! 6376: /* Easy way of using setuid()/setgid() instead of setreuid()/setregid().*/ ! 6377: return(priv_off()); ! 6378: ! 6379: #endif /* SETREUID */ ! 6380: } ! 6381: ! 6382: /* P R I V _ O P N -- For opening protected files or devices. */ ! 6383: ! 6384: int ! 6385: priv_opn(name, modes) char *name; int modes; { ! 6386: int x; ! 6387: priv_on(); /* Turn privileges on */ ! 6388: x = open(name, modes); /* Try to open the device */ ! 6389: priv_off(); /* Turn privileges off */ ! 6390: return(x); /* Return open's return code */ ! 6391: } ! 6392: ! 6393: /* P R I V _ C H K -- Check privileges. */ ! 6394: ! 6395: /* Try to turn them off. If turning them off did not succeed, cancel them */ ! 6396: ! 6397: int ! 6398: priv_chk() { ! 6399: int x, y = 0; ! 6400: x = priv_off(); /* Turn off privs. */ ! 6401: if (x != 0 || getuid() == privuid || geteuid() == privuid) ! 6402: y = priv_can(); ! 6403: if (x != 0 || getgid() == privgid || getegid() == privgid) ! 6404: y = y | priv_can(); ! 6405: return(y); ! 6406: } ! 6407: ! 6408: UID_T ! 6409: real_uid() { ! 6410: return(realuid); ! 6411: } ! 6412: ! 6413: VOID ! 6414: ttimoff() { /* Turn off any timer interrupts */ ! 6415: int xx; ! 6416: /* ! 6417: As of 5A(183), we set SIGALRM to SIG_IGN (to ignore alarms) rather than to ! 6418: SIG_DFL (to catch alarms, or if there is no handler, to exit). This is to ! 6419: cure (mask, really) a deeper problem with stray alarms that occurs on some ! 6420: systems, possibly having to do with sleep(), that caused core dumps. It ! 6421: should be OK to do this, because no code in this module uses nested alarms. ! 6422: (But we still have to watch out for SCRIPT and DIAL...) ! 6423: */ ! 6424: xx = alarm(0); ! 6425: /* debug(F101,"ttimoff alarm","",xx); */ ! 6426: if (saval) { /* Restore any previous */ ! 6427: signal(SIGALRM,saval); /* alarm handler. */ ! 6428: /* debug(F101,"ttimoff alarm restoring saval","",saval); */ ! 6429: saval = NULL; ! 6430: } else { ! 6431: signal(SIGALRM,SIG_IGN); /* Used to be SIG_DFL */ ! 6432: /* debug(F100,"ttimoff alarm SIG_IGN","",0); */ ! 6433: } ! 6434: }
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.