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