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