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