Added packet filtering, subnet spec for allowed IP addr; select
[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.29 1996/01/18 03:35:38 paulus Exp $";
22 #endif
23
24 #include <stdio.h>
25 #include <errno.h>
26 #include <unistd.h>
27 #include <limits.h>
28 #include <stdlib.h>
29 #include <termios.h>
30 #include <syslog.h>
31 #include <string.h>
32 #include <netdb.h>
33 #include <pwd.h>
34 #include <sys/types.h>
35 #include <sys/stat.h>
36 #include <netinet/in.h>
37
38 #include "pppd.h"
39 #include "pathnames.h"
40 #include "patchlevel.h"
41 #include "fsm.h"
42 #include "lcp.h"
43 #include "ipcp.h"
44 #include "upap.h"
45 #include "chap.h"
46 #include "ccp.h"
47
48 #ifdef IPX_CHANGE
49 #include "ipxcp.h"
50 #endif /* IPX_CHANGE */
51
52 #include <net/ppp-comp.h>
53
54 #define FALSE   0
55 #define TRUE    1
56
57 #if defined(ultrix) || defined(NeXT)
58 char *strdup __P((char *));
59 #endif
60
61 #ifndef GIDSET_TYPE
62 #define GIDSET_TYPE     gid_t
63 #endif
64
65 /*
66  * Option variables and default values.
67  */
68 int     debug = 0;              /* Debug flag */
69 int     kdebugflag = 0;         /* Tell kernel to print debug messages */
70 int     default_device = 1;     /* Using /dev/tty or equivalent */
71 char    devnam[MAXPATHLEN] = "/dev/tty";        /* Device name */
72 int     crtscts = 0;            /* Use hardware flow control */
73 int     modem = 1;              /* Use modem control lines */
74 int     inspeed = 0;            /* Input/Output speed requested */
75 u_int32_t netmask = 0;          /* IP netmask to set on interface */
76 int     lockflag = 0;           /* Create lock file to lock the serial dev */
77 int     nodetach = 0;           /* Don't detach from controlling tty */
78 char    *connector = NULL;      /* Script to establish physical link */
79 char    *disconnector = NULL;   /* Script to disestablish physical link */
80 char    *welcomer = NULL;       /* Script to run after phys link estab. */
81 int     maxconnect = 0;         /* Maximum connect time */
82 char    user[MAXNAMELEN];       /* Username for PAP */
83 char    passwd[MAXSECRETLEN];   /* Password for PAP */
84 int     auth_required = 0;      /* Peer is required to authenticate */
85 int     defaultroute = 0;       /* assign default route through interface */
86 int     proxyarp = 0;           /* Set up proxy ARP entry for peer */
87 int     persist = 0;            /* Reopen link after it goes down */
88 int     uselogin = 0;           /* Use /etc/passwd for checking PAP */
89 int     lcp_echo_interval = 0;  /* Interval between LCP echo-requests */
90 int     lcp_echo_fails = 0;     /* Tolerance to unanswered echo-requests */
91 char    our_name[MAXNAMELEN];   /* Our name for authentication purposes */
92 char    remote_name[MAXNAMELEN]; /* Peer's name for authentication */
93 int     usehostname = 0;        /* Use hostname for our_name */
94 int     disable_defaultip = 0;  /* Don't use hostname for default IP adrs */
95 int     demand = 0;             /* do dial-on-demand */
96 char    *ipparam = NULL;        /* Extra parameter for ip up/down scripts */
97 int     cryptpap;               /* Passwords in pap-secrets are encrypted */
98 int     idle_time_limit = 0;    /* Disconnect if idle for this many seconds */
99 int     holdoff = 30;           /* # seconds to pause before reconnecting */
100
101 /*
102  * Prototypes
103  */
104 static int setdebug __P((void));
105 static int setkdebug __P((char **));
106 static int setpassive __P((void));
107 static int setsilent __P((void));
108 static int noopt __P((void));
109 static int setnovj __P((void));
110 static int setnovjccomp __P((void));
111 static int setvjslots __P((char **));
112 static int reqpap __P((void));
113 static int nopap __P((void));
114 static int setupapfile __P((char **));
115 static int nochap __P((void));
116 static int reqchap __P((void));
117 static int setspeed __P((char *));
118 static int noaccomp __P((void));
119 static int noasyncmap __P((void));
120 static int noip __P((void));
121 static int nomagicnumber __P((void));
122 static int setasyncmap __P((char **));
123 static int setescape __P((char **));
124 static int setmru __P((char **));
125 static int setmtu __P((char **));
126 static int nomru __P((void));
127 static int nopcomp __P((void));
128 static int setconnector __P((char **));
129 static int setdisconnector __P((char **));
130 static int setwelcomer __P((char **));
131 static int setmaxconnect __P((char **));
132 static int setdomain __P((char **));
133 static int setnetmask __P((char **));
134 static int setcrtscts __P((void));
135 static int setnocrtscts __P((void));
136 static int setxonxoff __P((void));
137 static int setnodetach __P((void));
138 static int setmodem __P((void));
139 static int setlocal __P((void));
140 static int setlock __P((void));
141 static int setname __P((char **));
142 static int setuser __P((char **));
143 static int setremote __P((char **));
144 static int setauth __P((void));
145 static int readfile __P((char **));
146 static int setdefaultroute __P((void));
147 static int setnodefaultroute __P((void));
148 static int setproxyarp __P((void));
149 static int setnoproxyarp __P((void));
150 static int setpersist __P((void));
151 static int setdologin __P((void));
152 static int setusehostname __P((void));
153 static int setnoipdflt __P((void));
154 static int setlcptimeout __P((char **));
155 static int setlcpterm __P((char **));
156 static int setlcpconf __P((char **));
157 static int setlcpfails __P((char **));
158 static int setipcptimeout __P((char **));
159 static int setipcpterm __P((char **));
160 static int setipcpconf __P((char **));
161 static int setipcpfails __P((char **));
162 static int setpaptimeout __P((char **));
163 static int setpapreqs __P((char **));
164 static int setpapreqtime __P((char **));
165 static int setchaptimeout __P((char **));
166 static int setchapchal __P((char **));
167 static int setchapintv __P((char **));
168 static int setipcpaccl __P((void));
169 static int setipcpaccr __P((void));
170 static int setlcpechointv __P((char **));
171 static int setlcpechofails __P((char **));
172 static int setbsdcomp __P((char **));
173 static int setnobsdcomp __P((void));
174 static int setdeflate __P((char **));
175 static int setnodeflate __P((void));
176 static int setdemand __P((void));
177 static int setpred1comp __P((void));
178 static int setnopred1comp __P((void));
179 static int setipparam __P((char **));
180 static int setpapcrypt __P((void));
181 static int setidle __P((char **));
182 static int setholdoff __P((char **));
183
184 #ifdef IPX_CHANGE
185 static int setipxproto __P((void));
186 static int resetipxproto __P((void));
187 static int setipxanet __P((void));
188 static int setipxalcl __P((void));
189 static int setipxarmt __P((void));
190 static int setipxnetwork __P((char **));
191 static int setipxnode __P((char **));
192 static int setipxrouter __P((char **));
193 static int setipxname __P((char **));
194 static int setipxcptimeout __P((char **));
195 static int setipxcpterm __P((char **));
196 static int setipxcpconf __P((char **));
197 static int setipxcpfails __P((char **));
198 #endif /* IPX_CHANGE */
199
200 #ifdef USE_MS_DNS
201 static int setdnsaddr __P((char **));
202 #endif
203
204 static int number_option __P((char *, u_int32_t *, int));
205 static int readable __P((int fd));
206
207 void usage();
208
209 /*
210  * Valid arguments.
211  */
212 static struct cmd {
213     char *cmd_name;
214     int num_args;
215     int (*cmd_func)();
216 } cmds[] = {
217     {"-all", 0, noopt},         /* Don't request/allow any options */
218     {"-ac", 0, noaccomp},       /* Disable Address/Control compress */
219     {"-am", 0, noasyncmap},     /* Disable asyncmap negotiation */
220     {"-as", 1, setasyncmap},    /* set the desired async map */
221     {"-d", 0, setdebug},        /* Increase debugging level */
222     {"-detach", 0, setnodetach}, /* don't fork */
223     {"-ip", 0, noip},           /* Disable IP and IPCP */
224     {"-mn", 0, nomagicnumber},  /* Disable magic number negotiation */
225     {"-mru", 0, nomru},         /* Disable mru negotiation */
226     {"-p", 0, setpassive},      /* Set passive mode */
227     {"-pc", 0, nopcomp},        /* Disable protocol field compress */
228     {"+ua", 1, setupapfile},    /* Get PAP user and password from file */
229     {"+pap", 0, reqpap},        /* Require PAP auth from peer */
230     {"-pap", 0, nopap},         /* Don't allow UPAP authentication with peer */
231     {"+chap", 0, reqchap},      /* Require CHAP authentication from peer */
232     {"-chap", 0, nochap},       /* Don't allow CHAP authentication with peer */
233     {"-vj", 0, setnovj},        /* disable VJ compression */
234     {"-vjccomp", 0, setnovjccomp}, /* disable VJ connection-ID compression */
235     {"vj-max-slots", 1, setvjslots}, /* Set maximum VJ header slots */
236     {"asyncmap", 1, setasyncmap}, /* set the desired async map */
237     {"escape", 1, setescape},   /* set chars to escape on transmission */
238     {"connect", 1, setconnector}, /* A program to set up a connection */
239     {"disconnect", 1, setdisconnector}, /* program to disconnect serial dev. */
240     {"welcome", 1, setwelcomer},/* Script to welcome client */
241     {"maxconnect", 1, setmaxconnect},  /* specify a maximum connect time */
242     {"crtscts", 0, setcrtscts}, /* set h/w flow control */
243     {"-crtscts", 0, setnocrtscts}, /* clear h/w flow control */
244     {"xonxoff", 0, setxonxoff}, /* set s/w flow control */
245     {"debug", 0, setdebug},     /* Increase debugging level */
246     {"kdebug", 1, setkdebug},   /* Enable kernel-level debugging */
247     {"domain", 1, setdomain},   /* Add given domain name to hostname*/
248     {"mru", 1, setmru},         /* Set MRU value for negotiation */
249     {"mtu", 1, setmtu},         /* Set our MTU */
250     {"netmask", 1, setnetmask}, /* set netmask */
251     {"passive", 0, setpassive}, /* Set passive mode */
252     {"silent", 0, setsilent},   /* Set silent mode */
253     {"modem", 0, setmodem},     /* Use modem control lines */
254     {"local", 0, setlocal},     /* Don't use modem control lines */
255     {"lock", 0, setlock},       /* Lock serial device (with lock file) */
256     {"name", 1, setname},       /* Set local name for authentication */
257     {"user", 1, setuser},       /* Set username for PAP auth with peer */
258     {"usehostname", 0, setusehostname}, /* Must use hostname for auth. */
259     {"remotename", 1, setremote}, /* Set remote name for authentication */
260     {"auth", 0, setauth},       /* Require authentication from peer */
261     {"file", 1, readfile},      /* Take options from a file */
262     {"defaultroute", 0, setdefaultroute}, /* Add default route */
263     {"-defaultroute", 0, setnodefaultroute}, /* disable defaultroute option */
264     {"proxyarp", 0, setproxyarp}, /* Add proxy ARP entry */
265     {"-proxyarp", 0, setnoproxyarp}, /* disable proxyarp option */
266     {"persist", 0, setpersist}, /* Keep on reopening connection after close */
267     {"demand", 0, setdemand},   /* Dial on demand */
268     {"login", 0, setdologin},   /* Use system password database for UPAP */
269     {"noipdefault", 0, setnoipdflt}, /* Don't use name for default IP adrs */
270     {"lcp-echo-failure", 1, setlcpechofails}, /* consecutive echo failures */
271     {"lcp-echo-interval", 1, setlcpechointv}, /* time for lcp echo events */
272     {"lcp-restart", 1, setlcptimeout}, /* Set timeout for LCP */
273     {"lcp-max-terminate", 1, setlcpterm}, /* Set max #xmits for term-reqs */
274     {"lcp-max-configure", 1, setlcpconf}, /* Set max #xmits for conf-reqs */
275     {"lcp-max-failure", 1, setlcpfails}, /* Set max #conf-naks for LCP */
276     {"ipcp-restart", 1, setipcptimeout}, /* Set timeout for IPCP */
277     {"ipcp-max-terminate", 1, setipcpterm}, /* Set max #xmits for term-reqs */
278     {"ipcp-max-configure", 1, setipcpconf}, /* Set max #xmits for conf-reqs */
279     {"ipcp-max-failure", 1, setipcpfails}, /* Set max #conf-naks for IPCP */
280     {"pap-restart", 1, setpaptimeout},  /* Set retransmit timeout for PAP */
281     {"pap-max-authreq", 1, setpapreqs}, /* Set max #xmits for auth-reqs */
282     {"pap-timeout", 1, setpapreqtime},  /* Set time limit for peer PAP auth. */
283     {"chap-restart", 1, setchaptimeout}, /* Set timeout for CHAP */
284     {"chap-max-challenge", 1, setchapchal}, /* Set max #xmits for challenge */
285     {"chap-interval", 1, setchapintv}, /* Set interval for rechallenge */
286     {"ipcp-accept-local", 0, setipcpaccl}, /* Accept peer's address for us */
287     {"ipcp-accept-remote", 0, setipcpaccr}, /* Accept peer's address for it */
288     {"bsdcomp", 1, setbsdcomp},         /* request BSD-Compress */
289     {"-bsdcomp", 0, setnobsdcomp},      /* don't allow BSD-Compress */
290     {"deflate", 1, setdeflate},         /* request Deflate compression */
291     {"-deflate", 0, setnodeflate},      /* don't allow Deflate compression */
292     {"predictor1", 0, setpred1comp},    /* request Predictor-1 */
293     {"-predictor1", 0, setnopred1comp}, /* don't allow Predictor-1 */
294     {"ipparam", 1, setipparam},         /* set ip script parameter */
295     {"papcrypt", 0, setpapcrypt},       /* PAP passwords encrypted */
296     {"idle", 1, setidle},               /* idle time limit (seconds) */
297     {"holdoff", 1, setholdoff},         /* set holdoff time (seconds) */
298
299 #ifdef IPX_CHANGE
300     {"ipx-network",          1, setipxnetwork}, /* IPX network number */
301     {"ipxcp-accept-network", 0, setipxanet},    /* Accept peer netowrk */
302     {"ipx-node",             1, setipxnode},    /* IPX node number */
303     {"ipxcp-accept-local",   0, setipxalcl},    /* Accept our address */
304     {"ipxcp-accept-remote",  0, setipxarmt},    /* Accept peer's address */
305     {"ipx-routing",          1, setipxrouter},  /* IPX routing proto number */
306     {"ipx-router-name",      1, setipxname},    /* IPX router name */
307     {"ipxcp-restart",        1, setipxcptimeout}, /* Set timeout for IPXCP */
308     {"ipxcp-max-terminate",  1, setipxcpterm},  /* max #xmits for term-reqs */
309     {"ipxcp-max-configure",  1, setipxcpconf},  /* max #xmits for conf-reqs */
310     {"ipxcp-max-failure",    1, setipxcpfails}, /* max #conf-naks for IPXCP */
311 #if 0
312     {"ipx-compression", 1, setipxcompression}, /* IPX compression number */
313 #endif
314     {"+ipx",                 0, setipxproto},   /* Enable IPXCP (and IPX) */
315     {"-ipx",                 0, resetipxproto}, /* Disable IPXCP (and IPX) */
316 #endif /* IPX_CHANGE */
317
318 #ifdef _linux_
319     {"idle-disconnect", 1, setidle}, /* seconds for disconnect of idle IP */
320 #endif
321
322 #ifdef USE_MS_DNS
323     {"ms-dns", 1, setdnsaddr},  /* DNS address(es) for the peer's use */
324 #endif
325
326     {NULL, 0, NULL}
327 };
328
329
330 #ifndef IMPLEMENTATION
331 #define IMPLEMENTATION ""
332 #endif
333
334 static char *usage_string = "\
335 pppd version %s patch level %d%s\n\
336 Usage: %s [ arguments ], where arguments are:\n\
337         <device>        Communicate over the named device\n\
338         <speed>         Set the baud rate to <speed>\n\
339         <loc>:<rem>     Set the local and/or remote interface IP\n\
340                         addresses.  Either one may be omitted.\n\
341         asyncmap <n>    Set the desired async map to hex <n>\n\
342         auth            Require authentication from peer\n\
343         connect <p>     Invoke shell command <p> to set up the serial line\n\
344         crtscts         Use hardware RTS/CTS flow control\n\
345         defaultroute    Add default route through interface\n\
346         file <f>        Take options from file <f>\n\
347         modem           Use modem control lines\n\
348         mru <n>         Set MRU value to <n> for negotiation\n\
349         netmask <n>     Set interface netmask to <n>\n\
350 See pppd(8) for more options.\n\
351 ";
352
353
354 /*
355  * parse_args - parse a string of arguments, from the command
356  * line or from a file.
357  */
358 int
359 parse_args(argc, argv)
360     int argc;
361     char **argv;
362 {
363     char *arg, *val;
364     struct cmd *cmdp;
365     int ret;
366
367     while (argc > 0) {
368         arg = *argv++;
369         --argc;
370
371         /*
372          * First see if it's a command.
373          */
374         for (cmdp = cmds; cmdp->cmd_name; cmdp++)
375             if (!strcmp(arg, cmdp->cmd_name))
376                 break;
377
378         if (cmdp->cmd_name != NULL) {
379             if (argc < cmdp->num_args) {
380                 fprintf(stderr, "Too few parameters for command %s\n", arg);
381                 return 0;
382             }
383             if (!(*cmdp->cmd_func)(argv))
384                 return 0;
385             argc -= cmdp->num_args;
386             argv += cmdp->num_args;
387
388         } else {
389             /*
390              * Maybe a tty name, speed or IP address?
391              */
392             if ((ret = setdevname(arg)) == 0
393                 && (ret = setspeed(arg)) == 0
394                 && (ret = setipaddr(arg)) == 0) {
395                 fprintf(stderr, "%s: unrecognized command\n", arg);
396                 usage();
397                 return 0;
398             }
399             if (ret < 0)        /* error */
400                 return 0;
401         }
402     }
403     return 1;
404 }
405
406 /*
407  * usage - print out a message telling how to use the program.
408  */
409 void
410 usage()
411 {
412     fprintf(stderr, usage_string, VERSION, PATCHLEVEL, IMPLEMENTATION,
413             progname);
414 }
415
416 /*
417  * options_from_file - Read a string of options from a file,
418  * and interpret them.
419  */
420 int
421 options_from_file(filename, must_exist, check_prot)
422     char *filename;
423     int must_exist;
424     int check_prot;
425 {
426     FILE *f;
427     int i, newline, ret;
428     struct cmd *cmdp;
429     char *argv[MAXARGS];
430     char args[MAXARGS][MAXWORDLEN];
431     char cmd[MAXWORDLEN];
432
433     if ((f = fopen(filename, "r")) == NULL) {
434         if (!must_exist && errno == ENOENT)
435             return 1;
436         perror(filename);
437         return 0;
438     }
439     if (check_prot && !readable(fileno(f))) {
440         fprintf(stderr, "%s: access denied\n", filename);
441         fclose(f);
442         return 0;
443     }
444
445     while (getword(f, cmd, &newline, filename)) {
446         /*
447          * First see if it's a command.
448          */
449         for (cmdp = cmds; cmdp->cmd_name; cmdp++)
450             if (!strcmp(cmd, cmdp->cmd_name))
451                 break;
452
453         if (cmdp->cmd_name != NULL) {
454             for (i = 0; i < cmdp->num_args; ++i) {
455                 if (!getword(f, args[i], &newline, filename)) {
456                     fprintf(stderr,
457                             "In file %s: too few parameters for command %s\n",
458                             filename, cmd);
459                     fclose(f);
460                     return 0;
461                 }
462                 argv[i] = args[i];
463             }
464             if (!(*cmdp->cmd_func)(argv)) {
465                 fclose(f);
466                 return 0;
467             }
468
469         } else {
470             /*
471              * Maybe a tty name, speed or IP address?
472              */
473             if ((ret = setdevname(cmd)) == 0
474                 && (ret = setspeed(cmd)) == 0
475                 && (ret = setipaddr(cmd)) == 0) {
476                 fprintf(stderr, "In file %s: unrecognized command %s\n",
477                         filename, cmd);
478                 fclose(f);
479                 return 0;
480             }
481             if (ret < 0)        /* error */
482                 return 0;
483         }
484     }
485     return 1;
486 }
487
488 /*
489  * options_from_user - See if the use has a ~/.ppprc file,
490  * and if so, interpret options from it.
491  */
492 int
493 options_from_user()
494 {
495     char *user, *path, *file;
496     int ret;
497     struct passwd *pw;
498
499     pw = getpwuid(getuid());
500     if (pw == NULL || (user = pw->pw_dir) == NULL || user[0] == 0)
501         return 1;
502     file = _PATH_USEROPT;
503     path = malloc(strlen(user) + strlen(file) + 2);
504     if (path == NULL)
505         novm("init file name");
506     strcpy(path, user);
507     strcat(path, "/");
508     strcat(path, file);
509     ret = options_from_file(path, 0, 1);
510     free(path);
511     return ret;
512 }
513
514 /*
515  * options_for_tty - See if an options file exists for the serial
516  * device, and if so, interpret options from it.
517  */
518 int
519 options_for_tty()
520 {
521     char *dev, *path, *p;
522     int ret;
523
524     dev = devnam;
525     if (strncmp(dev, "/dev/", 5) == 0)
526         dev += 5;
527     if (strcmp(dev, "tty") == 0)
528         return 1;               /* don't look for /etc/ppp/options.tty */
529     path = malloc(strlen(_PATH_TTYOPT) + strlen(dev) + 1);
530     if (path == NULL)
531         novm("tty init file name");
532     strcpy(path, _PATH_TTYOPT);
533     /* Turn slashes into dots, for Solaris case (e.g. /dev/term/a) */
534     for (p = path + strlen(path); *dev != 0; ++dev)
535         *p++ = (*dev == '/'? '.': *dev);
536     *p = 0;
537     ret = options_from_file(path, 0, 0);
538     free(path);
539     return ret;
540 }
541
542 /*
543  * readable - check if a file is readable by the real user.
544  */
545 static int
546 readable(fd)
547     int fd;
548 {
549     uid_t uid;
550     int ngroups, i;
551     struct stat sbuf;
552     GIDSET_TYPE groups[NGROUPS_MAX];
553
554     uid = getuid();
555     if (uid == 0)
556         return 1;
557     if (fstat(fd, &sbuf) != 0)
558         return 0;
559     if (sbuf.st_uid == uid)
560         return sbuf.st_mode & S_IRUSR;
561     if (sbuf.st_gid == getgid())
562         return sbuf.st_mode & S_IRGRP;
563     ngroups = getgroups(NGROUPS_MAX, groups);
564     for (i = 0; i < ngroups; ++i)
565         if (sbuf.st_gid == groups[i])
566             return sbuf.st_mode & S_IRGRP;
567     return sbuf.st_mode & S_IROTH;
568 }
569
570 /*
571  * Read a word from a file.
572  * Words are delimited by white-space or by quotes (" or ').
573  * Quotes, white-space and \ may be escaped with \.
574  * \<newline> is ignored.
575  */
576 int
577 getword(f, word, newlinep, filename)
578     FILE *f;
579     char *word;
580     int *newlinep;
581     char *filename;
582 {
583     int c, len, escape;
584     int quoted, comment;
585     int value, digit, got, n;
586
587 #define isoctal(c) ((c) >= '0' && (c) < '8')
588
589     *newlinep = 0;
590     len = 0;
591     escape = 0;
592     comment = 0;
593
594     /*
595      * First skip white-space and comments.
596      */
597     for (;;) {
598         c = getc(f);
599         if (c == EOF)
600             break;
601
602         /*
603          * A newline means the end of a comment; backslash-newline
604          * is ignored.  Note that we cannot have escape && comment.
605          */
606         if (c == '\n') {
607             if (!escape) {
608                 *newlinep = 1;
609                 comment = 0;
610             } else
611                 escape = 0;
612             continue;
613         }
614
615         /*
616          * Ignore characters other than newline in a comment.
617          */
618         if (comment)
619             continue;
620
621         /*
622          * If this character is escaped, we have a word start.
623          */
624         if (escape)
625             break;
626
627         /*
628          * If this is the escape character, look at the next character.
629          */
630         if (c == '\\') {
631             escape = 1;
632             continue;
633         }
634
635         /*
636          * If this is the start of a comment, ignore the rest of the line.
637          */
638         if (c == '#') {
639             comment = 1;
640             continue;
641         }
642
643         /*
644          * A non-whitespace character is the start of a word.
645          */
646         if (!isspace(c))
647             break;
648     }
649
650     /*
651      * Save the delimiter for quoted strings.
652      */
653     if (!escape && (c == '"' || c == '\'')) {
654         quoted = c;
655         c = getc(f);
656     } else
657         quoted = 0;
658
659     /*
660      * Process characters until the end of the word.
661      */
662     while (c != EOF) {
663         if (escape) {
664             /*
665              * This character is escaped: backslash-newline is ignored,
666              * various other characters indicate particular values
667              * as for C backslash-escapes.
668              */
669             escape = 0;
670             if (c == '\n') {
671                 c = getc(f);
672                 continue;
673             }
674
675             got = 0;
676             switch (c) {
677             case 'a':
678                 value = '\a';
679                 break;
680             case 'b':
681                 value = '\b';
682                 break;
683             case 'f':
684                 value = '\f';
685                 break;
686             case 'n':
687                 value = '\n';
688                 break;
689             case 'r':
690                 value = '\r';
691                 break;
692             case 's':
693                 value = ' ';
694                 break;
695             case 't':
696                 value = '\t';
697                 break;
698
699             default:
700                 if (isoctal(c)) {
701                     /*
702                      * \ddd octal sequence
703                      */
704                     value = 0;
705                     for (n = 0; n < 3 && isoctal(c); ++n) {
706                         value = (value << 3) + (c & 07);
707                         c = getc(f);
708                     }
709                     got = 1;
710                     break;
711                 }
712
713                 if (c == 'x') {
714                     /*
715                      * \x<hex_string> sequence
716                      */
717                     value = 0;
718                     c = getc(f);
719                     for (n = 0; n < 2 && isxdigit(c); ++n) {
720                         digit = toupper(c) - '0';
721                         if (digit > 10)
722                             digit += '0' + 10 - 'A';
723                         value = (value << 4) + digit;
724                         c = getc (f);
725                     }
726                     got = 1;
727                     break;
728                 }
729
730                 /*
731                  * Otherwise the character stands for itself.
732                  */
733                 value = c;
734                 break;
735             }
736
737             /*
738              * Store the resulting character for the escape sequence.
739              */
740             if (len < MAXWORDLEN-1)
741                 word[len] = value;
742             ++len;
743
744             if (!got)
745                 c = getc(f);
746             continue;
747
748         }
749
750         /*
751          * Not escaped: see if we've reached the end of the word.
752          */
753         if (quoted) {
754             if (c == quoted)
755                 break;
756         } else {
757             if (isspace(c) || c == '#') {
758                 ungetc (c, f);
759                 break;
760             }
761         }
762
763         /*
764          * Backslash starts an escape sequence.
765          */
766         if (c == '\\') {
767             escape = 1;
768             c = getc(f);
769             continue;
770         }
771
772         /*
773          * An ordinary character: store it in the word and get another.
774          */
775         if (len < MAXWORDLEN-1)
776             word[len] = c;
777         ++len;
778
779         c = getc(f);
780     }
781
782     /*
783      * End of the word: check for errors.
784      */
785     if (c == EOF) {
786         if (ferror(f)) {
787             if (errno == 0)
788                 errno = EIO;
789             perror(filename);
790             die(1);
791         }
792         /*
793          * If len is zero, then we didn't find a word before the
794          * end of the file.
795          */
796         if (len == 0)
797             return 0;
798     }
799
800     /*
801      * Warn if the word was too long, and append a terminating null.
802      */
803     if (len >= MAXWORDLEN) {
804         fprintf(stderr, "%s: warning: word in file %s too long (%.20s...)\n",
805                 progname, filename, word);
806         len = MAXWORDLEN - 1;
807     }
808     word[len] = 0;
809
810     return 1;
811
812 #undef isoctal
813
814 }
815
816 /*
817  * number_option - parse an unsigned numeric parameter for an option.
818  */
819 static int
820 number_option(str, valp, base)
821     char *str;
822     u_int32_t *valp;
823     int base;
824 {
825     char *ptr;
826
827     *valp = strtoul(str, &ptr, base);
828     if (ptr == str) {
829         fprintf(stderr, "%s: invalid number: %s\n", progname, str);
830         return 0;
831     }
832     return 1;
833 }
834
835
836 /*
837  * int_option - like number_option, but valp is int *,
838  * the base is assumed to be 0, and *valp is not changed
839  * if there is an error.
840  */
841 static int
842 int_option(str, valp)
843     char *str;
844     int *valp;
845 {
846     u_int32_t v;
847
848     if (!number_option(str, &v, 0))
849         return 0;
850     *valp = (int) v;
851     return 1;
852 }
853
854
855 /*
856  * The following procedures execute commands.
857  */
858
859 /*
860  * readfile - take commands from a file.
861  */
862 static int
863 readfile(argv)
864     char **argv;
865 {
866     return options_from_file(*argv, 1, 1);
867 }
868
869 /*
870  * setdebug - Set debug (command line argument).
871  */
872 static int
873 setdebug()
874 {
875     debug++;
876     return (1);
877 }
878
879 /*
880  * setkdebug - Set kernel debugging level.
881  */
882 static int
883 setkdebug(argv)
884     char **argv;
885 {
886     return int_option(*argv, &kdebugflag);
887 }
888
889 /*
890  * noopt - Disable all options.
891  */
892 static int
893 noopt()
894 {
895     BZERO((char *) &lcp_wantoptions[0], sizeof (struct lcp_options));
896     BZERO((char *) &lcp_allowoptions[0], sizeof (struct lcp_options));
897     BZERO((char *) &ipcp_wantoptions[0], sizeof (struct ipcp_options));
898     BZERO((char *) &ipcp_allowoptions[0], sizeof (struct ipcp_options));
899
900 #ifdef IPX_CHANGE
901     BZERO((char *) &ipxcp_wantoptions[0], sizeof (struct ipxcp_options));
902     BZERO((char *) &ipxcp_allowoptions[0], sizeof (struct ipxcp_options));
903 #endif /* IPX_CHANGE */
904
905     return (1);
906 }
907
908 /*
909  * noaccomp - Disable Address/Control field compression negotiation.
910  */
911 static int
912 noaccomp()
913 {
914     lcp_wantoptions[0].neg_accompression = 0;
915     lcp_allowoptions[0].neg_accompression = 0;
916     return (1);
917 }
918
919
920 /*
921  * noasyncmap - Disable async map negotiation.
922  */
923 static int
924 noasyncmap()
925 {
926     lcp_wantoptions[0].neg_asyncmap = 0;
927     lcp_allowoptions[0].neg_asyncmap = 0;
928     return (1);
929 }
930
931
932 /*
933  * noip - Disable IP and IPCP.
934  */
935 static int
936 noip()
937 {
938     ipcp_protent.enabled_flag = 0;
939     return (1);
940 }
941
942
943 /*
944  * nomagicnumber - Disable magic number negotiation.
945  */
946 static int
947 nomagicnumber()
948 {
949     lcp_wantoptions[0].neg_magicnumber = 0;
950     lcp_allowoptions[0].neg_magicnumber = 0;
951     return (1);
952 }
953
954
955 /*
956  * nomru - Disable mru negotiation.
957  */
958 static int
959 nomru()
960 {
961     lcp_wantoptions[0].neg_mru = 0;
962     lcp_allowoptions[0].neg_mru = 0;
963     return (1);
964 }
965
966
967 /*
968  * setmru - Set MRU for negotiation.
969  */
970 static int
971 setmru(argv)
972     char **argv;
973 {
974     u_int32_t mru;
975
976     if (!number_option(*argv, &mru, 0))
977         return 0;
978     lcp_wantoptions[0].mru = mru;
979     lcp_wantoptions[0].neg_mru = 1;
980     return (1);
981 }
982
983
984 /*
985  * setmru - Set the largest MTU we'll use.
986  */
987 static int
988 setmtu(argv)
989     char **argv;
990 {
991     u_int32_t mtu;
992
993     if (!number_option(*argv, &mtu, 0))
994         return 0;
995     if (mtu < MINMRU || mtu > MAXMRU) {
996         fprintf(stderr, "mtu option value of %ld is too %s\n", mtu,
997                 (mtu < MINMRU? "small": "large"));
998         return 0;
999     }
1000     lcp_allowoptions[0].mru = mtu;
1001     return (1);
1002 }
1003
1004
1005 /*
1006  * nopcomp - Disable Protocol field compression negotiation.
1007  */
1008 static int
1009 nopcomp()
1010 {
1011     lcp_wantoptions[0].neg_pcompression = 0;
1012     lcp_allowoptions[0].neg_pcompression = 0;
1013     return (1);
1014 }
1015
1016
1017 /*
1018  * setpassive - Set passive mode (don't give up if we time out sending
1019  * LCP configure-requests).
1020  */
1021 static int
1022 setpassive()
1023 {
1024     lcp_wantoptions[0].passive = 1;
1025     return (1);
1026 }
1027
1028
1029 /*
1030  * setsilent - Set silent mode (don't start sending LCP configure-requests
1031  * until we get one from the peer).
1032  */
1033 static int
1034 setsilent()
1035 {
1036     lcp_wantoptions[0].silent = 1;
1037     return 1;
1038 }
1039
1040
1041 /*
1042  * nopap - Disable PAP authentication with peer.
1043  */
1044 static int
1045 nopap()
1046 {
1047     lcp_allowoptions[0].neg_upap = 0;
1048     return (1);
1049 }
1050
1051
1052 /*
1053  * reqpap - Require PAP authentication from peer.
1054  */
1055 static int
1056 reqpap()
1057 {
1058     lcp_wantoptions[0].neg_upap = 1;
1059     auth_required = 1;
1060     return 1;
1061 }
1062
1063
1064 /*
1065  * setupapfile - specifies UPAP info for authenticating with peer.
1066  */
1067 static int
1068 setupapfile(argv)
1069     char **argv;
1070 {
1071     FILE * ufile;
1072     int l;
1073
1074     lcp_allowoptions[0].neg_upap = 1;
1075
1076     /* open user info file */
1077     if ((ufile = fopen(*argv, "r")) == NULL) {
1078         fprintf(stderr, "unable to open user login data file %s\n", *argv);
1079         return 0;
1080     }
1081     if (!readable(fileno(ufile))) {
1082         fprintf(stderr, "%s: access denied\n", *argv);
1083         return 0;
1084     }
1085     check_access(ufile, *argv);
1086
1087     /* get username */
1088     if (fgets(user, MAXNAMELEN - 1, ufile) == NULL
1089         || fgets(passwd, MAXSECRETLEN - 1, ufile) == NULL){
1090         fprintf(stderr, "Unable to read user login data file %s.\n", *argv);
1091         return 0;
1092     }
1093     fclose(ufile);
1094
1095     /* get rid of newlines */
1096     l = strlen(user);
1097     if (l > 0 && user[l-1] == '\n')
1098         user[l-1] = 0;
1099     l = strlen(passwd);
1100     if (l > 0 && passwd[l-1] == '\n')
1101         passwd[l-1] = 0;
1102
1103     return (1);
1104 }
1105
1106
1107 /*
1108  * nochap - Disable CHAP authentication with peer.
1109  */
1110 static int
1111 nochap()
1112 {
1113     lcp_allowoptions[0].neg_chap = 0;
1114     return (1);
1115 }
1116
1117
1118 /*
1119  * reqchap - Require CHAP authentication from peer.
1120  */
1121 static int
1122 reqchap()
1123 {
1124     lcp_wantoptions[0].neg_chap = 1;
1125     auth_required = 1;
1126     return (1);
1127 }
1128
1129
1130 /*
1131  * setnovj - disable vj compression
1132  */
1133 static int
1134 setnovj()
1135 {
1136     ipcp_wantoptions[0].neg_vj = 0;
1137     ipcp_allowoptions[0].neg_vj = 0;
1138     return (1);
1139 }
1140
1141
1142 /*
1143  * setnovjccomp - disable VJ connection-ID compression
1144  */
1145 static int
1146 setnovjccomp()
1147 {
1148     ipcp_wantoptions[0].cflag = 0;
1149     ipcp_allowoptions[0].cflag = 0;
1150     return 1;
1151 }
1152
1153
1154 /*
1155  * setvjslots - set maximum number of connection slots for VJ compression
1156  */
1157 static int
1158 setvjslots(argv)
1159     char **argv;
1160 {
1161     int value;
1162
1163     if (!int_option(*argv, &value))
1164         return 0;
1165     if (value < 2 || value > 16) {
1166         fprintf(stderr, "pppd: vj-max-slots value must be between 2 and 16\n");
1167         return 0;
1168     }
1169     ipcp_wantoptions [0].maxslotindex =
1170         ipcp_allowoptions[0].maxslotindex = value - 1;
1171     return 1;
1172 }
1173
1174
1175 /*
1176  * setconnector - Set a program to connect to a serial line
1177  */
1178 static int
1179 setconnector(argv)
1180     char **argv;
1181 {
1182     connector = strdup(*argv);
1183     if (connector == NULL)
1184         novm("connect script");
1185   
1186     return (1);
1187 }
1188
1189 /*
1190  * setdisconnector - Set a program to disconnect from the serial line
1191  */
1192 static int
1193 setdisconnector(argv)
1194     char **argv;
1195 {
1196     disconnector = strdup(*argv);
1197     if (disconnector == NULL)
1198         novm("disconnect script");
1199   
1200     return (1);
1201 }
1202
1203 /*
1204  * setwelcomer - Set a program to welcome a client after connection
1205  */
1206 static int
1207 setwelcomer(argv)
1208     char **argv;
1209 {
1210     welcomer = strdup(*argv);
1211     if (welcomer == NULL)
1212         novm("welcome script");
1213   
1214     return (1);
1215 }
1216
1217 /*
1218  * setmaxconnect - Set the maximum connect time
1219  */
1220 static int
1221 setmaxconnect(argv)
1222     char **argv;
1223 {
1224     int value;
1225
1226     if (!int_option(*argv, &value))
1227       return 0;
1228     if (value < 0) {
1229       fprintf(stderr, "pppd: maxconnect time must be positive\n");
1230       return 0;
1231     }
1232     maxconnect = value;
1233     return 1;
1234 }
1235
1236 /*
1237  * setdomain - Set domain name to append to hostname 
1238  */
1239 static int
1240 setdomain(argv)
1241     char **argv;
1242 {
1243     gethostname(hostname, MAXNAMELEN);
1244     if (**argv != 0) {
1245         if (**argv != '.')
1246             strncat(hostname, ".", MAXNAMELEN - strlen(hostname));
1247         strncat(hostname, *argv, MAXNAMELEN - strlen(hostname));
1248     }
1249     hostname[MAXNAMELEN-1] = 0;
1250     return (1);
1251 }
1252
1253
1254 /*
1255  * setasyncmap - add bits to asyncmap (what we request peer to escape).
1256  */
1257 static int
1258 setasyncmap(argv)
1259     char **argv;
1260 {
1261     u_int32_t asyncmap;
1262
1263     if (!number_option(*argv, &asyncmap, 16))
1264         return 0;
1265     lcp_wantoptions[0].asyncmap |= asyncmap;
1266     lcp_wantoptions[0].neg_asyncmap = 1;
1267     return(1);
1268 }
1269
1270
1271 /*
1272  * setescape - add chars to the set we escape on transmission.
1273  */
1274 static int
1275 setescape(argv)
1276     char **argv;
1277 {
1278     int n, ret;
1279     char *p, *endp;
1280
1281     p = *argv;
1282     ret = 1;
1283     while (*p) {
1284         n = strtol(p, &endp, 16);
1285         if (p == endp) {
1286             fprintf(stderr, "%s: invalid hex number: %s\n", progname, p);
1287             return 0;
1288         }
1289         p = endp;
1290         if (n < 0 || 0x20 <= n && n <= 0x3F || n == 0x5E || n > 0xFF) {
1291             fprintf(stderr, "%s: can't escape character 0x%x\n", progname, n);
1292             ret = 0;
1293         } else
1294             xmit_accm[0][n >> 5] |= 1 << (n & 0x1F);
1295         while (*p == ',' || *p == ' ')
1296             ++p;
1297     }
1298     return ret;
1299 }
1300
1301
1302 /*
1303  * setspeed - Set the speed.
1304  */
1305 static int
1306 setspeed(arg)
1307     char *arg;
1308 {
1309     char *ptr;
1310     int spd;
1311
1312     spd = strtol(arg, &ptr, 0);
1313     if (ptr == arg || *ptr != 0 || spd == 0)
1314         return 0;
1315     inspeed = spd;
1316     return 1;
1317 }
1318
1319
1320 /*
1321  * setdevname - Set the device name.
1322  */
1323 int
1324 setdevname(cp)
1325     char *cp;
1326 {
1327     struct stat statbuf;
1328     char *tty, *ttyname();
1329     char dev[MAXPATHLEN];
1330   
1331     if (strncmp("/dev/", cp, 5) != 0) {
1332         strcpy(dev, "/dev/");
1333         strncat(dev, cp, MAXPATHLEN - 5);
1334         dev[MAXPATHLEN-1] = 0;
1335         cp = dev;
1336     }
1337
1338     /*
1339      * Check if there is a device by this name.
1340      */
1341     if (stat(cp, &statbuf) < 0) {
1342         if (errno == ENOENT)
1343             return 0;
1344         syslog(LOG_ERR, cp);
1345         return -1;
1346     }
1347   
1348     (void) strncpy(devnam, cp, MAXPATHLEN);
1349     devnam[MAXPATHLEN-1] = 0;
1350     default_device = FALSE;
1351   
1352     return 1;
1353 }
1354
1355
1356 /*
1357  * setipaddr - Set the IP address
1358  */
1359 int
1360 setipaddr(arg)
1361     char *arg;
1362 {
1363     struct hostent *hp;
1364     char *colon;
1365     u_int32_t local, remote;
1366     ipcp_options *wo = &ipcp_wantoptions[0];
1367   
1368     /*
1369      * IP address pair separated by ":".
1370      */
1371     if ((colon = strchr(arg, ':')) == NULL)
1372         return 0;
1373   
1374     /*
1375      * If colon first character, then no local addr.
1376      */
1377     if (colon != arg) {
1378         *colon = '\0';
1379         if ((local = inet_addr(arg)) == -1) {
1380             if ((hp = gethostbyname(arg)) == NULL) {
1381                 fprintf(stderr, "unknown host: %s\n", arg);
1382                 return -1;
1383             } else {
1384                 local = *(u_int32_t *)hp->h_addr;
1385                 if (our_name[0] == 0) {
1386                     strncpy(our_name, arg, MAXNAMELEN);
1387                     our_name[MAXNAMELEN-1] = 0;
1388                 }
1389             }
1390         }
1391         if (bad_ip_adrs(local)) {
1392             fprintf(stderr, "bad local IP address %s\n", ip_ntoa(local));
1393             return -1;
1394         }
1395         if (local != 0)
1396             wo->ouraddr = local;
1397         *colon = ':';
1398     }
1399   
1400     /*
1401      * If colon last character, then no remote addr.
1402      */
1403     if (*++colon != '\0') {
1404         if ((remote = inet_addr(colon)) == -1) {
1405             if ((hp = gethostbyname(colon)) == NULL) {
1406                 fprintf(stderr, "unknown host: %s\n", colon);
1407                 return -1;
1408             } else {
1409                 remote = *(u_int32_t *)hp->h_addr;
1410                 if (remote_name[0] == 0) {
1411                     strncpy(remote_name, colon, MAXNAMELEN);
1412                     remote_name[MAXNAMELEN-1] = 0;
1413                 }
1414             }
1415         }
1416         if (bad_ip_adrs(remote)) {
1417             fprintf(stderr, "bad remote IP address %s\n", ip_ntoa(remote));
1418             return -1;
1419         }
1420         if (remote != 0)
1421             wo->hisaddr = remote;
1422     }
1423
1424     return 1;
1425 }
1426
1427
1428 /*
1429  * setnoipdflt - disable setipdefault()
1430  */
1431 static int
1432 setnoipdflt()
1433 {
1434     disable_defaultip = 1;
1435     return 1;
1436 }
1437
1438
1439 /*
1440  * setipcpaccl - accept peer's idea of our address
1441  */
1442 static int
1443 setipcpaccl()
1444 {
1445     ipcp_wantoptions[0].accept_local = 1;
1446     return 1;
1447 }
1448
1449
1450 /*
1451  * setipcpaccr - accept peer's idea of its address
1452  */
1453 static int
1454 setipcpaccr()
1455 {
1456     ipcp_wantoptions[0].accept_remote = 1;
1457     return 1;
1458 }
1459
1460
1461 /*
1462  * setnetmask - set the netmask to be used on the interface.
1463  */
1464 static int
1465 setnetmask(argv)
1466     char **argv;
1467 {
1468     u_int32_t mask;
1469
1470     if ((mask = inet_addr(*argv)) == -1 || (netmask & ~mask) != 0) {
1471         fprintf(stderr, "Invalid netmask %s\n", *argv);
1472         return 0;
1473     }
1474
1475     netmask = mask;
1476     return (1);
1477 }
1478
1479 static int
1480 setcrtscts()
1481 {
1482     crtscts = 1;
1483     return (1);
1484 }
1485
1486 static int
1487 setnocrtscts()
1488 {
1489     crtscts = -1;
1490     return (1);
1491 }
1492
1493 static int
1494 setxonxoff()
1495 {
1496     lcp_wantoptions[0].asyncmap |= 0x000A0000;  /* escape ^S and ^Q */
1497     lcp_wantoptions[0].neg_asyncmap = 1;
1498
1499     crtscts = -2;
1500     return (1);
1501 }
1502
1503 static int
1504 setnodetach()
1505 {
1506     nodetach = 1;
1507     return (1);
1508 }
1509
1510 static int
1511 setdemand()
1512 {
1513     demand = 1;
1514     return 1;
1515 }
1516
1517 static int
1518 setmodem()
1519 {
1520     modem = 1;
1521     return 1;
1522 }
1523
1524 static int
1525 setlocal()
1526 {
1527     modem = 0;
1528     return 1;
1529 }
1530
1531 static int
1532 setlock()
1533 {
1534     lockflag = 1;
1535     return 1;
1536 }
1537
1538 static int
1539 setusehostname()
1540 {
1541     usehostname = 1;
1542     return 1;
1543 }
1544
1545 static int
1546 setname(argv)
1547     char **argv;
1548 {
1549     if (our_name[0] == 0) {
1550         strncpy(our_name, argv[0], MAXNAMELEN);
1551         our_name[MAXNAMELEN-1] = 0;
1552     }
1553     return 1;
1554 }
1555
1556 static int
1557 setuser(argv)
1558     char **argv;
1559 {
1560     strncpy(user, argv[0], MAXNAMELEN);
1561     user[MAXNAMELEN-1] = 0;
1562     return 1;
1563 }
1564
1565 static int
1566 setremote(argv)
1567     char **argv;
1568 {
1569     strncpy(remote_name, argv[0], MAXNAMELEN);
1570     remote_name[MAXNAMELEN-1] = 0;
1571     return 1;
1572 }
1573
1574 static int
1575 setauth()
1576 {
1577     auth_required = 1;
1578     return 1;
1579 }
1580
1581 static int
1582 setdefaultroute()
1583 {
1584     if (!ipcp_allowoptions[0].default_route) {
1585         fprintf(stderr, "%s: defaultroute option is disabled\n", progname);
1586         return 0;
1587     }
1588     ipcp_wantoptions[0].default_route = 1;
1589     return 1;
1590 }
1591
1592 static int
1593 setnodefaultroute()
1594 {
1595     ipcp_allowoptions[0].default_route = 0;
1596     ipcp_wantoptions[0].default_route = 0;
1597     return 1;
1598 }
1599
1600 static int
1601 setproxyarp()
1602 {
1603     if (!ipcp_allowoptions[0].proxy_arp) {
1604         fprintf(stderr, "%s: proxyarp option is disabled\n", progname);
1605         return 0;
1606     }
1607     ipcp_wantoptions[0].proxy_arp = 1;
1608     return 1;
1609 }
1610
1611 static int
1612 setnoproxyarp()
1613 {
1614     ipcp_wantoptions[0].proxy_arp = 0;
1615     ipcp_allowoptions[0].proxy_arp = 0;
1616     return 1;
1617 }
1618
1619 static int
1620 setpersist()
1621 {
1622     persist = 1;
1623     return 1;
1624 }
1625
1626 static int
1627 setdologin()
1628 {
1629     uselogin = 1;
1630     return 1;
1631 }
1632
1633 /*
1634  * Functions to set the echo interval for modem-less monitors
1635  */
1636
1637 static int
1638 setlcpechointv(argv)
1639     char **argv;
1640 {
1641     return int_option(*argv, &lcp_echo_interval);
1642 }
1643
1644 static int
1645 setlcpechofails(argv)
1646     char **argv;
1647 {
1648     return int_option(*argv, &lcp_echo_fails);
1649 }
1650
1651 /*
1652  * Functions to set timeouts, max transmits, etc.
1653  */
1654 static int
1655 setlcptimeout(argv)
1656     char **argv;
1657 {
1658     return int_option(*argv, &lcp_fsm[0].timeouttime);
1659 }
1660
1661 static int
1662 setlcpterm(argv)
1663     char **argv;
1664 {
1665     return int_option(*argv, &lcp_fsm[0].maxtermtransmits);
1666 }
1667
1668 static int
1669 setlcpconf(argv)
1670     char **argv;
1671 {
1672     return int_option(*argv, &lcp_fsm[0].maxconfreqtransmits);
1673 }
1674
1675 static int
1676 setlcpfails(argv)
1677     char **argv;
1678 {
1679     return int_option(*argv, &lcp_fsm[0].maxnakloops);
1680 }
1681
1682 static int
1683 setipcptimeout(argv)
1684     char **argv;
1685 {
1686     return int_option(*argv, &ipcp_fsm[0].timeouttime);
1687 }
1688
1689 static int
1690 setipcpterm(argv)
1691     char **argv;
1692 {
1693     return int_option(*argv, &ipcp_fsm[0].maxtermtransmits);
1694 }
1695
1696 static int
1697 setipcpconf(argv)
1698     char **argv;
1699 {
1700     return int_option(*argv, &ipcp_fsm[0].maxconfreqtransmits);
1701 }
1702
1703 static int
1704 setipcpfails(argv)
1705     char **argv;
1706 {
1707     return int_option(*argv, &lcp_fsm[0].maxnakloops);
1708 }
1709
1710 static int
1711 setpaptimeout(argv)
1712     char **argv;
1713 {
1714     return int_option(*argv, &upap[0].us_timeouttime);
1715 }
1716
1717 static int
1718 setpapreqtime(argv)
1719     char **argv;
1720 {
1721     return int_option(*argv, &upap[0].us_reqtimeout);
1722 }
1723
1724 static int
1725 setpapreqs(argv)
1726     char **argv;
1727 {
1728     return int_option(*argv, &upap[0].us_maxtransmits);
1729 }
1730
1731 static int
1732 setchaptimeout(argv)
1733     char **argv;
1734 {
1735     return int_option(*argv, &chap[0].timeouttime);
1736 }
1737
1738 static int
1739 setchapchal(argv)
1740     char **argv;
1741 {
1742     return int_option(*argv, &chap[0].max_transmits);
1743 }
1744
1745 static int
1746 setchapintv(argv)
1747     char **argv;
1748 {
1749     return int_option(*argv, &chap[0].chal_interval);
1750 }
1751
1752 static int
1753 setbsdcomp(argv)
1754     char **argv;
1755 {
1756     int rbits, abits;
1757     char *str, *endp;
1758
1759     str = *argv;
1760     abits = rbits = strtol(str, &endp, 0);
1761     if (endp != str && *endp == ',') {
1762         str = endp + 1;
1763         abits = strtol(str, &endp, 0);
1764     }
1765     if (*endp != 0 || endp == str) {
1766         fprintf(stderr, "%s: invalid argument format for bsdcomp option\n",
1767                 progname);
1768         return 0;
1769     }
1770     if (rbits != 0 && (rbits < BSD_MIN_BITS || rbits > BSD_MAX_BITS)
1771         || abits != 0 && (abits < BSD_MIN_BITS || abits > BSD_MAX_BITS)) {
1772         fprintf(stderr, "%s: bsdcomp option values must be 0 or %d .. %d\n",
1773                 progname, BSD_MIN_BITS, BSD_MAX_BITS);
1774         return 0;
1775     }
1776     if (rbits > 0) {
1777         ccp_wantoptions[0].bsd_compress = 1;
1778         ccp_wantoptions[0].bsd_bits = rbits;
1779     } else
1780         ccp_wantoptions[0].bsd_compress = 0;
1781     if (abits > 0) {
1782         ccp_allowoptions[0].bsd_compress = 1;
1783         ccp_allowoptions[0].bsd_bits = abits;
1784     } else
1785         ccp_allowoptions[0].bsd_compress = 0;
1786     return 1;
1787 }
1788
1789 static int
1790 setnobsdcomp()
1791 {
1792     ccp_wantoptions[0].bsd_compress = 0;
1793     ccp_allowoptions[0].bsd_compress = 0;
1794     return 1;
1795 }
1796
1797 static int
1798 setdeflate(argv)
1799     char **argv;
1800 {
1801     int rbits, abits;
1802     char *str, *endp;
1803
1804     str = *argv;
1805     abits = rbits = strtol(str, &endp, 0);
1806     if (endp != str && *endp == ',') {
1807         str = endp + 1;
1808         abits = strtol(str, &endp, 0);
1809     }
1810     if (*endp != 0 || endp == str) {
1811         fprintf(stderr, "%s: invalid argument format for deflate option\n",
1812                 progname);
1813         return 0;
1814     }
1815     if (rbits != 0 && (rbits < DEFLATE_MIN_SIZE || rbits > DEFLATE_MAX_SIZE)
1816         || abits != 0 && (abits < DEFLATE_MIN_SIZE
1817                           || abits > DEFLATE_MAX_SIZE)) {
1818         fprintf(stderr, "%s: deflate option values must be 0 or %d .. %d\n",
1819                 progname, DEFLATE_MIN_SIZE, DEFLATE_MAX_SIZE);
1820         return 0;
1821     }
1822     if (rbits > 0) {
1823         ccp_wantoptions[0].deflate = 1;
1824         ccp_wantoptions[0].deflate_size = rbits;
1825     } else
1826         ccp_wantoptions[0].deflate = 0;
1827     if (abits > 0) {
1828         ccp_allowoptions[0].deflate = 1;
1829         ccp_allowoptions[0].deflate_size = abits;
1830     } else
1831         ccp_allowoptions[0].deflate = 0;
1832     return 1;
1833 }
1834
1835 static int
1836 setnodeflate()
1837 {
1838     ccp_wantoptions[0].deflate = 0;
1839     ccp_allowoptions[0].deflate = 0;
1840     return 1;
1841 }
1842
1843 static int
1844 setpred1comp()
1845 {
1846     ccp_wantoptions[0].predictor_1 = 1;
1847     ccp_allowoptions[0].predictor_1 = 1;
1848     return 1;
1849 }
1850
1851 static int
1852 setnopred1comp()
1853 {
1854     ccp_wantoptions[0].predictor_1 = 0;
1855     ccp_allowoptions[0].predictor_1 = 0;
1856     return 1;
1857 }
1858
1859 static int
1860 setipparam(argv)
1861     char **argv;
1862 {
1863     ipparam = strdup(*argv);
1864     if (ipparam == NULL)
1865         novm("ipparam string");
1866
1867     return 1;
1868 }
1869
1870 static int
1871 setpapcrypt()
1872 {
1873     cryptpap = 1;
1874     return 1;
1875 }
1876
1877 static int
1878 setidle(argv)
1879     char **argv;
1880 {
1881     return int_option(*argv, &idle_time_limit);
1882 }
1883
1884 static int
1885 setholdoff(argv)
1886     char **argv;
1887 {
1888     return int_option(*argv, &holdoff);
1889 }
1890
1891 #ifdef IPX_CHANGE
1892 static int
1893 setipxrouter (argv)
1894     char **argv;
1895 {
1896     ipxcp_wantoptions[0].neg_router  = 1;
1897     ipxcp_allowoptions[0].neg_router = 1;
1898     return int_option(*argv, &ipxcp_wantoptions[0].router); 
1899 }
1900
1901 static int
1902 setipxname (argv)
1903     char **argv;
1904 {
1905     char *dest = ipxcp_wantoptions[0].name;
1906     char *src  = *argv;
1907     int  count;
1908     char ch;
1909
1910     ipxcp_wantoptions[0].neg_name  = 1;
1911     ipxcp_allowoptions[0].neg_name = 1;
1912     memset (dest, '\0', sizeof (ipxcp_wantoptions[0].name));
1913
1914     count = 0;
1915     while (*src) {
1916         ch = *src++;
1917         if (! isalnum (ch) && ch != '_') {
1918             fprintf (stderr,
1919                      "%s: IPX router name must be alphanumeric or _\n",
1920                      progname);
1921             return 0;
1922         }
1923
1924         if (count >= sizeof (ipxcp_wantoptions[0].name)) {
1925             fprintf (stderr,
1926                      "%s: IPX router name is limited to %d characters\n",
1927                      progname,
1928                      sizeof (ipxcp_wantoptions[0].name) - 1);
1929             return 0;
1930         }
1931
1932         dest[count++] = toupper (ch);
1933     }
1934
1935     return 1;
1936 }
1937
1938 static int
1939 setipxcptimeout (argv)
1940     char **argv;
1941 {
1942     return int_option(*argv, &ipxcp_fsm[0].timeouttime);
1943 }
1944
1945 static int
1946 setipxcpterm (argv)
1947     char **argv;
1948 {
1949     return int_option(*argv, &ipxcp_fsm[0].maxtermtransmits);
1950 }
1951
1952 static int
1953 setipxcpconf (argv)
1954     char **argv;
1955 {
1956     return int_option(*argv, &ipxcp_fsm[0].maxconfreqtransmits);
1957 }
1958
1959 static int
1960 setipxcpfails (argv)
1961     char **argv;
1962 {
1963     return int_option(*argv, &ipxcp_fsm[0].maxnakloops);
1964 }
1965
1966 static int
1967 setipxnetwork(argv)
1968     char **argv;
1969 {
1970     ipxcp_wantoptions[0].neg_nn = 1;
1971     return int_option(*argv, &ipxcp_wantoptions[0].our_network); 
1972 }
1973
1974 static int
1975 setipxanet()
1976 {
1977     ipxcp_wantoptions[0].accept_network = 1;
1978     ipxcp_allowoptions[0].accept_network = 1;
1979 }
1980
1981 static int
1982 setipxalcl()
1983 {
1984     ipxcp_wantoptions[0].accept_local = 1;
1985     ipxcp_allowoptions[0].accept_local = 1;
1986 }
1987
1988 static int
1989 setipxarmt()
1990 {
1991     ipxcp_wantoptions[0].accept_remote = 1;
1992     ipxcp_allowoptions[0].accept_remote = 1;
1993 }
1994
1995 static u_char *
1996 setipxnodevalue(src,dst)
1997 u_char *src, *dst;
1998 {
1999     int indx;
2000     int item;
2001
2002     for (;;) {
2003         if (!isxdigit (*src))
2004             break;
2005         
2006         for (indx = 0; indx < 5; ++indx) {
2007             dst[indx] <<= 4;
2008             dst[indx] |= (dst[indx + 1] >> 4) & 0x0F;
2009         }
2010
2011         item = toupper (*src) - '0';
2012         if (item > 9)
2013             item -= 7;
2014
2015         dst[5] = (dst[5] << 4) | item;
2016         ++src;
2017     }
2018     return src;
2019 }
2020
2021 static int
2022 setipxnode(argv)
2023     char **argv;
2024 {
2025     char *end;
2026
2027     memset (&ipxcp_wantoptions[0].our_node[0], 0, 6);
2028     memset (&ipxcp_wantoptions[0].his_node[0], 0, 6);
2029
2030     end = setipxnodevalue (*argv, &ipxcp_wantoptions[0].our_node[0]);
2031     if (*end == ':')
2032         end = setipxnodevalue (++end, &ipxcp_wantoptions[0].his_node[0]);
2033
2034     if (*end == '\0') {
2035         ipxcp_wantoptions[0].neg_node = 1;
2036         return 1;
2037     }
2038
2039     fprintf(stderr, "%s: invalid argument for ipx-node option\n",
2040             progname);
2041     return 0;
2042 }
2043
2044 static int
2045 setipxproto()
2046 {
2047     ipx_enabled = 1;            /* Enable IPXCP and IPX protocol */
2048     return 1;
2049 }
2050
2051 static int
2052 resetipxproto()
2053 {
2054     ipx_enabled = 0;            /* Disable IPXCP and IPX protocol */
2055     return 1;
2056 }
2057 #endif /* IPX_CHANGE */
2058
2059 #ifdef USE_MS_DNS
2060 /*
2061  * setdnsaddr - set the dns address(es)
2062  */
2063
2064 static int
2065 setdnsaddr(argv)
2066     char **argv;
2067 {
2068     u_int32_t dns;
2069     struct hostent *hp;
2070
2071     dns = inet_addr(*argv);
2072     if (dns == -1) {
2073         if ((hp = gethostbyname(*argv)) == NULL) {
2074             fprintf(stderr, "Invalid DNS Address %s\n", *argv);
2075             return 0;
2076         }
2077         dns = *(u_int32_t *)hp->h_addr;
2078     }
2079
2080     if (ipcp_allowoptions[0].dnsaddr[0] == 0) {
2081         ipcp_allowoptions[0].dnsaddr[0] = dns;
2082     } else {
2083         ipcp_allowoptions[0].dnsaddr[1] = dns;
2084     }
2085
2086     return (1);
2087 }
2088 #endif /* USE_MS_DNS */