userapps/opensource/ppp/pppoe/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 #define RCSID   "$Id: auth.c,v 1.69 2001/03/12 22:50:01 paulus Exp $"
  36
  37 #include <stdio.h>
  38 #include <stddef.h>
  39 #include <stdlib.h>
  40 #include <unistd.h>
  41 #include <pwd.h>
  42 #include <grp.h>
  43 #include <string.h>
  44 #include <sys/types.h>
  45 #include <sys/stat.h>
  46 #include <sys/socket.h>
  47 #include <time.h>
  48 #include <utmp.h>
  49 #include <fcntl.h>
  50 #if defined(_PATH_LASTLOG) && defined(_linux_)
  51 #include <lastlog.h>
  52 #endif
  53
  54 #include <netdb.h>
  55 #include <netinet/in.h>
  56 #include <arpa/inet.h>
  57
  58 // brcm
  59 #include <syscall.h>
  60 #include <syslog.h>
  61 #ifdef USE_PAM
  62 #include <security/pam_appl.h>
  63 #endif
  64
  65 #ifdef HAS_SHADOW
  66 #include <shadow.h>
  67 #ifndef PW_PPP
  68 #define PW_PPP PW_LOGIN
  69 #endif
  70 #endif
  71
  72 #include "pppd.h"
  73 #include "fsm.h"
  74 #include "lcp.h"
  75 #include "ipcp.h"
  76 #include "upap.h"
  77 #include "chap.h"
  78 #ifdef CBCP_SUPPORT
  79 #include "cbcp.h"
  80 #endif
  81 #include "pathnames.h"
  82
  83 static const char rcsid[] = RCSID;
  84
  85 /* Bits in scan_authfile return value */
  86 #define NONWILD_SERVER  1
  87 #define NONWILD_CLIENT  2
  88
  89 #define ISWILD(word)    (word[0] == '*' && word[1] == 0)
  90
  91 /* The name by which the peer authenticated itself to us. */
  92 char peer_authname[MAXNAMELEN];
  93
  94 /* Records which authentication operations haven't completed yet. */
  95 static int auth_pending[NUM_PPP];
  96
  97 /* Set if we have successfully called plogin() */
  98 static int logged_in;
  99
 100 /* List of addresses which the peer may use. */
 101 static struct permitted_ip *addresses[NUM_PPP];
 102
 103 /* Wordlist giving addresses which the peer may use
 104    without authenticating itself. */
 105 static struct wordlist *noauth_addrs;
 106
 107 /* Extra options to apply, from the secrets file entry for the peer. */
 108 static struct wordlist *extra_options;
 109
 110 /* Number of network protocols which we have opened. */
 111 static int num_np_open;
 112
 113 /* Number of network protocols which have come up. */
 114 static int num_np_up;
 115
 116 /* Set if we got the contents of passwd[] from the pap-secrets file. */
 117 static int passwd_from_file;
 118
 119 /* Set if we require authentication only because we have a default route. */
 120 static bool default_auth;
 121
 122 /* Hook to enable a plugin to control the idle time limit */
 123 int (*idle_time_hook) __P((struct ppp_idle *)) = NULL;
 124
 125 /* Hook for a plugin to say whether we can possibly authenticate any peer */
 126 int (*pap_check_hook) __P((void)) = NULL;
 127
 128 /* Hook for a plugin to check the PAP user and password */
 129 int (*pap_auth_hook) __P((char *user, char *passwd, char **msgp,
 130                           struct wordlist **paddrs,
 131                           struct wordlist **popts)) = NULL;
 132
 133 /* Hook for a plugin to know about the PAP user logout */
 134 void (*pap_logout_hook) __P((void)) = NULL;
 135
 136 /* Hook for a plugin to get the PAP password for authenticating us */
 137 int (*pap_passwd_hook) __P((char *user, char *passwd)) = NULL;
 138
 139 /*
 140  * This is used to ensure that we don't start an auth-up/down
 141  * script while one is already running.
 142  */
 143 enum script_state {
 144     s_down,
 145     s_up
 146 };
 147
 148 static enum script_state auth_state = s_down;
 149 static enum script_state auth_script_state = s_down;
 150 static pid_t auth_script_pid = 0;
 151
 152 static int used_login;          /* peer authenticated against login database */
 153
 154 /*
 155  * Option variables.
 156  */
 157 bool uselogin = 0;              /* Use /etc/passwd for checking PAP */
 158 bool cryptpap = 0;              /* Passwords in pap-secrets are encrypted */
 159 bool refuse_pap = 0;            /* Don't wanna auth. ourselves with PAP */
 160 bool refuse_chap = 0;           /* Don't wanna auth. ourselves with CHAP */
 161 bool usehostname = 0;           /* Use hostname for our_name */
 162 bool auth_required = 0;         /* Always require authentication from peer */
 163 bool allow_any_ip = 0;          /* Allow peer to use any IP address */
 164 bool explicit_remote = 0;       /* User specified explicit remote name */
 165 char remote_name[MAXNAMELEN];   /* Peer's name for authentication */
 166
 167 static char *uafname;           /* name of most recent +ua file */
 168
 169 /* Bits in auth_pending[] */
 170 #define PAP_WITHPEER    1
 171 #define PAP_PEER        2
 172 #define CHAP_WITHPEER   4
 173 #define CHAP_PEER       8
 174
 175 extern char *crypt __P((const char *, const char *));
 176
 177 /* Prototypes for procedures local to this file. */
 178
 179 static void network_phase __P((int));
 180 static void check_idle __P((void *));
 181 // brcm
 182 static void check_link __P((void *));
 183 static void check_lan_link __P((void *));
 184 static void connect_time_expired __P((void *));
 185 static int  plogin __P((char *, char *, char **));
 186 static void plogout __P((void));
 187 static int  null_login __P((int));
 188 static int  get_pap_passwd __P((char *));
 189 static int  have_pap_secret __P((int *));
 190 static int  have_chap_secret __P((char *, char *, int, int *));
 191 static int  ip_addr_check __P((u_int32_t, struct permitted_ip *));
 192 static int  scan_authfile __P((FILE *, char *, char *, char *,
 193                                struct wordlist **, struct wordlist **,
 194                                char *));
 195 static void free_wordlist __P((struct wordlist *));
 196 static void auth_script __P((char *));
 197 static void auth_script_done __P((void *));
 198 static void set_allowed_addrs __P((int, struct wordlist *, struct wordlist *));
 199 static int  some_ip_ok __P((struct wordlist *));
 200 static int  setupapfile __P((char **));
 201 static int  privgroup __P((char **));
 202 static int  set_noauth_addr __P((char **));
 203 static void check_access __P((FILE *, char *));
 204 static int  wordlist_count __P((struct wordlist *));
 205
 206 /*
 207  * Authentication-related options.
 208  */
 209 option_t auth_options[] = {
 210     { "auth", o_bool, &auth_required,
 211       "Require authentication from peer", OPT_PRIO | 1 },
 212     { "noauth", o_bool, &auth_required,
 213       "Don't require peer to authenticate", OPT_PRIOSUB | OPT_PRIV,
 214       &allow_any_ip },
 215     { "require-pap", o_bool, &lcp_wantoptions[0].neg_upap,
 216       "Require PAP authentication from peer",
 217       OPT_PRIOSUB | 1, &auth_required },
 218     { "+pap", o_bool, &lcp_wantoptions[0].neg_upap,
 219       "Require PAP authentication from peer",
 220       OPT_ALIAS | OPT_PRIOSUB | 1, &auth_required },
 221     { "require-chap", o_bool, &lcp_wantoptions[0].neg_chap,
 222       "Require CHAP authentication from peer",
 223       OPT_PRIOSUB | 1, &auth_required },
 224     { "+chap", o_bool, &lcp_wantoptions[0].neg_chap,
 225       "Require CHAP authentication from peer",
 226       OPT_ALIAS | OPT_PRIOSUB | 1, &auth_required },
 227
 228     { "refuse-pap", o_bool, &refuse_pap,
 229       "Don't agree to auth to peer with PAP", 1 },
 230     { "-pap", o_bool, &refuse_pap,
 231       "Don't allow PAP authentication with peer", OPT_ALIAS | 1 },
 232
 233     { "refuse-chap", o_bool, &refuse_chap,
 234       "Don't agree to auth to peer with CHAP", 1 },
 235     { "-chap", o_bool, &refuse_chap,
 236       "Don't allow CHAP authentication with peer", OPT_ALIAS | 1 },
 237
 238     { "name", o_string, our_name,
 239       "Set local name for authentication",
 240       OPT_PRIO | OPT_PRIV | OPT_STATIC, NULL, MAXNAMELEN },
 241
 242     { "+ua", o_special, (void *)setupapfile,
 243       "Get PAP user and password from file",
 244       OPT_PRIO | OPT_A2STRVAL, &uafname },
 245
 246     { "user", o_string, user,
 247       "Set name for auth with peer", OPT_PRIO | OPT_STATIC, NULL, MAXNAMELEN },
 248
 249     { "password", o_string, passwd,
 250       "Password for authenticating us to the peer",
 251       OPT_PRIO | OPT_STATIC | OPT_HIDE, NULL, MAXSECRETLEN },
 252
 253     { "usehostname", o_bool, &usehostname,
 254       "Must use hostname for authentication", 1 },
 255
 256     { "remotename", o_string, remote_name,
 257       "Set remote name for authentication", OPT_PRIO | OPT_STATIC,
 258       &explicit_remote, MAXNAMELEN },
 259
 260     { "login", o_bool, &uselogin,
 261       "Use system password database for PAP", 1 },
 262
 263     { "papcrypt", o_bool, &cryptpap,
 264       "PAP passwords are encrypted", 1 },
 265
 266     { "privgroup", o_special, (void *)privgroup,
 267       "Allow group members to use privileged options", OPT_PRIV | OPT_A2LIST },
 268
 269     { "allow-ip", o_special, (void *)set_noauth_addr,
 270       "Set IP address(es) which can be used without authentication",
 271       OPT_PRIV | OPT_A2LIST },
 272
 273     { NULL }
 274 };
 275
 276 /*
 277  * setupapfile - specifies UPAP info for authenticating with peer.
 278  */
 279 static int
 280 setupapfile(argv)
 281     char **argv;
 282 {
 283     FILE *ufile;
 284     int l;
 285     char u[MAXNAMELEN], p[MAXSECRETLEN];
 286     char *fname;
 287
 288     lcp_allowoptions[0].neg_upap = 1;
 289
 290     /* open user info file */
 291     fname = strdup(*argv);
 292     if (fname == NULL)
 293         novm("+ua file name");
 294     seteuid(getuid());
 295     ufile = fopen(fname, "r");
 296     seteuid(0);
 297     if (ufile == NULL) {
 298         option_error("unable to open user login data file %s", fname);
 299         return 0;
 300     }
 301     check_access(ufile, fname);
 302     uafname = fname;
 303
 304     /* get username */
 305     if (fgets(u, MAXNAMELEN - 1, ufile) == NULL
 306         || fgets(p, MAXSECRETLEN - 1, ufile) == NULL){
 307         option_error("unable to read user login data file %s", fname);
 308         return 0;
 309     }
 310     fclose(ufile);
 311
 312     /* get rid of newlines */
 313     l = strlen(u);
 314     if (l > 0 && u[l-1] == '\n')
 315         u[l-1] = 0;
 316     l = strlen(p);
 317     if (l > 0 && p[l-1] == '\n')
 318         p[l-1] = 0;
 319
 320     if (override_value("user", option_priority, fname))
 321         strlcpy(user, u, sizeof(user));
 322     if (override_value("passwd", option_priority, fname))
 323         strlcpy(passwd, p, sizeof(passwd));
 324
 325     return (1);
 326 }
 327
 328
 329 /*
 330  * privgroup - allow members of the group to have privileged access.
 331  */
 332 static int
 333 privgroup(argv)
 334     char **argv;
 335 {
 336     struct group *g;
 337     int i;
 338
 339     g = getgrnam(*argv);
 340     if (g == 0) {
 341         option_error("group %s is unknown", *argv);
 342         return 0;
 343     }
 344     for (i = 0; i < ngroups; ++i) {
 345         if (groups[i] == g->gr_gid) {
 346             privileged = 1;
 347             break;
 348         }
 349     }
 350     return 1;
 351 }
 352
 353
 354 /*
 355  * set_noauth_addr - set address(es) that can be used without authentication.
 356  * Equivalent to specifying an entry like `"" * "" addr' in pap-secrets.
 357  */
 358 static int
 359 set_noauth_addr(argv)
 360     char **argv;
 361 {
 362     char *addr = *argv;
 363     int l = strlen(addr) + 1;
 364     struct wordlist *wp;
 365
 366     wp = (struct wordlist *) malloc(sizeof(struct wordlist) + l);
 367     if (wp == NULL)
 368         novm("allow-ip argument");
 369     wp->word = (char *) (wp + 1);
 370     wp->next = noauth_addrs;
 371     BCOPY(addr, wp->word, l);
 372     noauth_addrs = wp;
 373     return 1;
 374 }
 375
 376
 377 /*
 378  * An Open on LCP has requested a change from Dead to Establish phase.
 379  * Do what's necessary to bring the physical layer up.
 380  */
 381 void
 382 link_required(unit)
 383     int unit;
 384 {
 385 }
 386
 387 /*
 388  * LCP has terminated the link; go to the Dead phase and take the
 389  * physical layer down.
 390  */
 391 void
 392 link_terminated(unit)
 393     int unit;
 394 {
 395     if (phase == PHASE_DEAD)
 396         return;
 397     if (pap_logout_hook) {
 398         pap_logout_hook();
 399     } else {
 400         if (logged_in)
 401             plogout();
 402     }
 403     new_phase(PHASE_DEAD);
 404     notice("Connection terminated.");
 405 }
 406
 407 /*
 408  * LCP has gone down; it will either die or try to re-establish.
 409  */
 410 void
 411 link_down(unit)
 412     int unit;
 413 {
 414     int i;
 415     struct protent *protp;
 416
 417     auth_state = s_down;
 418     if (auth_script_state == s_up && auth_script_pid == 0) {
 419         update_link_stats(unit);
 420         auth_script_state = s_down;
 421         auth_script(_PATH_AUTHDOWN);
 422     }
 423     for (i = 0; (protp = protocols[i]) != NULL; ++i) {
 424         if (!protp->enabled_flag)
 425             continue;
 426         if (protp->protocol != PPP_LCP && protp->lowerdown != NULL)
 427             (*protp->lowerdown)(unit);
 428         if (protp->protocol < 0xC000 && protp->close != NULL)
 429             (*protp->close)(unit, "LCP down");
 430     }
 431     num_np_open = 0;
 432     num_np_up = 0;
 433     if (phase != PHASE_DEAD)
 434         new_phase(PHASE_TERMINATE);
 435 }
 436
 437 /*
 438  * The link is established.
 439  * Proceed to the Dead, Authenticate or Network phase as appropriate.
 440  */
 441 void
 442 link_established(unit)
 443     int unit;
 444 {
 445     int auth;
 446     lcp_options *wo = &lcp_wantoptions[unit];
 447     lcp_options *go = &lcp_gotoptions[unit];
 448     lcp_options *ho = &lcp_hisoptions[unit];
 449     int i;
 450     struct protent *protp;
 451
 452     /*
 453      * Tell higher-level protocols that LCP is up.
 454      */
 455     for (i = 0; (protp = protocols[i]) != NULL; ++i)
 456         if (protp->protocol != PPP_LCP && protp->enabled_flag
 457             && protp->lowerup != NULL)
 458             (*protp->lowerup)(unit);
 459
 460     if (auth_required && !(go->neg_chap || go->neg_upap)) {
 461         /*
 462          * We wanted the peer to authenticate itself, and it refused:
 463          * if we have some address(es) it can use without auth, fine,
 464          * otherwise treat it as though it authenticated with PAP using
 465          * a username * of "" and a password of "".  If that's not OK,
 466          * boot it out.
 467          */
 468         if (noauth_addrs != NULL) {
 469             set_allowed_addrs(unit, NULL, NULL);
 470         } else if (!wo->neg_upap || uselogin || !null_login(unit)) {
 471             warn("peer refused to authenticate: terminating link");
 472             lcp_close(unit, "peer refused to authenticate");
 473             status = EXIT_PEER_AUTH_FAILED;
 474             return;
 475         }
 476     }
 477
 478     new_phase(PHASE_AUTHENTICATE);
 479     used_login = 0;
 480     auth = 0;
 481     if (go->neg_chap) {
 482         ChapAuthPeer(unit, our_name, go->chap_mdtype);
 483         auth |= CHAP_PEER;
 484     } else if (go->neg_upap) {
 485         upap_authpeer(unit);
 486         auth |= PAP_PEER;
 487     }
 488     if (ho->neg_chap) {
 489         ChapAuthWithPeer(unit, user, ho->chap_mdtype);
 490         auth |= CHAP_WITHPEER;
 491     } else if (ho->neg_upap) {
 492         if (passwd[0] == 0) {
 493             passwd_from_file = 1;
 494             if (!get_pap_passwd(passwd))
 495                 error("No secret found for PAP login");
 496         }
 497         upap_authwithpeer(unit, user, passwd);
 498         auth |= PAP_WITHPEER;
 499     }
 500     auth_pending[unit] = auth;
 501
 502     if (!auth)
 503         network_phase(unit);
 504 }
 505
 506 /*
 507  * Proceed to the network phase.
 508  */
 509 static void
 510 network_phase(unit)
 511     int unit;
 512 {
 513     lcp_options *go = &lcp_gotoptions[unit];
 514
 515     /*
 516      * If the peer had to authenticate, run the auth-up script now.
 517      */
 518     if (go->neg_chap || go->neg_upap) {
 519         auth_state = s_up;
 520         if (auth_script_state == s_down && auth_script_pid == 0) {
 521             auth_script_state = s_up;
 522             auth_script(_PATH_AUTHUP);
 523         }
 524     }
 525
 526 #ifdef CBCP_SUPPORT
 527     /*
 528      * If we negotiated callback, do it now.
 529      */
 530     if (go->neg_cbcp) {
 531         new_phase(PHASE_CALLBACK);
 532         (*cbcp_protent.open)(unit);
 533         return;
 534     }
 535 #endif
 536
 537     /*
 538      * Process extra options from the secrets file
 539      */
 540 // brcm
 541 #if 0
 542     if (extra_options) {
 543         options_from_list(extra_options, 1);
 544         free_wordlist(extra_options);
 545         extra_options = 0;
 546     }
 547 #endif
 548     start_networks();
 549 }
 550
 551 void
 552 start_networks()
 553 {
 554     int i;
 555     struct protent *protp;
 556
 557     new_phase(PHASE_NETWORK);
 558
 559 #ifdef HAVE_MULTILINK
 560     if (multilink) {
 561         if (mp_join_bundle()) {
 562             if (updetach && !nodetach)
 563                 detach();
 564             return;
 565         }
 566     }
 567 #endif /* HAVE_MULTILINK */
 568
 569 #ifdef PPP_FILTER
 570     if (!demand)
 571         set_filters(&pass_filter, &active_filter);
 572 #endif
 573     for (i = 0; (protp = protocols[i]) != NULL; ++i)
 574         if (protp->protocol < 0xC000 && protp->enabled_flag
 575             && protp->open != NULL) {
 576             (*protp->open)(0);
 577             if (protp->protocol != PPP_CCP)
 578                 ++num_np_open;
 579         }
 580
 581     if (num_np_open == 0)
 582         /* nothing to do */
 583         lcp_close(0, "No network protocols running");
 584 }
 585
 586 /*
 587  * The peer has failed to authenticate himself using `protocol'.
 588  */
 589 void
 590 auth_peer_fail(unit, protocol)
 591     int unit, protocol;
 592 {
 593     /*
 594      * Authentication failure: take the link down
 595      */
 596     lcp_close(unit, "Authentication failed");
 597     status = EXIT_PEER_AUTH_FAILED;
 598 }
 599
 600 /*
 601  * The peer has been successfully authenticated using `protocol'.
 602  */
 603 void
 604 auth_peer_success(unit, protocol, name, namelen)
 605     int unit, protocol;
 606     char *name;
 607     int namelen;
 608 {
 609     int bit;
 610
 611     switch (protocol) {
 612     case PPP_CHAP:
 613         bit = CHAP_PEER;
 614         break;
 615     case PPP_PAP:
 616         bit = PAP_PEER;
 617         break;
 618     default:
 619         warn("auth_peer_success: unknown protocol %x", protocol);
 620         return;
 621     }
 622
 623     /*
 624      * Save the authenticated name of the peer for later.
 625      */
 626     if (namelen > sizeof(peer_authname) - 1)
 627         namelen = sizeof(peer_authname) - 1;
 628     BCOPY(name, peer_authname, namelen);
 629     peer_authname[namelen] = 0;
 630     script_setenv("PEERNAME", peer_authname, 0);
 631
 632     /*
 633      * If there is no more authentication still to be done,
 634      * proceed to the network (or callback) phase.
 635      */
 636     if ((auth_pending[unit] &= ~bit) == 0)
 637         network_phase(unit);
 638 }
 639
 640 /*
 641  * We have failed to authenticate ourselves to the peer using `protocol'.
 642  */
 643 void
 644 auth_withpeer_fail(unit, protocol)
 645     int unit, protocol;
 646 {
 647     if (passwd_from_file)
 648         BZERO(passwd, MAXSECRETLEN);
 649     /*
 650      * We've failed to authenticate ourselves to our peer.
 651      * Some servers keep sending CHAP challenges, but there
 652      * is no point in persisting without any way to get updated
 653      * authentication secrets.
 654      */
 655     lcp_close(unit, "Failed to authenticate ourselves to peer");
 656     status = EXIT_AUTH_TOPEER_FAILED;
 657 // brcm
 658     if ((strlen(user) > 0) || autoscanP2) {
 659     printf("PPP: Authenication failed.\n");
 660     create_msg(BCM_PPPOE_AUTH_FAILED);
 661     syslog(LOG_ERR,"User name and password authentication failed.\n");
 662     }
 663
 664     if (autoscanP2) {
 665     maxfail=0;
 666     persist=0;
 667     }
 668     else {
 669     unsuccess++;
 670     persist=1;
 671     }
 672 }
 673
 674 /*
 675  * We have successfully authenticated ourselves with the peer using `protocol'.
 676  */
 677 void
 678 auth_withpeer_success(unit, protocol)
 679     int unit, protocol;
 680 {
 681     int bit;
 682
 683     switch (protocol) {
 684     case PPP_CHAP:
 685         bit = CHAP_WITHPEER;
 686         break;
 687     case PPP_PAP:
 688         if (passwd_from_file)
 689             BZERO(passwd, MAXSECRETLEN);
 690         bit = PAP_WITHPEER;
 691         break;
 692     default:
 693         warn("auth_withpeer_success: unknown protocol %x", protocol);
 694         bit = 0;
 695     }
 696
 697     persist=1;  // for autoscan
 698
 699     /*
 700      * If there is no more authentication still being done,
 701      * proceed to the network (or callback) phase.
 702      */
 703     if ((auth_pending[unit] &= ~bit) == 0)
 704         network_phase(unit);
 705 }
 706
 707
 708 /*
 709  * np_up - a network protocol has come up.
 710  */
 711 void
 712 np_up(unit, proto)
 713     int unit, proto;
 714 {
 715     int tlim;
 716
 717     if (num_np_up == 0) {
 718         /*
 719          * At this point we consider that the link has come up successfully.
 720          */
 721         status = EXIT_OK;
 722         unsuccess = 0;
 723         holdoff = 10;
 724         new_phase(PHASE_RUNNING);
 725
 726         if (idle_time_hook != 0)
 727             tlim = (*idle_time_hook)(NULL);
 728         else
 729             tlim = idle_time_limit;
 730         if (tlim > 0)
 731             TIMEOUT(check_idle, NULL, tlim);
 732
 733         // brcm
 734         TIMEOUT(check_link, NULL, 3);
 735
 736         // brcm
 737         if (ipext)
 738             TIMEOUT(check_lan_link, NULL, 5);
 739
 740         /*
 741          * Set a timeout to close the connection once the maximum
 742          * connect time has expired.
 743          */
 744         if (maxconnect > 0)
 745             TIMEOUT(connect_time_expired, 0, maxconnect);
 746
 747         /*
 748          * Detach now, if the updetach option was given.
 749          */
 750         if (updetach && !nodetach)
 751             detach();
 752     }
 753     ++num_np_up;
 754 }
 755
 756 /*
 757  * np_down - a network protocol has gone down.
 758  */
 759 void
 760 np_down(unit, proto)
 761     int unit, proto;
 762 {
 763     if (--num_np_up == 0) {
 764         UNTIMEOUT(check_idle, NULL);
 765         // brcm
 766         UNTIMEOUT(check_link, NULL);
 767         if (ipext)
 768             UNTIMEOUT(check_lan_link, NULL);
 769         new_phase(PHASE_NETWORK);
 770     }
 771 }
 772
 773 /*
 774  * np_finished - a network protocol has finished using the link.
 775  */
 776 void
 777 np_finished(unit, proto)
 778     int unit, proto;
 779 {
 780     if (--num_np_open <= 0) {
 781         /* no further use for the link: shut up shop. */
 782         lcp_close(0, "No network protocols running");
 783     }
 784 }
 785
 786 /*
 787  * check_idle - check whether the link has been idle for long
 788  * enough that we can shut it down.
 789  */
 790 static void
 791 check_idle(arg)
 792     void *arg;
 793 {
 794     struct ppp_idle idle;
 795     time_t itime;
 796     int tlim;
 797
 798     if (!get_idle_time(0, &idle))
 799         return;
 800     if (idle_time_hook != 0) {
 801         tlim = idle_time_hook(&idle);
 802     } else {
 803         tlim = idle_time_limit - idle.xmit_idle;
 804         itime = MIN(idle.xmit_idle, idle.recv_idle);
 805         tlim = idle_time_limit - itime;
 806     }
 807     if (tlim <= 0) {
 808         /* link is idle: shut it down. */
 809         notice("Terminating connection due to lack of activity.");
 810         lcp_close(0, "Link inactive");
 811         need_holdoff = 0;
 812         status = EXIT_IDLE_TIMEOUT;
 813         // brcm
 814         redisconn = 0;
 815         sprintf(oldsession, "%s", "");
 816     } else {
 817         TIMEOUT(check_idle, NULL, tlim);
 818     }
 819 }
 820
 821 // brcm
 822 int link_up()
 823 {
 824 /*
 825     FILE * fd = NULL;
 826     if ((fd=fopen("/var/run/wanup", "r"))) {
 827         fclose(fd);
 828         return 1;
 829     }
 830     else
 831         return 0;
 832 */
 833     FILE * fd = NULL;
 834     char path[128]="";
 835     char data[8];
 836
 837     sprintf(path, "%s/%s/%s", "/proc/var/fyi/wan", session_path, "wanup");
 838     //printf("=== %s ===\n", path);
 839
 840     if (fd=fopen(path, "r")) {
 841         fgets(data, 8, fd);
 842         fclose(fd);
 843         //printf("data=%x\n", data[0]);
 844         if (strstr(data, "1"))
 845             return 1;
 846         else
 847             return 0;
 848         return 1;
 849     }
 850     else
 851         return 0;
 852 }
 853
 854
 855 // brcm
 856 static void
 857 check_link(arg)
 858     void *arg;
 859 {
 860     if (!link_up()) {
 861         /* link is idle: shut it down. */
 862         notice("Terminating connection due to link down.");
 863         lcp_close(0, "Link down");
 864         need_holdoff = 0;
 865         status = EXIT_IDLE_TIMEOUT;
 866     } else {
 867         UNTIMEOUT(check_link, NULL);
 868         TIMEOUT(check_link, NULL, 3);
 869     }
 870 }
 871
 872 int lan_pending_cur=0;
 873 int lan_pending_max=36;
 874 int lan_state=0;
 875
 876
 877 int lan_link_up()
 878 {
 879     FILE * fd = NULL;
 880     if ((fd=fopen("/var/run/ethup", "r"))) {
 881         fclose(fd);
 882         lan_state=1;
 883         return 1;
 884     }
 885     else if ((fd=fopen("/var/run/usbup", "r"))) {
 886         fclose(fd);
 887         lan_state=1;
 888         return 1;
 889     }
 890     else {
 891         lan_state=0;
 892         return 0;
 893     }
 894 }
 895
 896
 897 static void
 898 check_lan_link(arg)
 899     void *arg;
 900 {
 901     if (!lan_link_up()) {
 902         lan_pending_cur++;
 903         //printf("LAN link down %d ....\n", lan_pending_cur);
 904         if (lan_pending_cur >= lan_pending_max) {
 905             /* link is idle: shut it down. */
 906             lan_pending_cur=0;
 907             notice("Terminating connection due to link down.");
 908             lcp_close(0, "Link down");
 909             need_holdoff = 0;
 910             status = EXIT_IDLE_TIMEOUT;
 911         }
 912         UNTIMEOUT(check_lan_link, NULL);
 913         TIMEOUT(check_lan_link, NULL, 5);
 914     } else {
 915         //printf("LAN link up ....\n");
 916         lan_pending_cur=0;
 917         UNTIMEOUT(check_lan_link, NULL);
 918         TIMEOUT(check_lan_link, NULL, 5);
 919     }
 920 }
 921
 922 /*
 923  * connect_time_expired - log a message and close the connection.
 924  */
 925 static void
 926 connect_time_expired(arg)
 927     void *arg;
 928 {
 929     info("Connect time expired");
 930     lcp_close(0, "Connect time expired");       /* Close connection */
 931     status = EXIT_CONNECT_TIME;
 932 }
 933
 934 /*
 935  * auth_check_options - called to check authentication options.
 936  */
 937 void
 938 auth_check_options()
 939 {
 940     lcp_options *wo = &lcp_wantoptions[0];
 941     int can_auth;
 942     int lacks_ip;
 943
 944     /* Default our_name to hostname, and user to our_name */
 945     if (our_name[0] == 0 || usehostname)
 946         strlcpy(our_name, hostname, sizeof(our_name));
 947     if (user[0] == 0)
 948         strlcpy(user, our_name, sizeof(user));
 949
 950     /*
 951      * If we have a default route, require the peer to authenticate
 952      * unless the noauth option was given or the real user is root.
 953      */
 954     if (!auth_required && !allow_any_ip && have_route_to(0) && !privileged) {
 955         auth_required = 1;
 956         default_auth = 1;
 957     }
 958
 959     /* If authentication is required, ask peer for CHAP or PAP. */
 960     if (auth_required) {
 961         allow_any_ip = 0;
 962         if (!wo->neg_chap && !wo->neg_upap) {
 963             wo->neg_chap = 1;
 964             wo->neg_upap = 1;
 965         }
 966     } else {
 967         wo->neg_chap = 0;
 968         wo->neg_upap = 0;
 969     }
 970
 971     /*
 972      * Check whether we have appropriate secrets to use
 973      * to authenticate the peer.
 974      */
 975     lacks_ip = 0;
 976     can_auth = wo->neg_upap && (uselogin || have_pap_secret(&lacks_ip));
 977     if (!can_auth && wo->neg_chap) {
 978         can_auth = have_chap_secret((explicit_remote? remote_name: NULL),
 979                                     our_name, 1, &lacks_ip);
 980     }
 981
 982     if (auth_required && !can_auth && noauth_addrs == NULL) {
 983         if (default_auth) {
 984             option_error(
 985 "By default the remote system is required to authenticate itself");
 986             option_error(
 987 "(because this system has a default route to the internet)");
 988         } else if (explicit_remote)
 989             option_error(
 990 "The remote system (%s) is required to authenticate itself",
 991                          remote_name);
 992         else
 993             option_error(
 994 "The remote system is required to authenticate itself");
 995         option_error(
 996 "but I couldn't find any suitable secret (password) for it to use to do so.");
 997         if (lacks_ip)
 998             option_error(
 999 "(None of the available passwords would let it use an IP address.)");
1000
1001         exit(1);
1002     }
1003 }
1004
1005 /*
1006  * auth_reset - called when LCP is starting negotiations to recheck
1007  * authentication options, i.e. whether we have appropriate secrets
1008  * to use for authenticating ourselves and/or the peer.
1009  */
1010 void
1011 auth_reset(unit)
1012     int unit;
1013 {
1014     lcp_options *go = &lcp_gotoptions[unit];
1015     lcp_options *ao = &lcp_allowoptions[0];
1016
1017     ao->neg_upap = !refuse_pap && (passwd[0] != 0 || get_pap_passwd(NULL));
1018     ao->neg_chap = !refuse_chap
1019         && (passwd[0] != 0
1020             || have_chap_secret(user, (explicit_remote? remote_name: NULL),
1021                                 0, NULL));
1022
1023     if (go->neg_upap && !uselogin && !have_pap_secret(NULL))
1024         go->neg_upap = 0;
1025     if (go->neg_chap) {
1026         if (!have_chap_secret((explicit_remote? remote_name: NULL),
1027                               our_name, 1, NULL))
1028             go->neg_chap = 0;
1029     }
1030 }
1031
1032
1033 /*
1034  * check_passwd - Check the user name and passwd against the PAP secrets
1035  * file.  If requested, also check against the system password database,
1036  * and login the user if OK.
1037  *
1038  * returns:
1039  *      UPAP_AUTHNAK: Authentication failed.
1040  *      UPAP_AUTHACK: Authentication succeeded.
1041  * In either case, msg points to an appropriate message.
1042  */
1043 int
1044 check_passwd(unit, auser, userlen, apasswd, passwdlen, msg)
1045     int unit;
1046     char *auser;
1047     int userlen;
1048     char *apasswd;
1049     int passwdlen;
1050     char **msg;
1051 {
1052     int ret;
1053     char *filename;
1054     FILE *f;
1055     struct wordlist *addrs = NULL, *opts = NULL;
1056     char passwd[256], user[256];
1057     char secret[MAXWORDLEN];
1058     static int attempts = 0;
1059
1060     /*
1061      * Make copies of apasswd and auser, then null-terminate them.
1062      * If there are unprintable characters in the password, make
1063      * them visible.
1064      */
1065     slprintf(passwd, sizeof(passwd), "%.*v", passwdlen, apasswd);
1066     slprintf(user, sizeof(user), "%.*v", userlen, auser);
1067     *msg = "";
1068
1069     /*
1070      * Check if a plugin wants to handle this.
1071      */
1072     if (pap_auth_hook) {
1073         ret = (*pap_auth_hook)(user, passwd, msg, &addrs, &opts);
1074         if (ret >= 0) {
1075             if (ret)
1076                 set_allowed_addrs(unit, addrs, opts);
1077             BZERO(passwd, sizeof(passwd));
1078             if (addrs != 0)
1079                 free_wordlist(addrs);
1080             return ret? UPAP_AUTHACK: UPAP_AUTHNAK;
1081         }
1082     }
1083
1084     /*
1085      * Open the file of pap secrets and scan for a suitable secret
1086      * for authenticating this user.
1087      */
1088     filename = _PATH_UPAPFILE;
1089     addrs = opts = NULL;
1090     ret = UPAP_AUTHNAK;
1091     f = fopen(filename, "r");
1092     if (f == NULL) {
1093         error("Can't open PAP password file %s: %m", filename);
1094
1095     } else {
1096         check_access(f, filename);
1097         if (scan_authfile(f, user, our_name, secret, &addrs, &opts, filename) < 0) {
1098             warn("no PAP secret found for %s", user);
1099         } else {
1100             /*
1101              * If the secret is "@login", it means to check
1102              * the password against the login database.
1103              */
1104             int login_secret = strcmp(secret, "@login") == 0;
1105             ret = UPAP_AUTHACK;
1106             if (uselogin || login_secret) {
1107                 /* login option or secret is @login */
1108                 ret = plogin(user, passwd, msg);
1109                 if (ret == UPAP_AUTHNAK)
1110                     warn("PAP login failure for %s", user);
1111                 else
1112                     used_login = 1;
1113             }
1114             if (secret[0] != 0 && !login_secret) {
1115                 /* password given in pap-secrets - must match */
1116                 if ((cryptpap || strcmp(passwd, secret) != 0)
1117                     && strcmp(crypt(passwd, secret), secret) != 0) {
1118                     ret = UPAP_AUTHNAK;
1119                     warn("PAP authentication failure for %s", user);
1120                 }
1121             }
1122         }
1123         fclose(f);
1124     }
1125
1126     if (ret == UPAP_AUTHNAK) {
1127         if (**msg == 0)
1128             *msg = "Login incorrect";
1129         /*
1130          * XXX can we ever get here more than once??
1131          * Frustrate passwd stealer programs.
1132          * Allow 10 tries, but start backing off after 3 (stolen from login).
1133          * On 10'th, drop the connection.
1134          */
1135         if (attempts++ >= 10) {
1136             warn("%d LOGIN FAILURES ON %s, %s", attempts, devnam, user);
1137             lcp_close(unit, "login failed");
1138         }
1139         if (attempts > 3)
1140             sleep((u_int) (attempts - 3) * 5);
1141         if (opts != NULL)
1142             free_wordlist(opts);
1143
1144     } else {
1145         attempts = 0;                   /* Reset count */
1146         if (**msg == 0)
1147             *msg = "Login ok";
1148         set_allowed_addrs(unit, addrs, opts);
1149     }
1150
1151     if (addrs != NULL)
1152         free_wordlist(addrs);
1153     BZERO(passwd, sizeof(passwd));
1154     BZERO(secret, sizeof(secret));
1155
1156     return ret;
1157 }
1158
1159 /*
1160  * This function is needed for PAM.
1161  */
1162
1163 #ifdef USE_PAM
1164 /* Static variables used to communicate between the conversation function
1165  * and the server_login function
1166  */
1167 static char *PAM_username;
1168 static char *PAM_password;
1169 static int PAM_error = 0;
1170 static pam_handle_t *pamh = NULL;
1171
1172 /* PAM conversation function
1173  * Here we assume (for now, at least) that echo on means login name, and
1174  * echo off means password.
1175  */
1176
1177 static int PAM_conv (int num_msg, const struct pam_message **msg,
1178                     struct pam_response **resp, void *appdata_ptr)
1179 {
1180     int replies = 0;
1181     struct pam_response *reply = NULL;
1182
1183 #define COPY_STRING(s) (s) ? strdup(s) : NULL
1184
1185     reply = malloc(sizeof(struct pam_response) * num_msg);
1186     if (!reply) return PAM_CONV_ERR;
1187
1188     for (replies = 0; replies < num_msg; replies++) {
1189         switch (msg[replies]->msg_style) {
1190             case PAM_PROMPT_ECHO_ON:
1191                 reply[replies].resp_retcode = PAM_SUCCESS;
1192                 reply[replies].resp = COPY_STRING(PAM_username);
1193                 /* PAM frees resp */
1194                 break;
1195             case PAM_PROMPT_ECHO_OFF:
1196                 reply[replies].resp_retcode = PAM_SUCCESS;
1197                 reply[replies].resp = COPY_STRING(PAM_password);
1198                 /* PAM frees resp */
1199                 break;
1200             case PAM_TEXT_INFO:
1201                 /* fall through */
1202             case PAM_ERROR_MSG:
1203                 /* ignore it, but pam still wants a NULL response... */
1204                 reply[replies].resp_retcode = PAM_SUCCESS;
1205                 reply[replies].resp = NULL;
1206                 break;
1207             default:
1208                 /* Must be an error of some sort... */
1209                 free (reply);
1210                 PAM_error = 1;
1211                 return PAM_CONV_ERR;
1212         }
1213     }
1214     *resp = reply;
1215     return PAM_SUCCESS;
1216 }
1217
1218 static struct pam_conv PAM_conversation = {
1219     &PAM_conv,
1220     NULL
1221 };
1222 #endif  /* USE_PAM */
1223
1224 /*
1225  * plogin - Check the user name and password against the system
1226  * password database, and login the user if OK.
1227  *
1228  * returns:
1229  *      UPAP_AUTHNAK: Login failed.
1230  *      UPAP_AUTHACK: Login succeeded.
1231  * In either case, msg points to an appropriate message.
1232  */
1233
1234 static int
1235 plogin(user, passwd, msg)
1236     char *user;
1237     char *passwd;
1238     char **msg;
1239 {
1240     char *tty;
1241
1242 #ifdef USE_PAM
1243     int pam_error;
1244
1245     pam_error = pam_start ("ppp", user, &PAM_conversation, &pamh);
1246     if (pam_error != PAM_SUCCESS) {
1247         *msg = (char *) pam_strerror (pamh, pam_error);
1248         reopen_log();
1249         return UPAP_AUTHNAK;
1250     }
1251     /*
1252      * Define the fields for the credential validation
1253      */
1254
1255     PAM_username = user;
1256     PAM_password = passwd;
1257     PAM_error = 0;
1258     pam_set_item (pamh, PAM_TTY, devnam); /* this might be useful to some modules */
1259
1260     /*
1261      * Validate the user
1262      */
1263     pam_error = pam_authenticate (pamh, PAM_SILENT);
1264     if (pam_error == PAM_SUCCESS && !PAM_error) {
1265         pam_error = pam_acct_mgmt (pamh, PAM_SILENT);
1266         if (pam_error == PAM_SUCCESS)
1267             pam_open_session (pamh, PAM_SILENT);
1268     }
1269
1270     *msg = (char *) pam_strerror (pamh, pam_error);
1271
1272     /*
1273      * Clean up the mess
1274      */
1275     reopen_log();       /* apparently the PAM stuff does closelog() */
1276     PAM_username = NULL;
1277     PAM_password = NULL;
1278     if (pam_error != PAM_SUCCESS)
1279         return UPAP_AUTHNAK;
1280 #else /* #ifdef USE_PAM */
1281
1282 /*
1283  * Use the non-PAM methods directly
1284  */
1285
1286 #ifdef HAS_SHADOW
1287     struct spwd *spwd;
1288     struct spwd *getspnam();
1289 #endif
1290     struct passwd *pw = getpwnam(user);
1291
1292     endpwent();
1293     if (pw == NULL)
1294         return (UPAP_AUTHNAK);
1295
1296 #ifdef HAS_SHADOW
1297     spwd = getspnam(user);
1298     endspent();
1299     if (spwd) {
1300         /* check the age of the password entry */
1301         long now = time(NULL) / 86400L;
1302
1303         if ((spwd->sp_expire > 0 && now >= spwd->sp_expire)
1304             || ((spwd->sp_max >= 0 && spwd->sp_max < 10000)
1305                 && spwd->sp_lstchg >= 0
1306                 && now >= spwd->sp_lstchg + spwd->sp_max)) {
1307             warn("Password for %s has expired", user);
1308             return (UPAP_AUTHNAK);
1309         }
1310         pw->pw_passwd = spwd->sp_pwdp;
1311     }
1312 #endif
1313
1314     /*
1315      * If no passwd, don't let them login.
1316      */
1317     if (pw->pw_passwd == NULL || strlen(pw->pw_passwd) < 2
1318         || strcmp(crypt(passwd, pw->pw_passwd), pw->pw_passwd) != 0)
1319         return (UPAP_AUTHNAK);
1320
1321 #endif /* #ifdef USE_PAM */
1322
1323     /*
1324      * Write a wtmp entry for this user.
1325      */
1326
1327     tty = devnam;
1328     if (strncmp(tty, "/dev/", 5) == 0)
1329         tty += 5;
1330     logwtmp(tty, user, remote_name);            /* Add wtmp login entry */
1331
1332 #if defined(_PATH_LASTLOG) && !defined(USE_PAM)
1333     if (pw != (struct passwd *)NULL) {
1334             struct lastlog ll;
1335             int fd;
1336
1337             if ((fd = open(_PATH_LASTLOG, O_RDWR, 0)) >= 0) {
1338                 (void)lseek(fd, (off_t)(pw->pw_uid * sizeof(ll)), SEEK_SET);
1339                 memset((void *)&ll, 0, sizeof(ll));
1340                 (void)time(&ll.ll_time);
1341                 (void)strncpy(ll.ll_line, tty, sizeof(ll.ll_line));
1342                 (void)write(fd, (char *)&ll, sizeof(ll));
1343                 (void)close(fd);
1344             }
1345     }
1346 #endif /* _PATH_LASTLOG and not USE_PAM */
1347
1348     info("user %s logged in", user);
1349     logged_in = 1;
1350
1351     return (UPAP_AUTHACK);
1352 }
1353
1354 /*
1355  * plogout - Logout the user.
1356  */
1357 static void
1358 plogout()
1359 {
1360 #ifdef USE_PAM
1361     int pam_error;
1362
1363     if (pamh != NULL) {
1364         pam_error = pam_close_session (pamh, PAM_SILENT);
1365         pam_end (pamh, pam_error);
1366         pamh = NULL;
1367     }
1368     /* Apparently the pam stuff does closelog(). */
1369     reopen_log();
1370 #else /* ! USE_PAM */
1371     char *tty;
1372
1373     tty = devnam;
1374     if (strncmp(tty, "/dev/", 5) == 0)
1375         tty += 5;
1376     logwtmp(tty, "", "");               /* Wipe out utmp logout entry */
1377 #endif /* ! USE_PAM */
1378     logged_in = 0;
1379 }
1380
1381
1382 /*
1383  * null_login - Check if a username of "" and a password of "" are
1384  * acceptable, and iff so, set the list of acceptable IP addresses
1385  * and return 1.
1386  */
1387 static int
1388 null_login(unit)
1389     int unit;
1390 {
1391     char *filename;
1392     FILE *f;
1393     int i, ret;
1394     struct wordlist *addrs, *opts;
1395     char secret[MAXWORDLEN];
1396
1397     /*
1398      * Open the file of pap secrets and scan for a suitable secret.
1399      */
1400     filename = _PATH_UPAPFILE;
1401     addrs = NULL;
1402     f = fopen(filename, "r");
1403     if (f == NULL)
1404         return 0;
1405     check_access(f, filename);
1406
1407     i = scan_authfile(f, "", our_name, secret, &addrs, &opts, filename);
1408     ret = i >= 0 && secret[0] == 0;
1409     BZERO(secret, sizeof(secret));
1410
1411     if (ret)
1412         set_allowed_addrs(unit, addrs, opts);
1413     else if (opts != 0)
1414         free_wordlist(opts);
1415     if (addrs != 0)
1416         free_wordlist(addrs);
1417
1418     fclose(f);
1419     return ret;
1420 }
1421
1422
1423 /*
1424  * get_pap_passwd - get a password for authenticating ourselves with
1425  * our peer using PAP.  Returns 1 on success, 0 if no suitable password
1426  * could be found.
1427  * Assumes passwd points to MAXSECRETLEN bytes of space (if non-null).
1428  */
1429 static int
1430 get_pap_passwd(passwd)
1431     char *passwd;
1432 {
1433     char *filename;
1434     FILE *f;
1435     int ret;
1436     char secret[MAXWORDLEN];
1437
1438     /*
1439      * Check whether a plugin wants to supply this.
1440      */
1441     if (pap_passwd_hook) {
1442         ret = (*pap_passwd_hook)(user, passwd);
1443         if (ret >= 0)
1444             return ret;
1445     }
1446
1447     filename = _PATH_UPAPFILE;
1448     f = fopen(filename, "r");
1449     if (f == NULL)
1450         return 0;
1451     check_access(f, filename);
1452     ret = scan_authfile(f, user,
1453                         (remote_name[0]? remote_name: NULL),
1454                         secret, NULL, NULL, filename);
1455     fclose(f);
1456     if (ret < 0)
1457         return 0;
1458     if (passwd != NULL)
1459         strlcpy(passwd, secret, MAXSECRETLEN);
1460     BZERO(secret, sizeof(secret));
1461     return 1;
1462 }
1463
1464
1465 /*
1466  * have_pap_secret - check whether we have a PAP file with any
1467  * secrets that we could possibly use for authenticating the peer.
1468  */
1469 static int
1470 have_pap_secret(lacks_ipp)
1471     int *lacks_ipp;
1472 {
1473     FILE *f;
1474     int ret;
1475     char *filename;
1476     struct wordlist *addrs;
1477
1478     /* let the plugin decide, if there is one */
1479     if (pap_check_hook) {
1480         ret = (*pap_check_hook)();
1481         if (ret >= 0)
1482             return ret;
1483     }
1484
1485     filename = _PATH_UPAPFILE;
1486     f = fopen(filename, "r");
1487     if (f == NULL)
1488         return 0;
1489
1490     ret = scan_authfile(f, (explicit_remote? remote_name: NULL), our_name,
1491                         NULL, &addrs, NULL, filename);
1492     fclose(f);
1493     if (ret >= 0 && !some_ip_ok(addrs)) {
1494         if (lacks_ipp != 0)
1495             *lacks_ipp = 1;
1496         ret = -1;
1497     }
1498     if (addrs != 0)
1499         free_wordlist(addrs);
1500
1501     return ret >= 0;
1502 }
1503
1504
1505 /*
1506  * have_chap_secret - check whether we have a CHAP file with a
1507  * secret that we could possibly use for authenticating `client'
1508  * on `server'.  Either can be the null string, meaning we don't
1509  * know the identity yet.
1510  */
1511 static int
1512 have_chap_secret(client, server, need_ip, lacks_ipp)
1513     char *client;
1514     char *server;
1515     int need_ip;
1516     int *lacks_ipp;
1517 {
1518     FILE *f;
1519     int ret;
1520     char *filename;
1521     struct wordlist *addrs;
1522
1523     filename = _PATH_CHAPFILE;
1524     f = fopen(filename, "r");
1525     if (f == NULL)
1526         return 0;
1527
1528     if (client != NULL && client[0] == 0)
1529         client = NULL;
1530     else if (server != NULL && server[0] == 0)
1531         server = NULL;
1532
1533     ret = scan_authfile(f, client, server, NULL, &addrs, NULL, filename);
1534     fclose(f);
1535     if (ret >= 0 && need_ip && !some_ip_ok(addrs)) {
1536         if (lacks_ipp != 0)
1537             *lacks_ipp = 1;
1538         ret = -1;
1539     }
1540     if (addrs != 0)
1541         free_wordlist(addrs);
1542
1543     return ret >= 0;
1544 }
1545
1546
1547 /*
1548  * get_secret - open the CHAP secret file and return the secret
1549  * for authenticating the given client on the given server.
1550  * (We could be either client or server).
1551  */
1552 int
1553 get_secret(unit, client, server, secret, secret_len, am_server)
1554     int unit;
1555     char *client;
1556     char *server;
1557     char *secret;
1558     int *secret_len;
1559     int am_server;
1560 {
1561     FILE *f;
1562     int ret, len;
1563     char *filename;
1564     struct wordlist *addrs, *opts;
1565     char secbuf[MAXWORDLEN];
1566
1567     if (!am_server && passwd[0] != 0) {
1568         strlcpy(secbuf, passwd, sizeof(secbuf));
1569     } else {
1570         filename = _PATH_CHAPFILE;
1571         addrs = NULL;
1572         secbuf[0] = 0;
1573
1574         f = fopen(filename, "r");
1575         if (f == NULL) {
1576             error("Can't open chap secret file %s: %m", filename);
1577             return 0;
1578         }
1579         check_access(f, filename);
1580
1581         ret = scan_authfile(f, client, server, secbuf, &addrs, &opts, filename);
1582         fclose(f);
1583         if (ret < 0)
1584             return 0;
1585
1586         if (am_server)
1587             set_allowed_addrs(unit, addrs, opts);
1588         else if (opts != 0)
1589             free_wordlist(opts);
1590         if (addrs != 0)
1591             free_wordlist(addrs);
1592     }
1593
1594     len = strlen(secbuf);
1595     if (len > MAXSECRETLEN) {
1596         error("Secret for %s on %s is too long", client, server);
1597         len = MAXSECRETLEN;
1598     }
1599     BCOPY(secbuf, secret, len);
1600     BZERO(secbuf, sizeof(secbuf));
1601     *secret_len = len;
1602
1603     return 1;
1604 }
1605
1606 /*
1607  * set_allowed_addrs() - set the list of allowed addresses.
1608  * Also looks for `--' indicating options to apply for this peer
1609  * and leaves the following words in extra_options.
1610  */
1611 static void
1612 set_allowed_addrs(unit, addrs, opts)
1613     int unit;
1614     struct wordlist *addrs;
1615     struct wordlist *opts;
1616 {
1617     int n;
1618     struct wordlist *ap, **plink;
1619     struct permitted_ip *ip;
1620     char *ptr_word, *ptr_mask;
1621     struct hostent *hp;
1622     struct netent *np;
1623     u_int32_t a, mask, ah, offset;
1624     struct ipcp_options *wo = &ipcp_wantoptions[unit];
1625     u_int32_t suggested_ip = 0;
1626
1627     if (addresses[unit] != NULL)
1628         free(addresses[unit]);
1629     addresses[unit] = NULL;
1630     if (extra_options != NULL)
1631         free_wordlist(extra_options);
1632     extra_options = opts;
1633
1634     /*
1635      * Count the number of IP addresses given.
1636      */
1637     n = wordlist_count(addrs) + wordlist_count(noauth_addrs);
1638     if (n == 0)
1639         return;
1640     ip = (struct permitted_ip *) malloc((n + 1) * sizeof(struct permitted_ip));
1641     if (ip == 0)
1642         return;
1643
1644     /* temporarily append the noauth_addrs list to addrs */
1645     for (plink = &addrs; *plink != NULL; plink = &(*plink)->next)
1646         ;
1647     *plink = noauth_addrs;
1648
1649     n = 0;
1650     for (ap = addrs; ap != NULL; ap = ap->next) {
1651         /* "-" means no addresses authorized, "*" means any address allowed */
1652         ptr_word = ap->word;
1653         if (strcmp(ptr_word, "-") == 0)
1654             break;
1655         if (strcmp(ptr_word, "*") == 0) {
1656             ip[n].permit = 1;
1657             ip[n].base = ip[n].mask = 0;
1658             ++n;
1659             break;
1660         }
1661
1662         ip[n].permit = 1;
1663         if (*ptr_word == '!') {
1664             ip[n].permit = 0;
1665             ++ptr_word;
1666         }
1667
1668         mask = ~ (u_int32_t) 0;
1669         offset = 0;
1670         ptr_mask = strchr (ptr_word, '/');
1671         if (ptr_mask != NULL) {
1672             int bit_count;
1673             char *endp;
1674
1675             bit_count = (int) strtol (ptr_mask+1, &endp, 10);
1676             if (bit_count <= 0 || bit_count > 32) {
1677                 warn("invalid address length %v in auth. address list",
1678                      ptr_mask+1);
1679                 continue;
1680             }
1681             bit_count = 32 - bit_count; /* # bits in host part */
1682             if (*endp == '+') {
1683                 offset = ifunit + 1;
1684                 ++endp;
1685             }
1686             if (*endp != 0) {
1687                 warn("invalid address length syntax: %v", ptr_mask+1);
1688                 continue;
1689             }
1690             *ptr_mask = '\0';
1691             mask <<= bit_count;
1692         }
1693
1694         hp = gethostbyname(ptr_word);
1695         if (hp != NULL && hp->h_addrtype == AF_INET) {
1696             a = *(u_int32_t *)hp->h_addr;
1697         } else {
1698             np = getnetbyname (ptr_word);
1699             if (np != NULL && np->n_addrtype == AF_INET) {
1700                 a = htonl (*(u_int32_t *)np->n_net);
1701                 if (ptr_mask == NULL) {
1702                     /* calculate appropriate mask for net */
1703                     ah = ntohl(a);
1704                     if (IN_CLASSA(ah))
1705                         mask = IN_CLASSA_NET;
1706                     else if (IN_CLASSB(ah))
1707                         mask = IN_CLASSB_NET;
1708                     else if (IN_CLASSC(ah))
1709                         mask = IN_CLASSC_NET;
1710                 }
1711             } else {
1712                 a = inet_addr (ptr_word);
1713             }
1714         }
1715
1716         if (ptr_mask != NULL)
1717             *ptr_mask = '/';
1718
1719         if (a == (u_int32_t)-1L) {
1720             warn("unknown host %s in auth. address list", ap->word);
1721             continue;
1722         }
1723         if (offset != 0) {
1724             if (offset >= ~mask) {
1725                 warn("interface unit %d too large for subnet %v",
1726                      ifunit, ptr_word);
1727                 continue;
1728             }
1729             a = htonl((ntohl(a) & mask) + offset);
1730             mask = ~(u_int32_t)0;
1731         }
1732         ip[n].mask = htonl(mask);
1733         ip[n].base = a & ip[n].mask;
1734         ++n;
1735         if (~mask == 0 && suggested_ip == 0)
1736             suggested_ip = a;
1737     }
1738     *plink = NULL;
1739
1740     ip[n].permit = 0;           /* make the last entry forbid all addresses */
1741     ip[n].base = 0;             /* to terminate the list */
1742     ip[n].mask = 0;
1743
1744     addresses[unit] = ip;
1745
1746     /*
1747      * If the address given for the peer isn't authorized, or if
1748      * the user hasn't given one, AND there is an authorized address
1749      * which is a single host, then use that if we find one.
1750      */
1751     if (suggested_ip != 0
1752         && (wo->hisaddr == 0 || !auth_ip_addr(unit, wo->hisaddr))) {
1753         wo->hisaddr = suggested_ip;
1754         /*
1755          * Do we insist on this address?  No, if there are other
1756          * addresses authorized than the suggested one.
1757          */
1758         if (n > 1)
1759             wo->accept_remote = 1;
1760     }
1761 }
1762
1763 /*
1764  * auth_ip_addr - check whether the peer is authorized to use
1765  * a given IP address.  Returns 1 if authorized, 0 otherwise.
1766  */
1767 int
1768 auth_ip_addr(unit, addr)
1769     int unit;
1770     u_int32_t addr;
1771 {
1772     int ok;
1773
1774     /* don't allow loopback or multicast address */
1775     if (bad_ip_adrs(addr))
1776         return 0;
1777
1778     if (addresses[unit] != NULL) {
1779         ok = ip_addr_check(addr, addresses[unit]);
1780         if (ok >= 0)
1781             return ok;
1782     }
1783     if (auth_required)
1784         return 0;               /* no addresses authorized */
1785     return allow_any_ip || privileged || !have_route_to(addr);
1786 }
1787
1788 static int
1789 ip_addr_check(addr, addrs)
1790     u_int32_t addr;
1791     struct permitted_ip *addrs;
1792 {
1793     for (; ; ++addrs)
1794         if ((addr & addrs->mask) == addrs->base)
1795             return addrs->permit;
1796 }
1797
1798 /*
1799  * bad_ip_adrs - return 1 if the IP address is one we don't want
1800  * to use, such as an address in the loopback net or a multicast address.
1801  * addr is in network byte order.
1802  */
1803 int
1804 bad_ip_adrs(addr)
1805     u_int32_t addr;
1806 {
1807     addr = ntohl(addr);
1808     return (addr >> IN_CLASSA_NSHIFT) == IN_LOOPBACKNET
1809         || IN_MULTICAST(addr) || IN_BADCLASS(addr);
1810 }
1811
1812 /*
1813  * some_ip_ok - check a wordlist to see if it authorizes any
1814  * IP address(es).
1815  */
1816 static int
1817 some_ip_ok(addrs)
1818     struct wordlist *addrs;
1819 {
1820     for (; addrs != 0; addrs = addrs->next) {
1821         if (addrs->word[0] == '-')
1822             break;
1823         if (addrs->word[0] != '!')
1824             return 1;           /* some IP address is allowed */
1825     }
1826     return 0;
1827 }
1828
1829 /*
1830  * check_access - complain if a secret file has too-liberal permissions.
1831  */
1832 static void
1833 check_access(f, filename)
1834     FILE *f;
1835     char *filename;
1836 {
1837     struct stat sbuf;
1838
1839     if (fstat(fileno(f), &sbuf) < 0) {
1840         warn("cannot stat secret file %s: %m", filename);
1841     } else if ((sbuf.st_mode & (S_IRWXG | S_IRWXO)) != 0) {
1842         warn("Warning - secret file %s has world and/or group access",
1843              filename);
1844     }
1845 }
1846
1847
1848 /*
1849  * scan_authfile - Scan an authorization file for a secret suitable
1850  * for authenticating `client' on `server'.  The return value is -1
1851  * if no secret is found, otherwise >= 0.  The return value has
1852  * NONWILD_CLIENT set if the secret didn't have "*" for the client, and
1853  * NONWILD_SERVER set if the secret didn't have "*" for the server.
1854  * Any following words on the line up to a "--" (i.e. address authorization
1855  * info) are placed in a wordlist and returned in *addrs.  Any
1856  * following words (extra options) are placed in a wordlist and
1857  * returned in *opts.
1858  * We assume secret is NULL or points to MAXWORDLEN bytes of space.
1859  */
1860 static int
1861 scan_authfile(f, client, server, secret, addrs, opts, filename)
1862     FILE *f;
1863     char *client;
1864     char *server;
1865     char *secret;
1866     struct wordlist **addrs;
1867     struct wordlist **opts;
1868     char *filename;
1869 {
1870     int newline, xxx;
1871     int got_flag, best_flag;
1872     FILE *sf;
1873     struct wordlist *ap, *addr_list, *alist, **app;
1874     char word[MAXWORDLEN];
1875     char atfile[MAXWORDLEN];
1876     char lsecret[MAXWORDLEN];
1877
1878     if (addrs != NULL)
1879         *addrs = NULL;
1880     if (opts != NULL)
1881         *opts = NULL;
1882     addr_list = NULL;
1883     if (!getword(f, word, &newline, filename))
1884         return -1;              /* file is empty??? */
1885     newline = 1;
1886     best_flag = -1;
1887     for (;;) {
1888         /*
1889          * Skip until we find a word at the start of a line.
1890          */
1891         while (!newline && getword(f, word, &newline, filename))
1892             ;
1893         if (!newline)
1894             break;              /* got to end of file */
1895
1896         /*
1897          * Got a client - check if it's a match or a wildcard.
1898          */
1899         got_flag = 0;
1900         if (client != NULL && strcmp(word, client) != 0 && !ISWILD(word)) {
1901             newline = 0;
1902             continue;
1903         }
1904         if (!ISWILD(word))
1905             got_flag = NONWILD_CLIENT;
1906
1907         /*
1908          * Now get a server and check if it matches.
1909          */
1910         if (!getword(f, word, &newline, filename))
1911             break;
1912         if (newline)
1913             continue;
1914         if (!ISWILD(word)) {
1915             if (server != NULL && strcmp(word, server) != 0)
1916                 continue;
1917             got_flag |= NONWILD_SERVER;
1918         }
1919
1920         /*
1921          * Got some sort of a match - see if it's better than what
1922          * we have already.
1923          */
1924         if (got_flag <= best_flag)
1925             continue;
1926
1927         /*
1928          * Get the secret.
1929          */
1930         if (!getword(f, word, &newline, filename))
1931             break;
1932         if (newline)
1933             continue;
1934
1935         if (secret != NULL) {
1936             /*
1937              * Special syntax: @/pathname means read secret from file.
1938              */
1939             if (word[0] == '@' && word[1] == '/') {
1940                 strlcpy(atfile, word+1, sizeof(atfile));
1941                 if ((sf = fopen(atfile, "r")) == NULL) {
1942                     warn("can't open indirect secret file %s", atfile);
1943                     continue;
1944                 }
1945                 check_access(sf, atfile);
1946                 if (!getword(sf, word, &xxx, atfile)) {
1947                     warn("no secret in indirect secret file %s", atfile);
1948                     fclose(sf);
1949                     continue;
1950                 }
1951                 fclose(sf);
1952             }
1953             strlcpy(lsecret, word, sizeof(lsecret));
1954         }
1955
1956         /*
1957          * Now read address authorization info and make a wordlist.
1958          */
1959         app = &alist;
1960         for (;;) {
1961             if (!getword(f, word, &newline, filename) || newline)
1962                 break;
1963             ap = (struct wordlist *)
1964                     malloc(sizeof(struct wordlist) + strlen(word) + 1);
1965             if (ap == NULL)
1966                 novm("authorized addresses");
1967             ap->word = (char *) (ap + 1);
1968             strcpy(ap->word, word);
1969             *app = ap;
1970             app = &ap->next;
1971         }
1972         *app = NULL;
1973
1974         /*
1975          * This is the best so far; remember it.
1976          */
1977         best_flag = got_flag;
1978         if (addr_list)
1979             free_wordlist(addr_list);
1980         addr_list = alist;
1981         if (secret != NULL)
1982             strlcpy(secret, lsecret, MAXWORDLEN);
1983
1984         if (!newline)
1985             break;
1986     }
1987
1988     /* scan for a -- word indicating the start of options */
1989     for (app = &addr_list; (ap = *app) != NULL; app = &ap->next)
1990         if (strcmp(ap->word, "--") == 0)
1991             break;
1992     /* ap = start of options */
1993     if (ap != NULL) {
1994         ap = ap->next;          /* first option */
1995         free(*app);                     /* free the "--" word */
1996         *app = NULL;            /* terminate addr list */
1997     }
1998     if (opts != NULL)
1999         *opts = ap;
2000     else if (ap != NULL)
2001         free_wordlist(ap);
2002     if (addrs != NULL)
2003         *addrs = addr_list;
2004     else if (addr_list != NULL)
2005         free_wordlist(addr_list);
2006
2007     return best_flag;
2008 }
2009
2010 /*
2011  * wordlist_count - return the number of items in a wordlist
2012  */
2013 static int
2014 wordlist_count(wp)
2015     struct wordlist *wp;
2016 {
2017     int n;
2018
2019     for (n = 0; wp != NULL; wp = wp->next)
2020         ++n;
2021     return n;
2022 }
2023
2024 /*
2025  * free_wordlist - release memory allocated for a wordlist.
2026  */
2027 static void
2028 free_wordlist(wp)
2029     struct wordlist *wp;
2030 {
2031     struct wordlist *next;
2032
2033     while (wp != NULL) {
2034         next = wp->next;
2035         free(wp);
2036         wp = next;
2037     }
2038 }
2039
2040 /*
2041  * auth_script_done - called when the auth-up or auth-down script
2042  * has finished.
2043  */
2044 static void
2045 auth_script_done(arg)
2046     void *arg;
2047 {
2048     auth_script_pid = 0;
2049     switch (auth_script_state) {
2050     case s_up:
2051         if (auth_state == s_down) {
2052             auth_script_state = s_down;
2053             auth_script(_PATH_AUTHDOWN);
2054         }
2055         break;
2056     case s_down:
2057         if (auth_state == s_up) {
2058             auth_script_state = s_up;
2059             auth_script(_PATH_AUTHUP);
2060         }
2061         break;
2062     }
2063 }
2064
2065 /*
2066  * auth_script - execute a script with arguments
2067  * interface-name peer-name real-user tty speed
2068  */
2069 static void
2070 auth_script(script)
2071     char *script;
2072 {
2073     char strspeed[32];
2074     struct passwd *pw;
2075     char struid[32];
2076     char *user_name;
2077     char *argv[8];
2078
2079     if ((pw = getpwuid(getuid())) != NULL && pw->pw_name != NULL)
2080         user_name = pw->pw_name;
2081     else {
2082         slprintf(struid, sizeof(struid), "%d", getuid());
2083         user_name = struid;
2084     }
2085     slprintf(strspeed, sizeof(strspeed), "%d", baud_rate);
2086
2087     argv[0] = script;
2088     argv[1] = ifname;
2089     argv[2] = peer_authname;
2090     argv[3] = user_name;
2091     argv[4] = devnam;
2092     argv[5] = strspeed;
2093     argv[6] = NULL;
2094
2095     auth_script_pid = run_program(script, argv, 0, auth_script_done, NULL);
2096 }