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, &notty,
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 */
2007