Home | History | Annotate | Line # | Download | only in telnet
commands.c revision 1.41
      1  1.41     blymn /*	$NetBSD: commands.c,v 1.41 2000/05/25 12:25:14 blymn Exp $	*/
      2  1.26    itojun 
      3  1.26    itojun /*
      4  1.26    itojun  * Copyright (C) 1997 and 1998 WIDE Project.
      5  1.26    itojun  * All rights reserved.
      6  1.26    itojun  *
      7  1.26    itojun  * Redistribution and use in source and binary forms, with or without
      8  1.26    itojun  * modification, are permitted provided that the following conditions
      9  1.26    itojun  * are met:
     10  1.26    itojun  * 1. Redistributions of source code must retain the above copyright
     11  1.26    itojun  *    notice, this list of conditions and the following disclaimer.
     12  1.26    itojun  * 2. Redistributions in binary form must reproduce the above copyright
     13  1.26    itojun  *    notice, this list of conditions and the following disclaimer in the
     14  1.26    itojun  *    documentation and/or other materials provided with the distribution.
     15  1.26    itojun  * 3. Neither the name of the project nor the names of its contributors
     16  1.26    itojun  *    may be used to endorse or promote products derived from this software
     17  1.26    itojun  *    without specific prior written permission.
     18  1.26    itojun  *
     19  1.26    itojun  * THIS SOFTWARE IS PROVIDED BY THE PROJECT AND CONTRIBUTORS ``AS IS'' AND
     20  1.26    itojun  * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
     21  1.26    itojun  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
     22  1.26    itojun  * ARE DISCLAIMED.  IN NO EVENT SHALL THE PROJECT OR CONTRIBUTORS BE LIABLE
     23  1.26    itojun  * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
     24  1.26    itojun  * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
     25  1.26    itojun  * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
     26  1.26    itojun  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
     27  1.26    itojun  * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
     28  1.26    itojun  * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
     29  1.26    itojun  * SUCH DAMAGE.
     30  1.26    itojun  */
     31  1.13   thorpej 
     32   1.1       cgd /*
     33   1.5       cgd  * Copyright (c) 1988, 1990, 1993
     34   1.5       cgd  *	The Regents of the University of California.  All rights reserved.
     35   1.1       cgd  *
     36   1.1       cgd  * Redistribution and use in source and binary forms, with or without
     37   1.1       cgd  * modification, are permitted provided that the following conditions
     38   1.1       cgd  * are met:
     39   1.1       cgd  * 1. Redistributions of source code must retain the above copyright
     40   1.1       cgd  *    notice, this list of conditions and the following disclaimer.
     41   1.1       cgd  * 2. Redistributions in binary form must reproduce the above copyright
     42   1.1       cgd  *    notice, this list of conditions and the following disclaimer in the
     43   1.1       cgd  *    documentation and/or other materials provided with the distribution.
     44   1.1       cgd  * 3. All advertising materials mentioning features or use of this software
     45   1.1       cgd  *    must display the following acknowledgement:
     46   1.1       cgd  *	This product includes software developed by the University of
     47   1.1       cgd  *	California, Berkeley and its contributors.
     48   1.1       cgd  * 4. Neither the name of the University nor the names of its contributors
     49   1.1       cgd  *    may be used to endorse or promote products derived from this software
     50   1.1       cgd  *    without specific prior written permission.
     51   1.1       cgd  *
     52   1.1       cgd  * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
     53   1.1       cgd  * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
     54   1.1       cgd  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
     55   1.1       cgd  * ARE DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
     56   1.1       cgd  * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
     57   1.1       cgd  * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
     58   1.1       cgd  * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
     59   1.1       cgd  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
     60   1.1       cgd  * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
     61   1.1       cgd  * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
     62   1.1       cgd  * SUCH DAMAGE.
     63   1.1       cgd  */
     64   1.1       cgd 
     65  1.15  christos #include <sys/cdefs.h>
     66   1.1       cgd #ifndef lint
     67  1.13   thorpej #if 0
     68  1.13   thorpej static char sccsid[] = "@(#)commands.c	8.4 (Berkeley) 5/30/95";
     69  1.13   thorpej #else
     70  1.41     blymn __RCSID("$NetBSD: commands.c,v 1.41 2000/05/25 12:25:14 blymn Exp $");
     71  1.13   thorpej #endif
     72   1.1       cgd #endif /* not lint */
     73   1.1       cgd 
     74   1.1       cgd #if	defined(unix)
     75   1.1       cgd #include <sys/param.h>
     76   1.5       cgd #if	defined(CRAY) || defined(sysV88)
     77   1.1       cgd #include <sys/types.h>
     78   1.1       cgd #endif
     79   1.1       cgd #include <sys/file.h>
     80   1.1       cgd #else
     81   1.1       cgd #include <sys/types.h>
     82   1.1       cgd #endif	/* defined(unix) */
     83  1.15  christos #include <sys/wait.h>
     84   1.1       cgd #include <sys/socket.h>
     85   1.1       cgd #include <netinet/in.h>
     86  1.15  christos #include <arpa/inet.h>
     87   1.1       cgd #ifdef	CRAY
     88   1.1       cgd #include <fcntl.h>
     89   1.1       cgd #endif	/* CRAY */
     90   1.1       cgd 
     91   1.1       cgd #include <signal.h>
     92   1.1       cgd #include <netdb.h>
     93   1.1       cgd #include <ctype.h>
     94   1.1       cgd #include <pwd.h>
     95  1.15  christos #ifdef __STDC__
     96  1.15  christos #include <stdarg.h>
     97  1.15  christos #else
     98   1.1       cgd #include <varargs.h>
     99  1.15  christos #endif
    100   1.1       cgd #include <errno.h>
    101  1.15  christos #include <unistd.h>
    102   1.1       cgd 
    103   1.1       cgd #include <arpa/telnet.h>
    104  1.10       jtk #include <sys/cdefs.h>
    105  1.10       jtk #define P __P
    106   1.1       cgd 
    107   1.1       cgd #include "general.h"
    108   1.1       cgd 
    109   1.1       cgd #include "ring.h"
    110   1.1       cgd 
    111   1.1       cgd #include "externs.h"
    112   1.1       cgd #include "defines.h"
    113   1.1       cgd #include "types.h"
    114  1.15  christos #include <libtelnet/misc.h>
    115   1.1       cgd 
    116   1.5       cgd #if !defined(CRAY) && !defined(sysV88)
    117   1.1       cgd #include <netinet/in_systm.h>
    118   1.1       cgd # if (defined(vax) || defined(tahoe) || defined(hp300)) && !defined(ultrix)
    119   1.1       cgd # include <machine/endian.h>
    120   1.1       cgd # endif /* vax */
    121   1.5       cgd #endif /* !defined(CRAY) && !defined(sysV88) */
    122   1.1       cgd #include <netinet/ip.h>
    123   1.1       cgd 
    124   1.1       cgd 
    125  1.10       jtk #ifndef	MAXHOSTNAMELEN
    126  1.10       jtk #define	MAXHOSTNAMELEN 64
    127  1.10       jtk #endif	MAXHOSTNAMELEN
    128   1.1       cgd 
    129   1.1       cgd #if	defined(IPPROTO_IP) && defined(IP_TOS)
    130   1.1       cgd int tos = -1;
    131   1.1       cgd #endif	/* defined(IPPROTO_IP) && defined(IP_TOS) */
    132   1.1       cgd 
    133   1.1       cgd char	*hostname;
    134   1.1       cgd static char _hostname[MAXHOSTNAMELEN];
    135   1.1       cgd 
    136   1.1       cgd typedef struct {
    137   1.1       cgd 	char	*name;		/* command name */
    138   1.1       cgd 	char	*help;		/* help string (NULL for no help) */
    139  1.15  christos 	int	(*handler)	/* routine which executes command */
    140  1.15  christos 			    P((int, char *[]));
    141   1.1       cgd 	int	needconnect;	/* Do we need to be connected to execute? */
    142   1.1       cgd } Command;
    143   1.1       cgd 
    144   1.1       cgd static char line[256];
    145   1.1       cgd static char saveline[256];
    146   1.1       cgd static int margc;
    147   1.1       cgd static char *margv[20];
    148   1.1       cgd 
    149  1.15  christos static void makeargv P((void));
    150  1.20       mrg static int special P((char *));
    151  1.15  christos static char *control P((cc_t));
    152  1.15  christos static int sendcmd P((int, char **));
    153  1.15  christos static int send_esc P((char *));
    154  1.15  christos static int send_docmd P((char *));
    155  1.15  christos static int send_dontcmd P((char *));
    156  1.15  christos static int send_willcmd P((char *));
    157  1.15  christos static int send_wontcmd P((char *));
    158  1.15  christos static int send_help P((char *));
    159  1.15  christos static int lclchars P((int));
    160  1.15  christos static int togdebug P((int));
    161  1.15  christos static int togcrlf P((int));
    162  1.15  christos static int togbinary P((int));
    163  1.15  christos static int togrbinary P((int));
    164  1.15  christos static int togxbinary P((int));
    165  1.15  christos static int togglehelp P((int));
    166  1.15  christos static void settogglehelp P((int));
    167  1.15  christos static int toggle P((int, char *[]));
    168  1.15  christos static struct setlist *getset P((char *));
    169  1.15  christos static int setcmd P((int, char *[]));
    170  1.15  christos static int unsetcmd P((int, char *[]));
    171  1.15  christos static int dokludgemode P((int));
    172  1.15  christos static int dolinemode P((int));
    173  1.15  christos static int docharmode P((int));
    174  1.15  christos static int dolmmode P((int, int ));
    175  1.15  christos static int modecmd P((int, char *[]));
    176  1.15  christos static int display P((int, char *[]));
    177  1.15  christos static int setescape P((int, char *[]));
    178  1.15  christos static int togcrmod P((int, char *[]));
    179  1.20       mrg static int bye P((int, char *[]));
    180  1.15  christos static void slc_help P((int));
    181  1.15  christos static struct slclist *getslc P((char *));
    182  1.20       mrg static int slccmd P((int, char *[]));
    183  1.15  christos static struct env_lst *env_help P((unsigned char *, unsigned char *));
    184  1.15  christos static struct envlist *getenvcmd P((char *));
    185  1.15  christos #ifdef AUTHENTICATION
    186  1.25  christos static int auth_help P((char *));
    187  1.15  christos #endif
    188  1.15  christos #if	defined(unix) && defined(TN3270)
    189  1.15  christos static void filestuff P((int));
    190  1.15  christos #endif
    191  1.20       mrg static int status P((int, char *[]));
    192  1.26    itojun static const char *sockaddr_ntop __P((struct sockaddr *));
    193  1.15  christos typedef int (*intrtn_t) P((int, char **));
    194  1.15  christos static int call P((intrtn_t, ...));
    195  1.15  christos static Command *getcmd P((char *));
    196  1.20       mrg static int help P((int, char *[]));
    197  1.15  christos 
    198   1.1       cgd     static void
    199   1.1       cgd makeargv()
    200   1.1       cgd {
    201   1.1       cgd     register char *cp, *cp2, c;
    202   1.1       cgd     register char **argp = margv;
    203   1.1       cgd 
    204   1.1       cgd     margc = 0;
    205   1.1       cgd     cp = line;
    206   1.1       cgd     if (*cp == '!') {		/* Special case shell escape */
    207   1.1       cgd 	strcpy(saveline, line);	/* save for shell command */
    208   1.1       cgd 	*argp++ = "!";		/* No room in string to get this */
    209   1.1       cgd 	margc++;
    210   1.1       cgd 	cp++;
    211   1.1       cgd     }
    212  1.15  christos     while ((c = *cp) != '\0') {
    213   1.1       cgd 	register int inquote = 0;
    214  1.25  christos 	while (isspace((unsigned char)c))
    215   1.1       cgd 	    c = *++cp;
    216   1.1       cgd 	if (c == '\0')
    217   1.1       cgd 	    break;
    218   1.1       cgd 	*argp++ = cp;
    219   1.1       cgd 	margc += 1;
    220   1.1       cgd 	for (cp2 = cp; c != '\0'; c = *++cp) {
    221   1.1       cgd 	    if (inquote) {
    222   1.1       cgd 		if (c == inquote) {
    223   1.1       cgd 		    inquote = 0;
    224   1.1       cgd 		    continue;
    225   1.1       cgd 		}
    226   1.1       cgd 	    } else {
    227   1.1       cgd 		if (c == '\\') {
    228   1.1       cgd 		    if ((c = *++cp) == '\0')
    229   1.1       cgd 			break;
    230   1.1       cgd 		} else if (c == '"') {
    231   1.1       cgd 		    inquote = '"';
    232   1.1       cgd 		    continue;
    233   1.1       cgd 		} else if (c == '\'') {
    234   1.1       cgd 		    inquote = '\'';
    235   1.1       cgd 		    continue;
    236  1.25  christos 		} else if (isspace((unsigned char)c))
    237   1.1       cgd 		    break;
    238   1.1       cgd 	    }
    239   1.1       cgd 	    *cp2++ = c;
    240   1.1       cgd 	}
    241   1.1       cgd 	*cp2 = '\0';
    242   1.1       cgd 	if (c == '\0')
    243   1.1       cgd 	    break;
    244   1.1       cgd 	cp++;
    245   1.1       cgd     }
    246   1.1       cgd     *argp++ = 0;
    247   1.1       cgd }
    248   1.1       cgd 
    249   1.1       cgd /*
    250   1.1       cgd  * Make a character string into a number.
    251   1.1       cgd  *
    252   1.1       cgd  * Todo:  1.  Could take random integers (12, 0x12, 012, 0b1).
    253   1.1       cgd  */
    254   1.1       cgd 
    255  1.15  christos 	static int
    256   1.1       cgd special(s)
    257   1.1       cgd 	register char *s;
    258   1.1       cgd {
    259   1.1       cgd 	register char c;
    260   1.1       cgd 	char b;
    261   1.1       cgd 
    262   1.1       cgd 	switch (*s) {
    263   1.1       cgd 	case '^':
    264   1.1       cgd 		b = *++s;
    265   1.1       cgd 		if (b == '?') {
    266   1.1       cgd 		    c = b | 0x40;		/* DEL */
    267   1.1       cgd 		} else {
    268   1.1       cgd 		    c = b & 0x1f;
    269   1.1       cgd 		}
    270   1.1       cgd 		break;
    271   1.1       cgd 	default:
    272   1.1       cgd 		c = *s;
    273   1.1       cgd 		break;
    274   1.1       cgd 	}
    275   1.1       cgd 	return c;
    276   1.1       cgd }
    277   1.1       cgd 
    278   1.1       cgd /*
    279   1.1       cgd  * Construct a control character sequence
    280   1.1       cgd  * for a special character.
    281   1.1       cgd  */
    282   1.1       cgd 	static char *
    283   1.1       cgd control(c)
    284   1.1       cgd 	register cc_t c;
    285   1.1       cgd {
    286   1.1       cgd 	static char buf[5];
    287   1.1       cgd 	/*
    288   1.1       cgd 	 * The only way I could get the Sun 3.5 compiler
    289   1.1       cgd 	 * to shut up about
    290   1.1       cgd 	 *	if ((unsigned int)c >= 0x80)
    291   1.1       cgd 	 * was to assign "c" to an unsigned int variable...
    292   1.1       cgd 	 * Arggg....
    293   1.1       cgd 	 */
    294   1.1       cgd 	register unsigned int uic = (unsigned int)c;
    295   1.1       cgd 
    296   1.1       cgd 	if (uic == 0x7f)
    297   1.1       cgd 		return ("^?");
    298   1.1       cgd 	if (c == (cc_t)_POSIX_VDISABLE) {
    299   1.1       cgd 		return "off";
    300   1.1       cgd 	}
    301   1.1       cgd 	if (uic >= 0x80) {
    302   1.1       cgd 		buf[0] = '\\';
    303   1.1       cgd 		buf[1] = ((c>>6)&07) + '0';
    304   1.1       cgd 		buf[2] = ((c>>3)&07) + '0';
    305   1.1       cgd 		buf[3] = (c&07) + '0';
    306   1.1       cgd 		buf[4] = 0;
    307   1.1       cgd 	} else if (uic >= 0x20) {
    308   1.1       cgd 		buf[0] = c;
    309   1.1       cgd 		buf[1] = 0;
    310   1.1       cgd 	} else {
    311   1.1       cgd 		buf[0] = '^';
    312   1.1       cgd 		buf[1] = '@'+c;
    313   1.1       cgd 		buf[2] = 0;
    314   1.1       cgd 	}
    315   1.1       cgd 	return (buf);
    316   1.1       cgd }
    317   1.1       cgd 
    318   1.1       cgd 
    319   1.1       cgd 
    320   1.1       cgd /*
    321   1.1       cgd  *	The following are data structures and routines for
    322   1.1       cgd  *	the "send" command.
    323   1.1       cgd  *
    324   1.1       cgd  */
    325  1.10       jtk 
    326   1.1       cgd struct sendlist {
    327   1.1       cgd     char	*name;		/* How user refers to it (case independent) */
    328   1.1       cgd     char	*help;		/* Help information (0 ==> no help) */
    329   1.1       cgd     int		needconnect;	/* Need to be connected */
    330   1.1       cgd     int		narg;		/* Number of arguments */
    331  1.15  christos     int		(*handler)	/* Routine to perform (for special ops) */
    332  1.15  christos 			    P((char *));
    333   1.1       cgd     int		nbyte;		/* Number of bytes to send this command */
    334   1.1       cgd     int		what;		/* Character to be sent (<0 ==> special) */
    335   1.1       cgd };
    336   1.1       cgd 
    337   1.1       cgd 
    339   1.1       cgd static struct sendlist Sendlist[] = {
    340   1.1       cgd     { "ao",	"Send Telnet Abort output",		1, 0, 0, 2, AO },
    341   1.1       cgd     { "ayt",	"Send Telnet 'Are You There'",		1, 0, 0, 2, AYT },
    342   1.1       cgd     { "brk",	"Send Telnet Break",			1, 0, 0, 2, BREAK },
    343   1.1       cgd     { "break",	0,					1, 0, 0, 2, BREAK },
    344   1.1       cgd     { "ec",	"Send Telnet Erase Character",		1, 0, 0, 2, EC },
    345   1.1       cgd     { "el",	"Send Telnet Erase Line",		1, 0, 0, 2, EL },
    346   1.1       cgd     { "escape",	"Send current escape character",	1, 0, send_esc, 1, 0 },
    347   1.1       cgd     { "ga",	"Send Telnet 'Go Ahead' sequence",	1, 0, 0, 2, GA },
    348   1.1       cgd     { "ip",	"Send Telnet Interrupt Process",	1, 0, 0, 2, IP },
    349   1.1       cgd     { "intp",	0,					1, 0, 0, 2, IP },
    350   1.1       cgd     { "interrupt", 0,					1, 0, 0, 2, IP },
    351   1.1       cgd     { "intr",	0,					1, 0, 0, 2, IP },
    352   1.1       cgd     { "nop",	"Send Telnet 'No operation'",		1, 0, 0, 2, NOP },
    353   1.1       cgd     { "eor",	"Send Telnet 'End of Record'",		1, 0, 0, 2, EOR },
    354   1.1       cgd     { "abort",	"Send Telnet 'Abort Process'",		1, 0, 0, 2, ABORT },
    355   1.1       cgd     { "susp",	"Send Telnet 'Suspend Process'",	1, 0, 0, 2, SUSP },
    356   1.1       cgd     { "eof",	"Send Telnet End of File Character",	1, 0, 0, 2, xEOF },
    357   1.1       cgd     { "synch",	"Perform Telnet 'Synch operation'",	1, 0, dosynch, 2, 0 },
    358   1.1       cgd     { "getstatus", "Send request for STATUS",		1, 0, get_status, 6, 0 },
    359   1.1       cgd     { "?",	"Display send options",			0, 0, send_help, 0, 0 },
    360   1.1       cgd     { "help",	0,					0, 0, send_help, 0, 0 },
    361   1.1       cgd     { "do",	0,					0, 1, send_docmd, 3, 0 },
    362   1.1       cgd     { "dont",	0,					0, 1, send_dontcmd, 3, 0 },
    363   1.1       cgd     { "will",	0,					0, 1, send_willcmd, 3, 0 },
    364   1.1       cgd     { "wont",	0,					0, 1, send_wontcmd, 3, 0 },
    365   1.1       cgd     { 0 }
    366   1.1       cgd };
    367   1.1       cgd 
    368   1.1       cgd #define	GETSEND(name) ((struct sendlist *) genget(name, (char **) Sendlist, \
    369   1.1       cgd 				sizeof(struct sendlist)))
    370   1.1       cgd 
    371   1.1       cgd     static int
    372   1.1       cgd sendcmd(argc, argv)
    373   1.1       cgd     int  argc;
    374   1.1       cgd     char **argv;
    375   1.1       cgd {
    376   1.1       cgd     int count;		/* how many bytes we are going to need to send */
    377   1.1       cgd     int i;
    378   1.1       cgd     struct sendlist *s;	/* pointer to current command */
    379   1.1       cgd     int success = 0;
    380   1.1       cgd     int needconnect = 0;
    381   1.1       cgd 
    382   1.1       cgd     if (argc < 2) {
    383   1.1       cgd 	printf("need at least one argument for 'send' command\n");
    384   1.1       cgd 	printf("'send ?' for help\n");
    385   1.1       cgd 	return 0;
    386   1.1       cgd     }
    387   1.1       cgd     /*
    388   1.1       cgd      * First, validate all the send arguments.
    389   1.1       cgd      * In addition, we see how much space we are going to need, and
    390   1.1       cgd      * whether or not we will be doing a "SYNCH" operation (which
    391   1.1       cgd      * flushes the network queue).
    392   1.1       cgd      */
    393   1.1       cgd     count = 0;
    394   1.1       cgd     for (i = 1; i < argc; i++) {
    395   1.1       cgd 	s = GETSEND(argv[i]);
    396   1.1       cgd 	if (s == 0) {
    397   1.1       cgd 	    printf("Unknown send argument '%s'\n'send ?' for help.\n",
    398   1.1       cgd 			argv[i]);
    399   1.1       cgd 	    return 0;
    400   1.1       cgd 	} else if (Ambiguous(s)) {
    401   1.1       cgd 	    printf("Ambiguous send argument '%s'\n'send ?' for help.\n",
    402   1.1       cgd 			argv[i]);
    403   1.1       cgd 	    return 0;
    404   1.1       cgd 	}
    405   1.1       cgd 	if (i + s->narg >= argc) {
    406   1.1       cgd 	    fprintf(stderr,
    407   1.1       cgd 	    "Need %d argument%s to 'send %s' command.  'send %s ?' for help.\n",
    408   1.1       cgd 		s->narg, s->narg == 1 ? "" : "s", s->name, s->name);
    409   1.1       cgd 	    return 0;
    410   1.1       cgd 	}
    411   1.1       cgd 	count += s->nbyte;
    412  1.15  christos 	if (s->handler == send_help) {
    413   1.1       cgd 	    send_help(NULL);
    414   1.1       cgd 	    return 0;
    415   1.1       cgd 	}
    416   1.1       cgd 
    417   1.1       cgd 	i += s->narg;
    418   1.1       cgd 	needconnect += s->needconnect;
    419   1.1       cgd     }
    420   1.1       cgd     if (!connected && needconnect) {
    421   1.1       cgd 	printf("?Need to be connected first.\n");
    422   1.1       cgd 	printf("'send ?' for help\n");
    423   1.1       cgd 	return 0;
    424   1.1       cgd     }
    425   1.1       cgd     /* Now, do we have enough room? */
    426   1.1       cgd     if (NETROOM() < count) {
    427   1.1       cgd 	printf("There is not enough room in the buffer TO the network\n");
    428   1.1       cgd 	printf("to process your request.  Nothing will be done.\n");
    429   1.1       cgd 	printf("('send synch' will throw away most data in the network\n");
    430   1.1       cgd 	printf("buffer, if this might help.)\n");
    431   1.1       cgd 	return 0;
    432   1.1       cgd     }
    433   1.1       cgd     /* OK, they are all OK, now go through again and actually send */
    434   1.1       cgd     count = 0;
    435   1.1       cgd     for (i = 1; i < argc; i++) {
    436   1.1       cgd 	if ((s = GETSEND(argv[i])) == 0) {
    437  1.15  christos 	    fprintf(stderr, "Telnet 'send' error - argument disappeared!\n");
    438   1.1       cgd 	    (void) quit(0, NULL);
    439   1.1       cgd 	    /*NOTREACHED*/
    440   1.1       cgd 	}
    441   1.1       cgd 	if (s->handler) {
    442  1.15  christos 	    count++;
    443   1.1       cgd 	    success += (*s->handler)(argv[i+1]);
    444   1.1       cgd 	    i += s->narg;
    445   1.3       cgd 	} else {
    446   1.3       cgd 	    NET2ADD(IAC, s->what);
    447   1.1       cgd 	    printoption("SENT", IAC, s->what);
    448   1.1       cgd 	}
    449   1.1       cgd     }
    450   1.1       cgd     return (count == success);
    451   1.1       cgd }
    452   1.1       cgd 
    453  1.15  christos     static int
    454  1.15  christos send_esc(s)
    455   1.1       cgd     char *s;
    456   1.1       cgd {
    457   1.1       cgd     NETADD(escape);
    458   1.1       cgd     return 1;
    459   1.1       cgd }
    460   1.1       cgd 
    461   1.1       cgd     static int
    462   1.1       cgd send_docmd(name)
    463   1.1       cgd     char *name;
    464   1.1       cgd {
    465   1.1       cgd     return(send_tncmd(send_do, "do", name));
    466   1.1       cgd }
    467   1.1       cgd 
    468   1.1       cgd     static int
    469   1.1       cgd send_dontcmd(name)
    470   1.1       cgd     char *name;
    471   1.1       cgd {
    472   1.1       cgd     return(send_tncmd(send_dont, "dont", name));
    473   1.1       cgd }
    474   1.1       cgd     static int
    475   1.1       cgd send_willcmd(name)
    476   1.1       cgd     char *name;
    477   1.1       cgd {
    478   1.1       cgd     return(send_tncmd(send_will, "will", name));
    479   1.1       cgd }
    480   1.1       cgd     static int
    481   1.1       cgd send_wontcmd(name)
    482   1.1       cgd     char *name;
    483   1.1       cgd {
    484   1.1       cgd     return(send_tncmd(send_wont, "wont", name));
    485   1.1       cgd }
    486   1.1       cgd 
    487   1.1       cgd     int
    488  1.15  christos send_tncmd(func, cmd, name)
    489   1.1       cgd     void	(*func) P((int, int));
    490   1.1       cgd     char	*cmd, *name;
    491   1.1       cgd {
    492   1.1       cgd     char **cpp;
    493   1.5       cgd     extern char *telopts[];
    494   1.1       cgd     register int val = 0;
    495  1.11       jtk 
    496   1.1       cgd     if (isprefix(name, "?")) {
    497   1.1       cgd 	register int col, len;
    498   1.5       cgd 
    499   1.5       cgd 	printf("Usage: send %s <value|option>\n", cmd);
    500   1.1       cgd 	printf("\"value\" must be from 0 to 255\n");
    501   1.1       cgd 	printf("Valid options are:\n\t");
    502   1.1       cgd 
    503   1.1       cgd 	col = 8;
    504   1.5       cgd 	for (cpp = telopts; *cpp; cpp++) {
    505   1.1       cgd 	    len = strlen(*cpp) + 3;
    506   1.1       cgd 	    if (col + len > 65) {
    507   1.1       cgd 		printf("\n\t");
    508   1.1       cgd 		col = 8;
    509   1.5       cgd 	    }
    510   1.1       cgd 	    printf(" \"%s\"", *cpp);
    511   1.1       cgd 	    col += len;
    512   1.1       cgd 	}
    513   1.1       cgd 	printf("\n");
    514   1.1       cgd 	return 0;
    515   1.1       cgd     }
    516   1.1       cgd     cpp = (char **)genget(name, telopts, sizeof(char *));
    517   1.1       cgd     if (Ambiguous(cpp)) {
    518   1.1       cgd 	fprintf(stderr,"'%s': ambiguous argument ('send %s ?' for help).\n",
    519   1.1       cgd 					name, cmd);
    520   1.1       cgd 	return 0;
    521   1.5       cgd     }
    522   1.5       cgd     if (cpp) {
    523   1.5       cgd 	val = cpp - telopts;
    524   1.5       cgd     } else {
    525   1.5       cgd 	register char *cp = name;
    526   1.5       cgd 
    527   1.5       cgd 	while (*cp >= '0' && *cp <= '9') {
    528   1.5       cgd 	    val *= 10;
    529   1.5       cgd 	    val += *cp - '0';
    530   1.5       cgd 	    cp++;
    531   1.5       cgd 	}
    532   1.5       cgd 	if (*cp != 0) {
    533   1.5       cgd 	    fprintf(stderr, "'%s': unknown argument ('send %s ?' for help).\n",
    534   1.5       cgd 					name, cmd);
    535   1.5       cgd 	    return 0;
    536   1.5       cgd 	} else if (val < 0 || val > 255) {
    537   1.1       cgd 	    fprintf(stderr, "'%s': bad value ('send %s ?' for help).\n",
    538   1.5       cgd 					name, cmd);
    539   1.5       cgd 	    return 0;
    540   1.1       cgd 	}
    541   1.1       cgd     }
    542   1.1       cgd     if (!connected) {
    543   1.1       cgd 	printf("?Need to be connected first.\n");
    544   1.1       cgd 	return 0;
    545   1.5       cgd     }
    546   1.1       cgd     (*func)(val, 1);
    547   1.1       cgd     return 1;
    548   1.1       cgd }
    549   1.1       cgd 
    550  1.15  christos     static int
    551  1.15  christos send_help(n)
    552   1.1       cgd     char *n;
    553   1.1       cgd {
    554   1.1       cgd     struct sendlist *s;	/* pointer to current command */
    555   1.1       cgd     for (s = Sendlist; s->name; s++) {
    556   1.1       cgd 	if (s->help)
    557   1.1       cgd 	    printf("%-15s %s\n", s->name, s->help);
    558   1.1       cgd     }
    559   1.1       cgd     return(0);
    560   1.1       cgd }
    561   1.1       cgd 
    562   1.1       cgd /*
    564   1.1       cgd  * The following are the routines and data structures referred
    565   1.1       cgd  * to by the arguments to the "toggle" command.
    566   1.1       cgd  */
    567  1.15  christos 
    568  1.15  christos     static int
    569   1.1       cgd lclchars(n)
    570   1.1       cgd     int n;
    571   1.1       cgd {
    572   1.1       cgd     donelclchars = 1;
    573   1.1       cgd     return 1;
    574   1.1       cgd }
    575  1.15  christos 
    576  1.15  christos     static int
    577   1.1       cgd togdebug(n)
    578   1.1       cgd     int n;
    579   1.1       cgd {
    580   1.1       cgd #ifndef	NOT43
    581   1.1       cgd     if (net > 0 &&
    582   1.1       cgd 	(SetSockOpt(net, SOL_SOCKET, SO_DEBUG, debug)) < 0) {
    583   1.1       cgd 	    perror("setsockopt (SO_DEBUG)");
    584   1.1       cgd     }
    585  1.12       jtk #else	/* NOT43 */
    586   1.1       cgd     if (debug) {
    587   1.1       cgd 	if (net > 0 && SetSockOpt(net, SOL_SOCKET, SO_DEBUG, 1) < 0)
    588   1.1       cgd 	    perror("setsockopt (SO_DEBUG)");
    589   1.1       cgd     } else
    590   1.1       cgd 	printf("Cannot turn off socket debugging\n");
    591   1.1       cgd #endif	/* NOT43 */
    592   1.1       cgd     return 1;
    593   1.1       cgd }
    594   1.1       cgd 
    595  1.15  christos 
    596  1.15  christos     static int
    597   1.1       cgd togcrlf(n)
    598   1.1       cgd     int n;
    599   1.1       cgd {
    600   1.1       cgd     if (crlf) {
    601   1.1       cgd 	printf("Will send carriage returns as telnet <CR><LF>.\n");
    602   1.1       cgd     } else {
    603   1.1       cgd 	printf("Will send carriage returns as telnet <CR><NUL>.\n");
    604   1.1       cgd     }
    605   1.1       cgd     return 1;
    606   1.1       cgd }
    607   1.1       cgd 
    608   1.1       cgd int binmode;
    609   1.1       cgd 
    610   1.1       cgd     static int
    611   1.1       cgd togbinary(val)
    612   1.1       cgd     int val;
    613   1.1       cgd {
    614   1.1       cgd     donebinarytoggle = 1;
    615   1.1       cgd 
    616   1.1       cgd     if (val >= 0) {
    617   1.1       cgd 	binmode = val;
    618   1.1       cgd     } else {
    619   1.1       cgd 	if (my_want_state_is_will(TELOPT_BINARY) &&
    620   1.1       cgd 				my_want_state_is_do(TELOPT_BINARY)) {
    621   1.1       cgd 	    binmode = 1;
    622   1.1       cgd 	} else if (my_want_state_is_wont(TELOPT_BINARY) &&
    623   1.1       cgd 				my_want_state_is_dont(TELOPT_BINARY)) {
    624   1.1       cgd 	    binmode = 0;
    625   1.1       cgd 	}
    626   1.1       cgd 	val = binmode ? 0 : 1;
    627   1.1       cgd     }
    628   1.1       cgd 
    629   1.1       cgd     if (val == 1) {
    630   1.1       cgd 	if (my_want_state_is_will(TELOPT_BINARY) &&
    631   1.1       cgd 					my_want_state_is_do(TELOPT_BINARY)) {
    632   1.1       cgd 	    printf("Already operating in binary mode with remote host.\n");
    633   1.1       cgd 	} else {
    634   1.1       cgd 	    printf("Negotiating binary mode with remote host.\n");
    635   1.1       cgd 	    tel_enter_binary(3);
    636   1.1       cgd 	}
    637   1.1       cgd     } else {
    638   1.1       cgd 	if (my_want_state_is_wont(TELOPT_BINARY) &&
    639   1.1       cgd 					my_want_state_is_dont(TELOPT_BINARY)) {
    640   1.1       cgd 	    printf("Already in network ascii mode with remote host.\n");
    641   1.1       cgd 	} else {
    642   1.1       cgd 	    printf("Negotiating network ascii mode with remote host.\n");
    643   1.1       cgd 	    tel_leave_binary(3);
    644   1.1       cgd 	}
    645   1.1       cgd     }
    646   1.1       cgd     return 1;
    647   1.1       cgd }
    648   1.1       cgd 
    649   1.1       cgd     static int
    650   1.1       cgd togrbinary(val)
    651   1.1       cgd     int val;
    652   1.1       cgd {
    653   1.1       cgd     donebinarytoggle = 1;
    654   1.1       cgd 
    655   1.1       cgd     if (val == -1)
    656   1.1       cgd 	val = my_want_state_is_do(TELOPT_BINARY) ? 0 : 1;
    657   1.1       cgd 
    658   1.1       cgd     if (val == 1) {
    659   1.1       cgd 	if (my_want_state_is_do(TELOPT_BINARY)) {
    660   1.1       cgd 	    printf("Already receiving in binary mode.\n");
    661   1.1       cgd 	} else {
    662   1.1       cgd 	    printf("Negotiating binary mode on input.\n");
    663   1.1       cgd 	    tel_enter_binary(1);
    664   1.1       cgd 	}
    665   1.1       cgd     } else {
    666   1.1       cgd 	if (my_want_state_is_dont(TELOPT_BINARY)) {
    667   1.1       cgd 	    printf("Already receiving in network ascii mode.\n");
    668   1.1       cgd 	} else {
    669   1.1       cgd 	    printf("Negotiating network ascii mode on input.\n");
    670   1.1       cgd 	    tel_leave_binary(1);
    671   1.1       cgd 	}
    672   1.1       cgd     }
    673   1.1       cgd     return 1;
    674   1.1       cgd }
    675   1.1       cgd 
    676   1.1       cgd     static int
    677   1.1       cgd togxbinary(val)
    678   1.1       cgd     int val;
    679   1.1       cgd {
    680   1.1       cgd     donebinarytoggle = 1;
    681   1.1       cgd 
    682   1.1       cgd     if (val == -1)
    683   1.1       cgd 	val = my_want_state_is_will(TELOPT_BINARY) ? 0 : 1;
    684   1.1       cgd 
    685   1.1       cgd     if (val == 1) {
    686   1.1       cgd 	if (my_want_state_is_will(TELOPT_BINARY)) {
    687   1.1       cgd 	    printf("Already transmitting in binary mode.\n");
    688   1.1       cgd 	} else {
    689   1.1       cgd 	    printf("Negotiating binary mode on output.\n");
    690   1.1       cgd 	    tel_enter_binary(2);
    691   1.1       cgd 	}
    692   1.1       cgd     } else {
    693   1.1       cgd 	if (my_want_state_is_wont(TELOPT_BINARY)) {
    694   1.1       cgd 	    printf("Already transmitting in network ascii mode.\n");
    695   1.1       cgd 	} else {
    696   1.1       cgd 	    printf("Negotiating network ascii mode on output.\n");
    697   1.1       cgd 	    tel_leave_binary(2);
    698   1.1       cgd 	}
    699   1.1       cgd     }
    700   1.1       cgd     return 1;
    701   1.1       cgd }
    702   1.1       cgd 
    703   1.1       cgd 
    704   1.1       cgd struct togglelist {
    705  1.15  christos     char	*name;		/* name of toggle */
    706  1.15  christos     char	*help;		/* help message */
    707   1.1       cgd     int		(*handler)	/* routine to do actual setting */
    708   1.1       cgd 			P((int));
    709   1.1       cgd     int		*variable;
    710   1.1       cgd     char	*actionexplanation;
    711   1.1       cgd };
    712   1.1       cgd 
    713   1.1       cgd static struct togglelist Togglelist[] = {
    714   1.1       cgd     { "autoflush",
    715   1.1       cgd 	"flushing of output when sending interrupt characters",
    716   1.1       cgd 	    0,
    717   1.1       cgd 		&autoflush,
    718   1.1       cgd 		    "flush output when sending interrupt characters" },
    719   1.1       cgd     { "autosynch",
    720   1.1       cgd 	"automatic sending of interrupt characters in urgent mode",
    721   1.1       cgd 	    0,
    722   1.5       cgd 		&autosynch,
    723   1.1       cgd 		    "send interrupt characters in urgent mode" },
    724   1.1       cgd #if	defined(AUTHENTICATION)
    725   1.1       cgd     { "autologin",
    726   1.1       cgd 	"automatic sending of login and/or authentication info",
    727   1.1       cgd 	    0,
    728  1.25  christos 		&autologin,
    729   1.1       cgd 		    "send login name and/or authentication information" },
    730   1.1       cgd #if 0
    731   1.1       cgd     { "authdebug",
    732   1.1       cgd 	"Toggle authentication debugging",
    733   1.1       cgd 	    auth_togdebug,
    734   1.1       cgd 		0,
    735  1.25  christos 		     "print authentication debugging information" },
    736   1.1       cgd #endif
    737   1.1       cgd #endif
    738   1.1       cgd     { "skiprc",
    739   1.1       cgd 	"don't read ~/.telnetrc file",
    740   1.5       cgd 	    0,
    741   1.1       cgd 		&skiprc,
    742   1.1       cgd 		    "skip reading of ~/.telnetrc file" },
    743   1.1       cgd     { "binary",
    744   1.1       cgd 	"sending and receiving of binary data",
    745   1.1       cgd 	    togbinary,
    746   1.1       cgd 		0,
    747   1.1       cgd 		    0 },
    748   1.1       cgd     { "inbinary",
    749   1.1       cgd 	"receiving of binary data",
    750   1.1       cgd 	    togrbinary,
    751   1.1       cgd 		0,
    752   1.1       cgd 		    0 },
    753   1.1       cgd     { "outbinary",
    754   1.1       cgd 	"sending of binary data",
    755   1.1       cgd 	    togxbinary,
    756   1.1       cgd 		0,
    757   1.1       cgd 		    0 },
    758  1.15  christos     { "crlf",
    759   1.1       cgd 	"sending carriage returns as telnet <CR><LF>",
    760   1.1       cgd 	   togcrlf,
    761   1.1       cgd 		&crlf,
    762   1.1       cgd 		    0 },
    763   1.1       cgd     { "crmod",
    764   1.1       cgd 	"mapping of received carriage returns",
    765   1.1       cgd 	    0,
    766   1.1       cgd 		&crmod,
    767   1.1       cgd 		    "map carriage return on output" },
    768   1.1       cgd     { "localchars",
    769   1.1       cgd 	"local recognition of certain control characters",
    770   1.1       cgd 	    lclchars,
    771   1.1       cgd 		&localchars,
    772   1.1       cgd 		    "recognize certain control characters" },
    773   1.1       cgd     { " ", "", 0 },		/* empty line */
    774   1.1       cgd #if	defined(unix) && defined(TN3270)
    775   1.1       cgd     { "apitrace",
    776   1.1       cgd 	"(debugging) toggle tracing of API transactions",
    777   1.1       cgd 	    0,
    778   1.1       cgd 		&apitrace,
    779   1.1       cgd 		    "trace API transactions" },
    780   1.1       cgd     { "cursesdata",
    781   1.1       cgd 	"(debugging) toggle printing of hexadecimal curses data",
    782   1.1       cgd 	    0,
    783   1.1       cgd 		&cursesdata,
    784   1.1       cgd 		    "print hexadecimal representation of curses data" },
    785   1.1       cgd #endif	/* defined(unix) && defined(TN3270) */
    786   1.1       cgd     { "debug",
    787   1.1       cgd 	"debugging",
    788   1.1       cgd 	    togdebug,
    789   1.1       cgd 		&debug,
    790   1.1       cgd 		    "turn on socket level debugging" },
    791   1.1       cgd     { "netdata",
    792   1.1       cgd 	"printing of hexadecimal network data (debugging)",
    793   1.1       cgd 	    0,
    794   1.1       cgd 		&netdata,
    795   1.1       cgd 		    "print hexadecimal representation of network traffic" },
    796   1.1       cgd     { "prettydump",
    797   1.1       cgd 	"output of \"netdata\" to user readable format (debugging)",
    798   1.1       cgd 	    0,
    799   1.1       cgd 		&prettydump,
    800   1.1       cgd 		    "print user readable output for \"netdata\"" },
    801   1.1       cgd     { "options",
    802   1.1       cgd 	"viewing of options processing (debugging)",
    803   1.1       cgd 	    0,
    804   1.1       cgd 		&showoptions,
    805   1.1       cgd 		    "show option processing" },
    806   1.1       cgd #if	defined(unix)
    807   1.1       cgd     { "termdata",
    808   1.1       cgd 	"(debugging) toggle printing of hexadecimal terminal data",
    809   1.1       cgd 	    0,
    810   1.1       cgd 		&termdata,
    811   1.1       cgd 		    "print hexadecimal representation of terminal traffic" },
    812   1.1       cgd #endif	/* defined(unix) */
    813   1.1       cgd     { "?",
    814   1.1       cgd 	0,
    815   1.1       cgd 	    togglehelp },
    816   1.1       cgd     { "help",
    817   1.1       cgd 	0,
    818   1.1       cgd 	    togglehelp },
    819   1.1       cgd     { 0 }
    820   1.1       cgd };
    821  1.15  christos 
    822  1.15  christos     static int
    823   1.1       cgd togglehelp(n)
    824   1.1       cgd     int n;
    825   1.1       cgd {
    826   1.1       cgd     struct togglelist *c;
    827   1.1       cgd 
    828   1.1       cgd     for (c = Togglelist; c->name; c++) {
    829   1.1       cgd 	if (c->help) {
    830   1.1       cgd 	    if (*c->help)
    831   1.1       cgd 		printf("%-15s toggle %s\n", c->name, c->help);
    832   1.1       cgd 	    else
    833   1.1       cgd 		printf("\n");
    834   1.1       cgd 	}
    835   1.1       cgd     }
    836   1.1       cgd     printf("\n");
    837   1.1       cgd     printf("%-15s %s\n", "?", "display help information");
    838   1.1       cgd     return 0;
    839   1.1       cgd }
    840   1.1       cgd 
    841   1.1       cgd     static void
    842   1.1       cgd settogglehelp(set)
    843   1.1       cgd     int set;
    844   1.1       cgd {
    845   1.1       cgd     struct togglelist *c;
    846   1.1       cgd 
    847   1.1       cgd     for (c = Togglelist; c->name; c++) {
    848   1.1       cgd 	if (c->help) {
    849   1.1       cgd 	    if (*c->help)
    850   1.1       cgd 		printf("%-15s %s %s\n", c->name, set ? "enable" : "disable",
    851   1.1       cgd 						c->help);
    852   1.1       cgd 	    else
    853   1.1       cgd 		printf("\n");
    854   1.1       cgd 	}
    855   1.1       cgd     }
    856   1.1       cgd }
    857   1.1       cgd 
    858   1.1       cgd #define	GETTOGGLE(name) (struct togglelist *) \
    859   1.1       cgd 		genget(name, (char **) Togglelist, sizeof(struct togglelist))
    860   1.1       cgd 
    861   1.1       cgd     static int
    862   1.1       cgd toggle(argc, argv)
    863   1.1       cgd     int  argc;
    864   1.1       cgd     char *argv[];
    865   1.1       cgd {
    866   1.1       cgd     int retval = 1;
    867   1.1       cgd     char *name;
    868   1.1       cgd     struct togglelist *c;
    869   1.1       cgd 
    870   1.1       cgd     if (argc < 2) {
    871   1.1       cgd 	fprintf(stderr,
    872   1.1       cgd 	    "Need an argument to 'toggle' command.  'toggle ?' for help.\n");
    873   1.1       cgd 	return 0;
    874   1.1       cgd     }
    875   1.1       cgd     argc--;
    876   1.1       cgd     argv++;
    877   1.1       cgd     while (argc--) {
    878   1.1       cgd 	name = *argv++;
    879   1.1       cgd 	c = GETTOGGLE(name);
    880   1.1       cgd 	if (Ambiguous(c)) {
    881   1.1       cgd 	    fprintf(stderr, "'%s': ambiguous argument ('toggle ?' for help).\n",
    882   1.1       cgd 					name);
    883   1.1       cgd 	    return 0;
    884   1.1       cgd 	} else if (c == 0) {
    885   1.1       cgd 	    fprintf(stderr, "'%s': unknown argument ('toggle ?' for help).\n",
    886   1.1       cgd 					name);
    887   1.1       cgd 	    return 0;
    888   1.1       cgd 	} else {
    889   1.1       cgd 	    if (c->variable) {
    890   1.1       cgd 		*c->variable = !*c->variable;		/* invert it */
    891   1.1       cgd 		if (c->actionexplanation) {
    892   1.1       cgd 		    printf("%s %s.\n", *c->variable? "Will" : "Won't",
    893   1.1       cgd 							c->actionexplanation);
    894   1.1       cgd 		}
    895   1.1       cgd 	    }
    896   1.1       cgd 	    if (c->handler) {
    897   1.1       cgd 		retval &= (*c->handler)(-1);
    898   1.1       cgd 	    }
    899   1.1       cgd 	}
    900   1.1       cgd     }
    901   1.1       cgd     return retval;
    902   1.1       cgd }
    903   1.1       cgd 
    904   1.1       cgd /*
    906   1.1       cgd  * The following perform the "set" command.
    907   1.1       cgd  */
    908   1.1       cgd 
    909   1.1       cgd #ifdef	USE_TERMIO
    910   1.1       cgd struct termio new_tc = { 0 };
    911   1.1       cgd #endif
    912   1.1       cgd 
    913  1.15  christos struct setlist {
    914   1.1       cgd     char *name;				/* name */
    915   1.1       cgd     char *help;				/* help information */
    916   1.1       cgd     void (*handler) P((char *));
    917   1.1       cgd     cc_t *charp;			/* where it is located at */
    918   1.1       cgd };
    919   1.1       cgd 
    920   1.1       cgd static struct setlist Setlist[] = {
    921   1.1       cgd #ifdef	KLUDGELINEMODE
    922   1.1       cgd     { "echo", 	"character to toggle local echoing on/off", 0, &echoc },
    923   1.1       cgd #endif
    924   1.1       cgd     { "escape",	"character to escape back to telnet command mode", 0, &escape },
    925   1.1       cgd     { "rlogin", "rlogin escape character", 0, &rlogin },
    926   1.1       cgd     { "tracefile", "file to write trace information to", SetNetTrace, (cc_t *)NetTraceFile},
    927   1.1       cgd     { " ", "" },
    928   1.1       cgd     { " ", "The following need 'localchars' to be toggled true", 0, 0 },
    929   1.1       cgd     { "flushoutput", "character to cause an Abort Output", 0, termFlushCharp },
    930   1.1       cgd     { "interrupt", "character to cause an Interrupt Process", 0, termIntCharp },
    931   1.1       cgd     { "quit",	"character to cause an Abort process", 0, termQuitCharp },
    932   1.1       cgd     { "eof",	"character to cause an EOF ", 0, termEofCharp },
    933   1.1       cgd     { " ", "" },
    934   1.1       cgd     { " ", "The following are for local editing in linemode", 0, 0 },
    935   1.1       cgd     { "erase",	"character to use to erase a character", 0, termEraseCharp },
    936   1.1       cgd     { "kill",	"character to use to erase a line", 0, termKillCharp },
    937   1.1       cgd     { "lnext",	"character to use for literal next", 0, termLiteralNextCharp },
    938   1.1       cgd     { "susp",	"character to cause a Suspend Process", 0, termSuspCharp },
    939   1.1       cgd     { "reprint", "character to use for line reprint", 0, termRprntCharp },
    940   1.1       cgd     { "worderase", "character to use to erase a word", 0, termWerasCharp },
    941   1.1       cgd     { "start",	"character to use for XON", 0, termStartCharp },
    942   1.1       cgd     { "stop",	"character to use for XOFF", 0, termStopCharp },
    943   1.1       cgd     { "forw1",	"alternate end of line character", 0, termForw1Charp },
    944   1.1       cgd     { "forw2",	"alternate end of line character", 0, termForw2Charp },
    945   1.1       cgd     { "ayt",	"alternate AYT character", 0, termAytCharp },
    946   1.1       cgd     { 0 }
    947   1.1       cgd };
    948   1.1       cgd 
    949   1.1       cgd #if	defined(CRAY) && !defined(__STDC__)
    950   1.1       cgd /* Work around compiler bug in pcc 4.1.5 */
    951   1.1       cgd     void
    952   1.1       cgd _setlist_init()
    953   1.1       cgd {
    954   1.1       cgd #ifndef	KLUDGELINEMODE
    955   1.1       cgd #define	N 5
    956   1.1       cgd #else
    957   1.1       cgd #define	N 6
    958   1.1       cgd #endif
    959   1.1       cgd 	Setlist[N+0].charp = &termFlushChar;
    960   1.1       cgd 	Setlist[N+1].charp = &termIntChar;
    961   1.1       cgd 	Setlist[N+2].charp = &termQuitChar;
    962   1.1       cgd 	Setlist[N+3].charp = &termEofChar;
    963   1.1       cgd 	Setlist[N+6].charp = &termEraseChar;
    964   1.1       cgd 	Setlist[N+7].charp = &termKillChar;
    965   1.1       cgd 	Setlist[N+8].charp = &termLiteralNextChar;
    966   1.1       cgd 	Setlist[N+9].charp = &termSuspChar;
    967   1.1       cgd 	Setlist[N+10].charp = &termRprntChar;
    968   1.1       cgd 	Setlist[N+11].charp = &termWerasChar;
    969   1.1       cgd 	Setlist[N+12].charp = &termStartChar;
    970   1.1       cgd 	Setlist[N+13].charp = &termStopChar;
    971   1.1       cgd 	Setlist[N+14].charp = &termForw1Char;
    972   1.1       cgd 	Setlist[N+15].charp = &termForw2Char;
    973   1.1       cgd 	Setlist[N+16].charp = &termAytChar;
    974   1.1       cgd #undef	N
    975   1.1       cgd }
    976   1.1       cgd #endif	/* defined(CRAY) && !defined(__STDC__) */
    977   1.1       cgd 
    978   1.1       cgd     static struct setlist *
    979   1.1       cgd getset(name)
    980   1.1       cgd     char *name;
    981   1.1       cgd {
    982   1.1       cgd     return (struct setlist *)
    983   1.1       cgd 		genget(name, (char **) Setlist, sizeof(struct setlist));
    984   1.1       cgd }
    985   1.1       cgd 
    986   1.1       cgd     void
    987   1.1       cgd set_escape_char(s)
    988   1.1       cgd     char *s;
    989   1.1       cgd {
    990   1.1       cgd 	if (rlogin != _POSIX_VDISABLE) {
    991   1.1       cgd 		rlogin = (s && *s) ? special(s) : _POSIX_VDISABLE;
    992   1.1       cgd 		printf("Telnet rlogin escape character is '%s'.\n",
    993   1.1       cgd 					control(rlogin));
    994   1.1       cgd 	} else {
    995   1.1       cgd 		escape = (s && *s) ? special(s) : _POSIX_VDISABLE;
    996   1.1       cgd 		printf("Telnet escape character is '%s'.\n", control(escape));
    997   1.1       cgd 	}
    998   1.1       cgd }
    999   1.1       cgd 
   1000   1.1       cgd     static int
   1001   1.1       cgd setcmd(argc, argv)
   1002   1.1       cgd     int  argc;
   1003   1.1       cgd     char *argv[];
   1004   1.1       cgd {
   1005   1.1       cgd     int value;
   1006   1.1       cgd     struct setlist *ct;
   1007   1.1       cgd     struct togglelist *c;
   1008   1.1       cgd 
   1009   1.1       cgd     if (argc < 2 || argc > 3) {
   1010   1.1       cgd 	printf("Format is 'set Name Value'\n'set ?' for help.\n");
   1011   1.1       cgd 	return 0;
   1012   1.1       cgd     }
   1013   1.1       cgd     if ((argc == 2) && (isprefix(argv[1], "?") || isprefix(argv[1], "help"))) {
   1014   1.1       cgd 	for (ct = Setlist; ct->name; ct++)
   1015   1.1       cgd 	    printf("%-15s %s\n", ct->name, ct->help);
   1016   1.1       cgd 	printf("\n");
   1017   1.1       cgd 	settogglehelp(1);
   1018   1.1       cgd 	printf("%-15s %s\n", "?", "display help information");
   1019   1.1       cgd 	return 0;
   1020   1.1       cgd     }
   1021   1.1       cgd 
   1022   1.1       cgd     ct = getset(argv[1]);
   1023   1.1       cgd     if (ct == 0) {
   1024   1.1       cgd 	c = GETTOGGLE(argv[1]);
   1025   1.1       cgd 	if (c == 0) {
   1026   1.1       cgd 	    fprintf(stderr, "'%s': unknown argument ('set ?' for help).\n",
   1027   1.1       cgd 			argv[1]);
   1028   1.1       cgd 	    return 0;
   1029   1.1       cgd 	} else if (Ambiguous(c)) {
   1030   1.1       cgd 	    fprintf(stderr, "'%s': ambiguous argument ('set ?' for help).\n",
   1031   1.1       cgd 			argv[1]);
   1032   1.1       cgd 	    return 0;
   1033   1.1       cgd 	}
   1034   1.1       cgd 	if (c->variable) {
   1035   1.1       cgd 	    if ((argc == 2) || (strcmp("on", argv[2]) == 0))
   1036   1.1       cgd 		*c->variable = 1;
   1037   1.1       cgd 	    else if (strcmp("off", argv[2]) == 0)
   1038   1.1       cgd 		*c->variable = 0;
   1039   1.1       cgd 	    else {
   1040   1.1       cgd 		printf("Format is 'set togglename [on|off]'\n'set ?' for help.\n");
   1041   1.1       cgd 		return 0;
   1042   1.1       cgd 	    }
   1043   1.1       cgd 	    if (c->actionexplanation) {
   1044   1.1       cgd 		printf("%s %s.\n", *c->variable? "Will" : "Won't",
   1045   1.1       cgd 							c->actionexplanation);
   1046   1.1       cgd 	    }
   1047   1.1       cgd 	}
   1048   1.1       cgd 	if (c->handler)
   1049   1.1       cgd 	    (*c->handler)(1);
   1050   1.1       cgd     } else if (argc != 3) {
   1051   1.1       cgd 	printf("Format is 'set Name Value'\n'set ?' for help.\n");
   1052   1.1       cgd 	return 0;
   1053   1.1       cgd     } else if (Ambiguous(ct)) {
   1054   1.1       cgd 	fprintf(stderr, "'%s': ambiguous argument ('set ?' for help).\n",
   1055   1.1       cgd 			argv[1]);
   1056   1.1       cgd 	return 0;
   1057   1.1       cgd     } else if (ct->handler) {
   1058   1.1       cgd 	(*ct->handler)(argv[2]);
   1059   1.1       cgd 	printf("%s set to \"%s\".\n", ct->name, (char *)ct->charp);
   1060   1.1       cgd     } else {
   1061   1.1       cgd 	if (strcmp("off", argv[2])) {
   1062   1.1       cgd 	    value = special(argv[2]);
   1063   1.1       cgd 	} else {
   1064   1.1       cgd 	    value = _POSIX_VDISABLE;
   1065   1.1       cgd 	}
   1066   1.1       cgd 	*(ct->charp) = (cc_t)value;
   1067   1.1       cgd 	printf("%s character is '%s'.\n", ct->name, control(*(ct->charp)));
   1068   1.1       cgd     }
   1069   1.1       cgd     slc_check();
   1070   1.1       cgd     return 1;
   1071   1.1       cgd }
   1072   1.1       cgd 
   1073   1.1       cgd     static int
   1074   1.1       cgd unsetcmd(argc, argv)
   1075   1.1       cgd     int  argc;
   1076   1.1       cgd     char *argv[];
   1077   1.1       cgd {
   1078   1.1       cgd     struct setlist *ct;
   1079   1.1       cgd     struct togglelist *c;
   1080   1.1       cgd     register char *name;
   1081   1.1       cgd 
   1082   1.1       cgd     if (argc < 2) {
   1083   1.1       cgd 	fprintf(stderr,
   1084   1.1       cgd 	    "Need an argument to 'unset' command.  'unset ?' for help.\n");
   1085   1.1       cgd 	return 0;
   1086   1.1       cgd     }
   1087   1.1       cgd     if (isprefix(argv[1], "?") || isprefix(argv[1], "help")) {
   1088   1.1       cgd 	for (ct = Setlist; ct->name; ct++)
   1089   1.1       cgd 	    printf("%-15s %s\n", ct->name, ct->help);
   1090   1.1       cgd 	printf("\n");
   1091   1.1       cgd 	settogglehelp(0);
   1092   1.1       cgd 	printf("%-15s %s\n", "?", "display help information");
   1093   1.1       cgd 	return 0;
   1094   1.1       cgd     }
   1095   1.1       cgd 
   1096   1.1       cgd     argc--;
   1097   1.1       cgd     argv++;
   1098   1.1       cgd     while (argc--) {
   1099   1.1       cgd 	name = *argv++;
   1100   1.1       cgd 	ct = getset(name);
   1101   1.1       cgd 	if (ct == 0) {
   1102   1.1       cgd 	    c = GETTOGGLE(name);
   1103   1.1       cgd 	    if (c == 0) {
   1104   1.1       cgd 		fprintf(stderr, "'%s': unknown argument ('unset ?' for help).\n",
   1105   1.1       cgd 			name);
   1106   1.1       cgd 		return 0;
   1107   1.1       cgd 	    } else if (Ambiguous(c)) {
   1108   1.1       cgd 		fprintf(stderr, "'%s': ambiguous argument ('unset ?' for help).\n",
   1109   1.1       cgd 			name);
   1110   1.1       cgd 		return 0;
   1111   1.1       cgd 	    }
   1112   1.1       cgd 	    if (c->variable) {
   1113   1.1       cgd 		*c->variable = 0;
   1114   1.1       cgd 		if (c->actionexplanation) {
   1115   1.1       cgd 		    printf("%s %s.\n", *c->variable? "Will" : "Won't",
   1116   1.1       cgd 							c->actionexplanation);
   1117   1.1       cgd 		}
   1118   1.1       cgd 	    }
   1119   1.1       cgd 	    if (c->handler)
   1120   1.1       cgd 		(*c->handler)(0);
   1121   1.1       cgd 	} else if (Ambiguous(ct)) {
   1122   1.1       cgd 	    fprintf(stderr, "'%s': ambiguous argument ('unset ?' for help).\n",
   1123   1.1       cgd 			name);
   1124   1.1       cgd 	    return 0;
   1125   1.1       cgd 	} else if (ct->handler) {
   1126   1.1       cgd 	    (*ct->handler)(0);
   1127   1.1       cgd 	    printf("%s reset to \"%s\".\n", ct->name, (char *)ct->charp);
   1128   1.1       cgd 	} else {
   1129   1.1       cgd 	    *(ct->charp) = _POSIX_VDISABLE;
   1130   1.1       cgd 	    printf("%s character is '%s'.\n", ct->name, control(*(ct->charp)));
   1131   1.1       cgd 	}
   1132   1.1       cgd     }
   1133   1.1       cgd     return 1;
   1134   1.1       cgd }
   1135   1.1       cgd 
   1136   1.1       cgd /*
   1138   1.1       cgd  * The following are the data structures and routines for the
   1139   1.1       cgd  * 'mode' command.
   1140   1.1       cgd  */
   1141  1.15  christos #ifdef	KLUDGELINEMODE
   1142  1.15  christos extern int kludgelinemode;
   1143   1.1       cgd 
   1144   1.1       cgd     static int
   1145   1.1       cgd dokludgemode(n)
   1146   1.1       cgd     int n;
   1147   1.1       cgd {
   1148  1.15  christos     kludgelinemode = 1;
   1149   1.1       cgd     send_wont(TELOPT_LINEMODE, 1);
   1150   1.1       cgd     send_dont(TELOPT_SGA, 1);
   1151   1.1       cgd     send_dont(TELOPT_ECHO, 1);
   1152   1.1       cgd     return 1;
   1153  1.15  christos }
   1154  1.15  christos #endif
   1155   1.1       cgd 
   1156   1.1       cgd     static int
   1157   1.1       cgd dolinemode(n)
   1158   1.1       cgd     int n;
   1159   1.1       cgd {
   1160   1.1       cgd #ifdef	KLUDGELINEMODE
   1161   1.1       cgd     if (kludgelinemode)
   1162   1.1       cgd 	send_dont(TELOPT_SGA, 1);
   1163   1.1       cgd #endif
   1164   1.1       cgd     send_will(TELOPT_LINEMODE, 1);
   1165   1.1       cgd     send_dont(TELOPT_ECHO, 1);
   1166  1.15  christos     return 1;
   1167  1.15  christos }
   1168   1.1       cgd 
   1169   1.1       cgd     static int
   1170   1.1       cgd docharmode(n)
   1171   1.1       cgd     int n;
   1172   1.1       cgd {
   1173   1.1       cgd #ifdef	KLUDGELINEMODE
   1174   1.1       cgd     if (kludgelinemode)
   1175   1.1       cgd 	send_do(TELOPT_SGA, 1);
   1176   1.1       cgd     else
   1177   1.1       cgd #endif
   1178   1.1       cgd     send_wont(TELOPT_LINEMODE, 1);
   1179   1.1       cgd     send_do(TELOPT_ECHO, 1);
   1180   1.1       cgd     return 1;
   1181   1.1       cgd }
   1182   1.1       cgd 
   1183   1.1       cgd     static int
   1184   1.1       cgd dolmmode(bit, on)
   1185   1.1       cgd     int bit, on;
   1186   1.1       cgd {
   1187   1.1       cgd     unsigned char c;
   1188   1.1       cgd     extern int linemode;
   1189   1.1       cgd 
   1190   1.1       cgd     if (my_want_state_is_wont(TELOPT_LINEMODE)) {
   1191   1.1       cgd 	printf("?Need to have LINEMODE option enabled first.\n");
   1192   1.1       cgd 	printf("'mode ?' for help.\n");
   1193   1.1       cgd 	return 0;
   1194   1.1       cgd     }
   1195   1.1       cgd 
   1196   1.1       cgd     if (on)
   1197   1.1       cgd 	c = (linemode | bit);
   1198   1.1       cgd     else
   1199   1.1       cgd 	c = (linemode & ~bit);
   1200   1.1       cgd     lm_mode(&c, 1, 1);
   1201  1.15  christos     return 1;
   1202  1.15  christos }
   1203   1.1       cgd 
   1204   1.1       cgd     int
   1205   1.1       cgd set_mode(bit)
   1206   1.1       cgd     int bit;
   1207   1.1       cgd {
   1208  1.15  christos     return dolmmode(bit, 1);
   1209  1.15  christos }
   1210   1.1       cgd 
   1211   1.1       cgd     int
   1212   1.1       cgd clear_mode(bit)
   1213   1.1       cgd     int bit;
   1214   1.1       cgd {
   1215   1.1       cgd     return dolmmode(bit, 0);
   1216   1.1       cgd }
   1217  1.15  christos 
   1218  1.15  christos struct modelist {
   1219   1.1       cgd 	char	*name;		/* command name */
   1220   1.1       cgd 	char	*help;		/* help string */
   1221   1.1       cgd 	int	(*handler)	/* routine which executes command */
   1222   1.1       cgd 			P((int));
   1223   1.1       cgd 	int	needconnect;	/* Do we need to be connected to execute? */
   1224   1.1       cgd 	int	arg1;
   1225   1.1       cgd };
   1226   1.1       cgd 
   1227   1.1       cgd static struct modelist ModeList[] = {
   1228   1.1       cgd     { "character", "Disable LINEMODE option",	docharmode, 1 },
   1229   1.1       cgd #ifdef	KLUDGELINEMODE
   1230   1.1       cgd     { "",	"(or disable obsolete line-by-line mode)", 0 },
   1231   1.1       cgd #endif
   1232   1.1       cgd     { "line",	"Enable LINEMODE option",	dolinemode, 1 },
   1233   1.1       cgd #ifdef	KLUDGELINEMODE
   1234  1.15  christos     { "",	"(or enable obsolete line-by-line mode)", 0 },
   1235  1.15  christos #endif
   1236  1.15  christos     { "", "", 0 },
   1237  1.15  christos     { "",	"These require the LINEMODE option to be enabled", 0 },
   1238  1.15  christos     { "isig",	"Enable signal trapping",	set_mode, 1, MODE_TRAPSIG },
   1239  1.15  christos     { "+isig",	0,				set_mode, 1, MODE_TRAPSIG },
   1240  1.15  christos     { "-isig",	"Disable signal trapping",	clear_mode, 1, MODE_TRAPSIG },
   1241  1.15  christos     { "edit",	"Enable character editing",	set_mode, 1, MODE_EDIT },
   1242  1.15  christos     { "+edit",	0,				set_mode, 1, MODE_EDIT },
   1243  1.15  christos     { "-edit",	"Disable character editing",	clear_mode, 1, MODE_EDIT },
   1244  1.15  christos     { "softtabs", "Enable tab expansion",	set_mode, 1, MODE_SOFT_TAB },
   1245  1.15  christos     { "+softtabs", 0,				set_mode, 1, MODE_SOFT_TAB },
   1246   1.1       cgd     { "-softtabs", "Disable character editing",	clear_mode, 1, MODE_SOFT_TAB },
   1247   1.1       cgd     { "litecho", "Enable literal character echo", set_mode, 1, MODE_LIT_ECHO },
   1248   1.1       cgd     { "+litecho", 0,				set_mode, 1, MODE_LIT_ECHO },
   1249   1.1       cgd     { "-litecho", "Disable literal character echo", clear_mode, 1, MODE_LIT_ECHO },
   1250   1.1       cgd     { "help",	0,				modehelp, 0 },
   1251   1.1       cgd #ifdef	KLUDGELINEMODE
   1252   1.1       cgd     { "kludgeline", 0,				dokludgemode, 1 },
   1253   1.1       cgd #endif
   1254   1.1       cgd     { "", "", 0 },
   1255   1.1       cgd     { "?",	"Print help information",	modehelp, 0 },
   1256   1.1       cgd     { 0 },
   1257  1.15  christos };
   1258  1.15  christos 
   1259   1.1       cgd 
   1260   1.1       cgd     int
   1261   1.1       cgd modehelp(n)
   1262   1.1       cgd     int n;
   1263   1.1       cgd {
   1264   1.1       cgd     struct modelist *mt;
   1265   1.1       cgd 
   1266   1.1       cgd     printf("format is:  'mode Mode', where 'Mode' is one of:\n\n");
   1267   1.1       cgd     for (mt = ModeList; mt->name; mt++) {
   1268   1.1       cgd 	if (mt->help) {
   1269   1.1       cgd 	    if (*mt->help)
   1270   1.1       cgd 		printf("%-15s %s\n", mt->name, mt->help);
   1271   1.1       cgd 	    else
   1272   1.1       cgd 		printf("\n");
   1273   1.1       cgd 	}
   1274   1.1       cgd     }
   1275   1.1       cgd     return 0;
   1276   1.1       cgd }
   1277   1.1       cgd 
   1278   1.1       cgd #define	GETMODECMD(name) (struct modelist *) \
   1279   1.1       cgd 		genget(name, (char **) ModeList, sizeof(struct modelist))
   1280   1.1       cgd 
   1281   1.1       cgd     static int
   1282   1.1       cgd modecmd(argc, argv)
   1283   1.1       cgd     int  argc;
   1284   1.1       cgd     char *argv[];
   1285   1.1       cgd {
   1286   1.1       cgd     struct modelist *mt;
   1287   1.1       cgd 
   1288   1.1       cgd     if (argc != 2) {
   1289   1.1       cgd 	printf("'mode' command requires an argument\n");
   1290   1.1       cgd 	printf("'mode ?' for help.\n");
   1291   1.1       cgd     } else if ((mt = GETMODECMD(argv[1])) == 0) {
   1292   1.1       cgd 	fprintf(stderr, "Unknown mode '%s' ('mode ?' for help).\n", argv[1]);
   1293   1.1       cgd     } else if (Ambiguous(mt)) {
   1294   1.1       cgd 	fprintf(stderr, "Ambiguous mode '%s' ('mode ?' for help).\n", argv[1]);
   1295   1.1       cgd     } else if (mt->needconnect && !connected) {
   1296   1.1       cgd 	printf("?Need to be connected first.\n");
   1297   1.1       cgd 	printf("'mode ?' for help.\n");
   1298   1.1       cgd     } else if (mt->handler) {
   1299   1.1       cgd 	return (*mt->handler)(mt->arg1);
   1300   1.1       cgd     }
   1301   1.1       cgd     return 0;
   1302   1.1       cgd }
   1303   1.1       cgd 
   1304   1.1       cgd /*
   1306   1.1       cgd  * The following data structures and routines implement the
   1307   1.1       cgd  * "display" command.
   1308   1.1       cgd  */
   1309   1.1       cgd 
   1310   1.1       cgd     static int
   1311   1.1       cgd display(argc, argv)
   1312   1.1       cgd     int  argc;
   1313   1.1       cgd     char *argv[];
   1314   1.1       cgd {
   1315   1.1       cgd     struct togglelist *tl;
   1316   1.1       cgd     struct setlist *sl;
   1317   1.1       cgd 
   1318   1.1       cgd #define	dotog(tl)	if (tl->variable && tl->actionexplanation) { \
   1319   1.1       cgd 			    if (*tl->variable) { \
   1320   1.1       cgd 				printf("will"); \
   1321   1.1       cgd 			    } else { \
   1322   1.1       cgd 				printf("won't"); \
   1323   1.1       cgd 			    } \
   1324   1.1       cgd 			    printf(" %s.\n", tl->actionexplanation); \
   1325   1.1       cgd 			}
   1326   1.1       cgd 
   1327   1.1       cgd #define	doset(sl)   if (sl->name && *sl->name != ' ') { \
   1328   1.1       cgd 			if (sl->handler == 0) \
   1329   1.1       cgd 			    printf("%-15s [%s]\n", sl->name, control(*sl->charp)); \
   1330   1.1       cgd 			else \
   1331   1.1       cgd 			    printf("%-15s \"%s\"\n", sl->name, (char *)sl->charp); \
   1332   1.1       cgd 		    }
   1333   1.1       cgd 
   1334   1.1       cgd     if (argc == 1) {
   1335   1.1       cgd 	for (tl = Togglelist; tl->name; tl++) {
   1336   1.1       cgd 	    dotog(tl);
   1337   1.1       cgd 	}
   1338   1.1       cgd 	printf("\n");
   1339   1.1       cgd 	for (sl = Setlist; sl->name; sl++) {
   1340   1.1       cgd 	    doset(sl);
   1341   1.1       cgd 	}
   1342   1.1       cgd     } else {
   1343   1.1       cgd 	int i;
   1344   1.1       cgd 
   1345   1.1       cgd 	for (i = 1; i < argc; i++) {
   1346   1.1       cgd 	    sl = getset(argv[i]);
   1347   1.1       cgd 	    tl = GETTOGGLE(argv[i]);
   1348   1.1       cgd 	    if (Ambiguous(sl) || Ambiguous(tl)) {
   1349   1.1       cgd 		printf("?Ambiguous argument '%s'.\n", argv[i]);
   1350   1.1       cgd 		return 0;
   1351   1.1       cgd 	    } else if (!sl && !tl) {
   1352   1.1       cgd 		printf("?Unknown argument '%s'.\n", argv[i]);
   1353   1.1       cgd 		return 0;
   1354   1.1       cgd 	    } else {
   1355   1.1       cgd 		if (tl) {
   1356   1.1       cgd 		    dotog(tl);
   1357   1.1       cgd 		}
   1358   1.1       cgd 		if (sl) {
   1359   1.1       cgd 		    doset(sl);
   1360   1.1       cgd 		}
   1361   1.1       cgd 	    }
   1362   1.1       cgd 	}
   1363   1.1       cgd     }
   1364   1.1       cgd /*@*/optionstatus();
   1365   1.1       cgd     return 1;
   1366   1.1       cgd #undef	doset
   1367   1.1       cgd #undef	dotog
   1368   1.1       cgd }
   1369   1.1       cgd 
   1370   1.1       cgd /*
   1372   1.1       cgd  * The following are the data structures, and many of the routines,
   1373   1.1       cgd  * relating to command processing.
   1374   1.1       cgd  */
   1375   1.1       cgd 
   1376   1.1       cgd /*
   1377   1.1       cgd  * Set the escape character.
   1378   1.1       cgd  */
   1379   1.1       cgd 	static int
   1380   1.1       cgd setescape(argc, argv)
   1381   1.1       cgd 	int argc;
   1382   1.1       cgd 	char *argv[];
   1383   1.1       cgd {
   1384   1.1       cgd 	register char *arg;
   1385   1.1       cgd 	char buf[50];
   1386   1.1       cgd 
   1387   1.1       cgd 	printf(
   1388   1.1       cgd 	    "Deprecated usage - please use 'set escape%s%s' in the future.\n",
   1389   1.1       cgd 				(argc > 2)? " ":"", (argc > 2)? argv[1]: "");
   1390   1.1       cgd 	if (argc > 2)
   1391   1.1       cgd 		arg = argv[1];
   1392   1.1       cgd 	else {
   1393   1.1       cgd 		printf("new escape character: ");
   1394   1.1       cgd 		(void) fgets(buf, sizeof(buf), stdin);
   1395   1.1       cgd 		arg = buf;
   1396   1.1       cgd 	}
   1397   1.1       cgd 	if (arg[0] != '\0')
   1398   1.1       cgd 		escape = arg[0];
   1399   1.1       cgd 	if (!In3270) {
   1400   1.1       cgd 		printf("Escape character is '%s'.\n", control(escape));
   1401   1.1       cgd 	}
   1402  1.15  christos 	(void) fflush(stdout);
   1403  1.15  christos 	return 1;
   1404  1.15  christos }
   1405   1.1       cgd 
   1406   1.1       cgd     /*VARARGS*/
   1407   1.1       cgd     static int
   1408   1.1       cgd togcrmod(argc, argv)
   1409   1.1       cgd     int argc;
   1410   1.1       cgd     char *argv[];
   1411   1.1       cgd {
   1412   1.1       cgd     crmod = !crmod;
   1413   1.1       cgd     printf("Deprecated usage - please use 'toggle crmod' in the future.\n");
   1414   1.1       cgd     printf("%s map carriage return on output.\n", crmod ? "Will" : "Won't");
   1415  1.15  christos     (void) fflush(stdout);
   1416  1.15  christos     return 1;
   1417  1.15  christos }
   1418   1.1       cgd 
   1419   1.1       cgd     /*VARARGS*/
   1420   1.1       cgd     int
   1421   1.1       cgd suspend(argc, argv)
   1422   1.1       cgd     int argc;
   1423   1.1       cgd     char *argv[];
   1424   1.5       cgd {
   1425   1.1       cgd #ifdef	SIGTSTP
   1426   1.5       cgd     setcommandmode();
   1427   1.5       cgd     {
   1428  1.10       jtk 	long oldrows, oldcols, newrows, newcols, err;
   1429   1.5       cgd 
   1430   1.5       cgd 	err = (TerminalWindowSize(&oldrows, &oldcols) == 0) ? 1 : 0;
   1431   1.5       cgd 	(void) kill(0, SIGTSTP);
   1432   1.5       cgd 	/*
   1433   1.1       cgd 	 * If we didn't get the window size before the SUSPEND, but we
   1434   1.1       cgd 	 * can get them now (?), then send the NAWS to make sure that
   1435   1.1       cgd 	 * we are set up for the right window size.
   1436   1.1       cgd 	 */
   1437   1.1       cgd 	if (TerminalWindowSize(&newrows, &newcols) && connected &&
   1438   1.1       cgd 	    (err || ((oldrows != newrows) || (oldcols != newcols)))) {
   1439   1.1       cgd 		sendnaws();
   1440   1.1       cgd 	}
   1441   1.1       cgd     }
   1442   1.1       cgd     /* reget parameters in case they were changed */
   1443   1.1       cgd     TerminalSaveState();
   1444   1.1       cgd     setconnmode(0);
   1445   1.1       cgd #else
   1446   1.1       cgd     printf("Suspend is not supported.  Try the '!' command instead\n");
   1447   1.1       cgd #endif
   1448   1.1       cgd     return 1;
   1449   1.1       cgd }
   1450   1.1       cgd 
   1451   1.1       cgd #if	!defined(TN3270)
   1452   1.5       cgd     /*ARGSUSED*/
   1453  1.19   thorpej     int
   1454  1.19   thorpej shell(argc, argv)
   1455  1.19   thorpej     int argc;
   1456  1.19   thorpej     char *argv[];
   1457   1.5       cgd {
   1458   1.1       cgd     long oldrows, oldcols, newrows, newcols, err;
   1459   1.5       cgd 
   1460   1.5       cgd #ifdef __GNUC__
   1461   1.1       cgd     (void) &err;	/* XXX avoid GCC warning */
   1462   1.1       cgd #endif
   1463  1.32     soren 
   1464   1.1       cgd     setcommandmode();
   1465   1.1       cgd 
   1466   1.1       cgd     err = (TerminalWindowSize(&oldrows, &oldcols) == 0) ? 1 : 0;
   1467   1.1       cgd     switch(vfork()) {
   1468   1.1       cgd     case -1:
   1469   1.1       cgd 	perror("Fork failed");
   1470   1.1       cgd 	break;
   1471   1.1       cgd 
   1472   1.1       cgd     case 0:
   1473   1.1       cgd 	{
   1474   1.1       cgd 	    /*
   1475   1.1       cgd 	     * Fire up the shell in the child.
   1476  1.10       jtk 	     */
   1477   1.1       cgd 	    register char *shellp, *shellname;
   1478   1.1       cgd 
   1479   1.1       cgd 	    shellp = getenv("SHELL");
   1480   1.1       cgd 	    if (shellp == NULL)
   1481   1.1       cgd 		shellp = "/bin/sh";
   1482   1.1       cgd 	    if ((shellname = strrchr(shellp, '/')) == 0)
   1483   1.1       cgd 		shellname = shellp;
   1484  1.32     soren 	    else
   1485   1.1       cgd 		shellname++;
   1486   1.1       cgd 	    if (argc > 1)
   1487   1.1       cgd 		execl(shellp, shellname, "-c", &saveline[1], 0);
   1488   1.1       cgd 	    else
   1489   1.5       cgd 		execl(shellp, shellname, 0);
   1490   1.5       cgd 	    perror("execl");
   1491   1.5       cgd 	    _exit(1);
   1492   1.5       cgd 	}
   1493   1.5       cgd     default:
   1494   1.5       cgd 	    (void)wait((int *)0);	/* Wait for the shell to complete */
   1495   1.1       cgd 
   1496   1.1       cgd 	    if (TerminalWindowSize(&newrows, &newcols) && connected &&
   1497   1.1       cgd 		(err || ((oldrows != newrows) || (oldcols != newcols)))) {
   1498   1.1       cgd 		    sendnaws();
   1499   1.1       cgd 	    }
   1500   1.1       cgd 	    break;
   1501  1.15  christos     }
   1502   1.1       cgd     return 1;
   1503   1.1       cgd }
   1504   1.1       cgd #endif	/* !defined(TN3270) */
   1505   1.1       cgd 
   1506   1.1       cgd     /*VARARGS*/
   1507   1.1       cgd     static int
   1508   1.1       cgd bye(argc, argv)
   1509   1.1       cgd     int  argc;		/* Number of arguments */
   1510   1.1       cgd     char *argv[];	/* arguments */
   1511   1.1       cgd {
   1512   1.1       cgd     extern int resettermname;
   1513   1.1       cgd 
   1514   1.5       cgd     if (connected) {
   1515   1.1       cgd 	(void) shutdown(net, 2);
   1516   1.5       cgd 	printf("Connection closed.\n");
   1517   1.1       cgd 	(void) NetClose(net);
   1518   1.1       cgd 	connected = 0;
   1519   1.1       cgd 	resettermname = 1;
   1520   1.1       cgd #if	defined(AUTHENTICATION)
   1521   1.1       cgd 	auth_encrypt_connect(connected);
   1522   1.1       cgd #endif	/* defined(AUTHENTICATION) */
   1523   1.1       cgd 	/* reset options */
   1524   1.1       cgd 	tninit();
   1525   1.1       cgd #if	defined(TN3270)
   1526   1.1       cgd 	SetIn3270();		/* Get out of 3270 mode */
   1527   1.1       cgd #endif	/* defined(TN3270) */
   1528   1.1       cgd     }
   1529   1.1       cgd     if ((argc != 2) || (strcmp(argv[1], "fromquit") != 0)) {
   1530   1.1       cgd 	longjmp(toplevel, 1);
   1531  1.15  christos 	/* NOTREACHED */
   1532  1.15  christos     }
   1533  1.15  christos     return 1;			/* Keep lint, etc., happy */
   1534  1.15  christos }
   1535   1.1       cgd 
   1536   1.1       cgd /*VARARGS*/
   1537   1.1       cgd int
   1538   1.1       cgd quit(argc, argv)
   1539   1.1       cgd 	int argc;
   1540   1.1       cgd 	char *argv[];
   1541   1.1       cgd {
   1542   1.1       cgd 	(void) call(bye, "bye", "fromquit", 0);
   1543  1.15  christos 	Exit(0);
   1544  1.15  christos 	/*NOTREACHED*/
   1545  1.15  christos }
   1546   1.1       cgd 
   1547   1.1       cgd /*VARARGS*/
   1548   1.1       cgd 	int
   1549   1.1       cgd logout(argc, argv)
   1550   1.1       cgd 	int argc;
   1551   1.1       cgd 	char *argv[];
   1552   1.1       cgd {
   1553   1.1       cgd 	send_do(TELOPT_LOGOUT, 1);
   1554   1.1       cgd 	(void) netflush();
   1555   1.1       cgd 	return 1;
   1556   1.1       cgd }
   1557   1.1       cgd 
   1558   1.1       cgd 
   1559   1.1       cgd /*
   1561   1.1       cgd  * The SLC command.
   1562   1.1       cgd  */
   1563   1.1       cgd 
   1564   1.1       cgd struct slclist {
   1565   1.1       cgd 	char	*name;
   1566   1.1       cgd 	char	*help;
   1567   1.1       cgd 	void	(*handler) P((int));
   1568   1.1       cgd 	int	arg;
   1569   1.1       cgd };
   1570   1.1       cgd 
   1571   1.1       cgd struct slclist SlcList[] = {
   1572   1.1       cgd     { "export",	"Use local special character definitions",
   1573   1.1       cgd 						slc_mode_export,	0 },
   1574   1.1       cgd     { "import",	"Use remote special character definitions",
   1575   1.1       cgd 						slc_mode_import,	1 },
   1576   1.1       cgd     { "check",	"Verify remote special character definitions",
   1577  1.15  christos 						slc_mode_import,	0 },
   1578  1.15  christos     { "help",	0,				slc_help,		0 },
   1579   1.1       cgd     { "?",	"Print help information",	slc_help,		0 },
   1580   1.1       cgd     { 0 },
   1581   1.1       cgd };
   1582   1.1       cgd 
   1583   1.1       cgd     static void
   1584   1.1       cgd slc_help(n)
   1585   1.1       cgd     int n;
   1586   1.1       cgd {
   1587   1.1       cgd     struct slclist *c;
   1588   1.1       cgd 
   1589   1.1       cgd     for (c = SlcList; c->name; c++) {
   1590   1.1       cgd 	if (c->help) {
   1591   1.1       cgd 	    if (*c->help)
   1592   1.1       cgd 		printf("%-15s %s\n", c->name, c->help);
   1593   1.1       cgd 	    else
   1594   1.1       cgd 		printf("\n");
   1595   1.1       cgd 	}
   1596   1.1       cgd     }
   1597   1.1       cgd }
   1598   1.1       cgd 
   1599   1.1       cgd     static struct slclist *
   1600  1.15  christos getslc(name)
   1601   1.1       cgd     char *name;
   1602   1.1       cgd {
   1603   1.1       cgd     return (struct slclist *)
   1604   1.1       cgd 		genget(name, (char **) SlcList, sizeof(struct slclist));
   1605   1.1       cgd }
   1606   1.1       cgd 
   1607   1.1       cgd     static int
   1608   1.1       cgd slccmd(argc, argv)
   1609   1.1       cgd     int  argc;
   1610   1.1       cgd     char *argv[];
   1611   1.1       cgd {
   1612   1.1       cgd     struct slclist *c;
   1613   1.1       cgd 
   1614  1.10       jtk     if (argc != 2) {
   1615   1.1       cgd 	fprintf(stderr,
   1616  1.10       jtk 	    "Need an argument to 'slc' command.  'slc ?' for help.\n");
   1617   1.1       cgd 	return 0;
   1618   1.1       cgd     }
   1619  1.10       jtk     c = getslc(argv[1]);
   1620   1.1       cgd     if (c == 0) {
   1621  1.10       jtk 	fprintf(stderr, "'%s': unknown argument ('slc ?' for help).\n",
   1622   1.1       cgd     				argv[1]);
   1623   1.1       cgd 	return 0;
   1624   1.1       cgd     }
   1625   1.1       cgd     if (Ambiguous(c)) {
   1626   1.1       cgd 	fprintf(stderr, "'%s': ambiguous argument ('slc ?' for help).\n",
   1627   1.1       cgd     				argv[1]);
   1628   1.1       cgd 	return 0;
   1629   1.1       cgd     }
   1630   1.1       cgd     (*c->handler)(c->arg);
   1631   1.1       cgd     slcstate();
   1632   1.1       cgd     return 1;
   1633   1.1       cgd }
   1634   1.1       cgd 
   1635  1.15  christos /*
   1637   1.1       cgd  * The ENVIRON command.
   1638   1.1       cgd  */
   1639   1.1       cgd 
   1640   1.1       cgd struct envlist {
   1641  1.15  christos 	char	*name;
   1642   1.1       cgd 	char	*help;
   1643   1.1       cgd 	struct env_lst *(*handler) P((unsigned char *, unsigned char *));
   1644   1.1       cgd 	int	narg;
   1645   1.1       cgd };
   1646   1.1       cgd 
   1647   1.1       cgd struct envlist EnvList[] = {
   1648   1.1       cgd     { "define",	"Define an environment variable",
   1649   1.1       cgd 						env_define,	2 },
   1650   1.1       cgd     { "undefine", "Undefine an environment variable",
   1651   1.5       cgd 						env_undefine,	1 },
   1652   1.5       cgd     { "export",	"Mark an environment variable for automatic export",
   1653   1.5       cgd 						env_export,	1 },
   1654   1.5       cgd     { "unexport", "Don't mark an environment variable for automatic export",
   1655   1.1       cgd 						env_unexport,	1 },
   1656   1.1       cgd     { "send",	"Send an environment variable", env_send,	1 },
   1657   1.1       cgd     { "list",	"List the current environment variables",
   1658   1.1       cgd 						env_list,	0 },
   1659   1.1       cgd #if defined(OLD_ENVIRON) && defined(ENV_HACK)
   1660  1.15  christos     { "varval", "Reverse VAR and VALUE (auto, right, wrong, status)",
   1661  1.15  christos 						env_varval,    1 },
   1662  1.15  christos #endif
   1663   1.1       cgd     { "help",	0,				env_help,		0 },
   1664   1.1       cgd     { "?",	"Print help information",	env_help,		0 },
   1665   1.1       cgd     { 0 },
   1666   1.1       cgd };
   1667   1.1       cgd 
   1668   1.1       cgd     static struct env_lst *
   1669   1.1       cgd env_help(us1, us2)
   1670   1.1       cgd     unsigned char *us1, *us2;
   1671   1.1       cgd {
   1672   1.1       cgd     struct envlist *c;
   1673   1.1       cgd 
   1674  1.15  christos     for (c = EnvList; c->name; c++) {
   1675   1.1       cgd 	if (c->help) {
   1676   1.1       cgd 	    if (*c->help)
   1677   1.1       cgd 		printf("%-15s %s\n", c->name, c->help);
   1678   1.1       cgd 	    else
   1679   1.1       cgd 		printf("\n");
   1680   1.1       cgd 	}
   1681   1.1       cgd     }
   1682   1.1       cgd     return NULL;
   1683   1.1       cgd }
   1684   1.1       cgd 
   1685  1.15  christos     static struct envlist *
   1686   1.1       cgd getenvcmd(name)
   1687   1.1       cgd     char *name;
   1688   1.1       cgd {
   1689   1.1       cgd     return (struct envlist *)
   1690   1.1       cgd 		genget(name, (char **) EnvList, sizeof(struct envlist));
   1691   1.1       cgd }
   1692   1.1       cgd 
   1693   1.1       cgd     int
   1694   1.1       cgd env_cmd(argc, argv)
   1695   1.1       cgd     int  argc;
   1696   1.1       cgd     char *argv[];
   1697   1.1       cgd {
   1698   1.1       cgd     struct envlist *c;
   1699  1.10       jtk 
   1700   1.1       cgd     if (argc < 2) {
   1701  1.10       jtk 	fprintf(stderr,
   1702   1.1       cgd 	    "Need an argument to 'environ' command.  'environ ?' for help.\n");
   1703   1.1       cgd 	return 0;
   1704  1.10       jtk     }
   1705   1.1       cgd     c = getenvcmd(argv[1]);
   1706  1.10       jtk     if (c == 0) {
   1707   1.1       cgd 	fprintf(stderr, "'%s': unknown argument ('environ ?' for help).\n",
   1708   1.1       cgd     				argv[1]);
   1709   1.1       cgd 	return 0;
   1710   1.1       cgd     }
   1711   1.1       cgd     if (Ambiguous(c)) {
   1712   1.1       cgd 	fprintf(stderr, "'%s': ambiguous argument ('environ ?' for help).\n",
   1713   1.1       cgd     				argv[1]);
   1714   1.1       cgd 	return 0;
   1715   1.1       cgd     }
   1716   1.1       cgd     if (c->narg + 2 != argc) {
   1717   1.1       cgd 	fprintf(stderr,
   1718   1.1       cgd 	    "Need %s%d argument%s to 'environ %s' command.  'environ ?' for help.\n",
   1719   1.1       cgd 		c->narg < argc + 2 ? "only " : "",
   1720   1.1       cgd 		c->narg, c->narg == 1 ? "" : "s", c->name);
   1721   1.5       cgd 	return 0;
   1722   1.1       cgd     }
   1723   1.5       cgd     (*c->handler)(argv[2], argv[3]);
   1724   1.1       cgd     return 1;
   1725   1.5       cgd }
   1726   1.1       cgd 
   1727   1.1       cgd struct env_lst {
   1728   1.1       cgd 	struct env_lst *next;	/* pointer to next structure */
   1729   1.1       cgd 	struct env_lst *prev;	/* pointer to previous structure */
   1730   1.1       cgd 	unsigned char *var;	/* pointer to variable name */
   1731   1.1       cgd 	unsigned char *value;	/* pointer to variable value */
   1732   1.1       cgd 	int export;		/* 1 -> export with default list of variables */
   1733   1.1       cgd 	int welldefined;	/* A well defined variable */
   1734   1.1       cgd };
   1735   1.1       cgd 
   1736   1.1       cgd struct env_lst envlisthead;
   1737   1.1       cgd 
   1738   1.1       cgd 	struct env_lst *
   1739   1.1       cgd env_find(var)
   1740   1.1       cgd 	unsigned char *var;
   1741   1.1       cgd {
   1742   1.1       cgd 	register struct env_lst *ep;
   1743   1.1       cgd 
   1744   1.1       cgd 	for (ep = envlisthead.next; ep; ep = ep->next) {
   1745   1.1       cgd 		if (strcmp((char *)ep->var, (char *)var) == 0)
   1746   1.1       cgd 			return(ep);
   1747   1.1       cgd 	}
   1748   1.1       cgd 	return(NULL);
   1749   1.1       cgd }
   1750   1.1       cgd 
   1751  1.15  christos 	void
   1752   1.1       cgd env_init()
   1753   1.1       cgd {
   1754   1.1       cgd 	extern char **environ;
   1755   1.1       cgd 	register char **epp, *cp;
   1756   1.1       cgd 	register struct env_lst *ep;
   1757   1.1       cgd 
   1758   1.1       cgd 	for (epp = environ; *epp; epp++) {
   1759   1.1       cgd 		if ((cp = strchr(*epp, '=')) != NULL) {
   1760   1.1       cgd 			*cp = '\0';
   1761   1.1       cgd 			ep = env_define((unsigned char *)*epp,
   1762   1.1       cgd 					(unsigned char *)cp+1);
   1763   1.1       cgd 			ep->export = 0;
   1764   1.1       cgd 			*cp = '=';
   1765   1.1       cgd 		}
   1766  1.10       jtk 	}
   1767  1.21       mrg 	/*
   1768  1.10       jtk 	 * Special case for DISPLAY variable.  If it is ":0.0" or
   1769   1.1       cgd 	 * "unix:0.0", we have to get rid of "unix" and insert our
   1770  1.21       mrg 	 * hostname.
   1771  1.22      fvdl 	 */
   1772   1.1       cgd 	if ((ep = env_find("DISPLAY"))
   1773   1.1       cgd 	    && ((*ep->value == ':')
   1774   1.1       cgd 		|| (strncmp((char *)ep->value, "unix:", 5) == 0))) {
   1775   1.1       cgd 		char hbuf[MAXHOSTNAMELEN + 1];
   1776   1.1       cgd 		char *cp2 = strchr((char *)ep->value, ':');
   1777   1.1       cgd 
   1778   1.1       cgd 		gethostname(hbuf, sizeof hbuf);
   1779   1.1       cgd 		hbuf[sizeof(hbuf) - 1] = '\0';
   1780   1.1       cgd 		cp = (char *)malloc(strlen(hbuf) + strlen(cp2) + 1);
   1781   1.1       cgd 		sprintf((char *)cp, "%s%s", hbuf, cp2);
   1782   1.1       cgd 		free(ep->value);
   1783   1.1       cgd 		ep->value = (unsigned char *)cp;
   1784  1.15  christos 	}
   1785   1.1       cgd 	/*
   1786  1.15  christos 	 * If USER is not defined, but LOGNAME is, then add
   1787  1.15  christos 	 * USER with the value from LOGNAME.  By default, we
   1788   1.1       cgd 	 * don't export the USER variable.
   1789   1.1       cgd 	 */
   1790   1.1       cgd 	if ((env_find("USER") == NULL) && (ep = env_find("LOGNAME"))) {
   1791   1.1       cgd 		env_define((unsigned char *)"USER", ep->value);
   1792   1.1       cgd 		env_unexport((unsigned char *)"USER", NULL);
   1793   1.1       cgd 	}
   1794   1.1       cgd 	env_export((unsigned char *)"DISPLAY", NULL);
   1795   1.1       cgd 	env_export((unsigned char *)"PRINTER", NULL);
   1796  1.15  christos }
   1797   1.1       cgd 
   1798   1.1       cgd 	struct env_lst *
   1799   1.1       cgd env_define(var, value)
   1800   1.1       cgd 	unsigned char *var, *value;
   1801   1.1       cgd {
   1802   1.1       cgd 	register struct env_lst *ep;
   1803   1.1       cgd 
   1804   1.1       cgd 	if ((ep = env_find(var)) != NULL) {
   1805   1.1       cgd 		if (ep->var)
   1806   1.1       cgd 			free(ep->var);
   1807   1.1       cgd 		if (ep->value)
   1808   1.1       cgd 			free(ep->value);
   1809   1.5       cgd 	} else {
   1810   1.1       cgd 		ep = (struct env_lst *)malloc(sizeof(struct env_lst));
   1811   1.1       cgd 		ep->next = envlisthead.next;
   1812   1.1       cgd 		envlisthead.next = ep;
   1813   1.1       cgd 		ep->prev = &envlisthead;
   1814   1.1       cgd 		if (ep->next)
   1815   1.1       cgd 			ep->next->prev = ep;
   1816  1.15  christos 	}
   1817  1.15  christos 	ep->welldefined = opt_welldefined(var);
   1818   1.1       cgd 	ep->export = 1;
   1819  1.15  christos 	ep->var = (unsigned char *)strdup((char *)var);
   1820   1.1       cgd 	ep->value = (unsigned char *)strdup((char *)value);
   1821   1.1       cgd 	return(ep);
   1822   1.1       cgd }
   1823  1.15  christos 
   1824   1.1       cgd 	struct env_lst *
   1825   1.1       cgd env_undefine(var, d)
   1826   1.1       cgd 	unsigned char *var;
   1827   1.1       cgd 	unsigned char *d;
   1828   1.1       cgd {
   1829   1.1       cgd 	register struct env_lst *ep;
   1830   1.1       cgd 
   1831   1.1       cgd 	if ((ep = env_find(var)) != NULL) {
   1832   1.1       cgd 		ep->prev->next = ep->next;
   1833  1.15  christos 		if (ep->next)
   1834   1.1       cgd 			ep->next->prev = ep->prev;
   1835   1.1       cgd 		if (ep->var)
   1836  1.15  christos 			free(ep->var);
   1837  1.15  christos 		if (ep->value)
   1838   1.1       cgd 			free(ep->value);
   1839  1.15  christos 		free(ep);
   1840   1.1       cgd 	}
   1841   1.1       cgd 	return NULL;
   1842   1.1       cgd }
   1843  1.15  christos 
   1844   1.1       cgd 	struct env_lst *
   1845  1.15  christos env_export(var, d)
   1846   1.1       cgd 	unsigned char *var;
   1847   1.1       cgd 	unsigned char *d;
   1848  1.15  christos {
   1849  1.15  christos 	register struct env_lst *ep;
   1850   1.1       cgd 
   1851  1.15  christos 	if ((ep = env_find(var)) != NULL)
   1852   1.1       cgd 		ep->export = 1;
   1853   1.1       cgd 	return NULL;
   1854   1.1       cgd }
   1855  1.15  christos 
   1856   1.1       cgd 	struct env_lst *
   1857  1.15  christos env_unexport(var, d)
   1858   1.1       cgd 	unsigned char *var;
   1859   1.1       cgd 	unsigned char *d;
   1860  1.15  christos {
   1861  1.15  christos 	register struct env_lst *ep;
   1862   1.1       cgd 
   1863  1.15  christos 	if ((ep = env_find(var)) != NULL)
   1864   1.1       cgd 		ep->export = 0;
   1865   1.1       cgd 	return NULL;
   1866   1.1       cgd }
   1867  1.10       jtk 
   1868   1.5       cgd 	struct env_lst *
   1869   1.5       cgd env_send(var, d)
   1870   1.5       cgd 	unsigned char *var;
   1871   1.5       cgd 	unsigned char *d;
   1872   1.1       cgd {
   1873   1.1       cgd 	register struct env_lst *ep;
   1874   1.1       cgd 
   1875  1.15  christos 	if (my_state_is_wont(TELOPT_NEW_ENVIRON)
   1876   1.1       cgd #ifdef	OLD_ENVIRON
   1877   1.1       cgd 	    && my_state_is_wont(TELOPT_OLD_ENVIRON)
   1878   1.1       cgd #endif
   1879   1.1       cgd 		) {
   1880   1.1       cgd 		fprintf(stderr,
   1881  1.15  christos 		    "Cannot send '%s': Telnet ENVIRON option not enabled\n",
   1882   1.1       cgd 									var);
   1883   1.1       cgd 		return NULL;
   1884   1.1       cgd 	}
   1885   1.1       cgd 	ep = env_find(var);
   1886  1.15  christos 	if (ep == 0) {
   1887   1.1       cgd 		fprintf(stderr, "Cannot send '%s': variable not defined\n",
   1888   1.1       cgd 									var);
   1889  1.15  christos 		return NULL;
   1890  1.15  christos 	}
   1891  1.15  christos 	env_opt_start_info();
   1892   1.1       cgd 	env_opt_add(ep->var);
   1893   1.1       cgd 	env_opt_end(0);
   1894   1.1       cgd 	return NULL;
   1895   1.1       cgd }
   1896   1.1       cgd 
   1897   1.1       cgd 	struct env_lst *
   1898   1.1       cgd env_list(d1, d2)
   1899  1.15  christos 	unsigned char *d1, *d2;
   1900   1.1       cgd {
   1901   1.1       cgd 	register struct env_lst *ep;
   1902   1.1       cgd 
   1903   1.5       cgd 	for (ep = envlisthead.next; ep; ep = ep->next) {
   1904   1.1       cgd 		printf("%c %-20s %s\n", ep->export ? '*' : ' ',
   1905  1.23   msaitoh 					ep->var, ep->value);
   1906   1.1       cgd 	}
   1907   1.1       cgd 	return NULL;
   1908   1.1       cgd }
   1909   1.1       cgd 
   1910   1.1       cgd 	unsigned char *
   1911  1.15  christos env_default(init, welldefined)
   1912   1.1       cgd 	int init;
   1913   1.1       cgd 	int welldefined;
   1914  1.15  christos {
   1915   1.5       cgd 	static struct env_lst *nep = NULL;
   1916   1.1       cgd 
   1917   1.1       cgd 	if (init) {
   1918   1.1       cgd 		nep = &envlisthead;
   1919   1.1       cgd 		return NULL;
   1920   1.1       cgd 	}
   1921   1.1       cgd 	if (nep) {
   1922   1.1       cgd 		while ((nep = nep->next) != NULL) {
   1923   1.1       cgd 			if (nep->export && (nep->welldefined == welldefined))
   1924   1.1       cgd 				return(nep->var);
   1925   1.1       cgd 		}
   1926   1.1       cgd 	}
   1927   1.1       cgd 	return(NULL);
   1928  1.15  christos }
   1929   1.1       cgd 
   1930   1.1       cgd 	unsigned char *
   1931   1.1       cgd env_getvalue(var)
   1932   1.1       cgd 	unsigned char *var;
   1933   1.5       cgd {
   1934   1.5       cgd 	register struct env_lst *ep;
   1935   1.5       cgd 
   1936   1.5       cgd 	if ((ep = env_find(var)) != NULL)
   1937   1.5       cgd 		return(ep->value);
   1938   1.5       cgd 	return(NULL);
   1939   1.5       cgd }
   1940   1.5       cgd 
   1941   1.5       cgd #if defined(OLD_ENVIRON) && defined(ENV_HACK)
   1942   1.5       cgd 	void
   1943   1.5       cgd env_varval(what)
   1944   1.5       cgd 	unsigned char *what;
   1945   1.5       cgd {
   1946   1.5       cgd 	extern int old_env_var, old_env_value, env_auto;
   1947   1.5       cgd 	int len = strlen((char *)what);
   1948   1.5       cgd 
   1949   1.5       cgd 	if (len == 0)
   1950   1.5       cgd 		goto unknown;
   1951   1.5       cgd 
   1952   1.5       cgd 	if (strncasecmp((char *)what, "status", len) == 0) {
   1953   1.5       cgd 		if (env_auto)
   1954   1.5       cgd 			printf("%s%s", "VAR and VALUE are/will be ",
   1955   1.5       cgd 					"determined automatically\n");
   1956   1.5       cgd 		if (old_env_var == OLD_ENV_VAR)
   1957   1.5       cgd 			printf("VAR and VALUE set to correct definitions\n");
   1958   1.5       cgd 		else
   1959   1.5       cgd 			printf("VAR and VALUE definitions are reversed\n");
   1960   1.5       cgd 	} else if (strncasecmp((char *)what, "auto", len) == 0) {
   1961   1.5       cgd 		env_auto = 1;
   1962   1.5       cgd 		old_env_var = OLD_ENV_VALUE;
   1963   1.5       cgd 		old_env_value = OLD_ENV_VAR;
   1964   1.5       cgd 	} else if (strncasecmp((char *)what, "right", len) == 0) {
   1965   1.5       cgd 		env_auto = 0;
   1966   1.5       cgd 		old_env_var = OLD_ENV_VAR;
   1967   1.5       cgd 		old_env_value = OLD_ENV_VALUE;
   1968   1.5       cgd 	} else if (strncasecmp((char *)what, "wrong", len) == 0) {
   1969   1.5       cgd 		env_auto = 0;
   1970   1.5       cgd 		old_env_var = OLD_ENV_VALUE;
   1971   1.5       cgd 		old_env_value = OLD_ENV_VAR;
   1972   1.1       cgd 	} else {
   1973   1.1       cgd unknown:
   1974   1.1       cgd 		printf("Unknown \"varval\" command. (\"auto\", \"right\", \"wrong\", \"status\")\n");
   1975   1.1       cgd 	}
   1976   1.1       cgd }
   1977   1.1       cgd #endif
   1978   1.1       cgd 
   1979  1.25  christos #if	defined(AUTHENTICATION)
   1980   1.1       cgd /*
   1981   1.1       cgd  * The AUTHENTICATE command.
   1982   1.1       cgd  */
   1983   1.1       cgd 
   1984   1.1       cgd struct authlist {
   1985   1.1       cgd 	char	*name;
   1986   1.1       cgd 	char	*help;
   1987   1.1       cgd 	int	(*handler) P((char *));
   1988   1.1       cgd 	int	narg;
   1989   1.1       cgd };
   1990   1.1       cgd 
   1991   1.1       cgd struct authlist AuthList[] = {
   1992   1.1       cgd     { "status",	"Display current status of authentication information",
   1993   1.1       cgd 						auth_status,	0 },
   1994   1.1       cgd     { "disable", "Disable an authentication type ('auth disable ?' for more)",
   1995   1.1       cgd 						auth_disable,	1 },
   1996  1.25  christos     { "enable", "Enable an authentication type ('auth enable ?' for more)",
   1997  1.25  christos 						auth_enable,	1 },
   1998   1.1       cgd     { "help",	0,				auth_help,		0 },
   1999   1.1       cgd     { "?",	"Print help information",	auth_help,		0 },
   2000   1.1       cgd     { 0 },
   2001   1.1       cgd };
   2002   1.1       cgd 
   2003   1.1       cgd     static int
   2004   1.1       cgd auth_help(s)
   2005   1.1       cgd     char *s;
   2006   1.1       cgd {
   2007   1.1       cgd     struct authlist *c;
   2008   1.1       cgd 
   2009   1.1       cgd     for (c = AuthList; c->name; c++) {
   2010   1.1       cgd 	if (c->help) {
   2011   1.1       cgd 	    if (*c->help)
   2012  1.25  christos 		printf("%-15s %s\n", c->name, c->help);
   2013   1.1       cgd 	    else
   2014   1.1       cgd 		printf("\n");
   2015   1.1       cgd 	}
   2016   1.1       cgd     }
   2017   1.1       cgd     return 0;
   2018   1.1       cgd }
   2019  1.10       jtk 
   2020  1.10       jtk     int
   2021  1.10       jtk auth_cmd(argc, argv)
   2022  1.10       jtk     int  argc;
   2023  1.10       jtk     char *argv[];
   2024  1.10       jtk {
   2025   1.1       cgd     struct authlist *c;
   2026   1.1       cgd 
   2027   1.1       cgd     if (argc < 2) {
   2028  1.10       jtk 	fprintf(stderr,
   2029   1.1       cgd 	    "Need an argument to 'auth' command.  'auth ?' for help.\n");
   2030  1.10       jtk 	return 0;
   2031   1.1       cgd     }
   2032   1.1       cgd 
   2033  1.10       jtk     c = (struct authlist *)
   2034   1.1       cgd 		genget(argv[1], (char **) AuthList, sizeof(struct authlist));
   2035  1.10       jtk     if (c == 0) {
   2036   1.1       cgd 	fprintf(stderr, "'%s': unknown argument ('auth ?' for help).\n",
   2037   1.1       cgd     				argv[1]);
   2038   1.1       cgd 	return 0;
   2039   1.1       cgd     }
   2040   1.1       cgd     if (Ambiguous(c)) {
   2041   1.1       cgd 	fprintf(stderr, "'%s': ambiguous argument ('auth ?' for help).\n",
   2042   1.1       cgd     				argv[1]);
   2043   1.1       cgd 	return 0;
   2044  1.25  christos     }
   2045   1.1       cgd     if (c->narg + 2 != argc) {
   2046   1.1       cgd 	fprintf(stderr,
   2047   1.1       cgd 	    "Need %s%d argument%s to 'auth %s' command.  'auth ?' for help.\n",
   2048   1.1       cgd 		c->narg < argc + 2 ? "only " : "",
   2049   1.1       cgd 		c->narg, c->narg == 1 ? "" : "s", c->name);
   2050   1.1       cgd 	return 0;
   2051   1.1       cgd     }
   2052   1.1       cgd     return((*c->handler)(argv[2]));
   2053   1.1       cgd }
   2054   1.1       cgd #endif
   2055   1.1       cgd 
   2056   1.1       cgd 
   2057   1.1       cgd #if	defined(unix) && defined(TN3270)
   2058   1.1       cgd     static void
   2059   1.1       cgd filestuff(fd)
   2060   1.1       cgd     int fd;
   2061   1.1       cgd {
   2062   1.1       cgd     int res;
   2063   1.1       cgd 
   2064   1.1       cgd #ifdef	F_GETOWN
   2065   1.1       cgd     setconnmode(0);
   2066   1.1       cgd     res = fcntl(fd, F_GETOWN, 0);
   2067   1.1       cgd     setcommandmode();
   2068   1.1       cgd 
   2069   1.1       cgd     if (res == -1) {
   2070   1.1       cgd 	perror("fcntl");
   2071   1.1       cgd 	return;
   2072   1.1       cgd     }
   2073   1.1       cgd     printf("\tOwner is %d.\n", res);
   2074   1.1       cgd #endif
   2075   1.1       cgd 
   2076   1.5       cgd     setconnmode(0);
   2077   1.5       cgd     res = fcntl(fd, F_GETFL, 0);
   2078   1.5       cgd     setcommandmode();
   2079   1.1       cgd 
   2080   1.1       cgd     if (res == -1) {
   2081   1.1       cgd 	perror("fcntl");
   2082   1.1       cgd 	return;
   2083   1.1       cgd     }
   2084   1.1       cgd #ifdef notdef
   2085   1.1       cgd     printf("\tFlags are 0x%x: %s\n", res, decodeflags(res));
   2086  1.15  christos #endif
   2087   1.1       cgd }
   2088   1.1       cgd #endif /* defined(unix) && defined(TN3270) */
   2089   1.1       cgd 
   2090   1.1       cgd /*
   2091   1.1       cgd  * Print status about the connection.
   2092   1.1       cgd  */
   2093   1.1       cgd     /*ARGSUSED*/
   2094   1.1       cgd     static int
   2095   1.1       cgd status(argc, argv)
   2096   1.1       cgd     int	 argc;
   2097   1.1       cgd     char *argv[];
   2098   1.1       cgd {
   2099   1.1       cgd     if (connected) {
   2100   1.1       cgd 	printf("Connected to %s.\n", hostname);
   2101   1.1       cgd 	if ((argc < 2) || strcmp(argv[1], "notmuch")) {
   2102   1.1       cgd 	    int mode = getconnmode();
   2103   1.1       cgd 
   2104   1.1       cgd 	    if (my_want_state_is_will(TELOPT_LINEMODE)) {
   2105   1.1       cgd 		printf("Operating with LINEMODE option\n");
   2106   1.1       cgd 		printf("%s line editing\n", (mode&MODE_EDIT) ? "Local" : "No");
   2107   1.1       cgd 		printf("%s catching of signals\n",
   2108   1.1       cgd 					(mode&MODE_TRAPSIG) ? "Local" : "No");
   2109   1.1       cgd 		slcstate();
   2110   1.1       cgd #ifdef	KLUDGELINEMODE
   2111   1.1       cgd 	    } else if (kludgelinemode && my_want_state_is_dont(TELOPT_SGA)) {
   2112   1.1       cgd 		printf("Operating in obsolete linemode\n");
   2113   1.1       cgd #endif
   2114   1.1       cgd 	    } else {
   2115   1.1       cgd 		printf("Operating in single character mode\n");
   2116   1.1       cgd 		if (localchars)
   2117   1.1       cgd 		    printf("Catching signals locally\n");
   2118   1.1       cgd 	    }
   2119   1.1       cgd 	    printf("%s character echo\n", (mode&MODE_ECHO) ? "Local" : "Remote");
   2120   1.1       cgd 	    if (my_want_state_is_will(TELOPT_LFLOW))
   2121   1.1       cgd 		printf("%s flow control\n", (mode&MODE_FLOW) ? "Local" : "No");
   2122   1.1       cgd 	}
   2123   1.1       cgd     } else {
   2124   1.1       cgd 	printf("No connection.\n");
   2125   1.1       cgd     }
   2126   1.1       cgd #   if !defined(TN3270)
   2127   1.1       cgd     printf("Escape character is '%s'.\n", control(escape));
   2128   1.1       cgd     (void) fflush(stdout);
   2129   1.1       cgd #   else /* !defined(TN3270) */
   2130   1.1       cgd     if ((!In3270) && ((argc < 2) || strcmp(argv[1], "notmuch"))) {
   2131  1.16     enami 	printf("Escape character is '%s'.\n", control(escape));
   2132   1.1       cgd     }
   2133   1.1       cgd #   if defined(unix)
   2134   1.1       cgd     if ((argc >= 2) && !strcmp(argv[1], "everything")) {
   2135   1.1       cgd 	printf("SIGIO received %d time%s.\n",
   2136   1.1       cgd 				sigiocount, (sigiocount == 1)? "":"s");
   2137   1.1       cgd 	if (In3270) {
   2138   1.1       cgd 	    printf("Process ID %d, process group %d.\n",
   2139   1.1       cgd 					    getpid(), getpgrp());
   2140   1.1       cgd 	    printf("Terminal input:\n");
   2141  1.36    itojun 	    filestuff(tin);
   2142   1.1       cgd 	    printf("Terminal output:\n");
   2143   1.1       cgd 	    filestuff(tout);
   2144   1.1       cgd 	    printf("Network socket:\n");
   2145   1.1       cgd 	    filestuff(net);
   2146   1.1       cgd 	}
   2147   1.1       cgd     }
   2148   1.1       cgd     if (In3270 && transcom) {
   2149   1.1       cgd 	printf("Transparent mode command is '%s'.\n", transcom);
   2150   1.1       cgd     }
   2151   1.1       cgd #   endif /* defined(unix) */
   2152   1.1       cgd     (void) fflush(stdout);
   2153   1.1       cgd     if (In3270) {
   2154   1.1       cgd 	return 0;
   2155   1.1       cgd     }
   2156  1.15  christos #   endif /* defined(TN3270) */
   2157   1.1       cgd     return 1;
   2158   1.1       cgd }
   2159  1.15  christos 
   2160   1.1       cgd #ifdef	SIGINFO
   2161   1.1       cgd /*
   2162   1.1       cgd  * Function that gets called when SIGINFO is received.
   2163  1.26    itojun  */
   2164  1.26    itojun int
   2165  1.26    itojun ayt_status()
   2166  1.26    itojun {
   2167  1.38    itojun     return call(status, "status", "notmuch", 0);
   2168  1.38    itojun }
   2169  1.38    itojun #endif
   2170  1.38    itojun 
   2171  1.38    itojun static const char *
   2172  1.38    itojun sockaddr_ntop(sa)
   2173  1.26    itojun     struct sockaddr *sa;
   2174  1.38    itojun {
   2175  1.38    itojun     static char addrbuf[NI_MAXHOST];
   2176  1.38    itojun #ifdef NI_WITHSCOPEID
   2177  1.38    itojun     const int niflags = NI_NUMERICHOST | NI_WITHSCOPEID;
   2178  1.26    itojun #else
   2179  1.26    itojun     const int niflags = NI_NUMERICHOST;
   2180  1.26    itojun #endif
   2181  1.37    itojun 
   2182  1.37    itojun     if (getnameinfo(sa, sa->sa_len, addrbuf, sizeof(addrbuf),
   2183  1.37    itojun 	    NULL, 0, niflags) == 0)
   2184  1.37    itojun 	return addrbuf;
   2185  1.37    itojun     else
   2186  1.37    itojun 	return NULL;
   2187  1.37    itojun }
   2188  1.37    itojun 
   2189  1.37    itojun #if defined(IPSEC) && defined(IPSEC_POLICY_IPSEC)
   2190  1.37    itojun static int setpolicy __P((int, struct addrinfo *, char *));
   2191  1.37    itojun 
   2192  1.37    itojun static int
   2193  1.37    itojun setpolicy(net, res, policy)
   2194  1.37    itojun 	int net;
   2195  1.37    itojun 	struct addrinfo *res;
   2196  1.37    itojun 	char *policy;
   2197  1.37    itojun {
   2198  1.37    itojun 	char *buf;
   2199  1.37    itojun 	int level;
   2200  1.37    itojun 	int optname;
   2201  1.37    itojun 
   2202  1.37    itojun 	if (policy == NULL)
   2203  1.37    itojun 		return 0;
   2204  1.37    itojun 
   2205  1.37    itojun 	buf = ipsec_set_policy(policy, strlen(policy));
   2206  1.37    itojun 	if (buf == NULL) {
   2207  1.37    itojun 		printf("%s\n", ipsec_strerror());
   2208  1.37    itojun 		return -1;
   2209  1.37    itojun 	}
   2210  1.37    itojun 	level = res->ai_family == AF_INET ? IPPROTO_IP : IPPROTO_IPV6;
   2211  1.37    itojun 	optname = res->ai_family == AF_INET ? IP_IPSEC_POLICY : IPV6_IPSEC_POLICY;
   2212  1.37    itojun 	if (setsockopt(net, level, optname, buf, ipsec_get_policylen(buf)) < 0){
   2213  1.37    itojun 		perror("setsockopt");
   2214   1.1       cgd 		return -1;
   2215   1.1       cgd 	}
   2216   1.1       cgd 
   2217   1.1       cgd 	free(buf);
   2218   1.1       cgd 	return 0;
   2219  1.29    itojun }
   2220  1.29    itojun #endif
   2221  1.26    itojun 
   2222   1.1       cgd     int
   2223  1.15  christos tn(argc, argv)
   2224  1.15  christos     int argc;
   2225  1.26    itojun     char *argv[];
   2226   1.1       cgd {
   2227  1.24   mycroft     struct addrinfo hints, *res, *res0;
   2228  1.24   mycroft     char *cause = "telnet: unknown";
   2229  1.15  christos     int error;
   2230  1.15  christos #if	defined(IP_OPTIONS) && defined(IPPROTO_IP)
   2231  1.15  christos     char *srp = 0;
   2232   1.1       cgd     unsigned long srlen;
   2233   1.1       cgd     int proto, opt;
   2234   1.1       cgd #endif
   2235   1.1       cgd     char *cmd, *hostp = 0, *portp = 0;
   2236   1.1       cgd     const char *user = 0;
   2237   1.1       cgd #ifdef __GNUC__	/* Avoid vfork clobbering */
   2238   1.1       cgd     (void) &user;
   2239   1.1       cgd #endif
   2240   1.1       cgd 
   2241   1.1       cgd     if (connected) {
   2242   1.1       cgd 	printf("?Already connected to %s\n", hostname);
   2243   1.1       cgd 	return 0;
   2244   1.1       cgd     }
   2245   1.1       cgd     if (argc < 2) {
   2246   1.1       cgd 	(void) strcpy(line, "open ");
   2247   1.1       cgd 	printf("(to) ");
   2248  1.10       jtk 	(void) fgets(&line[strlen(line)], sizeof(line) - strlen(line), stdin);
   2249   1.1       cgd 	makeargv();
   2250   1.1       cgd 	argc = margc;
   2251   1.1       cgd 	argv = margv;
   2252   1.1       cgd     }
   2253   1.1       cgd     cmd = *argv;
   2254   1.1       cgd     --argc; ++argv;
   2255   1.1       cgd     while (argc) {
   2256   1.1       cgd 	if (strcmp(*argv, "help") == 0 || isprefix(*argv, "?"))
   2257   1.1       cgd 	    goto usage;
   2258   1.1       cgd 	if (strcmp(*argv, "-l") == 0) {
   2259   1.1       cgd 	    --argc; ++argv;
   2260   1.1       cgd 	    if (argc == 0)
   2261   1.1       cgd 		goto usage;
   2262   1.1       cgd 	    user = *argv++;
   2263   1.1       cgd 	    --argc;
   2264   1.1       cgd 	    continue;
   2265   1.1       cgd 	}
   2266   1.1       cgd 	if (strcmp(*argv, "-a") == 0) {
   2267   1.1       cgd 	    --argc; ++argv;
   2268   1.1       cgd 	    autologin = 1;
   2269   1.1       cgd 	    continue;
   2270   1.1       cgd 	}
   2271   1.1       cgd 	if (hostp == 0) {
   2272   1.1       cgd 	    hostp = *argv++;
   2273   1.1       cgd 	    --argc;
   2274   1.1       cgd 	    continue;
   2275   1.1       cgd 	}
   2276   1.1       cgd 	if (portp == 0) {
   2277   1.1       cgd 	    portp = *argv++;
   2278   1.1       cgd 	    --argc;
   2279   1.1       cgd 	    continue;
   2280  1.26    itojun 	}
   2281   1.1       cgd     usage:
   2282  1.26    itojun 	printf("usage: %s [-l user] [-a] host-name [port]\n", cmd);
   2283  1.26    itojun 	return 0;
   2284  1.26    itojun     }
   2285  1.26    itojun     if (hostp == 0)
   2286  1.26    itojun 	goto usage;
   2287  1.26    itojun 
   2288  1.26    itojun     (void) strcpy(_hostname, hostp);
   2289  1.26    itojun     if (hostp[0] == '@' || hostp[0] == '!') {
   2290   1.1       cgd 	char *p;
   2291   1.1       cgd 	hostname = NULL;
   2292  1.26    itojun 	for (p = hostp + 1; *p; p++) {
   2293  1.26    itojun 	    if (*p == ',' || *p == '@')
   2294  1.26    itojun 		hostname = p;
   2295  1.26    itojun 	}
   2296  1.26    itojun 	if (hostname == NULL) {
   2297  1.36    itojun 	    fprintf(stderr, "%s: bad source route specification\n", hostp);
   2298  1.36    itojun 	    return 0;
   2299  1.30       jtk 	}
   2300  1.36    itojun 	*hostname++ = '\0';
   2301  1.36    itojun     } else
   2302  1.36    itojun 	hostname = hostp;
   2303  1.26    itojun 
   2304  1.26    itojun     if (!portp) {
   2305  1.26    itojun 	telnetport = 1;
   2306  1.26    itojun 	portp = "telnet";
   2307  1.26    itojun     } else if (portp[0] == '-') {
   2308  1.26    itojun 	/* use telnet negotiation if port number/name preceded by minus sign */
   2309  1.36    itojun 	telnetport = 1;
   2310  1.29    itojun 	portp++;
   2311  1.26    itojun     }
   2312  1.36    itojun 
   2313  1.36    itojun     memset(&hints, 0, sizeof(hints));
   2314  1.36    itojun     hints.ai_family = AF_UNSPEC;
   2315  1.36    itojun     hints.ai_socktype = SOCK_STREAM;
   2316  1.36    itojun     hints.ai_protocol = 0;
   2317  1.36    itojun     hints.ai_flags = AI_NUMERICHOST;	/* avoid forward lookup */
   2318  1.36    itojun     error = getaddrinfo(hostname, portp, &hints, &res0);
   2319  1.36    itojun     if (!error) {
   2320  1.36    itojun 	/* numeric */
   2321   1.1       cgd 	if (doaddrlookup &&
   2322  1.36    itojun 	    getnameinfo(res0->ai_addr, res0->ai_addrlen,
   2323  1.26    itojun 		_hostname, sizeof(_hostname), NULL, 0, NI_NAMEREQD) == 0)
   2324  1.26    itojun 	    ; /* okay */
   2325  1.26    itojun 	else {
   2326  1.26    itojun 	    strncpy(_hostname, hostname, sizeof(_hostname) - 1);
   2327  1.36    itojun 	    _hostname[sizeof(_hostname) - 1] = '\0';
   2328  1.29    itojun 	}
   2329  1.40    itojun     } else {
   2330  1.40    itojun 	/* FQDN - try again with forward DNS lookup */
   2331  1.40    itojun 	memset(&hints, 0, sizeof(hints));
   2332  1.40    itojun 	hints.ai_family = AF_UNSPEC;
   2333  1.36    itojun 	hints.ai_socktype = SOCK_STREAM;
   2334  1.36    itojun 	hints.ai_protocol = 0;
   2335  1.36    itojun 	hints.ai_flags = AI_CANONNAME;
   2336  1.36    itojun 	error = getaddrinfo(hostname, portp, &hints, &res0);
   2337  1.36    itojun 	if (error == EAI_SERVICE) {
   2338  1.36    itojun 	    fprintf(stderr, "tcp/%s: unknown service\n", portp);
   2339  1.36    itojun 	    return 0;
   2340  1.36    itojun 	} else if (error) {
   2341  1.36    itojun 	    fprintf(stderr, "%s: %s\n", hostname, gai_strerror(error));
   2342  1.26    itojun 	    return 0;
   2343  1.26    itojun 	}
   2344  1.26    itojun 	if (res0->ai_canonname) {
   2345  1.29    itojun 	    (void) strncpy(_hostname, res0->ai_canonname,
   2346  1.29    itojun 	        sizeof(_hostname) - 1);
   2347  1.26    itojun 	} else
   2348  1.26    itojun 	    (void) strncpy(_hostname, hostname, sizeof(_hostname) - 1);
   2349   1.1       cgd 	_hostname[sizeof(_hostname) - 1] = '\0';
   2350  1.29    itojun     }
   2351  1.29    itojun     hostname = _hostname;
   2352   1.1       cgd 
   2353   1.1       cgd     net = -1;
   2354   1.1       cgd     for (res = res0; res; res = res->ai_next) {
   2355  1.29    itojun 	printf("Trying %s...\n", sockaddr_ntop(res->ai_addr));
   2356   1.1       cgd 	net = socket(res->ai_family, res->ai_socktype, res->ai_protocol);
   2357  1.26    itojun 	if (net < 0) {
   2358  1.33    itojun 	    cause = "telnet: socket";
   2359  1.33    itojun 	    continue;
   2360  1.33    itojun 	}
   2361  1.26    itojun 
   2362  1.33    itojun 	if (debug && SetSockOpt(net, SOL_SOCKET, SO_DEBUG, 1) < 0) {
   2363  1.26    itojun 	    perror("setsockopt (SO_DEBUG)");
   2364  1.26    itojun 	}
   2365  1.26    itojun 	if (hostp[0] == '@' || hostp[0] == '!') {
   2366  1.37    itojun 	    if ((srlen = sourceroute(res, hostp, &srp, &proto, &opt)) < 0) {
   2367  1.26    itojun 		(void) NetClose(net);
   2368  1.37    itojun 		net = -1;
   2369  1.37    itojun 		continue;
   2370  1.37    itojun 	    }
   2371  1.37    itojun 	    if (srp && setsockopt(net, proto, opt, srp, srlen) < 0)
   2372  1.37    itojun 		perror("setsockopt (source route)");
   2373  1.37    itojun 	}
   2374  1.37    itojun 
   2375  1.37    itojun #if defined(IPSEC) && defined(IPSEC_POLICY_IPSEC)
   2376  1.37    itojun 	if (setpolicy(net, res, ipsec_policy_in) < 0) {
   2377  1.26    itojun 	    (void) NetClose(net);
   2378  1.26    itojun 	    net = -1;
   2379   1.1       cgd 	    continue;
   2380  1.26    itojun 	}
   2381  1.26    itojun 	if (setpolicy(net, res, ipsec_policy_out) < 0) {
   2382   1.1       cgd 	    (void) NetClose(net);
   2383   1.1       cgd 	    net = -1;
   2384   1.1       cgd 	    continue;
   2385  1.26    itojun 	}
   2386   1.1       cgd #endif
   2387   1.1       cgd 
   2388   1.1       cgd 	if (connect(net, res->ai_addr, res->ai_addrlen) < 0) {
   2389  1.29    itojun 	    if (res->ai_next) {
   2390  1.29    itojun 		int oerrno = errno;
   2391  1.29    itojun 
   2392  1.29    itojun 		fprintf(stderr, "telnet: connect to address %s: ",
   2393   1.1       cgd 						sockaddr_ntop(res->ai_addr));
   2394  1.29    itojun 		errno = oerrno;
   2395   1.1       cgd 		perror((char *)0);
   2396   1.5       cgd 	    }
   2397   1.1       cgd 	    cause = "telnet: Unable to connect to remote host";
   2398   1.5       cgd 	    (void) NetClose(net);
   2399  1.29    itojun 	    net = -1;
   2400  1.29    itojun 	    continue;
   2401  1.29    itojun 	}
   2402  1.29    itojun 
   2403  1.29    itojun 	connected++;
   2404  1.29    itojun #if	defined(AUTHENTICATION)
   2405  1.29    itojun 	auth_encrypt_connect(connected);
   2406  1.29    itojun #endif	/* defined(AUTHENTICATION) */
   2407   1.1       cgd 	break;
   2408   1.1       cgd     }
   2409   1.1       cgd     freeaddrinfo(res0);
   2410   1.1       cgd     if (net < 0 || connected == 0) {
   2411   1.1       cgd 	perror(cause);
   2412   1.1       cgd 	return 0;
   2413  1.15  christos     }
   2414  1.15  christos 
   2415   1.1       cgd     cmdrc(hostp, hostname);
   2416   1.1       cgd     if (autologin && user == NULL) {
   2417   1.1       cgd 	struct passwd *pw;
   2418   1.1       cgd 
   2419   1.1       cgd 	user = getenv("USER");
   2420   1.1       cgd 	if (user == NULL ||
   2421   1.1       cgd 	    ((pw = getpwnam(user)) && pw->pw_uid != getuid())) {
   2422  1.15  christos 		if ((pw = getpwuid(getuid())) != NULL)
   2423   1.1       cgd 			user = pw->pw_name;
   2424   1.1       cgd 		else
   2425   1.1       cgd 			user = NULL;
   2426   1.1       cgd 	}
   2427   1.1       cgd     }
   2428   1.1       cgd     if (user) {
   2429   1.1       cgd 	env_define((unsigned char *)"USER", (unsigned char *)user);
   2430   1.1       cgd 	env_export((unsigned char *)"USER", NULL);
   2431   1.1       cgd     }
   2432  1.17   thorpej     (void) call(status, "status", "notmuch", 0);
   2433   1.1       cgd     if (setjmp(peerdied) == 0)
   2434   1.1       cgd 	telnet(user);
   2435   1.1       cgd     (void) NetClose(net);
   2436   1.1       cgd     ExitString("Connection closed by foreign host.\n",1);
   2437   1.1       cgd     /*NOTREACHED*/
   2438   1.1       cgd }
   2439   1.1       cgd 
   2440   1.1       cgd #define HELPINDENT ((int)sizeof ("connect"))
   2441   1.1       cgd 
   2442   1.1       cgd static char
   2443   1.1       cgd 	openhelp[] =	"connect to a site",
   2444   1.1       cgd 	closehelp[] =	"close current connection",
   2445   1.1       cgd 	logouthelp[] =	"forcibly logout remote user and close the connection",
   2446   1.1       cgd 	quithelp[] =	"exit telnet",
   2447   1.1       cgd 	statushelp[] =	"print status information",
   2448   1.1       cgd 	helphelp[] =	"print help information",
   2449   1.1       cgd 	sendhelp[] =	"transmit special characters ('send ?' for more)",
   2450   1.5       cgd 	sethelp[] = 	"set operating parameters ('set ?' for more)",
   2451   1.1       cgd 	unsethelp[] = 	"unset operating parameters ('unset ?' for more)",
   2452   1.1       cgd 	togglestring[] ="toggle operating parameters ('toggle ?' for more)",
   2453   1.1       cgd 	slchelp[] =	"change state of special charaters ('slc ?' for more)",
   2454   1.1       cgd 	displayhelp[] =	"display operating parameters",
   2455   1.1       cgd #if	defined(TN3270) && defined(unix)
   2456   1.1       cgd 	transcomhelp[] = "specify Unix command for transparent mode pipe",
   2457   1.1       cgd #endif	/* defined(TN3270) && defined(unix) */
   2458   1.1       cgd #if	defined(AUTHENTICATION)
   2459   1.1       cgd 	authhelp[] =	"turn on (off) authentication ('auth ?' for more)",
   2460   1.1       cgd #endif
   2461   1.1       cgd #if	defined(unix)
   2462   1.1       cgd 	zhelp[] =	"suspend telnet",
   2463   1.1       cgd #endif	/* defined(unix) */
   2464   1.1       cgd 	shellhelp[] =	"invoke a subshell",
   2465   1.1       cgd 	envhelp[] =	"change environment variables ('environ ?' for more)",
   2466   1.1       cgd 	modestring[] = "try to enter line or character mode ('mode ?' for more)";
   2467   1.1       cgd 
   2468   1.1       cgd static Command cmdtab[] = {
   2469   1.1       cgd 	{ "close",	closehelp,	bye,		1 },
   2470   1.1       cgd 	{ "logout",	logouthelp,	logout,		1 },
   2471   1.1       cgd 	{ "display",	displayhelp,	display,	0 },
   2472   1.1       cgd 	{ "mode",	modestring,	modecmd,	0 },
   2473   1.1       cgd 	{ "open",	openhelp,	tn,		0 },
   2474   1.1       cgd 	{ "quit",	quithelp,	quit,		0 },
   2475   1.1       cgd 	{ "send",	sendhelp,	sendcmd,	0 },
   2476   1.5       cgd 	{ "set",	sethelp,	setcmd,		0 },
   2477   1.1       cgd 	{ "unset",	unsethelp,	unsetcmd,	0 },
   2478   1.1       cgd 	{ "status",	statushelp,	status,		0 },
   2479   1.1       cgd 	{ "toggle",	togglestring,	toggle,		0 },
   2480   1.1       cgd 	{ "slc",	slchelp,	slccmd,		0 },
   2481   1.1       cgd #if	defined(TN3270) && defined(unix)
   2482   1.1       cgd 	{ "transcom",	transcomhelp,	settranscom,	0 },
   2483   1.1       cgd #endif	/* defined(TN3270) && defined(unix) */
   2484   1.1       cgd #if	defined(AUTHENTICATION)
   2485   1.1       cgd 	{ "auth",	authhelp,	auth_cmd,	0 },
   2486   1.1       cgd #endif
   2487   1.1       cgd #if	defined(unix)
   2488   1.1       cgd 	{ "z",		zhelp,		suspend,	0 },
   2489  1.15  christos #endif	/* defined(unix) */
   2490   1.1       cgd #if	defined(TN3270)
   2491   1.1       cgd 	{ "!",		shellhelp,	shell,		1 },
   2492   1.1       cgd #else
   2493   1.1       cgd 	{ "!",		shellhelp,	shell,		0 },
   2494   1.1       cgd #endif
   2495   1.1       cgd 	{ "environ",	envhelp,	env_cmd,	0 },
   2496   1.1       cgd 	{ "?",		helphelp,	help,		0 },
   2497   1.1       cgd 	{ NULL,		NULL,		NULL,		0 }
   2498   1.1       cgd };
   2499  1.15  christos 
   2500   1.1       cgd static char	crmodhelp[] =	"deprecated command -- use 'toggle crmod' instead";
   2501   1.1       cgd static char	escapehelp[] =	"deprecated command -- use 'set escape' instead";
   2502   1.1       cgd 
   2503   1.1       cgd static Command cmdtab2[] = {
   2504   1.1       cgd 	{ "help",	0,		help,		0 },
   2505   1.1       cgd 	{ "escape",	escapehelp,	setescape,	0 },
   2506   1.1       cgd 	{ "crmod",	crmodhelp,	togcrmod,	0 },
   2507   1.1       cgd 	{ NULL,		NULL,		NULL,		0 }
   2508  1.15  christos };
   2509  1.15  christos 
   2510  1.15  christos 
   2511  1.15  christos /*
   2512   1.1       cgd  * Call routine with argc, argv set from args (terminated by 0).
   2513   1.1       cgd  */
   2514  1.15  christos 
   2515   1.1       cgd     /*VARARGS1*/
   2516   1.1       cgd     static int
   2517   1.1       cgd #ifdef __STDC__
   2518   1.1       cgd call(intrtn_t routine, ...)
   2519  1.15  christos #else
   2520  1.15  christos call(va_alist)
   2521   1.1       cgd     va_dcl
   2522   1.1       cgd #endif
   2523   1.1       cgd {
   2524  1.15  christos     va_list ap;
   2525  1.15  christos     char *args[100];
   2526  1.15  christos     int argno = 0;
   2527  1.15  christos #ifndef __STDC__
   2528   1.1       cgd     intrtn_t routine;
   2529   1.1       cgd 
   2530   1.1       cgd     va_start(ap);
   2531   1.1       cgd     routine = (va_arg(ap, intrtn_t));
   2532   1.1       cgd #else
   2533   1.1       cgd     va_start(ap, routine);
   2534   1.1       cgd #endif
   2535   1.1       cgd 
   2536   1.1       cgd     while ((args[argno++] = va_arg(ap, char *)) != 0) {
   2537   1.1       cgd 	;
   2538   1.1       cgd     }
   2539   1.1       cgd     va_end(ap);
   2540   1.1       cgd     return (*routine)(argno-1, args);
   2541   1.1       cgd }
   2542  1.15  christos 
   2543   1.1       cgd 
   2544   1.1       cgd     static Command *
   2545   1.1       cgd getcmd(name)
   2546   1.1       cgd     char *name;
   2547   1.1       cgd {
   2548   1.1       cgd     Command *cm;
   2549   1.1       cgd 
   2550   1.1       cgd     if ((cm = (Command *) genget(name, (char **) cmdtab, sizeof(Command))) != NULL)
   2551   1.1       cgd 	return cm;
   2552   1.1       cgd     return (Command *) genget(name, (char **) cmdtab2, sizeof(Command));
   2553   1.1       cgd }
   2554   1.1       cgd 
   2555   1.1       cgd     void
   2556   1.1       cgd command(top, tbuf, cnt)
   2557   1.1       cgd     int top;
   2558   1.1       cgd     char *tbuf;
   2559   1.1       cgd     int cnt;
   2560   1.1       cgd {
   2561   1.1       cgd     register Command *c;
   2562   1.1       cgd 
   2563   1.1       cgd     setcommandmode();
   2564   1.1       cgd     if (!top) {
   2565   1.1       cgd 	putchar('\n');
   2566   1.1       cgd #if	defined(unix)
   2567   1.1       cgd     } else {
   2568   1.1       cgd 	(void) signal(SIGINT, SIG_DFL);
   2569   1.1       cgd 	(void) signal(SIGQUIT, SIG_DFL);
   2570   1.1       cgd #endif	/* defined(unix) */
   2571   1.1       cgd     }
   2572   1.1       cgd     for (;;) {
   2573   1.1       cgd 	if (rlogin == _POSIX_VDISABLE)
   2574   1.1       cgd 		printf("%s> ", prompt);
   2575   1.1       cgd 	if (tbuf) {
   2576   1.1       cgd 	    register char *cp;
   2577  1.10       jtk 	    cp = line;
   2578   1.1       cgd 	    while (cnt > 0 && (*cp++ = *tbuf++) != '\n')
   2579   1.1       cgd 		cnt--;
   2580   1.1       cgd 	    tbuf = 0;
   2581   1.1       cgd 	    if (cp == line || *--cp != '\n' || cp == line)
   2582   1.1       cgd 		goto getline;
   2583   1.1       cgd 	    *cp = '\0';
   2584  1.15  christos 	    if (rlogin == _POSIX_VDISABLE)
   2585   1.1       cgd 		printf("%s\n", line);
   2586   1.1       cgd 	} else {
   2587   1.1       cgd 	getline:
   2588   1.1       cgd 	    if (rlogin != _POSIX_VDISABLE)
   2589   1.1       cgd 		printf("%s> ", prompt);
   2590   1.1       cgd 	    if (fgets(line, sizeof(line), stdin) == NULL) {
   2591   1.1       cgd 		if (feof(stdin) || ferror(stdin)) {
   2592   1.1       cgd 		    (void) quit(0, NULL);
   2593   1.1       cgd 		    /*NOTREACHED*/
   2594   1.1       cgd 		}
   2595   1.1       cgd 		break;
   2596   1.1       cgd 	    }
   2597   1.1       cgd 	}
   2598   1.1       cgd 	if (line[0] == 0)
   2599   1.1       cgd 	    break;
   2600   1.1       cgd 	makeargv();
   2601   1.1       cgd 	if (margv[0] == 0) {
   2602   1.1       cgd 	    break;
   2603   1.1       cgd 	}
   2604   1.1       cgd 	c = getcmd(margv[0]);
   2605   1.1       cgd 	if (Ambiguous(c)) {
   2606   1.1       cgd 	    printf("?Ambiguous command\n");
   2607   1.1       cgd 	    continue;
   2608   1.1       cgd 	}
   2609   1.1       cgd 	if (c == 0) {
   2610   1.1       cgd 	    printf("?Invalid command\n");
   2611   1.1       cgd 	    continue;
   2612   1.1       cgd 	}
   2613   1.1       cgd 	if (c->needconnect && !connected) {
   2614   1.1       cgd 	    printf("?Need to be connected first.\n");
   2615   1.1       cgd 	    continue;
   2616   1.1       cgd 	}
   2617   1.1       cgd 	if ((*c->handler)(margc, margv)) {
   2618   1.1       cgd 	    break;
   2619   1.1       cgd 	}
   2620   1.1       cgd     }
   2621   1.1       cgd     if (!top) {
   2622   1.1       cgd 	if (!connected) {
   2623   1.1       cgd 	    longjmp(toplevel, 1);
   2624   1.1       cgd 	    /*NOTREACHED*/
   2625   1.1       cgd 	}
   2626   1.1       cgd #if	defined(TN3270)
   2627   1.1       cgd 	if (shell_active == 0) {
   2628   1.1       cgd 	    setconnmode(0);
   2629   1.1       cgd 	}
   2630   1.1       cgd #else	/* defined(TN3270) */
   2631  1.15  christos 	setconnmode(0);
   2632   1.1       cgd #endif	/* defined(TN3270) */
   2633   1.1       cgd     }
   2634   1.1       cgd }
   2635   1.1       cgd 
   2636   1.1       cgd /*
   2638   1.1       cgd  * Help command.
   2639   1.1       cgd  */
   2640   1.1       cgd 	static int
   2641   1.1       cgd help(argc, argv)
   2642   1.1       cgd 	int argc;
   2643   1.1       cgd 	char *argv[];
   2644   1.1       cgd {
   2645   1.1       cgd 	register Command *c;
   2646   1.1       cgd 
   2647   1.1       cgd 	if (argc == 1) {
   2648   1.1       cgd 		printf("Commands may be abbreviated.  Commands are:\n\n");
   2649   1.1       cgd 		for (c = cmdtab; c->name; c++)
   2650   1.1       cgd 			if (c->help) {
   2651   1.1       cgd 				printf("%-*s\t%s\n", HELPINDENT, c->name,
   2652   1.1       cgd 								    c->help);
   2653   1.1       cgd 			}
   2654   1.1       cgd 		return 0;
   2655   1.1       cgd 	}
   2656   1.1       cgd 	while (--argc > 0) {
   2657   1.1       cgd 		register char *arg;
   2658   1.1       cgd 		arg = *++argv;
   2659   1.1       cgd 		c = getcmd(arg);
   2660   1.1       cgd 		if (Ambiguous(c))
   2661   1.1       cgd 			printf("?Ambiguous help command %s\n", arg);
   2662   1.1       cgd 		else if (c == (Command *)0)
   2663   1.1       cgd 			printf("?Invalid help command %s\n", arg);
   2664  1.15  christos 		else
   2665   1.1       cgd 			printf("%s\n", c->help);
   2666  1.24   mycroft 	}
   2667   1.1       cgd 	return 0;
   2668   1.1       cgd }
   2669   1.1       cgd 
   2670   1.1       cgd static char *rcname = 0;
   2671   1.1       cgd static char rcbuf[128];
   2672   1.1       cgd 
   2673   1.1       cgd void
   2674   1.1       cgd cmdrc(m1, m2)
   2675   1.1       cgd 	const char *m1, *m2;
   2676   1.1       cgd {
   2677   1.1       cgd     register Command *c;
   2678   1.1       cgd     FILE *rcfile;
   2679   1.1       cgd     int gotmachine = 0;
   2680   1.1       cgd     int l1 = strlen(m1);
   2681   1.1       cgd     int l2 = strlen(m2);
   2682   1.1       cgd     char m1save[64];
   2683   1.1       cgd 
   2684   1.1       cgd     if (skiprc)
   2685   1.1       cgd 	return;
   2686   1.1       cgd 
   2687   1.1       cgd     strcpy(m1save, m1);
   2688   1.1       cgd     m1 = m1save;
   2689   1.1       cgd 
   2690   1.1       cgd     if (rcname == 0) {
   2691   1.1       cgd 	rcname = getenv("HOME");
   2692   1.1       cgd 	if (rcname)
   2693   1.1       cgd 	    strcpy(rcbuf, rcname);
   2694   1.1       cgd 	else
   2695   1.1       cgd 	    rcbuf[0] = '\0';
   2696   1.1       cgd 	strcat(rcbuf, "/.telnetrc");
   2697   1.1       cgd 	rcname = rcbuf;
   2698   1.1       cgd     }
   2699   1.1       cgd 
   2700   1.1       cgd     if ((rcfile = fopen(rcname, "r")) == 0) {
   2701   1.1       cgd 	return;
   2702   1.1       cgd     }
   2703  1.25  christos 
   2704   1.1       cgd     for (;;) {
   2705   1.1       cgd 	if (fgets(line, sizeof(line), rcfile) == NULL)
   2706   1.1       cgd 	    break;
   2707  1.25  christos 	if (line[0] == 0)
   2708   1.1       cgd 	    break;
   2709   1.1       cgd 	if (line[0] == '#')
   2710   1.1       cgd 	    continue;
   2711   1.1       cgd 	if (gotmachine) {
   2712   1.1       cgd 	    if (!isspace((unsigned char)line[0]))
   2713   1.1       cgd 		gotmachine = 0;
   2714   1.1       cgd 	}
   2715   1.1       cgd 	if (gotmachine == 0) {
   2716   1.1       cgd 	    if (isspace((unsigned char)line[0]))
   2717   1.1       cgd 		continue;
   2718   1.1       cgd 	    if (strncasecmp(line, m1, l1) == 0)
   2719   1.1       cgd 		strncpy(line, &line[l1], sizeof(line) - l1);
   2720   1.1       cgd 	    else if (strncasecmp(line, m2, l2) == 0)
   2721   1.1       cgd 		strncpy(line, &line[l2], sizeof(line) - l2);
   2722   1.1       cgd 	    else if (strncasecmp(line, "DEFAULT", 7) == 0)
   2723   1.1       cgd 		strncpy(line, &line[7], sizeof(line) - 7);
   2724   1.1       cgd 	    else
   2725   1.1       cgd 		continue;
   2726   1.1       cgd 	    if (line[0] != ' ' && line[0] != '\t' && line[0] != '\n')
   2727   1.1       cgd 		continue;
   2728   1.1       cgd 	    gotmachine = 1;
   2729   1.1       cgd 	}
   2730   1.1       cgd 	makeargv();
   2731   1.1       cgd 	if (margv[0] == 0)
   2732   1.1       cgd 	    continue;
   2733   1.1       cgd 	c = getcmd(margv[0]);
   2734   1.1       cgd 	if (Ambiguous(c)) {
   2735   1.1       cgd 	    printf("?Ambiguous command: %s\n", margv[0]);
   2736   1.1       cgd 	    continue;
   2737   1.1       cgd 	}
   2738   1.1       cgd 	if (c == 0) {
   2739   1.1       cgd 	    printf("?Invalid command: %s\n", margv[0]);
   2740   1.1       cgd 	    continue;
   2741   1.1       cgd 	}
   2742   1.1       cgd 	/*
   2743   1.1       cgd 	 * This should never happen...
   2744   1.1       cgd 	 */
   2745   1.1       cgd 	if (c->needconnect && !connected) {
   2746   1.1       cgd 	    printf("?Need to be connected first for %s.\n", margv[0]);
   2747  1.26    itojun 	    continue;
   2748  1.39    itojun 	}
   2749  1.39    itojun 	(*c->handler)(margc, margv);
   2750  1.39    itojun     }
   2751  1.39    itojun     fclose(rcfile);
   2752   1.1       cgd }
   2753   1.1       cgd 
   2754   1.1       cgd /*
   2755   1.1       cgd  * Source route is handed in as
   2756   1.1       cgd  *	[!]@hop1 (at) hop2...@dst
   2757   1.1       cgd  *
   2758   1.1       cgd  * If the leading ! is present, it is a strict source route, otherwise it is
   2759  1.39    itojun  * assmed to be a loose source route.  Note that leading ! is effective
   2760  1.39    itojun  * only for IPv4 case.
   2761  1.39    itojun  *
   2762   1.1       cgd  * We fill in the source route option as
   2763  1.39    itojun  *	hop1,hop2,hop3...dest
   2764  1.39    itojun  * and return a pointer to hop1, which will
   2765   1.1       cgd  * be the address to connect() to.
   2766  1.39    itojun  *
   2767  1.39    itojun  * Arguments:
   2768   1.1       cgd  *	ai:	The address (by struct addrinfo) for the final destination.
   2769   1.1       cgd  *
   2770   1.1       cgd  *	arg:	Pointer to route list to decipher
   2771   1.1       cgd  *
   2772   1.1       cgd  *	cpp: 	Pointer to a pointer, so that sourceroute() can return
   2773  1.39    itojun  *		the address of result buffer (statically alloc'ed).
   2774   1.1       cgd  *
   2775  1.39    itojun  *	protop/optp:
   2776  1.39    itojun  *		Pointer to an integer.  The pointed variable
   2777  1.39    itojun  *	lenp:	pointer to an integer that contains the
   2778  1.39    itojun  *		length of *cpp if *cpp != NULL.
   2779  1.39    itojun  *
   2780  1.39    itojun  * Return values:
   2781  1.39    itojun  *
   2782  1.39    itojun  *	Returns the length of the option pointed to by *cpp.  If the
   2783   1.1       cgd  *	return value is -1, there was a syntax error in the
   2784  1.39    itojun  *	option, either arg contained unknown characters or too many hosts,
   2785  1.39    itojun  *	or hostname cannot be resolved.
   2786  1.10       jtk  *
   2787  1.39    itojun  *	The caller needs to pass return value (len), *cpp, *protop and *optp
   2788  1.10       jtk  *	to setsockopt(2).
   2789   1.1       cgd  *
   2790  1.26    itojun  *	*cpp:	Points to the result buffer.  The region is statically
   2791  1.26    itojun  *		allocated by the function.
   2792  1.26    itojun  *
   2793  1.24   mycroft  *	*protop:
   2794  1.26    itojun  *		protocol # to be passed to setsockopt(2).
   2795  1.26    itojun  *
   2796  1.26    itojun  *	*optp:	option # to be passed to setsockopt(2).
   2797   1.1       cgd  *
   2798   1.5       cgd  */
   2799   1.5       cgd int
   2800   1.5       cgd sourceroute(ai, arg, cpp, protop, optp)
   2801   1.1       cgd 	struct addrinfo *ai;
   2802  1.26    itojun 	char *arg;
   2803  1.26    itojun 	char **cpp;
   2804  1.26    itojun 	int *protop;
   2805   1.1       cgd 	int *optp;
   2806  1.26    itojun {
   2807  1.26    itojun #ifdef	sysV88
   2808  1.26    itojun 	static IOPTN ipopt;
   2809  1.26    itojun #endif
   2810  1.26    itojun 	char *cp, *cp2, *lsrp, *lsrep;
   2811  1.26    itojun 	struct addrinfo hints, *res;
   2812   1.1       cgd 	int len, error;
   2813   1.1       cgd 	struct sockaddr_in *sin;
   2814  1.26    itojun 	register char c;
   2815   1.1       cgd 	static char lsr[44];
   2816  1.26    itojun #ifdef INET6
   2817  1.26    itojun 	struct cmsghdr *cmsg;
   2818   1.1       cgd 	struct sockaddr_in6 *sin6;
   2819   1.1       cgd 	static char rhbuf[1024];
   2820   1.1       cgd #endif
   2821  1.26    itojun 
   2822  1.41     blymn 	/*
   2823  1.41     blymn 	 * Verify the arguments.
   2824  1.41     blymn 	 */
   2825  1.41     blymn 	if (cpp == NULL)
   2826  1.41     blymn 		return -1;
   2827  1.41     blymn 
   2828  1.26    itojun 	cp = arg;
   2829  1.26    itojun 
   2830  1.26    itojun 	*cpp = NULL;
   2831  1.26    itojun 
   2832  1.26    itojun 	  /* init these just in case.... */
   2833  1.26    itojun 	lsrp = NULL;
   2834  1.26    itojun 	lsrep = NULL;
   2835  1.26    itojun 	cmsg = NULL;
   2836  1.26    itojun 
   2837  1.26    itojun 	switch (ai->ai_family) {
   2838   1.5       cgd 	case AF_INET:
   2839  1.26    itojun 		lsrp = lsr;
   2840  1.26    itojun 		lsrep = lsrp + sizeof(lsr);
   2841  1.26    itojun 
   2842  1.26    itojun 		/*
   2843  1.26    itojun 		 * Next, decide whether we have a loose source
   2844   1.5       cgd 		 * route or a strict source route, and fill in
   2845  1.26    itojun 		 * the begining of the option.
   2846  1.26    itojun 		 */
   2847  1.26    itojun #ifndef	sysV88
   2848  1.26    itojun 		if (*cp == '!') {
   2849  1.26    itojun 			cp++;
   2850   1.5       cgd 			*lsrp++ = IPOPT_SSRR;
   2851  1.26    itojun 		} else
   2852  1.26    itojun 			*lsrp++ = IPOPT_LSRR;
   2853   1.5       cgd #else
   2854  1.26    itojun 		if (*cp == '!') {
   2855  1.26    itojun 			cp++;
   2856  1.26    itojun 			ipopt.io_type = IPOPT_SSRR;
   2857  1.26    itojun 		} else
   2858  1.26    itojun 			ipopt.io_type = IPOPT_LSRR;
   2859  1.26    itojun #endif
   2860  1.26    itojun 		if (*cp != '@')
   2861  1.26    itojun 			return -1;
   2862  1.26    itojun #ifndef	sysV88
   2863  1.26    itojun 		lsrp++;		/* skip over length, we'll fill it in later */
   2864  1.26    itojun 		*lsrp++ = 4;
   2865  1.26    itojun #endif
   2866  1.26    itojun 		cp++;
   2867  1.26    itojun 		*protop = IPPROTO_IP;
   2868  1.26    itojun 		*optp = IP_OPTIONS;
   2869  1.26    itojun 		break;
   2870   1.5       cgd #ifdef INET6
   2871  1.26    itojun 	case AF_INET6:
   2872  1.26    itojun 		cmsg = inet6_rthdr_init(rhbuf, IPV6_RTHDR_TYPE_0);
   2873  1.26    itojun 		if (*cp != '@')
   2874   1.1       cgd 			return -1;
   2875  1.26    itojun 		cp++;
   2876  1.26    itojun 		*protop = IPPROTO_IPV6;
   2877  1.26    itojun 		*optp = IPV6_PKTOPTIONS;
   2878   1.1       cgd 		break;
   2879   1.1       cgd #endif
   2880   1.1       cgd 	default:
   2881   1.1       cgd 		return -1;
   2882  1.15  christos 	}
   2883   1.1       cgd 
   2884   1.1       cgd 	memset(&hints, 0, sizeof(hints));
   2885   1.1       cgd 	hints.ai_family = ai->ai_family;
   2886   1.1       cgd 	hints.ai_socktype = SOCK_STREAM;
   2887   1.1       cgd 
   2888   1.1       cgd 	for (c = 0;;) {
   2889  1.26    itojun 		if (c == ':')
   2890  1.26    itojun 			cp2 = 0;
   2891  1.26    itojun 		else for (cp2 = cp; (c = *cp2) != '\0'; cp2++) {
   2892   1.1       cgd 			if (c == ',') {
   2893  1.26    itojun 				*cp2++ = '\0';
   2894  1.26    itojun 				if (*cp2 == '@')
   2895  1.26    itojun 					cp2++;
   2896   1.1       cgd 			} else if (c == '@') {
   2897   1.1       cgd 				*cp2++ = '\0';
   2898   1.1       cgd 			}
   2899   1.1       cgd #if 0	/*colon conflicts with IPv6 address*/
   2900   1.1       cgd 			else if (c == ':') {
   2901   1.1       cgd 				*cp2++ = '\0';
   2902  1.26    itojun 			}
   2903  1.26    itojun #endif
   2904  1.26    itojun 			else
   2905  1.26    itojun 				continue;
   2906  1.26    itojun 			break;
   2907  1.26    itojun 		}
   2908  1.26    itojun 		if (!c)
   2909  1.26    itojun 			cp2 = 0;
   2910  1.26    itojun 
   2911  1.26    itojun 		error = getaddrinfo(cp, NULL, &hints, &res);
   2912  1.26    itojun 		if (error) {
   2913  1.26    itojun 			fprintf(stderr, "%s: %s\n", cp, gai_strerror(error));
   2914  1.26    itojun 			return -1;
   2915  1.26    itojun 		}
   2916  1.26    itojun 		if (ai->ai_family != res->ai_family) {
   2917  1.26    itojun 			freeaddrinfo(res);
   2918  1.26    itojun 			return -1;
   2919  1.26    itojun 		}
   2920  1.26    itojun 		if (ai->ai_family == AF_INET) {
   2921  1.26    itojun 			/*
   2922  1.26    itojun 			 * Check to make sure there is space for address
   2923  1.26    itojun 			 */
   2924  1.26    itojun 			if (lsrp + 4 > lsrep) {
   2925  1.26    itojun 				freeaddrinfo(res);
   2926  1.26    itojun 				return -1;
   2927  1.26    itojun 			}
   2928  1.26    itojun 			sin = (struct sockaddr_in *)res->ai_addr;
   2929   1.1       cgd 			memcpy(lsrp, &sin->sin_addr, sizeof(struct in_addr));
   2930  1.26    itojun 			lsrp += sizeof(struct in_addr);
   2931  1.26    itojun 		}
   2932  1.26    itojun #ifdef INET6
   2933   1.1       cgd 		else if (ai->ai_family == AF_INET6) {
   2934  1.26    itojun 			sin6 = (struct sockaddr_in6 *)res->ai_addr;
   2935   1.1       cgd 			inet6_rthdr_add(cmsg, &sin6->sin6_addr,
   2936   1.1       cgd 				IPV6_RTHDR_LOOSE);
   2937   1.1       cgd 		}
   2938   1.1       cgd #endif
   2939  1.26    itojun 		else {
   2940  1.26    itojun 			freeaddrinfo(res);
   2941  1.26    itojun 			return -1;
   2942   1.1       cgd 		}
   2943  1.26    itojun 		freeaddrinfo(res);
   2944  1.26    itojun 		if (cp2)
   2945  1.26    itojun 			cp = cp2;
   2946  1.26    itojun 		else
   2947   1.5       cgd 			break;
   2948  1.26    itojun 	}
   2949  1.26    itojun 	if (ai->ai_family == AF_INET) {
   2950  1.26    itojun 		/* record the last hop */
   2951  1.26    itojun 		if (lsrp + 4 > lsrep)
   2952  1.26    itojun 			return -1;
   2953  1.26    itojun 		sin = (struct sockaddr_in *)ai->ai_addr;
   2954  1.26    itojun 		memcpy(lsrp, &sin->sin_addr, sizeof(struct in_addr));
   2955  1.26    itojun 		lsrp += sizeof(struct in_addr);
   2956  1.26    itojun #ifndef	sysV88
   2957  1.26    itojun 		lsr[IPOPT_OLEN] = lsrp - lsr;
   2958  1.26    itojun 		if (lsr[IPOPT_OLEN] <= 7 || lsr[IPOPT_OLEN] > 40)
   2959  1.26    itojun 			return -1;
   2960   1.1       cgd 		*lsrp++ = IPOPT_NOP;	/*32bit word align*/
   2961  1.26    itojun 		len = lsrp - lsr;
   2962  1.26    itojun 		*cpp = lsr;
   2963  1.26    itojun #else
   2964  1.26    itojun 		ipopt.io_len = lsrp - lsr;
   2965  1.26    itojun 		if (ipopt.io_len <= 5)	/*is 3 better?*/
   2966   1.5       cgd 			return -1;
   2967   1.5       cgd 		*cpp = (char 8)&ipopt;
   2968  1.26    itojun #endif
   2969  1.26    itojun 	}
   2970  1.26    itojun #ifdef INET6
   2971   1.1       cgd 	else if (ai->ai_family == AF_INET6) {
   2972                 		inet6_rthdr_lasthop(cmsg, IPV6_RTHDR_LOOSE);
   2973                 		len = cmsg->cmsg_len;
   2974                 		*cpp = rhbuf;
   2975                 	}
   2976                 #endif
   2977                 	else
   2978                 		return -1;
   2979                 	return len;
   2980                 }
   2981