add support for CCP and BSD-Compress
[ppp.git] / pppd / auth.c
1 /*
2  * auth.c - PPP authentication and phase control.
3  *
4  * Copyright (c) 1993 The Australian National University.
5  * All rights reserved.
6  *
7  * Redistribution and use in source and binary forms are permitted
8  * provided that the above copyright notice and this paragraph are
9  * duplicated in all such forms and that any documentation,
10  * advertising materials, and other materials related to such
11  * distribution and use acknowledge that the software was developed
12  * by the Australian National University.  The name of the University
13  * may not be used to endorse or promote products derived from this
14  * software without specific prior written permission.
15  * THIS SOFTWARE IS PROVIDED ``AS IS'' AND WITHOUT ANY EXPRESS OR
16  * IMPLIED WARRANTIES, INCLUDING, WITHOUT LIMITATION, THE IMPLIED
17  * WARRANTIES OF MERCHANTIBILITY AND FITNESS FOR A PARTICULAR PURPOSE.
18  *
19  * Copyright (c) 1989 Carnegie Mellon University.
20  * All rights reserved.
21  *
22  * Redistribution and use in source and binary forms are permitted
23  * provided that the above copyright notice and this paragraph are
24  * duplicated in all such forms and that any documentation,
25  * advertising materials, and other materials related to such
26  * distribution and use acknowledge that the software was developed
27  * by Carnegie Mellon University.  The name of the
28  * University may not be used to endorse or promote products derived
29  * from this software without specific prior written permission.
30  * THIS SOFTWARE IS PROVIDED ``AS IS'' AND WITHOUT ANY EXPRESS OR
31  * IMPLIED WARRANTIES, INCLUDING, WITHOUT LIMITATION, THE IMPLIED
32  * WARRANTIES OF MERCHANTIBILITY AND FITNESS FOR A PARTICULAR PURPOSE.
33  */
34
35 #ifndef lint
36 static char rcsid[] = "$Id: auth.c,v 1.7 1994/08/09 06:29:14 paulus Exp $";
37 #endif
38
39 #include <stdio.h>
40 #include <stddef.h>
41 #include <syslog.h>
42 #include <pwd.h>
43 #include <string.h>
44 #include <sys/types.h>
45 #include <sys/stat.h>
46
47 #include <netdb.h>
48 #include <netinet/in.h>
49 #include <arpa/inet.h>
50
51 #include "ppp.h"
52 #include "pppd.h"
53 #include "fsm.h"
54 #include "lcp.h"
55 #include "upap.h"
56 #include "chap.h"
57 #include "ipcp.h"
58 #include "ccp.h"
59 #include "pathnames.h"
60
61 #ifdef sparc
62 #include <alloca.h>
63 #endif /*sparc*/
64
65 /* Used for storing a sequence of words.  Usually malloced. */
66 struct wordlist {
67     struct wordlist     *next;
68     char                word[1];
69 };
70
71 /* Bits in scan_authfile return value */
72 #define NONWILD_SERVER  1
73 #define NONWILD_CLIENT  2
74
75 #define ISWILD(word)    (word[0] == '*' && word[1] == 0)
76
77 #define FALSE   0
78 #define TRUE    1
79
80 extern char user[];
81 extern char passwd[];
82 extern char devname[];
83 extern char our_name[];
84 extern char remote_name[];
85 extern char hostname[];
86 extern int uselogin;
87 extern int usehostname;
88 extern int auth_required;
89
90 /* Records which authentication operations haven't completed yet. */
91 static int auth_pending[NPPP];
92 static int logged_in;
93 static struct wordlist *addresses[NPPP];
94
95 /* Bits in auth_pending[] */
96 #define UPAP_WITHPEER   1
97 #define UPAP_PEER       2
98 #define CHAP_WITHPEER   4
99 #define CHAP_PEER       8
100
101 /* Prototypes */
102 void check_access __ARGS((FILE *, char *));
103
104 static void network_phase __ARGS((int));
105 static int  login __ARGS((char *, char *, char **, int *));
106 static void logout __ARGS((void));
107 static int  null_login __ARGS((int));
108 static int  get_upap_passwd __ARGS((void));
109 static int  have_upap_secret __ARGS((void));
110 static int  have_chap_secret __ARGS((char *, char *));
111 static int  scan_authfile __ARGS((FILE *, char *, char *, char *,
112                                   struct wordlist **, char *));
113 static void free_wordlist __ARGS((struct wordlist *));
114
115 extern char *crypt __ARGS((char *, char *));
116
117 /*
118  * An Open on LCP has requested a change from Dead to Establish phase.
119  * Do what's necessary to bring the physical layer up.
120  */
121 void
122 link_required(unit)
123     int unit;
124 {
125 }
126
127 /*
128  * LCP has terminated the link; go to the Dead phase and take the
129  * physical layer down.
130  */
131 void
132 link_terminated(unit)
133     int unit;
134 {
135     if (phase == PHASE_DEAD)
136         return;
137     if (logged_in)
138         logout();
139     phase = PHASE_DEAD;
140     syslog(LOG_NOTICE, "Connection terminated.");
141 }
142
143 /*
144  * LCP has gone down; it will either die or try to re-establish.
145  */
146 void
147 link_down(unit)
148     int unit;
149 {
150     ipcp_close(0);
151     ccp_close(0);
152     phase = PHASE_TERMINATE;
153 }
154
155 /*
156  * The link is established.
157  * Proceed to the Dead, Authenticate or Network phase as appropriate.
158  */
159 void
160 link_established(unit)
161     int unit;
162 {
163     int auth;
164     lcp_options *wo = &lcp_wantoptions[unit];
165     lcp_options *go = &lcp_gotoptions[unit];
166     lcp_options *ho = &lcp_hisoptions[unit];
167
168     if (auth_required && !(go->neg_chap || go->neg_upap)) {
169         /*
170          * We wanted the peer to authenticate itself, and it refused:
171          * treat it as though it authenticated with PAP using a username
172          * of "" and a password of "".  If that's not OK, boot it out.
173          */
174         if (wo->neg_upap && !null_login(unit)) {
175             syslog(LOG_WARNING, "peer refused to authenticate");
176             lcp_close(unit);
177             phase = PHASE_TERMINATE;
178             return;
179         }
180     }
181
182     phase = PHASE_AUTHENTICATE;
183     auth = 0;
184     if (go->neg_chap) {
185         ChapAuthPeer(unit, our_name, go->chap_mdtype);
186         auth |= CHAP_PEER;
187     } else if (go->neg_upap) {
188         upap_authpeer(unit);
189         auth |= UPAP_PEER;
190     }
191     if (ho->neg_chap) {
192         ChapAuthWithPeer(unit, our_name, ho->chap_mdtype);
193         auth |= CHAP_WITHPEER;
194     } else if (ho->neg_upap) {
195         upap_authwithpeer(unit, user, passwd);
196         auth |= UPAP_WITHPEER;
197     }
198     auth_pending[unit] = auth;
199
200     if (!auth)
201         network_phase(unit);
202 }
203
204 /*
205  * Proceed to the network phase.
206  */
207 static void
208 network_phase(unit)
209     int unit;
210 {
211     phase = PHASE_NETWORK;
212     ipcp_open(unit);
213     ccp_open(unit);
214 }
215
216 /*
217  * The peer has failed to authenticate himself using `protocol'.
218  */
219 void
220 auth_peer_fail(unit, protocol)
221     int unit, protocol;
222 {
223     /*
224      * Authentication failure: take the link down
225      */
226     lcp_close(unit);
227     phase = PHASE_TERMINATE;
228 }
229
230 /*
231  * The peer has been successfully authenticated using `protocol'.
232  */
233 void
234 auth_peer_success(unit, protocol)
235     int unit, protocol;
236 {
237     int bit;
238
239     switch (protocol) {
240     case CHAP:
241         bit = CHAP_PEER;
242         break;
243     case UPAP:
244         bit = UPAP_PEER;
245         break;
246     default:
247         syslog(LOG_WARNING, "auth_peer_success: unknown protocol %x",
248                protocol);
249         return;
250     }
251
252     /*
253      * If there is no more authentication still to be done,
254      * proceed to the network phase.
255      */
256     if ((auth_pending[unit] &= ~bit) == 0) {
257         phase = PHASE_NETWORK;
258         ipcp_open(unit);
259         ccp_open(unit);
260     }
261 }
262
263 /*
264  * We have failed to authenticate ourselves to the peer using `protocol'.
265  */
266 void
267 auth_withpeer_fail(unit, protocol)
268     int unit, protocol;
269 {
270     /*
271      * We've failed to authenticate ourselves to our peer.
272      * He'll probably take the link down, and there's not much
273      * we can do except wait for that.
274      */
275 }
276
277 /*
278  * We have successfully authenticated ourselves with the peer using `protocol'.
279  */
280 void
281 auth_withpeer_success(unit, protocol)
282     int unit, protocol;
283 {
284     int bit;
285
286     switch (protocol) {
287     case CHAP:
288         bit = CHAP_WITHPEER;
289         break;
290     case UPAP:
291         bit = UPAP_WITHPEER;
292         break;
293     default:
294         syslog(LOG_WARNING, "auth_peer_success: unknown protocol %x",
295                protocol);
296         bit = 0;
297     }
298
299     /*
300      * If there is no more authentication still being done,
301      * proceed to the network phase.
302      */
303     if ((auth_pending[unit] &= ~bit) == 0)
304         network_phase(unit);
305 }
306
307
308 /*
309  * check_auth_options - called to check authentication options.
310  */
311 void
312 check_auth_options()
313 {
314     lcp_options *wo = &lcp_wantoptions[0];
315     lcp_options *ao = &lcp_allowoptions[0];
316
317     /* Default our_name to hostname, and user to our_name */
318     if (our_name[0] == 0 || usehostname)
319         strcpy(our_name, hostname);
320     if (user[0] == 0)
321         strcpy(user, our_name);
322
323     /* If authentication is required, ask peer for CHAP or PAP. */
324     if (auth_required && !wo->neg_chap && !wo->neg_upap) {
325         wo->neg_chap = 1;
326         wo->neg_upap = 1;
327     }
328
329     /*
330      * Check whether we have appropriate secrets to use
331      * to authenticate ourselves and/or the peer.
332      */
333     if (ao->neg_upap && passwd[0] == 0 && !get_upap_passwd())
334         ao->neg_upap = 0;
335     if (wo->neg_upap && !uselogin && !have_upap_secret())
336         wo->neg_upap = 0;
337     if (ao->neg_chap && !have_chap_secret(our_name, remote_name))
338         ao->neg_chap = 0;
339     if (wo->neg_chap && !have_chap_secret(remote_name, our_name))
340         wo->neg_chap = 0;
341
342     if (auth_required && !wo->neg_chap && !wo->neg_upap) {
343         fprintf(stderr, "\
344 pppd: peer authentication required but no authentication files accessible\n");
345         exit(1);
346     }
347
348 }
349
350
351 /*
352  * check_passwd - Check the user name and passwd against the PAP secrets
353  * file.  If requested, also check against the system password database,
354  * and login the user if OK.
355  *
356  * returns:
357  *      UPAP_AUTHNAK: Authentication failed.
358  *      UPAP_AUTHACK: Authentication succeeded.
359  * In either case, msg points to an appropriate message.
360  */
361 int
362 check_passwd(unit, auser, userlen, apasswd, passwdlen, msg, msglen)
363     int unit;
364     char *auser;
365     int userlen;
366     char *apasswd;
367     int passwdlen;
368     char **msg;
369     int *msglen;
370 {
371     int ret;
372     char *filename;
373     FILE *f;
374     struct wordlist *addrs;
375     char passwd[256], user[256];
376     char secret[MAXWORDLEN];
377     static int attempts = 0;
378
379     /*
380      * Make copies of apasswd and auser, then null-terminate them.
381      */
382     BCOPY(apasswd, passwd, passwdlen);
383     passwd[passwdlen] = '\0';
384     BCOPY(auser, user, userlen);
385     user[userlen] = '\0';
386
387     /*
388      * Open the file of upap secrets and scan for a suitable secret
389      * for authenticating this user.
390      */
391     filename = _PATH_UPAPFILE;
392     addrs = NULL;
393     ret = UPAP_AUTHACK;
394     f = fopen(filename, "r");
395     if (f == NULL) {
396         if (!uselogin) {
397             syslog(LOG_ERR, "Can't open upap password file %s: %m", filename);
398             ret = UPAP_AUTHNAK;
399         }
400
401     } else {
402         check_access(f, filename);
403         if (scan_authfile(f, user, our_name, secret, &addrs, filename) < 0
404             || (secret[0] != 0 && strcmp(passwd, secret) != 0
405                 && strcmp(crypt(passwd, secret), secret) != 0)) {
406             syslog(LOG_WARNING, "upap authentication failure for %s", user);
407             ret = UPAP_AUTHNAK;
408         }
409         fclose(f);
410     }
411
412     if (uselogin && ret == UPAP_AUTHACK) {
413         ret = login(user, passwd, msg, msglen);
414         if (ret == UPAP_AUTHNAK) {
415             syslog(LOG_WARNING, "upap login failure for %s", user);
416         }
417     }
418
419     if (ret == UPAP_AUTHNAK) {
420         *msg = "Login incorrect";
421         *msglen = strlen(*msg);
422         /*
423          * Frustrate passwd stealer programs.
424          * Allow 10 tries, but start backing off after 3 (stolen from login).
425          * On 10'th, drop the connection.
426          */
427         if (attempts++ >= 10) {
428             syslog(LOG_WARNING, "%d LOGIN FAILURES ON %s, %s",
429                    attempts, devname, user);
430             quit();
431         }
432         if (attempts > 3)
433             sleep((u_int) (attempts - 3) * 5);
434         if (addrs != NULL)
435             free_wordlist(addrs);
436
437     } else {
438         attempts = 0;                   /* Reset count */
439         *msg = "Login ok";
440         *msglen = strlen(*msg);
441         if (addresses[unit] != NULL)
442             free_wordlist(addresses[unit]);
443         addresses[unit] = addrs;
444     }
445
446     return ret;
447 }
448
449
450 /*
451  * login - Check the user name and password against the system
452  * password database, and login the user if OK.
453  *
454  * returns:
455  *      UPAP_AUTHNAK: Login failed.
456  *      UPAP_AUTHACK: Login succeeded.
457  * In either case, msg points to an appropriate message.
458  */
459 static int
460 login(user, passwd, msg, msglen)
461     char *user;
462     char *passwd;
463     char **msg;
464     int *msglen;
465 {
466     struct passwd *pw;
467     char *epasswd;
468     char *tty;
469
470     if ((pw = getpwnam(user)) == NULL) {
471         return (UPAP_AUTHNAK);
472     }
473
474     /*
475      * XXX If no passwd, let them login without one.
476      */
477     if (pw->pw_passwd == '\0') {
478         return (UPAP_AUTHACK);
479     }
480
481     epasswd = crypt(passwd, pw->pw_passwd);
482     if (strcmp(epasswd, pw->pw_passwd)) {
483         return (UPAP_AUTHNAK);
484     }
485
486     syslog(LOG_INFO, "user %s logged in", user);
487
488     /*
489      * Write a wtmp entry for this user.
490      */
491     tty = strrchr(devname, '/');
492     if (tty == NULL)
493         tty = devname;
494     else
495         tty++;
496     logwtmp(tty, user, "");             /* Add wtmp login entry */
497     logged_in = TRUE;
498
499     return (UPAP_AUTHACK);
500 }
501
502 /*
503  * logout - Logout the user.
504  */
505 static void
506 logout()
507 {
508     char *tty;
509
510     tty = strrchr(devname, '/');
511     if (tty == NULL)
512         tty = devname;
513     else
514         tty++;
515     logwtmp(tty, "", "");               /* Wipe out wtmp logout entry */
516     logged_in = FALSE;
517 }
518
519
520 /*
521  * null_login - Check if a username of "" and a password of "" are
522  * acceptable, and iff so, set the list of acceptable IP addresses
523  * and return 1.
524  */
525 static int
526 null_login(unit)
527     int unit;
528 {
529     char *filename;
530     FILE *f;
531     int i, ret;
532     struct wordlist *addrs;
533     char secret[MAXWORDLEN];
534
535     /*
536      * Open the file of upap secrets and scan for a suitable secret.
537      * We don't accept a wildcard client.
538      */
539     filename = _PATH_UPAPFILE;
540     addrs = NULL;
541     f = fopen(filename, "r");
542     if (f == NULL)
543         return 0;
544     check_access(f, filename);
545
546     i = scan_authfile(f, "", our_name, secret, &addrs, filename);
547     ret = i >= 0 && (i & NONWILD_CLIENT) != 0 && secret[0] == 0;
548
549     if (ret) {
550         if (addresses[unit] != NULL)
551             free_wordlist(addresses[unit]);
552         addresses[unit] = addrs;
553     }
554
555     fclose(f);
556     return ret;
557 }
558
559
560 /*
561  * get_upap_passwd - get a password for authenticating ourselves with
562  * our peer using PAP.  Returns 1 on success, 0 if no suitable password
563  * could be found.
564  */
565 static int
566 get_upap_passwd()
567 {
568     char *filename;
569     FILE *f;
570     struct wordlist *addrs;
571     char secret[MAXWORDLEN];
572
573     filename = _PATH_UPAPFILE;
574     addrs = NULL;
575     f = fopen(filename, "r");
576     if (f == NULL)
577         return 0;
578     check_access(f, filename);
579     if (scan_authfile(f, user, remote_name, secret, NULL, filename) < 0)
580         return 0;
581     strncpy(passwd, secret, MAXSECRETLEN);
582     passwd[MAXSECRETLEN-1] = 0;
583     return 1;
584 }
585
586
587 /*
588  * have_upap_secret - check whether we have a PAP file with any
589  * secrets that we could possibly use for authenticating the peer.
590  */
591 static int
592 have_upap_secret()
593 {
594     FILE *f;
595     int ret;
596     char *filename;
597
598     filename = _PATH_UPAPFILE;
599     f = fopen(filename, "r");
600     if (f == NULL)
601         return 0;
602
603     ret = scan_authfile(f, NULL, our_name, NULL, NULL, filename);
604     fclose(f);
605     if (ret < 0)
606         return 0;
607
608     return 1;
609 }
610
611
612 /*
613  * have_chap_secret - check whether we have a CHAP file with a
614  * secret that we could possibly use for authenticating `client'
615  * on `server'.  Either can be the null string, meaning we don't
616  * know the identity yet.
617  */
618 static int
619 have_chap_secret(client, server)
620     char *client;
621     char *server;
622 {
623     FILE *f;
624     int ret;
625     char *filename;
626
627     filename = _PATH_CHAPFILE;
628     f = fopen(filename, "r");
629     if (f == NULL)
630         return 0;
631
632     if (client[0] == 0)
633         client = NULL;
634     else if (server[0] == 0)
635         server = NULL;
636
637     ret = scan_authfile(f, client, server, NULL, NULL, filename);
638     fclose(f);
639     if (ret < 0)
640         return 0;
641
642     return 1;
643 }
644
645
646 /*
647  * get_secret - open the CHAP secret file and return the secret
648  * for authenticating the given client on the given server.
649  * (We could be either client or server).
650  */
651 int
652 get_secret(unit, client, server, secret, secret_len, save_addrs)
653     int unit;
654     char *client;
655     char *server;
656     char *secret;
657     int *secret_len;
658     int save_addrs;
659 {
660     FILE *f;
661     int ret, len;
662     char *filename;
663     struct wordlist *addrs;
664     char secbuf[MAXWORDLEN];
665
666     filename = _PATH_CHAPFILE;
667     addrs = NULL;
668     secbuf[0] = 0;
669
670     f = fopen(filename, "r");
671     if (f == NULL) {
672         syslog(LOG_ERR, "Can't open chap secret file %s: %m", filename);
673         return 0;
674     }
675     check_access(f, filename);
676
677     ret = scan_authfile(f, client, server, secbuf, &addrs, filename);
678     fclose(f);
679     if (ret < 0)
680         return 0;
681
682     if (save_addrs) {
683         if (addresses[unit] != NULL)
684             free_wordlist(addresses[unit]);
685         addresses[unit] = addrs;
686     }
687
688     len = strlen(secbuf);
689     if (len > MAXSECRETLEN) {
690         syslog(LOG_ERR, "Secret for %s on %s is too long", client, server);
691         len = MAXSECRETLEN;
692     }
693     BCOPY(secbuf, secret, len);
694     *secret_len = len;
695
696     return 1;
697 }
698
699 /*
700  * auth_ip_addr - check whether the peer is authorized to use
701  * a given IP address.  Returns 1 if authorized, 0 otherwise.
702  */
703 int
704 auth_ip_addr(unit, addr)
705     int unit;
706     u_long addr;
707 {
708     u_long a;
709     struct hostent *hp;
710     struct wordlist *addrs;
711
712     /* don't allow loopback or multicast address */
713     if (bad_ip_adrs(addr))
714         return 0;
715
716     if ((addrs = addresses[unit]) == NULL)
717         return 1;               /* no restriction */
718
719     for (; addrs != NULL; addrs = addrs->next) {
720         /* "-" means no addresses authorized */
721         if (strcmp(addrs->word, "-") == 0)
722             break;
723         if ((a = inet_addr(addrs->word)) == -1) {
724             if ((hp = gethostbyname(addrs->word)) == NULL) {
725                 syslog(LOG_WARNING, "unknown host %s in auth. address list",
726                        addrs->word);
727                 continue;
728             } else
729                 a = *(u_long *)hp->h_addr;
730         }
731         if (addr == a)
732             return 1;
733     }
734     return 0;                   /* not in list => can't have it */
735 }
736
737 /*
738  * bad_ip_adrs - return 1 if the IP address is one we don't want
739  * to use, such as an address in the loopback net or a multicast address.
740  * addr is in network byte order.
741  */
742 int
743 bad_ip_adrs(addr)
744     u_long addr;
745 {
746     addr = ntohl(addr);
747     return (addr >> IN_CLASSA_NSHIFT) == IN_LOOPBACKNET
748         || IN_MULTICAST(addr) || IN_BADCLASS(addr);
749 }
750
751 /*
752  * check_access - complain if a secret file has too-liberal permissions.
753  */
754 void
755 check_access(f, filename)
756     FILE *f;
757     char *filename;
758 {
759     struct stat sbuf;
760
761     if (fstat(fileno(f), &sbuf) < 0) {
762         syslog(LOG_WARNING, "cannot stat secret file %s: %m", filename);
763     } else if ((sbuf.st_mode & (S_IRWXG | S_IRWXO)) != 0) {
764         syslog(LOG_WARNING, "Warning - secret file %s has world and/or group access", filename);
765     }
766 }
767
768
769 /*
770  * scan_authfile - Scan an authorization file for a secret suitable
771  * for authenticating `client' on `server'.  The return value is -1
772  * if no secret is found, otherwise >= 0.  The return value has
773  * NONWILD_CLIENT set if the secret didn't have "*" for the client, and
774  * NONWILD_SERVER set if the secret didn't have "*" for the server.
775  * Any following words on the line (i.e. address authorization
776  * info) are placed in a wordlist and returned in *addrs.  
777  */
778 static int
779 scan_authfile(f, client, server, secret, addrs, filename)
780     FILE *f;
781     char *client;
782     char *server;
783     char *secret;
784     struct wordlist **addrs;
785     char *filename;
786 {
787     int newline, xxx;
788     int got_flag, best_flag;
789     FILE *sf;
790     struct wordlist *ap, *addr_list, *addr_last;
791     char word[MAXWORDLEN];
792     char atfile[MAXWORDLEN];
793
794     if (addrs != NULL)
795         *addrs = NULL;
796     addr_list = NULL;
797     if (!getword(f, word, &newline, filename))
798         return -1;              /* file is empty??? */
799     newline = 1;
800     best_flag = -1;
801     for (;;) {
802         /*
803          * Skip until we find a word at the start of a line.
804          */
805         while (!newline && getword(f, word, &newline, filename))
806             ;
807         if (!newline)
808             break;              /* got to end of file */
809
810         /*
811          * Got a client - check if it's a match or a wildcard.
812          */
813         got_flag = 0;
814         if (client != NULL && strcmp(word, client) != 0 && !ISWILD(word)) {
815             newline = 0;
816             continue;
817         }
818         if (!ISWILD(word))
819             got_flag = NONWILD_CLIENT;
820
821         /*
822          * Now get a server and check if it matches.
823          */
824         if (!getword(f, word, &newline, filename))
825             break;
826         if (newline)
827             continue;
828         if (server != NULL && strcmp(word, server) != 0 && !ISWILD(word))
829             continue;
830         if (!ISWILD(word))
831             got_flag |= NONWILD_SERVER;
832
833         /*
834          * Got some sort of a match - see if it's better than what
835          * we have already.
836          */
837         if (got_flag <= best_flag)
838             continue;
839
840         /*
841          * Get the secret.
842          */
843         if (!getword(f, word, &newline, filename))
844             break;
845         if (newline)
846             continue;
847
848         /*
849          * Special syntax: @filename means read secret from file.
850          */
851         if (word[0] == '@') {
852             strcpy(atfile, word+1);
853             if ((sf = fopen(atfile, "r")) == NULL) {
854                 syslog(LOG_WARNING, "can't open indirect secret file %s",
855                        atfile);
856                 continue;
857             }
858             check_access(sf, atfile);
859             if (!getword(sf, word, &xxx, atfile)) {
860                 syslog(LOG_WARNING, "no secret in indirect secret file %s",
861                        atfile);
862                 fclose(sf);
863                 continue;
864             }
865             fclose(sf);
866         }
867         if (secret != NULL)
868             strcpy(secret, word);
869                 
870         best_flag = got_flag;
871
872         /*
873          * Now read address authorization info and make a wordlist.
874          */
875         if (addr_list)
876             free_wordlist(addr_list);
877         addr_list = addr_last = NULL;
878         for (;;) {
879             if (!getword(f, word, &newline, filename) || newline)
880                 break;
881             ap = (struct wordlist *) malloc(sizeof(struct wordlist)
882                                             + strlen(word));
883             if (ap == NULL)
884                 novm("authorized addresses");
885             ap->next = NULL;
886             strcpy(ap->word, word);
887             if (addr_list == NULL)
888                 addr_list = ap;
889             else
890                 addr_last->next = ap;
891             addr_last = ap;
892         }
893         if (!newline)
894             break;
895     }
896
897     if (addrs != NULL)
898         *addrs = addr_list;
899     else if (addr_list != NULL)
900         free_wordlist(addr_list);
901
902     return best_flag;
903 }
904
905 /*
906  * free_wordlist - release memory allocated for a wordlist.
907  */
908 static void
909 free_wordlist(wp)
910     struct wordlist *wp;
911 {
912     struct wordlist *next;
913
914     while (wp != NULL) {
915         next = wp->next;
916         free(wp);
917         wp = next;
918     }
919 }