pppd/plugins/radius/radius.c

   1 /***********************************************************************
   2 *
   3 * radius.c
   4 *
   5 * RADIUS plugin for pppd.  Performs PAP and CHAP authentication using
   6 * RADIUS.
   7 *
   8 * Copyright (C) 2002 Roaring Penguin Software Inc.
   9 *
  10 * Based on a patch for ipppd, which is:
  11 *    Copyright (C) 1996, Matjaz Godec <gody@elgo.si>
  12 *    Copyright (C) 1996, Lars Fenneberg <in5y050@public.uni-hamburg.de>
  13 *    Copyright (C) 1997, Miguel A.L. Paraz <map@iphil.net>
  14 *
  15 * Uses radiusclient library, which is:
  16 *    Copyright (C) 1995,1996,1997,1998 Lars Fenneberg <lf@elemental.net>
  17 *    Copyright (C) 2002 Roaring Penguin Software Inc.
  18 *
  19 * This plugin may be distributed according to the terms of the GNU
  20 * General Public License, version 2 or (at your option) any later version.
  21 *
  22 ***********************************************************************/
  23 static char const RCSID[] =
  24 "$Id: radius.c,v 1.2 2002/02/08 17:28:31 dfs Exp $";
  25
  26 #include "pppd.h"
  27 #include "chap.h"
  28 #include "radiusclient.h"
  29 #include "fsm.h"
  30 #include "ipcp.h"
  31 #include <syslog.h>
  32 #include <sys/types.h>
  33 #include <sys/time.h>
  34
  35 #define BUF_LEN 1024
  36
  37 static char *config_file = NULL;
  38
  39 static option_t Options[] = {
  40     { "radius-config-file", o_string, &config_file },
  41     { NULL }
  42 };
  43
  44 static int radius_secret_check(void);
  45 static int radius_pap_auth(char *user,
  46                            char *passwd,
  47                            char **msgp,
  48                            struct wordlist **paddrs,
  49                            struct wordlist **popts);
  50 static int radius_chap_auth(char *user,
  51                             u_char *remmd,
  52                             int remmd_len,
  53                             chap_state *cstate);
  54
  55 static void radius_ip_up(void *opaque, int arg);
  56 static void radius_ip_down(void *opaque, int arg);
  57 static void make_username_realm(char *user);
  58 static int radius_setparams(VALUE_PAIR *vp, char *msg);
  59 static void radius_choose_ip(u_int32_t *addrp);
  60 static int radius_init(char *msg);
  61 static int get_client_port(char *ifname);
  62 static int radius_allowed_address(u_int32_t addr);
  63
  64 void (*radius_attributes_hook)(VALUE_PAIR *) = NULL;
  65 void (*radius_pre_auth_hook)(char const *user) = NULL;
  66
  67 #ifndef MAXSESSIONID
  68 #define MAXSESSIONID 32
  69 #endif
  70
  71 struct radius_state {
  72     int accounting_started;
  73     int initialized;
  74     int client_port;
  75     int choose_ip;
  76     int any_ip_addr_ok;
  77     int done_chap_once;
  78     u_int32_t ip_addr;
  79     char user[MAXNAMELEN];
  80     char config_file[MAXPATHLEN];
  81     char session_id[MAXSESSIONID + 1];
  82     time_t start_time;
  83 };
  84
  85 static struct radius_state rstate;
  86
  87 char pppd_version[] = VERSION;
  88
  89 /**********************************************************************
  90 * %FUNCTION: plugin_init
  91 * %ARGUMENTS:
  92 *  None
  93 * %RETURNS:
  94 *  Nothing
  95 * %DESCRIPTION:
  96 *  Initializes RADIUS plugin.
  97 ***********************************************************************/
  98 void
  99 plugin_init(void)
 100 {
 101     pap_check_hook = radius_secret_check;
 102     pap_auth_hook = radius_pap_auth;
 103
 104     chap_check_hook = radius_secret_check;
 105     chap_auth_hook = radius_chap_auth;
 106
 107     ip_choose_hook = radius_choose_ip;
 108     allowed_address_hook = radius_allowed_address;
 109
 110     add_notifier(&ip_up_notifier, radius_ip_up, NULL);
 111     add_notifier(&ip_down_notifier, radius_ip_down, NULL);
 112
 113     memset(&rstate, 0, sizeof(rstate));
 114
 115     strlcpy(rstate.config_file, "/etc/radiusclient/radiusclient.conf",
 116             sizeof(rstate.config_file));
 117
 118     add_options(Options);
 119
 120     info("RADIUS plugin initialized.");
 121 }
 122
 123 /**********************************************************************
 124 * %FUNCTION: radius_secret_check
 125 * %ARGUMENTS:
 126 *  None
 127 * %RETURNS:
 128 *  1 -- we are ALWAYS willing to supply a secret. :-)
 129 * %DESCRIPTION:
 130 * Tells pppd that we will try to authenticate the peer, and not to
 131 * worry about looking in /etc/ppp/*-secrets
 132 ***********************************************************************/
 133 static int
 134 radius_secret_check(void)
 135 {
 136     return 1;
 137 }
 138
 139 /**********************************************************************
 140 * %FUNCTION: radius_choose_ip
 141 * %ARGUMENTS:
 142 *  addrp -- where to store the IP address
 143 * %RETURNS:
 144 *  Nothing
 145 * %DESCRIPTION:
 146 *  If RADIUS server has specified an IP address, it is stored in *addrp.
 147 ***********************************************************************/
 148 static void
 149 radius_choose_ip(u_int32_t *addrp)
 150 {
 151     if (rstate.choose_ip) {
 152         *addrp = rstate.ip_addr;
 153     }
 154 }
 155
 156 /**********************************************************************
 157 * %FUNCTION: radius_pap_auth
 158 * %ARGUMENTS:
 159 *  user -- user-name of peer
 160 *  passwd -- password supplied by peer
 161 *  msgp -- Message which will be sent in PAP response
 162 *  paddrs -- set to a list of possible peer IP addresses
 163 *  popts -- set to a list of additional pppd options
 164 * %RETURNS:
 165 *  1 if we can authenticate, -1 if we cannot.
 166 * %DESCRIPTION:
 167 * Performs PAP authentication using RADIUS
 168 ***********************************************************************/
 169 static int
 170 radius_pap_auth(char *user,
 171                 char *passwd,
 172                 char **msgp,
 173                 struct wordlist **paddrs,
 174                 struct wordlist **popts)
 175 {
 176     VALUE_PAIR *send, *received;
 177     UINT4 av_type;
 178     int result;
 179     static char radius_msg[BUF_LEN];
 180
 181     radius_msg[0] = 0;
 182     *msgp = radius_msg;
 183
 184     if (radius_init(radius_msg) < 0) {
 185         return 0;
 186     }
 187
 188     /* Put user with potentially realm added in rstate.user */
 189     make_username_realm(user);
 190
 191     if (radius_pre_auth_hook) {
 192         radius_pre_auth_hook(rstate.user);
 193     }
 194
 195     send = NULL;
 196     received = NULL;
 197
 198     /* Hack... the "port" is the ppp interface number.  Should really be
 199        the tty */
 200     rstate.client_port = get_client_port(ifname);
 201
 202     av_type = PW_FRAMED;
 203     rc_avpair_add(&send, PW_SERVICE_TYPE, &av_type, 0, VENDOR_NONE);
 204
 205     av_type = PW_PPP;
 206     rc_avpair_add(&send, PW_FRAMED_PROTOCOL, &av_type, 0, VENDOR_NONE);
 207
 208     rc_avpair_add(&send, PW_USER_NAME, rstate.user , 0, VENDOR_NONE);
 209     rc_avpair_add(&send, PW_USER_PASSWORD, passwd, 0, VENDOR_NONE);
 210     if (*remote_number) {
 211         rc_avpair_add(&send, PW_CALLING_STATION_ID, remote_number, 0,
 212                        VENDOR_NONE);
 213     }
 214
 215     result = rc_auth(rstate.client_port, send, &received, radius_msg);
 216
 217     if (result == OK_RC) {
 218         if (radius_setparams(received, radius_msg) < 0) {
 219             result = ERROR_RC;
 220         }
 221     }
 222
 223     /* free value pairs */
 224     rc_avpair_free(received);
 225     rc_avpair_free(send);
 226
 227     return (result == OK_RC) ? 1 : 0;
 228 }
 229
 230 /**********************************************************************
 231 * %FUNCTION: radius_chap_auth
 232 * %ARGUMENTS:
 233 *  user -- user-name of peer
 234 *  remmd -- hash received from peer
 235 *  remmd_len -- length of remmd
 236 *  cstate -- pppd's chap_state structure
 237 * %RETURNS:
 238 *  CHAP_SUCCESS if we can authenticate, CHAP_FAILURE if we cannot.
 239 * %DESCRIPTION:
 240 * Performs CHAP authentication using RADIUS
 241 ***********************************************************************/
 242 static int
 243 radius_chap_auth(char *user,
 244                  u_char *remmd,
 245                  int remmd_len,
 246                  chap_state *cstate)
 247 {
 248     VALUE_PAIR *send, *received;
 249     UINT4 av_type;
 250     static char radius_msg[BUF_LEN];
 251     int result;
 252     u_char cpassword[MD5_SIGNATURE_SIZE+1];
 253     radius_msg[0] = 0;
 254
 255     if (radius_init(radius_msg) < 0) {
 256         error("%s", radius_msg);
 257         return CHAP_FAILURE;
 258     }
 259
 260     /* we handle md5 digest at the moment */
 261     if (cstate->chal_type != CHAP_DIGEST_MD5) {
 262         error("RADIUS: Challenge type not MD5");
 263         return CHAP_FAILURE;
 264     }
 265
 266     /* Put user with potentially realm added in rstate.user */
 267     if (!rstate.done_chap_once) {
 268         make_username_realm(user);
 269         rstate.client_port = get_client_port (ifname);
 270         if (radius_pre_auth_hook) {
 271             radius_pre_auth_hook(rstate.user);
 272         }
 273     }
 274
 275     send = received = NULL;
 276
 277     av_type = PW_FRAMED;
 278     rc_avpair_add (&send, PW_SERVICE_TYPE, &av_type, 0, VENDOR_NONE);
 279
 280     av_type = PW_PPP;
 281     rc_avpair_add (&send, PW_FRAMED_PROTOCOL, &av_type, 0, VENDOR_NONE);
 282
 283     rc_avpair_add (&send, PW_USER_NAME, rstate.user , 0, VENDOR_NONE);
 284
 285     /*
 286      * add the CHAP-Password and CHAP-Challenge fields
 287      */
 288
 289     cpassword[0] = cstate->chal_id;
 290
 291     memcpy(&cpassword[1], remmd, MD5_SIGNATURE_SIZE);
 292
 293     rc_avpair_add(&send, PW_CHAP_PASSWORD, cpassword, MD5_SIGNATURE_SIZE + 1, VENDOR_NONE);
 294
 295     rc_avpair_add(&send, PW_CHAP_CHALLENGE, cstate->challenge, cstate->chal_len, VENDOR_NONE);
 296
 297     /*
 298      * make authentication with RADIUS server
 299      */
 300
 301     result = rc_auth (rstate.client_port, send, &received, radius_msg);
 302
 303     if (result == OK_RC) {
 304         if (!rstate.done_chap_once) {
 305             if (radius_setparams(received, radius_msg) < 0) {
 306                 error("%s", radius_msg);
 307                 result = ERROR_RC;
 308             } else {
 309                 rstate.done_chap_once = 1;
 310             }
 311         }
 312     }
 313
 314     rc_avpair_free(received);
 315     rc_avpair_free (send);
 316     return (result == OK_RC) ? CHAP_SUCCESS : CHAP_FAILURE;
 317 }
 318
 319 /**********************************************************************
 320 * %FUNCTION: make_username_realm
 321 * %ARGUMENTS:
 322 *  user -- the user given to pppd
 323 * %RETURNS:
 324 *  Nothing
 325 * %DESCRIPTION:
 326 *  Copies user into rstate.user.  If it lacks a realm (no "@domain" part),
 327 * then the default realm from the radiusclient config file is added.
 328 ***********************************************************************/
 329 static void
 330 make_username_realm(char *user)
 331 {
 332     char *default_realm;
 333
 334     if ( user != NULL ) {
 335         strlcpy(rstate.user, user, sizeof(rstate.user));
 336     }  else {
 337         rstate.user[0] = 0;
 338     }
 339
 340     default_realm = rc_conf_str("default_realm");
 341
 342     if (!strchr(rstate.user, '@') &&
 343         default_realm &&
 344         (*default_realm != '\0')) {
 345         strlcat(rstate.user, "@", sizeof(rstate.user));
 346         strlcat(rstate.user, default_realm, sizeof(rstate.user));
 347     }
 348 }
 349
 350 /**********************************************************************
 351 * %FUNCTION: radius_setparams
 352 * %ARGUMENTS:
 353 *  vp -- received value-pairs
 354 *  msg -- buffer in which to place error message.  Holds up to BUF_LEN chars
 355 * %RETURNS:
 356 *  >= 0 on success; -1 on failure
 357 * %DESCRIPTION:
 358 *  Parses attributes sent by RADIUS server and sets them in pppd.  Currently,
 359 *  used only to set IP address.
 360 ***********************************************************************/
 361 static int
 362 radius_setparams(VALUE_PAIR *vp, char *msg)
 363 {
 364     u_int32_t remote;
 365
 366     /* Send RADIUS attributes to anyone else who might be interested */
 367     if (radius_attributes_hook) {
 368         (*radius_attributes_hook)(vp);
 369     }
 370
 371     /*
 372      * service type (if not framed then quit),
 373      * new IP address (RADIUS can define static IP for some users),
 374      */
 375
 376     while (vp) {
 377         switch (vp->attribute) {
 378         case PW_SERVICE_TYPE:
 379             /* check for service type       */
 380             /* if not FRAMED then exit      */
 381             if (vp->lvalue != PW_FRAMED) {
 382                 slprintf(msg, BUF_LEN, "RADIUS: wrong service type %ld for %s",
 383                          vp->lvalue, rstate.user);
 384                 return -1;
 385             }
 386             break;
 387         case PW_FRAMED_PROTOCOL:
 388             /* check for framed protocol type       */
 389             /* if not PPP then also exit            */
 390             if (vp->lvalue != PW_PPP) {
 391                 slprintf(msg, BUF_LEN, "RADIUS: wrong framed protocol %ld for %s",
 392                          vp->lvalue, rstate.user);
 393                 return -1;
 394             }
 395             break;
 396
 397         case PW_FRAMED_IP_ADDRESS:
 398             /* seting up remote IP addresses */
 399             remote = vp->lvalue;
 400             if (remote == 0xffffffff) {
 401                 /* 0xffffffff means user should be allowed to select one */
 402                 rstate.any_ip_addr_ok = 1;
 403             } else if (remote != 0xfffffffe) {
 404                 /* 0xfffffffe means NAS should select an ip address */
 405                 remote = htonl(vp->lvalue);
 406                 if (bad_ip_adrs (remote)) {
 407                     slprintf(msg, BUF_LEN, "RADIUS: bad remote IP address %I for %s",
 408                              remote, rstate.user);
 409                     return -1;
 410                 }
 411                 rstate.choose_ip = 1;
 412                 rstate.ip_addr = remote;
 413             }
 414             break;
 415         }
 416         vp = vp->next;
 417     }
 418     return 0;
 419 }
 420
 421 /**********************************************************************
 422 * %FUNCTION: radius_acct_start
 423 * %ARGUMENTS:
 424 *  None
 425 * %RETURNS:
 426 *  Nothing
 427 * %DESCRIPTION:
 428 *  Sends a "start" accounting message to the RADIUS server.
 429 ***********************************************************************/
 430 static void
 431 radius_acct_start(void)
 432 {
 433     UINT4 av_type;
 434     int result;
 435     VALUE_PAIR *send = NULL;
 436     ipcp_options *ho = &ipcp_hisoptions[0];
 437     u_int32_t hisaddr;
 438
 439     if (!rstate.initialized) {
 440         return;
 441     }
 442
 443     rstate.start_time = time(NULL);
 444
 445     strncpy(rstate.session_id, rc_mksid(), sizeof(rstate.session_id));
 446
 447     rc_avpair_add(&send, PW_ACCT_SESSION_ID,
 448                    rstate.session_id, 0, VENDOR_NONE);
 449     rc_avpair_add(&send, PW_USER_NAME,
 450                    rstate.user, 0, VENDOR_NONE);
 451
 452     av_type = PW_STATUS_START;
 453     rc_avpair_add(&send, PW_ACCT_STATUS_TYPE, &av_type, 0, VENDOR_NONE);
 454
 455     av_type = PW_FRAMED;
 456     rc_avpair_add(&send, PW_SERVICE_TYPE, &av_type, 0, VENDOR_NONE);
 457
 458     av_type = PW_PPP;
 459     rc_avpair_add(&send, PW_FRAMED_PROTOCOL, &av_type, 0, VENDOR_NONE);
 460
 461     if (*remote_number) {
 462         rc_avpair_add(&send, PW_CALLING_STATION_ID,
 463                        remote_number, 0, VENDOR_NONE);
 464     }
 465
 466     av_type = PW_RADIUS;
 467     rc_avpair_add(&send, PW_ACCT_AUTHENTIC, &av_type, 0, VENDOR_NONE);
 468
 469
 470     av_type = PW_ASYNC;
 471     rc_avpair_add(&send, PW_NAS_PORT_TYPE, &av_type, 0, VENDOR_NONE);
 472
 473     hisaddr = ho->hisaddr;
 474     av_type = htonl(hisaddr);
 475     rc_avpair_add(&send, PW_FRAMED_IP_ADDRESS , &av_type , 0, VENDOR_NONE);
 476
 477     result = rc_acct(rstate.client_port, send);
 478
 479     rc_avpair_free(send);
 480
 481     if (result != OK_RC) {
 482         /* RADIUS server could be down so make this a warning */
 483         syslog(LOG_WARNING,
 484                 "Accounting START failed for %s", rstate.user);
 485     } else {
 486         rstate.accounting_started = 1;
 487     }
 488 }
 489
 490 /**********************************************************************
 491 * %FUNCTION: radius_acct_stop
 492 * %ARGUMENTS:
 493 *  None
 494 * %RETURNS:
 495 *  Nothing
 496 * %DESCRIPTION:
 497 *  Sends a "stop" accounting message to the RADIUS server.
 498 ***********************************************************************/
 499 static void
 500 radius_acct_stop(void)
 501 {
 502     UINT4 av_type;
 503     VALUE_PAIR *send = NULL;
 504     ipcp_options *ho = &ipcp_hisoptions[0];
 505     u_int32_t hisaddr;
 506     int result;
 507
 508     if (!rstate.initialized) {
 509         return;
 510     }
 511
 512     if (!rstate.accounting_started) {
 513         return;
 514     }
 515
 516     rstate.accounting_started = 0;
 517     rc_avpair_add(&send, PW_ACCT_SESSION_ID, rstate.session_id,
 518                    0, VENDOR_NONE);
 519
 520     rc_avpair_add(&send, PW_USER_NAME, rstate.user, 0, VENDOR_NONE);
 521
 522     av_type = PW_STATUS_STOP;
 523     rc_avpair_add(&send, PW_ACCT_STATUS_TYPE, &av_type, 0, VENDOR_NONE);
 524
 525     av_type = PW_FRAMED;
 526     rc_avpair_add(&send, PW_SERVICE_TYPE, &av_type, 0, VENDOR_NONE);
 527
 528     av_type = PW_PPP;
 529     rc_avpair_add(&send, PW_FRAMED_PROTOCOL, &av_type, 0, VENDOR_NONE);
 530
 531     av_type = PW_RADIUS;
 532     rc_avpair_add(&send, PW_ACCT_AUTHENTIC, &av_type, 0, VENDOR_NONE);
 533
 534
 535     if (link_stats_valid) {
 536         av_type = link_connect_time;
 537         rc_avpair_add(&send, PW_ACCT_SESSION_TIME, &av_type, 0, VENDOR_NONE);
 538
 539         av_type = link_stats.bytes_out;
 540         rc_avpair_add(&send, PW_ACCT_OUTPUT_OCTETS, &av_type, 0, VENDOR_NONE);
 541
 542         av_type = link_stats.bytes_in;
 543         rc_avpair_add(&send, PW_ACCT_INPUT_OCTETS, &av_type, 0, VENDOR_NONE);
 544
 545         av_type = link_stats.pkts_out;
 546         rc_avpair_add(&send, PW_ACCT_OUTPUT_PACKETS, &av_type, 0, VENDOR_NONE);
 547
 548         av_type = link_stats.pkts_in;
 549         rc_avpair_add(&send, PW_ACCT_INPUT_PACKETS, &av_type, 0, VENDOR_NONE);
 550     }
 551
 552     if (*remote_number) {
 553         rc_avpair_add(&send, PW_CALLING_STATION_ID,
 554                        remote_number, 0, VENDOR_NONE);
 555     }
 556
 557     av_type = PW_ASYNC;
 558     rc_avpair_add(&send, PW_NAS_PORT_TYPE, &av_type, 0, VENDOR_NONE);
 559
 560     hisaddr = ho->hisaddr;
 561     av_type = htonl(hisaddr);
 562     rc_avpair_add(&send, PW_FRAMED_IP_ADDRESS , &av_type , 0, VENDOR_NONE);
 563
 564     result = rc_acct(rstate.client_port, send);
 565     if (result != OK_RC) {
 566         /* RADIUS server could be down so make this a warning */
 567         syslog(LOG_WARNING,
 568                 "Accounting STOP failed for %s", rstate.user);
 569     }
 570     rc_avpair_free(send);
 571 }
 572
 573 /**********************************************************************
 574 * %FUNCTION: radius_ip_up
 575 * %ARGUMENTS:
 576 *  opaque -- ignored
 577 *  arg -- ignored
 578 * %RETURNS:
 579 *  Nothing
 580 * %DESCRIPTION:
 581 *  Called when IPCP is up.  We'll do a start-accounting record.
 582 ***********************************************************************/
 583 static void
 584 radius_ip_up(void *opaque, int arg)
 585 {
 586     radius_acct_start();
 587 }
 588
 589 /**********************************************************************
 590 * %FUNCTION: radius_ip_down
 591 * %ARGUMENTS:
 592 *  opaque -- ignored
 593 *  arg -- ignored
 594 * %RETURNS:
 595 *  Nothing
 596 * %DESCRIPTION:
 597 *  Called when IPCP is down.  We'll do a stop-accounting record.
 598 ***********************************************************************/
 599 static void
 600 radius_ip_down(void *opaque, int arg)
 601 {
 602     radius_acct_stop();
 603 }
 604
 605 /**********************************************************************
 606 * %FUNCTION: radius_init
 607 * %ARGUMENTS:
 608 *  msg -- buffer of size BUF_LEN for error message
 609 * %RETURNS:
 610 *  negative on failure; non-negative on success
 611 * %DESCRIPTION:
 612 *  Initializes radiusclient library
 613 ***********************************************************************/
 614 static int
 615 radius_init(char *msg)
 616 {
 617     if (rstate.initialized) {
 618         return 0;
 619     }
 620
 621     if (config_file && *config_file) {
 622         strlcpy(rstate.config_file, config_file, MAXPATHLEN-1);
 623     }
 624
 625     rstate.initialized = 1;
 626
 627     if (rc_read_config(rstate.config_file) != 0) {
 628         slprintf(msg, BUF_LEN, "RADIUS: Can't read config file %s",
 629                  rstate.config_file);
 630         return -1;
 631     }
 632
 633     if (rc_read_dictionary(rc_conf_str("dictionary")) != 0) {
 634         slprintf(msg, BUF_LEN, "RADIUS: Can't read dictionary file %s",
 635                  rc_conf_str("dictionary"));
 636         return -1;
 637     }
 638
 639     if (rc_read_mapfile(rc_conf_str("mapfile")) != 0)   {
 640         slprintf(msg, BUF_LEN, "RADIUS: Can't read map file %s",
 641                  rc_conf_str("mapfile"));
 642         return -1;
 643     }
 644     return 0;
 645 }
 646
 647 /**********************************************************************
 648 * %FUNCTION: get_client_port
 649 * %ARGUMENTS:
 650 *  ifname -- PPP interface name (e.g. "ppp7")
 651 * %RETURNS:
 652 *  The NAS port number (e.g. 7)
 653 * %DESCRIPTION:
 654 *  Extracts the port number from the interface name
 655 ***********************************************************************/
 656 static int
 657 get_client_port(char *ifname)
 658 {
 659     int port;
 660     if (sscanf(ifname, "ppp%d", &port) == 1) {
 661         return port;
 662     }
 663     return rc_map2id(ifname);
 664 }
 665
 666 /**********************************************************************
 667 * %FUNCTION: radius_allowed_address
 668 * %ARGUMENTS:
 669 *  addr -- IP address
 670 * %RETURNS:
 671 *  1 if we're allowed to use that IP address; 0 if not; -1 if we do
 672 *  not know.
 673 ***********************************************************************/
 674 static int
 675 radius_allowed_address(u_int32_t addr)
 676 {
 677     ipcp_options *wo = &ipcp_wantoptions[0];
 678
 679     if (!rstate.choose_ip) {
 680         /* If RADIUS server said any address is OK, then fine... */
 681         if (rstate.any_ip_addr_ok) {
 682             return 1;
 683         }
 684
 685         /* Sigh... if an address was supplied for remote host in pppd
 686            options, it has to match that.  */
 687         if (wo->hisaddr != 0 && wo->hisaddr == addr) {
 688             return 1;
 689         }
 690
 691         return 0;
 692     }
 693     if (addr == rstate.ip_addr) return 1;
 694     return 0;
 695 }
 696
 697 /* Useful for other plugins */
 698 char *radius_logged_in_user(void)
 699 {
 700     return rstate.user;
 701 }
 702