home *** CD-ROM | disk | FTP | other *** search
/ Super Net 1 / SUPERNET_1.iso / PC / OTROS / SUN / PPP / SUNOS_OL / PPPD_1_0.TAR / main.c < prev    next >
Encoding:
C/C++ Source or Header  |  1992-01-31  |  44.9 KB  |  2,024 lines
  1. /*
  2.  * ppp.c - Point-to-Point Protocol.
  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. /*
  21.  
  22.  * TODO:
  23.  * Don't prompt for passwd on /dev/tty (go into server mode).
  24.  * Might want to choose IP addresses from config file based on user id
  25.  * if the server, or based on remote host if tip'd client.
  26.  * Way to set asyncmap.
  27.  * Wait for tty queue to empty before exiting in quit.
  28.  */
  29.  
  30. /*
  31.  * There are three scenarios:
  32.  * 1.  pppd used as daemon started from /etc/rc or perhaps /etc/ttys.
  33.  *    a.  server
  34.  *    b.  authentication necessary
  35.  *    c.  want to use constant local ip addr
  36.  *    d.  want to use constant remote ip addr, constant ip addr based on
  37.  *        authenticated user, or request ip addr
  38.  * 2.  pppd used on /dev/tty after remote login.
  39.  *    a.  server
  40.  *    b.  no authentication necessary or allowed
  41.  *    c.  want to use constant local ip addr
  42.  *    d.  want to use constant remote ip addr, constant ip addr based on
  43.  *        authenticated user, or request ip addr
  44.  * 3.  pppd used on line after tip'ing out.
  45.  *    a.  client
  46.  *    b.  remote end may request authentication
  47.  *    c.  want to use constant local ip addr or request ip addr
  48.  *    d.  want to use constant remote ip addr based on tip'd host, or
  49.  *        request remote ip addr
  50.  */
  51.  
  52. #include <stdio.h>
  53. #include <signal.h>
  54. #include <errno.h>
  55. #include <fcntl.h>
  56. #ifndef    STREAMS
  57. #include <sgtty.h>
  58. #endif
  59. #include <pwd.h>
  60. #include <syslog.h>
  61. #include <netdb.h>
  62. #include <utmp.h>
  63. #include <alloca.h>
  64.  
  65. #include <sys/param.h>
  66. #include <sys/types.h>
  67. #include <sys/stat.h>
  68. #include <sys/socket.h>
  69. #include <netinet/in.h>
  70. #include <arpa/inet.h>
  71. #include <sys/time.h>
  72. #include "callout.h"
  73.  
  74. #include <net/if.h>
  75.  
  76. #ifdef    STREAMS
  77. #include <sys/stream.h>
  78. #include <sys/stropts.h>
  79. #include <sys/termios.h>
  80. #include <sys/conf.h>
  81. #endif
  82.  
  83. # define    DEVNAME_SIZE    128    /* Buffer size for /dev filenames */
  84.  
  85. #ifdef sun
  86. /*
  87.  *    Get definition of SUNOS
  88.  */
  89. #include <pixrect/pr_impl_util.h>
  90.  
  91. #ifndef BSD
  92. #define BSD 43
  93. #endif /*BSD*/
  94.  
  95. #if defined(SUNOS) && SUNOS >= 41
  96. #define SETSID
  97. #else 
  98. typedef int pid_t;
  99. #endif /* defined(SUNOS) && SUNOS >= 41 */
  100. #endif /* sun */
  101.  
  102. #include <malloc.h>
  103. #include <string.h>
  104.  
  105. #include "ppp.h"
  106. #include "magic.h"
  107. #include "fsm.h"
  108. #include "lcp.h"
  109. #include "ipcp.h"
  110. #include "upap.h"
  111. #include "chap.h"
  112. #include "pathnames.h"
  113. #include "patchlevel.h"
  114.  
  115. #define PPPHOSTS    "/etc/hosts.ppp"
  116.  
  117. #ifndef TRUE
  118. #define TRUE (1)
  119. #endif /*TRUE*/
  120.  
  121. #ifndef FALSE
  122. #define FALSE (0)
  123. #endif /*FALSE*/
  124.  
  125. #ifdef PIDPATH
  126. static char *pidpath = PIDPATH;    /* filename in which pid will be */
  127.                 /* stored */
  128. #else
  129. static char *pidpath = _PATH_PIDFILE;
  130. #endif /* PIDFILE */
  131.  
  132. static char uinfopath[DEVNAME_SIZE];
  133.  
  134. /* global vars */
  135.  
  136. int debug = 0;                /* Debug flag */
  137. char ifname[IFNAMSIZ];        /* Interface name */
  138.  
  139. int fd;                /* Device file descriptor */
  140.  
  141. char hostname[MAX_HOSTNAME_LEN]; /* hostname */
  142. u_char hostname_len;        /* hostname length */
  143. u_char outpacket_buf[MTU+DLLHEADERLEN]; /* buffer for outgoing packet */
  144.  
  145. /* local vars */
  146. static char *progname;            /* Name of this program */
  147. static char devname[DEVNAME_SIZE] = "/dev/tty";    /* Device name */
  148. static int ifunit;            /* Interface unit number */
  149. static char inspeed = 0;            /* Input/Output speed */
  150. int s;                /* Socket file descriptor */
  151. #ifndef    STREAMS
  152. static int initdisc;            /* Initial TTY discipline */
  153. static struct sgttyb initsgttyb;    /* Initial TTY sgttyb */
  154. #endif
  155. static int initfdflags;        /* Initial file descriptor flags */
  156. static pid_t    pid;            /* Our pid */
  157. #ifdef sun
  158. static pid_t    pgrpid;            /* Process Group ID */
  159. #endif
  160. static char user[80];            /* User name */
  161. static char passwd[80];        /* passwd */
  162. static char *connector = NULL;    /* holds command specified by the */
  163.                 /* "connect" command line option */
  164.  
  165. static int default_device = TRUE; /* use default device (stdin/out) */
  166.  
  167. static u_char inpacket_buf[MTU+DLLHEADERLEN]; /* buffer for incoming packet */
  168.  
  169. static u_long netmask = 0;    /* netmask to use on ppp interface */
  170. static char pidfilename[DEVNAME_SIZE];
  171.  
  172. static void hup __ARGS((int, int, struct sigcontext *, char *));
  173. static void intr __ARGS((int, int, struct sigcontext *, char *));
  174. static void term __ARGS((int, int, struct sigcontext *, char *));
  175. static void alrm __ARGS((int, int, struct sigcontext *, char *));
  176. static void io __ARGS((int, int, struct sigcontext *, char *));
  177. static void incdebug __ARGS((int, int, struct sigcontext *, char *));
  178. static void nodebug __ARGS((int, int, struct sigcontext *, char *));
  179. static void getuserpasswd __ARGS((void));
  180.  
  181. static int setdebug __ARGS((int *, char ***));
  182. static int setpassive __ARGS((int *, char ***));
  183. static int noopt __ARGS((int *, char ***));
  184. static int setnovj __ARGS((int *, char ***));
  185. static int noupap __ARGS((int *, char ***));
  186. static int requpap __ARGS((int *, char ***));
  187. static int nochap __ARGS((int *, char ***));
  188. static int reqchap __ARGS((int *, char ***));
  189. static int setspeed __ARGS((int *, char ***));
  190. static int noaccomp __ARGS((int *, char ***));
  191. static int noasyncmap __ARGS((int *, char ***));
  192. static int noipaddr __ARGS((int *, char ***));
  193. static int nomagicnumber __ARGS((int *, char ***));
  194. static int setasyncmap __ARGS((int *, char ***));
  195. static int setvjmode __ARGS((int *, char ***));
  196. static int setmru __ARGS((int *, char ***));
  197. static int nomru __ARGS((int *, char ***));
  198. static int nopcomp __ARGS((int *, char ***));
  199. static int setconnector __ARGS((int *, char ***));
  200. static int setdomain __ARGS((int *, char ***));
  201. static int setnetmask __ARGS((int *, char ***));
  202. static void cleanup __ARGS((int, caddr_t));
  203. #ifdef    STREAMS
  204. static void str_restore __ARGS((void));
  205. extern    char    *ttyname __ARGS((int));
  206. #define    MAXMODULES    10        /* max number of module names that we can save */
  207. static struct    modlist {
  208.   char    modname[FMNAMESZ+1];
  209. } str_modules[MAXMODULES];
  210. static int    str_module_count = 0;
  211. #endif
  212.  
  213. /*
  214.  * Valid arguments.
  215.  */
  216. static struct cmd {
  217.   char *cmd_name;
  218.   int (*cmd_func)();
  219. } cmds[] = {
  220.   "-all", noopt,            /* Don't request/allow any options */
  221.   "-ac", noaccomp,            /* Disable Address/Control compress */
  222.   "-am", noasyncmap,            /* Disable asyncmap negotiation */
  223.   "-as", setasyncmap,            /* set the desired async map */
  224.   "-d", setdebug,            /* Increase debugging level */
  225.   "debug", setdebug,            /* Increase debugging level */
  226.   "-ip", noipaddr,            /* Disable IP address negotiation */
  227.   "-mn", nomagicnumber,                /* Disable magic number negotiation */
  228.   "-mru", nomru,            /* Disable mru negotiation */
  229.   "mru", setmru,            /* Set MRU value for negotiation */
  230.   "-p", setpassive,            /* Set passive mode */
  231.   "-pc", nopcomp,            /* Disable protocol field compress */
  232.   "passive", setpassive,        /* Set passive mode */
  233.   "+ua", requpap,            /* Require UPAP authentication */
  234.   "-ua", noupap,            /* Don't allow UPAP authentication */
  235.   "+chap", reqchap,            /* Require CHAP authentication */
  236.   "-chap", nochap,            /* Don't allow CHAP authentication */
  237.   "vjmode", setvjmode,                /* set VJ compression mode */
  238.   "-vj", setnovj,            /* disbale VJ compression */
  239.   "connect", setconnector,              /* A program to set up a connection */
  240.   "domain", setdomain,                /* Add given domain name to */
  241.                     /* hostname*/
  242.   "netmask", setnetmask,            /* set netmask */
  243.   NULL
  244.   };
  245.  
  246.  
  247. /*
  248.  * PPP Data Link Layer "protocol" table.
  249.  * One entry per supported protocol.
  250.  */
  251. static struct protent {
  252.   u_short protocol;
  253.   void (*init)();
  254.   void (*input)();
  255.   void (*protrej)();
  256. } prottbl[] = {
  257.   { LCP, lcp_init, lcp_input, lcp_protrej },
  258.   { IPCP, ipcp_init, ipcp_input, ipcp_protrej },
  259.   { UPAP, upap_init, upap_input, upap_protrej },
  260.   { CHAP, ChapInit, ChapInput, ChapProtocolReject },
  261. };
  262.  
  263.  
  264. static char *usage = "pppd version %s patch level %d\n\
  265. Usage: %s [ arguments ], where arguments are:\n\
  266.     -all        Don't request/allow any options\n\
  267.     -ac        Disable Address/Control compression\n\
  268.     -am        Disable asyncmap negotiation\n\
  269.     -as <n>        Set the desired async map to hex <n>\n\
  270.     -d        Increase debugging level\n\
  271.     debug        Increase debugging level\n\
  272.     -ip        Disable IP address negotiation\n\
  273.     -mn        Disable magic number negotiation\n\
  274.     -mru        Disable mru negotiation\n\
  275.     mru <n>        Set MRU value to <n> for negotiation\n\
  276.     -p        Set passive mode\n\
  277.     -pc        Disable protocol field compression\n\
  278.     passive        Set passive mode\n\
  279.     +ua <p>        Require UPAP authentication and use file <p> for\n\
  280.                         remote login data\n\
  281.     -ua        Don't allow UPAP authentication\n\
  282.     +chap        Require CHAP authentication\n\
  283.     -chap        Don't allow CHAP authentication\n\
  284.     vjmode <m>      VJ compression mode {old, current (default), draft}\n\
  285.         -vj             disable VJ compression\n\
  286.         connect <p>     Invoke shell command <p> to set up the serial line\n\
  287.         domain <d>      Append domain name <d> to hostname for authentication\n\
  288.     <device>    Communicate over the named device\n\
  289.     <speed>        Set the baud rate to <speed>\n\
  290.     <loc>:<rem>    Set the local and/or remote interface IP\n\
  291.             addresses.  Either one may be omitted.\n";
  292.  
  293. #ifdef    STREAMS
  294.  
  295. /* 
  296.  * this module will attempt to reconstruct the stream with the
  297.  * previously popped modules
  298.  */
  299.  
  300. /*ARGSUSED*/
  301. static void
  302.   str_restore()
  303. {
  304.   /*EMPTY*/ 
  305.   while(ioctl(fd, I_POP, 0) == 0);     /* pop any we pushed */ 
  306.   
  307.   for(; str_module_count > 0; str_module_count--) {
  308.     if(ioctl(fd, I_PUSH, str_modules[str_module_count-1].modname)) {
  309.       syslog(LOG_ERR, "str_restore: couldn't push module %s: %m",
  310.           str_modules[str_module_count-1].modname);
  311.     }
  312.     else {
  313.       MAINDEBUG((LOG_INFO, "str_restore: pushed module %s",
  314.         str_modules[str_module_count-1].modname))
  315.     }
  316.   }
  317. }
  318. #endif
  319.  
  320. main(argc, argv)
  321.      int argc;
  322.      char *argv[];
  323. {
  324.   int mask, i;
  325. #ifdef    STREAMS
  326.   struct termios    tios;
  327. #else
  328.   int pppdisc = PPPDISC;
  329.   struct sgttyb sgttyb;
  330. #endif
  331.   struct sigvec sv;
  332.   struct cmd *cmdp;
  333.  
  334.   FILE *pidfile;
  335.  
  336.   /*
  337.    * Initialize syslog system and magic number package.
  338.    */
  339. #if BSD >= 43
  340.   openlog("pppd", LOG_PID | LOG_NDELAY, LOG_PPP);
  341.   setlogmask(LOG_UPTO(LOG_WARNING));
  342. #else
  343.   openlog("pppd", LOG_PID);
  344. #define LOG_UPTO(x) (x)
  345. #define setlogmask(x) (x)
  346. #endif
  347.  
  348.   
  349. #ifdef        STREAMS
  350.   if (ttyname(fileno(stdin)))
  351.     strcpy(devname, ttyname(fileno(stdin)));
  352. #endif
  353.   magic_init();
  354.  
  355.   if (gethostname(hostname, MAX_HOSTNAME_LEN) < 0 ) {
  356.     syslog(LOG_ERR, "couldn't get hostname: %m");
  357.     exit(1);
  358.   }
  359.  
  360.   /*
  361.    * Initialize to the standard option set and then parse the command
  362.    * line arguments.
  363.    */
  364.   for (i = 0; i < sizeof (prottbl) / sizeof (struct protent); i++)
  365.     (*prottbl[i].init)(0);
  366.   
  367.   progname = *argv;
  368.   for (argc--, argv++; argc; ) {
  369.     /*
  370.      * First see if it's a command.
  371.      */
  372.     for (cmdp = cmds; cmdp->cmd_name; cmdp++)
  373.       if (!strcmp(*argv, cmdp->cmd_name) &&
  374.       (*cmdp->cmd_func)(&argc, &argv))
  375.     break;
  376.     
  377.     /*
  378.      * Maybe a tty name, speed or IP address?
  379.      */
  380.     if (cmdp->cmd_name == NULL &&
  381.     !setdevname(&argc, &argv) &&
  382.     !setspeed(&argc, &argv) &&
  383.     !setipaddr(&argc, &argv)) {
  384.       fprintf(stderr, usage, VERSION, PATCHLEVEL, progname);
  385.       exit(1);
  386.     }
  387.   }
  388.   
  389.   syslog(LOG_INFO, "Starting ppp daemon version %s patchlevel %d",
  390.      VERSION, PATCHLEVEL); 
  391.   /*
  392.    * Initialize state.
  393.    */
  394.  
  395. #ifdef SETSID
  396.   if (default_device) {
  397.     /* No device name was specified... inherit the old controlling
  398.        terminal */
  399.     
  400.     if ((pgrpid = getpgrp(0)) < 0) {
  401.       syslog(LOG_ERR, "getpgrp(0): %m");
  402.       exit(1);
  403.     }
  404.     if (pgrpid != pid) 
  405.       syslog(LOG_WARNING, "warning... not a process group leader");
  406.   }
  407.   else /*default_device*/
  408.     if ((pgrpid = setsid()) < 0) {
  409.       syslog(LOG_ERR, "setsid(): %m");
  410.       exit(1);
  411.     }
  412.     syslog(LOG_INFO, "pgrpid = %d", pgrpid);
  413. #endif
  414.   if ((fd = open(devname, O_RDWR /*| O_NDELAY*/)) < 0) {
  415.     syslog(LOG_ERR, "open(%s): %m", devname);
  416.     exit(1);
  417.   }
  418.  
  419.   
  420.   if (connector) {
  421.     if (set_up_connection(connector, fd, fd) < 0) {
  422.       syslog(LOG_ERR, "could not set up connection");
  423.       exit(1);
  424.     }
  425.   }
  426.   
  427.   if ((s = socket(AF_INET, SOCK_DGRAM, 0)) < 0) {
  428.     syslog(LOG_ERR, "socket : %m");
  429.     exit(1);
  430.   }
  431.   
  432.   /* if we exit, then try and restore the stream */ 
  433.   on_exit(cleanup, NULL);
  434.   
  435. #ifdef    STREAMS
  436.   /* go through and save the name of all the modules, then pop em */
  437.   while(1)    { 
  438.     if(!ioctl(fd, I_LOOK, str_modules[str_module_count].modname))
  439.     MAINDEBUG((LOG_DEBUG, "popped stream module : %s",
  440.         str_modules[str_module_count].modname))
  441.     if(!ioctl(fd, I_POP, 0))
  442.       str_module_count++;
  443.     else
  444.       break;
  445.   }
  446.   
  447.   if(ioctl(fd, TCGETS, (caddr_t) &tios) < 0) {
  448.     syslog(LOG_ERR, "ioctl(TCGETS): %m");
  449.     exit(1);
  450.   }
  451.   
  452.   tios.c_cflag  = CRTSCTS | (inspeed  ? inspeed : (tios.c_cflag & CBAUD));
  453.   tios.c_cflag |= CS8|CREAD|HUPCL;
  454.   tios.c_iflag = IGNBRK;
  455.   
  456.   if(ioctl(fd, TCSETS, (caddr_t) &tios) < 0) {
  457.     syslog(LOG_ERR, "ioctl(TCSETS): %m");
  458.     exit(1);
  459.   }
  460.   /* now push the async/fcs module */
  461.   if(ioctl(fd, I_PUSH, "pppasync") < 0) {
  462.     syslog(LOG_ERR, "ioctl(I_PUSH, ppp_async): %m");
  463.     exit(1);
  464.   }
  465.   /* finally, push the ppp_if module that actually handles the */
  466.   /* network interface */ 
  467.   if(ioctl(fd, I_PUSH, "pppif") < 0) {
  468.     syslog(LOG_ERR, "ioctl(I_PUSH, ppp_if): %m");
  469.     exit(1);
  470.   }
  471.   if(ioctl(fd, I_SETSIG, S_INPUT) < 0) {
  472.     syslog(LOG_ERR, "ioctl(I_SETSIG, S_INPUT): %m");
  473.     exit(1);
  474.   }
  475.   /* read mode, message non-discard mode */
  476.   if(ioctl(fd, I_SRDOPT, RMSGN) < 0) {
  477.     syslog(LOG_ERR, "ioctl(I_SRDOPT, RMSGN): %m");
  478.     exit(1);
  479.   }
  480.   /* Flush any waiting messages, or we'll never get SIGPOLL */
  481.   if(ioctl(fd, I_FLUSH, FLUSHRW) < 0) {
  482.     syslog(LOG_ERR, "ioctl(I_FLUSH, FLUSHRW): %m");
  483.     exit(1);
  484.   }
  485. #else
  486.   /*
  487.    * Put the tty in raw mode and set the discipline to PPP.
  488.    */
  489.   if (ioctl(fd, TIOCGETP, &initsgttyb) < 0) {
  490.     syslog(LOG_ERR, "ioctl(TIOCGETP): %m");
  491.     exit(1);
  492.   }
  493.   sgttyb = initsgttyb;
  494.   sgttyb.sg_flags = RAW | ANYP;
  495.   if (inspeed)
  496.     sgttyb.sg_ispeed = inspeed;
  497.   if (ioctl(fd, TIOCSETP, &sgttyb) < 0) {
  498.     syslog(LOG_ERR, "ioctl(TIOCSETP): %m");
  499.     exit(1);
  500.   }
  501.   
  502.   if (ioctl(fd, TIOCGETD, &initdisc) < 0) {
  503.     syslog(LOG_ERR, "ioctl(TIOCGETD): %m");
  504.     exit(1);
  505.   }
  506.   if (ioctl(fd, TIOCSETD, &pppdisc) < 0) {
  507.     syslog(LOG_ERR, "ioctl(TIOCSETD): %m");
  508.     exit(1);
  509.   }
  510. #endif
  511.   /*
  512.    * Find out which interface we were given.
  513.    */
  514. #ifdef    STREAMS
  515.   /* in streams, ppp_if handles this ioctl */
  516.   if (ioctl(fd, SIOCGETU, &ifunit) < 0) {
  517.     syslog(LOG_ERR, "ioctl(SIOCGETU): %m");
  518.     exit(1);
  519.   }
  520. #else
  521.   if (ioctl(fd, TIOCGETD, &ifunit) < 0) {    
  522.     syslog(LOG_ERR, "ioctl(TIOCGETD): %m");
  523.     exit(1);
  524.   }
  525. #endif
  526.   syslog(LOG_NOTICE, "Using unit ppp%d", ifunit);
  527.   (void) sprintf(ifname, "ppp%d", ifunit);
  528.   pid = getpid();
  529.  
  530.   (void) sprintf(pidfilename, "%s/%s.pid", pidpath, ifname);
  531.  
  532.   /* write pid to file */
  533.  
  534.   if ((pidfile = fopen(pidfilename, "w")) != NULL) {
  535.     fprintf(pidfile, "%d\n", pid);
  536.     (void) fclose(pidfile);
  537.   }
  538.  
  539.   hostname_len = (u_char) strlen(hostname);
  540.  
  541.   MAINDEBUG((LOG_DEBUG, "hostname = %s", hostname))
  542.       
  543. #ifdef SETSID
  544.   if (default_device) {
  545.     int id = tcgetpgrp(fd);
  546.     if (id != pgrpid) {
  547.       MAINDEBUG((LOG_WARNING, "warning: pppd is not the leader of a forground process group"))
  548.     }
  549.   }
  550.   else
  551.     if (tcsetpgrp(fd, pgrpid) < 0) {
  552.       syslog(LOG_ERR, "tcsetpgrp(): %m");
  553.       exit(1);
  554.     }
  555. #else
  556.   if (ioctl(fd, TIOCSPGRP, &pid) < 0) {
  557.     syslog(LOG_ERR, "ioctl(TIOCSPGRP): %m");
  558.     exit(1);
  559.   }
  560. # endif
  561.   
  562.   /*
  563.    * Compute mask of all interesting signals and install signal handlers
  564.    * for each.  Only one signal handler may be active at a time.  Therefore,
  565.    * all other signals should be masked when any handler is executing.
  566.    */
  567.   mask = sigmask(SIGHUP) | sigmask(SIGINT) | sigmask(SIGALRM) |
  568.     sigmask(SIGIO);
  569. #ifdef    STREAMS
  570.   mask |= sigmask(SIGPOLL);
  571. #endif
  572.   sv.sv_handler = hup;        /* Hangup */
  573.   sv.sv_mask = mask;
  574.   sv.sv_flags = 0;
  575.   if (sigvec(SIGHUP, &sv, NULL)) {
  576.     syslog(LOG_ERR, "sigvec(SIGHUP)");
  577.     exit(1);
  578.   }
  579.   sv.sv_handler = intr;        /* Interrupt */
  580.   sv.sv_mask = mask;
  581.   sv.sv_flags = 0;
  582.   if (sigvec(SIGINT, &sv, NULL)) {
  583.     syslog(LOG_ERR, "sigvec(SIGINT)");
  584.     exit(1);
  585.   }
  586.   sv.sv_handler = term;        /* Terminate */
  587.   sv.sv_mask = mask;
  588.   sv.sv_flags = 0;
  589.   if (sigvec(SIGTERM, &sv, NULL)) {
  590.     syslog(LOG_ERR, "sigvec(SIGTERM)");
  591.     exit(1);
  592.   }
  593.   sv.sv_handler = alrm;        /* Timeout */
  594.   sv.sv_mask = mask;
  595.   sv.sv_flags = 0;
  596.   if (sigvec(SIGALRM, &sv, NULL)) {
  597.     syslog(LOG_ERR, "sigvec(SIGALRM)");
  598.     exit(1);
  599.   }
  600.   sv.sv_handler = io;            /* Input available */
  601.   sv.sv_mask = mask;
  602.   sv.sv_flags = 0;
  603.   if (sigvec(SIGIO, &sv, NULL)) {
  604.     syslog(LOG_ERR, "sigvec(SIGIO)");
  605.     exit(1);
  606.   }
  607. #ifdef    STREAMS
  608.   sv.sv_handler = io;            /* Input available */
  609.   sv.sv_mask = mask;
  610.   sv.sv_flags = 0;
  611.   if (sigvec(SIGPOLL, &sv, NULL)) {
  612.     syslog(LOG_ERR, "sigvec(SIGPOLL)");
  613.     exit(1);
  614.   }
  615. #endif
  616.   (void) signal(SIGUSR1, incdebug);    /* Increment debug flag */
  617.   (void) signal(SIGUSR2, nodebug);    /* Reset debug flag */
  618.   
  619.   /*
  620.    * Record initial device flags, then set device to cause SIGIO
  621.    * signals to be generated.
  622.    */
  623.   if ((initfdflags = fcntl(fd, F_GETFL)) == -1) {
  624.     syslog(LOG_ERR, "fcntl(F_GETFL): %m");
  625.     exit(1);
  626.   }
  627.   if (fcntl(fd, F_SETFL, FNDELAY | FASYNC) == -1) {
  628.     syslog(LOG_ERR, "fcntl(F_SETFL, FNDELAY | FASYNC): %m");
  629.     exit(1);
  630.   }
  631.   
  632.   /*
  633.    * Block all signals, start opening the connection, and  wait for
  634.    * incoming signals (reply, timeout, etc.).
  635.    */
  636.   MAINDEBUG((LOG_INFO, "connect: %s %s", ifname, devname))
  637.   sigblock(mask);            /* Block signals now */
  638.   lcp_lowerup(0);            /* XXX Well, sort of... */
  639.   if (lcp_wantoptions[0].passive)
  640.     lcp_passiveopen(0);        /* Start protocol in passive mode */
  641.   else
  642.     lcp_activeopen(0);        /* Start protocol in active mode */
  643.   for (;;) {
  644.     sigpause(0);            /* Wait for next signal */
  645.     
  646.     /* Need to read user/passwd? */
  647.     if (upap[0].us_flags & UPAPF_UPPENDING) {
  648.       sigsetmask(0);        /* Allow other signals to occur */
  649.       getuserpasswd();        /* Get user and passwd */
  650.       upap[0].us_flags &= ~UPAPF_UPPENDING;
  651.       upap[0].us_flags |= UPAPF_UPVALID;
  652.       sigsetmask(mask);        /* Disallow signals */
  653.       upap_authwithpeer(0);
  654.     }
  655.   }
  656. }
  657.  
  658.  
  659. /*
  660.  * quit - Clean up state and exit.
  661.  */
  662. void 
  663.   quit()
  664. {
  665.   if (fcntl(fd, F_SETFL, initfdflags) == -1) {
  666.     syslog(LOG_ERR, "fcntl(F_SETFL, fdflags): %m");
  667.     exit(1);
  668.   }
  669. #ifndef    STREAMS
  670.   if (ioctl(fd, TIOCSETP, &initsgttyb) < 0) {
  671.     syslog(LOG_ERR, "ioctl(TIOCSETP)");
  672.     exit(1);
  673.   }
  674.   if (ioctl(fd, TIOCSETD, &initdisc) < 0) {
  675.     syslog(LOG_ERR, "ioctl(TIOCSETD)");
  676.     exit(1);
  677.   }
  678. #else
  679. #ifdef undef
  680.   /*
  681.    * this is probably not needed and seems to break things.  ifdef'ed
  682.    * out for now - gmc
  683.    */
  684.  
  685.   /*
  686.    * the I_FLUSH ioctl should return ENXIO if carrier is missing on the 
  687.    * line, but due to a typo, it returns EINVAL instead.  We ignore
  688.    * both.
  689.    */
  690.   if((ioctl(fd, I_FLUSH, FLUSHRW) < 0) &&
  691.      (errno != EINVAL) && (errno != ENXIO)) { 
  692.     syslog(LOG_ERR, "quit ioctl(I_FLUSH,FLUSHRW)");
  693.   }
  694. #endif
  695.   str_restore();
  696. #endif
  697.   close(fd);
  698.   exit(0);
  699. }
  700.  
  701.  
  702. static struct callout *callout = NULL;        /* Callout list */
  703. static struct timeval schedtime;        /* Time last timeout was set */
  704.  
  705.  
  706. /*
  707.  * timeout - Schedule a timeout.
  708.  *
  709.  * Note that this timeout takes the number of seconds, NOT hz (as in
  710.  * the kernel).
  711.  */
  712. void timeout(func, arg, time)
  713.      void (*func)();
  714.      caddr_t arg;
  715.      int time;
  716. {
  717.   struct itimerval itv;
  718.   struct callout *newp, **oldpp;
  719.   
  720.   MAINDEBUG((LOG_DEBUG, "Timeout %x:%x in %d seconds.",
  721.         (int) func, (int) arg, time))
  722.   
  723.   /*
  724.    * Allocate timeout.
  725.    */
  726.   if ((newp = (struct callout *) malloc(sizeof(struct callout))) == NULL) {
  727.     syslog(LOG_ERR, "Out of memory in timeout()!");
  728.     exit(1);
  729.   }
  730.   newp->c_arg = arg;
  731.   newp->c_func = func;
  732.   
  733.   /*
  734.    * Find correct place to link it in and decrement its time by the
  735.    * amount of time used by preceding timeouts.
  736.    */
  737.   for (oldpp = &callout;
  738.        *oldpp && (*oldpp)->c_time <= time;
  739.        oldpp = &(*oldpp)->c_next)
  740.     time -= (*oldpp)->c_time;
  741.   newp->c_time = time;
  742.   newp->c_next = *oldpp;
  743.   if (*oldpp)
  744.     (*oldpp)->c_time -= time;
  745.   *oldpp = newp;
  746.   
  747.   /*
  748.    * If this is now the first callout then we have to set a new
  749.    * itimer.
  750.    */
  751.   if (callout == newp) {
  752.     itv.it_interval.tv_sec = itv.it_interval.tv_usec =
  753.       itv.it_value.tv_usec = 0;
  754.     itv.it_value.tv_sec = callout->c_time;
  755.     MAINDEBUG((LOG_DEBUG, "Setting itimer for %d seconds.",
  756.           itv.it_value.tv_sec))
  757.     if (setitimer(ITIMER_REAL, &itv, NULL)) {
  758.       syslog(LOG_ERR, "setitimer(ITIMER_REAL)");
  759.       exit(1);
  760.     }
  761.     if (gettimeofday(&schedtime, NULL)) {
  762.       syslog(LOG_ERR, "gettimeofday");
  763.       exit(1);
  764.     }
  765.   }
  766. }
  767.  
  768.  
  769. /*
  770.  * untimeout - Unschedule a timeout.
  771.  */
  772. void untimeout(func, arg)
  773.      void (*func)();
  774.      caddr_t arg;
  775. {
  776.   
  777.   struct itimerval itv;
  778.   struct callout **copp, *freep;
  779.   int reschedule = 0;
  780.   
  781.   MAINDEBUG((LOG_DEBUG, "Untimeout %x:%x.", (int) func, (int) arg))
  782.   
  783.   /*
  784.    * If the first callout is unscheduled then we have to set a new
  785.    * itimer.
  786.    */
  787.   if (callout &&
  788.       callout->c_func == func &&
  789.       callout->c_arg == arg)
  790.     reschedule = 1;
  791.   
  792.   /*
  793.    * Find first matching timeout.  Add its time to the next timeouts
  794.    * time.
  795.    */
  796.   for (copp = &callout; *copp; copp = &(*copp)->c_next)
  797.     if ((*copp)->c_func == func &&
  798.     (*copp)->c_arg == arg) {
  799.       freep = *copp;
  800.       *copp = freep->c_next;
  801.       if (*copp)
  802.     (*copp)->c_time += freep->c_time;
  803.       (void) free((char *) freep);
  804.       break;
  805.     }
  806.   
  807.   if (reschedule) {
  808.     itv.it_interval.tv_sec = itv.it_interval.tv_usec =
  809.       itv.it_value.tv_usec = 0;
  810.     itv.it_value.tv_sec = callout ? callout->c_time : 0;
  811.     MAINDEBUG((LOG_DEBUG, "Setting itimer for %d seconds.",
  812.           itv.it_value.tv_sec))
  813.     if (setitimer(ITIMER_REAL, &itv, NULL)) {
  814.       syslog(LOG_ERR, "setitimer(ITIMER_REAL)");
  815.       exit(1);
  816.     }
  817.     if (gettimeofday(&schedtime, NULL)) {
  818.       syslog(LOG_ERR, "gettimeofday");
  819.       exit(1);
  820.     }
  821.   }
  822. }
  823.  
  824.  
  825. /*
  826.  * adjtimeout - Decrement the first timeout by the amount of time since
  827.  * it was scheduled.
  828.  */
  829. void adjtimeout()
  830. {
  831.   struct timeval tv;
  832.   int timediff;
  833.   
  834.   if (callout == NULL)
  835.     return;
  836.   /*
  837.    * Make sure that the clock hasn't been warped dramatically.
  838.    * Account for recently expired, but blocked timer by adding
  839.    * small fudge factor.
  840.    */
  841.   if (gettimeofday(&tv, NULL)) {
  842.     syslog(LOG_ERR, "gettimeofday");
  843.     exit(1);
  844.   }
  845.   timediff = tv.tv_sec - schedtime.tv_sec;
  846.   if (timediff < 0 ||
  847.       timediff > callout->c_time + 1)
  848.     return;
  849.   
  850.   callout->c_time -= timediff;    /* OK, Adjust time */
  851. }
  852.  
  853.  
  854. /*
  855.  * output - Output PPP packet.
  856.  */
  857. void
  858.   output(unit, p, len)
  859. int unit;
  860. u_char *p;
  861. int len;
  862. {
  863. #ifdef    STREAMS
  864.   struct strbuf    str;
  865. #endif
  866.   if (unit != 0) {
  867.     MAINDEBUG((LOG_WARNING, "output: unit != 0!"))
  868.     abort();
  869.   }
  870. #ifdef    STREAMS
  871.   str.len = len;
  872.   str.buf = (caddr_t) p;
  873.   if(putmsg(fd, NULL, &str, 0) < 0) {
  874.     syslog(LOG_ERR, "putmsg");
  875.     exit(1);
  876.   }
  877. #else
  878.   if (write(fd, p, len) < 0) {
  879.     syslog(LOG_ERR, "write");
  880.     exit(1);
  881.   }
  882. #endif
  883. }
  884.  
  885.  
  886. /*
  887.  * hup - Catch SIGHUP signal.
  888.  *
  889.  * Indicates that the physical layer has been disconnected.
  890.  */
  891. /*ARGSUSED*/
  892. static void
  893.   hup(sig, code, scp, addr)
  894. int sig, code;
  895. struct sigcontext *scp;
  896. char *addr;
  897. {
  898.   MAINDEBUG((LOG_NOTICE, "Hangup"))
  899.   adjtimeout();        /* Adjust timeouts */
  900.   lcp_lowerdown(0);        /* Reset connection */
  901. }
  902.  
  903.  
  904. /*
  905.  * term - Catch SIGTERM signal.
  906.  *
  907.  * Indicates that we should initiate a graceful disconnect and exit.
  908.  */
  909. /*ARGSUSED*/
  910. static void
  911.   term(sig, code, scp, addr)
  912. int sig, code;
  913. struct sigcontext *scp;
  914. char *addr;
  915. {
  916.   syslog(LOG_NOTICE, "Terminate signal received.");
  917.   adjtimeout();        /* Adjust timeouts */
  918.   lcp_close(0);        /* Close connection */
  919. }
  920.  
  921.  
  922. /*
  923.  * intr - Catch SIGINT signal (DEL/^C).
  924.  *
  925.  * Indicates that we should initiate a graceful disconnect and exit.
  926.  */
  927. /*ARGSUSED*/
  928. static void
  929.   intr(sig, code, scp, addr)
  930. int sig, code;
  931. struct sigcontext *scp;
  932. char *addr;
  933. {
  934.   syslog(LOG_NOTICE, "Interrupt received.  Exiting.");
  935.   adjtimeout();        /* Adjust timeouts */
  936.   lcp_close(0);        /* Close connection */
  937. }
  938.  
  939.  
  940. /*
  941.  * alrm - Catch SIGALRM signal.
  942.  *
  943.  * Indicates a timeout.
  944.  */
  945. /*ARGSUSED*/
  946. static void
  947.   alrm(sig, code, scp, addr)
  948. int sig, code;
  949. struct sigcontext *scp;
  950. char *addr;
  951. {
  952.   struct itimerval itv;
  953.   struct callout *freep;
  954.   
  955.   MAINDEBUG((LOG_DEBUG, "Alarm"))
  956.   
  957.   /*
  958.    * Call and free first scheduled timeout and any that were scheduled
  959.    * for the same time.
  960.    */
  961.   while (callout) {
  962.     freep = callout;    /* Remove entry before calling */
  963.     callout = freep->c_next;
  964.     (*freep->c_func)(freep->c_arg);
  965.     (void) free((char *) freep);
  966.     if (callout && callout->c_time)
  967.       break;
  968.   }
  969.   
  970.   /*
  971.    * Set a new itimer if there are more timeouts scheduled.
  972.    */
  973.   if (callout) {
  974.     itv.it_interval.tv_sec = itv.it_interval.tv_usec =
  975.       itv.it_value.tv_usec = 0;
  976.     itv.it_value.tv_sec = callout->c_time;
  977.     MAINDEBUG((LOG_DEBUG, "Setting itimer for %d seconds.",
  978.           itv.it_value.tv_sec))
  979.     if (setitimer(ITIMER_REAL, &itv, NULL)) {
  980.       syslog(LOG_ERR, "setitimer(ITIMER_REAL)");
  981.       exit(1);
  982.     }
  983.     if (gettimeofday(&schedtime, NULL)) {
  984.       syslog(LOG_ERR, "gettimeofday");
  985.       exit(1);
  986.     }
  987.   }
  988. }
  989.  
  990.  
  991. /*
  992.  * io - Catch SIGIO signal.
  993.  *
  994.  * Indicates that incoming data is available.
  995.  */
  996. /*ARGSUSED*/
  997. static void
  998.   io(sig, code, scp, addr)
  999. int sig, code;
  1000. struct sigcontext *scp;
  1001. char *addr;
  1002. {
  1003.   int len, i;
  1004.   u_char *p;
  1005.   u_short protocol;
  1006.   fd_set fdset;
  1007.   struct timeval notime;
  1008.   int ready;
  1009.  
  1010. #ifdef    STREAMS
  1011.   struct strbuf str;
  1012. #endif
  1013.   MAINDEBUG((LOG_DEBUG, "IO signal received"))
  1014.   adjtimeout();        /* Adjust timeouts */
  1015.  
  1016.   /* we do this to see if the SIGIO handler is being invoked for input */
  1017.   /* ready, or for the socket buffer hitting the low-water mark. */
  1018.  
  1019.   notime.tv_sec = 0;
  1020.   notime.tv_usec = 0;
  1021.  
  1022.   FD_ZERO(&fdset);
  1023.   FD_SET(fd, &fdset);
  1024.   
  1025.   if ((ready = select(32, &fdset, (fd_set *) NULL, (fd_set *) NULL,
  1026.               ¬ime)) == -1) {
  1027.     syslog(LOG_ERR, "Error in io() select: %m");
  1028.     exit(1);
  1029.   }
  1030.     
  1031.   if (ready == 0) {
  1032.     MAINDEBUG((LOG_DEBUG, "IO non-input ready SIGIO occured."));
  1033.     return;
  1034.   }
  1035.  
  1036.   /* Yup, this is for real */
  1037.   for (;;) {            /* Read all available packets */
  1038.     p = inpacket_buf;        /* point to beggining of packet buffer */
  1039. #ifdef    STREAMS
  1040.     str.maxlen = MTU+DLLHEADERLEN;
  1041.     str.buf = (caddr_t) p;
  1042.     i = 0;
  1043.     len = getmsg(fd, NULL, &str, &i);
  1044.     if(len < 0) {
  1045.       if(errno == EAGAIN || errno == EWOULDBLOCK) {
  1046.     return;
  1047.       }
  1048.       syslog(LOG_ERR, "getmsg(fd) %m");
  1049.       exit(1);
  1050.     }
  1051.     else if(len) 
  1052.       MAINDEBUG((LOG_DEBUG, "getmsg returns with length 0x%x",len))
  1053.     
  1054.     if(str.len < 0) {
  1055.       MAINDEBUG((LOG_DEBUG, "getmsg short return length %d",
  1056.         str.len))
  1057.       return;
  1058.     }
  1059.     
  1060.     len = str.len;
  1061. #else
  1062.     if ((len = read(fd, p, MTU + DLLHEADERLEN)) < 0) {
  1063.       if (errno == EWOULDBLOCK) {
  1064.     MAINDEBUG((LOG_DEBUG, "read(fd): EWOULDBLOCK"))
  1065.     return;
  1066.       }
  1067.       else {
  1068.     syslog(LOG_ERR, "read(fd): %m");
  1069.     exit(1);
  1070.       }
  1071.     }
  1072.     else 
  1073. #endif
  1074.       if (len == 0) {
  1075.     syslog(LOG_ERR, "End of file on fd!");
  1076.     exit(1);
  1077.       }
  1078.     
  1079.     if (len < DLLHEADERLEN) {
  1080.       MAINDEBUG((LOG_INFO, "io(): Received short packet."))
  1081.       return;
  1082.     }
  1083.     
  1084.     p += 2;                /* Skip address and control */
  1085.     GETSHORT(protocol, p);
  1086.     len -= DLLHEADERLEN;
  1087.     
  1088.     /*
  1089.      * Toss all non-LCP packets unless LCP is OPEN.
  1090.      */
  1091.     if (protocol != LCP && lcp_fsm[0].state != OPEN) {
  1092.       MAINDEBUG((LOG_INFO, "io(): Received non-LCP packet and LCP is not in open state."))
  1093.       return;
  1094.     }
  1095.     
  1096.     /*
  1097.      * Upcall the proper protocol input routine.
  1098.      */
  1099.     for (i = 0; i < sizeof (prottbl) / sizeof (struct protent); i++)
  1100.       if (prottbl[i].protocol == protocol) {
  1101.     (*prottbl[i].input)(0, p, len);
  1102.     break;
  1103.       }
  1104.     
  1105.     if (i == sizeof (prottbl) / sizeof (struct protent)) {
  1106.       syslog(LOG_WARNING, "input: Unknown protocol (%x) received!",
  1107.          protocol);
  1108.       p -= DLLHEADERLEN;
  1109.       len += DLLHEADERLEN;
  1110.       lcp_sprotrej(0, p, len);
  1111.     }
  1112.   }
  1113. }
  1114.  
  1115. /*
  1116.  * cleanup - clean_up before we exit
  1117.  */
  1118. /* ARGSUSED */
  1119. static void
  1120.   cleanup(status, arg)
  1121. int status;
  1122. caddr_t arg;
  1123. {
  1124.   adjtimeout();
  1125.   lcp_lowerdown(0);
  1126.   str_restore();
  1127.   if (unlink(pidfilename) < 0) 
  1128.     syslog(LOG_WARNING, "unable to unlink pid file: %m");
  1129. }
  1130.  
  1131.  
  1132. /*
  1133.  * demuxprotrej - Demultiplex a Protocol-Reject.
  1134.  */
  1135. void
  1136.   demuxprotrej(unit, protocol)
  1137. int unit;
  1138. u_short protocol;
  1139. {
  1140.   int i;
  1141.   
  1142.   /*
  1143.    * Upcall the proper Protocol-Reject routine.
  1144.    */
  1145.   for (i = 0; i < sizeof (prottbl) / sizeof (struct protent); i++)
  1146.     if (prottbl[i].protocol == protocol) {
  1147.       (*prottbl[i].protrej)(unit);
  1148.       return;
  1149.     }
  1150.   syslog(LOG_WARNING, "demuxprotrej: Unrecognized Protocol-Reject for protocol %d!", protocol);
  1151. }
  1152.  
  1153.  
  1154. /*
  1155.  * incdebug - Catch SIGUSR1 signal.
  1156.  *
  1157.  * Increment debug flag.
  1158.  */
  1159. /*ARGSUSED*/
  1160. static void
  1161.   incdebug(sig, code, scp, addr)
  1162. int sig, code;
  1163. struct sigcontext *scp;
  1164. char *addr;
  1165. {
  1166.   MAINDEBUG((LOG_NOTICE, "Debug turned ON, Level %d",debug))
  1167.   setlogmask(LOG_UPTO(LOG_DEBUG));
  1168.   debug++;
  1169. }
  1170.  
  1171.  
  1172. /*
  1173.  * nodebug - Catch SIGUSR2 signal.
  1174.  *
  1175.  * Turn off debugging.
  1176.  */
  1177. /*ARGSUSED*/
  1178. static void
  1179.   nodebug(sig, code, scp, addr)
  1180. int sig, code;
  1181. struct sigcontext *scp;
  1182. char *addr;
  1183. {
  1184.   setlogmask(LOG_UPTO(LOG_WARNING));
  1185.   debug = 0;
  1186. }
  1187.  
  1188.  
  1189. /*
  1190.  * setdebug - Set debug (command line argument).
  1191.  */
  1192. static int
  1193.   setdebug(argcp, argvp)
  1194. int *argcp;
  1195. char ***argvp;
  1196. {
  1197.   debug++;
  1198.   setlogmask(LOG_UPTO(LOG_DEBUG));
  1199.   --*argcp, ++*argvp;
  1200.   return (1);
  1201. }
  1202.  
  1203. /*
  1204.  * noopt - Disable all options.
  1205.  */
  1206. static int
  1207.   noopt(argcp, argvp)
  1208. int *argcp;
  1209. char ***argvp;
  1210. {
  1211.   bzero((char *) &lcp_wantoptions[0], sizeof (struct lcp_options));
  1212.   bzero((char *) &lcp_allowoptions[0], sizeof (struct lcp_options));
  1213.   bzero((char *) &ipcp_wantoptions[0], sizeof (struct ipcp_options));
  1214.   bzero((char *) &ipcp_allowoptions[0], sizeof (struct ipcp_options));
  1215.   --*argcp, ++*argvp;
  1216.   return (1);
  1217. }
  1218.  
  1219.  
  1220. /*
  1221.  * setconnector - Set a program to connect to a serial line
  1222.  */
  1223. static int
  1224.   setconnector(argcp, argvp)
  1225. int *argcp;
  1226. char ***argvp;
  1227. {
  1228.   
  1229.   --*argcp, ++*argvp;
  1230.   
  1231.   connector = strdup(**argvp);
  1232.   if (connector == NULL) {
  1233.     syslog(LOG_ERR, "cannot allocate space for connector string");
  1234.     exit(1);
  1235.   }
  1236.   
  1237.   --*argcp, ++*argvp;
  1238.   return (1);
  1239. }
  1240.  
  1241.  
  1242. /*
  1243.  * set_up_connection - run a program to initialize the serial connector
  1244.  */
  1245. int set_up_connection(program, in, out)
  1246.      char *program;
  1247.      int in, out;
  1248. {
  1249.   int pid;
  1250.   int flags;
  1251.   int status;
  1252.   
  1253.   flags = sigblock(sigmask(SIGINT)|sigmask(SIGHUP));
  1254.   pid = fork();
  1255.   
  1256.   if (pid < 0) {
  1257.     syslog(LOG_ERR, "fork");
  1258.     exit(1);
  1259.   }
  1260.   
  1261.   if (pid == 0) {
  1262.     (void) setreuid(getuid(), getuid());
  1263.     (void) setregid(getgid(), getgid());
  1264.     (void) sigsetmask(flags);
  1265.     (void) dup2(in, 0);
  1266.     (void) dup2(out, 1);
  1267.     (void) execl("/bin/sh", "sh", "-c", program, (char *)0);
  1268.     syslog(LOG_ERR, "could not exec /bin/sh");
  1269.     _exit(99);
  1270.   }
  1271.   else {
  1272.     while (waitpid(pid, &status, 0) != pid) {
  1273.       if (errno == EINTR)
  1274.     continue;
  1275.       syslog(LOG_ERR, "waiting for connection process");
  1276.       exit(1);
  1277.     }
  1278.     (void) sigsetmask(flags);
  1279.   }
  1280.   return (status == 0 ? 0 : -1);
  1281. }
  1282.  
  1283. /*
  1284.  * noaccomp - Disable Address/Control field compression negotiation.
  1285.  */
  1286. static int
  1287.   noaccomp(argcp, argvp)
  1288. int *argcp;
  1289. char ***argvp;
  1290. {
  1291.   lcp_wantoptions[0].neg_accompression = 0;
  1292.   lcp_allowoptions[0].neg_accompression = 0;
  1293.   --*argcp, ++*argvp;
  1294.   return (1);
  1295. }
  1296.  
  1297.  
  1298. /*
  1299.  * noasyncmap - Disable async map negotiation.
  1300.  */
  1301. static int
  1302.   noasyncmap(argcp, argvp)
  1303. int *argcp;
  1304. char ***argvp;
  1305. {
  1306.   lcp_wantoptions[0].neg_asyncmap = 0;
  1307.   lcp_allowoptions[0].neg_asyncmap = 0;
  1308.   --*argcp, ++*argvp;
  1309.   return (1);
  1310. }
  1311.  
  1312.  
  1313. /*
  1314.  * noipaddr - Disable IP address negotiation.
  1315.  */
  1316. static int
  1317.   noipaddr(argcp, argvp)
  1318. int *argcp;
  1319. char ***argvp;
  1320. {
  1321.   ipcp_wantoptions[0].neg_addrs = 0;
  1322.   ipcp_allowoptions[0].neg_addrs = 0;
  1323.   --*argcp, ++*argvp;
  1324.   return (1);
  1325. }
  1326.  
  1327.  
  1328. /*
  1329.  * nomagicnumber - Disable magic number negotiation.
  1330.  */
  1331. static int
  1332.   nomagicnumber(argcp, argvp)
  1333. int *argcp;
  1334. char ***argvp;
  1335. {
  1336.   lcp_wantoptions[0].neg_magicnumber = 0;
  1337.   lcp_allowoptions[0].neg_magicnumber = 0;
  1338.   --*argcp, ++*argvp;
  1339.   return (1);
  1340. }
  1341.  
  1342.  
  1343. /*
  1344.  * nomru - Disable mru negotiation.
  1345.  */
  1346. static int
  1347.   nomru(argcp, argvp)
  1348. int *argcp;
  1349. char ***argvp;
  1350. {
  1351.   lcp_wantoptions[0].neg_mru = 0;
  1352.   lcp_allowoptions[0].neg_mru = 0;
  1353.   --*argcp, ++*argvp;
  1354.   return (1);
  1355. }
  1356.  
  1357.  
  1358. /*
  1359.  * setmru - Set MRU for negotiation.
  1360.  */
  1361. static int
  1362.   setmru(argcp, argvp)
  1363. int *argcp;
  1364. char ***argvp;
  1365. {
  1366.   --*argcp, ++*argvp;
  1367.   lcp_wantoptions[0].mru = atoi(**argvp);
  1368.   --*argcp, ++*argvp;
  1369.   return (1);
  1370. }
  1371.  
  1372.  
  1373. /*
  1374.  * nopcomp - Disable Protocol field compression negotiation.
  1375.  */
  1376. static int
  1377.   nopcomp(argcp, argvp)
  1378. int *argcp;
  1379. char ***argvp;
  1380. {
  1381.   lcp_wantoptions[0].neg_pcompression = 0;
  1382.   lcp_allowoptions[0].neg_pcompression = 0;
  1383.   --*argcp, ++*argvp;
  1384.   return (1);
  1385. }
  1386.  
  1387.  
  1388. /*
  1389.  * setpassive - Set passive mode.
  1390.  */
  1391. static int
  1392.   setpassive(argcp, argvp)
  1393. int *argcp;
  1394. char ***argvp;
  1395. {
  1396.   lcp_wantoptions[0].passive = 1;
  1397.   --*argcp, ++*argvp;
  1398.   return (1);
  1399. }
  1400.  
  1401.  
  1402. /*
  1403.  * noupap - Disable UPAP authentication.
  1404.  */
  1405. static int
  1406.   noupap(argcp, argvp)
  1407. int *argcp;
  1408. char ***argvp;
  1409. {
  1410.   lcp_allowoptions[0].neg_upap = 0;
  1411.   --*argcp, ++*argvp;
  1412.   return (1);
  1413. }
  1414.  
  1415.  
  1416. /*
  1417.  * requpap - Require UPAP authentication.
  1418.  */
  1419. static int
  1420.   requpap(argcp, argvp)
  1421. int *argcp;
  1422. char ***argvp;
  1423. {
  1424.   FILE * ufile;
  1425.   struct stat sbuf;
  1426.  
  1427.   lcp_wantoptions[0].neg_upap = 1;
  1428.   lcp_allowoptions[0].neg_upap = 0;
  1429.   --*argcp, ++*argvp;
  1430.   strcpy(uinfopath, **argvp);
  1431.   --*argcp, ++*argvp;
  1432.  
  1433.   /* open user info file */
  1434.  
  1435.   if ((ufile = fopen(uinfopath, "r")) == NULL) {
  1436.     fprintf(stderr,  "unable to open user login data file %s\n", uinfopath);
  1437.     exit(1);
  1438.   };
  1439.      
  1440.   if (fstat(fileno(ufile), &sbuf) < 0) {
  1441.     perror("cannot stat user login data file!");
  1442.     exit(1);
  1443.   }
  1444.   if ((sbuf.st_mode & 077) != 0)
  1445.     syslog(LOG_WARNING, "Warning - user info file has world and/or group access!\n");
  1446.  
  1447.   /* get username */
  1448.   fgets(user, sizeof (user) - 1, ufile);
  1449.   if (strlen(user) == 0) {
  1450.     fprintf(stderr, "Unable to get user name from user login data file.\n");
  1451.     exit(2);
  1452.   }
  1453.   /* get rid of newline */
  1454.   user[strlen(user) - 1] = '\000';
  1455.  
  1456.   fgets(passwd, sizeof(passwd) - 1, ufile);
  1457.  
  1458.   if (strlen(passwd) == 0) {
  1459.     fprintf(stderr, "Unable to get password from user login data file.\n");
  1460.     exit(2);
  1461.   }
  1462.  
  1463.   passwd[strlen(passwd) - 1] = '\000';
  1464.  
  1465.   return (1);
  1466. }
  1467.  
  1468.  
  1469. /*
  1470.  * nochap - Disable CHAP authentication.
  1471.  */
  1472. static int
  1473.   nochap(argcp, argvp)
  1474. int *argcp;
  1475. char ***argvp;
  1476. {
  1477.   lcp_allowoptions[0].neg_chap = 0;
  1478.   --*argcp, ++*argvp;
  1479.   return (1);
  1480. }
  1481.  
  1482.  
  1483. /*
  1484.  * reqchap - Require CHAP authentication.
  1485.  */
  1486. static int
  1487.   reqchap(argcp, argvp)
  1488. int *argcp;
  1489. char ***argvp;
  1490. {
  1491.   lcp_wantoptions[0].neg_chap = 1;
  1492.   lcp_allowoptions[0].neg_chap = 0;
  1493.   --*argcp, ++*argvp;
  1494.   return (1);
  1495. }
  1496.  
  1497.  
  1498. /*
  1499.  *    setvjmode - Set vj compression mode
  1500.  */
  1501.  
  1502. static int
  1503.   setvjmode(argcp, argvp)
  1504. int *argcp;
  1505. char ***argvp;
  1506. {
  1507.   extern int ipcp_vj_mode;
  1508.   
  1509.   --*argcp, ++*argvp;
  1510.   
  1511.   if (!strcmp(**argvp, "old")) {    /* "old" mode */
  1512.     ipcp_vj_setmode(IPCP_VJMODE_OLD);
  1513.   }
  1514.   
  1515.   else if (!strcmp(**argvp, "current")) {    /* "current" mode (default)*/
  1516.     ipcp_vj_setmode(IPCP_VJMODE_CURRENT);
  1517.   }
  1518.   
  1519.   else if (!strcmp(**argvp, "draft")) {    /* "draft" mode */
  1520.     ipcp_vj_setmode(IPCP_VJMODE_DRAFT);
  1521.   }
  1522.   else {
  1523.     MAINDEBUG((LOG_WARNING, "Unknown vj compression mode %s. Defaulting to current.", **argvp))
  1524.     ipcp_vj_setmode(IPCP_VJMODE_CURRENT);
  1525.   }
  1526.   --*argcp, ++*argvp;
  1527.   
  1528.   return (1);
  1529. }
  1530. /*
  1531.  *    setnovj - diable vj compression
  1532.  */
  1533.  
  1534. static int
  1535.   setnovj(argcp, argvp)
  1536. int *argcp;
  1537. char ***argvp;
  1538. {
  1539.   extern int ipcp_vj_mode;
  1540.   
  1541.   --*argcp, ++*argvp;
  1542.   ipcp_wantoptions[0].neg_vj = 0;
  1543.   ipcp_allowoptions[0].neg_vj = 0;
  1544.   
  1545.   return (1);
  1546. }
  1547.  
  1548. /*
  1549.  * setdomain - Set domain name to append to hostname 
  1550.  */
  1551. static int
  1552.   setdomain(argcp, argvp)
  1553. int *argcp;
  1554. char ***argvp;
  1555. {
  1556.   
  1557.   --*argcp, ++*argvp;
  1558.  
  1559.   strcat(hostname, **argvp);
  1560.   hostname_len = strlen(hostname);
  1561.  
  1562.   --*argcp, ++*argvp;
  1563.  
  1564.   return (1);
  1565. }
  1566.  
  1567. /*
  1568.  * Valid speeds.
  1569.  */
  1570. struct speed {
  1571.   int speed_int, speed_val;
  1572. } speeds[] = {
  1573. #ifdef B50
  1574.   { 50, B50 },
  1575. #endif
  1576. #ifdef B75
  1577.   { 75, B75 },
  1578. #endif
  1579. #ifdef B110
  1580.   { 110, B110 },
  1581. #endif
  1582. #ifdef B150
  1583.   { 150, B150 },
  1584. #endif
  1585. #ifdef B200
  1586.   { 200, B200 },
  1587. #endif
  1588. #ifdef B300
  1589.   { 300, B300 },
  1590. #endif
  1591. #ifdef B600
  1592.   { 600, B600 },
  1593. #endif
  1594. #ifdef B1200
  1595.   { 1200, B1200 },
  1596. #endif
  1597. #ifdef B1800
  1598.   { 1800, B1800 },
  1599. #endif
  1600. #ifdef B2000
  1601.   { 2000, B2000 },
  1602. #endif
  1603. #ifdef B2400
  1604.   { 2400, B2400 },
  1605. #endif
  1606. #ifdef B3600
  1607.   { 3600, B3600 },
  1608. #endif
  1609. #ifdef B4800
  1610.   { 4800, B4800 },
  1611. #endif
  1612. #ifdef B7200
  1613.   { 7200, B7200 },
  1614. #endif
  1615. #ifdef B9600
  1616.   { 9600, B9600 },
  1617. #endif
  1618. #ifdef EXTA
  1619.   { 19200, EXTA },
  1620. #endif
  1621. #ifdef EXTB
  1622.   { 38400, EXTB },
  1623. #endif
  1624.   { 0, 0 }
  1625. };
  1626.  
  1627. static int
  1628.   setasyncmap(argcp, argvp) 
  1629. int    *argcp;
  1630. char    ***argvp;
  1631. {
  1632.   unsigned long asyncmap;
  1633.   
  1634.   asyncmap = 0xffffffff;
  1635.   ++*argvp;
  1636.   sscanf(**argvp,"%lx",&asyncmap);
  1637.   ++*argvp;
  1638.   lcp_wantoptions[0].asyncmap = asyncmap;
  1639.   *argcp -= 2;
  1640.   return(1);
  1641. }
  1642.  
  1643. /*
  1644.  * setspeed - Set the speed.
  1645.  */
  1646. static int
  1647.   setspeed(argcp, argvp)
  1648. int *argcp;
  1649. char ***argvp;
  1650. {
  1651.   int speed;
  1652.   struct speed *speedp;
  1653.   
  1654.   speed = atoi(**argvp);
  1655.   for (speedp = speeds; speedp->speed_int; speedp++)
  1656.     if (speed == speedp->speed_int) {
  1657.       inspeed = speedp->speed_val;
  1658.       --*argcp, ++*argvp;
  1659.       return (1);
  1660.     }
  1661.   return (0);
  1662. }
  1663.  
  1664.  
  1665. /*
  1666.  * setdevname - Set the device name.
  1667.  */
  1668. int setdevname(argcp, argvp)
  1669.      int *argcp;
  1670.      char ***argvp;
  1671. {
  1672.   char dev[DEVNAME_SIZE];
  1673.   char *cp = **argvp;
  1674.   struct stat statbuf;
  1675.   char *tty, *ttyname();
  1676.   
  1677.   if (strncmp("/dev/", cp, sizeof ("/dev/") - 1)) {
  1678.     (void) sprintf(dev, "/dev/%s", cp);
  1679.     cp = dev;
  1680.   }
  1681.   
  1682.   /*
  1683.    * Check if there is a device by this name.
  1684.    */
  1685.   if (stat(cp, &statbuf) < 0) {
  1686.     if (errno == ENOENT)
  1687.       return (0);
  1688.     syslog(LOG_ERR, cp);
  1689.     exit(1);
  1690.   }
  1691.   
  1692.   (void) strcpy(devname, cp);
  1693.   --*argcp, ++*argvp;
  1694.   
  1695.   /*
  1696.    * If we haven't already decided to require authentication,
  1697.    * or we are running ppp on the control terminal, then we can
  1698.    * allow authentication to be requested.
  1699.    */
  1700.   if ((tty = ttyname(fileno(stdin))) == NULL)
  1701.     tty = ""; /* running from init means no stdin.  Null kills strcmp -KWK */
  1702.   if (lcp_wantoptions[0].neg_upap == 0 &&
  1703.       strcmp(devname, "/dev/tty") &&
  1704.       strcmp(devname, tty)) {
  1705.     lcp_wantoptions[0].neg_upap = 0;
  1706.     lcp_allowoptions[0].neg_upap = 1;
  1707.   }
  1708.   return (1);
  1709. }
  1710.  
  1711.  
  1712. /*
  1713.  * setipaddr - Set the IP address
  1714.  */
  1715. int setipaddr(argcp, argvp)
  1716.      int *argcp;
  1717.      char ***argvp;
  1718. {
  1719.   u_long local, remote;
  1720.   struct hostent *hp;
  1721.   char *colon, *index();
  1722.   
  1723.   /*
  1724.    * IP address pair separated by ":".
  1725.    */
  1726.   if ((colon = index(**argvp, ':')) == NULL)
  1727.     return (0);
  1728.   
  1729.   /*
  1730.    * If colon first character, then no local addr.
  1731.    */
  1732.   if (colon == **argvp) {
  1733.     local = 0l;
  1734.     ++colon;
  1735.   }
  1736.   else {
  1737.     *colon++ = '\0';
  1738.     if ((local = inet_addr(**argvp)) == -1) {
  1739.       if ((hp = gethostbyname(**argvp)) == NULL) {
  1740.     syslog(LOG_WARNING, "unknown host: %s", **argvp);
  1741.     goto ret;
  1742.       }
  1743.       bcopy(hp->h_addr, (char *) &local, hp->h_length);
  1744.     }
  1745.   }
  1746.   
  1747.   /*
  1748.    * If colon last character, then no remote addr.
  1749.    */
  1750.   if (*colon == '\0')
  1751.     remote = 0l;
  1752.   else {
  1753.     if ((remote = inet_addr(colon)) == -1) {
  1754.       if ((hp = gethostbyname(colon)) == NULL) {
  1755.     syslog(LOG_WARNING,"unknown host: %s", colon);
  1756.     goto ret;
  1757.       }
  1758.       bcopy(hp->h_addr, (char *) &remote, hp->h_length);
  1759.     }
  1760.   }
  1761.   
  1762.   ipcp_wantoptions[0].neg_addrs = 1;
  1763.   ipcp_wantoptions[0].ouraddr = local;
  1764.   ipcp_wantoptions[0].hisaddr = remote;
  1765.   
  1766.  ret:
  1767.   --*argcp, ++*argvp;
  1768.   return (1);
  1769. }
  1770.  
  1771. static int
  1772.   setnetmask(argcp, argvp)
  1773. int *argcp;
  1774. char ***argvp;
  1775. {
  1776.   u_long mask;
  1777.     
  1778.   --*argcp, ++*argvp;
  1779.   if ((mask = inet_addr(**argvp)) == -1) {
  1780.     fprintf(stderr, "Invalid netmask %s\n", **argvp);
  1781.     exit(1);
  1782.   }
  1783.  
  1784.   netmask = mask;
  1785.   --*argcp, ++*argvp;
  1786.   return (1);
  1787. }
  1788.  
  1789. /*
  1790.  * getuserpasswd - Get the user name and passwd.
  1791.  */
  1792. static void
  1793.   getuserpasswd()
  1794. {
  1795.  
  1796.   upap[0].us_user = user;
  1797.   upap[0].us_userlen = strlen(upap[0].us_user);
  1798.  
  1799.   upap[0].us_passwd = passwd;
  1800.   upap[0].us_passwdlen = strlen(upap[0].us_passwd);
  1801. }
  1802.  
  1803.  
  1804. /*
  1805.  * login - Check the user name and passwd and login the user.
  1806.  *
  1807.  * returns:
  1808.  *    UPAP_AUTHNAK: Login failed.
  1809.  *    UPAP_AUTHACK: Login succeeded.
  1810.  * In either case, msg points to an appropriate message.
  1811.  */
  1812. u_char
  1813.   login(user, userlen, passwd, passwdlen, msg, msglen)
  1814. char *user;
  1815. int userlen;
  1816. char *passwd;
  1817. int passwdlen;
  1818. char **msg;
  1819. int *msglen;
  1820. {
  1821.   struct passwd *pw;
  1822.   char *epasswd, *crypt();
  1823.   static int attempts = 0;
  1824.   char *tty, *rindex();
  1825.   char *tmp_passwd, *tmp_user;
  1826.   
  1827.   /* why alloca.h doesn't define what alloca() returns is a mystery */
  1828.   
  1829. #ifdef sparc
  1830.   char *__builtin_alloca __ARGS((int));
  1831. #else
  1832.   char *alloca __ARGS((int));
  1833. #endif /*sparc*/
  1834.   tmp_passwd = alloca(passwdlen + 1);    /* we best make copies before */
  1835.   /* null terminating the string */ 
  1836.   if (tmp_passwd == NULL) {
  1837.     syslog(LOG_ERR, "alloca failed");
  1838.     exit(1);
  1839.   }
  1840.   bcopy(passwd, tmp_passwd, passwdlen);
  1841.   tmp_passwd[passwdlen] = '\0';
  1842.   
  1843.   tmp_user = alloca(userlen + 1);
  1844.   if (tmp_user == NULL) {
  1845.     syslog(LOG_ERR, "alloca failed");
  1846.     exit(1);
  1847.   }
  1848.   bcopy(user, tmp_user, userlen);
  1849.   tmp_user[userlen] = '\0';
  1850.   
  1851.   if ((pw = getpwnam(tmp_user)) == NULL) {
  1852.     *msg = "Login incorrect";
  1853.     *msglen = strlen(*msg);
  1854.     syslog(LOG_WARNING, "upap login userid '%s' incorrect",tmp_user);
  1855.     return (UPAP_AUTHNAK);
  1856.   }
  1857.   
  1858.   /*
  1859.    * XXX If no passwd, let them login without one.
  1860.    */
  1861.   if (pw->pw_passwd == '\0') {
  1862.     *msg = "Login ok";
  1863.     *msglen = strlen(*msg);
  1864.     return (UPAP_AUTHACK);
  1865.   }
  1866.   
  1867.   epasswd = crypt(tmp_passwd, pw->pw_passwd);
  1868.   if (strcmp(epasswd, pw->pw_passwd)) {
  1869.     *msg = "Login incorrect";
  1870.     *msglen = strlen(*msg);
  1871.     syslog(LOG_WARNING, "upap login password '%s' incorrect", tmp_passwd);
  1872.     /*
  1873.      * Frustrate passwd stealer programs.
  1874.      * Allow 10 tries, but start backing off after 3 (stolen from login).
  1875.      * On 10'th, drop the connection.
  1876.      */
  1877.     if (attempts++ >= 10) {
  1878.       syslog(LOG_WARNING, "%d LOGIN FAILURES ON %s, %s",
  1879.          attempts, devname, tmp_user);
  1880.       lcp_close(0);        /* Drop DTR? */
  1881.     }
  1882.     if (attempts > 3)
  1883.       sleep((u_int) (attempts - 3) * 5);
  1884.     return (UPAP_AUTHNAK);
  1885.   }
  1886.   
  1887.   attempts = 0;            /* Reset count */
  1888.   *msg = "Login ok";
  1889.   *msglen = strlen(*msg);
  1890.   syslog(LOG_NOTICE, "user %s logged in", tmp_user);
  1891.   tty = rindex(devname, '/');
  1892.   if (tty == NULL)
  1893.     tty = devname;
  1894.   else
  1895.     tty++;
  1896.   logwtmp(tty, tmp_user, "");        /* Add wtmp login entry */
  1897.   
  1898.   return (UPAP_AUTHACK);
  1899. }
  1900.  
  1901.  
  1902. /*
  1903.  * logout - Logout the user.
  1904.  */
  1905. void logout()
  1906. {
  1907.   char *tty;
  1908.   
  1909.   tty = rindex(devname, '/');
  1910.   if (tty == NULL)
  1911.     tty = devname;
  1912.   else
  1913.     tty++;
  1914.   logwtmp(tty, "", "");        /* Add wtmp logout entry */
  1915. }
  1916.  
  1917.  
  1918. /*
  1919.  * getuseropt - Get the options from /etc/hosts.ppp for this user.
  1920.  */
  1921. int getuseropt(user)
  1922.      char *user;
  1923. {
  1924.   char buf[1024], *s;
  1925.   FILE *fp;
  1926.   int rc = 0;
  1927.   
  1928.   if ((fp = fopen(PPPHOSTS, "r")) == NULL)
  1929.     return (0);;
  1930.   
  1931.   /*
  1932.    * Loop till we find an entry for this user.
  1933.    */
  1934.   for (;;) {
  1935.     if (fgets(buf, sizeof (buf), fp) == NULL) {
  1936.       if (feof(fp))
  1937.     break;
  1938.       else {
  1939.     syslog(LOG_ERR, "fgets");
  1940.     exit(1);
  1941.       }
  1942.     }
  1943.     if ((s = index(buf, ' ')) == NULL)
  1944.       continue;
  1945.     *s++ = '\0';
  1946.     if (!strcmp(user, buf)) {
  1947.       rc = 1;
  1948.       break;
  1949.     }
  1950.   }
  1951.   fclose(fp);
  1952.   return (rc);
  1953. }
  1954. /*
  1955.  * open "secret" file and return the secret matching the given name.
  1956.  * If no secret for a given name is found, use the one for "default".
  1957.  */
  1958.  
  1959. void
  1960.   get_secret(name, secret, secret_len)
  1961. u_char * name;
  1962. u_char * secret;
  1963. int * secret_len;
  1964. {
  1965.   FILE * sfile;
  1966.   struct stat sbuf;
  1967.   u_char fname[256];
  1968.   int match_found, default_found;
  1969.  
  1970.   match_found = FALSE;
  1971.   default_found = FALSE;
  1972.  
  1973.   if ((sfile = fopen(_PATH_CHAPFILE, "r")) == NULL) {
  1974.     syslog(LOG_ERR, "unable to open secret file %s", _PATH_CHAPFILE);
  1975.     exit(1);
  1976.   };
  1977.      
  1978.   if (fstat(fileno(sfile), &sbuf) < 0) {
  1979.     syslog(LOG_ERR, "cannot stat secret file!: %m");
  1980.     exit(1);
  1981.   }
  1982.   if ((sbuf.st_mode & 077) != 0)
  1983.     syslog(LOG_WARNING, "Warning - secret file has world and/or group access!");
  1984.  
  1985.   while (!feof(sfile) && !match_found) {
  1986.     if (fscanf(sfile, "%s %s", fname, secret) == EOF)
  1987.       break;
  1988.     if (!strcasecmp(fname, name)) {
  1989.       match_found = TRUE;
  1990.     }
  1991.     if (!strcasecmp("default", name)) {
  1992.       default_found = TRUE;
  1993.     }
  1994.   }
  1995.  
  1996.   if (!match_found && !default_found)  {
  1997.     syslog(LOG_ERR, "No match or default entry found for %s in CHAP secret file! Aborting...", name);
  1998.     cleanup(0, NULL);        /* shut us down */
  1999.   }
  2000. #ifdef UNSECURE
  2001. /* while this is useful for debugging, it is a security hole as well */
  2002.  
  2003.     syslog(LOG_DEBUG, "get_secret: found secret %s", secret);
  2004. #endif /*UNSECURE*/
  2005.   fclose(sfile);
  2006.   *secret_len = strlen(secret);
  2007.   if (*secret_len > MAX_SECRET_LEN) { /* don't let it overflow the buffer */
  2008.     syslog(LOG_ERR, "Length of secret for host %s is greater than the maximum %d characters! ", name, MAX_SECRET_LEN);
  2009.     cleanup(0, NULL);            /* scream and die */
  2010.   }
  2011.   return;
  2012. }
  2013. /*
  2014.  * Return user specified netmask. A value of zero means no netmask has
  2015.  * been set. 
  2016.  */
  2017. /* ARGSUSED */
  2018. u_long
  2019.   GetMask(addr)
  2020. u_long addr;
  2021. {
  2022.   return(netmask);
  2023. }
  2024.