pppd/options.c

   1 /*
   2  * options.c - handles option processing for PPP.
   3  *
   4  * Copyright (c) 1989 Carnegie Mellon University.
   5  * All rights reserved.
   6  *
   7  * Redistribution and use in source and binary forms are permitted
   8  * provided that the above copyright notice and this paragraph are
   9  * duplicated in all such forms and that any documentation,
  10  * advertising materials, and other materials related to such
  11  * distribution and use acknowledge that the software was developed
  12  * by Carnegie Mellon University.  The name of the
  13  * University may not be used to endorse or promote products derived
  14  * from this software without specific prior written permission.
  15  * THIS SOFTWARE IS PROVIDED ``AS IS'' AND WITHOUT ANY EXPRESS OR
  16  * IMPLIED WARRANTIES, INCLUDING, WITHOUT LIMITATION, THE IMPLIED
  17  * WARRANTIES OF MERCHANTIBILITY AND FITNESS FOR A PARTICULAR PURPOSE.
  18  */
  19
  20 #ifndef lint
  21 static char rcsid[] = "$Id: options.c,v 1.56 1999/03/30 06:33:08 paulus Exp $";
  22 #endif
  23
  24 #include <ctype.h>
  25 #include <stdio.h>
  26 #include <errno.h>
  27 #include <unistd.h>
  28 #include <stdlib.h>
  29 #include <termios.h>
  30 #include <syslog.h>
  31 #include <string.h>
  32 #include <netdb.h>
  33 #include <pwd.h>
  34 #include <sys/types.h>
  35 #include <sys/stat.h>
  36 #include <netinet/in.h>
  37 #include <arpa/inet.h>
  38 #ifdef PPP_FILTER
  39 #include <pcap.h>
  40 #include <pcap-int.h>   /* XXX: To get struct pcap */
  41 #endif
  42
  43 #include "pppd.h"
  44 #include "pathnames.h"
  45 #include "patchlevel.h"
  46 #include "fsm.h"
  47 #include "lcp.h"
  48 #include "ipcp.h"
  49 #include "upap.h"
  50 #include "chap.h"
  51 #include "ccp.h"
  52
  53 #include <net/ppp-comp.h>
  54
  55 #if defined(ultrix) || defined(NeXT)
  56 char *strdup __P((char *));
  57 #endif
  58
  59 /*
  60  * Option variables and default values.
  61  */
  62 #ifdef PPP_FILTER
  63 int     dflag = 0;              /* Tell libpcap we want debugging */
  64 #endif
  65 int     debug = 0;              /* Debug flag */
  66 int     kdebugflag = 0;         /* Tell kernel to print debug messages */
  67 int     default_device = 1;     /* Using /dev/tty or equivalent */
  68 char    devnam[MAXPATHLEN];     /* Device name */
  69 int     crtscts = 0;            /* Use hardware flow control */
  70 bool    modem = 1;              /* Use modem control lines */
  71 int     inspeed = 0;            /* Input/Output speed requested */
  72 u_int32_t netmask = 0;          /* IP netmask to set on interface */
  73 bool    lockflag = 0;           /* Create lock file to lock the serial dev */
  74 bool    nodetach = 0;           /* Don't detach from controlling tty */
  75 bool    updetach = 0;           /* Detach once link is up */
  76 char    *connector = NULL;      /* Script to establish physical link */
  77 char    *disconnector = NULL;   /* Script to disestablish physical link */
  78 char    *welcomer = NULL;       /* Script to run after phys link estab. */
  79 char    *ptycommand = NULL;     /* Command to run on other side of pty */
  80 int     maxconnect = 0;         /* Maximum connect time */
  81 char    user[MAXNAMELEN];       /* Username for PAP */
  82 char    passwd[MAXSECRETLEN];   /* Password for PAP */
  83 bool    persist = 0;            /* Reopen link after it goes down */
  84 char    our_name[MAXNAMELEN];   /* Our name for authentication purposes */
  85 bool    demand = 0;             /* do dial-on-demand */
  86 char    *ipparam = NULL;        /* Extra parameter for ip up/down scripts */
  87 int     idle_time_limit = 0;    /* Disconnect if idle for this many seconds */
  88 int     holdoff = 30;           /* # seconds to pause before reconnecting */
  89 bool    notty = 0;              /* Stdin/out is not a tty */
  90 char    *record_file = NULL;    /* File to record chars sent/received */
  91 int     using_pty = 0;
  92 bool    sync_serial = 0;        /* Device is synchronous serial device */
  93
  94 extern option_t auth_options[];
  95
  96 struct option_info connector_info;
  97 struct option_info disconnector_info;
  98 struct option_info welcomer_info;
  99 struct option_info devnam_info;
 100 struct option_info ptycommand_info;
 101
 102 #ifdef PPP_FILTER
 103 struct  bpf_program pass_filter;/* Filter program for packets to pass */
 104 struct  bpf_program active_filter; /* Filter program for link-active pkts */
 105 pcap_t  pc;                     /* Fake struct pcap so we can compile expr */
 106 #endif
 107
 108 /*
 109  * Prototypes
 110  */
 111 static int setdevname __P((char *, int));
 112 static int setipaddr __P((char *));
 113 static int setspeed __P((char *));
 114 static int noopt __P((char **));
 115 static int setdomain __P((char **));
 116 static int setnetmask __P((char **));
 117 static int setxonxoff __P((char **));
 118 static int readfile __P((char **));
 119 static int callfile __P((char **));
 120 static int showversion __P((char **));
 121 static int showhelp __P((char **));
 122 static void usage __P((void));
 123
 124 #ifdef PPP_FILTER
 125 static int setpassfilter __P((char **));
 126 static int setactivefilter __P((char **));
 127 #endif
 128
 129
 130 static option_t *find_option __P((char *name));
 131 static int process_option __P((option_t *, char **));
 132 static int n_arguments __P((option_t *));
 133 static int number_option __P((char *, u_int32_t *, int));
 134
 135 /*
 136  * Valid arguments.
 137  */
 138 option_t general_options[] = {
 139     { "debug", o_int, &debug,
 140       "Increase debugging level", OPT_INC|OPT_NOARG|1 },
 141     { "-d", o_int, &debug,
 142       "Increase debugging level", OPT_INC|OPT_NOARG|1 },
 143     { "kdebug", o_int, &kdebugflag,
 144       "Set kernel driver debug level" },
 145     { "nodetach", o_bool, &nodetach,
 146       "Don't detach from controlling tty", 1 },
 147     { "-detach", o_bool, &nodetach,
 148       "Don't detach from controlling tty", 1 },
 149     { "updetach", o_bool, &updetach,
 150       "Detach from controlling tty once link is up", 1 },
 151     { "holdoff", o_int, &holdoff,
 152       "Set time in seconds before retrying connection" },
 153     { "idle", o_int, &idle_time_limit,
 154       "Set time in seconds before disconnecting idle link" },
 155     { "lock", o_bool, &lockflag,
 156       "Lock serial device with UUCP-style lock file", 1 },
 157     { "-all", o_special_noarg, noopt,
 158       "Don't request/allow any LCP or IPCP options (useless)" },
 159     { "connect", o_string, &connector,
 160       "A program to set up a connection",
 161       OPT_A2INFO | OPT_PRIVFIX, &connector_info },
 162     { "disconnect", o_string, &disconnector,
 163       "Program to disconnect serial device",
 164       OPT_A2INFO | OPT_PRIVFIX, &disconnector_info },
 165     { "welcome", o_string, &welcomer,
 166       "Script to welcome client",
 167       OPT_A2INFO | OPT_PRIVFIX, &welcomer_info },
 168     { "pty", o_string, &ptycommand,
 169       "Script to run on pseudo-tty master side",
 170       OPT_A2INFO | OPT_PRIVFIX, &ptycommand_info },
 171     { "notty", o_bool, &notty,
 172       "Input/output is not a tty", 1 },
 173     { "record", o_string, &record_file,
 174       "Record characters sent/received to file" },
 175     { "maxconnect", o_int, &maxconnect,
 176       "Set connection time limit", OPT_LLIMIT|OPT_NOINCR|OPT_ZEROINF },
 177     { "crtscts", o_int, &crtscts,
 178       "Set hardware (RTS/CTS) flow control", OPT_NOARG|OPT_VAL(1) },
 179     { "nocrtscts", o_int, &crtscts,
 180       "Disable hardware flow control", OPT_NOARG|OPT_VAL(-1) },
 181     { "-crtscts", o_int, &crtscts,
 182       "Disable hardware flow control", OPT_NOARG|OPT_VAL(-1) },
 183     { "cdtrcts", o_int, &crtscts,
 184       "Set alternate hardware (DTR/CTS) flow control", OPT_NOARG|OPT_VAL(2) },
 185     { "nocdtrcts", o_int, &crtscts,
 186       "Disable hardware flow control", OPT_NOARG|OPT_VAL(-1) },
 187     { "xonxoff", o_special_noarg, setxonxoff,
 188       "Set software (XON/XOFF) flow control" },
 189     { "domain", o_special, setdomain,
 190       "Add given domain name to hostname" },
 191     { "mtu", o_int, &lcp_allowoptions[0].mru,
 192       "Set our MTU", OPT_LIMITS, NULL, MAXMRU, MINMRU },
 193     { "netmask", o_special, setnetmask,
 194       "set netmask" },
 195     { "modem", o_bool, &modem,
 196       "Use modem control lines", 1 },
 197     { "local", o_bool, &modem,
 198       "Don't use modem control lines" },
 199     { "file", o_special, readfile,
 200       "Take options from a file" },
 201     { "call", o_special, callfile,
 202       "Take options from a privileged file" },
 203     { "persist", o_bool, &persist,
 204       "Keep on reopening connection after close", 1 },
 205     { "nopersist", o_bool, &persist,
 206       "Turn off persist option" },
 207     { "demand", o_bool, &demand,
 208       "Dial on demand", 1, &persist },
 209     { "--version", o_special_noarg, showversion,
 210       "Show version number" },
 211     { "--help", o_special_noarg, showhelp,
 212       "Show brief listing of options" },
 213     { "-h", o_special_noarg, showhelp,
 214       "Show brief listing of options" },
 215     { "sync", o_bool, &sync_serial,
 216       "Use synchronous HDLC serial encoding", 1 },
 217
 218 #ifdef PPP_FILTER
 219     { "pdebug", o_int, &dflag,
 220       "libpcap debugging" },
 221     { "pass-filter", 1, setpassfilter,
 222       "set filter for packets to pass" },
 223     { "active-filter", 1, setactivefilter,
 224       "set filter for active pkts" },
 225 #endif
 226
 227     { NULL }
 228 };
 229
 230 #ifndef IMPLEMENTATION
 231 #define IMPLEMENTATION ""
 232 #endif
 233
 234 static char *usage_string = "\
 235 pppd version %s.%d%s\n\
 236 Usage: %s [ options ], where options are:\n\
 237         <device>        Communicate over the named device\n\
 238         <speed>         Set the baud rate to <speed>\n\
 239         <loc>:<rem>     Set the local and/or remote interface IP\n\
 240                         addresses.  Either one may be omitted.\n\
 241         asyncmap <n>    Set the desired async map to hex <n>\n\
 242         auth            Require authentication from peer\n\
 243         connect <p>     Invoke shell command <p> to set up the serial line\n\
 244         crtscts         Use hardware RTS/CTS flow control\n\
 245         defaultroute    Add default route through interface\n\
 246         file <f>        Take options from file <f>\n\
 247         modem           Use modem control lines\n\
 248         mru <n>         Set MRU value to <n> for negotiation\n\
 249 See pppd(8) for more options.\n\
 250 ";
 251
 252 /*
 253  * parse_args - parse a string of arguments from the command line.
 254  */
 255 int
 256 parse_args(argc, argv)
 257     int argc;
 258     char **argv;
 259 {
 260     char *arg;
 261     option_t *opt;
 262     int ret;
 263
 264     privileged_option = privileged;
 265     option_source = "command line";
 266     while (argc > 0) {
 267         arg = *argv++;
 268         --argc;
 269
 270         /*
 271          * First see if it's an option in the new option list.
 272          */
 273         opt = find_option(arg);
 274         if (opt != NULL) {
 275             int n = n_arguments(opt);
 276             if (argc < n) {
 277                 option_error("too few parameters for option %s", arg);
 278                 return 0;
 279             }
 280             current_option = arg;
 281             if (!process_option(opt, argv))
 282                 return 0;
 283             argc -= n;
 284             argv += n;
 285             continue;
 286         }
 287
 288         /*
 289          * Maybe a tty name, speed or IP address?
 290          */
 291         if ((ret = setdevname(arg, 0)) == 0
 292             && (ret = setspeed(arg)) == 0
 293             && (ret = setipaddr(arg)) == 0) {
 294             option_error("unrecognized option '%s'", arg);
 295             usage();
 296             return 0;
 297         }
 298         if (ret < 0)    /* error */
 299             return 0;
 300     }
 301     return 1;
 302 }
 303
 304 /*
 305  * scan_args - scan the command line arguments to get the tty name,
 306  * if specified.  Also checks whether the notty or pty option was given.
 307  */
 308 void
 309 scan_args(argc, argv)
 310     int argc;
 311     char **argv;
 312 {
 313     char *arg;
 314     option_t *opt;
 315
 316     privileged_option = privileged;
 317     while (argc > 0) {
 318         arg = *argv++;
 319         --argc;
 320
 321         if (strcmp(arg, "notty") == 0 || strcmp(arg, "pty") == 0)
 322             using_pty = 1;
 323
 324         /* Skip options and their arguments */
 325         opt = find_option(arg);
 326         if (opt != NULL) {
 327             int n = n_arguments(opt);
 328             argc -= n;
 329             argv += n;
 330             continue;
 331         }
 332
 333         /* Check if it's a tty name and copy it if so */
 334         (void) setdevname(arg, 1);
 335     }
 336 }
 337
 338 /*
 339  * options_from_file - Read a string of options from a file,
 340  * and interpret them.
 341  */
 342 int
 343 options_from_file(filename, must_exist, check_prot, priv)
 344     char *filename;
 345     int must_exist;
 346     int check_prot;
 347     int priv;
 348 {
 349     FILE *f;
 350     int i, newline, ret;
 351     option_t *opt;
 352     int oldpriv;
 353     char *oldsource;
 354     char *argv[MAXARGS];
 355     char args[MAXARGS][MAXWORDLEN];
 356     char cmd[MAXWORDLEN];
 357
 358     if (check_prot)
 359         seteuid(getuid());
 360     f = fopen(filename, "r");
 361     if (check_prot)
 362         seteuid(0);
 363     if (f == NULL) {
 364         if (!must_exist && errno == ENOENT)
 365             return 1;
 366         option_error("Can't open options file %s: %m", filename);
 367         return 0;
 368     }
 369
 370     oldpriv = privileged_option;
 371     privileged_option = priv;
 372     oldsource = option_source;
 373     option_source = strdup(filename);
 374     if (option_source == NULL)
 375         option_source = "file";
 376     ret = 0;
 377     while (getword(f, cmd, &newline, filename)) {
 378         /*
 379          * First see if it's a command.
 380          */
 381         opt = find_option(cmd);
 382         if (opt != NULL) {
 383             int n = n_arguments(opt);
 384             for (i = 0; i < n; ++i) {
 385                 if (!getword(f, args[i], &newline, filename)) {
 386                     option_error(
 387                         "In file %s: too few parameters for option '%s'",
 388                         filename, cmd);
 389                     goto err;
 390                 }
 391                 argv[i] = args[i];
 392             }
 393             current_option = cmd;
 394             if (!process_option(opt, argv))
 395                 goto err;
 396             continue;
 397         }
 398
 399         /*
 400          * Maybe a tty name, speed or IP address?
 401          */
 402         if ((i = setdevname(cmd, 0)) == 0
 403             && (i = setspeed(cmd)) == 0
 404             && (i = setipaddr(cmd)) == 0) {
 405             option_error("In file %s: unrecognized option '%s'",
 406                          filename, cmd);
 407             goto err;
 408         }
 409         if (i < 0)              /* error */
 410             goto err;
 411     }
 412     ret = 1;
 413
 414 err:
 415     fclose(f);
 416     privileged_option = oldpriv;
 417     option_source = oldsource;
 418     return ret;
 419 }
 420
 421 /*
 422  * options_from_user - See if the use has a ~/.ppprc file,
 423  * and if so, interpret options from it.
 424  */
 425 int
 426 options_from_user()
 427 {
 428     char *user, *path, *file;
 429     int ret;
 430     struct passwd *pw;
 431     size_t pl;
 432
 433     pw = getpwuid(getuid());
 434     if (pw == NULL || (user = pw->pw_dir) == NULL || user[0] == 0)
 435         return 1;
 436     file = _PATH_USEROPT;
 437     pl = strlen(user) + strlen(file) + 2;
 438     path = malloc(pl);
 439     if (path == NULL)
 440         novm("init file name");
 441     slprintf(path, pl, "%s/%s", user, file);
 442     ret = options_from_file(path, 0, 1, privileged);
 443     free(path);
 444     return ret;
 445 }
 446
 447 /*
 448  * options_for_tty - See if an options file exists for the serial
 449  * device, and if so, interpret options from it.
 450  */
 451 int
 452 options_for_tty()
 453 {
 454     char *dev, *path, *p;
 455     int ret;
 456     size_t pl;
 457
 458     dev = devnam;
 459     if (strncmp(dev, "/dev/", 5) == 0)
 460         dev += 5;
 461     if (dev[0] == 0 || strcmp(dev, "tty") == 0)
 462         return 1;               /* don't look for /etc/ppp/options.tty */
 463     pl = strlen(_PATH_TTYOPT) + strlen(dev) + 1;
 464     path = malloc(pl);
 465     if (path == NULL)
 466         novm("tty init file name");
 467     slprintf(path, pl, "%s%s", _PATH_TTYOPT, dev);
 468     /* Turn slashes into dots, for Solaris case (e.g. /dev/term/a) */
 469     for (p = path + strlen(_PATH_TTYOPT); *p != 0; ++p)
 470         if (*p == '/')
 471             *p = '.';
 472     ret = options_from_file(path, 0, 0, 1);
 473     free(path);
 474     return ret;
 475 }
 476
 477 /*
 478  * find_option - scan the option lists for the various protocols
 479  * looking for an entry with the given name.
 480  * This could be optimized by using a hash table.
 481  */
 482 static option_t *
 483 find_option(name)
 484     char *name;
 485 {
 486     option_t *opt;
 487     int i;
 488
 489     for (opt = general_options; opt->name != NULL; ++opt)
 490         if (strcmp(name, opt->name) == 0)
 491             return opt;
 492     for (opt = auth_options; opt->name != NULL; ++opt)
 493         if (strcmp(name, opt->name) == 0)
 494             return opt;
 495     for (i = 0; protocols[i] != NULL; ++i)
 496         if ((opt = protocols[i]->options) != NULL)
 497             for (; opt->name != NULL; ++opt)
 498                 if (strcmp(name, opt->name) == 0)
 499                     return opt;
 500     return NULL;
 501 }
 502
 503 /*
 504  * process_option - process one new-style option.
 505  */
 506 static int
 507 process_option(opt, argv)
 508     option_t *opt;
 509     char **argv;
 510 {
 511     u_int32_t v;
 512     int iv, a;
 513     char *sv;
 514     int (*parser) __P((char **));
 515
 516     if ((opt->flags & OPT_PRIV) && !privileged_option) {
 517         option_error("using the %s option requires root privilege", opt->name);
 518         return 0;
 519     }
 520     if ((opt->flags & OPT_ENABLE) && *(bool *)(opt->addr2) == 0) {
 521         option_error("%s option is disabled", opt->name);
 522         return 0;
 523     }
 524     if ((opt->flags & OPT_PRIVFIX) && !privileged_option) {
 525         struct option_info *ip = (struct option_info *) opt->addr2;
 526         if (ip && ip->priv) {
 527             option_error("%s option cannot be overridden", opt->name);
 528             return 0;
 529         }
 530     }
 531
 532     switch (opt->type) {
 533     case o_bool:
 534         v = opt->flags & OPT_VALUE;
 535         *(bool *)(opt->addr) = v;
 536         if (opt->addr2 && (opt->flags & OPT_A2COPY))
 537             *(bool *)(opt->addr2) = v;
 538         break;
 539
 540     case o_int:
 541         iv = 0;
 542         if ((opt->flags & OPT_NOARG) == 0) {
 543             if (!int_option(*argv, &iv))
 544                 return 0;
 545             if ((((opt->flags & OPT_LLIMIT) && iv < opt->lower_limit)
 546                  || ((opt->flags & OPT_ULIMIT) && iv > opt->upper_limit))
 547                 && !((opt->flags & OPT_ZEROOK && iv == 0))) {
 548                 char *zok = (opt->flags & OPT_ZEROOK)? " zero or": "";
 549                 switch (opt->flags & OPT_LIMITS) {
 550                 case OPT_LLIMIT:
 551                     option_error("%s value must be%s >= %d",
 552                                  opt->name, zok, opt->lower_limit);
 553                     break;
 554                 case OPT_ULIMIT:
 555                     option_error("%s value must be%s <= %d",
 556                                  opt->name, zok, opt->upper_limit);
 557                     break;
 558                 case OPT_LIMITS:
 559                     option_error("%s value must be%s between %d and %d",
 560                                 opt->name, opt->lower_limit, opt->upper_limit);
 561                     break;
 562                 }
 563                 return 0;
 564             }
 565         }
 566         a = opt->flags & OPT_VALUE;
 567         if (a >= 128)
 568             a -= 256;           /* sign extend */
 569         iv += a;
 570         if (opt->flags & OPT_INC)
 571             iv += *(int *)(opt->addr);
 572         if ((opt->flags & OPT_NOINCR) && !privileged_option) {
 573             int oldv = *(int *)(opt->addr);
 574             if ((opt->flags & OPT_ZEROINF) ?
 575                 (oldv != 0 && (iv == 0 || iv > oldv)) : (iv > oldv)) {
 576                 option_error("%s value cannot be increased", opt->name);
 577                 return 0;
 578             }
 579         }
 580         *(int *)(opt->addr) = iv;
 581         if (opt->addr2 && (opt->flags & OPT_A2COPY))
 582             *(int *)(opt->addr2) = iv;
 583         break;
 584
 585     case o_uint32:
 586         if (opt->flags & OPT_NOARG) {
 587             v = opt->flags & OPT_VALUE;
 588         } else if (!number_option(*argv, &v, 16))
 589             return 0;
 590         if (opt->flags & OPT_OR)
 591             v |= *(u_int32_t *)(opt->addr);
 592         *(u_int32_t *)(opt->addr) = v;
 593         if (opt->addr2 && (opt->flags & OPT_A2COPY))
 594             *(u_int32_t *)(opt->addr2) = v;
 595         break;
 596
 597     case o_string:
 598         if (opt->flags & OPT_STATIC) {
 599             strlcpy((char *)(opt->addr), *argv, opt->upper_limit);
 600         } else {
 601             sv = strdup(*argv);
 602             if (sv == NULL)
 603                 novm("option argument");
 604             *(char **)(opt->addr) = sv;
 605         }
 606         break;
 607
 608     case o_special_noarg:
 609     case o_special:
 610         parser = (int (*) __P((char **))) opt->addr;
 611         if (!(*parser)(argv))
 612             return 0;
 613         break;
 614     }
 615
 616     if (opt->addr2) {
 617         if (opt->flags & OPT_A2INFO) {
 618             struct option_info *ip = (struct option_info *) opt->addr2;
 619             ip->priv = privileged_option;
 620             ip->source = option_source;
 621         } else if ((opt->flags & (OPT_A2COPY|OPT_ENABLE)) == 0)
 622             *(bool *)(opt->addr2) = 1;
 623     }
 624
 625     return 1;
 626 }
 627
 628 /*
 629  * n_arguments - tell how many arguments an option takes
 630  */
 631 static int
 632 n_arguments(opt)
 633     option_t *opt;
 634 {
 635     return (opt->type == o_bool || opt->type == o_special_noarg
 636             || (opt->flags & OPT_NOARG))? 0: 1;
 637 }
 638
 639 /*
 640  * usage - print out a message telling how to use the program.
 641  */
 642 static void
 643 usage()
 644 {
 645     if (phase == PHASE_INITIALIZE)
 646         fprintf(stderr, usage_string, VERSION, PATCHLEVEL, IMPLEMENTATION,
 647                 progname);
 648 }
 649
 650 /*
 651  * showhelp - print out usage message and exit.
 652  */
 653 static int
 654 showhelp(argv)
 655     char **argv;
 656 {
 657     if (phase == PHASE_INITIALIZE) {
 658         usage();
 659         exit(0);
 660     }
 661     return 0;
 662 }
 663
 664 /*
 665  * showversion - print out the version number and exit.
 666  */
 667 static int
 668 showversion(argv)
 669     char **argv;
 670 {
 671     if (phase == PHASE_INITIALIZE) {
 672         fprintf(stderr, "pppd version %s.%d%s\n",
 673                 VERSION, PATCHLEVEL, IMPLEMENTATION);
 674         exit(0);
 675     }
 676     return 0;
 677 }
 678
 679 /*
 680  * option_error - print a message about an error in an option.
 681  * The message is logged, and also sent to
 682  * stderr if phase == PHASE_INITIALIZE.
 683  */
 684 void
 685 option_error __V((char *fmt, ...))
 686 {
 687     va_list args;
 688     char buf[256];
 689
 690 #if __STDC__
 691     va_start(args, fmt);
 692 #else
 693     char *fmt;
 694     va_start(args);
 695     fmt = va_arg(args, char *);
 696 #endif
 697     vslprintf(buf, sizeof(buf), fmt, args);
 698     va_end(args);
 699     if (phase == PHASE_INITIALIZE)
 700         fprintf(stderr, "%s: %s\n", progname, buf);
 701     syslog(LOG_ERR, "%s", buf);
 702 }
 703
 704 #if 0
 705 /*
 706  * readable - check if a file is readable by the real user.
 707  */
 708 int
 709 readable(fd)
 710     int fd;
 711 {
 712     uid_t uid;
 713     int i;
 714     struct stat sbuf;
 715
 716     uid = getuid();
 717     if (uid == 0)
 718         return 1;
 719     if (fstat(fd, &sbuf) != 0)
 720         return 0;
 721     if (sbuf.st_uid == uid)
 722         return sbuf.st_mode & S_IRUSR;
 723     if (sbuf.st_gid == getgid())
 724         return sbuf.st_mode & S_IRGRP;
 725     for (i = 0; i < ngroups; ++i)
 726         if (sbuf.st_gid == groups[i])
 727             return sbuf.st_mode & S_IRGRP;
 728     return sbuf.st_mode & S_IROTH;
 729 }
 730 #endif
 731
 732 /*
 733  * Read a word from a file.
 734  * Words are delimited by white-space or by quotes (" or ').
 735  * Quotes, white-space and \ may be escaped with \.
 736  * \<newline> is ignored.
 737  */
 738 int
 739 getword(f, word, newlinep, filename)
 740     FILE *f;
 741     char *word;
 742     int *newlinep;
 743     char *filename;
 744 {
 745     int c, len, escape;
 746     int quoted, comment;
 747     int value, digit, got, n;
 748
 749 #define isoctal(c) ((c) >= '0' && (c) < '8')
 750
 751     *newlinep = 0;
 752     len = 0;
 753     escape = 0;
 754     comment = 0;
 755
 756     /*
 757      * First skip white-space and comments.
 758      */
 759     for (;;) {
 760         c = getc(f);
 761         if (c == EOF)
 762             break;
 763
 764         /*
 765          * A newline means the end of a comment; backslash-newline
 766          * is ignored.  Note that we cannot have escape && comment.
 767          */
 768         if (c == '\n') {
 769             if (!escape) {
 770                 *newlinep = 1;
 771                 comment = 0;
 772             } else
 773                 escape = 0;
 774             continue;
 775         }
 776
 777         /*
 778          * Ignore characters other than newline in a comment.
 779          */
 780         if (comment)
 781             continue;
 782
 783         /*
 784          * If this character is escaped, we have a word start.
 785          */
 786         if (escape)
 787             break;
 788
 789         /*
 790          * If this is the escape character, look at the next character.
 791          */
 792         if (c == '\\') {
 793             escape = 1;
 794             continue;
 795         }
 796
 797         /*
 798          * If this is the start of a comment, ignore the rest of the line.
 799          */
 800         if (c == '#') {
 801             comment = 1;
 802             continue;
 803         }
 804
 805         /*
 806          * A non-whitespace character is the start of a word.
 807          */
 808         if (!isspace(c))
 809             break;
 810     }
 811
 812     /*
 813      * Save the delimiter for quoted strings.
 814      */
 815     if (!escape && (c == '"' || c == '\'')) {
 816         quoted = c;
 817         c = getc(f);
 818     } else
 819         quoted = 0;
 820
 821     /*
 822      * Process characters until the end of the word.
 823      */
 824     while (c != EOF) {
 825         if (escape) {
 826             /*
 827              * This character is escaped: backslash-newline is ignored,
 828              * various other characters indicate particular values
 829              * as for C backslash-escapes.
 830              */
 831             escape = 0;
 832             if (c == '\n') {
 833                 c = getc(f);
 834                 continue;
 835             }
 836
 837             got = 0;
 838             switch (c) {
 839             case 'a':
 840                 value = '\a';
 841                 break;
 842             case 'b':
 843                 value = '\b';
 844                 break;
 845             case 'f':
 846                 value = '\f';
 847                 break;
 848             case 'n':
 849                 value = '\n';
 850                 break;
 851             case 'r':
 852                 value = '\r';
 853                 break;
 854             case 's':
 855                 value = ' ';
 856                 break;
 857             case 't':
 858                 value = '\t';
 859                 break;
 860
 861             default:
 862                 if (isoctal(c)) {
 863                     /*
 864                      * \ddd octal sequence
 865                      */
 866                     value = 0;
 867                     for (n = 0; n < 3 && isoctal(c); ++n) {
 868                         value = (value << 3) + (c & 07);
 869                         c = getc(f);
 870                     }
 871                     got = 1;
 872                     break;
 873                 }
 874
 875                 if (c == 'x') {
 876                     /*
 877                      * \x<hex_string> sequence
 878                      */
 879                     value = 0;
 880                     c = getc(f);
 881                     for (n = 0; n < 2 && isxdigit(c); ++n) {
 882                         digit = toupper(c) - '0';
 883                         if (digit > 10)
 884                             digit += '0' + 10 - 'A';
 885                         value = (value << 4) + digit;
 886                         c = getc (f);
 887                     }
 888                     got = 1;
 889                     break;
 890                 }
 891
 892                 /*
 893                  * Otherwise the character stands for itself.
 894                  */
 895                 value = c;
 896                 break;
 897             }
 898
 899             /*
 900              * Store the resulting character for the escape sequence.
 901              */
 902             if (len < MAXWORDLEN-1)
 903                 word[len] = value;
 904             ++len;
 905
 906             if (!got)
 907                 c = getc(f);
 908             continue;
 909
 910         }
 911
 912         /*
 913          * Not escaped: see if we've reached the end of the word.
 914          */
 915         if (quoted) {
 916             if (c == quoted)
 917                 break;
 918         } else {
 919             if (isspace(c) || c == '#') {
 920                 ungetc (c, f);
 921                 break;
 922             }
 923         }
 924
 925         /*
 926          * Backslash starts an escape sequence.
 927          */
 928         if (c == '\\') {
 929             escape = 1;
 930             c = getc(f);
 931             continue;
 932         }
 933
 934         /*
 935          * An ordinary character: store it in the word and get another.
 936          */
 937         if (len < MAXWORDLEN-1)
 938             word[len] = c;
 939         ++len;
 940
 941         c = getc(f);
 942     }
 943
 944     /*
 945      * End of the word: check for errors.
 946      */
 947     if (c == EOF) {
 948         if (ferror(f)) {
 949             if (errno == 0)
 950                 errno = EIO;
 951             option_error("Error reading %s: %m", filename);
 952             die(1);
 953         }
 954         /*
 955          * If len is zero, then we didn't find a word before the
 956          * end of the file.
 957          */
 958         if (len == 0)
 959             return 0;
 960     }
 961
 962     /*
 963      * Warn if the word was too long, and append a terminating null.
 964      */
 965     if (len >= MAXWORDLEN) {
 966         option_error("warning: word in file %s too long (%.20s...)",
 967                      filename, word);
 968         len = MAXWORDLEN - 1;
 969     }
 970     word[len] = 0;
 971
 972     return 1;
 973
 974 #undef isoctal
 975
 976 }
 977
 978 /*
 979  * number_option - parse an unsigned numeric parameter for an option.
 980  */
 981 static int
 982 number_option(str, valp, base)
 983     char *str;
 984     u_int32_t *valp;
 985     int base;
 986 {
 987     char *ptr;
 988
 989     *valp = strtoul(str, &ptr, base);
 990     if (ptr == str) {
 991         option_error("invalid numeric parameter '%s' for %s option",
 992                      str, current_option);
 993         return 0;
 994     }
 995     return 1;
 996 }
 997
 998
 999 /*
1000  * int_option - like number_option, but valp is int *,
1001  * the base is assumed to be 0, and *valp is not changed
1002  * if there is an error.
1003  */
1004 int
1005 int_option(str, valp)
1006     char *str;
1007     int *valp;
1008 {
1009     u_int32_t v;
1010
1011     if (!number_option(str, &v, 0))
1012         return 0;
1013     *valp = (int) v;
1014     return 1;
1015 }
1016
1017
1018 /*
1019  * The following procedures parse options.
1020  */
1021
1022 /*
1023  * readfile - take commands from a file.
1024  */
1025 static int
1026 readfile(argv)
1027     char **argv;
1028 {
1029     return options_from_file(*argv, 1, 1, privileged_option);
1030 }
1031
1032 /*
1033  * callfile - take commands from /etc/ppp/peers/<name>.
1034  * Name may not contain /../, start with / or ../, or end in /..
1035  */
1036 static int
1037 callfile(argv)
1038     char **argv;
1039 {
1040     char *fname, *arg, *p;
1041     int l, ok;
1042
1043     arg = *argv;
1044     ok = 1;
1045     if (arg[0] == '/' || arg[0] == 0)
1046         ok = 0;
1047     else {
1048         for (p = arg; *p != 0; ) {
1049             if (p[0] == '.' && p[1] == '.' && (p[2] == '/' || p[2] == 0)) {
1050                 ok = 0;
1051                 break;
1052             }
1053             while (*p != '/' && *p != 0)
1054                 ++p;
1055             if (*p == '/')
1056                 ++p;
1057         }
1058     }
1059     if (!ok) {
1060         option_error("call option value may not contain .. or start with /");
1061         return 0;
1062     }
1063
1064     l = strlen(arg) + strlen(_PATH_PEERFILES) + 1;
1065     if ((fname = (char *) malloc(l)) == NULL)
1066         novm("call file name");
1067     slprintf(fname, l, "%s%s", _PATH_PEERFILES, arg);
1068
1069     ok = options_from_file(fname, 1, 1, 1);
1070
1071     free(fname);
1072     return ok;
1073 }
1074
1075 #ifdef PPP_FILTER
1076 /*
1077  * setpdebug - Set libpcap debugging level.
1078  */
1079 static int
1080 setpdebug(argv)
1081     char **argv;
1082 {
1083     return int_option(*argv, &dflag);
1084 }
1085
1086 /*
1087  * setpassfilter - Set the pass filter for packets
1088  */
1089 static int
1090 setpassfilter(argv)
1091     char **argv;
1092 {
1093     pc.linktype = DLT_PPP;
1094     pc.snapshot = PPP_HDRLEN;
1095
1096     if (pcap_compile(&pc, &pass_filter, *argv, 1, netmask) == 0)
1097         return 1;
1098     option_error("error in pass-filter expression: %s\n", pcap_geterr(&pc));
1099     return 0;
1100 }
1101
1102 /*
1103  * setactivefilter - Set the active filter for packets
1104  */
1105 static int
1106 setactivefilter(argv)
1107     char **argv;
1108 {
1109     pc.linktype = DLT_PPP;
1110     pc.snapshot = PPP_HDRLEN;
1111
1112     if (pcap_compile(&pc, &active_filter, *argv, 1, netmask) == 0)
1113         return 1;
1114     option_error("error in active-filter expression: %s\n", pcap_geterr(&pc));
1115     return 0;
1116 }
1117 #endif
1118
1119 /*
1120  * noopt - Disable all options.
1121  */
1122 static int
1123 noopt(argv)
1124     char **argv;
1125 {
1126     BZERO((char *) &lcp_wantoptions[0], sizeof (struct lcp_options));
1127     BZERO((char *) &lcp_allowoptions[0], sizeof (struct lcp_options));
1128     BZERO((char *) &ipcp_wantoptions[0], sizeof (struct ipcp_options));
1129     BZERO((char *) &ipcp_allowoptions[0], sizeof (struct ipcp_options));
1130
1131     return (1);
1132 }
1133
1134 /*
1135  * setdomain - Set domain name to append to hostname
1136  */
1137 static int
1138 setdomain(argv)
1139     char **argv;
1140 {
1141     if (!privileged_option) {
1142         option_error("using the domain option requires root privilege");
1143         return 0;
1144     }
1145     gethostname(hostname, MAXNAMELEN);
1146     if (**argv != 0) {
1147         if (**argv != '.')
1148             strncat(hostname, ".", MAXNAMELEN - strlen(hostname));
1149         strncat(hostname, *argv, MAXNAMELEN - strlen(hostname));
1150     }
1151     hostname[MAXNAMELEN-1] = 0;
1152     return (1);
1153 }
1154
1155
1156 /*
1157  * setspeed - Set the speed.
1158  */
1159 static int
1160 setspeed(arg)
1161     char *arg;
1162 {
1163     char *ptr;
1164     int spd;
1165
1166     spd = strtol(arg, &ptr, 0);
1167     if (ptr == arg || *ptr != 0 || spd == 0)
1168         return 0;
1169     inspeed = spd;
1170     return 1;
1171 }
1172
1173
1174 /*
1175  * setdevname - Set the device name.
1176  */
1177 static int
1178 setdevname(cp, quiet)
1179     char *cp;
1180     int quiet;
1181 {
1182     struct stat statbuf;
1183     char dev[MAXPATHLEN];
1184
1185     if (*cp == 0)
1186         return 0;
1187
1188     if (strncmp("/dev/", cp, 5) != 0) {
1189         strlcpy(dev, "/dev/", sizeof(dev));
1190         strlcat(dev, cp, sizeof(dev));
1191         cp = dev;
1192     }
1193
1194     /*
1195      * Check if there is a device by this name.
1196      */
1197     if (stat(cp, &statbuf) < 0) {
1198         if (errno == ENOENT || quiet)
1199             return 0;
1200         option_error("Couldn't stat %s: %m", cp);
1201         return -1;
1202     }
1203
1204     if (devnam_info.priv && !privileged_option) {
1205         if (!quiet)
1206             option_error("device name cannot be overridden");
1207         return -1;
1208     }
1209
1210     strlcpy(devnam, cp, sizeof(devnam));
1211     default_device = 0;
1212     devnam_info.priv = privileged_option;
1213     devnam_info.source = option_source;
1214
1215     return 1;
1216 }
1217
1218
1219 /*
1220  * setipaddr - Set the IP address
1221  */
1222 static int
1223 setipaddr(arg)
1224     char *arg;
1225 {
1226     struct hostent *hp;
1227     char *colon;
1228     u_int32_t local, remote;
1229     ipcp_options *wo = &ipcp_wantoptions[0];
1230
1231     /*
1232      * IP address pair separated by ":".
1233      */
1234     if ((colon = strchr(arg, ':')) == NULL)
1235         return 0;
1236
1237     /*
1238      * If colon first character, then no local addr.
1239      */
1240     if (colon != arg) {
1241         *colon = '\0';
1242         if ((local = inet_addr(arg)) == -1) {
1243             if ((hp = gethostbyname(arg)) == NULL) {
1244                 option_error("unknown host: %s", arg);
1245                 return -1;
1246             } else {
1247                 local = *(u_int32_t *)hp->h_addr;
1248             }
1249         }
1250         if (bad_ip_adrs(local)) {
1251             option_error("bad local IP address %s", ip_ntoa(local));
1252             return -1;
1253         }
1254         if (local != 0)
1255             wo->ouraddr = local;
1256         *colon = ':';
1257     }
1258
1259     /*
1260      * If colon last character, then no remote addr.
1261      */
1262     if (*++colon != '\0') {
1263         if ((remote = inet_addr(colon)) == -1) {
1264             if ((hp = gethostbyname(colon)) == NULL) {
1265                 option_error("unknown host: %s", colon);
1266                 return -1;
1267             } else {
1268                 remote = *(u_int32_t *)hp->h_addr;
1269                 if (remote_name[0] == 0)
1270                     strlcpy(remote_name, colon, sizeof(remote_name));
1271             }
1272         }
1273         if (bad_ip_adrs(remote)) {
1274             option_error("bad remote IP address %s", ip_ntoa(remote));
1275             return -1;
1276         }
1277         if (remote != 0)
1278             wo->hisaddr = remote;
1279     }
1280
1281     return 1;
1282 }
1283
1284
1285 /*
1286  * setnetmask - set the netmask to be used on the interface.
1287  */
1288 static int
1289 setnetmask(argv)
1290     char **argv;
1291 {
1292     u_int32_t mask, b;
1293     int n, ok;
1294     char *p, *endp;
1295
1296     /*
1297      * Unfortunately, if we use inet_addr, we can't tell whether
1298      * a result of all 1s is an error or a valid 255.255.255.255.
1299      */
1300     p = *argv;
1301     ok = 0;
1302     mask = 0;
1303     for (n = 3;; --n) {
1304         b = strtoul(p, &endp, 0);
1305         if (endp == p)
1306             break;
1307         if (b < 0 || b > 255) {
1308             if (n == 3) {
1309                 /* accept e.g. 0xffffff00 */
1310                 p = endp;
1311                 mask = b;
1312             }
1313             break;
1314         }
1315         mask |= b << (n * 8);
1316         p = endp;
1317         if (*p != '.' || n == 0)
1318             break;
1319         ++p;
1320     }
1321
1322     mask = htonl(mask);
1323
1324     if (*p != 0 || (netmask & ~mask) != 0) {
1325         option_error("invalid netmask value '%s'", *argv);
1326         return 0;
1327     }
1328
1329     netmask = mask;
1330     return (1);
1331 }
1332
1333 static int
1334 setxonxoff(argv)
1335     char **argv;
1336 {
1337     lcp_wantoptions[0].asyncmap |= 0x000A0000;  /* escape ^S and ^Q */
1338     lcp_wantoptions[0].neg_asyncmap = 1;
1339
1340     crtscts = -2;
1341     return (1);
1342 }