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