X-Git-Url: https://git.ozlabs.org/?p=ppp.git;a=blobdiff_plain;f=pppd%2Fauth.c;h=3d466e2e52fa097f95b72dac09ab50d4d71a9ea1;hp=c51a67d975501cad52673bb38b1f43cb357f538c;hb=2c872bc67b83b91ba6390f6e5e72be08e09811a1;hpb=0d9cdddebd14f1499eb32bb322c74d4edb89a7ac diff --git a/pppd/auth.c b/pppd/auth.c index c51a67d..3d466e2 100644 --- a/pppd/auth.c +++ b/pppd/auth.c @@ -32,9 +32,7 @@ * WARRANTIES OF MERCHANTIBILITY AND FITNESS FOR A PARTICULAR PURPOSE. */ -#ifndef lint -static char rcsid[] = "$Id: auth.c,v 1.53 1999/05/13 00:33:05 paulus Exp $"; -#endif +#define RCSID "$Id: auth.c,v 1.62 2000/03/27 06:02:59 paulus Exp $" #include #include @@ -78,11 +76,7 @@ static char rcsid[] = "$Id: auth.c,v 1.53 1999/05/13 00:33:05 paulus Exp $"; #endif #include "pathnames.h" -/* Used for storing a sequence of words. Usually malloced. */ -struct wordlist { - struct wordlist *next; - char *word; -}; +static const char rcsid[] = RCSID; /* Bits in scan_authfile return value */ #define NONWILD_SERVER 1 @@ -102,6 +96,13 @@ static int logged_in; /* 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; + +/* Extra options to apply, from the secrets file entry for the peer. */ +static struct wordlist *extra_options; + /* Number of network protocols which we have opened. */ static int num_np_open; @@ -111,6 +112,26 @@ static int num_np_up; /* Set if we got the contents of passwd[] from the pap-secrets file. */ static int passwd_from_file; +/* 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) __P((struct ppp_idle *)) = NULL; + +/* Hook for a plugin to say whether we can possibly authenticate any peer */ +int (*pap_check_hook) __P((void)) = NULL; + +/* Hook for a plugin to check the PAP user and password */ +int (*pap_auth_hook) __P((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) __P((void)) = NULL; + +/* Hook for a plugin to get the PAP password for authenticating us */ +int (*pap_passwd_hook) __P((char *user, char *passwd)) = NULL; + /* * This is used to ensure that we don't start an auth-up/down * script while one is already running. @@ -150,7 +171,7 @@ extern char *crypt __P((const char *, const char *)); static void network_phase __P((int)); static void check_idle __P((void *)); static void connect_time_expired __P((void *)); -static int plogin __P((char *, char *, char **, int *)); +static int plogin __P((char *, char *, char **)); static void plogout __P((void)); static int null_login __P((int)); static int get_pap_passwd __P((char *)); @@ -158,14 +179,16 @@ static int have_pap_secret __P((int *)); static int have_chap_secret __P((char *, char *, int, int *)); static int ip_addr_check __P((u_int32_t, struct permitted_ip *)); static int scan_authfile __P((FILE *, char *, char *, char *, - struct wordlist **, char *)); + struct wordlist **, struct wordlist **, + char *)); static void free_wordlist __P((struct wordlist *)); static void auth_script __P((char *)); static void auth_script_done __P((void *)); -static void set_allowed_addrs __P((int, struct wordlist *)); +static void set_allowed_addrs __P((int, struct wordlist *, struct wordlist *)); static int some_ip_ok __P((struct wordlist *)); static int setupapfile __P((char **)); static int privgroup __P((char **)); +static int set_noauth_addr __P((char **)); static void check_access __P((FILE *, char *)); /* @@ -208,8 +231,14 @@ option_t auth_options[] = { "PAP passwords are encrypted", 1 }, { "+ua", o_special, setupapfile, "Get PAP user and password from file" }, + { "password", o_string, passwd, + "Password for authenticating us to the peer", OPT_STATIC, + NULL, MAXSECRETLEN }, { "privgroup", o_special, privgroup, "Allow group members to use privileged options", OPT_PRIV }, + { "allow-ip", o_special, set_noauth_addr, + "Set IP address(es) which can be used without authentication", + OPT_PRIV }, { NULL } }; @@ -280,6 +309,29 @@ privgroup(argv) } +/* + * 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); + struct wordlist *wp; + + wp = (struct wordlist *) malloc(sizeof(struct wordlist) + l + 1); + if (wp == NULL) + novm("allow-ip argument"); + wp->word = (char *) (wp + 1); + wp->next = noauth_addrs; + BCOPY(addr, wp->word, l); + noauth_addrs = wp; + return 1; +} + + /* * An Open on LCP has requested a change from Dead to Establish phase. * Do what's necessary to bring the physical layer up. @@ -300,9 +352,13 @@ link_terminated(unit) { if (phase == PHASE_DEAD) return; - if (logged_in) - plogout(); - phase = PHASE_DEAD; + if (pap_logout_hook) { + pap_logout_hook(); + } else { + if (logged_in) + plogout(); + } + new_phase(PHASE_DEAD); notice("Connection terminated."); } @@ -318,6 +374,7 @@ link_down(unit) auth_state = s_down; if (auth_script_state == s_up && auth_script_pid == 0) { + update_link_stats(unit); auth_script_state = s_down; auth_script(_PATH_AUTHDOWN); } @@ -332,7 +389,7 @@ link_down(unit) num_np_open = 0; num_np_up = 0; if (phase != PHASE_DEAD) - phase = PHASE_TERMINATE; + new_phase(PHASE_TERMINATE); } /* @@ -361,10 +418,14 @@ link_established(unit) if (auth_required && !(go->neg_chap || go->neg_upap)) { /* * We wanted the peer to authenticate itself, and it refused: - * 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 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 (!wo->neg_upap || !null_login(unit)) { + if (noauth_addrs != NULL) { + set_allowed_addrs(unit, noauth_addrs, NULL); + } else if (!wo->neg_upap || !null_login(unit)) { warn("peer refused to authenticate: terminating link"); lcp_close(unit, "peer refused to authenticate"); status = EXIT_PEER_AUTH_FAILED; @@ -372,7 +433,7 @@ link_established(unit) } } - phase = PHASE_AUTHENTICATE; + new_phase(PHASE_AUTHENTICATE); auth = 0; if (go->neg_chap) { ChapAuthPeer(unit, our_name, go->chap_mdtype); @@ -406,8 +467,6 @@ static void network_phase(unit) int unit; { - int i; - struct protent *protp; lcp_options *go = &lcp_gotoptions[unit]; /* @@ -426,13 +485,31 @@ network_phase(unit) * If we negotiated callback, do it now. */ if (go->neg_cbcp) { - phase = PHASE_CALLBACK; + new_phase(PHASE_CALLBACK); (*cbcp_protent.open)(unit); return; } #endif - phase = PHASE_NETWORK; + /* + * Process extra options from the secrets file + */ + if (extra_options) { + options_from_list(extra_options, 1); + free_wordlist(extra_options); + extra_options = 0; + } + start_networks(); +} + +void +start_networks() +{ + int i; + struct protent *protp; + + new_phase(PHASE_NETWORK); + #if 0 if (!demand) set_filters(&pass_filter, &active_filter); @@ -440,7 +517,7 @@ network_phase(unit) for (i = 0; (protp = protocols[i]) != NULL; ++i) if (protp->protocol < 0xC000 && protp->enabled_flag && protp->open != NULL) { - (*protp->open)(unit); + (*protp->open)(0); if (protp->protocol != PPP_CCP) ++num_np_open; } @@ -515,9 +592,12 @@ auth_withpeer_fail(unit, protocol) BZERO(passwd, MAXSECRETLEN); /* * We've failed to authenticate ourselves to our peer. - * He'll probably take the link down, and there's not much - * we can do except wait for that. + * Some servers keep sending CHAP challenges, but there + * is no point in persisting without any way to get updated + * authentication secrets. */ + lcp_close(unit, "Failed to authenticate ourselves to peer"); + status = EXIT_AUTH_TOPEER_FAILED; } /* @@ -559,15 +639,22 @@ void np_up(unit, proto) int unit, proto; { + int tlim; + if (num_np_up == 0) { /* * At this point we consider that the link has come up successfully. */ - need_holdoff = 0; status = EXIT_OK; + unsuccess = 0; + new_phase(PHASE_RUNNING); - if (idle_time_limit > 0) - TIMEOUT(check_idle, NULL, idle_time_limit); + if (idle_time_hook != 0) + tlim = (*idle_time_hook)(NULL); + else + tlim = idle_time_limit; + if (tlim > 0) + TIMEOUT(check_idle, NULL, tlim); /* * Set a timeout to close the connection once the maximum @@ -592,8 +679,9 @@ void np_down(unit, proto) int unit, proto; { - if (--num_np_up == 0 && idle_time_limit > 0) { + if (--num_np_up == 0) { UNTIMEOUT(check_idle, NULL); + new_phase(PHASE_NETWORK); } } @@ -616,21 +704,28 @@ np_finished(unit, proto) */ static void check_idle(arg) - void *arg; + void *arg; { struct ppp_idle idle; time_t itime; + int tlim; if (!get_idle_time(0, &idle)) return; - itime = MIN(idle.xmit_idle, idle.recv_idle); - if (itime >= idle_time_limit) { + if (idle_time_hook != 0) { + tlim = idle_time_hook(&idle); + } else { + itime = MIN(idle.xmit_idle, idle.recv_idle); + tlim = idle_time_limit - itime; + } + if (tlim <= 0) { /* link is idle: shut it down. */ notice("Terminating connection due to lack of activity."); lcp_close(0, "Link inactive"); + need_holdoff = 0; status = EXIT_IDLE_TIMEOUT; } else { - TIMEOUT(check_idle, NULL, idle_time_limit - itime); + TIMEOUT(check_idle, NULL, tlim); } } @@ -664,10 +759,12 @@ auth_check_options() /* * If we have a default route, require the peer to authenticate - * unless the noauth option was given. + * unless the noauth option was given or the real user is root. */ - if (!auth_required && !allow_any_ip && have_route_to(0)) + if (!auth_required && !allow_any_ip && have_route_to(0) && !privileged) { auth_required = 1; + default_auth = 1; + } /* If authentication is required, ask peer for CHAP or PAP. */ if (auth_required) { @@ -691,21 +788,24 @@ auth_check_options() our_name, 1, &lacks_ip); } - if (auth_required && !can_auth) { - if (explicit_remote) + if (auth_required && !can_auth && noauth_addrs == NULL) { + if (default_auth) { option_error( -"The remote system (%s) is required to authenticate itself but I", - remote_name); - else +"By default the remote system is required to authenticate itself"); option_error( -"The remote system is required to authenticate itself but I"); - - if (!lacks_ip) +"(because this system has a default route to the internet)"); + } else if (explicit_remote) option_error( -"couldn't find any suitable secret (password) for it to use to do so."); +"The remote system (%s) is required to authenticate itself", + remote_name); else option_error( -"couldn't find any secret (password) which would let it use an IP address."); +"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); } @@ -725,8 +825,9 @@ auth_reset(unit) ao->neg_upap = !refuse_pap && (passwd[0] != 0 || get_pap_passwd(NULL)); ao->neg_chap = !refuse_chap - && have_chap_secret(user, (explicit_remote? remote_name: NULL), - 0, NULL); + && (passwd[0] != 0 + || have_chap_secret(user, (explicit_remote? remote_name: NULL), + 0, NULL)); if (go->neg_upap && !uselogin && !have_pap_secret(NULL)) go->neg_upap = 0; @@ -749,67 +850,83 @@ auth_reset(unit) * In either case, msg points to an appropriate message. */ int -check_passwd(unit, auser, userlen, apasswd, passwdlen, msg, msglen) +check_passwd(unit, auser, userlen, apasswd, passwdlen, msg) int unit; char *auser; int userlen; char *apasswd; int passwdlen; char **msg; - int *msglen; { int ret; char *filename; FILE *f; - struct wordlist *addrs; + 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(passwd, sizeof(passwd), "%.*v", passwdlen, apasswd); + slprintf(user, sizeof(user), "%.*v", userlen, auser); + *msg = ""; + + /* + * Check if a plugin wants to handle this. */ - BCOPY(apasswd, passwd, passwdlen); - passwd[passwdlen] = '\0'; - BCOPY(auser, user, userlen); - user[userlen] = '\0'; - *msg = (char *) 0; + if (pap_auth_hook) { + ret = (*pap_auth_hook)(user, passwd, msg, &addrs, &opts); + if (ret >= 0) { + if (ret) + set_allowed_addrs(unit, addrs, opts); + BZERO(passwd, sizeof(passwd)); + if (addrs != 0) + free_wordlist(addrs); + 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 = NULL; - ret = UPAP_AUTHACK; + addrs = opts = NULL; + ret = UPAP_AUTHNAK; f = fopen(filename, "r"); if (f == NULL) { error("Can't open PAP password file %s: %m", filename); - ret = UPAP_AUTHNAK; } else { check_access(f, filename); - if (scan_authfile(f, user, our_name, secret, &addrs, filename) < 0 - || (!uselogin && secret[0] != 0 - && (cryptpap || strcmp(passwd, secret) != 0) - && strcmp(crypt(passwd, secret), secret) != 0)) { - warn("PAP authentication failure for %s", user); - ret = UPAP_AUTHNAK; + if (scan_authfile(f, user, our_name, secret, &addrs, &opts, filename) < 0) { + warn("no PAP secret found for %s", user); + } else if (secret[0] != 0) { + /* password given in pap-secrets - must match */ + if ((!cryptpap && strcmp(passwd, secret) == 0) + || strcmp(crypt(passwd, secret), secret) == 0) + ret = UPAP_AUTHACK; + else + warn("PAP authentication failure for %s", user); + } else if (uselogin) { + /* empty password in pap-secrets and login option */ + ret = plogin(user, passwd, msg); + if (ret == UPAP_AUTHNAK) + warn("PAP login failure for %s", user); + } else { + /* empty password in pap-secrets and login option not used */ + ret = UPAP_AUTHACK; } fclose(f); } - if (uselogin && ret == UPAP_AUTHACK) { - ret = plogin(user, passwd, msg, msglen); - if (ret == UPAP_AUTHNAK) { - warn("PAP login failure for %s", user); - } - } - if (ret == UPAP_AUTHNAK) { - if (*msg == (char *) 0) + if (**msg == 0) *msg = "Login incorrect"; - *msglen = strlen(*msg); /* * XXX can we ever get here more than once?? * Frustrate passwd stealer programs. @@ -822,17 +939,18 @@ check_passwd(unit, auser, userlen, apasswd, passwdlen, msg, msglen) } if (attempts > 3) sleep((u_int) (attempts - 3) * 5); - if (addrs != NULL) - free_wordlist(addrs); + if (opts != NULL) + free_wordlist(opts); } else { attempts = 0; /* Reset count */ - if (*msg == (char *) 0) + if (**msg == 0) *msg = "Login ok"; - *msglen = strlen(*msg); - set_allowed_addrs(unit, addrs); + set_allowed_addrs(unit, addrs, opts); } + if (addrs != NULL) + free_wordlist(addrs); BZERO(passwd, sizeof(passwd)); BZERO(secret, sizeof(secret)); @@ -915,11 +1033,10 @@ static struct pam_conv PAM_conversation = { */ static int -plogin(user, passwd, msg, msglen) +plogin(user, passwd, msg) char *user; char *passwd; char **msg; - int *msglen; { char *tty; @@ -1075,12 +1192,11 @@ null_login(unit) char *filename; FILE *f; int i, ret; - struct wordlist *addrs; + struct wordlist *addrs, *opts; char secret[MAXWORDLEN]; /* * Open the file of pap secrets and scan for a suitable secret. - * We don't accept a wildcard client. */ filename = _PATH_UPAPFILE; addrs = NULL; @@ -1089,13 +1205,15 @@ null_login(unit) return 0; check_access(f, filename); - i = scan_authfile(f, "", our_name, secret, &addrs, filename); - ret = i >= 0 && (i & NONWILD_CLIENT) != 0 && secret[0] == 0; + i = scan_authfile(f, "", our_name, secret, &addrs, &opts, filename); + ret = i >= 0 && secret[0] == 0; BZERO(secret, sizeof(secret)); if (ret) - set_allowed_addrs(unit, addrs); - else + set_allowed_addrs(unit, addrs, opts); + else if (opts != 0) + free_wordlist(opts); + if (addrs != 0) free_wordlist(addrs); fclose(f); @@ -1116,18 +1234,25 @@ get_pap_passwd(passwd) char *filename; FILE *f; int ret; - struct wordlist *addrs; char secret[MAXWORDLEN]; + /* + * Check whether a plugin wants to supply this. + */ + if (pap_passwd_hook) { + ret = (*pap_passwd_hook)(user, passwd); + if (ret >= 0) + return ret; + } + filename = _PATH_UPAPFILE; - addrs = NULL; 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, filename); + secret, NULL, NULL, filename); fclose(f); if (ret < 0) return 0; @@ -1151,13 +1276,20 @@ have_pap_secret(lacks_ipp) 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, filename); + NULL, &addrs, NULL, filename); fclose(f); if (ret >= 0 && !some_ip_ok(addrs)) { if (lacks_ipp != 0) @@ -1199,7 +1331,7 @@ have_chap_secret(client, server, need_ip, lacks_ipp) else if (server != NULL && server[0] == 0) server = NULL; - ret = scan_authfile(f, client, server, NULL, &addrs, filename); + ret = scan_authfile(f, client, server, NULL, &addrs, NULL, filename); fclose(f); if (ret >= 0 && need_ip && !some_ip_ok(addrs)) { if (lacks_ipp != 0) @@ -1219,38 +1351,46 @@ have_chap_secret(client, server, need_ip, lacks_ipp) * (We could be either client or server). */ int -get_secret(unit, client, server, secret, secret_len, save_addrs) +get_secret(unit, client, server, secret, secret_len, am_server) int unit; char *client; char *server; char *secret; int *secret_len; - int save_addrs; + int am_server; { FILE *f; int ret, len; char *filename; - struct wordlist *addrs; + struct wordlist *addrs, *opts; char secbuf[MAXWORDLEN]; - filename = _PATH_CHAPFILE; - addrs = NULL; - secbuf[0] = 0; + if (!am_server && passwd[0] != 0) { + strlcpy(secbuf, passwd, sizeof(secbuf)); + } else { + filename = _PATH_CHAPFILE; + addrs = NULL; + secbuf[0] = 0; + + f = fopen(filename, "r"); + if (f == NULL) { + error("Can't open chap secret file %s: %m", filename); + return 0; + } + check_access(f, filename); - f = fopen(filename, "r"); - if (f == NULL) { - error("Can't open chap secret file %s: %m", filename); - return 0; + ret = scan_authfile(f, client, server, secbuf, &addrs, &opts, filename); + 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); } - check_access(f, filename); - - ret = scan_authfile(f, client, server, secbuf, &addrs, filename); - fclose(f); - if (ret < 0) - return 0; - - if (save_addrs) - set_allowed_addrs(unit, addrs); len = strlen(secbuf); if (len > MAXSECRETLEN) { @@ -1266,27 +1406,36 @@ get_secret(unit, client, server, secret, secret_len, save_addrs) /* * 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) +set_allowed_addrs(unit, addrs, opts) int unit; struct wordlist *addrs; + struct wordlist *opts; { - int n = 0; - struct wordlist *ap; + int n; + struct wordlist *ap, **pap; struct permitted_ip *ip; char *ptr_word, *ptr_mask; struct hostent *hp; struct netent *np; - u_int32_t a, mask, ah; + u_int32_t a, mask, ah, offset; struct ipcp_options *wo = &ipcp_wantoptions[unit]; u_int32_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; - for (ap = addrs; ap != NULL; ap = ap->next) + /* + * Count the number of IP addresses given. + */ + for (n = 0, pap = &addrs; (ap = *pap) != NULL; pap = &ap->next) ++n; if (n == 0) return; @@ -1314,18 +1463,29 @@ set_allowed_addrs(unit, addrs) } mask = ~ (u_int32_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, (char **) 0, 10); + bit_count = (int) strtol (ptr_mask+1, &endp, 10); if (bit_count <= 0 || bit_count > 32) { warn("invalid address length %v in auth. address list", - ptr_mask); + ptr_mask+1); + continue; + } + bit_count = 32 - bit_count; /* # bits in host part */ + if (*endp == '+') { + offset = ifunit + 1; + ++endp; + } + if (*endp != 0) { + warn("invalid address length syntax: %v", ptr_mask+1); continue; } *ptr_mask = '\0'; - mask <<= 32 - bit_count; + mask <<= bit_count; } hp = gethostbyname(ptr_word); @@ -1353,15 +1513,24 @@ set_allowed_addrs(unit, addrs) if (ptr_mask != NULL) *ptr_mask = '/'; - if (a == (u_int32_t)-1L) + if (a == (u_int32_t)-1L) { warn("unknown host %s in auth. address list", ap->word); - else { - ip[n].mask = htonl(mask); - ip[n].base = a & ip[n].mask; - ++n; - if (~mask == 0 && suggested_ip == 0) - suggested_ip = a; + continue; + } + if (offset != 0) { + if (offset >= ~mask) { + warn("interface unit %d too large for subnet %v", + ifunit, ptr_word); + continue; + } + a = htonl((ntohl(a) & mask) + offset); + mask = ~(u_int32_t)0; } + ip[n].mask = htonl(mask); + ip[n].base = a & ip[n].mask; + ++n; + if (~mask == 0 && suggested_ip == 0) + suggested_ip = a; } ip[n].permit = 0; /* make the last entry forbid all addresses */ @@ -1389,12 +1558,20 @@ auth_ip_addr(unit, addr) int unit; u_int32_t addr; { - if (addresses[unit] == NULL) { - if (auth_required) - return 0; /* no addresses authorized */ - return allow_any_ip || !have_route_to(addr); + int ok; + + /* don't allow loopback or multicast address */ + if (bad_ip_adrs(addr)) + return 0; + + if (addresses[unit] != NULL) { + ok = ip_addr_check(addr, addresses[unit]); + if (ok >= 0) + return ok; } - return ip_addr_check(addr, addresses[unit]); + if (auth_required) + return 0; /* no addresses authorized */ + return allow_any_ip || privileged || !have_route_to(addr); } static int @@ -1402,10 +1579,6 @@ ip_addr_check(addr, addrs) u_int32_t addr; struct permitted_ip *addrs; { - /* don't allow loopback or multicast address */ - if (bad_ip_adrs(addr)) - return 0; - for (; ; ++addrs) if ((addr & addrs->mask) == addrs->base) return addrs->permit; @@ -1434,7 +1607,7 @@ some_ip_ok(addrs) struct wordlist *addrs; { for (; addrs != 0; addrs = addrs->next) { - if (strcmp(addrs->word, "-") == 0) + if (addrs->word[0] == '-') break; if (addrs->word[0] != '!') return 1; /* some IP address is allowed */ @@ -1467,29 +1640,34 @@ check_access(f, filename) * 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 (i.e. address authorization - * info) are placed in a wordlist and returned in *addrs. + * 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. */ static int -scan_authfile(f, client, server, secret, addrs, filename) +scan_authfile(f, client, server, secret, addrs, opts, filename) FILE *f; char *client; char *server; char *secret; struct wordlist **addrs; + struct wordlist **opts; char *filename; { int newline, xxx; int got_flag, best_flag; FILE *sf; - struct wordlist *ap, *addr_list, *alist, *alast; + struct wordlist *ap, *addr_list, *alist, **app; char word[MAXWORDLEN]; char atfile[MAXWORDLEN]; char lsecret[MAXWORDLEN]; if (addrs != NULL) *addrs = NULL; + if (opts != NULL) + *opts = NULL; addr_list = NULL; if (!getword(f, word, &newline, filename)) return -1; /* file is empty??? */ @@ -1566,23 +1744,20 @@ scan_authfile(f, client, server, secret, addrs, filename) /* * Now read address authorization info and make a wordlist. */ - alist = alast = NULL; + app = &alist; for (;;) { if (!getword(f, word, &newline, filename) || newline) break; ap = (struct wordlist *) malloc(sizeof(struct wordlist)); if (ap == NULL) novm("authorized addresses"); - ap->next = NULL; ap->word = strdup(word); if (ap->word == NULL) - novm("authorized address"); - if (alist == NULL) - alist = ap; - else - alast->next = ap; - alast = ap; + novm("authorized addresses"); + *app = ap; + app = &ap->next; } + *app = NULL; /* * This is the best so far; remember it. @@ -1598,6 +1773,20 @@ scan_authfile(f, client, server, secret, addrs, filename) 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)