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