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.43 1998/09/04 18:49:15 christos 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 #ifdef CBCP_SUPPORT
  54 #include "cbcp.h"
  55 #endif
  56
  57 #ifdef IPX_CHANGE
  58 #include "ipxcp.h"
  59 #endif /* IPX_CHANGE */
  60
  61 #include <net/ppp-comp.h>
  62
  63 #define FALSE   0
  64 #define TRUE    1
  65
  66 #if defined(ultrix) || defined(NeXT)
  67 char *strdup __P((char *));
  68 #endif
  69
  70 #ifndef GIDSET_TYPE
  71 #define GIDSET_TYPE     gid_t
  72 #endif
  73
  74 /*
  75  * Option variables and default values.
  76  */
  77 #ifdef PPP_FILTER
  78 int     dflag = 0;              /* Tell libpcap we want debugging */
  79 #endif
  80 int     debug = 0;              /* Debug flag */
  81 int     kdebugflag = 0;         /* Tell kernel to print debug messages */
  82 int     default_device = 1;     /* Using /dev/tty or equivalent */
  83 char    devnam[MAXPATHLEN] = "/dev/tty";        /* Device name */
  84 int     crtscts = 0;            /* Use hardware flow control */
  85 int     modem = 1;              /* Use modem control lines */
  86 int     inspeed = 0;            /* Input/Output speed requested */
  87 u_int32_t netmask = 0;          /* IP netmask to set on interface */
  88 int     lockflag = 0;           /* Create lock file to lock the serial dev */
  89 int     nodetach = 0;           /* Don't detach from controlling tty */
  90 char    *connector = NULL;      /* Script to establish physical link */
  91 char    *disconnector = NULL;   /* Script to disestablish physical link */
  92 char    *welcomer = NULL;       /* Script to run after phys link estab. */
  93 int     maxconnect = 0;         /* Maximum connect time */
  94 char    user[MAXNAMELEN];       /* Username for PAP */
  95 char    passwd[MAXSECRETLEN];   /* Password for PAP */
  96 int     auth_required = 0;      /* Peer is required to authenticate */
  97 int     defaultroute = 0;       /* assign default route through interface */
  98 int     proxyarp = 0;           /* Set up proxy ARP entry for peer */
  99 int     persist = 0;            /* Reopen link after it goes down */
 100 int     uselogin = 0;           /* Use /etc/passwd for checking PAP */
 101 int     lcp_echo_interval = 0;  /* Interval between LCP echo-requests */
 102 int     lcp_echo_fails = 0;     /* Tolerance to unanswered echo-requests */
 103 char    our_name[MAXNAMELEN];   /* Our name for authentication purposes */
 104 char    remote_name[MAXNAMELEN]; /* Peer's name for authentication */
 105 int     explicit_remote = 0;    /* User specified explicit remote name */
 106 int     usehostname = 0;        /* Use hostname for our_name */
 107 int     disable_defaultip = 0;  /* Don't use hostname for default IP adrs */
 108 int     demand = 0;             /* do dial-on-demand */
 109 char    *ipparam = NULL;        /* Extra parameter for ip up/down scripts */
 110 int     cryptpap;               /* Passwords in pap-secrets are encrypted */
 111 int     idle_time_limit = 0;    /* Disconnect if idle for this many seconds */
 112 int     holdoff = 30;           /* # seconds to pause before reconnecting */
 113 int     refuse_pap = 0;         /* Set to say we won't do PAP */
 114 int     refuse_chap = 0;        /* Set to say we won't do CHAP */
 115
 116 #ifdef MSLANMAN
 117 int     ms_lanman = 0;          /* Nonzero if use LanMan password instead of NT */
 118                                 /* Has meaning only with MS-CHAP challenges */
 119 #endif
 120
 121 struct option_info auth_req_info;
 122 struct option_info connector_info;
 123 struct option_info disconnector_info;
 124 struct option_info welcomer_info;
 125 struct option_info devnam_info;
 126 #ifdef PPP_FILTER
 127 struct  bpf_program pass_filter;/* Filter program for packets to pass */
 128 struct  bpf_program active_filter; /* Filter program for link-active pkts */
 129 pcap_t  pc;                     /* Fake struct pcap so we can compile expr */
 130 #endif
 131
 132 /*
 133  * Prototypes
 134  */
 135 static int setdevname __P((char *, int));
 136 static int setipaddr __P((char *));
 137 static int setspeed __P((char *));
 138 static int setdebug __P((char **));
 139 static int setkdebug __P((char **));
 140 static int setpassive __P((char **));
 141 static int setsilent __P((char **));
 142 static int noopt __P((char **));
 143 static int setnovj __P((char **));
 144 static int setnovjccomp __P((char **));
 145 static int setvjslots __P((char **));
 146 static int reqpap __P((char **));
 147 static int nopap __P((char **));
 148 #ifdef OLD_OPTIONS
 149 static int setupapfile __P((char **));
 150 #endif
 151 static int nochap __P((char **));
 152 static int reqchap __P((char **));
 153 static int noaccomp __P((char **));
 154 static int noasyncmap __P((char **));
 155 static int noip __P((char **));
 156 static int nomagicnumber __P((char **));
 157 static int setasyncmap __P((char **));
 158 static int setescape __P((char **));
 159 static int setmru __P((char **));
 160 static int setmtu __P((char **));
 161 #ifdef CBCP_SUPPORT
 162 static int setcbcp __P((char **));
 163 #endif
 164 static int nomru __P((char **));
 165 static int nopcomp __P((char **));
 166 static int setconnector __P((char **));
 167 static int setdisconnector __P((char **));
 168 static int setwelcomer __P((char **));
 169 static int setmaxconnect __P((char **));
 170 static int setdomain __P((char **));
 171 static int setnetmask __P((char **));
 172 static int setcrtscts __P((char **));
 173 static int setnocrtscts __P((char **));
 174 static int setcdtrcts __P((char **));
 175 static int setxonxoff __P((char **));
 176 static int setnodetach __P((char **));
 177 static int setupdetach __P((char **));
 178 static int setmodem __P((char **));
 179 static int setlocal __P((char **));
 180 static int setlock __P((char **));
 181 static int setname __P((char **));
 182 static int setuser __P((char **));
 183 static int setremote __P((char **));
 184 static int setauth __P((char **));
 185 static int setnoauth __P((char **));
 186 static int readfile __P((char **));
 187 static int callfile __P((char **));
 188 static int setdefaultroute __P((char **));
 189 static int setnodefaultroute __P((char **));
 190 static int setproxyarp __P((char **));
 191 static int setnoproxyarp __P((char **));
 192 static int setpersist __P((char **));
 193 static int setnopersist __P((char **));
 194 static int setdologin __P((char **));
 195 static int setusehostname __P((char **));
 196 static int setnoipdflt __P((char **));
 197 static int setlcptimeout __P((char **));
 198 static int setlcpterm __P((char **));
 199 static int setlcpconf __P((char **));
 200 static int setlcpfails __P((char **));
 201 static int setipcptimeout __P((char **));
 202 static int setipcpterm __P((char **));
 203 static int setipcpconf __P((char **));
 204 static int setipcpfails __P((char **));
 205 static int setpaptimeout __P((char **));
 206 static int setpapreqs __P((char **));
 207 static int setpapreqtime __P((char **));
 208 static int setchaptimeout __P((char **));
 209 static int setchapchal __P((char **));
 210 static int setchapintv __P((char **));
 211 static int setipcpaccl __P((char **));
 212 static int setipcpaccr __P((char **));
 213 static int setlcpechointv __P((char **));
 214 static int setlcpechofails __P((char **));
 215 static int noccp __P((char **));
 216 static int setbsdcomp __P((char **));
 217 static int setnobsdcomp __P((char **));
 218 static int setdeflate __P((char **));
 219 static int setnodeflate __P((char **));
 220 static int setnodeflatedraft __P((char **));
 221 static int setdemand __P((char **));
 222 static int setpred1comp __P((char **));
 223 static int setnopred1comp __P((char **));
 224 static int setipparam __P((char **));
 225 static int setpapcrypt __P((char **));
 226 static int setidle __P((char **));
 227 static int setholdoff __P((char **));
 228 static int setdnsaddr __P((char **));
 229 static int resetipxproto __P((char **));
 230 static int setwinsaddr __P((char **));
 231 static int showversion __P((char **));
 232 static int showhelp __P((char **));
 233
 234 #ifdef PPP_FILTER
 235 static int setpdebug __P((char **));
 236 static int setpassfilter __P((char **));
 237 static int setactivefilter __P((char **));
 238 #endif
 239
 240 #ifdef IPX_CHANGE
 241 static int setipxproto __P((char **));
 242 static int setipxanet __P((char **));
 243 static int setipxalcl __P((char **));
 244 static int setipxarmt __P((char **));
 245 static int setipxnetwork __P((char **));
 246 static int setipxnode __P((char **));
 247 static int setipxrouter __P((char **));
 248 static int setipxname __P((char **));
 249 static int setipxcptimeout __P((char **));
 250 static int setipxcpterm __P((char **));
 251 static int setipxcpconf __P((char **));
 252 static int setipxcpfails __P((char **));
 253 #endif /* IPX_CHANGE */
 254
 255 #ifdef MSLANMAN
 256 static int setmslanman __P((char **));
 257 #endif
 258
 259 static int number_option __P((char *, u_int32_t *, int));
 260 static int int_option __P((char *, int *));
 261 static int readable __P((int fd));
 262
 263 /*
 264  * Valid arguments.
 265  */
 266 static struct cmd {
 267     char *cmd_name;
 268     int num_args;
 269     int (*cmd_func) __P((char **));
 270 } cmds[] = {
 271     {"-all", 0, noopt},         /* Don't request/allow any options (useless) */
 272     {"noaccomp", 0, noaccomp},  /* Disable Address/Control compression */
 273     {"-ac", 0, noaccomp},       /* Disable Address/Control compress */
 274     {"default-asyncmap", 0, noasyncmap}, /* Disable asyncmap negoatiation */
 275     {"-am", 0, noasyncmap},     /* Disable asyncmap negotiation */
 276     {"-as", 1, setasyncmap},    /* set the desired async map */
 277     {"-d", 0, setdebug},        /* Increase debugging level */
 278     {"nodetach", 0, setnodetach}, /* Don't detach from controlling tty */
 279     {"-detach", 0, setnodetach}, /* don't fork */
 280     {"updetach", 0, setupdetach}, /* Detach once an NP has come up */
 281     {"noip", 0, noip},          /* Disable IP and IPCP */
 282     {"-ip", 0, noip},           /* Disable IP and IPCP */
 283     {"nomagic", 0, nomagicnumber}, /* Disable magic number negotiation */
 284     {"-mn", 0, nomagicnumber},  /* Disable magic number negotiation */
 285     {"default-mru", 0, nomru},  /* Disable MRU negotiation */
 286     {"-mru", 0, nomru},         /* Disable mru negotiation */
 287     {"-p", 0, setpassive},      /* Set passive mode */
 288     {"nopcomp", 0, nopcomp},    /* Disable protocol field compression */
 289     {"-pc", 0, nopcomp},        /* Disable protocol field compress */
 290 #if OLD_OPTIONS
 291     {"+ua", 1, setupapfile},    /* Get PAP user and password from file */
 292 #endif
 293     {"require-pap", 0, reqpap}, /* Require PAP authentication from peer */
 294     {"+pap", 0, reqpap},        /* Require PAP auth from peer */
 295     {"refuse-pap", 0, nopap},   /* Don't agree to auth to peer with PAP */
 296     {"-pap", 0, nopap},         /* Don't allow UPAP authentication with peer */
 297     {"require-chap", 0, reqchap}, /* Require CHAP authentication from peer */
 298     {"+chap", 0, reqchap},      /* Require CHAP authentication from peer */
 299     {"refuse-chap", 0, nochap}, /* Don't agree to auth to peer with CHAP */
 300     {"-chap", 0, nochap},       /* Don't allow CHAP authentication with peer */
 301     {"novj", 0, setnovj},       /* Disable VJ compression */
 302     {"-vj", 0, setnovj},        /* disable VJ compression */
 303     {"novjccomp", 0, setnovjccomp}, /* disable VJ connection-ID compression */
 304     {"-vjccomp", 0, setnovjccomp}, /* disable VJ connection-ID compression */
 305     {"vj-max-slots", 1, setvjslots}, /* Set maximum VJ header slots */
 306     {"asyncmap", 1, setasyncmap}, /* set the desired async map */
 307     {"escape", 1, setescape},   /* set chars to escape on transmission */
 308     {"connect", 1, setconnector}, /* A program to set up a connection */
 309     {"disconnect", 1, setdisconnector}, /* program to disconnect serial dev. */
 310     {"welcome", 1, setwelcomer},/* Script to welcome client */
 311     {"maxconnect", 1, setmaxconnect},  /* specify a maximum connect time */
 312     {"crtscts", 0, setcrtscts}, /* set h/w flow control */
 313     {"nocrtscts", 0, setnocrtscts}, /* clear h/w flow control */
 314     {"-crtscts", 0, setnocrtscts}, /* clear h/w flow control */
 315     {"cdtrcts", 0, setcdtrcts},  /* set alternate h/w flow control */
 316     {"nocdtrcts", 0, setnocrtscts}, /* clear h/w flow control */
 317     {"-cdtrcts", 0, setnocrtscts}, /* clear h/w flow control */
 318     {"xonxoff", 0, setxonxoff}, /* set s/w flow control */
 319     {"debug", 0, setdebug},     /* Increase debugging level */
 320     {"kdebug", 1, setkdebug},   /* Enable kernel-level debugging */
 321     {"domain", 1, setdomain},   /* Add given domain name to hostname*/
 322     {"mru", 1, setmru},         /* Set MRU value for negotiation */
 323     {"mtu", 1, setmtu},         /* Set our MTU */
 324 #ifdef CBCP_SUPPORT
 325     {"callback", 1, setcbcp},   /* Ask for callback */
 326 #endif
 327     {"netmask", 1, setnetmask}, /* set netmask */
 328     {"passive", 0, setpassive}, /* Set passive mode */
 329     {"silent", 0, setsilent},   /* Set silent mode */
 330     {"modem", 0, setmodem},     /* Use modem control lines */
 331     {"local", 0, setlocal},     /* Don't use modem control lines */
 332     {"lock", 0, setlock},       /* Lock serial device (with lock file) */
 333     {"name", 1, setname},       /* Set local name for authentication */
 334     {"user", 1, setuser},       /* Set name for auth with peer */
 335     {"usehostname", 0, setusehostname}, /* Must use hostname for auth. */
 336     {"remotename", 1, setremote}, /* Set remote name for authentication */
 337     {"auth", 0, setauth},       /* Require authentication from peer */
 338     {"noauth", 0, setnoauth},   /* Don't require peer to authenticate */
 339     {"file", 1, readfile},      /* Take options from a file */
 340     {"call", 1, callfile},      /* Take options from a privileged file */
 341     {"defaultroute", 0, setdefaultroute}, /* Add default route */
 342     {"nodefaultroute", 0, setnodefaultroute}, /* disable defaultroute option */
 343     {"-defaultroute", 0, setnodefaultroute}, /* disable defaultroute option */
 344     {"proxyarp", 0, setproxyarp}, /* Add proxy ARP entry */
 345     {"noproxyarp", 0, setnoproxyarp}, /* disable proxyarp option */
 346     {"-proxyarp", 0, setnoproxyarp}, /* disable proxyarp option */
 347     {"persist", 0, setpersist}, /* Keep on reopening connection after close */
 348     {"nopersist", 0, setnopersist},  /* Turn off persist option */
 349     {"demand", 0, setdemand},   /* Dial on demand */
 350     {"login", 0, setdologin},   /* Use system password database for UPAP */
 351     {"noipdefault", 0, setnoipdflt}, /* Don't use name for default IP adrs */
 352     {"lcp-echo-failure", 1, setlcpechofails}, /* consecutive echo failures */
 353     {"lcp-echo-interval", 1, setlcpechointv}, /* time for lcp echo events */
 354     {"lcp-restart", 1, setlcptimeout}, /* Set timeout for LCP */
 355     {"lcp-max-terminate", 1, setlcpterm}, /* Set max #xmits for term-reqs */
 356     {"lcp-max-configure", 1, setlcpconf}, /* Set max #xmits for conf-reqs */
 357     {"lcp-max-failure", 1, setlcpfails}, /* Set max #conf-naks for LCP */
 358     {"ipcp-restart", 1, setipcptimeout}, /* Set timeout for IPCP */
 359     {"ipcp-max-terminate", 1, setipcpterm}, /* Set max #xmits for term-reqs */
 360     {"ipcp-max-configure", 1, setipcpconf}, /* Set max #xmits for conf-reqs */
 361     {"ipcp-max-failure", 1, setipcpfails}, /* Set max #conf-naks for IPCP */
 362     {"pap-restart", 1, setpaptimeout},  /* Set retransmit timeout for PAP */
 363     {"pap-max-authreq", 1, setpapreqs}, /* Set max #xmits for auth-reqs */
 364     {"pap-timeout", 1, setpapreqtime},  /* Set time limit for peer PAP auth. */
 365     {"chap-restart", 1, setchaptimeout}, /* Set timeout for CHAP */
 366     {"chap-max-challenge", 1, setchapchal}, /* Set max #xmits for challenge */
 367     {"chap-interval", 1, setchapintv}, /* Set interval for rechallenge */
 368     {"ipcp-accept-local", 0, setipcpaccl}, /* Accept peer's address for us */
 369     {"ipcp-accept-remote", 0, setipcpaccr}, /* Accept peer's address for it */
 370     {"noccp", 0, noccp},                /* Disable CCP negotiation */
 371     {"-ccp", 0, noccp},                 /* Disable CCP negotiation */
 372     {"bsdcomp", 1, setbsdcomp},         /* request BSD-Compress */
 373     {"nobsdcomp", 0, setnobsdcomp},     /* don't allow BSD-Compress */
 374     {"-bsdcomp", 0, setnobsdcomp},      /* don't allow BSD-Compress */
 375     {"deflate", 1, setdeflate},         /* request Deflate compression */
 376     {"nodeflate", 0, setnodeflate},     /* don't allow Deflate compression */
 377     {"-deflate", 0, setnodeflate},      /* don't allow Deflate compression */
 378     {"nodeflatedraft", 0, setnodeflatedraft}, /* don't use draft deflate # */
 379     {"predictor1", 0, setpred1comp},    /* request Predictor-1 */
 380     {"nopredictor1", 0, setnopred1comp},/* don't allow Predictor-1 */
 381     {"-predictor1", 0, setnopred1comp}, /* don't allow Predictor-1 */
 382     {"ipparam", 1, setipparam},         /* set ip script parameter */
 383     {"papcrypt", 0, setpapcrypt},       /* PAP passwords encrypted */
 384     {"idle", 1, setidle},               /* idle time limit (seconds) */
 385     {"holdoff", 1, setholdoff},         /* set holdoff time (seconds) */
 386     {"ms-dns", 1, setdnsaddr},          /* DNS address for the peer's use */
 387     {"ms-wins", 1, setwinsaddr},        /* Nameserver for SMB over TCP/IP for peer */
 388     {"noipx",  0, resetipxproto},       /* Disable IPXCP (and IPX) */
 389     {"-ipx",   0, resetipxproto},       /* Disable IPXCP (and IPX) */
 390     {"--version", 0, showversion},      /* Show version number */
 391     {"--help", 0, showhelp},            /* Show brief listing of options */
 392     {"-h", 0, showhelp},                /* ditto */
 393
 394 #ifdef PPP_FILTER
 395     {"pdebug", 1, setpdebug},           /* libpcap debugging */
 396     {"pass-filter", 1, setpassfilter},  /* set filter for packets to pass */
 397     {"active-filter", 1, setactivefilter}, /* set filter for active pkts */
 398 #endif
 399
 400 #ifdef IPX_CHANGE
 401     {"ipx-network",          1, setipxnetwork}, /* IPX network number */
 402     {"ipxcp-accept-network", 0, setipxanet},    /* Accept peer netowrk */
 403     {"ipx-node",             1, setipxnode},    /* IPX node number */
 404     {"ipxcp-accept-local",   0, setipxalcl},    /* Accept our address */
 405     {"ipxcp-accept-remote",  0, setipxarmt},    /* Accept peer's address */
 406     {"ipx-routing",          1, setipxrouter},  /* IPX routing proto number */
 407     {"ipx-router-name",      1, setipxname},    /* IPX router name */
 408     {"ipxcp-restart",        1, setipxcptimeout}, /* Set timeout for IPXCP */
 409     {"ipxcp-max-terminate",  1, setipxcpterm},  /* max #xmits for term-reqs */
 410     {"ipxcp-max-configure",  1, setipxcpconf},  /* max #xmits for conf-reqs */
 411     {"ipxcp-max-failure",    1, setipxcpfails}, /* max #conf-naks for IPXCP */
 412 #if 0
 413     {"ipx-compression", 1, setipxcompression}, /* IPX compression number */
 414 #endif
 415     {"ipx",                  0, setipxproto},   /* Enable IPXCP (and IPX) */
 416     {"+ipx",                 0, setipxproto},   /* Enable IPXCP (and IPX) */
 417 #endif /* IPX_CHANGE */
 418
 419 #ifdef MSLANMAN
 420     {"ms-lanman", 0, setmslanman},      /* Use LanMan psswd when using MS-CHAP */
 421 #endif
 422
 423     {NULL, 0, NULL}
 424 };
 425
 426
 427 #ifndef IMPLEMENTATION
 428 #define IMPLEMENTATION ""
 429 #endif
 430
 431 static char *usage_string = "\
 432 pppd version %s patch level %d%s\n\
 433 Usage: %s [ options ], where options are:\n\
 434         <device>        Communicate over the named device\n\
 435         <speed>         Set the baud rate to <speed>\n\
 436         <loc>:<rem>     Set the local and/or remote interface IP\n\
 437                         addresses.  Either one may be omitted.\n\
 438         asyncmap <n>    Set the desired async map to hex <n>\n\
 439         auth            Require authentication from peer\n\
 440         connect <p>     Invoke shell command <p> to set up the serial line\n\
 441         crtscts         Use hardware RTS/CTS flow control\n\
 442         cdtrcts         Use hardware DTR/CTS flow control (if supported)\n\
 443         defaultroute    Add default route through interface\n\
 444         file <f>        Take options from file <f>\n\
 445         modem           Use modem control lines\n\
 446         mru <n>         Set MRU value to <n> for negotiation\n\
 447 See pppd(8) for more options.\n\
 448 ";
 449
 450 static char *current_option;    /* the name of the option being parsed */
 451 static int privileged_option;   /* set iff the current option came from root */
 452 static char *option_source;     /* string saying where the option came from */
 453
 454 /*
 455  * parse_args - parse a string of arguments from the command line.
 456  */
 457 int
 458 parse_args(argc, argv)
 459     int argc;
 460     char **argv;
 461 {
 462     char *arg;
 463     struct cmd *cmdp;
 464     int ret;
 465
 466     privileged_option = privileged;
 467     option_source = "command line";
 468     while (argc > 0) {
 469         arg = *argv++;
 470         --argc;
 471
 472         /*
 473          * First see if it's a command.
 474          */
 475         for (cmdp = cmds; cmdp->cmd_name; cmdp++)
 476             if (!strcmp(arg, cmdp->cmd_name))
 477                 break;
 478
 479         if (cmdp->cmd_name != NULL) {
 480             if (argc < cmdp->num_args) {
 481                 option_error("too few parameters for option %s", arg);
 482                 return 0;
 483             }
 484             current_option = arg;
 485             if (!(*cmdp->cmd_func)(argv))
 486                 return 0;
 487             argc -= cmdp->num_args;
 488             argv += cmdp->num_args;
 489
 490         } else {
 491             /*
 492              * Maybe a tty name, speed or IP address?
 493              */
 494             if ((ret = setdevname(arg, 0)) == 0
 495                 && (ret = setspeed(arg)) == 0
 496                 && (ret = setipaddr(arg)) == 0) {
 497                 option_error("unrecognized option '%s'", arg);
 498                 usage();
 499                 return 0;
 500             }
 501             if (ret < 0)        /* error */
 502                 return 0;
 503         }
 504     }
 505     return 1;
 506 }
 507
 508 /*
 509  * scan_args - scan the command line arguments to get the tty name,
 510  * if specified.
 511  */
 512 void
 513 scan_args(argc, argv)
 514     int argc;
 515     char **argv;
 516 {
 517     char *arg;
 518     struct cmd *cmdp;
 519
 520     while (argc > 0) {
 521         arg = *argv++;
 522         --argc;
 523
 524         /* Skip options and their arguments */
 525         for (cmdp = cmds; cmdp->cmd_name; cmdp++)
 526             if (!strcmp(arg, cmdp->cmd_name))
 527                 break;
 528
 529         if (cmdp->cmd_name != NULL) {
 530             argc -= cmdp->num_args;
 531             argv += cmdp->num_args;
 532             continue;
 533         }
 534
 535         /* Check if it's a tty name and copy it if so */
 536         (void) setdevname(arg, 1);
 537     }
 538 }
 539
 540 /*
 541  * usage - print out a message telling how to use the program.
 542  */
 543 void
 544 usage()
 545 {
 546     if (phase == PHASE_INITIALIZE)
 547         fprintf(stderr, usage_string, VERSION, PATCHLEVEL, IMPLEMENTATION,
 548                 progname);
 549 }
 550
 551 /*
 552  * showhelp - print out usage message and exit.
 553  */
 554 static int
 555 showhelp(argv)
 556     char **argv;
 557 {
 558     if (phase == PHASE_INITIALIZE) {
 559         usage();
 560         exit(0);
 561     }
 562     return 0;
 563 }
 564
 565 /*
 566  * showversion - print out the version number and exit.
 567  */
 568 static int
 569 showversion(argv)
 570     char **argv;
 571 {
 572     if (phase == PHASE_INITIALIZE) {
 573         fprintf(stderr, "pppd version %s patch level %d%s\n",
 574                 VERSION, PATCHLEVEL, IMPLEMENTATION);
 575         exit(0);
 576     }
 577     return 0;
 578 }
 579
 580 /*
 581  * options_from_file - Read a string of options from a file,
 582  * and interpret them.
 583  */
 584 int
 585 options_from_file(filename, must_exist, check_prot, priv)
 586     char *filename;
 587     int must_exist;
 588     int check_prot;
 589     int priv;
 590 {
 591     FILE *f;
 592     int i, newline, ret;
 593     struct cmd *cmdp;
 594     int oldpriv;
 595     char *argv[MAXARGS];
 596     char args[MAXARGS][MAXWORDLEN];
 597     char cmd[MAXWORDLEN];
 598
 599     if ((f = fopen(filename, "r")) == NULL) {
 600         if (!must_exist && errno == ENOENT)
 601             return 1;
 602         option_error("Can't open options file %s: %m", filename);
 603         return 0;
 604     }
 605     if (check_prot && !readable(fileno(f))) {
 606         option_error("Can't open options file %s: access denied", filename);
 607         fclose(f);
 608         return 0;
 609     }
 610
 611     oldpriv = privileged_option;
 612     privileged_option = priv;
 613     ret = 0;
 614     while (getword(f, cmd, &newline, filename)) {
 615         /*
 616          * First see if it's a command.
 617          */
 618         for (cmdp = cmds; cmdp->cmd_name; cmdp++)
 619             if (!strcmp(cmd, cmdp->cmd_name))
 620                 break;
 621
 622         if (cmdp->cmd_name != NULL) {
 623             for (i = 0; i < cmdp->num_args; ++i) {
 624                 if (!getword(f, args[i], &newline, filename)) {
 625                     option_error(
 626                         "In file %s: too few parameters for option '%s'",
 627                         filename, cmd);
 628                     goto err;
 629                 }
 630                 argv[i] = args[i];
 631             }
 632             current_option = cmd;
 633             if (!(*cmdp->cmd_func)(argv))
 634                 goto err;
 635
 636         } else {
 637             /*
 638              * Maybe a tty name, speed or IP address?
 639              */
 640             if ((i = setdevname(cmd, 0)) == 0
 641                 && (i = setspeed(cmd)) == 0
 642                 && (i = setipaddr(cmd)) == 0) {
 643                 option_error("In file %s: unrecognized option '%s'",
 644                              filename, cmd);
 645                 goto err;
 646             }
 647             if (i < 0)          /* error */
 648                 goto err;
 649         }
 650     }
 651     ret = 1;
 652
 653 err:
 654     fclose(f);
 655     privileged_option = oldpriv;
 656     return ret;
 657 }
 658
 659 /*
 660  * options_from_user - See if the use has a ~/.ppprc file,
 661  * and if so, interpret options from it.
 662  */
 663 int
 664 options_from_user()
 665 {
 666     char *user, *path, *file;
 667     int ret;
 668     struct passwd *pw;
 669
 670     pw = getpwuid(getuid());
 671     if (pw == NULL || (user = pw->pw_dir) == NULL || user[0] == 0)
 672         return 1;
 673     file = _PATH_USEROPT;
 674     path = malloc(strlen(user) + strlen(file) + 2);
 675     if (path == NULL)
 676         novm("init file name");
 677     strcpy(path, user);
 678     strcat(path, "/");
 679     strcat(path, file);
 680     ret = options_from_file(path, 0, 1, privileged);
 681     free(path);
 682     return ret;
 683 }
 684
 685 /*
 686  * options_for_tty - See if an options file exists for the serial
 687  * device, and if so, interpret options from it.
 688  */
 689 int
 690 options_for_tty()
 691 {
 692     char *dev, *path, *p;
 693     int ret;
 694
 695     dev = devnam;
 696     if (strncmp(dev, "/dev/", 5) == 0)
 697         dev += 5;
 698     if (strcmp(dev, "tty") == 0)
 699         return 1;               /* don't look for /etc/ppp/options.tty */
 700     path = malloc(strlen(_PATH_TTYOPT) + strlen(dev) + 1);
 701     if (path == NULL)
 702         novm("tty init file name");
 703     strcpy(path, _PATH_TTYOPT);
 704     /* Turn slashes into dots, for Solaris case (e.g. /dev/term/a) */
 705     for (p = path + strlen(path); *dev != 0; ++dev)
 706         *p++ = (*dev == '/'? '.': *dev);
 707     *p = 0;
 708     ret = options_from_file(path, 0, 0, 1);
 709     free(path);
 710     return ret;
 711 }
 712
 713 /*
 714  * option_error - print a message about an error in an option.
 715  * The message is logged, and also sent to
 716  * stderr if phase == PHASE_INITIALIZE.
 717  */
 718 void
 719 option_error __V((char *fmt, ...))
 720 {
 721     va_list args;
 722     char buf[256];
 723
 724 #if __STDC__
 725     va_start(args, fmt);
 726 #else
 727     char *fmt;
 728     va_start(args);
 729     fmt = va_arg(args, char *);
 730 #endif
 731     vfmtmsg(buf, sizeof(buf), fmt, args);
 732     va_end(args);
 733     if (phase == PHASE_INITIALIZE)
 734         fprintf(stderr, "%s: %s\n", progname, buf);
 735     syslog(LOG_ERR, "%s", buf);
 736 }
 737
 738 /*
 739  * readable - check if a file is readable by the real user.
 740  */
 741 static int
 742 readable(fd)
 743     int fd;
 744 {
 745     uid_t uid;
 746     int ngroups, i;
 747     struct stat sbuf;
 748     GIDSET_TYPE groups[NGROUPS_MAX];
 749
 750     uid = getuid();
 751     if (uid == 0)
 752         return 1;
 753     if (fstat(fd, &sbuf) != 0)
 754         return 0;
 755     if (sbuf.st_uid == uid)
 756         return sbuf.st_mode & S_IRUSR;
 757     if (sbuf.st_gid == getgid())
 758         return sbuf.st_mode & S_IRGRP;
 759     ngroups = getgroups(NGROUPS_MAX, groups);
 760     for (i = 0; i < ngroups; ++i)
 761         if (sbuf.st_gid == groups[i])
 762             return sbuf.st_mode & S_IRGRP;
 763     return sbuf.st_mode & S_IROTH;
 764 }
 765
 766 /*
 767  * Read a word from a file.
 768  * Words are delimited by white-space or by quotes (" or ').
 769  * Quotes, white-space and \ may be escaped with \.
 770  * \<newline> is ignored.
 771  */
 772 int
 773 getword(f, word, newlinep, filename)
 774     FILE *f;
 775     char *word;
 776     int *newlinep;
 777     char *filename;
 778 {
 779     int c, len, escape;
 780     int quoted, comment;
 781     int value, digit, got, n;
 782
 783 #define isoctal(c) ((c) >= '0' && (c) < '8')
 784
 785     *newlinep = 0;
 786     len = 0;
 787     escape = 0;
 788     comment = 0;
 789
 790     /*
 791      * First skip white-space and comments.
 792      */
 793     for (;;) {
 794         c = getc(f);
 795         if (c == EOF)
 796             break;
 797
 798         /*
 799          * A newline means the end of a comment; backslash-newline
 800          * is ignored.  Note that we cannot have escape && comment.
 801          */
 802         if (c == '\n') {
 803             if (!escape) {
 804                 *newlinep = 1;
 805                 comment = 0;
 806             } else
 807                 escape = 0;
 808             continue;
 809         }
 810
 811         /*
 812          * Ignore characters other than newline in a comment.
 813          */
 814         if (comment)
 815             continue;
 816
 817         /*
 818          * If this character is escaped, we have a word start.
 819          */
 820         if (escape)
 821             break;
 822
 823         /*
 824          * If this is the escape character, look at the next character.
 825          */
 826         if (c == '\\') {
 827             escape = 1;
 828             continue;
 829         }
 830
 831         /*
 832          * If this is the start of a comment, ignore the rest of the line.
 833          */
 834         if (c == '#') {
 835             comment = 1;
 836             continue;
 837         }
 838
 839         /*
 840          * A non-whitespace character is the start of a word.
 841          */
 842         if (!isspace(c))
 843             break;
 844     }
 845
 846     /*
 847      * Save the delimiter for quoted strings.
 848      */
 849     if (!escape && (c == '"' || c == '\'')) {
 850         quoted = c;
 851         c = getc(f);
 852     } else
 853         quoted = 0;
 854
 855     /*
 856      * Process characters until the end of the word.
 857      */
 858     while (c != EOF) {
 859         if (escape) {
 860             /*
 861              * This character is escaped: backslash-newline is ignored,
 862              * various other characters indicate particular values
 863              * as for C backslash-escapes.
 864              */
 865             escape = 0;
 866             if (c == '\n') {
 867                 c = getc(f);
 868                 continue;
 869             }
 870
 871             got = 0;
 872             switch (c) {
 873             case 'a':
 874                 value = '\a';
 875                 break;
 876             case 'b':
 877                 value = '\b';
 878                 break;
 879             case 'f':
 880                 value = '\f';
 881                 break;
 882             case 'n':
 883                 value = '\n';
 884                 break;
 885             case 'r':
 886                 value = '\r';
 887                 break;
 888             case 's':
 889                 value = ' ';
 890                 break;
 891             case 't':
 892                 value = '\t';
 893                 break;
 894
 895             default:
 896                 if (isoctal(c)) {
 897                     /*
 898                      * \ddd octal sequence
 899                      */
 900                     value = 0;
 901                     for (n = 0; n < 3 && isoctal(c); ++n) {
 902                         value = (value << 3) + (c & 07);
 903                         c = getc(f);
 904                     }
 905                     got = 1;
 906                     break;
 907                 }
 908
 909                 if (c == 'x') {
 910                     /*
 911                      * \x<hex_string> sequence
 912                      */
 913                     value = 0;
 914                     c = getc(f);
 915                     for (n = 0; n < 2 && isxdigit(c); ++n) {
 916                         digit = toupper(c) - '0';
 917                         if (digit > 10)
 918                             digit += '0' + 10 - 'A';
 919                         value = (value << 4) + digit;
 920                         c = getc (f);
 921                     }
 922                     got = 1;
 923                     break;
 924                 }
 925
 926                 /*
 927                  * Otherwise the character stands for itself.
 928                  */
 929                 value = c;
 930                 break;
 931             }
 932
 933             /*
 934              * Store the resulting character for the escape sequence.
 935              */
 936             if (len < MAXWORDLEN-1)
 937                 word[len] = value;
 938             ++len;
 939
 940             if (!got)
 941                 c = getc(f);
 942             continue;
 943
 944         }
 945
 946         /*
 947          * Not escaped: see if we've reached the end of the word.
 948          */
 949         if (quoted) {
 950             if (c == quoted)
 951                 break;
 952         } else {
 953             if (isspace(c) || c == '#') {
 954                 ungetc (c, f);
 955                 break;
 956             }
 957         }
 958
 959         /*
 960          * Backslash starts an escape sequence.
 961          */
 962         if (c == '\\') {
 963             escape = 1;
 964             c = getc(f);
 965             continue;
 966         }
 967
 968         /*
 969          * An ordinary character: store it in the word and get another.
 970          */
 971         if (len < MAXWORDLEN-1)
 972             word[len] = c;
 973         ++len;
 974
 975         c = getc(f);
 976     }
 977
 978     /*
 979      * End of the word: check for errors.
 980      */
 981     if (c == EOF) {
 982         if (ferror(f)) {
 983             if (errno == 0)
 984                 errno = EIO;
 985             option_error("Error reading %s: %m", filename);
 986             die(1);
 987         }
 988         /*
 989          * If len is zero, then we didn't find a word before the
 990          * end of the file.
 991          */
 992         if (len == 0)
 993             return 0;
 994     }
 995
 996     /*
 997      * Warn if the word was too long, and append a terminating null.
 998      */
 999     if (len >= MAXWORDLEN) {
1000         option_error("warning: word in file %s too long (%.20s...)",
1001                      filename, word);
1002         len = MAXWORDLEN - 1;
1003     }
1004     word[len] = 0;
1005
1006     return 1;
1007
1008 #undef isoctal
1009
1010 }
1011
1012 /*
1013  * number_option - parse an unsigned numeric parameter for an option.
1014  */
1015 static int
1016 number_option(str, valp, base)
1017     char *str;
1018     u_int32_t *valp;
1019     int base;
1020 {
1021     char *ptr;
1022
1023     *valp = strtoul(str, &ptr, base);
1024     if (ptr == str) {
1025         option_error("invalid numeric parameter '%s' for %s option",
1026                      str, current_option);
1027         return 0;
1028     }
1029     return 1;
1030 }
1031
1032
1033 /*
1034  * int_option - like number_option, but valp is int *,
1035  * the base is assumed to be 0, and *valp is not changed
1036  * if there is an error.
1037  */
1038 static int
1039 int_option(str, valp)
1040     char *str;
1041     int *valp;
1042 {
1043     u_int32_t v;
1044
1045     if (!number_option(str, &v, 0))
1046         return 0;
1047     *valp = (int) v;
1048     return 1;
1049 }
1050
1051
1052 /*
1053  * The following procedures parse options.
1054  */
1055
1056 /*
1057  * readfile - take commands from a file.
1058  */
1059 static int
1060 readfile(argv)
1061     char **argv;
1062 {
1063     return options_from_file(*argv, 1, 1, privileged_option);
1064 }
1065
1066 /*
1067  * callfile - take commands from /etc/ppp/peers/<name>.
1068  * Name may not contain /../, start with / or ../, or end in /..
1069  */
1070 static int
1071 callfile(argv)
1072     char **argv;
1073 {
1074     char *fname, *arg, *p;
1075     int l, ok;
1076
1077     arg = *argv;
1078     ok = 1;
1079     if (arg[0] == '/' || arg[0] == 0)
1080         ok = 0;
1081     else {
1082         for (p = arg; *p != 0; ) {
1083             if (p[0] == '.' && p[1] == '.' && (p[2] == '/' || p[2] == 0)) {
1084                 ok = 0;
1085                 break;
1086             }
1087             while (*p != '/' && *p != 0)
1088                 ++p;
1089             if (*p == '/')
1090                 ++p;
1091         }
1092     }
1093     if (!ok) {
1094         option_error("call option value may not contain .. or start with /");
1095         return 0;
1096     }
1097
1098     l = strlen(arg) + strlen(_PATH_PEERFILES) + 1;
1099     if ((fname = (char *) malloc(l)) == NULL)
1100         novm("call file name");
1101     strcpy(fname, _PATH_PEERFILES);
1102     strcat(fname, arg);
1103
1104     ok = options_from_file(fname, 1, 1, 1);
1105
1106     free(fname);
1107     return ok;
1108 }
1109
1110
1111 /*
1112  * setdebug - Set debug (command line argument).
1113  */
1114 static int
1115 setdebug(argv)
1116     char **argv;
1117 {
1118     debug++;
1119     return (1);
1120 }
1121
1122 /*
1123  * setkdebug - Set kernel debugging level.
1124  */
1125 static int
1126 setkdebug(argv)
1127     char **argv;
1128 {
1129     return int_option(*argv, &kdebugflag);
1130 }
1131
1132 #ifdef PPP_FILTER
1133 /*
1134  * setpdebug - Set libpcap debugging level.
1135  */
1136 static int
1137 setpdebug(argv)
1138     char **argv;
1139 {
1140     return int_option(*argv, &dflag);
1141 }
1142
1143 /*
1144  * setpassfilter - Set the pass filter for packets
1145  */
1146 static int
1147 setpassfilter(argv)
1148     char **argv;
1149 {
1150     pc.linktype = DLT_PPP;
1151     pc.snapshot = PPP_HDRLEN;
1152
1153     if (pcap_compile(&pc, &pass_filter, *argv, 1, netmask) == 0)
1154         return 1;
1155     option_error("error in pass-filter expression: %s\n", pcap_geterr(&pc));
1156     return 0;
1157 }
1158
1159 /*
1160  * setactivefilter - Set the active filter for packets
1161  */
1162 static int
1163 setactivefilter(argv)
1164     char **argv;
1165 {
1166     pc.linktype = DLT_PPP;
1167     pc.snapshot = PPP_HDRLEN;
1168
1169     if (pcap_compile(&pc, &active_filter, *argv, 1, netmask) == 0)
1170         return 1;
1171     option_error("error in active-filter expression: %s\n", pcap_geterr(&pc));
1172     return 0;
1173 }
1174 #endif
1175
1176 /*
1177  * noopt - Disable all options.
1178  */
1179 static int
1180 noopt(argv)
1181     char **argv;
1182 {
1183     BZERO((char *) &lcp_wantoptions[0], sizeof (struct lcp_options));
1184     BZERO((char *) &lcp_allowoptions[0], sizeof (struct lcp_options));
1185     BZERO((char *) &ipcp_wantoptions[0], sizeof (struct ipcp_options));
1186     BZERO((char *) &ipcp_allowoptions[0], sizeof (struct ipcp_options));
1187
1188 #ifdef IPX_CHANGE
1189     BZERO((char *) &ipxcp_wantoptions[0], sizeof (struct ipxcp_options));
1190     BZERO((char *) &ipxcp_allowoptions[0], sizeof (struct ipxcp_options));
1191 #endif /* IPX_CHANGE */
1192
1193     return (1);
1194 }
1195
1196 /*
1197  * noaccomp - Disable Address/Control field compression negotiation.
1198  */
1199 static int
1200 noaccomp(argv)
1201     char **argv;
1202 {
1203     lcp_wantoptions[0].neg_accompression = 0;
1204     lcp_allowoptions[0].neg_accompression = 0;
1205     return (1);
1206 }
1207
1208
1209 /*
1210  * noasyncmap - Disable async map negotiation.
1211  */
1212 static int
1213 noasyncmap(argv)
1214     char **argv;
1215 {
1216     lcp_wantoptions[0].neg_asyncmap = 0;
1217     lcp_allowoptions[0].neg_asyncmap = 0;
1218     return (1);
1219 }
1220
1221
1222 /*
1223  * noip - Disable IP and IPCP.
1224  */
1225 static int
1226 noip(argv)
1227     char **argv;
1228 {
1229     ipcp_protent.enabled_flag = 0;
1230     return (1);
1231 }
1232
1233
1234 /*
1235  * nomagicnumber - Disable magic number negotiation.
1236  */
1237 static int
1238 nomagicnumber(argv)
1239     char **argv;
1240 {
1241     lcp_wantoptions[0].neg_magicnumber = 0;
1242     lcp_allowoptions[0].neg_magicnumber = 0;
1243     return (1);
1244 }
1245
1246
1247 /*
1248  * nomru - Disable mru negotiation.
1249  */
1250 static int
1251 nomru(argv)
1252     char **argv;
1253 {
1254     lcp_wantoptions[0].neg_mru = 0;
1255     lcp_allowoptions[0].neg_mru = 0;
1256     return (1);
1257 }
1258
1259
1260 /*
1261  * setmru - Set MRU for negotiation.
1262  */
1263 static int
1264 setmru(argv)
1265     char **argv;
1266 {
1267     u_int32_t mru;
1268
1269     if (!number_option(*argv, &mru, 0))
1270         return 0;
1271     lcp_wantoptions[0].mru = mru;
1272     lcp_wantoptions[0].neg_mru = 1;
1273     return (1);
1274 }
1275
1276
1277 /*
1278  * setmru - Set the largest MTU we'll use.
1279  */
1280 static int
1281 setmtu(argv)
1282     char **argv;
1283 {
1284     u_int32_t mtu;
1285
1286     if (!number_option(*argv, &mtu, 0))
1287         return 0;
1288     if (mtu < MINMRU || mtu > MAXMRU) {
1289         option_error("mtu option value of %u is too %s", mtu,
1290                      (mtu < MINMRU? "small": "large"));
1291         return 0;
1292     }
1293     lcp_allowoptions[0].mru = mtu;
1294     return (1);
1295 }
1296
1297 #ifdef CBCP_SUPPORT
1298 static int
1299 setcbcp(argv)
1300     char **argv;
1301 {
1302     lcp_wantoptions[0].neg_cbcp = 1;
1303     cbcp_protent.enabled_flag = 1;
1304     cbcp[0].us_number = strdup(*argv);
1305     if (cbcp[0].us_number == 0)
1306         novm("callback number");
1307     cbcp[0].us_type |= (1 << CB_CONF_USER);
1308     cbcp[0].us_type |= (1 << CB_CONF_ADMIN);
1309     return (1);
1310 }
1311 #endif
1312
1313 /*
1314  * nopcomp - Disable Protocol field compression negotiation.
1315  */
1316 static int
1317 nopcomp(argv)
1318     char **argv;
1319 {
1320     lcp_wantoptions[0].neg_pcompression = 0;
1321     lcp_allowoptions[0].neg_pcompression = 0;
1322     return (1);
1323 }
1324
1325
1326 /*
1327  * setpassive - Set passive mode (don't give up if we time out sending
1328  * LCP configure-requests).
1329  */
1330 static int
1331 setpassive(argv)
1332     char **argv;
1333 {
1334     lcp_wantoptions[0].passive = 1;
1335     return (1);
1336 }
1337
1338
1339 /*
1340  * setsilent - Set silent mode (don't start sending LCP configure-requests
1341  * until we get one from the peer).
1342  */
1343 static int
1344 setsilent(argv)
1345     char **argv;
1346 {
1347     lcp_wantoptions[0].silent = 1;
1348     return 1;
1349 }
1350
1351
1352 /*
1353  * nopap - Disable PAP authentication with peer.
1354  */
1355 static int
1356 nopap(argv)
1357     char **argv;
1358 {
1359     refuse_pap = 1;
1360     return (1);
1361 }
1362
1363
1364 /*
1365  * reqpap - Require PAP authentication from peer.
1366  */
1367 static int
1368 reqpap(argv)
1369     char **argv;
1370 {
1371     lcp_wantoptions[0].neg_upap = 1;
1372     setauth(NULL);
1373     return 1;
1374 }
1375
1376 #if OLD_OPTIONS
1377 /*
1378  * setupapfile - specifies UPAP info for authenticating with peer.
1379  */
1380 static int
1381 setupapfile(argv)
1382     char **argv;
1383 {
1384     FILE * ufile;
1385     int l;
1386
1387     lcp_allowoptions[0].neg_upap = 1;
1388
1389     /* open user info file */
1390     if ((ufile = fopen(*argv, "r")) == NULL) {
1391         option_error("unable to open user login data file %s", *argv);
1392         return 0;
1393     }
1394     if (!readable(fileno(ufile))) {
1395         option_error("%s: access denied", *argv);
1396         return 0;
1397     }
1398     check_access(ufile, *argv);
1399
1400     /* get username */
1401     if (fgets(user, MAXNAMELEN - 1, ufile) == NULL
1402         || fgets(passwd, MAXSECRETLEN - 1, ufile) == NULL){
1403         option_error("unable to read user login data file %s", *argv);
1404         return 0;
1405     }
1406     fclose(ufile);
1407
1408     /* get rid of newlines */
1409     l = strlen(user);
1410     if (l > 0 && user[l-1] == '\n')
1411         user[l-1] = 0;
1412     l = strlen(passwd);
1413     if (l > 0 && passwd[l-1] == '\n')
1414         passwd[l-1] = 0;
1415
1416     return (1);
1417 }
1418 #endif
1419
1420 /*
1421  * nochap - Disable CHAP authentication with peer.
1422  */
1423 static int
1424 nochap(argv)
1425     char **argv;
1426 {
1427     refuse_chap = 1;
1428     return (1);
1429 }
1430
1431
1432 /*
1433  * reqchap - Require CHAP authentication from peer.
1434  */
1435 static int
1436 reqchap(argv)
1437     char **argv;
1438 {
1439     lcp_wantoptions[0].neg_chap = 1;
1440     setauth(NULL);
1441     return (1);
1442 }
1443
1444
1445 /*
1446  * setnovj - disable vj compression
1447  */
1448 static int
1449 setnovj(argv)
1450     char **argv;
1451 {
1452     ipcp_wantoptions[0].neg_vj = 0;
1453     ipcp_allowoptions[0].neg_vj = 0;
1454     return (1);
1455 }
1456
1457
1458 /*
1459  * setnovjccomp - disable VJ connection-ID compression
1460  */
1461 static int
1462 setnovjccomp(argv)
1463     char **argv;
1464 {
1465     ipcp_wantoptions[0].cflag = 0;
1466     ipcp_allowoptions[0].cflag = 0;
1467     return 1;
1468 }
1469
1470
1471 /*
1472  * setvjslots - set maximum number of connection slots for VJ compression
1473  */
1474 static int
1475 setvjslots(argv)
1476     char **argv;
1477 {
1478     int value;
1479
1480     if (!int_option(*argv, &value))
1481         return 0;
1482     if (value < 2 || value > 16) {
1483         option_error("vj-max-slots value must be between 2 and 16");
1484         return 0;
1485     }
1486     ipcp_wantoptions [0].maxslotindex =
1487         ipcp_allowoptions[0].maxslotindex = value - 1;
1488     return 1;
1489 }
1490
1491
1492 /*
1493  * setconnector - Set a program to connect to a serial line
1494  */
1495 static int
1496 setconnector(argv)
1497     char **argv;
1498 {
1499     connector = strdup(*argv);
1500     if (connector == NULL)
1501         novm("connect script");
1502     connector_info.priv = privileged_option;
1503     connector_info.source = option_source;
1504
1505     return (1);
1506 }
1507
1508 /*
1509  * setdisconnector - Set a program to disconnect from the serial line
1510  */
1511 static int
1512 setdisconnector(argv)
1513     char **argv;
1514 {
1515     disconnector = strdup(*argv);
1516     if (disconnector == NULL)
1517         novm("disconnect script");
1518     disconnector_info.priv = privileged_option;
1519     disconnector_info.source = option_source;
1520
1521     return (1);
1522 }
1523
1524 /*
1525  * setwelcomer - Set a program to welcome a client after connection
1526  */
1527 static int
1528 setwelcomer(argv)
1529     char **argv;
1530 {
1531     welcomer = strdup(*argv);
1532     if (welcomer == NULL)
1533         novm("welcome script");
1534     welcomer_info.priv = privileged_option;
1535     welcomer_info.source = option_source;
1536
1537     return (1);
1538 }
1539
1540 /*
1541  * setmaxconnect - Set the maximum connect time
1542  */
1543 static int
1544 setmaxconnect(argv)
1545     char **argv;
1546 {
1547     int value;
1548
1549     if (!int_option(*argv, &value))
1550         return 0;
1551     if (value < 0) {
1552         option_error("maxconnect time must be positive");
1553         return 0;
1554     }
1555     if (maxconnect > 0 && (value == 0 || value > maxconnect)) {
1556         option_error("maxconnect time cannot be increased");
1557         return 0;
1558     }
1559     maxconnect = value;
1560     return 1;
1561 }
1562
1563 /*
1564  * setdomain - Set domain name to append to hostname
1565  */
1566 static int
1567 setdomain(argv)
1568     char **argv;
1569 {
1570     if (!privileged_option) {
1571         option_error("using the domain option requires root privilege");
1572         return 0;
1573     }
1574     gethostname(hostname, MAXNAMELEN);
1575     if (**argv != 0) {
1576         if (**argv != '.')
1577             strncat(hostname, ".", MAXNAMELEN - strlen(hostname));
1578         strncat(hostname, *argv, MAXNAMELEN - strlen(hostname));
1579     }
1580     hostname[MAXNAMELEN-1] = 0;
1581     return (1);
1582 }
1583
1584
1585 /*
1586  * setasyncmap - add bits to asyncmap (what we request peer to escape).
1587  */
1588 static int
1589 setasyncmap(argv)
1590     char **argv;
1591 {
1592     u_int32_t asyncmap;
1593
1594     if (!number_option(*argv, &asyncmap, 16))
1595         return 0;
1596     lcp_wantoptions[0].asyncmap |= asyncmap;
1597     lcp_wantoptions[0].neg_asyncmap = 1;
1598     return(1);
1599 }
1600
1601
1602 /*
1603  * setescape - add chars to the set we escape on transmission.
1604  */
1605 static int
1606 setescape(argv)
1607     char **argv;
1608 {
1609     int n, ret;
1610     char *p, *endp;
1611
1612     p = *argv;
1613     ret = 1;
1614     while (*p) {
1615         n = strtol(p, &endp, 16);
1616         if (p == endp) {
1617             option_error("escape parameter contains invalid hex number '%s'",
1618                          p);
1619             return 0;
1620         }
1621         p = endp;
1622         if (n < 0 || (0x20 <= n && n <= 0x3F) || n == 0x5E || n > 0xFF) {
1623             option_error("can't escape character 0x%x", n);
1624             ret = 0;
1625         } else
1626             xmit_accm[0][n >> 5] |= 1 << (n & 0x1F);
1627         while (*p == ',' || *p == ' ')
1628             ++p;
1629     }
1630     return ret;
1631 }
1632
1633
1634 /*
1635  * setspeed - Set the speed.
1636  */
1637 static int
1638 setspeed(arg)
1639     char *arg;
1640 {
1641     char *ptr;
1642     int spd;
1643
1644     spd = strtol(arg, &ptr, 0);
1645     if (ptr == arg || *ptr != 0 || spd == 0)
1646         return 0;
1647     inspeed = spd;
1648     return 1;
1649 }
1650
1651
1652 /*
1653  * setdevname - Set the device name.
1654  */
1655 static int
1656 setdevname(cp, quiet)
1657     char *cp;
1658     int quiet;
1659 {
1660     struct stat statbuf;
1661     char dev[MAXPATHLEN];
1662
1663     if (*cp == 0)
1664         return 0;
1665
1666     if (strncmp("/dev/", cp, 5) != 0) {
1667         strcpy(dev, "/dev/");
1668         strncat(dev, cp, MAXPATHLEN - 5);
1669         dev[MAXPATHLEN-1] = 0;
1670         cp = dev;
1671     }
1672
1673     /*
1674      * Check if there is a device by this name.
1675      */
1676     if (stat(cp, &statbuf) < 0) {
1677         if (errno == ENOENT || quiet)
1678             return 0;
1679         option_error("Couldn't stat %s: %m", cp);
1680         return -1;
1681     }
1682
1683     (void) strncpy(devnam, cp, MAXPATHLEN);
1684     devnam[MAXPATHLEN-1] = 0;
1685     default_device = FALSE;
1686     devnam_info.priv = privileged_option;
1687     devnam_info.source = option_source;
1688
1689     return 1;
1690 }
1691
1692
1693 /*
1694  * setipaddr - Set the IP address
1695  */
1696 static int
1697 setipaddr(arg)
1698     char *arg;
1699 {
1700     struct hostent *hp;
1701     char *colon;
1702     u_int32_t local, remote;
1703     ipcp_options *wo = &ipcp_wantoptions[0];
1704
1705     /*
1706      * IP address pair separated by ":".
1707      */
1708     if ((colon = strchr(arg, ':')) == NULL)
1709         return 0;
1710
1711     /*
1712      * If colon first character, then no local addr.
1713      */
1714     if (colon != arg) {
1715         *colon = '\0';
1716         if ((local = inet_addr(arg)) == -1) {
1717             if ((hp = gethostbyname(arg)) == NULL) {
1718                 option_error("unknown host: %s", arg);
1719                 return -1;
1720             } else {
1721                 local = *(u_int32_t *)hp->h_addr;
1722             }
1723         }
1724         if (bad_ip_adrs(local)) {
1725             option_error("bad local IP address %s", ip_ntoa(local));
1726             return -1;
1727         }
1728         if (local != 0)
1729             wo->ouraddr = local;
1730         *colon = ':';
1731     }
1732
1733     /*
1734      * If colon last character, then no remote addr.
1735      */
1736     if (*++colon != '\0') {
1737         if ((remote = inet_addr(colon)) == -1) {
1738             if ((hp = gethostbyname(colon)) == NULL) {
1739                 option_error("unknown host: %s", colon);
1740                 return -1;
1741             } else {
1742                 remote = *(u_int32_t *)hp->h_addr;
1743                 if (remote_name[0] == 0) {
1744                     strncpy(remote_name, colon, MAXNAMELEN);
1745                     remote_name[MAXNAMELEN-1] = 0;
1746                 }
1747             }
1748         }
1749         if (bad_ip_adrs(remote)) {
1750             option_error("bad remote IP address %s", ip_ntoa(remote));
1751             return -1;
1752         }
1753         if (remote != 0)
1754             wo->hisaddr = remote;
1755     }
1756
1757     return 1;
1758 }
1759
1760
1761 /*
1762  * setnoipdflt - disable setipdefault()
1763  */
1764 static int
1765 setnoipdflt(argv)
1766     char **argv;
1767 {
1768     disable_defaultip = 1;
1769     return 1;
1770 }
1771
1772
1773 /*
1774  * setipcpaccl - accept peer's idea of our address
1775  */
1776 static int
1777 setipcpaccl(argv)
1778     char **argv;
1779 {
1780     ipcp_wantoptions[0].accept_local = 1;
1781     return 1;
1782 }
1783
1784
1785 /*
1786  * setipcpaccr - accept peer's idea of its address
1787  */
1788 static int
1789 setipcpaccr(argv)
1790     char **argv;
1791 {
1792     ipcp_wantoptions[0].accept_remote = 1;
1793     return 1;
1794 }
1795
1796
1797 /*
1798  * setnetmask - set the netmask to be used on the interface.
1799  */
1800 static int
1801 setnetmask(argv)
1802     char **argv;
1803 {
1804     u_int32_t mask, b;
1805     int n, ok;
1806     char *p, *endp;
1807
1808     /*
1809      * Unfortunately, if we use inet_addr, we can't tell whether
1810      * a result of all 1s is an error or a valid 255.255.255.255.
1811      */
1812     p = *argv;
1813     ok = 0;
1814     mask = 0;
1815     for (n = 3;; --n) {
1816         b = strtoul(p, &endp, 0);
1817         if (endp == p)
1818             break;
1819         if (b < 0 || b > 255) {
1820             if (n == 3) {
1821                 /* accept e.g. 0xffffff00 */
1822                 p = endp;
1823                 mask = b;
1824             }
1825             break;
1826         }
1827         mask |= b << (n * 8);
1828         p = endp;
1829         if (*p != '.' || n == 0)
1830             break;
1831         ++p;
1832     }
1833
1834     mask = htonl(mask);
1835
1836     if (*p != 0 || (netmask & ~mask) != 0) {
1837         option_error("invalid netmask value '%s'", *argv);
1838         return 0;
1839     }
1840
1841     netmask = mask;
1842     return (1);
1843 }
1844
1845 static int
1846 setcrtscts(argv)
1847     char **argv;
1848 {
1849     crtscts = 1;
1850     return (1);
1851 }
1852
1853 static int
1854 setnocrtscts(argv)
1855     char **argv;
1856 {
1857     crtscts = -1;
1858     return (1);
1859 }
1860
1861 static int
1862 setcdtrcts(argv)
1863     char **argv;
1864 {
1865     crtscts = 2;
1866     return (1);
1867 }
1868
1869 static int
1870 setxonxoff(argv)
1871     char **argv;
1872 {
1873     lcp_wantoptions[0].asyncmap |= 0x000A0000;  /* escape ^S and ^Q */
1874     lcp_wantoptions[0].neg_asyncmap = 1;
1875
1876     crtscts = -2;
1877     return (1);
1878 }
1879
1880 static int
1881 setnodetach(argv)
1882     char **argv;
1883 {
1884     nodetach = 1;
1885     return (1);
1886 }
1887
1888 static int
1889 setupdetach(argv)
1890     char **argv;
1891 {
1892     nodetach = -1;
1893     return (1);
1894 }
1895
1896 static int
1897 setdemand(argv)
1898     char **argv;
1899 {
1900     demand = 1;
1901     persist = 1;
1902     return 1;
1903 }
1904
1905 static int
1906 setmodem(argv)
1907     char **argv;
1908 {
1909     modem = 1;
1910     return 1;
1911 }
1912
1913 static int
1914 setlocal(argv)
1915     char **argv;
1916 {
1917     modem = 0;
1918     return 1;
1919 }
1920
1921 static int
1922 setlock(argv)
1923     char **argv;
1924 {
1925     lockflag = 1;
1926     return 1;
1927 }
1928
1929 static int
1930 setusehostname(argv)
1931     char **argv;
1932 {
1933     usehostname = 1;
1934     return 1;
1935 }
1936
1937 static int
1938 setname(argv)
1939     char **argv;
1940 {
1941     if (!privileged_option) {
1942         option_error("using the name option requires root privilege");
1943         return 0;
1944     }
1945     strncpy(our_name, argv[0], MAXNAMELEN);
1946     our_name[MAXNAMELEN-1] = 0;
1947     return 1;
1948 }
1949
1950 static int
1951 setuser(argv)
1952     char **argv;
1953 {
1954     strncpy(user, argv[0], MAXNAMELEN);
1955     user[MAXNAMELEN-1] = 0;
1956     return 1;
1957 }
1958
1959 static int
1960 setremote(argv)
1961     char **argv;
1962 {
1963     strncpy(remote_name, argv[0], MAXNAMELEN);
1964     remote_name[MAXNAMELEN-1] = 0;
1965     return 1;
1966 }
1967
1968 static int
1969 setauth(argv)
1970     char **argv;
1971 {
1972     auth_required = 1;
1973     if (privileged_option > auth_req_info.priv) {
1974         auth_req_info.priv = privileged_option;
1975         auth_req_info.source = option_source;
1976     }
1977     return 1;
1978 }
1979
1980 static int
1981 setnoauth(argv)
1982     char **argv;
1983 {
1984     if (auth_required && privileged_option < auth_req_info.priv) {
1985         option_error("cannot override auth option set by %s",
1986                      auth_req_info.source);
1987         return 0;
1988     }
1989     auth_required = 0;
1990     return 1;
1991 }
1992
1993 static int
1994 setdefaultroute(argv)
1995     char **argv;
1996 {
1997     if (!ipcp_allowoptions[0].default_route) {
1998         option_error("defaultroute option is disabled");
1999         return 0;
2000     }
2001     ipcp_wantoptions[0].default_route = 1;
2002     return 1;
2003 }
2004
2005 static int
2006 setnodefaultroute(argv)
2007     char **argv;
2008 {
2009     ipcp_allowoptions[0].default_route = 0;
2010     ipcp_wantoptions[0].default_route = 0;
2011     return 1;
2012 }
2013
2014 static int
2015 setproxyarp(argv)
2016     char **argv;
2017 {
2018     if (!ipcp_allowoptions[0].proxy_arp) {
2019         option_error("proxyarp option is disabled");
2020         return 0;
2021     }
2022     ipcp_wantoptions[0].proxy_arp = 1;
2023     return 1;
2024 }
2025
2026 static int
2027 setnoproxyarp(argv)
2028     char **argv;
2029 {
2030     ipcp_wantoptions[0].proxy_arp = 0;
2031     ipcp_allowoptions[0].proxy_arp = 0;
2032     return 1;
2033 }
2034
2035 static int
2036 setpersist(argv)
2037     char **argv;
2038 {
2039     persist = 1;
2040     return 1;
2041 }
2042
2043 static int
2044 setnopersist(argv)
2045     char **argv;
2046 {
2047     persist = 0;
2048     return 1;
2049 }
2050
2051 static int
2052 setdologin(argv)
2053     char **argv;
2054 {
2055     uselogin = 1;
2056     return 1;
2057 }
2058
2059 /*
2060  * Functions to set the echo interval for modem-less monitors
2061  */
2062
2063 static int
2064 setlcpechointv(argv)
2065     char **argv;
2066 {
2067     return int_option(*argv, &lcp_echo_interval);
2068 }
2069
2070 static int
2071 setlcpechofails(argv)
2072     char **argv;
2073 {
2074     return int_option(*argv, &lcp_echo_fails);
2075 }
2076
2077 /*
2078  * Functions to set timeouts, max transmits, etc.
2079  */
2080 static int
2081 setlcptimeout(argv)
2082     char **argv;
2083 {
2084     return int_option(*argv, &lcp_fsm[0].timeouttime);
2085 }
2086
2087 static int
2088 setlcpterm(argv)
2089     char **argv;
2090 {
2091     return int_option(*argv, &lcp_fsm[0].maxtermtransmits);
2092 }
2093
2094 static int
2095 setlcpconf(argv)
2096     char **argv;
2097 {
2098     return int_option(*argv, &lcp_fsm[0].maxconfreqtransmits);
2099 }
2100
2101 static int
2102 setlcpfails(argv)
2103     char **argv;
2104 {
2105     return int_option(*argv, &lcp_fsm[0].maxnakloops);
2106 }
2107
2108 static int
2109 setipcptimeout(argv)
2110     char **argv;
2111 {
2112     return int_option(*argv, &ipcp_fsm[0].timeouttime);
2113 }
2114
2115 static int
2116 setipcpterm(argv)
2117     char **argv;
2118 {
2119     return int_option(*argv, &ipcp_fsm[0].maxtermtransmits);
2120 }
2121
2122 static int
2123 setipcpconf(argv)
2124     char **argv;
2125 {
2126     return int_option(*argv, &ipcp_fsm[0].maxconfreqtransmits);
2127 }
2128
2129 static int
2130 setipcpfails(argv)
2131     char **argv;
2132 {
2133     return int_option(*argv, &lcp_fsm[0].maxnakloops);
2134 }
2135
2136 static int
2137 setpaptimeout(argv)
2138     char **argv;
2139 {
2140     return int_option(*argv, &upap[0].us_timeouttime);
2141 }
2142
2143 static int
2144 setpapreqtime(argv)
2145     char **argv;
2146 {
2147     return int_option(*argv, &upap[0].us_reqtimeout);
2148 }
2149
2150 static int
2151 setpapreqs(argv)
2152     char **argv;
2153 {
2154     return int_option(*argv, &upap[0].us_maxtransmits);
2155 }
2156
2157 static int
2158 setchaptimeout(argv)
2159     char **argv;
2160 {
2161     return int_option(*argv, &chap[0].timeouttime);
2162 }
2163
2164 static int
2165 setchapchal(argv)
2166     char **argv;
2167 {
2168     return int_option(*argv, &chap[0].max_transmits);
2169 }
2170
2171 static int
2172 setchapintv(argv)
2173     char **argv;
2174 {
2175     return int_option(*argv, &chap[0].chal_interval);
2176 }
2177
2178 static int
2179 noccp(argv)
2180     char **argv;
2181 {
2182     ccp_protent.enabled_flag = 0;
2183     return 1;
2184 }
2185
2186 static int
2187 setbsdcomp(argv)
2188     char **argv;
2189 {
2190     int rbits, abits;
2191     char *str, *endp;
2192
2193     str = *argv;
2194     abits = rbits = strtol(str, &endp, 0);
2195     if (endp != str && *endp == ',') {
2196         str = endp + 1;
2197         abits = strtol(str, &endp, 0);
2198     }
2199     if (*endp != 0 || endp == str) {
2200         option_error("invalid parameter '%s' for bsdcomp option", *argv);
2201         return 0;
2202     }
2203     if ((rbits != 0 && (rbits < BSD_MIN_BITS || rbits > BSD_MAX_BITS))
2204         || (abits != 0 && (abits < BSD_MIN_BITS || abits > BSD_MAX_BITS))) {
2205         option_error("bsdcomp option values must be 0 or %d .. %d",
2206                      BSD_MIN_BITS, BSD_MAX_BITS);
2207         return 0;
2208     }
2209     if (rbits > 0) {
2210         ccp_wantoptions[0].bsd_compress = 1;
2211         ccp_wantoptions[0].bsd_bits = rbits;
2212     } else
2213         ccp_wantoptions[0].bsd_compress = 0;
2214     if (abits > 0) {
2215         ccp_allowoptions[0].bsd_compress = 1;
2216         ccp_allowoptions[0].bsd_bits = abits;
2217     } else
2218         ccp_allowoptions[0].bsd_compress = 0;
2219     return 1;
2220 }
2221
2222 static int
2223 setnobsdcomp(argv)
2224     char **argv;
2225 {
2226     ccp_wantoptions[0].bsd_compress = 0;
2227     ccp_allowoptions[0].bsd_compress = 0;
2228     return 1;
2229 }
2230
2231 static int
2232 setdeflate(argv)
2233     char **argv;
2234 {
2235     int rbits, abits;
2236     char *str, *endp;
2237
2238     str = *argv;
2239     abits = rbits = strtol(str, &endp, 0);
2240     if (endp != str && *endp == ',') {
2241         str = endp + 1;
2242         abits = strtol(str, &endp, 0);
2243     }
2244     if (*endp != 0 || endp == str) {
2245         option_error("invalid parameter '%s' for deflate option", *argv);
2246         return 0;
2247     }
2248     if ((rbits != 0 && (rbits < DEFLATE_MIN_SIZE || rbits > DEFLATE_MAX_SIZE))
2249         || (abits != 0 && (abits < DEFLATE_MIN_SIZE
2250                           || abits > DEFLATE_MAX_SIZE))) {
2251         option_error("deflate option values must be 0 or %d .. %d",
2252                      DEFLATE_MIN_SIZE, DEFLATE_MAX_SIZE);
2253         return 0;
2254     }
2255     if (rbits > 0) {
2256         ccp_wantoptions[0].deflate = 1;
2257         ccp_wantoptions[0].deflate_size = rbits;
2258     } else
2259         ccp_wantoptions[0].deflate = 0;
2260     if (abits > 0) {
2261         ccp_allowoptions[0].deflate = 1;
2262         ccp_allowoptions[0].deflate_size = abits;
2263     } else
2264         ccp_allowoptions[0].deflate = 0;
2265     return 1;
2266 }
2267
2268 static int
2269 setnodeflate(argv)
2270     char **argv;
2271 {
2272     ccp_wantoptions[0].deflate = 0;
2273     ccp_allowoptions[0].deflate = 0;
2274     return 1;
2275 }
2276
2277 static int
2278 setnodeflatedraft(argv)
2279     char **argv;
2280 {
2281     ccp_wantoptions[0].deflate_draft = 0;
2282     ccp_allowoptions[0].deflate_draft = 0;
2283     return 1;
2284 }
2285
2286 static int
2287 setpred1comp(argv)
2288     char **argv;
2289 {
2290     ccp_wantoptions[0].predictor_1 = 1;
2291     ccp_allowoptions[0].predictor_1 = 1;
2292     return 1;
2293 }
2294
2295 static int
2296 setnopred1comp(argv)
2297     char **argv;
2298 {
2299     ccp_wantoptions[0].predictor_1 = 0;
2300     ccp_allowoptions[0].predictor_1 = 0;
2301     return 1;
2302 }
2303
2304 static int
2305 setipparam(argv)
2306     char **argv;
2307 {
2308     ipparam = strdup(*argv);
2309     if (ipparam == NULL)
2310         novm("ipparam string");
2311
2312     return 1;
2313 }
2314
2315 static int
2316 setpapcrypt(argv)
2317     char **argv;
2318 {
2319     cryptpap = 1;
2320     return 1;
2321 }
2322
2323 static int
2324 setidle(argv)
2325     char **argv;
2326 {
2327     return int_option(*argv, &idle_time_limit);
2328 }
2329
2330 static int
2331 setholdoff(argv)
2332     char **argv;
2333 {
2334     return int_option(*argv, &holdoff);
2335 }
2336
2337 /*
2338  * setdnsaddr - set the dns address(es)
2339  */
2340 static int
2341 setdnsaddr(argv)
2342     char **argv;
2343 {
2344     u_int32_t dns;
2345     struct hostent *hp;
2346
2347     dns = inet_addr(*argv);
2348     if (dns == -1) {
2349         if ((hp = gethostbyname(*argv)) == NULL) {
2350             option_error("invalid address parameter '%s' for ms-dns option",
2351                          *argv);
2352             return 0;
2353         }
2354         dns = *(u_int32_t *)hp->h_addr;
2355     }
2356
2357     /* if there is no primary then update it. */
2358     if (ipcp_allowoptions[0].dnsaddr[0] == 0)
2359         ipcp_allowoptions[0].dnsaddr[0] = dns;
2360
2361     /* always set the secondary address value to the same value. */
2362     ipcp_allowoptions[0].dnsaddr[1] = dns;
2363
2364     return (1);
2365 }
2366
2367 /*
2368  * setwinsaddr - set the wins address(es)
2369  * This is primrarly used with the Samba package under UNIX or for pointing
2370  * the caller to the existing WINS server on a Windows NT platform.
2371  */
2372 static int
2373 setwinsaddr(argv)
2374     char **argv;
2375 {
2376     u_int32_t wins;
2377     struct hostent *hp;
2378
2379     wins = inet_addr(*argv);
2380     if (wins == -1) {
2381         if ((hp = gethostbyname(*argv)) == NULL) {
2382             option_error("invalid address parameter '%s' for ms-wins option",
2383                          *argv);
2384             return 0;
2385         }
2386         wins = *(u_int32_t *)hp->h_addr;
2387     }
2388
2389     /* if there is no primary then update it. */
2390     if (ipcp_allowoptions[0].winsaddr[0] == 0)
2391         ipcp_allowoptions[0].winsaddr[0] = wins;
2392
2393     /* always set the secondary address value to the same value. */
2394     ipcp_allowoptions[0].winsaddr[1] = wins;
2395
2396     return (1);
2397 }
2398
2399 #ifdef IPX_CHANGE
2400 static int
2401 setipxrouter (argv)
2402     char **argv;
2403 {
2404     ipxcp_wantoptions[0].neg_router  = 1;
2405     ipxcp_allowoptions[0].neg_router = 1;
2406     return int_option(*argv, &ipxcp_wantoptions[0].router);
2407 }
2408
2409 static int
2410 setipxname (argv)
2411     char **argv;
2412 {
2413     char *dest = ipxcp_wantoptions[0].name;
2414     char *src  = *argv;
2415     int  count;
2416     char ch;
2417
2418     ipxcp_wantoptions[0].neg_name  = 1;
2419     ipxcp_allowoptions[0].neg_name = 1;
2420     memset (dest, '\0', sizeof (ipxcp_wantoptions[0].name));
2421
2422     count = 0;
2423     while (*src) {
2424         ch = *src++;
2425         if (! isalnum (ch) && ch != '_') {
2426             option_error("IPX router name must be alphanumeric or _");
2427             return 0;
2428         }
2429
2430         if (count >= sizeof (ipxcp_wantoptions[0].name)) {
2431             option_error("IPX router name is limited to %d characters",
2432                          sizeof (ipxcp_wantoptions[0].name) - 1);
2433             return 0;
2434         }
2435
2436         dest[count++] = toupper (ch);
2437     }
2438
2439     return 1;
2440 }
2441
2442 static int
2443 setipxcptimeout (argv)
2444     char **argv;
2445 {
2446     return int_option(*argv, &ipxcp_fsm[0].timeouttime);
2447 }
2448
2449 static int
2450 setipxcpterm (argv)
2451     char **argv;
2452 {
2453     return int_option(*argv, &ipxcp_fsm[0].maxtermtransmits);
2454 }
2455
2456 static int
2457 setipxcpconf (argv)
2458     char **argv;
2459 {
2460     return int_option(*argv, &ipxcp_fsm[0].maxconfreqtransmits);
2461 }
2462
2463 static int
2464 setipxcpfails (argv)
2465     char **argv;
2466 {
2467     return int_option(*argv, &ipxcp_fsm[0].maxnakloops);
2468 }
2469
2470 static int
2471 setipxnetwork(argv)
2472     char **argv;
2473 {
2474     u_int32_t v;
2475
2476     if (!number_option(*argv, &v, 16))
2477         return 0;
2478
2479     ipxcp_wantoptions[0].our_network = (int) v;
2480     ipxcp_wantoptions[0].neg_nn      = 1;
2481     return 1;
2482 }
2483
2484 static int
2485 setipxanet(argv)
2486     char **argv;
2487 {
2488     ipxcp_wantoptions[0].accept_network = 1;
2489     ipxcp_allowoptions[0].accept_network = 1;
2490     return 1;
2491 }
2492
2493 static int
2494 setipxalcl(argv)
2495     char **argv;
2496 {
2497     ipxcp_wantoptions[0].accept_local = 1;
2498     ipxcp_allowoptions[0].accept_local = 1;
2499     return 1;
2500 }
2501
2502 static int
2503 setipxarmt(argv)
2504     char **argv;
2505 {
2506     ipxcp_wantoptions[0].accept_remote = 1;
2507     ipxcp_allowoptions[0].accept_remote = 1;
2508     return 1;
2509 }
2510
2511 static u_char *
2512 setipxnodevalue(src,dst)
2513 u_char *src, *dst;
2514 {
2515     int indx;
2516     int item;
2517
2518     for (;;) {
2519         if (!isxdigit (*src))
2520             break;
2521
2522         for (indx = 0; indx < 5; ++indx) {
2523             dst[indx] <<= 4;
2524             dst[indx] |= (dst[indx + 1] >> 4) & 0x0F;
2525         }
2526
2527         item = toupper (*src) - '0';
2528         if (item > 9)
2529             item -= 7;
2530
2531         dst[5] = (dst[5] << 4) | item;
2532         ++src;
2533     }
2534     return src;
2535 }
2536
2537 static int
2538 setipxnode(argv)
2539     char **argv;
2540 {
2541     char *end;
2542
2543     memset (&ipxcp_wantoptions[0].our_node[0], 0, 6);
2544     memset (&ipxcp_wantoptions[0].his_node[0], 0, 6);
2545
2546     end = setipxnodevalue (*argv, &ipxcp_wantoptions[0].our_node[0]);
2547     if (*end == ':')
2548         end = setipxnodevalue (++end, &ipxcp_wantoptions[0].his_node[0]);
2549
2550     if (*end == '\0') {
2551         ipxcp_wantoptions[0].neg_node = 1;
2552         return 1;
2553     }
2554
2555     option_error("invalid parameter '%s' for ipx-node option", *argv);
2556     return 0;
2557 }
2558
2559 static int
2560 setipxproto(argv)
2561     char **argv;
2562 {
2563     ipxcp_protent.enabled_flag = 1;
2564     return 1;
2565 }
2566
2567 static int
2568 resetipxproto(argv)
2569     char **argv;
2570 {
2571     ipxcp_protent.enabled_flag = 0;
2572     return 1;
2573 }
2574 #else
2575
2576 static int
2577 resetipxproto(argv)
2578     char **argv;
2579 {
2580     return 1;
2581 }
2582 #endif /* IPX_CHANGE */
2583
2584 #ifdef MSLANMAN
2585 static int
2586 setmslanman(argv)
2587     char **argv;
2588 {
2589     ms_lanman = 1;
2590     return (1);
2591 }
2592 #endif