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