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