1 /*****************************************************************************
2 * auth.c - Network Authentication and Phase Control program file.
4 * Copyright (c) 2003 by Marc Boucher, Services Informatiques (MBSI) inc.
5 * Copyright (c) 1997 by Global Election Systems Inc. All rights reserved.
7 * The authors hereby grant permission to use, copy, modify, distribute,
8 * and license this software and its documentation for any purpose, provided
9 * that existing copyright notices are retained in all copies and that this
10 * notice and the following disclaimer are included verbatim in any
11 * distributions. No written agreement, license, or royalty fee is required
12 * for any of the authorized uses.
14 * THIS SOFTWARE IS PROVIDED BY THE CONTRIBUTORS *AS IS* AND ANY EXPRESS OR
15 * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
16 * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
17 * IN NO EVENT SHALL THE CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT,
18 * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
19 * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
20 * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
21 * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
22 * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
23 * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
25 ******************************************************************************
28 * 03-01-01 Marc Boucher <marc@mbsi.ca>
30 * 97-12-08 Guy Lancaster <lancasterg@acm.org>, Global Election Systems Inc.
31 * Ported from public pppd code.
32 *****************************************************************************/
34 * auth.c - PPP authentication and phase control.
36 * Copyright (c) 1993 The Australian National University.
37 * All rights reserved.
39 * Redistribution and use in source and binary forms are permitted
40 * provided that the above copyright notice and this paragraph are
41 * duplicated in all such forms and that any documentation,
42 * advertising materials, and other materials related to such
43 * distribution and use acknowledge that the software was developed
44 * by the Australian National University. The name of the University
45 * may not be used to endorse or promote products derived from this
46 * software without specific prior written permission.
47 * THIS SOFTWARE IS PROVIDED ``AS IS'' AND WITHOUT ANY EXPRESS OR
48 * IMPLIED WARRANTIES, INCLUDING, WITHOUT LIMITATION, THE IMPLIED
49 * WARRANTIES OF MERCHANTIBILITY AND FITNESS FOR A PARTICULAR PURPOSE.
51 * Copyright (c) 1989 Carnegie Mellon University.
52 * All rights reserved.
54 * Redistribution and use in source and binary forms are permitted
55 * provided that the above copyright notice and this paragraph are
56 * duplicated in all such forms and that any documentation,
57 * advertising materials, and other materials related to such
58 * distribution and use acknowledge that the software was developed
59 * by Carnegie Mellon University. The name of the
60 * University may not be used to endorse or promote products derived
61 * from this software without specific prior written permission.
62 * THIS SOFTWARE IS PROVIDED ``AS IS'' AND WITHOUT ANY EXPRESS OR
63 * IMPLIED WARRANTIES, INCLUDING, WITHOUT LIMITATION, THE IMPLIED
64 * WARRANTIES OF MERCHANTIBILITY AND FITNESS FOR A PARTICULAR PURPOSE.
83 /*************************/
84 /*** LOCAL DEFINITIONS ***/
85 /*************************/
87 /* Bits in auth_pending[] */
88 #define PAP_WITHPEER 1
90 #define CHAP_WITHPEER 4
95 /************************/
96 /*** LOCAL DATA TYPES ***/
97 /************************/
98 /* Used for storing a sequence of words. Usually malloced. */
100 struct wordlist
*next
;
106 /***********************************/
107 /*** LOCAL FUNCTION DECLARATIONS ***/
108 /***********************************/
109 extern char *crypt (const char *, const char *);
111 /* Prototypes for procedures local to this file. */
113 static void network_phase (int);
114 static void check_idle (void *);
115 static void connect_time_expired (void *);
117 static int login (char *, char *, char **, int *);
119 static void logout (void);
120 static int null_login (int);
121 static int get_pap_passwd (int, char *, char *);
122 static int have_pap_secret (void);
123 static int have_chap_secret (char *, char *, u32_t
);
124 static int ip_addr_check (u32_t
, struct wordlist
*);
125 #if 0 /* PAP_SUPPORT > 0 || CHAP_SUPPORT > 0 */
126 static void set_allowed_addrs(int unit
, struct wordlist
*addrs
);
127 static void free_wordlist (struct wordlist
*);
130 static void callback_phase (int);
134 /******************************/
135 /*** PUBLIC DATA STRUCTURES ***/
136 /******************************/
139 /*****************************/
140 /*** LOCAL DATA STRUCTURES ***/
141 /*****************************/
142 #if PAP_SUPPORT > 0 || CHAP_SUPPORT > 0
143 /* The name by which the peer authenticated itself to us. */
144 static char peer_authname
[MAXNAMELEN
];
147 /* Records which authentication operations haven't completed yet. */
148 static int auth_pending
[NUM_PPP
];
150 /* Set if we have successfully called login() */
151 static int logged_in
;
153 /* Set if we have run the /etc/ppp/auth-up script. */
154 static int did_authup
;
156 /* List of addresses which the peer may use. */
157 static struct wordlist
*addresses
[NUM_PPP
];
159 /* Number of network protocols which we have opened. */
160 static int num_np_open
;
162 /* Number of network protocols which have come up. */
163 static int num_np_up
;
165 #if PAP_SUPPORT > 0 || CHAP_SUPPORT > 0
166 /* Set if we got the contents of passwd[] from the pap-secrets file. */
167 static int passwd_from_file
;
172 /***********************************/
173 /*** PUBLIC FUNCTION DEFINITIONS ***/
174 /***********************************/
176 * An Open on LCP has requested a change from Dead to Establish phase.
177 * Do what's necessary to bring the physical layer up.
179 void link_required(int unit
)
181 AUTHDEBUG((LOG_INFO
, "link_required: %d\n", unit
));
185 * LCP has terminated the link; go to the Dead phase and take the
186 * physical layer down.
188 void link_terminated(int unit
)
190 AUTHDEBUG((LOG_INFO
, "link_terminated: %d\n", unit
));
192 if (lcp_phase
[unit
] == PHASE_DEAD
)
196 lcp_phase
[unit
] = PHASE_DEAD
;
197 AUTHDEBUG((LOG_NOTICE
, "Connection terminated.\n"));
202 * LCP has gone down; it will either die or try to re-establish.
204 void link_down(int unit
)
207 struct protent
*protp
;
209 AUTHDEBUG((LOG_INFO
, "link_down: %d\n", unit
));
211 /* XXX Do link down processing. */
214 for (i
= 0; (protp
= ppp_protocols
[i
]) != NULL
; ++i
) {
215 if (!protp
->enabled_flag
)
217 if (protp
->protocol
!= PPP_LCP
&& protp
->lowerdown
!= NULL
)
218 (*protp
->lowerdown
)(unit
);
219 if (protp
->protocol
< 0xC000 && protp
->close
!= NULL
)
220 (*protp
->close
)(unit
, "LCP down");
224 if (lcp_phase
[unit
] != PHASE_DEAD
)
225 lcp_phase
[unit
] = PHASE_TERMINATE
;
230 * The link is established.
231 * Proceed to the Dead, Authenticate or Network phase as appropriate.
233 void link_established(int unit
)
237 struct protent
*protp
;
238 lcp_options
*wo
= &lcp_wantoptions
[unit
];
239 lcp_options
*go
= &lcp_gotoptions
[unit
];
240 #if PAP_SUPPORT > 0 || CHAP_SUPPORT > 0
241 lcp_options
*ho
= &lcp_hisoptions
[unit
];
244 AUTHDEBUG((LOG_INFO
, "link_established: %d\n", unit
));
246 * Tell higher-level protocols that LCP is up.
248 for (i
= 0; (protp
= ppp_protocols
[i
]) != NULL
; ++i
)
249 if (protp
->protocol
!= PPP_LCP
&& protp
->enabled_flag
250 && protp
->lowerup
!= NULL
)
251 (*protp
->lowerup
)(unit
);
253 if (ppp_settings
.auth_required
&& !(go
->neg_chap
|| go
->neg_upap
)) {
255 * We wanted the peer to authenticate itself, and it refused:
256 * treat it as though it authenticated with PAP using a username
257 * of "" and a password of "". If that's not OK, boot it out.
259 if (!wo
->neg_upap
|| !null_login(unit
)) {
260 AUTHDEBUG((LOG_WARNING
, "peer refused to authenticate\n"));
261 lcp_close(unit
, "peer refused to authenticate");
266 lcp_phase
[unit
] = PHASE_AUTHENTICATE
;
270 ChapAuthPeer(unit
, ppp_settings
.our_name
, go
->chap_mdtype
);
274 #if PAP_SUPPORT > 0 && CHAP_SUPPORT > 0
285 ChapAuthWithPeer(unit
, ppp_settings
.user
, ho
->chap_mdtype
);
286 auth
|= CHAP_WITHPEER
;
289 #if PAP_SUPPORT > 0 && CHAP_SUPPORT > 0
294 if (ppp_settings
.passwd
[0] == 0) {
295 passwd_from_file
= 1;
296 if (!get_pap_passwd(unit
, ppp_settings
.user
, ppp_settings
.passwd
))
297 AUTHDEBUG((LOG_ERR
, "No secret found for PAP login\n"));
299 upap_authwithpeer(unit
, ppp_settings
.user
, ppp_settings
.passwd
);
300 auth
|= PAP_WITHPEER
;
303 auth_pending
[unit
] = auth
;
311 * The peer has failed to authenticate himself using `protocol'.
313 void auth_peer_fail(int unit
, u16_t protocol
)
315 AUTHDEBUG((LOG_INFO
, "auth_peer_fail: %d proto=%X\n", unit
, protocol
));
317 * Authentication failure: take the link down
319 lcp_close(unit
, "Authentication failed");
323 #if PAP_SUPPORT > 0 || CHAP_SUPPORT > 0
325 * The peer has been successfully authenticated using `protocol'.
327 void auth_peer_success(int unit
, u16_t protocol
, char *name
, int namelen
)
331 AUTHDEBUG((LOG_INFO
, "auth_peer_success: %d proto=%X\n", unit
, protocol
));
340 AUTHDEBUG((LOG_WARNING
, "auth_peer_success: unknown protocol %x\n",
346 * Save the authenticated name of the peer for later.
348 if (namelen
> sizeof(peer_authname
) - 1)
349 namelen
= sizeof(peer_authname
) - 1;
350 BCOPY(name
, peer_authname
, namelen
);
351 peer_authname
[namelen
] = 0;
354 * If there is no more authentication still to be done,
355 * proceed to the network (or callback) phase.
357 if ((auth_pending
[unit
] &= ~pbit
) == 0)
362 * We have failed to authenticate ourselves to the peer using `protocol'.
364 void auth_withpeer_fail(int unit
, u16_t protocol
)
366 int errCode
= PPPERR_AUTHFAIL
;
368 AUTHDEBUG((LOG_INFO
, "auth_withpeer_fail: %d proto=%X\n", unit
, protocol
));
369 if (passwd_from_file
)
370 BZERO(ppp_settings
.passwd
, MAXSECRETLEN
);
372 * XXX Warning: the unit number indicates the interface which is
373 * not necessarily the PPP connection. It works here as long
374 * as we are only supporting PPP interfaces.
376 pppIOCtl(unit
, PPPCTLS_ERRCODE
, &errCode
);
379 * We've failed to authenticate ourselves to our peer.
380 * He'll probably take the link down, and there's not much
381 * we can do except wait for that.
386 * We have successfully authenticated ourselves with the peer using `protocol'.
388 void auth_withpeer_success(int unit
, u16_t protocol
)
392 AUTHDEBUG((LOG_INFO
, "auth_withpeer_success: %d proto=%X\n", unit
, protocol
));
395 pbit
= CHAP_WITHPEER
;
398 if (passwd_from_file
)
399 BZERO(ppp_settings
.passwd
, MAXSECRETLEN
);
403 AUTHDEBUG((LOG_WARNING
, "auth_peer_success: unknown protocol %x\n",
409 * If there is no more authentication still being done,
410 * proceed to the network (or callback) phase.
412 if ((auth_pending
[unit
] &= ~pbit
) == 0)
419 * np_up - a network protocol has come up.
421 void np_up(int unit
, u16_t proto
)
423 AUTHDEBUG((LOG_INFO
, "np_up: %d proto=%X\n", unit
, proto
));
424 if (num_np_up
== 0) {
425 AUTHDEBUG((LOG_INFO
, "np_up: maxconnect=%d idle_time_limit=%d\n",ppp_settings
.maxconnect
,ppp_settings
.idle_time_limit
));
427 * At this point we consider that the link has come up successfully.
429 if (ppp_settings
.idle_time_limit
> 0)
430 TIMEOUT(check_idle
, NULL
, ppp_settings
.idle_time_limit
);
433 * Set a timeout to close the connection once the maximum
434 * connect time has expired.
436 if (ppp_settings
.maxconnect
> 0)
437 TIMEOUT(connect_time_expired
, 0, ppp_settings
.maxconnect
);
443 * np_down - a network protocol has gone down.
445 void np_down(int unit
, u16_t proto
)
447 AUTHDEBUG((LOG_INFO
, "np_down: %d proto=%X\n", unit
, proto
));
448 if (--num_np_up
== 0 && ppp_settings
.idle_time_limit
> 0) {
449 UNTIMEOUT(check_idle
, NULL
);
454 * np_finished - a network protocol has finished using the link.
456 void np_finished(int unit
, u16_t proto
)
458 AUTHDEBUG((LOG_INFO
, "np_finished: %d proto=%X\n", unit
, proto
));
459 if (--num_np_open
<= 0) {
460 /* no further use for the link: shut up shop. */
461 lcp_close(0, "No network protocols running");
466 * auth_reset - called when LCP is starting negotiations to recheck
467 * authentication options, i.e. whether we have appropriate secrets
468 * to use for authenticating ourselves and/or the peer.
470 void auth_reset(int unit
)
472 lcp_options
*go
= &lcp_gotoptions
[unit
];
473 lcp_options
*ao
= &lcp_allowoptions
[0];
474 ipcp_options
*ipwo
= &ipcp_wantoptions
[0];
477 AUTHDEBUG((LOG_INFO
, "auth_reset: %d\n", unit
));
478 ao
->neg_upap
= !ppp_settings
.refuse_pap
&& (ppp_settings
.passwd
[0] != 0 || get_pap_passwd(unit
, NULL
, NULL
));
479 ao
->neg_chap
= !ppp_settings
.refuse_chap
&& ppp_settings
.passwd
[0] != 0 /*have_chap_secret(ppp_settings.user, ppp_settings.remote_name, (u32_t)0)*/;
481 if (go
->neg_upap
&& !have_pap_secret())
484 remote
= ipwo
->accept_remote
? 0: ipwo
->hisaddr
;
485 if (!have_chap_secret(ppp_settings
.remote_name
, ppp_settings
.our_name
, remote
))
493 * check_passwd - Check the user name and passwd against the PAP secrets
494 * file. If requested, also check against the system password database,
495 * and login the user if OK.
498 * UPAP_AUTHNAK: Authentication failed.
499 * UPAP_AUTHACK: Authentication succeeded.
500 * In either case, msg points to an appropriate message.
514 return UPAP_AUTHACK
; /* XXX Assume all entries OK. */
517 struct wordlist
*addrs
= NULL
;
518 char passwd
[256], user
[256];
519 char secret
[MAXWORDLEN
];
520 static u_short attempts
= 0;
523 * Make copies of apasswd and auser, then null-terminate them.
525 BCOPY(apasswd
, passwd
, passwdlen
);
526 passwd
[passwdlen
] = '\0';
527 BCOPY(auser
, user
, userlen
);
528 user
[userlen
] = '\0';
531 /* XXX Validate user name and password. */
532 ret
= UPAP_AUTHACK
; /* XXX Assume all entries OK. */
534 if (ret
== UPAP_AUTHNAK
) {
535 if (*msg
== (char *) 0)
536 *msg
= "Login incorrect";
537 *msglen
= strlen(*msg
);
539 * Frustrate passwd stealer programs.
540 * Allow 10 tries, but start backing off after 3 (stolen from login).
541 * On 10'th, drop the connection.
543 if (attempts
++ >= 10) {
544 AUTHDEBUG((LOG_WARNING
, "%d LOGIN FAILURES BY %s\n", attempts
, user
));
545 /*ppp_panic("Excess Bad Logins");*/
548 sys_msleep((attempts
- 3) * 5);
551 free_wordlist(addrs
);
554 attempts
= 0; /* Reset count */
555 if (*msg
== (char *) 0)
557 *msglen
= strlen(*msg
);
558 set_allowed_addrs(unit
, addrs
);
561 BZERO(passwd
, sizeof(passwd
));
562 BZERO(secret
, sizeof(secret
));
571 * auth_ip_addr - check whether the peer is authorized to use
572 * a given IP address. Returns 1 if authorized, 0 otherwise.
574 int auth_ip_addr(int unit
, u32_t addr
)
576 return ip_addr_check(addr
, addresses
[unit
]);
580 * bad_ip_adrs - return 1 if the IP address is one we don't want
581 * to use, such as an address in the loopback net or a multicast address.
582 * addr is in network byte order.
584 int bad_ip_adrs(u32_t addr
)
587 return (addr
>> IN_CLASSA_NSHIFT
) == IN_LOOPBACKNET
588 || IN_MULTICAST(addr
) || IN_BADCLASS(addr
);
594 * get_secret - open the CHAP secret file and return the secret
595 * for authenticating the given client on the given server.
596 * (We could be either client or server).
609 struct wordlist
*addrs
;
613 if(!client
|| !client
[0] || strcmp(client
, ppp_settings
.user
)) {
617 len
= strlen(ppp_settings
.passwd
);
618 if (len
> MAXSECRETLEN
) {
619 AUTHDEBUG((LOG_ERR
, "Secret for %s on %s is too long\n", client
, server
));
622 BCOPY(ppp_settings
.passwd
, secret
, len
);
628 struct wordlist
*addrs
;
629 char secbuf
[MAXWORDLEN
];
634 /* XXX Find secret. */
639 set_allowed_addrs(unit
, addrs
);
641 len
= strlen(secbuf
);
642 if (len
> MAXSECRETLEN
) {
643 AUTHDEBUG((LOG_ERR
, "Secret for %s on %s is too long\n", client
, server
));
646 BCOPY(secbuf
, secret
, len
);
647 BZERO(secbuf
, sizeof(secbuf
));
658 * auth_check_options - called to check authentication options.
660 void auth_check_options(void)
662 lcp_options
*wo
= &lcp_wantoptions
[0];
664 ipcp_options
*ipwo
= &ipcp_wantoptions
[0];
667 /* Default our_name to hostname, and user to our_name */
668 if (ppp_settings
.our_name
[0] == 0 || ppp_settings
.usehostname
)
669 strcpy(ppp_settings
.our_name
, ppp_settings
.hostname
);
670 if (ppp_settings
.user
[0] == 0)
671 strcpy(ppp_settings
.user
, ppp_settings
.our_name
);
673 /* If authentication is required, ask peer for CHAP or PAP. */
674 if (ppp_settings
.auth_required
&& !wo
->neg_chap
&& !wo
->neg_upap
) {
680 * Check whether we have appropriate secrets to use
681 * to authenticate the peer.
683 can_auth
= wo
->neg_upap
&& have_pap_secret();
684 if (!can_auth
&& wo
->neg_chap
) {
685 remote
= ipwo
->accept_remote
? 0: ipwo
->hisaddr
;
686 can_auth
= have_chap_secret(ppp_settings
.remote_name
, ppp_settings
.our_name
, remote
);
689 if (ppp_settings
.auth_required
&& !can_auth
) {
690 ppp_panic("No auth secret");
696 /**********************************/
697 /*** LOCAL FUNCTION DEFINITIONS ***/
698 /**********************************/
700 * Proceed to the network phase.
702 static void network_phase(int unit
)
705 struct protent
*protp
;
706 lcp_options
*go
= &lcp_gotoptions
[unit
];
709 * If the peer had to authenticate, run the auth-up script now.
711 if ((go
->neg_chap
|| go
->neg_upap
) && !did_authup
) {
712 /* XXX Do setup for peer authentication. */
718 * If we negotiated callback, do it now.
721 lcp_phase
[unit
] = PHASE_CALLBACK
;
722 (*cbcp_protent
.open
)(unit
);
727 lcp_phase
[unit
] = PHASE_NETWORK
;
728 for (i
= 0; (protp
= ppp_protocols
[i
]) != NULL
; ++i
)
729 if (protp
->protocol
< 0xC000 && protp
->enabled_flag
730 && protp
->open
!= NULL
) {
731 (*protp
->open
)(unit
);
732 if (protp
->protocol
!= PPP_CCP
)
736 if (num_np_open
== 0)
738 lcp_close(0, "No network protocols running");
742 * check_idle - check whether the link has been idle for long
743 * enough that we can shut it down.
745 static void check_idle(void *arg
)
747 struct ppp_idle idle
;
751 if (!get_idle_time(0, &idle
))
753 itime
= LWIP_MIN(idle
.xmit_idle
, idle
.recv_idle
);
754 if (itime
>= ppp_settings
.idle_time_limit
) {
755 /* link is idle: shut it down. */
756 AUTHDEBUG((LOG_INFO
, "Terminating connection due to lack of activity.\n"));
757 lcp_close(0, "Link inactive");
759 TIMEOUT(check_idle
, NULL
, ppp_settings
.idle_time_limit
- itime
);
764 * connect_time_expired - log a message and close the connection.
766 static void connect_time_expired(void *arg
)
770 AUTHDEBUG((LOG_INFO
, "Connect time expired\n"));
771 lcp_close(0, "Connect time expired"); /* Close connection */
776 * login - Check the user name and password against the system
777 * password database, and login the user if OK.
780 * UPAP_AUTHNAK: Login failed.
781 * UPAP_AUTHACK: Login succeeded.
782 * In either case, msg points to an appropriate message.
784 static int login(char *user
, char *passwd
, char **msg
, int *msglen
)
786 /* XXX Fail until we decide that we want to support logins. */
787 return (UPAP_AUTHNAK
);
792 * logout - Logout the user.
794 static void logout(void)
801 * null_login - Check if a username of "" and a password of "" are
802 * acceptable, and iff so, set the list of acceptable IP addresses
805 static int null_login(int unit
)
808 /* XXX Fail until we decide that we want to support logins. */
814 * get_pap_passwd - get a password for authenticating ourselves with
815 * our peer using PAP. Returns 1 on success, 0 if no suitable password
818 static int get_pap_passwd(int unit
, char *user
, char *passwd
)
820 /* normally we would reject PAP if no password is provided,
821 but this causes problems with some providers (like CHT in Taiwan)
822 who incorrectly request PAP and expect a bogus/empty password, so
823 always provide a default user/passwd of "none"/"none"
826 strcpy(user
, "none");
828 strcpy(passwd
, "none");
835 * have_pap_secret - check whether we have a PAP file with any
836 * secrets that we could possibly use for authenticating the peer.
838 static int have_pap_secret(void)
840 /* XXX Fail until we set up our passwords. */
846 * have_chap_secret - check whether we have a CHAP file with a
847 * secret that we could possibly use for authenticating `client'
848 * on `server'. Either can be the null string, meaning we don't
849 * know the identity yet.
851 static int have_chap_secret(char *client
, char *server
, u32_t remote
)
856 /* XXX Fail until we set up our passwords. */
861 #if 0 /* PAP_SUPPORT > 0 || CHAP_SUPPORT > 0 */
863 * set_allowed_addrs() - set the list of allowed addresses.
865 static void set_allowed_addrs(int unit
, struct wordlist
*addrs
)
867 if (addresses
[unit
] != NULL
)
868 free_wordlist(addresses
[unit
]);
869 addresses
[unit
] = addrs
;
873 * If there's only one authorized address we might as well
874 * ask our peer for that one right away
876 if (addrs
!= NULL
&& addrs
->next
== NULL
) {
877 char *p
= addrs
->word
;
878 struct ipcp_options
*wo
= &ipcp_wantoptions
[unit
];
882 if (wo
->hisaddr
== 0 && *p
!= '!' && *p
!= '-'
883 && strchr(p
, '/') == NULL
) {
884 hp
= gethostbyname(p
);
885 if (hp
!= NULL
&& hp
->h_addrtype
== AF_INET
)
886 a
= *(u32_t
*)hp
->h_addr
;
897 static int ip_addr_check(u32_t addr
, struct wordlist
*addrs
)
900 /* don't allow loopback or multicast address */
901 if (bad_ip_adrs(addr
))
905 return !ppp_settings
.auth_required
; /* no addresses authorized */
907 /* XXX All other addresses allowed. */
911 #if 0 /* PAP_SUPPORT > 0 || CHAP_SUPPORT */
913 * free_wordlist - release memory allocated for a wordlist.
915 static void free_wordlist(struct wordlist
*wp
)
917 struct wordlist
*next
;
927 #endif /* PPP_SUPPORT */