开通博客赚积分
发布资源赚积分
分类

源码开发语言/平台
当前位置：首页 > 源码/资料 > 嵌入式/单片机编程 > VxWorks > 查看源码
options.c
资源名称：vxwork_src.rar　[点击查看]
上传用户：nvosite88
上传日期：2007-01-17
资源大小：4983k
文件大小：36k
源码类别：

VxWorks

开发平台：

C/C++

options.c：源码内容
  1. /* options.c - handles option processing for PPP */
  3. /* Copyright 1995 Wind River Systems, Inc. */
  4. #include "copyright_wrs.h"
  6. /*
  7.  * Copyright (c) 1989 Carnegie Mellon University.
  8.  * All rights reserved.
  9.  *
  10.  * Redistribution and use in source and binary forms are permitted
  11.  * provided that the above copyright notice and this paragraph are
  12.  * duplicated in all such forms and that any documentation,
  13.  * advertising materials, and other materials related to such
  14.  * distribution and use acknowledge that the software was developed
  15.  * by Carnegie Mellon University.  The name of the
  16.  * University may not be used to endorse or promote products derived
  17.  * from this software without specific prior written permission.
  18.  * THIS SOFTWARE IS PROVIDED ``AS IS'' AND WITHOUT ANY EXPRESS OR
  19.  * IMPLIED WARRANTIES, INCLUDING, WITHOUT LIMITATION, THE IMPLIED
  20.  * WARRANTIES OF MERCHANTIBILITY AND FITNESS FOR A PARTICULAR PURPOSE.
  21.  */
  23. /*
  24. modification history
  25. --------------------
  26. 01m,29nov95,vin  added code to accept hostnames for local_adrs & remote_adrs
  27. 01l,05jul95,dzb  close fd's in setupapfile() and setchapfile().
  28. 01k,23jun95,dzb  fixed setipcpfails() to access ipcp, not lcp.
  29.                  removed usehostname option.
  30. 01j,16jun95,dzb  header file consolidation.  removed perror() references.
  31. 01i,22may95,dzb  Changed pap/chap_require_file to just pap/chap_require.
  32.                  Changed to no params for reqpap() and reqchap().
  33. 01h,05may95,dzb  removed parsing code in setupapfile() (original +ua file).
  34.  fixed getword() for "/n", then EOF exit condition.
  35.  added setpasswd() for setting passwd[].
  36.                  re-activated "login" option.
  37. 01g,16feb95,dab  added stringdup() call for pap_file in setupapfile().
  38. 01f,13feb95,dab  added call out to setchapfile() in parse_args() (SPR #4072).
  39. 01e,09feb95,dab  removed "login" option.
  40. 01d,07feb95,dab  only parse options struct if one is specified.
  41. 01c,18jan95,dzb  ifdef'ed out usage().
  42. 01b,16jan95,dab  ifdef'ed out options_from_user(), options_for_tty().
  43. 01a,21dec94,dab  VxWorks port - first WRS version.
  44.    +dzb  added: path for ppp header files, WRS copyright.
  45. */
  47. #include <vxWorks.h>
  48. #include <stdlib.h>
  49. #include <stdio.h>
  50. #include <errno.h>
  51. #include <hostLib.h>
  52. #include <ioLib.h>
  53. #include <inetLib.h>
  54. #include <string.h>
  55. #include <sys/types.h>
  56. #include <sys/stat.h>
  57. #include <netinet/in.h>
  58. #include <ctype.h>
  59. #include "pppLib.h"
  61. #ifndef GIDSET_TYPE
  62. #define GIDSET_TYPE     int
  63. #endif
  65. /*
  66.  * Prototypes
  67.  */
  68. static int setdebug __ARGS((void));
  69. static int setkdebug __ARGS((void));
  70. static int setpassive __ARGS((void));
  71. static int setsilent __ARGS((void));
  72. static int noopt __ARGS((void));
  73. static int setnovj __ARGS((void));
  74. static int setnovjccomp __ARGS((void));
  75. static int setvjslots __ARGS((char *));
  76. static int nopap __ARGS((void));
  77. static int nochap __ARGS((void));
  78. static int reqpap __ARGS((void));
  79. static int reqchap __ARGS((void));
  80. static int setchapfile __ARGS((char *));
  81. static int setupapfile __ARGS((char *));
  82. static int setspeed __ARGS((int, int));
  83. static int noaccomp __ARGS((void));
  84. static int noasyncmap __ARGS((void));
  85. static int noipaddr __ARGS((void));
  86. static int nomagicnumber __ARGS((void));
  87. static int setasyncmap __ARGS((char *));
  88. static int setescape __ARGS((char *));
  89. static int setmru __ARGS((char *));
  90. static int setmtu __ARGS((char *));
  91. static int nomru __ARGS((void));
  92. static int nopcomp __ARGS((void));
  93. static int setnetmask __ARGS((char *));
  94. static int setname __ARGS((char *));
  95. static int setuser __ARGS((char *));
  96. static int setpasswd __ARGS((char *));
  97. static int setremote __ARGS((char *));
  98. static int readfile __ARGS((char *));
  99. static int setdefaultroute __ARGS((void));
  100. static int setproxyarp __ARGS((void));
  101. static int setdologin __ARGS((void));
  102. static int setlcptimeout __ARGS((char *));
  103. static int setlcpterm __ARGS((char *));
  104. static int setlcpconf __ARGS((char *));
  105. static int setlcpfails __ARGS((char *));
  106. static int setipcptimeout __ARGS((char *));
  107. static int setipcpterm __ARGS((char *));
  108. static int setipcpconf __ARGS((char *));
  109. static int setipcpfails __ARGS((char *));
  110. static int setpaptimeout __ARGS((char *));
  111. static int setpapreqs __ARGS((char *));
  112. static int setchaptimeout __ARGS((char *));
  113. static int setchapchal __ARGS((char *));
  114. static int setchapintv __ARGS((char *));
  115. static int setipcpaccl __ARGS((void));
  116. static int setipcpaccr __ARGS((void));
  117. static int setlcpechointv __ARGS((char *));
  118. static int setlcpechofails __ARGS((char *));
  120. static int number_option __ARGS((char *, long *, int));
  121. static int readable __ARGS((int fd));
  123. /*
  124.  * Valid arguments.
  125.  */
  126. static struct cmd {
  127.     char *cmd_name;
  128.     int num_args;
  129.     int (*cmd_func)();
  130. } cmds[] = {
  131.     {"no_all", 0, noopt}, /* Don't request/allow any options */
  132.     {"no_acc", 0, noaccomp}, /* Disable Address/Control compress */
  133.     {"no_asyncmap", 0, noasyncmap}, /* Disable asyncmap negotiation */
  134.     {"debug", 0, setdebug}, /* Enable the daemon debug mode */
  135.     {"driver_debug", 1, setkdebug}, /* Enable driver-level debugging */
  136.     {"no_ip", 0, noipaddr}, /* Disable IP address negotiation */
  137.     {"no_mn", 0, nomagicnumber}, /* Disable magic number negotiation */
  138.     {"no_mru", 0, nomru}, /* Disable mru negotiation */
  139.     {"passive_mode", 0, setpassive}, /* Set passive mode */
  140.     {"no_pc", 0, nopcomp}, /* Disable protocol field compress */
  141.     {"no_pap", 0, nopap}, /* Don't allow UPAP authentication with peer */
  142.     {"no_chap", 0, nochap}, /* Don't allow CHAP authentication with peer */
  143.     {"require_pap", 0, reqpap}, /* Require PAP auth from peer */
  144.     {"require_chap", 0, reqchap}, /* Require CHAP auth from peer */
  145.     {"no_vj", 0, setnovj}, /* disable VJ compression */
  146.     {"no_vjccomp", 0, setnovjccomp}, /* disable VJ connection-ID compression */
  147.     {"silent_mode", 0, setsilent}, /* Set silent mode */
  148.     {"defaultroute", 0, setdefaultroute}, /* Add default route */
  149.     {"proxyarp", 0, setproxyarp}, /* Add proxy ARP entry */
  150.     {"login", 0, setdologin}, /* Use system password database for UPAP */
  151.     {"ipcp_accept_local", 0, setipcpaccl}, /* Accept peer's address for us */
  152.     {"ipcp_accept_remote", 0, setipcpaccr}, /* Accept peer's address for it */
  153.     {"asyncmap", 1, setasyncmap}, /* set the desired async map */
  154.     {"vj_max_slots", 1, setvjslots}, /* Set maximum VJ header slots */
  155.     {"escape_chars", 1, setescape}, /* set chars to escape on transmission */
  156.     {"pap_file", 1, setupapfile}, /* Get PAP user and password from file */
  157.     {"chap_file", 1, setchapfile}, /* Get CHAP info */
  158.     {"mru", 1, setmru}, /* Set MRU value for negotiation */
  159.     {"mtu", 1, setmtu}, /* Set our MTU */
  160.     {"netmask", 1, setnetmask}, /* Set netmask */
  161.     {"local_auth_name", 1, setname}, /* Set local name for authentication */
  162.     {"pap_user_name", 1, setuser}, /* Set username for PAP auth with peer */
  163.     {"pap_passwd", 1, setpasswd}, /* Set password for PAP auth with peer */
  164.     {"remote_auth_name", 1, setremote}, /* Set remote name for authentication */
  165.     {"lcp_echo_failure", 1, setlcpechofails}, /* consecutive echo failures */
  166.     {"lcp_echo_interval", 1, setlcpechointv}, /* time for lcp echo events */
  167.     {"lcp_restart", 1, setlcptimeout}, /* Set timeout for LCP */
  168.     {"lcp_max_terminate", 1, setlcpterm}, /* Set max #xmits for term-reqs */
  169.     {"lcp_max_configure", 1, setlcpconf}, /* Set max #xmits for conf-reqs */
  170.     {"lcp_max_failure", 1, setlcpfails}, /* Set max #conf-naks for LCP */
  171.     {"ipcp_restart", 1, setipcptimeout}, /* Set timeout for IPCP */
  172.     {"ipcp_max_terminate", 1, setipcpterm}, /* Set max #xmits for term-reqs */
  173.     {"ipcp_max_configure", 1, setipcpconf}, /* Set max #xmits for conf-reqs */
  174.     {"ipcp_max_failure", 1, setipcpfails}, /* Set max #conf-naks for IPCP */
  175.     {"pap_restart", 1, setpaptimeout}, /* Set timeout for UPAP */
  176.     {"pap_max_authreq", 1, setpapreqs}, /* Set max #xmits for auth-reqs */
  177.     {"chap_restart", 1, setchaptimeout}, /* Set timeout for CHAP */
  178.     {"chap_max_challenge", 1, setchapchal}, /* Set max #xmits for challenge */
  179.     {"chap_interval", 1, setchapintv}, /* Set interval for rechallenge */
  180.     {NULL, 0, NULL}
  181. };
  183. #ifdef notyet
  185. #ifndef IMPLEMENTATION
  186. #define IMPLEMENTATION ""
  187. #endif
  189. static char *usage_string = "
  190. pppd version %s patch level %d%sn
  191. Usage: %s [ arguments ], where arguments are:n
  192.         <device>        Communicate over the named devicen
  193.         <speed>         Set the baud rate to <speed>n
  194.         <loc>:<rem>     Set the local and/or remote interface IPn
  195.                         addresses.  Either one may be omitted.n
  196.         asyncmap <n>    Set the desired async map to hex <n>n
  197.         auth            Require authentication from peern
  198.         connect <p>     Invoke shell command <p> to set up the serial linen
  199.         defaultroute    Add default route through interfacen
  200.         file <f>        Take options from file <f>n
  201.         modem           Use modem control linesn
  202.         mru <n>         Set MRU value to <n> for negotiationn
  203.         netmask <n>     Set interface netmask to <n>n
  204. See pppd(8) for more options.n
  205. ";
  206. #endif /* notyet */
  209. /*
  210.  * parse_args - parse a string of arguments, from the command
  211.  * line or from a file.
  212.  */
  213. int
  214. parse_args(unit, devname, local_addr, remote_addr, baud, options, fileName)
  215.     int unit;
  216.     char *devname;
  217.     char *local_addr;
  218.     char *remote_addr;
  219.     int baud;
  220.     PPP_OPTIONS *options;
  221.     char *fileName;
  222. {
  223.     if (options) {
  224.         if (options->flags & OPT_NO_ALL)
  225.             noopt();
  227.         if (options->flags & OPT_NO_ACC)
  228.             noaccomp();
  230.         if (options->flags & OPT_NO_ASYNCMAP)
  231.             noasyncmap();
  233.         if (options->flags & OPT_DEBUG)
  234.             setdebug();
  236.         if (options->flags & OPT_DRIVER_DEBUG)
  237.             setkdebug();
  239.         if (options->flags & OPT_NO_IP)
  240.             noipaddr();
  242.         if (options->flags & OPT_NO_MN)
  243.             nomagicnumber();
  245.         if (options->flags & OPT_NO_MRU)
  246.             nomru();
  248.         if (options->flags & OPT_PASSIVE_MODE)
  249.             setpassive();
  251.         if (options->flags & OPT_NO_PC)
  252.             nopcomp();
  254.         if (options->flags & OPT_NO_PAP)
  255.             nopap();
  257.         if (options->flags & OPT_NO_CHAP)
  258.             nochap();
  260.         if (options->flags & OPT_REQUIRE_PAP)
  261.             reqpap();
  263.         if (options->flags & OPT_REQUIRE_CHAP)
  264.             reqchap();
  266.         if (options->flags & OPT_NO_VJ)
  267.             setnovj();
  269.         if (options->flags & OPT_NO_VJCCOMP)
  270.             setnovjccomp();
  272.         if (options->flags & OPT_SILENT_MODE)
  273.             setsilent();
  275.         if (options->flags & OPT_DEFAULTROUTE)
  276.             setdefaultroute();
  278.         if (options->flags & OPT_PROXYARP)
  279.             setproxyarp();
  281.         if (options->flags & OPT_LOGIN)
  282.             setdologin();
  284.         if (options->flags & OPT_IPCP_ACCEPT_LOCAL)
  285.             setipcpaccl();
  287.         if (options->flags & OPT_IPCP_ACCEPT_REMOTE)
  288.             setipcpaccr();
  290.         if (options->asyncmap)
  291.             if (!setasyncmap(options->asyncmap)) {
  292.         syslog(LOG_ERR, "asyncmap error");
  293.         return 0;
  294.             }
  296.         if (options->vj_max_slots)
  297.             if (!setvjslots(options->vj_max_slots)) {
  298.         syslog(LOG_ERR, "vj_max_slots error");
  299.         return 0;
  300.             }
  302.         if (options->escape_chars)
  303.             if (!setescape(options->escape_chars)) {
  304.         syslog(LOG_ERR, "escape chars error");
  305.         return 0;
  306.             }
  308.         if (options->pap_file)
  309.             if (!setupapfile(options->pap_file)) {
  310.         syslog(LOG_ERR, "pap file error");
  311.         return 0;
  312.             }
  314.         if (options->chap_file)
  315.             if (!setchapfile(options->chap_file)) {
  316.                 syslog(LOG_ERR, "chap file error");
  317.                 return 0;
  318.             }
  320.         if (options->mru)
  321.             if (!setmru(options->mru)) {
  322.         syslog(LOG_ERR, "mru error");
  323.         return 0;
  324.             }
  326.         if (options->mtu)
  327.             if (!setmtu(options->mtu)) {
  328.         syslog(LOG_ERR, "mtu error");
  329.         return 0;
  330.             }
  332.         if (options->netmask)
  333.             if (!setnetmask(options->netmask)) {
  334.         syslog(LOG_ERR, "netmask error");
  335.         return 0;
  336.             }
  338.         if (options->local_auth_name)
  339.             if (!setname(options->local_auth_name)) {
  340.         syslog(LOG_ERR, "local auth name error");
  341.         return 0;
  342.             }
  344.         if (options->pap_user_name)
  345.             if (!setuser(options->pap_user_name)) {
  346.         syslog(LOG_ERR, "pap auth name error");
  347.         return 0;
  348.             }
  350.         if (options->pap_passwd)
  351.             if (!setpasswd(options->pap_passwd)) {
  352.         syslog(LOG_ERR, "pap auth password error");
  353.         return 0;
  354.             }
  356.         if (options->remote_auth_name)
  357.             if (!setremote(options->remote_auth_name)) {
  358.         syslog(LOG_ERR, "remote auth name error");
  359.         return 0;
  360.             }
  362.         if (options->lcp_echo_failure)
  363.             if (!setlcpechofails(options->lcp_echo_failure)) {
  364.         syslog(LOG_ERR, "lcp echo failure error");
  365.         return 0;
  366.             }
  368.         if (options->lcp_echo_interval)
  369.             if (!setlcpechointv(options->lcp_echo_interval)) {
  370.         syslog(LOG_ERR, "lcp echo interval error");
  371.         return 0;
  372.             }
  374.         if (options->lcp_restart)
  375.             if (!setlcptimeout(options->lcp_restart)) {
  376.         syslog(LOG_ERR, "lcp timeout error");
  377.         return 0;
  378.             }
  380.         if (options->lcp_max_terminate)
  381.             if (!setlcpterm(options->lcp_max_terminate)) {
  382.         syslog(LOG_ERR, "lcp max terminate error");
  383.         return 0;
  384.             }
  386.         if (options->lcp_max_configure)
  387.             if (!setlcpconf(options->lcp_max_configure)) {
  388.         syslog(LOG_ERR, "lcp max configure error");
  389.         return 0;
  390.             }
  392.         if (options->lcp_max_failure)
  393.             if (!setlcpfails(options->lcp_max_failure)) {
  394.         syslog(LOG_ERR, "lcp max failure error");
  395.         return 0;
  396.             }
  398.         if (options->ipcp_restart)
  399.             if (!setipcptimeout(options->ipcp_restart)) {
  400.         syslog(LOG_ERR, "ipcp restart error");
  401.         return 0;
  402.             }
  404.         if (options->ipcp_max_terminate)
  405.             if (!setipcpterm(options->ipcp_max_terminate)) {
  406.         syslog(LOG_ERR, "ipcp max terminate error");
  407.         return 0;
  408.             }
  410.         if (options->ipcp_max_configure)
  411.             if (!setipcpconf(options->ipcp_max_configure)) {
  412.         syslog(LOG_ERR, "ipcp max configure error");
  413.         return 0;
  414.             }
  416.         if (options->ipcp_max_failure)
  417.             if (!setipcpfails(options->ipcp_max_failure)) {
  418.         syslog(LOG_ERR, "ipcp max failure error");
  419.         return 0;
  420.             }
  422.         if (options->pap_restart)
  423.             if (!setpaptimeout(options->pap_restart)) {
  424.         syslog(LOG_ERR, "pap restart error");
  425.         return 0;
  426.             }
  428.         if (options->pap_max_authreq)
  429.             if (!setpapreqs(options->pap_max_authreq)) {
  430.         syslog(LOG_ERR, "pap max reqs error");
  431.         return 0;
  432.             }
  434.         if (options->chap_restart)
  435.             if (!setchaptimeout(options->chap_restart)) {
  436.         syslog(LOG_ERR, "chap restart error");
  437.         return 0;
  438.             }
  440.         if (options->chap_max_challenge)
  441.             if (!setchapchal(options->chap_max_challenge)) {
  442.         syslog(LOG_ERR, "chap max challenge error");
  443.         return 0;
  444.             }
  446.         if (options->chap_interval)
  447.             if (!setchapintv(options->chap_interval)) {
  448.         syslog(LOG_ERR, "chap interval error");
  449.         return 0;
  450.             }
  451.     }
  453.     if (fileName)
  454.         if (!readfile(fileName)) {
  455.     syslog(LOG_ERR, "options file error");
  456.     return 0;
  457.         }
  459.     if (!setdevname(devname)) {
  460. syslog(LOG_ERR, "error setting device name");
  461. return 0;
  462.     }
  464.     if (!setspeed(baud, 0)) {
  465. syslog(LOG_ERR, "error setting baud rate");
  466. return 0;
  467.     }
  469.     if (!setipaddr(local_addr, remote_addr)) {
  470. syslog(LOG_ERR, "error setting address");
  471. return 0;
  472.     }
  474.     return 1;
  475. }
  477. /*
  478.  * usage - print out a message telling how to use the program.
  479.  */
  481. #ifdef notyet
  482. static void
  483. usage()
  484. {
  485.     logMsg(usage_string, VERSION, PATCHLEVEL, IMPLEMENTATION,
  486.            "pppInit");
  487. }
  488. #endif /* notyet */
  490. /*
  491.  * options_from_file - Read a string of options from a file,
  492.  * and interpret them.
  493.  */
  494. int
  495. options_from_file(fileName, must_exist, check_prot)
  496.     char *fileName;
  497.     int must_exist;
  498.     int check_prot;
  499. {
  500.     FILE *f;
  501.     int i, newline;
  502.     struct cmd *cmdp;
  503.     char *argv[MAXARGS];
  504.     char args[MAXARGS][MAXWORDLEN];
  505.     char cmd[MAXWORDLEN];
  507.     if ((f = fopen(fileName, "r")) == NULL) {
  508. if (!must_exist)
  509.     return 1;
  510.         syslog(LOG_ERR, "%s: could not openn", fileName);
  511. return 0;
  512.     }
  513.     if (check_prot && !readable(fileno(f))) {
  514.         syslog(LOG_ERR, "%s: access deniedn", fileName);
  515.         fclose(f);
  516.         return 0;
  517.     }
  519.     while (getword(f, cmd, &newline, fileName)) {
  520. /*
  521.  * First see if it's a command.
  522.  */
  523. for (cmdp = cmds; cmdp->cmd_name; cmdp++)
  524.     if (!strcmp(cmd, cmdp->cmd_name))
  525. break;
  527. if (cmdp->cmd_name != NULL) {
  528.     for (i = 0; i < cmdp->num_args; ++i) {
  529. if (!getword(f, args[i], &newline, fileName)) {
  530.     syslog(LOG_ERR,
  531.     "In file %s: too few parameters for command %sn",
  532.     fileName, cmd);
  533.     fclose(f);
  534.     return 0;
  535. }
  536. argv[i] = args[i];
  537.     }
  538.     if (!(*cmdp->cmd_func)(argv[0])) {
  539. fclose(f);
  540. return 0;
  541.     }
  543. } else {
  544.     syslog(LOG_ERR, "In file %s: unrecognized command %sn",
  545.                    fileName, cmd);
  546.             fclose(f);
  547.             return 0;
  548. }
  549.     }
  550.     fclose(f);
  551.     return 1;
  552. }
  554. #ifdef notyet
  556. /*
  557.  * options_from_user - See if the use has a ~/.ppprc file,
  558.  * and if so, interpret options from it.
  559.  */
  560. int
  561. options_from_user()
  562. {
  563.     char *user, *path, *file;
  564.     int ret;
  566.     if (user[0] == 0)
  567.         return 1;
  568.     file = _PATH_USEROPT;
  569.     path = (char *)malloc(strlen(user) + strlen(file) + 2);
  570.     if (path == NULL)
  571.         novm("init file name");
  572.     strcpy(path, user);
  573.     strcat(path, "/");
  574.     strcat(path, file);
  575.     ret = options_from_file(path, 0, 1);
  576.     free(path);
  577.     return ret;
  578. }
  580. /*
  581.  * options_for_tty - See if an options file exists for the serial
  582.  * device, and if so, interpret options from it.
  583.  */
  584. int
  585. options_for_tty(devname)
  586.     char *devname;
  587. {
  588.     char *dev, *path;
  589.     int ret;
  591.     dev = strrchr(devname, '/');
  592.     if (dev == NULL)
  593.         dev = devname;
  594.     else
  595.         ++dev;
  596.     if (strcmp(dev, "tty") == 0)
  597.         return 1;               /* don't look for /etc/ppp/options.tty */
  598.     path = (char *)malloc(strlen(_PATH_TTYOPT) + strlen(dev) + 1);
  599.     if (path == NULL)
  600.         novm("tty init file name");
  601.     strcpy(path, _PATH_TTYOPT);
  602.     strcat(path, dev);
  603.     ret = options_from_file(path, 0, 0);
  604.     free(path);
  605.     return ret;
  606. }
  608. #endif /* notyet */
  610. /*
  611.  * readable - check if a file is readable by the real user.
  612.  */
  613. static int
  614. readable(fd)
  615.     int fd;
  616. {
  617. #ifdef notyet
  618.     uid_t uid;
  619.     int ngroups, i;
  620.     struct stat sbuf;
  621.     GIDSET_TYPE groups[NGROUPS_MAX];
  623.     uid = getuid();
  624.     if (uid == 0)
  625.         return 1;
  626.     if (fstat(fd, &sbuf) != 0)
  627.         return 0;
  628.     if (sbuf.st_uid == uid)
  629.         return sbuf.st_mode & S_IRUSR;
  630.     if (sbuf.st_gid == getgid())
  631.         return sbuf.st_mode & S_IRGRP;
  632.     ngroups = getgroups(NGROUPS_MAX, groups);
  633.     for (i = 0; i < ngroups; ++i)
  634.         if (sbuf.st_gid == groups[i])
  635.             return sbuf.st_mode & S_IRGRP;
  636.     return sbuf.st_mode & S_IROTH;
  637. #else /* notyet */
  638.     return 1;
  639. #endif /* notyet */
  640. }
  642. /*
  643.  * Read a word from a file.
  644.  * Words are delimited by white-space or by quotes (").
  645.  * Quotes, white-space and  may be escaped with .
  646.  * <newline> is ignored.
  647.  */
  648. int
  649. getword(f, word, newlinep, fileName)
  650.     FILE *f;
  651.     char *word;
  652.     int *newlinep;
  653.     char *fileName;
  654. {
  655.     int c, len, escape;
  656.     int quoted;
  658.     *newlinep = 0;
  659.     len = 0;
  660.     escape = 0;
  661.     quoted = 0;
  663.     /*
  664.      * First skip white-space and comments
  665.      */
  666.     while ((c = getc(f)) != EOF) {
  667. if (c == '\') {
  668.     /*
  669.      * <newline> is ignored;  followed by anything else
  670.      * starts a word.
  671.      */
  672.     if ((c = getc(f)) == 'n')
  673. continue;
  674.     word[len++] = '\';
  675.     escape = 1;
  676.     break;
  677. }
  678. if (c == 'n')
  679.     *newlinep = 1; /* next word starts a line */
  680. else if (c == '#') {
  681.     /* comment - ignore until EOF or n */
  682.     while ((c = getc(f)) != EOF && c != 'n')
  683. ;
  684.     if (c == EOF)
  685. break;
  686.     *newlinep = 1;
  687. } else if (!isspace(c))
  688.     break;
  689.     }
  691.     /*
  692.      * End of file or error - fail
  693.      */
  694.     if (c == EOF) {
  695. if (ferror(f)) {
  696.             syslog(LOG_ERR, "%s: EOFn", fileName);
  697.     die(ppp_unit, 1);
  698. }
  699.         *newlinep = 0; /* added to make sure scan_authfile() exits -dzb */
  700. return 0;
  701.     }
  703.     for (;;) {
  704. /*
  705.  * Is this character escaped by  ?
  706.  */
  707. if (escape) {
  708.     if (c == 'n')
  709. --len; /* ignore <newline> */
  710.     else if (c == '"' || isspace(c) || c == '\')
  711. word[len-1] = c; /* put special char in word */
  712.     else {
  713. if (len < MAXWORDLEN-1)
  714.     word[len] = c;
  715. ++len;
  716.     }
  717.     escape = 0;
  718. } else if (c == '"') {
  719.     quoted = !quoted;
  720. } else if (!quoted && (isspace(c) || c == '#')) {
  721.     ungetc(c, f);
  722.     break;
  723. } else {
  724.     if (len < MAXWORDLEN-1)
  725. word[len] = c;
  726.     ++len;
  727.     if (c == '\')
  728. escape = 1;
  729. }
  730. if ((c = getc(f)) == EOF)
  731.     break;
  732.     }
  734.     if (ferror(f)) {
  735.         syslog(LOG_ERR, "%s: errorn", fileName);
  736. die(ppp_unit, 1);
  737.     }
  739.     if (len >= MAXWORDLEN) {
  740. word[MAXWORDLEN-1] = 0;
  741. syslog(LOG_WARNING, "warning: word in file %s too long (%.20s...)n",
  742. fileName, word);
  743.     } else
  744. word[len] = 0;
  746.     return 1;
  747. }
  749. /*
  750.  * number_option - parse a numeric parameter for an option
  751.  */
  752. static int
  753. number_option(str, valp, base)
  754.     char *str;
  755.     long *valp;
  756.     int base;
  757. {
  758.     char *ptr;
  760.     *valp = strtoul(str, &ptr, base);
  761.     if (errno == ERANGE) {
  762.         syslog(LOG_ERR, "invalid number: %s", str);
  763. return 0;
  764.     }
  765.     return 1;
  766. }
  769. /*
  770.  * int_option - like number_option, but valp is int *,
  771.  * the base is assumed to be 0, and *valp is not changed
  772.  * if there is an error.
  773.  */
  774. static int
  775. int_option(str, valp)
  776.     char *str;
  777.     int *valp;
  778. {
  779.     long v;
  781.     if (!number_option(str, &v, 0))
  782. return 0;
  783.     *valp = (int) v;
  784.     return 1;
  785. }
  788. /*
  789.  * The following procedures execute commands.
  790.  */
  792. /*
  793.  * readfile - take commands from a file.
  794.  */
  795. static int
  796. readfile(argv)
  797.     char *argv;
  798. {
  799.     return options_from_file(argv, 1, 1);
  800. }
  802. /*
  803.  * setdebug - Set debug (command line argument).
  804.  */
  805. static int
  806. setdebug()
  807. {
  808.     ppp_if[ppp_unit]->debug = 1;
  809.     return (1);
  810. }
  812. /*
  813.  * setkdebug - Set kernel debugging level.
  814.  */
  815. static int
  816. setkdebug()
  817. {
  818.     ppp_if[ppp_unit]->kdebugflag = 1;
  819.     return (1);
  820. }
  822. /*
  823.  * noopt - Disable all options.
  824.  */
  825. static int
  826. noopt()
  827. {
  828.     BZERO((char *) &ppp_if[ppp_unit]->lcp_wantoptions,
  829.           sizeof (struct lcp_options));
  830.     BZERO((char *) &ppp_if[ppp_unit]->lcp_allowoptions,
  831.           sizeof (struct lcp_options));
  832.     BZERO((char *) &ppp_if[ppp_unit]->ipcp_wantoptions,
  833.           sizeof (struct ipcp_options));
  834.     BZERO((char *) &ppp_if[ppp_unit]->ipcp_allowoptions,
  835.           sizeof (struct ipcp_options));
  836.     return (1);
  837. }
  839. /*
  840.  * noaccomp - Disable Address/Control field compression negotiation.
  841.  */
  842. static int
  843. noaccomp()
  844. {
  845.     ppp_if[ppp_unit]->lcp_wantoptions.neg_accompression = 0;
  846.     ppp_if[ppp_unit]->lcp_allowoptions.neg_accompression = 0;
  847.     return (1);
  848. }
  851. /*
  852.  * noasyncmap - Disable async map negotiation.
  853.  */
  854. static int
  855. noasyncmap()
  856. {
  857.     ppp_if[ppp_unit]->lcp_wantoptions.neg_asyncmap = 0;
  858.     ppp_if[ppp_unit]->lcp_allowoptions.neg_asyncmap = 0;
  859.     return (1);
  860. }
  863. /*
  864.  * noipaddr - Disable IP address negotiation.
  865.  */
  866. static int
  867. noipaddr()
  868. {
  869.     ppp_if[ppp_unit]->ipcp_wantoptions.neg_addr = 0;
  870.     ppp_if[ppp_unit]->ipcp_allowoptions.neg_addr = 0;
  871.     return (1);
  872. }
  875. /*
  876.  * nomagicnumber - Disable magic number negotiation.
  877.  */
  878. static int
  879. nomagicnumber()
  880. {
  881.     ppp_if[ppp_unit]->lcp_wantoptions.neg_magicnumber = 0;
  882.     ppp_if[ppp_unit]->lcp_allowoptions.neg_magicnumber = 0;
  883.     return (1);
  884. }
  887. /*
  888.  * nomru - Disable mru negotiation.
  889.  */
  890. static int
  891. nomru()
  892. {
  893.     ppp_if[ppp_unit]->lcp_wantoptions.neg_mru = 0;
  894.     ppp_if[ppp_unit]->lcp_allowoptions.neg_mru = 0;
  895.     return (1);
  896. }
  899. /*
  900.  * setmru - Set MRU for negotiation.
  901.  */
  902. static int
  903. setmru(argv)
  904.     char *argv;
  905. {
  906.     long mru;
  908.     if (!number_option(argv, &mru, 0))
  909.         return 0;
  910.     ppp_if[ppp_unit]->lcp_wantoptions.mru = mru;
  911.     ppp_if[ppp_unit]->lcp_wantoptions.neg_mru = 1;
  912.     return (1);
  913. }
  916. /*
  917.  * setmtu - Set the largest MTU we'll use.
  918.  */
  919. static int
  920. setmtu(argv)
  921.     char *argv;
  922. {
  923.     long mtu;
  925.     if (!number_option(argv, &mtu, 0))
  926.         return 0;
  927.     if (mtu < MINMRU || mtu > MAXMRU) {
  928.         syslog(LOG_ERR, "mtu option value of %d is too %sn", mtu,
  929.                 (mtu < MINMRU? "small": "large"));
  930.         return 0;
  931.     }
  932.     ppp_if[ppp_unit]->lcp_allowoptions.mru = mtu;
  933.     return (1);
  934. }
  937. /*
  938.  * nopcomp - Disable Protocol field compression negotiation.
  939.  */
  940. static int
  941. nopcomp()
  942. {
  943.     ppp_if[ppp_unit]->lcp_wantoptions.neg_pcompression = 0;
  944.     ppp_if[ppp_unit]->lcp_allowoptions.neg_pcompression = 0;
  945.     return (1);
  946. }
  949. /*
  950.  * setpassive - Set passive mode (don't give up if we time out sending
  951.  * LCP configure-requests).
  952.  */
  953. static int
  954. setpassive()
  955. {
  956.     ppp_if[ppp_unit]->lcp_wantoptions.passive = 1;
  957.     return (1);
  958. }
  961. /*
  962.  * setsilent - Set silent mode (don't start sending LCP configure-requests
  963.  * until we get one from the peer).
  964.  */
  965. static int
  966. setsilent()
  967. {
  968.     ppp_if[ppp_unit]->lcp_wantoptions.silent = 1;
  969.     return (1);
  970. }
  973. /*
  974.  * nopap - Disable PAP authentication with peer.
  975.  */
  976. static int
  977. nopap()
  978. {
  979.     ppp_if[ppp_unit]->lcp_allowoptions.neg_upap = 0;
  980.     return (1);
  981. }
  984. /*
  985.  * reqpap - Require PAP authentication from peer.
  986.  */
  987. static int
  988. reqpap()
  989. {
  990.     ppp_if[ppp_unit]->lcp_wantoptions.neg_upap = 1;
  991.     ppp_if[ppp_unit]->auth_required = 1;
  992.     return (1);
  993. }
  995. /*
  996.  * setupapfile - specifies UPAP info for authenticating with peer.
  997.  */
  998. static int
  999. setupapfile(argv)
  1000.     char *argv;
  1001. {
  1002.     FILE * ufile;
  1004.     ppp_if[ppp_unit]->lcp_allowoptions.neg_upap = 1;
  1005.     ppp_if[ppp_unit]->options->pap_file = (char *)stringdup(argv);
  1007.     /* open user info file */
  1008.     if ((ufile = fopen(argv, "r")) == NULL) {
  1009. syslog(LOG_ERR, "unable to open PAP secrets file %s", argv);
  1010. return 0;
  1011.     }
  1012.     if (!readable(fileno(ufile))) {
  1013.         syslog(LOG_ERR, "%s: access denied", argv);
  1014.         fclose(ufile);
  1015.         return 0;
  1016.     }
  1017.     check_access(ufile, argv);
  1019.     fclose(ufile);
  1020.     return (1);
  1021. }
  1024. /*
  1025.  * nochap - Disable CHAP authentication with peer.
  1026.  */
  1027. static int
  1028. nochap()
  1029. {
  1030.     ppp_if[ppp_unit]->lcp_allowoptions.neg_chap = 0;
  1031.     return (1);
  1032. }
  1035. /*
  1036.  * reqchap - Require CHAP authentication from peer.
  1037.  */
  1038. static int
  1039. reqchap()
  1040. {
  1041.     ppp_if[ppp_unit]->lcp_wantoptions.neg_chap = 1;
  1042.     ppp_if[ppp_unit]->auth_required = 1;
  1043.     return (1);
  1044. }
  1047. /*
  1048.  * setchapfile - specifies CHAP info for authenticating with peer.
  1049.  */
  1050. static int
  1051. setchapfile(argv)
  1052. char *argv;
  1053. {
  1054.     FILE * ufile;
  1056.     ppp_if[ppp_unit]->lcp_allowoptions.neg_chap = 1;
  1057.     ppp_if[ppp_unit]->options->chap_file = (char *)stringdup(argv);
  1059.     /* open user info file */
  1060.     if ((ufile = fopen(argv, "r")) == NULL) {
  1061. syslog(LOG_ERR, "unable to open CHAP secrets file %s", argv);
  1062. return 0;
  1063.     }
  1064.     if (!readable(fileno(ufile))) {
  1065.         syslog(LOG_ERR, "%s: access denied", argv);
  1066.         fclose(ufile);
  1067.         return 0;
  1068.     }
  1069.     check_access(ufile, argv);
  1071.     fclose(ufile);
  1072.     return (1);
  1073. }
  1075. /*
  1076.  * setnovj - disable vj compression
  1077.  */
  1078. static int
  1079. setnovj()
  1080. {
  1081.     ppp_if[ppp_unit]->ipcp_wantoptions.neg_vj = 0;
  1082.     ppp_if[ppp_unit]->ipcp_allowoptions.neg_vj = 0;
  1083.     return (1);
  1084. }
  1087. /*
  1088.  * setnovjccomp - disable VJ connection-ID compression
  1089.  */
  1090. static int
  1091. setnovjccomp()
  1092. {
  1093.     ppp_if[ppp_unit]->ipcp_wantoptions.cflag = 0;
  1094.     ppp_if[ppp_unit]->ipcp_allowoptions.cflag = 0;
  1095.     return (1);
  1096. }
  1099. /*
  1100.  * setvjslots - set maximum number of connection slots for VJ compression
  1101.  */
  1102. static int
  1103. setvjslots(argv)
  1104.     char *argv;
  1105. {
  1106.     int value;
  1108.     if (!int_option(argv, &value))
  1109.         return 0;
  1110.     if (value < 2 || value > 16) {
  1111.         syslog(LOG_ERR, "pppd: vj-max-slots value must be between 2 and 16");
  1112.         return 0;
  1113.     }
  1114.     ppp_if[ppp_unit]->ipcp_wantoptions.maxslotindex =
  1115.         ppp_if[ppp_unit]->ipcp_allowoptions.maxslotindex = value - 1;
  1116.     return 1;
  1117. }
  1119. #ifdef notyet
  1120. /*
  1121.  * setconnector - Set a program to connect to a serial line
  1122.  */
  1123. static int
  1124. setconnector(argv)
  1125.     char *argv;
  1126. {
  1127.     ppp_if[ppp_unit]->connector = (char *)stringdup(argv);
  1128.     if (ppp_if[ppp_unit]->connector == NULL)
  1129. novm("connector string");
  1131.     return (1);
  1132. }
  1133. #endif /* notyet */
  1135. #ifdef notyet
  1136. /*
  1137.  * setdisconnector - Set a program to disconnect from the serial line
  1138.  */
  1139. static int
  1140. setdisconnector(argv)
  1141.     char *argv;
  1142. {
  1143.     ppp_if[ppp_unit]->disconnector = (char *)stringdup(argv);
  1144.     if (ppp_if[ppp_unit]->disconnector == NULL)
  1145.         novm("disconnector string");
  1147.     return (1);
  1148. }
  1149. #endif /* notyet */
  1151. #ifdef notyet
  1152. /*
  1153.  * setdomain - Set domain name to append to hostname 
  1154.  */
  1155. static int
  1156. setdomain(argv)
  1157.     char *argv;
  1158. {
  1159.     strncat(ppp_if[ppp_unit]->hostname, argv,
  1160.     MAXNAMELEN - strlen(ppp_if[ppp_unit]->hostname));
  1161.     ppp_if[ppp_unit]->hostname[MAXNAMELEN-1] = 0;
  1162.     return (1);
  1163. }
  1164. #endif /* notyet */
  1167. /*
  1168.  * setasyncmap - add bits to asyncmap (what we request peer to escape).
  1169.  */
  1170. static int
  1171. setasyncmap(argv)
  1172.     char *argv;
  1173. {
  1174.     long asyncmap;
  1176.     if (!number_option(argv, &asyncmap, 16))
  1177. return 0;
  1178.     ppp_if[ppp_unit]->lcp_wantoptions.asyncmap |= asyncmap;
  1179.     ppp_if[ppp_unit]->lcp_wantoptions.neg_asyncmap = 1;
  1180.     return (1);
  1181. }
  1183. /*
  1184.  * setescape - add chars to the set we escape on transmission.
  1185.  */
  1186. static int
  1187. setescape(argv)
  1188.     char *argv;
  1189. {
  1190.     int n, ret;
  1191.     char *p, *endp;
  1193.     p = argv;
  1194.     ret = 1;
  1195.     while (*p) {
  1196.         n = strtoul(p, &endp, 16);
  1197.         if (p == endp) {
  1198.             syslog(LOG_ERR, "invalid hex number: %s", p);
  1199.             return 0;
  1200.         }
  1201.         p = endp;
  1202.         if (n < 0 || (0x20 <= n && n <= 0x3F) || n == 0x5E || n > 0xFF) {
  1203.             syslog(LOG_ERR, "can't escape character 0x%x", n);
  1204.             ret = 0;
  1205.         } else
  1206.             ppp_if[ppp_unit]->xmit_accm[n >> 5] |= 1 << (n & 0x1F);
  1207.         while (*p == ',' || *p == ' ')
  1208.             ++p;
  1209.     }
  1210.     return ret;
  1211. }
  1214. /*
  1215.  * setspeed - Set the speed.
  1216.  */
  1217. static int
  1218. setspeed(arg, is_string)
  1219.     int arg;
  1220.     int is_string;
  1221. {
  1222.     char *ptr;
  1223.     int spd;
  1225.     if (is_string) {
  1226.         spd = strtol((char *)arg, &ptr, 0);
  1227.         if (ptr == (char *)arg || *ptr != 0 || spd == 0)
  1228.     return 0;
  1229.         ppp_if[ppp_unit]->inspeed = spd;
  1230.     }
  1231.     else 
  1232. ppp_if[ppp_unit]->inspeed = arg;
  1233.     
  1234.     return 1;
  1235. }
  1238. /*
  1239.  * setdevname - Set the device name.
  1240.  */
  1241. int
  1242. setdevname(cp)
  1243.     char *cp;
  1244. {
  1245.     (void) strncpy(ppp_if[ppp_unit]->devname, cp, MAXPATHLEN);
  1246.     ppp_if[ppp_unit]->devname[MAXPATHLEN-1] = 0;
  1247.   
  1248.     return 1;
  1249. }
  1252. /*
  1253.  * setipaddr - Set the IP address
  1254.  *
  1255.  * This function also accepts hostnames apart from ip address strings.
  1256.  * If hostnames are passed to this function, the hostnames should be
  1257.  * added to the system by making calls to hostAdd() prior to calling this
  1258.  * function. This requires the hostTblInit be called before hostGetByName
  1259.  * is called.
  1260.  */
  1261. int
  1262. setipaddr(local_addr, remote_addr)
  1263.     char *local_addr;
  1264.     char *remote_addr;
  1265. {
  1266.     u_long local, remote;
  1267.     ipcp_options *wo = &ppp_if[ppp_unit]->ipcp_wantoptions;
  1269.     if ((local = hostGetByName (local_addr)) == ERROR)
  1270. {
  1271. if ((((local = inet_addr(local_addr)) == ERROR)) || 
  1272.     (bad_ip_adrs(local)))
  1273.     {
  1274.     syslog(LOG_ERR, "bad local IP address: %s", ip_ntoa(local));
  1275.     return 0;
  1276.     }
  1277. }
  1278.     else
  1279. {
  1280. strncpy(ppp_if[ppp_unit]->our_name, local_addr, MAXNAMELEN);
  1281. ppp_if[ppp_unit]->our_name[MAXNAMELEN-1] = 0;
  1282. }
  1284.     if (local != 0)
  1285.         wo->ouraddr = local;
  1287.     if ((remote = hostGetByName (remote_addr)) == ERROR)
  1288. {
  1289. if ((((remote = inet_addr(remote_addr)) == ERROR)) || 
  1290.     (bad_ip_adrs(remote)))
  1291.     {
  1292.     syslog(LOG_ERR, "bad remote IP address: %s", ip_ntoa(remote));
  1293.     return 0;
  1294.     }
  1295. }
  1296.     else
  1297. {
  1298. strncpy(ppp_if[ppp_unit]->remote_name, remote_addr, MAXNAMELEN);
  1299. ppp_if[ppp_unit]->remote_name[MAXNAMELEN-1] = 0;
  1300. }
  1302.     if (remote != 0)
  1303.         wo->hisaddr = remote;
  1305.     return 1;
  1306. }
  1308. #ifdef notyet
  1309. /*
  1310.  * setnoipdflt - disable setipdefault()
  1311.  */
  1312. static int
  1313. setnoipdflt()
  1314. {
  1315.     ppp_if[ppp_unit]->disable_defaultip = 1;
  1316.     return 1;
  1317. }
  1318. #endif /* notyet */
  1321. /*
  1322.  * setipcpaccl - accept peer's idea of our address
  1323.  */
  1324. static int
  1325. setipcpaccl()
  1326. {
  1327.     ppp_if[ppp_unit]->ipcp_wantoptions.accept_local = 1;
  1328.     return 1;
  1329. }
  1331. /*
  1332.  * setipcpaccr - accept peer's idea of its address
  1333.  */
  1334. static int
  1335. setipcpaccr()
  1336. {
  1337.     ppp_if[ppp_unit]->ipcp_wantoptions.accept_remote = 1;
  1338.     return 1;
  1339. }
  1342. /*
  1343.  * setipdefault - default our local IP address based on our hostname.
  1344.  */
  1345. void
  1346. setipdefault()
  1347. {
  1348.     u_long local;
  1349.     ipcp_options *wo = &ppp_if[ppp_unit]->ipcp_wantoptions;
  1351.     /*
  1352.      * If local IP address already given, don't bother.
  1353.      */
  1354.     if (wo->ouraddr != 0 || ppp_if[ppp_unit]->disable_defaultip)
  1355. return;
  1357.     /*
  1358.      * Look up our hostname (possibly with domain name appended)
  1359.      * and take the first IP address as our local IP address.
  1360.      * If there isn't an IP address for our hostname, too bad.
  1361.      */
  1362.     wo->accept_local = 1;       /* don't insist on this default value */
  1363.     if ((local = hostGetByName(ppp_if[ppp_unit]->hostname)) == ERROR)
  1364. return;
  1365.     if (local != 0 && !bad_ip_adrs(local))
  1366. wo->ouraddr = local;
  1367. }
  1370. /*
  1371.  * setnetmask - set the netmask to be used on the interface.
  1372.  */
  1373. static int
  1374. setnetmask(argv)
  1375.     char *argv;
  1376. {
  1377.     u_long mask;
  1379.     if ((mask = inet_addr(argv)) == ERROR || (ppp_if[ppp_unit]->netmask & ~mask) != 0) {
  1380. syslog(LOG_ERR, "Invalid netmask %sn", argv);
  1381. return 0;
  1382.     }
  1384.     ppp_if[ppp_unit]->netmask = mask;
  1385.     return (1);
  1386. }
  1388. /*
  1389.  * Return user specified netmask. A value of zero means no netmask has
  1390.  * been set.
  1391.  */
  1392. /* ARGSUSED */
  1393. u_long
  1394. GetMask(addr)
  1395.     u_long addr;
  1396. {
  1397.     return(ppp_if[ppp_unit]->netmask);
  1398. }
  1400. static int
  1401. setname(argv)
  1402.     char *argv;
  1403. {
  1404.     if (ppp_if[ppp_unit]->our_name[0] == 0) {
  1405. strncpy(ppp_if[ppp_unit]->our_name, argv, MAXNAMELEN);
  1406. ppp_if[ppp_unit]->our_name[MAXNAMELEN-1] = 0;
  1407.     }
  1408.     return 1;
  1409. }
  1411. static int
  1412. setuser(argv)
  1413.     char *argv;
  1414. {
  1415.     strncpy(ppp_if[ppp_unit]->user, argv, MAXNAMELEN);
  1416.     ppp_if[ppp_unit]->user[MAXNAMELEN-1] = 0;
  1417.     return 1;
  1418. }
  1420. static int
  1421. setpasswd(argv)
  1422.     char *argv;
  1423. {
  1424.     strncpy(ppp_if[ppp_unit]->passwd, argv, MAXSECRETLEN);
  1425.     ppp_if[ppp_unit]->passwd[MAXSECRETLEN-1] = 0;
  1426.     return 1;
  1427. }
  1429. static int
  1430. setremote(argv)
  1431.     char *argv;
  1432. {
  1433.     strncpy(ppp_if[ppp_unit]->remote_name, argv, MAXNAMELEN);
  1434.     ppp_if[ppp_unit]->remote_name[MAXNAMELEN-1] = 0;
  1435.     return 1;
  1436. }
  1438. #ifdef notyet
  1439. static int
  1440. setauth()
  1441. {
  1442.     ppp_if[ppp_unit]->auth_required = 1;
  1443.     return 1;
  1444. }
  1445. #endif /* notyet */
  1447. static int
  1448. setdefaultroute()
  1449. {
  1450.     ppp_if[ppp_unit]->ipcp_wantoptions.default_route = 1;
  1451.     return 1;
  1452. }
  1454. static int
  1455. setproxyarp()
  1456. {
  1457.     ppp_if[ppp_unit]->ipcp_wantoptions.proxy_arp = 1;
  1458.     return 1;
  1459. }
  1461. static int
  1462. setdologin()
  1463. {
  1464.     ppp_if[ppp_unit]->uselogin = 1;
  1465.     return 1;
  1466. }
  1468. /*
  1469.  * Functions to set the echo interval for modem-less monitors
  1470.  */
  1472. static int
  1473. setlcpechointv(argv)
  1474.     char *argv;
  1475. {
  1476.     return int_option(argv, &ppp_if[ppp_unit]->lcp_echo_interval);
  1477. }
  1479. static int
  1480. setlcpechofails(argv)
  1481.     char *argv;
  1482. {
  1483.     return int_option(argv, &ppp_if[ppp_unit]->lcp_echo_fails);
  1484. }
  1486. /*
  1487.  * Functions to set timeouts, max transmits, etc.
  1488.  */
  1489. static int
  1490. setlcptimeout(argv)
  1491.     char *argv;
  1492. {
  1493.     return int_option(argv, &ppp_if[ppp_unit]->lcp_fsm.timeouttime);
  1494. }
  1496. static int setlcpterm(argv)
  1497.     char *argv;
  1498. {
  1499.     return int_option(argv, &ppp_if[ppp_unit]->lcp_fsm.maxtermtransmits);
  1500. }
  1502. static int setlcpconf(argv)
  1503.     char *argv;
  1504. {
  1505.     return int_option(argv, &ppp_if[ppp_unit]->lcp_fsm.maxconfreqtransmits);
  1506. }
  1508. static int setlcpfails(argv)
  1509.     char *argv;
  1510. {
  1511.     return int_option(argv, &ppp_if[ppp_unit]->lcp_fsm.maxnakloops);
  1512. }
  1514. static int setipcptimeout(argv)
  1515.     char *argv;
  1516. {
  1517.     return int_option(argv, &ppp_if[ppp_unit]->ipcp_fsm.timeouttime);
  1518. }
  1520. static int setipcpterm(argv)
  1521.     char *argv;
  1522. {
  1523.     return int_option(argv, &ppp_if[ppp_unit]->ipcp_fsm.maxtermtransmits);
  1524. }
  1526. static int setipcpconf(argv)
  1527.     char *argv;
  1528. {
  1529.     return int_option(argv, &ppp_if[ppp_unit]->ipcp_fsm.maxconfreqtransmits);
  1530. }
  1532. static int setipcpfails(argv)
  1533.     char *argv;
  1534. {
  1535.     return int_option(argv, &ppp_if[ppp_unit]->ipcp_fsm.maxnakloops);
  1536. }
  1538. static int setpaptimeout(argv)
  1539.     char *argv;
  1540. {
  1541.     return int_option(argv, &ppp_if[ppp_unit]->upap.us_timeouttime);
  1542. }
  1544. static int setpapreqs(argv)
  1545.     char *argv;
  1546. {
  1547.     return int_option(argv, &ppp_if[ppp_unit]->upap.us_maxtransmits);
  1548. }
  1550. static int setchaptimeout(argv)
  1551.     char *argv;
  1552. {
  1553.     return int_option(argv, &ppp_if[ppp_unit]->chap.timeouttime);
  1554. }
  1556. static int setchapchal(argv)
  1557.     char *argv;
  1558. {
  1559.     return int_option(argv, &ppp_if[ppp_unit]->chap.max_transmits);
  1560. }
  1562. static int setchapintv(argv)
  1563.     char *argv;
  1564. {
  1565.     return int_option(argv, &ppp_if[ppp_unit]->chap.chal_interval);
  1566. }