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