Home | History | Annotate | Line # | Download | only in telnetd
sys_term.c revision 1.14
      1  1.14   tsarna /*	$NetBSD: sys_term.c,v 1.14 1998/08/29 17:31:56 tsarna Exp $	*/
      2   1.8  thorpej 
      3   1.1      cgd /*
      4   1.3      cgd  * Copyright (c) 1989, 1993
      5   1.3      cgd  *	The Regents of the University of California.  All rights reserved.
      6   1.1      cgd  *
      7   1.1      cgd  * Redistribution and use in source and binary forms, with or without
      8   1.1      cgd  * modification, are permitted provided that the following conditions
      9   1.1      cgd  * are met:
     10   1.1      cgd  * 1. Redistributions of source code must retain the above copyright
     11   1.1      cgd  *    notice, this list of conditions and the following disclaimer.
     12   1.1      cgd  * 2. Redistributions in binary form must reproduce the above copyright
     13   1.1      cgd  *    notice, this list of conditions and the following disclaimer in the
     14   1.1      cgd  *    documentation and/or other materials provided with the distribution.
     15   1.1      cgd  * 3. All advertising materials mentioning features or use of this software
     16   1.1      cgd  *    must display the following acknowledgement:
     17   1.1      cgd  *	This product includes software developed by the University of
     18   1.1      cgd  *	California, Berkeley and its contributors.
     19   1.1      cgd  * 4. Neither the name of the University nor the names of its contributors
     20   1.1      cgd  *    may be used to endorse or promote products derived from this software
     21   1.1      cgd  *    without specific prior written permission.
     22   1.1      cgd  *
     23   1.1      cgd  * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
     24   1.1      cgd  * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
     25   1.1      cgd  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
     26   1.1      cgd  * ARE DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
     27   1.1      cgd  * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
     28   1.1      cgd  * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
     29   1.1      cgd  * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
     30   1.1      cgd  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
     31   1.1      cgd  * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
     32   1.1      cgd  * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
     33   1.1      cgd  * SUCH DAMAGE.
     34   1.1      cgd  */
     35   1.1      cgd 
     36  1.11      mrg #include <sys/cdefs.h>
     37   1.1      cgd #ifndef lint
     38   1.8  thorpej #if 0
     39   1.8  thorpej static char sccsid[] = "@(#)sys_term.c	8.4+1 (Berkeley) 5/30/95";
     40   1.8  thorpej #else
     41  1.14   tsarna __RCSID("$NetBSD: sys_term.c,v 1.14 1998/08/29 17:31:56 tsarna Exp $");
     42   1.8  thorpej #endif
     43   1.1      cgd #endif /* not lint */
     44   1.1      cgd 
     45   1.1      cgd #include "telnetd.h"
     46   1.1      cgd #include "pathnames.h"
     47   1.1      cgd 
     48  1.11      mrg #include <util.h>
     49  1.11      mrg 
     50   1.6      jtk #include <sys/cdefs.h>
     51   1.6      jtk #define P __P
     52   1.6      jtk 
     53   1.3      cgd #if	defined(AUTHENTICATION)
     54   1.1      cgd #include <libtelnet/auth.h>
     55   1.1      cgd #endif
     56   1.1      cgd 
     57   1.3      cgd #if defined(CRAY) || defined(__hpux)
     58   1.3      cgd # define PARENT_DOES_UTMP
     59   1.3      cgd #endif
     60   1.3      cgd 
     61   1.1      cgd #ifdef	NEWINIT
     62   1.1      cgd #include <initreq.h>
     63   1.3      cgd int	utmp_len = MAXHOSTNAMELEN;	/* sizeof(init_request.host) */
     64   1.1      cgd #else	/* NEWINIT*/
     65   1.3      cgd # ifdef	UTMPX
     66   1.3      cgd # include <utmpx.h>
     67   1.3      cgd struct	utmpx wtmp;
     68   1.3      cgd # else
     69   1.3      cgd # include <utmp.h>
     70   1.1      cgd struct	utmp wtmp;
     71   1.3      cgd # endif /* UTMPX */
     72   1.1      cgd 
     73   1.3      cgd int	utmp_len = sizeof(wtmp.ut_host);
     74   1.3      cgd # ifndef PARENT_DOES_UTMP
     75   1.1      cgd char	wtmpf[]	= "/usr/adm/wtmp";
     76   1.1      cgd char	utmpf[] = "/etc/utmp";
     77   1.3      cgd # else /* PARENT_DOES_UTMP */
     78   1.1      cgd char	wtmpf[]	= "/etc/wtmp";
     79   1.3      cgd # endif /* PARENT_DOES_UTMP */
     80   1.3      cgd 
     81   1.3      cgd # ifdef CRAY
     82   1.1      cgd #include <tmpdir.h>
     83   1.1      cgd #include <sys/wait.h>
     84   1.6      jtk #  if (UNICOS_LVL == '7.0') || (UNICOS_LVL == '7.1')
     85   1.6      jtk #   define UNICOS7x
     86   1.3      cgd #  endif
     87   1.3      cgd 
     88   1.6      jtk #  ifdef UNICOS7x
     89   1.3      cgd #include <sys/sysv.h>
     90   1.3      cgd #include <sys/secstat.h>
     91   1.3      cgd extern int secflag;
     92   1.3      cgd extern struct sysv sysv;
     93   1.6      jtk #  endif /* UNICOS7x */
     94   1.1      cgd # endif	/* CRAY */
     95   1.1      cgd #endif	/* NEWINIT */
     96   1.1      cgd 
     97   1.3      cgd #ifdef	STREAMSPTY
     98   1.3      cgd #include <sac.h>
     99   1.3      cgd #include <sys/stropts.h>
    100   1.3      cgd #endif
    101   1.3      cgd 
    102   1.1      cgd #define SCPYN(a, b)	(void) strncpy(a, b, sizeof(a))
    103   1.1      cgd #define SCMPN(a, b)	strncmp(a, b, sizeof(a))
    104   1.1      cgd 
    105   1.1      cgd #ifdef	STREAMS
    106   1.1      cgd #include <sys/stream.h>
    107   1.1      cgd #endif
    108   1.3      cgd #ifdef __hpux
    109   1.3      cgd #include <sys/resource.h>
    110   1.3      cgd #include <sys/proc.h>
    111   1.3      cgd #endif
    112   1.1      cgd #ifdef	t_erase
    113   1.1      cgd #undef	t_erase
    114   1.1      cgd #undef	t_kill
    115   1.1      cgd #undef	t_intrc
    116   1.1      cgd #undef	t_quitc
    117   1.1      cgd #undef	t_startc
    118   1.1      cgd #undef	t_stopc
    119   1.1      cgd #undef	t_eofc
    120   1.1      cgd #undef	t_brkc
    121   1.1      cgd #undef	t_suspc
    122   1.1      cgd #undef	t_dsuspc
    123   1.1      cgd #undef	t_rprntc
    124   1.1      cgd #undef	t_flushc
    125   1.1      cgd #undef	t_werasc
    126   1.1      cgd #undef	t_lnextc
    127   1.1      cgd #endif
    128   1.1      cgd 
    129   1.1      cgd #if defined(UNICOS5) && defined(CRAY2) && !defined(EXTPROC)
    130   1.1      cgd # define EXTPROC 0400
    131   1.1      cgd #endif
    132   1.1      cgd 
    133   1.1      cgd #ifndef	USE_TERMIO
    134   1.1      cgd struct termbuf {
    135   1.1      cgd 	struct sgttyb sg;
    136   1.1      cgd 	struct tchars tc;
    137   1.1      cgd 	struct ltchars ltc;
    138   1.1      cgd 	int state;
    139   1.1      cgd 	int lflags;
    140   1.1      cgd } termbuf, termbuf2;
    141   1.1      cgd # define	cfsetospeed(tp, val)	(tp)->sg.sg_ospeed = (val)
    142   1.1      cgd # define	cfsetispeed(tp, val)	(tp)->sg.sg_ispeed = (val)
    143   1.1      cgd # define	cfgetospeed(tp)		(tp)->sg.sg_ospeed
    144   1.1      cgd # define	cfgetispeed(tp)		(tp)->sg.sg_ispeed
    145   1.1      cgd #else	/* USE_TERMIO */
    146   1.1      cgd # ifdef	SYSV_TERMIO
    147   1.1      cgd #	define termios termio
    148   1.1      cgd # endif
    149   1.1      cgd # ifndef	TCSANOW
    150   1.1      cgd #  ifdef TCSETS
    151   1.1      cgd #   define	TCSANOW		TCSETS
    152   1.1      cgd #   define	TCSADRAIN	TCSETSW
    153   1.1      cgd #   define	tcgetattr(f, t)	ioctl(f, TCGETS, (char *)t)
    154   1.1      cgd #  else
    155   1.1      cgd #   ifdef TCSETA
    156   1.1      cgd #    define	TCSANOW		TCSETA
    157   1.1      cgd #    define	TCSADRAIN	TCSETAW
    158   1.1      cgd #    define	tcgetattr(f, t)	ioctl(f, TCGETA, (char *)t)
    159   1.1      cgd #   else
    160   1.1      cgd #    define	TCSANOW		TIOCSETA
    161   1.1      cgd #    define	TCSADRAIN	TIOCSETAW
    162   1.1      cgd #    define	tcgetattr(f, t)	ioctl(f, TIOCGETA, (char *)t)
    163   1.1      cgd #   endif
    164   1.1      cgd #  endif
    165   1.1      cgd #  define	tcsetattr(f, a, t)	ioctl(f, a, t)
    166   1.1      cgd #  define	cfsetospeed(tp, val)	(tp)->c_cflag &= ~CBAUD; \
    167   1.1      cgd 					(tp)->c_cflag |= (val)
    168   1.1      cgd #  define	cfgetospeed(tp)		((tp)->c_cflag & CBAUD)
    169   1.1      cgd #  ifdef CIBAUD
    170   1.1      cgd #   define	cfsetispeed(tp, val)	(tp)->c_cflag &= ~CIBAUD; \
    171   1.1      cgd 					(tp)->c_cflag |= ((val)<<IBSHIFT)
    172   1.1      cgd #   define	cfgetispeed(tp)		(((tp)->c_cflag & CIBAUD)>>IBSHIFT)
    173   1.1      cgd #  else
    174   1.1      cgd #   define	cfsetispeed(tp, val)	(tp)->c_cflag &= ~CBAUD; \
    175   1.1      cgd 					(tp)->c_cflag |= (val)
    176   1.1      cgd #   define	cfgetispeed(tp)		((tp)->c_cflag & CBAUD)
    177   1.1      cgd #  endif
    178   1.1      cgd # endif /* TCSANOW */
    179   1.1      cgd struct termios termbuf, termbuf2;	/* pty control structure */
    180   1.3      cgd # ifdef  STREAMSPTY
    181   1.3      cgd int ttyfd = -1;
    182   1.3      cgd # endif
    183   1.1      cgd #endif	/* USE_TERMIO */
    184   1.1      cgd 
    185  1.11      mrg void getptyslave __P((void));
    186  1.11      mrg int cleanopen __P((char *));
    187  1.11      mrg void init_env __P((void));
    188  1.11      mrg char **addarg __P((char **, char *));
    189  1.11      mrg void scrub_env __P((void));
    190  1.11      mrg int getent __P((char *, char *));
    191  1.11      mrg char *getstr __P((char *, char **));
    192  1.11      mrg 
    193   1.1      cgd /*
    194   1.1      cgd  * init_termbuf()
    195   1.1      cgd  * copy_termbuf(cp)
    196   1.1      cgd  * set_termbuf()
    197   1.1      cgd  *
    198   1.1      cgd  * These three routines are used to get and set the "termbuf" structure
    199   1.1      cgd  * to and from the kernel.  init_termbuf() gets the current settings.
    200   1.1      cgd  * copy_termbuf() hands in a new "termbuf" to write to the kernel, and
    201   1.1      cgd  * set_termbuf() writes the structure into the kernel.
    202   1.1      cgd  */
    203   1.1      cgd 
    204   1.1      cgd 	void
    205   1.1      cgd init_termbuf()
    206   1.1      cgd {
    207   1.1      cgd #ifndef	USE_TERMIO
    208   1.1      cgd 	(void) ioctl(pty, TIOCGETP, (char *)&termbuf.sg);
    209   1.1      cgd 	(void) ioctl(pty, TIOCGETC, (char *)&termbuf.tc);
    210   1.1      cgd 	(void) ioctl(pty, TIOCGLTC, (char *)&termbuf.ltc);
    211   1.1      cgd # ifdef	TIOCGSTATE
    212   1.1      cgd 	(void) ioctl(pty, TIOCGSTATE, (char *)&termbuf.state);
    213   1.1      cgd # endif
    214   1.1      cgd #else
    215   1.3      cgd # ifdef  STREAMSPTY
    216   1.3      cgd 	(void) tcgetattr(ttyfd, &termbuf);
    217   1.3      cgd # else
    218   1.1      cgd 	(void) tcgetattr(pty, &termbuf);
    219   1.3      cgd # endif
    220   1.1      cgd #endif
    221   1.1      cgd 	termbuf2 = termbuf;
    222   1.1      cgd }
    223   1.1      cgd 
    224   1.1      cgd #if	defined(LINEMODE) && defined(TIOCPKT_IOCTL)
    225   1.1      cgd 	void
    226   1.1      cgd copy_termbuf(cp, len)
    227   1.1      cgd 	char *cp;
    228   1.1      cgd 	int len;
    229   1.1      cgd {
    230   1.1      cgd 	if (len > sizeof(termbuf))
    231   1.1      cgd 		len = sizeof(termbuf);
    232   1.6      jtk 	memmove((char *)&termbuf, cp, len);
    233   1.1      cgd 	termbuf2 = termbuf;
    234   1.1      cgd }
    235   1.1      cgd #endif	/* defined(LINEMODE) && defined(TIOCPKT_IOCTL) */
    236   1.1      cgd 
    237   1.1      cgd 	void
    238   1.1      cgd set_termbuf()
    239   1.1      cgd {
    240   1.1      cgd 	/*
    241   1.1      cgd 	 * Only make the necessary changes.
    242   1.1      cgd 	 */
    243   1.1      cgd #ifndef	USE_TERMIO
    244   1.6      jtk 	if (memcmp((char *)&termbuf.sg, (char *)&termbuf2.sg,
    245   1.6      jtk 							sizeof(termbuf.sg)))
    246   1.1      cgd 		(void) ioctl(pty, TIOCSETN, (char *)&termbuf.sg);
    247   1.6      jtk 	if (memcmp((char *)&termbuf.tc, (char *)&termbuf2.tc,
    248   1.6      jtk 							sizeof(termbuf.tc)))
    249   1.1      cgd 		(void) ioctl(pty, TIOCSETC, (char *)&termbuf.tc);
    250   1.6      jtk 	if (memcmp((char *)&termbuf.ltc, (char *)&termbuf2.ltc,
    251   1.1      cgd 							sizeof(termbuf.ltc)))
    252   1.1      cgd 		(void) ioctl(pty, TIOCSLTC, (char *)&termbuf.ltc);
    253   1.1      cgd 	if (termbuf.lflags != termbuf2.lflags)
    254   1.1      cgd 		(void) ioctl(pty, TIOCLSET, (char *)&termbuf.lflags);
    255   1.1      cgd #else	/* USE_TERMIO */
    256   1.6      jtk 	if (memcmp((char *)&termbuf, (char *)&termbuf2, sizeof(termbuf)))
    257   1.3      cgd # ifdef  STREAMSPTY
    258   1.3      cgd 		(void) tcsetattr(ttyfd, TCSANOW, &termbuf);
    259   1.3      cgd # else
    260   1.1      cgd 		(void) tcsetattr(pty, TCSANOW, &termbuf);
    261   1.3      cgd # endif
    262   1.3      cgd # if	defined(CRAY2) && defined(UNICOS5)
    263   1.1      cgd 	needtermstat = 1;
    264   1.1      cgd # endif
    265   1.1      cgd #endif	/* USE_TERMIO */
    266   1.1      cgd }
    267   1.1      cgd 
    268   1.1      cgd 
    269   1.1      cgd /*
    270   1.1      cgd  * spcset(func, valp, valpp)
    271   1.1      cgd  *
    272   1.1      cgd  * This function takes various special characters (func), and
    273   1.1      cgd  * sets *valp to the current value of that character, and
    274   1.1      cgd  * *valpp to point to where in the "termbuf" structure that
    275   1.1      cgd  * value is kept.
    276   1.1      cgd  *
    277   1.1      cgd  * It returns the SLC_ level of support for this function.
    278   1.1      cgd  */
    279   1.1      cgd 
    280   1.1      cgd #ifndef	USE_TERMIO
    281   1.1      cgd 	int
    282   1.1      cgd spcset(func, valp, valpp)
    283   1.1      cgd 	int func;
    284   1.1      cgd 	cc_t *valp;
    285   1.1      cgd 	cc_t **valpp;
    286   1.1      cgd {
    287   1.1      cgd 	switch(func) {
    288   1.1      cgd 	case SLC_EOF:
    289   1.1      cgd 		*valp = termbuf.tc.t_eofc;
    290   1.1      cgd 		*valpp = (cc_t *)&termbuf.tc.t_eofc;
    291   1.1      cgd 		return(SLC_VARIABLE);
    292   1.1      cgd 	case SLC_EC:
    293   1.1      cgd 		*valp = termbuf.sg.sg_erase;
    294   1.1      cgd 		*valpp = (cc_t *)&termbuf.sg.sg_erase;
    295   1.1      cgd 		return(SLC_VARIABLE);
    296   1.1      cgd 	case SLC_EL:
    297   1.1      cgd 		*valp = termbuf.sg.sg_kill;
    298   1.1      cgd 		*valpp = (cc_t *)&termbuf.sg.sg_kill;
    299   1.1      cgd 		return(SLC_VARIABLE);
    300   1.1      cgd 	case SLC_IP:
    301   1.1      cgd 		*valp = termbuf.tc.t_intrc;
    302   1.1      cgd 		*valpp = (cc_t *)&termbuf.tc.t_intrc;
    303   1.1      cgd 		return(SLC_VARIABLE|SLC_FLUSHIN|SLC_FLUSHOUT);
    304   1.1      cgd 	case SLC_ABORT:
    305   1.1      cgd 		*valp = termbuf.tc.t_quitc;
    306   1.1      cgd 		*valpp = (cc_t *)&termbuf.tc.t_quitc;
    307   1.1      cgd 		return(SLC_VARIABLE|SLC_FLUSHIN|SLC_FLUSHOUT);
    308   1.1      cgd 	case SLC_XON:
    309   1.1      cgd 		*valp = termbuf.tc.t_startc;
    310   1.1      cgd 		*valpp = (cc_t *)&termbuf.tc.t_startc;
    311   1.1      cgd 		return(SLC_VARIABLE);
    312   1.1      cgd 	case SLC_XOFF:
    313   1.1      cgd 		*valp = termbuf.tc.t_stopc;
    314   1.1      cgd 		*valpp = (cc_t *)&termbuf.tc.t_stopc;
    315   1.1      cgd 		return(SLC_VARIABLE);
    316   1.1      cgd 	case SLC_AO:
    317   1.1      cgd 		*valp = termbuf.ltc.t_flushc;
    318   1.1      cgd 		*valpp = (cc_t *)&termbuf.ltc.t_flushc;
    319   1.1      cgd 		return(SLC_VARIABLE);
    320   1.1      cgd 	case SLC_SUSP:
    321   1.1      cgd 		*valp = termbuf.ltc.t_suspc;
    322   1.1      cgd 		*valpp = (cc_t *)&termbuf.ltc.t_suspc;
    323   1.1      cgd 		return(SLC_VARIABLE);
    324   1.1      cgd 	case SLC_EW:
    325   1.1      cgd 		*valp = termbuf.ltc.t_werasc;
    326   1.1      cgd 		*valpp = (cc_t *)&termbuf.ltc.t_werasc;
    327   1.1      cgd 		return(SLC_VARIABLE);
    328   1.1      cgd 	case SLC_RP:
    329   1.1      cgd 		*valp = termbuf.ltc.t_rprntc;
    330   1.1      cgd 		*valpp = (cc_t *)&termbuf.ltc.t_rprntc;
    331   1.1      cgd 		return(SLC_VARIABLE);
    332   1.1      cgd 	case SLC_LNEXT:
    333   1.1      cgd 		*valp = termbuf.ltc.t_lnextc;
    334   1.1      cgd 		*valpp = (cc_t *)&termbuf.ltc.t_lnextc;
    335   1.1      cgd 		return(SLC_VARIABLE);
    336   1.1      cgd 	case SLC_FORW1:
    337   1.1      cgd 		*valp = termbuf.tc.t_brkc;
    338   1.1      cgd 		*valpp = (cc_t *)&termbuf.ltc.t_lnextc;
    339   1.1      cgd 		return(SLC_VARIABLE);
    340   1.1      cgd 	case SLC_BRK:
    341   1.1      cgd 	case SLC_SYNCH:
    342   1.1      cgd 	case SLC_AYT:
    343   1.1      cgd 	case SLC_EOR:
    344   1.1      cgd 		*valp = (cc_t)0;
    345   1.1      cgd 		*valpp = (cc_t *)0;
    346   1.1      cgd 		return(SLC_DEFAULT);
    347   1.1      cgd 	default:
    348   1.1      cgd 		*valp = (cc_t)0;
    349   1.1      cgd 		*valpp = (cc_t *)0;
    350   1.1      cgd 		return(SLC_NOSUPPORT);
    351   1.1      cgd 	}
    352   1.1      cgd }
    353   1.1      cgd 
    354   1.1      cgd #else	/* USE_TERMIO */
    355   1.1      cgd 
    356   1.1      cgd 	int
    357   1.1      cgd spcset(func, valp, valpp)
    358   1.1      cgd 	int func;
    359   1.1      cgd 	cc_t *valp;
    360   1.1      cgd 	cc_t **valpp;
    361   1.1      cgd {
    362   1.1      cgd 
    363   1.1      cgd #define	setval(a, b)	*valp = termbuf.c_cc[a]; \
    364   1.1      cgd 			*valpp = &termbuf.c_cc[a]; \
    365   1.1      cgd 			return(b);
    366   1.1      cgd #define	defval(a) *valp = ((cc_t)a); *valpp = (cc_t *)0; return(SLC_DEFAULT);
    367   1.1      cgd 
    368   1.1      cgd 	switch(func) {
    369   1.1      cgd 	case SLC_EOF:
    370   1.1      cgd 		setval(VEOF, SLC_VARIABLE);
    371   1.1      cgd 	case SLC_EC:
    372   1.1      cgd 		setval(VERASE, SLC_VARIABLE);
    373   1.1      cgd 	case SLC_EL:
    374   1.1      cgd 		setval(VKILL, SLC_VARIABLE);
    375   1.1      cgd 	case SLC_IP:
    376   1.1      cgd 		setval(VINTR, SLC_VARIABLE|SLC_FLUSHIN|SLC_FLUSHOUT);
    377   1.1      cgd 	case SLC_ABORT:
    378   1.1      cgd 		setval(VQUIT, SLC_VARIABLE|SLC_FLUSHIN|SLC_FLUSHOUT);
    379   1.1      cgd 	case SLC_XON:
    380   1.1      cgd #ifdef	VSTART
    381   1.1      cgd 		setval(VSTART, SLC_VARIABLE);
    382   1.1      cgd #else
    383   1.1      cgd 		defval(0x13);
    384   1.1      cgd #endif
    385   1.1      cgd 	case SLC_XOFF:
    386   1.1      cgd #ifdef	VSTOP
    387   1.1      cgd 		setval(VSTOP, SLC_VARIABLE);
    388   1.1      cgd #else
    389   1.1      cgd 		defval(0x11);
    390   1.1      cgd #endif
    391   1.1      cgd 	case SLC_EW:
    392   1.1      cgd #ifdef	VWERASE
    393   1.1      cgd 		setval(VWERASE, SLC_VARIABLE);
    394   1.1      cgd #else
    395   1.1      cgd 		defval(0);
    396   1.1      cgd #endif
    397   1.1      cgd 	case SLC_RP:
    398   1.1      cgd #ifdef	VREPRINT
    399   1.1      cgd 		setval(VREPRINT, SLC_VARIABLE);
    400   1.1      cgd #else
    401   1.1      cgd 		defval(0);
    402   1.1      cgd #endif
    403   1.1      cgd 	case SLC_LNEXT:
    404   1.1      cgd #ifdef	VLNEXT
    405   1.1      cgd 		setval(VLNEXT, SLC_VARIABLE);
    406   1.1      cgd #else
    407   1.1      cgd 		defval(0);
    408   1.1      cgd #endif
    409   1.1      cgd 	case SLC_AO:
    410   1.1      cgd #if	!defined(VDISCARD) && defined(VFLUSHO)
    411   1.1      cgd # define VDISCARD VFLUSHO
    412   1.1      cgd #endif
    413   1.1      cgd #ifdef	VDISCARD
    414   1.1      cgd 		setval(VDISCARD, SLC_VARIABLE|SLC_FLUSHOUT);
    415   1.1      cgd #else
    416   1.1      cgd 		defval(0);
    417   1.1      cgd #endif
    418   1.1      cgd 	case SLC_SUSP:
    419   1.1      cgd #ifdef	VSUSP
    420   1.1      cgd 		setval(VSUSP, SLC_VARIABLE|SLC_FLUSHIN);
    421   1.1      cgd #else
    422   1.1      cgd 		defval(0);
    423   1.1      cgd #endif
    424   1.1      cgd #ifdef	VEOL
    425   1.1      cgd 	case SLC_FORW1:
    426   1.1      cgd 		setval(VEOL, SLC_VARIABLE);
    427   1.1      cgd #endif
    428   1.1      cgd #ifdef	VEOL2
    429   1.1      cgd 	case SLC_FORW2:
    430   1.1      cgd 		setval(VEOL2, SLC_VARIABLE);
    431   1.1      cgd #endif
    432   1.1      cgd 	case SLC_AYT:
    433   1.1      cgd #ifdef	VSTATUS
    434   1.1      cgd 		setval(VSTATUS, SLC_VARIABLE);
    435   1.1      cgd #else
    436   1.1      cgd 		defval(0);
    437   1.1      cgd #endif
    438   1.1      cgd 
    439   1.1      cgd 	case SLC_BRK:
    440   1.1      cgd 	case SLC_SYNCH:
    441   1.1      cgd 	case SLC_EOR:
    442   1.1      cgd 		defval(0);
    443   1.1      cgd 
    444   1.1      cgd 	default:
    445   1.1      cgd 		*valp = 0;
    446   1.1      cgd 		*valpp = 0;
    447   1.1      cgd 		return(SLC_NOSUPPORT);
    448   1.1      cgd 	}
    449   1.1      cgd }
    450   1.1      cgd #endif	/* USE_TERMIO */
    451   1.1      cgd 
    452   1.1      cgd #ifdef CRAY
    453   1.1      cgd /*
    454   1.1      cgd  * getnpty()
    455   1.1      cgd  *
    456   1.1      cgd  * Return the number of pty's configured into the system.
    457   1.1      cgd  */
    458   1.1      cgd 	int
    459   1.1      cgd getnpty()
    460   1.1      cgd {
    461   1.1      cgd #ifdef _SC_CRAY_NPTY
    462   1.1      cgd 	int numptys;
    463   1.1      cgd 
    464   1.1      cgd 	if ((numptys = sysconf(_SC_CRAY_NPTY)) != -1)
    465   1.1      cgd 		return numptys;
    466   1.1      cgd 	else
    467   1.1      cgd #endif /* _SC_CRAY_NPTY */
    468   1.1      cgd 		return 128;
    469   1.1      cgd }
    470   1.1      cgd #endif /* CRAY */
    471   1.1      cgd 
    472   1.1      cgd #ifndef	convex
    473   1.1      cgd /*
    474   1.1      cgd  * getpty()
    475   1.1      cgd  *
    476   1.1      cgd  * Allocate a pty.  As a side effect, the external character
    477   1.1      cgd  * array "line" contains the name of the slave side.
    478   1.1      cgd  *
    479   1.1      cgd  * Returns the file descriptor of the opened pty.
    480   1.1      cgd  */
    481   1.1      cgd #ifndef	__GNUC__
    482   1.1      cgd char *line = "\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0";
    483   1.1      cgd #else
    484   1.1      cgd static char Xline[] = "\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0";
    485   1.1      cgd char *line = Xline;
    486   1.1      cgd #endif
    487   1.1      cgd #ifdef	CRAY
    488   1.1      cgd char *myline = "\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0";
    489   1.1      cgd #endif	/* CRAY */
    490   1.1      cgd 
    491  1.13    perry #ifdef OPENPTY_PTY
    492  1.13    perry 
    493  1.13    perry static int ptyslavefd; /* for cleanopen() */
    494  1.13    perry 
    495  1.13    perry int
    496  1.13    perry getpty(ptynum)
    497  1.13    perry int *ptynum;
    498  1.13    perry {
    499  1.13    perry 	int ptyfd;
    500  1.13    perry 
    501  1.13    perry 	ptyfd = openpty(ptynum, &ptyslavefd, line, NULL, NULL);
    502  1.13    perry 	if (ptyfd == 0)
    503  1.13    perry 		return *ptynum;
    504  1.13    perry 	ptyslavefd = -1;
    505  1.13    perry 	return (-1);
    506  1.13    perry }
    507  1.13    perry #else /* ! OPENPTY_PTY */
    508  1.13    perry 
    509   1.1      cgd 	int
    510   1.3      cgd getpty(ptynum)
    511   1.3      cgd int *ptynum;
    512   1.1      cgd {
    513   1.1      cgd 	register int p;
    514   1.3      cgd #ifdef	STREAMSPTY
    515   1.3      cgd 	int t;
    516   1.3      cgd 	char *ptsname();
    517   1.3      cgd 
    518   1.3      cgd 	p = open("/dev/ptmx", 2);
    519   1.3      cgd 	if (p > 0) {
    520   1.3      cgd 		grantpt(p);
    521   1.3      cgd 		unlockpt(p);
    522   1.3      cgd 		strcpy(line, ptsname(p));
    523   1.3      cgd 		return(p);
    524   1.3      cgd 	}
    525   1.3      cgd 
    526   1.3      cgd #else	/* ! STREAMSPTY */
    527   1.1      cgd #ifndef CRAY
    528   1.3      cgd 	register char *cp, *p1, *p2;
    529   1.1      cgd 	register int i;
    530   1.3      cgd #if defined(sun) && defined(TIOCGPGRP) && BSD < 199207
    531   1.3      cgd 	int dummy;
    532   1.3      cgd #endif
    533   1.1      cgd 
    534   1.3      cgd #ifndef	__hpux
    535   1.1      cgd 	(void) sprintf(line, "/dev/ptyXX");
    536   1.1      cgd 	p1 = &line[8];
    537   1.1      cgd 	p2 = &line[9];
    538   1.3      cgd #else
    539   1.3      cgd 	(void) sprintf(line, "/dev/ptym/ptyXX");
    540   1.3      cgd 	p1 = &line[13];
    541   1.3      cgd 	p2 = &line[14];
    542   1.3      cgd #endif
    543   1.1      cgd 
    544   1.3      cgd 	for (cp = "pqrstuvwxyzPQRST"; *cp; cp++) {
    545   1.1      cgd 		struct stat stb;
    546   1.1      cgd 
    547   1.3      cgd 		*p1 = *cp;
    548   1.1      cgd 		*p2 = '0';
    549   1.3      cgd 		/*
    550   1.3      cgd 		 * This stat() check is just to keep us from
    551   1.3      cgd 		 * looping through all 256 combinations if there
    552   1.3      cgd 		 * aren't that many ptys available.
    553   1.3      cgd 		 */
    554   1.1      cgd 		if (stat(line, &stb) < 0)
    555   1.1      cgd 			break;
    556   1.1      cgd 		for (i = 0; i < 16; i++) {
    557   1.1      cgd 			*p2 = "0123456789abcdef"[i];
    558   1.1      cgd 			p = open(line, 2);
    559   1.1      cgd 			if (p > 0) {
    560   1.3      cgd #ifndef	__hpux
    561   1.1      cgd 				line[5] = 't';
    562   1.3      cgd #else
    563   1.3      cgd 				for (p1 = &line[8]; *p1; p1++)
    564   1.3      cgd 					*p1 = *(p1+1);
    565   1.3      cgd 				line[9] = 't';
    566   1.3      cgd #endif
    567   1.3      cgd 				chown(line, 0, 0);
    568   1.3      cgd 				chmod(line, 0600);
    569   1.3      cgd #if defined(sun) && defined(TIOCGPGRP) && BSD < 199207
    570   1.3      cgd 				if (ioctl(p, TIOCGPGRP, &dummy) == 0
    571   1.3      cgd 				    || errno != EIO) {
    572   1.3      cgd 					chmod(line, 0666);
    573   1.3      cgd 					close(p);
    574   1.3      cgd 					line[5] = 'p';
    575   1.3      cgd 				} else
    576   1.3      cgd #endif /* defined(sun) && defined(TIOCGPGRP) && BSD < 199207 */
    577   1.3      cgd 					return(p);
    578   1.1      cgd 			}
    579   1.1      cgd 		}
    580   1.1      cgd 	}
    581   1.1      cgd #else	/* CRAY */
    582   1.1      cgd 	extern lowpty, highpty;
    583   1.1      cgd 	struct stat sb;
    584   1.1      cgd 
    585   1.3      cgd 	for (*ptynum = lowpty; *ptynum <= highpty; (*ptynum)++) {
    586   1.3      cgd 		(void) sprintf(myline, "/dev/pty/%03d", *ptynum);
    587   1.1      cgd 		p = open(myline, 2);
    588   1.1      cgd 		if (p < 0)
    589   1.1      cgd 			continue;
    590   1.3      cgd 		(void) sprintf(line, "/dev/ttyp%03d", *ptynum);
    591   1.1      cgd 		/*
    592   1.1      cgd 		 * Here are some shenanigans to make sure that there
    593   1.1      cgd 		 * are no listeners lurking on the line.
    594   1.1      cgd 		 */
    595   1.1      cgd 		if(stat(line, &sb) < 0) {
    596   1.1      cgd 			(void) close(p);
    597   1.1      cgd 			continue;
    598   1.1      cgd 		}
    599   1.1      cgd 		if(sb.st_uid || sb.st_gid || sb.st_mode != 0600) {
    600   1.1      cgd 			chown(line, 0, 0);
    601   1.1      cgd 			chmod(line, 0600);
    602   1.1      cgd 			(void)close(p);
    603   1.1      cgd 			p = open(myline, 2);
    604   1.1      cgd 			if (p < 0)
    605   1.1      cgd 				continue;
    606   1.1      cgd 		}
    607   1.1      cgd 		/*
    608   1.1      cgd 		 * Now it should be safe...check for accessability.
    609   1.1      cgd 		 */
    610   1.1      cgd 		if (access(line, 6) == 0)
    611   1.1      cgd 			return(p);
    612   1.1      cgd 		else {
    613   1.1      cgd 			/* no tty side to pty so skip it */
    614   1.1      cgd 			(void) close(p);
    615   1.1      cgd 		}
    616   1.1      cgd 	}
    617   1.1      cgd #endif	/* CRAY */
    618   1.3      cgd #endif	/* STREAMSPTY */
    619   1.1      cgd 	return(-1);
    620   1.1      cgd }
    621  1.13    perry #endif /* OPENPTY_PTY */
    622   1.1      cgd #endif	/* convex */
    623   1.1      cgd 
    624   1.1      cgd #ifdef	LINEMODE
    625   1.1      cgd /*
    626   1.1      cgd  * tty_flowmode()	Find out if flow control is enabled or disabled.
    627   1.1      cgd  * tty_linemode()	Find out if linemode (external processing) is enabled.
    628   1.1      cgd  * tty_setlinemod(on)	Turn on/off linemode.
    629   1.1      cgd  * tty_isecho()		Find out if echoing is turned on.
    630   1.1      cgd  * tty_setecho(on)	Enable/disable character echoing.
    631   1.1      cgd  * tty_israw()		Find out if terminal is in RAW mode.
    632   1.1      cgd  * tty_binaryin(on)	Turn on/off BINARY on input.
    633   1.1      cgd  * tty_binaryout(on)	Turn on/off BINARY on output.
    634   1.1      cgd  * tty_isediting()	Find out if line editing is enabled.
    635   1.1      cgd  * tty_istrapsig()	Find out if signal trapping is enabled.
    636   1.1      cgd  * tty_setedit(on)	Turn on/off line editing.
    637   1.1      cgd  * tty_setsig(on)	Turn on/off signal trapping.
    638   1.1      cgd  * tty_issofttab()	Find out if tab expansion is enabled.
    639   1.1      cgd  * tty_setsofttab(on)	Turn on/off soft tab expansion.
    640   1.1      cgd  * tty_islitecho()	Find out if typed control chars are echoed literally
    641   1.1      cgd  * tty_setlitecho()	Turn on/off literal echo of control chars
    642   1.1      cgd  * tty_tspeed(val)	Set transmit speed to val.
    643   1.1      cgd  * tty_rspeed(val)	Set receive speed to val.
    644   1.1      cgd  */
    645   1.1      cgd 
    646   1.1      cgd #ifdef convex
    647   1.1      cgd static int linestate;
    648   1.1      cgd #endif
    649   1.1      cgd 
    650   1.1      cgd 	int
    651   1.1      cgd tty_linemode()
    652   1.1      cgd {
    653   1.1      cgd #ifndef convex
    654   1.1      cgd #ifndef	USE_TERMIO
    655   1.1      cgd 	return(termbuf.state & TS_EXTPROC);
    656   1.1      cgd #else
    657   1.1      cgd 	return(termbuf.c_lflag & EXTPROC);
    658   1.1      cgd #endif
    659   1.1      cgd #else
    660   1.1      cgd 	return(linestate);
    661   1.1      cgd #endif
    662   1.1      cgd }
    663   1.1      cgd 
    664   1.1      cgd 	void
    665   1.1      cgd tty_setlinemode(on)
    666   1.1      cgd 	int on;
    667   1.1      cgd {
    668   1.1      cgd #ifdef	TIOCEXT
    669   1.1      cgd # ifndef convex
    670   1.1      cgd 	set_termbuf();
    671   1.1      cgd # else
    672   1.1      cgd 	linestate = on;
    673   1.1      cgd # endif
    674   1.1      cgd 	(void) ioctl(pty, TIOCEXT, (char *)&on);
    675   1.1      cgd # ifndef convex
    676   1.1      cgd 	init_termbuf();
    677   1.1      cgd # endif
    678   1.1      cgd #else	/* !TIOCEXT */
    679   1.1      cgd # ifdef	EXTPROC
    680   1.1      cgd 	if (on)
    681   1.1      cgd 		termbuf.c_lflag |= EXTPROC;
    682   1.1      cgd 	else
    683   1.1      cgd 		termbuf.c_lflag &= ~EXTPROC;
    684   1.1      cgd # endif
    685   1.1      cgd #endif	/* TIOCEXT */
    686   1.1      cgd }
    687   1.3      cgd #endif	/* LINEMODE */
    688   1.1      cgd 
    689   1.1      cgd 	int
    690   1.1      cgd tty_isecho()
    691   1.1      cgd {
    692   1.1      cgd #ifndef USE_TERMIO
    693   1.1      cgd 	return (termbuf.sg.sg_flags & ECHO);
    694   1.1      cgd #else
    695   1.1      cgd 	return (termbuf.c_lflag & ECHO);
    696   1.1      cgd #endif
    697   1.1      cgd }
    698   1.3      cgd 
    699   1.3      cgd 	int
    700   1.3      cgd tty_flowmode()
    701   1.3      cgd {
    702   1.3      cgd #ifndef USE_TERMIO
    703   1.3      cgd 	return(((termbuf.tc.t_startc) > 0 && (termbuf.tc.t_stopc) > 0) ? 1 : 0);
    704   1.3      cgd #else
    705   1.3      cgd 	return((termbuf.c_iflag & IXON) ? 1 : 0);
    706   1.3      cgd #endif
    707   1.3      cgd }
    708   1.3      cgd 
    709   1.3      cgd 	int
    710   1.3      cgd tty_restartany()
    711   1.3      cgd {
    712   1.3      cgd #ifndef USE_TERMIO
    713   1.3      cgd # ifdef	DECCTQ
    714   1.3      cgd 	return((termbuf.lflags & DECCTQ) ? 0 : 1);
    715   1.3      cgd # else
    716   1.3      cgd 	return(-1);
    717   1.3      cgd # endif
    718   1.3      cgd #else
    719   1.3      cgd 	return((termbuf.c_iflag & IXANY) ? 1 : 0);
    720   1.3      cgd #endif
    721   1.3      cgd }
    722   1.1      cgd 
    723   1.1      cgd 	void
    724   1.1      cgd tty_setecho(on)
    725   1.1      cgd 	int on;
    726   1.1      cgd {
    727   1.1      cgd #ifndef	USE_TERMIO
    728   1.1      cgd 	if (on)
    729   1.1      cgd 		termbuf.sg.sg_flags |= ECHO|CRMOD;
    730   1.1      cgd 	else
    731   1.1      cgd 		termbuf.sg.sg_flags &= ~(ECHO|CRMOD);
    732   1.1      cgd #else
    733   1.1      cgd 	if (on)
    734   1.1      cgd 		termbuf.c_lflag |= ECHO;
    735   1.1      cgd 	else
    736   1.1      cgd 		termbuf.c_lflag &= ~ECHO;
    737   1.1      cgd #endif
    738   1.1      cgd }
    739   1.1      cgd 
    740   1.1      cgd 	int
    741   1.1      cgd tty_israw()
    742   1.1      cgd {
    743   1.1      cgd #ifndef USE_TERMIO
    744   1.1      cgd 	return(termbuf.sg.sg_flags & RAW);
    745   1.1      cgd #else
    746   1.1      cgd 	return(!(termbuf.c_lflag & ICANON));
    747   1.1      cgd #endif
    748   1.1      cgd }
    749   1.3      cgd 
    750   1.3      cgd #if	defined (AUTHENTICATION) && defined(NO_LOGIN_F) && defined(LOGIN_R)
    751   1.3      cgd 	int
    752   1.3      cgd tty_setraw(on)
    753   1.3      cgd {
    754   1.3      cgd #  ifndef USE_TERMIO
    755   1.3      cgd 	if (on)
    756   1.3      cgd 		termbuf.sg.sg_flags |= RAW;
    757   1.3      cgd 	else
    758   1.3      cgd 		termbuf.sg.sg_flags &= ~RAW;
    759   1.3      cgd #  else
    760   1.3      cgd 	if (on)
    761   1.3      cgd 		termbuf.c_lflag &= ~ICANON;
    762   1.3      cgd 	else
    763   1.3      cgd 		termbuf.c_lflag |= ICANON;
    764   1.3      cgd #  endif
    765   1.3      cgd }
    766   1.3      cgd #endif
    767   1.1      cgd 
    768   1.1      cgd 	void
    769   1.1      cgd tty_binaryin(on)
    770   1.1      cgd 	int on;
    771   1.1      cgd {
    772   1.1      cgd #ifndef	USE_TERMIO
    773   1.1      cgd 	if (on)
    774   1.1      cgd 		termbuf.lflags |= LPASS8;
    775   1.1      cgd 	else
    776   1.1      cgd 		termbuf.lflags &= ~LPASS8;
    777   1.1      cgd #else
    778   1.1      cgd 	if (on) {
    779   1.1      cgd 		termbuf.c_iflag &= ~ISTRIP;
    780   1.1      cgd 	} else {
    781   1.1      cgd 		termbuf.c_iflag |= ISTRIP;
    782   1.1      cgd 	}
    783   1.1      cgd #endif
    784   1.1      cgd }
    785   1.1      cgd 
    786   1.1      cgd 	void
    787   1.1      cgd tty_binaryout(on)
    788   1.1      cgd 	int on;
    789   1.1      cgd {
    790   1.1      cgd #ifndef	USE_TERMIO
    791   1.1      cgd 	if (on)
    792   1.1      cgd 		termbuf.lflags |= LLITOUT;
    793   1.1      cgd 	else
    794   1.1      cgd 		termbuf.lflags &= ~LLITOUT;
    795   1.1      cgd #else
    796   1.1      cgd 	if (on) {
    797   1.1      cgd 		termbuf.c_cflag &= ~(CSIZE|PARENB);
    798   1.1      cgd 		termbuf.c_cflag |= CS8;
    799   1.1      cgd 		termbuf.c_oflag &= ~OPOST;
    800   1.1      cgd 	} else {
    801   1.1      cgd 		termbuf.c_cflag &= ~CSIZE;
    802   1.1      cgd 		termbuf.c_cflag |= CS7|PARENB;
    803   1.1      cgd 		termbuf.c_oflag |= OPOST;
    804   1.1      cgd 	}
    805   1.1      cgd #endif
    806   1.1      cgd }
    807   1.1      cgd 
    808   1.1      cgd 	int
    809   1.1      cgd tty_isbinaryin()
    810   1.1      cgd {
    811   1.1      cgd #ifndef	USE_TERMIO
    812   1.1      cgd 	return(termbuf.lflags & LPASS8);
    813   1.1      cgd #else
    814   1.1      cgd 	return(!(termbuf.c_iflag & ISTRIP));
    815   1.1      cgd #endif
    816   1.1      cgd }
    817   1.1      cgd 
    818   1.1      cgd 	int
    819   1.1      cgd tty_isbinaryout()
    820   1.1      cgd {
    821   1.1      cgd #ifndef	USE_TERMIO
    822   1.1      cgd 	return(termbuf.lflags & LLITOUT);
    823   1.1      cgd #else
    824   1.1      cgd 	return(!(termbuf.c_oflag&OPOST));
    825   1.1      cgd #endif
    826   1.1      cgd }
    827   1.1      cgd 
    828   1.1      cgd #ifdef	LINEMODE
    829   1.1      cgd 	int
    830   1.1      cgd tty_isediting()
    831   1.1      cgd {
    832   1.1      cgd #ifndef USE_TERMIO
    833   1.1      cgd 	return(!(termbuf.sg.sg_flags & (CBREAK|RAW)));
    834   1.1      cgd #else
    835   1.1      cgd 	return(termbuf.c_lflag & ICANON);
    836   1.1      cgd #endif
    837   1.1      cgd }
    838   1.1      cgd 
    839   1.1      cgd 	int
    840   1.1      cgd tty_istrapsig()
    841   1.1      cgd {
    842   1.1      cgd #ifndef USE_TERMIO
    843   1.1      cgd 	return(!(termbuf.sg.sg_flags&RAW));
    844   1.1      cgd #else
    845   1.1      cgd 	return(termbuf.c_lflag & ISIG);
    846   1.1      cgd #endif
    847   1.1      cgd }
    848   1.1      cgd 
    849   1.1      cgd 	void
    850   1.1      cgd tty_setedit(on)
    851   1.1      cgd 	int on;
    852   1.1      cgd {
    853   1.1      cgd #ifndef USE_TERMIO
    854   1.1      cgd 	if (on)
    855   1.1      cgd 		termbuf.sg.sg_flags &= ~CBREAK;
    856   1.1      cgd 	else
    857   1.1      cgd 		termbuf.sg.sg_flags |= CBREAK;
    858   1.1      cgd #else
    859   1.1      cgd 	if (on)
    860   1.1      cgd 		termbuf.c_lflag |= ICANON;
    861   1.1      cgd 	else
    862   1.1      cgd 		termbuf.c_lflag &= ~ICANON;
    863   1.1      cgd #endif
    864   1.1      cgd }
    865   1.1      cgd 
    866   1.1      cgd 	void
    867   1.1      cgd tty_setsig(on)
    868   1.1      cgd 	int on;
    869   1.1      cgd {
    870   1.1      cgd #ifndef	USE_TERMIO
    871   1.1      cgd 	if (on)
    872   1.1      cgd 		;
    873   1.1      cgd #else
    874   1.1      cgd 	if (on)
    875   1.1      cgd 		termbuf.c_lflag |= ISIG;
    876   1.1      cgd 	else
    877   1.1      cgd 		termbuf.c_lflag &= ~ISIG;
    878   1.1      cgd #endif
    879   1.1      cgd }
    880   1.1      cgd #endif	/* LINEMODE */
    881   1.1      cgd 
    882   1.1      cgd 	int
    883   1.1      cgd tty_issofttab()
    884   1.1      cgd {
    885   1.1      cgd #ifndef	USE_TERMIO
    886   1.1      cgd 	return (termbuf.sg.sg_flags & XTABS);
    887   1.1      cgd #else
    888   1.1      cgd # ifdef	OXTABS
    889   1.1      cgd 	return (termbuf.c_oflag & OXTABS);
    890   1.1      cgd # endif
    891   1.1      cgd # ifdef	TABDLY
    892   1.1      cgd 	return ((termbuf.c_oflag & TABDLY) == TAB3);
    893   1.1      cgd # endif
    894   1.1      cgd #endif
    895   1.1      cgd }
    896   1.1      cgd 
    897   1.1      cgd 	void
    898   1.1      cgd tty_setsofttab(on)
    899   1.1      cgd 	int on;
    900   1.1      cgd {
    901   1.1      cgd #ifndef	USE_TERMIO
    902   1.1      cgd 	if (on)
    903   1.1      cgd 		termbuf.sg.sg_flags |= XTABS;
    904   1.1      cgd 	else
    905   1.1      cgd 		termbuf.sg.sg_flags &= ~XTABS;
    906   1.1      cgd #else
    907   1.1      cgd 	if (on) {
    908   1.1      cgd # ifdef	OXTABS
    909   1.1      cgd 		termbuf.c_oflag |= OXTABS;
    910   1.1      cgd # endif
    911   1.1      cgd # ifdef	TABDLY
    912   1.1      cgd 		termbuf.c_oflag &= ~TABDLY;
    913   1.1      cgd 		termbuf.c_oflag |= TAB3;
    914   1.1      cgd # endif
    915   1.1      cgd 	} else {
    916   1.1      cgd # ifdef	OXTABS
    917   1.1      cgd 		termbuf.c_oflag &= ~OXTABS;
    918   1.1      cgd # endif
    919   1.1      cgd # ifdef	TABDLY
    920   1.1      cgd 		termbuf.c_oflag &= ~TABDLY;
    921   1.1      cgd 		termbuf.c_oflag |= TAB0;
    922   1.1      cgd # endif
    923   1.1      cgd 	}
    924   1.1      cgd #endif
    925   1.1      cgd }
    926   1.1      cgd 
    927   1.1      cgd 	int
    928   1.1      cgd tty_islitecho()
    929   1.1      cgd {
    930   1.1      cgd #ifndef	USE_TERMIO
    931   1.1      cgd 	return (!(termbuf.lflags & LCTLECH));
    932   1.1      cgd #else
    933   1.1      cgd # ifdef	ECHOCTL
    934   1.1      cgd 	return (!(termbuf.c_lflag & ECHOCTL));
    935   1.1      cgd # endif
    936   1.1      cgd # ifdef	TCTLECH
    937   1.1      cgd 	return (!(termbuf.c_lflag & TCTLECH));
    938   1.1      cgd # endif
    939   1.1      cgd # if	!defined(ECHOCTL) && !defined(TCTLECH)
    940   1.1      cgd 	return (0);	/* assumes ctl chars are echoed '^x' */
    941   1.1      cgd # endif
    942   1.1      cgd #endif
    943   1.1      cgd }
    944   1.1      cgd 
    945   1.1      cgd 	void
    946   1.1      cgd tty_setlitecho(on)
    947   1.1      cgd 	int on;
    948   1.1      cgd {
    949   1.1      cgd #ifndef	USE_TERMIO
    950   1.1      cgd 	if (on)
    951   1.1      cgd 		termbuf.lflags &= ~LCTLECH;
    952   1.1      cgd 	else
    953   1.1      cgd 		termbuf.lflags |= LCTLECH;
    954   1.1      cgd #else
    955   1.1      cgd # ifdef	ECHOCTL
    956   1.1      cgd 	if (on)
    957   1.1      cgd 		termbuf.c_lflag &= ~ECHOCTL;
    958   1.1      cgd 	else
    959   1.1      cgd 		termbuf.c_lflag |= ECHOCTL;
    960   1.1      cgd # endif
    961   1.1      cgd # ifdef	TCTLECH
    962   1.1      cgd 	if (on)
    963   1.1      cgd 		termbuf.c_lflag &= ~TCTLECH;
    964   1.1      cgd 	else
    965   1.1      cgd 		termbuf.c_lflag |= TCTLECH;
    966   1.1      cgd # endif
    967   1.1      cgd #endif
    968   1.1      cgd }
    969   1.1      cgd 
    970   1.1      cgd 	int
    971   1.1      cgd tty_iscrnl()
    972   1.1      cgd {
    973   1.1      cgd #ifndef	USE_TERMIO
    974   1.1      cgd 	return (termbuf.sg.sg_flags & CRMOD);
    975   1.1      cgd #else
    976   1.1      cgd 	return (termbuf.c_iflag & ICRNL);
    977   1.1      cgd #endif
    978   1.1      cgd }
    979   1.1      cgd 
    980   1.1      cgd /*
    981   1.6      jtk  * Try to guess whether speeds are "encoded" (4.2BSD) or just numeric (4.4BSD).
    982   1.6      jtk  */
    983   1.6      jtk #if B4800 != 4800
    984   1.6      jtk #define	DECODE_BAUD
    985   1.6      jtk #endif
    986   1.6      jtk 
    987   1.6      jtk #ifdef	DECODE_BAUD
    988   1.6      jtk 
    989   1.6      jtk /*
    990   1.1      cgd  * A table of available terminal speeds
    991   1.1      cgd  */
    992   1.1      cgd struct termspeeds {
    993   1.1      cgd 	int	speed;
    994   1.1      cgd 	int	value;
    995   1.1      cgd } termspeeds[] = {
    996   1.6      jtk 	{ 0,      B0 },      { 50,    B50 },    { 75,     B75 },
    997   1.6      jtk 	{ 110,    B110 },    { 134,   B134 },   { 150,    B150 },
    998   1.6      jtk 	{ 200,    B200 },    { 300,   B300 },   { 600,    B600 },
    999   1.6      jtk 	{ 1200,   B1200 },   { 1800,  B1800 },  { 2400,   B2400 },
   1000   1.6      jtk 	{ 4800,   B4800 },
   1001   1.6      jtk #ifdef	B7200
   1002   1.6      jtk 	{ 7200,  B7200 },
   1003   1.6      jtk #endif
   1004   1.6      jtk 	{ 9600,   B9600 },
   1005   1.6      jtk #ifdef	B14400
   1006   1.6      jtk 	{ 14400,  B14400 },
   1007   1.6      jtk #endif
   1008   1.6      jtk #ifdef	B19200
   1009   1.6      jtk 	{ 19200,  B19200 },
   1010   1.6      jtk #endif
   1011   1.6      jtk #ifdef	B28800
   1012   1.6      jtk 	{ 28800,  B28800 },
   1013   1.6      jtk #endif
   1014   1.6      jtk #ifdef	B38400
   1015   1.6      jtk 	{ 38400,  B38400 },
   1016   1.6      jtk #endif
   1017   1.6      jtk #ifdef	B57600
   1018   1.6      jtk 	{ 57600,  B57600 },
   1019   1.6      jtk #endif
   1020   1.6      jtk #ifdef	B115200
   1021   1.6      jtk 	{ 115200, B115200 },
   1022   1.6      jtk #endif
   1023   1.6      jtk #ifdef	B230400
   1024   1.6      jtk 	{ 230400, B230400 },
   1025   1.6      jtk #endif
   1026   1.6      jtk 	{ -1,     0 }
   1027   1.1      cgd };
   1028   1.6      jtk #endif	/* DECODE_BUAD */
   1029   1.1      cgd 
   1030   1.1      cgd 	void
   1031   1.1      cgd tty_tspeed(val)
   1032   1.1      cgd 	int val;
   1033   1.1      cgd {
   1034   1.6      jtk #ifdef	DECODE_BAUD
   1035   1.1      cgd 	register struct termspeeds *tp;
   1036   1.1      cgd 
   1037   1.1      cgd 	for (tp = termspeeds; (tp->speed != -1) && (val > tp->speed); tp++)
   1038   1.1      cgd 		;
   1039   1.6      jtk 	if (tp->speed == -1)	/* back up to last valid value */
   1040   1.6      jtk 		--tp;
   1041   1.1      cgd 	cfsetospeed(&termbuf, tp->value);
   1042   1.6      jtk #else	/* DECODE_BUAD */
   1043   1.6      jtk 	cfsetospeed(&termbuf, val);
   1044   1.6      jtk #endif	/* DECODE_BUAD */
   1045   1.1      cgd }
   1046   1.1      cgd 
   1047   1.1      cgd 	void
   1048   1.1      cgd tty_rspeed(val)
   1049   1.1      cgd 	int val;
   1050   1.1      cgd {
   1051   1.6      jtk #ifdef	DECODE_BAUD
   1052   1.1      cgd 	register struct termspeeds *tp;
   1053   1.1      cgd 
   1054   1.1      cgd 	for (tp = termspeeds; (tp->speed != -1) && (val > tp->speed); tp++)
   1055   1.1      cgd 		;
   1056   1.6      jtk 	if (tp->speed == -1)	/* back up to last valid value */
   1057   1.6      jtk 		--tp;
   1058   1.1      cgd 	cfsetispeed(&termbuf, tp->value);
   1059   1.6      jtk #else	/* DECODE_BAUD */
   1060   1.6      jtk 	cfsetispeed(&termbuf, val);
   1061   1.6      jtk #endif	/* DECODE_BAUD */
   1062   1.1      cgd }
   1063   1.1      cgd 
   1064   1.1      cgd #if	defined(CRAY2) && defined(UNICOS5)
   1065   1.1      cgd 	int
   1066   1.1      cgd tty_isnewmap()
   1067   1.1      cgd {
   1068   1.1      cgd 	return((termbuf.c_oflag & OPOST) && (termbuf.c_oflag & ONLCR) &&
   1069   1.1      cgd 			!(termbuf.c_oflag & ONLRET));
   1070   1.1      cgd }
   1071   1.1      cgd #endif
   1072   1.1      cgd 
   1073   1.3      cgd #ifdef PARENT_DOES_UTMP
   1074   1.1      cgd # ifndef NEWINIT
   1075   1.1      cgd extern	struct utmp wtmp;
   1076   1.1      cgd extern char wtmpf[];
   1077   1.1      cgd # else	/* NEWINIT */
   1078   1.1      cgd int	gotalarm;
   1079   1.1      cgd 
   1080   1.1      cgd 	/* ARGSUSED */
   1081   1.1      cgd 	void
   1082   1.1      cgd nologinproc(sig)
   1083   1.1      cgd 	int sig;
   1084   1.1      cgd {
   1085   1.1      cgd 	gotalarm++;
   1086   1.1      cgd }
   1087   1.1      cgd # endif	/* NEWINIT */
   1088   1.3      cgd #endif /* PARENT_DOES_UTMP */
   1089   1.1      cgd 
   1090   1.1      cgd #ifndef	NEWINIT
   1091   1.3      cgd # ifdef PARENT_DOES_UTMP
   1092   1.1      cgd extern void utmp_sig_init P((void));
   1093   1.1      cgd extern void utmp_sig_reset P((void));
   1094   1.1      cgd extern void utmp_sig_wait P((void));
   1095   1.1      cgd extern void utmp_sig_notify P((int));
   1096   1.3      cgd # endif /* PARENT_DOES_UTMP */
   1097   1.1      cgd #endif
   1098   1.1      cgd 
   1099   1.1      cgd /*
   1100   1.1      cgd  * getptyslave()
   1101   1.1      cgd  *
   1102   1.1      cgd  * Open the slave side of the pty, and do any initialization
   1103   1.1      cgd  * that is necessary.  The return value is a file descriptor
   1104   1.1      cgd  * for the slave side.
   1105   1.1      cgd  */
   1106  1.11      mrg 	void
   1107   1.1      cgd getptyslave()
   1108   1.1      cgd {
   1109   1.1      cgd 	register int t = -1;
   1110   1.1      cgd 
   1111   1.1      cgd #if	!defined(CRAY) || !defined(NEWINIT)
   1112   1.1      cgd # ifdef	LINEMODE
   1113   1.1      cgd 	int waslm;
   1114   1.1      cgd # endif
   1115   1.1      cgd # ifdef	TIOCGWINSZ
   1116   1.1      cgd 	struct winsize ws;
   1117   1.1      cgd 	extern int def_row, def_col;
   1118   1.1      cgd # endif
   1119   1.1      cgd 	extern int def_tspeed, def_rspeed;
   1120   1.1      cgd 	/*
   1121   1.1      cgd 	 * Opening the slave side may cause initilization of the
   1122   1.1      cgd 	 * kernel tty structure.  We need remember the state of
   1123   1.1      cgd 	 * 	if linemode was turned on
   1124   1.1      cgd 	 *	terminal window size
   1125   1.1      cgd 	 *	terminal speed
   1126   1.1      cgd 	 * so that we can re-set them if we need to.
   1127   1.1      cgd 	 */
   1128   1.1      cgd # ifdef	LINEMODE
   1129   1.1      cgd 	waslm = tty_linemode();
   1130   1.1      cgd # endif
   1131   1.1      cgd 
   1132   1.1      cgd 
   1133   1.1      cgd 	/*
   1134   1.1      cgd 	 * Make sure that we don't have a controlling tty, and
   1135   1.1      cgd 	 * that we are the session (process group) leader.
   1136   1.1      cgd 	 */
   1137   1.1      cgd # ifdef	TIOCNOTTY
   1138   1.1      cgd 	t = open(_PATH_TTY, O_RDWR);
   1139   1.1      cgd 	if (t >= 0) {
   1140   1.1      cgd 		(void) ioctl(t, TIOCNOTTY, (char *)0);
   1141   1.1      cgd 		(void) close(t);
   1142   1.1      cgd 	}
   1143   1.1      cgd # endif
   1144   1.1      cgd 
   1145   1.1      cgd 
   1146   1.3      cgd # ifdef PARENT_DOES_UTMP
   1147   1.1      cgd 	/*
   1148   1.1      cgd 	 * Wait for our parent to get the utmp stuff to get done.
   1149   1.1      cgd 	 */
   1150   1.1      cgd 	utmp_sig_wait();
   1151   1.1      cgd # endif
   1152   1.1      cgd 
   1153   1.1      cgd 	t = cleanopen(line);
   1154   1.1      cgd 	if (t < 0)
   1155   1.1      cgd 		fatalperror(net, line);
   1156   1.1      cgd 
   1157   1.3      cgd #ifdef  STREAMSPTY
   1158   1.3      cgd #ifdef	USE_TERMIO
   1159   1.3      cgd 	ttyfd = t;
   1160   1.3      cgd #endif
   1161   1.6      jtk 	if (ioctl(t, I_PUSH, "ptem") < 0)
   1162   1.3      cgd 		fatal(net, "I_PUSH ptem");
   1163   1.3      cgd 	if (ioctl(t, I_PUSH, "ldterm") < 0)
   1164   1.3      cgd 		fatal(net, "I_PUSH ldterm");
   1165   1.3      cgd 	if (ioctl(t, I_PUSH, "ttcompat") < 0)
   1166   1.3      cgd 		fatal(net, "I_PUSH ttcompat");
   1167   1.3      cgd 	if (ioctl(pty, I_PUSH, "pckt") < 0)
   1168   1.3      cgd 		fatal(net, "I_PUSH pckt");
   1169   1.3      cgd #endif
   1170   1.3      cgd 
   1171   1.1      cgd 	/*
   1172   1.1      cgd 	 * set up the tty modes as we like them to be.
   1173   1.1      cgd 	 */
   1174   1.1      cgd 	init_termbuf();
   1175   1.1      cgd # ifdef	TIOCGWINSZ
   1176   1.1      cgd 	if (def_row || def_col) {
   1177   1.6      jtk 		memset((char *)&ws, 0, sizeof(ws));
   1178   1.1      cgd 		ws.ws_col = def_col;
   1179   1.1      cgd 		ws.ws_row = def_row;
   1180   1.1      cgd 		(void)ioctl(t, TIOCSWINSZ, (char *)&ws);
   1181   1.1      cgd 	}
   1182   1.1      cgd # endif
   1183   1.1      cgd 
   1184   1.1      cgd 	/*
   1185   1.1      cgd 	 * Settings for sgtty based systems
   1186   1.1      cgd 	 */
   1187   1.1      cgd # ifndef	USE_TERMIO
   1188   1.1      cgd 	termbuf.sg.sg_flags |= CRMOD|ANYP|ECHO|XTABS;
   1189   1.1      cgd # endif	/* USE_TERMIO */
   1190   1.1      cgd 
   1191   1.1      cgd 	/*
   1192   1.3      cgd 	 * Settings for UNICOS (and HPUX)
   1193   1.1      cgd 	 */
   1194   1.3      cgd # if defined(CRAY) || defined(__hpux)
   1195   1.1      cgd 	termbuf.c_oflag = OPOST|ONLCR|TAB3;
   1196   1.1      cgd 	termbuf.c_iflag = IGNPAR|ISTRIP|ICRNL|IXON;
   1197   1.1      cgd 	termbuf.c_lflag = ISIG|ICANON|ECHO|ECHOE|ECHOK;
   1198   1.1      cgd 	termbuf.c_cflag = EXTB|HUPCL|CS8;
   1199   1.1      cgd # endif
   1200   1.1      cgd 
   1201   1.1      cgd 	/*
   1202   1.1      cgd 	 * Settings for all other termios/termio based
   1203   1.1      cgd 	 * systems, other than 4.4BSD.  In 4.4BSD the
   1204   1.1      cgd 	 * kernel does the initial terminal setup.
   1205   1.1      cgd 	 */
   1206   1.3      cgd # if defined(USE_TERMIO) && !(defined(CRAY) || defined(__hpux)) && (BSD <= 43)
   1207   1.1      cgd #  ifndef	OXTABS
   1208   1.1      cgd #   define OXTABS	0
   1209   1.1      cgd #  endif
   1210   1.1      cgd 	termbuf.c_lflag |= ECHO;
   1211   1.1      cgd 	termbuf.c_oflag |= ONLCR|OXTABS;
   1212   1.1      cgd 	termbuf.c_iflag |= ICRNL;
   1213   1.1      cgd 	termbuf.c_iflag &= ~IXOFF;
   1214   1.1      cgd # endif /* defined(USE_TERMIO) && !defined(CRAY) && (BSD <= 43) */
   1215   1.1      cgd 	tty_rspeed((def_rspeed > 0) ? def_rspeed : 9600);
   1216   1.1      cgd 	tty_tspeed((def_tspeed > 0) ? def_tspeed : 9600);
   1217   1.1      cgd # ifdef	LINEMODE
   1218   1.1      cgd 	if (waslm)
   1219   1.1      cgd 		tty_setlinemode(1);
   1220   1.1      cgd # endif	/* LINEMODE */
   1221   1.1      cgd 
   1222   1.1      cgd 	/*
   1223   1.1      cgd 	 * Set the tty modes, and make this our controlling tty.
   1224   1.1      cgd 	 */
   1225   1.1      cgd 	set_termbuf();
   1226   1.1      cgd 	if (login_tty(t) == -1)
   1227   1.1      cgd 		fatalperror(net, "login_tty");
   1228   1.1      cgd #endif	/* !defined(CRAY) || !defined(NEWINIT) */
   1229   1.1      cgd 	if (net > 2)
   1230   1.1      cgd 		(void) close(net);
   1231   1.3      cgd #if	defined(AUTHENTICATION) && defined(NO_LOGIN_F) && defined(LOGIN_R)
   1232   1.3      cgd 	/*
   1233   1.3      cgd 	 * Leave the pty open so that we can write out the rlogin
   1234   1.3      cgd 	 * protocol for /bin/login, if the authentication works.
   1235   1.3      cgd 	 */
   1236   1.3      cgd #else
   1237   1.3      cgd 	if (pty > 2) {
   1238   1.1      cgd 		(void) close(pty);
   1239   1.3      cgd 		pty = -1;
   1240   1.3      cgd 	}
   1241   1.3      cgd #endif
   1242   1.1      cgd }
   1243   1.1      cgd 
   1244   1.1      cgd #if	!defined(CRAY) || !defined(NEWINIT)
   1245   1.1      cgd #ifndef	O_NOCTTY
   1246   1.1      cgd #define	O_NOCTTY	0
   1247   1.1      cgd #endif
   1248   1.1      cgd /*
   1249   1.1      cgd  * Open the specified slave side of the pty,
   1250   1.1      cgd  * making sure that we have a clean tty.
   1251   1.1      cgd  */
   1252   1.1      cgd 	int
   1253   1.1      cgd cleanopen(line)
   1254   1.1      cgd 	char *line;
   1255   1.1      cgd {
   1256  1.13    perry #ifdef OPENPTY_PTY
   1257  1.13    perry 	return ptyslavefd;
   1258  1.13    perry #else /* ! OPENPTY_PTY */
   1259   1.1      cgd 	register int t;
   1260   1.6      jtk #ifdef	UNICOS7x
   1261   1.3      cgd 	struct secstat secbuf;
   1262   1.6      jtk #endif	/* UNICOS7x */
   1263   1.1      cgd 
   1264   1.3      cgd #ifndef STREAMSPTY
   1265   1.1      cgd 	/*
   1266   1.1      cgd 	 * Make sure that other people can't open the
   1267   1.1      cgd 	 * slave side of the connection.
   1268   1.1      cgd 	 */
   1269   1.1      cgd 	(void) chown(line, 0, 0);
   1270   1.1      cgd 	(void) chmod(line, 0600);
   1271   1.3      cgd #endif
   1272   1.1      cgd 
   1273   1.1      cgd # if !defined(CRAY) && (BSD > 43)
   1274   1.1      cgd 	(void) revoke(line);
   1275   1.1      cgd # endif
   1276   1.6      jtk #ifdef	UNICOS7x
   1277   1.3      cgd 	if (secflag) {
   1278   1.3      cgd 		if (secstat(line, &secbuf) < 0)
   1279   1.3      cgd 			return(-1);
   1280   1.3      cgd 		if (setulvl(secbuf.st_slevel) < 0)
   1281   1.3      cgd 			return(-1);
   1282   1.3      cgd 		if (setucmp(secbuf.st_compart) < 0)
   1283   1.3      cgd 			return(-1);
   1284   1.3      cgd 	}
   1285   1.6      jtk #endif	/* UNICOS7x */
   1286   1.3      cgd 
   1287   1.1      cgd 	t = open(line, O_RDWR|O_NOCTTY);
   1288   1.3      cgd 
   1289   1.6      jtk #ifdef	UNICOS7x
   1290   1.3      cgd 	if (secflag) {
   1291   1.3      cgd 		if (setulvl(sysv.sy_minlvl) < 0)
   1292   1.3      cgd 			return(-1);
   1293   1.3      cgd 		if (setucmp(0) < 0)
   1294   1.3      cgd 			return(-1);
   1295   1.3      cgd 	}
   1296   1.6      jtk #endif	/* UNICOS7x */
   1297   1.3      cgd 
   1298   1.1      cgd 	if (t < 0)
   1299   1.1      cgd 		return(-1);
   1300   1.1      cgd 
   1301   1.1      cgd 	/*
   1302   1.1      cgd 	 * Hangup anybody else using this ttyp, then reopen it for
   1303   1.1      cgd 	 * ourselves.
   1304   1.1      cgd 	 */
   1305   1.3      cgd # if !(defined(CRAY) || defined(__hpux)) && (BSD <= 43) && !defined(STREAMSPTY)
   1306   1.1      cgd 	(void) signal(SIGHUP, SIG_IGN);
   1307   1.1      cgd 	vhangup();
   1308   1.1      cgd 	(void) signal(SIGHUP, SIG_DFL);
   1309   1.1      cgd 	t = open(line, O_RDWR|O_NOCTTY);
   1310   1.1      cgd 	if (t < 0)
   1311   1.1      cgd 		return(-1);
   1312   1.1      cgd # endif
   1313   1.1      cgd # if	defined(CRAY) && defined(TCVHUP)
   1314   1.1      cgd 	{
   1315   1.1      cgd 		register int i;
   1316   1.1      cgd 		(void) signal(SIGHUP, SIG_IGN);
   1317   1.1      cgd 		(void) ioctl(t, TCVHUP, (char *)0);
   1318   1.1      cgd 		(void) signal(SIGHUP, SIG_DFL);
   1319   1.3      cgd 
   1320   1.6      jtk #ifdef	UNICOS7x
   1321   1.3      cgd 		if (secflag) {
   1322   1.3      cgd 			if (secstat(line, &secbuf) < 0)
   1323   1.3      cgd 				return(-1);
   1324   1.3      cgd 			if (setulvl(secbuf.st_slevel) < 0)
   1325   1.3      cgd 				return(-1);
   1326   1.3      cgd 			if (setucmp(secbuf.st_compart) < 0)
   1327   1.3      cgd 				return(-1);
   1328   1.3      cgd 		}
   1329   1.6      jtk #endif	/* UNICOS7x */
   1330   1.3      cgd 
   1331   1.1      cgd 		i = open(line, O_RDWR);
   1332   1.3      cgd 
   1333   1.6      jtk #ifdef	UNICOS7x
   1334   1.3      cgd 		if (secflag) {
   1335   1.3      cgd 			if (setulvl(sysv.sy_minlvl) < 0)
   1336   1.3      cgd 				return(-1);
   1337   1.3      cgd 			if (setucmp(0) < 0)
   1338   1.3      cgd 				return(-1);
   1339   1.3      cgd 		}
   1340   1.6      jtk #endif	/* UNICOS7x */
   1341   1.3      cgd 
   1342   1.1      cgd 		if (i < 0)
   1343   1.1      cgd 			return(-1);
   1344   1.1      cgd 		(void) close(t);
   1345   1.1      cgd 		t = i;
   1346   1.1      cgd 	}
   1347   1.1      cgd # endif	/* defined(CRAY) && defined(TCVHUP) */
   1348   1.1      cgd 	return(t);
   1349  1.13    perry #endif /* OPENPTY_PTY */
   1350   1.1      cgd }
   1351   1.1      cgd #endif	/* !defined(CRAY) || !defined(NEWINIT) */
   1352   1.1      cgd 
   1353   1.1      cgd #if BSD <= 43
   1354   1.3      cgd 
   1355   1.1      cgd 	int
   1356   1.1      cgd login_tty(t)
   1357   1.1      cgd 	int t;
   1358   1.1      cgd {
   1359   1.3      cgd 	if (setsid() < 0) {
   1360   1.3      cgd #ifdef ultrix
   1361   1.3      cgd 		/*
   1362   1.3      cgd 		 * The setsid() may have failed because we
   1363   1.3      cgd 		 * already have a pgrp == pid.  Zero out
   1364   1.3      cgd 		 * our pgrp and try again...
   1365   1.3      cgd 		 */
   1366   1.3      cgd 		if ((setpgrp(0, 0) < 0) || (setsid() < 0))
   1367   1.3      cgd #endif
   1368   1.3      cgd 			fatalperror(net, "setsid()");
   1369   1.3      cgd 	}
   1370   1.1      cgd # ifdef	TIOCSCTTY
   1371   1.1      cgd 	if (ioctl(t, TIOCSCTTY, (char *)0) < 0)
   1372   1.1      cgd 		fatalperror(net, "ioctl(sctty)");
   1373   1.3      cgd #  if defined(CRAY)
   1374   1.1      cgd 	/*
   1375   1.1      cgd 	 * Close the hard fd to /dev/ttypXXX, and re-open through
   1376   1.1      cgd 	 * the indirect /dev/tty interface.
   1377   1.1      cgd 	 */
   1378   1.1      cgd 	close(t);
   1379   1.1      cgd 	if ((t = open("/dev/tty", O_RDWR)) < 0)
   1380   1.1      cgd 		fatalperror(net, "open(/dev/tty)");
   1381   1.1      cgd #  endif
   1382   1.1      cgd # else
   1383   1.3      cgd 	/*
   1384   1.3      cgd 	 * We get our controlling tty assigned as a side-effect
   1385   1.3      cgd 	 * of opening up a tty device.  But on BSD based systems,
   1386   1.3      cgd 	 * this only happens if our process group is zero.  The
   1387   1.3      cgd 	 * setsid() call above may have set our pgrp, so clear
   1388   1.3      cgd 	 * it out before opening the tty...
   1389   1.3      cgd 	 */
   1390   1.6      jtk #  ifndef SOLARIS
   1391   1.3      cgd 	(void) setpgrp(0, 0);
   1392   1.6      jtk #  else
   1393   1.6      jtk 	(void) setpgrp();
   1394   1.6      jtk #  endif
   1395   1.1      cgd 	close(open(line, O_RDWR));
   1396   1.1      cgd # endif
   1397   1.1      cgd 	if (t != 0)
   1398   1.1      cgd 		(void) dup2(t, 0);
   1399   1.1      cgd 	if (t != 1)
   1400   1.1      cgd 		(void) dup2(t, 1);
   1401   1.1      cgd 	if (t != 2)
   1402   1.1      cgd 		(void) dup2(t, 2);
   1403   1.1      cgd 	if (t > 2)
   1404   1.1      cgd 		close(t);
   1405   1.1      cgd 	return(0);
   1406   1.1      cgd }
   1407   1.1      cgd #endif	/* BSD <= 43 */
   1408   1.1      cgd 
   1409   1.1      cgd #ifdef	NEWINIT
   1410   1.1      cgd char *gen_id = "fe";
   1411   1.1      cgd #endif
   1412   1.1      cgd 
   1413   1.1      cgd /*
   1414   1.1      cgd  * startslave(host)
   1415   1.1      cgd  *
   1416   1.1      cgd  * Given a hostname, do whatever
   1417   1.1      cgd  * is necessary to startup the login process on the slave side of the pty.
   1418   1.1      cgd  */
   1419   1.1      cgd 
   1420   1.1      cgd /* ARGSUSED */
   1421   1.1      cgd 	void
   1422   1.1      cgd startslave(host, autologin, autoname)
   1423   1.1      cgd 	char *host;
   1424   1.1      cgd 	int autologin;
   1425   1.1      cgd 	char *autoname;
   1426   1.1      cgd {
   1427   1.1      cgd 	register int i;
   1428   1.1      cgd #ifdef	NEWINIT
   1429   1.1      cgd 	extern char *ptyip;
   1430   1.1      cgd 	struct init_request request;
   1431   1.1      cgd 	void nologinproc();
   1432   1.1      cgd 	register int n;
   1433   1.1      cgd #endif	/* NEWINIT */
   1434   1.1      cgd 
   1435   1.3      cgd #if	defined(AUTHENTICATION)
   1436   1.1      cgd 	if (!autoname || !autoname[0])
   1437   1.1      cgd 		autologin = 0;
   1438   1.1      cgd 
   1439   1.1      cgd 	if (autologin < auth_level) {
   1440   1.1      cgd 		fatal(net, "Authorization failed");
   1441   1.1      cgd 		exit(1);
   1442   1.1      cgd 	}
   1443   1.1      cgd #endif
   1444   1.1      cgd 
   1445   1.1      cgd #ifndef	NEWINIT
   1446   1.3      cgd # ifdef	PARENT_DOES_UTMP
   1447   1.1      cgd 	utmp_sig_init();
   1448   1.3      cgd # endif	/* PARENT_DOES_UTMP */
   1449   1.1      cgd 
   1450   1.1      cgd 	if ((i = fork()) < 0)
   1451   1.1      cgd 		fatalperror(net, "fork");
   1452   1.1      cgd 	if (i) {
   1453   1.3      cgd # ifdef PARENT_DOES_UTMP
   1454   1.1      cgd 		/*
   1455   1.1      cgd 		 * Cray parent will create utmp entry for child and send
   1456   1.1      cgd 		 * signal to child to tell when done.  Child waits for signal
   1457   1.1      cgd 		 * before doing anything important.
   1458   1.1      cgd 		 */
   1459   1.1      cgd 		register int pid = i;
   1460   1.1      cgd 		void sigjob P((int));
   1461   1.1      cgd 
   1462   1.1      cgd 		setpgrp();
   1463   1.1      cgd 		utmp_sig_reset();		/* reset handler to default */
   1464   1.1      cgd 		/*
   1465   1.1      cgd 		 * Create utmp entry for child
   1466   1.1      cgd 		 */
   1467   1.1      cgd 		(void) time(&wtmp.ut_time);
   1468   1.1      cgd 		wtmp.ut_type = LOGIN_PROCESS;
   1469   1.1      cgd 		wtmp.ut_pid = pid;
   1470   1.1      cgd 		SCPYN(wtmp.ut_user, "LOGIN");
   1471   1.1      cgd 		SCPYN(wtmp.ut_host, host);
   1472   1.1      cgd 		SCPYN(wtmp.ut_line, line + sizeof("/dev/") - 1);
   1473   1.3      cgd #ifndef	__hpux
   1474   1.1      cgd 		SCPYN(wtmp.ut_id, wtmp.ut_line+3);
   1475   1.3      cgd #else
   1476   1.3      cgd 		SCPYN(wtmp.ut_id, wtmp.ut_line+7);
   1477   1.3      cgd #endif
   1478   1.1      cgd 		pututline(&wtmp);
   1479   1.1      cgd 		endutent();
   1480   1.1      cgd 		if ((i = open(wtmpf, O_WRONLY|O_APPEND)) >= 0) {
   1481   1.1      cgd 			(void) write(i, (char *)&wtmp, sizeof(struct utmp));
   1482   1.1      cgd 			(void) close(i);
   1483   1.1      cgd 		}
   1484   1.3      cgd #ifdef	CRAY
   1485   1.1      cgd 		(void) signal(WJSIGNAL, sigjob);
   1486   1.3      cgd #endif
   1487   1.1      cgd 		utmp_sig_notify(pid);
   1488   1.3      cgd # endif	/* PARENT_DOES_UTMP */
   1489   1.1      cgd 	} else {
   1490  1.11      mrg 		getptyslave();
   1491   1.1      cgd 		start_login(host, autologin, autoname);
   1492   1.1      cgd 		/*NOTREACHED*/
   1493   1.1      cgd 	}
   1494   1.1      cgd #else	/* NEWINIT */
   1495   1.1      cgd 
   1496   1.1      cgd 	/*
   1497   1.1      cgd 	 * Init will start up login process if we ask nicely.  We only wait
   1498   1.1      cgd 	 * for it to start up and begin normal telnet operation.
   1499   1.1      cgd 	 */
   1500   1.1      cgd 	if ((i = open(INIT_FIFO, O_WRONLY)) < 0) {
   1501   1.1      cgd 		char tbuf[128];
   1502  1.11      mrg 
   1503  1.11      mrg 		(void)snprintf(tbuf, sizeof tbuf, "Can't open %s\n", INIT_FIFO);
   1504   1.1      cgd 		fatalperror(net, tbuf);
   1505   1.1      cgd 	}
   1506   1.1      cgd 	memset((char *)&request, 0, sizeof(request));
   1507   1.1      cgd 	request.magic = INIT_MAGIC;
   1508   1.1      cgd 	SCPYN(request.gen_id, gen_id);
   1509   1.1      cgd 	SCPYN(request.tty_id, &line[8]);
   1510   1.1      cgd 	SCPYN(request.host, host);
   1511   1.1      cgd 	SCPYN(request.term_type, terminaltype ? terminaltype : "network");
   1512   1.1      cgd #if	!defined(UNICOS5)
   1513   1.1      cgd 	request.signal = SIGCLD;
   1514   1.1      cgd 	request.pid = getpid();
   1515   1.1      cgd #endif
   1516   1.1      cgd #ifdef BFTPDAEMON
   1517   1.1      cgd 	/*
   1518   1.1      cgd 	 * Are we working as the bftp daemon?
   1519   1.1      cgd 	 */
   1520   1.1      cgd 	if (bftpd) {
   1521   1.1      cgd 		SCPYN(request.exec_name, BFTPPATH);
   1522   1.1      cgd 	}
   1523   1.1      cgd #endif /* BFTPDAEMON */
   1524   1.1      cgd 	if (write(i, (char *)&request, sizeof(request)) < 0) {
   1525   1.1      cgd 		char tbuf[128];
   1526  1.11      mrg 
   1527  1.11      mrg 		(void)snprintf(tbuf, sizeof tbuf, "Can't write to %s\n", INIT_FIFO);
   1528   1.1      cgd 		fatalperror(net, tbuf);
   1529   1.1      cgd 	}
   1530   1.1      cgd 	(void) close(i);
   1531   1.1      cgd 	(void) signal(SIGALRM, nologinproc);
   1532   1.1      cgd 	for (i = 0; ; i++) {
   1533   1.1      cgd 		char tbuf[128];
   1534  1.11      mrg 
   1535   1.1      cgd 		alarm(15);
   1536   1.1      cgd 		n = read(pty, ptyip, BUFSIZ);
   1537   1.1      cgd 		if (i == 3 || n >= 0 || !gotalarm)
   1538   1.1      cgd 			break;
   1539   1.1      cgd 		gotalarm = 0;
   1540  1.11      mrg 		(void)snprintf(tbuf, sizeof tbuf,
   1541  1.11      mrg 		    "telnetd: waiting for /etc/init to start login process on %s\r\n", line);
   1542  1.11      mrg 		(void)write(net, tbuf, strlen(tbuf));
   1543   1.1      cgd 	}
   1544   1.1      cgd 	if (n < 0 && gotalarm)
   1545   1.1      cgd 		fatal(net, "/etc/init didn't start login process");
   1546   1.1      cgd 	pcc += n;
   1547   1.1      cgd 	alarm(0);
   1548   1.1      cgd 	(void) signal(SIGALRM, SIG_DFL);
   1549   1.1      cgd 
   1550   1.1      cgd 	return;
   1551   1.1      cgd #endif	/* NEWINIT */
   1552   1.1      cgd }
   1553   1.1      cgd 
   1554   1.1      cgd char	*envinit[3];
   1555   1.1      cgd extern char **environ;
   1556   1.1      cgd 
   1557   1.1      cgd 	void
   1558   1.1      cgd init_env()
   1559   1.1      cgd {
   1560   1.1      cgd 	char **envp;
   1561   1.1      cgd 
   1562   1.1      cgd 	envp = envinit;
   1563  1.11      mrg 	if ((*envp = getenv("TZ")))
   1564   1.1      cgd 		*envp++ -= 3;
   1565   1.3      cgd #if	defined(CRAY) || defined(__hpux)
   1566   1.1      cgd 	else
   1567   1.1      cgd 		*envp++ = "TZ=GMT0";
   1568   1.1      cgd #endif
   1569   1.1      cgd 	*envp = 0;
   1570   1.1      cgd 	environ = envinit;
   1571   1.1      cgd }
   1572   1.1      cgd 
   1573   1.1      cgd #ifndef	NEWINIT
   1574   1.1      cgd 
   1575   1.1      cgd /*
   1576   1.1      cgd  * start_login(host)
   1577   1.1      cgd  *
   1578   1.1      cgd  * Assuming that we are now running as a child processes, this
   1579   1.1      cgd  * function will turn us into the login process.
   1580   1.1      cgd  */
   1581   1.1      cgd 
   1582   1.1      cgd 	void
   1583   1.1      cgd start_login(host, autologin, name)
   1584   1.1      cgd 	char *host;
   1585   1.1      cgd 	int autologin;
   1586   1.1      cgd 	char *name;
   1587   1.1      cgd {
   1588   1.1      cgd 	register char **argv;
   1589   1.9      tls 	extern char *gettyname;
   1590   1.9      tls #define	TABBUFSIZ	512
   1591   1.9      tls 	char	defent[TABBUFSIZ];
   1592   1.9      tls 	char	defstrs[TABBUFSIZ];
   1593   1.9      tls #undef	TABBUFSIZ
   1594  1.11      mrg 	char *loginprog = NULL;
   1595   1.3      cgd #ifdef	UTMPX
   1596   1.3      cgd 	register int pid = getpid();
   1597   1.3      cgd 	struct utmpx utmpx;
   1598   1.3      cgd #endif
   1599   1.3      cgd #ifdef SOLARIS
   1600   1.3      cgd 	char *term;
   1601   1.3      cgd 	char termbuf[64];
   1602   1.3      cgd #endif
   1603   1.3      cgd 
   1604   1.3      cgd #ifdef	UTMPX
   1605   1.3      cgd 	/*
   1606   1.3      cgd 	 * Create utmp entry for child
   1607   1.3      cgd 	 */
   1608   1.3      cgd 
   1609   1.6      jtk 	memset(&utmpx, 0, sizeof(utmpx));
   1610   1.3      cgd 	SCPYN(utmpx.ut_user, ".telnet");
   1611   1.3      cgd 	SCPYN(utmpx.ut_line, line + sizeof("/dev/") - 1);
   1612   1.3      cgd 	utmpx.ut_pid = pid;
   1613   1.3      cgd 	utmpx.ut_id[0] = 't';
   1614   1.3      cgd 	utmpx.ut_id[1] = 'n';
   1615   1.3      cgd 	utmpx.ut_id[2] = SC_WILDC;
   1616   1.3      cgd 	utmpx.ut_id[3] = SC_WILDC;
   1617   1.3      cgd 	utmpx.ut_type = LOGIN_PROCESS;
   1618   1.3      cgd 	(void) time(&utmpx.ut_tv.tv_sec);
   1619   1.3      cgd 	if (makeutx(&utmpx) == NULL)
   1620   1.3      cgd 		fatal(net, "makeutx failed");
   1621   1.3      cgd #endif
   1622   1.1      cgd 
   1623   1.6      jtk 	scrub_env();
   1624   1.6      jtk 
   1625   1.1      cgd 	/*
   1626   1.1      cgd 	 * -h : pass on name of host.
   1627   1.1      cgd 	 *		WARNING:  -h is accepted by login if and only if
   1628   1.1      cgd 	 *			getuid() == 0.
   1629   1.1      cgd 	 * -p : don't clobber the environment (so terminal type stays set).
   1630   1.1      cgd 	 *
   1631   1.1      cgd 	 * -f : force this login, he has already been authenticated
   1632   1.1      cgd 	 */
   1633   1.1      cgd 	argv = addarg(0, "login");
   1634   1.3      cgd 
   1635   1.3      cgd #if	!defined(NO_LOGIN_H)
   1636   1.3      cgd 
   1637   1.3      cgd # if	defined (AUTHENTICATION) && defined(NO_LOGIN_F) && defined(LOGIN_R)
   1638   1.3      cgd 	/*
   1639   1.3      cgd 	 * Don't add the "-h host" option if we are going
   1640   1.3      cgd 	 * to be adding the "-r host" option down below...
   1641   1.3      cgd 	 */
   1642   1.3      cgd 	if ((auth_level < 0) || (autologin != AUTH_VALID))
   1643   1.3      cgd # endif
   1644   1.3      cgd 	{
   1645   1.3      cgd 		argv = addarg(argv, "-h");
   1646   1.3      cgd 		argv = addarg(argv, host);
   1647   1.3      cgd #ifdef	SOLARIS
   1648   1.3      cgd 		/*
   1649   1.3      cgd 		 * SVR4 version of -h takes TERM= as second arg, or -
   1650   1.3      cgd 		 */
   1651   1.3      cgd 		term = getenv("TERM");
   1652   1.3      cgd 		if (term == NULL || term[0] == 0) {
   1653   1.3      cgd 			term = "-";
   1654   1.3      cgd 		} else {
   1655   1.3      cgd 			strcpy(termbuf, "TERM=");
   1656   1.3      cgd 			strncat(termbuf, term, sizeof(termbuf) - 6);
   1657   1.3      cgd 			term = termbuf;
   1658   1.3      cgd 		}
   1659   1.3      cgd 		argv = addarg(argv, term);
   1660   1.3      cgd #endif
   1661   1.3      cgd 	}
   1662   1.3      cgd #endif
   1663   1.1      cgd #if	!defined(NO_LOGIN_P)
   1664   1.1      cgd 	argv = addarg(argv, "-p");
   1665   1.1      cgd #endif
   1666   1.6      jtk #ifdef	LINEMODE
   1667   1.6      jtk 	/*
   1668   1.6      jtk 	 * Set the environment variable "LINEMODE" to either
   1669   1.6      jtk 	 * "real" or "kludge" if we are operating in either
   1670   1.6      jtk 	 * real or kludge linemode.
   1671   1.6      jtk 	 */
   1672   1.6      jtk 	if (lmodetype == REAL_LINEMODE)
   1673   1.6      jtk 		setenv("LINEMODE", "real", 1);
   1674   1.6      jtk # ifdef KLUDGELINEMODE
   1675   1.6      jtk 	else if (lmodetype == KLUDGE_LINEMODE || lmodetype == KLUDGE_OK)
   1676   1.6      jtk 		setenv("LINEMODE", "kludge", 1);
   1677   1.6      jtk # endif
   1678   1.6      jtk #endif
   1679   1.1      cgd #ifdef	BFTPDAEMON
   1680   1.1      cgd 	/*
   1681   1.1      cgd 	 * Are we working as the bftp daemon?  If so, then ask login
   1682   1.1      cgd 	 * to start bftp instead of shell.
   1683   1.1      cgd 	 */
   1684   1.1      cgd 	if (bftpd) {
   1685   1.1      cgd 		argv = addarg(argv, "-e");
   1686   1.1      cgd 		argv = addarg(argv, BFTPPATH);
   1687   1.6      jtk 	} else
   1688   1.1      cgd #endif
   1689   1.1      cgd #if	defined (SecurID)
   1690   1.1      cgd 	/*
   1691   1.1      cgd 	 * don't worry about the -f that might get sent.
   1692   1.1      cgd 	 * A -s is supposed to override it anyhow.
   1693   1.1      cgd 	 */
   1694   1.1      cgd 	if (require_SecurID)
   1695   1.1      cgd 		argv = addarg(argv, "-s");
   1696   1.1      cgd #endif
   1697   1.3      cgd #if	defined (AUTHENTICATION)
   1698   1.1      cgd 	if (auth_level >= 0 && autologin == AUTH_VALID) {
   1699   1.1      cgd # if	!defined(NO_LOGIN_F)
   1700   1.1      cgd 		argv = addarg(argv, "-f");
   1701   1.5  mycroft 		argv = addarg(argv, "--");
   1702   1.3      cgd 		argv = addarg(argv, name);
   1703   1.3      cgd # else
   1704   1.3      cgd #  if defined(LOGIN_R)
   1705   1.3      cgd 		/*
   1706   1.3      cgd 		 * We don't have support for "login -f", but we
   1707   1.3      cgd 		 * can fool /bin/login into thinking that we are
   1708   1.3      cgd 		 * rlogind, and allow us to log in without a
   1709   1.3      cgd 		 * password.  The rlogin protocol expects
   1710   1.3      cgd 		 *	local-user\0remote-user\0term/speed\0
   1711   1.3      cgd 		 */
   1712   1.3      cgd 
   1713   1.3      cgd 		if (pty > 2) {
   1714   1.3      cgd 			register char *cp;
   1715   1.3      cgd 			char speed[128];
   1716   1.3      cgd 			int isecho, israw, xpty, len;
   1717   1.3      cgd 			extern int def_rspeed;
   1718   1.3      cgd #  ifndef LOGIN_HOST
   1719   1.3      cgd 			/*
   1720   1.3      cgd 			 * Tell login that we are coming from "localhost".
   1721   1.3      cgd 			 * If we passed in the real host name, then the
   1722   1.3      cgd 			 * user would have to allow .rhost access from
   1723   1.3      cgd 			 * every machine that they want authenticated
   1724   1.3      cgd 			 * access to work from, which sort of defeats
   1725   1.3      cgd 			 * the purpose of an authenticated login...
   1726   1.3      cgd 			 * So, we tell login that the session is coming
   1727   1.3      cgd 			 * from "localhost", and the user will only have
   1728   1.3      cgd 			 * to have "localhost" in their .rhost file.
   1729   1.3      cgd 			 */
   1730   1.3      cgd #			define LOGIN_HOST "localhost"
   1731   1.3      cgd #  endif
   1732   1.3      cgd 			argv = addarg(argv, "-r");
   1733   1.3      cgd 			argv = addarg(argv, LOGIN_HOST);
   1734   1.3      cgd 
   1735   1.3      cgd 			xpty = pty;
   1736   1.3      cgd # ifndef  STREAMSPTY
   1737   1.3      cgd 			pty = 0;
   1738   1.3      cgd # else
   1739   1.3      cgd 			ttyfd = 0;
   1740   1.1      cgd # endif
   1741   1.3      cgd 			init_termbuf();
   1742   1.3      cgd 			isecho = tty_isecho();
   1743   1.3      cgd 			israw = tty_israw();
   1744   1.3      cgd 			if (isecho || !israw) {
   1745   1.3      cgd 				tty_setecho(0);		/* Turn off echo */
   1746   1.3      cgd 				tty_setraw(1);		/* Turn on raw */
   1747   1.3      cgd 				set_termbuf();
   1748   1.3      cgd 			}
   1749   1.3      cgd 			len = strlen(name)+1;
   1750   1.3      cgd 			write(xpty, name, len);
   1751   1.3      cgd 			write(xpty, name, len);
   1752   1.3      cgd 			sprintf(speed, "%s/%d", (cp = getenv("TERM")) ? cp : "",
   1753   1.3      cgd 				(def_rspeed > 0) ? def_rspeed : 9600);
   1754   1.3      cgd 			len = strlen(speed)+1;
   1755   1.3      cgd 			write(xpty, speed, len);
   1756   1.3      cgd 
   1757   1.3      cgd 			if (isecho || !israw) {
   1758   1.3      cgd 				init_termbuf();
   1759   1.3      cgd 				tty_setecho(isecho);
   1760   1.3      cgd 				tty_setraw(israw);
   1761   1.3      cgd 				set_termbuf();
   1762   1.3      cgd 				if (!israw) {
   1763   1.3      cgd 					/*
   1764   1.3      cgd 					 * Write a newline to ensure
   1765   1.3      cgd 					 * that login will be able to
   1766   1.3      cgd 					 * read the line...
   1767   1.3      cgd 					 */
   1768   1.3      cgd 					write(xpty, "\n", 1);
   1769   1.3      cgd 				}
   1770   1.3      cgd 			}
   1771   1.3      cgd 			pty = xpty;
   1772   1.3      cgd 		}
   1773   1.3      cgd #  else
   1774   1.5  mycroft 		argv = addarg(argv, "--");
   1775   1.1      cgd 		argv = addarg(argv, name);
   1776   1.3      cgd #  endif
   1777   1.3      cgd # endif
   1778   1.1      cgd 	} else
   1779   1.1      cgd #endif
   1780   1.1      cgd 	if (getenv("USER")) {
   1781   1.5  mycroft 		argv = addarg(argv, "--");
   1782   1.1      cgd 		argv = addarg(argv, getenv("USER"));
   1783   1.3      cgd #if	defined(LOGIN_ARGS) && defined(NO_LOGIN_P)
   1784   1.1      cgd 		{
   1785   1.1      cgd 			register char **cpp;
   1786   1.1      cgd 			for (cpp = environ; *cpp; cpp++)
   1787   1.1      cgd 				argv = addarg(argv, *cpp);
   1788   1.1      cgd 		}
   1789   1.1      cgd #endif
   1790   1.3      cgd 		/*
   1791   1.3      cgd 		 * Assume that login will set the USER variable
   1792   1.3      cgd 		 * correctly.  For SysV systems, this means that
   1793   1.3      cgd 		 * USER will no longer be set, just LOGNAME by
   1794   1.3      cgd 		 * login.  (The problem is that if the auto-login
   1795   1.3      cgd 		 * fails, and the user then specifies a different
   1796   1.3      cgd 		 * account name, he can get logged in with both
   1797   1.3      cgd 		 * LOGNAME and USER in his environment, but the
   1798   1.3      cgd 		 * USER value will be wrong.
   1799   1.3      cgd 		 */
   1800   1.3      cgd 		unsetenv("USER");
   1801   1.1      cgd 	}
   1802   1.6      jtk #ifdef	SOLARIS
   1803   1.6      jtk 	else {
   1804   1.6      jtk 		char **p;
   1805   1.6      jtk 
   1806   1.6      jtk 		argv = addarg(argv, "");	/* no login name */
   1807   1.6      jtk 		for (p = environ; *p; p++) {
   1808   1.6      jtk 			argv = addarg(argv, *p);
   1809   1.6      jtk 		}
   1810   1.6      jtk 	}
   1811   1.6      jtk #endif	/* SOLARIS */
   1812   1.3      cgd #if	defined(AUTHENTICATION) && defined(NO_LOGIN_F) && defined(LOGIN_R)
   1813   1.3      cgd 	if (pty > 2)
   1814   1.3      cgd 		close(pty);
   1815   1.3      cgd #endif
   1816   1.9      tls         if (getent(defent, gettyname) == 1) {
   1817   1.9      tls                 char *cp = defstrs;
   1818   1.9      tls 
   1819   1.9      tls                 loginprog = getstr("lo", &cp);
   1820   1.9      tls         }
   1821   1.9      tls         if (loginprog == NULL)
   1822   1.9      tls                 loginprog = _PATH_LOGIN;
   1823   1.1      cgd 	closelog();
   1824   1.6      jtk 	/*
   1825   1.6      jtk 	 * This sleep(1) is in here so that telnetd can
   1826   1.6      jtk 	 * finish up with the tty.  There's a race condition
   1827   1.6      jtk 	 * the login banner message gets lost...
   1828   1.6      jtk 	 */
   1829   1.6      jtk 	sleep(1);
   1830   1.9      tls         execv(loginprog, argv);
   1831   1.1      cgd 
   1832   1.9      tls         syslog(LOG_ERR, "%s: %m\n", loginprog);
   1833   1.9      tls         fatalperror(net, loginprog);
   1834   1.1      cgd 	/*NOTREACHED*/
   1835   1.1      cgd }
   1836   1.1      cgd 
   1837   1.1      cgd 	char **
   1838   1.1      cgd addarg(argv, val)
   1839   1.1      cgd 	register char **argv;
   1840   1.1      cgd 	register char *val;
   1841   1.1      cgd {
   1842   1.1      cgd 	register char **cpp;
   1843   1.1      cgd 
   1844   1.1      cgd 	if (argv == NULL) {
   1845   1.1      cgd 		/*
   1846   1.1      cgd 		 * 10 entries, a leading length, and a null
   1847   1.1      cgd 		 */
   1848   1.1      cgd 		argv = (char **)malloc(sizeof(*argv) * 12);
   1849   1.1      cgd 		if (argv == NULL)
   1850   1.1      cgd 			return(NULL);
   1851   1.1      cgd 		*argv++ = (char *)10;
   1852   1.1      cgd 		*argv = (char *)0;
   1853   1.1      cgd 	}
   1854   1.1      cgd 	for (cpp = argv; *cpp; cpp++)
   1855   1.1      cgd 		;
   1856   1.7      jtk 	if (cpp == &argv[(long)argv[-1]]) {
   1857   1.1      cgd 		--argv;
   1858   1.7      jtk 		*argv = (char *)((long)(*argv) + 10);
   1859   1.7      jtk 		argv = (char **)realloc(argv, sizeof(*argv)*((long)(*argv) + 2));
   1860   1.1      cgd 		if (argv == NULL)
   1861   1.1      cgd 			return(NULL);
   1862   1.1      cgd 		argv++;
   1863   1.7      jtk 		cpp = &argv[(long)argv[-1] - 10];
   1864   1.1      cgd 	}
   1865   1.1      cgd 	*cpp++ = val;
   1866   1.1      cgd 	*cpp = 0;
   1867   1.1      cgd 	return(argv);
   1868   1.1      cgd }
   1869   1.1      cgd #endif	/* NEWINIT */
   1870   1.1      cgd 
   1871   1.1      cgd /*
   1872   1.6      jtk  * scrub_env()
   1873   1.6      jtk  *
   1874   1.6      jtk  * Remove a few things from the environment that
   1875   1.6      jtk  * don't need to be there.
   1876   1.6      jtk  */
   1877  1.11      mrg void
   1878   1.6      jtk scrub_env()
   1879   1.6      jtk {
   1880   1.6      jtk 	register char **cpp, **cpp2;
   1881   1.6      jtk 
   1882   1.6      jtk 	for (cpp2 = cpp = environ; *cpp; cpp++) {
   1883   1.6      jtk 		if (strncmp(*cpp, "LD_", 3) &&
   1884   1.6      jtk 		    strncmp(*cpp, "_RLD_", 5) &&
   1885   1.6      jtk 		    strncmp(*cpp, "LIBPATH=", 8) &&
   1886   1.6      jtk 		    strncmp(*cpp, "IFS=", 4))
   1887   1.6      jtk 			*cpp2++ = *cpp;
   1888   1.6      jtk 	}
   1889   1.6      jtk 	*cpp2 = 0;
   1890   1.6      jtk }
   1891   1.6      jtk 
   1892   1.6      jtk /*
   1893   1.1      cgd  * cleanup()
   1894   1.1      cgd  *
   1895   1.1      cgd  * This is the routine to call when we are all through, to
   1896   1.1      cgd  * clean up anything that needs to be cleaned up.
   1897   1.1      cgd  */
   1898   1.1      cgd 	/* ARGSUSED */
   1899   1.1      cgd 	void
   1900   1.1      cgd cleanup(sig)
   1901   1.1      cgd 	int sig;
   1902   1.1      cgd {
   1903   1.3      cgd #ifndef	PARENT_DOES_UTMP
   1904   1.1      cgd # if (BSD > 43) || defined(convex)
   1905  1.14   tsarna 	char *p, c;
   1906   1.1      cgd 
   1907   1.1      cgd 	p = line + sizeof("/dev/") - 1;
   1908   1.1      cgd 	if (logout(p))
   1909   1.1      cgd 		logwtmp(p, "", "");
   1910   1.1      cgd 	(void)chmod(line, 0666);
   1911   1.1      cgd 	(void)chown(line, 0, 0);
   1912  1.14   tsarna 	c = *p; *p = 'p';
   1913   1.1      cgd 	(void)chmod(line, 0666);
   1914   1.1      cgd 	(void)chown(line, 0, 0);
   1915  1.14   tsarna 	*p = c;
   1916  1.14   tsarna 	if (ttyaction(line, "telnetd", "root"))
   1917  1.14   tsarna 		syslog(LOG_ERR, "%s: ttyaction failed", line);
   1918   1.1      cgd 	(void) shutdown(net, 2);
   1919   1.1      cgd 	exit(1);
   1920   1.1      cgd # else
   1921   1.1      cgd 	void rmut();
   1922   1.1      cgd 
   1923   1.1      cgd 	rmut();
   1924   1.1      cgd 	vhangup();	/* XXX */
   1925   1.1      cgd 	(void) shutdown(net, 2);
   1926   1.1      cgd 	exit(1);
   1927   1.1      cgd # endif
   1928   1.3      cgd #else	/* PARENT_DOES_UTMP */
   1929   1.1      cgd # ifdef	NEWINIT
   1930   1.1      cgd 	(void) shutdown(net, 2);
   1931   1.1      cgd 	exit(1);
   1932   1.1      cgd # else	/* NEWINIT */
   1933   1.3      cgd #  ifdef CRAY
   1934   1.1      cgd 	static int incleanup = 0;
   1935   1.1      cgd 	register int t;
   1936   1.6      jtk 	int child_status; /* status of child process as returned by waitpid */
   1937   1.6      jtk 	int flags = WNOHANG|WUNTRACED;
   1938   1.1      cgd 
   1939   1.1      cgd 	/*
   1940   1.1      cgd 	 * 1: Pick up the zombie, if we are being called
   1941   1.1      cgd 	 *    as the signal handler.
   1942   1.1      cgd 	 * 2: If we are a nested cleanup(), return.
   1943   1.1      cgd 	 * 3: Try to clean up TMPDIR.
   1944   1.1      cgd 	 * 4: Fill in utmp with shutdown of process.
   1945   1.1      cgd 	 * 5: Close down the network and pty connections.
   1946   1.1      cgd 	 * 6: Finish up the TMPDIR cleanup, if needed.
   1947   1.1      cgd 	 */
   1948   1.6      jtk 	if (sig == SIGCHLD) {
   1949   1.6      jtk 		while (waitpid(-1, &child_status, flags) > 0)
   1950   1.1      cgd 			;	/* VOID */
   1951   1.6      jtk 		/* Check if the child process was stopped
   1952   1.6      jtk 		 * rather than exited.  We want cleanup only if
   1953   1.6      jtk 		 * the child has died.
   1954   1.6      jtk 		 */
   1955   1.6      jtk 		if (WIFSTOPPED(child_status)) {
   1956   1.6      jtk 			return;
   1957   1.6      jtk 		}
   1958   1.6      jtk 	}
   1959   1.1      cgd 	t = sigblock(sigmask(SIGCHLD));
   1960   1.1      cgd 	if (incleanup) {
   1961   1.1      cgd 		sigsetmask(t);
   1962   1.1      cgd 		return;
   1963   1.1      cgd 	}
   1964   1.1      cgd 	incleanup = 1;
   1965   1.1      cgd 	sigsetmask(t);
   1966   1.6      jtk #ifdef	UNICOS7x
   1967   1.3      cgd 	if (secflag) {
   1968   1.3      cgd 		/*
   1969   1.3      cgd 		 *	We need to set ourselves back to a null
   1970   1.3      cgd 		 *	label to clean up.
   1971   1.3      cgd 		 */
   1972   1.3      cgd 
   1973   1.3      cgd 		setulvl(sysv.sy_minlvl);
   1974   1.3      cgd 		setucmp((long)0);
   1975   1.3      cgd 	}
   1976   1.6      jtk #endif	/* UNICOS7x */
   1977   1.1      cgd 
   1978   1.1      cgd 	t = cleantmp(&wtmp);
   1979   1.1      cgd 	setutent();	/* just to make sure */
   1980   1.3      cgd #  endif /* CRAY */
   1981   1.1      cgd 	rmut(line);
   1982   1.1      cgd 	close(pty);
   1983   1.1      cgd 	(void) shutdown(net, 2);
   1984   1.3      cgd #  ifdef CRAY
   1985   1.1      cgd 	if (t == 0)
   1986   1.1      cgd 		cleantmp(&wtmp);
   1987   1.3      cgd #  endif /* CRAY */
   1988   1.1      cgd 	exit(1);
   1989   1.1      cgd # endif	/* NEWINT */
   1990   1.3      cgd #endif	/* PARENT_DOES_UTMP */
   1991   1.1      cgd }
   1992   1.1      cgd 
   1993   1.3      cgd #if defined(PARENT_DOES_UTMP) && !defined(NEWINIT)
   1994   1.1      cgd /*
   1995   1.1      cgd  * _utmp_sig_rcv
   1996   1.1      cgd  * utmp_sig_init
   1997   1.1      cgd  * utmp_sig_wait
   1998   1.1      cgd  *	These three functions are used to coordinate the handling of
   1999   1.1      cgd  *	the utmp file between the server and the soon-to-be-login shell.
   2000   1.1      cgd  *	The server actually creates the utmp structure, the child calls
   2001   1.1      cgd  *	utmp_sig_wait(), until the server calls utmp_sig_notify() and
   2002   1.1      cgd  *	signals the future-login shell to proceed.
   2003   1.1      cgd  */
   2004   1.1      cgd static int caught=0;		/* NZ when signal intercepted */
   2005   1.1      cgd static void (*func)();		/* address of previous handler */
   2006   1.1      cgd 
   2007   1.1      cgd 	void
   2008   1.1      cgd _utmp_sig_rcv(sig)
   2009   1.1      cgd 	int sig;
   2010   1.1      cgd {
   2011   1.1      cgd 	caught = 1;
   2012   1.1      cgd 	(void) signal(SIGUSR1, func);
   2013   1.1      cgd }
   2014   1.1      cgd 
   2015   1.1      cgd 	void
   2016   1.1      cgd utmp_sig_init()
   2017   1.1      cgd {
   2018   1.1      cgd 	/*
   2019   1.1      cgd 	 * register signal handler for UTMP creation
   2020   1.1      cgd 	 */
   2021   1.1      cgd 	if ((int)(func = signal(SIGUSR1, _utmp_sig_rcv)) == -1)
   2022   1.1      cgd 		fatalperror(net, "telnetd/signal");
   2023   1.1      cgd }
   2024   1.1      cgd 
   2025   1.1      cgd 	void
   2026   1.1      cgd utmp_sig_reset()
   2027   1.1      cgd {
   2028   1.1      cgd 	(void) signal(SIGUSR1, func);	/* reset handler to default */
   2029   1.1      cgd }
   2030   1.1      cgd 
   2031   1.3      cgd # ifdef __hpux
   2032   1.3      cgd # define sigoff() /* do nothing */
   2033   1.3      cgd # define sigon() /* do nothing */
   2034   1.3      cgd # endif
   2035   1.3      cgd 
   2036   1.1      cgd 	void
   2037   1.1      cgd utmp_sig_wait()
   2038   1.1      cgd {
   2039   1.1      cgd 	/*
   2040   1.1      cgd 	 * Wait for parent to write our utmp entry.
   2041   1.1      cgd 	 */
   2042   1.1      cgd 	sigoff();
   2043   1.1      cgd 	while (caught == 0) {
   2044   1.1      cgd 		pause();	/* wait until we get a signal (sigon) */
   2045   1.1      cgd 		sigoff();	/* turn off signals while we check caught */
   2046   1.1      cgd 	}
   2047   1.1      cgd 	sigon();		/* turn on signals again */
   2048   1.1      cgd }
   2049   1.1      cgd 
   2050   1.1      cgd 	void
   2051   1.1      cgd utmp_sig_notify(pid)
   2052   1.1      cgd {
   2053   1.1      cgd 	kill(pid, SIGUSR1);
   2054   1.1      cgd }
   2055   1.1      cgd 
   2056   1.3      cgd # ifdef CRAY
   2057   1.1      cgd static int gotsigjob = 0;
   2058   1.1      cgd 
   2059   1.1      cgd 	/*ARGSUSED*/
   2060   1.1      cgd 	void
   2061   1.1      cgd sigjob(sig)
   2062   1.1      cgd 	int sig;
   2063   1.1      cgd {
   2064   1.1      cgd 	register int jid;
   2065   1.1      cgd 	register struct jobtemp *jp;
   2066   1.1      cgd 
   2067   1.1      cgd 	while ((jid = waitjob(NULL)) != -1) {
   2068   1.1      cgd 		if (jid == 0) {
   2069   1.1      cgd 			return;
   2070   1.1      cgd 		}
   2071   1.1      cgd 		gotsigjob++;
   2072   1.1      cgd 		jobend(jid, NULL, NULL);
   2073   1.1      cgd 	}
   2074   1.1      cgd }
   2075   1.1      cgd 
   2076   1.1      cgd /*
   2077   1.6      jtk  *	jid_getutid:
   2078   1.6      jtk  *		called by jobend() before calling cleantmp()
   2079   1.6      jtk  *		to find the correct $TMPDIR to cleanup.
   2080   1.6      jtk  */
   2081   1.6      jtk 
   2082   1.6      jtk 	struct utmp *
   2083   1.6      jtk jid_getutid(jid)
   2084   1.6      jtk 	int jid;
   2085   1.6      jtk {
   2086   1.6      jtk 	struct utmp *cur = NULL;
   2087   1.6      jtk 
   2088   1.6      jtk 	setutent();	/* just to make sure */
   2089   1.6      jtk 	while (cur = getutent()) {
   2090   1.6      jtk 		if ( (cur->ut_type != NULL) && (jid == cur->ut_jid) ) {
   2091   1.6      jtk 			return(cur);
   2092   1.6      jtk 		}
   2093   1.6      jtk 	}
   2094   1.6      jtk 
   2095   1.6      jtk 	return(0);
   2096   1.6      jtk }
   2097   1.6      jtk 
   2098   1.6      jtk /*
   2099   1.1      cgd  * Clean up the TMPDIR that login created.
   2100   1.1      cgd  * The first time this is called we pick up the info
   2101   1.1      cgd  * from the utmp.  If the job has already gone away,
   2102   1.1      cgd  * then we'll clean up and be done.  If not, then
   2103   1.1      cgd  * when this is called the second time it will wait
   2104   1.1      cgd  * for the signal that the job is done.
   2105   1.1      cgd  */
   2106   1.1      cgd 	int
   2107   1.1      cgd cleantmp(wtp)
   2108   1.1      cgd 	register struct utmp *wtp;
   2109   1.1      cgd {
   2110   1.1      cgd 	struct utmp *utp;
   2111   1.1      cgd 	static int first = 1;
   2112   1.1      cgd 	register int mask, omask, ret;
   2113   1.3      cgd 	extern struct utmp *getutid P((const struct utmp *_Id));
   2114   1.3      cgd 
   2115   1.1      cgd 
   2116   1.1      cgd 	mask = sigmask(WJSIGNAL);
   2117   1.1      cgd 
   2118   1.1      cgd 	if (first == 0) {
   2119   1.1      cgd 		omask = sigblock(mask);
   2120   1.1      cgd 		while (gotsigjob == 0)
   2121   1.1      cgd 			sigpause(omask);
   2122   1.1      cgd 		return(1);
   2123   1.1      cgd 	}
   2124   1.1      cgd 	first = 0;
   2125   1.1      cgd 	setutent();	/* just to make sure */
   2126   1.1      cgd 
   2127   1.1      cgd 	utp = getutid(wtp);
   2128   1.1      cgd 	if (utp == 0) {
   2129   1.1      cgd 		syslog(LOG_ERR, "Can't get /etc/utmp entry to clean TMPDIR");
   2130   1.1      cgd 		return(-1);
   2131   1.1      cgd 	}
   2132   1.1      cgd 	/*
   2133   1.1      cgd 	 * Nothing to clean up if the user shell was never started.
   2134   1.1      cgd 	 */
   2135   1.1      cgd 	if (utp->ut_type != USER_PROCESS || utp->ut_jid == 0)
   2136   1.1      cgd 		return(1);
   2137   1.1      cgd 
   2138   1.1      cgd 	/*
   2139   1.1      cgd 	 * Block the WJSIGNAL while we are in jobend().
   2140   1.1      cgd 	 */
   2141   1.1      cgd 	omask = sigblock(mask);
   2142   1.1      cgd 	ret = jobend(utp->ut_jid, utp->ut_tpath, utp->ut_user);
   2143   1.1      cgd 	sigsetmask(omask);
   2144   1.1      cgd 	return(ret);
   2145   1.1      cgd }
   2146   1.1      cgd 
   2147   1.1      cgd 	int
   2148   1.1      cgd jobend(jid, path, user)
   2149   1.1      cgd 	register int jid;
   2150   1.1      cgd 	register char *path;
   2151   1.1      cgd 	register char *user;
   2152   1.1      cgd {
   2153   1.1      cgd 	static int saved_jid = 0;
   2154   1.6      jtk 	static int pty_saved_jid = 0;
   2155   1.1      cgd 	static char saved_path[sizeof(wtmp.ut_tpath)+1];
   2156   1.1      cgd 	static char saved_user[sizeof(wtmp.ut_user)+1];
   2157   1.1      cgd 
   2158   1.6      jtk 	/*
   2159   1.6      jtk 	 * this little piece of code comes into play
   2160   1.6      jtk 	 * only when ptyreconnect is used to reconnect
   2161   1.6      jtk 	 * to an previous session.
   2162   1.6      jtk 	 *
   2163   1.6      jtk 	 * this is the only time when the
   2164   1.6      jtk 	 * "saved_jid != jid" code is executed.
   2165   1.6      jtk 	 */
   2166   1.6      jtk 
   2167   1.6      jtk 	if ( saved_jid && saved_jid != jid ) {
   2168   1.6      jtk 		if (!path) {	/* called from signal handler */
   2169   1.6      jtk 			pty_saved_jid = jid;
   2170   1.6      jtk 		} else {
   2171   1.6      jtk 			pty_saved_jid = saved_jid;
   2172   1.6      jtk 		}
   2173   1.6      jtk 	}
   2174   1.6      jtk 
   2175   1.1      cgd 	if (path) {
   2176   1.1      cgd 		strncpy(saved_path, path, sizeof(wtmp.ut_tpath));
   2177   1.1      cgd 		strncpy(saved_user, user, sizeof(wtmp.ut_user));
   2178   1.1      cgd 		saved_path[sizeof(saved_path)] = '\0';
   2179   1.1      cgd 		saved_user[sizeof(saved_user)] = '\0';
   2180   1.1      cgd 	}
   2181   1.1      cgd 	if (saved_jid == 0) {
   2182   1.1      cgd 		saved_jid = jid;
   2183   1.1      cgd 		return(0);
   2184   1.1      cgd 	}
   2185   1.6      jtk 
   2186   1.6      jtk 	/* if the jid has changed, get the correct entry from the utmp file */
   2187   1.6      jtk 
   2188   1.6      jtk 	if ( saved_jid != jid ) {
   2189   1.6      jtk 		struct utmp *utp = NULL;
   2190   1.6      jtk 		struct utmp *jid_getutid();
   2191   1.6      jtk 
   2192   1.6      jtk 		utp = jid_getutid(pty_saved_jid);
   2193   1.6      jtk 
   2194   1.6      jtk 		if (utp == 0) {
   2195   1.6      jtk 			syslog(LOG_ERR, "Can't get /etc/utmp entry to clean TMPDIR");
   2196   1.6      jtk 			return(-1);
   2197   1.6      jtk 		}
   2198   1.6      jtk 
   2199   1.6      jtk 		cleantmpdir(jid, utp->ut_tpath, utp->ut_user);
   2200   1.6      jtk 		return(1);
   2201   1.6      jtk 	}
   2202   1.6      jtk 
   2203   1.1      cgd 	cleantmpdir(jid, saved_path, saved_user);
   2204   1.1      cgd 	return(1);
   2205   1.1      cgd }
   2206   1.1      cgd 
   2207   1.1      cgd /*
   2208   1.1      cgd  * Fork a child process to clean up the TMPDIR
   2209   1.1      cgd  */
   2210   1.1      cgd cleantmpdir(jid, tpath, user)
   2211   1.1      cgd 	register int jid;
   2212   1.1      cgd 	register char *tpath;
   2213   1.1      cgd 	register char *user;
   2214   1.1      cgd {
   2215   1.1      cgd 	switch(fork()) {
   2216   1.1      cgd 	case -1:
   2217   1.1      cgd 		syslog(LOG_ERR, "TMPDIR cleanup(%s): fork() failed: %m\n",
   2218   1.1      cgd 							tpath);
   2219   1.1      cgd 		break;
   2220   1.1      cgd 	case 0:
   2221   1.1      cgd 		execl(CLEANTMPCMD, CLEANTMPCMD, user, tpath, 0);
   2222   1.1      cgd 		syslog(LOG_ERR, "TMPDIR cleanup(%s): execl(%s) failed: %m\n",
   2223   1.1      cgd 							tpath, CLEANTMPCMD);
   2224   1.1      cgd 		exit(1);
   2225   1.1      cgd 	default:
   2226   1.1      cgd 		/*
   2227   1.1      cgd 		 * Forget about child.  We will exit, and
   2228   1.1      cgd 		 * /etc/init will pick it up.
   2229   1.1      cgd 		 */
   2230   1.1      cgd 		break;
   2231   1.1      cgd 	}
   2232   1.1      cgd }
   2233   1.3      cgd # endif /* CRAY */
   2234   1.3      cgd #endif	/* defined(PARENT_DOES_UTMP) && !defined(NEWINIT) */
   2235   1.1      cgd 
   2236   1.1      cgd /*
   2237   1.1      cgd  * rmut()
   2238   1.1      cgd  *
   2239   1.1      cgd  * This is the function called by cleanup() to
   2240   1.1      cgd  * remove the utmp entry for this person.
   2241   1.1      cgd  */
   2242   1.1      cgd 
   2243   1.3      cgd #ifdef	UTMPX
   2244   1.3      cgd 	void
   2245   1.3      cgd rmut()
   2246   1.3      cgd {
   2247   1.3      cgd 	register f;
   2248   1.3      cgd 	int found = 0;
   2249   1.3      cgd 	struct utmp *u, *utmp;
   2250   1.3      cgd 	int nutmp;
   2251   1.3      cgd 	struct stat statbf;
   2252   1.3      cgd 
   2253   1.3      cgd 	struct utmpx *utxp, utmpx;
   2254   1.3      cgd 
   2255   1.3      cgd 	/*
   2256   1.3      cgd 	 * This updates the utmpx and utmp entries and make a wtmp/x entry
   2257   1.3      cgd 	 */
   2258   1.3      cgd 
   2259   1.3      cgd 	SCPYN(utmpx.ut_line, line + sizeof("/dev/") - 1);
   2260   1.3      cgd 	utxp = getutxline(&utmpx);
   2261   1.3      cgd 	if (utxp) {
   2262   1.3      cgd 		utxp->ut_type = DEAD_PROCESS;
   2263   1.3      cgd 		utxp->ut_exit.e_termination = 0;
   2264   1.3      cgd 		utxp->ut_exit.e_exit = 0;
   2265   1.3      cgd 		(void) time(&utmpx.ut_tv.tv_sec);
   2266   1.3      cgd 		utmpx.ut_tv.tv_usec = 0;
   2267   1.3      cgd 		modutx(utxp);
   2268   1.3      cgd 	}
   2269   1.3      cgd 	endutxent();
   2270   1.3      cgd }  /* end of rmut */
   2271   1.3      cgd #endif
   2272   1.3      cgd 
   2273   1.3      cgd #if	!defined(UTMPX) && !(defined(CRAY) || defined(__hpux)) && BSD <= 43
   2274   1.1      cgd 	void
   2275   1.1      cgd rmut()
   2276   1.1      cgd {
   2277   1.1      cgd 	register f;
   2278   1.1      cgd 	int found = 0;
   2279   1.1      cgd 	struct utmp *u, *utmp;
   2280   1.1      cgd 	int nutmp;
   2281   1.1      cgd 	struct stat statbf;
   2282   1.1      cgd 
   2283   1.1      cgd 	f = open(utmpf, O_RDWR);
   2284   1.1      cgd 	if (f >= 0) {
   2285   1.1      cgd 		(void) fstat(f, &statbf);
   2286   1.1      cgd 		utmp = (struct utmp *)malloc((unsigned)statbf.st_size);
   2287   1.1      cgd 		if (!utmp)
   2288   1.1      cgd 			syslog(LOG_ERR, "utmp malloc failed");
   2289   1.1      cgd 		if (statbf.st_size && utmp) {
   2290   1.1      cgd 			nutmp = read(f, (char *)utmp, (int)statbf.st_size);
   2291   1.1      cgd 			nutmp /= sizeof(struct utmp);
   2292   1.6      jtk 
   2293   1.1      cgd 			for (u = utmp ; u < &utmp[nutmp] ; u++) {
   2294   1.1      cgd 				if (SCMPN(u->ut_line, line+5) ||
   2295   1.1      cgd 				    u->ut_name[0]==0)
   2296   1.1      cgd 					continue;
   2297  1.10   kleink 				(void)lseek(f, (off_t)((long)u)-((long)utmp),
   2298  1.10   kleink 				    SEEK_SET);
   2299   1.1      cgd 				SCPYN(u->ut_name, "");
   2300   1.1      cgd 				SCPYN(u->ut_host, "");
   2301   1.1      cgd 				(void) time(&u->ut_time);
   2302   1.1      cgd 				(void) write(f, (char *)u, sizeof(wtmp));
   2303   1.1      cgd 				found++;
   2304   1.1      cgd 			}
   2305   1.1      cgd 		}
   2306   1.1      cgd 		(void) close(f);
   2307   1.1      cgd 	}
   2308   1.1      cgd 	if (found) {
   2309   1.1      cgd 		f = open(wtmpf, O_WRONLY|O_APPEND);
   2310   1.1      cgd 		if (f >= 0) {
   2311   1.1      cgd 			SCPYN(wtmp.ut_line, line+5);
   2312   1.1      cgd 			SCPYN(wtmp.ut_name, "");
   2313   1.1      cgd 			SCPYN(wtmp.ut_host, "");
   2314   1.1      cgd 			(void) time(&wtmp.ut_time);
   2315   1.1      cgd 			(void) write(f, (char *)&wtmp, sizeof(wtmp));
   2316   1.1      cgd 			(void) close(f);
   2317   1.1      cgd 		}
   2318   1.1      cgd 	}
   2319   1.1      cgd 	(void) chmod(line, 0666);
   2320   1.1      cgd 	(void) chown(line, 0, 0);
   2321   1.1      cgd 	line[strlen("/dev/")] = 'p';
   2322   1.1      cgd 	(void) chmod(line, 0666);
   2323   1.1      cgd 	(void) chown(line, 0, 0);
   2324   1.1      cgd }  /* end of rmut */
   2325   1.1      cgd #endif	/* CRAY */
   2326   1.3      cgd 
   2327   1.3      cgd #ifdef __hpux
   2328   1.3      cgd rmut (line)
   2329   1.3      cgd char *line;
   2330   1.3      cgd {
   2331   1.3      cgd 	struct utmp utmp;
   2332   1.3      cgd 	struct utmp *utptr;
   2333   1.3      cgd 	int fd;			/* for /etc/wtmp */
   2334   1.3      cgd 
   2335   1.3      cgd 	utmp.ut_type = USER_PROCESS;
   2336   1.3      cgd 	(void) strncpy(utmp.ut_id, line+12, sizeof(utmp.ut_id));
   2337   1.3      cgd 	(void) setutent();
   2338   1.3      cgd 	utptr = getutid(&utmp);
   2339   1.3      cgd 	/* write it out only if it exists */
   2340   1.3      cgd 	if (utptr) {
   2341   1.3      cgd 		utptr->ut_type = DEAD_PROCESS;
   2342   1.3      cgd 		utptr->ut_time = time((long *) 0);
   2343   1.3      cgd 		(void) pututline(utptr);
   2344   1.3      cgd 		/* set wtmp entry if wtmp file exists */
   2345   1.3      cgd 		if ((fd = open(wtmpf, O_WRONLY | O_APPEND)) >= 0) {
   2346   1.3      cgd 			(void) write(fd, utptr, sizeof(utmp));
   2347   1.3      cgd 			(void) close(fd);
   2348   1.3      cgd 		}
   2349   1.3      cgd 	}
   2350   1.3      cgd 	(void) endutent();
   2351   1.3      cgd 
   2352   1.3      cgd 	(void) chmod(line, 0666);
   2353   1.3      cgd 	(void) chown(line, 0, 0);
   2354   1.3      cgd 	line[14] = line[13];
   2355   1.3      cgd 	line[13] = line[12];
   2356   1.3      cgd 	line[8] = 'm';
   2357   1.3      cgd 	line[9] = '/';
   2358   1.3      cgd 	line[10] = 'p';
   2359   1.3      cgd 	line[11] = 't';
   2360   1.3      cgd 	line[12] = 'y';
   2361   1.3      cgd 	(void) chmod(line, 0666);
   2362   1.3      cgd 	(void) chown(line, 0, 0);
   2363   1.3      cgd }
   2364   1.3      cgd #endif
   2365