Return to ckutio.c CVS log

Up to [CSRG BSD Unix] / 43BSD / contrib / kermit

Annotation of 43BSD/contrib/kermit/ckutio.c, revision 1.1

1.1     ! root        1: char *ckxv = "Unix tty I/O, 4C(037), 31 Jul 85";
        !             2: 
        !             3: /*  C K U T I O  */
        !             4: 
        !             5: /* C-Kermit interrupt, terminal control & i/o functions for Unix systems */
        !             6: 
        !             7: /*
        !             8:  Author: Frank da Cruz (SY.FDC@CU20B),
        !             9:  Columbia University Center for Computing Activities, January 1985.
        !            10:  Copyright (C) 1985, Trustees of Columbia University in the City of New York.
        !            11:  Permission is granted to any individual or institution to use, copy, or
        !            12:  redistribute this software so long as it is not sold for profit, provided this
        !            13:  copyright notice is retained. 
        !            14: */
        !            15: /* Includes for all Unixes (conditional includes come later) */
        !            16: 
        !            17: #include <sys/types.h>                 /* Types */
        !            18: #include <sys/dir.h>                   /* Directory */
        !            19: #include <ctype.h>                     /* Character types */
        !            20: #include <stdio.h>                     /* Unix Standard i/o */
        !            21: #include <signal.h>                    /* Interrupts */
        !            22: #include <setjmp.h>                    /* Longjumps */
        !            23: #include "ckcdeb.h"                    /* Typedefs, formats for debug() */
        !            24: 
        !            25: /* Maximum length for the name of a tty device */
        !            26: 
        !            27: #ifndef DEVNAMLEN
        !            28: #define DEVNAMLEN 25
        !            29: #endif
        !            30: 
        !            31: /* 4.1 BSD support added by Charles E. Brooks, EDN-VAX */
        !            32: /* Fortune 16:32 For:Pro 1.7 support mostly like 4.1, added by J-P Dumas */
        !            33: 
        !            34: #ifdef BSD4
        !            35: #define ANYBSD
        !            36: #undef DIRSIZ
        !            37: #define DIRSIZ (sizeof(struct direct))
        !            38: #ifdef MAXNAMLEN
        !            39: #define BSD42
        !            40: char *ckxsys = " 4.2 BSD";
        !            41: #else
        !            42: #ifdef FT17
        !            43: #define BSD41
        !            44: char *ckxsys = " For:Pro Fortune 1.7";
        !            45: #else
        !            46: #define BSD41
        !            47: #ifndef C70
        !            48: char *ckxsys = " 4.1 BSD";
        !            49: #endif
        !            50: #endif
        !            51: #endif
        !            52: #endif
        !            53: 
        !            54: /* 2.9bsd support contributed by Bradley Smith, UCLA */
        !            55: #ifdef BSD29
        !            56: #define ANYBSD
        !            57: char *ckxsys = " 2.9 BSD";
        !            58: #endif
        !            59: 
        !            60: /*
        !            61:  Version 7 UNIX support contributed by Gregg Wonderly,
        !            62:  Oklahoma State University:  [email protected]
        !            63: */
        !            64: #ifdef V7
        !            65: char *ckxsys = " Version 7 UNIX (tm)";
        !            66: #endif V7
        !            67: 
        !            68: /* BBN C70 support from Frank Wancho, WANCHO@SIMTEL20 */
        !            69: #ifdef C70
        !            70: char *ckxsys = " BBN C/70";
        !            71: #endif
        !            72: 
        !            73: /* Amdahl UTS 2.4 (v7 derivative) for IBM 370 series compatible mainframes */
        !            74: /* Contributed by Garard Gaye, Jean-Pierre Dumas, DUMAS@SUMEX-AIM. */
        !            75: #ifdef UTS24
        !            76: char *ckxsys = " Amdahl UTS 2.4";
        !            77: #endif
        !            78: 
        !            79: /* Pro/Venix Version 1.x support from Columbia U. */
        !            80: #ifdef PROVX1
        !            81: char *ckxsys = " Pro-3xx Venix v1";
        !            82: #endif
        !            83: 
        !            84: /* Tower support contributed by John Bray, Auburn, Alabama */
        !            85: #ifdef TOWER1
        !            86: char *ckxsys = " NCR Tower 1632, OS 1.02";
        !            87: #endif
        !            88: 
        !            89: /* Sys III/V, Xenix, PC/IX support by Herm Fischer, Encino, CA */
        !            90: #ifdef UXIII
        !            91: #ifdef XENIX
        !            92: char *ckxsys = " Xenix/286";
        !            93: #else
        !            94: #ifdef PCIX
        !            95: char *ckxsys = " PC/IX";
        !            96: #else
        !            97: #ifdef ISIII
        !            98: char *ckxsys = " Interactive Systems Corp System III";
        !            99: #else
        !           100: char *ckxsys = " AT&T System III/System V";
        !           101: #endif
        !           102: #endif
        !           103: #endif
        !           104: #endif
        !           105: 
        !           106: /* Features... */
        !           107: 
        !           108: /* Do own buffering, using unbuffered read() calls... */
        !           109: #ifdef UXIII
        !           110: #define MYREAD
        !           111: #endif
        !           112: 
        !           113: #ifdef BSD42
        !           114: #define MYREAD
        !           115: #endif
        !           116: 
        !           117: /*
        !           118:  Note - KERLD is the Berkeley Unix Berknet line driver, modified to pass
        !           119:  through all 8  bits, and to allow an arbitrary break character to be set.
        !           120:  Don't define this symbol unless you have made this modification to your
        !           121:  4.2BSD kernel!
        !           122: */
        !           123: #ifdef BSD4
        !           124: /* #define KERLD */  /* <-- note, commented out */
        !           125: #endif
        !           126: 
        !           127: /*
        !           128:  Variables available to outside world:
        !           129: 
        !           130:    dftty  -- Pointer to default tty name string, like "/dev/tty".
        !           131:    dfloc  -- 0 if dftty is console, 1 if external line.
        !           132:    dfprty -- Default parity
        !           133:    dfflow -- Default flow control
        !           134:    ckxech -- Flag for who echoes console typein:
        !           135:      1 - The program (system echo is turned off)
        !           136:      0 - The system (or front end, or terminal).
        !           137:    functions that want to do their own echoing should check this flag
        !           138:    before doing so.
        !           139: 
        !           140:    flfnam -- Name of lock file, including its path, e.g.,
        !           141:                "/usr/spool/uucp/LCK..cul0" or "/etc/locks/tty77"
        !           142:    hasLock -- Flag set if this kermit established a uucp lock.
        !           143:    inbufc -- number of tty line rawmode unread characters 
        !           144:                (system III/V unixes)
        !           145:    backgrd -- Flag indicating program executing in background ( & on 
        !           146:                end of shell command). Used to ignore INT and QUIT signals.
        !           147: 
        !           148:  Functions for assigned communication line (either external or console tty):
        !           149: 
        !           150:    sysinit()               -- System dependent program initialization
        !           151:    ttopen(ttname,local,mdmtyp) -- Open the named tty for exclusive access.
        !           152:    ttclos()                -- Close & reset the tty, releasing any access lock.
        !           153:    ttpkt(speed,flow)       -- Put the tty in packet mode and set the speed.
        !           154:    ttvt(speed,flow)        -- Put the tty in virtual terminal mode.
        !           155:                                or in DIALING or CONNECTED modem control state.
        !           156:    ttinl(dest,max,timo)    -- Timed read line from the tty.
        !           157:    ttinc(timo)             -- Timed read character from tty.
        !           158:    myread()               -- System 3 raw mode bulk buffer read, gives
        !           159:                           --   subsequent chars one at a time and simulates
        !           160:                           --   FIONREAD!
        !           161:    myunrd(c)              -- Places c back in buffer to be read (one only)
        !           162:    ttchk()                 -- See how many characters in tty input buffer.
        !           163:    ttxin(n,buf)            -- Read n characters from tty (untimed).
        !           164:    ttol(string,length)     -- Write a string to the tty.
        !           165:    ttoc(c)                 -- Write a character to the tty.
        !           166:    ttflui()                -- Flush tty input buffer.
        !           167: 
        !           168:    ttlock(ttname)         -- Lock against uucp collisions (Sys III)
        !           169:    ttunlck()              -- Unlock "       "     "
        !           170:    look4lk(ttname)        -- Check if a lock file exists
        !           171: */
        !           172: 
        !           173: /*
        !           174: Functions for console terminal:
        !           175: 
        !           176:    congm()   -- Get console terminal modes.
        !           177:    concb(esc) -- Put the console in single-character wakeup mode with no echo.
        !           178:    conbin(esc) -- Put the console in binary (raw) mode.
        !           179:    conres()  -- Restore the console to mode obtained by congm().
        !           180:    conoc(c)  -- Unbuffered output, one character to console.
        !           181:    conol(s)  -- Unbuffered output, null-terminated string to the console.
        !           182:    conola(s) -- Unbuffered output, array of strings to the console.
        !           183:    conxo(n,s) -- Unbuffered output, n characters to the console.
        !           184:    conchk()  -- Check if characters available at console (bsd 4.2).
        !           185:                Check if escape char (^\) typed at console (System III/V).
        !           186:    coninc(timo)  -- Timed get a character from the console.
        !           187:    conint()  -- Enable terminal interrupts on the console if not background.
        !           188:    connoi()  -- Disable terminal interrupts on the console if not background.
        !           189: 
        !           190: Time functions
        !           191: 
        !           192:    msleep(m) -- Millisecond sleep
        !           193:    ztime(&s) -- Return pointer to date/time string
        !           194:    rtimer() --  Reset timer
        !           195:    gtimer()  -- Get elapsed time since last call to rtimer()
        !           196: */
        !           197: 
        !           198: /* Conditional Includes */
        !           199: 
        !           200: #ifdef FT17
        !           201: #include <sys/file.h>                  /* File information */
        !           202: #endif
        !           203: 
        !           204: #ifndef PROVX1
        !           205: #include <sys/file.h>                  /* File information */
        !           206: #endif
        !           207: 
        !           208: /* System III, System V */
        !           209: 
        !           210: #ifdef UXIII
        !           211: #include <termio.h>
        !           212: #include <sys/ioctl.h>
        !           213: #include <fcntl.h>                     /* directory reading for locking */
        !           214: #include <errno.h>                     /* error numbers for system returns */
        !           215: #endif
        !           216: 
        !           217: /* Not Sys III/V */
        !           218: 
        !           219: #ifndef UXIII
        !           220: #include <sgtty.h>                     /* Set/Get tty modes */
        !           221: #ifndef PROVX1
        !           222: #ifndef V7
        !           223: #ifndef BSD41
        !           224: #include <sys/time.h>                  /* Clock info (for break generation) */
        !           225: #endif
        !           226: #endif
        !           227: #endif
        !           228: #endif
        !           229: 
        !           230: #ifdef BSD41
        !           231: #include <sys/timeb.h>                 /* BSD 4.1 ... ceb */
        !           232: #endif
        !           233: 
        !           234: #ifdef TOWER1
        !           235: #include <sys/timeb.h>                 /* Clock info for NCR Tower */
        !           236: #endif
        !           237: 
        !           238: /* Declarations */
        !           239: 
        !           240: long time();                           /* All Unixes should have this... */
        !           241: extern int errno;                      /* System call error return */
        !           242: 
        !           243: /* Special stuff for V7 input buffer peeking */
        !           244: 
        !           245: #ifdef V7
        !           246: int kmem[2] = { -1, -1};
        !           247: char *initrawq(), *qaddr[2]={0,0};
        !           248: #define CON 0
        !           249: #define TTY 1
        !           250: #endif
        !           251: 
        !           252: /* dftty is the device name of the default device for file transfer */
        !           253: /* dfloc is 0 if dftty is the user's console terminal, 1 if an external line */
        !           254: 
        !           255: #ifdef PROVX1
        !           256:     char *dftty = "/dev/com1.dout"; /* Only example so far of a system */
        !           257:     int dfloc = 1;                 /* that goes in local mode by default */
        !           258: #else
        !           259:     char *dftty = CTTNAM;              /* Remote by default, use normal */
        !           260:     int dfloc = 0;                     /* controlling terminal name. */
        !           261: #endif
        !           262: 
        !           263:     int dfprty = 0;                    /* Parity (0 = none) */
        !           264:     int dfflow = 1;                    /* Xon/Xoff flow control */
        !           265:     int backgrd = 0;                   /* Assume in foreground (no '&' ) */
        !           266: 
        !           267: int ckxech = 0; /* 0 if system normally echoes console characters, else 1 */
        !           268: 
        !           269: /* Declarations of variables global within this module */
        !           270: 
        !           271: static long tcount;                    /* Elapsed time counter */
        !           272: 
        !           273: static char *brnuls = "\0\0\0\0\0\0\0"; /* A string of nulls */
        !           274: 
        !           275: static jmp_buf sjbuf, jjbuf;           /* Longjump buffer */
        !           276: static int lkf = 0,                    /* Line lock flag */
        !           277:     conif = 0,                         /* Console interrupts on/off flag */
        !           278:     cgmf = 0,                          /* Flag that console modes saved */
        !           279:     xlocal = 0,                                /* Flag for tty local or remote */
        !           280:     ttyfd = -1;                                /* TTY file descriptor */
        !           281: static char escchr;                    /* Escape or attn character */
        !           282: 
        !           283: /* Special line discipline, 4.2bsd only, and only with kernel mods... */
        !           284: #ifdef KERLD
        !           285:     static int kerld = 1;              /* Special Kermit line discipline... */
        !           286:     struct tchars oldc, newc;          /* Special characters */
        !           287:     int ld = NETLDISC;                 /* Really a hack to "Berknet" l.d. */
        !           288:     int oldld;                         /* Old discipline */
        !           289: #else
        !           290:     static int kerld = 0;              /* Not selected, no special l.d. */
        !           291: #endif
        !           292: 
        !           293: #ifdef BSD42
        !           294:     static struct timeval tv;          /* For getting time, from sys/time.h */
        !           295:     static struct timezone tz;
        !           296: #endif
        !           297: 
        !           298: #ifdef BSD29
        !           299:     static struct timeval tv;          /* For getting time, from sys/time.h */
        !           300:     static struct timezone tz;         /* Same as 4.2 */
        !           301: #endif
        !           302: 
        !           303: #ifdef BSD41
        !           304:     static long clock;                 /* For getting time from sys/time.h */
        !           305:     static struct timeb ftp;           /* And from sys/timeb.h */
        !           306: #endif
        !           307: 
        !           308: #ifdef TOWER1
        !           309: static long clock;                     /* For getting time from sys/time.h */
        !           310: static struct timeb ftp;               /* And from sys/timeb.h */
        !           311: #endif
        !           312: 
        !           313: #ifdef V7
        !           314: static long clock;
        !           315: #endif
        !           316: 
        !           317: #ifdef UXIII
        !           318:   static struct termio                         /* sgtty info... */
        !           319:     ttold, ttraw, tttvt,               /* for communication line */
        !           320:     ccold, ccraw, cccbrk;              /* and for console */
        !           321: #else
        !           322:   static struct sgttyb                         /* sgtty info... */
        !           323:     ttold, ttraw, tttvt, ttbuf,                /* for communication line */
        !           324:     ccold, ccraw, cccbrk;              /* and for console */
        !           325: #endif
        !           326: 
        !           327: static char flfnam[80];                        /* uucp lock file path name */
        !           328: static int hasLock = 0;                        /* =1 if this kermit locked uucp */
        !           329: static int inbufc = 0;                 /* stuff for efficient SIII raw line */
        !           330: static int ungotn = -1;                        /* pushback to unread character */
        !           331: static int conesc = 0;                 /* set to 1 if esc char (^\) typed */
        !           332: 
        !           333: static int ttlock();                   /* definition of ttlock subprocedure */
        !           334: static int ttunlck();                  /* and unlock subprocedure */
        !           335: static char ttnmsv[DEVNAMLEN];         /* copy of open path for tthang */
        !           336: 
        !           337: /*  S Y S I N I T  --  System-dependent program initialization.  */
        !           338: 
        !           339: sysinit() {
        !           340: 
        !           341: /* for now, nothing... */
        !           342: 
        !           343: }
        !           344: 
        !           345: /*  T T O P E N  --  Open a tty for exclusive access.  */
        !           346: 
        !           347: /*  Returns 0 on success, -1 on failure.  */
        !           348: /*
        !           349:   If called with lcl < 0, sets value of lcl as follows:
        !           350:   0: the terminal named by ttname is the job's controlling terminal.
        !           351:   1: the terminal named by ttname is not the job's controlling terminal.
        !           352:   But watch out: if a line is already open, or if requested line can't
        !           353:   be opened, then lcl remains (and is returned as) -1.
        !           354: */
        !           355: ttopen(ttname,lcl,modem) char *ttname; int *lcl, modem; {
        !           356: 
        !           357: #ifdef UXIII
        !           358:     char *ctermid();                   /* Wish they all had this! */
        !           359: #endif
        !           360:     char *x; extern char* ttyname();
        !           361:     char cname[DEVNAMLEN];
        !           362: 
        !           363:     if (ttyfd > -1) return(0);         /* If already open, ignore this call */
        !           364:     xlocal = *lcl;                     /* Make this available to other fns */
        !           365: 
        !           366: #ifndef UXIII
        !           367:     ttyfd = open(ttname,2);            /* Try to open for read/write */
        !           368: #else
        !           369:     /* if modem connection, don't wait for carrier */
        !           370:     ttyfd = open(ttname,O_RDWR | (modem ? O_NDELAY : 0) );
        !           371: #endif
        !           372: 
        !           373:     if (ttyfd < 0) {                   /* If couldn't open, fail. */
        !           374:        return(-1);
        !           375:     }
        !           376:     strncpy(ttnmsv,ttname,DEVNAMLEN);  /* Open, keep copy of name locally. */
        !           377: 
        !           378: /* Caller wants us to figure out if line is controlling tty */
        !           379: 
        !           380:     debug(F111,"ttopen",ttname,*lcl);
        !           381:     if (*lcl == -1) {
        !           382:        if (strcmp(ttname,CTTNAM) == 0) {   /* "/dev/tty" always remote */
        !           383:            debug(F110," Same as CTTNAM",ttname,0);
        !           384:            xlocal = 0;
        !           385:        } else if (isatty(0)) {         /* Else, if stdin not redirected */
        !           386:            x = ttyname(0);             /* then compare its device name */
        !           387:            strncpy(cname,x,DEVNAMLEN); /* (copy from internal static buf) */
        !           388:            debug(F110," ttyname(0)",x,0);
        !           389:            x = ttyname(ttyfd);         /* ...with real name of ttname. */
        !           390:            xlocal = (strncmp(x,cname,DEVNAMLEN) == 0) ? 0 : 1;
        !           391:            debug(F111," ttyname",x,xlocal);
        !           392:        } else {                        /* Else, if stdin redirected... */
        !           393: #ifdef UXIII
        !           394: /* Sys III/V provides nice ctermid() function to get name of controlling tty */
        !           395:            ctermid(cname);             /* Get name of controlling terminal */
        !           396:            debug(F110," ctermid",cname,0);
        !           397:            x = ttyname(ttyfd);         /* Compare with name of comm line. */
        !           398:            xlocal = (strncmp(x,cname,DEVNAMLEN) == 0) ? 0 : 1;
        !           399:            debug(F111," ttyname",x,xlocal);
        !           400: #else
        !           401: /* Just assume local, so "set speed" and similar commands will work */
        !           402: /* If not really local, how could it work anyway?... */
        !           403:            xlocal = 1;
        !           404:            debug(F101," redirected stdin","",xlocal);
        !           405: #endif
        !           406:         }
        !           407:     }    
        !           408: 
        !           409: /* Now check if line is locked -- if so fail, else lock for ourselves */
        !           410: 
        !           411:     lkf = 0;                           /* Check lock */
        !           412:     if (xlocal > 0) {
        !           413:        if (ttlock(ttname) < 0) {
        !           414:            fprintf(stderr,"Exclusive access to %s denied\n",ttname);
        !           415:            close(ttyfd); ttyfd = -1;
        !           416:            debug(F110," Access denied by lock",ttname,0);
        !           417:            return(-1);                 /* Not if already locked */
        !           418:        } else lkf = 1;
        !           419:     }
        !           420: 
        !           421: /* Got the line, now set the desired value for local. */
        !           422: 
        !           423:     if (*lcl < 0) *lcl = xlocal;
        !           424: 
        !           425: /* Some special stuff for v7... */
        !           426: 
        !           427: #ifdef V7
        !           428:        if (kmem[TTY] < 0) {    /*  If open, then skip this.  */
        !           429:                qaddr[TTY] = initrawq(ttyfd);   /* Init the queue. */
        !           430:                if ((kmem[TTY] = open("/dev/kmem", 0)) < 0) {
        !           431:                        fprintf(stderr, "Can't read /dev/kmem in ttopen.\n");
        !           432:                        perror("/dev/kmem");
        !           433:                        exit(1);
        !           434:                }
        !           435:        }
        !           436: #endif V7
        !           437: 
        !           438: /* Request exclusive access on systems that allow it. */
        !           439: 
        !           440: #ifndef XENIX
        !           441: /* Xenix exclusive access prevents open(close(...)) from working... */
        !           442: #ifdef TIOCEXCL
        !           443:        if (ioctl(ttyfd,TIOCEXCL, NULL) < 0)
        !           444:            fprintf(stderr,"Warning, problem getting exclusive access\n");
        !           445: #endif
        !           446: #endif
        !           447: 
        !           448: /* Get tty device settings */
        !           449: 
        !           450: #ifndef UXIII
        !           451:     gtty(ttyfd,&ttold);                        /* Get sgtty info */
        !           452:     gtty(ttyfd,&ttraw);                        /* And a copy of it for packets*/
        !           453:     gtty(ttyfd,&tttvt);                        /* And one for virtual tty service */
        !           454: #else
        !           455:     ioctl(ttyfd,TCGETA,&ttold);                /* Same deal for Sys III, Sys V */
        !           456:     ioctl(ttyfd,TCGETA,&ttraw);
        !           457:     ioctl(ttyfd,TCGETA,&tttvt);
        !           458: #endif
        !           459:     debug(F101,"ttopen, ttyfd","",ttyfd);
        !           460:     debug(F101," lcl","",*lcl);
        !           461:     debug(F111," lock file",flfnam,lkf);
        !           462:     return(0);
        !           463: }
        !           464: 
        !           465: /*  T T C L O S  --  Close the TTY, releasing any lock.  */
        !           466: 
        !           467: ttclos() {
        !           468:     if (ttyfd < 0) return(0);          /* Wasn't open. */
        !           469:     if (xlocal) {
        !           470:        if (tthang())                   /* Hang up phone line */
        !           471:            fprintf(stderr,"Warning, problem hanging up the phone\n");
        !           472:        if (ttunlck())                  /* Release uucp-style lock */
        !           473:            fprintf(stderr,"Warning, problem releasing lock\n");
        !           474:     }
        !           475:     ttres();                           /* Reset modes. */
        !           476: /* Relinquish exclusive access if we might have had it... */
        !           477: #ifndef XENIX
        !           478: #ifdef TIOCEXCL
        !           479: #ifdef TIOCNXCL
        !           480:     if (ioctl(ttyfd, TIOCNXCL, NULL) < 0)
        !           481:        fprintf(stderr,"Warning, problem relinquishing exclusive access\n");
        !           482: #endif
        !           483: #endif
        !           484: #endif
        !           485:     close(ttyfd);                      /* Close it. */
        !           486:     ttyfd = -1;                                /* Mark it as closed. */
        !           487:     return(0);
        !           488: }
        !           489: 
        !           490: /*  T T H A N G -- Hangup phone line */
        !           491: 
        !           492: tthang() {
        !           493: #ifdef UXIII
        !           494:     unsigned short ttc_save;
        !           495: #endif
        !           496: 
        !           497:     if (ttyfd < 0) return(0);          /* Not open. */
        !           498: #ifdef ANYBSD
        !           499:     ioctl(ttyfd,TIOCCDTR,0);           /* Clear DTR */
        !           500:     msleep(500);                       /* Let things settle */
        !           501:     ioctl(ttyfd,TIOCSDTR,0);           /* Restore DTR */
        !           502: #endif
        !           503: #ifdef UXIII
        !           504:     ttc_save = ttraw.c_cflag;
        !           505:     ttraw.c_cflag &= ~CBAUD;           /* swa: set baud rate to 0 to hangup */
        !           506:     if (ioctl(ttyfd,TCSETAF,&ttraw) < 0) return(-1); /* do it */
        !           507:     msleep(100);                       /* let things settle */
        !           508:     ttraw.c_cflag = ttc_save;
        !           509: #ifndef XENIX          /* xenix cannot do close/open when carrier drops */
        !           510:                                /* following corrects a PC/IX defficiency */
        !           511:     ttc_save = fcntl(ttyfd,F_GETFL,0);
        !           512:     close(ttyfd);              /* close/reopen file descriptor */
        !           513:     if ((ttyfd = open(ttnmsv, ttc_save)) < 0) return(-1);
        !           514: #endif
        !           515:     if (ioctl(ttyfd,TCSETAF,&ttraw) < 0) return(-1); /* un-do it */
        !           516: #endif
        !           517:     return (0);
        !           518: }
        !           519: 
        !           520: 
        !           521: /*  T T R E S  --  Restore terminal to "normal" mode.  */
        !           522: 
        !           523: ttres() {                              /* Restore the tty to normal. */
        !           524:     if (ttyfd < 0) return(-1);         /* Not open. */
        !           525: #ifndef UXIII                          /* except for sIII, */
        !           526:     sleep(1);                          /* Wait for pending i/o to finish. */
        !           527: #endif                                 /*   (sIII does wait in ioctls) */
        !           528: #ifdef KERLD
        !           529:     if (kerld) ioctl(ttyfd,TIOCSETD,&oldld); /* Restore old line discipline. */
        !           530: #endif
        !           531: #ifdef UXIII
        !           532:     if (ioctl(ttyfd,TCSETAW,&ttold) < 0) return(-1); /* restore termio stuff */
        !           533: #else
        !           534:     if (stty(ttyfd,&ttold) < 0) return(-1); /* Restore sgtty stuff */
        !           535: #endif
        !           536: #ifdef KERLD
        !           537:     if (kerld) ioctl(ttyfd,TIOCSETC,&oldc); /* Restore old special chars. */
        !           538: #endif
        !           539: 
        !           540:     return(0);
        !           541: }
        !           542: 
        !           543: /* Exclusive uucp file locking control */
        !           544: /*
        !           545:  by H. Fischer, creative non-Bell coding !
        !           546:  copyright rights for lock modules assigned to Columbia University
        !           547: */
        !           548: static char *
        !           549: xxlast(s,c) char *s; char c; {         /* Equivalent to strrchr() */
        !           550:     int i;
        !           551:     for (i = strlen(s); i > 0; i--)
        !           552:        if ( s[i-1] == c ) return( s + (i - 1) );
        !           553:     return(NULL);          
        !           554: }
        !           555: static
        !           556: look4lk(ttname) char *ttname; {
        !           557:     extern char *strcat(), *strcpy();
        !           558:     char *device, *devname;
        !           559:     char lockfil[DIRSIZ+1];
        !           560: 
        !           561: #ifdef ISIII
        !           562:     char *lockdir = "/etc/locks";
        !           563: #else
        !           564: #ifdef ATT3BX
        !           565:     char *lockdir = "/usr/spool/locks";
        !           566: #else
        !           567:     char *lockdir = "/usr/spool/uucp";
        !           568: #endif
        !           569: #endif
        !           570: 
        !           571:     device = ( (devname=xxlast(ttname,'/')) != NULL ? devname+1 : ttname);
        !           572: 
        !           573: #ifdef ISIII
        !           574:     (void) strcpy( lockfil, device );
        !           575: #else
        !           576:     strcat( strcpy( lockfil, "LCK.." ), device );
        !           577: #endif
        !           578: 
        !           579:     if (access( lockdir, 04 ) < 0) {   /* read access denied on lock dir */
        !           580:        fprintf(stderr,"Warning, read access to lock directory denied\n");
        !           581:        return( 1 );                    /* cannot check or set lock file */
        !           582:     }
        !           583:        
        !           584:     strcat(strcat(strcpy(flfnam,lockdir),"/"), lockfil);
        !           585:     debug(F110,"look4lk",flfnam,0);
        !           586: 
        !           587:     if ( ! access( flfnam, 00 ) ) {    /* print out lock file entry */
        !           588:        char lckcmd[40] ;
        !           589:        strcat( strcpy(lckcmd, "ls -l ") , flfnam);
        !           590:        system(lckcmd);
        !           591:        if (access(flfnam,02) == 0)
        !           592:            printf("(You may type \"! rm %s\" to remove this file)\n",flfnam);
        !           593:        return( -1 );
        !           594:     }
        !           595:     if ( access( lockdir, 02 ) < 0 ) { /* lock file cannot be written */
        !           596:        fprintf(stderr,"Warning, write access to lock directory denied\n");
        !           597:        return( 1 );
        !           598:     }
        !           599:     return( 0 );                       /* okay to go ahead and lock */
        !           600: }
        !           601: 
        !           602: /*  T T L O C K  */
        !           603: 
        !           604: 
        !           605: static
        !           606: ttlock(ttyfd) char *ttyfd; {           /* lock uucp if possible */
        !           607: #ifdef ATT3BX
        !           608:     FILE *lck_fild;
        !           609: #endif
        !           610:     int lck_fil, l4l;
        !           611:     int pid_buf = getpid();            /* pid to save in lock file */
        !           612:        
        !           613:     hasLock = 0;                       /* not locked yet */
        !           614:     l4l = look4lk(ttyfd);
        !           615:     if (l4l < 0) return (-1);          /* already locked */
        !           616:     if (l4l == 1) return (0);          /* can't read/write lock directory */
        !           617:     lck_fil = creat(flfnam, 0444);     /* create lock file ... */
        !           618:     if (lck_fil < 0) return (-1);      /* create of lockfile failed */
        !           619:                /* creat leaves file handle open for writing -- hf */
        !           620: #ifdef ATT3BX
        !           621:     fprintf((lck_fild = fdopen(lck_fil, "w")), "%10d\n", pid_buf);
        !           622:     fflush(lck_fild);
        !           623: #else
        !           624:     write (lck_fil, &pid_buf, sizeof(pid_buf) ); /* uucp expects int in file */
        !           625: #endif
        !           626:     close (lck_fil);
        !           627:     hasLock = 1;                       /* now is locked */
        !           628:     return(0);
        !           629: }
        !           630: 
        !           631: /*  T T U N L O C K  */
        !           632: 
        !           633: static
        !           634: ttunlck() {                            /* kill uucp lock if possible */
        !           635:     if (hasLock) return( unlink( flfnam ) );
        !           636: }
        !           637: 
        !           638: /*  T T P K T  --  Condition the communication line for packets. */
        !           639: /*             or for modem dialing */
        !           640: 
        !           641: #define DIALING        4               /* flags (via flow) for modem handling */
        !           642: #define CONNECT 5
        !           643: 
        !           644: /*  If called with speed > -1, also set the speed.  */
        !           645: 
        !           646: /*  Returns 0 on success, -1 on failure.  */
        !           647: 
        !           648: ttpkt(speed,flow) int speed, flow; {
        !           649:     int s;
        !           650:     if (ttyfd < 0) return(-1);         /* Not open. */
        !           651: 
        !           652: #ifdef KERLD
        !           653: /* Note, KERLD ignores the TANDEM, ECHO, and CRMOD bits */
        !           654:     if (kerld) {
        !           655:        ioctl(ttyfd,TIOCGETD,&oldld);   /* Get line discipline */
        !           656:        ioctl(ttyfd,TIOCGETC,&oldc);    /* Get special chars */
        !           657:        newc = oldc;                    /* Copy special chars */
        !           658:        newc.t_brkc = '\r';             /* Set CR to be break character */
        !           659:        if(ioctl(ttyfd,TIOCSETC,&newc) < 0) return(-1);
        !           660:     }
        !           661: #endif
        !           662: 
        !           663:     s = ttsspd(speed);                 /* Check the speed */
        !           664: 
        !           665: #ifndef UXIII
        !           666:     if (flow == 1) ttraw.sg_flags |= TANDEM; /* Use XON/XOFF if selected */
        !           667:     if (flow == 0) ttraw.sg_flags &= ~TANDEM;
        !           668:     ttraw.sg_flags |= RAW;             /* Go into raw mode */
        !           669:     ttraw.sg_flags &= ~(ECHO|CRMOD);   /* Use CR for break character */
        !           670: #ifdef TOWER1
        !           671:     ttraw.sg_flags &= ~ANYP;           /* Must tell Tower no parityr */
        !           672: #endif
        !           673:     if (s > -1) ttraw.sg_ispeed = ttraw.sg_ospeed = s; /* Do the speed */
        !           674:     if (stty(ttyfd,&ttraw) < 0) return(-1);    /* Set the new modes. */
        !           675: 
        !           676: #ifdef MYREAD
        !           677: #ifdef BSD4
        !           678: /* Try to make reads nonblocking */
        !           679:     if (kerld == 0) {
        !           680:        if (fcntl(ttyfd,F_SETFL,fcntl(ttyfd,F_GETFL,0) & FNDELAY) == -1)
        !           681:            return(-1);
        !           682:        else return(0);
        !           683:     }
        !           684: #endif
        !           685: #endif
        !           686: #endif
        !           687: 
        !           688: #ifdef UXIII
        !           689:     if (flow == 1) ttraw.c_iflag |= (IXON|IXOFF);
        !           690:     if (flow == 0) ttraw.c_iflag &= ~(IXON|IXOFF);
        !           691: 
        !           692:     if (flow == DIALING)  ttraw.c_cflag |= CLOCAL|HUPCL;
        !           693:     if (flow == CONNECT)  ttraw.c_cflag &= ~CLOCAL;
        !           694: 
        !           695:     ttraw.c_lflag &= ~(ICANON|ECHO);
        !           696:     ttraw.c_lflag |= ISIG;             /* do check for interrupt */
        !           697:     ttraw.c_iflag |= (BRKINT|IGNPAR);
        !           698:     ttraw.c_iflag &= ~(IGNBRK|INLCR|IGNCR|ICRNL|IUCLC|INPCK|ISTRIP|IXANY);
        !           699:     ttraw.c_oflag &= ~OPOST;
        !           700:     ttraw.c_cflag &= ~(CSIZE|PARENB);
        !           701:     ttraw.c_cflag |= (CS8|CREAD);
        !           702:     ttraw.c_cc[4] = 1;
        !           703:     ttraw.c_cc[5] = 0;
        !           704: 
        !           705:     if (s > -1) ttraw.c_cflag &= ~CBAUD, ttraw.c_cflag |= s; /* set speed */
        !           706: 
        !           707:     if (ioctl(ttyfd,TCSETAW,&ttraw) < 0) return(-1);  /* set new modes . */
        !           708:     if (flow == DIALING) {
        !           709:        if (fcntl(ttyfd,F_SETFL, fcntl(ttyfd, F_GETFL, 0) & ~O_NDELAY) < 0 )
        !           710:                return(-1);
        !           711:        close( open(ttnmsv,2) );        /* magic to force mode change!!! */
        !           712:        }
        !           713: #endif
        !           714: 
        !           715: #ifdef KERLD
        !           716:     if (kerld) {
        !           717:        if (ioctl(ttyfd,TIOCSETD,&ld) < 0)
        !           718:            return(-1); /* Set line discpline. */
        !           719:     }
        !           720: #endif
        !           721: 
        !           722:     ttflui();                          /* Flush any pending input */
        !           723:     return(0);
        !           724: }
        !           725: 
        !           726: /*  T T V T -- Condition communication line for use as virtual terminal  */
        !           727: 
        !           728: ttvt(speed,flow) int speed, flow; {
        !           729:     int s;
        !           730:     if (ttyfd < 0) return(-1);         /* Not open. */
        !           731: 
        !           732:     s = ttsspd(speed);                 /* Check the speed */
        !           733: 
        !           734: #ifndef UXIII
        !           735:     if (flow == 1) tttvt.sg_flags |= TANDEM; /* XON/XOFF if selected */
        !           736:     if (flow == 0) tttvt.sg_flags &= ~TANDEM;
        !           737:     tttvt.sg_flags |= RAW;             /* Raw mode */
        !           738: #ifdef TOWER1
        !           739:     tttvt.sg_flags &= ~(ECHO|ANYP);    /* No echo or system III ??? parity */
        !           740: #else
        !           741:     tttvt.sg_flags &= ~ECHO;           /* No echo */
        !           742: #endif    
        !           743:     if (s > -1) tttvt.sg_ispeed = tttvt.sg_ospeed = s; /* Do the speed */
        !           744:     if (stty(ttyfd,&tttvt) < 0) return(-1);
        !           745: #ifdef MYREAD
        !           746: #ifdef BSD4
        !           747: /* Make reads nonblocking */
        !           748:     if (kerld == 0) {
        !           749:        if (fcntl(ttyfd,F_SETFL,fcntl(ttyfd,F_GETFL,0) & FNDELAY) == -1)
        !           750:            return(-1);
        !           751:        else return(0);
        !           752:     }
        !           753: #endif
        !           754: #endif
        !           755: 
        !           756: #else
        !           757:     if (flow == 1) tttvt.c_iflag |= (IXON|IXOFF);
        !           758:     if (flow == 0) tttvt.c_iflag &= ~(IXON|IXOFF);
        !           759: 
        !           760:     if (flow == DIALING)  tttvt.c_cflag |= CLOCAL|HUPCL;
        !           761:     if (flow == CONNECT)  tttvt.c_cflag &= ~CLOCAL;
        !           762: 
        !           763:     tttvt.c_lflag &= ~(ISIG|ICANON|ECHO);
        !           764:     tttvt.c_iflag |= (IGNBRK|IGNPAR);
        !           765:     tttvt.c_iflag &= ~(INLCR|IGNCR|ICRNL|IUCLC|BRKINT|INPCK|ISTRIP|IXANY);
        !           766:     tttvt.c_oflag &= ~OPOST;
        !           767:     tttvt.c_cflag &= ~(CSIZE|PARENB);
        !           768:     tttvt.c_cflag |= (CS8|CREAD);
        !           769:     tttvt.c_cc[4] = 1;
        !           770:     tttvt.c_cc[5] = 0;
        !           771: 
        !           772:     if (s > -1) tttvt.c_cflag &= ~CBAUD, tttvt.c_cflag |= s; /* set speed */
        !           773: 
        !           774:     if (ioctl(ttyfd,TCSETAW,&tttvt) < 0) return(-1);  /* set new modes . */
        !           775:     if (flow == DIALING) {
        !           776:        if (fcntl(ttyfd,F_SETFL, fcntl(ttyfd, F_GETFL, 0) & ~O_NDELAY) < 0 )
        !           777:                return(-1);
        !           778:        close( open(ttnmsv,2) );        /* magic to force mode change!!! */
        !           779:        }
        !           780:     return(0);
        !           781: #endif
        !           782: }
        !           783: 
        !           784: /*  T T S S P D  --  Return the internal baud rate code for 'speed'.  */
        !           785: 
        !           786: ttsspd(speed) {
        !           787:     int s, spdok;
        !           788: 
        !           789:     if (speed < 0) return(-1);
        !           790:        spdok = 1;                      /* Assume arg ok */
        !           791:        switch (speed) {
        !           792:            case 0:    s = B0;    break;        /* Just the common ones. */
        !           793:            case 110:  s = B110;  break;        /* The others from ttydev.h */
        !           794:            case 150:  s = B150;  break;        /* could also be included if */
        !           795:            case 300:  s = B300;  break;        /* necessary... */
        !           796:            case 600:  s = B600;  break;
        !           797:            case 1200: s = B1200; break;
        !           798:            case 1800: s = B1800; break;
        !           799:            case 2400: s = B2400; break;
        !           800:            case 4800: s = B4800; break;
        !           801:            case 9600: s = B9600; break;
        !           802: #ifdef PLEXUS
        !           803:            case 19200: s = EXTA; break;
        !           804: #endif
        !           805:            default:
        !           806:                spdok = 0;
        !           807:                fprintf(stderr,"Unsupported line speed - %d\n",speed);
        !           808:                fprintf(stderr,"Current speed not changed\n");
        !           809:                break;
        !           810:        }           
        !           811:        if (spdok) return(s); else return(-1);
        !           812:  }
        !           813: 
        !           814: 
        !           815: 
        !           816: /*  T T F L U I  --  Flush tty input buffer */
        !           817: 
        !           818: ttflui() {
        !           819: 
        !           820: #ifndef UXIII
        !           821:     long n;
        !           822: #endif
        !           823:     if (ttyfd < 0) return(-1);         /* Not open. */
        !           824: 
        !           825:     ungotn = -1;                       /* Initialize myread() stuff */
        !           826:     inbufc = 0;
        !           827: 
        !           828: #ifdef UXIII
        !           829:     if (ioctl(ttyfd,TCFLSH,0) < 0) perror("flush failed");
        !           830: #else
        !           831: #ifdef TIOCFLUSH
        !           832: #ifdef ANYBSD
        !           833:     n = FREAD;                         /* Specify read queue */
        !           834:     if (ioctl(ttyfd,TIOCFLUSH,&n) < 0) perror("flush failed");
        !           835: #else
        !           836:     if (ioctl(ttyfd,TIOCFLUSH,0) < 0) perror("flush failed");
        !           837: #endif
        !           838: #endif
        !           839: #endif
        !           840:     return(0);
        !           841: }
        !           842: 
        !           843: /* Interrupt Functions */
        !           844: 
        !           845: 
        !           846: /* Timeout handler for communication line input functions */
        !           847: 
        !           848: timerh() {
        !           849:     longjmp(sjbuf,1);
        !           850: }
        !           851: 
        !           852:  
        !           853: /* Set up terminal interrupts on console terminal */
        !           854: 
        !           855: #ifdef UXIII
        !           856: esctrp() {                             /* trap console escapes (^\) */
        !           857:     conesc = 1;
        !           858:     signal(SIGQUIT,SIG_IGN);           /* ignore until trapped */
        !           859: }
        !           860: #endif
        !           861: 
        !           862: #ifdef V7
        !           863: esctrp() {                             /* trap console escapes (^\) */
        !           864:     conesc = 1;
        !           865:     signal(SIGQUIT,SIG_IGN);           /* ignore until trapped */
        !           866: }
        !           867: #endif
        !           868: 
        !           869: #ifdef C70
        !           870: esctrp() {                             /* trap console escapes (^\) */
        !           871:     conesc = 1;
        !           872:     signal(SIGQUIT,SIG_IGN);           /* ignore until trapped */
        !           873: }
        !           874: #endif
        !           875: 
        !           876: /*  C O N I N T  --  Console Interrupt setter  */
        !           877: 
        !           878: conint(f) int (*f)(); {                        /* Set an interrupt trap. */
        !           879: 
        !           880:     if (backgrd) return;               /* must ignore signals in bkgrd */
        !           881: 
        !           882: /*
        !           883:  Except for special cases below, ignore keyboard quit signal.
        !           884:  ^\ too easily confused with connect escape, and besides, we don't want
        !           885:  to leave lock files around.  (Frank Prindle)
        !           886: */
        !           887:     signal(SIGQUIT,SIG_IGN);
        !           888: 
        !           889: #ifdef UXIII
        !           890:     signal(SIGQUIT,esctrp);            /* console escape in pkt modes */
        !           891:     if (conesc) {                      /* clear out pending escapes */
        !           892:        conesc = 0;
        !           893:     }
        !           894: #endif
        !           895: 
        !           896: #ifdef V7
        !           897:     signal(SIGQUIT,esctrp);            /* console escape in pkt modes */
        !           898:     if (conesc) {                      /* clear out pending escapes */
        !           899:        conesc = 0;
        !           900:     }
        !           901: #endif
        !           902: 
        !           903:     if (conif) return;                 /* Nothing to do if already on. */
        !           904: 
        !           905: /* check if invoked in background -- if so signals set to be ignored */
        !           906: 
        !           907:     if (signal(SIGINT,SIG_IGN) == SIG_IGN) {
        !           908:        backgrd = 1;                    /*   means running in background */
        !           909: #ifdef UXIII
        !           910:        signal(SIGQUIT,SIG_IGN);        /*   must leave signals ignored */
        !           911: #endif
        !           912: #ifdef V7
        !           913:        signal(SIGQUIT,SIG_IGN);        /*   must leave signals ignored */
        !           914: #endif
        !           915:        return;
        !           916:     }
        !           917:     signal(SIGINT,f);                  /* Function to trap to on interrupt. */
        !           918:     signal(SIGHUP,f);                  /* Or hangup, so lock file cleared. */
        !           919:     conif = 1;                         /* Flag console interrupts on. */
        !           920: }
        !           921: 
        !           922: 
        !           923: /*  C O N N O I  --  Reset console terminal interrupts */
        !           924: 
        !           925: connoi() {                             /* Console-no-interrupts */
        !           926: 
        !           927:     if (backgrd) return;               /* Ignore signals in background */
        !           928: 
        !           929:     signal(SIGINT,SIG_DFL);
        !           930:     signal(SIGHUP,SIG_DFL);
        !           931:     signal(SIGQUIT,SIG_DFL);
        !           932:     conif = 0;                         /* Flag interrupt trapping off */
        !           933: }
        !           934: 
        !           935: /*  myread() -- For use by systems that can do nonblocking read() calls  */
        !           936: /*
        !           937:  Returns:
        !           938:   -1  if no characters available,
        !           939:   -2  upon error (such as disconnect),
        !           940:   otherwise value of character (0 or greater)
        !           941: */
        !           942: myread() {
        !           943:     static int inbuf_item;
        !           944:     static CHAR inbuf[257];
        !           945:     CHAR readit;
        !           946:     
        !           947:     if (ungotn >= 0) {
        !           948:        readit = ungotn;
        !           949:     } else {
        !           950:         if (inbufc > 0) {
        !           951:            readit = inbuf[++inbuf_item];
        !           952:         } else {
        !           953:            if ((inbufc = read(ttyfd,inbuf,256)) == 0) {  /* end of file */
        !           954:                        /* means carrier dropped on modem connection */
        !           955:                errno = 9999;           /* magic number for no carrier */
        !           956:                return(-2);             /* end of file has no errno */
        !           957:                }
        !           958:            if (inbufc < 0) return(-2);
        !           959:            readit = inbuf[inbuf_item = 0];
        !           960:        }
        !           961:         inbufc--;      
        !           962:     }
        !           963:     ungotn = -1;
        !           964:     return(readit);
        !           965: }
        !           966: 
        !           967: myunrd(ch) CHAR ch; {                  /* push back up to one character */
        !           968:     ungotn = ch;
        !           969: }
        !           970: 
        !           971: /*  I N I T R A W Q  --  Set up to read /DEV/KMEM for character count.  */
        !           972: 
        !           973: #ifdef V7
        !           974: /*
        !           975:  Used in Version 7 to simulate Berkeley's FIONREAD ioctl call.  This
        !           976:  eliminates blocking on a read, because we can read /dev/kmem to get the
        !           977:  number of characters available for raw input.  If your system can't
        !           978:  or you won't let it read /dev/kmem (the world that is) then you must
        !           979:  figure out a different way to do the counting of characters available,
        !           980:  or else replace this by a dummy function that always returns 0.
        !           981: */
        !           982: /*
        !           983:  * Call this routine as: initrawq(tty)
        !           984:  * where tty is the file descriptor of a terminal.  It will return
        !           985:  * (as a char *) the kernel-mode memory address of the rawq character
        !           986:  * count, which may then be read.  It has the side-effect of flushing
        !           987:  * input on the terminal.
        !           988:  */
        !           989: /*
        !           990:  * John Mackin, Physiology Dept., University of Sydney (Australia)
        !           991:  * ...!decvax!mulga!physiol.su.oz!john
        !           992:  *
        !           993:  * Permission is hereby granted to do anything with this code, as
        !           994:  * long as this comment is retained unmodified and no commercial
        !           995:  * advantage is gained.
        !           996:  */
        !           997: #include <a.out.h>
        !           998: #include <sys/proc.h>
        !           999: 
        !          1000: char *initrawq(tty) int tty; {
        !          1001: #ifdef UTS24
        !          1002:     return(0);
        !          1003: #else
        !          1004: #ifdef BSD29
        !          1005:     return(0);
        !          1006: #else
        !          1007:     long lseek();
        !          1008:     static struct nlist nl[] = {
        !          1009:        {PROCNAME},
        !          1010:        {NPROCNAME},
        !          1011:        {""}
        !          1012:     };
        !          1013:     static struct proc *pp;
        !          1014:     char *malloc(), *qaddr, *p, c;
        !          1015:     int m, pid, me;
        !          1016:     NPTYPE xproc;                      /* Its type is defined in makefile. */
        !          1017:     int catch();
        !          1018: 
        !          1019:     me = getpid();
        !          1020:     if ((m = open("/dev/kmem", 0)) < 0) err("kmem");
        !          1021:     nlist(BOOTNAME, nl);
        !          1022:     if (nl[0].n_type == 0) err("proc array");
        !          1023:  
        !          1024:     if (nl[1].n_type == 0) err("nproc");
        !          1025: 
        !          1026:     lseek(m, (long)(nl[1].n_value), 0);
        !          1027:     read (m, &xproc, sizeof(xproc));
        !          1028:     signal(SIGALRM, catch);
        !          1029:     if ((pid = fork()) == 0) {
        !          1030:        while(1)
        !          1031:            read(tty, &c, 1);
        !          1032:     }
        !          1033:     alarm(2);
        !          1034:  
        !          1035:     if(setjmp(jjbuf) == 0) {
        !          1036:        while(1)
        !          1037:            read(tty, &c, 1);
        !          1038:     }
        !          1039:     signal(SIGALRM, SIG_DFL);
        !          1040: 
        !          1041: #ifdef DIRECT
        !          1042:     pp = (struct proc *) nl[0].n_value;
        !          1043: #else 
        !          1044:     if (lseek(m, (long)(nl[0].n_value), 0) < 0L) err("seek");
        !          1045:     if (read(m, &pp, sizeof(pp)) != sizeof(pp))  err("no read of proc ptr");
        !          1046: #endif
        !          1047:     lseek(m, (long)(nl[1].n_value), 0);
        !          1048:     read(m, &xproc, sizeof(xproc));
        !          1049: 
        !          1050:     if (lseek(m, (long)pp, 0) < 0L) err("Can't seek to proc");
        !          1051:     if ((p = malloc(xproc * sizeof(struct proc))) == NULL) err("malloc");
        !          1052:     if (read(m,p,xproc * sizeof(struct proc)) != xproc*sizeof(struct proc))
        !          1053:        err("read proc table");
        !          1054:     for (pp = (struct proc *)p; xproc > 0; --xproc, ++pp) {
        !          1055:        if (pp -> p_pid == (short) pid) goto iout;
        !          1056:     }
        !          1057:     err("no such proc");
        !          1058:  
        !          1059: iout:
        !          1060:     close(m);
        !          1061:     qaddr = (char *)(pp -> p_wchan);
        !          1062:     free (p);
        !          1063:     kill(pid, SIGKILL);
        !          1064:     wait((int *)0);            /* Destroy the ZOMBIEs! */
        !          1065:     return (qaddr);
        !          1066: #endif
        !          1067: #endif
        !          1068: }
        !          1069: 
        !          1070: /*  More V7-support functions...  */
        !          1071: 
        !          1072: static
        !          1073: err(s) char *s; {
        !          1074:     char buf[200];
        !          1075: 
        !          1076:     sprintf(buf, "fatal error in initrawq: %s", s);
        !          1077:     perror(buf);
        !          1078:     doexit(1);
        !          1079: }
        !          1080: 
        !          1081: static
        !          1082: catch() {
        !          1083:     longjmp(jjbuf, -1);
        !          1084: }
        !          1085: 
        !          1086: 
        !          1087: /*  G E N B R K  --  Simulate a modem break.  */
        !          1088: 
        !          1089: #define        BSPEED  B150
        !          1090: 
        !          1091: genbrk(fn) int fn; {
        !          1092:     struct sgttyb ttbuf;
        !          1093:     int ret, sospeed;
        !          1094: 
        !          1095:     ret = ioctl(fn, TIOCGETP, &ttbuf);
        !          1096:     sospeed = ttbuf.sg_ospeed;
        !          1097:     ttbuf.sg_ospeed = BSPEED;
        !          1098:     ret = ioctl(fn, TIOCSETP, &ttbuf);
        !          1099:     ret = write(fn, "\0\0\0\0\0\0\0\0\0\0\0\0", 8);
        !          1100:     ttbuf.sg_ospeed = sospeed;
        !          1101:     ret = ioctl(fn, TIOCSETP, &ttbuf);
        !          1102:     ret = write(fn, "@", 1);
        !          1103:     return;
        !          1104: }
        !          1105: #endif V7
        !          1106: 
        !          1107: /*  T T C H K  --  Tell how many characters are waiting in tty input buffer  */
        !          1108: 
        !          1109: ttchk() {
        !          1110:     int x; long n;
        !          1111: #ifdef FIONREAD
        !          1112:     x = ioctl(ttyfd, FIONREAD, &n);    /* Berkeley and maybe some others */
        !          1113:     debug(F101,"ttchk","",n);
        !          1114:     return((x < 0) ? 0 : n);
        !          1115: #else
        !          1116: #ifdef V7
        !          1117:     lseek(kmem[TTY], (long) qaddr[TTY], 0);
        !          1118:     x = read(kmem[TTY], &n, sizeof(int));
        !          1119:     return((x == sizeof(int))? n: 0);
        !          1120: #else  V7
        !          1121: #ifdef UXIII
        !          1122:     return(inbufc + (ungotn >= 0) );   
        !          1123: #else
        !          1124: #ifdef C70
        !          1125:     return(inbufc + (ungotn >= 0) );
        !          1126: #else
        !          1127: #ifdef PROVX1
        !          1128:     x = ioctl(ttyfd, TIOCQCNT, &ttbuf);
        !          1129:     n = ttbuf.sg_ispeed & 0377;
        !          1130:     return((x < 0) ? 0 : n);
        !          1131: #else
        !          1132:     return(0);
        !          1133: #endif
        !          1134: #endif
        !          1135: #endif
        !          1136: #endif
        !          1137: #endif
        !          1138: }
        !          1139: 
        !          1140: 
        !          1141: /*  T T X I N  --  Get n characters from tty input buffer  */
        !          1142: 
        !          1143: /*  Returns number of characters actually gotten, or -1 on failure  */
        !          1144: 
        !          1145: /*  Intended for use only when it is known that n characters are actually */
        !          1146: /*  Available in the input buffer.  */
        !          1147: 
        !          1148: ttxin(n,buf) int n; char *buf; {
        !          1149:     int x;
        !          1150:     CHAR c;
        !          1151: 
        !          1152: #ifdef MYREAD
        !          1153:     for( x = 0; (x > -1) && (x < n); buf[x++] = myread() );
        !          1154: #else
        !          1155:     debug(F101,"ttxin: n","",n);
        !          1156:     x = read(ttyfd,buf,n);
        !          1157:     debug(F101," x","",x);
        !          1158: #endif
        !          1159:     if (x > 0) buf[x] = '\0';
        !          1160:     if (x < 0) x = -1;
        !          1161:     return(x);
        !          1162: }
        !          1163: 
        !          1164: /*  T T O L  --  Similar to "ttinl", but for writing.  */
        !          1165: 
        !          1166: ttol(s,n) int n; char *s; {
        !          1167:     int x;
        !          1168:     if (ttyfd < 0) return(-1);         /* Not open. */
        !          1169:     x = write(ttyfd,s,n);
        !          1170:     debug(F111,"ttol",s,n);
        !          1171:     if (x < 0) debug(F101,"ttol failed","",x);
        !          1172:     return(x);
        !          1173: }
        !          1174: 
        !          1175: 
        !          1176: /*  T T O C  --  Output a character to the communication line  */
        !          1177: 
        !          1178: ttoc(c) char c; {
        !          1179:     if (ttyfd < 0) return(-1);         /* Not open. */
        !          1180:     return(write(ttyfd,&c,1));
        !          1181: }
        !          1182: 
        !          1183: /*  T T I N L  --  Read a record (up to break character) from comm line.  */
        !          1184: /*
        !          1185:   If no break character encountered within "max", return "max" characters,
        !          1186:   with disposition of any remaining characters undefined.  Otherwise, return
        !          1187:   the characters that were read, including the break character, in "dest" and
        !          1188:   the number of characters read as the value of function, or 0 upon end of
        !          1189:   file, or -1 if an error occurred.  Times out & returns error if not completed
        !          1190:   within "timo" seconds.
        !          1191: */
        !          1192: 
        !          1193: ttinl(dest,max,timo,eol) int max,timo; char *dest; char eol; {
        !          1194:     int x, y;
        !          1195:     CHAR c;
        !          1196: 
        !          1197:     if (ttyfd < 0) return(-1);         /* Not open. */
        !          1198:     if (timo <= 0) {                   /* Untimed read... */
        !          1199: 
        !          1200: #ifdef MYREAD
        !          1201:        for (x = y = 0; (x < max) && (c != eol); x++) {
        !          1202:             while ((y = myread()) == -1) ;
        !          1203:             if (y == -2) return(-1);
        !          1204:             dest[x] = y & 0377;
        !          1205:        }
        !          1206: #else
        !          1207:        x = read(ttyfd,dest,max);       /* Try to read. */
        !          1208: #endif
        !          1209:        return(x);                      /* Return the count. */
        !          1210:     }
        !          1211: 
        !          1212: /* Timed read... */
        !          1213: 
        !          1214:     signal(SIGALRM,timerh);            /* Set up timeout action. */
        !          1215:     alarm(timo);                       /* Set the timer. */
        !          1216:     if (setjmp(sjbuf))                 /* Do this if timer went off. */
        !          1217:        x = -1;
        !          1218:     else if (kerld) {                  /* Efficient Kermit line discipline */
        !          1219:        x = read(ttyfd,dest,max);       /* for 4.2bsd only... */
        !          1220:     } else {                           /* Normal case... */
        !          1221:        for (x = c = y = 0; (x < max) && (c != eol); x++) {
        !          1222: #ifdef MYREAD
        !          1223:            while ((y = myread()) == -1) /* Use own buffering if we can */
        !          1224:                ;
        !          1225:            if (y == -2) y++;
        !          1226:            c = y & 0377;
        !          1227: #else
        !          1228:            while ((y = read(ttyfd,&c,1)) == 0) /* Else call system */
        !          1229:                ;                       /* ...for each character. */
        !          1230: #endif
        !          1231:            if (y < 0) {
        !          1232:                alarm(0);               /* Error, turn off timer, */
        !          1233:                signal(SIGALRM,SIG_DFL); /* and associated interrupt. */
        !          1234:                return(y);              /* Return the error indication. */
        !          1235:            }
        !          1236:            dest[x] = c;
        !          1237:        }
        !          1238:        x++;
        !          1239:     }
        !          1240:     alarm(0);                          /* Success, turn off timer, */
        !          1241:     signal(SIGALRM,SIG_DFL);           /* and associated interrupt. */
        !          1242:     return(x);                         /* Return the count. */
        !          1243: }
        !          1244: 
        !          1245: /*  T T I N C --  Read a character from the communication line  */
        !          1246: 
        !          1247: ttinc(timo) int timo; {
        !          1248:     int n = 0;
        !          1249:     CHAR ch = 0;
        !          1250: 
        !          1251:     if (ttyfd < 0) return(-1);         /* Not open. */
        !          1252:     if (timo <= 0) {                   /* Untimed. */
        !          1253: #ifdef MYREAD
        !          1254:        /* comm line failure returns -1 thru myread, so no &= 0377 */
        !          1255:        while ((n = myread()) == -1) ;  /* Wait for a character... */
        !          1256:        if (n == -2) n++;
        !          1257:        return( n );
        !          1258: #else
        !          1259:        while ((n = read(ttyfd,&ch,1)) == 0) ; /* Wait for a character. */
        !          1260:        return( (n > 0) ? (ch & 0377) : n );
        !          1261: #endif
        !          1262:     }
        !          1263: 
        !          1264:     signal(SIGALRM,timerh);            /* Timed, set up timer. */
        !          1265:     alarm(timo);
        !          1266:     if (setjmp(sjbuf)) {
        !          1267:        n = -1;
        !          1268:     } else {
        !          1269: #ifdef MYREAD
        !          1270:        while ((n = myread()) == -1) ;  /* If managing own buffer... */
        !          1271:        if (n == -2) {
        !          1272:            n++;
        !          1273:        } else {
        !          1274:            ch = n;
        !          1275:            n = 1;      
        !          1276:        }
        !          1277: #else
        !          1278:        n = read(ttyfd,&ch,1);          /* Otherwise call the system. */
        !          1279: #endif
        !          1280:     }
        !          1281:     alarm(0);                          /* Turn off timer, */
        !          1282:     signal(SIGALRM,SIG_DFL);           /* and interrupt. */
        !          1283:     return( (n > 0) ? (ch & 0377) : n ); /* Return char or -1. */
        !          1284: }
        !          1285: 
        !          1286: /*  T T S N D B  --  Send a BREAK signal  */
        !          1287: 
        !          1288: ttsndb() {
        !          1289:     int x; long n; char spd;
        !          1290: 
        !          1291:     if (ttyfd < 0) return(-1);         /* Not open. */
        !          1292: 
        !          1293: #ifdef PROVX1
        !          1294:     gtty(ttyfd,&ttbuf);                        /* Get current tty flags */
        !          1295:     spd = ttbuf.sg_ospeed;             /* Save speed */
        !          1296:     ttbuf.sg_ospeed = B50;             /* Change to 50 baud */
        !          1297:     stty(ttyfd,&ttbuf);                        /*  ... */
        !          1298:     write(ttyfd,brnuls,3);             /* Send 3 nulls */
        !          1299:     ttbuf.sg_ospeed = spd;             /* Restore speed */
        !          1300:     stty(ttyfd,&ttbuf);                        /*  ... */
        !          1301:     return(0);
        !          1302: #else
        !          1303: #ifdef UXIII
        !          1304:     if (ioctl(ttyfd,TCSBRK,(char *)0) < 0) {   /* Send a BREAK */
        !          1305:        perror("Can't send BREAK");
        !          1306:        return(-1);
        !          1307:     }
        !          1308:     return(0);
        !          1309: #else
        !          1310: #ifdef ANYBSD
        !          1311:     n = FWRITE;                                /* Flush output queue. */
        !          1312:     ioctl(ttyfd,TIOCFLUSH,&n);                 /* Ignore any errors.. */
        !          1313:     if (ioctl(ttyfd,TIOCSBRK,(char *)0) < 0) { /* Turn on BREAK */
        !          1314:        perror("Can't send BREAK");
        !          1315:        return(-1);
        !          1316:     }
        !          1317:     x = msleep(275);                   /* Sleep for so many milliseconds */
        !          1318:     if (ioctl(ttyfd,TIOCCBRK,(char *)0) < 0) { /* Turn off BREAK */
        !          1319:        perror("BREAK stuck!!!");
        !          1320:        doexit(1);                      /* Get out, closing the line. */
        !          1321:                                        /*   with exit status = 1 */
        !          1322:     }
        !          1323:     return(x);
        !          1324: #else
        !          1325: #ifdef V7
        !          1326:     genbrk(ttyfd);                     /* Simulate a BREAK */
        !          1327:     return(x);
        !          1328: #endif
        !          1329: #endif
        !          1330: #endif
        !          1331: #endif
        !          1332: }
        !          1333: 
        !          1334: /*  M S L E E P  --  Millisecond version of sleep().  */
        !          1335: 
        !          1336: /*
        !          1337:  Intended only for small intervals.  For big ones, just use sleep().
        !          1338: */
        !          1339: 
        !          1340: msleep(m) int m; {
        !          1341: 
        !          1342: #ifdef PROVX1
        !          1343:     sleep(-((m * 60 + 500) / 1000));
        !          1344:     return(0);
        !          1345: #endif
        !          1346: 
        !          1347: #ifdef ANYBSD
        !          1348:     int t1, t3, t4;
        !          1349: #ifdef BSD41
        !          1350:     if (ftime(&ftp) < 0) return(-1);   /* Get current time. */
        !          1351:     t1 = ((ftp.time & 0xff) * 1000) + ftp.millitm;
        !          1352:     while (1) {
        !          1353:        ftime(&ftp);                    /* new time */
        !          1354:        t3 = (((ftp.time & 0xff) * 1000) + ftp.millitm) - t1;
        !          1355:        if (t3 > m) return (t3);
        !          1356:     }
        !          1357: #else
        !          1358: /* 2.9 and 4.1 BSD do it this way */
        !          1359:     if (gettimeofday(&tv, &tz) < 0) return(-1); /* Get current time. */
        !          1360:     t1 = tv.tv_sec;                    /* Seconds */
        !          1361: 
        !          1362:     tv.tv_sec = 0;                     /* Use select() */
        !          1363:     tv.tv_usec = m * 1000;
        !          1364:     return(select( 0, (int *)0, (int *)0, (int *)0, &tv) );
        !          1365: #endif
        !          1366: #endif
        !          1367: 
        !          1368: #ifdef UXIII
        !          1369: #ifdef XENIX
        !          1370: #define CLOCK_TICK 50                  /* millisecs per clock tick */
        !          1371: #else
        !          1372: #define CLOCK_TICK 17                  /* 1/60 sec */
        !          1373: #endif
        !          1374:     extern long times();
        !          1375:     long t1, t2, tarray[4];
        !          1376:     int t3;
        !          1377: 
        !          1378:     if ((t1 = times(tarray)) < 0) return(-1);
        !          1379:     while (1) {
        !          1380:        if ((t2 = times(tarray)) < 0) return(-1);
        !          1381:        t3 = ((int)(t2 - t1)) * CLOCK_TICK;
        !          1382:        if (t3 > m) return(t3);
        !          1383:     }
        !          1384: #endif
        !          1385: 
        !          1386: #ifdef TOWER1
        !          1387:     int t1, t3;
        !          1388:     if (ftime(&ftp) < 0) return(-1);           /* Get current time. */
        !          1389:     t1 = ((ftp.time & 0xff) * 1000) + ftp.millitm;
        !          1390:     while (1) {
        !          1391:        ftime(&ftp);                            /* new time */
        !          1392:        t3 = (((ftp.time & 0xff) * 1000) + ftp.millitm) - t1;
        !          1393:        if (t3 > m) return (t3);
        !          1394:     }
        !          1395: #endif
        !          1396: }
        !          1397: 
        !          1398: /*  R T I M E R --  Reset elapsed time counter  */
        !          1399: 
        !          1400: rtimer() {
        !          1401:     tcount = time( (long *) 0 );
        !          1402: }
        !          1403: 
        !          1404: 
        !          1405: /*  G T I M E R --  Get current value of elapsed time counter in seconds  */
        !          1406: 
        !          1407: gtimer() {
        !          1408:     int x;
        !          1409:     x = (int) (time( (long *) 0 ) - tcount);
        !          1410:     rtimer();
        !          1411:     return( (x < 0) ? 0 : x );
        !          1412: }
        !          1413: 
        !          1414: 
        !          1415: /*  Z T I M E  --  Return date/time string  */
        !          1416: 
        !          1417: ztime(s) char **s; {
        !          1418: 
        !          1419: #ifdef UXIII
        !          1420:     extern long time();                        /* Sys III/V way to do it */
        !          1421:     char *ctime();
        !          1422:     long clock_storage;
        !          1423: 
        !          1424:     clock_storage = time( (long *) 0 );
        !          1425:     *s = ctime( &clock_storage );
        !          1426: #endif
        !          1427: 
        !          1428: #ifdef PROVX1
        !          1429:     int utime[2];                      /* Venix way */
        !          1430:     time(utime);
        !          1431:     *s = ctime(utime);
        !          1432: #endif
        !          1433: 
        !          1434: #ifdef ANYBSD
        !          1435:     char *asctime();                   /* Berkeley way */
        !          1436:     struct tm *localtime();
        !          1437:     struct tm *tp;
        !          1438: #ifndef BSD41
        !          1439:     gettimeofday(&tv, &tz);            /* BSD 2.9, 4.2 ... */
        !          1440:     time(&tv.tv_sec);
        !          1441:     tp = localtime(&tv.tv_sec);
        !          1442: #else
        !          1443:     time(&clock);                      /* BSD 4.1 ... ceb */
        !          1444:     tp = localtime(&clock);
        !          1445: #endif
        !          1446:     *s = asctime(tp);
        !          1447: #endif
        !          1448: 
        !          1449: #ifdef TOWER1
        !          1450:     char *asctime();                   /* Tower way */
        !          1451:     struct tm *localtime();
        !          1452:     struct tm *tp;
        !          1453: 
        !          1454:     time(&clock);
        !          1455:     tp = localtime(&clock);
        !          1456:     *s = asctime(tp);
        !          1457: #endif
        !          1458: #ifdef V7
        !          1459:     char *asctime();                   /* V7 way */
        !          1460:     struct tm *localtime();
        !          1461:     struct tm *tp;
        !          1462: 
        !          1463:     time(&clock);
        !          1464:     tp = localtime(&clock);
        !          1465:     *s = asctime(tp);
        !          1466: #endif
        !          1467: }
        !          1468: 
        !          1469: /*  C O N G M  --  Get console terminal modes.  */
        !          1470: 
        !          1471: /*
        !          1472:  Saves current console mode, and establishes variables for switching between 
        !          1473:  current (presumably normal) mode and other modes.
        !          1474: */
        !          1475: 
        !          1476: congm() {
        !          1477: #ifndef UXIII
        !          1478:      gtty(0,&ccold);                   /* Structure for restoring */
        !          1479:      gtty(0,&cccbrk);                  /* For setting CBREAK mode */
        !          1480:      gtty(0,&ccraw);                   /* For setting RAW mode */
        !          1481: #else
        !          1482:      ioctl(0,TCGETA,&ccold);
        !          1483:      ioctl(0,TCGETA,&cccbrk);
        !          1484:      ioctl(0,TCGETA,&ccraw);
        !          1485: #endif
        !          1486:      cgmf = 1;                         /* Flag that we got them. */
        !          1487: }
        !          1488: 
        !          1489: 
        !          1490: /*  C O N C B --  Put console in cbreak mode.  */
        !          1491: 
        !          1492: /*  Returns 0 if ok, -1 if not  */
        !          1493: 
        !          1494: concb(esc) char esc; {
        !          1495:     int x;
        !          1496:     if (cgmf == 0) congm();            /* Get modes if necessary. */
        !          1497:     escchr = esc;                      /* Make this available to other fns */
        !          1498:     ckxech = 1;                                /* Program can echo characters */
        !          1499: #ifndef UXIII
        !          1500:     cccbrk.sg_flags |= CBREAK;         /* Set to character wakeup, */
        !          1501:     cccbrk.sg_flags &= ~ECHO;          /* no echo. */
        !          1502:     x = stty(0,&cccbrk);
        !          1503: #else
        !          1504:     cccbrk.c_lflag &= ~(ICANON|ECHO);
        !          1505:     cccbrk.c_cc[0] = 003;              /* interrupt char is control-c */
        !          1506:     cccbrk.c_cc[1] = escchr;           /* escape during packet modes */
        !          1507:     cccbrk.c_cc[4] = 1;
        !          1508:     cccbrk.c_cc[5] = 1;
        !          1509:     x = ioctl(0,TCSETAW,&cccbrk);      /* set new modes . */
        !          1510: #endif
        !          1511:     if (x > -1) setbuf(stdout,NULL);   /* Make console unbuffered. */
        !          1512: #ifdef V7
        !          1513:     if (kmem[CON] < 0) {
        !          1514:        qaddr[CON] = initrawq(0);
        !          1515:        if((kmem[CON] = open("/dev/kmem", 0)) < 0) {
        !          1516:            fprintf(stderr, "Can't read /dev/kmem in concb.\n");
        !          1517:            perror("/dev/kmem");
        !          1518:            exit(1);
        !          1519:        }
        !          1520:     }
        !          1521: #endif V7
        !          1522:     return(x);
        !          1523: }
        !          1524: 
        !          1525: /*  C O N B I N  --  Put console in binary mode  */
        !          1526: 
        !          1527: /*  Returns 0 if ok, -1 if not  */
        !          1528: 
        !          1529: conbin(esc) char esc; {
        !          1530:     if (cgmf == 0) congm();            /* Get modes if necessary. */
        !          1531:     escchr = esc;                      /* Make this available to other fns */
        !          1532:     ckxech = 1;                                /* Program can echo characters */
        !          1533: #ifndef UXIII
        !          1534:     ccraw.sg_flags |= (RAW|TANDEM);    /* Set rawmode, XON/XOFF */
        !          1535:     ccraw.sg_flags &= ~(ECHO|CRMOD);   /* Set char wakeup, no echo */
        !          1536:     return(stty(0,&ccraw));
        !          1537: #else
        !          1538:     ccraw.c_lflag &= ~(ISIG|ICANON|ECHO);
        !          1539:     ccraw.c_iflag |= (BRKINT|IGNPAR);
        !          1540:     ccraw.c_iflag &= ~(IGNBRK|INLCR|IGNCR|ICRNL|IUCLC|IXON|IXANY|IXOFF
        !          1541:                        |INPCK|ISTRIP);
        !          1542:     ccraw.c_oflag &= ~OPOST;
        !          1543: 
        !          1544: /*** Kermit used to put the console in 8-bit raw mode, but some users have
        !          1545:  *** pointed out that this should not be done, since some sites actually
        !          1546:  *** use terminals with parity settings on their Unix systems, and if we
        !          1547:  *** override the current settings and stop doing parity, then their terminals
        !          1548:  *** will display blotches for characters whose parity is wrong.  Therefore,
        !          1549:  *** the following two lines are commented out (Larry Afrin, Clemson U):
        !          1550:  ***
        !          1551:  ***   ccraw.c_cflag &= ~(PARENB|CSIZE);
        !          1552:  ***   ccraw.c_cflag |= (CS8|CREAD);
        !          1553:  ***
        !          1554:  *** Sys III/V sites that have trouble with this can restore these lines.
        !          1555:  ***/
        !          1556:     ccraw.c_cc[4] = 1;
        !          1557:     ccraw.c_cc[5] = 1;
        !          1558:     return(ioctl(0,TCSETAW,&ccraw) );          /* set new modes . */
        !          1559: #endif
        !          1560: }
        !          1561: 
        !          1562: 
        !          1563: /*  C O N R E S  --  Restore the console terminal  */
        !          1564: 
        !          1565: conres() {
        !          1566:     if (cgmf == 0) return(0);          /* Don't do anything if modes */
        !          1567: #ifndef UXIII                          /* except for sIII, */
        !          1568:     sleep(1);                          /*  not known! */
        !          1569: #endif                                 /*   (sIII does wait in ioctls) */
        !          1570:     ckxech = 0;                                /* System should echo chars */
        !          1571: #ifndef UXIII
        !          1572:     return(stty(0,&ccold));            /* Restore controlling tty */
        !          1573: #else
        !          1574:     return(ioctl(0,TCSETAW,&ccold));
        !          1575: #endif
        !          1576: }
        !          1577: 
        !          1578: /*  C O N O C  --  Output a character to the console terminal  */
        !          1579: 
        !          1580: conoc(c) char c; {
        !          1581:     write(1,&c,1);
        !          1582: }
        !          1583: 
        !          1584: /*  C O N X O  --  Write x characters to the console terminal  */
        !          1585: 
        !          1586: conxo(x,s) char *s; int x; {
        !          1587:     write(1,s,x);
        !          1588: }
        !          1589: 
        !          1590: /*  C O N O L  --  Write a line to the console terminal  */
        !          1591: 
        !          1592: conol(s) char *s; {
        !          1593:     int len;
        !          1594:     len = strlen(s);
        !          1595:     write(1,s,len);
        !          1596: }
        !          1597: 
        !          1598: /*  C O N O L A  --  Write an array of lines to the console terminal */
        !          1599: 
        !          1600: conola(s) char *s[]; {
        !          1601:     int i;
        !          1602:     for (i=0 ; *s[i] ; i++) conol(s[i]);
        !          1603: }
        !          1604: 
        !          1605: /*  C O N O L L  --  Output a string followed by CRLF  */
        !          1606: 
        !          1607: conoll(s) char *s; {
        !          1608:     conol(s);
        !          1609:     write(1,"\r\n",2);
        !          1610: }
        !          1611: 
        !          1612: /*  C O N C H K  --  Return how many characters available at console  */
        !          1613: 
        !          1614: conchk() {
        !          1615:     int x; long n;
        !          1616: 
        !          1617: #ifdef PROVX1 
        !          1618:     x = ioctl(0, TIOCQCNT, &ttbuf);
        !          1619:     n = ttbuf.sg_ispeed & 0377;
        !          1620:     return((x < 0) ? 0 : n);
        !          1621: #else
        !          1622: #ifdef V7
        !          1623:     lseek(kmem[CON], (long) qaddr[CON], 0);
        !          1624:     x = read(kmem[CON], &n, sizeof(int));
        !          1625:     return((x == sizeof(int))? n: 0);
        !          1626: #else
        !          1627: #ifdef UXIII
        !          1628:     if (conesc) {                      /* Escape typed */
        !          1629:        conesc = 0;
        !          1630:        signal(SIGQUIT,esctrp);         /* Restore escape */
        !          1631:        return(1);
        !          1632:     }
        !          1633:     return(0);
        !          1634: #else
        !          1635: #ifdef C70
        !          1636:     if (conesc) {                      /* Escape typed */
        !          1637:        conesc = 0;
        !          1638:        signal(SIGQUIT,esctrp);         /* Restore escape */
        !          1639:        return(1);
        !          1640:     }
        !          1641:     return(0);
        !          1642: #else
        !          1643: #ifdef FIONREAD
        !          1644:     x = ioctl(0, FIONREAD, &n);                /* BSD and maybe some others */
        !          1645:     return((x < 0) ? 0 : n);
        !          1646: #else
        !          1647:     return(0);                         /* Others can't do. */
        !          1648: #endif
        !          1649: #endif
        !          1650: #endif
        !          1651: #endif
        !          1652: #endif
        !          1653: }
        !          1654: 
        !          1655: /*  C O N I N C  --  Get a character from the console  */
        !          1656: 
        !          1657: coninc(timo) int timo; {
        !          1658:     int n = 0; char ch;
        !          1659:     if (timo <= 0 ) {                  /* untimed */
        !          1660:        n = read(0, &ch, 1);            /* Read a character. */
        !          1661:        ch &= 0377;
        !          1662:        if (n > 0) return(ch);          /* Return the char if read */
        !          1663:        else 
        !          1664: #ifdef UXIII
        !          1665:            if (n < 0 && errno == EINTR) /* if read was interrupted by QUIT */
        !          1666:                return(escchr);          /* user entered escape character */
        !          1667:            else                    /* couldnt be ^c, sigint never returns */
        !          1668: #endif
        !          1669:                return(-1);             /* Return the char, or -1. */
        !          1670:        }
        !          1671:     signal(SIGALRM,timerh);            /* Timed read, so set up timer */
        !          1672:     alarm(timo);
        !          1673:     if (setjmp(sjbuf)) n = -2;
        !          1674:     else {
        !          1675:        n = read(0, &ch, 1);
        !          1676:        ch &= 0377;
        !          1677:     }
        !          1678:     alarm(0);                          /* Stop timing, we got our character */
        !          1679:     signal(SIGALRM,SIG_DFL);
        !          1680:     if (n > 0) return(ch);  
        !          1681:     else
        !          1682: #ifdef UXIII
        !          1683:         if (n == -1 && errno == EINTR)  /* If read interrupted by QUIT, */
        !          1684:            return(escchr);             /* user entered escape character, */
        !          1685:         else                           /* can't be ^c, sigint never returns */
        !          1686: #endif
        !          1687:        return(-1);
        !          1688: }

This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.