usr.sbin/ppp/command.c

   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  * $FreeBSD$
  21  *
  22  */
  23 #include <sys/param.h>
  24 #include <netinet/in_systm.h>
  25 #include <netinet/in.h>
  26 #include <netinet/ip.h>
  27 #include <arpa/inet.h>
  28 #include <sys/socket.h>
  29 #include <net/route.h>
  30 #include <netdb.h>
  31 #include <sys/un.h>
  32
  33 #include <ctype.h>
  34 #include <errno.h>
  35 #include <fcntl.h>
  36 #include <paths.h>
  37 #include <stdio.h>
  38 #include <stdlib.h>
  39 #include <string.h>
  40 #include <sys/wait.h>
  41 #include <termios.h>
  42 #include <unistd.h>
  43
  44 #ifndef NONAT
  45 #ifdef __FreeBSD__
  46 #include <alias.h>
  47 #else
  48 #include "alias.h"
  49 #endif
  50 #endif
  51 #include "layer.h"
  52 #include "defs.h"
  53 #include "command.h"
  54 #include "mbuf.h"
  55 #include "log.h"
  56 #include "timer.h"
  57 #include "fsm.h"
  58 #include "lcp.h"
  59 #include "iplist.h"
  60 #include "throughput.h"
  61 #include "slcompress.h"
  62 #include "lqr.h"
  63 #include "hdlc.h"
  64 #include "ipcp.h"
  65 #ifndef NONAT
  66 #include "alias_cmd.h"
  67 #endif
  68 #include "systems.h"
  69 #include "filter.h"
  70 #include "descriptor.h"
  71 #include "main.h"
  72 #include "route.h"
  73 #include "ccp.h"
  74 #include "auth.h"
  75 #include "async.h"
  76 #include "link.h"
  77 #include "physical.h"
  78 #include "mp.h"
  79 #ifndef NORADIUS
  80 #include "radius.h"
  81 #endif
  82 #include "bundle.h"
  83 #include "server.h"
  84 #include "prompt.h"
  85 #include "chat.h"
  86 #include "chap.h"
  87 #include "cbcp.h"
  88 #include "datalink.h"
  89 #include "iface.h"
  90
  91 /* ``set'' values */
  92 #define VAR_AUTHKEY     0
  93 #define VAR_DIAL        1
  94 #define VAR_LOGIN       2
  95 #define VAR_AUTHNAME    3
  96 #define VAR_AUTOLOAD    4
  97 #define VAR_WINSIZE     5
  98 #define VAR_DEVICE      6
  99 #define VAR_ACCMAP      7
 100 #define VAR_MRRU        8
 101 #define VAR_MRU         9
 102 #define VAR_MTU         10
 103 #define VAR_OPENMODE    11
 104 #define VAR_PHONE       12
 105 #define VAR_HANGUP      13
 106 #define VAR_IDLETIMEOUT 14
 107 #define VAR_LQRPERIOD   15
 108 #define VAR_LCPRETRY    16
 109 #define VAR_CHAPRETRY   17
 110 #define VAR_PAPRETRY    18
 111 #define VAR_CCPRETRY    19
 112 #define VAR_IPCPRETRY   20
 113 #define VAR_DNS         21
 114 #define VAR_NBNS        22
 115 #define VAR_MODE        23
 116 #define VAR_CALLBACK    24
 117 #define VAR_CBCP        25
 118 #define VAR_CHOKED      26
 119 #define VAR_SENDPIPE    27
 120 #define VAR_RECVPIPE    28
 121 #define VAR_RADIUS      29
 122 #define VAR_CD          30
 123 #define VAR_PARITY      31
 124 #define VAR_CRTSCTS     32
 125
 126 /* ``accept|deny|disable|enable'' masks */
 127 #define NEG_HISMASK (1)
 128 #define NEG_MYMASK (2)
 129
 130 /* ``accept|deny|disable|enable'' values */
 131 #define NEG_ACFCOMP     40
 132 #define NEG_CHAP05      41
 133 #define NEG_CHAP80      42
 134 #define NEG_CHAP80LM    43
 135 #define NEG_DEFLATE     44
 136 #define NEG_DNS         45
 137 #define NEG_ENDDISC     46
 138 #define NEG_LQR         47
 139 #define NEG_PAP         48
 140 #define NEG_PPPDDEFLATE 49
 141 #define NEG_PRED1       50
 142 #define NEG_PROTOCOMP   51
 143 #define NEG_SHORTSEQ    52
 144 #define NEG_VJCOMP      53
 145
 146 const char Version[] = "2.23";
 147 const char VersionDate[] = "$Date: 1999/08/22 01:29:53 $";
 148
 149 static int ShowCommand(struct cmdargs const *);
 150 static int TerminalCommand(struct cmdargs const *);
 151 static int QuitCommand(struct cmdargs const *);
 152 static int OpenCommand(struct cmdargs const *);
 153 static int CloseCommand(struct cmdargs const *);
 154 static int DownCommand(struct cmdargs const *);
 155 static int SetCommand(struct cmdargs const *);
 156 static int LinkCommand(struct cmdargs const *);
 157 static int AddCommand(struct cmdargs const *);
 158 static int DeleteCommand(struct cmdargs const *);
 159 static int NegotiateCommand(struct cmdargs const *);
 160 static int ClearCommand(struct cmdargs const *);
 161 static int RunListCommand(struct cmdargs const *);
 162 static int IfaceAddCommand(struct cmdargs const *);
 163 static int IfaceDeleteCommand(struct cmdargs const *);
 164 static int IfaceClearCommand(struct cmdargs const *);
 165 static int SetProcTitle(struct cmdargs const *);
 166 #ifndef NONAT
 167 static int AliasEnable(struct cmdargs const *);
 168 static int AliasOption(struct cmdargs const *);
 169 #endif
 170
 171 static const char *
 172 showcx(struct cmdtab const *cmd)
 173 {
 174   if (cmd->lauth & LOCAL_CX)
 175     return "(c)";
 176   else if (cmd->lauth & LOCAL_CX_OPT)
 177     return "(o)";
 178
 179   return "";
 180 }
 181
 182 static int
 183 HelpCommand(struct cmdargs const *arg)
 184 {
 185   struct cmdtab const *cmd;
 186   int n, cmax, dmax, cols, cxlen;
 187   const char *cx;
 188
 189   if (!arg->prompt) {
 190     log_Printf(LogWARN, "help: Cannot help without a prompt\n");
 191     return 0;
 192   }
 193
 194   if (arg->argc > arg->argn) {
 195     for (cmd = arg->cmdtab; cmd->name || cmd->alias; cmd++)
 196       if ((cmd->lauth & arg->prompt->auth) &&
 197           ((cmd->name && !strcasecmp(cmd->name, arg->argv[arg->argn])) ||
 198            (cmd->alias && !strcasecmp(cmd->alias, arg->argv[arg->argn])))) {
 199         prompt_Printf(arg->prompt, "%s %s\n", cmd->syntax, showcx(cmd));
 200         return 0;
 201       }
 202     return -1;
 203   }
 204
 205   cmax = dmax = 0;
 206   for (cmd = arg->cmdtab; cmd->func; cmd++)
 207     if (cmd->name && (cmd->lauth & arg->prompt->auth)) {
 208       if ((n = strlen(cmd->name) + strlen(showcx(cmd))) > cmax)
 209         cmax = n;
 210       if ((n = strlen(cmd->helpmes)) > dmax)
 211         dmax = n;
 212     }
 213
 214   cols = 80 / (dmax + cmax + 3);
 215   n = 0;
 216   prompt_Printf(arg->prompt, "(o) = Optional context,"
 217                 " (c) = Context required\n");
 218   for (cmd = arg->cmdtab; cmd->func; cmd++)
 219     if (cmd->name && (cmd->lauth & arg->prompt->auth)) {
 220       cx = showcx(cmd);
 221       cxlen = cmax - strlen(cmd->name);
 222       if (n % cols != 0)
 223         prompt_Printf(arg->prompt, " ");
 224       prompt_Printf(arg->prompt, "%s%-*.*s: %-*.*s",
 225               cmd->name, cxlen, cxlen, cx, dmax, dmax, cmd->helpmes);
 226       if (++n % cols == 0)
 227         prompt_Printf(arg->prompt, "\n");
 228     }
 229   if (n % cols != 0)
 230     prompt_Printf(arg->prompt, "\n");
 231
 232   return 0;
 233 }
 234
 235 static int
 236 CloneCommand(struct cmdargs const *arg)
 237 {
 238   char namelist[LINE_LEN];
 239   char *name;
 240   int f;
 241
 242   if (arg->argc == arg->argn)
 243     return -1;
 244
 245   namelist[sizeof namelist - 1] = '\0';
 246   for (f = arg->argn; f < arg->argc; f++) {
 247     strncpy(namelist, arg->argv[f], sizeof namelist - 1);
 248     for(name = strtok(namelist, ", "); name; name = strtok(NULL,", "))
 249       bundle_DatalinkClone(arg->bundle, arg->cx, name);
 250   }
 251
 252   return 0;
 253 }
 254
 255 static int
 256 RemoveCommand(struct cmdargs const *arg)
 257 {
 258   if (arg->argc != arg->argn)
 259     return -1;
 260
 261   if (arg->cx->state != DATALINK_CLOSED) {
 262     log_Printf(LogWARN, "remove: Cannot delete links that aren't closed\n");
 263     return 2;
 264   }
 265
 266   bundle_DatalinkRemove(arg->bundle, arg->cx);
 267   return 0;
 268 }
 269
 270 static int
 271 RenameCommand(struct cmdargs const *arg)
 272 {
 273   if (arg->argc != arg->argn + 1)
 274     return -1;
 275
 276   if (bundle_RenameDatalink(arg->bundle, arg->cx, arg->argv[arg->argn]))
 277     return 0;
 278
 279   log_Printf(LogWARN, "%s -> %s: target name already exists\n",
 280              arg->cx->name, arg->argv[arg->argn]);
 281   return 1;
 282 }
 283
 284 int
 285 LoadCommand(struct cmdargs const *arg)
 286 {
 287   const char *err;
 288   int n, mode;
 289
 290   mode = arg->bundle->phys_type.all;
 291
 292   if (arg->argn < arg->argc) {
 293     for (n = arg->argn; n < arg->argc; n++)
 294       if ((err = system_IsValid(arg->argv[n], arg->prompt, mode)) != NULL) {
 295         log_Printf(LogWARN, "%s: %s\n", arg->argv[n], err);
 296         return 1;
 297       }
 298
 299     for (n = arg->argn; n < arg->argc; n++) {
 300       bundle_SetLabel(arg->bundle, arg->argv[arg->argc - 1]);
 301       system_Select(arg->bundle, arg->argv[n], CONFFILE, arg->prompt, arg->cx);
 302     }
 303     bundle_SetLabel(arg->bundle, arg->argv[arg->argc - 1]);
 304   } else if ((err = system_IsValid("default", arg->prompt, mode)) != NULL) {
 305     log_Printf(LogWARN, "default: %s\n", err);
 306     return 1;
 307   } else {
 308     bundle_SetLabel(arg->bundle, "default");
 309     system_Select(arg->bundle, "default", CONFFILE, arg->prompt, arg->cx);
 310     bundle_SetLabel(arg->bundle, "default");
 311   }
 312
 313   return 0;
 314 }
 315
 316 int
 317 SaveCommand(struct cmdargs const *arg)
 318 {
 319   log_Printf(LogWARN, "save command is not implemented (yet).\n");
 320   return 1;
 321 }
 322
 323 static int
 324 DialCommand(struct cmdargs const *arg)
 325 {
 326   int res;
 327
 328   if ((arg->cx && !(arg->cx->physical->type & (PHYS_INTERACTIVE|PHYS_AUTO)))
 329       || (!arg->cx &&
 330           (arg->bundle->phys_type.all & ~(PHYS_INTERACTIVE|PHYS_AUTO)))) {
 331     log_Printf(LogWARN, "Manual dial is only available for auto and"
 332               " interactive links\n");
 333     return 1;
 334   }
 335
 336   if (arg->argc > arg->argn && (res = LoadCommand(arg)) != 0)
 337     return res;
 338
 339   bundle_Open(arg->bundle, arg->cx ? arg->cx->name : NULL, PHYS_ALL, 1);
 340
 341   return 0;
 342 }
 343
 344 #define isinword(ch) (isalnum(ch) || (ch) == '_')
 345
 346 static char *
 347 strstrword(char *big, const char *little)
 348 {
 349   /* Get the first occurance of the word ``little'' in ``big'' */
 350   char *pos;
 351   int len;
 352
 353   pos = big;
 354   len = strlen(little);
 355
 356   while ((pos = strstr(pos, little)) != NULL)
 357     if ((pos != big && isinword(pos[-1])) || isinword(pos[len]))
 358       pos++;
 359     else if (pos != big && pos[-1] == '\\')
 360       memmove(pos - 1, pos, strlen(pos) + 1);
 361     else
 362       break;
 363
 364   return pos;
 365 }
 366
 367 static char *
 368 subst(char *tgt, const char *oldstr, const char *newstr)
 369 {
 370   /* tgt is a malloc()d area... realloc() as necessary */
 371   char *word, *ntgt;
 372   int ltgt, loldstr, lnewstr, pos;
 373
 374   if ((word = strstrword(tgt, oldstr)) == NULL)
 375     return tgt;
 376
 377   ltgt = strlen(tgt) + 1;
 378   loldstr = strlen(oldstr);
 379   lnewstr = strlen(newstr);
 380   do {
 381     pos = word - tgt;
 382     if (loldstr > lnewstr)
 383       bcopy(word + loldstr, word + lnewstr, ltgt - pos - loldstr);
 384     if (loldstr != lnewstr) {
 385       ntgt = realloc(tgt, ltgt += lnewstr - loldstr);
 386       if (ntgt == NULL)
 387         break;                  /* Oh wonderful ! */
 388       word = ntgt + pos;
 389       tgt = ntgt;
 390     }
 391     if (lnewstr > loldstr)
 392       bcopy(word + loldstr, word + lnewstr, ltgt - pos - loldstr);
 393     bcopy(newstr, word, lnewstr);
 394   } while ((word = strstrword(word, oldstr)));
 395
 396   return tgt;
 397 }
 398
 399 void
 400 command_Expand(char **nargv, int argc, char const *const *oargv,
 401                struct bundle *bundle, int inc0, pid_t pid)
 402 {
 403   int arg;
 404   char pidstr[12];
 405
 406   if (inc0)
 407     arg = 0;            /* Start at arg 0 */
 408   else {
 409     nargv[0] = strdup(oargv[0]);
 410     arg = 1;
 411   }
 412   snprintf(pidstr, sizeof pidstr, "%d", (int)pid);
 413   for (; arg < argc; arg++) {
 414     nargv[arg] = strdup(oargv[arg]);
 415     nargv[arg] = subst(nargv[arg], "HISADDR",
 416                        inet_ntoa(bundle->ncp.ipcp.peer_ip));
 417     nargv[arg] = subst(nargv[arg], "AUTHNAME", bundle->cfg.auth.name);
 418     nargv[arg] = subst(nargv[arg], "INTERFACE", bundle->iface->name);
 419     nargv[arg] = subst(nargv[arg], "MYADDR", inet_ntoa(bundle->ncp.ipcp.my_ip));
 420     nargv[arg] = subst(nargv[arg], "USER", bundle->ncp.mp.peer.authname);
 421     nargv[arg] = subst(nargv[arg], "PEER_ENDDISC",
 422                        mp_Enddisc(bundle->ncp.mp.peer.enddisc.class,
 423                                   bundle->ncp.mp.peer.enddisc.address,
 424                                   bundle->ncp.mp.peer.enddisc.len));
 425     nargv[arg] = subst(nargv[arg], "ENDDISC",
 426                        mp_Enddisc(bundle->ncp.mp.cfg.enddisc.class,
 427                                   bundle->ncp.mp.cfg.enddisc.address,
 428                                   bundle->ncp.mp.cfg.enddisc.len));
 429     nargv[arg] = subst(nargv[arg], "PROCESSID", pidstr);
 430     nargv[arg] = subst(nargv[arg], "LABEL", bundle_GetLabel(bundle));
 431   }
 432   nargv[arg] = NULL;
 433 }
 434
 435 static int
 436 ShellCommand(struct cmdargs const *arg, int bg)
 437 {
 438   const char *shell;
 439   pid_t shpid, pid;
 440
 441 #ifdef SHELL_ONLY_INTERACTIVELY
 442   /* we're only allowed to shell when we run ppp interactively */
 443   if (arg->prompt && arg->prompt->owner) {
 444     log_Printf(LogWARN, "Can't start a shell from a network connection\n");
 445     return 1;
 446   }
 447 #endif
 448
 449   if (arg->argc == arg->argn) {
 450     if (!arg->prompt) {
 451       log_Printf(LogWARN, "Can't start an interactive shell from"
 452                 " a config file\n");
 453       return 1;
 454     } else if (arg->prompt->owner) {
 455       log_Printf(LogWARN, "Can't start an interactive shell from"
 456                 " a socket connection\n");
 457       return 1;
 458     } else if (bg) {
 459       log_Printf(LogWARN, "Can only start an interactive shell in"
 460                 " the foreground mode\n");
 461       return 1;
 462     }
 463   }
 464
 465   pid = getpid();
 466   if ((shpid = fork()) == 0) {
 467     int i, fd;
 468
 469     if ((shell = getenv("SHELL")) == 0)
 470       shell = _PATH_BSHELL;
 471
 472     timer_TermService();
 473
 474     if (arg->prompt)
 475       fd = arg->prompt->fd_out;
 476     else if ((fd = open(_PATH_DEVNULL, O_RDWR)) == -1) {
 477       log_Printf(LogALERT, "Failed to open %s: %s\n",
 478                 _PATH_DEVNULL, strerror(errno));
 479       exit(1);
 480     }
 481     dup2(fd, STDIN_FILENO);
 482     dup2(fd, STDOUT_FILENO);
 483     dup2(fd, STDERR_FILENO);
 484     for (i = getdtablesize(); i > STDERR_FILENO; i--)
 485       fcntl(i, F_SETFD, 1);
 486
 487     setuid(geteuid());
 488     if (arg->argc > arg->argn) {
 489       /* substitute pseudo args */
 490       char *argv[MAXARGS];
 491       int argc = arg->argc - arg->argn;
 492
 493       if (argc >= sizeof argv / sizeof argv[0]) {
 494         argc = sizeof argv / sizeof argv[0] - 1;
 495         log_Printf(LogWARN, "Truncating shell command to %d args\n", argc);
 496       }
 497       command_Expand(argv, argc, arg->argv + arg->argn, arg->bundle, 0, pid);
 498       if (bg) {
 499         pid_t p;
 500
 501         p = getpid();
 502         if (daemon(1, 1) == -1) {
 503           log_Printf(LogERROR, "%d: daemon: %s\n", (int)p, strerror(errno));
 504           exit(1);
 505         }
 506       } else if (arg->prompt)
 507         printf("ppp: Pausing until %s finishes\n", arg->argv[arg->argn]);
 508       execvp(argv[0], argv);
 509     } else {
 510       if (arg->prompt)
 511         printf("ppp: Pausing until %s finishes\n", shell);
 512       prompt_TtyOldMode(arg->prompt);
 513       execl(shell, shell, NULL);
 514     }
 515
 516     log_Printf(LogWARN, "exec() of %s failed: %s\n",
 517               arg->argc > arg->argn ? arg->argv[arg->argn] : shell,
 518               strerror(errno));
 519     _exit(255);
 520   }
 521
 522   if (shpid == (pid_t) - 1)
 523     log_Printf(LogERROR, "Fork failed: %s\n", strerror(errno));
 524   else {
 525     int status;
 526     waitpid(shpid, &status, 0);
 527   }
 528
 529   if (arg->prompt && !arg->prompt->owner)
 530     prompt_TtyCommandMode(arg->prompt);
 531
 532   return 0;
 533 }
 534
 535 static int
 536 BgShellCommand(struct cmdargs const *arg)
 537 {
 538   if (arg->argc == arg->argn)
 539     return -1;
 540   return ShellCommand(arg, 1);
 541 }
 542
 543 static int
 544 FgShellCommand(struct cmdargs const *arg)
 545 {
 546   return ShellCommand(arg, 0);
 547 }
 548
 549 #ifndef NONAT
 550 static struct cmdtab const AliasCommands[] =
 551 {
 552   {"addr", NULL, nat_RedirectAddr, LOCAL_AUTH,
 553    "static address translation", "nat addr [addr_local addr_alias]"},
 554   {"deny_incoming", NULL, AliasOption, LOCAL_AUTH,
 555    "stop incoming connections", "nat deny_incoming yes|no",
 556    (const void *) PKT_ALIAS_DENY_INCOMING},
 557   {"enable", NULL, AliasEnable, LOCAL_AUTH,
 558    "enable NAT", "nat enable yes|no"},
 559   {"log", NULL, AliasOption, LOCAL_AUTH,
 560    "log NAT link creation", "nat log yes|no",
 561    (const void *) PKT_ALIAS_LOG},
 562   {"port", NULL, nat_RedirectPort, LOCAL_AUTH, "port redirection",
 563    "nat port proto localaddr:port[-port] aliasport[-aliasport]"},
 564   {"pptp", NULL, nat_Pptp, LOCAL_AUTH,
 565    "Set the PPTP address", "nat pptp IP"},
 566   {"proxy", NULL, nat_ProxyRule, LOCAL_AUTH,
 567    "proxy control", "nat proxy server host[:port] ..."},
 568   {"same_ports", NULL, AliasOption, LOCAL_AUTH,
 569    "try to leave port numbers unchanged", "nat same_ports yes|no",
 570    (const void *) PKT_ALIAS_SAME_PORTS},
 571   {"unregistered_only", NULL, AliasOption, LOCAL_AUTH,
 572    "translate unregistered (private) IP address space only",
 573    "nat unregistered_only yes|no",
 574    (const void *) PKT_ALIAS_UNREGISTERED_ONLY},
 575   {"use_sockets", NULL, AliasOption, LOCAL_AUTH,
 576    "allocate host sockets", "nat use_sockets yes|no",
 577    (const void *) PKT_ALIAS_USE_SOCKETS},
 578   {"help", "?", HelpCommand, LOCAL_AUTH | LOCAL_NO_AUTH,
 579    "Display this message", "nat help|? [command]", AliasCommands},
 580   {NULL, NULL, NULL},
 581 };
 582 #endif
 583
 584 static struct cmdtab const AllowCommands[] = {
 585   {"modes", "mode", AllowModes, LOCAL_AUTH,
 586   "Only allow certain ppp modes", "allow modes mode..."},
 587   {"users", "user", AllowUsers, LOCAL_AUTH,
 588   "Only allow ppp access to certain users", "allow users logname..."},
 589   {"help", "?", HelpCommand, LOCAL_AUTH | LOCAL_NO_AUTH,
 590   "Display this message", "allow help|? [command]", AllowCommands},
 591   {NULL, NULL, NULL},
 592 };
 593
 594 static struct cmdtab const IfaceCommands[] =
 595 {
 596   {"add", NULL, IfaceAddCommand, LOCAL_AUTH,
 597    "Add iface address", "iface add addr[/bits| mask] peer", NULL},
 598   {NULL, "add!", IfaceAddCommand, LOCAL_AUTH,
 599    "Add or change an iface address", "iface add! addr[/bits| mask] peer",
 600    (void *)1},
 601   {"clear", NULL, IfaceClearCommand, LOCAL_AUTH,
 602    "Clear iface address(es)", "iface clear"},
 603   {"delete", "rm", IfaceDeleteCommand, LOCAL_AUTH,
 604    "Delete iface address", "iface delete addr", NULL},
 605   {NULL, "rm!", IfaceDeleteCommand, LOCAL_AUTH,
 606    "Delete iface address", "iface delete addr", (void *)1},
 607   {NULL, "delete!", IfaceDeleteCommand, LOCAL_AUTH,
 608    "Delete iface address", "iface delete addr", (void *)1},
 609   {"show", NULL, iface_Show, LOCAL_AUTH,
 610    "Show iface address(es)", "iface show"},
 611   {"help", "?", HelpCommand, LOCAL_AUTH | LOCAL_NO_AUTH,
 612    "Display this message", "nat help|? [command]", IfaceCommands},
 613   {NULL, NULL, NULL},
 614 };
 615
 616 static struct cmdtab const Commands[] = {
 617   {"accept", NULL, NegotiateCommand, LOCAL_AUTH | LOCAL_CX_OPT,
 618   "accept option request", "accept option .."},
 619   {"add", NULL, AddCommand, LOCAL_AUTH,
 620   "add route", "add dest mask gateway", NULL},
 621   {NULL, "add!", AddCommand, LOCAL_AUTH,
 622   "add or change route", "add! dest mask gateway", (void *)1},
 623   {"allow", "auth", RunListCommand, LOCAL_AUTH,
 624   "Allow ppp access", "allow users|modes ....", AllowCommands},
 625   {"bg", "!bg", BgShellCommand, LOCAL_AUTH,
 626   "Run a background command", "[!]bg command"},
 627   {"clear", NULL, ClearCommand, LOCAL_AUTH | LOCAL_CX_OPT,
 628   "Clear throughput statistics",
 629   "clear ipcp|physical [current|overall|peak]..."},
 630   {"clone", NULL, CloneCommand, LOCAL_AUTH | LOCAL_CX,
 631   "Clone a link", "clone newname..."},
 632   {"close", NULL, CloseCommand, LOCAL_AUTH | LOCAL_CX_OPT,
 633   "Close an FSM", "close [lcp|ccp]"},
 634   {"delete", NULL, DeleteCommand, LOCAL_AUTH,
 635   "delete route", "delete dest", NULL},
 636   {NULL, "delete!", DeleteCommand, LOCAL_AUTH,
 637   "delete a route if it exists", "delete! dest", (void *)1},
 638   {"deny", NULL, NegotiateCommand, LOCAL_AUTH | LOCAL_CX_OPT,
 639   "Deny option request", "deny option .."},
 640   {"dial", "call", DialCommand, LOCAL_AUTH | LOCAL_CX_OPT,
 641   "Dial and login", "dial|call [system ...]", NULL},
 642   {"disable", NULL, NegotiateCommand, LOCAL_AUTH | LOCAL_CX_OPT,
 643   "Disable option", "disable option .."},
 644   {"down", NULL, DownCommand, LOCAL_AUTH | LOCAL_CX_OPT,
 645   "Generate a down event", "down [ccp|lcp]"},
 646   {"enable", NULL, NegotiateCommand, LOCAL_AUTH | LOCAL_CX_OPT,
 647   "Enable option", "enable option .."},
 648   {"iface", "interface", RunListCommand, LOCAL_AUTH,
 649   "interface control", "iface option ...", IfaceCommands},
 650   {"link", "datalink", LinkCommand, LOCAL_AUTH,
 651   "Link specific commands", "link name command ..."},
 652   {"load", NULL, LoadCommand, LOCAL_AUTH | LOCAL_CX_OPT,
 653   "Load settings", "load [system ...]"},
 654 #ifndef NONAT
 655   {"nat", "alias", RunListCommand, LOCAL_AUTH,
 656   "NAT control", "nat option yes|no", AliasCommands},
 657 #endif
 658   {"open", NULL, OpenCommand, LOCAL_AUTH | LOCAL_CX_OPT,
 659   "Open an FSM", "open! [lcp|ccp|ipcp]", (void *)1},
 660   {"passwd", NULL, PasswdCommand, LOCAL_NO_AUTH,
 661   "Password for manipulation", "passwd LocalPassword"},
 662   {"quit", "bye", QuitCommand, LOCAL_AUTH | LOCAL_NO_AUTH,
 663   "Quit PPP program", "quit|bye [all]"},
 664   {"remove", "rm", RemoveCommand, LOCAL_AUTH | LOCAL_CX,
 665   "Remove a link", "remove"},
 666   {"rename", "mv", RenameCommand, LOCAL_AUTH | LOCAL_CX,
 667   "Rename a link", "rename name"},
 668   {"save", NULL, SaveCommand, LOCAL_AUTH,
 669   "Save settings", "save"},
 670   {"set", "setup", SetCommand, LOCAL_AUTH | LOCAL_CX_OPT,
 671   "Set parameters", "set[up] var value"},
 672   {"shell", "!", FgShellCommand, LOCAL_AUTH,
 673   "Run a subshell", "shell|! [sh command]"},
 674   {"show", NULL, ShowCommand, LOCAL_AUTH | LOCAL_CX_OPT,
 675   "Show status and stats", "show var"},
 676   {"term", NULL, TerminalCommand, LOCAL_AUTH | LOCAL_CX,
 677   "Enter terminal mode", "term"},
 678   {"help", "?", HelpCommand, LOCAL_AUTH | LOCAL_NO_AUTH,
 679   "Display this message", "help|? [command]", Commands},
 680   {NULL, NULL, NULL},
 681 };
 682
 683 static int
 684 ShowEscape(struct cmdargs const *arg)
 685 {
 686   if (arg->cx->physical->async.cfg.EscMap[32]) {
 687     int code, bit;
 688     const char *sep = "";
 689
 690     for (code = 0; code < 32; code++)
 691       if (arg->cx->physical->async.cfg.EscMap[code])
 692         for (bit = 0; bit < 8; bit++)
 693           if (arg->cx->physical->async.cfg.EscMap[code] & (1 << bit)) {
 694             prompt_Printf(arg->prompt, "%s0x%02x", sep, (code << 3) + bit);
 695             sep = ", ";
 696           }
 697     prompt_Printf(arg->prompt, "\n");
 698   }
 699   return 0;
 700 }
 701
 702 static int
 703 ShowTimerList(struct cmdargs const *arg)
 704 {
 705   timer_Show(0, arg->prompt);
 706   return 0;
 707 }
 708
 709 static int
 710 ShowStopped(struct cmdargs const *arg)
 711 {
 712   prompt_Printf(arg->prompt, " Stopped Timer:  LCP: ");
 713   if (!arg->cx->physical->link.lcp.fsm.StoppedTimer.load)
 714     prompt_Printf(arg->prompt, "Disabled");
 715   else
 716     prompt_Printf(arg->prompt, "%ld secs",
 717                   arg->cx->physical->link.lcp.fsm.StoppedTimer.load / SECTICKS);
 718
 719   prompt_Printf(arg->prompt, ", CCP: ");
 720   if (!arg->cx->physical->link.ccp.fsm.StoppedTimer.load)
 721     prompt_Printf(arg->prompt, "Disabled");
 722   else
 723     prompt_Printf(arg->prompt, "%ld secs",
 724                   arg->cx->physical->link.ccp.fsm.StoppedTimer.load / SECTICKS);
 725
 726   prompt_Printf(arg->prompt, "\n");
 727
 728   return 0;
 729 }
 730
 731 static int
 732 ShowVersion(struct cmdargs const *arg)
 733 {
 734   prompt_Printf(arg->prompt, "PPP Version %s - %s\n", Version, VersionDate);
 735   return 0;
 736 }
 737
 738 static int
 739 ShowProtocolStats(struct cmdargs const *arg)
 740 {
 741   struct link *l = command_ChooseLink(arg);
 742
 743   prompt_Printf(arg->prompt, "%s:\n", l->name);
 744   link_ReportProtocolStatus(l, arg->prompt);
 745   return 0;
 746 }
 747
 748 static struct cmdtab const ShowCommands[] = {
 749   {"bundle", NULL, bundle_ShowStatus, LOCAL_AUTH,
 750   "bundle details", "show bundle"},
 751   {"ccp", NULL, ccp_ReportStatus, LOCAL_AUTH | LOCAL_CX_OPT,
 752   "CCP status", "show cpp"},
 753   {"compress", NULL, sl_Show, LOCAL_AUTH,
 754   "VJ compression stats", "show compress"},
 755   {"escape", NULL, ShowEscape, LOCAL_AUTH | LOCAL_CX,
 756   "escape characters", "show escape"},
 757   {"filter", NULL, filter_Show, LOCAL_AUTH,
 758   "packet filters", "show filter [in|out|dial|alive]"},
 759   {"hdlc", NULL, hdlc_ReportStatus, LOCAL_AUTH | LOCAL_CX,
 760   "HDLC errors", "show hdlc"},
 761   {"iface", "interface", iface_Show, LOCAL_AUTH,
 762   "Interface status", "show iface"},
 763   {"ipcp", NULL, ipcp_Show, LOCAL_AUTH,
 764   "IPCP status", "show ipcp"},
 765   {"layers", NULL, link_ShowLayers, LOCAL_AUTH | LOCAL_CX_OPT,
 766   "Protocol layers", "show layers"},
 767   {"lcp", NULL, lcp_ReportStatus, LOCAL_AUTH | LOCAL_CX,
 768   "LCP status", "show lcp"},
 769   {"link", "datalink", datalink_Show, LOCAL_AUTH | LOCAL_CX,
 770   "(high-level) link info", "show link"},
 771   {"links", NULL, bundle_ShowLinks, LOCAL_AUTH,
 772   "available link names", "show links"},
 773   {"log", NULL, log_ShowLevel, LOCAL_AUTH,
 774   "log levels", "show log"},
 775   {"mem", NULL, mbuf_Show, LOCAL_AUTH,
 776   "mbuf allocations", "show mem"},
 777   {"physical", NULL, physical_ShowStatus, LOCAL_AUTH | LOCAL_CX,
 778   "(low-level) link info", "show physical"},
 779   {"mp", "multilink", mp_ShowStatus, LOCAL_AUTH,
 780   "multilink setup", "show mp"},
 781   {"proto", NULL, ShowProtocolStats, LOCAL_AUTH | LOCAL_CX_OPT,
 782   "protocol summary", "show proto"},
 783   {"route", NULL, route_Show, LOCAL_AUTH,
 784   "routing table", "show route"},
 785   {"stopped", NULL, ShowStopped, LOCAL_AUTH | LOCAL_CX,
 786   "STOPPED timeout", "show stopped"},
 787   {"timers", NULL, ShowTimerList, LOCAL_AUTH,
 788   "alarm timers", "show timers"},
 789   {"version", NULL, ShowVersion, LOCAL_NO_AUTH | LOCAL_AUTH,
 790   "version string", "show version"},
 791   {"who", NULL, log_ShowWho, LOCAL_AUTH,
 792   "client list", "show who"},
 793   {"help", "?", HelpCommand, LOCAL_NO_AUTH | LOCAL_AUTH,
 794   "Display this message", "show help|? [command]", ShowCommands},
 795   {NULL, NULL, NULL},
 796 };
 797
 798 static struct cmdtab const *
 799 FindCommand(struct cmdtab const *cmds, const char *str, int *pmatch)
 800 {
 801   int nmatch;
 802   int len;
 803   struct cmdtab const *found;
 804
 805   found = NULL;
 806   len = strlen(str);
 807   nmatch = 0;
 808   while (cmds->func) {
 809     if (cmds->name && strncasecmp(str, cmds->name, len) == 0) {
 810       if (cmds->name[len] == '\0') {
 811         *pmatch = 1;
 812         return cmds;
 813       }
 814       nmatch++;
 815       found = cmds;
 816     } else if (cmds->alias && strncasecmp(str, cmds->alias, len) == 0) {
 817       if (cmds->alias[len] == '\0') {
 818         *pmatch = 1;
 819         return cmds;
 820       }
 821       nmatch++;
 822       found = cmds;
 823     }
 824     cmds++;
 825   }
 826   *pmatch = nmatch;
 827   return found;
 828 }
 829
 830 static const char *
 831 mkPrefix(int argc, char const *const *argv, char *tgt, int sz)
 832 {
 833   int f, tlen, len;
 834
 835   tlen = 0;
 836   for (f = 0; f < argc && tlen < sz - 2; f++) {
 837     if (f)
 838       tgt[tlen++] = ' ';
 839     len = strlen(argv[f]);
 840     if (len > sz - tlen - 1)
 841       len = sz - tlen - 1;
 842     strncpy(tgt+tlen, argv[f], len);
 843     tlen += len;
 844   }
 845   tgt[tlen] = '\0';
 846   return tgt;
 847 }
 848
 849 static int
 850 FindExec(struct bundle *bundle, struct cmdtab const *cmds, int argc, int argn,
 851          char const *const *argv, struct prompt *prompt, struct datalink *cx)
 852 {
 853   struct cmdtab const *cmd;
 854   int val = 1;
 855   int nmatch;
 856   struct cmdargs arg;
 857   char prefix[100];
 858
 859   cmd = FindCommand(cmds, argv[argn], &nmatch);
 860   if (nmatch > 1)
 861     log_Printf(LogWARN, "%s: Ambiguous command\n",
 862               mkPrefix(argn+1, argv, prefix, sizeof prefix));
 863   else if (cmd && (!prompt || (cmd->lauth & prompt->auth))) {
 864     if ((cmd->lauth & LOCAL_CX) && !cx)
 865       /* We've got no context, but we require it */
 866       cx = bundle2datalink(bundle, NULL);
 867
 868     if ((cmd->lauth & LOCAL_CX) && !cx)
 869       log_Printf(LogWARN, "%s: No context (use the `link' command)\n",
 870                 mkPrefix(argn+1, argv, prefix, sizeof prefix));
 871     else {
 872       if (cx && !(cmd->lauth & (LOCAL_CX|LOCAL_CX_OPT))) {
 873         log_Printf(LogWARN, "%s: Redundant context (%s) ignored\n",
 874                   mkPrefix(argn+1, argv, prefix, sizeof prefix), cx->name);
 875         cx = NULL;
 876       }
 877       arg.cmdtab = cmds;
 878       arg.cmd = cmd;
 879       arg.argc = argc;
 880       arg.argn = argn+1;
 881       arg.argv = argv;
 882       arg.bundle = bundle;
 883       arg.cx = cx;
 884       arg.prompt = prompt;
 885       val = (*cmd->func) (&arg);
 886     }
 887   } else
 888     log_Printf(LogWARN, "%s: Invalid command\n",
 889               mkPrefix(argn+1, argv, prefix, sizeof prefix));
 890
 891   if (val == -1)
 892     log_Printf(LogWARN, "Usage: %s\n", cmd->syntax);
 893   else if (val)
 894     log_Printf(LogWARN, "%s: Failed %d\n",
 895               mkPrefix(argn+1, argv, prefix, sizeof prefix), val);
 896
 897   return val;
 898 }
 899
 900 int
 901 command_Interpret(char *buff, int nb, char *argv[MAXARGS])
 902 {
 903   char *cp;
 904
 905   if (nb > 0) {
 906     cp = buff + strcspn(buff, "\r\n");
 907     if (cp)
 908       *cp = '\0';
 909     return MakeArgs(buff, argv, MAXARGS);
 910   }
 911   return 0;
 912 }
 913
 914 static int
 915 arghidden(int argc, char const *const *argv, int n)
 916 {
 917   /* Is arg n of the given command to be hidden from the log ? */
 918
 919   /* set authkey xxxxx */
 920   /* set key xxxxx */
 921   if (n == 2 && !strncasecmp(argv[0], "se", 2) &&
 922       (!strncasecmp(argv[1], "authk", 5) || !strncasecmp(argv[1], "ke", 2)))
 923     return 1;
 924
 925   /* passwd xxxxx */
 926   if (n == 1 && !strncasecmp(argv[0], "p", 1))
 927     return 1;
 928
 929   /* set server port xxxxx .... */
 930   if (n == 3 && !strncasecmp(argv[0], "se", 2) &&
 931       !strncasecmp(argv[1], "se", 2))
 932     return 1;
 933
 934   return 0;
 935 }
 936
 937 void
 938 command_Run(struct bundle *bundle, int argc, char const *const *argv,
 939            struct prompt *prompt, const char *label, struct datalink *cx)
 940 {
 941   if (argc > 0) {
 942     if (log_IsKept(LogCOMMAND)) {
 943       char buf[LINE_LEN];
 944       int f, n;
 945
 946       if (label) {
 947         strncpy(buf, label, sizeof buf - 3);
 948         buf[sizeof buf - 3] = '\0';
 949         strcat(buf, ": ");
 950         n = strlen(buf);
 951       } else {
 952         *buf = '\0';
 953         n = 0;
 954       }
 955       buf[sizeof buf - 1] = '\0';       /* In case we run out of room in buf */
 956
 957       for (f = 0; f < argc; f++) {
 958         if (n < sizeof buf - 1 && f)
 959           buf[n++] = ' ';
 960         if (arghidden(argc, argv, f))
 961           strncpy(buf+n, "********", sizeof buf - n - 1);
 962         else
 963           strncpy(buf+n, argv[f], sizeof buf - n - 1);
 964         n += strlen(buf+n);
 965       }
 966       log_Printf(LogCOMMAND, "%s\n", buf);
 967     }
 968     FindExec(bundle, Commands, argc, 0, argv, prompt, cx);
 969   }
 970 }
 971
 972 void
 973 command_Decode(struct bundle *bundle, char *buff, int nb, struct prompt *prompt,
 974               const char *label)
 975 {
 976   int argc;
 977   char *argv[MAXARGS];
 978
 979   argc = command_Interpret(buff, nb, argv);
 980   command_Run(bundle, argc, (char const *const *)argv, prompt, label, NULL);
 981 }
 982
 983 static int
 984 ShowCommand(struct cmdargs const *arg)
 985 {
 986   if (!arg->prompt)
 987     log_Printf(LogWARN, "show: Cannot show without a prompt\n");
 988   else if (arg->argc > arg->argn)
 989     FindExec(arg->bundle, ShowCommands, arg->argc, arg->argn, arg->argv,
 990              arg->prompt, arg->cx);
 991   else
 992     prompt_Printf(arg->prompt, "Use ``show ?'' to get a list.\n");
 993
 994   return 0;
 995 }
 996
 997 static int
 998 TerminalCommand(struct cmdargs const *arg)
 999 {
1000   if (!arg->prompt) {
1001     log_Printf(LogWARN, "term: Need a prompt\n");
1002     return 1;
1003   }
1004
1005   if (arg->cx->physical->link.lcp.fsm.state > ST_CLOSED) {
1006     prompt_Printf(arg->prompt, "LCP state is [%s]\n",
1007                   State2Nam(arg->cx->physical->link.lcp.fsm.state));
1008     return 1;
1009   }
1010
1011   datalink_Up(arg->cx, 0, 0);
1012   prompt_TtyTermMode(arg->prompt, arg->cx);
1013   return 0;
1014 }
1015
1016 static int
1017 QuitCommand(struct cmdargs const *arg)
1018 {
1019   if (!arg->prompt || prompt_IsController(arg->prompt) ||
1020       (arg->argc > arg->argn && !strcasecmp(arg->argv[arg->argn], "all") &&
1021        (arg->prompt->auth & LOCAL_AUTH)))
1022     Cleanup(EX_NORMAL);
1023   if (arg->prompt)
1024     prompt_Destroy(arg->prompt, 1);
1025
1026   return 0;
1027 }
1028
1029 static int
1030 OpenCommand(struct cmdargs const *arg)
1031 {
1032   if (arg->argc == arg->argn)
1033     bundle_Open(arg->bundle, arg->cx ? arg->cx->name : NULL, PHYS_ALL, 1);
1034   else if (arg->argc == arg->argn + 1) {
1035     if (!strcasecmp(arg->argv[arg->argn], "lcp")) {
1036       struct datalink *cx = arg->cx ?
1037         arg->cx : bundle2datalink(arg->bundle, NULL);
1038       if (cx) {
1039         if (cx->physical->link.lcp.fsm.state == ST_OPENED)
1040           fsm_Reopen(&cx->physical->link.lcp.fsm);
1041         else
1042           bundle_Open(arg->bundle, cx->name, PHYS_ALL, 1);
1043       } else
1044         log_Printf(LogWARN, "open lcp: You must specify a link\n");
1045     } else if (!strcasecmp(arg->argv[arg->argn], "ccp")) {
1046       struct fsm *fp;
1047
1048       fp = &command_ChooseLink(arg)->ccp.fsm;
1049       if (fp->link->lcp.fsm.state != ST_OPENED)
1050         log_Printf(LogWARN, "open: LCP must be open before opening CCP\n");
1051       else if (fp->state == ST_OPENED)
1052         fsm_Reopen(fp);
1053       else {
1054         fp->open_mode = 0;      /* Not passive any more */
1055         if (fp->state == ST_STOPPED) {
1056           fsm_Down(fp);
1057           fsm_Up(fp);
1058         } else {
1059           fsm_Up(fp);
1060           fsm_Open(fp);
1061         }
1062       }
1063     } else if (!strcasecmp(arg->argv[arg->argn], "ipcp")) {
1064       if (arg->cx)
1065         log_Printf(LogWARN, "open ipcp: You need not specify a link\n");
1066       if (arg->bundle->ncp.ipcp.fsm.state == ST_OPENED)
1067         fsm_Reopen(&arg->bundle->ncp.ipcp.fsm);
1068       else
1069         bundle_Open(arg->bundle, NULL, PHYS_ALL, 1);
1070     } else
1071       return -1;
1072   } else
1073     return -1;
1074
1075   return 0;
1076 }
1077
1078 static int
1079 CloseCommand(struct cmdargs const *arg)
1080 {
1081   if (arg->argc == arg->argn)
1082     bundle_Close(arg->bundle, arg->cx ? arg->cx->name : NULL, CLOSE_STAYDOWN);
1083   else if (arg->argc == arg->argn + 1) {
1084     if (!strcasecmp(arg->argv[arg->argn], "lcp"))
1085       bundle_Close(arg->bundle, arg->cx ? arg->cx->name : NULL, CLOSE_LCP);
1086     else if (!strcasecmp(arg->argv[arg->argn], "ccp") ||
1087              !strcasecmp(arg->argv[arg->argn], "ccp!")) {
1088       struct fsm *fp;
1089
1090       fp = &command_ChooseLink(arg)->ccp.fsm;
1091       if (fp->state == ST_OPENED) {
1092         fsm_Close(fp);
1093         if (arg->argv[arg->argn][3] == '!')
1094           fp->open_mode = 0;            /* Stay ST_CLOSED */
1095         else
1096           fp->open_mode = OPEN_PASSIVE; /* Wait for the peer to start */
1097       }
1098     } else
1099       return -1;
1100   } else
1101     return -1;
1102
1103   return 0;
1104 }
1105
1106 static int
1107 DownCommand(struct cmdargs const *arg)
1108 {
1109   if (arg->argc == arg->argn) {
1110       if (arg->cx)
1111         datalink_Down(arg->cx, CLOSE_STAYDOWN);
1112       else
1113         bundle_Down(arg->bundle, CLOSE_STAYDOWN);
1114   } else if (arg->argc == arg->argn + 1) {
1115     if (!strcasecmp(arg->argv[arg->argn], "lcp")) {
1116       if (arg->cx)
1117         datalink_Down(arg->cx, CLOSE_LCP);
1118       else
1119         bundle_Down(arg->bundle, CLOSE_LCP);
1120     } else if (!strcasecmp(arg->argv[arg->argn], "ccp")) {
1121       struct fsm *fp = arg->cx ? &arg->cx->physical->link.ccp.fsm :
1122                                  &arg->bundle->ncp.mp.link.ccp.fsm;
1123       fsm2initial(fp);
1124     } else
1125       return -1;
1126   } else
1127     return -1;
1128
1129   return 0;
1130 }
1131
1132 static int
1133 SetModemSpeed(struct cmdargs const *arg)
1134 {
1135   long speed;
1136   char *end;
1137
1138   if (arg->argc > arg->argn && *arg->argv[arg->argn]) {
1139     if (arg->argc > arg->argn+1) {
1140       log_Printf(LogWARN, "SetModemSpeed: Too many arguments");
1141       return -1;
1142     }
1143     if (strcasecmp(arg->argv[arg->argn], "sync") == 0) {
1144       physical_SetSync(arg->cx->physical);
1145       return 0;
1146     }
1147     end = NULL;
1148     speed = strtol(arg->argv[arg->argn], &end, 10);
1149     if (*end) {
1150       log_Printf(LogWARN, "SetModemSpeed: Bad argument \"%s\"",
1151                 arg->argv[arg->argn]);
1152       return -1;
1153     }
1154     if (physical_SetSpeed(arg->cx->physical, speed))
1155       return 0;
1156     log_Printf(LogWARN, "%s: Invalid speed\n", arg->argv[arg->argn]);
1157   } else
1158     log_Printf(LogWARN, "SetModemSpeed: No speed specified\n");
1159
1160   return -1;
1161 }
1162
1163 static int
1164 SetStoppedTimeout(struct cmdargs const *arg)
1165 {
1166   struct link *l = &arg->cx->physical->link;
1167
1168   l->lcp.fsm.StoppedTimer.load = 0;
1169   l->ccp.fsm.StoppedTimer.load = 0;
1170   if (arg->argc <= arg->argn+2) {
1171     if (arg->argc > arg->argn) {
1172       l->lcp.fsm.StoppedTimer.load = atoi(arg->argv[arg->argn]) * SECTICKS;
1173       if (arg->argc > arg->argn+1)
1174         l->ccp.fsm.StoppedTimer.load = atoi(arg->argv[arg->argn+1]) * SECTICKS;
1175     }
1176     return 0;
1177   }
1178   return -1;
1179 }
1180
1181 #define ismask(x) \
1182   (*x == '0' && strlen(x) == 4 && strspn(x+1, "0123456789.") == 3)
1183
1184 static int
1185 SetServer(struct cmdargs const *arg)
1186 {
1187   int res = -1;
1188
1189   if (arg->argc > arg->argn && arg->argc < arg->argn+4) {
1190     const char *port, *passwd, *mask;
1191
1192     /* What's what ? */
1193     port = arg->argv[arg->argn];
1194     if (arg->argc == arg->argn + 2) {
1195       passwd = arg->argv[arg->argn+1];
1196       mask = NULL;
1197     } else if (arg->argc == arg->argn + 3) {
1198       passwd = arg->argv[arg->argn+1];
1199       mask = arg->argv[arg->argn+2];
1200       if (!ismask(mask))
1201         return -1;
1202     } else if (strcasecmp(port, "none") == 0) {
1203       if (server_Close(arg->bundle))
1204         log_Printf(LogPHASE, "Disabled server port.\n");
1205       return 0;
1206     } else
1207       return -1;
1208
1209     strncpy(server.passwd, passwd, sizeof server.passwd - 1);
1210     server.passwd[sizeof server.passwd - 1] = '\0';
1211
1212     if (*port == '/') {
1213       mode_t imask;
1214       char *ptr, name[LINE_LEN + 12];
1215
1216       if (mask != NULL) {
1217         unsigned m;
1218
1219         if (sscanf(mask, "%o", &m) == 1)
1220           imask = m;
1221         else
1222           return -1;
1223       } else
1224         imask = (mode_t)-1;
1225
1226       ptr = strstr(port, "%d");
1227       if (ptr) {
1228         snprintf(name, sizeof name, "%.*s%d%s",
1229                  (int)(ptr - port), port, arg->bundle->unit, ptr + 2);
1230         port = name;
1231       }
1232       res = server_LocalOpen(arg->bundle, port, imask);
1233     } else {
1234       int iport, add = 0;
1235
1236       if (mask != NULL)
1237         return -1;
1238
1239       if (*port == '+') {
1240         port++;
1241         add = 1;
1242       }
1243       if (strspn(port, "0123456789") != strlen(port)) {
1244         struct servent *s;
1245
1246         if ((s = getservbyname(port, "tcp")) == NULL) {
1247           iport = 0;
1248           log_Printf(LogWARN, "%s: Invalid port or service\n", port);
1249         } else
1250           iport = ntohs(s->s_port);
1251       } else
1252         iport = atoi(port);
1253
1254       if (iport) {
1255         if (add)
1256           iport += arg->bundle->unit;
1257         res = server_TcpOpen(arg->bundle, iport);
1258       } else
1259         res = -1;
1260     }
1261   }
1262
1263   return res;
1264 }
1265
1266 static int
1267 SetEscape(struct cmdargs const *arg)
1268 {
1269   int code;
1270   int argc = arg->argc - arg->argn;
1271   char const *const *argv = arg->argv + arg->argn;
1272
1273   for (code = 0; code < 33; code++)
1274     arg->cx->physical->async.cfg.EscMap[code] = 0;
1275
1276   while (argc-- > 0) {
1277     sscanf(*argv++, "%x", &code);
1278     code &= 0xff;
1279     arg->cx->physical->async.cfg.EscMap[code >> 3] |= (1 << (code & 7));
1280     arg->cx->physical->async.cfg.EscMap[32] = 1;
1281   }
1282   return 0;
1283 }
1284
1285 static int
1286 SetInterfaceAddr(struct cmdargs const *arg)
1287 {
1288   struct ipcp *ipcp = &arg->bundle->ncp.ipcp;
1289   const char *hisaddr;
1290
1291   if (arg->argc > arg->argn + 4)
1292     return -1;
1293
1294   hisaddr = NULL;
1295   memset(&ipcp->cfg.my_range, '\0', sizeof ipcp->cfg.my_range);
1296   memset(&ipcp->cfg.peer_range, '\0', sizeof ipcp->cfg.peer_range);
1297   ipcp->cfg.HaveTriggerAddress = 0;
1298   ipcp->cfg.netmask.s_addr = INADDR_ANY;
1299   iplist_reset(&ipcp->cfg.peer_list);
1300
1301   if (arg->argc > arg->argn) {
1302     if (!ParseAddr(ipcp, arg->argv[arg->argn],
1303                    &ipcp->cfg.my_range.ipaddr, &ipcp->cfg.my_range.mask,
1304                    &ipcp->cfg.my_range.width))
1305       return 1;
1306     if (arg->argc > arg->argn+1) {
1307       hisaddr = arg->argv[arg->argn+1];
1308       if (arg->argc > arg->argn+2) {
1309         ipcp->ifmask = ipcp->cfg.netmask = GetIpAddr(arg->argv[arg->argn+2]);
1310         if (arg->argc > arg->argn+3) {
1311           ipcp->cfg.TriggerAddress = GetIpAddr(arg->argv[arg->argn+3]);
1312           ipcp->cfg.HaveTriggerAddress = 1;
1313         }
1314       }
1315     }
1316   }
1317
1318   /* 0.0.0.0 means any address (0 bits) */
1319   if (ipcp->cfg.my_range.ipaddr.s_addr == INADDR_ANY) {
1320     ipcp->cfg.my_range.mask.s_addr = INADDR_ANY;
1321     ipcp->cfg.my_range.width = 0;
1322   }
1323   ipcp->my_ip.s_addr = ipcp->cfg.my_range.ipaddr.s_addr;
1324   bundle_AdjustFilters(arg->bundle, &ipcp->my_ip, NULL);
1325
1326   if (hisaddr && !ipcp_UseHisaddr(arg->bundle, hisaddr,
1327                                   arg->bundle->phys_type.all & PHYS_AUTO))
1328     return 4;
1329
1330   return 0;
1331 }
1332
1333 static int
1334 SetRetry(int argc, char const *const *argv, u_int *timeout, u_int *maxreq,
1335           u_int *maxtrm, int def)
1336 {
1337   if (argc == 0) {
1338     *timeout = DEF_FSMRETRY;
1339     *maxreq = def;
1340     if (maxtrm != NULL)
1341       *maxtrm = def;
1342   } else {
1343     long l = atol(argv[0]);
1344
1345     if (l < MIN_FSMRETRY) {
1346       log_Printf(LogWARN, "%ld: Invalid FSM retry period - min %d\n",
1347                  l, MIN_FSMRETRY);
1348       return 1;
1349     } else
1350       *timeout = l;
1351
1352     if (argc > 1) {
1353       l = atol(argv[1]);
1354       if (l < 1) {
1355         log_Printf(LogWARN, "%ld: Invalid FSM REQ tries - changed to 1\n", l);
1356         l = 1;
1357       }
1358       *maxreq = l;
1359
1360       if (argc > 2 && maxtrm != NULL) {
1361         l = atol(argv[2]);
1362         if (l < 1) {
1363           log_Printf(LogWARN, "%ld: Invalid FSM TRM tries - changed to 1\n", l);
1364           l = 1;
1365         }
1366         *maxtrm = l;
1367       }
1368     }
1369   }
1370
1371   return 0;
1372 }
1373
1374 static int
1375 SetVariable(struct cmdargs const *arg)
1376 {
1377   long long_val, param = (long)arg->cmd->args;
1378   int mode, dummyint;
1379   const char *argp;
1380   struct datalink *cx = arg->cx;        /* LOCAL_CX uses this */
1381   const char *err = NULL;
1382   struct link *l = command_ChooseLink(arg);     /* LOCAL_CX_OPT uses this */
1383   struct in_addr dummyaddr, *addr;
1384
1385   if (arg->argc > arg->argn)
1386     argp = arg->argv[arg->argn];
1387   else
1388     argp = "";
1389
1390   if ((arg->cmd->lauth & LOCAL_CX) && !cx) {
1391     log_Printf(LogWARN, "set %s: No context (use the `link' command)\n",
1392               arg->cmd->name);
1393     return 1;
1394   } else if (cx && !(arg->cmd->lauth & (LOCAL_CX|LOCAL_CX_OPT))) {
1395     log_Printf(LogWARN, "set %s: Redundant context (%s) ignored\n",
1396               arg->cmd->name, cx->name);
1397     cx = NULL;
1398   }
1399
1400   switch (param) {
1401   case VAR_AUTHKEY:
1402     strncpy(arg->bundle->cfg.auth.key, argp,
1403             sizeof arg->bundle->cfg.auth.key - 1);
1404     arg->bundle->cfg.auth.key[sizeof arg->bundle->cfg.auth.key - 1] = '\0';
1405     break;
1406
1407   case VAR_AUTHNAME:
1408     switch (bundle_Phase(arg->bundle)) {
1409       case PHASE_DEAD:
1410       case PHASE_ESTABLISH:
1411         strncpy(arg->bundle->cfg.auth.name, argp,
1412                 sizeof arg->bundle->cfg.auth.name - 1);
1413         arg->bundle->cfg.auth.name[sizeof arg->bundle->cfg.auth.name-1] = '\0';
1414         break;
1415       default:
1416         err = "set authname: Only available at phase DEAD/ESTABLISH\n";
1417         log_Printf(LogWARN, err);
1418         break;
1419     }
1420     break;
1421
1422   case VAR_AUTOLOAD:
1423     if (arg->argc == arg->argn + 3) {
1424       int v1, v2, v3;
1425       char *end;
1426
1427       v1 = strtol(arg->argv[arg->argn], &end, 0);
1428       if (v1 < 0 || *end) {
1429         log_Printf(LogWARN, "autoload: %s: Invalid min percentage\n",
1430                    arg->argv[arg->argn]);
1431         return 1;
1432       }
1433
1434       v2 = strtol(arg->argv[arg->argn + 1], &end, 0);
1435       if (v2 < 0 || *end) {
1436         log_Printf(LogWARN, "autoload: %s: Invalid max percentage\n",
1437                    arg->argv[arg->argn + 1]);
1438         return 1;
1439       }
1440       if (v2 < v1) {
1441         v3 = v1;
1442         v1 = v2;
1443         v2 = v3;
1444       }
1445
1446       v3 = strtol(arg->argv[arg->argn + 2], &end, 0);
1447       if (v3 <= 0 || *end) {
1448         log_Printf(LogWARN, "autoload: %s: Invalid throughput period\n",
1449                    arg->argv[arg->argn + 2]);
1450         return 1;
1451       }
1452
1453       arg->bundle->ncp.mp.cfg.autoload.min = v1;
1454       arg->bundle->ncp.mp.cfg.autoload.max = v2;
1455       arg->bundle->ncp.mp.cfg.autoload.period = v3;
1456       mp_RestartAutoloadTimer(&arg->bundle->ncp.mp);
1457     } else {
1458       err = "Set autoload requires three arguments\n";
1459       log_Printf(LogWARN, err);
1460     }
1461     break;
1462
1463   case VAR_DIAL:
1464     strncpy(cx->cfg.script.dial, argp, sizeof cx->cfg.script.dial - 1);
1465     cx->cfg.script.dial[sizeof cx->cfg.script.dial - 1] = '\0';
1466     break;
1467
1468   case VAR_LOGIN:
1469     strncpy(cx->cfg.script.login, argp, sizeof cx->cfg.script.login - 1);
1470     cx->cfg.script.login[sizeof cx->cfg.script.login - 1] = '\0';
1471     break;
1472
1473   case VAR_WINSIZE:
1474     if (arg->argc > arg->argn) {
1475       l->ccp.cfg.deflate.out.winsize = atoi(arg->argv[arg->argn]);
1476       if (l->ccp.cfg.deflate.out.winsize < 8 ||
1477           l->ccp.cfg.deflate.out.winsize > 15) {
1478           log_Printf(LogWARN, "%d: Invalid outgoing window size\n",
1479                     l->ccp.cfg.deflate.out.winsize);
1480           l->ccp.cfg.deflate.out.winsize = 15;
1481       }
1482       if (arg->argc > arg->argn+1) {
1483         l->ccp.cfg.deflate.in.winsize = atoi(arg->argv[arg->argn+1]);
1484         if (l->ccp.cfg.deflate.in.winsize < 8 ||
1485             l->ccp.cfg.deflate.in.winsize > 15) {
1486             log_Printf(LogWARN, "%d: Invalid incoming window size\n",
1487                       l->ccp.cfg.deflate.in.winsize);
1488             l->ccp.cfg.deflate.in.winsize = 15;
1489         }
1490       } else
1491         l->ccp.cfg.deflate.in.winsize = 0;
1492     } else {
1493       err = "No window size specified\n";
1494       log_Printf(LogWARN, err);
1495     }
1496     break;
1497
1498   case VAR_DEVICE:
1499     physical_SetDeviceList(cx->physical, arg->argc - arg->argn,
1500                            arg->argv + arg->argn);
1501     break;
1502
1503   case VAR_ACCMAP:
1504     if (arg->argc > arg->argn) {
1505       u_long ulong_val;
1506       sscanf(argp, "%lx", &ulong_val);
1507       cx->physical->link.lcp.cfg.accmap = (u_int32_t)ulong_val;
1508     } else {
1509       err = "No accmap specified\n";
1510       log_Printf(LogWARN, err);
1511     }
1512     break;
1513
1514   case VAR_MODE:
1515     mode = Nam2mode(argp);
1516     if (mode == PHYS_NONE || mode == PHYS_ALL) {
1517       log_Printf(LogWARN, "%s: Invalid mode\n", argp);
1518       return -1;
1519     }
1520     bundle_SetMode(arg->bundle, cx, mode);
1521     break;
1522
1523   case VAR_MRRU:
1524     switch (bundle_Phase(arg->bundle)) {
1525       case PHASE_DEAD:
1526         break;
1527       case PHASE_ESTABLISH:
1528         /* Make sure none of our links are DATALINK_LCP or greater */
1529         if (bundle_HighestState(arg->bundle) >= DATALINK_LCP) {
1530           log_Printf(LogWARN, "mrru: Only changable before LCP negotiations\n");
1531           return 1;
1532         }
1533         break;
1534       default:
1535         log_Printf(LogWARN, "mrru: Only changable at phase DEAD/ESTABLISH\n");
1536         return 1;
1537     }
1538     long_val = atol(argp);
1539     if (long_val && long_val < MIN_MRU) {
1540       log_Printf(LogWARN, "MRRU %ld: too small - min %d\n", long_val, MIN_MRU);
1541       return 1;
1542     } else if (long_val > MAX_MRU) {
1543       log_Printf(LogWARN, "MRRU %ld: too big - max %d\n", long_val, MAX_MRU);
1544       return 1;
1545     } else
1546       arg->bundle->ncp.mp.cfg.mrru = long_val;
1547     break;
1548
1549   case VAR_MRU:
1550     long_val = atol(argp);
1551     if (long_val == 0)
1552       l->lcp.cfg.mru = DEF_MRU;
1553     else if (long_val < MIN_MRU) {
1554       log_Printf(LogWARN, "MRU %ld: too small - min %d\n", long_val, MIN_MRU);
1555       return 1;
1556     } else if (long_val > MAX_MRU) {
1557       log_Printf(LogWARN, "MRU %ld: too big - max %d\n", long_val, MAX_MRU);
1558       return 1;
1559     } else
1560       l->lcp.cfg.mru = long_val;
1561     break;
1562
1563   case VAR_MTU:
1564     long_val = atol(argp);
1565     if (long_val && long_val < MIN_MTU) {
1566       log_Printf(LogWARN, "MTU %ld: too small - min %d\n", long_val, MIN_MTU);
1567       return 1;
1568     } else if (long_val > MAX_MTU) {
1569       log_Printf(LogWARN, "MTU %ld: too big - max %d\n", long_val, MAX_MTU);
1570       return 1;
1571     } else
1572       arg->bundle->cfg.mtu = long_val;
1573     break;
1574
1575   case VAR_OPENMODE:
1576     if (strcasecmp(argp, "active") == 0)
1577       cx->physical->link.lcp.cfg.openmode = arg->argc > arg->argn+1 ?
1578         atoi(arg->argv[arg->argn+1]) : 1;
1579     else if (strcasecmp(argp, "passive") == 0)
1580       cx->physical->link.lcp.cfg.openmode = OPEN_PASSIVE;
1581     else {
1582       err = "%s: Invalid openmode\n";
1583       log_Printf(LogWARN, err, argp);
1584     }
1585     break;
1586
1587   case VAR_PHONE:
1588     strncpy(cx->cfg.phone.list, argp, sizeof cx->cfg.phone.list - 1);
1589     cx->cfg.phone.list[sizeof cx->cfg.phone.list - 1] = '\0';
1590     cx->phone.alt = cx->phone.next = NULL;
1591     break;
1592
1593   case VAR_HANGUP:
1594     strncpy(cx->cfg.script.hangup, argp, sizeof cx->cfg.script.hangup - 1);
1595     cx->cfg.script.hangup[sizeof cx->cfg.script.hangup - 1] = '\0';
1596     break;
1597
1598   case VAR_IDLETIMEOUT:
1599     if (arg->argc > arg->argn+2)
1600       err = "Too many idle timeout values\n";
1601     else if (arg->argc == arg->argn)
1602       err = "Too few idle timeout values\n";
1603     else {
1604       int timeout, min;
1605
1606       timeout = atoi(argp);
1607       min = arg->argc == arg->argn + 2 ? atoi(arg->argv[arg->argn + 1]) : -1;
1608       bundle_SetIdleTimer(arg->bundle, timeout, min);
1609     }
1610     if (err)
1611       log_Printf(LogWARN, err);
1612     break;
1613
1614   case VAR_LQRPERIOD:
1615     long_val = atol(argp);
1616     if (long_val < MIN_LQRPERIOD) {
1617       log_Printf(LogWARN, "%ld: Invalid lqr period - min %d\n",
1618                  long_val, MIN_LQRPERIOD);
1619       return 1;
1620     } else
1621       l->lcp.cfg.lqrperiod = long_val;
1622     break;
1623
1624   case VAR_LCPRETRY:
1625     return SetRetry(arg->argc - arg->argn, arg->argv + arg->argn,
1626                     &cx->physical->link.lcp.cfg.fsm.timeout,
1627                     &cx->physical->link.lcp.cfg.fsm.maxreq,
1628                     &cx->physical->link.lcp.cfg.fsm.maxtrm, DEF_FSMTRIES);
1629     break;
1630
1631   case VAR_CHAPRETRY:
1632     return SetRetry(arg->argc - arg->argn, arg->argv + arg->argn,
1633                     &cx->chap.auth.cfg.fsm.timeout,
1634                     &cx->chap.auth.cfg.fsm.maxreq, NULL, DEF_FSMAUTHTRIES);
1635     break;
1636
1637   case VAR_PAPRETRY:
1638     return SetRetry(arg->argc - arg->argn, arg->argv + arg->argn,
1639                     &cx->pap.cfg.fsm.timeout, &cx->pap.cfg.fsm.maxreq,
1640                     NULL, DEF_FSMAUTHTRIES);
1641     break;
1642
1643   case VAR_CCPRETRY:
1644     return SetRetry(arg->argc - arg->argn, arg->argv + arg->argn,
1645                     &l->ccp.cfg.fsm.timeout, &l->ccp.cfg.fsm.maxreq,
1646                     &l->ccp.cfg.fsm.maxtrm, DEF_FSMTRIES);
1647     break;
1648
1649   case VAR_IPCPRETRY:
1650     return SetRetry(arg->argc - arg->argn, arg->argv + arg->argn,
1651                     &arg->bundle->ncp.ipcp.cfg.fsm.timeout,
1652                     &arg->bundle->ncp.ipcp.cfg.fsm.maxreq,
1653                     &arg->bundle->ncp.ipcp.cfg.fsm.maxtrm, DEF_FSMTRIES);
1654     break;
1655
1656   case VAR_NBNS:
1657   case VAR_DNS:
1658     if (param == VAR_DNS)
1659       addr = arg->bundle->ncp.ipcp.cfg.ns.dns;
1660     else
1661       addr = arg->bundle->ncp.ipcp.cfg.ns.nbns;
1662
1663     addr[0].s_addr = addr[1].s_addr = INADDR_ANY;
1664
1665     if (arg->argc > arg->argn) {
1666       ParseAddr(&arg->bundle->ncp.ipcp, arg->argv[arg->argn],
1667                 addr, &dummyaddr, &dummyint);
1668       if (arg->argc > arg->argn+1)
1669         ParseAddr(&arg->bundle->ncp.ipcp, arg->argv[arg->argn + 1],
1670                   addr + 1, &dummyaddr, &dummyint);
1671
1672       if (addr[1].s_addr == INADDR_ANY)
1673         addr[1].s_addr = addr[0].s_addr;
1674       if (addr[0].s_addr == INADDR_ANY)
1675         addr[0].s_addr = addr[1].s_addr;
1676     }
1677     break;
1678
1679   case VAR_CALLBACK:
1680     cx->cfg.callback.opmask = 0;
1681     for (dummyint = arg->argn; dummyint < arg->argc; dummyint++) {
1682       if (!strcasecmp(arg->argv[dummyint], "auth"))
1683         cx->cfg.callback.opmask |= CALLBACK_BIT(CALLBACK_AUTH);
1684       else if (!strcasecmp(arg->argv[dummyint], "cbcp"))
1685         cx->cfg.callback.opmask |= CALLBACK_BIT(CALLBACK_CBCP);
1686       else if (!strcasecmp(arg->argv[dummyint], "e.164")) {
1687         if (dummyint == arg->argc - 1)
1688           log_Printf(LogWARN, "No E.164 arg (E.164 ignored) !\n");
1689         else {
1690           cx->cfg.callback.opmask |= CALLBACK_BIT(CALLBACK_E164);
1691           strncpy(cx->cfg.callback.msg, arg->argv[++dummyint],
1692                   sizeof cx->cfg.callback.msg - 1);
1693           cx->cfg.callback.msg[sizeof cx->cfg.callback.msg - 1] = '\0';
1694         }
1695       } else if (!strcasecmp(arg->argv[dummyint], "none"))
1696         cx->cfg.callback.opmask |= CALLBACK_BIT(CALLBACK_NONE);
1697       else
1698         return -1;
1699     }
1700     if (cx->cfg.callback.opmask == CALLBACK_BIT(CALLBACK_NONE))
1701       cx->cfg.callback.opmask = 0;
1702     break;
1703
1704   case VAR_CBCP:
1705     cx->cfg.cbcp.delay = 0;
1706     *cx->cfg.cbcp.phone = '\0';
1707     cx->cfg.cbcp.fsmretry = DEF_FSMRETRY;
1708     if (arg->argc > arg->argn) {
1709       strncpy(cx->cfg.cbcp.phone, arg->argv[arg->argn],
1710               sizeof cx->cfg.cbcp.phone - 1);
1711       cx->cfg.cbcp.phone[sizeof cx->cfg.cbcp.phone - 1] = '\0';
1712       if (arg->argc > arg->argn + 1) {
1713         cx->cfg.cbcp.delay = atoi(arg->argv[arg->argn + 1]);
1714         if (arg->argc > arg->argn + 2) {
1715           long_val = atol(arg->argv[arg->argn + 2]);
1716           if (long_val < MIN_FSMRETRY)
1717             log_Printf(LogWARN, "%ld: Invalid CBCP FSM retry period - min %d\n",
1718                        long_val, MIN_FSMRETRY);
1719           else
1720             cx->cfg.cbcp.fsmretry = long_val;
1721         }
1722       }
1723     }
1724     break;
1725
1726   case VAR_CHOKED:
1727     arg->bundle->cfg.choked.timeout = atoi(argp);
1728     if (arg->bundle->cfg.choked.timeout <= 0)
1729       arg->bundle->cfg.choked.timeout = CHOKED_TIMEOUT;
1730     break;
1731
1732   case VAR_SENDPIPE:
1733     long_val = atol(argp);
1734     arg->bundle->ncp.ipcp.cfg.sendpipe = long_val;
1735     break;
1736
1737   case VAR_RECVPIPE:
1738     long_val = atol(argp);
1739     arg->bundle->ncp.ipcp.cfg.recvpipe = long_val;
1740     break;
1741
1742 #ifndef NORADIUS
1743   case VAR_RADIUS:
1744     if (!*argp)
1745       *arg->bundle->radius.cfg.file = '\0';
1746     else if (access(argp, R_OK)) {
1747       log_Printf(LogWARN, "%s: %s\n", argp, strerror(errno));
1748       return 1;
1749     } else {
1750       strncpy(arg->bundle->radius.cfg.file, argp,
1751               sizeof arg->bundle->radius.cfg.file - 1);
1752       arg->bundle->radius.cfg.file
1753         [sizeof arg->bundle->radius.cfg.file - 1] = '\0';
1754     }
1755     break;
1756 #endif
1757
1758   case VAR_CD:
1759     if (*argp) {
1760       long_val = atol(argp);
1761       if (long_val < 0)
1762         long_val = 0;
1763       cx->physical->cfg.cd.delay = long_val;
1764       cx->physical->cfg.cd.required = argp[strlen(argp)-1] == '!';
1765     } else {
1766       cx->physical->cfg.cd.delay = DEF_CDDELAY;
1767       cx->physical->cfg.cd.required = 0;
1768     }
1769     break;
1770
1771   case VAR_PARITY:
1772     if (arg->argc == arg->argn + 1)
1773       return physical_SetParity(arg->cx->physical, argp);
1774     else {
1775       err = "Parity value must be odd, even or none\n";
1776       log_Printf(LogWARN, err);
1777     }
1778     break;
1779
1780   case VAR_CRTSCTS:
1781     if (strcasecmp(argp, "on") == 0)
1782       physical_SetRtsCts(arg->cx->physical, 1);
1783     else if (strcasecmp(argp, "off") == 0)
1784       physical_SetRtsCts(arg->cx->physical, 0);
1785     else {
1786       err = "RTS/CTS value must be on or off\n";
1787       log_Printf(LogWARN, err);
1788     }
1789     break;
1790   }
1791
1792   return err ? 1 : 0;
1793 }
1794
1795 static struct cmdtab const SetCommands[] = {
1796   {"accmap", NULL, SetVariable, LOCAL_AUTH | LOCAL_CX,
1797   "accmap value", "set accmap hex-value", (const void *)VAR_ACCMAP},
1798   {"authkey", "key", SetVariable, LOCAL_AUTH,
1799   "authentication key", "set authkey|key key", (const void *)VAR_AUTHKEY},
1800   {"authname", NULL, SetVariable, LOCAL_AUTH,
1801   "authentication name", "set authname name", (const void *)VAR_AUTHNAME},
1802   {"autoload", NULL, SetVariable, LOCAL_AUTH,
1803   "auto link [de]activation", "set autoload maxtime maxload mintime minload",
1804   (const void *)VAR_AUTOLOAD},
1805   {"callback", NULL, SetVariable, LOCAL_AUTH | LOCAL_CX,
1806   "callback control", "set callback [none|auth|cbcp|"
1807   "E.164 *|number[,number]...]...", (const void *)VAR_CALLBACK},
1808   {"cbcp", NULL, SetVariable, LOCAL_AUTH | LOCAL_CX,
1809   "CBCP control", "set cbcp [*|phone[,phone...] [delay [timeout]]]",
1810   (const void *)VAR_CBCP},
1811   {"ccpretry", "ccpretries", SetVariable, LOCAL_AUTH | LOCAL_CX_OPT,
1812    "CCP retries", "set ccpretry value [attempts]", (const void *)VAR_CCPRETRY},
1813   {"cd", NULL, SetVariable, LOCAL_AUTH | LOCAL_CX, "Carrier delay requirement",
1814    "set cd value[!]", (const void *)VAR_CD},
1815   {"chapretry", "chapretries", SetVariable, LOCAL_AUTH | LOCAL_CX,
1816    "CHAP retries", "set chapretry value [attempts]",
1817    (const void *)VAR_CHAPRETRY},
1818   {"choked", NULL, SetVariable, LOCAL_AUTH,
1819   "choked timeout", "set choked [secs]", (const void *)VAR_CHOKED},
1820   {"ctsrts", "crtscts", SetVariable, LOCAL_AUTH | LOCAL_CX,
1821    "Use hardware flow control", "set ctsrts [on|off]",
1822    (const char *)VAR_CRTSCTS},
1823   {"deflate", NULL, SetVariable, LOCAL_AUTH | LOCAL_CX_OPT,
1824   "deflate window sizes", "set deflate out-winsize in-winsize",
1825   (const void *) VAR_WINSIZE},
1826   {"device", "line", SetVariable, LOCAL_AUTH | LOCAL_CX,
1827   "physical device name", "set device|line device-name[,device-name]",
1828   (const void *) VAR_DEVICE},
1829   {"dial", NULL, SetVariable, LOCAL_AUTH | LOCAL_CX,
1830   "dialing script", "set dial chat-script", (const void *) VAR_DIAL},
1831   {"dns", NULL, SetVariable, LOCAL_AUTH, "Domain Name Server",
1832   "set dns pri-addr [sec-addr]", (const void *)VAR_DNS},
1833   {"enddisc", NULL, mp_SetEnddisc, LOCAL_AUTH,
1834   "Endpoint Discriminator", "set enddisc [IP|magic|label|psn value]"},
1835   {"escape", NULL, SetEscape, LOCAL_AUTH | LOCAL_CX,
1836   "escape characters", "set escape hex-digit ..."},
1837   {"filter", NULL, filter_Set, LOCAL_AUTH,
1838   "packet filters", "set filter alive|dial|in|out rule-no permit|deny "
1839   "[src_addr[/width]] [dst_addr[/width]] [tcp|udp|icmp|ospf|igmp "
1840   "[src [lt|eq|gt port]] [dst [lt|eq|gt port]] [estab] [syn] [finrst]]"},
1841   {"hangup", NULL, SetVariable, LOCAL_AUTH | LOCAL_CX,
1842   "hangup script", "set hangup chat-script", (const void *) VAR_HANGUP},
1843   {"ifaddr", NULL, SetInterfaceAddr, LOCAL_AUTH, "destination address",
1844   "set ifaddr [src-addr [dst-addr [netmask [trg-addr]]]]"},
1845   {"ipcpretry", "ipcpretries", SetVariable, LOCAL_AUTH, "IPCP retries",
1846    "set ipcpretry value [attempts]", (const void *)VAR_IPCPRETRY},
1847   {"lcpretry", "lcpretries", SetVariable, LOCAL_AUTH | LOCAL_CX, "LCP retries",
1848    "set lcpretry value [attempts]", (const void *)VAR_LCPRETRY},
1849   {"log", NULL, log_SetLevel, LOCAL_AUTH, "log level",
1850   "set log [local] [+|-]async|cbcp|ccp|chat|command|connect|debug|hdlc|id0|"
1851   "ipcp|lcp|lqm|phase|physical|sync|tcp/ip|timer|tun..."},
1852   {"login", NULL, SetVariable, LOCAL_AUTH | LOCAL_CX,
1853   "login script", "set login chat-script", (const void *) VAR_LOGIN},
1854   {"lqrperiod", NULL, SetVariable, LOCAL_AUTH | LOCAL_CX_OPT,
1855   "LQR period", "set lqrperiod value", (const void *)VAR_LQRPERIOD},
1856   {"mode", NULL, SetVariable, LOCAL_AUTH | LOCAL_CX, "mode value",
1857   "set mode interactive|auto|ddial|background", (const void *)VAR_MODE},
1858   {"mrru", NULL, SetVariable, LOCAL_AUTH, "MRRU value",
1859   "set mrru value", (const void *)VAR_MRRU},
1860   {"mru", NULL, SetVariable, LOCAL_AUTH | LOCAL_CX_OPT,
1861   "MRU value", "set mru value", (const void *)VAR_MRU},
1862   {"mtu", NULL, SetVariable, LOCAL_AUTH,
1863   "interface MTU value", "set mtu value", (const void *)VAR_MTU},
1864   {"nbns", NULL, SetVariable, LOCAL_AUTH, "NetBIOS Name Server",
1865   "set nbns pri-addr [sec-addr]", (const void *)VAR_NBNS},
1866   {"openmode", NULL, SetVariable, LOCAL_AUTH | LOCAL_CX, "open mode",
1867   "set openmode active|passive [secs]", (const void *)VAR_OPENMODE},
1868   {"papretry", "papretries", SetVariable, LOCAL_AUTH | LOCAL_CX, "PAP retries",
1869    "set papretry value [attempts]", (const void *)VAR_PAPRETRY},
1870   {"parity", NULL, SetVariable, LOCAL_AUTH | LOCAL_CX, "serial parity",
1871    "set parity [odd|even|none]", (const void *)VAR_PARITY},
1872   {"phone", NULL, SetVariable, LOCAL_AUTH | LOCAL_CX, "telephone number(s)",
1873   "set phone phone1[:phone2[...]]", (const void *)VAR_PHONE},
1874   {"proctitle", "title", SetProcTitle, LOCAL_AUTH,
1875   "Process title", "set proctitle [value]"},
1876 #ifndef NORADIUS
1877   {"radius", NULL, SetVariable, LOCAL_AUTH,
1878   "RADIUS Config", "set radius cfgfile", (const void *)VAR_RADIUS},
1879 #endif
1880   {"reconnect", NULL, datalink_SetReconnect, LOCAL_AUTH | LOCAL_CX,
1881   "Reconnect timeout", "set reconnect value ntries"},
1882   {"recvpipe", NULL, SetVariable, LOCAL_AUTH,
1883   "RECVPIPE value", "set recvpipe value", (const void *)VAR_RECVPIPE},
1884   {"redial", NULL, datalink_SetRedial, LOCAL_AUTH | LOCAL_CX,
1885   "Redial timeout", "set redial secs[+inc[-incmax]][.next] [attempts]"},
1886   {"sendpipe", NULL, SetVariable, LOCAL_AUTH,
1887   "SENDPIPE value", "set sendpipe value", (const void *)VAR_SENDPIPE},
1888   {"server", "socket", SetServer, LOCAL_AUTH,
1889   "server port", "set server|socket TcpPort|LocalName|none password [mask]"},
1890   {"speed", NULL, SetModemSpeed, LOCAL_AUTH | LOCAL_CX,
1891   "physical speed", "set speed value|sync"},
1892   {"stopped", NULL, SetStoppedTimeout, LOCAL_AUTH | LOCAL_CX,
1893   "STOPPED timeouts", "set stopped [LCPseconds [CCPseconds]]"},
1894   {"timeout", NULL, SetVariable, LOCAL_AUTH, "Idle timeout",
1895   "set timeout idletime", (const void *)VAR_IDLETIMEOUT},
1896   {"vj", NULL, ipcp_vjset, LOCAL_AUTH,
1897   "vj values", "set vj slots|slotcomp [value]"},
1898   {"bandwidth", NULL, mp_SetDatalinkBandwidth, LOCAL_AUTH | LOCAL_CX,
1899   "datalink bandwidth", "set bandwidth value"},
1900   {"help", "?", HelpCommand, LOCAL_AUTH | LOCAL_NO_AUTH,
1901   "Display this message", "set help|? [command]", SetCommands},
1902   {NULL, NULL, NULL},
1903 };
1904
1905 static int
1906 SetCommand(struct cmdargs const *arg)
1907 {
1908   if (arg->argc > arg->argn)
1909     FindExec(arg->bundle, SetCommands, arg->argc, arg->argn, arg->argv,
1910              arg->prompt, arg->cx);
1911   else if (arg->prompt)
1912     prompt_Printf(arg->prompt, "Use `set ?' to get a list or `set ? <var>' for"
1913             " syntax help.\n");
1914   else
1915     log_Printf(LogWARN, "set command must have arguments\n");
1916
1917   return 0;
1918 }
1919
1920 static int
1921 AddCommand(struct cmdargs const *arg)
1922 {
1923   struct in_addr dest, gateway, netmask;
1924   int gw, addrs;
1925
1926   if (arg->argc != arg->argn+3 && arg->argc != arg->argn+2)
1927     return -1;
1928
1929   addrs = 0;
1930   if (arg->argc == arg->argn+2) {
1931     if (!strcasecmp(arg->argv[arg->argn], "default"))
1932       dest.s_addr = netmask.s_addr = INADDR_ANY;
1933     else {
1934       int width;
1935
1936       if (!ParseAddr(&arg->bundle->ncp.ipcp, arg->argv[arg->argn],
1937                      &dest, &netmask, &width))
1938         return -1;
1939       if (!strncasecmp(arg->argv[arg->argn], "MYADDR", 6))
1940         addrs = ROUTE_DSTMYADDR;
1941       else if (!strncasecmp(arg->argv[arg->argn], "HISADDR", 7))
1942         addrs = ROUTE_DSTHISADDR;
1943     }
1944     gw = 1;
1945   } else {
1946     if (strcasecmp(arg->argv[arg->argn], "MYADDR") == 0) {
1947       addrs = ROUTE_DSTMYADDR;
1948       dest = arg->bundle->ncp.ipcp.my_ip;
1949     } else if (strcasecmp(arg->argv[arg->argn], "HISADDR") == 0) {
1950       addrs = ROUTE_DSTHISADDR;
1951       dest = arg->bundle->ncp.ipcp.peer_ip;
1952     } else
1953       dest = GetIpAddr(arg->argv[arg->argn]);
1954     netmask = GetIpAddr(arg->argv[arg->argn+1]);
1955     gw = 2;
1956   }
1957
1958   if (strcasecmp(arg->argv[arg->argn+gw], "HISADDR") == 0) {
1959     gateway = arg->bundle->ncp.ipcp.peer_ip;
1960     addrs |= ROUTE_GWHISADDR;
1961   } else
1962     gateway = GetIpAddr(arg->argv[arg->argn+gw]);
1963
1964   if (bundle_SetRoute(arg->bundle, RTM_ADD, dest, gateway, netmask,
1965                   arg->cmd->args ? 1 : 0, (addrs & ROUTE_GWHISADDR) ? 1 : 0)
1966       && addrs != ROUTE_STATIC)
1967     route_Add(&arg->bundle->ncp.ipcp.route, addrs, dest, netmask, gateway);
1968
1969   return 0;
1970 }
1971
1972 static int
1973 DeleteCommand(struct cmdargs const *arg)
1974 {
1975   struct in_addr dest, none;
1976   int addrs;
1977
1978   if (arg->argc == arg->argn+1) {
1979     if(strcasecmp(arg->argv[arg->argn], "all") == 0) {
1980       route_IfDelete(arg->bundle, 0);
1981       route_DeleteAll(&arg->bundle->ncp.ipcp.route);
1982     } else {
1983       addrs = 0;
1984       if (strcasecmp(arg->argv[arg->argn], "MYADDR") == 0) {
1985         dest = arg->bundle->ncp.ipcp.my_ip;
1986         addrs = ROUTE_DSTMYADDR;
1987       } else if (strcasecmp(arg->argv[arg->argn], "HISADDR") == 0) {
1988         dest = arg->bundle->ncp.ipcp.peer_ip;
1989         addrs = ROUTE_DSTHISADDR;
1990       } else {
1991         dest = GetIpAddr(arg->argv[arg->argn]);
1992         if (dest.s_addr == INADDR_NONE) {
1993           log_Printf(LogWARN, "%s: Invalid IP address\n", arg->argv[arg->argn]);
1994           return -1;
1995         }
1996         addrs = ROUTE_STATIC;
1997       }
1998       none.s_addr = INADDR_ANY;
1999       bundle_SetRoute(arg->bundle, RTM_DELETE, dest, none, none,
2000                       arg->cmd->args ? 1 : 0, 0);
2001       route_Delete(&arg->bundle->ncp.ipcp.route, addrs, dest);
2002     }
2003   } else
2004     return -1;
2005
2006   return 0;
2007 }
2008
2009 #ifndef NONAT
2010 static int
2011 AliasEnable(struct cmdargs const *arg)
2012 {
2013   if (arg->argc == arg->argn+1) {
2014     if (strcasecmp(arg->argv[arg->argn], "yes") == 0) {
2015       if (!arg->bundle->NatEnabled) {
2016         if (arg->bundle->ncp.ipcp.fsm.state == ST_OPENED)
2017           PacketAliasSetAddress(arg->bundle->ncp.ipcp.my_ip);
2018         arg->bundle->NatEnabled = 1;
2019       }
2020       return 0;
2021     } else if (strcasecmp(arg->argv[arg->argn], "no") == 0) {
2022       arg->bundle->NatEnabled = 0;
2023       arg->bundle->cfg.opt &= ~OPT_IFACEALIAS;
2024       /* Don't iface_Clear() - there may be manually configured addresses */
2025       return 0;
2026     }
2027   }
2028
2029   return -1;
2030 }
2031
2032
2033 static int
2034 AliasOption(struct cmdargs const *arg)
2035 {
2036   long param = (long)arg->cmd->args;
2037
2038   if (arg->argc == arg->argn+1) {
2039     if (strcasecmp(arg->argv[arg->argn], "yes") == 0) {
2040       if (arg->bundle->NatEnabled) {
2041         PacketAliasSetMode(param, param);
2042         return 0;
2043       }
2044       log_Printf(LogWARN, "nat not enabled\n");
2045     } else if (strcmp(arg->argv[arg->argn], "no") == 0) {
2046       if (arg->bundle->NatEnabled) {
2047         PacketAliasSetMode(0, param);
2048         return 0;
2049       }
2050       log_Printf(LogWARN, "nat not enabled\n");
2051     }
2052   }
2053   return -1;
2054 }
2055 #endif /* #ifndef NONAT */
2056
2057 static int
2058 LinkCommand(struct cmdargs const *arg)
2059 {
2060   if (arg->argc > arg->argn+1) {
2061     char namelist[LINE_LEN];
2062     struct datalink *cx;
2063     char *name;
2064     int result = 0;
2065
2066     if (!strcmp(arg->argv[arg->argn], "*")) {
2067       struct datalink *dl;
2068
2069       cx = arg->bundle->links;
2070       while (cx) {
2071         /* Watch it, the command could be a ``remove'' */
2072         dl = cx->next;
2073         FindExec(arg->bundle, Commands, arg->argc, arg->argn+1, arg->argv,
2074                  arg->prompt, cx);
2075         for (cx = arg->bundle->links; cx; cx = cx->next)
2076           if (cx == dl)
2077             break;              /* Pointer's still valid ! */
2078       }
2079     } else {
2080       strncpy(namelist, arg->argv[arg->argn], sizeof namelist - 1);
2081       namelist[sizeof namelist - 1] = '\0';
2082       for(name = strtok(namelist, ", "); name; name = strtok(NULL,", "))
2083         if (!bundle2datalink(arg->bundle, name)) {
2084           log_Printf(LogWARN, "link: %s: Invalid link name\n", name);
2085           return 1;
2086         }
2087
2088       strncpy(namelist, arg->argv[arg->argn], sizeof namelist - 1);
2089       namelist[sizeof namelist - 1] = '\0';
2090       for(name = strtok(namelist, ", "); name; name = strtok(NULL,", ")) {
2091         cx = bundle2datalink(arg->bundle, name);
2092         if (cx)
2093           FindExec(arg->bundle, Commands, arg->argc, arg->argn+1, arg->argv,
2094                    arg->prompt, cx);
2095         else {
2096           log_Printf(LogWARN, "link: %s: Invalidated link name !\n", name);
2097           result++;
2098         }
2099       }
2100     }
2101     return result;
2102   }
2103
2104   log_Printf(LogWARN, "Usage: %s\n", arg->cmd->syntax);
2105   return 2;
2106 }
2107
2108 struct link *
2109 command_ChooseLink(struct cmdargs const *arg)
2110 {
2111   if (arg->cx)
2112     return &arg->cx->physical->link;
2113   else if (!arg->bundle->ncp.mp.cfg.mrru) {
2114     struct datalink *dl = bundle2datalink(arg->bundle, NULL);
2115     if (dl)
2116       return &dl->physical->link;
2117   }
2118   return &arg->bundle->ncp.mp.link;
2119 }
2120
2121 static const char *
2122 ident_cmd(const char *cmd, unsigned *keep, unsigned *add)
2123 {
2124   const char *result;
2125
2126   switch (*cmd) {
2127     case 'A':
2128     case 'a':
2129       result = "accept";
2130       *keep = NEG_MYMASK;
2131       *add = NEG_ACCEPTED;
2132       break;
2133     case 'D':
2134     case 'd':
2135       switch (cmd[1]) {
2136         case 'E':
2137         case 'e':
2138           result = "deny";
2139           *keep = NEG_MYMASK;
2140           *add = 0;
2141           break;
2142         case 'I':
2143         case 'i':
2144           result = "disable";
2145           *keep = NEG_HISMASK;
2146           *add = 0;
2147           break;
2148         default:
2149           return NULL;
2150       }
2151       break;
2152     case 'E':
2153     case 'e':
2154       result = "enable";
2155       *keep = NEG_HISMASK;
2156       *add = NEG_ENABLED;
2157       break;
2158     default:
2159       return NULL;
2160   }
2161
2162   return result;
2163 }
2164
2165 static int
2166 OptSet(struct cmdargs const *arg)
2167 {
2168   int bit = (int)(long)arg->cmd->args;
2169   const char *cmd;
2170   unsigned keep;                        /* Keep these bits */
2171   unsigned add;                         /* Add these bits */
2172
2173   if ((cmd = ident_cmd(arg->argv[arg->argn-2], &keep, &add)) == NULL)
2174     return 1;
2175
2176   if (add)
2177     arg->bundle->cfg.opt |= bit;
2178   else
2179     arg->bundle->cfg.opt &= ~bit;
2180   return 0;
2181 }
2182
2183 static int
2184 IfaceAliasOptSet(struct cmdargs const *arg)
2185 {
2186   unsigned save = arg->bundle->cfg.opt;
2187   int result = OptSet(arg);
2188
2189   if (result == 0)
2190     if (Enabled(arg->bundle, OPT_IFACEALIAS) && !arg->bundle->NatEnabled) {
2191       arg->bundle->cfg.opt = save;
2192       log_Printf(LogWARN, "Cannot enable iface-alias without NAT\n");
2193       result = 2;
2194     }
2195
2196   return result;
2197 }
2198
2199 static int
2200 NegotiateSet(struct cmdargs const *arg)
2201 {
2202   long param = (long)arg->cmd->args;
2203   struct link *l = command_ChooseLink(arg);     /* LOCAL_CX_OPT uses this */
2204   struct datalink *cx = arg->cx;        /* LOCAL_CX uses this */
2205   const char *cmd;
2206   unsigned keep;                        /* Keep these bits */
2207   unsigned add;                         /* Add these bits */
2208
2209   if ((cmd = ident_cmd(arg->argv[arg->argn-2], &keep, &add)) == NULL)
2210     return 1;
2211
2212   if ((arg->cmd->lauth & LOCAL_CX) && !cx) {
2213     log_Printf(LogWARN, "%s %s: No context (use the `link' command)\n",
2214               cmd, arg->cmd->name);
2215     return 2;
2216   } else if (cx && !(arg->cmd->lauth & (LOCAL_CX|LOCAL_CX_OPT))) {
2217     log_Printf(LogWARN, "%s %s: Redundant context (%s) ignored\n",
2218               cmd, arg->cmd->name, cx->name);
2219     cx = NULL;
2220   }
2221
2222   switch (param) {
2223     case NEG_ACFCOMP:
2224       cx->physical->link.lcp.cfg.acfcomp &= keep;
2225       cx->physical->link.lcp.cfg.acfcomp |= add;
2226       break;
2227     case NEG_CHAP05:
2228       cx->physical->link.lcp.cfg.chap05 &= keep;
2229       cx->physical->link.lcp.cfg.chap05 |= add;
2230       break;
2231 #ifdef HAVE_DES
2232     case NEG_CHAP80:
2233       cx->physical->link.lcp.cfg.chap80nt &= keep;
2234       cx->physical->link.lcp.cfg.chap80nt |= add;
2235       break;
2236     case NEG_CHAP80LM:
2237       cx->physical->link.lcp.cfg.chap80lm &= keep;
2238       cx->physical->link.lcp.cfg.chap80lm |= add;
2239       break;
2240 #endif
2241     case NEG_DEFLATE:
2242       l->ccp.cfg.neg[CCP_NEG_DEFLATE] &= keep;
2243       l->ccp.cfg.neg[CCP_NEG_DEFLATE] |= add;
2244       break;
2245     case NEG_DNS:
2246       arg->bundle->ncp.ipcp.cfg.ns.dns_neg &= keep;
2247       arg->bundle->ncp.ipcp.cfg.ns.dns_neg |= add;
2248       break;
2249     case NEG_ENDDISC:
2250       arg->bundle->ncp.mp.cfg.negenddisc &= keep;
2251       arg->bundle->ncp.mp.cfg.negenddisc |= add;
2252       break;
2253     case NEG_LQR:
2254       cx->physical->link.lcp.cfg.lqr &= keep;
2255       cx->physical->link.lcp.cfg.lqr |= add;
2256       break;
2257     case NEG_PAP:
2258       cx->physical->link.lcp.cfg.pap &= keep;
2259       cx->physical->link.lcp.cfg.pap |= add;
2260       break;
2261     case NEG_PPPDDEFLATE:
2262       l->ccp.cfg.neg[CCP_NEG_DEFLATE24] &= keep;
2263       l->ccp.cfg.neg[CCP_NEG_DEFLATE24] |= add;
2264       break;
2265     case NEG_PRED1:
2266       l->ccp.cfg.neg[CCP_NEG_PRED1] &= keep;
2267       l->ccp.cfg.neg[CCP_NEG_PRED1] |= add;
2268       break;
2269     case NEG_PROTOCOMP:
2270       cx->physical->link.lcp.cfg.protocomp &= keep;
2271       cx->physical->link.lcp.cfg.protocomp |= add;
2272       break;
2273     case NEG_SHORTSEQ:
2274       switch (bundle_Phase(arg->bundle)) {
2275         case PHASE_DEAD:
2276           break;
2277         case PHASE_ESTABLISH:
2278           /* Make sure none of our links are DATALINK_LCP or greater */
2279           if (bundle_HighestState(arg->bundle) >= DATALINK_LCP) {
2280             log_Printf(LogWARN, "shortseq: Only changable before"
2281                        " LCP negotiations\n");
2282             return 1;
2283           }
2284           break;
2285         default:
2286           log_Printf(LogWARN, "shortseq: Only changable at phase"
2287                      " DEAD/ESTABLISH\n");
2288           return 1;
2289       }
2290       arg->bundle->ncp.mp.cfg.shortseq &= keep;
2291       arg->bundle->ncp.mp.cfg.shortseq |= add;
2292       break;
2293     case NEG_VJCOMP:
2294       arg->bundle->ncp.ipcp.cfg.vj.neg &= keep;
2295       arg->bundle->ncp.ipcp.cfg.vj.neg |= add;
2296       break;
2297   }
2298
2299   return 0;
2300 }
2301
2302 static struct cmdtab const NegotiateCommands[] = {
2303   {"idcheck", NULL, OptSet, LOCAL_AUTH, "Check FSM reply ids",
2304   "disable|enable", (const void *)OPT_IDCHECK},
2305   {"iface-alias", NULL, IfaceAliasOptSet, LOCAL_AUTH,
2306    "retain interface addresses", "disable|enable",
2307    (const void *)OPT_IFACEALIAS},
2308   {"keep-session", NULL, OptSet, LOCAL_AUTH, "Retain device session leader",
2309   "disable|enable", (const void *)OPT_KEEPSESSION},
2310   {"loopback", NULL, OptSet, LOCAL_AUTH, "Loop packets for local iface",
2311   "disable|enable", (const void *)OPT_LOOPBACK},
2312   {"passwdauth", NULL, OptSet, LOCAL_AUTH, "Use passwd file",
2313   "disable|enable", (const void *)OPT_PASSWDAUTH},
2314   {"proxy", NULL, OptSet, LOCAL_AUTH, "Create a proxy ARP entry",
2315   "disable|enable", (const void *)OPT_PROXY},
2316   {"proxyall", NULL, OptSet, LOCAL_AUTH, "Proxy ARP for all remote hosts",
2317   "disable|enable", (const void *)OPT_PROXYALL},
2318   {"sroutes", NULL, OptSet, LOCAL_AUTH, "Use sticky routes",
2319   "disable|enable", (const void *)OPT_SROUTES},
2320   {"throughput", NULL, OptSet, LOCAL_AUTH, "Rolling throughput",
2321   "disable|enable", (const void *)OPT_THROUGHPUT},
2322   {"utmp", NULL, OptSet, LOCAL_AUTH, "Log connections in utmp",
2323   "disable|enable", (const void *)OPT_UTMP},
2324
2325 #define OPT_MAX 10      /* accept/deny allowed below and not above */
2326
2327   {"acfcomp", NULL, NegotiateSet, LOCAL_AUTH | LOCAL_CX,
2328   "Address & Control field compression", "accept|deny|disable|enable",
2329   (const void *)NEG_ACFCOMP},
2330   {"chap", "chap05", NegotiateSet, LOCAL_AUTH | LOCAL_CX,
2331   "Challenge Handshake Authentication Protocol", "accept|deny|disable|enable",
2332   (const void *)NEG_CHAP05},
2333 #ifdef HAVE_DES
2334   {"mschap", "chap80nt", NegotiateSet, LOCAL_AUTH | LOCAL_CX,
2335   "Microsoft (NT) CHAP", "accept|deny|disable|enable",
2336   (const void *)NEG_CHAP80},
2337   {"LANMan", "chap80lm", NegotiateSet, LOCAL_AUTH | LOCAL_CX,
2338   "Microsoft (NT) CHAP", "accept|deny|disable|enable",
2339   (const void *)NEG_CHAP80LM},
2340 #endif
2341   {"deflate", NULL, NegotiateSet, LOCAL_AUTH | LOCAL_CX_OPT,
2342   "Deflate compression", "accept|deny|disable|enable",
2343   (const void *)NEG_DEFLATE},
2344   {"deflate24", NULL, NegotiateSet, LOCAL_AUTH | LOCAL_CX_OPT,
2345   "Deflate (type 24) compression", "accept|deny|disable|enable",
2346   (const void *)NEG_PPPDDEFLATE},
2347   {"dns", NULL, NegotiateSet, LOCAL_AUTH,
2348   "DNS specification", "accept|deny|disable|enable", (const void *)NEG_DNS},
2349   {"enddisc", NULL, NegotiateSet, LOCAL_AUTH, "ENDDISC negotiation",
2350   "accept|deny|disable|enable", (const void *)NEG_ENDDISC},
2351   {"lqr", NULL, NegotiateSet, LOCAL_AUTH | LOCAL_CX,
2352   "Link Quality Reports", "accept|deny|disable|enable",
2353   (const void *)NEG_LQR},
2354   {"pap", NULL, NegotiateSet, LOCAL_AUTH | LOCAL_CX,
2355   "Password Authentication protocol", "accept|deny|disable|enable",
2356   (const void *)NEG_PAP},
2357   {"pred1", "predictor1", NegotiateSet, LOCAL_AUTH | LOCAL_CX_OPT,
2358   "Predictor 1 compression", "accept|deny|disable|enable",
2359   (const void *)NEG_PRED1},
2360   {"protocomp", NULL, NegotiateSet, LOCAL_AUTH | LOCAL_CX,
2361   "Protocol field compression", "accept|deny|disable|enable",
2362   (const void *)NEG_PROTOCOMP},
2363   {"shortseq", NULL, NegotiateSet, LOCAL_AUTH,
2364   "MP Short Sequence Numbers", "accept|deny|disable|enable",
2365   (const void *)NEG_SHORTSEQ},
2366   {"vjcomp", NULL, NegotiateSet, LOCAL_AUTH,
2367   "Van Jacobson header compression", "accept|deny|disable|enable",
2368   (const void *)NEG_VJCOMP},
2369   {"help", "?", HelpCommand, LOCAL_AUTH | LOCAL_NO_AUTH,
2370   "Display this message", "accept|deny|disable|enable help|? [value]",
2371   NegotiateCommands},
2372   {NULL, NULL, NULL},
2373 };
2374
2375 static int
2376 NegotiateCommand(struct cmdargs const *arg)
2377 {
2378   if (arg->argc > arg->argn) {
2379     char const *argv[3];
2380     unsigned keep, add;
2381     int n;
2382
2383     if ((argv[0] = ident_cmd(arg->argv[arg->argn-1], &keep, &add)) == NULL)
2384       return -1;
2385     argv[2] = NULL;
2386
2387     for (n = arg->argn; n < arg->argc; n++) {
2388       argv[1] = arg->argv[n];
2389       FindExec(arg->bundle, NegotiateCommands + (keep == NEG_HISMASK ?
2390                0 : OPT_MAX), 2, 1, argv, arg->prompt, arg->cx);
2391     }
2392   } else if (arg->prompt)
2393     prompt_Printf(arg->prompt, "Use `%s ?' to get a list.\n",
2394             arg->argv[arg->argn-1]);
2395   else
2396     log_Printf(LogWARN, "%s command must have arguments\n",
2397               arg->argv[arg->argn] );
2398
2399   return 0;
2400 }
2401
2402 const char *
2403 command_ShowNegval(unsigned val)
2404 {
2405   switch (val&3) {
2406     case 1: return "disabled & accepted";
2407     case 2: return "enabled & denied";
2408     case 3: return "enabled & accepted";
2409   }
2410   return "disabled & denied";
2411 }
2412
2413 static int
2414 ClearCommand(struct cmdargs const *arg)
2415 {
2416   struct pppThroughput *t;
2417   struct datalink *cx;
2418   int i, clear_type;
2419
2420   if (arg->argc < arg->argn + 1)
2421     return -1;
2422
2423   if (strcasecmp(arg->argv[arg->argn], "physical") == 0) {
2424     cx = arg->cx;
2425     if (!cx)
2426       cx = bundle2datalink(arg->bundle, NULL);
2427     if (!cx) {
2428       log_Printf(LogWARN, "A link must be specified for ``clear physical''\n");
2429       return 1;
2430     }
2431     t = &cx->physical->link.throughput;
2432   } else if (strcasecmp(arg->argv[arg->argn], "ipcp") == 0)
2433     t = &arg->bundle->ncp.ipcp.throughput;
2434   else
2435     return -1;
2436
2437   if (arg->argc > arg->argn + 1) {
2438     clear_type = 0;
2439     for (i = arg->argn + 1; i < arg->argc; i++)
2440       if (strcasecmp(arg->argv[i], "overall") == 0)
2441         clear_type |= THROUGHPUT_OVERALL;
2442       else if (strcasecmp(arg->argv[i], "current") == 0)
2443         clear_type |= THROUGHPUT_CURRENT;
2444       else if (strcasecmp(arg->argv[i], "peak") == 0)
2445         clear_type |= THROUGHPUT_PEAK;
2446       else
2447         return -1;
2448   } else
2449     clear_type = THROUGHPUT_ALL;
2450
2451   throughput_clear(t, clear_type, arg->prompt);
2452   return 0;
2453 }
2454
2455 static int
2456 RunListCommand(struct cmdargs const *arg)
2457 {
2458   const char *cmd = arg->argc ? arg->argv[arg->argc - 1] : "???";
2459
2460   if (arg->argc > arg->argn)
2461     FindExec(arg->bundle, arg->cmd->args, arg->argc, arg->argn, arg->argv,
2462              arg->prompt, arg->cx);
2463   else if (arg->prompt)
2464     prompt_Printf(arg->prompt, "Use `%s help' to get a list or `%s help"
2465                   " <option>' for syntax help.\n", cmd, cmd);
2466   else
2467     log_Printf(LogWARN, "%s command must have arguments\n", cmd);
2468
2469   return 0;
2470 }
2471
2472 static int
2473 IfaceAddCommand(struct cmdargs const *arg)
2474 {
2475   int bits, n, how;
2476   struct in_addr ifa, mask, brd;
2477
2478   if (arg->argc == arg->argn + 1) {
2479     if (!ParseAddr(NULL, arg->argv[arg->argn], &ifa, NULL, NULL))
2480       return -1;
2481     mask.s_addr = brd.s_addr = INADDR_BROADCAST;
2482   } else {
2483     if (arg->argc == arg->argn + 2) {
2484       if (!ParseAddr(NULL, arg->argv[arg->argn], &ifa, &mask, &bits))
2485         return -1;
2486       n = 1;
2487     } else if (arg->argc == arg->argn + 3) {
2488       if (!ParseAddr(NULL, arg->argv[arg->argn], &ifa, NULL, NULL))
2489         return -1;
2490       if (!ParseAddr(NULL, arg->argv[arg->argn + 1], &mask, NULL, NULL))
2491         return -1;
2492       n = 2;
2493     } else
2494       return -1;
2495
2496     if (!ParseAddr(NULL, arg->argv[arg->argn + n], &brd, NULL, NULL))
2497       return -1;
2498   }
2499
2500   how = IFACE_ADD_LAST;
2501   if (arg->cmd->args)
2502     how |= IFACE_FORCE_ADD;
2503
2504   return !iface_inAdd(arg->bundle->iface, ifa, mask, brd, how);
2505 }
2506
2507 static int
2508 IfaceDeleteCommand(struct cmdargs const *arg)
2509 {
2510   struct in_addr ifa;
2511   int ok;
2512
2513   if (arg->argc != arg->argn + 1)
2514     return -1;
2515
2516   if (!ParseAddr(NULL, arg->argv[arg->argn], &ifa, NULL, NULL))
2517     return -1;
2518
2519   if (arg->bundle->ncp.ipcp.fsm.state == ST_OPENED &&
2520       arg->bundle->ncp.ipcp.my_ip.s_addr == ifa.s_addr) {
2521     log_Printf(LogWARN, "%s: Cannot remove active interface address\n",
2522                inet_ntoa(ifa));
2523     return 1;
2524   }
2525
2526   ok = iface_inDelete(arg->bundle->iface, ifa);
2527   if (!ok) {
2528     if (arg->cmd->args)
2529       ok = 1;
2530     else if (arg->prompt)
2531       prompt_Printf(arg->prompt, "%s: No such address\n", inet_ntoa(ifa));
2532     else
2533       log_Printf(LogWARN, "%s: No such address\n", inet_ntoa(ifa));
2534   }
2535
2536   return !ok;
2537 }
2538
2539 static int
2540 IfaceClearCommand(struct cmdargs const *arg)
2541 {
2542   int how;
2543
2544   if (arg->argc != arg->argn)
2545     return -1;
2546
2547   how = arg->bundle->ncp.ipcp.fsm.state == ST_OPENED ||
2548         arg->bundle->phys_type.all & PHYS_AUTO ?
2549         IFACE_CLEAR_ALIASES : IFACE_CLEAR_ALL;
2550   iface_Clear(arg->bundle->iface, how);
2551
2552   return 0;
2553 }
2554
2555 static int
2556 SetProcTitle(struct cmdargs const *arg)
2557 {
2558   static char title[LINE_LEN];
2559   char *argv[MAXARGS], *ptr;
2560   int len, remaining, f, argc = arg->argc - arg->argn;
2561
2562   if (arg->argc == arg->argn) {
2563     arg->bundle->argv[0] = arg->bundle->argv0;
2564     arg->bundle->argv[1] = arg->bundle->argv1;
2565     return 0;
2566   }
2567
2568   if (argc >= sizeof argv / sizeof argv[0]) {
2569     argc = sizeof argv / sizeof argv[0] - 1;
2570     log_Printf(LogWARN, "Truncating proc title to %d args\n", argc);
2571   }
2572   command_Expand(argv, argc, arg->argv + arg->argn, arg->bundle, 1, getpid());
2573
2574   ptr = title;
2575   remaining = sizeof title - 1;
2576   for (f = 0; f < argc && remaining; f++) {
2577     if (f) {
2578       *ptr++ = ' ';
2579       remaining--;
2580     }
2581     len = strlen(argv[f]);
2582     if (len > remaining)
2583       len = remaining;
2584     memcpy(ptr, argv[f], len);
2585     remaining -= len;
2586     ptr += len;
2587   }
2588   *ptr = '\0';
2589
2590   arg->bundle->argv[0] = title;
2591   arg->bundle->argv[1] = NULL;
2592
2593   return 0;
2594 }