home *** CD-ROM | disk | FTP | other *** search
/ Columbia Kermit / kermit.zip / c-kermit / ckdtio.c < prev    next >
C/C++ Source or Header  |  2020-01-01  |  97KB  |  2,888 lines
  1. char *ckxv = "Data General tty I/O, 7.1.106, 22 Jul 2000";
  2.  
  3. /*  C K D T I O  */
  4.  
  5. /* C-Kermit interrupt, terminal control & i/o functions for DG AOS/VS */
  6.  
  7. /*
  8.   Author: Frank da Cruz <fdc@columbia.edu>
  9.   Columbia University Academic Information Systems, New York City.
  10.  
  11.   Copyright (C) 1985, 2000,
  12.     Trustees of Columbia University in the City of New York.
  13.     All rights reserved.  See the C-Kermit COPYING.TXT file or the 
  14.     copyright text in the ckcmai.c module for disclaimer and permissions.
  15.  
  16.   This module originally adapted to AOS/VS by:
  17.   Phil Julian, SAS Institute, Inc., Box 8000, Cary, NC 27512-8000, circa 1985.
  18.   Adapted to C-Kermit 5A by Eugenia Harris of Data General, 1992.
  19.   Upgraded to C-Kermit 6.0 by Frank da Cruz, 1996; 7.0 (1998); 7.1 (2000).
  20. */
  21. #define MAXINBUF 2048                  /* See ckdcon.c for same definition. */
  22. #nolist
  23. #include <memory.h>
  24. #include <string.h>
  25. #include <dglib.h>
  26. #include <bit.h>
  27. #include <sysid.h>
  28. #include <sys_calls.h>
  29. #include <packets/normal_io.h>
  30. #include <multitask.h>                                  
  31. #include <paru.h>
  32. #include <stdio.h>
  33. #include <packets:common.h>
  34. #include <packets:characteristics.h>
  35. #list
  36. #define CONINT_TSK 20                   /* Task id of interrupt-checker */
  37. #define CONINT_PRI 0                    /* Same as calling task */ 
  38. #define CONINT_STACK 02000
  39. int con_reads_mt = 0;                   /* Flag if task is active */
  40. int conint_ch;                          /* MT character read */
  41. int conint_avl;                         /* Flag that char available */
  42. int termtype;
  43. /* Delimiter table -- defaults to CR only */
  44. short idel_tbl[7] = {0x4,0,0,0,0,0,0};
  45. #include <stdio.h>                      /* Unix Standard i/o */
  46.  
  47. #ifndef DEVNAMLEN
  48. #define DEVNAMLEN (L_ctermid + 6)
  49. #endif 
  50.  
  51. #ifdef  NETCONN
  52. #undef DEVNAMLEN
  53. #define DEVNAMLEN 50                    /* longer field for host:service */
  54. #endif  /* NETCONN */
  55.  
  56. #include <sys/dir.h>                    /* Directory */
  57. #include <ctype.h>                      /* Character types */
  58.  
  59. /* Maximum length for the name of a tty device */
  60. #ifndef DEVNAMLEN
  61. #define DEVNAMLEN 25
  62. #endif
  63.  
  64. #include <stdio.h>                      /* Unix Standard i/o */
  65. #include <signal.h>                     /* Interrupts */
  66. #include <setjmp.h>                     /* Longjumps */
  67. #include "ckcdeb.h"                     /* Typedefs, formats for debug() */
  68. #include "ckcnet.h"
  69. #include <sys/stat.h>
  70.  
  71. char *ckxsys = " Data General AOS/VS";
  72.  
  73. /* Features... */
  74.  
  75. #define MYREAD
  76.  
  77. /*
  78.  Variables available to outside world:
  79.  
  80.    dftty  -- Pointer to default tty name string, like "/dev/tty".
  81.    dfloc  -- 0 if dftty is console, 1 if external line.
  82.    dfprty -- Default parity
  83.    dfflow -- Default flow control
  84.    ckxech -- Flag for who echoes console typein:
  85.      1 - The program (system echo is turned off)
  86.      0 - The system (or front end, or terminal).
  87.    functions that want to do their own echoing should check this flag
  88.    before doing so.
  89.  
  90.    flfnam -- Name of lock file, including its path, e.g.,
  91.                 "/usr/spool/uucp/LCK..cul0" or "/etc/locks/tty77"
  92.    haslock -- Flag set if this kermit established a uucp lock.
  93.    inbufc -- number of tty line rawmode unread characters 
  94.                 (system III/V unixes)
  95.    backgrd -- Flag indicating program executing in background ( & on 
  96.                 end of shell command). Used to ignore INT and QUIT signals.
  97.  
  98. /* Declarations of variables global within this module */
  99.  
  100. /* Declarations of variables global within this module */
  101.  
  102. #ifdef TTLEBUF                /* See ckcnet.h */
  103. int ttpush = -1;
  104. #define LEBUFSIZ 4096
  105. static CHAR le_buf[LEBUFSIZ];
  106. static int le_start = 0, le_end = 0, le_data = 0;
  107. #endif /* TTLEBUF */
  108.  
  109. static time_t tcount;                   /* Elapsed time counter */
  110. SIGTYP (*saval)() = NULL;               /* For saving alarm handler */
  111.  
  112. /* The following lists of functions are somewhat out of date.  For a
  113.    better listing, see ckutio.c
  114.  
  115. Functions for assigned communication line (either external or console tty):
  116.  
  117.    sysinit()               -- System dependent program initialization
  118.    ttopen(ttname,local,mdmtyp) -- Open the named tty for exclusive access.
  119.    ttclos()                -- Close & reset the tty, releasing any access lock.
  120.    ttpkt(speed,flow,parity)-- Put the tty in packet mode and set the speed.
  121.    ttvt(speed,flow)        -- Put the tty in virtual terminal mode.
  122.                               or in DIALING or CONNECTED modem control state.
  123.    ttinl(dest,max,timo,eol,start) -- Timed read line from the tty.
  124.    ttinc(timo)             -- Timed read character from tty.
  125.    myread()                -- System 3 raw mode bulk buffer read, gives
  126.                            -- subsequent chars one at a time and simulates
  127.                            -- FIONREAD!
  128.    ttchk()                 -- See how many characters in tty input buffer.
  129.    ttxin(n,buf)            -- Read n characters from tty (untimed).
  130.    ttol(string,length)     -- Write a string to the tty.
  131.    ttoc(c)                 -- Write a character to the tty.
  132.    ttflui()                -- Flush tty input buffer.
  133.    ttfluo()                -- Flush tty output buffer.  (not used)
  134.    ttgmdm()                -- Returns status of modem signals (not used)
  135.    ttgspd()                -- Returns speed of tty line
  136.    ttsspd(cps)             -- Set line speed on tty line
  137.    ttimoff()               -- Turns off all pending timer interrupts
  138.    ttscarr(carrier)        -- Copies argument to global variable
  139.    ttwmdm(mdmsig,timo)     -- Wait for specified signal (not used)
  140.    ttlock(ttname)          -- Lock against uucp collisions (not used)
  141.    ttunlck()               -- Unlock "       "     "       (not used)
  142.    look4lk(ttname)         -- Check if a lock file exists  (not used)
  143.  
  144. Functions for console terminal:
  145.  
  146.    congm()   -- Get console terminal modes.
  147.    concb(esc) -- Put the console in single-character wakeup mode with no echo.
  148.    conbin(esc) -- Put the console in binary (raw) mode.
  149.    conres()  -- Restore the console to mode obtained by congm().
  150.    conoc(c)  -- Unbuffered output, one character to console.
  151.    conol(s)  -- Unbuffered output, null-terminated string to the console.
  152.    conola(s) -- Unbuffered output, array of strings to the console.
  153.    conxo(n,s) -- Unbuffered output, n characters to the console.
  154.    conchk()  -- Check if characters available at console (bsd 4.2).
  155.  
  156.                 Check if escape char (^\) typed at console (System III/V).
  157.    coninc(timo)  -- Timed get a character from the console.
  158.    conint()  -- Enable terminal interrupts on the console if not background.
  159.    connoi()  -- Disable terminal interrupts on the console if not background.
  160.    congks(timo) -- Get keyboard scan code (not used)
  161.  
  162. Time functions:
  163.  
  164.    msleep(m) -- Millisecond sleep
  165.    ztime(&s) -- Return pointer to date/time string
  166.    rtimer() --  Reset timer
  167.    gtimer()  -- Get elapsed time since last call to rtimer()
  168. */
  169.  
  170. #ifdef UXIII
  171. #ifdef datageneral
  172. /* Console and terminal characteristics vectors */
  173. short *charcurr;
  174. short charconin[$CLMAX];    /* Console input; channel 0 */
  175. short charconout[$CLMAX];   /* Console output; channel 1 */
  176. short chartty[$CLMAX];      /* generic tty channel */
  177. short charttyin[$CLMAX];    /* tty input; channel ttyfd */
  178. short charttyout[$CLMAX];   /* tty output; channel ttyfdout */
  179. short ch_ttold[$CLMAX];
  180. short ch_ttraw[$CLMAX];
  181. short ch_ttvt[$CLMAX]; 
  182. short ch_ccold[$CLMAX];
  183. short ch_ccraw[$CLMAX];
  184. short ch_ccbrk[$CLMAX]; 
  185. #undef ECHO
  186. #include <sys/termio.h>
  187. /* Add synonyms for Unix type ioctl */
  188. #define TCSETAF TCSETA
  189. #define TCSETAW TCSETA
  190. #else
  191. #include <termio.h>
  192. #include <sys/ioctl.h>
  193. #endif datageneral
  194.  
  195. #include <fcntl.h>                      /* directory reading for locking */
  196. #include <errno.h>                      /* error numbers for system returns */
  197. #endif /* UXIII */
  198.  
  199. /* Declarations */
  200.  
  201. long time();                            /* All Unixes should have this... */
  202. extern int errno;                       /* System call error return */
  203. extern int ttnproto;
  204. extern int ttnet;
  205. extern int xfrcan, xfrchr, xfrnum;    /* Transfer cancellation */
  206.  
  207. /* dftty is the device name of the default device for file transfer */
  208. /* dfloc is 0 if dftty is the user's console terminal, 1 if an external line */
  209.  
  210. char *dftty = CTTNAM;                   /* Remote by default, use normal */
  211. int dfloc = 0;                          /* controlling terminal name. */
  212. int dfprty = 0;                         /* Parity (0 = none) */
  213. int dfflow = 1;                         /* Xon/Xoff flow control */
  214. int backgrd = 0;                        /* Assume in foreground. */
  215. int ckxech = 0; /* 0 if system normally echoes console characters, else 1 */
  216.  
  217. /* Declarations of variables global within this module */
  218.  
  219. static long tcount;                     /* Elapsed time counter */
  220. static char *brnuls = "\0\0\0\0\0\0\0"; /* A string of nulls */
  221. static jmp_buf sjbuf, jjbuf;            /* Longjump buffer */
  222.  
  223. static int lkf = 0,                     /* Line lock flag */
  224.     conif = 0,                          /* Console interrupts on/off flag */
  225.     cgmf = 0,                           /* Flag that console modes saved */
  226.     xlocal = 0;                         /* Flag for tty local or remote */
  227.     curcarr = 0;                        /* Carrier mode: require/ignore. */
  228. int ttyfd = -1;                         /* TTY file descriptor */
  229. int tvtflg = 0;
  230. long ttspeed = -1;                      /* For saving speed */
  231. int ttflow = -9;                        /* For saving flow */
  232. int ttld = -1;                          /* Line discipline */
  233. int ttfdflg = 0;
  234. int ttpmsk = 0377;
  235. int ttprty = 0;
  236. int ttpflg = 0;                         /* Parity not sensed yet */
  237. int ttmdm = 0;
  238. int ttcarr = CAR_AUT;                   /* Carrier handling mode. */
  239. int telnetfd = 0;
  240. static int netconn = 0;
  241. int fdflag = 0;
  242. static char escchr;                     /* Escape or attn character */
  243. static int kerld = 0;                   /* Not selected, no special l.d. */
  244. int x25fd = 0;
  245.  
  246. #ifdef UXIII
  247.   static struct termio                  /* sgtty info... */
  248.     ttold, ttraw, tttvt,                /* for communication line */
  249.     ccold, ccraw, cccbrk;               /* and for console */
  250. #else
  251.   static struct sgttyb                  /* sgtty info... */
  252.     ttold, ttraw, tttvt, ttbuf,         /* for communication line */
  253.     ccold, ccraw, cccbrk;               /* and for console */
  254. #endif
  255.  
  256. char flfnam[80];                        /* uucp lock file path name */
  257. int haslock = 0;                        /* =1 if this kermit locked uucp */
  258.  
  259. static int inbufc = 0;                  /* stuff for efficient SIII raw line */
  260. static int ungotn = -1;                 /* pushback to unread character */
  261. static int conesc = 0;                  /* set to 1 if esc char (^\) typed */
  262.  
  263. static int ttlock();                    /* definition of ttlock subprocedure */
  264. static int ttunlck();                   /* and unlock subprocedure */
  265. static char ttnmsv[DEVNAMLEN];          /* copy of open path for tthang */
  266.  
  267. #ifdef datageneral
  268. FILE *ttfile,*ttfileout;                /* Files opened by ttopen */
  269.   
  270. struct p_nio_ex w_io_parms;             /* ?write system call structure */
  271. struct p_nio_ex r_io_parms;             /* ?read system call structure */
  272.  
  273. struct p_nio_ex io_parms;               /* open structure in ttopen */
  274. struct p_nio_ex x_io_parms;             /* ?read/?write structure for ttyfd */
  275. struct p_nio_ex xout_parms;             /* ?write structure for ttyfdout */
  276. struct p_screen x_io_scrn,
  277.        r_io_scrn,io_screen;             /* Edit-read structures */
  278.  
  279. int ttyfdout = -1;                      /* ?write Unix number for remote out */
  280. short timotty = 0;                      /* {Flag for timeouts (=1), value */
  281. short timocon = 0;                      /* tty is ttyfd..., con is Unix 0/1 */
  282. extern char *SPACMD;                    /* returns space in CURRENT dir */
  283. #endif
  284.  
  285. /* Timeout handler for communication line input functions */
  286.  
  287. SIGTYP
  288. timerh(foo) int foo; {                  /* we will try to use this */
  289.     ttimoff();
  290.     longjmp(sjbuf,1);
  291. }
  292.  
  293. /* Control-C trap for communication line input functions */
  294. /* These are not used in the VS implementation.  Instead, there is a task */
  295. /* called conint_mt that reads characters from the keyboard and sets a    */
  296. /* flag when it gets one.  It is then up to other routines (e.g., chkint()*/
  297. /* to determine what to do with the characters (and zero the flag)  --ENH */
  298.  
  299. int cc_int;                             /* Flag */
  300. SIGTYP (* occt)();                      /* For saving old SIGINT handler */
  301.  
  302. SIGTYP
  303. cctrap(foo) int foo; {                  /* Needs arg for ANSI C */
  304.   cc_int = 1;                           /* signal() prototype. */
  305.   return;
  306. }
  307.  
  308. #ifdef TTLEBUF
  309. VOID
  310. le_init() {                /* LocalEchoInit() */
  311.     int i;
  312.     for (i = 0; i < LEBUFSIZ; i++)
  313.       le_buf[i] = '\0';
  314.     le_start = 0;
  315.     le_end = 0;
  316.     le_data = 0;
  317. }
  318.  
  319. VOID
  320. le_clean() {                /* LocalEchoCleanup() */
  321.     le_init();
  322.     return;
  323. }
  324.  
  325. int
  326. le_inbuf() {
  327.     int rc = 0;
  328.     if (le_start != le_end) {
  329.     rc = (le_end -
  330.           le_start +
  331.           LEBUFSIZ) % LEBUFSIZ;
  332.     }  
  333.     debug(F111,"le_inbuf","chars waiting",rc);
  334.     return(rc);
  335. }
  336.  
  337. int
  338. #ifdef CK_ANSIC
  339. le_putchar(char ch)
  340. #else
  341. le_putchar(ch) char ch;
  342. #endif /* CK_ANSIC */
  343. /* le_putchar */ {
  344.     if ((le_start - le_end + LEBUFSIZ)%LEBUFSIZ == 1) {
  345.         debug(F110,"le_putchar","buffer is full",0);
  346.         return(-1);
  347.     }
  348.     le_buf[le_end++] = ch;
  349.     if (le_end == LEBUFSIZ)
  350.       le_end = 0;
  351.     le_data = 1;
  352.     return(0);
  353. }
  354.  
  355. int
  356. #ifdef CK_ANSIC
  357. le_puts(CHAR * s, int n)
  358. #else
  359. le_puts(s,n) CHAR * s; int n; 
  360. #endif /* CK_ANSIC */
  361. /* le_puts */ {
  362.     int rc = 0;
  363.     int i = 0;
  364.     CHAR * p = (CHAR *)"le_puts";
  365.     hexdump(p,s,n);
  366.     for (i = 0; i < n; i++) 
  367.       rc = le_putchar((char)s[i]);
  368.     debug(F101,"le_puts","",rc);
  369.     return(rc);
  370. }
  371.  
  372. int
  373. #ifdef CK_ANSIC
  374. le_putstr(CHAR * s)
  375. #else
  376. le_putstr(s) CHAR * s; 
  377. #endif /* CK_ANSIC */
  378. /* le_puts */ {
  379.     CHAR * p;
  380.     int rc = 0;
  381.     p = (CHAR *)"le_putstr";
  382.     hexdump(p,s,(int)strlen((char *)s));
  383.     for (p = s; *p && !rc; p++)
  384.       rc = le_putchar(*p);
  385.     return(rc);
  386. }
  387.  
  388. int 
  389. #ifdef CK_ANSIC
  390. le_getchar(CHAR * pch) 
  391. #else /* CK_ANSIC */
  392. le_getchar(pch) CHAR * pch; 
  393. #endif /* CK_ANSIC */
  394. /* le_getchar */ {
  395.     int rc = 0;
  396.     if (le_start != le_end) {
  397.         *pch = le_buf[le_start];
  398.         le_buf[le_start] = 0;
  399.         le_start++;
  400.  
  401.         if (le_start == LEBUFSIZ)
  402.           le_start = 0;
  403.  
  404.         if (le_start == le_end) {
  405.             le_data = 0;
  406.         }
  407.         rc++;
  408.     } else {
  409.         *pch = 0;
  410.     }
  411.     return(rc);
  412. }
  413. #endif /* TTLEBUF */
  414.  
  415.  
  416. /*  S Y S I N I T  --  System-dependent program initialization.  */
  417.  
  418. int
  419. sysinit() {
  420.     extern char uidbuf[];
  421.  
  422. #ifdef datageneral
  423.      /* Set up many things on the DG system, for initialization, etc. */
  424.      
  425.      short flags[3];
  426.      char *username;
  427.      int err;
  428.      
  429.      signal(SIGALRM,SIG_IGN);
  430.  
  431.      /* Get the terminal type, since DG terminals are different from others,
  432.         especially in the way BS is handled ('\b' is EM).
  433.         termtype = 0 means a regular DG style terminal, and 
  434.         termtype = 1 means an ANSI style terminal with ^H for backspace.
  435.         If Kermit is run in batch or has redirected input, then we do not
  436.         want to test or set the console characteristics.
  437.      */
  438.      termtype = 0;
  439.      if (isatty(0)) {
  440.         if (sys_gchr(channel(0),1<<31,&flags))
  441.              { perror("sysinit: sys_gchr: "); return(1); }
  442.  
  443.         /* Only determine whether or not it is a $TTY */
  444.         if ((flags[1] & $DTYPE) == $TTY) termtype = 1;
  445.      }
  446.  
  447.      zero((char *) &w_io_parms, sizeof(w_io_parms));
  448.      w_io_parms.ich  = channel(1);                   /* stdout */
  449.      w_io_parms.isti = $IBIN|$RTDS|$ICRF|$OFOT;
  450.      w_io_parms.isti &= ~$IPST;
  451.      w_io_parms.imrs = MAXINBUF-1;
  452.      w_io_parms.ibad = -1;
  453.      w_io_parms.ircl = -1;
  454.  
  455.      zero((char *) &r_io_parms, sizeof(r_io_parms));
  456.      r_io_parms.ich  = channel(0);                   /* stdin */
  457.      r_io_parms.isti = $IBIN|$RTFX|$ICRF|$OFIN;
  458.      r_io_parms.isti &= ~$IPST;
  459.      r_io_parms.imrs = MAXINBUF-1;
  460.      r_io_parms.ibad = -1;
  461.      r_io_parms.ircl = -1;
  462.  
  463.      zero((char *) &r_io_scrn, sizeof(r_io_scrn));
  464.      r_io_parms.etsp = 0;              /* Screen management extension */
  465.      r_io_scrn.esfc &= ~$ESNE;         /* Echo input data */
  466.      r_io_scrn.esfc &= ~$ESSE;         /* No screen edit */
  467.      r_io_scrn.esfc |= $ESGT;          /* Dump ring buffer */
  468.  
  469.      zero((char *) &x_io_parms, sizeof(x_io_parms));
  470.      /* $RTDY must be used instead of $RTDS since this causes failure on
  471.       * the Prime, which is probably getting data overruns on output or
  472.       * missing data.  Also, $RTDY is more efficient and faster.
  473.       */
  474.      x_io_parms.isti = $IBIN|$RTFX|$ICRF|$OFIO|$IPKL;
  475.      x_io_parms.isti &= ~$IPST;
  476.      x_io_parms.imrs = MAXINBUF-1;
  477.      x_io_parms.ibad = -1;
  478.      x_io_parms.ircl = -1;
  479.  
  480.      /* IDEL would default to NULL, FF, CR, NL as delimiters.
  481.       * The only delimiters here are CR and NL, for data sensitive 
  482.       * records.
  483.       */
  484.      idel_tbl[0] = 0x24;
  485.      x_io_parms.idel = idel_tbl;
  486.  
  487.      zero((char *) &x_io_scrn, sizeof(x_io_scrn));
  488.      x_io_parms.etsp = &x_io_scrn;     /* Screen management extension */
  489.      x_io_parms.etsp |= BIT0;          /* Turn on the high bit */
  490.      x_io_scrn.esfc &= ~$ESNE;         /* Echo input data */
  491.      x_io_scrn.esfc &= ~$ESSE;         /* No screen edit */
  492.      x_io_scrn.esfc |= $ESGT;          /* Dump ring buffer */
  493.  
  494.      memcpy((char *) &xout_parms,(char *) &x_io_parms,sizeof(x_io_parms));
  495.      xout_parms.isti = $IBIN|$RTDY|$ICRF|$OFOT;
  496.      xout_parms.etsp = 0;              /* Screen management extension */
  497.  
  498.      username = getenv("LOGNAME");
  499.      ckstrncpy(uidbuf,username,UIDBUFLEN);
  500.  
  501.      /* Zero the console characteristics arrays */
  502.      zero ((char *) charconin, sizeof(charconin));
  503.      zero ((char *) charconout, sizeof(charconout));
  504.      zero ((char *) chartty, sizeof(chartty));
  505.      zero ((char *) charttyin, sizeof(charttyin));
  506.      zero ((char *) charttyout, sizeof(charttyout));
  507.       
  508.      /* Initialize charconin & out, 
  509.       * and set up the console for CHAR/BREAK=BMOB 
  510.       */
  511.           if (sys_gechr( channel(0), (1<<31)|$CLMAX, charconin)) 
  512.                { perror("sysinit: gechr 0"); return(-1); }
  513.           if (sys_gechr( channel(1), (1<<31)|$CLMAX, charconout)) 
  514.                { perror("sysinit: gechr 1"); return(-1); }
  515.           charconin[4] &= ~$CBKM;
  516.           charconin[4] |= $CBBM;
  517.           if (sys_sechr( channel(0), (1<<31)|$CLMAX, charconin)) 
  518.                { perror("sysinit: sechr stdin "); return(-1); }
  519.           if (sys_sechr( channel(1), (1<<31)|$CLMAX, charconout))
  520.                { perror("sysinit: sechr stdout "); return(-1); }
  521.  
  522. #ifdef TTLEBUF
  523.      le_init();
  524. #endif /* TTLEBUF */
  525.  
  526.      return(0);
  527. }
  528.  
  529. char *
  530. whoami() {
  531.     extern char uidbuf[];
  532.     return(uidbuf[0] ? (char *)uidbuf : "UNKNOWN");
  533. }
  534.  
  535.  
  536. /* S E T T O -- set timeout on the channel to period.
  537.                 Save the old characteristics in char***in[]. 
  538. */
  539. /* AOS/VS device timeouts are used sparingly in this implementation of    */
  540. /* Kermit.  In most cases, signals are used instead.                --ENH */
  541.  
  542. int setto(chan, period) int chan, period; 
  543. {
  544.      int isconsole = 0;
  545.      int iscon[2];       /* Flags because i/o could be redirected */
  546.  
  547.      /* Setting is done external to here, since they can distinguish the 
  548.         console from ttyfd device.  Both console channels must be set
  549.         the same.
  550.      */
  551.      if ( (chan == channel(0)) || (chan == channel(1)) ) {
  552.           isconsole = 1; zero((char *) iscon, sizeof(iscon));
  553.           chan = channel(0);
  554.           if (sys_gechr( channel(0), (1<<31)|$CLMAX, charconin)) 
  555.                if (isatty(0)) {
  556.                     iscon[0] = 1;
  557.                     perror("setto: gechr 0: "); 
  558.                     return(-1);
  559.                }
  560.           charcurr = charconin;
  561.           if (sys_gechr( channel(1), (1<<31)|$CLMAX, charconout)) 
  562.                if (isatty(1)) {
  563.                     iscon[1] = 1;
  564.                     perror("setto: gechr 1: "); 
  565.                     return(-1);
  566.                }
  567.           timocon = period;
  568.      }
  569.  
  570.      else {
  571.           if (sys_gechr( chan, (1<<31)|$CLMAX, chartty))
  572.                { perror("setto: gechr tty: "); return(-1); }
  573.           charcurr = chartty;
  574.           timotty = period;
  575.      }
  576.  
  577.      charcurr[1] |= (0100000>>$CTO);
  578.      if (sys_sechr( chan, (1<<31)|$CLMAX, charcurr))
  579.           if ((isconsole == 0) || iscon[0]) {
  580.                perror("setto: sechr: "); 
  581.                return(-1); 
  582.           }
  583.      if (sys_stom( chan, 1<<31, period)) 
  584.           if ((isconsole == 0) || iscon[0]) {
  585.                perror("setto: stom: "); 
  586.                return(-1);
  587.           }
  588.  
  589.      if (isconsole == 0) return(0);
  590.      
  591.      chan = channel(1);
  592.      charconout[1] |= (0100000>>$CTO);
  593.      if (sys_sechr( chan, (1<<31)|$CLMAX, charconout)) 
  594.           if (iscon[1]) {
  595.                perror("setto: sechr 1: "); 
  596.                return(-1);
  597.           }
  598.      if (sys_stom( chan, 1<<31, period)) 
  599.           if (iscon[1]) {
  600.                perror("setto: stom 1: "); 
  601.                return(-1);
  602.           }
  603.      return(0);
  604. }
  605.  
  606.  
  607. /* R E S T O -- reset timeouts to the previous values, and restore char */
  608.  
  609. int
  610. resto(chan) int chan;
  611. {
  612.      int i, chan0, chan1, iscon[2];
  613.  
  614.      if ( (chan==channel(0)) || (chan==channel(1)) ) {
  615.  
  616.           chan0 = channel(0);      chan1 = channel(1); 
  617.           iscon[0] = isatty(0);    iscon[1] = isatty(1);
  618.           charconin[1] &= ~(0100000>>$CTO);
  619.           if (sys_stom( chan0, 1<<31, -1)) 
  620.                if (iscon[0]) {
  621.                     perror("resto: stom 0: "); 
  622.                     return(-1);
  623.                }
  624.           for (i = 0; i < $CLMAX; i++) if (charconin[i] != 0) {
  625.                if (sys_sechr( chan0, (1<<31)|$CLMAX, charconin))
  626.                     if (iscon[0]) {
  627.                          perror("resto: sechr 0: "); 
  628.                          return(-1); 
  629.                     }
  630.                break;
  631.           }
  632.           charconout[1] &= ~(0100000>>$CTO);
  633.           if (sys_stom( chan1, 1<<31, -1)) 
  634.                if (iscon[1]) {
  635.                     perror("resto: stom 1: "); 
  636.                     return(-1);
  637.                }
  638.           for (i = 0; i < $CLMAX; i++) if (charconout[i] != 0) {
  639.                if (sys_sechr( chan1, (1<<31)|$CLMAX, charconout)) 
  640.                if (iscon[1]) {
  641.                     perror("resto: sechr 1: "); 
  642.                     return(-1);
  643.                }
  644.                break;
  645.           }
  646.  
  647.           timocon = 0; 
  648.      }
  649.      else {
  650.           chartty[1] &= ~(0100000>>$CTO);
  651.           if (sys_stom( chan, 1<<31, -1)) 
  652.                { perror("setto: stom tty: "); return(-1); }
  653.           for (i = 0; i < $CLMAX; i++) if (chartty[i] != 0) {
  654.                if (sys_sechr( chan, (1<<31)|$CLMAX, chartty))
  655.                     { perror("resto: sechr tty: "); return(-1); }
  656.                break;
  657.           }
  658.           timotty = 0; 
  659.      }
  660.       
  661.      return(0);
  662. }
  663.  
  664.  
  665. /* S E T F L O W -- Set flow control in the device. 
  666.      
  667.     The device is assumed to be an intelligent IAC, where a CHAR/ON/IFC/OFC
  668.     could be done.
  669.  
  670. */
  671. static int dgsetflow(chan) int chan;
  672. {
  673.      short termparms[$CLMAX];
  674.  
  675.      if (sys_gechr( chan, (1<<31)|$CLMAX, termparms)) 
  676.           { perror("dgsetflow: gechr "); return(-1); }
  677.  
  678.      bitset(&termparms[4],$XOFC,1);
  679.      bitset(&termparms[4],$XIFC,1);
  680.      
  681.      if (sys_sechr( chan, (1<<31)|$CLMAX, termparms)) 
  682.           { perror("dgsetflow: sechr "); return(-1); }
  683.  
  684.      return(0);
  685. }
  686.  
  687.  
  688. /* R E S F L O W -- Re-Set flow control in the device. 
  689.      
  690.     The device is assumed to be an intelligent IAC, where a CHAR/OFF/IFC/OFC
  691.     could be done.
  692.  
  693. */
  694. int resflow(chan) int chan;
  695. {
  696.      int i;
  697.      short termparms[$CLMAX];
  698.  
  699.      if (sys_gechr( chan, (1<<31)|$CLMAX, termparms)) 
  700.           { perror("resflow: gechr "); return(-1); }
  701.  
  702.      bitset(&termparms[4],$XOFC,0);
  703.      bitset(&termparms[4],$XIFC,0);
  704.      
  705.      if (sys_sechr( chan, (1<<31)|$CLMAX, termparms))
  706.           { perror("resflow: sechr "); return(-1); }
  707.  
  708.      return(0);
  709. }
  710.  
  711.  
  712. /* S E T S P E E D -- Set the baud rate when not possible thru IOCTL.
  713.      
  714.     The device is assumed to be an intelligent IAC, where a CHAR/ON/BAUD=
  715.     could be done.
  716.  
  717. */
  718. int setspeed(sp) int sp;
  719. {
  720.      short termparms[$CLMAX];
  721.  
  722.      /* ttyfd is the Unix file number for the tty device.  Setting the
  723.       * characteristics will set it for both ttyfd and ttyfdout, since
  724.       * it is the device itself which is affected, and not just the 
  725.       * channel.
  726.       */
  727.      if (sys_gechr( channel(ttyfd), (1<<31)|$CLMAX, termparms)) 
  728.           { perror("setspeed: gechr "); return(-1); }
  729.  
  730.      termparms[3] &= ~$BRMSK;            /* Zero out the previous setting */
  731.      termparms[3] |= sp;
  732.      
  733.      if (sys_sechr( channel(ttyfd), (1<<31)|$CLMAX, termparms)) 
  734.           { perror("setspeed: sechr "); return(-1); }
  735.  
  736.      return(0);
  737. }
  738. #endif datageneral
  739.  
  740. /*  S Y S C L E A N U P  --  System-dependent cleanup */
  741.  
  742. int
  743. syscleanup() {
  744.     return(0);
  745. } 
  746.  
  747. /*  T T O P E N  --  Open a tty for exclusive access.  */
  748.  
  749. /*
  750.   Returns:
  751.     0 on success
  752.    -5 if device is in use
  753.    -4 if access to device is denied
  754.    -3 if access to lock directory denied
  755.    -2 upon timeout waiting for device to open
  756.    -1 on other error
  757. /*
  758.   If called with lcl < 0, sets value of lcl as follows:
  759.   0: the terminal named by ttname is the job's controlling terminal.
  760.   1: the terminal named by ttname is not the job's controlling terminal.
  761.   But watch out: if a line is already open, or if requested line can't
  762.   be opened, then lcl remains (and is returned as) -1.
  763. */
  764. int
  765. ttopen(ttname,lcl,modem,timo) char *ttname; int *lcl, modem,timo; {
  766.  
  767.     /* AOS/VS special stuff */
  768.     FILE *dg_open();                    /* Custom file open */
  769.     int retrycnt = 0;                   /* Retry if Modem disc in progress */
  770.  
  771.     char *ctermid();                    /* Wish they all had this! */
  772.     char *x;
  773.     extern char* ttyname();
  774.     char cname[DEVNAMLEN+4];
  775.  
  776. #define NAMEFD
  777. #ifdef NAMEFD
  778.     int i, j; char *p;
  779.     debug(F101,"ttopen telnetfd","",telnetfd);
  780. #endif /* NAMEFD */
  781.  
  782.     debug(F111,"ttopen entry modem",ttname,modem);
  783.     debug(F101," ttyfd","",ttyfd);
  784.     debug(F101," lcl","",*lcl);
  785.  
  786.     if (ttyfd > -1) {
  787.         if (strncmp(ttname,ttnmsv,DEVNAMLEN))   /* are old & new the same? */
  788.             ttclos(ttyfd);                      /* no? - close old */
  789.         else                                    /* yes? - ignore this call */
  790.             return(0);                          /* and return */
  791.     }
  792.  
  793. #ifdef NETCONN
  794.     if (modem < 0) {                    /* means special code for net type */
  795.         int x;
  796.         ttmdm = modem;
  797.         modem = -modem;                 /* negative value is net type */
  798.         fdflag = 0;                     /* stdio not redirected */
  799.         ttyfdout = -1;                  /* only use ttyfd for nets */
  800.         netconn = 1;                    /* network connection */
  801.         debug (F111,"ttopen net",ttname,modem);
  802. #ifdef NAMEFD
  803.         for (p = ttname; isdigit(*p); p++) ; /* check for all digits */
  804.         if (*p == '\0' && telnetfd) {
  805.             ttyfd = atoi(ttname);       /* can we test if it's open? */
  806.             ttfdflg = 1;               /* we got an open file descriptor */
  807.             debug(F111,"ttopen got open network fd",ttname,ttyfd);
  808.             strncpy(ttnmsv,ttname,DEVNAMLEN);   /* remember the "name" */
  809.             x = 1;                      /* return code is "good" */
  810.             if (telnetfd) {
  811.                 ttnet = NET_TCPB;
  812.                 ttnproto = NP_TELNET;
  813.             }
  814.         } else {
  815. #endif /* NAMEFD */                             /* hostname or address */
  816.             x = netopen(ttname,lcl,modem);      /* (see ckcnet.h) */
  817.             if (x > -1) {
  818.                 strncpy(ttnmsv,ttname,DEVNAMLEN);
  819.             } else netconn = 0;
  820. #ifdef NAMEFD
  821.         }
  822. #endif NAMEFD
  823.  
  824. /* ENH - left out ifdef sony_news section */
  825.  
  826.         xlocal = *lcl = 1;              /* network connections are local */
  827.         debug(F101,"ttopen net x","",x);
  828. #ifdef COMMENT
  829. /* Let netopen() handle this. */
  830.         if ((x > -1) && (!x25fd))
  831.             x = tn_ini();               /* initialize telnet protocol */
  832. #endif /* COMMENT */
  833.         return(x);
  834.     } else {                            /* terminal device */
  835. #endif /* NETCONN */
  836.  
  837. #ifdef NAMEFD
  838. /*
  839.   This code lets you give Kermit an open file descriptor for a serial
  840.   communication device, rather than a device name.  Kermit assumes that the
  841.   line is already open, locked, conditioned with the right parameters, etc.
  842. */
  843.         for (p = ttname; isdigit(*p); p++) ;    /* check for all digits */
  844.         if (*p == '\0') {
  845.             ttyfd = atoi(ttname);               /* can we test if open? */
  846.             debug(F111,"ttopen got open fd",ttname,ttyfd);
  847.             strncpy(ttnmsv,ttname,DEVNAMLEN);   /* remember the "name" */
  848.             xlocal = *lcl = 1;                  /* assume it's local */
  849.             netconn = 0;                        /* assume not network */
  850.             tvtflg = 0;                         /* initialize modes? */
  851.             ttmdm = modem;                      /* remember modem type */
  852.             fdflag = 0;                         /* stdio not redirected */
  853.             ttfdflg = 1;                        /* flag we were opened */
  854.                                                 /* this way */
  855. /* ENH - left out ifdef sony_news */
  856.  
  857.             return(0);                          /* return success */
  858.         }
  859. #endif /* NAMEFD */
  860. #ifdef NETCONN
  861.     }                           
  862. #endif /* NETCONN */
  863.  
  864. /* Here we have to open a serial device of the given name */
  865.  
  866.     tvtflg = 0;                         /* flag for use by ttvt() */
  867.                                         /* 0 means ttvt() not called yet */
  868.     fdflag = (!isatty(0) || !isatty(1));/* flag for stdio redirected */
  869.     debug(F101,"ttopen fdflag","",fdflag);
  870.     ttmdm = modem;                      /* Make this available to other fns */
  871.     xlocal = *lcl;                      /* Make this available to other fns */
  872.  
  873. /* Code for handling bidirectional tty lines goes here.
  874. /* Use specified method for turning off logins and suppressing getty. */
  875.  
  876. #ifdef ACUCNTRL
  877.     /* Should put call to priv_on() here, but that would be very risky! */
  878.     acucntrl("disable",ttname);         /* acucntrl() program. */
  879.     /* and priv_off() here... */
  880. #else
  881. #ifdef ATT7300
  882.     if ((attmodem & DOGETY) == 0)       /* offgetty() program. */
  883.       attmodem |= offgetty(ttname);     /* Remember response.  */
  884. #endif /* ATT7300 */
  885. #endif /* ACUCNTRL */
  886.  
  887. #ifdef datageneral
  888.     /* A custom open is done for the device, but a FILE handle is also needed
  889.      * for doing other special operations on the device.  See sysinit() for
  890.      * the initialization of the x_io_parms and xout_parms structures.
  891.      *
  892.      * First open up the output channel ($OFOT) 
  893.      */
  894.     idel_tbl[0] = 0x4;             /* CR only */
  895.     xout_parms.idel = idel_tbl;
  896.     xout_parms.ifnp = ttname;
  897.  
  898. /*
  899.     ttotmo = 0;
  900.     saval = signal(SIGALRM,timerh);
  901.     if (timo > 0) {
  902.         alarm(timo);              
  903.         if (setjmp(sjbuf)) {
  904.         } else {
  905. */           /* Ignore timeout for now - let it take as long as it wants */
  906. retry:
  907.     if ((ttfileout =
  908.        dg_open(ttname, xout_parms.isti, xout_parms.isto, 
  909.                xout_parms.imrs,xout_parms.ires,xout_parms.idel))
  910.        == NULL) {
  911.           /* If a modem disconnect, or one in progress, wait and retry. */
  912.           if ((lasterror() == ERDCT) || (lasterror() == ERCDS))
  913.                if (retrycnt == 0) {
  914.                     retrycnt = 1; 
  915.                     sleep(2); 
  916.                     goto retry; 
  917.                }
  918.           ttyfdout = -1;
  919.           perror("ttopen: output_line: dg_open");
  920.           if ((lasterror() == EREO1) || (lasterror() == EREO2)) /* in use */
  921.               return(-5);                               /* EOF */
  922.           else if (lasterror() == ERFAD)
  923.               return(-4);                               /* access denied */
  924.           else                                          /* some other error */
  925.               return(-1);
  926.     }
  927.     /* Successfull opens fall through here! */
  928.     
  929.     ttyfdout = fileno(ttfileout);               /* Note that ttyfdout is */
  930.     xout_parms.ich = channel(ttyfdout);         /* only used for asynch  */
  931.     
  932.     /* Next, open up the input channel ($OFIN) */
  933.  
  934.     x_io_parms.ifnp = ttname;
  935.     /* IDEL would default to NULL, FF, CR, NL as delimiters.
  936.      * The only delimiters here are CR and NL, for data sensitive 
  937.      * records.
  938.      */
  939.     idel_tbl[0] = 0x24;
  940.     x_io_parms.idel = idel_tbl;
  941.  
  942.     if ((ttfile =
  943.        dg_open(ttname, x_io_parms.isti, x_io_parms.isto, 
  944.                x_io_parms.imrs,x_io_parms.ires,x_io_parms.idel,
  945.                (P_SCREEN *) x_io_parms.etsp))
  946.        == NULL) {
  947.           ttyfd = -1;
  948.           perror("ttopen: input_line: dg_open");
  949.           if ((lasterror() == EREO1) || (lasterror() == EREO2)) /* in use */
  950.               return(-5);                               /* EOF */
  951.           else if (lasterror() == ERFAD)
  952.               return(-4);                               /* access denied */
  953.           else                                          /* some other error */
  954.               return(-1);
  955.        }
  956.     else {
  957.           ttyfd = fileno(ttfile);
  958.           x_io_parms.ich = channel(ttyfd);
  959.     }
  960.  
  961. #endif
  962.  
  963.     /* Make sure it's a real tty. */
  964.     if (!isatty(ttyfd)) {
  965.         fprintf(stderr,"%s is not a tty!\n",ttname);
  966.         debug(F110,"ttopen not a tty",ttname,0);
  967.         close(ttyfd);
  968.         ttyfd = -1;
  969.         return(-1);
  970.     }
  971.  
  972.     strncpy(ttnmsv,ttname,DEVNAMLEN);   /* Open, keep copy of name locally. */
  973.  
  974. /* Caller wants us to figure out if line is controlling tty */
  975.  
  976.     debug(F111,"ttopen ok",ttname,*lcl);
  977.     if (*lcl == -1) {
  978.         if (strcmp(ttname,CTTNAM) == 0) {   /* "/dev/tty" always remote */
  979.             debug(F110," Same as CTTNAM",ttname,0);
  980.             xlocal = 0;
  981.         } else if (isatty(0)) {         /* Else, if stdin not redirected */
  982.             x = ttyname(0);             /* then compare its device name */
  983.             strncpy(cname,x,DEVNAMLEN); /* (copy from internal static buf) */
  984.             debug(F110," ttyname(0)",x,0);
  985.             x = ttyname(ttyfd);         /* ...with real name of ttname. */
  986.             xlocal = (strncmp(x,cname,DEVNAMLEN) == 0) ? 0 : 1;
  987.             debug(F111," ttyname",x,xlocal);
  988.         }                               /* Else, if stdin redirected... */
  989.     }    
  990.  
  991. /* Now check if line is locked -- if so fail, else lock for ourselves */
  992.  
  993.     lkf = 0;                            /* Check lock */
  994.     if (xlocal > 0) {
  995.         if (ttlock(ttname) < 0) {
  996.             fprintf(stderr,"Exclusive access to %s denied\n",ttname);
  997.             close(ttyfd); ttyfd = -1;
  998.             debug(F110," Access denied by lock",ttname,0);
  999.  
  1000.             return(-3);
  1001.         } else lkf = 1;
  1002.     }
  1003.  
  1004. /* Got the line, now set the desired value for local. */
  1005.  
  1006.     if (*lcl != 0) *lcl = xlocal;
  1007.  
  1008. /* Request exclusive access on systems that allow it. */
  1009.  
  1010. #ifdef TIOCEXCL
  1011.         if (ioctl(ttyfd,TIOCEXCL, NULL) < 0)
  1012.             fprintf(stderr,"Warning, problem getting exclusive access\n");
  1013. #endif
  1014.  
  1015. /* Get tty device settings */
  1016.  
  1017.     ioctl(ttyfd,TCGETA,&ttold);         /* Same deal for Sys III, Sys V */
  1018.     ioctl(ttyfd,TCGETA,&ttraw);
  1019.     ioctl(ttyfd,TCGETA,&tttvt);
  1020.  
  1021.     debug(F101,"ttopen, ttyfd","",ttyfd);
  1022.  
  1023.     debug(F101,"ttopen, ttyfdout","",ttyfdout);
  1024.     /* For DG, also get the tty extended device characteristics. */
  1025.     sys_gechr( channel(ttyfd), (1<<31)|$CLMAX, ch_ttold);
  1026.     sys_gechr( channel(ttyfd), (1<<31)|$CLMAX, ch_ttraw);
  1027.     sys_gechr( channel(ttyfd), (1<<31)|$CLMAX, ch_ttvt);
  1028.  
  1029.     debug(F101," lcl","",*lcl);
  1030.     debug(F111," lock file",flfnam,lkf);
  1031.     return(0);
  1032. }
  1033.  
  1034. /*  T T C L O S  --  Close the TTY, releasing any lock.  */
  1035. int
  1036. ttclos(foo) int foo; {
  1037.     int x = 0;
  1038.  
  1039.     debug(F101,"ttclos ttyfd","",ttyfd);
  1040.     if (ttyfd < 0) return(0);           /* Wasn't open. */
  1041.     if (ttfdflg) return(0);             /* If we got ttyfd from another */
  1042.                                         /* process, don't close it. */
  1043.     tvtflg = 0;
  1044.  
  1045. #ifdef  NETCONN
  1046.     if (netconn) {                      /* Network connection. */
  1047.         debug(F100,"ttclos closing net","",0);
  1048.         netclos();                      /* Close it. */
  1049.         netconn = 0;
  1050.         return(0);
  1051.     }
  1052. #endif  /* NETCONN */
  1053.  
  1054.     if (xlocal) {
  1055.         debug(F100,"ttclos skipping ttunlck for AOS/VS","",0);
  1056.         debug(F100,"ttclos about to call tthang()","",0);
  1057.     }
  1058.     if (ttyfd > 0) {
  1059.                                         /* & timer stuff &  moved closes in */
  1060.         saval = signal(SIGALRM,timerh); /* enable timer */
  1061.         alarm(5);                       /* allow 5 seconds for completion */
  1062.         if (setjmp(sjbuf)) {            /* timer went off */
  1063.             x = -1;                     /* set return value */
  1064.         } else {                        /* what we're really trying to do */
  1065.             if (xlocal) {
  1066.                 if (tthang())           /* Hang up first, then... */
  1067.                     fprintf(stderr,"Warning, problem hanging up the phone\n");
  1068.                 ttres();                /* reset device modes. */
  1069.             }
  1070. #ifdef TIOCEXCL
  1071. #ifdef TIOCNXCL
  1072.            if (ioctl(ttyfd, TIOCNXCL, NULL) < 0)
  1073.                 fprintf(stderr,"Problem relinquishing exclusive access\n");
  1074. #endif
  1075. #endif
  1076.  
  1077.             debug(F101,"ttclos, ttyfd","",ttyfd);
  1078.             debug(F101,"ttclos, ttyfdout","",ttyfdout);
  1079.             fclose(ttfile);                     /* Close it. */
  1080.  
  1081.             /* Close the output tty device */
  1082.             fclose(ttfileout);                  /* Close it. */
  1083.             x = 1;                              /* good return */
  1084.         }
  1085.         ttimoff();                              /* turn off timer */
  1086.         if (x < 0) {
  1087.             fprintf(stderr,"?Timed out closing device: %s\n",ttnmsv);
  1088.             debug(F100,"ttclos timed out","",0);
  1089.         }
  1090.     }
  1091.     ttyfd = -1;                         /* Mark it as closed. */
  1092.     ttyfdout = -1;                      /* Mark it as closed. */
  1093.  
  1094.     debug(F100,"ttclos done","",0);
  1095.     return(0);
  1096. }
  1097.  
  1098. /*  T T H A N G -- Hangup phone line */
  1099.  
  1100. tthang() {
  1101.     unsigned short ttc_save;
  1102.     int x;
  1103.  
  1104.     if (ttyfd < 0) return(0);           /* Not open. */
  1105.     if (xlocal < 1) return(0);
  1106.  
  1107. #ifdef NETCONN
  1108.     if (netconn) {                      /* Network connection. */
  1109.         return ((netclos() < 0) ?  -1 : 1); /* Close it */
  1110.     }
  1111. #endif /* NETCONN */
  1112.  
  1113.     ttc_save = ttraw.c_cflag;
  1114.     ttraw.c_cflag &= ~CBAUD;            /* swa: set baud rate to 0 to hangup */
  1115.     if (ioctl(ttyfd,TCSETAF,&ttraw) < 0) return(-1); /* do it */
  1116.     msleep(100);                        /* let things settle */
  1117.     ttraw.c_cflag = ttc_save;
  1118.     debug(F100, "tthang disconnecting line","",0);
  1119.     if (sys_sechr( channel(ttyfd), (1<<31)|$CLMAX, ch_ttraw)) 
  1120.          { perror("tthang: sechr "); return(-1); }
  1121.     if (ioctl(ttyfd,TCSETAF,&ttraw) < 0) return(-1); /* un-do it */
  1122.     return (0);
  1123. }
  1124.  
  1125.  
  1126. /*  T T R E S  --  Restore terminal to "normal" mode.  */
  1127.  
  1128. ttres() {                               /* Restore the tty to normal. */
  1129.     int x;
  1130.  
  1131.     if (ttyfd < 0) return(-1);          /* Not open. */
  1132.  
  1133.     if (ttfdflg) return(0);             /* Don't mess with terminal modes if */
  1134.                                         /* we got ttyfd from another process */
  1135. #ifdef  NETCONN
  1136.     if (netconn) return (0);            /* Network connection, do nothing */
  1137. #endif  /* NETCONN */
  1138.  
  1139.     x = (ioctl(ttyfd,TCSETAW,&ttold) < 0);       /* restore termio stuff */
  1140.  
  1141.     /* Un-set all the timeouts */
  1142.     if (timotty) {
  1143.          resto(channel(ttyfd));
  1144.          resto(channel(ttyfdout));
  1145.     }
  1146.     if (sys_sechr( channel(ttyfd), (1<<31)|$CLMAX, ch_ttold)) 
  1147.          { perror("ttres: sechr "); return(-1); }
  1148.  
  1149.     return(0);
  1150. }
  1151.  
  1152. /* Exclusive uucp file locking control */
  1153. /*
  1154.  by H. Fischer, creative non-Bell coding !
  1155.  copyright rights for lock modules assigned to Columbia University
  1156. */
  1157.  
  1158. /* The AOS/VS implementation does not use uucp locks.   --ENH */
  1159.  
  1160. static char *
  1161. xxlast(s,c) char *s; char c; {          /* Equivalent to strrchr() */
  1162.     int i;
  1163.     for (i = strlen(s); i > 0; i--)
  1164.         if ( s[i-1] == c ) return( s + (i - 1) );
  1165.     return(NULL);           
  1166. }
  1167. static
  1168. look4lk(ttname) char *ttname; {
  1169.     extern char *strcat(), *strcpy();
  1170.     char *device, *devname;
  1171.     char lockfil[50];                   /* Max length for lock file name */
  1172.     char *lockdir = "/usr/spool/uucp";
  1173.  
  1174.     device = ( (devname=xxlast(ttname,'/')) != NULL ? devname+1 : ttname);
  1175.  
  1176.     strcat( strcpy( lockfil, "LCK.." ), device );
  1177.  
  1178.     if (access( lockdir, 04 ) < 0) {    /* read access denied on lock dir */
  1179.         fprintf(stderr,"Warning, read access to lock directory denied\n");
  1180.         return( 1 );                    /* cannot check or set lock file */
  1181.     }
  1182.         
  1183.     strcat(strcat(strcpy(flfnam,lockdir),"/"), lockfil);
  1184.     debug(F110,"look4lk",flfnam,0);
  1185.  
  1186.     if ( ! access( flfnam, 00 ) ) {     /* print out lock file entry */
  1187.         char lckcmd[40] ;
  1188.         strcat( strcpy(lckcmd, "ls -l ") , flfnam);
  1189.         system(lckcmd);
  1190.         if (access(flfnam,02) == 0)
  1191.             printf("(You may type \"! rm %s\" to remove this file)\n",flfnam);
  1192.         return( -1 );
  1193.     }
  1194.     if ( access( lockdir, 02 ) < 0 ) {  /* lock file cannot be written */
  1195.         fprintf(stderr,"Warning, write access to lock directory denied\n");
  1196.         return( 1 );
  1197.     }
  1198.  
  1199.     return( 0 );                        /* okay to go ahead and lock */
  1200. }
  1201.  
  1202. /*  T T L O C K  */
  1203.  
  1204.  
  1205. static
  1206. ttlock(ttyfd) char *ttyfd; {            /* lock uucp if possible */
  1207.  
  1208. #ifdef datageneral
  1209.     /* The Data General locks a device when that device is opened.  So
  1210.      * return that the device is already locked.
  1211.      * Besides, because of internal multi-tasking, locking the device by
  1212.      * the ?ASSIGN call or an $IEXO flag would cause problem for the task
  1213.      * id that did not open the device first.
  1214.      */
  1215. #else datageneral
  1216.     int lck_fil, l4l;
  1217.     int pid_buf = getpid();             /* pid to save in lock file */
  1218.         
  1219.     haslock = 0;                        /* not locked yet */
  1220.     l4l = look4lk(ttyfd);
  1221.     if (l4l < 0) return (-1);           /* already locked */
  1222.     if (l4l == 1) return (0);           /* can't read/write lock directory */
  1223.     lck_fil = creat(flfnam, 0444);      /* create lock file ... */
  1224.     if (lck_fil < 0) return (-1);       /* create of lockfile failed */
  1225.                 /* creat leaves file handle open for writing -- hf */
  1226.     write (lck_fil, &pid_buf, sizeof(pid_buf) ); /* uucp expects int in file */
  1227.     close (lck_fil);
  1228. #endif datageneral
  1229.     haslock = 1;                        /* now is locked */
  1230.     return(0);
  1231. }
  1232.  
  1233. /*  T T U N L O C K  */
  1234.  
  1235. static
  1236. ttunlck() {                             /* kill uucp lock if possible */
  1237. #ifdef datageneral
  1238.     /* The DG automatically unlocks the device when it is closed, or when
  1239.      * the process is terminated for any reason.  Unlocking is not needed.
  1240.      * Also, see the note for ttlock().
  1241.      */
  1242.     return(0);
  1243. #else
  1244.     if (haslock) return( unlink( flfnam ) ); 
  1245. #endif
  1246.  
  1247. }
  1248.  
  1249. /*  T T P K T  --  Condition the communication line for packets. */
  1250. /*              or for modem dialing */
  1251.  
  1252. #define DIALING 4               /* flags (via flow) for modem handling */
  1253. #define CONNECT 5
  1254.  
  1255. /*  If called with speed > -1, also set the speed.  */
  1256.  
  1257. /*  Returns 0 on success, -1 on failure.  */
  1258.  
  1259. ttpkt(speed,xflow,parity) long speed; int xflow, parity; {
  1260.     int s2;
  1261.     int s = -1;
  1262.     int x;
  1263.     extern int flow;                    /* REAL flow-control setting */
  1264.  
  1265.     if (ttyfd < 0) return(-1);          /* Not open. */
  1266.  
  1267.     debug(F101,"ttpkt parity","",parity);
  1268.     debug(F101,"ttpkt xflow","",xflow);
  1269.     debug(F101,"ttpkt speed","",(int) speed);
  1270.  
  1271.     ttprty = parity;                    /* Let other tt functions see these. */
  1272.     ttpflg = 0;                         /* Parity not sensed yet */
  1273.     ttpmsk = ttprty ? 0177 : 0377;      /* Parity stripping mask */
  1274.     ttspeed = speed;
  1275.  
  1276. #ifdef NETCONN                          /* Nothing to do for telnet */
  1277.     if (netconn) return (0);
  1278. #endif /* NETCONN */
  1279.  
  1280.     if (ttfdflg && !isatty(ttyfd)) return(0);
  1281.  
  1282.     if (xflow != FLO_DIAL && xflow != FLO_DIAX)
  1283.       ttflow = xflow;                   /* Now make this available too. */
  1284.  
  1285.     if (xlocal) {
  1286.         s2 = (int) (speed / 10L);       /* convert bps to cps */
  1287.         s = ttsspd(s2);                 /* get associated speed */
  1288.         if (s < 0)
  1289.             return(-1);
  1290.         /* carrctl() call here in UNIX code */  
  1291.     }
  1292.                                         
  1293. #ifdef UXIII
  1294.     if (flow == FLO_XONX) ttraw.c_iflag |= (IXON|IXOFF);
  1295.     else if (flow == FLO_NONE) ttraw.c_iflag &= ~(IXON|IXOFF);
  1296.     else if (flow == FLO_KEEP) {
  1297.         ttraw.c_iflag &= ~(IXON|IXOFF);
  1298.         ttraw.c_iflag |= (ttold.c_iflag & (IXON|IXOFF));
  1299.     } else if (flow == FLO_RTSC) {
  1300.         /* RTS/CTS Flow control... */
  1301. #ifdef RTSXOFF
  1302.         /* This is the preferred way, according to SVID R4 */
  1303.         if (ioctl(ttyfd,TCGETX,&rctsx) > -1) {
  1304.             rctsx.x_hflag |= RTSXOFF | CTSXON;
  1305.             ioctl(ttyfd,TCSETX,&rctsx); /* Ignore errors for now. */
  1306.         }
  1307. #else
  1308. #ifdef CRTSCTS
  1309.         /* Found this one in <termios.h> */
  1310.         ttraw.c_iflag |= CRTSCTS;
  1311. #endif /* CRTSCRS */
  1312. #endif /* RTSXOFF */
  1313.     }
  1314.     if (flow == FLO_DTRC) {
  1315.         /* DTR/CD Flow control... */
  1316. #ifdef DTRXOFF
  1317.         /* This is straight out of SVID R3 */
  1318.         if (ioctl(ttyfd,TCGETX,&rctsx) > -1) {
  1319.             rctsx.x_hflag |= DTRXOFF | CDXON;
  1320.             ioctl(ttyfd,TCSETX,&rctsx); /* Ignore errors. */
  1321.         }
  1322. #endif /* DTRXOFF */
  1323.     }
  1324.     if (flow == DIALING)  ttraw.c_cflag |= CLOCAL|HUPCL;
  1325.     if (flow == CONNECT)  ttraw.c_cflag &= ~CLOCAL;
  1326.  
  1327.     ttraw.c_lflag &= ~(ICANON|ECHO);
  1328.     ttraw.c_lflag &= ~ISIG;
  1329.     ttraw.c_lflag |= NOFLSH;            /* Don't flush */
  1330.     ttraw.c_iflag |= (BRKINT|IGNPAR);
  1331.     ttraw.c_iflag &= ~(IGNBRK|INLCR|IGNCR|ICRNL|IUCLC|INPCK|ISTRIP|IXANY);
  1332.     ttraw.c_oflag &= ~OPOST;
  1333. #ifdef datageneral
  1334.     ttraw.c_lflag &= ~CSETPM;      /* No DG page mode */
  1335. #endif
  1336.     ttraw.c_cc[4] = 1;
  1337.     ttraw.c_cflag &= ~(CSIZE|PARENB);
  1338.     ttraw.c_cflag |= (CS8|CREAD);
  1339.     ttraw.c_cc[5] = 0;
  1340.  
  1341. #ifdef VINTR                            /* Turn off interrupt character */
  1342.     if (xlocal == 0)                    /* so ^C^C can break us out of */
  1343.       ttraw.c_cc[VINTR] = 0;            /* packet mode. */
  1344. #endif /* VINTR */
  1345.  
  1346.     if (s > -1) {
  1347.         ttraw.c_cflag &= ~CBAUD;
  1348.         ttraw.c_cflag |= s;             /* set speed */
  1349.     }
  1350.  
  1351.     if (ioctl(ttyfd,TCSETAW,&ttraw) < 0) return(-1);  /* set new modes . */
  1352. #ifdef datageneral
  1353.     if (flow == FLO_XONX) {
  1354.          dgsetflow(channel(ttyfdout));
  1355.          dgsetflow(channel(ttyfd));
  1356.     }
  1357.     if (flow == FLO_NONE) {
  1358.          resflow(channel(ttyfdout));
  1359.          resflow(channel(ttyfd));
  1360.     }
  1361.     /* if flow is FLO_KEEP, don't do anything */
  1362.     if (sys_gechr( channel(ttyfd), (1<<31)|$CLMAX, ch_ttraw)) 
  1363.          { perror("ttpkt: gechr: "); return(-1); }
  1364. #endif
  1365.  
  1366.     if (flow == DIALING) {
  1367. #ifdef datageneral
  1368. #ifndef aosvs
  1369.         if (fcntl(ttyfd,F_SETFL, fcntl(ttyfd, F_GETFL, 0)) < 0 )
  1370.                 return(-1);
  1371. #endif
  1372. #else
  1373.         if (fcntl(ttyfd,F_SETFL, fcntl(ttyfd, F_GETFL, 0) & ~O_NDELAY) < 0 )
  1374.                 return(-1);
  1375.         close( open(ttnmsv,2) );        /* magic to force mode change!!! */
  1376. #endif
  1377.         }
  1378.  
  1379. #endif
  1380.  
  1381. #ifdef COMMENT
  1382.     ttflui();                           /* Flush any pending input */
  1383. #endif /* COMMENT */
  1384.     tvtflg = 0;
  1385.     return(0);
  1386. }
  1387.  
  1388. /*  T T V T -- Condition communication line for use as virtual terminal  */
  1389.  
  1390. ttvt(speed,flow) int speed, flow; {
  1391.     int s, s2;
  1392.  
  1393.     debug(F101,"ttvt ttyfd","",ttyfd);
  1394.     debug(F101,"ttvt tvtflg","",tvtflg);
  1395.     debug(F101,"ttvt speed","",speed);
  1396.  
  1397.     if (ttyfd < 0) return(-1);          /* Not open. */
  1398.  
  1399. #ifdef NETCONN
  1400.     if (netconn) {
  1401.         tvtflg = 1;                     /* Network connections */
  1402.         return(0);                      /* require no special setup */
  1403.     }
  1404. #endif /* NETCONN */
  1405.  
  1406.     if (tvtflg != 0 && speed == ttspeed && flow == ttflow && ttcarr == curcarr)
  1407.       return(0);                        /* Already been called. */
  1408.  
  1409.     if (ttfdflg && !isatty(ttyfd)) return(0);
  1410.  
  1411.     if (xlocal) {
  1412.         s2 = (int) (speed / 10L);       /* convert bps to cps */
  1413.         s = ttsspd(s2);                 /* Check the speed */
  1414.         /* ENH - UNIX has call to carrctl here */
  1415.     }
  1416.     if (flow == FLO_XONX) tttvt.c_iflag |= (IXON|IXOFF);
  1417.     else if (flow == FLO_KEEP) {
  1418.         tttvt.c_iflag &= ~(IXON|IXOFF); /* Turn off Xon/Xoff flags */
  1419.         tttvt.c_iflag |= (ttold.c_iflag & (IXON|IXOFF)); /* OR in old ones */
  1420.     }else if (flow == FLO_NONE) tttvt.c_iflag &= ~(IXON|IXOFF);
  1421.  
  1422.     if (flow == DIALING)  tttvt.c_cflag |= CLOCAL|HUPCL;
  1423.     if (flow == CONNECT)  tttvt.c_cflag &= ~CLOCAL;
  1424.  
  1425.     tttvt.c_lflag &= ~(ISIG|ICANON|ECHO);
  1426.     tttvt.c_iflag |= (IGNBRK|IGNPAR);
  1427.     tttvt.c_iflag &= ~(INLCR|IGNCR|ICRNL|IUCLC|BRKINT|INPCK|ISTRIP|IXANY);
  1428.     tttvt.c_oflag &= ~OPOST;
  1429.     tttvt.c_cflag &= ~(CSIZE|PARENB);
  1430.     tttvt.c_cflag |= (CS8|CREAD);
  1431.     tttvt.c_cc[4] = 1;
  1432.     tttvt.c_cc[5] = 0;
  1433.  
  1434.     if (s > -1) {
  1435.         tttvt.c_cflag &= ~CBAUD;
  1436.         tttvt.c_cflag |= s; /* set speed */
  1437.     }
  1438.  
  1439.     if (ioctl(ttyfd,TCSETAW,&tttvt) < 0) return(-1);  /* set new modes . */
  1440.  
  1441. #ifdef datageneral
  1442.     if (flow == FLO_XONX) {
  1443.          dgsetflow(channel(ttyfdout));
  1444.          dgsetflow(channel(ttyfd));
  1445.     }
  1446.     if (flow == FLO_NONE) {
  1447.          resflow(channel(ttyfdout));
  1448.          resflow(channel(ttyfd));
  1449.     }
  1450.     if (sys_gechr( channel(ttyfd), (1<<31)|$CLMAX, ch_ttvt)) 
  1451.          { perror("ttvt: gechr: "); return(-1); }
  1452. #endif
  1453.  
  1454.     if (flow == DIALING) {
  1455. #ifdef datageneral
  1456. #ifndef aosvs
  1457.         if (fcntl(ttyfd,F_SETFL, fcntl(ttyfd, F_GETFL, 0)) < 0 )
  1458.                 return(-1);
  1459. #endif
  1460. #else
  1461.         if (fcntl(ttyfd,F_SETFL, fcntl(ttyfd, F_GETFL, 0) & ~O_NDELAY) < 0 )
  1462.                 return(-1);
  1463.         close( open(ttnmsv,2) );        /* magic to force mode change!!! */
  1464. #endif
  1465.         }
  1466.  
  1467.     ttspeed = speed;                    /* Done, remember how we were */
  1468.     ttflow = flow;                      /* called, so we can decide how to */
  1469.     tvtflg = 1;                         /* respond next time. */
  1470.  
  1471.     debug(F101,"ttvt done","",tvtflg);
  1472.     return(0);
  1473. }
  1474.  
  1475. /*  T T S S P D  --  Return the internal baud rate code for 'speed'.  */
  1476.  
  1477. ttsspd(cps) {
  1478.     int s,s2,spdok;
  1479.  
  1480.     debug(F101,"ttsspd","",cps);
  1481.  
  1482. #ifdef  NETCONN
  1483.     if (netconn) return (0);
  1484. #endif  /* NETCONN */
  1485.  
  1486.     if (cps < 0) return(-1);
  1487.         spdok = 1;                      /* Assume arg ok */
  1488.         switch (cps) {
  1489.             case 0:   s = B0;    break; /* Just the common ones. */
  1490.             case 11:  s = B110;  break; /* The others from ttydev.h */
  1491.             case 15:  s = B150;  break; /* could also be included if */
  1492.             case 30:  s = B300;  break; /* necessary... */
  1493.             case 60:  s = B600;  break;
  1494.             case 120: s = B1200; break;
  1495.             case 180: s = B1800; break;
  1496.  
  1497.             case 240: s = B2400; break;
  1498.             case 480: s = B4800; break;
  1499.             case 960: s = B9600; break;
  1500. #ifdef datageneral
  1501.             /* ioctl() allows other speeds */
  1502.             case 5:     s = B50; break;
  1503.             case 7:     s = B75; break;
  1504.             case 13:    s = B134; break;
  1505.             case 360:   s = B3600; break;
  1506.             case 720:   s = B7200; break;
  1507.             case 1920:  s = B19000; break;
  1508.  
  1509.             /* Some speeds are supported by the hardware thru PMGR.
  1510.                We don't bother about 45.5 but it could be added.
  1511.             */
  1512.             case 38400:  if (setspeed($CR38K)) spdok = 0; s = 0; break;
  1513. #endif
  1514.             default:
  1515.                 spdok = 0;
  1516.                 fprintf(stderr,"Unsupported line speed - %d\n",cps * 10);
  1517.                 fprintf(stderr,"Current speed not changed\n");
  1518.                 break;
  1519.         }           
  1520.         if (spdok)
  1521.             return(s);
  1522.         else
  1523.             return(-1);
  1524.  }
  1525.  
  1526. /*  T T S C A R R  --  Set ttcarr variable, controlling carrier handling.
  1527.  *
  1528.  *  0 = Off: Always ignore carrier. E.g. you can connect without carrier.
  1529.  *  1 = On: Heed carrier, except during dialing. Carrier loss gives disconnect.
  1530.  *  2 = Auto: For "modem direct": The same as "Off".
  1531.  *            For real modem types: Heed carrier during connect, but ignore
  1532.  *                it anytime else.  Compatible with pre-5A C-Kermit versions.
  1533.  *
  1534.  * As you can see, this setting does not affect dialing, which always ignores
  1535.  * carrier (unless there is some special exception for some modem type).  It
  1536.  * does affect ttopen() if it is set before ttopen() is used.  This setting
  1537.  * takes effect on the next call to ttopen()/ttpkt()/ttvt().  And they are
  1538.  * (or should be) always called before any communications is tried, which
  1539.  * means that, practically speaking, the effect is immediate.
  1540.  *
  1541.  * Of course, nothing of this applies to remote mode (xlocal = 0).
  1542.  *
  1543.  * Someone has yet to uncover how to manipulate the carrier in the BSD
  1544.  * environment (or any non-termio using environment).  Until that time, this
  1545.  * will simply be a no-op for BSD.
  1546.  *
  1547.  * Note that in previous versions, the carrier was most often left unchanged
  1548.  * in ttpkt()/ttvt() unless they were called with DIALING or CONNECT.  This
  1549.  * has changed.  Now it is controlled by ttcarr in conjunction with these
  1550.  * modes.
  1551.  */
  1552. int
  1553. ttscarr(carrier) int carrier; {
  1554.     ttcarr = carrier;
  1555.     debug(F101, "ttscarr","",ttcarr);
  1556.     return(ttcarr);
  1557. }
  1558.  
  1559. int
  1560. ttgmdm() {                              /* Read modem signals */
  1561.     return(-3);                         /* ENH - return value of -3 means */
  1562. }                                       /* not implemented, which it's not */
  1563.                                         /* because this can't (easily) be */
  1564.                                         /* done in AOS/VS */
  1565.  
  1566. int
  1567. ttwmdm(mdmsig,timo) int mdmsig,timo; {  /* wait timo seconds for specified */
  1568.     return(-3);                         /* modem signals to appear */
  1569. }
  1570.  
  1571.  
  1572. long
  1573. ttgspd() {                              /* Get line speed */
  1574.     P_CHAR_EX   cp;                     /* characteristics packet */
  1575.     int         ac0,ac1,ac2,error;
  1576.     static int  baud_rate[] = {
  1577.                     50,75,110,134,150,300,600,1200,1800,2000,2400,3600,4800,
  1578.                     7200,9600,19200},
  1579.                 baud_rate_x[] = {45,38400};
  1580.  
  1581. #ifdef NETCONN
  1582.     if (netconn) return (-1);
  1583. #endif /* NETCONN */
  1584.  
  1585.     if (ttyfd < 0)
  1586.         return (-1);
  1587.     else {
  1588.         ac0 = channel(ttyfd);
  1589.         ac1 = $CLMAX | BIT0;
  1590.         ac2 = (P_CHAR_EX *) &cp;
  1591.         error = sys($GECHR,&ac0,&ac1,&ac2);
  1592.         if (error)
  1593.             return(-1);
  1594.  
  1595.         if (cp.char_br0bit == 0)
  1596.             return(baud_rate[cp.char_br_1_4]);
  1597.         else
  1598.             return(baud_rate_x[cp.char_br_1_4]);
  1599.     }
  1600. }
  1601.  
  1602. int
  1603. psuspend() {                            /* ENH - not possible in VS */
  1604.     return(-1);
  1605. }
  1606.  
  1607. /* Interrupt Functions */
  1608.  
  1609. /* Set up terminal interrupts on console terminal */
  1610.  
  1611. #ifdef UXIII
  1612. esctrp() {                              /* trap console escapes (^\) */
  1613.  
  1614.     conesc = 1;
  1615.     signal(SIGQUIT,SIG_IGN);            /* ignore until trapped */
  1616. }
  1617. #endif
  1618.  
  1619. /*  C O N I N T  --  Console Interrupt setter  */
  1620. VOID
  1621. conint(f,s) SIGTYP (*f)(), (*s)(); {    /* Set an interrupt trap. */
  1622.  
  1623.     if (!isatty(0)) {                   /* only for real ttys */
  1624.         debug(F101,"conint not a tty","",isatty(0));
  1625.         return;
  1626.     }
  1627.     if (backgrd) {                      /* must ignore signals in bkgrd */
  1628.         debug(F101,"conint backgrd ignoring signals","",backgrd);
  1629.         return;
  1630.     } else
  1631.       debug(F101,"conint foreground catching signals","",0);
  1632. /*
  1633.  Except for special cases below, ignore keyboard quit signal.
  1634.  ^\ too easily confused with connect escape, and besides, we don't want
  1635.  to leave lock files around.  (Frank Prindle)
  1636. */
  1637. #ifdef datageneral
  1638.     /* Set up the asynchronous task to read the console. 
  1639.      * But, I don't want them set up all the time, so I will kludge up the
  1640.      * call in  chkint() (ckuus3.c) to see if this asynch task is running:
  1641.      * conint_mt()
  1642.      */
  1643. #endif
  1644.     signal(SIGQUIT,SIG_IGN);
  1645.  
  1646. #ifdef UXIII
  1647.     signal(SIGQUIT,esctrp);             /* console escape in pkt modes */
  1648.     if (conesc) {                       /* clear out pending escapes */
  1649.         conesc = 0;
  1650.     }
  1651. #endif
  1652.  
  1653.     if (conif) return;                  /* Nothing to do if already on. */
  1654.  
  1655. /* check if invoked in background -- if so signals set to be ignored */
  1656.  
  1657.     if (signal(SIGINT,SIG_IGN) == SIG_IGN) {
  1658.         backgrd = 1;                    /*   means running in background */
  1659. #ifdef UXIII
  1660.         signal(SIGQUIT,SIG_IGN);        /*   must leave signals ignored */
  1661. #endif
  1662.         return;
  1663.     }
  1664.     signal(SIGINT,f);                   /* Function to trap to on interrupt. */
  1665.     signal(SIGHUP,f);                   /* Or hangup, so lock file cleared. */
  1666.     conif = 1;                          /* Flag console interrupts on. */
  1667. }
  1668.  
  1669.  
  1670. /*  C O N N O I  --  Reset console terminal interrupts */
  1671.  
  1672. connoi() {                              /* Console-no-interrupts */
  1673.  
  1674.     if (!isatty(0)) return(0);          /* only for real ttys */
  1675.     if (backgrd) return;                /* Ignore signals in background */
  1676.  
  1677. #ifdef datageneral
  1678.     /* Terminate the asynchronous task that reads the console for
  1679.      * interrupt characters. 
  1680.      * But, I don't want to kill this task all the time, so I will kludge 
  1681.      * up the call in input() (ckcfn2.c) to kill the asynch task if it
  1682.      * is running: connoi_mt()
  1683.      */
  1684. #endif
  1685.     signal(SIGINT,SIG_DFL);
  1686.     signal(SIGHUP,SIG_DFL);
  1687.     signal(SIGQUIT,SIG_DFL);
  1688.     conif = 0;                          /* Flag interrupt trapping off */
  1689. }
  1690.  
  1691. #ifdef datageneral
  1692. /* C O N I N T _ M T  -- Asynch read console task */
  1693.  
  1694. void conint_mt() {
  1695.     int count = 0;
  1696.  
  1697.     /* Any input waiting? */
  1698.     con_reads_mt = 1;                   /* Flag that task is active */
  1699.     conint_avl = 0;                     /* Flag that interrupt gotten */
  1700.     while (con_reads_mt)
  1701.         if ((conint_ch = coninc(2)) > 0) { /* If character at keyboard */
  1702.             conint_avl = 1;             /* we set the flag */
  1703.             while ((conint_avl) && (++count <= 5))
  1704.                 sleep(1);               /* & wait for char to be processed */
  1705.         }
  1706.         count = 0;                      /* initialize counter */
  1707.         conint_avl = 0;
  1708. }
  1709.  
  1710.  
  1711. /* C O N N O I _ M T  -- Kill asynch read console task */
  1712.  
  1713. connoi_mt() {
  1714.     conint_avl = 0;
  1715.     if (con_reads_mt) {
  1716.         con_reads_mt = 0;
  1717.         midkill(CONINT_TSK);
  1718.     }
  1719. }
  1720.  
  1721.  
  1722. /* C O N S T A _ M T  --  Start the console asynch read task */
  1723.  
  1724. consta_mt() {
  1725.     if ((con_reads_mt == 0)      /* Not already running */
  1726.      && (mtask(conint_mt, CONINT_STACK, CONINT_TSK, CONINT_PRI) != 0))
  1727.         perror("consta_mt: Can't initiate task:");
  1728. }
  1729. #endif datageneral
  1730.  
  1731. /* Private buffer for myread() and its companions.  Not for use by anything
  1732.  * else.  ttflui() is allowed to reset them to initial values.  ttchk() is
  1733.  * allowed to read my_count.
  1734.  *
  1735.  * my_item is an index into mybuf[].  Increment it *before* reading mybuf[].
  1736.  *
  1737.  * A global parity mask variable could be useful too.  We could use it to
  1738.  * let myread() strip the parity on its own, instead of stripping sign
  1739.  * bits as it does now.
  1740.  */
  1741.  
  1742. #define MYBUFLEN 256
  1743. #define PEEKTYPE long
  1744. static CHAR mybuf[MYBUFLEN];            /* Buffer, including push back */
  1745. static int my_count = 0;                /* Number of chars still in mybuf */
  1746. static int my_item = -1;                /* Last index read from mybuf[] */
  1747.  
  1748. /* myread() -- Efficient read of one character from communications line.
  1749.  *
  1750.  * Uses a private buffer to minimize the number of expensive read() system
  1751.  * calls.  Essentially performs the equivalent of read() of 1 character, which
  1752.  * is then returned.  By reading all available input from the system buffers
  1753.  * to the private buffer in one chunk, and then working from this buffer, the
  1754.  * number of system calls is reduced in any case where more than one character
  1755.  * arrives during the processing of the previous chunk, for instance high
  1756.  * baud rates or network type connections where input arrives in packets.
  1757.  * If the time needed for a read() system call approaches the time for more
  1758.  * than one character to arrive, then this mechanism automatically compensates
  1759.  * for that by performing bigger read()s less frequently.  If the system load
  1760.  * is high, the same mechanism compensates for that too.
  1761.  *
  1762.  * myread() is a macro that returns the next character from the buffer.  If the
  1763.  * buffer is empty, mygetbuf() is called.  See mygetbuf() for possible error
  1764.  * returns.
  1765.  *
  1766.  * This should be efficient enough for any one-character-at-a-time loops.
  1767.  * For even better efficiency you might use memcpy()/bcopy() or such between
  1768.  * buffers (since they are often better optimized for copying), but it may not
  1769.  * be worth it if you have to take an extra pass over the buffer to strip
  1770.  * parity and check for CTRL-C anyway.
  1771.  *
  1772.  * Note that if you have been using myread() from another program module, you
  1773.  * may have some trouble accessing this macro version and the private variables
  1774.  * it uses.  In that case, just add a function in this module, that invokes the
  1775.  * macro.
  1776.  */
  1777.  
  1778. #define myread()  (--my_count < 0 ? mygetbuf() : 255 & (int)mybuf[++my_item])
  1779.  
  1780.  
  1781. /* not used right now */
  1782. /*
  1783. myunrd(ch) CHAR ch; {
  1784.     ungotn = ch;
  1785. }
  1786. */
  1787.  
  1788. /* mygetbuf() -- Fill buffer for myread() and return first character.
  1789.  *
  1790.  * This function is what myread() uses when it can't get the next character
  1791.  * directly from its buffer.  First, it calls a system dependent myfillbuf()
  1792.  * to read at least one new character into the buffer, and then it returns
  1793.  * the first character just as myread() would have done.  This function also
  1794.  * is responsible for all error conditions that myread() can indicate.
  1795.  *
  1796.  * Returns: When OK     => a positive character, 0 or greater.
  1797.  *          When EOF    => -2.
  1798.  *          When error  => -3, error code in errno.
  1799.  *
  1800.  * Older myread()s additionally returned -1 to indicate that there was nothing
  1801.  * to read, upon which the caller would call myread() again until it got
  1802.  * something.  The new myread()/mygetbuf() always gets something.  If it
  1803.  * doesn't, then make it do so!  Any program that actually depends on the old
  1804.  * behaviour will break.
  1805.  *
  1806.  * The older version also used to return -2 both for EOF and other errors,
  1807.  * and used to set errno to 9999 on EOF.  The errno stuff is gone, EOF and
  1808.  * other errors now return different results, although Kermit currently never
  1809.  * checks to see which it was.  It just disconnects in both cases.
  1810.  *
  1811.  * Kermit lets the user use the quit key to perform some special commands
  1812.  * during file transfer.  This causes read(), and thus also mygetbuf(), to
  1813.  * finish without reading anything and return the EINTR error.  This should
  1814.  * be checked by the caller.  Mygetbuf() could retry the read() on EINTR,
  1815.  * but if there is nothing to read, this could delay Kermit's reaction to
  1816.  * the command, and make Kermit appear unresponsive.
  1817.  *
  1818.  * The debug() call should be removed for optimum performance.
  1819.  */
  1820. int
  1821. mygetbuf() {
  1822.     my_count = myfillbuf();                     
  1823.     /* debug(F101, "myfillbuf read", "", my_count); */
  1824.     if (my_count <= 0)
  1825.       return(my_count < 0 ? -3 : -2);
  1826.     --my_count;
  1827.     return(255 & (int)mybuf[my_item = 0]);
  1828. }
  1829.  
  1830. /* myfillbuf():
  1831.  * System-dependent read() into mybuf[], as many characters as possible.
  1832.  *
  1833.  * Returns: OK => number of characters read, always more than zero.
  1834.  *          EOF => 0
  1835.  *          Error => -1, error code in errno.
  1836.  *
  1837.  * If there is input available in the system's buffers, all of it should be
  1838.  * read into mybuf[] and the function return immediately.  If no input is
  1839.  * available, it should wait for a character to arrive, and return with that
  1840.  * one in mybuf[] as soon as possible.  It may wait somewhat past the first
  1841.  * character, but be aware that any such delay lengthens the packet turnaround
  1842.  * time during kermit file transfers.  Should never return with zero characters
  1843.  * unless EOF or irrecoverable read error.
  1844.  *
  1845.  * Correct functioning depends on the correct tty parameters being used.
  1846.  * Better control of current parameters is required than may have been the
  1847.  * case in older Kermit releases.  For instance, O_NDELAY (or equivalent) can
  1848.  * no longer be sometimes off and sometimes on like it used to, unless a
  1849.  * special myfillbuf() is written to handle that.  Otherwise the ordinary
  1850.  * myfillbuf()s may think they have come to EOF.
  1851.  *
  1852.  * If your system has a facility to directly perform the functioning of
  1853.  * myfillbuf(), then use it.  If the system can tell you how many characters
  1854.  * are available in its buffers, then read that amount (but not less than 1).
  1855.  * If the system can return a special indication when you try to read without
  1856.  * anything to read, while allowing you to read all there is when there is
  1857.  * something, you may loop until there is something to read, but probably that
  1858.  * is not good for the system load.
  1859.  */
  1860. int
  1861. myfillbuf() {
  1862.     int n;
  1863.     int retry_count = 5;                        /* max # of retries */
  1864.  
  1865. #ifdef NETCONN
  1866.     if (netconn) {
  1867.         n = read(ttyfd, mybuf, sizeof(mybuf));
  1868.         if (n <= 0)
  1869.       debug(F101,"myfillbuf() got error reading from network, ","",n);
  1870.         return(n);
  1871.     } else {                                      /* console read */
  1872. #endif /* NETCONN */
  1873.         while (1) {
  1874.             n = dgncinb(ttyfd, mybuf, sizeof(mybuf));
  1875.             if (n > 0) {
  1876.                 return(n);
  1877.             }
  1878.             if ((n == -EROVR) || (n == -1) || (n == -2) || (n == 0)) {
  1879.                 if (n == -EROVR)
  1880.                     debug(F101,"myfillbuf() got data overrun ind., ","",-n);
  1881.                 else if (n == -1)
  1882.                     debug(F101,"myfillbuf() got EOF ind., ","",n);
  1883.                 else if (n == -2)
  1884.                     debug(F101,"myfillbuf() got device timeout ind., ","",n);
  1885.                 else
  1886.                     debug(F101,"myfillbuf() got zero characters, ","",n);
  1887.                 if (--retry_count > 0) {
  1888.                     debug(F101,"myfillbuf() tries remaining, ","",retry_count);
  1889.                     sleep(1);   /* keep trying on data over- */
  1890.                     continue;   /* run, EOF (-1), timeout (-2) & 0 */
  1891.                 } 
  1892.             } else if (n < -2)                  /* VS errors complimented */
  1893.                 debug(F101,"myfillbuf() got AOS/VS error ","",-n);
  1894.             if (n == -1)                        /* EOF is -1, but caller */
  1895.                 n = 0;                          /* wants it to be zero   */
  1896.             else n = -1;                        /* all others -1 */
  1897.             return(n);
  1898.         }
  1899. #ifdef NETCONN
  1900.     }
  1901. #endif /* NETCONN */
  1902. } 
  1903.  
  1904. /*  T T C H K  --  Tell how many characters are waiting in tty input buffer  */
  1905.  
  1906. ttchk() {
  1907.     return(in_chk(ttyfd));
  1908. }
  1909.  
  1910. /*  T T F L U I  --  Flush tty input buffer */
  1911.  
  1912. ttflui() {
  1913.     int ffd;
  1914.  
  1915. #ifndef UXIII
  1916.     long n;
  1917. #endif
  1918.  
  1919. #ifdef TTLEBUF
  1920.     ttpush = -1;            /* Clear the peek-ahead char */
  1921.     while (le_data && (le_inbuf() > 0)) {
  1922.         CHAR ch = '\0';
  1923.         if (le_getchar(&ch) > 0) {
  1924.             debug(F101,"ttflui le_inbuf ch","",ch);
  1925.         }
  1926.     }
  1927. #endif /* TTLEBUF */
  1928.  
  1929.     my_count = 0;                       /* Initialize myread() stuff */
  1930.     my_item = -1;
  1931.  
  1932. #ifdef NETCONN
  1933.     if (netconn) return(netflui());
  1934. #endif /* NETCONN */
  1935.  
  1936.     ffd = xlocal ? ttyfd : 0;           /* If not local, use stdin */
  1937.     debug(F101,"ttflui xlocal","",xlocal);
  1938.     debug(F101,"ttflui ttyfd","",ttyfd);
  1939.     debug(F101,"ttflui ffd","",ffd);
  1940.  
  1941.     if (ffd < 0) return(-1);            /* Not open. */
  1942.     
  1943.  
  1944. #ifdef UXIII
  1945. #ifdef datageneral
  1946.     /* Since $ESGT is turned on in the sys_read packets, there is never a need
  1947.      * to flush the input buffer -- the system automatically does it each time
  1948.      * a read is issued.
  1949.      */
  1950. #endif
  1951. #endif
  1952.  
  1953.     return(0);
  1954. }
  1955.  
  1956. int
  1957. ttfluo() {                              /* Flush output buffer - dummy */
  1958.     return(0);                          /* POSIX is only implementation */
  1959. }                                       /* that needs this */
  1960.  
  1961.  
  1962. /*  T T X I N  --  Get n characters from tty input buffer  */
  1963.  
  1964. /*  Returns number of characters actually gotten, or -1 on failure  */
  1965.  
  1966. /*  Intended for use only when it is known that n characters are actually */
  1967. /*  Available in the input buffer.  */
  1968.  
  1969. ttxin(n,buf) int n; CHAR *buf; {
  1970.     int i = 0, c = -2, x = 0;
  1971.  
  1972. #ifdef TTLEBUF
  1973.     if (ttpush >= 0) {
  1974.         buf[0] = ttpush;        /* Put pushed char in buffer*/
  1975.         ttpush = -1;            /* Clear the push buffer */
  1976.         if (ttchk() > 0)
  1977.       return(ttxin(n-1, &buf[1]) + 1);
  1978.         else 
  1979.       return(1);
  1980.     }
  1981.     if (le_data) {
  1982.         while (le_inbuf() > 0) {
  1983.         if (le_getchar(&buf[i])) {
  1984.                 i++;
  1985.                 n--;
  1986.             }
  1987.         }
  1988.         if (ttchk() > 0)
  1989.       return(ttxin(n,&buf[i])+i);
  1990.         else 
  1991.       return(i);
  1992.     }
  1993. #endif /* TTLEBUF */
  1994.  
  1995.     ttpmsk = (ttprty) ? 0177: 0377;             /* parity stripping mask */
  1996.     debug(F101,"ttxin: n","",n);
  1997.  
  1998.     for( x = 0; (x > -1) && (x < n) && (c = myread()) >= 0; )
  1999.       buf[x++] = c & ttpmsk;
  2000.  
  2001.     debug(F101," x","",x);                      
  2002.     for (c = 0; c < n; c++)
  2003.         buf[c] &= ttpmsk;
  2004.     if (x > 0) buf[x] = '\0';
  2005.     else if (x < 0) x = -1;
  2006.     return(x);
  2007. }
  2008.  
  2009. #define TTOLMAXT 5
  2010.  
  2011. /*  T T O L  --  Similar to "ttinl", but for writing.  */
  2012.  
  2013. ttol(s,n) int n; char *s; {
  2014.     int x,len,tries,outfd;
  2015.  
  2016. #ifdef NETCONN
  2017.     if (netconn) {
  2018.         if (ttyfd < 0) return (-1);
  2019.     } else
  2020. #endif /* NETCONN */
  2021.     if (ttyfdout < 0) return (-1);
  2022.  
  2023.     debug(F101,"ttol n","",n);
  2024.     tries = TTOLMAXT;
  2025.     len = n;
  2026.  
  2027.     while ((n > 0) && (tries-- > 0)) {
  2028.         debug(F101,"ttol try","",TTOLMAXT - tries);
  2029. #ifdef NETCONN
  2030.         if (netconn)
  2031.             x = write(ttyfd,s,n);
  2032.         else
  2033. #endif /* NETCONN */
  2034.         x = dgncoub(ttyfdout,s,n); 
  2035.         if (x == n) {
  2036.             debug(F101,"ttol ok","",x);
  2037.             return(len);
  2038.         } else if (x < 0) {
  2039.             debug(F101,"ttol failed","",lasterror());
  2040.             return(-1);
  2041.         } else {
  2042.             debug(F101,"ttol partial","",x);
  2043.             s += x;                     /* update buffer address for next */
  2044.             n -= x;                     /* update length for next read */
  2045.             if (x > 0) msleep(100);
  2046.         }
  2047.     }
  2048.     return((n < 1) ? len : -1);
  2049. }
  2050.  
  2051.  
  2052. /*  T T O C  --  Output a character to the communication line  */
  2053. /*
  2054.  This function should only be used for interactive, character-mode operations,
  2055.  like terminal connection, script execution, dialer i/o, where the overhead
  2056.  of the signals and alarms does not create a bottleneck.
  2057. */
  2058.  
  2059. ttoc(c) char c; {
  2060.     int x,xx;
  2061. #define TTOC_TMO 15
  2062.     c &= 0xff;
  2063.     /* debug(F101,"ttoc","",(CHAR) c); */
  2064. #ifdef NETCONN
  2065.     if (netconn) {
  2066.         if (ttyfd < 0) return(-1);
  2067.     } else
  2068. #endif /* NETCONN */
  2069.     if (ttyfdout < 0) return(-1);  /* Not open. */
  2070.     saval = signal(SIGALRM,timerh);
  2071.     xx = alarm(TTOC_TMO);
  2072.     if (xx < 0) xx = 0;                 /* Save old alarm value. */
  2073.     if (setjmp(sjbuf)) {
  2074.         ttimoff();
  2075.         if (xx - TTOC_TMO > 0) alarm(xx - TTOC_TMO); /* Restore previous one */
  2076. #ifdef NETCONN
  2077.         if (!netconn) {
  2078. #endif /* NETCONN */
  2079.             /* debug(F100,"ttoc timeout","",0); */
  2080.             if (ttflow == FLO_XONX) {
  2081.                 debug(F100,"ttoc flow","",ttflow);
  2082.                 /* issue clear device */
  2083.             }
  2084. #ifdef NETCONN
  2085.         }
  2086. #endif /* NETCONN */
  2087.         return(-1);
  2088.     } else {
  2089. #ifdef NETCONN
  2090.         if (netconn)                    /* use ttyfd for tcp connections */
  2091.             x = write(ttyfd,&c,1);
  2092.         else                            /* ttyfdout for local connections */
  2093. #endif /* NETCONN */
  2094.             x = (dgncoub(ttyfdout,&c,1)); 
  2095.         if (x != 1) {
  2096.             ttimoff();                  /* If error, turn off timer, */
  2097.             alarm(xx);
  2098.             debug(F101,"ttoc error x","",x);
  2099.             debug(F101,"ttoc last error","",lasterror());
  2100.             return (-1);
  2101.         }
  2102.     }
  2103.     ttimoff();
  2104.     alarm(xx);
  2105.     return (0);
  2106. }
  2107.  
  2108. /*  T T I N L  --  Read a record (up to break character) from comm line.  */
  2109. /*
  2110.  Reads up to "max" characters from the communication line, terminating on:
  2111.  
  2112.     (a) the packet length field if the "turn" argument is zero, or
  2113.     (b) on the packet-end character (eol) if the "turn" argument is nonzero
  2114.  
  2115.   and returns the number of characters read upon success, or if "max" was
  2116.   exceeded or the timeout interval expired before (a) or (b), returns -1.
  2117.  
  2118.   The characters that were input are copied into "dest" with their parity bits
  2119.   stripped if parity was selected.  Returns the number of characters read.
  2120.   Characters after the eol are available upon the next call to this function.
  2121.  
  2122.   The idea is to minimize the number of system calls per packet, and also to
  2123.   minimize timeouts.  This function is the inner loop of the program and must
  2124.   be as efficient as possible.  The current strategy is to use myread().
  2125.  
  2126.   WARNING: this function calls parchk(), which is defined in another module.
  2127.   Normally, ckutio.c does not depend on code from any other module, but there
  2128.   is an exception in this case because all the other ck?tio.c modules also
  2129.   need to call parchk(), so it's better to have it defined in a common place.
  2130. */
  2131.  
  2132. /* ENH -- assume PARSENSE */
  2133.  
  2134. #ifdef CTRLC
  2135. #undef CTRLC
  2136. #endif /* CTRLC */
  2137. #define CTRLC '\03'
  2138.  
  2139. int
  2140. ttinl(dest,max,timo,eol,start,turn) int max,timo,turn; CHAR *dest,eol,start; {
  2141.     int pktlen = -1;
  2142.     int j;
  2143.     CHAR ch;
  2144.     int lplen = 0;
  2145.     int havelen = 0;
  2146.  
  2147.     if (ttyfd < 0) return(-1);          /* Not open. */
  2148.     if (turn)
  2149.         debug(F101,"ttinl read until eol, turn","",turn);
  2150.     else
  2151.         debug(F101,"ttinl read packet-length characters, turn","",turn);
  2152.     debug(F101,"ttinl max","",max);
  2153.     debug(F101,"ttinl timo","",timo);
  2154.  
  2155.     *dest = '\0';                       /* Clear destination buffer */
  2156.  
  2157.     if (timo < 0) timo = 0;
  2158.    
  2159.     if (timo) {                         /* Don't time out if timo == 0 */
  2160.         saval = signal(SIGALRM,timerh); /* Enable timer interrupt */
  2161.         alarm(timo);                    /* Set it. */
  2162.     }
  2163.     if (setjmp(sjbuf)) {                /* Timer went off? */
  2164.         debug(F100,"ttinl timout","",0); /* Get here on timeout. */
  2165.         debug(F110," with",(char *) dest,0);
  2166.         ttimoff();                      /* Turn off timer */
  2167.         return(-1);                     /* and return error code. */
  2168.     } else {
  2169.         int i, m, n;
  2170.         int ccn = 0;
  2171.         int flag = 0;
  2172.  
  2173.         debug(F000,"ttinl start","",start);
  2174.         flag = 0;                       /* Start of packet flag */
  2175.  
  2176.         ttpmsk = m = (ttprty) ? 0177 : 0377; /* Set parity stripping mask. */
  2177.  
  2178. /* Now read into destination, stripping parity and looking for the */
  2179. /* the packet terminator, and also for two Ctrl-C's typed in a row. */
  2180.  
  2181.         i = 0;                          /* Destination index */
  2182.         debug(F101,"ttinl eol","",eol);
  2183.         while (i < max-1) {
  2184.             /* debug(F101,"ttinl i","",i); */
  2185.             if ((n = myread()) < 0) {
  2186.                 debug(F101,"ttinl myread failure, n","",n);
  2187.                 debug(F101,"ttinl myread errno,","",errno);
  2188.                 /* Don't let EINTR break packets. */
  2189.                 if (n == -3 && errno == EINTR && i > 0) {
  2190.                     debug(F101,"ttinl myread i","",i);
  2191.                     continue;
  2192.                 }
  2193.                 break;
  2194.             }
  2195.             debug(F101,"ttinl char","", (n & ttpmsk)); 
  2196. /*
  2197.   Figure out what the length is supposed to be in case the packet
  2198.   has no terminator (as with Honeywell GCOS-8 Kermit).
  2199. */
  2200. #ifndef xunchar
  2201. #define xunchar(ch) (((ch) - 32 ) & 0xFF )      /* Character to number */
  2202. #endif /* xunchar */
  2203.             if ((flag == 0) && ((n & 0x7f) == start)) flag = 1;
  2204.             if (flag) dest[i++] = n & ttpmsk;
  2205. /*
  2206.   If we have not been instructed to wait for a turnaround character, we
  2207.   can go by the packet length field.  If turn != 0, we must wait for the
  2208.   end of line (eol) character before returning.
  2209. */
  2210.             if (i == 2) {
  2211.                 pktlen = xunchar(dest[1] & 0x7f);
  2212.                 havelen = (pktlen > 1);
  2213.                 debug(F101,"ttinl length","",pktlen);
  2214.             } else if (i == 5 && pktlen == 0) {
  2215.                 lplen = xunchar(dest[4] & 0x7f);
  2216.             } else if (i == 6 && pktlen == 0) {
  2217.                 pktlen = lplen * 95 + xunchar(dest[5] & 0x7f) + 5;
  2218.                 havelen = 1;
  2219.                 debug(F101,"ttinl length","",pktlen);
  2220.             }
  2221.         /* Check cancellation */
  2222.             if (!xlocal && xfrcan && ((n & ttpmsk) == xfrchr)) {
  2223.                 if (++ccn >= xfrnum) {    /* If xfrnum in a row, bail out. */
  2224.                     if (timo) {         /* Clear timer. */
  2225.                         ttimoff();
  2226.                     }
  2227.                     fprintf(stderr,"^C...\r\n"); /* Echo Ctrl-C */
  2228.                     return(-2);
  2229.                 }
  2230.             } else ccn = 0;             /* Not ^C, so reset ^C counter, */
  2231.             if (flag == 0) {
  2232.                 debug(F101,"ttinl skipping","",n);
  2233.                 continue;
  2234.             }
  2235.  
  2236.     /* Check for end of packet */
  2237.  
  2238.             if (((n & 0x7f) == eol) || (!turn && havelen && (i > pktlen+1))) {
  2239.                 if ((n & 0x7f) != eol) {
  2240.                     debug(F101,"ttinl EOP length","",pktlen);
  2241.                     debug(F101,"ttinl i","",i);
  2242.                 } else debug(F101,"ttinl got eol","",eol);
  2243.                 dest[i] = '\0';         /* Terminate the string, */
  2244.  
  2245. /* Here's where we actually check and adjust the parity. */
  2246. /* The major flaw here is if parity is NONE (ttprty = 0) and the packets */
  2247. /* really do have no parity, then parchk() is called for every packet. */
  2248. /* In practice, this doesn't really harm efficiency noticably, but it would */
  2249. /* be better if ttinl() had a way of knowing to stop doing this once a */
  2250. /* particular file transfer had been started and checked. */
  2251.                 if (ttpflg++ == 0 && ttprty == 0) {
  2252.                     if ((ttprty = parchk(dest,start,i)) > 0) {
  2253.                         int j;
  2254.                         debug(F101,"ttinl senses parity","",ttprty);
  2255.                         debug(F110,"ttinl packet before",dest,0);
  2256.                         ttpmsk = 0x7f;
  2257.                         for (j = 0; j < i; j++)
  2258.                           dest[j] &= 0x7f;      /* Strip parity from packet */
  2259.                         debug(F110,"ttinl packet after ",dest,0);
  2260.                     } else debug(F101,"parchk","",ttprty);
  2261.                 }
  2262.                 if (timo) {                     /* Turn off timer. */
  2263.                     ttimoff();
  2264.                 }
  2265.                 debug(F111,"ttinl got", dest,i);
  2266.                 return(i);
  2267.             }
  2268.         }                               /* end of while() */
  2269.         ttimoff();
  2270.         return(-1);
  2271.     }
  2272. } 
  2273.  
  2274. /*  T T I N C --  Read a character from the communication line  */
  2275. /*
  2276.  On success, returns the character that was read, >= 0.
  2277.  On failure, returns -1 or other negative myread error code.
  2278. */
  2279.  
  2280. int
  2281. ttinc(timo) int timo; {
  2282.     int n = 0;
  2283.     CHAR ch = 0;
  2284.  
  2285.     if (ttyfd < 0)            /* Not open. */
  2286.       return(-2);
  2287.  
  2288. #ifdef TTLEBUF
  2289.     if (ttpush >= 0) {
  2290.         debug(F111,"ttinc","ttpush",ttpush);
  2291.         ch = ttpush;
  2292.         ttpush = -1;
  2293.         return(ch);
  2294.     }
  2295.     if (le_data) {
  2296.         if (le_getchar(&ch) > 0) {
  2297.             debug(F111,"ttinc le_getchar","ch",ch);
  2298.             return(ch);
  2299.         }
  2300.     }
  2301. #endif /* TTLEBUF */
  2302.  
  2303.     if (timo <= 0) {                    /* Untimed. */
  2304.         /* comm line failure returns -1 thru myread, so no &= 0377 */
  2305.         n = myread();                   /* Wait for a character... */
  2306.         /* debug(F101,"ttinc n","",n); */
  2307.         return(n < 0 ? n : n & ttpmsk);
  2308.     } else {
  2309.         int xx;
  2310.         saval = signal(SIGALRM,timerh); /* Timed, set up timer. */
  2311.         xx = alarm(timo);               /* calls because I'm getting errors  */
  2312.         if (setjmp(sjbuf))              /* about these signal calls -- " the */
  2313.             n = -1;                     /* destination of a non-local GOTO is*/
  2314.         else {                          /* an inactive block" */
  2315.             n = myread();               /* If managing own buffer... */
  2316.             /* debug(F101,"ttinc myread","",n); */
  2317.         }
  2318.         ttimoff();
  2319. #ifdef NETCONN
  2320.         if (netconn) {
  2321.             if (n == -2) {              /* read() returns 0 */
  2322.                 netclos();              /* on network read failure */
  2323.                 netconn = 0;            /* ENH - deleted errno = ENOTCON */
  2324.             }
  2325.         }
  2326. #endif  /* NETCONN */
  2327.         return( (n < 0) ? n : (n & ttpmsk) ); /* Return masked char or neg. */
  2328.     }
  2329. }
  2330.  
  2331. /*  T T S N D B  --  Send a BREAK signal  */
  2332.  
  2333. ttsndb() {
  2334.     int x; long n; char spd;            /* In VS, the duration of the break */
  2335.                                         /* is until next write() or charac- */
  2336.     debug(F101,"ttsndb ttyfd","",ttyfd); /* teristics change                */
  2337.     if (ttyfd < 0) return(-1);          /* Not open. */
  2338.  
  2339. #ifdef NETCONN
  2340.     if (netconn)                        /* Send network BREAK */
  2341.       return(netbreak());
  2342. #endif /* NETCONN */
  2343.  
  2344. #ifdef UXIII
  2345. #ifdef datageneral
  2346.     if (sys_clrdv(channel(ttyfdout),1<<31,$CDSBRK)) {   /* Send a BREAK */
  2347.         perror("Can't send BREAK");
  2348.         return(-1);
  2349.     }
  2350.     return(0);
  2351. #endif
  2352. #endif
  2353. }
  2354.  
  2355. /* T T S N D L B  --  Send a "long" BREAK signal */
  2356.  
  2357. ttsndlb() {             /* In VS, they're long by default -- see ttsndb() */
  2358.     return(ttsndb());
  2359. }
  2360.  
  2361.  
  2362. /*  M S L E E P  --  Millisecond version of sleep().  */
  2363.  
  2364. /*
  2365.  Intended only for small intervals.  For big ones, just use sleep().
  2366. */
  2367.  
  2368. msleep(m) int m; {
  2369.  
  2370. #ifdef UXIII
  2371. #define CLOCK_TICK 17                   /* 1/60 sec */
  2372.     extern long times();
  2373.     long t1, t2, tarray[4];
  2374.     int t3;
  2375.  
  2376.     if (m <= 0) return(0);
  2377.     if ((t1 = times(tarray)) < 0) return(-1);
  2378.     while (1) {
  2379.         if ((t2 = times(tarray)) < 0) return(-1);
  2380.         t3 = ((int)(t2 - t1)) * CLOCK_TICK;
  2381.         if (t3 > m) return(t3);
  2382.     }
  2383. #endif
  2384. }
  2385.  
  2386.  
  2387. /*  R T I M E R --  Reset elapsed time counter  */
  2388.  
  2389. rtimer() {
  2390.     tcount = time( (long *) 0 );
  2391. }
  2392.  
  2393.  
  2394. /*  G T I M E R --  Get current value of elapsed time counter in seconds  */
  2395.  
  2396. gtimer() {
  2397.     int x;
  2398.     x = (int) (time( (long *) 0 ) - tcount);
  2399.     debug(F101,"gtimer","",x);
  2400.     /* rtimer(); */
  2401.     return( (x < 0) ? 0 : x );
  2402. }
  2403.  
  2404.  
  2405. /*  Z T I M E  --  Return date/time string  */
  2406.  
  2407. ztime(s) char **s; {
  2408.  
  2409. #ifdef UXIII
  2410.     extern long time();                 /* Sys III/V way to do it */
  2411.     char *ctime();
  2412.     long clock_storage;
  2413.  
  2414.     clock_storage = time( (long *) 0 );
  2415.     *s = ctime( &clock_storage );
  2416. #endif
  2417. }
  2418.  
  2419.  
  2420. /*  C O N G M  --  Get console terminal modes.  */
  2421.  
  2422. /*
  2423.  Saves current console mode, and establishes variables for switching between 
  2424.  current (presumably normal) mode and other modes.
  2425. */
  2426.  
  2427. congm() {
  2428.     if (backgrd || !isatty(0)) {  /* only for real ttys */
  2429.         cgmf = -1;
  2430.         return (-1);            /* it used to return a zero for this case */
  2431.     }
  2432.      ioctl(0,TCGETA,&ccold);
  2433.      ioctl(0,TCGETA,&cccbrk);
  2434.      ioctl(0,TCGETA,&ccraw);
  2435.      /* For DG, also get the tty extended device characteristics. */
  2436.      sys_gechr( channel(0), (1<<31)|$CLMAX, ch_ccold);
  2437.      sys_gechr( channel(0), (1<<31)|$CLMAX, ch_ccraw);
  2438.      sys_gechr( channel(0), (1<<31)|$CLMAX, ch_ccbrk);
  2439.      cgmf = 1;                          /* Flag that we got them. */
  2440. }
  2441.  
  2442.  
  2443.  
  2444. /*  C O N C B --  Put console in cbreak mode.  */
  2445.  
  2446. /*  Returns 0 if ok, -1 if not  */
  2447.  
  2448. concb(esc) char esc; {
  2449.     int x;
  2450.     debug(F101,"concb backgrd","",backgrd);
  2451.     if (!isatty(0)) return(0);          /* only for real ttys */
  2452.     debug(F100,"concb isatty","",0);
  2453.     if (backgrd) return(0);
  2454.     if (cgmf == 0) congm();             /* Get modes if necessary. */
  2455.     escchr = esc;                       /* Make this available to other fns */
  2456.     ckxech = 1;                         /* Program can echo characters */
  2457. #ifdef datageneral
  2458.     cccbrk.c_lflag |= CBREAK;
  2459. #endif
  2460.     cccbrk.c_lflag &= ~(ICANON|ECHO);
  2461.     cccbrk.c_cc[0] = 003;               /* interrupt char is control-c */
  2462.     cccbrk.c_cc[1] = escchr;            /* escape during packet modes */
  2463.     cccbrk.c_cc[4] = 1;
  2464.     cccbrk.c_cc[5] = 1;
  2465.     x = ioctl(0,TCSETAW,&cccbrk);       /* set new modes . */
  2466. #ifdef datageneral
  2467.     if (sys_gechr( channel(0), (1<<31)|$CLMAX, ch_ccbrk)) 
  2468.          { perror("concb: gechr: "); return(-1); }
  2469. #endif
  2470. #ifndef NOSETBUF
  2471.     if (x > -1) setbuf(stdout,NULL);    /* Make console unbuffered. */
  2472. #endif /* NOSETBUF */
  2473.     return(x);
  2474. }
  2475.  
  2476. /*  C O N B I N  --  Put console in binary mode  */
  2477.  
  2478. /*  Returns 0 if ok, -1 if not  */
  2479.  
  2480. conbin(esc) char esc; {
  2481. int filedes,filedes2;
  2482.  
  2483.     if (!isatty(0)) return(0);          /* only for real ttys */
  2484.     if (backgrd) return;                /* ... */
  2485.     if (cgmf == 0) congm();             /* Get modes if necessary. */
  2486.     escchr = esc;                       /* Make this available to other fns */
  2487.     ckxech = 1;                         /* Program can echo characters */
  2488.     ccraw.c_lflag &= ~(ISIG|ICANON|ECHO);
  2489.     ccraw.c_iflag |= (BRKINT|IGNPAR);
  2490.     ccraw.c_iflag &= ~(IGNBRK|INLCR|IGNCR|ICRNL|IUCLC|IXON|IXANY|IXOFF
  2491.                         |INPCK|ISTRIP);
  2492.     ccraw.c_oflag &= ~OPOST;
  2493.  
  2494. /*** Kermit used to put the console in 8-bit raw mode, but some users have
  2495.  *** pointed out that this should not be done, since some sites actually
  2496.  *** use terminals with parity settings on their Unix systems, and if we
  2497.  *** override the current settings and stop doing parity, then their terminals
  2498.  *** will display blotches for characters whose parity is wrong.  Therefore,
  2499.  *** the following two lines are commented out (Larry Afrin, Clemson U):
  2500.  ***
  2501.  ***   ccraw.c_cflag &= ~(PARENB|CSIZE);
  2502.  ***   ccraw.c_cflag |= (CS8|CREAD);
  2503.  ***
  2504.  *** Sys III/V sites that have trouble with this can restore these lines.
  2505.  ***/
  2506.     ccraw.c_cc[4] = 1;
  2507.     ccraw.c_cc[5] = 1;
  2508. #ifdef datageneral
  2509.     if (ioctl(0,TCSETAW,&ccraw)) return(-1);    /* set new modes . */
  2510.     if (sys_gechr( channel(0), (1<<31)|$CLMAX, ch_ccraw))
  2511.          { perror("conbin: gechr: "); return(-1); }
  2512.     return(0);
  2513. #else
  2514.     return(ioctl(0,TCSETAW,&ccraw) );   /* set new modes . */
  2515. #endif
  2516. }
  2517.  
  2518.  
  2519. /*  C O N R E S  --  Restore the console terminal  */
  2520.  
  2521. conres() {
  2522.     if (cgmf == 0) return(0);           /* Don't do anything if modes */
  2523.     if (!isatty(0)) return(0);          /* only for real ttys */
  2524.     if (backgrd) return;                /* ... */
  2525. #ifdef datageneral
  2526.     if (timocon) 
  2527.          /* Timeouts are set, so un-set them. */
  2528.          resto(channel(0));
  2529. #endif
  2530.     ckxech = 0;                         /* System should echo chars */
  2531. #ifdef datageneral
  2532.     if (ioctl(0,TCSETAW,&ccold)) return(-1);    /* set new modes . */
  2533.     if (sys_sechr( channel(0), (1<<31)|$CLMAX, ch_ccold))
  2534.          { perror("conres: sechr "); return(-1); }
  2535.     return(0);
  2536. #else
  2537.     return(ioctl(0,TCSETAW,&ccold));
  2538. #endif
  2539. }
  2540.  
  2541.  
  2542. /*  C O N O C  --  Output a character to the console terminal  */
  2543.  
  2544. conoc(c) char c; {
  2545.     write(1,&c,1);
  2546. }
  2547.  
  2548. /*  C O N X O  --  Write x characters to the console terminal  */
  2549.  
  2550. conxo(x,s) char *s; int x; {
  2551.     write(1,s,x);
  2552. }
  2553.  
  2554. /*  C O N O L  --  Write a line to the console terminal  */
  2555.  
  2556. conol(s) char *s; {
  2557.     int len;
  2558.     len = strlen(s);
  2559.     write(1,s,len);
  2560. }
  2561.  
  2562. /*  C O N O L A  --  Write an array of lines to the console terminal */
  2563.  
  2564. conola(s) char *s[]; {
  2565.     int i;
  2566.     for (i=0 ; *s[i] ; i++) conol(s[i]);
  2567. }
  2568.  
  2569. /*  C O N O L L  --  Output a string followed by CRLF  */
  2570.  
  2571. conoll(s) char *s; {
  2572.     conol(s);
  2573.     write(1,"\r\n",2);
  2574. }
  2575.  
  2576. /* Input buffer checking */
  2577.  
  2578. #ifdef SELECT
  2579. /*
  2580.   NOTE: This can be compiled and linked OK with SELECT defined
  2581.   but it doesn't work at all.  Anybody who cares and knows how
  2582.   to fix it, feel free.  The select() call always returns -1.
  2583. */
  2584. #include <:usr:include:sys:vs_tcp_types.h>
  2585. #include <:usr:include:sys:vs_tcp_time.h>
  2586. #endif /* SELECT */
  2587.  
  2588. in_chk(fd) int fd; {
  2589.     int x, n = 0;
  2590.  
  2591. #ifdef SELECT
  2592.     struct timeval tv;
  2593.     fd_set rfds;
  2594. #endif /* SELECT */
  2595.  
  2596. #ifdef TTLEBUF
  2597.     ttpush = -1;            /* Clear the peek-ahead char */
  2598.     while (le_data && (le_inbuf() > 0)) {
  2599.         CHAR ch = '\0';
  2600.         if (le_getchar(&ch) > 0) {
  2601.             debug(F101,"ttflui le_inbuf ch","",ch);
  2602.         }
  2603.     }
  2604. #endif /* TTLEBUF */
  2605.  
  2606.     if (fd < 0) return(0);
  2607.  
  2608. #ifdef SELECT
  2609.     FD_ZERO(&rfds);            /* Initialize them */
  2610.     FD_SET(fd,&rfds);            /* We want to look at this fd */
  2611.     tv.tv_sec = tv.tv_usec = 0L;    /* A 0-valued timeval structure */
  2612.     n = select(FD_SETSIZE, &rfds, (fd_set *)0, (fd_set *)0, &tv);
  2613.     debug(F101,"in_chk select n","",n);
  2614. #endif /* SELECT */
  2615.     if (my_count > 0)
  2616.       n += my_count;
  2617.     debug(F101,"ttchk chars available, ","",n);
  2618.     return(n);
  2619. }
  2620.  
  2621. /*  C O N C H K  --  Return how many characters available at console  */
  2622.  
  2623. conchk() {
  2624.     int x; long n;
  2625.     if (backgrd)            /* There is no typeahead in batch */
  2626.       return;
  2627.     return(in_chk(0));
  2628. }
  2629.  
  2630.  
  2631. #ifdef datageneral
  2632.  
  2633. /* D G N C O U B -- Output len characters to the file number filenum */
  2634.  
  2635. dgncoub(filenum,chs,len) int filenum, len; char *chs; 
  2636. {
  2637.      int ac2,err;
  2638.  
  2639.      if (len == 0) return(0);
  2640.  
  2641.      if (filenum == ttyfdout) {
  2642.           xout_parms.ibad = chs;
  2643.           xout_parms.ircl = len;
  2644.           ac2 = &xout_parms;
  2645.      } else {
  2646.           w_io_parms.ich = channel(filenum);
  2647.           w_io_parms.ibad = chs;
  2648.           w_io_parms.ircl = len;
  2649.           ac2 = &w_io_parms;
  2650.      }
  2651.      
  2652.      if ((err = sys_write(ac2)) == 0)
  2653.          return(((P_NIO_EX *) ac2)->irlr);  /* ENH - change to return length */
  2654.      if ( err != ERLTL && err != EREOF ) {
  2655.           perror("dgncoub: sys_write ");
  2656.           return(-err);                     /* ENH - change to return */
  2657.      }                                      /* negative of error code */
  2658.      else return(((P_NIO_EX *) ac2)->irlr);
  2659. }
  2660.  
  2661.  
  2662. /* D G N C I N B -- System level read of len characters from file number 
  2663.    fileno.  The global DG i/o structures are used for this.
  2664.  
  2665.    Return codes:  irlr if data read ok, where irlr=length of data
  2666.                   -1 if EOF
  2667.                   -2 if timeout occured
  2668.                   -err if an AOS/VS error occured, where err is errno
  2669. */                  
  2670.  
  2671. int
  2672. dgncinb(filenum,chs,len) int filenum,len; char *chs; {               
  2673.      int ac2,                       /* I/O parameter address block */
  2674.          err,                       /* Error from sys_read */
  2675.          irlr;                      /* Number of bytes read */
  2676.      int rbe;                       /* Ring buffer empty on ESGT read */
  2677.  
  2678.      if (filenum == ttyfd) {
  2679.           x_io_parms.ibad = chs;
  2680.           x_io_parms.ircl = len;
  2681.           ac2 = (P_NIO_EX *) &x_io_parms;
  2682.           err = sys_read(ac2);
  2683.           irlr = x_io_parms.irlr;
  2684.           if (err == 0) {
  2685.               return(irlr);
  2686.           }
  2687.           rbe = (x_io_parms.etsp == 0) ? 0 : (x_io_scrn.esfc & $ESBE);
  2688.      } else {
  2689.           r_io_parms.ich  = channel(filenum); 
  2690.           r_io_parms.ibad = chs;
  2691.           r_io_parms.ircl = len;
  2692.           ac2 = (P_NIO_EX *) &r_io_parms;
  2693.           err = sys_read(ac2);
  2694.           irlr = r_io_parms.irlr;
  2695.           if (err == 0) {
  2696.               return(irlr);
  2697.           }
  2698.           rbe = (r_io_parms.etsp == 0) ? 0 : (r_io_scrn.esfc & $ESBE);
  2699.      }
  2700.      if ((err != ERLTL) && (err != ERDTO) && (err != EREOF)) {
  2701.      /*
  2702.         NOT line-too-long, timeout, or EOF errors.
  2703.             Don't print error when it is a data overrun.
  2704.          */
  2705.           if (err != EROVR) perror("dgncinb: sys_read error");
  2706.           return(-err);
  2707.      } else {
  2708.           /*
  2709.         If the system read buffer was empty when a screen management
  2710.             packet was supplied, then there is a virtual EOF condition.  
  2711.             So we return an EOF flag in that case (rbe != 0).
  2712.           */
  2713.           if ((err == EREOF) || rbe) return(-1); /* EOF */
  2714.           if (err == ERDTO) 
  2715.         if (irlr <= 0)        /* if no data, */ 
  2716.                   return (-2);        /* return -2 */
  2717.           return(irlr);            /* else chars read */
  2718.      }
  2719. }
  2720. #endif datageneral
  2721.  
  2722. /*  C O N I N C  --  Get a character from the console  */
  2723.  
  2724. coninc(timo) int timo; {
  2725.     int n = 0; char ch;
  2726.  
  2727.     if (timo <= 0) {            /* no timeout specified */
  2728.       while (1) {
  2729.         /* Binary input */
  2730.         n = dgncinb(0,&ch,1);
  2731.         if (n == 0) continue;
  2732.         if (n > 0)
  2733.             return(ch & 0377);                 /* Return the char if read */
  2734.         else {
  2735.             if (lasterror() == EINTR)
  2736.               if (conesc)  {            /* If by SIGQUIT, */
  2737.                  conesc = 0;            /* the conesc variable is set, */
  2738.                  return(escchr);        /* so return the escape character. */
  2739.               } else continue;           /* By other signal, try again. */
  2740.             else if (n == -2) {            /* won't happen unless ?STOM */
  2741.                 debug(F101,"coninc got timeout ","",n);   /* has happened */
  2742.                 continue;
  2743.             } else if (n == -1)                         /* behind our back */
  2744.                 debug(F101,"coninc got eof indication","",n);
  2745.             else if (n < -2)            /* -n = VS error code */
  2746.                 debug(F101,"coninc got AOS/VS error","",-n);
  2747.             return(-1);
  2748.         }
  2749.       }
  2750.     }
  2751.     saval = signal(SIGALRM,timerh);     /* else timeout specified */
  2752.     alarm(timo);
  2753.     if (setjmp(sjbuf)) n = -2;
  2754.     else 
  2755.         n = dgncinb(0, &ch, 1);
  2756.     ttimoff();                          /* Turn off timer */
  2757.     if (n > 0) return(ch & 0377);
  2758.     else {
  2759.         debug(F101, "coninc(timo) n","",n);
  2760.         debug(F101, "coninc(timo) errno","",lasterror());
  2761.         if ((lasterror() == EINTR) && conesc != 0) {
  2762.             conesc = 0;
  2763.             return(escchr);             /* User entered escape character. */
  2764.         } else if (n == -2)                        /* won't happen */
  2765.             debug(F101, "coninc got DEVICE timeout","",n);
  2766.         else if (n == -1)
  2767.             debug(F101,"coninc got eof indication","",n);
  2768.         else if (n < -2)                    /* -n = VS error code */
  2769.             debug(F101,"coninc got AOS/VS error","",-n);
  2770.         return(-1); 
  2771.         }
  2772.  
  2773.                 
  2774. }
  2775.  
  2776. /*  C O N G K S  --  Console Get Keyboard Scancode  */
  2777.  
  2778. #ifndef congks
  2779. /*
  2780.   This function needs to be filled in with the various system-dependent
  2781.   system calls used by SUNOS, NeXT OS, Xenix, Aviion, etc, to read a full
  2782.   keyboard scan code.  For now, it's a dummy.
  2783. */
  2784. int
  2785. congks(timo) int timo; {
  2786.     return(coninc(timo));
  2787. }
  2788. #endif /* congks */
  2789.  
  2790.  
  2791. /* These security routines are here, but they're not used.  There's no */
  2792. /* need for them in the AOS/VS implementation.  When they were here,   */
  2793. /* they caused superuser to be turned off when kermit was started with */
  2794. /* it on.  Seemed to cause problems instead of solve them.       --ENH */
  2795.  
  2796. int
  2797. priv_ini()                                  /* if superu is on, turn off    */
  2798. {
  2799.     int     ac0,ac1,ac2,error;
  2800.  
  2801.     ac0 = ac1 = ac2 = 0;
  2802.  
  2803.     error = sys( $SUSER, &ac0, &ac1, &ac2 );
  2804.     if( ac0 == -1 )                         /* if it's on...                */
  2805.         priv_off();                         /* turn it off                  */
  2806.  
  2807.     return  0;
  2808. }
  2809.  
  2810. int
  2811. priv_on()                                   /* turn superu on               */
  2812. {
  2813.     int     ac0,ac1,ac2,error;
  2814.  
  2815.     ac0 = -1;                               /* turn it on                   */
  2816.     ac1 = ac2 = 0;
  2817.  
  2818.     error = sys( $SUSER, &ac0, &ac1, &ac2 );
  2819.     if( error != NULL )
  2820.         error = -1;                         /* an error                     */
  2821.  
  2822.     return  error;
  2823. }
  2824.  
  2825. int
  2826. priv_off()
  2827. {
  2828.     int     ac0,ac1,ac2;
  2829.  
  2830.     ac0 = 1;                                /* turn it off                  */
  2831.     ac1 = ac2 = 0;
  2832.  
  2833.     return  sys( $SUSER, &ac0, &ac1, &ac2 );
  2834. }
  2835.  
  2836. int
  2837. priv_can()
  2838. {
  2839.     return  priv_off();
  2840. }
  2841.  
  2842. int
  2843. priv_chk()
  2844. {
  2845.     return  priv_off();
  2846. }
  2847.  
  2848. VOID
  2849. ttimoff() {                           /* Turn off any timer interrupts */
  2850.     alarm(0);
  2851.     if (saval)
  2852.       signal(SIGALRM,saval);
  2853.     else
  2854.       signal(SIGALRM,SIG_DFL);
  2855.     saval = NULL;
  2856. }
  2857.  
  2858. /* Similarly, this ctrlc_chk() routine is here, but it's not used. */
  2859.  
  2860. void
  2861. ctrlc_chk(buffer,n) int *buffer; int n; {
  2862. #nolist
  2863. #include <ckcker.h>
  2864. #list
  2865.     extern int local,what;
  2866.     int i;
  2867.     extern SIGTYP trap();
  2868.  
  2869.     debug(F101,"Entering ctrlc_chk -- number of chars in buf","",n);
  2870.     debug(F101,"ctrlc_chk local =","",local);
  2871.     debug(F101,"ctrlc_chk what =","",what);
  2872.     if (what == W_CONNECT)                  /* ignore ^C's in connect mode */
  2873.         return;
  2874.     if (what == W_NOTHING)                  /* don't know what's what here */
  2875.         return;                             /* so ignore ^C in case data   */
  2876.     if ((!local) &&
  2877.         ((what == W_SEND) || (what == W_RECV) || (what == W_REMO)))
  2878.         return;
  2879.     for (i = 0; i < n; i++)                 /* otherwise it's W_SEND, W_RECV */
  2880.                                             /* or W_REMOTE in local mode or  */
  2881.                                             /* W_COMMAND in either mode      */
  2882.         if ((buffer[i] & 0177) == CTRLC) {
  2883.             debug (F101,"Got ^C...","",what);
  2884.             my_count = 0;                   /* clear out buffer */
  2885.             trap(what);                     /* call signal handler */
  2886.         }
  2887. }
  2888.