1 /*- 2 * Copyright (c) 1996 - 2001 Brian Somers <brian@Awfulhak.org> 3 * based on work by Toshiharu OHNO <tony-o@iij.ad.jp> 4 * Internet Initiative Japan, Inc (IIJ) 5 * All rights reserved. 6 * 7 * Redistribution and use in source and binary forms, with or without 8 * modification, are permitted provided that the following conditions 9 * are met: 10 * 1. Redistributions of source code must retain the above copyright 11 * notice, this list of conditions and the following disclaimer. 12 * 2. Redistributions in binary form must reproduce the above copyright 13 * notice, this list of conditions and the following disclaimer in the 14 * documentation and/or other materials provided with the distribution. 15 * 16 * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND 17 * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE 18 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE 19 * ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE 20 * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL 21 * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS 22 * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) 23 * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT 24 * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY 25 * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF 26 * SUCH DAMAGE. 27 * 28 * $FreeBSD$ 29 */ 30 31 #include <sys/param.h> 32 #include <netinet/in.h> 33 #include <netinet/in_systm.h> 34 #include <netinet/ip.h> 35 #include <sys/un.h> 36 #include <sys/socket.h> 37 #include <net/route.h> 38 39 #include <errno.h> 40 #include <fcntl.h> 41 #include <paths.h> 42 #include <signal.h> 43 #include <stdio.h> 44 #include <stdlib.h> 45 #include <string.h> 46 #include <sys/time.h> 47 #include <termios.h> 48 #include <unistd.h> 49 #include <sys/stat.h> 50 51 #ifndef NONAT 52 #ifdef LOCALNAT 53 #include "alias.h" 54 #else 55 #include <alias.h> 56 #endif 57 #endif 58 59 #include "layer.h" 60 #include "probe.h" 61 #include "mbuf.h" 62 #include "log.h" 63 #include "defs.h" 64 #include "id.h" 65 #include "timer.h" 66 #include "fsm.h" 67 #include "lqr.h" 68 #include "hdlc.h" 69 #include "lcp.h" 70 #include "ccp.h" 71 #include "iplist.h" 72 #include "throughput.h" 73 #include "slcompress.h" 74 #include "ncpaddr.h" 75 #include "ip.h" 76 #include "ipcp.h" 77 #include "filter.h" 78 #include "descriptor.h" 79 #include "link.h" 80 #include "mp.h" 81 #ifndef NORADIUS 82 #include "radius.h" 83 #endif 84 #include "ipv6cp.h" 85 #include "ncp.h" 86 #include "bundle.h" 87 #include "auth.h" 88 #include "systems.h" 89 #include "sig.h" 90 #include "main.h" 91 #include "server.h" 92 #include "prompt.h" 93 #include "chat.h" 94 #include "chap.h" 95 #include "cbcp.h" 96 #include "datalink.h" 97 #include "iface.h" 98 99 #ifndef O_NONBLOCK 100 #ifdef O_NDELAY 101 #define O_NONBLOCK O_NDELAY 102 #endif 103 #endif 104 105 static void DoLoop(struct bundle *); 106 static void TerminalStop(int); 107 108 static struct bundle *SignalBundle; 109 static struct prompt *SignalPrompt; 110 111 void 112 Cleanup(int excode) 113 { 114 SignalBundle->CleaningUp = 1; 115 bundle_Close(SignalBundle, NULL, CLOSE_STAYDOWN); 116 } 117 118 void 119 AbortProgram(int excode) 120 { 121 server_Close(SignalBundle); 122 log_Printf(LogPHASE, "PPP Terminated (%s).\n", ex_desc(excode)); 123 bundle_Close(SignalBundle, NULL, CLOSE_STAYDOWN); 124 bundle_Destroy(SignalBundle); 125 log_Close(); 126 exit(excode); 127 } 128 129 static void 130 CloseConnection(int signo) 131 { 132 /* NOTE, these are manual, we've done a setsid() */ 133 sig_signal(SIGINT, SIG_IGN); 134 log_Printf(LogPHASE, "Caught signal %d, abort connection(s)\n", signo); 135 bundle_Down(SignalBundle, CLOSE_STAYDOWN); 136 sig_signal(SIGINT, CloseConnection); 137 } 138 139 static void 140 CloseSession(int signo) 141 { 142 log_Printf(LogPHASE, "Signal %d, terminate.\n", signo); 143 Cleanup(EX_TERM); 144 } 145 146 static pid_t BGPid = 0; 147 148 static void 149 KillChild(int signo) 150 { 151 signal(signo, SIG_IGN); 152 log_Printf(LogPHASE, "Parent: Signal %d\n", signo); 153 kill(BGPid, SIGINT); 154 } 155 156 static void 157 TerminalCont(int signo) 158 { 159 signal(SIGCONT, SIG_DFL); 160 prompt_Continue(SignalPrompt); 161 } 162 163 static void 164 TerminalStop(int signo) 165 { 166 prompt_Suspend(SignalPrompt); 167 signal(SIGCONT, TerminalCont); 168 raise(SIGSTOP); 169 } 170 171 static void 172 BringDownServer(int signo) 173 { 174 /* Drops all child prompts too ! */ 175 if (server_Close(SignalBundle)) 176 log_Printf(LogPHASE, "Closed server socket\n"); 177 } 178 179 static void 180 RestartServer(int signo) 181 { 182 /* Drops all child prompts and re-opens the socket */ 183 server_Reopen(SignalBundle); 184 } 185 186 static void 187 Usage(void) 188 { 189 fprintf(stderr, "Usage: ppp [-auto | -foreground | -background | -direct |" 190 " -dedicated | -ddial | -interactive]" 191 #ifndef NOALIAS 192 " [-nat]" 193 #endif 194 " [-quiet] [-unit N] [system ...]\n"); 195 exit(EX_START); 196 } 197 198 struct switches { 199 unsigned nat : 1; 200 unsigned fg : 1; 201 unsigned quiet : 1; 202 int mode; 203 int unit; 204 }; 205 206 static int 207 ProcessArgs(int argc, char **argv, struct switches *sw) 208 { 209 int optc, newmode, arg; 210 char *cp; 211 212 optc = 0; 213 memset(sw, '\0', sizeof *sw); 214 sw->mode = PHYS_INTERACTIVE; 215 sw->unit = -1; 216 217 for (arg = 1; arg < argc && *argv[arg] == '-'; arg++, optc++) { 218 cp = argv[arg] + 1; 219 newmode = Nam2mode(cp); 220 switch (newmode) { 221 case PHYS_NONE: 222 if (strcmp(cp, "nat") == 0) { 223 #ifdef NONAT 224 log_Printf(LogWARN, "%s ignored: NAT is compiled out\n", argv[arg]); 225 #else 226 sw->nat = 1; 227 #endif 228 optc--; /* this option isn't exclusive */ 229 } else if (strcmp(cp, "alias") == 0) { 230 #ifdef NONAT 231 log_Printf(LogWARN, "%s ignored: NAT is compiled out\n", argv[arg]); 232 fprintf(stderr, "%s ignored: NAT is compiled out\n", argv[arg]); 233 #else 234 log_Printf(LogWARN, "%s is deprecated\n", argv[arg]); 235 fprintf(stderr, "%s is deprecated\n", argv[arg]); 236 sw->nat = 1; 237 #endif 238 optc--; /* this option isn't exclusive */ 239 } else if (strncmp(cp, "unit", 4) == 0) { 240 optc--; /* this option isn't exclusive */ 241 if (cp[4] == '\0') { 242 optc--; /* nor is the argument */ 243 if (++arg == argc) { 244 fprintf(stderr, "-unit: Expected unit number\n"); 245 Usage(); 246 } else 247 sw->unit = atoi(argv[arg]); 248 } else 249 sw->unit = atoi(cp + 4); 250 } else if (strcmp(cp, "quiet") == 0) { 251 sw->quiet = 1; 252 optc--; /* this option isn't exclusive */ 253 } else 254 Usage(); 255 break; 256 257 case PHYS_ALL: 258 Usage(); 259 break; 260 261 default: 262 sw->mode = newmode; 263 if (newmode == PHYS_FOREGROUND) 264 sw->fg = 1; 265 } 266 } 267 268 if (optc > 1) { 269 fprintf(stderr, "You may specify only one mode.\n"); 270 exit(EX_START); 271 } 272 273 if (sw->mode == PHYS_AUTO && arg == argc) { 274 fprintf(stderr, "A system must be specified in auto mode.\n"); 275 exit(EX_START); 276 } 277 278 return arg; /* Don't SetLabel yet ! */ 279 } 280 281 static void 282 CheckLabel(const char *label, struct prompt *prompt, int mode) 283 { 284 const char *err; 285 286 if ((err = system_IsValid(label, prompt, mode)) != NULL) { 287 fprintf(stderr, "%s: %s\n", label, err); 288 if (mode == PHYS_DIRECT) 289 log_Printf(LogWARN, "Label %s rejected -direct connection: %s\n", 290 label, err); 291 log_Close(); 292 exit(1); 293 } 294 } 295 296 297 int 298 main(int argc, char **argv) 299 { 300 char *name; 301 const char *lastlabel; 302 int arg, f, holdfd[3], label; 303 struct bundle *bundle; 304 struct prompt *prompt; 305 struct switches sw; 306 307 probe_Init(); 308 309 /* 310 * We open 3 descriptors to ensure that STDIN_FILENO, STDOUT_FILENO and 311 * STDERR_FILENO are always open. These are closed before DoLoop(), 312 * but *after* we've avoided the possibility of erroneously closing 313 * an important descriptor with close(STD{IN,OUT,ERR}_FILENO). 314 */ 315 if ((holdfd[0] = open(_PATH_DEVNULL, O_RDWR)) == -1) { 316 fprintf(stderr, "Cannot open %s !\n", _PATH_DEVNULL); 317 return 2; 318 } 319 for (f = 1; f < sizeof holdfd / sizeof *holdfd; f++) 320 holdfd[f] = dup(holdfd[0]); 321 322 name = strrchr(argv[0], '/'); 323 log_Open(name ? name + 1 : argv[0]); 324 325 #ifndef NONAT 326 PacketAliasInit(); 327 #endif 328 label = ProcessArgs(argc, argv, &sw); 329 330 /* 331 * A FreeBSD & OpenBSD hack to dodge a bug in the tty driver that drops 332 * output occasionally.... I must find the real reason some time. To 333 * display the dodgy behaviour, comment out this bit, make yourself a large 334 * routing table and then run ppp in interactive mode. The `show route' 335 * command will drop chunks of data !!! 336 */ 337 if (sw.mode == PHYS_INTERACTIVE) { 338 close(STDIN_FILENO); 339 if (open(_PATH_TTY, O_RDONLY) != STDIN_FILENO) { 340 fprintf(stderr, "Cannot open %s for input !\n", _PATH_TTY); 341 return 2; 342 } 343 } 344 345 /* Allow output for the moment (except in direct mode) */ 346 if (sw.mode == PHYS_DIRECT) 347 prompt = NULL; 348 else 349 SignalPrompt = prompt = prompt_Create(NULL, NULL, PROMPT_STD); 350 351 ID0init(); 352 if (ID0realuid() != 0) { 353 char conf[200], *ptr; 354 355 snprintf(conf, sizeof conf, "%s/%s", PPP_CONFDIR, CONFFILE); 356 do { 357 struct stat sb; 358 359 if (stat(conf, &sb) == 0 && sb.st_mode & S_IWOTH) { 360 log_Printf(LogALERT, "ppp: Access violation: Please protect %s\n", 361 conf); 362 return -1; 363 } 364 ptr = conf + strlen(conf)-2; 365 while (ptr > conf && *ptr != '/') 366 *ptr-- = '\0'; 367 } while (ptr >= conf); 368 } 369 370 if (label < argc) 371 for (arg = label; arg < argc; arg++) 372 CheckLabel(argv[arg], prompt, sw.mode); 373 else 374 CheckLabel("default", prompt, sw.mode); 375 376 if (!sw.quiet) 377 prompt_Printf(prompt, "Working in %s mode\n", mode2Nam(sw.mode)); 378 379 if ((bundle = bundle_Create(TUN_PREFIX, sw.mode, sw.unit)) == NULL) 380 return EX_START; 381 382 /* NOTE: We may now have changed argv[1] via a ``set proctitle'' */ 383 384 if (prompt) { 385 prompt->bundle = bundle; /* couldn't do it earlier */ 386 if (!sw.quiet) 387 prompt_Printf(prompt, "Using interface: %s\n", bundle->iface->name); 388 } 389 SignalBundle = bundle; 390 bundle->NatEnabled = sw.nat; 391 if (sw.nat) 392 bundle->cfg.opt |= OPT_IFACEALIAS; 393 394 if (system_Select(bundle, "default", CONFFILE, prompt, NULL) < 0) 395 prompt_Printf(prompt, "Warning: No default entry found in config file.\n"); 396 397 sig_signal(SIGHUP, CloseSession); 398 sig_signal(SIGTERM, CloseSession); 399 sig_signal(SIGINT, CloseConnection); 400 sig_signal(SIGQUIT, CloseSession); 401 sig_signal(SIGALRM, SIG_IGN); 402 signal(SIGPIPE, SIG_IGN); 403 404 if (sw.mode == PHYS_INTERACTIVE) 405 sig_signal(SIGTSTP, TerminalStop); 406 407 sig_signal(SIGUSR1, RestartServer); 408 sig_signal(SIGUSR2, BringDownServer); 409 410 lastlabel = argv[argc - 1]; 411 for (arg = label; arg < argc; arg++) { 412 /* In case we use LABEL or ``set enddisc label'' */ 413 bundle_SetLabel(bundle, lastlabel); 414 system_Select(bundle, argv[arg], CONFFILE, prompt, NULL); 415 } 416 417 if (label < argc) 418 /* In case the last label did a ``load'' */ 419 bundle_SetLabel(bundle, lastlabel); 420 421 if (sw.mode == PHYS_AUTO && 422 ncprange_family(&bundle->ncp.ipcp.cfg.peer_range) == AF_UNSPEC) { 423 prompt_Printf(prompt, "You must ``set ifaddr'' with a peer address " 424 "in auto mode.\n"); 425 AbortProgram(EX_START); 426 } 427 428 if (sw.mode != PHYS_INTERACTIVE) { 429 if (sw.mode != PHYS_DIRECT) { 430 if (!sw.fg) { 431 int bgpipe[2]; 432 pid_t bgpid; 433 434 if (sw.mode == PHYS_BACKGROUND && pipe(bgpipe)) { 435 log_Printf(LogERROR, "pipe: %s\n", strerror(errno)); 436 AbortProgram(EX_SOCK); 437 } 438 439 bgpid = fork(); 440 if (bgpid == -1) { 441 log_Printf(LogERROR, "fork: %s\n", strerror(errno)); 442 AbortProgram(EX_SOCK); 443 } 444 445 if (bgpid) { 446 char c = EX_NORMAL; 447 int ret; 448 449 if (sw.mode == PHYS_BACKGROUND) { 450 close(bgpipe[1]); 451 BGPid = bgpid; 452 /* If we get a signal, kill the child */ 453 signal(SIGHUP, KillChild); 454 signal(SIGTERM, KillChild); 455 signal(SIGINT, KillChild); 456 signal(SIGQUIT, KillChild); 457 458 /* Wait for our child to close its pipe before we exit */ 459 while ((ret = read(bgpipe[0], &c, 1)) == 1) { 460 switch (c) { 461 case EX_NORMAL: 462 if (!sw.quiet) { 463 prompt_Printf(prompt, "PPP enabled\n"); 464 log_Printf(LogPHASE, "Parent: PPP enabled\n"); 465 } 466 break; 467 case EX_REDIAL: 468 if (!sw.quiet) 469 prompt_Printf(prompt, "Attempting redial\n"); 470 continue; 471 case EX_RECONNECT: 472 if (!sw.quiet) 473 prompt_Printf(prompt, "Attempting reconnect\n"); 474 continue; 475 default: 476 prompt_Printf(prompt, "Child failed (%s)\n", 477 ex_desc((int)c)); 478 log_Printf(LogPHASE, "Parent: Child failed (%s)\n", 479 ex_desc((int) c)); 480 } 481 break; 482 } 483 if (ret != 1) { 484 prompt_Printf(prompt, "Child exit, no status.\n"); 485 log_Printf(LogPHASE, "Parent: Child exit, no status.\n"); 486 } 487 close(bgpipe[0]); 488 } 489 return c; 490 } else if (sw.mode == PHYS_BACKGROUND) { 491 close(bgpipe[0]); 492 bundle->notify.fd = bgpipe[1]; 493 } 494 495 bundle_ChangedPID(bundle); 496 bundle_LockTun(bundle); /* we have a new pid */ 497 } 498 499 /* -auto, -dedicated, -ddial, -foreground & -background */ 500 prompt_Destroy(prompt, 0); 501 close(STDOUT_FILENO); 502 close(STDERR_FILENO); 503 close(STDIN_FILENO); 504 if (!sw.fg) 505 setsid(); 506 } else { 507 /* -direct - STDIN_FILENO gets used by physical_Open */ 508 prompt_TtyInit(NULL); 509 close(STDOUT_FILENO); 510 close(STDERR_FILENO); 511 } 512 } else { 513 /* -interactive */ 514 close(STDERR_FILENO); 515 prompt_TtyInit(prompt); 516 prompt_TtyCommandMode(prompt); 517 prompt_Required(prompt); 518 } 519 520 /* We can get rid of these now */ 521 for (f = 0; f < sizeof holdfd / sizeof *holdfd; f++) 522 close(holdfd[f]); 523 524 log_Printf(LogPHASE, "PPP Started (%s mode).\n", mode2Nam(sw.mode)); 525 DoLoop(bundle); 526 AbortProgram(EX_NORMAL); 527 528 return EX_NORMAL; 529 } 530 531 static void 532 DoLoop(struct bundle *bundle) 533 { 534 fd_set *rfds, *wfds, *efds; 535 int i, nfds, nothing_done; 536 537 if ((rfds = mkfdset()) == NULL) { 538 log_Printf(LogERROR, "DoLoop: Cannot create fd_set\n"); 539 return; 540 } 541 542 if ((wfds = mkfdset()) == NULL) { 543 log_Printf(LogERROR, "DoLoop: Cannot create fd_set\n"); 544 free(rfds); 545 return; 546 } 547 548 if ((efds = mkfdset()) == NULL) { 549 log_Printf(LogERROR, "DoLoop: Cannot create fd_set\n"); 550 free(rfds); 551 free(wfds); 552 return; 553 } 554 555 for (; !bundle_IsDead(bundle); bundle_CleanDatalinks(bundle)) { 556 nfds = 0; 557 zerofdset(rfds); 558 zerofdset(wfds); 559 zerofdset(efds); 560 561 /* All our datalinks, the tun device and the MP socket */ 562 descriptor_UpdateSet(&bundle->desc, rfds, wfds, efds, &nfds); 563 564 /* All our prompts and the diagnostic socket */ 565 descriptor_UpdateSet(&server.desc, rfds, NULL, NULL, &nfds); 566 567 bundle_CleanDatalinks(bundle); 568 if (bundle_IsDead(bundle)) 569 /* Don't select - we'll be here forever */ 570 break; 571 572 /* 573 * It's possible that we've had a signal since we last checked. If 574 * we don't check again before calling select(), we may end up stuck 575 * after having missed the event.... sig_Handle() tries to be as 576 * quick as possible if nothing is likely to have happened. 577 * This is only really likely if we block in open(... O_NONBLOCK) 578 * which will happen with a misconfigured device. 579 */ 580 if (sig_Handle()) 581 continue; 582 583 i = select(nfds, rfds, wfds, efds, NULL); 584 585 if (i < 0 && errno != EINTR) { 586 log_Printf(LogERROR, "DoLoop: select(): %s\n", strerror(errno)); 587 if (log_IsKept(LogTIMER)) { 588 struct timeval t; 589 590 for (i = 0; i <= nfds; i++) { 591 if (FD_ISSET(i, rfds)) { 592 log_Printf(LogTIMER, "Read set contains %d\n", i); 593 FD_CLR(i, rfds); 594 t.tv_sec = t.tv_usec = 0; 595 if (select(nfds, rfds, wfds, efds, &t) != -1) { 596 log_Printf(LogTIMER, "The culprit !\n"); 597 break; 598 } 599 } 600 if (FD_ISSET(i, wfds)) { 601 log_Printf(LogTIMER, "Write set contains %d\n", i); 602 FD_CLR(i, wfds); 603 t.tv_sec = t.tv_usec = 0; 604 if (select(nfds, rfds, wfds, efds, &t) != -1) { 605 log_Printf(LogTIMER, "The culprit !\n"); 606 break; 607 } 608 } 609 if (FD_ISSET(i, efds)) { 610 log_Printf(LogTIMER, "Error set contains %d\n", i); 611 FD_CLR(i, efds); 612 t.tv_sec = t.tv_usec = 0; 613 if (select(nfds, rfds, wfds, efds, &t) != -1) { 614 log_Printf(LogTIMER, "The culprit !\n"); 615 break; 616 } 617 } 618 } 619 } 620 break; 621 } 622 623 log_Printf(LogTIMER, "Select returns %d\n", i); 624 625 sig_Handle(); 626 627 if (i <= 0) 628 continue; 629 630 for (i = 0; i <= nfds; i++) 631 if (FD_ISSET(i, efds)) { 632 log_Printf(LogPHASE, "Exception detected on descriptor %d\n", i); 633 /* We deal gracefully with link descriptor exceptions */ 634 if (!bundle_Exception(bundle, i)) { 635 log_Printf(LogERROR, "Exception cannot be handled !\n"); 636 break; 637 } 638 } 639 640 if (i <= nfds) 641 break; 642 643 nothing_done = 1; 644 645 if (descriptor_IsSet(&server.desc, rfds)) { 646 descriptor_Read(&server.desc, bundle, rfds); 647 nothing_done = 0; 648 } 649 650 if (descriptor_IsSet(&bundle->desc, rfds)) { 651 descriptor_Read(&bundle->desc, bundle, rfds); 652 nothing_done = 0; 653 } 654 655 if (descriptor_IsSet(&bundle->desc, wfds)) 656 if (!descriptor_Write(&bundle->desc, bundle, wfds) && nothing_done) { 657 /* 658 * This is disasterous. The OS has told us that something is 659 * writable, and all our write()s have failed. Rather than 660 * going back immediately to do our UpdateSet()s and select(), 661 * we sleep for a bit to avoid gobbling up all cpu time. 662 */ 663 struct timeval t; 664 665 t.tv_sec = 0; 666 t.tv_usec = 100000; 667 select(0, NULL, NULL, NULL, &t); 668 } 669 } 670 671 log_Printf(LogDEBUG, "DoLoop done.\n"); 672 } 673