command.c revision 26940 
1/*
2 *		PPP User command processing module
3 *
4 *	    Written by Toshiharu OHNO (tony-o@iij.ad.jp)
5 *
6 *   Copyright (C) 1993, Internet Initiative Japan, Inc. All rights reserverd.
7 *
8 * Redistribution and use in source and binary forms are permitted
9 * provided that the above copyright notice and this paragraph are
10 * duplicated in all such forms and that any documentation,
11 * advertising materials, and other materials related to such
12 * distribution and use acknowledge that the software was developed
13 * by the Internet Initiative Japan, Inc.  The name of the
14 * IIJ may not be used to endorse or promote products derived
15 * from this software without specific prior written permission.
16 * THIS SOFTWARE IS PROVIDED ``AS IS'' AND WITHOUT ANY EXPRESS OR
17 * IMPLIED WARRANTIES, INCLUDING, WITHOUT LIMITATION, THE IMPLIED
18 * WARRANTIES OF MERCHANTIBILITY AND FITNESS FOR A PARTICULAR PURPOSE.
19 *
20 * $Id: command.c,v 1.62 1997/06/25 02:04:35 brian Exp $
21 *
22 */
23#include <sys/types.h>
24#include <ctype.h>
25#include <termios.h>
26#include <sys/wait.h>
27#include <time.h>
28#include <netdb.h>
29#include <sys/socket.h>
30#include <netinet/in.h>
31#include <arpa/inet.h>
32#include <net/route.h>
33#include <paths.h>
34#include <alias.h>
35#include <fcntl.h>
36#include <errno.h>
37#include "fsm.h"
38#include "phase.h"
39#include "lcp.h"
40#include "ipcp.h"
41#include "modem.h"
42#include "filter.h"
43#include "command.h"
44#include "alias_cmd.h"
45#include "hdlc.h"
46#include "loadalias.h"
47#include "vars.h"
48#include "systems.h"
49#include "chat.h"
50#include "os.h"
51#include "timeout.h"
52#include "server.h"
53
54extern void Cleanup(), TtyTermMode(), PacketMode();
55extern int  EnableCommand(), DisableCommand(), DisplayCommand();
56extern int  AcceptCommand(), DenyCommand();
57static int  AliasCommand();
58extern int  LocalAuthCommand();
59extern int  LoadCommand(), SaveCommand();
60extern int  ChangeParity(char *);
61extern int  SelectSystem();
62extern int  ShowRoute();
63extern void TtyOldMode(), TtyCommandMode();
64extern struct pppvars pppVars;
65extern struct cmdtab const SetCommands[];
66
67extern char *IfDevName;
68
69struct in_addr ifnetmask;
70int randinit;
71
72static int ShowCommand(), TerminalCommand(), QuitCommand();
73static int CloseCommand(), DialCommand(), DownCommand();
74static int SetCommand(), AddCommand(), DeleteCommand();
75static int ShellCommand();
76
77static int
78HelpCommand(list, argc, argv, plist)
79struct cmdtab *list;
80int argc;
81char **argv;
82struct cmdtab *plist;
83{
84  struct cmdtab *cmd;
85  int n;
86
87  if (!VarTerm)
88    return 0;
89
90  if (argc > 0) {
91    for (cmd = plist; cmd->name; cmd++)
92      if (strcasecmp(cmd->name, *argv) == 0 && (cmd->lauth & VarLocalAuth)) {
93        fprintf(VarTerm, "%s\n", cmd->syntax);
94        return 0;
95      }
96
97    return -1;
98  }
99
100  n = 0;
101  for (cmd = plist; cmd->func; cmd++)
102    if (cmd->name && (cmd->lauth & VarLocalAuth)) {
103      fprintf(VarTerm, "  %-9s: %-20s\n", cmd->name, cmd->helpmes);
104      n++;
105    }
106
107  if (n & 1)
108    fprintf(VarTerm, "\n");
109
110  return 0;
111}
112
113int
114IsInteractive()
115{
116  char *mes = NULL;
117
118  if (mode & MODE_DDIAL)
119    mes = "Working in dedicated dial mode.";
120  else if (mode & MODE_BACKGROUND)
121    mes = "Working in background mode.";
122  else if (mode & MODE_AUTO)
123    mes = "Working in auto mode.";
124  else if (mode & MODE_DIRECT)
125    mes = "Working in direct mode.";
126  else if (mode & MODE_DEDICATED)
127    mes = "Working in dedicated mode.";
128  if (mes) {
129    if (VarTerm)
130      fprintf(VarTerm, "%s\n", mes);
131    return 0;
132  }
133  return 1;
134}
135
136static int
137DialCommand(cmdlist, argc, argv)
138struct cmdtab *cmdlist;
139int argc;
140char **argv;
141{
142  int tries;
143  int res;
144
145  if (LcpFsm.state > ST_CLOSED) {
146    if (VarTerm)
147      fprintf(VarTerm, "LCP state is [%s]\n", StateNames[LcpFsm.state]);
148    return 0;
149  }
150
151  if (!IsInteractive())
152    return(1);
153
154  if (argc > 0) {
155    if (SelectSystem(*argv, CONFFILE) < 0) {
156      if (VarTerm)
157        fprintf(VarTerm, "%s: not found.\n", *argv);
158      return -1;
159    }
160  }
161
162  tries = 0;
163  do {
164    if (VarTerm)
165      fprintf(VarTerm, "Dial attempt %u of %d\n", ++tries, VarDialTries);
166    modem = OpenModem(mode);
167    if (modem < 0) {
168      if (VarTerm)
169        fprintf(VarTerm, "Failed to open modem.\n");
170      break;
171    }
172    if ((res = DialModem()) == EX_DONE) {
173      sleep(1);
174      ModemTimeout();
175      PacketMode();
176      break;
177    } else if (res == EX_SIG)
178      return 1;
179  } while (VarDialTries == 0 || tries < VarDialTries);
180
181  return 0;
182}
183
184static int
185ShellCommand(cmdlist, argc, argv)
186struct cmdtab *cmdlist;
187int argc;
188char **argv;
189{
190  const char *shell;
191  pid_t shpid;
192  FILE *oVarTerm;
193
194#ifdef SHELL_ONLY_INTERACTIVELY
195  /* we're only allowed to shell when we run ppp interactively */
196  if (mode != MODE_INTER) {
197    LogPrintf(LogWARN, "Can only start a shell in interactive mode\n");
198    return 1;
199  }
200#endif
201#ifdef NO_SHELL_IN_AUTO_INTERACTIVE
202  /*
203   * we want to stop shell commands when we've got a telnet connection
204   * to an auto mode ppp
205   */
206  if ((mode & (MODE_AUTO|MODE_INTER)) == (MODE_AUTO|MODE_INTER)) {
207    LogPrintf(LogWARN,  "Shell is not allowed interactively in auto mode\n");
208    return 1;
209  }
210#endif
211
212  if(argc == 0 && !(mode & MODE_INTER)) {
213    LogPrintf(LogWARN, "Can only start an interactive shell in"
214	      " interactive mode\n");
215    return 1;
216  }
217
218  if((shell = getenv("SHELL")) == 0)
219    shell = _PATH_BSHELL;
220
221  if((shpid = fork()) == 0) {
222     int dtablesize, i, fd;
223
224     if (VarTerm)
225       fd = fileno(VarTerm);
226     else if ((fd = open("/dev/null", O_RDWR)) == -1) {
227       LogPrintf(LogALERT, "Failed to open /dev/null: %s\n", strerror(errno));
228       exit(1);
229     }
230
231     for (i = 0; i < 3; i++)
232       dup2(fd, i);
233
234     if (fd > 2)
235       if (VarTerm) {
236	 oVarTerm = VarTerm;
237	 VarTerm = 0;
238         if (oVarTerm && oVarTerm != stdout)
239           fclose(oVarTerm);
240       } else
241         close(fd);
242
243     for (dtablesize = getdtablesize(), i = 3; i < dtablesize; i++)
244	(void)close(i);
245
246     /*
247      * We are running setuid, we should change to
248      * real user for avoiding security problems.
249      */
250     if (setgid(getgid()) < 0) {
251        LogPrintf(LogERROR, "setgid: %s\n", strerror(errno));
252	exit(1);
253     }
254     if (setuid(getuid()) < 0) {
255        LogPrintf(LogERROR, "setuid: %s\n", strerror(errno));
256	exit(1);
257     }
258     TtyOldMode();
259     if(argc > 0) {
260       /* substitute pseudo args */
261       for (i=1; i<argc; i++) {
262         if (strcasecmp(argv[i], "HISADDR") == 0) {
263           argv[i] = strdup(inet_ntoa(IpcpInfo.his_ipaddr));
264         }
265         if (strcasecmp(argv[i], "INTERFACE") == 0) {
266           argv[i] = strdup(IfDevName);
267         }
268         if (strcasecmp(argv[i], "MYADDR") == 0) {
269           argv[i] = strdup(inet_ntoa(IpcpInfo.want_ipaddr));
270         }
271       }
272       (void)execvp(argv[0], argv);
273     }
274     else
275       (void)execl(shell, shell, NULL);
276
277     LogPrintf(LogWARN, "exec() of %s failed\n", argc > 0 ? argv[0] : shell);
278     exit(255);
279  }
280
281  if( shpid == (pid_t)-1 ) {
282    LogPrintf(LogERROR, "Fork failed: %s\n", strerror(errno));
283  } else {
284    int status;
285    (void)waitpid(shpid, &status, 0);
286  }
287
288  TtyCommandMode(1);
289
290  return(0);
291}
292
293struct cmdtab const Commands[] = {
294  { "accept",  NULL,    AcceptCommand,	LOCAL_AUTH,
295  	"accept option request",	"accept option .."},
296  { "add",     NULL,	AddCommand,	LOCAL_AUTH,
297	"add route",			"add dest mask gateway"},
298  { "close",   NULL,    CloseCommand,	LOCAL_AUTH,
299	"Close connection",		"close"},
300  { "delete",  NULL,    DeleteCommand,	LOCAL_AUTH,
301	"delete route",                 "delete ALL | dest [gateway [mask]]"},
302  { "deny",    NULL,    DenyCommand,	LOCAL_AUTH,
303  	"Deny option request",		"deny option .."},
304  { "dial",    "call",  DialCommand,	LOCAL_AUTH,
305  	"Dial and login",		"dial|call [remote]"},
306  { "disable", NULL,    DisableCommand,	LOCAL_AUTH,
307  	"Disable option",		"disable option .."},
308  { "display", NULL,    DisplayCommand,	LOCAL_AUTH,
309  	"Display option configs",	"display"},
310  { "enable",  NULL,    EnableCommand,	LOCAL_AUTH,
311  	"Enable option",		"enable option .."},
312  { "passwd",  NULL,	LocalAuthCommand,LOCAL_NO_AUTH,
313  	"Password for manipulation", "passwd option .."},
314  { "load",    NULL,    LoadCommand,	LOCAL_AUTH,
315  	"Load settings",		"load [remote]"},
316  { "save",    NULL,    SaveCommand,	LOCAL_AUTH,
317  	"Save settings", "save"},
318  { "set",     "setup", SetCommand,	LOCAL_AUTH,
319  	"Set parameters",  "set[up] var value"},
320  { "shell",   "!",     ShellCommand,   LOCAL_AUTH,
321	"Run a subshell",  "shell|! [sh command]"},
322  { "show",    NULL,    ShowCommand,	LOCAL_AUTH,
323  	"Show status and statictics", "show var"},
324  { "term",    NULL,    TerminalCommand,LOCAL_AUTH,
325  	"Enter to terminal mode", "term"},
326  { "alias",   NULL,    AliasCommand,   LOCAL_AUTH,
327        "alias control",        "alias option [yes|no]"},
328  { "quit",    "bye",   QuitCommand,	LOCAL_AUTH | LOCAL_NO_AUTH,
329	"Quit PPP program", "quit|bye [all]"},
330  { "help",    "?",     HelpCommand,	LOCAL_AUTH | LOCAL_NO_AUTH,
331	"Display this message", "help|? [command]", (void *)Commands },
332  { NULL,      "down",  DownCommand,	LOCAL_AUTH,
333  	"Generate down event",		"down"},
334  { NULL,      NULL,    NULL },
335};
336
337extern int ReportCcpStatus();
338extern int ReportLcpStatus();
339extern int ReportIpcpStatus();
340extern int ReportProtStatus();
341extern int ReportCompress();
342extern int ShowModemStatus();
343extern int ReportHdlcStatus();
344extern int ShowMemMap();
345
346static int ShowLogLevel()
347{
348  int i;
349
350  if (!VarTerm)
351    return 0;
352  fprintf(VarTerm, "Log:");
353  for (i = LogMIN; i < LogMAXCONF; i++) {
354    if (LogIsKept(i))
355      fprintf(VarTerm, " %s", LogName(i));
356  }
357  fprintf(VarTerm, "\n");
358
359  return 0;
360}
361
362static int ShowEscape()
363{
364  int code, bit;
365
366  if (!VarTerm)
367    return 0;
368  if (EscMap[32]) {
369    for (code = 0; code < 32; code++)
370      if (EscMap[code])
371        for (bit = 0; bit < 8; bit++)
372          if (EscMap[code] & (1<<bit))
373            fprintf(VarTerm, " 0x%02x", (code << 3) + bit);
374    fprintf(VarTerm, "\n");
375  }
376  return 1;
377}
378
379static int ShowTimeout()
380{
381  if (!VarTerm)
382    return 0;
383  fprintf(VarTerm, " Idle Timer: %d secs   LQR Timer: %d secs"
384          "   Retry Timer: %d secs\n", VarIdleTimeout, VarLqrTimeout,
385          VarRetryTimeout);
386  return 1;
387}
388
389static int ShowAuthKey()
390{
391  if (!VarTerm)
392    return 0;
393  fprintf(VarTerm, "AuthName = %s\n", VarAuthName);
394  fprintf(VarTerm, "AuthKey  = %s\n", VarAuthKey);
395  return 1;
396}
397
398static int ShowVersion()
399{
400  extern char VarVersion[];
401  extern char VarLocalVersion[];
402
403  if (!VarTerm)
404    return 0;
405  fprintf(VarTerm, "%s - %s \n", VarVersion, VarLocalVersion);
406  return 1;
407}
408
409static int ShowInitialMRU()
410{
411  if (!VarTerm)
412    return 0;
413  fprintf(VarTerm, " Initial MRU: %ld\n", VarMRU);
414  return 1;
415}
416
417static int ShowPreferredMTU()
418{
419  if (!VarTerm)
420    return 0;
421  if (VarPrefMTU)
422    fprintf(VarTerm, " Preferred MTU: %ld\n", VarPrefMTU);
423  else
424    fprintf(VarTerm, " Preferred MTU: unspecified\n");
425  return 1;
426}
427
428static int ShowReconnect()
429{
430  if (!VarTerm)
431    return 0;
432  fprintf(VarTerm, " Reconnect Timer:  %d,  %d tries\n",
433         VarReconnectTimer, VarReconnectTries);
434  return 1;
435}
436
437static int ShowRedial()
438{
439  if (!VarTerm)
440    return 0;
441  fprintf(VarTerm, " Redial Timer: ");
442
443  if (VarRedialTimeout >= 0) {
444    fprintf(VarTerm, " %d seconds, ", VarRedialTimeout);
445  }
446  else {
447    fprintf(VarTerm, " Random 0 - %d seconds, ", REDIAL_PERIOD);
448  }
449
450  fprintf(VarTerm, " Redial Next Timer: ");
451
452  if (VarRedialNextTimeout >= 0) {
453    fprintf(VarTerm, " %d seconds, ", VarRedialNextTimeout);
454  }
455  else {
456    fprintf(VarTerm, " Random 0 - %d seconds, ", REDIAL_PERIOD);
457  }
458
459  if (VarDialTries)
460      fprintf(VarTerm, "%d dial tries", VarDialTries);
461
462  fprintf(VarTerm, "\n");
463
464  return 1;
465}
466
467#ifndef NOMSEXT
468static int ShowMSExt()
469{
470  if (!VarTerm)
471    return 0;
472  fprintf(VarTerm, " MS PPP extention values \n" );
473  fprintf(VarTerm, "   Primary NS     : %s\n", inet_ntoa( ns_entries[0] ));
474  fprintf(VarTerm, "   Secondary NS   : %s\n", inet_ntoa( ns_entries[1] ));
475  fprintf(VarTerm, "   Primary NBNS   : %s\n", inet_ntoa( nbns_entries[0] ));
476  fprintf(VarTerm, "   Secondary NBNS : %s\n", inet_ntoa( nbns_entries[1] ));
477  return 1;
478}
479#endif
480
481extern int ShowIfilter(), ShowOfilter(), ShowDfilter(), ShowAfilter();
482
483struct cmdtab const ShowCommands[] = {
484  { "afilter",  NULL,     ShowAfilter,		LOCAL_AUTH,
485	"Show keep Alive filters", "show afilter option .."},
486  { "auth",     NULL,     ShowAuthKey,		LOCAL_AUTH,
487	"Show auth name/key", "show auth"},
488  { "ccp",      NULL,     ReportCcpStatus,	LOCAL_AUTH,
489	"Show CCP status", "show cpp"},
490  { "compress", NULL,     ReportCompress,	LOCAL_AUTH,
491	"Show compression statictics", "show compress"},
492  { "dfilter",  NULL,     ShowDfilter,		LOCAL_AUTH,
493	"Show Demand filters", "show dfilteroption .."},
494  { "escape",   NULL,     ShowEscape,		LOCAL_AUTH,
495	"Show escape characters", "show escape"},
496  { "hdlc",	NULL,	  ReportHdlcStatus,	LOCAL_AUTH,
497	"Show HDLC error summary", "show hdlc"},
498  { "ifilter",  NULL,     ShowIfilter,		LOCAL_AUTH,
499	"Show Input filters", "show ifilter option .."},
500  { "ipcp",     NULL,     ReportIpcpStatus,	LOCAL_AUTH,
501	"Show IPCP status", "show ipcp"},
502  { "lcp",      NULL,     ReportLcpStatus,	LOCAL_AUTH,
503	"Show LCP status", "show lcp"},
504  { "log",	NULL,	  ShowLogLevel,	LOCAL_AUTH,
505	"Show current log level", "show log"},
506  { "mem",      NULL,     ShowMemMap,		LOCAL_AUTH,
507	"Show memory map", "show mem"},
508  { "modem",    NULL,     ShowModemStatus,	LOCAL_AUTH,
509	"Show modem setups", "show modem"},
510  { "mru",      NULL,     ShowInitialMRU,	LOCAL_AUTH,
511	"Show Initial MRU", "show mru"},
512  { "mtu",      NULL,     ShowPreferredMTU,	LOCAL_AUTH,
513	"Show Preferred MTU", "show mtu"},
514  { "ofilter",  NULL,     ShowOfilter,		LOCAL_AUTH,
515	"Show Output filters", "show ofilter option .."},
516  { "proto",    NULL,     ReportProtStatus,	LOCAL_AUTH,
517	"Show protocol summary", "show proto"},
518  { "reconnect",NULL,	  ShowReconnect,	LOCAL_AUTH,
519	"Show Reconnect timer,tries", "show reconnect"},
520  { "redial",   NULL,	  ShowRedial,		LOCAL_AUTH,
521	"Show Redial timeout value", "show redial"},
522  { "route",    NULL,     ShowRoute,		LOCAL_AUTH,
523	"Show routing table", "show route"},
524  { "timeout",  NULL,	  ShowTimeout,		LOCAL_AUTH,
525	"Show Idle timeout value", "show timeout"},
526#ifndef NOMSEXT
527  { "msext", 	NULL,	  ShowMSExt,		LOCAL_AUTH,
528	"Show MS PPP extentions", "show msext"},
529#endif
530  { "version",  NULL,	  ShowVersion,		LOCAL_NO_AUTH | LOCAL_AUTH,
531	"Show version string", "show version"},
532  { "help",     "?",      HelpCommand,		LOCAL_NO_AUTH | LOCAL_AUTH,
533	"Display this message", "show help|? [command]", (void *)ShowCommands},
534  { NULL,       NULL,     NULL },
535};
536
537struct cmdtab *
538FindCommand(cmds, str, pmatch)
539struct cmdtab *cmds;
540char *str;
541int *pmatch;
542{
543  int nmatch;
544  int len;
545  struct cmdtab *found;
546
547  found = NULL;
548  len = strlen(str);
549  nmatch = 0;
550  while (cmds->func) {
551    if (cmds->name && strncasecmp(str, cmds->name, len) == 0) {
552      if (cmds->name[len] == '\0') {
553        *pmatch = 1;
554        return cmds;
555      }
556      nmatch++;
557      found = cmds;
558    } else if(cmds->alias && strncasecmp(str, cmds->alias, len) == 0) {
559      if (cmds->alias[len] == '\0') {
560        *pmatch = 1;
561        return cmds;
562      }
563      nmatch++;
564      found = cmds;
565    }
566    cmds++;
567  }
568  *pmatch = nmatch;
569  return found;
570}
571
572int
573FindExec(cmdlist, argc, argv)
574struct cmdtab *cmdlist;
575int argc;
576char **argv;
577{
578  struct cmdtab *cmd;
579  int val = 1;
580  int nmatch;
581
582  cmd = FindCommand(cmdlist, *argv, &nmatch);
583  if (nmatch > 1)
584    LogPrintf(LogWARN, "%s: Ambiguous command\n", *argv);
585  else if (cmd && ( cmd->lauth & VarLocalAuth ) )
586    val = (cmd->func)(cmd, --argc, ++argv, cmd->args);
587  else
588    LogPrintf(LogWARN, "%s: Invalid command\n", *argv);
589
590  if (val == -1)
591    LogPrintf(LogWARN, "Usage: %s\n", cmd->syntax);
592  else if(val)
593    LogPrintf(LogCOMMAND, "%s: Failed %d\n", *argv, val);
594
595  return val;
596}
597
598int aft_cmd = 1;
599extern int TermMode;
600
601void
602Prompt()
603{
604  char *pconnect, *pauth;
605
606  if (!(mode & MODE_INTER) || !VarTerm || TermMode)
607    return;
608
609  if (!aft_cmd)
610    fprintf(VarTerm, "\n");
611  else
612    aft_cmd = 0;
613
614  if ( VarLocalAuth == LOCAL_AUTH )
615    pauth = " ON ";
616  else
617    pauth = " on ";
618  if (IpcpFsm.state == ST_OPENED && phase == PHASE_NETWORK)
619    pconnect = "PPP";
620  else
621    pconnect = "ppp";
622  fprintf(VarTerm, "%s%s%s> ", pconnect, pauth, VarShortHost);
623  fflush(VarTerm);
624}
625
626void
627DecodeCommand(buff, nb, prompt)
628char *buff;
629int nb;
630int prompt;
631{
632  char *vector[20];
633  char **argv;
634  int argc;
635  char *cp;
636
637  if (nb > 0) {
638    cp = buff + strcspn(buff, "\r\n");
639    if (cp)
640      *cp = '\0';
641    argc = MakeArgs(buff, vector, VECSIZE(vector));
642    argv = vector;
643
644    if (argc > 0)
645      FindExec(Commands, argc, argv);
646  }
647  if (prompt)
648    Prompt();
649}
650
651static int
652ShowCommand(list, argc, argv)
653struct cmdtab *list;
654int argc;
655char **argv;
656{
657  if (argc > 0)
658    FindExec(ShowCommands, argc, argv);
659  else if (VarTerm)
660    fprintf(VarTerm, "Use ``show ?'' to get a list.\n");
661  else
662    LogPrintf(LogWARN, "show command must have arguments\n");
663
664  return 0;
665}
666
667static int
668TerminalCommand()
669{
670  if (LcpFsm.state > ST_CLOSED) {
671    if (VarTerm)
672      fprintf(VarTerm, "LCP state is [%s]\n", StateNames[LcpFsm.state]);
673    return 1;
674  }
675  if (!IsInteractive())
676    return(1);
677  modem = OpenModem(mode);
678  if (modem < 0) {
679    if (VarTerm)
680      fprintf(VarTerm, "Failed to open modem.\n");
681    return(1);
682  }
683  if (VarTerm) {
684    fprintf(VarTerm, "Enter to terminal mode.\n");
685    fprintf(VarTerm, "Type `~?' for help.\n");
686  }
687  TtyTermMode();
688  return(0);
689}
690
691static int
692QuitCommand(list, argc, argv)
693struct cmdtab *list;
694int argc;
695char **argv;
696{
697  FILE *oVarTerm;
698
699  if (mode & (MODE_DIRECT|MODE_DEDICATED|MODE_AUTO)) {
700    if (argc > 0 && (VarLocalAuth & LOCAL_AUTH)) {
701      Cleanup(EX_NORMAL);
702      mode &= ~MODE_INTER;
703      oVarTerm = VarTerm;
704      VarTerm = 0;
705      if (oVarTerm && oVarTerm != stdout)
706        fclose(oVarTerm);
707    } else {
708      LogPrintf(LogPHASE, "Client connection closed.\n");
709      VarLocalAuth = LOCAL_NO_AUTH;
710      mode &= ~MODE_INTER;
711      oVarTerm = VarTerm;
712      VarTerm = 0;
713      if (oVarTerm && oVarTerm != stdout)
714        fclose(oVarTerm);
715      close(netfd);
716      netfd = -1;
717    }
718  } else
719    Cleanup(EX_NORMAL);
720
721  return 0;
722}
723
724static int
725CloseCommand()
726{
727  reconnect(RECON_FALSE);
728  LcpClose();
729  if (mode & MODE_BACKGROUND)
730      Cleanup(EX_NORMAL);
731  return 0;
732}
733
734static int
735DownCommand()
736{
737  LcpDown();
738  return 0;
739}
740
741static int
742SetModemSpeed(list, argc, argv)
743struct cmdtab *list;
744int argc;
745char **argv;
746{
747  int speed;
748
749  if (argc > 0) {
750    if (strcmp(*argv, "sync") == 0) {
751      VarSpeed = 0;
752      return 0;
753    }
754    speed = atoi(*argv);
755    if (IntToSpeed(speed) != B0) {
756      VarSpeed = speed;
757      return 0;
758    }
759    LogPrintf(LogWARN, "%s: Invalid speed\n", *argv);
760  }
761  return -1;
762}
763
764static int
765SetReconnect(list, argc, argv)
766struct cmdtab *list;
767int argc;
768char **argv;
769{
770  if (argc == 2) {
771    VarReconnectTimer = atoi(argv[0]);
772    VarReconnectTries = atoi(argv[1]);
773    return 0;
774  }
775
776  return -1;
777}
778
779static int
780SetRedialTimeout(list, argc, argv)
781struct cmdtab *list;
782int argc;
783char **argv;
784{
785  int timeout;
786  int tries;
787  char *dot;
788
789  if (argc == 1 || argc == 2 ) {
790    if (strncasecmp(argv[0], "random", 6) == 0 &&
791	(argv[0][6] == '\0' || argv[0][6] == '.')) {
792      VarRedialTimeout = -1;
793      if (!randinit) {
794	randinit = 1;
795	srandomdev();
796      }
797    } else {
798      timeout = atoi(argv[0]);
799
800      if (timeout >= 0)
801	VarRedialTimeout = timeout;
802      else {
803	LogPrintf(LogWARN, "Invalid redial timeout\n");
804        return -1;
805      }
806    }
807
808    dot = index(argv[0],'.');
809    if (dot) {
810      if (strcasecmp(++dot, "random") == 0) {
811        VarRedialNextTimeout = -1;
812        if (!randinit) {
813          randinit = 1;
814	  srandomdev();
815        }
816      }
817      else {
818        timeout = atoi(dot);
819        if (timeout >= 0)
820          VarRedialNextTimeout = timeout;
821        else {
822          LogPrintf(LogWARN, "Invalid next redial timeout\n");
823	  return -1;
824        }
825      }
826    }
827    else
828      VarRedialNextTimeout = NEXT_REDIAL_PERIOD;   /* Default next timeout */
829
830    if (argc == 2) {
831      tries = atoi(argv[1]);
832
833      if (tries >= 0) {
834	VarDialTries = tries;
835      } else {
836	LogPrintf(LogWARN, "Invalid retry value\n");
837	return 1;
838      }
839    }
840    return 0;
841  }
842
843  return -1;
844}
845
846static int
847SetServer(list, argc, argv)
848struct cmdtab *list;
849int argc;
850char **argv;
851{
852  int res = -1;
853
854  if (argc == 1)
855    if (strcasecmp(argv[0], "none") == 0) {
856      ServerClose();
857      LogPrintf(LogPHASE, "Disabling server port.\n");
858      res = 0;
859    } else if (*argv[0] == '/')
860      res = ServerLocalOpen(argv[0]);
861    else if (strspn(argv[0], "0123456789") == strlen(argv[0]))
862      res = ServerTcpOpen(atoi(argv[0]));
863
864  return res;
865}
866
867static int
868SetModemParity(list, argc, argv)
869struct cmdtab *list;
870int argc;
871char **argv;
872{
873  return argc > 0 ? ChangeParity(*argv) : -1;
874}
875
876static int
877SetLogLevel(list, argc, argv)
878struct cmdtab *list;
879int argc;
880char **argv;
881{
882  int i;
883  int res;
884  char *arg;
885
886  res = 0;
887  if (argc == 0 || (argv[0][0] != '+' && argv[0][0] != '-'))
888    LogDiscardAll();
889  while (argc--) {
890    arg = **argv == '+' || **argv == '-' ? *argv + 1 : *argv;
891    for (i = LogMIN; i <= LogMAX; i++)
892      if (strcasecmp(arg, LogName(i)) == 0) {
893        if (**argv == '-')
894          LogDiscard(i);
895        else
896	  LogKeep(i);
897	break;
898      }
899    if (i > LogMAX) {
900      LogPrintf(LogWARN, "%s: Invalid log value\n", arg);
901      res = -1;
902    }
903    argv++;
904  }
905  return res;
906}
907
908static int
909SetEscape(list, argc, argv)
910struct cmdtab *list;
911int argc;
912char **argv;
913{
914  int code;
915
916  for (code = 0; code < 33; code++)
917    EscMap[code] = 0;
918  while (argc-- > 0) {
919    sscanf(*argv++, "%x", &code);
920    code &= 0xff;
921    EscMap[code >> 3] |= (1 << (code&7));
922    EscMap[32] = 1;
923  }
924  return 0;
925}
926
927static int
928SetInitialMRU(list, argc, argv)
929struct cmdtab *list;
930int argc;
931char **argv;
932{
933  long mru;
934  char *err;
935
936  if (argc > 0) {
937    mru = atol(*argv);
938    if (mru < MIN_MRU)
939      err = "Given MRU value (%ld) is too small.\n";
940    else if (mru > MAX_MRU)
941      err = "Given MRU value (%ld) is too big.\n";
942    else {
943      VarMRU = mru;
944      return 0;
945    }
946    LogPrintf(LogWARN, err, mru);
947  }
948
949  return -1;
950}
951
952static int
953SetPreferredMTU(list, argc, argv)
954struct cmdtab *list;
955int argc;
956char **argv;
957{
958  long mtu;
959  char *err;
960
961  if (argc > 0) {
962    mtu = atol(*argv);
963    if (mtu == 0) {
964      VarPrefMTU = 0;
965      return 0;
966    } else if (mtu < MIN_MTU)
967      err = "Given MTU value (%ld) is too small.\n";
968    else if (mtu > MAX_MTU)
969      err = "Given MTU value (%ld) is too big.\n";
970    else {
971      VarPrefMTU = mtu;
972      return 0;
973    }
974    LogPrintf(LogWARN, err, mtu);
975  }
976
977  return -1;
978}
979
980static int
981SetIdleTimeout(list, argc, argv)
982struct cmdtab *list;
983int argc;
984char **argv;
985{
986  if (argc-- > 0) {
987    VarIdleTimeout = atoi(*argv++);
988    UpdateIdleTimer();  /* If we're connected, restart the idle timer */
989    if (argc-- > 0) {
990      VarLqrTimeout = atoi(*argv++);
991      if (VarLqrTimeout < 1)
992	VarLqrTimeout = 30;
993      if (argc > 0) {
994	VarRetryTimeout = atoi(*argv);
995	if (VarRetryTimeout < 1 || VarRetryTimeout > 10)
996	  VarRetryTimeout = 3;
997      }
998    }
999    return 0;
1000  }
1001
1002  return -1;
1003}
1004
1005struct in_addr
1006GetIpAddr(cp)
1007char *cp;
1008{
1009  struct hostent *hp;
1010  struct in_addr ipaddr;
1011
1012  hp = gethostbyname(cp);
1013  if (hp && hp->h_addrtype == AF_INET)
1014    bcopy(hp->h_addr, &ipaddr, hp->h_length);
1015  else if (inet_aton(cp, &ipaddr) == 0)
1016    ipaddr.s_addr = 0;
1017  return(ipaddr);
1018}
1019
1020static int
1021SetInterfaceAddr(list, argc, argv)
1022struct cmdtab *list;
1023int argc;
1024char **argv;
1025{
1026
1027  DefMyAddress.ipaddr.s_addr = DefHisAddress.ipaddr.s_addr = 0L;
1028  if (argc > 4)
1029     return -1;
1030
1031  if (argc > 0) {
1032    if (ParseAddr(argc, argv++,
1033            &DefMyAddress.ipaddr,
1034	    &DefMyAddress.mask,
1035	    &DefMyAddress.width) == 0)
1036       return 1;
1037    if (--argc > 0) {
1038      if (ParseAddr(argc, argv++,
1039		    &DefHisAddress.ipaddr,
1040		    &DefHisAddress.mask,
1041		    &DefHisAddress.width) == 0)
1042	 return 2;
1043      if (--argc > 0) {
1044        ifnetmask = GetIpAddr(*argv);
1045    	if (--argc > 0) {
1046	   if (ParseAddr(argc, argv++,
1047			 &DefTriggerAddress.ipaddr,
1048			 &DefTriggerAddress.mask,
1049			 &DefTriggerAddress.width) == 0)
1050	      return 3;
1051	}
1052      }
1053    }
1054  }
1055  /*
1056   * For backwards compatibility, 0.0.0.0 means any address.
1057   */
1058  if (DefMyAddress.ipaddr.s_addr == 0) {
1059    DefMyAddress.mask.s_addr = 0;
1060    DefMyAddress.width = 0;
1061  }
1062  if (DefHisAddress.ipaddr.s_addr == 0) {
1063    DefHisAddress.mask.s_addr = 0;
1064    DefHisAddress.width = 0;
1065  }
1066
1067  if ((mode & MODE_AUTO) ||
1068	((mode & MODE_DEDICATED) && dstsystem)) {
1069    if (OsSetIpaddress(DefMyAddress.ipaddr, DefHisAddress.ipaddr, ifnetmask) < 0)
1070       return 4;
1071  }
1072  return 0;
1073}
1074
1075#ifndef NOMSEXT
1076
1077void
1078SetMSEXT(pri_addr, sec_addr, argc, argv)
1079struct in_addr *pri_addr;
1080struct in_addr *sec_addr;
1081int argc;
1082char **argv;
1083{
1084  int dummyint;
1085  struct in_addr dummyaddr;
1086
1087  pri_addr->s_addr = sec_addr->s_addr = 0L;
1088
1089  if( argc > 0 ) {
1090    ParseAddr(argc, argv++, pri_addr, &dummyaddr, &dummyint);
1091    if( --argc > 0 )
1092      ParseAddr(argc, argv++, sec_addr, &dummyaddr, &dummyint);
1093    else
1094      sec_addr->s_addr = pri_addr->s_addr;
1095  }
1096
1097 /*
1098  * if the primary/secondary ns entries are 0.0.0.0 we should
1099  * set them to either the localhost's ip, or the values in
1100  * /etc/resolv.conf ??
1101  *
1102  * up to you if you want to implement this...
1103  */
1104
1105}
1106
1107static int
1108SetNS(list, argc, argv)
1109struct cmdtab *list;
1110int argc;
1111char **argv;
1112{
1113  SetMSEXT(&ns_entries[0], &ns_entries[1], argc, argv);
1114  return 0;
1115}
1116
1117static int
1118SetNBNS(list, argc, argv)
1119struct cmdtab *list;
1120int argc;
1121char **argv;
1122{
1123  SetMSEXT(&nbns_entries[0], &nbns_entries[1], argc, argv);
1124  return 0;
1125}
1126
1127#endif /* MS_EXT */
1128
1129#define	VAR_AUTHKEY	0
1130#define	VAR_DIAL	1
1131#define	VAR_LOGIN	2
1132#define	VAR_AUTHNAME	3
1133#define	VAR_DEVICE	4
1134#define	VAR_ACCMAP	5
1135#define	VAR_PHONE	6
1136
1137static int
1138SetVariable(list, argc, argv, param)
1139struct cmdtab *list;
1140int argc;
1141char **argv;
1142int param;
1143{
1144  u_long map;
1145  char *arg;
1146
1147  if (argc > 0)
1148    arg = *argv;
1149  else
1150    arg = "";
1151
1152  switch (param) {
1153    case VAR_AUTHKEY:
1154      strncpy(VarAuthKey, arg, sizeof(VarAuthKey)-1);
1155      VarAuthKey[sizeof(VarAuthKey)-1] = '\0';
1156      break;
1157    case VAR_AUTHNAME:
1158      strncpy(VarAuthName, arg, sizeof(VarAuthName)-1);
1159      VarAuthName[sizeof(VarAuthName)-1] = '\0';
1160      break;
1161    case VAR_DIAL:
1162      strncpy(VarDialScript, arg, sizeof(VarDialScript)-1);
1163      VarDialScript[sizeof(VarDialScript)-1] = '\0';
1164      break;
1165    case VAR_LOGIN:
1166      strncpy(VarLoginScript, arg, sizeof(VarLoginScript)-1);
1167      VarLoginScript[sizeof(VarLoginScript)-1] = '\0';
1168      break;
1169    case VAR_DEVICE:
1170      CloseModem();
1171      strncpy(VarDevice, arg, sizeof(VarDevice)-1);
1172      VarDevice[sizeof(VarDevice)-1] = '\0';
1173      VarBaseDevice = rindex(VarDevice, '/');
1174      VarBaseDevice = VarBaseDevice ? VarBaseDevice + 1 : "";
1175      break;
1176    case VAR_ACCMAP:
1177      sscanf(arg, "%lx", &map);
1178      VarAccmap = map;
1179      break;
1180    case VAR_PHONE:
1181      strncpy(VarPhoneList, arg, sizeof(VarPhoneList)-1);
1182      VarPhoneList[sizeof(VarPhoneList)-1] = '\0';
1183      strcpy(VarPhoneCopy, VarPhoneList);
1184      VarNextPhone = VarPhoneCopy;
1185      break;
1186  }
1187  return 0;
1188}
1189
1190static int SetCtsRts(list, argc, argv)
1191struct cmdtab *list;
1192int argc;
1193char **argv;
1194{
1195  if (argc > 0) {
1196    if (strcmp(*argv, "on") == 0)
1197      VarCtsRts = TRUE;
1198    else if (strcmp(*argv, "off") == 0)
1199      VarCtsRts = FALSE;
1200    else
1201      return -1;
1202    return 0;
1203  }
1204  return -1;
1205}
1206
1207
1208static int SetOpenMode(list, argc, argv)
1209struct cmdtab *list;
1210int argc;
1211char **argv;
1212{
1213  if (argc > 0) {
1214    if (strcmp(*argv, "active") == 0)
1215      VarOpenMode = OPEN_ACTIVE;
1216    else if (strcmp(*argv, "passive") == 0)
1217      VarOpenMode = OPEN_PASSIVE;
1218    else
1219      return -1;
1220    return 0;
1221  }
1222  return -1;
1223}
1224
1225extern int SetIfilter(), SetOfilter(), SetDfilter(), SetAfilter();
1226
1227struct cmdtab const SetCommands[] = {
1228  { "accmap",   NULL,	  SetVariable,		LOCAL_AUTH,
1229	"Set accmap value", "set accmap hex-value", (void *)VAR_ACCMAP},
1230  { "afilter",  NULL,     SetAfilter, 		LOCAL_AUTH,
1231	"Set keep Alive filter", "set afilter ..."},
1232  { "authkey",  "key",     SetVariable,		LOCAL_AUTH,
1233	"Set authentication key", "set authkey|key key", (void *)VAR_AUTHKEY},
1234  { "authname", NULL,     SetVariable,		LOCAL_AUTH,
1235	"Set authentication name", "set authname name", (void *)VAR_AUTHNAME},
1236  { "ctsrts", NULL,	  SetCtsRts,		LOCAL_AUTH,
1237	"Use CTS/RTS modem signalling", "set ctsrts [on|off]"},
1238  { "device",     "line", SetVariable, 		LOCAL_AUTH,
1239	"Set modem device name", "set device|line device-name", (void *)VAR_DEVICE},
1240  { "dfilter",  NULL,     SetDfilter,		 LOCAL_AUTH,
1241	"Set demand filter", "set dfilter ..."},
1242  { "dial",     NULL,     SetVariable, 		LOCAL_AUTH,
1243	"Set dialing script", "set dial chat-script", (void *)VAR_DIAL},
1244  { "escape",   NULL,	  SetEscape, 		LOCAL_AUTH,
1245	"Set escape characters", "set escape hex-digit ..."},
1246  { "ifaddr",   NULL,   SetInterfaceAddr,	LOCAL_AUTH,
1247	"Set destination address", "set ifaddr [src-addr [dst-addr [netmask [trg-addr]]]]"},
1248  { "ifilter",  NULL,     SetIfilter, 		LOCAL_AUTH,
1249	"Set input filter", "set ifilter ..."},
1250  { "log",    NULL,	  SetLogLevel,	LOCAL_AUTH,
1251	"Set log level", "set log [+|-]value..."},
1252  { "login",    NULL,     SetVariable,		LOCAL_AUTH,
1253	"Set login script", "set login chat-script",	(void *)VAR_LOGIN },
1254  { "mru",      NULL,     SetInitialMRU,	LOCAL_AUTH,
1255	"Set Initial MRU value", "set mru value" },
1256  { "mtu",      NULL,     SetPreferredMTU,	LOCAL_AUTH,
1257	"Set Preferred MTU value", "set mtu value" },
1258  { "ofilter",  NULL,	  SetOfilter,		LOCAL_AUTH,
1259	"Set output filter", "set ofilter ..." },
1260  { "openmode", NULL,	  SetOpenMode,		LOCAL_AUTH,
1261	"Set open mode", "set openmode [active|passive]"},
1262  { "parity",   NULL,     SetModemParity,	LOCAL_AUTH,
1263	"Set modem parity", "set parity [odd|even|none]"},
1264  { "phone",    NULL,     SetVariable,		LOCAL_AUTH,
1265	"Set telephone number(s)", "set phone phone1[:phone2[...]]", (void *)VAR_PHONE },
1266  { "reconnect",NULL,     SetReconnect,		LOCAL_AUTH,
1267	"Set Reconnect timeout", "set reconnect value ntries"},
1268  { "redial",   NULL,     SetRedialTimeout,	LOCAL_AUTH,
1269	"Set Redial timeout", "set redial value|random[.value|random] [dial_attempts]"},
1270  { "server",    "socket",     SetServer,	LOCAL_AUTH,
1271	"Set server port", "set server|socket TcpPort|LocalName|none"},
1272  { "speed",    NULL,     SetModemSpeed,	LOCAL_AUTH,
1273	"Set modem speed", "set speed value"},
1274  { "timeout",  NULL,     SetIdleTimeout,	LOCAL_AUTH,
1275	"Set Idle timeout", "set timeout value"},
1276#ifndef NOMSEXT
1277  { "ns",	NULL,	  SetNS,		LOCAL_AUTH,
1278	"Set NameServer", "set ns pri-addr [sec-addr]"},
1279  { "nbns",	NULL,	  SetNBNS,		LOCAL_AUTH,
1280	"Set NetBIOS NameServer", "set nbns pri-addr [sec-addr]"},
1281#endif
1282  { "help",     "?",      HelpCommand,		LOCAL_AUTH | LOCAL_NO_AUTH,
1283	"Display this message", "set help|? [command]", (void *)SetCommands},
1284  { NULL,       NULL,     NULL },
1285};
1286
1287static int
1288SetCommand(list, argc, argv)
1289struct cmdtab *list;
1290int argc;
1291char **argv;
1292{
1293  if (argc > 0)
1294    FindExec(SetCommands, argc, argv);
1295  else if (VarTerm)
1296    fprintf(VarTerm, "Use `set ?' to get a list or `set ? <var>' for"
1297	    " syntax help.\n");
1298  else
1299    LogPrintf(LogWARN, "set command must have arguments\n");
1300
1301  return 0;
1302}
1303
1304
1305static int
1306AddCommand(list, argc, argv)
1307struct cmdtab *list;
1308int argc;
1309char **argv;
1310{
1311  struct in_addr dest, gateway, netmask;
1312
1313  if (argc == 3) {
1314    dest = GetIpAddr(argv[0]);
1315    netmask = GetIpAddr(argv[1]);
1316    if (strcasecmp(argv[2], "HISADDR") == 0)
1317      gateway = IpcpInfo.his_ipaddr;
1318    else
1319      gateway = GetIpAddr(argv[2]);
1320    OsSetRoute(RTM_ADD, dest, gateway, netmask);
1321    return 0;
1322  }
1323
1324  return -1;
1325}
1326
1327static int
1328DeleteCommand(list, argc, argv)
1329struct cmdtab *list;
1330int argc;
1331char **argv;
1332{
1333  struct in_addr dest, gateway, netmask;
1334
1335  if (argc == 1 && strcasecmp(argv[0], "all") == 0)
1336    DeleteIfRoutes(0);
1337  else if (argc > 0 && argc < 4) {
1338    dest = GetIpAddr(argv[0]);
1339    netmask.s_addr = INADDR_ANY;
1340    if (argc > 1) {
1341      if (strcasecmp(argv[1], "HISADDR") == 0)
1342        gateway = IpcpInfo.his_ipaddr;
1343      else
1344        gateway = GetIpAddr(argv[1]);
1345      if (argc == 3) {
1346        if (inet_aton(argv[2], &netmask) == 0) {
1347	  LogPrintf(LogWARN, "Bad netmask value.\n");
1348	  return -1;
1349        }
1350      }
1351    } else
1352      gateway.s_addr = INADDR_ANY;
1353    OsSetRoute(RTM_DELETE, dest, gateway, netmask);
1354  } else
1355    return -1;
1356
1357  return 0;
1358}
1359
1360static int AliasEnable();
1361static int AliasOption();
1362
1363static struct cmdtab const AliasCommands[] =
1364{
1365  { "enable",   NULL,     AliasEnable,          LOCAL_AUTH,
1366        "enable IP aliasing", "alias enable [yes|no]"},
1367  { "port",   NULL,     AliasRedirectPort,          LOCAL_AUTH,
1368        "port redirection", "alias port [proto addr_local:port_local  port_alias]"},
1369  { "addr",   NULL,     AliasRedirectAddr,          LOCAL_AUTH,
1370        "static address translation", "alias addr [addr_local addr_alias]"},
1371  { "deny_incoming",  NULL,    AliasOption,     LOCAL_AUTH,
1372        "stop incoming connections",   "alias deny_incoming [yes|no]",
1373        (void*)PKT_ALIAS_DENY_INCOMING},
1374  { "log",  NULL,     AliasOption,              LOCAL_AUTH,
1375        "log aliasing link creation",           "alias log [yes|no]",
1376        (void*)PKT_ALIAS_LOG},
1377  { "same_ports", NULL,     AliasOption,        LOCAL_AUTH,
1378        "try to leave port numbers unchanged", "alias same_ports [yes|no]",
1379        (void*)PKT_ALIAS_SAME_PORTS},
1380  { "use_sockets", NULL,     AliasOption,       LOCAL_AUTH,
1381        "allocate host sockets", "alias use_sockets [yes|no]",
1382        (void*)PKT_ALIAS_USE_SOCKETS },
1383  { "unregistered_only", NULL,     AliasOption, LOCAL_AUTH,
1384        "alias unregistered (private) IP address space only",
1385        "alias unregistered_only [yes|no]",
1386        (void*)PKT_ALIAS_UNREGISTERED_ONLY},
1387  { "help",     "?",      HelpCommand,          LOCAL_AUTH | LOCAL_NO_AUTH,
1388        "Display this message", "alias help|? [command]",
1389        (void *)AliasCommands},
1390  { NULL,       NULL,     NULL },
1391};
1392
1393
1394static int
1395AliasCommand(list, argc, argv)
1396struct cmdtab *list;
1397int argc;
1398char **argv;
1399{
1400  if (argc > 0)
1401    FindExec(AliasCommands, argc, argv);
1402  else if (VarTerm)
1403    fprintf(VarTerm, "Use `alias help' to get a list or `alias help <option>'"
1404	    " for syntax help.\n");
1405  else
1406    LogPrintf(LogWARN, "alias command must have arguments\n");
1407
1408  return 0;
1409}
1410
1411static int
1412AliasEnable(list, argc, argv)
1413struct cmdtab *list;
1414int argc;
1415char **argv;
1416{
1417  if (argc == 1)
1418    if (strcasecmp(argv[0], "yes") == 0) {
1419      if (!(mode & MODE_ALIAS)) {
1420        if (loadAliasHandlers(&VarAliasHandlers) == 0) {
1421          mode |= MODE_ALIAS;
1422          return 0;
1423        }
1424        LogPrintf(LogWARN, "Cannot load alias library\n");
1425        return 1;
1426      }
1427      return 0;
1428    } else if (strcasecmp(argv[0], "no") == 0) {
1429      if (mode & MODE_ALIAS) {
1430        unloadAliasHandlers();
1431        mode &= ~MODE_ALIAS;
1432      }
1433      return 0;
1434    }
1435
1436  return -1;
1437}
1438
1439
1440static int
1441AliasOption(list, argc, argv, param)
1442struct cmdtab *list;
1443int argc;
1444char **argv;
1445void* param;
1446{
1447   if (argc == 1)
1448     if (strcasecmp(argv[0], "yes") == 0) {
1449       if (mode & MODE_ALIAS) {
1450         VarSetPacketAliasMode((unsigned)param, (unsigned)param);
1451         return 0;
1452       }
1453       LogPrintf(LogWARN, "alias not enabled\n");
1454     } else if (strcmp(argv[0], "no") == 0) {
1455       if (mode & MODE_ALIAS) {
1456         VarSetPacketAliasMode(0, (unsigned)param);
1457         return 0;
1458       }
1459       LogPrintf(LogWARN, "alias not enabled\n");
1460     }
1461
1462   return -1;
1463}
1464