1 /*
2 * options.c - handles option processing for PPP.
3 *
4 * Copyright (c) 2000-2001 by Sun Microsystems, Inc.
5 * All rights reserved.
6 *
7 * Permission to use, copy, modify, and distribute this software and its
8 * documentation is hereby granted, provided that the above copyright
9 * notice appears in all copies.
10 *
11 * SUN MAKES NO REPRESENTATION OR WARRANTIES ABOUT THE SUITABILITY OF
12 * THE SOFTWARE, EITHER EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED
13 * TO THE IMPLIED WARRANTIES OF MERCHANTABILITY, FITNESS FOR A
14 * PARTICULAR PURPOSE, OR NON-INFRINGEMENT. SUN SHALL NOT BE LIABLE FOR
15 * ANY DAMAGES SUFFERED BY LICENSEE AS A RESULT OF USING, MODIFYING OR
16 * DISTRIBUTING THIS SOFTWARE OR ITS DERIVATIVES
17 *
18 * Copyright (c) 1989 Carnegie Mellon University.
19 * All rights reserved.
20 *
21 * Redistribution and use in source and binary forms are permitted
22 * provided that the above copyright notice and this paragraph are
23 * duplicated in all such forms and that any documentation,
24 * advertising materials, and other materials related to such
25 * distribution and use acknowledge that the software was developed
26 * by Carnegie Mellon University. The name of the
27 * University may not be used to endorse or promote products derived
28 * from this software without specific prior written permission.
29 * THIS SOFTWARE IS PROVIDED ``AS IS'' AND WITHOUT ANY EXPRESS OR
30 * IMPLIED WARRANTIES, INCLUDING, WITHOUT LIMITATION, THE IMPLIED
31 * WARRANTIES OF MERCHANTIBILITY AND FITNESS FOR A PARTICULAR PURPOSE.
32 */
33
34 #pragma ident "%Z%%M% %I% %E% SMI"
35 #define RCSID "$Id: options.c,v 1.74 2000/04/15 01:27:13 masputra Exp $"
36
37 #include <ctype.h>
38 #include <stdio.h>
39 #include <errno.h>
40 #include <unistd.h>
41 #include <fcntl.h>
42 #include <stdlib.h>
43 #include <syslog.h>
44 #include <string.h>
45 #include <netdb.h>
46 #include <pwd.h>
47 #include <sys/types.h>
48 #include <sys/stat.h>
49 #include <netinet/in.h>
50 #include <arpa/inet.h>
51 #ifdef PLUGIN
52 #include <dlfcn.h>
53 #endif /* PLUGIN */
54 #ifdef PPP_FILTER
55 #include <pcap.h>
56 #include <pcap-int.h> /* XXX: To get struct pcap */
57 #endif /* PPP_FILTER */
58
59 #include "pppd.h"
60 #include "pathnames.h"
61 #include "patchlevel.h"
62 #include "fsm.h"
63 #include "lcp.h"
64 #include "ipcp.h"
65
66 #if defined(ultrix) || defined(NeXT)
67 char *strdup __P((char *));
68 #endif
69
70 #if !defined(lint) && !defined(_lint)
71 static const char rcsid[] = RCSID;
72 #endif
73
74 /*
75 * Option variables and default values.
76 */
77 #ifdef PPP_FILTER
78 int dflag = 0; /* Tell libpcap we want debugging */
79 #endif /* PPP_FILTER */
80 int debug = 0; /* Debug flag */
81 int kdebugflag = 0; /* Tell kernel to print debug messages */
82 int default_device = 1; /* Using /dev/tty or equivalent */
83 char devnam[MAXPATHLEN]; /* Device name */
84 int crtscts = 0; /* Use hardware flow control */
85 bool modem = 1; /* Use modem control lines */
86 int inspeed = 0; /* Input/Output speed requested */
87 u_int32_t netmask = 0; /* IP netmask to set on interface */
88 bool lockflag = 0; /* Create lock file to lock the serial dev */
89 bool nodetach = 0; /* Don't detach from controlling tty */
90 bool updetach = 0; /* Detach once link is up */
91 char *initializer = NULL; /* Script to initialize physical link */
92 char *connect_script = NULL; /* Script to establish physical link */
93 char *disconnect_script = NULL; /* Script to disestablish physical link */
94 char *welcomer = NULL; /* Script to run after phys link estab. */
95 char *ptycommand = NULL; /* Command to run on other side of pty */
96 int maxconnect = 0; /* Maximum connect time */
97 char user[MAXNAMELEN]; /* Username for PAP */
98 char passwd[MAXSECRETLEN]; /* Password for PAP */
99 bool persist = 0; /* Reopen link after it goes down */
100 char our_name[MAXNAMELEN]; /* Our name for authentication purposes */
101 bool demand = 0; /* do dial-on-demand */
102 char *ipparam = NULL; /* Extra parameter for ip up/down scripts */
103 int idle_time_limit = 0; /* Disconnect if idle for this many seconds */
104 int holdoff = 30; /* # seconds to pause before reconnecting */
105 bool holdoff_specified; /* true if a holdoff value has been given */
106 bool notty = 0; /* Stdin/out is not a tty */
107 char *pty_socket = NULL; /* Socket to connect to pty */
108 char *record_file = NULL; /* File to record chars sent/received */
109 int using_pty = 0;
110 bool sync_serial = 0; /* Device is synchronous serial device */
111 int log_to_fd = 1; /* send log messages to this fd too */
112 int maxfail = 10; /* max # of unsuccessful connection attempts */
113 char linkname[MAXPATHLEN]; /* logical name for link */
114 bool tune_kernel; /* may alter kernel settings */
115 int connect_delay = 1000; /* wait this many ms after connect script */
116 int max_data_rate; /* max bytes/sec through charshunt */
117 int req_unit = -1; /* requested interface unit */
118 bool multilink = 0; /* Enable multilink operation */
119 char *bundle_name = NULL; /* bundle name for multilink */
120 bool direct_tty = 0; /* use standard input directly; not a tty */
121
122 /* Maximum depth of include files; prevents looping. */
123 #define MAXFILENESTING 10
124
125 struct option_info initializer_info;
126 struct option_info connect_script_info;
127 struct option_info disconnect_script_info;
128 struct option_info welcomer_info;
129 struct option_info devnam_info;
130 struct option_info ptycommand_info;
131 struct option_info ipsrc_info;
132 struct option_info ipdst_info;
133 struct option_info speed_info;
134
135 #ifdef PPP_FILTER
136 struct bpf_program pass_filter;/* Filter program for packets to pass */
137 struct bpf_program active_filter; /* Filter program for link-active pkts */
138 pcap_t pc; /* Fake struct pcap so we can compile expr */
139 #endif /* PPP_FILTER */
140
141 char *current_option; /* the name of the option being parsed */
142 bool privileged_option; /* set iff the current option came from root */
143 char *option_source = NULL; /* string saying where the option came from */
144 int option_line = 0; /* line number in file */
145 bool log_to_file; /* log_to_fd is a file opened by us */
146 bool log_to_specific_fd; /* log_to_fd was specified by user option */
147
148 /*
149 * Prototypes.
150 */
151 static int setdevname __P((char *));
152 static int setipaddr __P((char *));
153 static int setspeed __P((char *));
154 static int noopt __P((char **, option_t *));
155 static int setdomain __P((char **, option_t *));
156 static int setnetmask __P((char **, option_t *));
157 static int setxonxoff __P((char **, option_t *));
158 static int readfile __P((char **, option_t *));
159 static int callfile __P((char **, option_t *));
160 static int showversion __P((char **, option_t *));
161 static int showhelp __P((char **, option_t *));
162 static int showalloptions __P((char **, option_t *));
163 static void usage __P((void));
164 static int setlogfile __P((char **, option_t *));
165 #ifdef PLUGIN
166 static int loadplugin __P((char **, option_t *));
167 #endif
168 #ifdef PPP_FILTER
169 static int setpassfilter __P((char **, option_t *));
170 static int setactivefilter __P((char **, option_t *));
171 #endif /* PPP_FILTER */
172 static option_t *find_option __P((char *name));
173 static int process_option __P((option_t *opt, char **argv, int sline));
174 static int n_arguments __P((option_t *opt));
175 static int number_option __P((char *str, u_int32_t *valp, int base));
176 static u_int32_t opt_hash __P((const void *key));
177 static int opt_compare __P((const void *p1, const void *p2));
178
179 typedef struct _opt_t {
180 option_t *p;
181 } opt_t;
182
183 typedef struct _hashentry_t {
184 struct _hashentry_t *next;
185 opt_t opt;
186 } hashentry_t;
187
188 /*
189 * A prime number describing the size of hash table.
190 */
191 #define OPTHASH_TBLSIZE 101
192
193 /*
194 * Chained hash table containing pointers to available options.
195 */
196 static hashentry_t *hash_tbl[OPTHASH_TBLSIZE] = { NULL };
197
198 /*
199 * Total number of entries in the hash table.
200 */
201 int hash_tblcnt = 0;
202
203 /*
204 * Valid arguments.
205 */
206 option_t general_options[] = {
207 { "debug", o_int, &debug,
208 "Increase debugging level", OPT_INC|OPT_NOARG|1 },
209 { "-d", o_int, &debug,
210 "Increase debugging level", OPT_INC|OPT_NOARG|1 },
211 { "kdebug", o_int, &kdebugflag,
212 "Set kernel driver debug level" },
213 { "nodetach", o_bool, &nodetach,
214 "Don't detach from controlling tty", 1 },
215 { "-detach", o_bool, &nodetach,
216 "Don't detach from controlling tty", 1 },
217 { "updetach", o_bool, &updetach,
218 "Detach from controlling tty once link is up", 1 },
219 { "holdoff", o_int, &holdoff,
220 "Set time in seconds before retrying connection" },
221 { "idle", o_int, &idle_time_limit,
222 "Set time in seconds before disconnecting idle link" },
223 { "lock", o_bool, &lockflag,
224 "Lock serial device with UUCP-style lock file", 1 },
225 { "-all", o_special_noarg, (void *)noopt,
226 "Don't request/allow any LCP or IPCP options (useless)" },
227 { "init", o_string, &initializer,
228 "A program to initialize the device",
229 OPT_A2INFO | OPT_PRIVFIX, &initializer_info },
230 { "connect", o_string, &connect_script,
231 "A program to set up a connection",
232 OPT_A2INFO | OPT_PRIVFIX, &connect_script_info },
233 { "disconnect", o_string, &disconnect_script,
234 "Program to disconnect serial device",
235 OPT_A2INFO | OPT_PRIVFIX, &disconnect_script_info },
236 { "welcome", o_string, &welcomer,
237 "Script to welcome client",
238 OPT_A2INFO | OPT_PRIVFIX, &welcomer_info },
239 { "pty", o_string, &ptycommand,
240 "Script to run on pseudo-tty master side",
241 OPT_A2INFO | OPT_PRIVFIX | OPT_DEVNAM, &ptycommand_info },
242 { "notty", o_bool, ¬ty,
243 "Input/output is not a tty", OPT_DEVNAM | 1 },
244 { "directtty", o_bool, &direct_tty,
245 "Use standard input as tty without checking", OPT_DEVNAM | 1 },
246 { "socket", o_string, &pty_socket,
247 "Send and receive over socket, arg is host:port", OPT_DEVNAM },
248 { "record", o_string, &record_file,
249 "Record characters sent/received to file" },
250 { "maxconnect", o_int, &maxconnect,
251 "Set connection time limit", OPT_LLIMIT|OPT_NOINCR|OPT_ZEROINF },
252 { "crtscts", o_int, &crtscts,
253 "Set hardware (RTS/CTS) flow control", OPT_NOARG|OPT_VAL(1) },
254 { "nocrtscts", o_int, &crtscts,
255 "Disable hardware flow control", OPT_NOARG|OPT_VAL(-1) },
256 { "-crtscts", o_int, &crtscts,
257 "Disable hardware flow control", OPT_NOARG|OPT_VAL(-1) },
258 { "cdtrcts", o_int, &crtscts,
259 "Set alternate hardware (DTR/CTS) flow control", OPT_NOARG|OPT_VAL(2) },
260 { "nocdtrcts", o_int, &crtscts,
261 "Disable hardware flow control", OPT_NOARG|OPT_VAL(-1) },
262 { "xonxoff", o_special_noarg, (void *)setxonxoff,
263 "Set software (XON/XOFF) flow control" },
264 { "domain", o_special, (void *)setdomain,
265 "Add given domain name to hostname" },
266 { "netmask", o_special, (void *)setnetmask,
267 "set netmask" },
268 { "modem", o_bool, &modem,
269 "Use modem control lines", 1 },
270 { "local", o_bool, &modem,
271 "Don't use modem control lines" },
272 { "file", o_special, (void *)readfile,
273 "Take options from a file", OPT_PREPASS },
274 { "call", o_special, (void *)callfile,
275 "Take options from a privileged file", OPT_PREPASS },
276 { "persist", o_bool, &persist,
277 "Keep on reopening connection after close", 1 },
278 { "nopersist", o_bool, &persist,
279 "Turn off persist option" },
280 { "demand", o_bool, &demand,
281 "Dial on demand", OPT_INITONLY | 1, &persist },
282 { "--version", o_special_noarg, (void *)showversion,
283 "Show version number" },
284 { "--help", o_special_noarg, (void *)showhelp,
285 "Show brief listing of options" },
286 { "-h", o_special_noarg, (void *)showhelp,
287 "Show brief listing of options" },
288 { "options", o_special_noarg, (void *)showalloptions,
289 "Show full listing of options" },
290 { "sync", o_bool, &sync_serial,
291 "Use synchronous HDLC serial encoding", 1 },
292 { "logfd", o_int, &log_to_fd,
293 "Send log messages to this file descriptor",
294 0, &log_to_specific_fd },
295 { "logfile", o_special, (void *)setlogfile,
296 "Append log messages to this file" },
297 { "nolog", o_int, &log_to_fd,
298 "Don't send log messages to any file",
299 OPT_NOARG | OPT_VAL(-1) },
300 { "nologfd", o_int, &log_to_fd,
301 "Don't send log messages to any file descriptor",
302 OPT_NOARG | OPT_VAL(-1) },
303 { "linkname", o_string, linkname,
304 "Set logical name for link",
305 OPT_PRIV|OPT_STATIC, NULL, MAXPATHLEN },
306 { "maxfail", o_int, &maxfail,
307 "Number of unsuccessful connection attempts to allow" },
308 { "ktune", o_bool, &tune_kernel,
309 "Alter kernel settings as necessary", 1 },
310 { "noktune", o_bool, &tune_kernel,
311 "Don't alter kernel settings", 0 },
312 { "connect-delay", o_int, &connect_delay,
313 "Maximum wait time (msec) after connect script finishes" },
314 { "datarate", o_int, &max_data_rate,
315 "Max data rate in bytes/sec for pty, notty, or record" },
316 { "unit", o_int, &req_unit,
317 "PPP interface unit number to use if possible", OPT_LLIMIT, 0, 0 },
318 #ifdef HAVE_MULTILINK
319 { "multilink", o_bool, &multilink,
320 "Enable multilink operation", 1 },
321 { "nomultilink", o_bool, &multilink,
322 "Disable multilink operation", 0 },
323 { "mp", o_bool, &multilink,
324 "Enable multilink operation", 1 },
325 { "nomp", o_bool, &multilink,
326 "Disable multilink operation", 0 },
327 { "bundle", o_string, &bundle_name,
328 "Bundle name for multilink" },
329 #endif /* HAVE_MULTILINK */
330 #ifdef PLUGIN
331 { "plugin", o_special, (void *)loadplugin,
332 "Load a plug-in module into pppd", OPT_PRIV },
333 #endif /* PLUGIN */
334 #ifdef PPP_FILTER
335 { "pdebug", o_int, &dflag,
336 "libpcap debugging" },
337 { "pass-filter", o_special, setpassfilter,
338 "set filter for packets to pass" },
339 { "active-filter", o_special, setactivefilter,
340 "set filter for active pkts" },
341 #endif /* PPP_FILTER */
342 { NULL }
343 };
344
345 /*
346 * This string gets printed out when "options" is given on the command
347 * line. Following this string, all of the available options and
348 * their descriptions are printed out as well. Certain options which
349 * are not available as part of the option_t structure are placed in
350 * the "dummy" option structure.
351 */
352 static const char pre_allopt_string[] = "\
353 pppd version %s.%d%s\n\
354 Usage: %s [ options ], where options are:\n\n\
355 ";
356
357 /* Do not call add_options() on this structure */
358 static option_t dummy_options[] = {
359 { "<device>", o_special_noarg, NULL,
360 "Communicate over the named device" },
361 { "<speed>", o_special_noarg, NULL,
362 "Set the baud rate to <speed>" },
363 { "[<loc>]:[<rem>]", o_special_noarg, NULL,
364 "Set the local and/or remote interface IP addresses" },
365 { NULL }
366 };
367
368 static const char post_allopt_string[] = "\
369 \n\
370 Notes:\
371 \t<n>\tinteger type argument\n\
372 \t<s>\tstring type argument\n\
373 \t<r>\tspecial type argument\n\
374 \t(!)\tprivileged option available only when pppd is executed by root\n\
375 \t\tor when found in the privileged option files (/etc/ppp/options,\n\
376 \t\t/etc/ppp/options.ttyname, /etc/ppp/peers/name, or following\n\
377 \t\t\"--\" in /etc/ppp/pap-secrets or /etc/ppp/chap-secrets).\n\
378 \t(#)\tdisabled option\n\
379 \n\
380 Please see the pppd man page for details.\n";
381
382 /*
383 * parse_args - parse a string of arguments from the command line. If prepass
384 * is true, we are scanning for the device name and only processing a few
385 * options, so error messages are suppressed. Returns 1 upon successful
386 * processing of options, and 0 otherwise.
387 */
388 int
389 parse_args(argc, argv)
390 int argc;
391 char **argv;
392 {
393 char *arg;
394 option_t *opt;
395 int ret;
396
397 privileged_option = privileged;
398 option_source = "command line";
399 option_line = 0;
400 while (argc > 0) {
401 arg = *argv++;
402 --argc;
403
404 /*
405 * First check to see if it's a known option name. If so, parse the
406 * argument(s) and set the option.
407 */
408 opt = find_option(arg);
409 if (opt != NULL) {
410 int n = n_arguments(opt);
411 if (argc < n) {
412 option_error("too few parameters for option '%s'", arg);
413 return (0);
414 }
415 current_option = arg;
416 if (!process_option(opt, argv, 0))
417 return (0);
418 argc -= n;
419 argv += n;
420 continue;
421 }
422
423 /*
424 * Maybe a tty name, speed or IP address ?
425 */
426 if (((ret = setdevname(arg)) == 0) &&
427 ((ret = setspeed(arg)) == 0) &&
428 ((ret = setipaddr(arg)) == 0) && !prepass) {
429 option_error("unrecognized option '%s'", arg);
430 usage();
431 return (0);
432 }
433 if (ret < 0) /* error */
434 return (0);
435 }
436 return (1);
437 }
438
439 /*
440 * options_from_file - read a string of options from a file, and
441 * interpret them. Returns 1 upon successful processing of options,
442 * and 0 otherwise.
443 */
444 int
445 options_from_file
446 #ifdef __STDC__
447 (char *filename, bool must_exist, bool check_prot, bool priv)
448 #else
449 (filename, must_exist, check_prot, priv)
450 char *filename;
451 bool must_exist;
452 bool check_prot;
453 bool priv;
454 #endif
455 {
456 FILE *f;
457 int i, newline, ret, err;
458 option_t *opt;
459 bool oldpriv;
460 int oldline, sline;
461 char *oldsource;
462 char *argv[MAXARGS];
463 char args[MAXARGS][MAXWORDLEN];
464 char cmd[MAXWORDLEN];
465 static bool firsterr = 1;
466 static int nestlevel = 0;
467
468 if (nestlevel >= MAXFILENESTING) {
469 option_error("file nesting too deep");
470 return (0);
471 }
472 if (check_prot)
473 (void) seteuid(getuid());
474 errno = 0;
475 f = fopen(filename, "r");
476 err = errno;
477 if (check_prot)
478 (void) seteuid(0);
479 if (f == NULL) {
480 if (!must_exist && err == ENOENT)
481 return (1);
482 errno = err;
483 option_error("Can't open options file %s: %m", filename);
484 return (0);
485 }
486
487 nestlevel++;
488 oldpriv = privileged_option;
489 privileged_option = priv;
490 oldsource = option_source;
491 /*
492 * strdup() is used here because the pointer might refer to the
493 * caller's automatic (stack) storage, and the option_info array
494 * records the source file name.
495 */
496 option_source = strdup(filename);
497 oldline = option_line;
498 option_line = 1;
499 if (option_source == NULL)
500 option_source = "file";
501 ret = 0;
502 while (getword(f, cmd, &newline, filename)) {
503 sline = option_line;
504 /*
505 * First see if it's a command.
506 */
507 opt = find_option(cmd);
508 if (opt != NULL) {
509 int n = n_arguments(opt);
510 for (i = 0; i < n; ++i) {
511 if (!getword(f, args[i], &newline, filename)) {
512 option_error("too few parameters for option '%s'", cmd);
513 goto err;
514 }
515 argv[i] = args[i];
516 }
517 current_option = cmd;
518 if ((opt->flags & OPT_DEVEQUIV) && devnam_fixed) {
519 option_error("the '%s' option may not be used here", cmd);
520 goto err;
521 }
522 if (!process_option(opt, argv, sline))
523 goto err;
524 continue;
525 }
526
527 /*
528 * Maybe a tty name, speed or IP address ?
529 */
530 if (((i = setdevname(cmd)) == 0) &&
531 ((i = setspeed(cmd)) == 0) &&
532 ((i = setipaddr(cmd)) == 0)) {
533 option_error("unrecognized option '%s'", cmd);
534 goto err;
535 }
536 if (i < 0) /* error */
537 goto err;
538 }
539 ret = 1;
540
541 err:
542 (void) fclose(f);
543 /* We assume here that we abort all processing on the first error. */
544 if (firsterr)
545 firsterr = 0;
546 else if (!prepass && !ret)
547 option_error("error in included file");
548 /*
549 * Cannot free option_source because it might be referenced in one
550 * or more option_info structures now.
551 */
552 privileged_option = oldpriv;
553 option_source = oldsource;
554 option_line = oldline;
555 nestlevel--;
556 return (ret);
557 }
558
559 /*
560 * options_from_user - see if the user has a ~/.ppprc file, and if so,
561 * interpret options from it. Returns 1 upon successful processing of
562 * options, and 0 otherwise.
563 */
564 int
565 options_from_user()
566 {
567 char *user, *path, *file;
568 int ret;
569 struct passwd *pw;
570 size_t pl;
571
572 pw = getpwuid(getuid());
573 if (pw == NULL || (user = pw->pw_dir) == NULL || user[0] == '\0')
574 return (1);
575 file = _PATH_USEROPT;
576 pl = strlen(user) + strlen(file) + 2;
577 path = malloc(pl);
578 if (path == NULL)
579 novm("init file name");
580 (void) slprintf(path, pl, "%s/%s", user, file);
581 ret = options_from_file(path, 0, 1, privileged);
582 free(path);
583 return (ret);
584 }
585
586 /*
587 * options_for_tty - see if an options file exists for the serial device, and
588 * if so, interpret options from it. Returns 1 upon successful processing of
589 * options, and 0 otherwise.
590 */
591 int
592 options_for_tty()
593 {
594 char *dev, *path, *p;
595 int ret;
596 size_t pl;
597
598 dev = devnam;
599 if (strncmp(dev, "/dev/", 5) == 0)
600 dev += 5;
601 if (dev[0] == '\0' || strcmp(dev, "tty") == 0)
602 return (1); /* don't look for /etc/ppp/options.tty */
603 pl = strlen(_PATH_TTYOPT) + strlen(dev) + 1;
604 path = malloc(pl);
605 if (path == NULL)
606 novm("tty init file name");
607 (void) slprintf(path, pl, "%s%s", _PATH_TTYOPT, dev);
608 /* Turn slashes into dots, for Solaris case (e.g. /dev/term/a) */
609 for (p = path + strlen(_PATH_TTYOPT); *p != '\0'; ++p)
610 if (*p == '/')
611 *p = '.';
612 ret = options_from_file(path, 0, 0, 1);
613 free(path);
614 return (ret);
615 }
616
617 /*
618 * options_from_list - process a string of options in a wordlist. Returns 1
619 * upon successful processing of options, and 0 otherwise.
620 */
621 int
622 options_from_list
623 #ifdef __STDC__
624 (struct wordlist *w, bool priv)
625 #else
626 (w, priv)
627 struct wordlist *w;
628 bool priv;
629 #endif
630 {
631 char *argv[MAXARGS];
632 option_t *opt;
633 int i, ret = 0;
634
635 privileged_option = priv;
636
637 /* Caller is expected to set option_source and option_line. */
638
639 while (w != NULL) {
640 /*
641 * First see if it's a command.
642 */
643 opt = find_option(w->word);
644 if (opt != NULL) {
645 int n = n_arguments(opt);
646 struct wordlist *w0 = w;
647 for (i = 0; i < n; ++i) {
648 w = w->next;
649 if (w == NULL) {
650 option_error("too few parameters for option '%s'",
651 w0->word);
652 goto err;
653 }
654 argv[i] = w->word;
655 }
656 current_option = w0->word;
657 if (!process_option(opt, argv, option_line))
658 goto err;
659 continue;
660 }
661
662 /*
663 * Options from the {p,ch}ap-secrets files can't change the device
664 * name nor the speed. Therefore, calls to setdevname() and
665 * setspeed() were removed.
666 */
667 if ((i = setipaddr(w->word)) == 0) {
668 option_error("unrecognized option '%s'", w->word);
669 goto err;
670 }
671 if (i < 0) /* error */
672 goto err;
673 }
674 ret = 1;
675
676 err:
677 return (ret);
678 }
679
680 /*
681 * find_option - scan the option lists for the various protocols looking for an
682 * entry with the given name. Returns a pointer to the matching option_t
683 * structure upon successful processing of options, and NULL otherwise.
684 */
685 static option_t *
686 find_option(name)
687 char *name;
688 {
689 hashentry_t *bucket;
690
691 bucket = hash_tbl[opt_hash(name)];
692 for (; bucket != NULL; bucket = bucket->next) {
693 if (bucket->opt.p->name != NULL) {
694 if ((strcmp(bucket->opt.p->name, name) == 0) &&
695 !(bucket->opt.p->flags & OPT_DISABLE)) {
696 return (bucket->opt.p);
697 }
698 }
699 }
700 return (NULL);
701 }
702
703 /*
704 * process_option - process one new-style option (something other than a
705 * port name, bit rate, or IP address). Returns 1 upon successful
706 * processing of options, and 0 otherwise.
707 */
708 static int
709 process_option(opt, argv, sline)
710 option_t *opt;
711 char **argv;
712 int sline;
713 {
714 u_int32_t v;
715 int iv, a;
716 char *sv;
717 int (*parser) __P((char **, option_t *));
718
719 if ((opt->flags & OPT_PREPASS) == 0 && prepass)
720 return (1);
721 if ((opt->flags & OPT_INITONLY) && phase != PHASE_INITIALIZE) {
722 option_error("it's too late to use the '%s' option", opt->name);
723 return (0);
724 }
725 if ((opt->flags & OPT_PRIV) && !privileged_option) {
726 option_error("using the '%s' option requires root privilege",
727 opt->name);
728 return (0);
729 }
730 if ((opt->flags & OPT_ENABLE) && !privileged_option &&
731 *(bool *)(opt->addr2) == 0) {
732 option_error("'%s' option is disabled", opt->name);
733 return (0);
734 }
735 if ((opt->flags & OPT_PRIVFIX) && !privileged_option) {
736 struct option_info *ip = (struct option_info *) opt->addr2;
737 if ((ip != NULL) && ip->priv) {
738 option_error("'%s' option cannot be overridden", opt->name);
739 return (0);
740 }
741 }
742
743 switch (opt->type) {
744 case o_bool:
745 v = opt->flags & OPT_VALUE;
746 *(bool *)(opt->addr) = (v != 0);
747 if ((opt->addr2 != NULL) && (opt->flags & OPT_A2COPY))
748 *(bool *)(opt->addr2) = (v != 0);
749 break;
750
751 case o_int:
752 iv = 0;
753 if ((opt->flags & OPT_NOARG) == 0) {
754 if (!int_option(*argv, &iv))
755 return (0);
756 if ((((opt->flags & OPT_LLIMIT) && (iv < opt->lower_limit)) ||
757 ((opt->flags & OPT_ULIMIT) && (iv > opt->upper_limit))) &&
758 !((opt->flags & OPT_ZEROOK) && (iv == 0))) {
759 char *zok = (opt->flags & OPT_ZEROOK) ? " zero or" : "";
760 switch (opt->flags & OPT_LIMITS) {
761 case OPT_LLIMIT:
762 option_error("%s value must be%s >= %d",
763 opt->name, zok, opt->lower_limit);
764 break;
765 case OPT_ULIMIT:
766 option_error("%s value must be%s <= %d",
767 opt->name, zok, opt->upper_limit);
768 break;
769 case OPT_LIMITS:
770 option_error("%s value must be%s between %d and %d",
771 opt->name, zok, opt->lower_limit, opt->upper_limit);
772 break;
773 }
774 return (0);
775 }
776 }
777 a = opt->flags & OPT_VALUE;
778 if (a >= 128)
779 a -= 256; /* sign extend */
780 iv += a;
781 if (opt->flags & OPT_INC)
782 iv += *(int *)(opt->addr);
783 if ((opt->flags & OPT_NOINCR) && !privileged_option) {
784 int oldv = *(int *)(opt->addr);
785
786 if ((opt->flags & OPT_ZEROINF) && (iv == 0)) {
787 if (oldv > 0) {
788 option_error("%s value cannot be set to infinity; limited to %d",
789 opt->name, oldv);
790 return (0);
791 }
792 } else if (iv > oldv) {
793 option_error("%s value cannot be increased beyond %d",
794 opt->name, oldv);
795 return (0);
796 }
797 }
798 *(int *)(opt->addr) = iv;
799 if ((opt->addr2 != NULL) && (opt->flags & OPT_A2COPY))
800 *(int *)(opt->addr2) = iv;
801 break;
802
803 case o_uint32:
804 if (opt->flags & OPT_NOARG) {
805 v = opt->flags & OPT_VALUE;
806 } else if (!number_option(*argv, &v, 16))
807 return (0);
808 if (opt->flags & OPT_OR)
809 v |= *(u_int32_t *)(opt->addr);
810 *(u_int32_t *)(opt->addr) = v;
811 if ((opt->addr2 != NULL) && (opt->flags & OPT_A2COPY))
812 *(u_int32_t *)(opt->addr2) = v;
813 break;
814
815 case o_string:
816 if (opt->flags & OPT_STATIC) {
817 (void) strlcpy((char *)(opt->addr), *argv, opt->upper_limit);
818 if ((opt->addr2 != NULL) && (opt->flags & OPT_A2COPY)) {
819 (void) strlcpy((char *)(opt->addr2), *argv, opt->upper_limit);
820 }
821 } else {
822 sv = strdup(*argv);
823 if (sv == NULL)
824 novm("option argument");
825 *(char **)(opt->addr) = sv;
826 if (opt->addr2 != NULL && (opt->flags & OPT_A2COPY))
827 *(char **)(opt->addr2) = sv;
828 }
829 break;
830
831 case o_special_noarg:
832 case o_special:
833 parser = (int (*) __P((char **, option_t *))) opt->addr;
834 if (!(*parser)(argv, opt))
835 return (0);
836 break;
837 }
838
839 if (opt->addr2 != NULL) {
840 if (opt->flags & OPT_A2INFO) {
841 struct option_info *ip = (struct option_info *) opt->addr2;
842 ip->priv = privileged_option;
843 ip->source = option_source;
844 ip->line = sline;
845 } else if ((opt->flags & (OPT_A2COPY|OPT_ENABLE)) == 0)
846 *(bool *)(opt->addr2) = 1;
847 }
848
849 return (1);
850 }
851
852 /*
853 * n_arguments - tell how many arguments an option takes. Returns 1 upon
854 * successful processing of options, and 0 otherwise.
855 */
856 static int
857 n_arguments(opt)
858 option_t *opt;
859 {
860 return ((opt->type == o_bool || opt->type == o_special_noarg ||
861 (opt->flags & OPT_NOARG)) ? 0 : 1);
862 }
863
864 /*
865 * opt_hash - a hash function that works quite well for strings. Returns
866 * the hash key of the supplied string.
867 */
868 static u_int32_t
869 opt_hash(key)
870 const void *key;
871 {
872 register const char *ptr;
873 register u_int32_t val;
874
875 val = 0;
876 ptr = key;
877 while (*ptr != '\0') {
878 int tmp;
879 val = (val << 4) + (*ptr);
880 tmp = val & 0xf0000000;
881 if (tmp) {
882 val ^= (tmp >> 24);
883 val ^= tmp;
884 }
885 ptr++;
886 }
887 return (val % OPTHASH_TBLSIZE);
888 }
889
890 /*
891 * add_options - add a list of options to the chained hash table.
892 * Also detect duplicate options, and if found, disable the older
893 * definition and log it as an error.
894 */
895 void
896 add_options(opt)
897 option_t *opt;
898 {
899 register option_t *sopt;
900 register hashentry_t *bucket;
901 register u_int32_t loc;
902 hashentry_t *he;
903
904 /* fill hash-table */
905 for (sopt = opt; sopt->name != NULL; ++sopt, hash_tblcnt++) {
906
907 /* first, allocate a hash entry */
908 he = (hashentry_t *)malloc(sizeof(*he));
909 if (he == NULL) {
910 novm("option hash table entry");
911 }
912 he->opt.p = sopt;
913 he->next = NULL;
914
915 /*
916 * fill the chained hash table and take care of any collisions or
917 * duplicate items.
918 */
919 loc = opt_hash(sopt->name);
920 bucket = hash_tbl[loc];
921 if (bucket != NULL) {
922 for (;;) {
923 if (!(bucket->opt.p->flags & OPT_DISABLE) &&
924 strcmp(sopt->name, bucket->opt.p->name) == 0) {
925 info("option '%s' redefined; old definition disabled",
926 sopt->name);
927 bucket->opt.p->flags |= OPT_DISABLE;
928 }
929 if (bucket->next == NULL)
930 break;
931 bucket = bucket->next;
932 }
933 bucket->next = he;
934 } else {
935 hash_tbl[loc] = he;
936 }
937 }
938 }
939
940 /*
941 * remove_option - disable an option. Returns the option_t structure
942 * of the disabled option, or NULL if the option name is invalid or if
943 * the option has already been disabled.
944 */
945 option_t *
946 remove_option(name)
947 char *name;
948 {
949 option_t *opt;
950
951 if ((opt = find_option(name)) != NULL) {
952 opt->flags |= OPT_DISABLE;
953 }
954 return (opt);
955 }
956
957 /*
958 * opt_compare - a compare function supplied to the quicksort routine.
959 * Returns an integer less than, equal to, or greater than zero to indicate
960 * if the first argument is considered less than, equal to, or greater
961 * than the second argument.
962 */
963 static int
964 opt_compare(p1, p2)
965 const void *p1;
966 const void *p2;
967 {
968 opt_t *o1 = (opt_t *)p1;
969 opt_t *o2 = (opt_t *)p2;
970
971 return (strcmp(o1->p->name, o2->p->name));
972 }
973
974 /*ARGSUSED*/
975 static int
976 showalloptions(argv, topt)
977 char **argv;
978 option_t *topt;
979 {
980 #define MAXOPTSTRLEN 257
981 #define PRINTOPTIONS() { \
982 (void) slprintf(opt_str, sizeof(opt_str), "%s", opt->name); \
983 if ((opt->type == o_int || opt->type == o_uint32) && \
984 !(opt->flags & OPT_NOARG)) { \
985 (void) strlcat(opt_str, " <n>", sizeof(opt_str)); \
986 } else if (opt->type == o_string) { \
987 (void) strlcat(opt_str, " <s>", sizeof(opt_str)); \
988 } else if (opt->type == o_special) { \
989 (void) strlcat(opt_str, " <r>", sizeof(opt_str)); \
990 } \
991 if (opt->flags & OPT_PRIV) { \
992 (void) strlcat(opt_str, " (!)", sizeof(opt_str)); \
993 } else if (opt->flags & OPT_DISABLE) { \
994 (void) strlcat(opt_str, " (#)", sizeof(opt_str)); \
995 } \
996 (void) printf("%-26s%s\n", opt_str, opt->description); \
997 }
998
999 char opt_str[MAXOPTSTRLEN];
1000 option_t *opt;
1001 hashentry_t *bucket;
1002 int i, sofar;
1003 opt_t *sopt;
1004
1005 if (phase != PHASE_INITIALIZE) {
1006 return (0);
1007 }
1008 (void) printf(pre_allopt_string, VERSION, PATCHLEVEL, IMPLEMENTATION,
1009 progname);
1010 for (opt = dummy_options; opt->name != NULL; ++opt) {
1011 PRINTOPTIONS();
1012 }
1013
1014 sopt = malloc(sizeof(*sopt) * hash_tblcnt);
1015 if (sopt == NULL) {
1016 novm("sorted option table");
1017 }
1018
1019 sofar = 0;
1020 for (i = 0; i < OPTHASH_TBLSIZE; i++) {
1021 for (bucket = hash_tbl[i]; bucket != NULL; bucket = bucket->next) {
1022 if (sofar >= hash_tblcnt) {
1023 fatal("options hash table corrupted; size mismatch");
1024 }
1025 sopt[sofar++].p = bucket->opt.p;
1026 }
1027 }
1028
1029 qsort((void *)sopt, sofar, sizeof(sopt[0]), opt_compare);
1030 for (i = 0; i < sofar; i++) {
1031 opt = sopt[i].p;
1032 PRINTOPTIONS();
1033 }
1034
1035 (void) printf(post_allopt_string);
1036 (void) free(sopt);
1037
1038 #undef MAXOPTSTRLEN
1039 #undef PRINTOPTIONS
1040 return (0);
1041 }
1042
1043 /*
1044 * usage - print out a message telling how to use the program.
1045 * This string gets printed out when either "--help" or an invalid option
1046 * is specified.
1047 */
1048 static void
1049 usage()
1050 {
1051 static const char usage_string[] = "\
1052 pppd version %s.%d%s\n\
1053 Usage: %s [ options ], where options are:\n\
1054 \t<device>\tCommunicate over the named device\n\
1055 \t<speed>\t\tSet the baud rate to <speed>\n\
1056 \t<loc>:<rem>\tSet the local and/or remote interface IP\n\
1057 \t\t\taddresses. Either one may be omitted.\n\
1058 \tnoauth\t\tDon't require authentication from peer\n\
1059 \tconnect <p>\tInvoke shell command <p> to set up the serial line\n\
1060 \tdefaultroute\tAdd default route through interface\n\
1061 Use \"%s options\" or \"man pppd\" for more options.\n\
1062 ";
1063
1064 if (phase == PHASE_INITIALIZE)
1065 (void) fprintf(stderr, usage_string, VERSION, PATCHLEVEL,
1066 IMPLEMENTATION, progname, progname);
1067 }
1068
1069 /*
1070 * showhelp - print out usage message and exit program upon success, or
1071 * return 0 otherwise.
1072 */
1073 /*ARGSUSED*/
1074 static int
1075 showhelp(argv, opt)
1076 char **argv;
1077 option_t *opt;
1078 {
1079 if (phase == PHASE_INITIALIZE) {
1080 usage();
1081 exit(0);
1082 }
1083 return (0);
1084 }
1085
1086 /*
1087 * showversion - print out the version number and exit program upon success,
1088 * or return 0 otherwise.
1089 */
1090 /*ARGSUSED*/
1091 static int
1092 showversion(argv, opt)
1093 char **argv;
1094 option_t *opt;
1095 {
1096 if (phase == PHASE_INITIALIZE) {
1097 (void) fprintf(stderr, "pppd version %s.%d%s\n", VERSION, PATCHLEVEL,
1098 IMPLEMENTATION);
1099 exit(0);
1100 }
1101 return (0);
1102 }
1103
1104 /*
1105 * option_error - print a message about an error in an option. The message is
1106 * logged, and also sent to stderr if phase == PHASE_INITIALIZE.
1107 */
1108 void
1109 option_error __V((char *fmt, ...))
1110 {
1111 va_list args;
1112 char buf[256];
1113 int i, err;
1114
1115 #if defined(__STDC__)
1116 va_start(args, fmt);
1117 #else
1118 char *fmt;
1119 va_start(args);
1120 fmt = va_arg(args, char *);
1121 #endif
1122 if (prepass) {
1123 va_end(args);
1124 return;
1125 }
1126 err = errno;
1127 if (option_source == NULL) {
1128 i = 0;
1129 } else if (option_line <= 0) {
1130 (void) strlcpy(buf, option_source, sizeof (buf));
1131 i = strlen(buf);
1132 } else {
1133 i = slprintf(buf, sizeof(buf), "%s:%d", option_source, option_line);
1134 }
1135 if (i != 0) {
1136 (void) strlcat(buf, ": ", sizeof (buf));
1137 i += 2;
1138 }
1139 errno = err;
1140 (void) vslprintf(buf + i, sizeof (buf) - i, fmt, args);
1141 va_end(args);
1142 if ((phase == PHASE_INITIALIZE) && !detached)
1143 (void) fprintf(stderr, "%s: %s\n", progname, buf);
1144 syslog(LOG_ERR, "%s", buf);
1145 }
1146
1147 /*
1148 * getword - read a word from a file. Words are delimited by white-space or by
1149 * quotes (" or '). Quotes, white-space and \ may be escaped with \.
1150 * \<newline> is ignored. Returns 1 upon successful processing of options,
1151 * and 0 otherwise.
1152 */
1153 int
1154 getword(f, word, newlinep, filename)
1155 FILE *f;
1156 char *word;
1157 int *newlinep;
1158 char *filename;
1159 {
1160 int c, len, escape;
1161 int quoted, comment;
1162 int value, digit, got, n;
1163
1164 #define isoctal(c) ((c) >= '0' && (c) < '8')
1165
1166 *newlinep = 0;
1167 len = 0;
1168 escape = 0;
1169 comment = 0;
1170
1171 /*
1172 * First skip white-space and comments.
1173 */
1174 for (;;) {
1175 c = getc(f);
1176 if (c == EOF)
1177 break;
1178
1179 /*
1180 * A newline means the end of a comment; backslash-newline
1181 * is ignored. Note that we cannot have escape && comment.
1182 */
1183 if (c == '\n') {
1184 option_line++;
1185 if (!escape) {
1186 *newlinep = 1;
1187 comment = 0;
1188 } else
1189 escape = 0;
1190 continue;
1191 }
1192
1193 /*
1194 * Ignore characters other than newline in a comment.
1195 */
1196 if (comment)
1197 continue;
1198
1199 /*
1200 * If this character is escaped, we have a word start.
1201 */
1202 if (escape)
1203 break;
1204
1205 /*
1206 * If this is the escape character, look at the next character.
1207 */
1208 if (c == '\\') {
1209 escape = 1;
1210 continue;
1211 }
1212
1213 /*
1214 * If this is the start of a comment, ignore the rest of the line.
1215 */
1216 if (c == '#') {
1217 comment = 1;
1218 continue;
1219 }
1220
1221 /*
1222 * A non-whitespace character is the start of a word.
1223 */
1224 if (!isspace(c))
1225 break;
1226 }
1227
1228 /*
1229 * Save the delimiter for quoted strings.
1230 */
1231 if (!escape && (c == '"' || c == '\'')) {
1232 quoted = c;
1233 c = getc(f);
1234 } else
1235 quoted = 0;
1236
1237 /*
1238 * Process characters until the end of the word.
1239 */
1240 while (c != EOF) {
1241 if (escape) {
1242 /*
1243 * This character is escaped: backslash-newline is ignored,
1244 * various other characters indicate particular values
1245 * as for C backslash-escapes.
1246 */
1247 escape = 0;
1248 if (c == '\n') {
1249 c = getc(f);
1250 continue;
1251 }
1252
1253 got = 0;
1254 switch (c) {
1255 case 'a':
1256 value = '\a';
1257 break;
1258 case 'b':
1259 value = '\b';
1260 break;
1261 case 'f':
1262 value = '\f';
1263 break;
1264 case 'n':
1265 value = '\n';
1266 break;
1267 case 'r':
1268 value = '\r';
1269 break;
1270 case 's':
1271 value = ' ';
1272 break;
1273 case 't':
1274 value = '\t';
1275 break;
1276
1277 default:
1278 if (isoctal(c)) {
1279 /*
1280 * \ddd octal sequence
1281 */
1282 value = 0;
1283 for (n = 0; n < 3 && isoctal(c); ++n) {
1284 value = (value << 3) + (c & 07);
1285 c = getc(f);
1286 }
1287 got = 1;
1288 break;
1289 }
1290
1291 if (c == 'x') {
1292 /*
1293 * \x<hex_string> sequence
1294 */
1295 value = 0;
1296 c = getc(f);
1297 for (n = 0; n < 2 && isxdigit(c); ++n) {
1298 digit = (islower(c) ? toupper(c) : c) - '0';
1299 if (digit > 10 || digit < 0) /* allow non-ASCII */
1300 digit += '0' + 10 - 'A';
1301 value = (value << 4) + digit;
1302 c = getc (f);
1303 }
1304 got = 1;
1305 break;
1306 }
1307
1308 /*
1309 * Otherwise the character stands for itself.
1310 */
1311 value = c;
1312 break;
1313 }
1314
1315 /*
1316 * Store the resulting character for the escape sequence.
1317 */
1318 if (len < MAXWORDLEN-1)
1319 word[len] = value;
1320 ++len;
1321
1322 if (!got)
1323 c = getc(f);
1324 continue;
1325
1326 }
1327
1328 /*
1329 * Not escaped: see if we've reached the end of the word.
1330 */
1331 if (quoted) {
1332 if (c == quoted)
1333 break;
1334 } else {
1335 if (isspace(c) || c == '#') {
1336 (void) ungetc (c, f);
1337 break;
1338 }
1339 }
1340
1341 /*
1342 * Backslash starts an escape sequence.
1343 */
1344 if (c == '\\') {
1345 escape = 1;
1346 c = getc(f);
1347 continue;
1348 }
1349
1350 /*
1351 * An ordinary character: store it in the word and get another.
1352 */
1353 if (len < MAXWORDLEN-1)
1354 word[len] = c;
1355 ++len;
1356
1357 c = getc(f);
1358 }
1359
1360 /*
1361 * End of the word: check for errors.
1362 */
1363 if (c == EOF) {
1364 if (ferror(f)) {
1365 if (errno == 0)
1366 errno = EIO;
1367 option_error("Error reading %s: %m", filename);
1368 die(1);
1369 }
1370 /*
1371 * If len is zero, then we didn't find a word before the
1372 * end of the file.
1373 */
1374 if (len == 0)
1375 return (0);
1376 }
1377
1378 /*
1379 * Warn if the word was too long, and append a terminating null.
1380 */
1381 if (len >= MAXWORDLEN) {
1382 option_error("warning: word in file %s too long (%.20s...)",
1383 filename, word);
1384 len = MAXWORDLEN - 1;
1385 }
1386 word[len] = '\0';
1387
1388 return (1);
1389
1390 #undef isoctal
1391
1392 }
1393
1394 /*
1395 * number_option - parse an unsigned numeric parameter for an option.
1396 * Returns 1 upon successful processing of options, and 0 otherwise.
1397 */
1398 static int
1399 number_option(str, valp, base)
1400 char *str;
1401 u_int32_t *valp;
1402 int base;
1403 {
1404 char *ptr;
1405
1406 *valp = strtoul(str, &ptr, base);
1407 if (ptr == str || *ptr != '\0') {
1408 option_error("invalid numeric parameter '%s' for '%s' option",
1409 str, current_option);
1410 return (0);
1411 }
1412 return (1);
1413 }
1414
1415 /*
1416 * save_source - store option source, line, and privilege into an
1417 * option_info structure.
1418 */
1419 void
1420 save_source(info)
1421 struct option_info *info;
1422 {
1423 info->priv = privileged_option;
1424 info->source = option_source;
1425 info->line = option_line;
1426 }
1427
1428 /*
1429 * set_source - set option source, line, and privilege from an
1430 * option_info structure.
1431 */
1432 void
1433 set_source(info)
1434 struct option_info *info;
1435 {
1436 privileged_option = info->priv;
1437 option_source = info->source;
1438 option_line = info->line;
1439 }
1440
1441 /*
1442 * name_source - return string containing option source and line. Can
1443 * be used as part of an option_error call.
1444 */
1445 const char *
1446 name_source(info)
1447 struct option_info *info;
1448 {
1449 static char buf[MAXPATHLEN];
1450
1451 if (info->source == NULL)
1452 return "none";
1453 if (info->line <= 0)
1454 return info->source;
1455 (void) slprintf(buf, sizeof (buf), "%s:%d", info->source, info->line);
1456 return (const char *)buf;
1457 }
1458
1459 /*
1460 * int_option - like number_option, but valp is int *, the base is assumed to
1461 * be 0, and *valp is not changed if there is an error. Returns 1 upon
1462 * successful processing of options, and 0 otherwise.
1463 */
1464 int
1465 int_option(str, valp)
1466 char *str;
1467 int *valp;
1468 {
1469 u_int32_t v;
1470
1471 if (!number_option(str, &v, 0))
1472 return (0);
1473 *valp = (int) v;
1474 return (1);
1475 }
1476
1477
1478 /*
1479 * The following procedures parse options.
1480 */
1481
1482 /*
1483 * readfile - take commands from a file.
1484 */
1485 /*ARGSUSED*/
1486 static int
1487 readfile(argv, opt)
1488 char **argv;
1489 option_t *opt;
1490 {
1491 return (options_from_file(*argv, 1, 1, privileged_option));
1492 }
1493
1494 /*
1495 * callfile - take commands from /etc/ppp/peers/<name>. Name may not contain
1496 * /../, start with / or ../, or end in /. Returns 1 upon successful
1497 * processing of options, and 0 otherwise.
1498 */
1499 /*ARGSUSED*/
1500 static int
1501 callfile(argv, opt)
1502 char **argv;
1503 option_t *opt;
1504 {
1505 char *fname, *arg, *p;
1506 int l, ok;
1507
1508 arg = *argv;
1509 ok = 1;
1510 if (arg[0] == '/' || arg[0] == '\0')
1511 ok = 0;
1512 else {
1513 for (p = arg; *p != '\0'; ) {
1514 if (p[0] == '.' && p[1] == '.' && (p[2] == '/' || p[2] == '\0')) {
1515 ok = 0;
1516 break;
1517 }
1518 while (*p != '/' && *p != '\0')
1519 ++p;
1520 if (*p == '/')
1521 ++p;
1522 }
1523 }
1524 if (!ok) {
1525 option_error("call option value may not contain .. or start with /");
1526 return (0);
1527 }
1528
1529 l = strlen(arg) + strlen(_PATH_PEERFILES) + 1;
1530 if ((fname = (char *) malloc(l)) == NULL)
1531 novm("call file name");
1532 (void) slprintf(fname, l, "%s%s", _PATH_PEERFILES, arg);
1533
1534 ok = options_from_file(fname, 1, 1, 1);
1535
1536 free(fname);
1537 return (ok);
1538 }
1539
1540 #ifdef PPP_FILTER
1541 /*
1542 * setpdebug - set libpcap debugging level. Returns 1 upon successful
1543 * processing of options, and 0 otherwise.
1544 */
1545 static int
1546 setpdebug(argv)
1547 char **argv;
1548 {
1549 return (int_option(*argv, &dflag));
1550 }
1551
1552 /*
1553 * setpassfilter - set the pass filter for packets. Returns 1 upon successful
1554 * processing of options, and 0 otherwise.
1555 */
1556 /*ARGSUSED*/
1557 static int
1558 setpassfilter(argv, opt)
1559 char **argv;
1560 option_t *opt;
1561 {
1562 pc.linktype = DLT_PPP;
1563 pc.snapshot = PPP_HDRLEN;
1564
1565 if (pcap_compile(&pc, &pass_filter, *argv, 1, netmask) == 0)
1566 return (1);
1567 option_error("error in pass-filter expression: %s\n", pcap_geterr(&pc));
1568 return (0);
1569 }
1570
1571 /*
1572 * setactivefilter - set the active filter for packets. Returns 1 upon
1573 * successful processing of options, and 0 otherwise.
1574 */
1575 /*ARGSUSED*/
1576 static int
1577 setactivefilter(argv, opt)
1578 char **argv;
1579 option_t *opt;
1580 {
1581 pc.linktype = DLT_PPP;
1582 pc.snapshot = PPP_HDRLEN;
1583
1584 if (pcap_compile(&pc, &active_filter, *argv, 1, netmask) == 0)
1585 return (1);
1586 option_error("error in active-filter expression: %s\n", pcap_geterr(&pc));
1587 return (0);
1588 }
1589 #endif /* PPP_FILTER */
1590
1591 /*
1592 * noopt - disable all options. Returns 1 upon successful processing of
1593 * options, and 0 otherwise.
1594 */
1595 /*ARGSUSED*/
1596 static int
1597 noopt(argv, opt)
1598 char **argv;
1599 option_t *opt;
1600 {
1601 BZERO((char *) &lcp_wantoptions[0], sizeof (struct lcp_options));
1602 BZERO((char *) &lcp_allowoptions[0], sizeof (struct lcp_options));
1603 BZERO((char *) &ipcp_wantoptions[0], sizeof (struct ipcp_options));
1604 BZERO((char *) &ipcp_allowoptions[0], sizeof (struct ipcp_options));
1605
1606 return (1);
1607 }
1608
1609 /*
1610 * setdomain - set domain name to append to hostname. Returns 1 upon
1611 * successful processing of options, and 0 otherwise.
1612 */
1613 /*ARGSUSED*/
1614 static int
1615 setdomain(argv, opt)
1616 char **argv;
1617 option_t *opt;
1618 {
1619 if (!privileged_option) {
1620 option_error("using the domain option requires root privilege");
1621 return (0);
1622 }
1623 (void) gethostname(hostname, MAXHOSTNAMELEN+1);
1624 if (**argv != '\0') {
1625 if (**argv != '.')
1626 (void) strncat(hostname, ".", MAXHOSTNAMELEN - strlen(hostname));
1627 (void) strncat(hostname, *argv, MAXHOSTNAMELEN - strlen(hostname));
1628 }
1629 hostname[MAXHOSTNAMELEN] = '\0';
1630 return (1);
1631 }
1632
1633
1634 /*
1635 * setspeed - set the speed. Returns 1 upon successful processing of options,
1636 * and 0 otherwise.
1637 */
1638 static int
1639 setspeed(arg)
1640 char *arg;
1641 {
1642 char *ptr;
1643 int spd;
1644
1645 if (prepass)
1646 return (1);
1647 spd = strtol(arg, &ptr, 0);
1648 if (ptr == arg || *ptr != '\0' || spd <= 0)
1649 return (0);
1650 inspeed = spd;
1651 save_source(&speed_info);
1652 return (1);
1653 }
1654
1655
1656 /*
1657 * setdevname - set the device name. Returns 1 upon successful processing of
1658 * options, 0 when the device does not exist, and -1 when an error is
1659 * encountered.
1660 */
1661 static int
1662 setdevname(cp)
1663 char *cp;
1664 {
1665 struct stat statbuf;
1666 char dev[MAXPATHLEN];
1667
1668 if (*cp == '\0')
1669 return (0);
1670
1671 if (strncmp("/dev/", cp, 5) != 0) {
1672 (void) strlcpy(dev, "/dev/", sizeof(dev));
1673 (void) strlcat(dev, cp, sizeof(dev));
1674 cp = dev;
1675 }
1676
1677 /*
1678 * Check if there is a character device by this name.
1679 */
1680 if (stat(cp, &statbuf) < 0) {
1681 if (errno == ENOENT) {
1682 return (0);
1683 }
1684 option_error("Couldn't stat '%s': %m", cp);
1685 return (-1);
1686 }
1687 if (!S_ISCHR(statbuf.st_mode)) {
1688 option_error("'%s' is not a character device", cp);
1689 return (-1);
1690 }
1691
1692 if (phase != PHASE_INITIALIZE) {
1693 option_error("device name cannot be changed after initialization");
1694 return (-1);
1695 } else if (devnam_fixed) {
1696 option_error("per-tty options file may not specify device name");
1697 return (-1);
1698 }
1699
1700 if (devnam_info.priv && !privileged_option) {
1701 option_error("device name %s from %s cannot be overridden",
1702 devnam, name_source(&devnam_info));
1703 return (-1);
1704 }
1705
1706 (void) strlcpy(devnam, cp, sizeof(devnam));
1707 devstat = statbuf;
1708 default_device = 0;
1709 save_source(&devnam_info);
1710
1711 return (1);
1712 }
1713
1714
1715 /*
1716 * setipaddr - set the IP address. Returns 1 upon successful processing of
1717 * options, 0 when the argument does not contain a `:', and -1 for error.
1718 */
1719 static int
1720 setipaddr(arg)
1721 char *arg;
1722 {
1723 struct hostent *hp;
1724 char *colon;
1725 u_int32_t local, remote;
1726 ipcp_options *wo = &ipcp_wantoptions[0];
1727
1728 /*
1729 * IP address pair separated by ":".
1730 */
1731 if ((colon = strchr(arg, ':')) == NULL)
1732 return (0);
1733 if (prepass)
1734 return (1);
1735
1736 /*
1737 * If colon first character, then no local addr.
1738 */
1739 if (colon != arg) {
1740 *colon = '\0';
1741 if ((local = inet_addr(arg)) == (u_int32_t) -1) {
1742 if ((hp = gethostbyname(arg)) == NULL) {
1743 option_error("unknown host: %s", arg);
1744 return (-1);
1745 } else {
1746 BCOPY(hp->h_addr, &local, sizeof(local));
1747 }
1748 }
1749 if (bad_ip_adrs(local)) {
1750 option_error("bad local IP address %I", local);
1751 return (-1);
1752 }
1753 if (local != 0) {
1754 save_source(&ipsrc_info);
1755 wo->ouraddr = local;
1756 }
1757 *colon = ':';
1758 }
1759
1760 /*
1761 * If colon last character, then no remote addr.
1762 */
1763 if (*++colon != '\0') {
1764 if ((remote = inet_addr(colon)) == (u_int32_t) -1) {
1765 if ((hp = gethostbyname(colon)) == NULL) {
1766 option_error("unknown host: %s", colon);
1767 return (-1);
1768 } else {
1769 BCOPY(hp->h_addr, &remote, sizeof(remote));
1770 if (remote_name[0] == '\0')
1771 (void) strlcpy(remote_name, colon, sizeof(remote_name));
1772 }
1773 }
1774 if (bad_ip_adrs(remote)) {
1775 option_error("bad remote IP address %I", remote);
1776 return (-1);
1777 }
1778 if (remote != 0) {
1779 save_source(&ipdst_info);
1780 wo->hisaddr = remote;
1781 }
1782 }
1783
1784 return (1);
1785 }
1786
1787
1788 /*
1789 * setnetmask - set the netmask to be used on the interface. Returns 1 upon
1790 * successful processing of options, and 0 otherwise.
1791 */
1792 /*ARGSUSED*/
1793 static int
1794 setnetmask(argv, opt)
1795 char **argv;
1796 option_t *opt;
1797 {
1798 u_int32_t mask;
1799 int n;
1800 char *p;
1801
1802 /*
1803 * Unfortunately, if we use inet_addr, we can't tell whether
1804 * a result of all 1s is an error or a valid 255.255.255.255.
1805 */
1806 p = *argv;
1807 n = parse_dotted_ip(p, &mask);
1808
1809 mask = htonl(mask);
1810
1811 if (n == 0 || p[n] != 0 || (netmask & ~mask) != 0) {
1812 option_error("invalid netmask value '%s'", *argv);
1813 return (0);
1814 }
1815
1816 netmask = mask;
1817 return (1);
1818 }
1819
1820 /*
1821 * parse_dotted_ip - parse and convert the IP address string to make
1822 * sure it conforms to the dotted notation. Returns the length of
1823 * processed characters upon success, and 0 otherwise. If successful,
1824 * the converted IP address number is stored in vp, in the host byte
1825 * order.
1826 */
1827 int
1828 parse_dotted_ip(cp, vp)
1829 register char *cp;
1830 u_int32_t *vp;
1831 {
1832 register u_int32_t val, base, n;
1833 register char c;
1834 char *cp0 = cp;
1835 u_char parts[3], *pp = parts;
1836
1837 if ((*cp == '\0') || (vp == NULL))
1838 return (0); /* disallow null string in cp */
1839 *vp = 0;
1840 again:
1841 /*
1842 * Collect number up to ``.''. Values are specified as for C:
1843 * 0x=hex, 0=octal, other=decimal.
1844 */
1845 val = 0; base = 10;
1846 if (*cp == '0') {
1847 if (*++cp == 'x' || *cp == 'X')
1848 base = 16, cp++;
1849 else
1850 base = 8;
1851 }
1852 while ((c = *cp) != '\0') {
1853 if (isdigit(c)) {
1854 if ((c - '0') >= base)
1855 break;
1856 val = (val * base) + (c - '0');
1857 cp++;
1858 continue;
1859 }
1860 if (base == 16 && isxdigit(c)) {
1861 val = (val << 4) + (c + 10 - (islower(c) ? 'a' : 'A'));
1862 cp++;
1863 continue;
1864 }
1865 break;
1866 }
1867 if (*cp == '.') {
1868 /*
1869 * Internet format:
1870 * a.b.c.d
1871 * a.b.c (with c treated as 16-bits)
1872 * a.b (with b treated as 24 bits)
1873 */
1874 if ((pp >= parts + 3) || (val > 0xff)) {
1875 return (0);
1876 }
1877 *pp++ = (u_char)val;
1878 cp++;
1879 goto again;
1880 }
1881 /*
1882 * Check for trailing characters.
1883 */
1884 if (*cp != '\0' && !isspace(*cp)) {
1885 return (0);
1886 }
1887 /*
1888 * Concoct the address according to the number of parts specified.
1889 */
1890 n = pp - parts;
1891 switch (n) {
1892 case 0: /* a -- 32 bits */
1893 break;
1894 case 1: /* a.b -- 8.24 bits */
1895 if (val > 0xffffff)
1896 return (0);
1897 val |= parts[0] << 24;
1898 break;
1899 case 2: /* a.b.c -- 8.8.16 bits */
1900 if (val > 0xffff)
1901 return (0);
1902 val |= (parts[0] << 24) | (parts[1] << 16);
1903 break;
1904 case 3: /* a.b.c.d -- 8.8.8.8 bits */
1905 if (val > 0xff)
1906 return (0);
1907 val |= (parts[0] << 24) | (parts[1] << 16) | (parts[2] << 8);
1908 break;
1909 default:
1910 return (0);
1911 }
1912 *vp = val;
1913 return (cp - cp0);
1914 }
1915
1916 /*
1917 * setxonxoff - modify the asyncmap to include escaping XON and XOFF
1918 * characters used for software flow control. Returns 1 upon successful
1919 * processing of options, and 0 otherwise.
1920 */
1921 /*ARGSUSED*/
1922 static int
1923 setxonxoff(argv, opt)
1924 char **argv;
1925 option_t *opt;
1926 {
1927 int xonxoff = 0x000A0000;
1928
1929 lcp_wantoptions[0].neg_asyncmap = 1;
1930 lcp_wantoptions[0].asyncmap |= xonxoff; /* escape ^S and ^Q */
1931 lcp_allowoptions[0].asyncmap |= xonxoff;
1932 xmit_accm[0][0] |= xonxoff;
1933 xmit_accm[0][4] |= xonxoff; /* escape 0x91 and 0x93 as well */
1934
1935 crtscts = -2;
1936 return (1);
1937 }
1938
1939 /*
1940 * setlogfile - open (or create) a file used for logging purposes. Returns 1
1941 * upon success, and 0 otherwise.
1942 */
1943 /*ARGSUSED*/
1944 static int
1945 setlogfile(argv, opt)
1946 char **argv;
1947 option_t *opt;
1948 {
1949 int fd, err;
1950
1951 if (!privileged_option)
1952 (void) seteuid(getuid());
1953 fd = open(*argv, O_WRONLY | O_APPEND | O_CREAT | O_EXCL, 0644);
1954 if (fd < 0 && errno == EEXIST)
1955 fd = open(*argv, O_WRONLY | O_APPEND);
1956 err = errno;
1957 if (!privileged_option)
1958 (void) seteuid(0);
1959 if (fd < 0) {
1960 errno = err;
1961 option_error("Can't open log file %s: %m", *argv);
1962 return (0);
1963 }
1964 if (log_to_file && log_to_fd >= 0)
1965 (void) close(log_to_fd);
1966 log_to_fd = fd;
1967 log_to_file = 1;
1968 early_log = 0;
1969 return (1);
1970 }
1971
1972 #ifdef PLUGIN
1973 /*
1974 * loadplugin - load and initialize the plugin. Returns 1 upon successful
1975 * processing of the plugin, and 0 otherwise.
1976 */
1977 /*ARGSUSED*/
1978 static int
1979 loadplugin(argv, opt)
1980 char **argv;
1981 option_t *opt;
1982 {
1983 char *arg = *argv;
1984 void *handle;
1985 const char *err;
1986 void (*init) __P((void));
1987
1988 handle = dlopen(arg, RTLD_GLOBAL | RTLD_NOW);
1989 if (handle == NULL) {
1990 err = dlerror();
1991 if (err != NULL)
1992 option_error("%s", err);
1993 option_error("Couldn't load plugin %s", arg);
1994 return (0);
1995 }
1996 init = (void (*)(void))dlsym(handle, "plugin_init");
1997 if (init == NULL) {
1998 option_error("%s has no initialization entry point", arg);
1999 (void) dlclose(handle);
2000 return (0);
2001 }
2002 info("Plugin %s loaded.", arg);
2003 (*init)();
2004 return (1);
2005 }
2006 #endif /* PLUGIN */