auth.c

/*
 * auth.c - PPP authentication and phase control.
 *
 * Copyright (c) 1993-2002 Paul Mackerras. All rights reserved.
 *
 * Redistribution and use in source and binary forms, with or without
 * modification, are permitted provided that the following conditions
 * are met:
 *
 * 1. Redistributions of source code must retain the above copyright
 *    notice, this list of conditions and the following disclaimer.
 *
 * 2. The name(s) of the authors of this software must not be used to
 *    endorse or promote products derived from this software without
 *    prior written permission.
 *
 * 3. Redistributions of any form whatsoever must retain the following
 *    acknowledgment:
 *    "This product includes software developed by Paul Mackerras
 *     <paulus@samba.org>".
 *
 * THE AUTHORS OF THIS SOFTWARE DISCLAIM ALL WARRANTIES WITH REGARD TO
 * THIS SOFTWARE, INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY
 * AND FITNESS, IN NO EVENT SHALL THE AUTHORS BE LIABLE FOR ANY
 * SPECIAL, INDIRECT OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
 * WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN
 * AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING
 * OUT OF OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
 *
 * Derived from main.c, which is:
 *
 * Copyright (c) 1984-2000 Carnegie Mellon University. All rights reserved.
 *
 * Redistribution and use in source and binary forms, with or without
 * modification, are permitted provided that the following conditions
 * are met:
 *
 * 1. Redistributions of source code must retain the above copyright
 *    notice, this list of conditions and the following disclaimer.
 *
 * 2. Redistributions in binary form must reproduce the above copyright
 *    notice, this list of conditions and the following disclaimer in
 *    the documentation and/or other materials provided with the
 *    distribution.
 *
 * 3. The name "Carnegie Mellon University" must not be used to
 *    endorse or promote products derived from this software without
 *    prior written permission. For permission or any legal
 *    details, please contact
 *      Office of Technology Transfer
 *      Carnegie Mellon University
 *      5000 Forbes Avenue
 *      Pittsburgh, PA  15213-3890
 *      (412) 268-4387, fax: (412) 268-7395
 *      tech-transfer@andrew.cmu.edu
 *
 * 4. Redistributions of any form whatsoever must retain the following
 *    acknowledgment:
 *    "This product includes software developed by Computing Services
 *     at Carnegie Mellon University (http://www.cmu.edu/computing/)."
 *
 * CARNEGIE MELLON UNIVERSITY DISCLAIMS ALL WARRANTIES WITH REGARD TO
 * THIS SOFTWARE, INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY
 * AND FITNESS, IN NO EVENT SHALL CARNEGIE MELLON UNIVERSITY BE LIABLE
 * FOR ANY SPECIAL, INDIRECT OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
 * WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN
 * AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING
 * OUT OF OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
 */

#include "netif/ppp/ppp_opts.h"
#if PPP_SUPPORT /* don't build if not configured for use in lwipopts.h */

#if 0 /* UNUSED */
#include <stdio.h>
#include <stddef.h>
#include <stdlib.h>
#include <unistd.h>
#include <errno.h>
#include <pwd.h>
#include <grp.h>
#include <string.h>
#include <sys/types.h>
#include <sys/stat.h>
#include <sys/socket.h>
#include <utmp.h>
#include <fcntl.h>
#if defined(_PATH_LASTLOG) && defined(__linux__)
#include <lastlog.h>
#endif

#include <netdb.h>
#include <netinet/in.h>
#include <arpa/inet.h>

#ifdef HAS_SHADOW
#include <shadow.h>
#ifndef PW_PPP
#define PW_PPP PW_LOGIN
#endif
#endif

#include <time.h>
#endif /* UNUSED */

#include "netif/ppp/ppp_impl.h"

#include "netif/ppp/fsm.h"
#include "netif/ppp/lcp.h"
#if CCP_SUPPORT
#include "netif/ppp/ccp.h"
#endif /* CCP_SUPPORT */
#if ECP_SUPPORT
#include "netif/ppp/ecp.h"
#endif /* ECP_SUPPORT */
#include "netif/ppp/ipcp.h"
#if PAP_SUPPORT
#include "netif/ppp/upap.h"
#endif /* PAP_SUPPORT */
#if CHAP_SUPPORT
#include "netif/ppp/chap-new.h"
#endif /* CHAP_SUPPORT */
#if EAP_SUPPORT
#include "netif/ppp/eap.h"
#endif /* EAP_SUPPORT */
#if CBCP_SUPPORT
#include "netif/ppp/cbcp.h"
#endif

#if 0 /* UNUSED */
#include "session.h"
#endif /* UNUSED */

#if 0 /* UNUSED */
/* Bits in scan_authfile return value */
#define NONWILD_SERVER  1
#define NONWILD_CLIENT  2

#define ISWILD(word)    (word[0] == '*' && word[1] == 0)
#endif /* UNUSED */

#if 0 /* UNUSED */
/* List of addresses which the peer may use. */
static struct permitted_ip *addresses[NUM_PPP];

/* Wordlist giving addresses which the peer may use
   without authenticating itself. */
static struct wordlist *noauth_addrs;

/* Remote telephone number, if available */
char remote_number[MAXNAMELEN];

/* Wordlist giving remote telephone numbers which may connect. */
static struct wordlist *permitted_numbers;

/* Extra options to apply, from the secrets file entry for the peer. */
static struct wordlist *extra_options;
#endif /* UNUSED */

#if 0 /* UNUSED */
/* Set if we require authentication only because we have a default route. */
static bool default_auth;

/* Hook to enable a plugin to control the idle time limit */
int (*idle_time_hook) (struct ppp_idle *) = NULL;

/* Hook for a plugin to say whether we can possibly authenticate any peer */
int (*pap_check_hook) (void) = NULL;

/* Hook for a plugin to check the PAP user and password */
int (*pap_auth_hook) (char *user, char *passwd, char **msgp,
              struct wordlist **paddrs,
              struct wordlist **popts) = NULL;

/* Hook for a plugin to know about the PAP user logout */
void (*pap_logout_hook) (void) = NULL;

/* Hook for a plugin to get the PAP password for authenticating us */
int (*pap_passwd_hook) (char *user, char *passwd) = NULL;

/* Hook for a plugin to say if we can possibly authenticate a peer using CHAP */
int (*chap_check_hook) (void) = NULL;

/* Hook for a plugin to get the CHAP password for authenticating us */
int (*chap_passwd_hook) (char *user, char *passwd) = NULL;

/* Hook for a plugin to say whether it is OK if the peer
   refuses to authenticate. */
int (*null_auth_hook) (struct wordlist **paddrs,
               struct wordlist **popts) = NULL;

int (*allowed_address_hook) (u32_t addr) = NULL;
#endif /* UNUSED */

#ifdef HAVE_MULTILINK
/* Hook for plugin to hear when an interface joins a multilink bundle */
void (*multilink_join_hook) (void) = NULL;
#endif

#if PPP_NOTIFY
/* A notifier for when the peer has authenticated itself,
   and we are proceeding to the network phase. */
struct notifier *auth_up_notifier = NULL;

/* A notifier for when the link goes down. */
struct notifier *link_down_notifier = NULL;
#endif /* PPP_NOTIFY */

/*
 * Option variables.
 */
#if 0 /* MOVED TO ppp_settings */
bool uselogin = 0;      /* Use /etc/passwd for checking PAP */
bool session_mgmt = 0;      /* Do session management (login records) */
bool cryptpap = 0;      /* Passwords in pap-secrets are encrypted */
bool refuse_pap = 0;        /* Don't wanna auth. ourselves with PAP */
bool refuse_chap = 0;       /* Don't wanna auth. ourselves with CHAP */
bool refuse_eap = 0;        /* Don't wanna auth. ourselves with EAP */
#if MSCHAP_SUPPORT
bool refuse_mschap = 0;     /* Don't wanna auth. ourselves with MS-CHAP */
bool refuse_mschap_v2 = 0;  /* Don't wanna auth. ourselves with MS-CHAPv2 */
#else /* MSCHAP_SUPPORT */
bool refuse_mschap = 1;     /* Don't wanna auth. ourselves with MS-CHAP */
bool refuse_mschap_v2 = 1;  /* Don't wanna auth. ourselves with MS-CHAPv2 */
#endif /* MSCHAP_SUPPORT */
bool usehostname = 0;       /* Use hostname for our_name */
bool auth_required = 0;     /* Always require authentication from peer */
bool allow_any_ip = 0;      /* Allow peer to use any IP address */
bool explicit_remote = 0;   /* User specified explicit remote name */
bool explicit_user = 0;     /* Set if "user" option supplied */
bool explicit_passwd = 0;   /* Set if "password" option supplied */
char remote_name[MAXNAMELEN];   /* Peer's name for authentication */
static char *uafname;       /* name of most recent +ua file */

extern char *crypt (const char *, const char *);
#endif /* UNUSED */
/* Prototypes for procedures local to this file. */

static void network_phase(ppp_pcb *pcb);
#if PPP_IDLETIMELIMIT
static void check_idle(void *arg);
#endif /* PPP_IDLETIMELIMIT */
#if PPP_MAXCONNECT
static void connect_time_expired(void *arg);
#endif /* PPP_MAXCONNECT */
#if 0 /* UNUSED */
static int  null_login (int);
/* static int  get_pap_passwd (char *); */
static int  have_pap_secret (int *);
static int  have_chap_secret (char *, char *, int, int *);
static int  have_srp_secret (char *client, char *server, int need_ip,
    int *lacks_ipp);
static int  ip_addr_check (u32_t, struct permitted_ip *);
static int  scan_authfile (FILE *, char *, char *, char *,
                   struct wordlist **, struct wordlist **,
                   char *, int);
static void free_wordlist (struct wordlist *);
static void set_allowed_addrs (int, struct wordlist *, struct wordlist *);
static int  some_ip_ok (struct wordlist *);
static int  setupapfile (char **);
static int  privgroup (char **);
static int  set_noauth_addr (char **);
static int  set_permitted_number (char **);
static void check_access (FILE *, char *);
static int  wordlist_count (struct wordlist *);
#endif /* UNUSED */

#ifdef MAXOCTETS
static void check_maxoctets (void *);
#endif

#if PPP_OPTIONS
/*
 * Authentication-related options.
 */
option_t auth_options[] = {
    { "auth", o_bool, &auth_required,
      "Require authentication from peer", OPT_PRIO | 1 },
    { "noauth", o_bool, &auth_required,
      "Don't require peer to authenticate", OPT_PRIOSUB | OPT_PRIV,
      &allow_any_ip },
    { "require-pap", o_bool, &lcp_wantoptions[0].neg_upap,
      "Require PAP authentication from peer",
      OPT_PRIOSUB | 1, &auth_required },
    { "+pap", o_bool, &lcp_wantoptions[0].neg_upap,
      "Require PAP authentication from peer",
      OPT_ALIAS | OPT_PRIOSUB | 1, &auth_required },
    { "require-chap", o_bool, &auth_required,
      "Require CHAP authentication from peer",
      OPT_PRIOSUB | OPT_A2OR | MDTYPE_MD5,
      &lcp_wantoptions[0].chap_mdtype },
    { "+chap", o_bool, &auth_required,
      "Require CHAP authentication from peer",
      OPT_ALIAS | OPT_PRIOSUB | OPT_A2OR | MDTYPE_MD5,
      &lcp_wantoptions[0].chap_mdtype },
#if MSCHAP_SUPPORT
    { "require-mschap", o_bool, &auth_required,
      "Require MS-CHAP authentication from peer",
      OPT_PRIOSUB | OPT_A2OR | MDTYPE_MICROSOFT,
      &lcp_wantoptions[0].chap_mdtype },
    { "+mschap", o_bool, &auth_required,
      "Require MS-CHAP authentication from peer",
      OPT_ALIAS | OPT_PRIOSUB | OPT_A2OR | MDTYPE_MICROSOFT,
      &lcp_wantoptions[0].chap_mdtype },
    { "require-mschap-v2", o_bool, &auth_required,
      "Require MS-CHAPv2 authentication from peer",
      OPT_PRIOSUB | OPT_A2OR | MDTYPE_MICROSOFT_V2,
      &lcp_wantoptions[0].chap_mdtype },
    { "+mschap-v2", o_bool, &auth_required,
      "Require MS-CHAPv2 authentication from peer",
      OPT_ALIAS | OPT_PRIOSUB | OPT_A2OR | MDTYPE_MICROSOFT_V2,
      &lcp_wantoptions[0].chap_mdtype },
#endif /* MSCHAP_SUPPORT */
#if 0
    { "refuse-pap", o_bool, &refuse_pap,
      "Don't agree to auth to peer with PAP", 1 },
    { "-pap", o_bool, &refuse_pap,
      "Don't allow PAP authentication with peer", OPT_ALIAS | 1 },
    { "refuse-chap", o_bool, &refuse_chap,
      "Don't agree to auth to peer with CHAP",
      OPT_A2CLRB | MDTYPE_MD5,
      &lcp_allowoptions[0].chap_mdtype },
    { "-chap", o_bool, &refuse_chap,
      "Don't allow CHAP authentication with peer",
      OPT_ALIAS | OPT_A2CLRB | MDTYPE_MD5,
      &lcp_allowoptions[0].chap_mdtype },
#endif
#if MSCHAP_SUPPORT
#if 0
    { "refuse-mschap", o_bool, &refuse_mschap,
      "Don't agree to auth to peer with MS-CHAP",
      OPT_A2CLRB | MDTYPE_MICROSOFT,
      &lcp_allowoptions[0].chap_mdtype },
    { "-mschap", o_bool, &refuse_mschap,
      "Don't allow MS-CHAP authentication with peer",
      OPT_ALIAS | OPT_A2CLRB | MDTYPE_MICROSOFT,
      &lcp_allowoptions[0].chap_mdtype },
    { "refuse-mschap-v2", o_bool, &refuse_mschap_v2,
      "Don't agree to auth to peer with MS-CHAPv2",
      OPT_A2CLRB | MDTYPE_MICROSOFT_V2,
      &lcp_allowoptions[0].chap_mdtype },
    { "-mschap-v2", o_bool, &refuse_mschap_v2,
      "Don't allow MS-CHAPv2 authentication with peer",
      OPT_ALIAS | OPT_A2CLRB | MDTYPE_MICROSOFT_V2,
      &lcp_allowoptions[0].chap_mdtype },
#endif
#endif /* MSCHAP_SUPPORT*/
#if EAP_SUPPORT
    { "require-eap", o_bool, &lcp_wantoptions[0].neg_eap,
      "Require EAP authentication from peer", OPT_PRIOSUB | 1,
      &auth_required },
#if 0
    { "refuse-eap", o_bool, &refuse_eap,
      "Don't agree to authenticate to peer with EAP", 1 },
#endif
#endif /* EAP_SUPPORT */
    { "name", o_string, our_name,
      "Set local name for authentication",
      OPT_PRIO | OPT_PRIV | OPT_STATIC, NULL, MAXNAMELEN },

    { "+ua", o_special, (void *)setupapfile,
      "Get PAP user and password from file",
      OPT_PRIO | OPT_A2STRVAL, &uafname },

#if 0
    { "user", o_string, user,
      "Set name for auth with peer", OPT_PRIO | OPT_STATIC,
      &explicit_user, MAXNAMELEN },

    { "password", o_string, passwd,
      "Password for authenticating us to the peer",
      OPT_PRIO | OPT_STATIC | OPT_HIDE,
      &explicit_passwd, MAXSECRETLEN },
#endif

    { "usehostname", o_bool, &usehostname,
      "Must use hostname for authentication", 1 },

    { "remotename", o_string, remote_name,
      "Set remote name for authentication", OPT_PRIO | OPT_STATIC,
      &explicit_remote, MAXNAMELEN },

    { "login", o_bool, &uselogin,
      "Use system password database for PAP", OPT_A2COPY | 1 ,
      &session_mgmt },
    { "enable-session", o_bool, &session_mgmt,
      "Enable session accounting for remote peers", OPT_PRIV | 1 },

    { "papcrypt", o_bool, &cryptpap,
      "PAP passwords are encrypted", 1 },

    { "privgroup", o_special, (void *)privgroup,
      "Allow group members to use privileged options", OPT_PRIV | OPT_A2LIST },

    { "allow-ip", o_special, (void *)set_noauth_addr,
      "Set IP address(es) which can be used without authentication",
      OPT_PRIV | OPT_A2LIST },

    { "remotenumber", o_string, remote_number,
      "Set remote telephone number for authentication", OPT_PRIO | OPT_STATIC,
      NULL, MAXNAMELEN },

    { "allow-number", o_special, (void *)set_permitted_number,
      "Set telephone number(s) which are allowed to connect",
      OPT_PRIV | OPT_A2LIST },

    { NULL }
};
#endif /* PPP_OPTIONS */

#if 0 /* UNUSED */
/*
 * setupapfile - specifies UPAP info for authenticating with peer.
 */
static int
setupapfile(argv)
    char **argv;
{
    FILE *ufile;
    int l;
    uid_t euid;
    char u[MAXNAMELEN], p[MAXSECRETLEN];
    char *fname;

    lcp_allowoptions[0].neg_upap = 1;

    /* open user info file */
    fname = strdup(*argv);
    if (fname == NULL)
    novm("+ua file name");
    euid = geteuid();
    if (seteuid(getuid()) == -1) {
    option_error("unable to reset uid before opening %s: %m", fname);
    return 0;
    }
    ufile = fopen(fname, "r");
    if (seteuid(euid) == -1)
    fatal("unable to regain privileges: %m");
    if (ufile == NULL) {
    option_error("unable to open user login data file %s", fname);
    return 0;
    }
    check_access(ufile, fname);
    uafname = fname;

    /* get username */
    if (fgets(u, MAXNAMELEN - 1, ufile) == NULL
    || fgets(p, MAXSECRETLEN - 1, ufile) == NULL) {
    fclose(ufile);
    option_error("unable to read user login data file %s", fname);
    return 0;
    }
    fclose(ufile);

    /* get rid of newlines */
    l = strlen(u);
    if (l > 0 && u[l-1] == '\n')
    u[l-1] = 0;
    l = strlen(p);
    if (l > 0 && p[l-1] == '\n')
    p[l-1] = 0;

    if (override_value("user", option_priority, fname)) {
    strlcpy(ppp_settings.user, u, sizeof(ppp_settings.user));
    explicit_user = 1;
    }
    if (override_value("passwd", option_priority, fname)) {
    strlcpy(ppp_settings.passwd, p, sizeof(ppp_settings.passwd));
    explicit_passwd = 1;
    }

    return (1);
}

/*
 * privgroup - allow members of the group to have privileged access.
 */
static int
privgroup(argv)
    char **argv;
{
    struct group *g;
    int i;

    g = getgrnam(*argv);
    if (g == 0) {
    option_error("group %s is unknown", *argv);
    return 0;
    }
    for (i = 0; i < ngroups; ++i) {
    if (groups[i] == g->gr_gid) {
        privileged = 1;
        break;
    }
    }
    return 1;
}


/*
 * set_noauth_addr - set address(es) that can be used without authentication.
 * Equivalent to specifying an entry like `"" * "" addr' in pap-secrets.
 */
static int
set_noauth_addr(argv)
    char **argv;
{
    char *addr = *argv;
    int l = strlen(addr) + 1;
    struct wordlist *wp;

    wp = (struct wordlist *) malloc(sizeof(struct wordlist) + l);
    if (wp == NULL)
    novm("allow-ip argument");
    wp->word = (char *) (wp + 1);
    wp->next = noauth_addrs;
    MEMCPY(wp->word, addr, l);
    noauth_addrs = wp;
    return 1;
}


/*
 * set_permitted_number - set remote telephone number(s) that may connect.
 */
static int
set_permitted_number(argv)
    char **argv;
{
    char *number = *argv;
    int l = strlen(number) + 1;
    struct wordlist *wp;

    wp = (struct wordlist *) malloc(sizeof(struct wordlist) + l);
    if (wp == NULL)
    novm("allow-number argument");
    wp->word = (char *) (wp + 1);
    wp->next = permitted_numbers;
    MEMCPY(wp->word, number, l);
    permitted_numbers = wp;
    return 1;
}
#endif

/*
 * An Open on LCP has requested a change from Dead to Establish phase.
 */
void link_required(ppp_pcb *pcb) {
    LWIP_UNUSED_ARG(pcb);
}

#if 0
/*
 * Bring the link up to the point of being able to do ppp.
 */
void start_link(unit)
    int unit;
{
    ppp_pcb *pcb = &ppp_pcb_list[unit];
    char *msg;

    status = EXIT_NEGOTIATION_FAILED;
    new_phase(pcb, PPP_PHASE_SERIALCONN);

    hungup = 0;
    devfd = the_channel->connect();
    msg = "Connect script failed";
    if (devfd < 0)
    goto fail;

    /* set up the serial device as a ppp interface */
    /*
     * N.B. we used to do tdb_writelock/tdb_writeunlock around this
     * (from establish_ppp to set_ifunit).  However, we won't be
     * doing the set_ifunit in multilink mode, which is the only time
     * we need the atomicity that the tdb_writelock/tdb_writeunlock
     * gives us.  Thus we don't need the tdb_writelock/tdb_writeunlock.
     */
    fd_ppp = the_channel->establish_ppp(devfd);
    msg = "ppp establishment failed";
    if (fd_ppp < 0) {
    status = EXIT_FATAL_ERROR;
    goto disconnect;
    }

    if (!demand && ifunit >= 0)
    set_ifunit(1);

    /*
     * Start opening the connection and wait for
     * incoming events (reply, timeout, etc.).
     */
    if (ifunit >= 0)
    ppp_notice("Connect: %s <--> %s", ifname, ppp_devnam);
    else
    ppp_notice("Starting negotiation on %s", ppp_devnam);
    add_fd(fd_ppp);

    new_phase(pcb, PPP_PHASE_ESTABLISH);

    lcp_lowerup(pcb);
    return;

 disconnect:
    new_phase(pcb, PPP_PHASE_DISCONNECT);
    if (the_channel->disconnect)
    the_channel->disconnect();

 fail:
    new_phase(pcb, PPP_PHASE_DEAD);
    if (the_channel->cleanup)
    (*the_channel->cleanup)();
}
#endif

/*
 * LCP has terminated the link; go to the Dead phase and take the
 * physical layer down.
 */
void link_terminated(ppp_pcb *pcb) {
    if (pcb->phase == PPP_PHASE_DEAD
#ifdef HAVE_MULTILINK
    || pcb->phase == PPP_PHASE_MASTER
#endif /* HAVE_MULTILINK */
    )
    return;
    new_phase(pcb, PPP_PHASE_DISCONNECT);

#if 0 /* UNUSED */
    if (pap_logout_hook) {
    pap_logout_hook();
    }
    session_end(devnam);
#endif /* UNUSED */

    if (!doing_multilink) {
    ppp_notice("Connection terminated.");
#if PPP_STATS_SUPPORT
    print_link_stats();
#endif /* PPP_STATS_SUPPORT */
    } else
    ppp_notice("Link terminated.");

    lcp_lowerdown(pcb);

    ppp_link_terminated(pcb);
#if 0
    /*
     * Delete pid files before disestablishing ppp.  Otherwise it
     * can happen that another pppd gets the same unit and then
     * we delete its pid file.
     */
    if (!doing_multilink && !demand)
    remove_pidfiles();

    /*
     * If we may want to bring the link up again, transfer
     * the ppp unit back to the loopback.  Set the
     * real serial device back to its normal mode of operation.
     */
    if (fd_ppp >= 0) {
    remove_fd(fd_ppp);
    clean_check();
    the_channel->disestablish_ppp(devfd);
    if (doing_multilink)
        mp_exit_bundle();
    fd_ppp = -1;
    }
    if (!hungup)
    lcp_lowerdown(pcb);
    if (!doing_multilink && !demand)
    script_unsetenv("IFNAME");

    /*
     * Run disconnector script, if requested.
     * XXX we may not be able to do this if the line has hung up!
     */
    if (devfd >= 0 && the_channel->disconnect) {
    the_channel->disconnect();
    devfd = -1;
    }
    if (the_channel->cleanup)
    (*the_channel->cleanup)();

    if (doing_multilink && multilink_master) {
    if (!bundle_terminating)
        new_phase(pcb, PPP_PHASE_MASTER);
    else
        mp_bundle_terminated();
    } else
    new_phase(pcb, PPP_PHASE_DEAD);
#endif
}

/*
 * LCP has gone down; it will either die or try to re-establish.
 */
void link_down(ppp_pcb *pcb) {
#if PPP_NOTIFY
    notify(link_down_notifier, 0);
#endif /* PPP_NOTIFY */

    if (!doing_multilink) {
    upper_layers_down(pcb);
    if (pcb->phase != PPP_PHASE_DEAD
#ifdef HAVE_MULTILINK
    && pcb->phase != PPP_PHASE_MASTER
#endif /* HAVE_MULTILINK */
    )
        new_phase(pcb, PPP_PHASE_ESTABLISH);
    }
    /* XXX if doing_multilink, should do something to stop
       network-layer traffic on the link */
}

void upper_layers_down(ppp_pcb *pcb) {
    int i;
    const struct protent *protp;

    for (i = 0; (protp = protocols[i]) != NULL; ++i) {
        if (protp->protocol != PPP_LCP && protp->lowerdown != NULL)
        (*protp->lowerdown)(pcb);
        if (protp->protocol < 0xC000 && protp->close != NULL)
        (*protp->close)(pcb, "LCP down");
    }
    pcb->num_np_open = 0;
    pcb->num_np_up = 0;
}

/*
 * The link is established.
 * Proceed to the Dead, Authenticate or Network phase as appropriate.
 */
void link_established(ppp_pcb *pcb) {
#if PPP_AUTH_SUPPORT
    int auth;
#if PPP_SERVER
#if PAP_SUPPORT
    lcp_options *wo = &pcb->lcp_wantoptions;
#endif /* PAP_SUPPORT */
    lcp_options *go = &pcb->lcp_gotoptions;
#endif /* PPP_SERVER */
    lcp_options *ho = &pcb->lcp_hisoptions;
#endif /* PPP_AUTH_SUPPORT */
    int i;
    const struct protent *protp;

    /*
     * Tell higher-level protocols that LCP is up.
     */
    if (!doing_multilink) {
    for (i = 0; (protp = protocols[i]) != NULL; ++i)
        if (protp->protocol != PPP_LCP
        && protp->lowerup != NULL)
        (*protp->lowerup)(pcb);
    }

#if PPP_AUTH_SUPPORT
#if PPP_SERVER
#if PPP_ALLOWED_ADDRS
    if (!auth_required && noauth_addrs != NULL)
    set_allowed_addrs(unit, NULL, NULL);
#endif /* PPP_ALLOWED_ADDRS */

    if (pcb->settings.auth_required && !(0
#if PAP_SUPPORT
    || go->neg_upap
#endif /* PAP_SUPPORT */
#if CHAP_SUPPORT
    || go->neg_chap
#endif /* CHAP_SUPPORT */
#if EAP_SUPPORT
    || go->neg_eap
#endif /* EAP_SUPPORT */
    )) {

#if PPP_ALLOWED_ADDRS
    /*
     * We wanted the peer to authenticate itself, and it refused:
     * if we have some address(es) it can use without auth, fine,
     * otherwise treat it as though it authenticated with PAP using
     * a username of "" and a password of "".  If that's not OK,
     * boot it out.
     */
    if (noauth_addrs != NULL) {
        set_allowed_addrs(unit, NULL, NULL);
    } else
#endif /* PPP_ALLOWED_ADDRS */
    if (!pcb->settings.null_login
#if PAP_SUPPORT
        || !wo->neg_upap
#endif /* PAP_SUPPORT */
        ) {
        ppp_warn("peer refused to authenticate: terminating link");
#if 0 /* UNUSED */
        status = EXIT_PEER_AUTH_FAILED;
#endif /* UNUSED */
        pcb->err_code = PPPERR_AUTHFAIL;
        lcp_close(pcb, "peer refused to authenticate");
        return;
    }
    }
#endif /* PPP_SERVER */

    new_phase(pcb, PPP_PHASE_AUTHENTICATE);
    auth = 0;
#if PPP_SERVER
#if EAP_SUPPORT
    if (go->neg_eap) {
    eap_authpeer(pcb, PPP_OUR_NAME);
    auth |= EAP_PEER;
    } else
#endif /* EAP_SUPPORT */
#if CHAP_SUPPORT
    if (go->neg_chap) {
    chap_auth_peer(pcb, PPP_OUR_NAME, CHAP_DIGEST(go->chap_mdtype));
    auth |= CHAP_PEER;
    } else
#endif /* CHAP_SUPPORT */
#if PAP_SUPPORT
    if (go->neg_upap) {
    upap_authpeer(pcb);
    auth |= PAP_PEER;
    } else
#endif /* PAP_SUPPORT */
    {}
#endif /* PPP_SERVER */

#if EAP_SUPPORT
    if (ho->neg_eap) {
    eap_authwithpeer(pcb, pcb->settings.user);
    auth |= EAP_WITHPEER;
    } else
#endif /* EAP_SUPPORT */
#if CHAP_SUPPORT
    if (ho->neg_chap) {
    chap_auth_with_peer(pcb, pcb->settings.user, CHAP_DIGEST(ho->chap_mdtype));
    auth |= CHAP_WITHPEER;
    } else
#endif /* CHAP_SUPPORT */
#if PAP_SUPPORT
    if (ho->neg_upap) {
    upap_authwithpeer(pcb, pcb->settings.user, pcb->settings.passwd);
    auth |= PAP_WITHPEER;
    } else
#endif /* PAP_SUPPORT */
    {}

    pcb->auth_pending = auth;
    pcb->auth_done = 0;

    if (!auth)
#endif /* PPP_AUTH_SUPPORT */
    network_phase(pcb);
}

/*
 * Proceed to the network phase.
 */
static void network_phase(ppp_pcb *pcb) {
#if CBCP_SUPPORT
    ppp_pcb *pcb = &ppp_pcb_list[unit];
#endif
#if 0 /* UNUSED */
    lcp_options *go = &lcp_gotoptions[unit];
#endif /* UNUSED */

#if 0 /* UNUSED */
    /* Log calling number. */
    if (*remote_number)
    ppp_notice("peer from calling number %q authorized", remote_number);
#endif /* UNUSED */

#if PPP_NOTIFY
    /*
     * If the peer had to authenticate, notify it now.
     */
    if (0
#if CHAP_SUPPORT
    || go->neg_chap
#endif /* CHAP_SUPPORT */
#if PAP_SUPPORT
    || go->neg_upap
#endif /* PAP_SUPPORT */
#if EAP_SUPPORT
    || go->neg_eap
#endif /* EAP_SUPPORT */
    ) {
    notify(auth_up_notifier, 0);
    }
#endif /* PPP_NOTIFY */

#if CBCP_SUPPORT
    /*
     * If we negotiated callback, do it now.
     */
    if (go->neg_cbcp) {
    new_phase(pcb, PPP_PHASE_CALLBACK);
    (*cbcp_protent.open)(pcb);
    return;
    }
#endif

#if PPP_OPTIONS
    /*
     * Process extra options from the secrets file
     */
    if (extra_options) {
    options_from_list(extra_options, 1);
    free_wordlist(extra_options);
    extra_options = 0;
    }
#endif /* PPP_OPTIONS */
    start_networks(pcb);
}

void start_networks(ppp_pcb *pcb) {
#if CCP_SUPPORT || ECP_SUPPORT
    int i;
    const struct protent *protp;
#endif /* CCP_SUPPORT || ECP_SUPPORT */

    new_phase(pcb, PPP_PHASE_NETWORK);

#ifdef HAVE_MULTILINK
    if (multilink) {
    if (mp_join_bundle()) {
        if (multilink_join_hook)
        (*multilink_join_hook)();
        if (updetach && !nodetach)
        detach();
        return;
    }
    }
#endif /* HAVE_MULTILINK */

#ifdef PPP_FILTER
    if (!demand)
    set_filters(&pass_filter, &active_filter);
#endif
#if CCP_SUPPORT || ECP_SUPPORT
    /* Start CCP and ECP */
    for (i = 0; (protp = protocols[i]) != NULL; ++i)
    if (
        (0
#if ECP_SUPPORT
        || protp->protocol == PPP_ECP
#endif /* ECP_SUPPORT */
#if CCP_SUPPORT
        || protp->protocol == PPP_CCP
#endif /* CCP_SUPPORT */
        )
        && protp->open != NULL)
        (*protp->open)(pcb);
#endif /* CCP_SUPPORT || ECP_SUPPORT */

    /*
     * Bring up other network protocols iff encryption is not required.
     */
    if (1
#if ECP_SUPPORT
        && !ecp_gotoptions[unit].required
#endif /* ECP_SUPPORT */
#if MPPE_SUPPORT
        && !pcb->ccp_gotoptions.mppe
#endif /* MPPE_SUPPORT */
        )
    continue_networks(pcb);
}

void continue_networks(ppp_pcb *pcb) {
    int i;
    const struct protent *protp;

    /*
     * Start the "real" network protocols.
     */
    for (i = 0; (protp = protocols[i]) != NULL; ++i)
    if (protp->protocol < 0xC000
#if CCP_SUPPORT
        && protp->protocol != PPP_CCP
#endif /* CCP_SUPPORT */
#if ECP_SUPPORT
        && protp->protocol != PPP_ECP
#endif /* ECP_SUPPORT */
        && protp->open != NULL) {
        (*protp->open)(pcb);
        ++pcb->num_np_open;
    }

    if (pcb->num_np_open == 0)
    /* nothing to do */
    lcp_close(pcb, "No network protocols running");
}

#if PPP_AUTH_SUPPORT
#if PPP_SERVER
/*
 * auth_check_passwd - Check the user name and passwd against configuration.
 *
 * returns:
 *      0: Authentication failed.
 *      1: Authentication succeeded.
 * In either case, msg points to an appropriate message and msglen to the message len.
 */
int auth_check_passwd(ppp_pcb *pcb, char *auser, int userlen, char *apasswd, int passwdlen, const char **msg, int *msglen) {
  int secretuserlen;
  int secretpasswdlen;

  if (pcb->settings.user && pcb->settings.passwd) {
    secretuserlen = (int)strlen(pcb->settings.user);
    secretpasswdlen = (int)strlen(pcb->settings.passwd);
    if (secretuserlen == userlen
        && secretpasswdlen == passwdlen
        && !memcmp(auser, pcb->settings.user, userlen)
        && !memcmp(apasswd, pcb->settings.passwd, passwdlen) ) {
      *msg = "Login ok";
      *msglen = sizeof("Login ok")-1;
      return 1;
    }
  }

  *msg = "Login incorrect";
  *msglen = sizeof("Login incorrect")-1;
  return 0;
}

/*
 * The peer has failed to authenticate himself using `protocol'.
 */
void auth_peer_fail(ppp_pcb *pcb, int protocol) {
    LWIP_UNUSED_ARG(protocol);
    /*
     * Authentication failure: take the link down
     */
#if 0 /* UNUSED */
    status = EXIT_PEER_AUTH_FAILED;
#endif /* UNUSED */
    pcb->err_code = PPPERR_AUTHFAIL;
    lcp_close(pcb, "Authentication failed");
}

/*
 * The peer has been successfully authenticated using `protocol'.
 */
void auth_peer_success(ppp_pcb *pcb, int protocol, int prot_flavor, const char *name, int namelen) {
    int bit;
#ifndef HAVE_MULTILINK
    LWIP_UNUSED_ARG(name);
    LWIP_UNUSED_ARG(namelen);
#endif /* HAVE_MULTILINK */

    switch (protocol) {
#if CHAP_SUPPORT
    case PPP_CHAP:
    bit = CHAP_PEER;
    switch (prot_flavor) {
    case CHAP_MD5:
        bit |= CHAP_MD5_PEER;
        break;
#if MSCHAP_SUPPORT
    case CHAP_MICROSOFT:
        bit |= CHAP_MS_PEER;
        break;
    case CHAP_MICROSOFT_V2:
        bit |= CHAP_MS2_PEER;
        break;
#endif /* MSCHAP_SUPPORT */
    default:
        break;
    }
    break;
#endif /* CHAP_SUPPORT */
#if PAP_SUPPORT
    case PPP_PAP:
    bit = PAP_PEER;
    break;
#endif /* PAP_SUPPORT */
#if EAP_SUPPORT
    case PPP_EAP:
    bit = EAP_PEER;
    break;
#endif /* EAP_SUPPORT */
    default:
    ppp_warn("auth_peer_success: unknown protocol %x", protocol);
    return;
    }

#ifdef HAVE_MULTILINK
    /*
     * Save the authenticated name of the peer for later.
     */
    if (namelen > (int)sizeof(pcb->peer_authname) - 1)
    namelen = (int)sizeof(pcb->peer_authname) - 1;
    MEMCPY(pcb->peer_authname, name, namelen);
    pcb->peer_authname[namelen] = 0;
#endif /* HAVE_MULTILINK */
#if 0 /* UNUSED */
    script_setenv("PEERNAME", , 0);
#endif /* UNUSED */

    /* Save the authentication method for later. */
    pcb->auth_done |= bit;

    /*
     * If there is no more authentication still to be done,
     * proceed to the network (or callback) phase.
     */
    if ((pcb->auth_pending &= ~bit) == 0)
        network_phase(pcb);
}
#endif /* PPP_SERVER */

/*
 * We have failed to authenticate ourselves to the peer using `protocol'.
 */
void auth_withpeer_fail(ppp_pcb *pcb, int protocol) {
    LWIP_UNUSED_ARG(protocol);
    /*
     * We've failed to authenticate ourselves to our peer.
     *
     * Some servers keep sending CHAP challenges, but there
     * is no point in persisting without any way to get updated
     * authentication secrets.
     *
     * He'll probably take the link down, and there's not much
     * we can do except wait for that.
     */
    pcb->err_code = PPPERR_AUTHFAIL;
    lcp_close(pcb, "Failed to authenticate ourselves to peer");
}

/*
 * We have successfully authenticated ourselves with the peer using `protocol'.
 */
void auth_withpeer_success(ppp_pcb *pcb, int protocol, int prot_flavor) {
    int bit;
    const char *prot = "";

    switch (protocol) {
#if CHAP_SUPPORT
    case PPP_CHAP:
    bit = CHAP_WITHPEER;
    prot = "CHAP";
    switch (prot_flavor) {
    case CHAP_MD5:
        bit |= CHAP_MD5_WITHPEER;
        break;
#if MSCHAP_SUPPORT
    case CHAP_MICROSOFT:
        bit |= CHAP_MS_WITHPEER;
        break;
    case CHAP_MICROSOFT_V2:
        bit |= CHAP_MS2_WITHPEER;
        break;
#endif /* MSCHAP_SUPPORT */
    default:
        break;
    }
    break;
#endif /* CHAP_SUPPORT */
#if PAP_SUPPORT
    case PPP_PAP:
    bit = PAP_WITHPEER;
    prot = "PAP";
    break;
#endif /* PAP_SUPPORT */
#if EAP_SUPPORT
    case PPP_EAP:
    bit = EAP_WITHPEER;
    prot = "EAP";
    break;
#endif /* EAP_SUPPORT */
    default:
    ppp_warn("auth_withpeer_success: unknown protocol %x", protocol);
    bit = 0;
    /* no break */
    }

    ppp_notice("%s authentication succeeded", prot);

    /* Save the authentication method for later. */
    pcb->auth_done |= bit;

    /*
     * If there is no more authentication still being done,
     * proceed to the network (or callback) phase.
     */
    if ((pcb->auth_pending &= ~bit) == 0)
    network_phase(pcb);
}
#endif /* PPP_AUTH_SUPPORT */


/*
 * np_up - a network protocol has come up.
 */
void np_up(ppp_pcb *pcb, int proto) {
#if PPP_IDLETIMELIMIT
    int tlim;
#endif /* PPP_IDLETIMELIMIT */
    LWIP_UNUSED_ARG(proto);

    if (pcb->num_np_up == 0) {
    /*
     * At this point we consider that the link has come up successfully.
     */
    new_phase(pcb, PPP_PHASE_RUNNING);

#if PPP_IDLETIMELIMIT
#if 0 /* UNUSED */
    if (idle_time_hook != 0)
        tlim = (*idle_time_hook)(NULL);
    else
#endif /* UNUSED */
        tlim = pcb->settings.idle_time_limit;
    if (tlim > 0)
        TIMEOUT(check_idle, (void*)pcb, tlim);
#endif /* PPP_IDLETIMELIMIT */

#if PPP_MAXCONNECT
    /*
     * Set a timeout to close the connection once the maximum
     * connect time has expired.
     */
    if (pcb->settings.maxconnect > 0)
        TIMEOUT(connect_time_expired, (void*)pcb, pcb->settings.maxconnect);
#endif /* PPP_MAXCONNECT */

#ifdef MAXOCTETS
    if (maxoctets > 0)
        TIMEOUT(check_maxoctets, NULL, maxoctets_timeout);
#endif

#if 0 /* Unused */
    /*
     * Detach now, if the updetach option was given.
     */
    if (updetach && !nodetach)
        detach();
#endif /* Unused */
    }
    ++pcb->num_np_up;
}

/*
 * np_down - a network protocol has gone down.
 */
void np_down(ppp_pcb *pcb, int proto) {
    LWIP_UNUSED_ARG(proto);
    if (--pcb->num_np_up == 0) {
#if PPP_IDLETIMELIMIT
    UNTIMEOUT(check_idle, (void*)pcb);
#endif /* PPP_IDLETIMELIMIT */
#if PPP_MAXCONNECT
    UNTIMEOUT(connect_time_expired, NULL);
#endif /* PPP_MAXCONNECT */
#ifdef MAXOCTETS
    UNTIMEOUT(check_maxoctets, NULL);
#endif
    new_phase(pcb, PPP_PHASE_NETWORK);
    }
}

/*
 * np_finished - a network protocol has finished using the link.
 */
void np_finished(ppp_pcb *pcb, int proto) {
    LWIP_UNUSED_ARG(proto);
    if (--pcb->num_np_open <= 0) {
    /* no further use for the link: shut up shop. */
    lcp_close(pcb, "No network protocols running");
    }
}

#ifdef MAXOCTETS
static void
check_maxoctets(arg)
    void *arg;
{
#if PPP_STATS_SUPPORT
    unsigned int used;

    update_link_stats(ifunit);
    link_stats_valid=0;

    switch(maxoctets_dir) {
    case PPP_OCTETS_DIRECTION_IN:
        used = link_stats.bytes_in;
        break;
    case PPP_OCTETS_DIRECTION_OUT:
        used = link_stats.bytes_out;
        break;
    case PPP_OCTETS_DIRECTION_MAXOVERAL:
    case PPP_OCTETS_DIRECTION_MAXSESSION:
        used = (link_stats.bytes_in > link_stats.bytes_out) ? link_stats.bytes_in : link_stats.bytes_out;
        break;
    default:
        used = link_stats.bytes_in+link_stats.bytes_out;
        break;
    }
    if (used > maxoctets) {
    ppp_notice("Traffic limit reached. Limit: %u Used: %u", maxoctets, used);
    status = EXIT_TRAFFIC_LIMIT;
    lcp_close(pcb, "Traffic limit");
#if 0 /* UNUSED */
    need_holdoff = 0;
#endif /* UNUSED */
    } else {
        TIMEOUT(check_maxoctets, NULL, maxoctets_timeout);
    }
#endif /* PPP_STATS_SUPPORT */
}
#endif /* MAXOCTETS */

#if PPP_IDLETIMELIMIT
/*
 * check_idle - check whether the link has been idle for long
 * enough that we can shut it down.
 */
static void check_idle(void *arg) {
    ppp_pcb *pcb = (ppp_pcb*)arg;
    struct ppp_idle idle;
    time_t itime;
    int tlim;

    if (!get_idle_time(pcb, &idle))
    return;
#if 0 /* UNUSED */
    if (idle_time_hook != 0) {
    tlim = idle_time_hook(&idle);
    } else {
#endif /* UNUSED */
    itime = LWIP_MIN(idle.xmit_idle, idle.recv_idle);
    tlim = pcb->settings.idle_time_limit - itime;
#if 0 /* UNUSED */
    }
#endif /* UNUSED */
    if (tlim <= 0) {
    /* link is idle: shut it down. */
    ppp_notice("Terminating connection due to lack of activity.");
    pcb->err_code = PPPERR_IDLETIMEOUT;
    lcp_close(pcb, "Link inactive");
#if 0 /* UNUSED */
    need_holdoff = 0;
#endif /* UNUSED */
    } else {
    TIMEOUT(check_idle, (void*)pcb, tlim);
    }
}
#endif /* PPP_IDLETIMELIMIT */

#if PPP_MAXCONNECT
/*
 * connect_time_expired - log a message and close the connection.
 */
static void connect_time_expired(void *arg) {
    ppp_pcb *pcb = (ppp_pcb*)arg;
    ppp_info("Connect time expired");
    pcb->err_code = PPPERR_CONNECTTIME;
    lcp_close(pcb, "Connect time expired"); /* Close connection */
}
#endif /* PPP_MAXCONNECT */

#if PPP_OPTIONS
/*
 * auth_check_options - called to check authentication options.
 */
void
auth_check_options()
{
    lcp_options *wo = &lcp_wantoptions[0];
    int can_auth;
    int lacks_ip;

    /* Default our_name to hostname, and user to our_name */
    if (our_name[0] == 0 || usehostname)
    strlcpy(our_name, hostname, sizeof(our_name));
    /* If a blank username was explicitly given as an option, trust
       the user and don't use our_name */
    if (ppp_settings.user[0] == 0 && !explicit_user)
    strlcpy(ppp_settings.user, our_name, sizeof(ppp_settings.user));

    /*
     * If we have a default route, require the peer to authenticate
     * unless the noauth option was given or the real user is root.
     */
    if (!auth_required && !allow_any_ip && have_route_to(0) && !privileged) {
    auth_required = 1;
    default_auth = 1;
    }

#if CHAP_SUPPORT
    /* If we selected any CHAP flavors, we should probably negotiate it. :-) */
    if (wo->chap_mdtype)
    wo->neg_chap = 1;
#endif /* CHAP_SUPPORT */

    /* If authentication is required, ask peer for CHAP, PAP, or EAP. */
    if (auth_required) {
    allow_any_ip = 0;
    if (1
#if CHAP_SUPPORT
        && !wo->neg_chap
#endif /* CHAP_SUPPORT */
#if PAP_SUPPORT
        && !wo->neg_upap
#endif /* PAP_SUPPORT */
#if EAP_SUPPORT
        && !wo->neg_eap
#endif /* EAP_SUPPORT */
        ) {
#if CHAP_SUPPORT
        wo->neg_chap = CHAP_MDTYPE_SUPPORTED != MDTYPE_NONE;
        wo->chap_mdtype = CHAP_MDTYPE_SUPPORTED;
#endif /* CHAP_SUPPORT */
#if PAP_SUPPORT
        wo->neg_upap = 1;
#endif /* PAP_SUPPORT */
#if EAP_SUPPORT
        wo->neg_eap = 1;
#endif /* EAP_SUPPORT */
    }
    } else {
#if CHAP_SUPPORT
    wo->neg_chap = 0;
    wo->chap_mdtype = MDTYPE_NONE;
#endif /* CHAP_SUPPORT */
#if PAP_SUPPORT
    wo->neg_upap = 0;
#endif /* PAP_SUPPORT */
#if EAP_SUPPORT
    wo->neg_eap = 0;
#endif /* EAP_SUPPORT */
    }

    /*
     * Check whether we have appropriate secrets to use
     * to authenticate the peer.  Note that EAP can authenticate by way
     * of a CHAP-like exchanges as well as SRP.
     */
    lacks_ip = 0;
#if PAP_SUPPORT
    can_auth = wo->neg_upap && (uselogin || have_pap_secret(&lacks_ip));
#else
    can_auth = 0;
#endif /* PAP_SUPPORT */
    if (!can_auth && (0
#if CHAP_SUPPORT
    || wo->neg_chap
#endif /* CHAP_SUPPORT */
#if EAP_SUPPORT
    || wo->neg_eap
#endif /* EAP_SUPPORT */
    )) {
#if CHAP_SUPPORT
    can_auth = have_chap_secret((explicit_remote? remote_name: NULL),
                    our_name, 1, &lacks_ip);
#else
    can_auth = 0;
#endif
    }
    if (!can_auth
#if EAP_SUPPORT
    && wo->neg_eap
#endif /* EAP_SUPPORT */
    ) {
    can_auth = have_srp_secret((explicit_remote? remote_name: NULL),
                    our_name, 1, &lacks_ip);
    }

    if (auth_required && !can_auth && noauth_addrs == NULL) {
    if (default_auth) {
        option_error(
"By default the remote system is required to authenticate itself");
        option_error(
"(because this system has a default route to the internet)");
    } else if (explicit_remote)
        option_error(
"The remote system (%s) is required to authenticate itself",
             remote_name);
    else
        option_error(
"The remote system is required to authenticate itself");
    option_error(
"but I couldn't find any suitable secret (password) for it to use to do so.");
    if (lacks_ip)
        option_error(
"(None of the available passwords would let it use an IP address.)");

    exit(1);
    }

    /*
     * Early check for remote number authorization.
     */
    if (!auth_number()) {
    ppp_warn("calling number %q is not authorized", remote_number);
    exit(EXIT_CNID_AUTH_FAILED);
    }
}
#endif /* PPP_OPTIONS */

#if 0 /* UNUSED */
/*
 * auth_reset - called when LCP is starting negotiations to recheck
 * authentication options, i.e. whether we have appropriate secrets
 * to use for authenticating ourselves and/or the peer.
 */
void
auth_reset(unit)
    int unit;
{
    lcp_options *go = &lcp_gotoptions[unit];
    lcp_options *ao = &lcp_allowoptions[unit];
    int hadchap;

    hadchap = -1;
    ao->neg_upap = !refuse_pap && (passwd[0] != 0 || get_pap_passwd(NULL));
    ao->neg_chap = (!refuse_chap || !refuse_mschap || !refuse_mschap_v2)
    && (passwd[0] != 0 ||
        (hadchap = have_chap_secret(user, (explicit_remote? remote_name:
                           NULL), 0, NULL)));
    ao->neg_eap = !refuse_eap && (
    passwd[0] != 0 ||
    (hadchap == 1 || (hadchap == -1 && have_chap_secret(user,
        (explicit_remote? remote_name: NULL), 0, NULL))) ||
    have_srp_secret(user, (explicit_remote? remote_name: NULL), 0, NULL));

    hadchap = -1;
    if (go->neg_upap && !uselogin && !have_pap_secret(NULL))
    go->neg_upap = 0;
    if (go->neg_chap) {
    if (!(hadchap = have_chap_secret((explicit_remote? remote_name: NULL),
                  our_name, 1, NULL)))
        go->neg_chap = 0;
    }
    if (go->neg_eap &&
    (hadchap == 0 || (hadchap == -1 &&
        !have_chap_secret((explicit_remote? remote_name: NULL), our_name,
        1, NULL))) &&
    !have_srp_secret((explicit_remote? remote_name: NULL), our_name, 1,
        NULL))
    go->neg_eap = 0;
}

/*
 * check_passwd - Check the user name and passwd against the PAP secrets
 * file.  If requested, also check against the system password database,
 * and login the user if OK.
 *
 * returns:
 *  UPAP_AUTHNAK: Authentication failed.
 *  UPAP_AUTHACK: Authentication succeeded.
 * In either case, msg points to an appropriate message.
 */
int
check_passwd(unit, auser, userlen, apasswd, passwdlen, msg)
    int unit;
    char *auser;
    int userlen;
    char *apasswd;
    int passwdlen;
    char **msg;
{
  return UPAP_AUTHNAK;
    int ret;
    char *filename;
    FILE *f;
    struct wordlist *addrs = NULL, *opts = NULL;
    char passwd[256], user[256];
    char secret[MAXWORDLEN];
    static int attempts = 0;

    /*
     * Make copies of apasswd and auser, then null-terminate them.
     * If there are unprintable characters in the password, make
     * them visible.
     */
    slprintf(ppp_settings.passwd, sizeof(ppp_settings.passwd), "%.*v", passwdlen, apasswd);
    slprintf(ppp_settings.user, sizeof(ppp_settings.user), "%.*v", userlen, auser);
    *msg = "";

    /*
     * Check if a plugin wants to handle this.
     */
    if (pap_auth_hook) {
    ret = (*pap_auth_hook)(ppp_settings.user, ppp_settings.passwd, msg, &addrs, &opts);
    if (ret >= 0) {
        /* note: set_allowed_addrs() saves opts (but not addrs):
           don't free it! */
        if (ret)
        set_allowed_addrs(unit, addrs, opts);
        else if (opts != 0)
        free_wordlist(opts);
        if (addrs != 0)
        free_wordlist(addrs);
        BZERO(ppp_settings.passwd, sizeof(ppp_settings.passwd));
        return ret? UPAP_AUTHACK: UPAP_AUTHNAK;
    }
    }

    /*
     * Open the file of pap secrets and scan for a suitable secret
     * for authenticating this user.
     */
    filename = _PATH_UPAPFILE;
    addrs = opts = NULL;
    ret = UPAP_AUTHNAK;
    f = fopen(filename, "r");
    if (f == NULL) {
    ppp_error("Can't open PAP password file %s: %m", filename);

    } else {
    check_access(f, filename);
    if (scan_authfile(f, ppp_settings.user, our_name, secret, &addrs, &opts, filename, 0) < 0) {
        ppp_warn("no PAP secret found for %s", user);
    } else {
        /*
         * If the secret is "@login", it means to check
         * the password against the login database.
         */
        int login_secret = strcmp(secret, "@login") == 0;
        ret = UPAP_AUTHACK;
        if (uselogin || login_secret) {
        /* login option or secret is @login */
        if (session_full(ppp_settings.user, ppp_settings.passwd, devnam, msg) == 0) {
            ret = UPAP_AUTHNAK;
        }
        } else if (session_mgmt) {
        if (session_check(ppp_settings.user, NULL, devnam, NULL) == 0) {
            ppp_warn("Peer %q failed PAP Session verification", user);
            ret = UPAP_AUTHNAK;
        }
        }
        if (secret[0] != 0 && !login_secret) {
        /* password given in pap-secrets - must match */
        if ((cryptpap || strcmp(ppp_settings.passwd, secret) != 0)
            && strcmp(crypt(ppp_settings.passwd, secret), secret) != 0)
            ret = UPAP_AUTHNAK;
        }
    }
    fclose(f);
    }

    if (ret == UPAP_AUTHNAK) {
        if (**msg == 0)
        *msg = "Login incorrect";
    /*
     * XXX can we ever get here more than once??
     * Frustrate passwd stealer programs.
     * Allow 10 tries, but start backing off after 3 (stolen from login).
     * On 10'th, drop the connection.
     */
    if (attempts++ >= 10) {
        ppp_warn("%d LOGIN FAILURES ON %s, %s", attempts, devnam, user);
        lcp_close(pcb, "login failed");
    }
    if (attempts > 3)
        sleep((u_int) (attempts - 3) * 5);
    if (opts != NULL)
        free_wordlist(opts);

    } else {
    attempts = 0;           /* Reset count */
    if (**msg == 0)
        *msg = "Login ok";
    set_allowed_addrs(unit, addrs, opts);
    }

    if (addrs != NULL)
    free_wordlist(addrs);
    BZERO(ppp_settings.passwd, sizeof(ppp_settings.passwd));
    BZERO(secret, sizeof(secret));

    return ret;
}

/*
 * null_login - Check if a username of "" and a password of "" are
 * acceptable, and iff so, set the list of acceptable IP addresses
 * and return 1.
 */
static int
null_login(unit)
    int unit;
{
    char *filename;
    FILE *f;
    int i, ret;
    struct wordlist *addrs, *opts;
    char secret[MAXWORDLEN];

    /*
     * Check if a plugin wants to handle this.
     */
    ret = -1;
    if (null_auth_hook)
    ret = (*null_auth_hook)(&addrs, &opts);

    /*
     * Open the file of pap secrets and scan for a suitable secret.
     */
    if (ret <= 0) {
    filename = _PATH_UPAPFILE;
    addrs = NULL;
    f = fopen(filename, "r");
    if (f == NULL)
        return 0;
    check_access(f, filename);

    i = scan_authfile(f, "", our_name, secret, &addrs, &opts, filename, 0);
    ret = i >= 0 && secret[0] == 0;
    BZERO(secret, sizeof(secret));
    fclose(f);
    }

    if (ret)
    set_allowed_addrs(unit, addrs, opts);
    else if (opts != 0)
    free_wordlist(opts);
    if (addrs != 0)
    free_wordlist(addrs);

    return ret;
}

/*
 * get_pap_passwd - get a password for authenticating ourselves with
 * our peer using PAP.  Returns 1 on success, 0 if no suitable password
 * could be found.
 * Assumes passwd points to MAXSECRETLEN bytes of space (if non-null).
 */
static int
get_pap_passwd(passwd)
    char *passwd;
{
    char *filename;
    FILE *f;
    int ret;
    char secret[MAXWORDLEN];

    /*
     * Check whether a plugin wants to supply this.
     */
    if (pap_passwd_hook) {
    ret = (*pap_passwd_hook)(ppp_settings,user, ppp_settings.passwd);
    if (ret >= 0)
        return ret;
    }

    filename = _PATH_UPAPFILE;
    f = fopen(filename, "r");
    if (f == NULL)
    return 0;
    check_access(f, filename);
    ret = scan_authfile(f, user,
            (remote_name[0]? remote_name: NULL),
            secret, NULL, NULL, filename, 0);
    fclose(f);
    if (ret < 0)
    return 0;
    if (passwd != NULL)
    strlcpy(passwd, secret, MAXSECRETLEN);
    BZERO(secret, sizeof(secret));
    return 1;
}

/*
 * have_pap_secret - check whether we have a PAP file with any
 * secrets that we could possibly use for authenticating the peer.
 */
static int
have_pap_secret(lacks_ipp)
    int *lacks_ipp;
{
    FILE *f;
    int ret;
    char *filename;
    struct wordlist *addrs;

    /* let the plugin decide, if there is one */
    if (pap_check_hook) {
    ret = (*pap_check_hook)();
    if (ret >= 0)
        return ret;
    }

    filename = _PATH_UPAPFILE;
    f = fopen(filename, "r");
    if (f == NULL)
    return 0;

    ret = scan_authfile(f, (explicit_remote? remote_name: NULL), our_name,
            NULL, &addrs, NULL, filename, 0);
    fclose(f);
    if (ret >= 0 && !some_ip_ok(addrs)) {
    if (lacks_ipp != 0)
        *lacks_ipp = 1;
    ret = -1;
    }
    if (addrs != 0)
    free_wordlist(addrs);

    return ret >= 0;
}

/*
 * have_chap_secret - check whether we have a CHAP file with a
 * secret that we could possibly use for authenticating `client'
 * on `server'.  Either can be the null string, meaning we don't
 * know the identity yet.
 */
static int
have_chap_secret(client, server, need_ip, lacks_ipp)
    char *client;
    char *server;
    int need_ip;
    int *lacks_ipp;
{
    FILE *f;
    int ret;
    char *filename;
    struct wordlist *addrs;

    if (chap_check_hook) {
    ret = (*chap_check_hook)();
    if (ret >= 0) {
        return ret;
    }
    }

    filename = _PATH_CHAPFILE;
    f = fopen(filename, "r");
    if (f == NULL)
    return 0;

    if (client != NULL && client[0] == 0)
    client = NULL;
    else if (server != NULL && server[0] == 0)
    server = NULL;

    ret = scan_authfile(f, client, server, NULL, &addrs, NULL, filename, 0);
    fclose(f);
    if (ret >= 0 && need_ip && !some_ip_ok(addrs)) {
    if (lacks_ipp != 0)
        *lacks_ipp = 1;
    ret = -1;
    }
    if (addrs != 0)
    free_wordlist(addrs);

    return ret >= 0;
}

/*
 * have_srp_secret - check whether we have a SRP file with a
 * secret that we could possibly use for authenticating `client'
 * on `server'.  Either can be the null string, meaning we don't
 * know the identity yet.
 */
static int
have_srp_secret(client, server, need_ip, lacks_ipp)
    char *client;
    char *server;
    int need_ip;
    int *lacks_ipp;
{
    FILE *f;
    int ret;
    char *filename;
    struct wordlist *addrs;

    filename = _PATH_SRPFILE;
    f = fopen(filename, "r");
    if (f == NULL)
    return 0;

    if (client != NULL && client[0] == 0)
    client = NULL;
    else if (server != NULL && server[0] == 0)
    server = NULL;

    ret = scan_authfile(f, client, server, NULL, &addrs, NULL, filename, 0);
    fclose(f);
    if (ret >= 0 && need_ip && !some_ip_ok(addrs)) {
    if (lacks_ipp != 0)
        *lacks_ipp = 1;
    ret = -1;
    }
    if (addrs != 0)
    free_wordlist(addrs);

    return ret >= 0;
}
#endif /* UNUSED */

#if PPP_AUTH_SUPPORT
/*
 * get_secret - open the CHAP secret file and return the secret
 * for authenticating the given client on the given server.
 * (We could be either client or server).
 */
int get_secret(ppp_pcb *pcb, const char *client, const char *server, char *secret, int *secret_len, int am_server) {
  int len;
  LWIP_UNUSED_ARG(server);
  LWIP_UNUSED_ARG(am_server);

  if (!client || !client[0] || !pcb->settings.user || !pcb->settings.passwd || strcmp(client, pcb->settings.user)) {
    return 0;
  }

  len = (int)strlen(pcb->settings.passwd);
  if (len > MAXSECRETLEN) {
    ppp_error("Secret for %s on %s is too long", client, server);
    len = MAXSECRETLEN;
  }

  MEMCPY(secret, pcb->settings.passwd, len);
  *secret_len = len;
  return 1;

#if 0 /* UNUSED */
    FILE *f;
    int ret, len;
    char *filename;
    struct wordlist *addrs, *opts;
    char secbuf[MAXWORDLEN];
    struct wordlist *addrs;
    addrs = NULL;

    if (!am_server && ppp_settings.passwd[0] != 0) {
    strlcpy(secbuf, ppp_settings.passwd, sizeof(secbuf));
    } else if (!am_server && chap_passwd_hook) {
    if ( (*chap_passwd_hook)(client, secbuf) < 0) {
        ppp_error("Unable to obtain CHAP password for %s on %s from plugin",
          client, server);
        return 0;
    }
    } else {
    filename = _PATH_CHAPFILE;
    addrs = NULL;
    secbuf[0] = 0;

    f = fopen(filename, "r");
    if (f == NULL) {
        ppp_error("Can't open chap secret file %s: %m", filename);
        return 0;
    }
    check_access(f, filename);

    ret = scan_authfile(f, client, server, secbuf, &addrs, &opts, filename, 0);
    fclose(f);
    if (ret < 0)
        return 0;

    if (am_server)
        set_allowed_addrs(unit, addrs, opts);
    else if (opts != 0)
        free_wordlist(opts);
    if (addrs != 0)
        free_wordlist(addrs);
    }

    len = strlen(secbuf);
    if (len > MAXSECRETLEN) {
    ppp_error("Secret for %s on %s is too long", client, server);
    len = MAXSECRETLEN;
    }
    MEMCPY(secret, secbuf, len);
    BZERO(secbuf, sizeof(secbuf));
    *secret_len = len;

    return 1;
#endif /* UNUSED */
}
#endif /* PPP_AUTH_SUPPORT */


#if 0 /* UNUSED */
/*
 * get_srp_secret - open the SRP secret file and return the secret
 * for authenticating the given client on the given server.
 * (We could be either client or server).
 */
int
get_srp_secret(unit, client, server, secret, am_server)
    int unit;
    char *client;
    char *server;
    char *secret;
    int am_server;
{
    FILE *fp;
    int ret;
    char *filename;
    struct wordlist *addrs, *opts;

    if (!am_server && ppp_settings.passwd[0] != '\0') {
    strlcpy(secret, ppp_settings.passwd, MAXWORDLEN);
    } else {
    filename = _PATH_SRPFILE;
    addrs = NULL;

    fp = fopen(filename, "r");
    if (fp == NULL) {
        ppp_error("Can't open srp secret file %s: %m", filename);
        return 0;
    }
    check_access(fp, filename);

    secret[0] = '\0';
    ret = scan_authfile(fp, client, server, secret, &addrs, &opts,
        filename, am_server);
    fclose(fp);
    if (ret < 0)
        return 0;

    if (am_server)
        set_allowed_addrs(unit, addrs, opts);
    else if (opts != NULL)
        free_wordlist(opts);
    if (addrs != NULL)
        free_wordlist(addrs);
    }

    return 1;
}

/*
 * set_allowed_addrs() - set the list of allowed addresses.
 * Also looks for `--' indicating options to apply for this peer
 * and leaves the following words in extra_options.
 */
static void
set_allowed_addrs(unit, addrs, opts)
    int unit;
    struct wordlist *addrs;
    struct wordlist *opts;
{
    int n;
    struct wordlist *ap, **plink;
    struct permitted_ip *ip;
    char *ptr_word, *ptr_mask;
    struct hostent *hp;
    struct netent *np;
    u32_t a, mask, ah, offset;
    struct ipcp_options *wo = &ipcp_wantoptions[unit];
    u32_t suggested_ip = 0;

    if (addresses[unit] != NULL)
    free(addresses[unit]);
    addresses[unit] = NULL;
    if (extra_options != NULL)
    free_wordlist(extra_options);
    extra_options = opts;

    /*
     * Count the number of IP addresses given.
     */
    n = wordlist_count(addrs) + wordlist_count(noauth_addrs);
    if (n == 0)
    return;
    ip = (struct permitted_ip *) malloc((n + 1) * sizeof(struct permitted_ip));
    if (ip == 0)
    return;

    /* temporarily append the noauth_addrs list to addrs */
    for (plink = &addrs; *plink != NULL; plink = &(*plink)->next)
    ;
    *plink = noauth_addrs;

    n = 0;
    for (ap = addrs; ap != NULL; ap = ap->next) {
    /* "-" means no addresses authorized, "*" means any address allowed */
    ptr_word = ap->word;
    if (strcmp(ptr_word, "-") == 0)
        break;
    if (strcmp(ptr_word, "*") == 0) {
        ip[n].permit = 1;
        ip[n].base = ip[n].mask = 0;
        ++n;
        break;
    }

    ip[n].permit = 1;
    if (*ptr_word == '!') {
        ip[n].permit = 0;
        ++ptr_word;
    }

    mask = ~ (u32_t) 0;
    offset = 0;
    ptr_mask = strchr (ptr_word, '/');
    if (ptr_mask != NULL) {
        int bit_count;
        char *endp;

        bit_count = (int) strtol (ptr_mask+1, &endp, 10);
        if (bit_count <= 0 || bit_count > 32) {
        ppp_warn("invalid address length %v in auth. address list",
             ptr_mask+1);
        continue;
        }
        bit_count = 32 - bit_count; /* # bits in host part */
        if (*endp == '+') {
        offset = ifunit + 1;
        ++endp;
        }
        if (*endp != 0) {
        ppp_warn("invalid address length syntax: %v", ptr_mask+1);
        continue;
        }
        *ptr_mask = '\0';
        mask <<= bit_count;
    }

    hp = gethostbyname(ptr_word);
    if (hp != NULL && hp->h_addrtype == AF_INET) {
        a = *(u32_t *)hp->h_addr;
    } else {
        np = getnetbyname (ptr_word);
        if (np != NULL && np->n_addrtype == AF_INET) {
        a = lwip_htonl ((u32_t)np->n_net);
        if (ptr_mask == NULL) {
            /* calculate appropriate mask for net */
            ah = lwip_ntohl(a);
            if (IN_CLASSA(ah))
            mask = IN_CLASSA_NET;
            else if (IN_CLASSB(ah))
            mask = IN_CLASSB_NET;
            else if (IN_CLASSC(ah))
            mask = IN_CLASSC_NET;
        }
        } else {
        a = inet_addr (ptr_word);
        }
    }

    if (ptr_mask != NULL)
        *ptr_mask = '/';

    if (a == (u32_t)-1L) {
        ppp_warn("unknown host %s in auth. address list", ap->word);
        continue;
    }
    if (offset != 0) {
        if (offset >= ~mask) {
        ppp_warn("interface unit %d too large for subnet %v",
             ifunit, ptr_word);
        continue;
        }
        a = lwip_htonl((lwip_ntohl(a) & mask) + offset);
        mask = ~(u32_t)0;
    }
    ip[n].mask = lwip_htonl(mask);
    ip[n].base = a & ip[n].mask;
    ++n;
    if (~mask == 0 && suggested_ip == 0)
        suggested_ip = a;
    }
    *plink = NULL;

    ip[n].permit = 0;       /* make the last entry forbid all addresses */
    ip[n].base = 0;     /* to terminate the list */
    ip[n].mask = 0;

    addresses[unit] = ip;

    /*
     * If the address given for the peer isn't authorized, or if
     * the user hasn't given one, AND there is an authorized address
     * which is a single host, then use that if we find one.
     */
    if (suggested_ip != 0
    && (wo->hisaddr == 0 || !auth_ip_addr(unit, wo->hisaddr))) {
    wo->hisaddr = suggested_ip;
    /*
     * Do we insist on this address?  No, if there are other
     * addresses authorized than the suggested one.
     */
    if (n > 1)
        wo->accept_remote = 1;
    }
}

/*
 * auth_ip_addr - check whether the peer is authorized to use
 * a given IP address.  Returns 1 if authorized, 0 otherwise.
 */
int
auth_ip_addr(unit, addr)
    int unit;
    u32_t addr;
{
    int ok;

    /* don't allow loopback or multicast address */
    if (bad_ip_adrs(addr))
    return 0;

    if (allowed_address_hook) {
    ok = allowed_address_hook(addr);
    if (ok >= 0) return ok;
    }

    if (addresses[unit] != NULL) {
    ok = ip_addr_check(addr, addresses[unit]);
    if (ok >= 0)
        return ok;
    }

    if (auth_required)
    return 0;       /* no addresses authorized */
    return allow_any_ip || privileged || !have_route_to(addr);
}

static int
ip_addr_check(addr, addrs)
    u32_t addr;
    struct permitted_ip *addrs;
{
    for (; ; ++addrs)
    if ((addr & addrs->mask) == addrs->base)
        return addrs->permit;
}

/*
 * bad_ip_adrs - return 1 if the IP address is one we don't want
 * to use, such as an address in the loopback net or a multicast address.
 * addr is in network byte order.
 */
int
bad_ip_adrs(addr)
    u32_t addr;
{
    addr = lwip_ntohl(addr);
    return (addr >> IN_CLASSA_NSHIFT) == IN_LOOPBACKNET
    || IN_MULTICAST(addr) || IN_BADCLASS(addr);
}

/*
 * some_ip_ok - check a wordlist to see if it authorizes any
 * IP address(es).
 */
static int
some_ip_ok(addrs)
    struct wordlist *addrs;
{
    for (; addrs != 0; addrs = addrs->next) {
    if (addrs->word[0] == '-')
        break;
    if (addrs->word[0] != '!')
        return 1;       /* some IP address is allowed */
    }
    return 0;
}

/*
 * auth_number - check whether the remote number is allowed to connect.
 * Returns 1 if authorized, 0 otherwise.
 */
int
auth_number()
{
    struct wordlist *wp = permitted_numbers;
    int l;

    /* Allow all if no authorization list. */
    if (!wp)
    return 1;

    /* Allow if we have a match in the authorization list. */
    while (wp) {
    /* trailing '*' wildcard */
    l = strlen(wp->word);
    if ((wp->word)[l - 1] == '*')
        l--;
    if (!strncasecmp(wp->word, remote_number, l))
        return 1;
    wp = wp->next;
    }

    return 0;
}

/*
 * check_access - complain if a secret file has too-liberal permissions.
 */
static void
check_access(f, filename)
    FILE *f;
    char *filename;
{
    struct stat sbuf;

    if (fstat(fileno(f), &sbuf) < 0) {
    ppp_warn("cannot stat secret file %s: %m", filename);
    } else if ((sbuf.st_mode & (S_IRWXG | S_IRWXO)) != 0) {
    ppp_warn("Warning - secret file %s has world and/or group access",
         filename);
    }
}

/*
 * scan_authfile - Scan an authorization file for a secret suitable
 * for authenticating `client' on `server'.  The return value is -1
 * if no secret is found, otherwise >= 0.  The return value has
 * NONWILD_CLIENT set if the secret didn't have "*" for the client, and
 * NONWILD_SERVER set if the secret didn't have "*" for the server.
 * Any following words on the line up to a "--" (i.e. address authorization
 * info) are placed in a wordlist and returned in *addrs.  Any
 * following words (extra options) are placed in a wordlist and
 * returned in *opts.
 * We assume secret is NULL or points to MAXWORDLEN bytes of space.
 * Flags are non-zero if we need two colons in the secret in order to
 * match.
 */
static int
scan_authfile(f, client, server, secret, addrs, opts, filename, flags)
    FILE *f;
    char *client;
    char *server;
    char *secret;
    struct wordlist **addrs;
    struct wordlist **opts;
    char *filename;
    int flags;
{
    int newline, xxx;
    int got_flag, best_flag;
    FILE *sf;
    struct wordlist *ap, *addr_list, *alist, **app;
    char word[MAXWORDLEN];
    char atfile[MAXWORDLEN];
    char lsecret[MAXWORDLEN];
    char *cp;

    if (addrs != NULL)
    *addrs = NULL;
    if (opts != NULL)
    *opts = NULL;
    addr_list = NULL;
    if (!getword(f, word, &newline, filename))
    return -1;      /* file is empty??? */
    newline = 1;
    best_flag = -1;
    for (;;) {
    /*
     * Skip until we find a word at the start of a line.
     */
    while (!newline && getword(f, word, &newline, filename))
        ;
    if (!newline)
        break;      /* got to end of file */

    /*
     * Got a client - check if it's a match or a wildcard.
     */
    got_flag = 0;
    if (client != NULL && strcmp(word, client) != 0 && !ISWILD(word)) {
        newline = 0;
        continue;
    }
    if (!ISWILD(word))
        got_flag = NONWILD_CLIENT;

    /*
     * Now get a server and check if it matches.
     */
    if (!getword(f, word, &newline, filename))
        break;
    if (newline)
        continue;
    if (!ISWILD(word)) {
        if (server != NULL && strcmp(word, server) != 0)
        continue;
        got_flag |= NONWILD_SERVER;
    }

    /*
     * Got some sort of a match - see if it's better than what
     * we have already.
     */
    if (got_flag <= best_flag)
        continue;

    /*
     * Get the secret.
     */
    if (!getword(f, word, &newline, filename))
        break;
    if (newline)
        continue;

    /*
     * SRP-SHA1 authenticator should never be reading secrets from
     * a file.  (Authenticatee may, though.)
     */
    if (flags && ((cp = strchr(word, ':')) == NULL ||
        strchr(cp + 1, ':') == NULL))
        continue;

    if (secret != NULL) {
        /*
         * Special syntax: @/pathname means read secret from file.
         */
        if (word[0] == '@' && word[1] == '/') {
        strlcpy(atfile, word+1, sizeof(atfile));
        if ((sf = fopen(atfile, "r")) == NULL) {
            ppp_warn("can't open indirect secret file %s", atfile);
            continue;
        }
        check_access(sf, atfile);
        if (!getword(sf, word, &xxx, atfile)) {
            ppp_warn("no secret in indirect secret file %s", atfile);
            fclose(sf);
            continue;
        }
        fclose(sf);
        }
        strlcpy(lsecret, word, sizeof(lsecret));
    }

    /*
     * Now read address authorization info and make a wordlist.
     */
    app = &alist;
    for (;;) {
        if (!getword(f, word, &newline, filename) || newline)
        break;
        ap = (struct wordlist *)
            malloc(sizeof(struct wordlist) + strlen(word) + 1);
        if (ap == NULL)
        novm("authorized addresses");
        ap->word = (char *) (ap + 1);
        strcpy(ap->word, word);
        *app = ap;
        app = &ap->next;
    }
    *app = NULL;

    /*
     * This is the best so far; remember it.
     */
    best_flag = got_flag;
    if (addr_list)
        free_wordlist(addr_list);
    addr_list = alist;
    if (secret != NULL)
        strlcpy(secret, lsecret, MAXWORDLEN);

    if (!newline)
        break;
    }

    /* scan for a -- word indicating the start of options */
    for (app = &addr_list; (ap = *app) != NULL; app = &ap->next)
    if (strcmp(ap->word, "--") == 0)
        break;
    /* ap = start of options */
    if (ap != NULL) {
    ap = ap->next;      /* first option */
    free(*app);         /* free the "--" word */
    *app = NULL;        /* terminate addr list */
    }
    if (opts != NULL)
    *opts = ap;
    else if (ap != NULL)
    free_wordlist(ap);
    if (addrs != NULL)
    *addrs = addr_list;
    else if (addr_list != NULL)
    free_wordlist(addr_list);

    return best_flag;
}

/*
 * wordlist_count - return the number of items in a wordlist
 */
static int
wordlist_count(wp)
    struct wordlist *wp;
{
    int n;

    for (n = 0; wp != NULL; wp = wp->next)
    ++n;
    return n;
}

/*
 * free_wordlist - release memory allocated for a wordlist.
 */
static void
free_wordlist(wp)
    struct wordlist *wp;
{
    struct wordlist *next;

    while (wp != NULL) {
    next = wp->next;
    free(wp);
    wp = next;
    }
}
#endif /* UNUSED */

#endif /* PPP_SUPPORT */