1 // sys_term.c

     2 //

     3 // © Portions Copyright (c) Symbian Software Ltd 2007. All rights reserved.

     4 //

     5 /*

     6  * Copyright (c) 1989, 1993

     7  *	The Regents of the University of California.  All rights reserved.

     8  *

     9  * Redistribution and use in source and binary forms, with or without

    10  * modification, are permitted provided that the following conditions

    11  * are met:

    12  * 1. Redistributions of source code must retain the above copyright

    13  *    notice, this list of conditions and the following disclaimer.

    14  * 2. Redistributions in binary form must reproduce the above copyright

    15  *    notice, this list of conditions and the following disclaimer in the

    16  *    documentation and/or other materials provided with the distribution.

    17  * 3. Neither the name of the University nor the names of its contributors

    18  *    may be used to endorse or promote products derived from this software

    19  *    without specific prior written permission.

    20  *

    21  * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND

    22  * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE

    23  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE

    24  * ARE DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE

    25  * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL

    26  * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS

    27  * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)

    28  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT

    29  * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY

    30  * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF

    31  * SUCH DAMAGE.

    32  */

    33 #include "telnetd.h"

    34 

    35 #ifdef __SYMBIAN32__

    36 #include "dummy.h"

    37 #endif

    38 

    39 #ifndef __SYMBIAN32__

    40 __RCSID("$Heimdal: sys_term.c,v 1.104 2001/09/17 02:09:04 assar Exp $"

    41         "$NetBSD: sys_term.c,v 1.2 2003/08/07 09:15:30 agc Exp $");

    42 #endif

    43 

    44 #if defined(_CRAY) || (defined(__hpux) && !defined(HAVE_UTMPX_H))

    45 # define PARENT_DOES_UTMP

    46 #endif

    47 

    48 #include <utmp.h>

    49 

    50 #ifdef HAVE_UTMPX_H

    51 #include <utmpx.h>

    52 #endif

    53 

    54 #ifdef __SYMBIAN32__

    55 #ifdef __WINSCW__

    56 #pragma warn_unusedarg off

    57 #endif//__WINSCW__

    58 #endif//__SYMBIAN32__

    59 

    60 #ifdef HAVE_UTMPX_H

    61 struct	utmpx wtmp;

    62 #elif defined(HAVE_UTMP_H)

    63 struct	utmp wtmp;

    64 #endif /* HAVE_UTMPX_H */

    65 

    66 #ifdef HAVE_STRUCT_UTMP_UT_HOST

    67 int	utmp_len = sizeof(wtmp.ut_host);

    68 #else

    69 int	utmp_len = MAXHOSTNAMELEN;

    70 #endif

    71 

    72 #ifndef UTMP_FILE

    73 #ifdef _PATH_UTMP

    74 #define UTMP_FILE _PATH_UTMP

    75 #else

    76 #define UTMP_FILE "/etc/utmp"

    77 #endif

    78 #endif

    79 

    80 #if !defined(WTMP_FILE) && defined(_PATH_WTMP)

    81 #define WTMP_FILE _PATH_WTMP

    82 #endif

    83 

    84 #ifndef PARENT_DOES_UTMP

    85 #ifdef WTMP_FILE

    86 char	wtmpf[] = WTMP_FILE;

    87 #else

    88 char	wtmpf[]	= "/usr/adm/wtmp";

    89 #endif

    90 char	utmpf[] = UTMP_FILE;

    91 #else /* PARENT_DOES_UTMP */

    92 #ifdef WTMP_FILE

    93 char	wtmpf[] = WTMP_FILE;

    94 #else

    95 char	wtmpf[]	= "/etc/wtmp";

    96 #endif

    97 #endif /* PARENT_DOES_UTMP */

    98 

    99 #ifdef HAVE_TMPDIR_H

   100 #include <tmpdir.h>

   101 #endif	/* CRAY */

   102 

   103 #ifdef	STREAMSPTY

   104 

   105 #ifdef HAVE_SAC_H

   106 #include <sac.h>

   107 #endif

   108 

   109 #ifdef HAVE_SYS_STROPTS_H

   110 #include <sys/stropts.h>

   111 #endif

   112 

   113 #endif /* STREAMSPTY */

   114 

   115 #undef NOERROR

   116 

   117 #ifdef	HAVE_SYS_STREAM_H

   118 #ifdef  HAVE_SYS_UIO_H

   119 #include <sys/uio.h>

   120 #endif

   121 #ifdef __hpux

   122 #undef SE

   123 #endif

   124 #include <sys/stream.h>

   125 #endif

   126 #if !(defined(__sgi) || defined(__linux) || defined(_AIX)) && defined(HAVE_SYS_TTY)

   127 #include <sys/tty.h>

   128 #endif

   129 #ifdef	t_erase

   130 #undef	t_erase

   131 #undef	t_kill

   132 #undef	t_intrc

   133 #undef	t_quitc

   134 #undef	t_startc

   135 #undef	t_stopc

   136 #undef	t_eofc

   137 #undef	t_brkc

   138 #undef	t_suspc

   139 #undef	t_dsuspc

   140 #undef	t_rprntc

   141 #undef	t_flushc

   142 #undef	t_werasc

   143 #undef	t_lnextc

   144 #endif

   145 

   146 #ifdef HAVE_TERMIOS_H

   147 #include <termios.h>

   148 #else

   149 #ifdef HAVE_TERMIO_H

   150 #include <termio.h>

   151 #endif

   152 #endif

   153 

   154 #ifdef HAVE_UTIL_H

   155 #include <util.h>

   156 #endif

   157 #ifdef HAVE_LIBUTIL_H

   158 #include <libutil.h>

   159 #endif

   160 

   161 # ifndef	TCSANOW

   162 #  ifdef TCSETS

   163 #   define	TCSANOW		TCSETS

   164 #   define	TCSADRAIN	TCSETSW

   165 #   define	tcgetattr(f, t)	ioctl(f, TCGETS, (char *)t)

   166 #  else

   167 #   ifdef TCSETA

   168 #    define	TCSANOW		TCSETA

   169 #    define	TCSADRAIN	TCSETAW

   170 #    define	tcgetattr(f, t)	ioctl(f, TCGETA, (char *)t)

   171 #   else

   172 #    define	TCSANOW		TIOCSETA

   173 #    define	TCSADRAIN	TIOCSETAW

   174 #    define	tcgetattr(f, t)	ioctl(f, TIOCGETA, (char *)t)

   175 #   endif

   176 #  endif

   177 #  define	tcsetattr(f, a, t)	ioctl(f, a, t)

   178 #  define	cfsetospeed(tp, val)	(tp)->c_cflag &= ~CBAUD; \

   179 (tp)->c_cflag |= (val)

   180 #  define	cfgetospeed(tp)		((tp)->c_cflag & CBAUD)

   181 #  ifdef CIBAUD

   182 #   define	cfsetispeed(tp, val)	(tp)->c_cflag &= ~CIBAUD; \

   183      (tp)->c_cflag |= ((val)<<IBSHIFT)

   184 #   define	cfgetispeed(tp)		(((tp)->c_cflag & CIBAUD)>>IBSHIFT)

   185 #  else

   186 #   define	cfsetispeed(tp, val)	(tp)->c_cflag &= ~CBAUD; \

   187      (tp)->c_cflag |= (val)

   188 #   define	cfgetispeed(tp)		((tp)->c_cflag & CBAUD)

   189 #  endif

   190 # endif /* TCSANOW */

   191      struct termios termbuf, termbuf2;	/* pty control structure */

   192 # ifdef  STREAMSPTY

   193      static int ttyfd = -1;

   194      int really_stream = 0;

   195 # endif

   196 

   197      const char *new_login = _PATH_LOGIN;

   198 

   199 /*

   200  * init_termbuf()

   201  * copy_termbuf(cp)

   202  * set_termbuf()

   203  *

   204  * These three routines are used to get and set the "termbuf" structure

   205  * to and from the kernel.  init_termbuf() gets the current settings.

   206  * copy_termbuf() hands in a new "termbuf" to write to the kernel, and

   207  * set_termbuf() writes the structure into the kernel.

   208  */

   209 

   210      void

   211      init_termbuf(void)

   212 {

   213 # ifdef  STREAMSPTY

   214     if (really_stream)

   215 	tcgetattr(ttyfd, &termbuf);

   216     else

   217 # endif

   218 	tcgetattr(ourpty, &termbuf);

   219     termbuf2 = termbuf;

   220 }

   221 

   222 void

   223 set_termbuf(void)

   224 {

   225     /*

   226      * Only make the necessary changes.

   227 	 */

   228     if (memcmp(&termbuf, &termbuf2, sizeof(termbuf)))

   229 # ifdef  STREAMSPTY

   230 	if (really_stream)

   231 	    tcsetattr(ttyfd, TCSANOW, &termbuf);

   232 	else

   233 # endif

   234 	    tcsetattr(ourpty, TCSANOW, &termbuf);

   235 }

   236 

   237 

   238 /*

   239  * spcset(func, valp, valpp)

   240  *

   241  * This function takes various special characters (func), and

   242  * sets *valp to the current value of that character, and

   243  * *valpp to point to where in the "termbuf" structure that

   244  * value is kept.

   245  *

   246  * It returns the SLC_ level of support for this function.

   247  */

   248 

   249 

   250 int

   251 spcset(int func, cc_t *valp, cc_t **valpp)

   252 {

   253 

   254 #define	setval(a, b)	*valp = termbuf.c_cc[a]; \

   255     *valpp = &termbuf.c_cc[a]; \

   256 				   return(b);

   257 #define	defval(a) *valp = ((cc_t)a); *valpp = (cc_t *)0; return(SLC_DEFAULT);

   258 

   259     switch(func) {

   260     case SLC_EOF:

   261 	setval(VEOF, SLC_VARIABLE);

   262     case SLC_EC:

   263 	setval(VERASE, SLC_VARIABLE);

   264     case SLC_EL:

   265 	setval(VKILL, SLC_VARIABLE);

   266     case SLC_IP:

   267 	setval(VINTR, SLC_VARIABLE|SLC_FLUSHIN|SLC_FLUSHOUT);

   268     case SLC_ABORT:

   269 	setval(VQUIT, SLC_VARIABLE|SLC_FLUSHIN|SLC_FLUSHOUT);

   270     case SLC_XON:

   271 #ifdef	VSTART

   272 	setval(VSTART, SLC_VARIABLE);

   273 #else

   274 	defval(0x13);

   275 #endif

   276     case SLC_XOFF:

   277 #ifdef	VSTOP

   278 	setval(VSTOP, SLC_VARIABLE);

   279 #else

   280 	defval(0x11);

   281 #endif

   282     case SLC_EW:

   283 #ifdef	VWERASE

   284 	setval(VWERASE, SLC_VARIABLE);

   285 #else

   286 	defval(0);

   287 #endif

   288     case SLC_RP:

   289 #ifdef	VREPRINT

   290 	setval(VREPRINT, SLC_VARIABLE);

   291 #else

   292 	defval(0);

   293 #endif

   294     case SLC_LNEXT:

   295 #ifdef	VLNEXT

   296 	setval(VLNEXT, SLC_VARIABLE);

   297 #else

   298 	defval(0);

   299 #endif

   300     case SLC_AO:

   301 #if	!defined(VDISCARD) && defined(VFLUSHO)

   302 # define VDISCARD VFLUSHO

   303 #endif

   304 #ifdef	VDISCARD

   305 	setval(VDISCARD, SLC_VARIABLE|SLC_FLUSHOUT);

   306 #else

   307 	defval(0);

   308 #endif

   309     case SLC_SUSP:

   310 #ifdef	VSUSP

   311 	setval(VSUSP, SLC_VARIABLE|SLC_FLUSHIN);

   312 #else

   313 	defval(0);

   314 #endif

   315 #ifdef	VEOL

   316     case SLC_FORW1:

   317 	setval(VEOL, SLC_VARIABLE);

   318 #endif

   319 #ifdef	VEOL2

   320     case SLC_FORW2:

   321 	setval(VEOL2, SLC_VARIABLE);

   322 #endif

   323     case SLC_AYT:

   324 #ifdef	VSTATUS

   325 	setval(VSTATUS, SLC_VARIABLE);

   326 #else

   327 	defval(0);

   328 #endif

   329 

   330     case SLC_BRK:

   331     case SLC_SYNCH:

   332     case SLC_EOR:

   333 	defval(0);

   334 

   335     default:

   336 	*valp = 0;

   337 	*valpp = 0;

   338 	return(SLC_NOSUPPORT);

   339     }

   340 }

   341 

   342 #ifdef _CRAY

   343 /*

   344  * getnpty()

   345  *

   346  * Return the number of pty's configured into the system.

   347  */

   348 int

   349 getnpty()

   350 {

   351 #ifdef _SC_CRAY_NPTY

   352     int numptys;

   353 

   354     if ((numptys = sysconf(_SC_CRAY_NPTY)) != -1)

   355 	return numptys;

   356     else

   357 #endif /* _SC_CRAY_NPTY */

   358 	return 128;

   359 }

   360 #endif /* CRAY */

   361 

   362 /*

   363  * getpty()

   364  *

   365  * Allocate a pty.  As a side effect, the external character

   366  * array "line" contains the name of the slave side.

   367  *

   368  * Returns the file descriptor of the opened pty.

   369  */

   370 

   371 static char Xline[] = "\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0";

   372 char *line = Xline;

   373 

   374 #ifdef	_CRAY

   375 char myline[] = "\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0";

   376 #endif	/* CRAY */

   377 

   378 #if !defined(HAVE_PTSNAME) && defined(STREAMSPTY)

   379 static char *ptsname(int fd)

   380 {

   381 #ifdef HAVE_TTYNAME

   382     return ttyname(fd);

   383 #else

   384     return NULL;

   385 #endif

   386 }

   387 #endif

   388 

   389 int getpty(int *ptynum)

   390 {

   391 #ifdef __osf__ /* XXX */

   392     int master;

   393     int slave;

   394     if(openpty(&master, &slave, line, 0, 0) == 0){

   395 	close(slave);

   396 	return master;

   397     }

   398     return -1;

   399 #else

   400 #ifdef HAVE__GETPTY

   401     int master, slave;

   402     char *p;

   403     p = _getpty(&master, O_RDWR, 0600, 1);

   404     if(p == NULL)

   405 	return -1;

   406     strlcpy(line, p, sizeof(Xline));

   407     return master;

   408 #else

   409 

   410     int p;

   411     char *cp, *p1, *p2;

   412     int i;

   413 #if SunOS == 40

   414     int dummy;

   415 #endif

   416 #if __linux

   417     int master;

   418     int slave;

   419     if(openpty(&master, &slave, line, 0, 0) == 0){

   420 	close(slave);

   421 	return master;

   422     }

   423 #else

   424 #ifdef	STREAMSPTY

   425     char *clone[] = { "/dev/ptc", "/dev/ptmx", "/dev/ptm", 

   426 		      "/dev/ptym/clone", 0 };

   427 

   428     char **q;

   429     for(q=clone; *q; q++){

   430 	p=open(*q, O_RDWR);

   431 	if(p >= 0){

   432 #ifdef HAVE_GRANTPT

   433 	    grantpt(p);

   434 #endif

   435 #ifdef HAVE_UNLOCKPT

   436 	    unlockpt(p);

   437 #endif

   438 	    strlcpy(line, ptsname(p), sizeof(Xline));

   439 	    really_stream = 1;

   440 	    return p;

   441 	}

   442     }

   443 #endif /* STREAMSPTY */

   444 #ifndef _CRAY

   445 

   446 #ifndef	__hpux

   447     snprintf(line, sizeof(Xline), "/dev/ptyXX");

   448     p1 = &line[8];

   449     p2 = &line[9];

   450 #else

   451     snprintf(line, sizeof(Xline), "/dev/ptym/ptyXX");

   452     p1 = &line[13];

   453     p2 = &line[14];

   454 #endif

   455 

   456 	

   457     for (cp = "pqrstuvwxyzPQRST"; *cp; cp++) {

   458 	struct stat stb;

   459 

   460 	*p1 = *cp;

   461 	*p2 = '0';

   462 	/*

   463 	 * This stat() check is just to keep us from

   464 	 * looping through all 256 combinations if there

   465 	 * aren't that many ptys available.

   466 	 */

   467 	if (stat(line, &stb) < 0)

   468 	    break;

   469 	for (i = 0; i < 16; i++) {

   470 	    *p2 = "0123456789abcdef"[i];

   471 	    p = open(line, O_RDWR);

   472 	    if (p > 0) {

   473 #ifndef	__hpux

   474 		line[5] = 't';

   475 #else

   476 		for (p1 = &line[8]; *p1; p1++)

   477 		    *p1 = *(p1+1);

   478 		line[9] = 't';

   479 #endif

   480 		chown(line, 0, 0);

   481 		chmod(line, 0600);

   482 #if SunOS == 40

   483 		if (ioctl(p, TIOCGPGRP, &dummy) == 0

   484 		    || errno != EIO) {

   485 		    chmod(line, 0666);

   486 		    close(p);

   487 		    line[5] = 'p';

   488 		} else

   489 #endif /* SunOS == 40 */

   490 		    return(p);

   491 	    }

   492 	}

   493     }

   494 #else	/* CRAY */

   495     extern lowpty, highpty;

   496     struct stat sb;

   497 

   498     for (*ptynum = lowpty; *ptynum <= highpty; (*ptynum)++) {

   499 	snprintf(myline, sizeof(myline), "/dev/pty/%03d", *ptynum);

   500 	p = open(myline, 2);

   501 	if (p < 0)

   502 	    continue;

   503 	snprintf(line, sizeof(Xline), "/dev/ttyp%03d", *ptynum);

   504 	/*

   505 	 * Here are some shenanigans to make sure that there

   506 	 * are no listeners lurking on the line.

   507 	 */

   508 	if(stat(line, &sb) < 0) {

   509 	    close(p);

   510 	    continue;

   511 	}

   512 	if(sb.st_uid || sb.st_gid || sb.st_mode != 0600) {

   513 	    chown(line, 0, 0);

   514 	    chmod(line, 0600);

   515 	    close(p);

   516 	    p = open(myline, 2);

   517 	    if (p < 0)

   518 		continue;

   519 	}

   520 	/*

   521 	 * Now it should be safe...check for accessability.

   522 	 */

   523 	if (access(line, 6) == 0)

   524 	    return(p);

   525 	else {

   526 	    /* no tty side to pty so skip it */

   527 	    close(p);

   528 	}

   529     }

   530 #endif	/* CRAY */

   531 #endif	/* STREAMSPTY */

   532 #endif /* OPENPTY */

   533     return(-1);

   534 #endif

   535 }

   536 

   537 

   538 int

   539 tty_isecho(void)

   540 {

   541     return (termbuf.c_lflag & ECHO);

   542 }

   543 

   544 int

   545 tty_flowmode(void)

   546 {

   547     return((termbuf.c_iflag & IXON) ? 1 : 0);

   548 }

   549 

   550 int

   551 tty_restartany(void)

   552 {

   553     return((termbuf.c_iflag & IXANY) ? 1 : 0);

   554 }

   555 

   556 void

   557 tty_setecho(int on)

   558 {

   559     if (on)

   560 	termbuf.c_lflag |= ECHO;

   561     else

   562 	termbuf.c_lflag &= ~ECHO;

   563 }

   564 

   565 int

   566 tty_israw(void)

   567 {

   568     return(!(termbuf.c_lflag & ICANON));

   569 }

   570 

   571 void

   572 tty_binaryin(int on)

   573 {

   574     if (on) {

   575 	termbuf.c_iflag &= ~ISTRIP;

   576     } else {

   577 	termbuf.c_iflag |= ISTRIP;

   578     }

   579 }

   580 

   581 void

   582 tty_binaryout(int on)

   583 {

   584     if (on) {

   585 	termbuf.c_cflag &= ~(CSIZE|PARENB);

   586 	termbuf.c_cflag |= CS8;

   587 	termbuf.c_oflag &= ~OPOST;

   588     } else {

   589 	termbuf.c_cflag &= ~CSIZE;

   590 	termbuf.c_cflag |= CS7|PARENB;

   591 	termbuf.c_oflag |= OPOST;

   592     }

   593 }

   594 

   595 int

   596 tty_isbinaryin(void)

   597 {

   598     return(!(termbuf.c_iflag & ISTRIP));

   599 }

   600 

   601 int

   602 tty_isbinaryout(void)

   603 {

   604     return(!(termbuf.c_oflag&OPOST));

   605 }

   606 

   607 

   608 int

   609 tty_issofttab(void)

   610 {

   611 # ifdef	OXTABS

   612     return (termbuf.c_oflag & OXTABS);

   613 # endif

   614 # ifdef	TABDLY

   615     return ((termbuf.c_oflag & TABDLY) == TAB3);

   616 # endif

   617 }

   618 

   619 void

   620 tty_setsofttab(int on)

   621 {

   622     if (on) {

   623 # ifdef	OXTABS

   624 	termbuf.c_oflag |= OXTABS;

   625 # endif

   626 # ifdef	TABDLY

   627 	termbuf.c_oflag &= ~TABDLY;

   628 	termbuf.c_oflag |= TAB3;

   629 # endif

   630     } else {

   631 # ifdef	OXTABS

   632 	termbuf.c_oflag &= ~OXTABS;

   633 # endif

   634 # ifdef	TABDLY

   635 	termbuf.c_oflag &= ~TABDLY;

   636 	termbuf.c_oflag |= TAB0;

   637 # endif

   638     }

   639 }

   640 

   641 int

   642 tty_islitecho(void)

   643 {

   644 # ifdef	ECHOCTL

   645     return (!(termbuf.c_lflag & ECHOCTL));

   646 # endif

   647 # ifdef	TCTLECH

   648     return (!(termbuf.c_lflag & TCTLECH));

   649 # endif

   650 # if	!defined(ECHOCTL) && !defined(TCTLECH)

   651     return (0);	/* assumes ctl chars are echoed '^x' */

   652 # endif

   653 }

   654 

   655 void

   656 tty_setlitecho(int on)

   657 {

   658 # ifdef	ECHOCTL

   659     if (on)

   660 	termbuf.c_lflag &= ~ECHOCTL;

   661     else

   662 	termbuf.c_lflag |= ECHOCTL;

   663 # endif

   664 # ifdef	TCTLECH

   665     if (on)

   666 	termbuf.c_lflag &= ~TCTLECH;

   667     else

   668 	termbuf.c_lflag |= TCTLECH;

   669 # endif

   670 }

   671 

   672 int

   673 tty_iscrnl(void)

   674 {

   675     return (termbuf.c_iflag & ICRNL);

   676 }

   677 

   678 /*

   679  * Try to guess whether speeds are "encoded" (4.2BSD) or just numeric (4.4BSD).

   680  */

   681 #if B4800 != 4800

   682 #define	DECODE_BAUD

   683 #endif

   684 

   685 #ifdef	DECODE_BAUD

   686 

   687 /*

   688  * A table of available terminal speeds

   689  */

   690 struct termspeeds {

   691     int	speed;

   692     int	value;

   693 } termspeeds[] = {

   694     { 0,      B0 },      { 50,    B50 },    { 75,     B75 },

   695     { 110,    B110 },    { 134,   B134 },   { 150,    B150 },

   696     { 200,    B200 },    { 300,   B300 },   { 600,    B600 },

   697     { 1200,   B1200 },   { 1800,  B1800 },  { 2400,   B2400 },

   698     { 4800,   B4800 },

   699 #ifdef	B7200

   700     { 7200,  B7200 },

   701 #endif

   702     { 9600,   B9600 },

   703 #ifdef	B14400

   704     { 14400,  B14400 },

   705 #endif

   706 #ifdef	B19200

   707     { 19200,  B19200 },

   708 #endif

   709 #ifdef	B28800

   710     { 28800,  B28800 },

   711 #endif

   712 #ifdef	B38400

   713     { 38400,  B38400 },

   714 #endif

   715 #ifdef	B57600

   716     { 57600,  B57600 },

   717 #endif

   718 #ifdef	B115200

   719     { 115200, B115200 },

   720 #endif

   721 #ifdef	B230400

   722     { 230400, B230400 },

   723 #endif

   724     { -1,     0 }

   725 };

   726 #endif	/* DECODE_BUAD */

   727 

   728 void

   729 tty_tspeed(int val)

   730 {

   731 #ifdef	DECODE_BAUD

   732     struct termspeeds *tp;

   733 

   734     for (tp = termspeeds; (tp->speed != -1) && (val > tp->speed); tp++)

   735 	;

   736     if (tp->speed == -1)	/* back up to last valid value */

   737 	--tp;

   738     cfsetospeed(&termbuf, tp->value);

   739 #else	/* DECODE_BUAD */

   740     cfsetospeed(&termbuf, val);

   741 #endif	/* DECODE_BUAD */

   742 }

   743 

   744 void

   745 tty_rspeed(int val)

   746 {

   747 #ifdef	DECODE_BAUD

   748     struct termspeeds *tp;

   749 

   750     for (tp = termspeeds; (tp->speed != -1) && (val > tp->speed); tp++)

   751 	;

   752     if (tp->speed == -1)	/* back up to last valid value */

   753 	--tp;

   754     cfsetispeed(&termbuf, tp->value);

   755 #else	/* DECODE_BAUD */

   756     cfsetispeed(&termbuf, val);

   757 #endif	/* DECODE_BAUD */

   758 }

   759 

   760 #ifdef PARENT_DOES_UTMP

   761 extern	struct utmp wtmp;

   762 extern char wtmpf[];

   763 

   764 extern void utmp_sig_init (void);

   765 extern void utmp_sig_reset (void);

   766 extern void utmp_sig_wait (void);

   767 extern void utmp_sig_notify (int);

   768 # endif /* PARENT_DOES_UTMP */

   769 

   770 #ifdef STREAMSPTY

   771 

   772 /* I_FIND seems to live a life of its own */

   773 static int my_find(int fd, char *module)

   774 {

   775 #if defined(I_FIND) && defined(I_LIST)

   776     static int flag;

   777     static struct str_list sl;

   778     int n;

   779     int i;

   780   

   781     if(!flag){

   782 	n = ioctl(fd, I_LIST, 0);

   783 	if(n < 0){

   784 	    perror("ioctl(fd, I_LIST, 0)");

   785 	    return -1;

   786 	}

   787 	sl.sl_modlist=(struct str_mlist*)malloc(n * sizeof(struct str_mlist));

   788 	sl.sl_nmods = n;

   789 	n = ioctl(fd, I_LIST, &sl);

   790 	if(n < 0){

   791 	    perror("ioctl(fd, I_LIST, n)");

   792 	    return -1;

   793 	}

   794 	flag = 1;

   795     }

   796   

   797     for(i=0; i<sl.sl_nmods; i++)

   798 	if(!strcmp(sl.sl_modlist[i].l_name, module))

   799 	    return 1;

   800 #endif

   801     return 0;

   802 }

   803 

   804 static void maybe_push_modules(int fd, char **modules)

   805 {

   806     char **p;

   807     int err;

   808 

   809     for(p=modules; *p; p++){

   810 	err = my_find(fd, *p);

   811 	if(err == 1)

   812 	    break;

   813 	if(err < 0 && errno != EINVAL)

   814 	    fatalperror(net, "my_find()");

   815 	/* module not pushed or does not exist */

   816     }

   817     /* p points to null or to an already pushed module, now push all

   818        modules before this one */

   819   

   820     for(p--; p >= modules; p--){

   821 	err = ioctl(fd, I_PUSH, *p);

   822 	if(err < 0 && errno != EINVAL)

   823 	    fatalperror(net, "I_PUSH");

   824     }

   825 }

   826 #endif

   827 

   828 /*

   829  * getptyslave()

   830  *

   831  * Open the slave side of the pty, and do any initialization

   832  * that is necessary.  The return value is a file descriptor

   833  * for the slave side.

   834  */

   835 void getptyslave(void)

   836 {

   837     int t = -1;

   838 

   839     struct winsize ws;

   840     /*

   841      * Opening the slave side may cause initilization of the

   842      * kernel tty structure.  We need remember the state of

   843      * 	if linemode was turned on

   844      *	terminal window size

   845      *	terminal speed

   846      * so that we can re-set them if we need to.

   847      */

   848 

   849 

   850     /*

   851      * Make sure that we don't have a controlling tty, and

   852      * that we are the session (process group) leader.

   853      */

   854 

   855 #ifdef HAVE_SETSID

   856     if(setsid()<0)

   857 	fatalperror(net, "setsid()");

   858 #else

   859 # ifdef	TIOCNOTTY

   860     t = open(_PATH_TTY, O_RDWR);

   861     if (t >= 0) {

   862 	ioctl(t, TIOCNOTTY, (char *)0);

   863 	close(t);

   864     }

   865 # endif

   866 #endif

   867 

   868 # ifdef PARENT_DOES_UTMP

   869     /*

   870      * Wait for our parent to get the utmp stuff to get done.

   871      */

   872     utmp_sig_wait();

   873 # endif

   874 

   875     t = cleanopen(line);

   876     if (t < 0)

   877 	fatalperror(net, line);

   878 

   879 #ifdef  STREAMSPTY

   880     ttyfd = t;

   881 	  

   882 

   883     /*

   884      * Not all systems have (or need) modules ttcompat and pckt so

   885      * don't flag it as a fatal error if they don't exist.

   886      */

   887 

   888     if (really_stream)

   889 	{

   890 	    /* these are the streams modules that we want pushed. note

   891 	       that they are in reverse order, ptem will be pushed

   892 	       first. maybe_push_modules() will try to push all modules

   893 	       before the first one that isn't already pushed. i.e if

   894 	       ldterm is pushed, only ttcompat will be attempted.

   895 

   896 	       all this is because we don't know which modules are

   897 	       available, and we don't know which modules are already

   898 	       pushed (via autopush, for instance).

   899 

   900 	       */

   901 	     

   902 	    char *ttymodules[] = { "ttcompat", "ldterm", "ptem", NULL };

   903 	    char *ptymodules[] = { "pckt", NULL };

   904 

   905 	    maybe_push_modules(t, ttymodules);

   906 	    maybe_push_modules(ourpty, ptymodules);

   907 	}

   908 #endif

   909     /*

   910      * set up the tty modes as we like them to be.

   911      */

   912     init_termbuf();

   913 # ifdef	TIOCSWINSZ

   914     if (def_row || def_col) {

   915 	memset(&ws, 0, sizeof(ws));

   916 	ws.ws_col = def_col;

   917 	ws.ws_row = def_row;

   918 	ioctl(t, TIOCSWINSZ, (char *)&ws);

   919     }

   920 # endif

   921 

   922     /*

   923      * Settings for sgtty based systems

   924      */

   925 

   926     /*

   927      * Settings for UNICOS (and HPUX)

   928      */

   929 # if defined(_CRAY) || defined(__hpux)

   930     termbuf.c_oflag = OPOST|ONLCR|TAB3;

   931     termbuf.c_iflag = IGNPAR|ISTRIP|ICRNL|IXON;

   932     termbuf.c_lflag = ISIG|ICANON|ECHO|ECHOE|ECHOK;

   933     termbuf.c_cflag = EXTB|HUPCL|CS8;

   934 # endif

   935 

   936     /*

   937      * Settings for all other termios/termio based

   938      * systems, other than 4.4BSD.  In 4.4BSD the

   939      * kernel does the initial terminal setup.

   940      */

   941 # if !(defined(_CRAY) || defined(__hpux)) && (BSD <= 43)

   942 #  ifndef	OXTABS

   943 #   define OXTABS	0

   944 #  endif

   945     termbuf.c_lflag |= ECHO;

   946     termbuf.c_oflag |= ONLCR|OXTABS;

   947     termbuf.c_iflag |= ICRNL;

   948     termbuf.c_iflag &= ~IXOFF;

   949 # endif

   950     tty_rspeed((def_rspeed > 0) ? def_rspeed : 9600);

   951     tty_tspeed((def_tspeed > 0) ? def_tspeed : 9600);

   952 

   953     /*

   954      * Set the tty modes, and make this our controlling tty.

   955      */

   956     set_termbuf();

   957     if (login_tty(t) == -1)

   958 	fatalperror(net, "login_tty");

   959     if (net > 2)

   960 	close(net);

   961     if (ourpty > 2) {

   962 	close(ourpty);

   963 	ourpty = -1;

   964     }

   965 }

   966 

   967 #ifndef	O_NOCTTY

   968 #define	O_NOCTTY	0

   969 #endif

   970 /*

   971  * Open the specified slave side of the pty,

   972  * making sure that we have a clean tty.

   973  */

   974 

   975 int cleanopen(char *line)

   976 {

   977     int t;

   978 

   979 #ifdef STREAMSPTY

   980     if (!really_stream)

   981 #endif

   982 	{

   983 	    /*

   984 	     * Make sure that other people can't open the

   985 	     * slave side of the connection.

   986 	     */

   987 	    chown(line, 0, 0);

   988 	    chmod(line, 0600);

   989 	}

   990 

   991 #ifdef HAVE_REVOKE

   992     revoke(line);

   993 #endif

   994 

   995     t = open(line, O_RDWR|O_NOCTTY);

   996 

   997     if (t < 0)

   998 	return(-1);

   999 

  1000     /*

  1001      * Hangup anybody else using this ttyp, then reopen it for

  1002      * ourselves.

  1003      */

  1004 # if !(defined(_CRAY) || defined(__hpux)) && (BSD <= 43) && !defined(STREAMSPTY)

  1005     signal(SIGHUP, SIG_IGN);

  1006 #ifdef HAVE_VHANGUP

  1007     vhangup();

  1008 #else

  1009 #endif

  1010     signal(SIGHUP, SIG_DFL);

  1011     t = open(line, O_RDWR|O_NOCTTY);

  1012     if (t < 0)

  1013 	return(-1);

  1014 # endif

  1015 # if	defined(_CRAY) && defined(TCVHUP)

  1016     {

  1017 	int i;

  1018 	signal(SIGHUP, SIG_IGN);

  1019 	ioctl(t, TCVHUP, (char *)0);

  1020 	signal(SIGHUP, SIG_DFL);

  1021 

  1022 	i = open(line, O_RDWR);

  1023 

  1024 	if (i < 0)

  1025 	    return(-1);

  1026 	close(t);

  1027 	t = i;

  1028     }

  1029 # endif	/* defined(CRAY) && defined(TCVHUP) */

  1030     return(t);

  1031 }

  1032 

  1033 //#if !defined(BSD4_4)

  1034 

  1035 int login_tty(int t)

  1036 {

  1037 # if defined(TIOCSCTTY) && !defined(__hpux)

  1038     if (ioctl(t, TIOCSCTTY, (char *)0) < 0)

  1039 	fatalperror(net, "ioctl(sctty)");

  1040 #  ifdef _CRAY

  1041     /*

  1042      * Close the hard fd to /dev/ttypXXX, and re-open through

  1043      * the indirect /dev/tty interface.

  1044      */

  1045     close(t);

  1046     if ((t = open("/dev/tty", O_RDWR)) < 0)

  1047 	fatalperror(net, "open(/dev/tty)");

  1048 #  endif

  1049 # else

  1050     /*

  1051      * We get our controlling tty assigned as a side-effect

  1052      * of opening up a tty device.  But on BSD based systems,

  1053      * this only happens if our process group is zero.  The

  1054      * setsid() call above may have set our pgrp, so clear

  1055      * it out before opening the tty...

  1056      */

  1057 #ifdef HAVE_SETPGID

  1058     setpgid(0, 0);

  1059 #else

  1060     setpgrp(0, 0); /* if setpgid isn't available, setpgrp

  1061 		      probably takes arguments */

  1062 #endif

  1063     close(open(line, O_RDWR));

  1064 # endif

  1065     if (t != 0)

  1066 	dup2(t, 0);

  1067     if (t != 1)

  1068 	dup2(t, 1);

  1069     if (t != 2)

  1070 	dup2(t, 2);

  1071     if (t > 2)

  1072 	close(t);

  1073     return(0);

  1074 }

  1075 //#endif	/* BSD <= 43 */

  1076 

  1077 /*

  1078  * This comes from ../../bsd/tty.c and should not really be here.

  1079  */

  1080 

  1081 /*

  1082  * Clean the tty name.  Return a pointer to the cleaned version.

  1083  */

  1084 #ifndef __SYMBIAN32__

  1085 static char *

  1086 clean_ttyname (char *tty)

  1087 {

  1088   char *res = tty;

  1089 

  1090   if (strncmp (res, _PATH_DEV, strlen(_PATH_DEV)) == 0)

  1091     res += strlen(_PATH_DEV);

  1092   if (strncmp (res, "pty/", 4) == 0)

  1093     res += 4;

  1094   if (strncmp (res, "ptym/", 5) == 0)

  1095     res += 5;

  1096   return res;

  1097 }

  1098 #endif

  1099 /*

  1100  * Generate a name usable as an `ut_id', typically without `tty'.

  1101  */

  1102 

  1103 #ifdef HAVE_STRUCT_UTMP_UT_ID

  1104 static char *

  1105 make_id (char *tty)

  1106 {

  1107   char *res = tty;

  1108   

  1109   if (strncmp (res, "pts/", 4) == 0)

  1110     res += 4;

  1111   if (strncmp (res, "tty", 3) == 0)

  1112     res += 3;

  1113   return res;

  1114 }

  1115 #endif

  1116 

  1117 

  1118 /*

  1119  * startslave(host)

  1120  *

  1121  * Given a hostname, do whatever

  1122  * is necessary to startup the login process on the slave side of the pty.

  1123  */

  1124 

  1125 /* ARGSUSED */

  1126 void

  1127 startslave(const char *host, const char *utmp_host,

  1128 	   int autologin, char *autoname)

  1129 {

  1130 #ifndef __SYMBIAN32__

  1131 	int i;

  1132 #else	

  1133     int fds[3];

  1134     int pid;