usr.sbin/ppp/command.c

   1 /*-
   2  * Copyright (c) 1996 - 2001 Brian Somers <brian@Awfulhak.org>
   3  *          based on work by Toshiharu OHNO <tony-o@iij.ad.jp>
   4  *                           Internet Initiative Japan, Inc (IIJ)
   5  * All rights reserved.
   6  *
   7  * Redistribution and use in source and binary forms, with or without
   8  * modification, are permitted provided that the following conditions
   9  * are met:
  10  * 1. Redistributions of source code must retain the above copyright
  11  *    notice, this list of conditions and the following disclaimer.
  12  * 2. Redistributions in binary form must reproduce the above copyright
  13  *    notice, this list of conditions and the following disclaimer in the
  14  *    documentation and/or other materials provided with the distribution.
  15  *
  16  * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND
  17  * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
  18  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
  19  * ARE DISCLAIMED.  IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE
  20  * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
  21  * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
  22  * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
  23  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
  24  * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
  25  * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
  26  * SUCH DAMAGE.
  27  *
  28  * $FreeBSD: src/usr.sbin/ppp/command.c,v 1.230.2.18 2003/04/05 10:48:08 ume Exp $
  29  * $DragonFly: src/usr.sbin/ppp/command.c,v 1.3 2007/05/17 08:19:03 swildner Exp $
  30  */
  31
  32 #include <sys/param.h>
  33 #include <netinet/in_systm.h>
  34 #include <netinet/in.h>
  35 #include <netinet/ip.h>
  36 #include <arpa/inet.h>
  37 #include <sys/socket.h>
  38 #include <net/route.h>
  39 #include <netdb.h>
  40 #include <sys/un.h>
  41
  42 #include <ctype.h>
  43 #include <errno.h>
  44 #include <fcntl.h>
  45 #include <paths.h>
  46 #include <stdarg.h>
  47 #include <stdio.h>
  48 #include <stdlib.h>
  49 #include <string.h>
  50 #include <sys/wait.h>
  51 #include <termios.h>
  52 #include <unistd.h>
  53
  54 #ifndef NONAT
  55 #ifdef LOCALNAT
  56 #include "alias.h"
  57 #else
  58 #include <alias.h>
  59 #endif
  60 #endif
  61
  62 #include "layer.h"
  63 #include "defs.h"
  64 #include "command.h"
  65 #include "mbuf.h"
  66 #include "log.h"
  67 #include "timer.h"
  68 #include "fsm.h"
  69 #include "iplist.h"
  70 #include "throughput.h"
  71 #include "slcompress.h"
  72 #include "lqr.h"
  73 #include "hdlc.h"
  74 #include "lcp.h"
  75 #include "ncpaddr.h"
  76 #include "ipcp.h"
  77 #ifndef NONAT
  78 #include "nat_cmd.h"
  79 #endif
  80 #include "systems.h"
  81 #include "filter.h"
  82 #include "descriptor.h"
  83 #include "main.h"
  84 #include "route.h"
  85 #include "ccp.h"
  86 #include "auth.h"
  87 #include "async.h"
  88 #include "link.h"
  89 #include "physical.h"
  90 #include "mp.h"
  91 #ifndef NORADIUS
  92 #include "radius.h"
  93 #endif
  94 #include "ipv6cp.h"
  95 #include "ncp.h"
  96 #include "bundle.h"
  97 #include "server.h"
  98 #include "prompt.h"
  99 #include "chat.h"
 100 #include "chap.h"
 101 #include "cbcp.h"
 102 #include "datalink.h"
 103 #include "iface.h"
 104 #include "id.h"
 105 #include "probe.h"
 106
 107 /* ``set'' values */
 108 #define VAR_AUTHKEY     0
 109 #define VAR_DIAL        1
 110 #define VAR_LOGIN       2
 111 #define VAR_AUTHNAME    3
 112 #define VAR_AUTOLOAD    4
 113 #define VAR_WINSIZE     5
 114 #define VAR_DEVICE      6
 115 #define VAR_ACCMAP      7
 116 #define VAR_MRRU        8
 117 #define VAR_MRU         9
 118 #define VAR_MTU         10
 119 #define VAR_OPENMODE    11
 120 #define VAR_PHONE       12
 121 #define VAR_HANGUP      13
 122 #define VAR_IDLETIMEOUT 14
 123 #define VAR_LQRPERIOD   15
 124 #define VAR_LCPRETRY    16
 125 #define VAR_CHAPRETRY   17
 126 #define VAR_PAPRETRY    18
 127 #define VAR_CCPRETRY    19
 128 #define VAR_IPCPRETRY   20
 129 #define VAR_DNS         21
 130 #define VAR_NBNS        22
 131 #define VAR_MODE        23
 132 #define VAR_CALLBACK    24
 133 #define VAR_CBCP        25
 134 #define VAR_CHOKED      26
 135 #define VAR_SENDPIPE    27
 136 #define VAR_RECVPIPE    28
 137 #define VAR_RADIUS      29
 138 #define VAR_CD          30
 139 #define VAR_PARITY      31
 140 #define VAR_CRTSCTS     32
 141 #define VAR_URGENTPORTS 33
 142 #define VAR_LOGOUT      34
 143 #define VAR_IFQUEUE     35
 144 #define VAR_MPPE        36
 145 #define VAR_IPV6CPRETRY 37
 146
 147 /* ``accept|deny|disable|enable'' masks */
 148 #define NEG_HISMASK (1)
 149 #define NEG_MYMASK (2)
 150
 151 /* ``accept|deny|disable|enable'' values */
 152 #define NEG_ACFCOMP     40
 153 #define NEG_CHAP05      41
 154 #define NEG_CHAP80      42
 155 #define NEG_CHAP80LM    43
 156 #define NEG_DEFLATE     44
 157 #define NEG_DNS         45
 158 #define NEG_ENDDISC     46
 159 #define NEG_LQR         47
 160 #define NEG_PAP         48
 161 #define NEG_PPPDDEFLATE 49
 162 #define NEG_PRED1       50
 163 #define NEG_PROTOCOMP   51
 164 #define NEG_SHORTSEQ    52
 165 #define NEG_VJCOMP      53
 166 #define NEG_MPPE        54
 167 #define NEG_CHAP81      55
 168
 169 const char Version[] = "3.1";
 170
 171 static int ShowCommand(struct cmdargs const *);
 172 static int TerminalCommand(struct cmdargs const *);
 173 static int QuitCommand(struct cmdargs const *);
 174 static int OpenCommand(struct cmdargs const *);
 175 static int CloseCommand(struct cmdargs const *);
 176 static int DownCommand(struct cmdargs const *);
 177 static int SetCommand(struct cmdargs const *);
 178 static int LinkCommand(struct cmdargs const *);
 179 static int AddCommand(struct cmdargs const *);
 180 static int DeleteCommand(struct cmdargs const *);
 181 static int NegotiateCommand(struct cmdargs const *);
 182 static int ClearCommand(struct cmdargs const *);
 183 static int RunListCommand(struct cmdargs const *);
 184 static int IfaceAddCommand(struct cmdargs const *);
 185 static int IfaceDeleteCommand(struct cmdargs const *);
 186 static int IfaceClearCommand(struct cmdargs const *);
 187 static int SetProcTitle(struct cmdargs const *);
 188 #ifndef NONAT
 189 static int NatEnable(struct cmdargs const *);
 190 static int NatOption(struct cmdargs const *);
 191 #endif
 192
 193 static const char *
 194 showcx(struct cmdtab const *cmd)
 195 {
 196   if (cmd->lauth & LOCAL_CX)
 197     return "(c)";
 198   else if (cmd->lauth & LOCAL_CX_OPT)
 199     return "(o)";
 200
 201   return "";
 202 }
 203
 204 static int
 205 HelpCommand(struct cmdargs const *arg)
 206 {
 207   struct cmdtab const *cmd;
 208   int n, cmax, dmax, cols, cxlen;
 209   const char *cx;
 210
 211   if (!arg->prompt) {
 212     log_Printf(LogWARN, "help: Cannot help without a prompt\n");
 213     return 0;
 214   }
 215
 216   if (arg->argc > arg->argn) {
 217     for (cmd = arg->cmdtab; cmd->name || cmd->alias; cmd++)
 218       if ((cmd->lauth & arg->prompt->auth) &&
 219           ((cmd->name && !strcasecmp(cmd->name, arg->argv[arg->argn])) ||
 220            (cmd->alias && !strcasecmp(cmd->alias, arg->argv[arg->argn])))) {
 221         prompt_Printf(arg->prompt, "%s %s\n", cmd->syntax, showcx(cmd));
 222         return 0;
 223       }
 224     return -1;
 225   }
 226
 227   cmax = dmax = 0;
 228   for (cmd = arg->cmdtab; cmd->func; cmd++)
 229     if (cmd->name && (cmd->lauth & arg->prompt->auth)) {
 230       if ((n = strlen(cmd->name) + strlen(showcx(cmd))) > cmax)
 231         cmax = n;
 232       if ((n = strlen(cmd->helpmes)) > dmax)
 233         dmax = n;
 234     }
 235
 236   cols = 80 / (dmax + cmax + 3);
 237   n = 0;
 238   prompt_Printf(arg->prompt, "(o) = Optional context,"
 239                 " (c) = Context required\n");
 240   for (cmd = arg->cmdtab; cmd->func; cmd++)
 241     if (cmd->name && (cmd->lauth & arg->prompt->auth)) {
 242       cx = showcx(cmd);
 243       cxlen = cmax - strlen(cmd->name);
 244       if (n % cols != 0)
 245         prompt_Printf(arg->prompt, " ");
 246       prompt_Printf(arg->prompt, "%s%-*.*s: %-*.*s",
 247               cmd->name, cxlen, cxlen, cx, dmax, dmax, cmd->helpmes);
 248       if (++n % cols == 0)
 249         prompt_Printf(arg->prompt, "\n");
 250     }
 251   if (n % cols != 0)
 252     prompt_Printf(arg->prompt, "\n");
 253
 254   return 0;
 255 }
 256
 257 static int
 258 IdentCommand(struct cmdargs const *arg)
 259 {
 260   Concatinate(arg->cx->physical->link.lcp.cfg.ident,
 261               sizeof arg->cx->physical->link.lcp.cfg.ident,
 262               arg->argc - arg->argn, arg->argv + arg->argn);
 263   return 0;
 264 }
 265
 266 static int
 267 SendIdentification(struct cmdargs const *arg)
 268 {
 269   if (arg->cx->state < DATALINK_LCP) {
 270     log_Printf(LogWARN, "sendident: link has not reached LCP\n");
 271     return 2;
 272   }
 273   return lcp_SendIdentification(&arg->cx->physical->link.lcp) ? 0 : 1;
 274 }
 275
 276 static int
 277 CloneCommand(struct cmdargs const *arg)
 278 {
 279   char namelist[LINE_LEN];
 280   char *name;
 281   int f;
 282
 283   if (arg->argc == arg->argn)
 284     return -1;
 285
 286   namelist[sizeof namelist - 1] = '\0';
 287   for (f = arg->argn; f < arg->argc; f++) {
 288     strncpy(namelist, arg->argv[f], sizeof namelist - 1);
 289     for(name = strtok(namelist, ", "); name; name = strtok(NULL,", "))
 290       bundle_DatalinkClone(arg->bundle, arg->cx, name);
 291   }
 292
 293   return 0;
 294 }
 295
 296 static int
 297 RemoveCommand(struct cmdargs const *arg)
 298 {
 299   if (arg->argc != arg->argn)
 300     return -1;
 301
 302   if (arg->cx->state != DATALINK_CLOSED) {
 303     log_Printf(LogWARN, "remove: Cannot delete links that aren't closed\n");
 304     return 2;
 305   }
 306
 307   bundle_DatalinkRemove(arg->bundle, arg->cx);
 308   return 0;
 309 }
 310
 311 static int
 312 RenameCommand(struct cmdargs const *arg)
 313 {
 314   if (arg->argc != arg->argn + 1)
 315     return -1;
 316
 317   if (bundle_RenameDatalink(arg->bundle, arg->cx, arg->argv[arg->argn]))
 318     return 0;
 319
 320   log_Printf(LogWARN, "%s -> %s: target name already exists\n",
 321              arg->cx->name, arg->argv[arg->argn]);
 322   return 1;
 323 }
 324
 325 static int
 326 LoadCommand(struct cmdargs const *arg)
 327 {
 328   const char *err;
 329   int n, mode;
 330
 331   mode = arg->bundle->phys_type.all;
 332
 333   if (arg->argn < arg->argc) {
 334     for (n = arg->argn; n < arg->argc; n++)
 335       if ((err = system_IsValid(arg->argv[n], arg->prompt, mode)) != NULL) {
 336         log_Printf(LogWARN, "%s: %s\n", arg->argv[n], err);
 337         return 1;
 338       }
 339
 340     for (n = arg->argn; n < arg->argc; n++) {
 341       bundle_SetLabel(arg->bundle, arg->argv[arg->argc - 1]);
 342       system_Select(arg->bundle, arg->argv[n], CONFFILE, arg->prompt, arg->cx);
 343     }
 344     bundle_SetLabel(arg->bundle, arg->argv[arg->argc - 1]);
 345   } else if ((err = system_IsValid("default", arg->prompt, mode)) != NULL) {
 346     log_Printf(LogWARN, "default: %s\n", err);
 347     return 1;
 348   } else {
 349     bundle_SetLabel(arg->bundle, "default");
 350     system_Select(arg->bundle, "default", CONFFILE, arg->prompt, arg->cx);
 351     bundle_SetLabel(arg->bundle, "default");
 352   }
 353
 354   return 0;
 355 }
 356
 357 static int
 358 LogCommand(struct cmdargs const *arg)
 359 {
 360   char buf[LINE_LEN];
 361
 362   if (arg->argn < arg->argc) {
 363     char *argv[MAXARGS];
 364     int argc = arg->argc - arg->argn;
 365
 366     if (argc >= sizeof argv / sizeof argv[0]) {
 367       argc = sizeof argv / sizeof argv[0] - 1;
 368       log_Printf(LogWARN, "Truncating log command to %d args\n", argc);
 369     }
 370     command_Expand(argv, argc, arg->argv + arg->argn, arg->bundle, 1, getpid());
 371     Concatinate(buf, sizeof buf, argc, (const char *const *)argv);
 372     log_Printf(LogLOG, "%s\n", buf);
 373     command_Free(argc, argv);
 374     return 0;
 375   }
 376
 377   return -1;
 378 }
 379
 380 static int
 381 SaveCommand(struct cmdargs const *arg)
 382 {
 383   log_Printf(LogWARN, "save command is not yet implemented.\n");
 384   return 1;
 385 }
 386
 387 static int
 388 DialCommand(struct cmdargs const *arg)
 389 {
 390   int res;
 391
 392   if ((arg->cx && !(arg->cx->physical->type & (PHYS_INTERACTIVE|PHYS_AUTO)))
 393       || (!arg->cx &&
 394           (arg->bundle->phys_type.all & ~(PHYS_INTERACTIVE|PHYS_AUTO)))) {
 395     log_Printf(LogWARN, "Manual dial is only available for auto and"
 396               " interactive links\n");
 397     return 1;
 398   }
 399
 400   if (arg->argc > arg->argn && (res = LoadCommand(arg)) != 0)
 401     return res;
 402
 403   bundle_Open(arg->bundle, arg->cx ? arg->cx->name : NULL, PHYS_ALL, 1);
 404
 405   return 0;
 406 }
 407
 408 #define isinword(ch) (isalnum(ch) || (ch) == '_')
 409
 410 static char *
 411 strstrword(char *big, const char *little)
 412 {
 413   /* Get the first occurance of the word ``little'' in ``big'' */
 414   char *pos;
 415   int len;
 416
 417   pos = big;
 418   len = strlen(little);
 419
 420   while ((pos = strstr(pos, little)) != NULL)
 421     if ((pos != big && isinword(pos[-1])) || isinword(pos[len]))
 422       pos++;
 423     else if (pos != big && pos[-1] == '\\')
 424       memmove(pos - 1, pos, strlen(pos) + 1);
 425     else
 426       break;
 427
 428   return pos;
 429 }
 430
 431 static char *
 432 subst(char *tgt, const char *oldstr, const char *newstr)
 433 {
 434   /* tgt is a malloc()d area... realloc() as necessary */
 435   char *word, *ntgt;
 436   int ltgt, loldstr, lnewstr, pos;
 437
 438   if ((word = strstrword(tgt, oldstr)) == NULL)
 439     return tgt;
 440
 441   ltgt = strlen(tgt) + 1;
 442   loldstr = strlen(oldstr);
 443   lnewstr = strlen(newstr);
 444   do {
 445     pos = word - tgt;
 446     if (loldstr > lnewstr)
 447       bcopy(word + loldstr, word + lnewstr, ltgt - pos - loldstr);
 448     if (loldstr != lnewstr) {
 449       ntgt = realloc(tgt, ltgt += lnewstr - loldstr);
 450       if (ntgt == NULL)
 451         break;                  /* Oh wonderful ! */
 452       word = ntgt + pos;
 453       tgt = ntgt;
 454     }
 455     if (lnewstr > loldstr)
 456       bcopy(word + loldstr, word + lnewstr, ltgt - pos - loldstr);
 457     bcopy(newstr, word, lnewstr);
 458   } while ((word = strstrword(word, oldstr)));
 459
 460   return tgt;
 461 }
 462
 463 static char *
 464 substip(char *tgt, const char *oldstr, struct in_addr ip)
 465 {
 466   return subst(tgt, oldstr, inet_ntoa(ip));
 467 }
 468
 469 static char *
 470 substlong(char *tgt, const char *oldstr, long l)
 471 {
 472   char buf[23];
 473
 474   snprintf(buf, sizeof buf, "%ld", l);
 475
 476   return subst(tgt, oldstr, buf);
 477 }
 478
 479 static char *
 480 substull(char *tgt, const char *oldstr, unsigned long long ull)
 481 {
 482   char buf[21];
 483
 484   snprintf(buf, sizeof buf, "%llu", ull);
 485
 486   return subst(tgt, oldstr, buf);
 487 }
 488
 489
 490 #ifndef NOINET6
 491 static char *
 492 substipv6(char *tgt, const char *oldstr, const struct ncpaddr *ip)
 493 {
 494     return subst(tgt, oldstr, ncpaddr_ntoa(ip));
 495 }
 496 #endif
 497
 498 void
 499 command_Expand(char **nargv, int argc, char const *const *oargv,
 500                struct bundle *bundle, int inc0, pid_t pid)
 501 {
 502   int arg, secs;
 503   char uptime[20];
 504   unsigned long long oin, oout, pin, pout;
 505
 506   if (inc0)
 507     arg = 0;            /* Start at arg 0 */
 508   else {
 509     nargv[0] = strdup(oargv[0]);
 510     arg = 1;
 511   }
 512
 513   secs = bundle_Uptime(bundle);
 514   snprintf(uptime, sizeof uptime, "%d:%02d:%02d",
 515            secs / 3600, (secs / 60) % 60, secs % 60);
 516   oin = bundle->ncp.ipcp.throughput.OctetsIn;
 517   oout = bundle->ncp.ipcp.throughput.OctetsOut;
 518   pin = bundle->ncp.ipcp.throughput.PacketsIn;
 519   pout = bundle->ncp.ipcp.throughput.PacketsOut;
 520 #ifndef NOINET6
 521   oin += bundle->ncp.ipv6cp.throughput.OctetsIn;
 522   oout += bundle->ncp.ipv6cp.throughput.OctetsOut;
 523   pin += bundle->ncp.ipv6cp.throughput.PacketsIn;
 524   pout += bundle->ncp.ipv6cp.throughput.PacketsOut;
 525 #endif
 526
 527   for (; arg < argc; arg++) {
 528     nargv[arg] = strdup(oargv[arg]);
 529     nargv[arg] = subst(nargv[arg], "AUTHNAME", bundle->cfg.auth.name);
 530     nargv[arg] = subst(nargv[arg], "COMPILATIONDATE", __DATE__);
 531     nargv[arg] = substip(nargv[arg], "DNS0", bundle->ncp.ipcp.ns.dns[0]);
 532     nargv[arg] = substip(nargv[arg], "DNS1", bundle->ncp.ipcp.ns.dns[1]);
 533     nargv[arg] = subst(nargv[arg], "ENDDISC",
 534                        mp_Enddisc(bundle->ncp.mp.cfg.enddisc.class,
 535                                   bundle->ncp.mp.cfg.enddisc.address,
 536                                   bundle->ncp.mp.cfg.enddisc.len));
 537     nargv[arg] = substip(nargv[arg], "HISADDR", bundle->ncp.ipcp.peer_ip);
 538 #ifndef NOINET6
 539     nargv[arg] = substipv6(nargv[arg], "HISADDR6", &bundle->ncp.ipv6cp.hisaddr);
 540 #endif
 541     nargv[arg] = subst(nargv[arg], "INTERFACE", bundle->iface->name);
 542     nargv[arg] = substull(nargv[arg], "IPOCTETSIN",
 543                           bundle->ncp.ipcp.throughput.OctetsIn);
 544     nargv[arg] = substull(nargv[arg], "IPOCTETSOUT",
 545                           bundle->ncp.ipcp.throughput.OctetsOut);
 546     nargv[arg] = substull(nargv[arg], "IPPACKETSIN",
 547                           bundle->ncp.ipcp.throughput.PacketsIn);
 548     nargv[arg] = substull(nargv[arg], "IPPACKETSOUT",
 549                           bundle->ncp.ipcp.throughput.PacketsOut);
 550 #ifndef NOINET6
 551     nargv[arg] = substull(nargv[arg], "IPV6OCTETSIN",
 552                           bundle->ncp.ipv6cp.throughput.OctetsIn);
 553     nargv[arg] = substull(nargv[arg], "IPV6OCTETSOUT",
 554                           bundle->ncp.ipv6cp.throughput.OctetsOut);
 555     nargv[arg] = substull(nargv[arg], "IPV6PACKETSIN",
 556                           bundle->ncp.ipv6cp.throughput.PacketsIn);
 557     nargv[arg] = substull(nargv[arg], "IPV6PACKETSOUT",
 558                           bundle->ncp.ipv6cp.throughput.PacketsOut);
 559 #endif
 560     nargv[arg] = subst(nargv[arg], "LABEL", bundle_GetLabel(bundle));
 561     nargv[arg] = substip(nargv[arg], "MYADDR", bundle->ncp.ipcp.my_ip);
 562 #ifndef NOINET6
 563     nargv[arg] = substipv6(nargv[arg], "MYADDR6", &bundle->ncp.ipv6cp.myaddr);
 564 #endif
 565     nargv[arg] = substull(nargv[arg], "OCTETSIN", oin);
 566     nargv[arg] = substull(nargv[arg], "OCTETSOUT", oout);
 567     nargv[arg] = substull(nargv[arg], "PACKETSIN", pin);
 568     nargv[arg] = substull(nargv[arg], "PACKETSOUT", pout);
 569     nargv[arg] = subst(nargv[arg], "PEER_ENDDISC",
 570                        mp_Enddisc(bundle->ncp.mp.peer.enddisc.class,
 571                                   bundle->ncp.mp.peer.enddisc.address,
 572                                   bundle->ncp.mp.peer.enddisc.len));
 573     nargv[arg] = substlong(nargv[arg], "PROCESSID", pid);
 574     if (server.cfg.port)
 575       nargv[arg] = substlong(nargv[arg], "SOCKNAME", server.cfg.port);
 576     else
 577       nargv[arg] = subst(nargv[arg], "SOCKNAME", server.cfg.sockname);
 578     nargv[arg] = subst(nargv[arg], "UPTIME", uptime);
 579     nargv[arg] = subst(nargv[arg], "USER", bundle->ncp.mp.peer.authname);
 580     nargv[arg] = subst(nargv[arg], "VERSION", Version);
 581   }
 582   nargv[arg] = NULL;
 583 }
 584
 585 void
 586 command_Free(int argc, char **argv)
 587 {
 588   while (argc) {
 589     free(*argv);
 590     argc--;
 591     argv++;
 592   }
 593 }
 594
 595 static int
 596 ShellCommand(struct cmdargs const *arg, int bg)
 597 {
 598   const char *shell;
 599   pid_t shpid, pid;
 600
 601 #ifdef SHELL_ONLY_INTERACTIVELY
 602   /* we're only allowed to shell when we run ppp interactively */
 603   if (arg->prompt && arg->prompt->owner) {
 604     log_Printf(LogWARN, "Can't start a shell from a network connection\n");
 605     return 1;
 606   }
 607 #endif
 608
 609   if (arg->argc == arg->argn) {
 610     if (!arg->prompt) {
 611       log_Printf(LogWARN, "Can't start an interactive shell from"
 612                 " a config file\n");
 613       return 1;
 614     } else if (arg->prompt->owner) {
 615       log_Printf(LogWARN, "Can't start an interactive shell from"
 616                 " a socket connection\n");
 617       return 1;
 618     } else if (bg) {
 619       log_Printf(LogWARN, "Can only start an interactive shell in"
 620                 " the foreground mode\n");
 621       return 1;
 622     }
 623   }
 624
 625   pid = getpid();
 626   if ((shpid = fork()) == 0) {
 627     int i, fd;
 628
 629     if ((shell = getenv("SHELL")) == 0)
 630       shell = _PATH_BSHELL;
 631
 632     timer_TermService();
 633
 634     if (arg->prompt)
 635       fd = arg->prompt->fd_out;
 636     else if ((fd = open(_PATH_DEVNULL, O_RDWR)) == -1) {
 637       log_Printf(LogALERT, "Failed to open %s: %s\n",
 638                 _PATH_DEVNULL, strerror(errno));
 639       exit(1);
 640     }
 641     dup2(fd, STDIN_FILENO);
 642     dup2(fd, STDOUT_FILENO);
 643     dup2(fd, STDERR_FILENO);
 644     for (i = getdtablesize(); i > STDERR_FILENO; i--)
 645       fcntl(i, F_SETFD, 1);
 646
 647 #ifndef NOSUID
 648     setuid(ID0realuid());
 649 #endif
 650     if (arg->argc > arg->argn) {
 651       /* substitute pseudo args */
 652       char *argv[MAXARGS];
 653       int argc = arg->argc - arg->argn;
 654
 655       if (argc >= sizeof argv / sizeof argv[0]) {
 656         argc = sizeof argv / sizeof argv[0] - 1;
 657         log_Printf(LogWARN, "Truncating shell command to %d args\n", argc);
 658       }
 659       command_Expand(argv, argc, arg->argv + arg->argn, arg->bundle, 0, pid);
 660       if (bg) {
 661         pid_t p;
 662
 663         p = getpid();
 664         if (daemon(1, 1) == -1) {
 665           log_Printf(LogERROR, "%ld: daemon: %s\n", (long)p, strerror(errno));
 666           exit(1);
 667         }
 668       } else if (arg->prompt)
 669         printf("ppp: Pausing until %s finishes\n", arg->argv[arg->argn]);
 670       execvp(argv[0], argv);
 671     } else {
 672       if (arg->prompt)
 673         printf("ppp: Pausing until %s finishes\n", shell);
 674       prompt_TtyOldMode(arg->prompt);
 675       execl(shell, shell, (char *)NULL);
 676     }
 677
 678     log_Printf(LogWARN, "exec() of %s failed: %s\n",
 679               arg->argc > arg->argn ? arg->argv[arg->argn] : shell,
 680               strerror(errno));
 681     _exit(255);
 682   }
 683
 684   if (shpid == (pid_t)-1)
 685     log_Printf(LogERROR, "Fork failed: %s\n", strerror(errno));
 686   else {
 687     int status;
 688     waitpid(shpid, &status, 0);
 689   }
 690
 691   if (arg->prompt && !arg->prompt->owner)
 692     prompt_TtyCommandMode(arg->prompt);
 693
 694   return 0;
 695 }
 696
 697 static int
 698 BgShellCommand(struct cmdargs const *arg)
 699 {
 700   if (arg->argc == arg->argn)
 701     return -1;
 702   return ShellCommand(arg, 1);
 703 }
 704
 705 static int
 706 FgShellCommand(struct cmdargs const *arg)
 707 {
 708   return ShellCommand(arg, 0);
 709 }
 710
 711 static int
 712 ResolvCommand(struct cmdargs const *arg)
 713 {
 714   if (arg->argc == arg->argn + 1) {
 715     if (!strcasecmp(arg->argv[arg->argn], "reload"))
 716       ipcp_LoadDNS(&arg->bundle->ncp.ipcp);
 717     else if (!strcasecmp(arg->argv[arg->argn], "restore"))
 718       ipcp_RestoreDNS(&arg->bundle->ncp.ipcp);
 719     else if (!strcasecmp(arg->argv[arg->argn], "rewrite"))
 720       ipcp_WriteDNS(&arg->bundle->ncp.ipcp);
 721     else if (!strcasecmp(arg->argv[arg->argn], "readonly"))
 722       arg->bundle->ncp.ipcp.ns.writable = 0;
 723     else if (!strcasecmp(arg->argv[arg->argn], "writable"))
 724       arg->bundle->ncp.ipcp.ns.writable = 1;
 725     else
 726       return -1;
 727
 728     return 0;
 729   }
 730
 731   return -1;
 732 }
 733
 734 #ifndef NONAT
 735 static struct cmdtab const NatCommands[] =
 736 {
 737   {"addr", NULL, nat_RedirectAddr, LOCAL_AUTH,
 738    "static address translation", "nat addr [addr_local addr_alias]"},
 739   {"deny_incoming", NULL, NatOption, LOCAL_AUTH,
 740    "stop incoming connections", "nat deny_incoming yes|no",
 741    (const void *) PKT_ALIAS_DENY_INCOMING},
 742   {"enable", NULL, NatEnable, LOCAL_AUTH,
 743    "enable NAT", "nat enable yes|no"},
 744   {"log", NULL, NatOption, LOCAL_AUTH,
 745    "log NAT link creation", "nat log yes|no",
 746    (const void *) PKT_ALIAS_LOG},
 747   {"port", NULL, nat_RedirectPort, LOCAL_AUTH, "port redirection",
 748    "nat port proto localaddr:port[-port] aliasport[-aliasport]"},
 749   {"proto", NULL, nat_RedirectProto, LOCAL_AUTH, "protocol redirection",
 750    "nat proto proto localIP [publicIP [remoteIP]]"},
 751   {"proxy", NULL, nat_ProxyRule, LOCAL_AUTH,
 752    "proxy control", "nat proxy server host[:port] ..."},
 753 #ifndef NO_FW_PUNCH
 754   {"punch_fw", NULL, nat_PunchFW, LOCAL_AUTH,
 755    "firewall control", "nat punch_fw [base count]"},
 756 #endif
 757   {"same_ports", NULL, NatOption, LOCAL_AUTH,
 758    "try to leave port numbers unchanged", "nat same_ports yes|no",
 759    (const void *) PKT_ALIAS_SAME_PORTS},
 760   {"target", NULL, nat_SetTarget, LOCAL_AUTH,
 761    "Default address for incoming connections", "nat target addr" },
 762   {"unregistered_only", NULL, NatOption, LOCAL_AUTH,
 763    "translate unregistered (private) IP address space only",
 764    "nat unregistered_only yes|no",
 765    (const void *) PKT_ALIAS_UNREGISTERED_ONLY},
 766   {"use_sockets", NULL, NatOption, LOCAL_AUTH,
 767    "allocate host sockets", "nat use_sockets yes|no",
 768    (const void *) PKT_ALIAS_USE_SOCKETS},
 769   {"help", "?", HelpCommand, LOCAL_AUTH | LOCAL_NO_AUTH,
 770    "Display this message", "nat help|? [command]", NatCommands},
 771   {NULL, NULL, NULL},
 772 };
 773 #endif
 774
 775 static struct cmdtab const AllowCommands[] = {
 776   {"modes", "mode", AllowModes, LOCAL_AUTH,
 777   "Only allow certain ppp modes", "allow modes mode..."},
 778   {"users", "user", AllowUsers, LOCAL_AUTH,
 779   "Only allow ppp access to certain users", "allow users logname..."},
 780   {"help", "?", HelpCommand, LOCAL_AUTH | LOCAL_NO_AUTH,
 781   "Display this message", "allow help|? [command]", AllowCommands},
 782   {NULL, NULL, NULL},
 783 };
 784
 785 static struct cmdtab const IfaceCommands[] =
 786 {
 787   {"add", NULL, IfaceAddCommand, LOCAL_AUTH,
 788    "Add iface address", "iface add addr[/bits| mask] peer", NULL},
 789   {NULL, "add!", IfaceAddCommand, LOCAL_AUTH,
 790    "Add or change an iface address", "iface add! addr[/bits| mask] peer",
 791    (void *)1},
 792   {"clear", NULL, IfaceClearCommand, LOCAL_AUTH,
 793    "Clear iface address(es)", "iface clear [INET | INET6]"},
 794   {"delete", "rm", IfaceDeleteCommand, LOCAL_AUTH,
 795    "Delete iface address", "iface delete addr", NULL},
 796   {NULL, "rm!", IfaceDeleteCommand, LOCAL_AUTH,
 797    "Delete iface address", "iface delete addr", (void *)1},
 798   {NULL, "delete!", IfaceDeleteCommand, LOCAL_AUTH,
 799    "Delete iface address", "iface delete addr", (void *)1},
 800   {"show", NULL, iface_Show, LOCAL_AUTH,
 801    "Show iface address(es)", "iface show"},
 802   {"help", "?", HelpCommand, LOCAL_AUTH | LOCAL_NO_AUTH,
 803    "Display this message", "nat help|? [command]", IfaceCommands},
 804   {NULL, NULL, NULL},
 805 };
 806
 807 static struct cmdtab const Commands[] = {
 808   {"accept", NULL, NegotiateCommand, LOCAL_AUTH | LOCAL_CX_OPT,
 809   "accept option request", "accept option .."},
 810   {"add", NULL, AddCommand, LOCAL_AUTH,
 811   "add route", "add dest mask gateway", NULL},
 812   {NULL, "add!", AddCommand, LOCAL_AUTH,
 813   "add or change route", "add! dest mask gateway", (void *)1},
 814   {"allow", "auth", RunListCommand, LOCAL_AUTH,
 815   "Allow ppp access", "allow users|modes ....", AllowCommands},
 816   {"bg", "!bg", BgShellCommand, LOCAL_AUTH,
 817   "Run a background command", "[!]bg command"},
 818   {"clear", NULL, ClearCommand, LOCAL_AUTH | LOCAL_CX_OPT,
 819   "Clear throughput statistics",
 820   "clear ipcp|ipv6cp|physical [current|overall|peak]..."},
 821   {"clone", NULL, CloneCommand, LOCAL_AUTH | LOCAL_CX,
 822   "Clone a link", "clone newname..."},
 823   {"close", NULL, CloseCommand, LOCAL_AUTH | LOCAL_CX_OPT,
 824   "Close an FSM", "close [lcp|ccp]"},
 825   {"delete", NULL, DeleteCommand, LOCAL_AUTH,
 826   "delete route", "delete dest", NULL},
 827   {NULL, "delete!", DeleteCommand, LOCAL_AUTH,
 828   "delete a route if it exists", "delete! dest", (void *)1},
 829   {"deny", NULL, NegotiateCommand, LOCAL_AUTH | LOCAL_CX_OPT,
 830   "Deny option request", "deny option .."},
 831   {"dial", "call", DialCommand, LOCAL_AUTH | LOCAL_CX_OPT,
 832   "Dial and login", "dial|call [system ...]", NULL},
 833   {"disable", NULL, NegotiateCommand, LOCAL_AUTH | LOCAL_CX_OPT,
 834   "Disable option", "disable option .."},
 835   {"down", NULL, DownCommand, LOCAL_AUTH | LOCAL_CX_OPT,
 836   "Generate a down event", "down [ccp|lcp]"},
 837   {"enable", NULL, NegotiateCommand, LOCAL_AUTH | LOCAL_CX_OPT,
 838   "Enable option", "enable option .."},
 839   {"ident", NULL, IdentCommand, LOCAL_AUTH | LOCAL_CX,
 840   "Set the link identity", "ident text..."},
 841   {"iface", "interface", RunListCommand, LOCAL_AUTH,
 842   "interface control", "iface option ...", IfaceCommands},
 843   {"link", "datalink", LinkCommand, LOCAL_AUTH,
 844   "Link specific commands", "link name command ..."},
 845   {"load", NULL, LoadCommand, LOCAL_AUTH | LOCAL_CX_OPT,
 846   "Load settings", "load [system ...]"},
 847   {"log", NULL, LogCommand, LOCAL_AUTH | LOCAL_CX_OPT,
 848   "log information", "log word ..."},
 849 #ifndef NONAT
 850   {"nat", "alias", RunListCommand, LOCAL_AUTH,
 851   "NAT control", "nat option yes|no", NatCommands},
 852 #endif
 853   {"open", NULL, OpenCommand, LOCAL_AUTH | LOCAL_CX_OPT,
 854   "Open an FSM", "open! [lcp|ccp|ipcp]", (void *)1},
 855   {"passwd", NULL, PasswdCommand, LOCAL_NO_AUTH,
 856   "Password for manipulation", "passwd LocalPassword"},
 857   {"quit", "bye", QuitCommand, LOCAL_AUTH | LOCAL_NO_AUTH,
 858   "Quit PPP program", "quit|bye [all]"},
 859   {"remove", "rm", RemoveCommand, LOCAL_AUTH | LOCAL_CX,
 860   "Remove a link", "remove"},
 861   {"rename", "mv", RenameCommand, LOCAL_AUTH | LOCAL_CX,
 862   "Rename a link", "rename name"},
 863   {"resolv", NULL, ResolvCommand, LOCAL_AUTH,
 864   "Manipulate resolv.conf", "resolv readonly|reload|restore|rewrite|writable"},
 865   {"save", NULL, SaveCommand, LOCAL_AUTH,
 866   "Save settings", "save"},
 867   {"sendident", NULL, SendIdentification, LOCAL_AUTH | LOCAL_CX,
 868   "Transmit the link identity", "sendident"},
 869   {"set", "setup", SetCommand, LOCAL_AUTH | LOCAL_CX_OPT,
 870   "Set parameters", "set[up] var value"},
 871   {"shell", "!", FgShellCommand, LOCAL_AUTH,
 872   "Run a subshell", "shell|! [sh command]"},
 873   {"show", NULL, ShowCommand, LOCAL_AUTH | LOCAL_CX_OPT,
 874   "Show status and stats", "show var"},
 875   {"term", NULL, TerminalCommand, LOCAL_AUTH | LOCAL_CX,
 876   "Enter terminal mode", "term"},
 877   {"help", "?", HelpCommand, LOCAL_AUTH | LOCAL_NO_AUTH,
 878   "Display this message", "help|? [command]", Commands},
 879   {NULL, NULL, NULL},
 880 };
 881
 882 static int
 883 ShowEscape(struct cmdargs const *arg)
 884 {
 885   if (arg->cx->physical->async.cfg.EscMap[32]) {
 886     int code, bit;
 887     const char *sep = "";
 888
 889     for (code = 0; code < 32; code++)
 890       if (arg->cx->physical->async.cfg.EscMap[code])
 891         for (bit = 0; bit < 8; bit++)
 892           if (arg->cx->physical->async.cfg.EscMap[code] & (1 << bit)) {
 893             prompt_Printf(arg->prompt, "%s0x%02x", sep, (code << 3) + bit);
 894             sep = ", ";
 895           }
 896     prompt_Printf(arg->prompt, "\n");
 897   }
 898   return 0;
 899 }
 900
 901 static int
 902 ShowTimerList(struct cmdargs const *arg)
 903 {
 904   timer_Show(0, arg->prompt);
 905   return 0;
 906 }
 907
 908 static int
 909 ShowStopped(struct cmdargs const *arg)
 910 {
 911   prompt_Printf(arg->prompt, " Stopped Timer:  LCP: ");
 912   if (!arg->cx->physical->link.lcp.fsm.StoppedTimer.load)
 913     prompt_Printf(arg->prompt, "Disabled");
 914   else
 915     prompt_Printf(arg->prompt, "%ld secs",
 916                   arg->cx->physical->link.lcp.fsm.StoppedTimer.load / SECTICKS);
 917
 918   prompt_Printf(arg->prompt, ", CCP: ");
 919   if (!arg->cx->physical->link.ccp.fsm.StoppedTimer.load)
 920     prompt_Printf(arg->prompt, "Disabled");
 921   else
 922     prompt_Printf(arg->prompt, "%ld secs",
 923                   arg->cx->physical->link.ccp.fsm.StoppedTimer.load / SECTICKS);
 924
 925   prompt_Printf(arg->prompt, "\n");
 926
 927   return 0;
 928 }
 929
 930 static int
 931 ShowVersion(struct cmdargs const *arg)
 932 {
 933   prompt_Printf(arg->prompt, "PPP Version %s - %s\n", Version, __DATE__);
 934   return 0;
 935 }
 936
 937 static int
 938 ShowProtocolStats(struct cmdargs const *arg)
 939 {
 940   struct link *l = command_ChooseLink(arg);
 941
 942   prompt_Printf(arg->prompt, "%s:\n", l->name);
 943   link_ReportProtocolStatus(l, arg->prompt);
 944   return 0;
 945 }
 946
 947 static struct cmdtab const ShowCommands[] = {
 948   {"bundle", NULL, bundle_ShowStatus, LOCAL_AUTH,
 949   "bundle details", "show bundle"},
 950   {"ccp", NULL, ccp_ReportStatus, LOCAL_AUTH | LOCAL_CX_OPT,
 951   "CCP status", "show cpp"},
 952   {"compress", NULL, sl_Show, LOCAL_AUTH,
 953   "VJ compression stats", "show compress"},
 954   {"escape", NULL, ShowEscape, LOCAL_AUTH | LOCAL_CX,
 955   "escape characters", "show escape"},
 956   {"filter", NULL, filter_Show, LOCAL_AUTH,
 957   "packet filters", "show filter [in|out|dial|alive]"},
 958   {"hdlc", NULL, hdlc_ReportStatus, LOCAL_AUTH | LOCAL_CX,
 959   "HDLC errors", "show hdlc"},
 960   {"iface", "interface", iface_Show, LOCAL_AUTH,
 961   "Interface status", "show iface"},
 962   {"ipcp", NULL, ipcp_Show, LOCAL_AUTH,
 963   "IPCP status", "show ipcp"},
 964 #ifndef NOINET6
 965   {"ipv6cp", NULL, ipv6cp_Show, LOCAL_AUTH,
 966   "IPV6CP status", "show ipv6cp"},
 967 #endif
 968   {"layers", NULL, link_ShowLayers, LOCAL_AUTH | LOCAL_CX_OPT,
 969   "Protocol layers", "show layers"},
 970   {"lcp", NULL, lcp_ReportStatus, LOCAL_AUTH | LOCAL_CX,
 971   "LCP status", "show lcp"},
 972   {"link", "datalink", datalink_Show, LOCAL_AUTH | LOCAL_CX,
 973   "(high-level) link info", "show link"},
 974   {"links", NULL, bundle_ShowLinks, LOCAL_AUTH,
 975   "available link names", "show links"},
 976   {"log", NULL, log_ShowLevel, LOCAL_AUTH,
 977   "log levels", "show log"},
 978   {"mem", NULL, mbuf_Show, LOCAL_AUTH,
 979   "mbuf allocations", "show mem"},
 980   {"ncp", NULL, ncp_Show, LOCAL_AUTH,
 981   "NCP status", "show ncp"},
 982   {"physical", NULL, physical_ShowStatus, LOCAL_AUTH | LOCAL_CX,
 983   "(low-level) link info", "show physical"},
 984   {"mp", "multilink", mp_ShowStatus, LOCAL_AUTH,
 985   "multilink setup", "show mp"},
 986   {"proto", NULL, ShowProtocolStats, LOCAL_AUTH | LOCAL_CX_OPT,
 987   "protocol summary", "show proto"},
 988   {"route", NULL, route_Show, LOCAL_AUTH,
 989   "routing table", "show route"},
 990   {"stopped", NULL, ShowStopped, LOCAL_AUTH | LOCAL_CX,
 991   "STOPPED timeout", "show stopped"},
 992   {"timers", NULL, ShowTimerList, LOCAL_AUTH,
 993   "alarm timers", "show timers"},
 994   {"version", NULL, ShowVersion, LOCAL_NO_AUTH | LOCAL_AUTH,
 995   "version string", "show version"},
 996   {"who", NULL, log_ShowWho, LOCAL_AUTH,
 997   "client list", "show who"},
 998   {"help", "?", HelpCommand, LOCAL_NO_AUTH | LOCAL_AUTH,
 999   "Display this message", "show help|? [command]", ShowCommands},
1000   {NULL, NULL, NULL},
1001 };
1002
1003 static struct cmdtab const *
1004 FindCommand(struct cmdtab const *cmds, const char *str, int *pmatch)
1005 {
1006   int nmatch;
1007   int len;
1008   struct cmdtab const *found;
1009
1010   found = NULL;
1011   len = strlen(str);
1012   nmatch = 0;
1013   while (cmds->func) {
1014     if (cmds->name && strncasecmp(str, cmds->name, len) == 0) {
1015       if (cmds->name[len] == '\0') {
1016         *pmatch = 1;
1017         return cmds;
1018       }
1019       nmatch++;
1020       found = cmds;
1021     } else if (cmds->alias && strncasecmp(str, cmds->alias, len) == 0) {
1022       if (cmds->alias[len] == '\0') {
1023         *pmatch = 1;
1024         return cmds;
1025       }
1026       nmatch++;
1027       found = cmds;
1028     }
1029     cmds++;
1030   }
1031   *pmatch = nmatch;
1032   return found;
1033 }
1034
1035 static const char *
1036 mkPrefix(int argc, char const *const *argv, char *tgt, int sz)
1037 {
1038   int f, tlen, len;
1039
1040   tlen = 0;
1041   for (f = 0; f < argc && tlen < sz - 2; f++) {
1042     if (f)
1043       tgt[tlen++] = ' ';
1044     len = strlen(argv[f]);
1045     if (len > sz - tlen - 1)
1046       len = sz - tlen - 1;
1047     strncpy(tgt+tlen, argv[f], len);
1048     tlen += len;
1049   }
1050   tgt[tlen] = '\0';
1051   return tgt;
1052 }
1053
1054 static int
1055 FindExec(struct bundle *bundle, struct cmdtab const *cmds, int argc, int argn,
1056          char const *const *argv, struct prompt *prompt, struct datalink *cx)
1057 {
1058   struct cmdtab const *cmd;
1059   int val = 1;
1060   int nmatch;
1061   struct cmdargs arg;
1062   char prefix[100];
1063
1064   cmd = FindCommand(cmds, argv[argn], &nmatch);
1065   if (nmatch > 1)
1066     log_Printf(LogWARN, "%s: Ambiguous command\n",
1067               mkPrefix(argn+1, argv, prefix, sizeof prefix));
1068   else if (cmd && (!prompt || (cmd->lauth & prompt->auth))) {
1069     if ((cmd->lauth & LOCAL_CX) && !cx)
1070       /* We've got no context, but we require it */
1071       cx = bundle2datalink(bundle, NULL);
1072
1073     if ((cmd->lauth & LOCAL_CX) && !cx)
1074       log_Printf(LogWARN, "%s: No context (use the `link' command)\n",
1075                 mkPrefix(argn+1, argv, prefix, sizeof prefix));
1076     else {
1077       if (cx && !(cmd->lauth & (LOCAL_CX|LOCAL_CX_OPT))) {
1078         log_Printf(LogWARN, "%s: Redundant context (%s) ignored\n",
1079                   mkPrefix(argn+1, argv, prefix, sizeof prefix), cx->name);
1080         cx = NULL;
1081       }
1082       arg.cmdtab = cmds;
1083       arg.cmd = cmd;
1084       arg.argc = argc;
1085       arg.argn = argn+1;
1086       arg.argv = argv;
1087       arg.bundle = bundle;
1088       arg.cx = cx;
1089       arg.prompt = prompt;
1090       val = (*cmd->func) (&arg);
1091     }
1092   } else
1093     log_Printf(LogWARN, "%s: Invalid command\n",
1094               mkPrefix(argn+1, argv, prefix, sizeof prefix));
1095
1096   if (val == -1)
1097     log_Printf(LogWARN, "usage: %s\n", cmd->syntax);
1098   else if (val)
1099     log_Printf(LogWARN, "%s: Failed %d\n",
1100               mkPrefix(argn+1, argv, prefix, sizeof prefix), val);
1101
1102   return val;
1103 }
1104
1105 int
1106 command_Expand_Interpret(char *buff, int nb, char *argv[MAXARGS], int offset)
1107 {
1108   char buff2[LINE_LEN-offset];
1109
1110   InterpretArg(buff, buff2);
1111   strncpy(buff, buff2, LINE_LEN - offset - 1);
1112   buff[LINE_LEN - offset - 1] = '\0';
1113
1114   return command_Interpret(buff, nb, argv);
1115 }
1116
1117 int
1118 command_Interpret(char *buff, int nb, char *argv[MAXARGS])
1119 {
1120   char *cp;
1121
1122   if (nb > 0) {
1123     cp = buff + strcspn(buff, "\r\n");
1124     if (cp)
1125       *cp = '\0';
1126     return MakeArgs(buff, argv, MAXARGS, PARSE_REDUCE);
1127   }
1128   return 0;
1129 }
1130
1131 static int
1132 arghidden(int argc, char const *const *argv, int n)
1133 {
1134   /* Is arg n of the given command to be hidden from the log ? */
1135
1136   /* set authkey xxxxx */
1137   /* set key xxxxx */
1138   if (n == 2 && !strncasecmp(argv[0], "se", 2) &&
1139       (!strncasecmp(argv[1], "authk", 5) || !strncasecmp(argv[1], "ke", 2)))
1140     return 1;
1141
1142   /* passwd xxxxx */
1143   if (n == 1 && !strncasecmp(argv[0], "p", 1))
1144     return 1;
1145
1146   /* set server port xxxxx .... */
1147   if (n == 3 && !strncasecmp(argv[0], "se", 2) &&
1148       !strncasecmp(argv[1], "se", 2))
1149     return 1;
1150
1151   return 0;
1152 }
1153
1154 void
1155 command_Run(struct bundle *bundle, int argc, char const *const *argv,
1156            struct prompt *prompt, const char *label, struct datalink *cx)
1157 {
1158   if (argc > 0) {
1159     if (log_IsKept(LogCOMMAND)) {
1160       char buf[LINE_LEN];
1161       int f, n;
1162
1163       if (label) {
1164         strncpy(buf, label, sizeof buf - 3);
1165         buf[sizeof buf - 3] = '\0';
1166         strcat(buf, ": ");
1167         n = strlen(buf);
1168       } else {
1169         *buf = '\0';
1170         n = 0;
1171       }
1172       buf[sizeof buf - 1] = '\0';       /* In case we run out of room in buf */
1173
1174       for (f = 0; f < argc; f++) {
1175         if (n < sizeof buf - 1 && f)
1176           buf[n++] = ' ';
1177         if (arghidden(argc, argv, f))
1178           strncpy(buf+n, "********", sizeof buf - n - 1);
1179         else
1180           strncpy(buf+n, argv[f], sizeof buf - n - 1);
1181         n += strlen(buf+n);
1182       }
1183       log_Printf(LogCOMMAND, "%s\n", buf);
1184     }
1185     FindExec(bundle, Commands, argc, 0, argv, prompt, cx);
1186   }
1187 }
1188
1189 int
1190 command_Decode(struct bundle *bundle, char *buff, int nb, struct prompt *prompt,
1191               const char *label)
1192 {
1193   int argc;
1194   char *argv[MAXARGS];
1195
1196   if ((argc = command_Expand_Interpret(buff, nb, argv, 0)) < 0)
1197     return 0;
1198
1199   command_Run(bundle, argc, (char const *const *)argv, prompt, label, NULL);
1200   return 1;
1201 }
1202
1203 static int
1204 ShowCommand(struct cmdargs const *arg)
1205 {
1206   if (!arg->prompt)
1207     log_Printf(LogWARN, "show: Cannot show without a prompt\n");
1208   else if (arg->argc > arg->argn)
1209     FindExec(arg->bundle, ShowCommands, arg->argc, arg->argn, arg->argv,
1210              arg->prompt, arg->cx);
1211   else
1212     prompt_Printf(arg->prompt, "Use ``show ?'' to get a list.\n");
1213
1214   return 0;
1215 }
1216
1217 static int
1218 TerminalCommand(struct cmdargs const *arg)
1219 {
1220   if (!arg->prompt) {
1221     log_Printf(LogWARN, "term: Need a prompt\n");
1222     return 1;
1223   }
1224
1225   if (arg->cx->physical->link.lcp.fsm.state > ST_CLOSED) {
1226     prompt_Printf(arg->prompt, "LCP state is [%s]\n",
1227                   State2Nam(arg->cx->physical->link.lcp.fsm.state));
1228     return 1;
1229   }
1230
1231   datalink_Up(arg->cx, 0, 0);
1232   prompt_TtyTermMode(arg->prompt, arg->cx);
1233   return 0;
1234 }
1235
1236 static int
1237 QuitCommand(struct cmdargs const *arg)
1238 {
1239   if (!arg->prompt || prompt_IsController(arg->prompt) ||
1240       (arg->argc > arg->argn && !strcasecmp(arg->argv[arg->argn], "all") &&
1241        (arg->prompt->auth & LOCAL_AUTH)))
1242     Cleanup(EX_NORMAL);
1243   if (arg->prompt)
1244     prompt_Destroy(arg->prompt, 1);
1245
1246   return 0;
1247 }
1248
1249 static int
1250 OpenCommand(struct cmdargs const *arg)
1251 {
1252   if (arg->argc == arg->argn)
1253     bundle_Open(arg->bundle, arg->cx ? arg->cx->name : NULL, PHYS_ALL, 1);
1254   else if (arg->argc == arg->argn + 1) {
1255     if (!strcasecmp(arg->argv[arg->argn], "lcp")) {
1256       struct datalink *cx = arg->cx ?
1257         arg->cx : bundle2datalink(arg->bundle, NULL);
1258       if (cx) {
1259         if (cx->physical->link.lcp.fsm.state == ST_OPENED)
1260           fsm_Reopen(&cx->physical->link.lcp.fsm);
1261         else
1262           bundle_Open(arg->bundle, cx->name, PHYS_ALL, 1);
1263       } else
1264         log_Printf(LogWARN, "open lcp: You must specify a link\n");
1265     } else if (!strcasecmp(arg->argv[arg->argn], "ccp")) {
1266       struct fsm *fp;
1267
1268       fp = &command_ChooseLink(arg)->ccp.fsm;
1269       if (fp->link->lcp.fsm.state != ST_OPENED)
1270         log_Printf(LogWARN, "open: LCP must be open before opening CCP\n");
1271       else if (fp->state == ST_OPENED)
1272         fsm_Reopen(fp);
1273       else {
1274         fp->open_mode = 0;      /* Not passive any more */
1275         if (fp->state == ST_STOPPED) {
1276           fsm_Down(fp);
1277           fsm_Up(fp);
1278         } else {
1279           fsm_Up(fp);
1280           fsm_Open(fp);
1281         }
1282       }
1283     } else if (!strcasecmp(arg->argv[arg->argn], "ipcp")) {
1284       if (arg->cx)
1285         log_Printf(LogWARN, "open ipcp: You need not specify a link\n");
1286       if (arg->bundle->ncp.ipcp.fsm.state == ST_OPENED)
1287         fsm_Reopen(&arg->bundle->ncp.ipcp.fsm);
1288       else
1289         bundle_Open(arg->bundle, NULL, PHYS_ALL, 1);
1290     } else
1291       return -1;
1292   } else
1293     return -1;
1294
1295   return 0;
1296 }
1297
1298 static int
1299 CloseCommand(struct cmdargs const *arg)
1300 {
1301   if (arg->argc == arg->argn)
1302     bundle_Close(arg->bundle, arg->cx ? arg->cx->name : NULL, CLOSE_STAYDOWN);
1303   else if (arg->argc == arg->argn + 1) {
1304     if (!strcasecmp(arg->argv[arg->argn], "lcp"))
1305       bundle_Close(arg->bundle, arg->cx ? arg->cx->name : NULL, CLOSE_LCP);
1306     else if (!strcasecmp(arg->argv[arg->argn], "ccp") ||
1307              !strcasecmp(arg->argv[arg->argn], "ccp!")) {
1308       struct fsm *fp;
1309
1310       fp = &command_ChooseLink(arg)->ccp.fsm;
1311       if (fp->state == ST_OPENED) {
1312         fsm_Close(fp);
1313         if (arg->argv[arg->argn][3] == '!')
1314           fp->open_mode = 0;            /* Stay ST_CLOSED */
1315         else
1316           fp->open_mode = OPEN_PASSIVE; /* Wait for the peer to start */
1317       }
1318     } else
1319       return -1;
1320   } else
1321     return -1;
1322
1323   return 0;
1324 }
1325
1326 static int
1327 DownCommand(struct cmdargs const *arg)
1328 {
1329   if (arg->argc == arg->argn) {
1330       if (arg->cx)
1331         datalink_Down(arg->cx, CLOSE_STAYDOWN);
1332       else
1333         bundle_Down(arg->bundle, CLOSE_STAYDOWN);
1334   } else if (arg->argc == arg->argn + 1) {
1335     if (!strcasecmp(arg->argv[arg->argn], "lcp")) {
1336       if (arg->cx)
1337         datalink_Down(arg->cx, CLOSE_LCP);
1338       else
1339         bundle_Down(arg->bundle, CLOSE_LCP);
1340     } else if (!strcasecmp(arg->argv[arg->argn], "ccp")) {
1341       struct fsm *fp = arg->cx ? &arg->cx->physical->link.ccp.fsm :
1342                                  &arg->bundle->ncp.mp.link.ccp.fsm;
1343       fsm2initial(fp);
1344     } else
1345       return -1;
1346   } else
1347     return -1;
1348
1349   return 0;
1350 }
1351
1352 static int
1353 SetModemSpeed(struct cmdargs const *arg)
1354 {
1355   long speed;
1356   char *end;
1357
1358   if (arg->argc > arg->argn && *arg->argv[arg->argn]) {
1359     if (arg->argc > arg->argn+1) {
1360       log_Printf(LogWARN, "SetModemSpeed: Too many arguments\n");
1361       return -1;
1362     }
1363     if (strcasecmp(arg->argv[arg->argn], "sync") == 0) {
1364       physical_SetSync(arg->cx->physical);
1365       return 0;
1366     }
1367     end = NULL;
1368     speed = strtol(arg->argv[arg->argn], &end, 10);
1369     if (*end) {
1370       log_Printf(LogWARN, "SetModemSpeed: Bad argument \"%s\"",
1371                 arg->argv[arg->argn]);
1372       return -1;
1373     }
1374     if (physical_SetSpeed(arg->cx->physical, speed))
1375       return 0;
1376     log_Printf(LogWARN, "%s: Invalid speed\n", arg->argv[arg->argn]);
1377   } else
1378     log_Printf(LogWARN, "SetModemSpeed: No speed specified\n");
1379
1380   return -1;
1381 }
1382
1383 static int
1384 SetStoppedTimeout(struct cmdargs const *arg)
1385 {
1386   struct link *l = &arg->cx->physical->link;
1387
1388   l->lcp.fsm.StoppedTimer.load = 0;
1389   l->ccp.fsm.StoppedTimer.load = 0;
1390   if (arg->argc <= arg->argn+2) {
1391     if (arg->argc > arg->argn) {
1392       l->lcp.fsm.StoppedTimer.load = atoi(arg->argv[arg->argn]) * SECTICKS;
1393       if (arg->argc > arg->argn+1)
1394         l->ccp.fsm.StoppedTimer.load = atoi(arg->argv[arg->argn+1]) * SECTICKS;
1395     }
1396     return 0;
1397   }
1398   return -1;
1399 }
1400
1401 static int
1402 SetServer(struct cmdargs const *arg)
1403 {
1404   int res = -1;
1405
1406   if (arg->argc > arg->argn && arg->argc < arg->argn+4) {
1407     const char *port, *passwd, *mask;
1408     int mlen;
1409
1410     /* What's what ? */
1411     port = arg->argv[arg->argn];
1412     if (arg->argc == arg->argn + 2) {
1413       passwd = arg->argv[arg->argn+1];
1414       mask = NULL;
1415     } else if (arg->argc == arg->argn + 3) {
1416       passwd = arg->argv[arg->argn+1];
1417       mask = arg->argv[arg->argn+2];
1418       mlen = strlen(mask);
1419       if (mlen == 0 || mlen > 4 || strspn(mask, "01234567") != mlen ||
1420           (mlen == 4 && *mask != '0')) {
1421         log_Printf(LogWARN, "%s %s: %s: Invalid mask\n",
1422                    arg->argv[arg->argn - 2], arg->argv[arg->argn - 1], mask);
1423         return -1;
1424       }
1425     } else if (arg->argc != arg->argn + 1)
1426       return -1;
1427     else if (strcasecmp(port, "none") == 0) {
1428       if (server_Clear(arg->bundle))
1429         log_Printf(LogPHASE, "Disabled server socket\n");
1430       return 0;
1431     } else if (strcasecmp(port, "open") == 0) {
1432       switch (server_Reopen(arg->bundle)) {
1433         case SERVER_OK:
1434           return 0;
1435         case SERVER_FAILED:
1436           log_Printf(LogWARN, "Failed to reopen server port\n");
1437           return 1;
1438         case SERVER_UNSET:
1439           log_Printf(LogWARN, "Cannot reopen unset server socket\n");
1440           return 1;
1441         default:
1442           break;
1443       }
1444       return -1;
1445     } else if (strcasecmp(port, "closed") == 0) {
1446       if (server_Close(arg->bundle))
1447         log_Printf(LogPHASE, "Closed server socket\n");
1448       else
1449         log_Printf(LogWARN, "Server socket not open\n");
1450
1451       return 0;
1452     } else
1453       return -1;
1454
1455     strncpy(server.cfg.passwd, passwd, sizeof server.cfg.passwd - 1);
1456     server.cfg.passwd[sizeof server.cfg.passwd - 1] = '\0';
1457
1458     if (*port == '/') {
1459       mode_t imask;
1460       char *ptr, name[LINE_LEN + 12];
1461
1462       if (mask == NULL)
1463         imask = (mode_t)-1;
1464       else for (imask = mlen = 0; mask[mlen]; mlen++)
1465         imask = (imask * 8) + mask[mlen] - '0';
1466
1467       ptr = strstr(port, "%d");
1468       if (ptr) {
1469         snprintf(name, sizeof name, "%.*s%d%s",
1470                  (int)(ptr - port), port, arg->bundle->unit, ptr + 2);
1471         port = name;
1472       }
1473       res = server_LocalOpen(arg->bundle, port, imask);
1474     } else {
1475       int iport, add = 0;
1476
1477       if (mask != NULL)
1478         return -1;
1479
1480       if (*port == '+') {
1481         port++;
1482         add = 1;
1483       }
1484       if (strspn(port, "0123456789") != strlen(port)) {
1485         struct servent *s;
1486
1487         if ((s = getservbyname(port, "tcp")) == NULL) {
1488           iport = 0;
1489           log_Printf(LogWARN, "%s: Invalid port or service\n", port);
1490         } else
1491           iport = ntohs(s->s_port);
1492       } else
1493         iport = atoi(port);
1494
1495       if (iport) {
1496         if (add)
1497           iport += arg->bundle->unit;
1498         res = server_TcpOpen(arg->bundle, iport);
1499       } else
1500         res = -1;
1501     }
1502   }
1503
1504   return res;
1505 }
1506
1507 static int
1508 SetEscape(struct cmdargs const *arg)
1509 {
1510   int code;
1511   int argc = arg->argc - arg->argn;
1512   char const *const *argv = arg->argv + arg->argn;
1513
1514   for (code = 0; code < 33; code++)
1515     arg->cx->physical->async.cfg.EscMap[code] = 0;
1516
1517   while (argc-- > 0) {
1518     sscanf(*argv++, "%x", &code);
1519     code &= 0xff;
1520     arg->cx->physical->async.cfg.EscMap[code >> 3] |= (1 << (code & 7));
1521     arg->cx->physical->async.cfg.EscMap[32] = 1;
1522   }
1523   return 0;
1524 }
1525
1526 static int
1527 SetInterfaceAddr(struct cmdargs const *arg)
1528 {
1529   struct ncp *ncp = &arg->bundle->ncp;
1530   struct ncpaddr ncpaddr;
1531   const char *hisaddr;
1532
1533   if (arg->argc > arg->argn + 4)
1534     return -1;
1535
1536   hisaddr = NULL;
1537   memset(&ncp->ipcp.cfg.my_range, '\0', sizeof ncp->ipcp.cfg.my_range);
1538   memset(&ncp->ipcp.cfg.peer_range, '\0', sizeof ncp->ipcp.cfg.peer_range);
1539   ncp->ipcp.cfg.HaveTriggerAddress = 0;
1540   ncp->ipcp.cfg.netmask.s_addr = INADDR_ANY;
1541   iplist_reset(&ncp->ipcp.cfg.peer_list);
1542
1543   if (arg->argc > arg->argn) {
1544     if (!ncprange_aton(&ncp->ipcp.cfg.my_range, ncp, arg->argv[arg->argn]))
1545       return 1;
1546     if (arg->argc > arg->argn+1) {
1547       hisaddr = arg->argv[arg->argn+1];
1548       if (arg->argc > arg->argn+2) {
1549         ncp->ipcp.ifmask = ncp->ipcp.cfg.netmask =
1550           GetIpAddr(arg->argv[arg->argn+2]);
1551         if (arg->argc > arg->argn+3) {
1552           ncp->ipcp.cfg.TriggerAddress = GetIpAddr(arg->argv[arg->argn+3]);
1553           ncp->ipcp.cfg.HaveTriggerAddress = 1;
1554         }
1555       }
1556     }
1557   }
1558
1559   /* 0.0.0.0 means any address (0 bits) */
1560   ncpaddr_getip4(&ncpaddr, &ncp->ipcp.my_ip);
1561   ncprange_getaddr(&ncp->ipcp.cfg.my_range, &ncpaddr);
1562   if (ncp->ipcp.my_ip.s_addr == INADDR_ANY)
1563     ncprange_setwidth(&ncp->ipcp.cfg.my_range, 0);
1564   bundle_AdjustFilters(arg->bundle, &ncpaddr, NULL);
1565
1566   if (hisaddr && !ipcp_UseHisaddr(arg->bundle, hisaddr,
1567                                   arg->bundle->phys_type.all & PHYS_AUTO))
1568     return 4;
1569
1570   return 0;
1571 }
1572
1573 static int
1574 SetRetry(int argc, char const *const *argv, u_int *timeout, u_int *maxreq,
1575           u_int *maxtrm, int def)
1576 {
1577   if (argc == 0) {
1578     *timeout = DEF_FSMRETRY;
1579     *maxreq = def;
1580     if (maxtrm != NULL)
1581       *maxtrm = def;
1582   } else {
1583     long l = atol(argv[0]);
1584
1585     if (l < MIN_FSMRETRY) {
1586       log_Printf(LogWARN, "%ld: Invalid FSM retry period - min %d\n",
1587                  l, MIN_FSMRETRY);
1588       return 1;
1589     } else
1590       *timeout = l;
1591
1592     if (argc > 1) {
1593       l = atol(argv[1]);
1594       if (l < 1) {
1595         log_Printf(LogWARN, "%ld: Invalid FSM REQ tries - changed to 1\n", l);
1596         l = 1;
1597       }
1598       *maxreq = l;
1599
1600       if (argc > 2 && maxtrm != NULL) {
1601         l = atol(argv[2]);
1602         if (l < 1) {
1603           log_Printf(LogWARN, "%ld: Invalid FSM TRM tries - changed to 1\n", l);
1604           l = 1;
1605         }
1606         *maxtrm = l;
1607       }
1608     }
1609   }
1610
1611   return 0;
1612 }
1613
1614 static int
1615 SetVariable(struct cmdargs const *arg)
1616 {
1617   long long_val, param = (long)arg->cmd->args;
1618   int mode, dummyint, f, first, res;
1619   u_short *change;
1620   const char *argp;
1621   struct datalink *cx = arg->cx;        /* LOCAL_CX uses this */
1622   struct link *l = command_ChooseLink(arg);     /* LOCAL_CX_OPT uses this */
1623   struct in_addr *ipaddr;
1624   struct ncpaddr ncpaddr[2];
1625
1626   if (arg->argc > arg->argn)
1627     argp = arg->argv[arg->argn];
1628   else
1629     argp = "";
1630
1631   res = 0;
1632
1633   if ((arg->cmd->lauth & LOCAL_CX) && !cx) {
1634     log_Printf(LogWARN, "set %s: No context (use the `link' command)\n",
1635               arg->cmd->name);
1636     return 1;
1637   } else if (cx && !(arg->cmd->lauth & (LOCAL_CX|LOCAL_CX_OPT))) {
1638     log_Printf(LogWARN, "set %s: Redundant context (%s) ignored\n",
1639               arg->cmd->name, cx->name);
1640     cx = NULL;
1641   }
1642
1643   switch (param) {
1644   case VAR_AUTHKEY:
1645     strncpy(arg->bundle->cfg.auth.key, argp,
1646             sizeof arg->bundle->cfg.auth.key - 1);
1647     arg->bundle->cfg.auth.key[sizeof arg->bundle->cfg.auth.key - 1] = '\0';
1648     break;
1649
1650   case VAR_AUTHNAME:
1651     switch (bundle_Phase(arg->bundle)) {
1652       default:
1653         log_Printf(LogWARN, "Altering authname while at phase %s\n",
1654                    bundle_PhaseName(arg->bundle));
1655         /* drop through */
1656       case PHASE_DEAD:
1657       case PHASE_ESTABLISH:
1658         strncpy(arg->bundle->cfg.auth.name, argp,
1659                 sizeof arg->bundle->cfg.auth.name - 1);
1660         arg->bundle->cfg.auth.name[sizeof arg->bundle->cfg.auth.name-1] = '\0';
1661         break;
1662     }
1663     break;
1664
1665   case VAR_AUTOLOAD:
1666     if (arg->argc == arg->argn + 3) {
1667       int v1, v2, v3;
1668       char *end;
1669
1670       v1 = strtol(arg->argv[arg->argn], &end, 0);
1671       if (v1 < 0 || *end) {
1672         log_Printf(LogWARN, "autoload: %s: Invalid min percentage\n",
1673                    arg->argv[arg->argn]);
1674         res = 1;
1675         break;
1676       }
1677
1678       v2 = strtol(arg->argv[arg->argn + 1], &end, 0);
1679       if (v2 < 0 || *end) {
1680         log_Printf(LogWARN, "autoload: %s: Invalid max percentage\n",
1681                    arg->argv[arg->argn + 1]);
1682         res = 1;
1683         break;
1684       }
1685       if (v2 < v1) {
1686         v3 = v1;
1687         v1 = v2;
1688         v2 = v3;
1689       }
1690
1691       v3 = strtol(arg->argv[arg->argn + 2], &end, 0);
1692       if (v3 <= 0 || *end) {
1693         log_Printf(LogWARN, "autoload: %s: Invalid throughput period\n",
1694                    arg->argv[arg->argn + 2]);
1695         res = 1;
1696         break;
1697       }
1698
1699       arg->bundle->ncp.mp.cfg.autoload.min = v1;
1700       arg->bundle->ncp.mp.cfg.autoload.max = v2;
1701       arg->bundle->ncp.mp.cfg.autoload.period = v3;
1702       mp_RestartAutoloadTimer(&arg->bundle->ncp.mp);
1703     } else {
1704       log_Printf(LogWARN, "Set autoload requires three arguments\n");
1705       res = 1;
1706     }
1707     break;
1708
1709   case VAR_DIAL:
1710     strncpy(cx->cfg.script.dial, argp, sizeof cx->cfg.script.dial - 1);
1711     cx->cfg.script.dial[sizeof cx->cfg.script.dial - 1] = '\0';
1712     break;
1713
1714   case VAR_LOGIN:
1715     strncpy(cx->cfg.script.login, argp, sizeof cx->cfg.script.login - 1);
1716     cx->cfg.script.login[sizeof cx->cfg.script.login - 1] = '\0';
1717     break;
1718
1719   case VAR_WINSIZE:
1720     if (arg->argc > arg->argn) {
1721       l->ccp.cfg.deflate.out.winsize = atoi(arg->argv[arg->argn]);
1722       if (l->ccp.cfg.deflate.out.winsize < 8 ||
1723           l->ccp.cfg.deflate.out.winsize > 15) {
1724           log_Printf(LogWARN, "%d: Invalid outgoing window size\n",
1725                     l->ccp.cfg.deflate.out.winsize);
1726           l->ccp.cfg.deflate.out.winsize = 15;
1727       }
1728       if (arg->argc > arg->argn+1) {
1729         l->ccp.cfg.deflate.in.winsize = atoi(arg->argv[arg->argn+1]);
1730         if (l->ccp.cfg.deflate.in.winsize < 8 ||
1731             l->ccp.cfg.deflate.in.winsize > 15) {
1732             log_Printf(LogWARN, "%d: Invalid incoming window size\n",
1733                       l->ccp.cfg.deflate.in.winsize);
1734             l->ccp.cfg.deflate.in.winsize = 15;
1735         }
1736       } else
1737         l->ccp.cfg.deflate.in.winsize = 0;
1738     } else {
1739       log_Printf(LogWARN, "No window size specified\n");
1740       res = 1;
1741     }
1742     break;
1743
1744 #ifndef NODES
1745   case VAR_MPPE:
1746     if (arg->argc > arg->argn + 2) {
1747       res = -1;
1748       break;
1749     }
1750
1751     if (arg->argc == arg->argn) {
1752       l->ccp.cfg.mppe.keybits = 0;
1753       l->ccp.cfg.mppe.state = MPPE_ANYSTATE;
1754       l->ccp.cfg.mppe.required = 0;
1755       break;
1756     }
1757
1758     if (!strcmp(argp, "*"))
1759       long_val = 0;
1760     else {
1761       long_val = atol(argp);
1762       if (long_val != 40 && long_val != 56 && long_val != 128) {
1763         log_Printf(LogWARN, "%s: Invalid bits value\n", argp);
1764         res = -1;
1765         break;
1766       }
1767     }
1768
1769     if (arg->argc == arg->argn + 2) {
1770       if (!strcmp(arg->argv[arg->argn + 1], "*"))
1771         l->ccp.cfg.mppe.state = MPPE_ANYSTATE;
1772       else if (!strcasecmp(arg->argv[arg->argn + 1], "stateless"))
1773         l->ccp.cfg.mppe.state = MPPE_STATELESS;
1774       else if (!strcasecmp(arg->argv[arg->argn + 1], "stateful"))
1775         l->ccp.cfg.mppe.state = MPPE_STATEFUL;
1776       else {
1777         log_Printf(LogWARN, "%s: Invalid state value\n",
1778                    arg->argv[arg->argn + 1]);
1779         res = -1;
1780         break;
1781       }
1782     } else
1783       l->ccp.cfg.mppe.state = MPPE_ANYSTATE;
1784     l->ccp.cfg.mppe.keybits = long_val;
1785     l->ccp.cfg.mppe.required = 1;
1786     break;
1787 #endif
1788
1789   case VAR_DEVICE:
1790     physical_SetDeviceList(cx->physical, arg->argc - arg->argn,
1791                            arg->argv + arg->argn);
1792     break;
1793
1794   case VAR_ACCMAP:
1795     if (arg->argc > arg->argn) {
1796       u_long ulong_val;
1797       sscanf(argp, "%lx", &ulong_val);
1798       cx->physical->link.lcp.cfg.accmap = (u_int32_t)ulong_val;
1799     } else {
1800       log_Printf(LogWARN, "No accmap specified\n");
1801       res = 1;
1802     }
1803     break;
1804
1805   case VAR_MODE:
1806     mode = Nam2mode(argp);
1807     if (mode == PHYS_NONE || mode == PHYS_ALL) {
1808       log_Printf(LogWARN, "%s: Invalid mode\n", argp);
1809       res = -1;
1810       break;
1811     }
1812     bundle_SetMode(arg->bundle, cx, mode);
1813     break;
1814
1815   case VAR_MRRU:
1816     switch (bundle_Phase(arg->bundle)) {
1817       case PHASE_DEAD:
1818         break;
1819       case PHASE_ESTABLISH:
1820         /* Make sure none of our links are DATALINK_LCP or greater */
1821         if (bundle_HighestState(arg->bundle) >= DATALINK_LCP) {
1822           log_Printf(LogWARN, "mrru: Only changeable before LCP negotiations\n");
1823           res = 1;
1824           break;
1825         }
1826         break;
1827       default:
1828         log_Printf(LogWARN, "mrru: Only changeable at phase DEAD/ESTABLISH\n");
1829         res = 1;
1830         break;
1831     }
1832     if (res != 0)
1833       break;
1834     long_val = atol(argp);
1835     if (long_val && long_val < MIN_MRU) {
1836       log_Printf(LogWARN, "MRRU %ld: too small - min %d\n", long_val, MIN_MRU);
1837       res = 1;
1838       break;
1839     } else if (long_val > MAX_MRU) {
1840       log_Printf(LogWARN, "MRRU %ld: too big - max %d\n", long_val, MAX_MRU);
1841       res = 1;
1842       break;
1843     } else
1844       arg->bundle->ncp.mp.cfg.mrru = long_val;
1845     break;
1846
1847   case VAR_MRU:
1848     long_val = 0;       /* silence gcc */
1849     change = NULL;      /* silence gcc */
1850     switch(arg->argc - arg->argn) {
1851     case 1:
1852       if (argp[strspn(argp, "0123456789")] != '\0') {
1853         res = -1;
1854         break;
1855       }
1856       /*FALLTHRU*/
1857     case 0:
1858       long_val = atol(argp);
1859       change = &l->lcp.cfg.mru;
1860       if (long_val > l->lcp.cfg.max_mru) {
1861         log_Printf(LogWARN, "MRU %ld: too large - max set to %d\n", long_val,
1862                    l->lcp.cfg.max_mru);
1863         res = 1;
1864         break;
1865       }
1866       break;
1867     case 2:
1868       if (strcasecmp(argp, "max") && strcasecmp(argp, "maximum")) {
1869         res = -1;
1870         break;
1871       }
1872       long_val = atol(arg->argv[arg->argn + 1]);
1873       change = &l->lcp.cfg.max_mru;
1874       if (long_val > MAX_MRU) {
1875         log_Printf(LogWARN, "MRU %ld: too large - maximum is %d\n", long_val,
1876                    MAX_MRU);
1877         res = 1;
1878         break;
1879       }
1880       break;
1881     default:
1882       res = -1;
1883       break;
1884     }
1885     if (res != 0)
1886       break;
1887
1888     if (long_val == 0)
1889       *change = 0;
1890     else if (long_val < MIN_MRU) {
1891       log_Printf(LogWARN, "MRU %ld: too small - min %d\n", long_val, MIN_MRU);
1892       res = 1;
1893       break;
1894     } else if (long_val > MAX_MRU) {
1895       log_Printf(LogWARN, "MRU %ld: too big - max %d\n", long_val, MAX_MRU);
1896       res = 1;
1897       break;
1898     } else
1899       *change = long_val;
1900     if (l->lcp.cfg.mru > *change)
1901       l->lcp.cfg.mru = *change;
1902     break;
1903
1904   case VAR_MTU:
1905     long_val = 0;       /* silence gcc */
1906     change = NULL;      /* silence gcc */
1907     switch(arg->argc - arg->argn) {
1908     case 1:
1909       if (argp[strspn(argp, "0123456789")] != '\0') {
1910         res = -1;
1911         break;
1912       }
1913       /*FALLTHRU*/
1914     case 0:
1915       long_val = atol(argp);
1916       change = &l->lcp.cfg.mtu;
1917       if (long_val > l->lcp.cfg.max_mtu) {
1918         log_Printf(LogWARN, "MTU %ld: too large - max set to %d\n", long_val,
1919                    l->lcp.cfg.max_mtu);
1920         res = 1;
1921         break;
1922       }
1923       break;
1924     case 2:
1925       if (strcasecmp(argp, "max") && strcasecmp(argp, "maximum")) {
1926         res = -1;
1927         break;
1928       }
1929       long_val = atol(arg->argv[arg->argn + 1]);
1930       change = &l->lcp.cfg.max_mtu;
1931       if (long_val > MAX_MTU) {
1932         log_Printf(LogWARN, "MTU %ld: too large - maximum is %d\n", long_val,
1933                    MAX_MTU);
1934         res = 1;
1935         break;
1936       }
1937       break;
1938     default:
1939       res = -1;
1940       break;
1941     }
1942
1943     if (res != 0)
1944       break;
1945
1946     if (long_val && long_val < MIN_MTU) {
1947       log_Printf(LogWARN, "MTU %ld: too small - min %d\n", long_val, MIN_MTU);
1948       res = 1;
1949       break;
1950     } else if (long_val > MAX_MTU) {
1951       log_Printf(LogWARN, "MTU %ld: too big - max %d\n", long_val, MAX_MTU);
1952       res = 1;
1953       break;
1954     } else
1955       *change = long_val;
1956     if (l->lcp.cfg.mtu > *change)
1957       l->lcp.cfg.mtu = *change;
1958     break;
1959
1960   case VAR_OPENMODE:
1961     if (strcasecmp(argp, "active") == 0)
1962       cx->physical->link.lcp.cfg.openmode = arg->argc > arg->argn+1 ?
1963         atoi(arg->argv[arg->argn+1]) : 1;
1964     else if (strcasecmp(argp, "passive") == 0)
1965       cx->physical->link.lcp.cfg.openmode = OPEN_PASSIVE;
1966     else {
1967       log_Printf(LogWARN, "%s: Invalid openmode\n", argp);
1968       res = 1;
1969     }
1970     break;
1971
1972   case VAR_PHONE:
1973     strncpy(cx->cfg.phone.list, argp, sizeof cx->cfg.phone.list - 1);
1974     cx->cfg.phone.list[sizeof cx->cfg.phone.list - 1] = '\0';
1975     cx->phone.alt = cx->phone.next = NULL;
1976     break;
1977
1978   case VAR_HANGUP:
1979     strncpy(cx->cfg.script.hangup, argp, sizeof cx->cfg.script.hangup - 1);
1980     cx->cfg.script.hangup[sizeof cx->cfg.script.hangup - 1] = '\0';
1981     break;
1982
1983   case VAR_IFQUEUE:
1984     long_val = atol(argp);
1985     arg->bundle->cfg.ifqueue = long_val < 0 ? 0 : long_val;
1986     break;
1987
1988   case VAR_LOGOUT:
1989     strncpy(cx->cfg.script.logout, argp, sizeof cx->cfg.script.logout - 1);
1990     cx->cfg.script.logout[sizeof cx->cfg.script.logout - 1] = '\0';
1991     break;
1992
1993   case VAR_IDLETIMEOUT:
1994     if (arg->argc > arg->argn+2) {
1995       log_Printf(LogWARN, "Too many idle timeout values\n");
1996       res = 1;
1997     } else if (arg->argc == arg->argn) {
1998       log_Printf(LogWARN, "Too few idle timeout values\n");
1999       res = 1;
2000     } else {
2001       int timeout, min;
2002
2003       timeout = atoi(argp);
2004       min = arg->argc == arg->argn + 2 ? atoi(arg->argv[arg->argn + 1]) : -1;
2005       bundle_SetIdleTimer(arg->bundle, timeout, min);
2006     }
2007     break;
2008
2009   case VAR_LQRPERIOD:
2010     long_val = atol(argp);
2011     if (long_val < MIN_LQRPERIOD) {
2012       log_Printf(LogWARN, "%ld: Invalid lqr period - min %d\n",
2013                  long_val, MIN_LQRPERIOD);
2014       res = 1;
2015     } else
2016       l->lcp.cfg.lqrperiod = long_val;
2017     break;
2018
2019   case VAR_LCPRETRY:
2020     res = SetRetry(arg->argc - arg->argn, arg->argv + arg->argn,
2021                    &cx->physical->link.lcp.cfg.fsm.timeout,
2022                    &cx->physical->link.lcp.cfg.fsm.maxreq,
2023                    &cx->physical->link.lcp.cfg.fsm.maxtrm, DEF_FSMTRIES);
2024     break;
2025
2026   case VAR_CHAPRETRY:
2027     res = SetRetry(arg->argc - arg->argn, arg->argv + arg->argn,
2028                    &cx->chap.auth.cfg.fsm.timeout,
2029                    &cx->chap.auth.cfg.fsm.maxreq, NULL, DEF_FSMAUTHTRIES);
2030     break;
2031
2032   case VAR_PAPRETRY:
2033     res = SetRetry(arg->argc - arg->argn, arg->argv + arg->argn,
2034                    &cx->pap.cfg.fsm.timeout, &cx->pap.cfg.fsm.maxreq,
2035                    NULL, DEF_FSMAUTHTRIES);
2036     break;
2037
2038   case VAR_CCPRETRY:
2039     res = SetRetry(arg->argc - arg->argn, arg->argv + arg->argn,
2040                    &l->ccp.cfg.fsm.timeout, &l->ccp.cfg.fsm.maxreq,
2041                    &l->ccp.cfg.fsm.maxtrm, DEF_FSMTRIES);
2042     break;
2043
2044   case VAR_IPCPRETRY:
2045     res = SetRetry(arg->argc - arg->argn, arg->argv + arg->argn,
2046                    &arg->bundle->ncp.ipcp.cfg.fsm.timeout,
2047                    &arg->bundle->ncp.ipcp.cfg.fsm.maxreq,
2048                    &arg->bundle->ncp.ipcp.cfg.fsm.maxtrm, DEF_FSMTRIES);
2049     break;
2050
2051 #ifndef NOINET6
2052   case VAR_IPV6CPRETRY:
2053     res = SetRetry(arg->argc - arg->argn, arg->argv + arg->argn,
2054                    &arg->bundle->ncp.ipv6cp.cfg.fsm.timeout,
2055                    &arg->bundle->ncp.ipv6cp.cfg.fsm.maxreq,
2056                    &arg->bundle->ncp.ipv6cp.cfg.fsm.maxtrm, DEF_FSMTRIES);
2057     break;
2058 #endif
2059
2060   case VAR_NBNS:
2061   case VAR_DNS:
2062     if (param == VAR_DNS) {
2063       ipaddr = arg->bundle->ncp.ipcp.cfg.ns.dns;
2064       ipaddr[0].s_addr = ipaddr[1].s_addr = INADDR_NONE;
2065     } else {
2066       ipaddr = arg->bundle->ncp.ipcp.cfg.ns.nbns;
2067       ipaddr[0].s_addr = ipaddr[1].s_addr = INADDR_ANY;
2068     }
2069
2070     if (arg->argc > arg->argn) {
2071       ncpaddr_aton(ncpaddr, &arg->bundle->ncp, arg->argv[arg->argn]);
2072       if (!ncpaddr_getip4(ncpaddr, ipaddr))
2073         return -1;
2074       if (arg->argc > arg->argn+1) {
2075         ncpaddr_aton(ncpaddr + 1, &arg->bundle->ncp, arg->argv[arg->argn + 1]);
2076         if (!ncpaddr_getip4(ncpaddr + 1, ipaddr + 1))
2077           return -1;
2078       }
2079
2080       if (ipaddr[0].s_addr == INADDR_ANY) {
2081         ipaddr[0] = ipaddr[1];
2082         ipaddr[1].s_addr = INADDR_ANY;
2083       }
2084       if (ipaddr[0].s_addr == INADDR_NONE) {
2085         ipaddr[0] = ipaddr[1];
2086         ipaddr[1].s_addr = INADDR_NONE;
2087       }
2088     }
2089     break;
2090
2091   case VAR_CALLBACK:
2092     cx->cfg.callback.opmask = 0;
2093     for (dummyint = arg->argn; dummyint < arg->argc; dummyint++) {
2094       if (!strcasecmp(arg->argv[dummyint], "auth"))
2095         cx->cfg.callback.opmask |= CALLBACK_BIT(CALLBACK_AUTH);
2096       else if (!strcasecmp(arg->argv[dummyint], "cbcp"))
2097         cx->cfg.callback.opmask |= CALLBACK_BIT(CALLBACK_CBCP);
2098       else if (!strcasecmp(arg->argv[dummyint], "e.164")) {
2099         if (dummyint == arg->argc - 1)
2100           log_Printf(LogWARN, "No E.164 arg (E.164 ignored) !\n");
2101         else {
2102           cx->cfg.callback.opmask |= CALLBACK_BIT(CALLBACK_E164);
2103           strncpy(cx->cfg.callback.msg, arg->argv[++dummyint],
2104                   sizeof cx->cfg.callback.msg - 1);
2105           cx->cfg.callback.msg[sizeof cx->cfg.callback.msg - 1] = '\0';
2106         }
2107       } else if (!strcasecmp(arg->argv[dummyint], "none"))
2108         cx->cfg.callback.opmask |= CALLBACK_BIT(CALLBACK_NONE);
2109       else {
2110         res = -1;
2111         break;
2112       }
2113     }
2114     if (cx->cfg.callback.opmask == CALLBACK_BIT(CALLBACK_NONE))
2115       cx->cfg.callback.opmask = 0;
2116     break;
2117
2118   case VAR_CBCP:
2119     cx->cfg.cbcp.delay = 0;
2120     *cx->cfg.cbcp.phone = '\0';
2121     cx->cfg.cbcp.fsmretry = DEF_FSMRETRY;
2122     if (arg->argc > arg->argn) {
2123       strncpy(cx->cfg.cbcp.phone, arg->argv[arg->argn],
2124               sizeof cx->cfg.cbcp.phone - 1);
2125       cx->cfg.cbcp.phone[sizeof cx->cfg.cbcp.phone - 1] = '\0';
2126       if (arg->argc > arg->argn + 1) {
2127         cx->cfg.cbcp.delay = atoi(arg->argv[arg->argn + 1]);
2128         if (arg->argc > arg->argn + 2) {
2129           long_val = atol(arg->argv[arg->argn + 2]);
2130           if (long_val < MIN_FSMRETRY)
2131             log_Printf(LogWARN, "%ld: Invalid CBCP FSM retry period - min %d\n",
2132                        long_val, MIN_FSMRETRY);
2133           else
2134             cx->cfg.cbcp.fsmretry = long_val;
2135         }
2136       }
2137     }
2138     break;
2139
2140   case VAR_CHOKED:
2141     arg->bundle->cfg.choked.timeout = atoi(argp);
2142     if (arg->bundle->cfg.choked.timeout <= 0)
2143       arg->bundle->cfg.choked.timeout = CHOKED_TIMEOUT;
2144     break;
2145
2146   case VAR_SENDPIPE:
2147     long_val = atol(argp);
2148     arg->bundle->ncp.cfg.sendpipe = long_val;
2149     break;
2150
2151   case VAR_RECVPIPE:
2152     long_val = atol(argp);
2153     arg->bundle->ncp.cfg.recvpipe = long_val;
2154     break;
2155
2156 #ifndef NORADIUS
2157   case VAR_RADIUS:
2158     if (!*argp)
2159       *arg->bundle->radius.cfg.file = '\0';
2160     else if (access(argp, R_OK)) {
2161       log_Printf(LogWARN, "%s: %s\n", argp, strerror(errno));
2162       res = 1;
2163       break;
2164     } else {
2165       strncpy(arg->bundle->radius.cfg.file, argp,
2166               sizeof arg->bundle->radius.cfg.file - 1);
2167       arg->bundle->radius.cfg.file
2168         [sizeof arg->bundle->radius.cfg.file - 1] = '\0';
2169     }
2170     break;
2171 #endif
2172
2173   case VAR_CD:
2174     if (*argp) {
2175       if (strcasecmp(argp, "off")) {
2176         long_val = atol(argp);
2177         if (long_val < 0)
2178           long_val = 0;
2179         cx->physical->cfg.cd.delay = long_val;
2180         cx->physical->cfg.cd.necessity = argp[strlen(argp)-1] == '!' ?
2181           CD_REQUIRED : CD_VARIABLE;
2182       } else
2183         cx->physical->cfg.cd.necessity = CD_NOTREQUIRED;
2184     } else {
2185       cx->physical->cfg.cd.delay = 0;
2186       cx->physical->cfg.cd.necessity = CD_DEFAULT;
2187     }
2188     break;
2189
2190   case VAR_PARITY:
2191     if (arg->argc == arg->argn + 1)
2192       res = physical_SetParity(arg->cx->physical, argp);
2193     else {
2194       log_Printf(LogWARN, "Parity value must be odd, even or none\n");
2195       res = 1;
2196     }
2197     break;
2198
2199   case VAR_CRTSCTS:
2200     if (strcasecmp(argp, "on") == 0)
2201       physical_SetRtsCts(arg->cx->physical, 1);
2202     else if (strcasecmp(argp, "off") == 0)
2203       physical_SetRtsCts(arg->cx->physical, 0);
2204     else {
2205       log_Printf(LogWARN, "RTS/CTS value must be on or off\n");
2206       res = 1;
2207     }
2208     break;
2209
2210   case VAR_URGENTPORTS:
2211     if (arg->argn == arg->argc) {
2212       ncp_SetUrgentTOS(&arg->bundle->ncp);
2213       ncp_ClearUrgentTcpPorts(&arg->bundle->ncp);
2214       ncp_ClearUrgentUdpPorts(&arg->bundle->ncp);
2215     } else if (!strcasecmp(arg->argv[arg->argn], "udp")) {
2216       ncp_SetUrgentTOS(&arg->bundle->ncp);
2217       if (arg->argn == arg->argc - 1)
2218         ncp_ClearUrgentUdpPorts(&arg->bundle->ncp);
2219       else for (f = arg->argn + 1; f < arg->argc; f++)
2220         if (*arg->argv[f] == '+')
2221           ncp_AddUrgentUdpPort(&arg->bundle->ncp, atoi(arg->argv[f] + 1));
2222         else if (*arg->argv[f] == '-')
2223           ncp_RemoveUrgentUdpPort(&arg->bundle->ncp, atoi(arg->argv[f] + 1));
2224         else {
2225           if (f == arg->argn)
2226             ncp_ClearUrgentUdpPorts(&arg->bundle->ncp);
2227           ncp_AddUrgentUdpPort(&arg->bundle->ncp, atoi(arg->argv[f]));
2228         }
2229     } else if (arg->argn == arg->argc - 1 &&
2230                !strcasecmp(arg->argv[arg->argn], "none")) {
2231       ncp_ClearUrgentTcpPorts(&arg->bundle->ncp);
2232       ncp_ClearUrgentUdpPorts(&arg->bundle->ncp);
2233       ncp_ClearUrgentTOS(&arg->bundle->ncp);
2234     } else {
2235       ncp_SetUrgentTOS(&arg->bundle->ncp);
2236       first = arg->argn;
2237       if (!strcasecmp(arg->argv[first], "tcp") && ++first == arg->argc)
2238         ncp_ClearUrgentTcpPorts(&arg->bundle->ncp);
2239
2240       for (f = first; f < arg->argc; f++)
2241         if (*arg->argv[f] == '+')
2242           ncp_AddUrgentTcpPort(&arg->bundle->ncp, atoi(arg->argv[f] + 1));
2243         else if (*arg->argv[f] == '-')
2244           ncp_RemoveUrgentTcpPort(&arg->bundle->ncp, atoi(arg->argv[f] + 1));
2245         else {
2246           if (f == first)
2247             ncp_ClearUrgentTcpPorts(&arg->bundle->ncp);
2248           ncp_AddUrgentTcpPort(&arg->bundle->ncp, atoi(arg->argv[f]));
2249         }
2250     }
2251     break;
2252   }
2253
2254   return res;
2255 }
2256
2257 static struct cmdtab const SetCommands[] = {
2258   {"accmap", NULL, SetVariable, LOCAL_AUTH | LOCAL_CX,
2259   "accmap value", "set accmap hex-value", (const void *)VAR_ACCMAP},
2260   {"authkey", "key", SetVariable, LOCAL_AUTH,
2261   "authentication key", "set authkey|key key", (const void *)VAR_AUTHKEY},
2262   {"authname", NULL, SetVariable, LOCAL_AUTH,
2263   "authentication name", "set authname name", (const void *)VAR_AUTHNAME},
2264   {"autoload", NULL, SetVariable, LOCAL_AUTH,
2265   "auto link [de]activation", "set autoload maxtime maxload mintime minload",
2266   (const void *)VAR_AUTOLOAD},
2267   {"bandwidth", NULL, mp_SetDatalinkBandwidth, LOCAL_AUTH | LOCAL_CX,
2268   "datalink bandwidth", "set bandwidth value"},
2269   {"callback", NULL, SetVariable, LOCAL_AUTH | LOCAL_CX,
2270   "callback control", "set callback [none|auth|cbcp|"
2271   "E.164 *|number[,number]...]...", (const void *)VAR_CALLBACK},
2272   {"cbcp", NULL, SetVariable, LOCAL_AUTH | LOCAL_CX,
2273   "CBCP control", "set cbcp [*|phone[,phone...] [delay [timeout]]]",
2274   (const void *)VAR_CBCP},
2275   {"ccpretry", "ccpretries", SetVariable, LOCAL_AUTH | LOCAL_CX_OPT,
2276    "CCP retries", "set ccpretry value [attempts]", (const void *)VAR_CCPRETRY},
2277   {"cd", NULL, SetVariable, LOCAL_AUTH | LOCAL_CX, "Carrier delay requirement",
2278    "set cd value[!]", (const void *)VAR_CD},
2279   {"chapretry", "chapretries", SetVariable, LOCAL_AUTH | LOCAL_CX,
2280    "CHAP retries", "set chapretry value [attempts]",
2281    (const void *)VAR_CHAPRETRY},
2282   {"choked", NULL, SetVariable, LOCAL_AUTH,
2283   "choked timeout", "set choked [secs]", (const void *)VAR_CHOKED},
2284   {"ctsrts", "crtscts", SetVariable, LOCAL_AUTH | LOCAL_CX,
2285    "Use hardware flow control", "set ctsrts [on|off]",
2286    (const char *)VAR_CRTSCTS},
2287   {"deflate", NULL, SetVariable, LOCAL_AUTH | LOCAL_CX_OPT,
2288   "deflate window sizes", "set deflate out-winsize in-winsize",
2289   (const void *) VAR_WINSIZE},
2290 #ifndef NODES
2291   {"mppe", NULL, SetVariable, LOCAL_AUTH | LOCAL_CX_OPT,
2292   "MPPE key size and state", "set mppe [40|56|128|* [stateful|stateless|*]]",
2293   (const void *) VAR_MPPE},
2294 #endif
2295   {"device", "line", SetVariable, LOCAL_AUTH | LOCAL_CX,
2296   "physical device name", "set device|line device-name[,device-name]",
2297   (const void *) VAR_DEVICE},
2298   {"dial", NULL, SetVariable, LOCAL_AUTH | LOCAL_CX,
2299   "dialing script", "set dial chat-script", (const void *) VAR_DIAL},
2300   {"dns", NULL, SetVariable, LOCAL_AUTH, "Domain Name Server",
2301   "set dns pri-addr [sec-addr]", (const void *)VAR_DNS},
2302   {"enddisc", NULL, mp_SetEnddisc, LOCAL_AUTH,
2303   "Endpoint Discriminator", "set enddisc [IP|magic|label|psn value]"},
2304   {"escape", NULL, SetEscape, LOCAL_AUTH | LOCAL_CX,
2305   "escape characters", "set escape hex-digit ..."},
2306   {"filter", NULL, filter_Set, LOCAL_AUTH,
2307   "packet filters", "set filter alive|dial|in|out rule-no permit|deny "
2308   "[src_addr[/width]] [dst_addr[/width]] [proto "
2309   "[src [lt|eq|gt port]] [dst [lt|eq|gt port]] [estab] [syn] [finrst]]"},
2310   {"hangup", NULL, SetVariable, LOCAL_AUTH | LOCAL_CX,
2311   "hangup script", "set hangup chat-script", (const void *) VAR_HANGUP},
2312   {"ifaddr", NULL, SetInterfaceAddr, LOCAL_AUTH, "destination address",
2313   "set ifaddr [src-addr [dst-addr [netmask [trg-addr]]]]"},
2314   {"ifqueue", NULL, SetVariable, LOCAL_AUTH, "interface queue",
2315   "set ifqueue packets", (const void *)VAR_IFQUEUE},
2316   {"ipcpretry", "ipcpretries", SetVariable, LOCAL_AUTH, "IPCP retries",
2317    "set ipcpretry value [attempts]", (const void *)VAR_IPCPRETRY},
2318   {"ipv6cpretry", "ipv6cpretries", SetVariable, LOCAL_AUTH, "IPV6CP retries",
2319    "set ipv6cpretry value [attempts]", (const void *)VAR_IPV6CPRETRY},
2320   {"lcpretry", "lcpretries", SetVariable, LOCAL_AUTH | LOCAL_CX, "LCP retries",
2321    "set lcpretry value [attempts]", (const void *)VAR_LCPRETRY},
2322   {"log", NULL, log_SetLevel, LOCAL_AUTH, "log level",
2323   "set log [local] [+|-]all|async|cbcp|ccp|chat|command|connect|debug|dns|hdlc|"
2324   "id0|ipcp|lcp|lqm|phase|physical|sync|tcp/ip|timer|tun..."},
2325   {"login", NULL, SetVariable, LOCAL_AUTH | LOCAL_CX,
2326   "login script", "set login chat-script", (const void *) VAR_LOGIN},
2327   {"logout", NULL, SetVariable, LOCAL_AUTH | LOCAL_CX,
2328   "logout script", "set logout chat-script", (const void *) VAR_LOGOUT},
2329   {"lqrperiod", NULL, SetVariable, LOCAL_AUTH | LOCAL_CX_OPT,
2330   "LQR period", "set lqrperiod value", (const void *)VAR_LQRPERIOD},
2331   {"mode", NULL, SetVariable, LOCAL_AUTH | LOCAL_CX, "mode value",
2332   "set mode interactive|auto|ddial|background", (const void *)VAR_MODE},
2333   {"mrru", NULL, SetVariable, LOCAL_AUTH, "MRRU value",
2334   "set mrru value", (const void *)VAR_MRRU},
2335   {"mru", NULL, SetVariable, LOCAL_AUTH | LOCAL_CX,
2336   "MRU value", "set mru [max[imum]] [value]", (const void *)VAR_MRU},
2337   {"mtu", NULL, SetVariable, LOCAL_AUTH | LOCAL_CX,
2338   "interface MTU value", "set mtu [max[imum]] [value]", (const void *)VAR_MTU},
2339   {"nbns", NULL, SetVariable, LOCAL_AUTH, "NetBIOS Name Server",
2340   "set nbns pri-addr [sec-addr]", (const void *)VAR_NBNS},
2341   {"openmode", NULL, SetVariable, LOCAL_AUTH | LOCAL_CX, "open mode",
2342   "set openmode active|passive [secs]", (const void *)VAR_OPENMODE},
2343   {"papretry", "papretries", SetVariable, LOCAL_AUTH | LOCAL_CX, "PAP retries",
2344    "set papretry value [attempts]", (const void *)VAR_PAPRETRY},
2345   {"parity", NULL, SetVariable, LOCAL_AUTH | LOCAL_CX, "serial parity",
2346    "set parity [odd|even|none]", (const void *)VAR_PARITY},
2347   {"phone", NULL, SetVariable, LOCAL_AUTH | LOCAL_CX, "telephone number(s)",
2348   "set phone phone1[:phone2[...]]", (const void *)VAR_PHONE},
2349   {"proctitle", "title", SetProcTitle, LOCAL_AUTH,
2350   "Process title", "set proctitle [value]"},
2351 #ifndef NORADIUS
2352   {"radius", NULL, SetVariable, LOCAL_AUTH,
2353   "RADIUS Config", "set radius cfgfile", (const void *)VAR_RADIUS},
2354 #endif
2355   {"reconnect", NULL, datalink_SetReconnect, LOCAL_AUTH | LOCAL_CX,
2356   "Reconnect timeout", "set reconnect value ntries"},
2357   {"recvpipe", NULL, SetVariable, LOCAL_AUTH,
2358   "RECVPIPE value", "set recvpipe value", (const void *)VAR_RECVPIPE},
2359   {"redial", NULL, datalink_SetRedial, LOCAL_AUTH | LOCAL_CX,
2360   "Redial timeout", "set redial secs[+inc[-incmax]][.next] [attempts]"},
2361   {"sendpipe", NULL, SetVariable, LOCAL_AUTH,
2362   "SENDPIPE value", "set sendpipe value", (const void *)VAR_SENDPIPE},
2363   {"server", "socket", SetServer, LOCAL_AUTH, "diagnostic port",
2364   "set server|socket TcpPort|LocalName|none|open|closed [password [mask]]"},
2365   {"speed", NULL, SetModemSpeed, LOCAL_AUTH | LOCAL_CX,
2366   "physical speed", "set speed value|sync"},
2367   {"stopped", NULL, SetStoppedTimeout, LOCAL_AUTH | LOCAL_CX,
2368   "STOPPED timeouts", "set stopped [LCPseconds [CCPseconds]]"},
2369   {"timeout", NULL, SetVariable, LOCAL_AUTH, "Idle timeout",
2370   "set timeout idletime", (const void *)VAR_IDLETIMEOUT},
2371   {"urgent", NULL, SetVariable, LOCAL_AUTH, "urgent ports",
2372   "set urgent [tcp|udp] [+|-]port...", (const void *)VAR_URGENTPORTS},
2373   {"vj", NULL, ipcp_vjset, LOCAL_AUTH,
2374   "vj values", "set vj slots|slotcomp [value]"},
2375   {"help", "?", HelpCommand, LOCAL_AUTH | LOCAL_NO_AUTH,
2376   "Display this message", "set help|? [command]", SetCommands},
2377   {NULL, NULL, NULL},
2378 };
2379
2380 static int
2381 SetCommand(struct cmdargs const *arg)
2382 {
2383   if (arg->argc > arg->argn)
2384     FindExec(arg->bundle, SetCommands, arg->argc, arg->argn, arg->argv,
2385              arg->prompt, arg->cx);
2386   else if (arg->prompt)
2387     prompt_Printf(arg->prompt, "Use `set ?' to get a list or `set ? <var>' for"
2388                   " syntax help.\n");
2389   else
2390     log_Printf(LogWARN, "set command must have arguments\n");
2391
2392   return 0;
2393 }
2394
2395 static int
2396 AddCommand(struct cmdargs const *arg)
2397 {
2398   struct ncpaddr gw;
2399   struct ncprange dest;
2400   struct in_addr host;
2401 #ifndef NOINET6
2402   struct in6_addr host6;
2403 #endif
2404   int dest_default, gw_arg, addrs;
2405
2406   if (arg->argc != arg->argn+3 && arg->argc != arg->argn+2)
2407     return -1;
2408
2409   addrs = 0;
2410   dest_default = 0;
2411   if (arg->argc == arg->argn + 2) {
2412     if (!strcasecmp(arg->argv[arg->argn], "default"))
2413       dest_default = 1;
2414     else {
2415       if (!ncprange_aton(&dest, &arg->bundle->ncp, arg->argv[arg->argn]))
2416         return -1;
2417       if (!strncasecmp(arg->argv[arg->argn], "MYADDR", 6))
2418         addrs = ROUTE_DSTMYADDR;
2419       else if (!strncasecmp(arg->argv[arg->argn], "MYADDR6", 7))
2420         addrs = ROUTE_DSTMYADDR6;
2421       else if (!strncasecmp(arg->argv[arg->argn], "HISADDR", 7))
2422         addrs = ROUTE_DSTHISADDR;
2423       else if (!strncasecmp(arg->argv[arg->argn], "HISADDR6", 8))
2424         addrs = ROUTE_DSTHISADDR6;
2425       else if (!strncasecmp(arg->argv[arg->argn], "DNS0", 4))
2426         addrs = ROUTE_DSTDNS0;
2427       else if (!strncasecmp(arg->argv[arg->argn], "DNS1", 4))
2428         addrs = ROUTE_DSTDNS1;
2429     }
2430     gw_arg = 1;
2431   } else {
2432     if (strcasecmp(arg->argv[arg->argn], "MYADDR") == 0) {
2433       addrs = ROUTE_DSTMYADDR;
2434       host = arg->bundle->ncp.ipcp.my_ip;
2435     } else if (strcasecmp(arg->argv[arg->argn], "HISADDR") == 0) {
2436       addrs = ROUTE_DSTHISADDR;
2437       host = arg->bundle->ncp.ipcp.peer_ip;
2438     } else if (strcasecmp(arg->argv[arg->argn], "DNS0") == 0) {
2439       addrs = ROUTE_DSTDNS0;
2440       host = arg->bundle->ncp.ipcp.ns.dns[0];
2441     } else if (strcasecmp(arg->argv[arg->argn], "DNS1") == 0) {
2442       addrs = ROUTE_DSTDNS1;
2443       host = arg->bundle->ncp.ipcp.ns.dns[1];
2444     } else {
2445       host = GetIpAddr(arg->argv[arg->argn]);
2446       if (host.s_addr == INADDR_NONE) {
2447         log_Printf(LogWARN, "%s: Invalid destination address\n",
2448                    arg->argv[arg->argn]);
2449         return -1;
2450       }
2451     }
2452     ncprange_setip4(&dest, host, GetIpAddr(arg->argv[arg->argn + 1]));
2453     gw_arg = 2;
2454   }
2455
2456   if (strcasecmp(arg->argv[arg->argn + gw_arg], "HISADDR") == 0) {
2457     ncpaddr_setip4(&gw, arg->bundle->ncp.ipcp.peer_ip);
2458     addrs |= ROUTE_GWHISADDR;
2459 #ifndef NOINET6
2460   } else if (strcasecmp(arg->argv[arg->argn + gw_arg], "HISADDR6") == 0) {
2461     if (!ncpaddr_getip6(&arg->bundle->ncp.ipv6cp.hisaddr, &host6))
2462       memset(&host6, '\0', sizeof host6);
2463     ncpaddr_setip6(&gw, &host6);
2464     addrs |= ROUTE_GWHISADDR6;
2465 #endif
2466   } else {
2467     if (!ncpaddr_aton(&gw, &arg->bundle->ncp, arg->argv[arg->argn + gw_arg])) {
2468       log_Printf(LogWARN, "%s: Invalid gateway address\n",
2469                  arg->argv[arg->argn + gw_arg]);
2470       return -1;
2471     }
2472   }
2473
2474   if (dest_default)
2475     ncprange_setdefault(&dest, ncpaddr_family(&gw));
2476
2477   if (rt_Set(arg->bundle, RTM_ADD, &dest, &gw, arg->cmd->args ? 1 : 0,
2478              ((addrs & ROUTE_GWHISADDR) || (addrs & ROUTE_GWHISADDR6)) ? 1 : 0)
2479       && addrs != ROUTE_STATIC)
2480     route_Add(&arg->bundle->ncp.route, addrs, &dest, &gw);
2481
2482   return 0;
2483 }
2484
2485 static int
2486 DeleteCommand(struct cmdargs const *arg)
2487 {
2488   struct ncprange dest;
2489   int addrs;
2490
2491   if (arg->argc == arg->argn+1) {
2492     if(strcasecmp(arg->argv[arg->argn], "all") == 0) {
2493       route_IfDelete(arg->bundle, 0);
2494       route_DeleteAll(&arg->bundle->ncp.route);
2495     } else {
2496       addrs = 0;
2497       if (strcasecmp(arg->argv[arg->argn], "MYADDR") == 0) {
2498         ncprange_setip4host(&dest, arg->bundle->ncp.ipcp.my_ip);
2499         addrs = ROUTE_DSTMYADDR;
2500 #ifndef NOINET6
2501       } else if (strcasecmp(arg->argv[arg->argn], "MYADDR6") == 0) {
2502         ncprange_sethost(&dest, &arg->bundle->ncp.ipv6cp.myaddr);
2503         addrs = ROUTE_DSTMYADDR6;
2504 #endif
2505       } else if (strcasecmp(arg->argv[arg->argn], "HISADDR") == 0) {
2506         ncprange_setip4host(&dest, arg->bundle->ncp.ipcp.peer_ip);
2507         addrs = ROUTE_DSTHISADDR;
2508 #ifndef NOINET6
2509       } else if (strcasecmp(arg->argv[arg->argn], "HISADDR6") == 0) {
2510         ncprange_sethost(&dest, &arg->bundle->ncp.ipv6cp.hisaddr);
2511         addrs = ROUTE_DSTHISADDR6;
2512 #endif
2513       } else if (strcasecmp(arg->argv[arg->argn], "DNS0") == 0) {
2514         ncprange_setip4host(&dest, arg->bundle->ncp.ipcp.ns.dns[0]);
2515         addrs = ROUTE_DSTDNS0;
2516       } else if (strcasecmp(arg->argv[arg->argn], "DNS1") == 0) {
2517         ncprange_setip4host(&dest, arg->bundle->ncp.ipcp.ns.dns[1]);
2518         addrs = ROUTE_DSTDNS1;
2519       } else {
2520         ncprange_aton(&dest, &arg->bundle->ncp, arg->argv[arg->argn]);
2521         addrs = ROUTE_STATIC;
2522       }
2523       rt_Set(arg->bundle, RTM_DELETE, &dest, NULL, arg->cmd->args ? 1 : 0, 0);
2524       route_Delete(&arg->bundle->ncp.route, addrs, &dest);
2525     }
2526   } else
2527     return -1;
2528
2529   return 0;
2530 }
2531
2532 #ifndef NONAT
2533 static int
2534 NatEnable(struct cmdargs const *arg)
2535 {
2536   if (arg->argc == arg->argn+1) {
2537     if (strcasecmp(arg->argv[arg->argn], "yes") == 0) {
2538       if (!arg->bundle->NatEnabled) {
2539         if (arg->bundle->ncp.ipcp.fsm.state == ST_OPENED)
2540           PacketAliasSetAddress(arg->bundle->ncp.ipcp.my_ip);
2541         arg->bundle->NatEnabled = 1;
2542       }
2543       return 0;
2544     } else if (strcasecmp(arg->argv[arg->argn], "no") == 0) {
2545       arg->bundle->NatEnabled = 0;
2546       arg->bundle->cfg.opt &= ~OPT_IFACEALIAS;
2547       /* Don't iface_Clear() - there may be manually configured addresses */
2548       return 0;
2549     }
2550   }
2551
2552   return -1;
2553 }
2554
2555
2556 static int
2557 NatOption(struct cmdargs const *arg)
2558 {
2559   long param = (long)arg->cmd->args;
2560
2561   if (arg->argc == arg->argn+1) {
2562     if (strcasecmp(arg->argv[arg->argn], "yes") == 0) {
2563       if (arg->bundle->NatEnabled) {
2564         PacketAliasSetMode(param, param);
2565         return 0;
2566       }
2567       log_Printf(LogWARN, "nat not enabled\n");
2568     } else if (strcmp(arg->argv[arg->argn], "no") == 0) {
2569       if (arg->bundle->NatEnabled) {
2570         PacketAliasSetMode(0, param);
2571         return 0;
2572       }
2573       log_Printf(LogWARN, "nat not enabled\n");
2574     }
2575   }
2576   return -1;
2577 }
2578 #endif /* #ifndef NONAT */
2579
2580 static int
2581 LinkCommand(struct cmdargs const *arg)
2582 {
2583   if (arg->argc > arg->argn+1) {
2584     char namelist[LINE_LEN];
2585     struct datalink *cx;
2586     char *name;
2587     int result = 0;
2588
2589     if (!strcmp(arg->argv[arg->argn], "*")) {
2590       struct datalink *dl;
2591
2592       cx = arg->bundle->links;
2593       while (cx) {
2594         /* Watch it, the command could be a ``remove'' */
2595         dl = cx->next;
2596         FindExec(arg->bundle, Commands, arg->argc, arg->argn+1, arg->argv,
2597                  arg->prompt, cx);
2598         for (cx = arg->bundle->links; cx; cx = cx->next)
2599           if (cx == dl)
2600             break;              /* Pointer's still valid ! */
2601       }
2602     } else {
2603       strncpy(namelist, arg->argv[arg->argn], sizeof namelist - 1);
2604       namelist[sizeof namelist - 1] = '\0';
2605       for(name = strtok(namelist, ", "); name; name = strtok(NULL,", "))
2606         if (!bundle2datalink(arg->bundle, name)) {
2607           log_Printf(LogWARN, "link: %s: Invalid link name\n", name);
2608           return 1;
2609         }
2610
2611       strncpy(namelist, arg->argv[arg->argn], sizeof namelist - 1);
2612       namelist[sizeof namelist - 1] = '\0';
2613       for(name = strtok(namelist, ", "); name; name = strtok(NULL,", ")) {
2614         cx = bundle2datalink(arg->bundle, name);
2615         if (cx)
2616           FindExec(arg->bundle, Commands, arg->argc, arg->argn+1, arg->argv,
2617                    arg->prompt, cx);
2618         else {
2619           log_Printf(LogWARN, "link: %s: Invalidated link name !\n", name);
2620           result++;
2621         }
2622       }
2623     }
2624     return result;
2625   }
2626
2627   log_Printf(LogWARN, "usage: %s\n", arg->cmd->syntax);
2628   return 2;
2629 }
2630
2631 struct link *
2632 command_ChooseLink(struct cmdargs const *arg)
2633 {
2634   if (arg->cx)
2635     return &arg->cx->physical->link;
2636   else if (!arg->bundle->ncp.mp.cfg.mrru) {
2637     struct datalink *dl = bundle2datalink(arg->bundle, NULL);
2638     if (dl)
2639       return &dl->physical->link;
2640   }
2641   return &arg->bundle->ncp.mp.link;
2642 }
2643
2644 static const char *
2645 ident_cmd(const char *cmd, unsigned *keep, unsigned *add)
2646 {
2647   const char *result;
2648
2649   switch (*cmd) {
2650     case 'A':
2651     case 'a':
2652       result = "accept";
2653       *keep = NEG_MYMASK;
2654       *add = NEG_ACCEPTED;
2655       break;
2656     case 'D':
2657     case 'd':
2658       switch (cmd[1]) {
2659         case 'E':
2660         case 'e':
2661           result = "deny";
2662           *keep = NEG_MYMASK;
2663           *add = 0;
2664           break;
2665         case 'I':
2666         case 'i':
2667           result = "disable";
2668           *keep = NEG_HISMASK;
2669           *add = 0;
2670           break;
2671         default:
2672           return NULL;
2673       }
2674       break;
2675     case 'E':
2676     case 'e':
2677       result = "enable";
2678       *keep = NEG_HISMASK;
2679       *add = NEG_ENABLED;
2680       break;
2681     default:
2682       return NULL;
2683   }
2684
2685   return result;
2686 }
2687
2688 static int
2689 OptSet(struct cmdargs const *arg)
2690 {
2691   int bit = (int)(long)arg->cmd->args;
2692   unsigned keep;                        /* Keep these bits */
2693   unsigned add;                         /* Add these bits */
2694
2695   if (ident_cmd(arg->argv[arg->argn - 2], &keep, &add) == NULL)
2696     return 1;
2697
2698 #ifndef NOINET6
2699   if (add == NEG_ENABLED && bit == OPT_IPV6CP && !probe.ipv6_available) {
2700     log_Printf(LogWARN, "IPv6 is not available on this machine\n");
2701     return 1;
2702   }
2703 #endif
2704
2705   if (add)
2706     arg->bundle->cfg.opt |= bit;
2707   else
2708     arg->bundle->cfg.opt &= ~bit;
2709
2710   return 0;
2711 }
2712
2713 static int
2714 IfaceAliasOptSet(struct cmdargs const *arg)
2715 {
2716   unsigned save = arg->bundle->cfg.opt;
2717   int result = OptSet(arg);
2718
2719   if (result == 0)
2720     if (Enabled(arg->bundle, OPT_IFACEALIAS) && !arg->bundle->NatEnabled) {
2721       arg->bundle->cfg.opt = save;
2722       log_Printf(LogWARN, "Cannot enable iface-alias without NAT\n");
2723       result = 2;
2724     }
2725
2726   return result;
2727 }
2728
2729 static int
2730 NegotiateSet(struct cmdargs const *arg)
2731 {
2732   long param = (long)arg->cmd->args;
2733   struct link *l = command_ChooseLink(arg);     /* LOCAL_CX_OPT uses this */
2734   struct datalink *cx = arg->cx;        /* LOCAL_CX uses this */
2735   const char *cmd;
2736   unsigned keep;                        /* Keep these bits */
2737   unsigned add;                         /* Add these bits */
2738
2739   if ((cmd = ident_cmd(arg->argv[arg->argn-2], &keep, &add)) == NULL)
2740     return 1;
2741
2742   if ((arg->cmd->lauth & LOCAL_CX) && !cx) {
2743     log_Printf(LogWARN, "%s %s: No context (use the `link' command)\n",
2744               cmd, arg->cmd->name);
2745     return 2;
2746   } else if (cx && !(arg->cmd->lauth & (LOCAL_CX|LOCAL_CX_OPT))) {
2747     log_Printf(LogWARN, "%s %s: Redundant context (%s) ignored\n",
2748               cmd, arg->cmd->name, cx->name);
2749     cx = NULL;
2750   }
2751
2752   switch (param) {
2753     case NEG_ACFCOMP:
2754       cx->physical->link.lcp.cfg.acfcomp &= keep;
2755       cx->physical->link.lcp.cfg.acfcomp |= add;
2756       break;
2757     case NEG_CHAP05:
2758       cx->physical->link.lcp.cfg.chap05 &= keep;
2759       cx->physical->link.lcp.cfg.chap05 |= add;
2760       break;
2761 #ifndef NODES
2762     case NEG_CHAP80:
2763       cx->physical->link.lcp.cfg.chap80nt &= keep;
2764       cx->physical->link.lcp.cfg.chap80nt |= add;
2765       break;
2766     case NEG_CHAP80LM:
2767       cx->physical->link.lcp.cfg.chap80lm &= keep;
2768       cx->physical->link.lcp.cfg.chap80lm |= add;
2769       break;
2770     case NEG_CHAP81:
2771       cx->physical->link.lcp.cfg.chap81 &= keep;
2772       cx->physical->link.lcp.cfg.chap81 |= add;
2773       break;
2774     case NEG_MPPE:
2775       l->ccp.cfg.neg[CCP_NEG_MPPE] &= keep;
2776       l->ccp.cfg.neg[CCP_NEG_MPPE] |= add;
2777       break;
2778 #endif
2779     case NEG_DEFLATE:
2780       l->ccp.cfg.neg[CCP_NEG_DEFLATE] &= keep;
2781       l->ccp.cfg.neg[CCP_NEG_DEFLATE] |= add;
2782       break;
2783     case NEG_DNS:
2784       arg->bundle->ncp.ipcp.cfg.ns.dns_neg &= keep;
2785       arg->bundle->ncp.ipcp.cfg.ns.dns_neg |= add;
2786       break;
2787     case NEG_ENDDISC:
2788       arg->bundle->ncp.mp.cfg.negenddisc &= keep;
2789       arg->bundle->ncp.mp.cfg.negenddisc |= add;
2790       break;
2791     case NEG_LQR:
2792       cx->physical->link.lcp.cfg.lqr &= keep;
2793       cx->physical->link.lcp.cfg.lqr |= add;
2794       break;
2795     case NEG_PAP:
2796       cx->physical->link.lcp.cfg.pap &= keep;
2797       cx->physical->link.lcp.cfg.pap |= add;
2798       break;
2799     case NEG_PPPDDEFLATE:
2800       l->ccp.cfg.neg[CCP_NEG_DEFLATE24] &= keep;
2801       l->ccp.cfg.neg[CCP_NEG_DEFLATE24] |= add;
2802       break;
2803     case NEG_PRED1:
2804       l->ccp.cfg.neg[CCP_NEG_PRED1] &= keep;
2805       l->ccp.cfg.neg[CCP_NEG_PRED1] |= add;
2806       break;
2807     case NEG_PROTOCOMP:
2808       cx->physical->link.lcp.cfg.protocomp &= keep;
2809       cx->physical->link.lcp.cfg.protocomp |= add;
2810       break;
2811     case NEG_SHORTSEQ:
2812       switch (bundle_Phase(arg->bundle)) {
2813         case PHASE_DEAD:
2814           break;
2815         case PHASE_ESTABLISH:
2816           /* Make sure none of our links are DATALINK_LCP or greater */
2817           if (bundle_HighestState(arg->bundle) >= DATALINK_LCP) {
2818             log_Printf(LogWARN, "shortseq: Only changeable before"
2819                        " LCP negotiations\n");
2820             return 1;
2821           }
2822           break;
2823         default:
2824           log_Printf(LogWARN, "shortseq: Only changeable at phase"
2825                      " DEAD/ESTABLISH\n");
2826           return 1;
2827       }
2828       arg->bundle->ncp.mp.cfg.shortseq &= keep;
2829       arg->bundle->ncp.mp.cfg.shortseq |= add;
2830       break;
2831     case NEG_VJCOMP:
2832       arg->bundle->ncp.ipcp.cfg.vj.neg &= keep;
2833       arg->bundle->ncp.ipcp.cfg.vj.neg |= add;
2834       break;
2835   }
2836
2837   return 0;
2838 }
2839
2840 static struct cmdtab const NegotiateCommands[] = {
2841   {"filter-decapsulation", NULL, OptSet, LOCAL_AUTH,
2842   "filter on PPPoUDP payloads", "disable|enable",
2843   (const void *)OPT_FILTERDECAP},
2844   {"idcheck", NULL, OptSet, LOCAL_AUTH, "Check FSM reply ids",
2845   "disable|enable", (const void *)OPT_IDCHECK},
2846   {"iface-alias", NULL, IfaceAliasOptSet, LOCAL_AUTH,
2847   "retain interface addresses", "disable|enable",
2848   (const void *)OPT_IFACEALIAS},
2849 #ifndef NOINET6
2850   {"ipcp", NULL, OptSet, LOCAL_AUTH, "IP Network Control Protocol",
2851   "disable|enable", (const void *)OPT_IPCP},
2852   {"ipv6cp", NULL, OptSet, LOCAL_AUTH, "IPv6 Network Control Protocol",
2853   "disable|enable", (const void *)OPT_IPV6CP},
2854 #endif
2855   {"keep-session", NULL, OptSet, LOCAL_AUTH, "Retain device session leader",
2856   "disable|enable", (const void *)OPT_KEEPSESSION},
2857   {"loopback", NULL, OptSet, LOCAL_AUTH, "Loop packets for local iface",
2858   "disable|enable", (const void *)OPT_LOOPBACK},
2859   {"passwdauth", NULL, OptSet, LOCAL_AUTH, "Use passwd file",
2860   "disable|enable", (const void *)OPT_PASSWDAUTH},
2861   {"proxy", NULL, OptSet, LOCAL_AUTH, "Create a proxy ARP entry",
2862   "disable|enable", (const void *)OPT_PROXY},
2863   {"proxyall", NULL, OptSet, LOCAL_AUTH, "Proxy ARP for all remote hosts",
2864   "disable|enable", (const void *)OPT_PROXYALL},
2865   {"sroutes", NULL, OptSet, LOCAL_AUTH, "Use sticky routes",
2866   "disable|enable", (const void *)OPT_SROUTES},
2867   {"tcpmssfixup", "mssfixup", OptSet, LOCAL_AUTH, "Modify MSS options",
2868   "disable|enable", (const void *)OPT_TCPMSSFIXUP},
2869   {"throughput", NULL, OptSet, LOCAL_AUTH, "Rolling throughput",
2870   "disable|enable", (const void *)OPT_THROUGHPUT},
2871   {"utmp", NULL, OptSet, LOCAL_AUTH, "Log connections in utmp",
2872   "disable|enable", (const void *)OPT_UTMP},
2873
2874 #ifndef NOINET6
2875 #define OPT_MAX 13      /* accept/deny allowed below and not above */
2876 #else
2877 #define OPT_MAX 11
2878 #endif
2879
2880   {"acfcomp", NULL, NegotiateSet, LOCAL_AUTH | LOCAL_CX,
2881   "Address & Control field compression", "accept|deny|disable|enable",
2882   (const void *)NEG_ACFCOMP},
2883   {"chap", "chap05", NegotiateSet, LOCAL_AUTH | LOCAL_CX,
2884   "Challenge Handshake Authentication Protocol", "accept|deny|disable|enable",
2885   (const void *)NEG_CHAP05},
2886 #ifndef NODES
2887   {"mschap", "chap80nt", NegotiateSet, LOCAL_AUTH | LOCAL_CX,
2888   "Microsoft (NT) CHAP", "accept|deny|disable|enable",
2889   (const void *)NEG_CHAP80},
2890   {"LANMan", "chap80lm", NegotiateSet, LOCAL_AUTH | LOCAL_CX,
2891   "Microsoft (NT) CHAP", "accept|deny|disable|enable",
2892   (const void *)NEG_CHAP80LM},
2893   {"mschapv2", "chap81", NegotiateSet, LOCAL_AUTH | LOCAL_CX,
2894   "Microsoft CHAP v2", "accept|deny|disable|enable",
2895   (const void *)NEG_CHAP81},
2896   {"mppe", NULL, NegotiateSet, LOCAL_AUTH | LOCAL_CX_OPT,
2897   "MPPE encryption", "accept|deny|disable|enable",
2898   (const void *)NEG_MPPE},
2899 #endif
2900   {"deflate", NULL, NegotiateSet, LOCAL_AUTH | LOCAL_CX_OPT,
2901   "Deflate compression", "accept|deny|disable|enable",
2902   (const void *)NEG_DEFLATE},
2903   {"deflate24", NULL, NegotiateSet, LOCAL_AUTH | LOCAL_CX_OPT,
2904   "Deflate (type 24) compression", "accept|deny|disable|enable",
2905   (const void *)NEG_PPPDDEFLATE},
2906   {"dns", NULL, NegotiateSet, LOCAL_AUTH,
2907   "DNS specification", "accept|deny|disable|enable", (const void *)NEG_DNS},
2908   {"enddisc", NULL, NegotiateSet, LOCAL_AUTH, "ENDDISC negotiation",
2909   "accept|deny|disable|enable", (const void *)NEG_ENDDISC},
2910   {"lqr", NULL, NegotiateSet, LOCAL_AUTH | LOCAL_CX,
2911   "Link Quality Reports", "accept|deny|disable|enable",
2912   (const void *)NEG_LQR},
2913   {"pap", NULL, NegotiateSet, LOCAL_AUTH | LOCAL_CX,
2914   "Password Authentication protocol", "accept|deny|disable|enable",
2915   (const void *)NEG_PAP},
2916   {"pred1", "predictor1", NegotiateSet, LOCAL_AUTH | LOCAL_CX_OPT,
2917   "Predictor 1 compression", "accept|deny|disable|enable",
2918   (const void *)NEG_PRED1},
2919   {"protocomp", NULL, NegotiateSet, LOCAL_AUTH | LOCAL_CX,
2920   "Protocol field compression", "accept|deny|disable|enable",
2921   (const void *)NEG_PROTOCOMP},
2922   {"shortseq", NULL, NegotiateSet, LOCAL_AUTH,
2923   "MP Short Sequence Numbers", "accept|deny|disable|enable",
2924   (const void *)NEG_SHORTSEQ},
2925   {"vjcomp", NULL, NegotiateSet, LOCAL_AUTH,
2926   "Van Jacobson header compression", "accept|deny|disable|enable",
2927   (const void *)NEG_VJCOMP},
2928   {"help", "?", HelpCommand, LOCAL_AUTH | LOCAL_NO_AUTH,
2929   "Display this message", "accept|deny|disable|enable help|? [value]",
2930   NegotiateCommands},
2931   {NULL, NULL, NULL},
2932 };
2933
2934 static int
2935 NegotiateCommand(struct cmdargs const *arg)
2936 {
2937   if (arg->argc > arg->argn) {
2938     char const *argv[3];
2939     unsigned keep, add;
2940     int n;
2941
2942     if ((argv[0] = ident_cmd(arg->argv[arg->argn-1], &keep, &add)) == NULL)
2943       return -1;
2944     argv[2] = NULL;
2945
2946     for (n = arg->argn; n < arg->argc; n++) {
2947       argv[1] = arg->argv[n];
2948       FindExec(arg->bundle, NegotiateCommands + (keep == NEG_HISMASK ?
2949                0 : OPT_MAX), 2, 1, argv, arg->prompt, arg->cx);
2950     }
2951   } else if (arg->prompt)
2952     prompt_Printf(arg->prompt, "Use `%s ?' to get a list.\n",
2953             arg->argv[arg->argn-1]);
2954   else
2955     log_Printf(LogWARN, "%s command must have arguments\n",
2956               arg->argv[arg->argn] );
2957
2958   return 0;
2959 }
2960
2961 const char *
2962 command_ShowNegval(unsigned val)
2963 {
2964   switch (val&3) {
2965     case 1: return "disabled & accepted";
2966     case 2: return "enabled & denied";
2967     case 3: return "enabled & accepted";
2968   }
2969   return "disabled & denied";
2970 }
2971
2972 static int
2973 ClearCommand(struct cmdargs const *arg)
2974 {
2975   struct pppThroughput *t;
2976   struct datalink *cx;
2977   int i, clear_type;
2978
2979   if (arg->argc < arg->argn + 1)
2980     return -1;
2981
2982   if (strcasecmp(arg->argv[arg->argn], "physical") == 0) {
2983     cx = arg->cx;
2984     if (!cx)
2985       cx = bundle2datalink(arg->bundle, NULL);
2986     if (!cx) {
2987       log_Printf(LogWARN, "A link must be specified for ``clear physical''\n");
2988       return 1;
2989     }
2990     t = &cx->physical->link.stats.total;
2991   } else if (strcasecmp(arg->argv[arg->argn], "ipcp") == 0)
2992     t = &arg->bundle->ncp.ipcp.throughput;
2993 #ifndef NOINET6
2994   else if (strcasecmp(arg->argv[arg->argn], "ipv6cp") == 0)
2995     t = &arg->bundle->ncp.ipv6cp.throughput;
2996 #endif
2997   else
2998     return -1;
2999
3000   if (arg->argc > arg->argn + 1) {
3001     clear_type = 0;
3002     for (i = arg->argn + 1; i < arg->argc; i++)
3003       if (strcasecmp(arg->argv[i], "overall") == 0)
3004         clear_type |= THROUGHPUT_OVERALL;
3005       else if (strcasecmp(arg->argv[i], "current") == 0)
3006         clear_type |= THROUGHPUT_CURRENT;
3007       else if (strcasecmp(arg->argv[i], "peak") == 0)
3008         clear_type |= THROUGHPUT_PEAK;
3009       else
3010         return -1;
3011   } else
3012     clear_type = THROUGHPUT_ALL;
3013
3014   throughput_clear(t, clear_type, arg->prompt);
3015   return 0;
3016 }
3017
3018 static int
3019 RunListCommand(struct cmdargs const *arg)
3020 {
3021   const char *cmd = arg->argc ? arg->argv[arg->argc - 1] : "???";
3022
3023 #ifndef NONAT
3024   if (arg->cmd->args == NatCommands &&
3025       tolower(*arg->argv[arg->argn - 1]) == 'a') {
3026     if (arg->prompt)
3027       prompt_Printf(arg->prompt, "The alias command is deprecated\n");
3028     else
3029       log_Printf(LogWARN, "The alias command is deprecated\n");
3030   }
3031 #endif
3032
3033   if (arg->argc > arg->argn)
3034     FindExec(arg->bundle, arg->cmd->args, arg->argc, arg->argn, arg->argv,
3035              arg->prompt, arg->cx);
3036   else if (arg->prompt)
3037     prompt_Printf(arg->prompt, "Use `%s help' to get a list or `%s help"
3038                   " <option>' for syntax help.\n", cmd, cmd);
3039   else
3040     log_Printf(LogWARN, "%s command must have arguments\n", cmd);
3041
3042   return 0;
3043 }
3044
3045 static int
3046 IfaceAddCommand(struct cmdargs const *arg)
3047 {
3048   struct ncpaddr peer, addr;
3049   struct ncprange ifa;
3050   struct in_addr mask;
3051   int n, how;
3052
3053   if (arg->argc == arg->argn + 1) {
3054     if (!ncprange_aton(&ifa, NULL, arg->argv[arg->argn]))
3055       return -1;
3056     ncpaddr_init(&peer);
3057   } else {
3058     if (arg->argc == arg->argn + 2) {
3059       if (!ncprange_aton(&ifa, NULL, arg->argv[arg->argn]))
3060         return -1;
3061       n = 1;
3062     } else if (arg->argc == arg->argn + 3) {
3063       if (!ncpaddr_aton(&addr, NULL, arg->argv[arg->argn]))
3064         return -1;
3065       if (ncpaddr_family(&addr) != AF_INET)
3066         return -1;
3067       ncprange_sethost(&ifa, &addr);
3068       if (!ncpaddr_aton(&addr, NULL, arg->argv[arg->argn + 1]))
3069         return -1;
3070       if (!ncpaddr_getip4(&addr, &mask))
3071         return -1;
3072       if (!ncprange_setip4mask(&ifa, mask))
3073         return -1;
3074       n = 2;
3075     } else
3076       return -1;
3077
3078     if (!ncpaddr_aton(&peer, NULL, arg->argv[arg->argn + n]))
3079       return -1;
3080
3081     if (ncprange_family(&ifa) != ncpaddr_family(&peer)) {
3082       log_Printf(LogWARN, "IfaceAddCommand: src and dst address families"
3083                  " differ\n");
3084       return -1;
3085     }
3086   }
3087
3088   how = IFACE_ADD_LAST;
3089   if (arg->cmd->args)
3090     how |= IFACE_FORCE_ADD;
3091
3092   return !iface_Add(arg->bundle->iface, &arg->bundle->ncp, &ifa, &peer, how);
3093 }
3094
3095 static int
3096 IfaceDeleteCommand(struct cmdargs const *arg)
3097 {
3098   struct ncpaddr ifa;
3099   struct in_addr ifa4;
3100   int ok;
3101
3102   if (arg->argc != arg->argn + 1)
3103     return -1;
3104
3105   if (!ncpaddr_aton(&ifa, NULL, arg->argv[arg->argn]))
3106     return -1;
3107
3108   if (arg->bundle->ncp.ipcp.fsm.state == ST_OPENED &&
3109       ncpaddr_getip4(&ifa, &ifa4) &&
3110       arg->bundle->ncp.ipcp.my_ip.s_addr == ifa4.s_addr) {
3111     log_Printf(LogWARN, "%s: Cannot remove active interface address\n",
3112                ncpaddr_ntoa(&ifa));
3113     return 1;
3114   }
3115
3116   ok = iface_Delete(arg->bundle->iface, &arg->bundle->ncp, &ifa);
3117   if (!ok) {
3118     if (arg->cmd->args)
3119       ok = 1;
3120     else if (arg->prompt)
3121       prompt_Printf(arg->prompt, "%s: No such interface address\n",
3122                     ncpaddr_ntoa(&ifa));
3123     else
3124       log_Printf(LogWARN, "%s: No such interface address\n",
3125                  ncpaddr_ntoa(&ifa));
3126   }
3127
3128   return !ok;
3129 }
3130
3131 static int
3132 IfaceClearCommand(struct cmdargs const *arg)
3133 {
3134   int family, how;
3135
3136   family = 0;
3137   if (arg->argc == arg->argn + 1) {
3138     if (strcasecmp(arg->argv[arg->argn], "inet") == 0)
3139       family = AF_INET;
3140 #ifndef NOINET6
3141     else if (strcasecmp(arg->argv[arg->argn], "inet6") == 0)
3142       family = AF_INET6;
3143 #endif
3144     else
3145       return -1;
3146   } else if (arg->argc != arg->argn)
3147     return -1;
3148
3149   how = arg->bundle->ncp.ipcp.fsm.state == ST_OPENED ||
3150         arg->bundle->phys_type.all & PHYS_AUTO ?
3151         IFACE_CLEAR_ALIASES : IFACE_CLEAR_ALL;
3152   iface_Clear(arg->bundle->iface, &arg->bundle->ncp, family, how);
3153
3154   return 0;
3155 }
3156
3157 static int
3158 SetProcTitle(struct cmdargs const *arg)
3159 {
3160   static char title[LINE_LEN];
3161   char *argv[MAXARGS];
3162   int argc = arg->argc - arg->argn;
3163
3164   if (arg->argc == arg->argn) {
3165     SetTitle(NULL);
3166     return 0;
3167   }
3168
3169   if (argc >= sizeof argv / sizeof argv[0]) {
3170     argc = sizeof argv / sizeof argv[0] - 1;
3171     log_Printf(LogWARN, "Truncating proc title to %d args\n", argc);
3172   }
3173   command_Expand(argv, argc, arg->argv + arg->argn, arg->bundle, 1, getpid());
3174   Concatinate(title, sizeof title, argc, (const char *const *)argv);
3175   SetTitle(title);
3176   command_Free(argc, argv);
3177
3178   return 0;
3179 }