src/modules/rlm_ldap/ldap.c

   1 /*
   2  *   This program is is free software; you can redistribute it and/or modify
   3  *   it under the terms of the GNU General Public License, version 2 if the
   4  *   License as published by the Free Software Foundation.
   5  *
   6  *   This program is distributed in the hope that it will be useful,
   7  *   but WITHOUT ANY WARRANTY; without even the implied warranty of
   8  *   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
   9  *   GNU General Public License for more details.
  10  *
  11  *   You should have received a copy of the GNU General Public License
  12  *   along with this program; if not, write to the Free Software
  13  *   Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA
  14  */
  15
  16 /**
  17  * $Id$
  18  * @file ldap.c
  19  * @brief LDAP module library functions.
  20  *
  21  * @author Arran Cudbard-Bell <a.cudbardb@freeradius.org>
  22  * @copyright 2013 Network RADIUS SARL <info@networkradius.com>
  23  * @copyright 2013 The FreeRADIUS Server Project.
  24  */
  25 #include        <freeradius-devel/radiusd.h>
  26 #include        <freeradius-devel/modules.h>
  27 #include        <freeradius-devel/rad_assert.h>
  28
  29 #include        <stdarg.h>
  30 #include        <ctype.h>
  31
  32 #include        <lber.h>
  33 #include        <ldap.h>
  34 #include        "ldap.h"
  35
  36
  37
  38 /** Converts "bad" strings into ones which are safe for LDAP
  39  *
  40  * This is a callback for xlat operations.
  41  *
  42  * Will escape any characters in input strings that would cause the string to be interpreted as part of a DN and or
  43  * filter. Escape sequence is @verbatim \<hex><hex> @endverbatim
  44  *
  45  * @param request The current request.
  46  * @param out Pointer to output buffer.
  47  * @param outlen Size of the output buffer.
  48  * @param in Raw unescaped string.
  49  * @param arg Any additional arguments (unused).
  50  */
  51 size_t rlm_ldap_escape_func(UNUSED REQUEST *request, char *out, size_t outlen, const char *in, UNUSED void *arg)
  52 {
  53         static const char encode[] = ",+\"\\<>;*=()";
  54         static const char hextab[] = "0123456789abcdef";
  55         size_t left = outlen;
  56
  57         if (*in && ((*in == ' ') || (*in == '#'))) {
  58                 goto encode;
  59         }
  60
  61         while (*in) {
  62                 /*
  63                  *      Encode unsafe characters.
  64                  */
  65                 if (memchr(encode, *in, sizeof(encode) - 1)) {
  66                         encode:
  67
  68                         /*
  69                          *      Only 3 or less bytes available.
  70                          */
  71                         if (left <= 3) break;
  72
  73                         *out++ = '\\';
  74                         *out++ = hextab[(*in >> 4) & 0x0f];
  75                         *out++ = hextab[*in & 0x0f];
  76                         in++;
  77                         left -= 3;
  78
  79                         continue;
  80                 }
  81
  82                 if (left <= 1) break;
  83
  84                 /*
  85                  *      Doesn't need encoding
  86                  */
  87                 *out++ = *in++;
  88                 left--;
  89         }
  90
  91         *out = '\0';
  92
  93         return outlen - left;
  94 }
  95
  96 /** Check whether a string is a DN
  97  *
  98  * @param str to check.
  99  * @return true if string is a DN, else false.
 100  */
 101 int rlm_ldap_is_dn(const char *str)
 102 {
 103         return strrchr(str, ',') == NULL ? FALSE : TRUE;
 104 }
 105
 106 /** Find the place at which the two DN strings diverge
 107  *
 108  * Returns the length of the non matching string in full.
 109  *
 110  * @param full DN.
 111  * @param part Partial DN as returned by ldap_parse_result.
 112  * @return the length of the portion of full which wasn't matched or -1 on error.
 113  */
 114 static size_t rlm_ldap_common_dn(const char *full, const char *part)
 115 {
 116         size_t f_len, p_len, i;
 117
 118         if (!full) {
 119                 return -1;
 120         }
 121
 122         f_len = strlen(full);
 123
 124         if (!part) {
 125                 return f_len;
 126         }
 127
 128         p_len = strlen(part);
 129         if (!p_len) {
 130                 return f_len;
 131         }
 132
 133         if ((f_len < p_len) || !f_len) {
 134                 return -1;
 135         }
 136
 137
 138         for (i = 0; i < p_len; i++) {
 139                 if (part[p_len - i] != full[f_len - i]) {
 140                         return -1;
 141                 }
 142         }
 143
 144         return f_len - p_len;
 145 }
 146
 147 /** Parse response from LDAP server dealing with any errors
 148  *
 149  * Should be called after an LDAP operation. Will check result of operation and if it was successful, then attempt
 150  * to retrieve and parse the result.
 151  *
 152  * Will also produce extended error output including any messages the server sent, and information about partial
 153  * DN matches.
 154  *
 155  * @param[in] inst of LDAP module.
 156  * @param[in] conn Current connection.
 157  * @param[in] msgid returned from last operation.
 158  * @param[in] dn Last search or bind DN.
 159  * @param[out] result Where to write result, if NULL result will be freed.
 160  * @param[out] error Where to write the error string, may be NULL, must not be freed.
 161  * @param[out] extra Where to write additional error string to, may be NULL (faster) or must be freed
 162  *      (with talloc_free).
 163  * @return One of the LDAP_PROC_* codes.
 164  */
 165 static ldap_rcode_t rlm_ldap_result(const ldap_instance_t *inst, const ldap_handle_t *conn, int msgid, const char *dn,
 166                                     LDAPMessage **result, const char **error, char **extra)
 167 {
 168         ldap_rcode_t status = LDAP_PROC_SUCCESS;
 169
 170         int lib_errno = LDAP_SUCCESS;   //!< errno returned by the library.
 171         int srv_errno = LDAP_SUCCESS;   //!< errno in the result message.
 172
 173         char *part_dn = NULL;           //!< Partial DN match.
 174         char *our_err = NULL;           //!< Our extended error message.
 175         char *srv_err = NULL;           //!< Server's extended error message.
 176         char *p, *a;
 177
 178         int freeit = FALSE;             //!< Whether the message should
 179                                         //!< be freed after being processed.
 180         int len;
 181
 182         struct timeval tv;              //!< Holds timeout values.
 183
 184         LDAPMessage *tmp_msg;           //!< Temporary message pointer storage
 185                                         //!< if we weren't provided with one.
 186
 187         const char *tmp_err;            //!< Temporary error pointer storage
 188                                         //!< if we weren't provided with one.
 189
 190         if (!error) {
 191                 error = &tmp_err;
 192         }
 193         *error = NULL;
 194
 195         if (extra) {
 196                 *extra = NULL;
 197         }
 198
 199         /*
 200          *      We always need the result, but our caller may not
 201          */
 202         if (!result) {
 203                 result = &tmp_msg;
 204                 freeit = TRUE;
 205         }
 206
 207         /*
 208          *      Check if there was an error sending the request
 209          */
 210         ldap_get_option(conn->handle, LDAP_OPT_ERROR_NUMBER,
 211                         &lib_errno);
 212         if (lib_errno != LDAP_SUCCESS) {
 213                 goto process_error;
 214         }
 215
 216         tv.tv_sec = inst->timeout;
 217         tv.tv_usec = 0;
 218
 219         /*
 220          *      Now retrieve the result and check for errors
 221          *      ldap_result returns -1 on error, and 0 on timeout
 222          */
 223         lib_errno = ldap_result(conn->handle, msgid, 1, &tv, result);
 224         if (lib_errno == 0) {
 225                 lib_errno = LDAP_TIMEOUT;
 226
 227                 goto process_error;
 228         }
 229
 230         if (lib_errno == -1) {
 231                 ldap_get_option(conn->handle, LDAP_OPT_ERROR_NUMBER,
 232                                 &lib_errno);
 233                 goto process_error;
 234         }
 235
 236         /*
 237          *      Parse the result and check for errors sent by the server
 238          */
 239         lib_errno = ldap_parse_result(conn->handle, *result,
 240                                       &srv_errno,
 241                                       extra ? &part_dn : NULL,
 242                                       extra ? extra : NULL,
 243                                       NULL, NULL, freeit);
 244
 245         if (lib_errno != LDAP_SUCCESS) {
 246                 ldap_get_option(conn->handle, LDAP_OPT_ERROR_NUMBER,
 247                                 &lib_errno);
 248                 goto process_error;
 249         }
 250
 251         process_error:
 252
 253         if ((lib_errno == LDAP_SUCCESS) && (srv_errno != LDAP_SUCCESS)) {
 254                 lib_errno = srv_errno;
 255         } else if ((lib_errno != LDAP_SUCCESS) && (srv_errno == LDAP_SUCCESS)) {
 256                 srv_errno = lib_errno;
 257         }
 258
 259         switch (lib_errno) {
 260         case LDAP_SUCCESS:
 261                 *error = "Success";
 262
 263                 break;
 264
 265         case LDAP_NO_SUCH_OBJECT:
 266                 *error = "The specified object wasn't found, check basedn and admin dn";
 267
 268                 status = LDAP_PROC_BAD_DN;
 269
 270                 if (!extra) break;
 271
 272                 /*
 273                  *      Build our own internal diagnostic string
 274                  */
 275                 len = rlm_ldap_common_dn(dn, part_dn);
 276                 if (len < 0) break;
 277
 278                 our_err = talloc_asprintf(conn, "Match stopped here: [%.*s]%s", len, part_dn, part_dn ? part_dn : "");
 279
 280                 break;
 281
 282         case LDAP_INSUFFICIENT_ACCESS:
 283                 *error = "Insufficient access. Check the identity and password configuration directives";
 284
 285                 status = LDAP_PROC_NOT_PERMITTED;
 286                 break;
 287
 288         case LDAP_UNWILLING_TO_PERFORM:
 289                 *error = "Server was unwilling to perform";
 290
 291                 status = LDAP_PROC_NOT_PERMITTED;
 292                 break;
 293
 294         case LDAP_TIMEOUT:
 295                 exec_trigger(NULL, inst->cs, "modules.ldap.timeout", TRUE);
 296
 297                 *error = "Timed out while waiting for server to respond";
 298
 299                 status = LDAP_PROC_ERROR;
 300                 break;
 301
 302         case LDAP_FILTER_ERROR:
 303                 *error = "Bad search filter";
 304
 305                 status = LDAP_PROC_ERROR;
 306                 break;
 307
 308         case LDAP_TIMELIMIT_EXCEEDED:
 309                 exec_trigger(NULL, inst->cs, "modules.ldap.timeout", TRUE);
 310
 311                 *error = "Time limit exceeded";
 312                 /* FALL-THROUGH */
 313
 314         case LDAP_BUSY:
 315         case LDAP_UNAVAILABLE:
 316         case LDAP_SERVER_DOWN:
 317                 status = LDAP_PROC_RETRY;
 318
 319                 goto error_string;
 320
 321         case LDAP_INVALID_CREDENTIALS:
 322         case LDAP_CONSTRAINT_VIOLATION:
 323                 status = LDAP_PROC_REJECT;
 324
 325                 goto error_string;
 326
 327         case LDAP_OPERATIONS_ERROR:
 328                 *error = "Please set 'chase_referrals=yes' and 'rebind=yes'. See the ldap module configuration "
 329                          "for details.";
 330                 /* FALL-THROUGH */
 331
 332         default:
 333                 status = LDAP_PROC_ERROR;
 334
 335                 error_string:
 336
 337                 if (!*error) {
 338                         *error = ldap_err2string(lib_errno);
 339                 }
 340
 341                 if (!extra || ((lib_errno == srv_errno) && !our_err && !srv_err)) {
 342                         break;
 343                 }
 344
 345                 /*
 346                  *      Output the error codes from the library and server
 347                  */
 348                 p = talloc_strdup(conn, "");
 349                 if (!p) break;
 350
 351                 if (lib_errno != srv_errno) {
 352                         a = talloc_asprintf_append(p, "LDAP lib error: %s (%u), srv error: %s (%u)",
 353                                                    ldap_err2string(lib_errno), lib_errno,
 354                                                    ldap_err2string(srv_errno), srv_errno);
 355                         if (!a) {
 356                                 talloc_free(p);
 357                                 break;
 358                         }
 359
 360                         p = a;
 361                 }
 362
 363                 if (our_err) {
 364                         a = talloc_asprintf_append_buffer(p,". %s", our_err);
 365                         if (!a) {
 366                                 talloc_free(p);
 367                                 break;
 368                         }
 369
 370                         p = a;
 371                 }
 372
 373                 if (srv_err) {
 374                         a = talloc_asprintf_append_buffer(p, ". Server said: %s", srv_err);
 375                         if (!a) {
 376                                 talloc_free(p);
 377                                 break;
 378                         }
 379
 380                         p = a;
 381                 }
 382
 383                 *extra = p;
 384
 385                 break;
 386         }
 387
 388         /*
 389          *      Cleanup memory
 390          */
 391         if (srv_err) {
 392                 ldap_memfree(srv_err);
 393         }
 394
 395         if (part_dn) {
 396                 ldap_memfree(part_dn);
 397         }
 398
 399         if (our_err) {
 400                 talloc_free(our_err);
 401         }
 402
 403         if ((lib_errno || srv_errno) && *result) {
 404                 ldap_msgfree(*result);
 405                 *result = NULL;
 406         }
 407
 408         return status;
 409 }
 410
 411 /** Bind to the LDAP directory as a user
 412  *
 413  * Performs a simple bind to the LDAP directory, and handles any errors that
 414  * occur.
 415  *
 416  * @param inst rlm_ldap configuration.
 417  * @param request Current request, this may be NULL, in which case all debug logging is done with radlog.
 418  * @param pconn to use. May change as this function auto re-connects. Caller must check that pconn is not NULL after
 419  *      calling this function.
 420  * @param dn The DN of the user, may be NULL to bind anonymously.
 421  * @param password May be NULL if no password is specified.
 422  * @param retry if the server is down.
 423  * @return one of the RLM_MODULE_* values.
 424  */
 425 rlm_rcode_t rlm_ldap_bind(const ldap_instance_t *inst, REQUEST *request, ldap_handle_t **pconn, const char *dn,
 426                           const char *password, int retry)
 427 {
 428         rlm_rcode_t     rcode = RLM_MODULE_OK;
 429         ldap_rcode_t    status;
 430
 431         int             msgid;
 432
 433         const char      *error = NULL;
 434         char            *extra = NULL;
 435
 436         /*
 437          *      Bind as anonymous user
 438          */
 439         if (!dn) dn = "";
 440
 441 retry:
 442         msgid = ldap_bind((*pconn)->handle, dn, password, LDAP_AUTH_SIMPLE);
 443         /* We got a valid message ID */
 444         if (msgid >= 0) {
 445                 if (request) {
 446                         RDEBUG2("Waiting for bind result...");
 447                 } else {
 448                         DEBUG2("rlm_ldap (%s): Waiting for bind result...", inst->xlat_name);
 449                 }
 450         }
 451
 452         status = rlm_ldap_result(inst, *pconn, msgid, dn, NULL, &error, &extra);
 453         switch (status) {
 454         case LDAP_PROC_SUCCESS:
 455                 break;
 456         case LDAP_PROC_NOT_PERMITTED:
 457                 rcode = RLM_MODULE_USERLOCK;
 458
 459                 LDAP_ERR_REQ("Bind was not permitted: %s", error);
 460                 LDAP_EXT_REQ();
 461
 462                 break;
 463
 464         case LDAP_PROC_REJECT:
 465                 rcode = RLM_MODULE_REJECT;
 466
 467                 LDAP_ERR_REQ("Bind credentials incorrect: %s", error);
 468                 LDAP_EXT_REQ();
 469
 470                 break;
 471
 472         case LDAP_PROC_RETRY:
 473                 if (retry) {
 474                         *pconn = fr_connection_reconnect(inst->pool, *pconn);
 475                         if (*pconn) {
 476                                 LDAP_DBGW_REQ("Bind with %s to %s:%d failed: %s. Got new socket, retrying...",
 477                                               dn, inst->server, inst->port, error);
 478
 479                                 talloc_free(extra); /* don't leak debug info */
 480
 481                                 goto retry;
 482                         }
 483                 };
 484
 485                 /*
 486                  *      Were not allowed to retry, or there are no more
 487                  *      sockets, treat this as a hard failure.
 488                  */
 489                 goto error;
 490         default:
 491 error:
 492                 rcode = RLM_MODULE_FAIL;
 493 #ifdef HAVE_LDAP_INITIALIZE
 494                 if (inst->is_url) {
 495                         LDAP_ERR_REQ("Bind with %s to %s failed: %s", dn, inst->server, error);
 496                 } else
 497 #endif
 498                 {
 499                         LDAP_ERR_REQ("Bind with %s to %s:%d failed: %s", dn, inst->server,
 500                                      inst->port, error);
 501                 }
 502                 LDAP_EXT_REQ();
 503
 504                 break;
 505         }
 506
 507         if (extra) talloc_free(extra);
 508
 509         return rcode; /* caller closes the connection */
 510 }
 511
 512
 513 /** Search for something in the LDAP directory
 514  *
 515  * Binds as the administrative user and performs a search, dealing with any
 516  * errors.
 517  *
 518  * @param inst rlm_ldap configuration.
 519  * @param request Current request.
 520  * @param pconn to use. May change as this function auto re-connects. Caller must check that pconn is not NULL
 521  *      after calling this function.
 522  * @param dn to use.
 523  * @param scope to use.
 524  * @param filter to use.
 525  * @param attrs to retrieve.
 526  * @param result Where to store the result. Must be freed with ldap_msgfree.
 527  *      may be NULL in which case result will be automatically freed after use.
 528  * @return One of the LDAP_PROC_* values.
 529  */
 530 ldap_rcode_t rlm_ldap_search(const ldap_instance_t *inst, REQUEST *request, ldap_handle_t **pconn,
 531                              const char *dn, int scope, const char *filter, const char * const *attrs,
 532                              LDAPMessage **result)
 533 {
 534         ldap_rcode_t    status;
 535
 536         int             msgid;          //!< Message id returned by
 537                                         //!< ldap_search_ext.
 538
 539         int             count = 0;      //!< Number of results we got.
 540
 541         struct timeval  tv;             //!< Holds timeout values.
 542
 543         const char      *error = NULL;
 544         char            *extra = NULL;
 545
 546         /*
 547          *      OpenLDAP library doesn't declare attrs array as const, but
 548          *      it really should be *sigh*.
 549          */
 550         char **search_attrs;
 551         memcpy(&search_attrs, &attrs, sizeof(attrs));
 552
 553         /*
 554          *      Do all searches as the admin user.
 555          */
 556         if ((*pconn)->rebound) {
 557                 if (rlm_ldap_bind(inst, request, pconn, inst->login, inst->password, TRUE) != RLM_MODULE_OK) {
 558                         return LDAP_PROC_ERROR;
 559                 }
 560
 561                 rad_assert(*pconn);
 562
 563                 (*pconn)->rebound = FALSE;
 564         }
 565
 566         RDEBUG2("Performing search in '%s' with filter '%s'", dn, filter);
 567
 568         /*
 569          *      If LDAP search produced an error it should also be logged
 570          *      to the ld. result should pick it up without us
 571          *      having to pass it explicitly.
 572          */
 573         tv.tv_sec = inst->timeout;
 574         tv.tv_usec = 0;
 575 retry:
 576         (void) ldap_search_ext((*pconn)->handle, dn, scope, filter, search_attrs, 0, NULL, NULL, &tv, 0, &msgid);
 577
 578         RDEBUG2("Waiting for search result...");
 579         status = rlm_ldap_result(inst, *pconn, msgid, dn, result, &error, &extra);
 580         switch (status) {
 581                 case LDAP_PROC_SUCCESS:
 582                         break;
 583                 case LDAP_PROC_RETRY:
 584                         *pconn = fr_connection_reconnect(inst->pool, *pconn);
 585                         if (*pconn) {
 586                                 RDEBUGW("Search failed: %s. Got new socket, retrying...", error);
 587
 588                                 talloc_free(extra); /* don't leak debug info */
 589
 590                                 goto retry;
 591                         }
 592
 593                         status = LDAP_PROC_ERROR;
 594
 595                         /* FALL-THROUGH */
 596                 default:
 597                         RDEBUGE("Failed performing search: %s", error);
 598                         RDEBUGE("%s", extra);
 599
 600                         goto finish;
 601         }
 602
 603         if (result) {
 604                 count = ldap_count_entries((*pconn)->handle, *result);
 605                 if (count == 0) {
 606                         ldap_msgfree(*result);
 607                         *result = NULL;
 608
 609                         RDEBUG("Search returned no results");
 610
 611                         status = LDAP_PROC_NO_RESULT;
 612                 }
 613         }
 614
 615         finish:
 616         if (extra) talloc_free(extra);
 617
 618         return status;
 619 }
 620
 621 /** Modify something in the LDAP directory
 622  *
 623  * Binds as the administrative user and attempts to modify an LDAP object.
 624  *
 625  * @param inst rlm_ldap configuration.
 626  * @param request Current request.
 627  * @param pconn to use. May change as this function auto re-connects. Caller must check that pconn is not NULL after
 628  *      calling this function.
 629  * @param dn to modify.
 630  * @param mods to make.
 631  * @return One of the LDAP_PROC_* values.
 632  */
 633 ldap_rcode_t rlm_ldap_modify(const ldap_instance_t *inst, REQUEST *request, ldap_handle_t **pconn,
 634                              const char *dn, LDAPMod *mods[])
 635 {
 636         ldap_rcode_t    status;
 637
 638         int             msgid;          //!< Message id returned by
 639                                         //!< ldap_search_ext.
 640
 641         const char      *error = NULL;
 642         char            *extra = NULL;
 643
 644         /*
 645          *      Perform all modifications as the admin user.
 646          */
 647         if ((*pconn)->rebound) {
 648                 if (rlm_ldap_bind(inst, request, pconn, inst->login, inst->password, TRUE) != RLM_MODULE_OK) {
 649                         return LDAP_PROC_ERROR;
 650                 }
 651
 652                 rad_assert(*pconn);
 653
 654                 (*pconn)->rebound = FALSE;
 655         }
 656
 657         RDEBUG2("Modifying object with DN \"%s\"", dn);
 658         retry:
 659         (void) ldap_modify_ext((*pconn)->handle, dn, mods, NULL, NULL, &msgid);
 660
 661         RDEBUG2("Waiting for modify result...");
 662         status = rlm_ldap_result(inst, *pconn, msgid, dn, NULL, &error, &extra);
 663         switch (status) {
 664                 case LDAP_PROC_SUCCESS:
 665                         break;
 666                 case LDAP_PROC_RETRY:
 667                         *pconn = fr_connection_reconnect(inst->pool, *pconn);
 668                         if (*pconn) {
 669                                 RDEBUGW("Modify failed: %s. Got new socket, retrying...", error);
 670
 671                                 talloc_free(extra); /* don't leak debug info */
 672
 673                                 goto retry;
 674                         }
 675
 676                         status = LDAP_PROC_ERROR;
 677
 678                         /* FALL-THROUGH */
 679                 default:
 680                         RDEBUGE("Failed modifying object: %s", error);
 681                         RDEBUGE("%s", extra);
 682
 683                         goto finish;
 684         }
 685
 686         finish:
 687         if (extra) talloc_free(extra);
 688
 689         return status;
 690 }
 691
 692 /** Retrieve the DN of a user object
 693  *
 694  * Retrieves the DN of a user and adds it to the control list as LDAP-UserDN. Will also retrieve any attributes
 695  * passed and return the result in *result.
 696  *
 697  * This potentially allows for all authorization and authentication checks to be performed in one ldap search
 698  * operation, which is a big bonus given the number of crappy, slow *cough*AD*cough* LDAP directory servers out there.
 699  *
 700  * @param[in] inst rlm_ldap configuration.
 701  * @param[in] request Current request.
 702  * @param[in,out] pconn to use. May change as this function auto re-connects. Caller must check that pconn is not NULL
 703  *      after calling this function.
 704  * @param[in] attrs Additional attributes to retrieve, may be NULL.
 705  * @param[in] force Query even if the User-DN already exists.
 706  * @param[out] result Where to write the result, may be NULL in which case result is discarded.
 707  * @param[out] rcode The status of the operation, one of the RLM_MODULE_* codes.
 708  * @return The user's DN or NULL on error.
 709  */
 710 const char *rlm_ldap_find_user(const ldap_instance_t *inst, REQUEST *request, ldap_handle_t **pconn,
 711                                const char *attrs[], int force, LDAPMessage **result, rlm_rcode_t *rcode)
 712 {
 713         static const char *tmp_attrs[] = { NULL };
 714
 715         ldap_rcode_t    status;
 716         VALUE_PAIR      *vp = NULL;
 717         LDAPMessage     *tmp_msg = NULL, *entry = NULL;
 718         int             ldap_errno;
 719         char            *dn;
 720         char            filter[LDAP_MAX_FILTER_STR_LEN];
 721         char            basedn[LDAP_MAX_FILTER_STR_LEN];
 722
 723         int freeit = FALSE;                                     //!< Whether the message should
 724                                                                 //!< be freed after being processed.
 725
 726         *rcode = RLM_MODULE_FAIL;
 727
 728         if (!result) {
 729                 result = &tmp_msg;
 730                 freeit = TRUE;
 731         }
 732         *result = NULL;
 733
 734         if (!attrs) {
 735                 memset(&attrs, 0, sizeof(tmp_attrs));
 736         }
 737
 738         /*
 739          *      If the caller isn't looking for the result we can just return the current userdn value.
 740          */
 741         if (!force) {
 742                 vp = pairfind(request->config_items, PW_LDAP_USERDN, 0, TAG_ANY);
 743                 if (vp) {
 744                         RDEBUG("Using user DN from request \"%s\"", vp->vp_strvalue);
 745                         *rcode = RLM_MODULE_OK;
 746                         return vp->vp_strvalue;
 747                 }
 748         }
 749
 750         /*
 751          *      Perform all searches as the admin user.
 752          */
 753         if ((*pconn)->rebound) {
 754                 if (rlm_ldap_bind(inst, request, pconn, inst->login, inst->password, TRUE) != RLM_MODULE_OK) {
 755                         *rcode = RLM_MODULE_FAIL;
 756                         return NULL;
 757                 }
 758
 759                 rad_assert(*pconn);
 760
 761                 (*pconn)->rebound = FALSE;
 762         }
 763
 764
 765         if (!radius_xlat(filter, sizeof(filter), inst->filter, request, rlm_ldap_escape_func, NULL)) {
 766                 RDEBUGE("Unable to create filter");
 767
 768                 *rcode = RLM_MODULE_INVALID;
 769                 return NULL;
 770         }
 771
 772         if (!radius_xlat(basedn, sizeof(basedn), inst->basedn, request, rlm_ldap_escape_func, NULL)) {
 773                 RDEBUGE("Unable to create basedn");
 774
 775                 *rcode = RLM_MODULE_INVALID;
 776                 return NULL;
 777         }
 778
 779         status = rlm_ldap_search(inst, request, pconn, basedn, LDAP_SCOPE_SUBTREE, filter, attrs, result);
 780         switch (status) {
 781                 case LDAP_PROC_SUCCESS:
 782                         break;
 783                 case LDAP_PROC_NO_RESULT:
 784                         *rcode = RLM_MODULE_NOTFOUND;
 785                         return NULL;
 786                 default:
 787                         *rcode = RLM_MODULE_FAIL;
 788                         return NULL;
 789         }
 790
 791         rad_assert(*pconn);
 792
 793         entry = ldap_first_entry((*pconn)->handle, *result);
 794         if (!entry) {
 795                 ldap_get_option((*pconn)->handle, LDAP_OPT_RESULT_CODE, &ldap_errno);
 796                 RDEBUGE("Failed retrieving entry: %s",
 797                         ldap_err2string(ldap_errno));
 798
 799                 goto finish;
 800         }
 801
 802         dn = ldap_get_dn((*pconn)->handle, entry);
 803         if (!dn) {
 804                 ldap_get_option((*pconn)->handle, LDAP_OPT_RESULT_CODE, &ldap_errno);
 805
 806                 RDEBUGE("Retrieving object DN from entry failed: %s",
 807                         ldap_err2string(ldap_errno));
 808
 809                 goto finish;
 810         }
 811
 812         RDEBUG("User object found at DN \"%s\"", dn);
 813         vp = pairmake(request, &request->config_items, "LDAP-UserDn", dn, T_OP_EQ);
 814         if (vp) {
 815                 *rcode = RLM_MODULE_OK;
 816         }
 817
 818         finish:
 819         ldap_memfree(dn);
 820
 821         if ((freeit || (*rcode != RLM_MODULE_OK)) && *result) {
 822                 ldap_msgfree(*result);
 823                 *result = NULL;
 824         }
 825
 826         return vp ? vp->vp_strvalue : NULL;
 827 }
 828
 829 rlm_rcode_t rlm_ldap_apply_profile(const ldap_instance_t *inst, REQUEST *request, ldap_handle_t **pconn,
 830                                    const char *profile, const rlm_ldap_map_xlat_t *expanded)
 831 {
 832         rlm_rcode_t     rcode = RLM_MODULE_OK;
 833         ldap_rcode_t    status;
 834         LDAPMessage     *result = NULL, *entry = NULL;
 835         int             ldap_errno;
 836         LDAP            *handle = (*pconn)->handle;
 837         char            filter[LDAP_MAX_FILTER_STR_LEN];
 838
 839         if (!profile || !*profile) {
 840                 return RLM_MODULE_NOOP;
 841         }
 842         strlcpy(filter, inst->base_filter, sizeof(filter));
 843
 844         status = rlm_ldap_search(inst, request, pconn, profile, LDAP_SCOPE_BASE, filter, expanded->attrs, &result);
 845         switch (status) {
 846                 case LDAP_PROC_SUCCESS:
 847                         break;
 848                 case LDAP_PROC_NO_RESULT:
 849                         RDEBUG("Profile \"%s\" not found", profile);
 850                         return RLM_MODULE_NOTFOUND;
 851                 default:
 852                         return RLM_MODULE_FAIL;
 853         }
 854
 855         rad_assert(*pconn);
 856         rad_assert(result);
 857
 858         entry = ldap_first_entry(handle, result);
 859         if (!entry) {
 860                 ldap_get_option(handle, LDAP_OPT_RESULT_CODE, &ldap_errno);
 861                 RDEBUGE("Failed retrieving entry: %s", ldap_err2string(ldap_errno));
 862
 863                 rcode = RLM_MODULE_NOTFOUND;
 864
 865                 goto free_result;
 866         }
 867
 868         rlm_ldap_map_do(inst, request, handle, expanded, entry);
 869
 870 free_result:
 871         ldap_msgfree(result);
 872
 873         return rcode;
 874 }
 875
 876 /** Check for presence of access attribute in result
 877  *
 878  * @param inst rlm_ldap configuration.
 879  * @param request Current request.
 880  * @param conn used to retrieve entry.
 881  * @param entry retrieved by rlm_ldap_find_user or rlm_ldap_search.
 882  * @return RLM_MODULE_USERLOCK if the user was denied access, else RLM_MODULE_OK.
 883  */
 884 rlm_rcode_t rlm_ldap_check_access(const ldap_instance_t *inst, REQUEST *request, const ldap_handle_t *conn,
 885                                   LDAPMessage *entry)
 886 {
 887         rlm_rcode_t rcode = RLM_MODULE_OK;
 888         char **vals = NULL;
 889
 890         vals = ldap_get_values(conn->handle, entry, inst->userobj_access_attr);
 891         if (vals) {
 892                 if (inst->access_positive && (strncmp(vals[0], "FALSE", 5) == 0)) {
 893                         RDEBUG("\"%s\" attribute exists but is set to 'false' - user locked out");
 894                         rcode = RLM_MODULE_USERLOCK;
 895                 } else {
 896                         RDEBUG("\"%s\" attribute exists - user locked out", inst->userobj_access_attr);
 897                         rcode = RLM_MODULE_USERLOCK;
 898                 }
 899
 900                 ldap_value_free(vals);
 901         } else if (inst->access_positive) {
 902                 RDEBUG("No \"%s\" attribute - user locked out", inst->userobj_access_attr);
 903                 rcode = RLM_MODULE_USERLOCK;
 904         }
 905
 906         return rcode;
 907 }
 908
 909 /** Verify we got a password from the search
 910  *
 911  * Checks to see if after the LDAP to RADIUS mapping has been completed that a reference password.
 912  *
 913  * @param inst rlm_ldap configuration.
 914  * @param request Current request.
 915  */
 916 void rlm_ldap_check_reply(const ldap_instance_t *inst, REQUEST *request)
 917 {
 918        /*
 919         *       More warning messages for people who can't be bothered to read the documentation.
 920         *
 921         *       Expect_password is set when we process the mapping, and is only true if there was a mapping between
 922         *       an LDAP attribute and a password reference attribute in the control list.
 923         */
 924         if (inst->expect_password && (debug_flag > 1)) {
 925                 if (!pairfind(request->config_items, PW_CLEARTEXT_PASSWORD, 0, TAG_ANY) &&
 926                     !pairfind(request->config_items, PW_NT_PASSWORD, 0, TAG_ANY) &&
 927                     !pairfind(request->config_items, PW_USER_PASSWORD, 0, TAG_ANY) &&
 928                     !pairfind(request->config_items, PW_PASSWORD_WITH_HEADER, 0, TAG_ANY) &&
 929                     !pairfind(request->config_items, PW_CRYPT_PASSWORD, 0, TAG_ANY)) {
 930                         RDEBUGW("No \"reference\" password added. Ensure the admin user has permission to "
 931                                 "read the password attribute");
 932                         RDEBUGW("PAP authentication will *NOT* work with Active Directory (if that is what you "
 933                                 "were trying to configure)");
 934                 }
 935        }
 936 }
 937
 938 #if LDAP_SET_REBIND_PROC_ARGS == 3
 939 /** Callback for OpenLDAP to rebind and chase referrals
 940  *
 941  * Called by OpenLDAP when it receives a referral and has to rebind.
 942  *
 943  * @param handle to rebind.
 944  * @param url to bind to.
 945  * @param request that triggered the rebind.
 946  * @param msgid that triggered the rebind.
 947  * @param ctx rlm_ldap configuration.
 948  */
 949 static int rlm_ldap_rebind(LDAP *handle, LDAP_CONST char *url, UNUSED ber_tag_t request, UNUSED ber_int_t msgid,
 950                            void *ctx)
 951 {
 952         rlm_rcode_t rcode;
 953         ldap_handle_t *conn = ctx;
 954
 955         int ldap_errno;
 956
 957         conn->referred = TRUE;
 958         conn->rebound = TRUE;   /* not really, but oh well... */
 959         rad_assert(handle == conn->handle);
 960
 961         DEBUG("rlm_ldap (%s): Rebinding to URL %s", conn->inst->xlat_name, url);
 962
 963         rcode = rlm_ldap_bind(conn->inst, NULL, &conn, conn->inst->login, conn->inst->password, FALSE);
 964
 965         if (rcode == RLM_MODULE_OK) {
 966                 return LDAP_SUCCESS;
 967         }
 968
 969         ldap_get_option(handle, LDAP_OPT_ERROR_NUMBER, &ldap_errno);
 970
 971         return ldap_errno;
 972 }
 973 #endif
 974
 975 /** Create and return a new connection
 976  *
 977  * Create a new ldap connection and allocate memory for a new rlm_handle_t
 978  *
 979  * @param ctx rlm_ldap instance.
 980  * @return A new connection handle or NULL on error.
 981  */
 982 void *rlm_ldap_conn_create(void *ctx)
 983 {
 984         rlm_rcode_t rcode;
 985
 986         int ldap_errno, ldap_version;
 987         struct timeval tv;
 988
 989         ldap_instance_t *inst = ctx;
 990         LDAP *handle = NULL;
 991         ldap_handle_t *conn = NULL;
 992
 993 #ifdef HAVE_LDAP_INITIALIZE
 994         if (inst->is_url) {
 995                 DEBUG("rlm_ldap (%s): Connecting to %s", inst->xlat_name, inst->server);
 996
 997                 ldap_errno = ldap_initialize(&handle, inst->server);
 998                 if (ldap_errno != LDAP_SUCCESS) {
 999                         LDAP_ERR("ldap_initialize failed: %s", ldap_err2string(ldap_errno));
1000                         goto error;
1001                 }
1002         } else
1003 #endif
1004         {
1005                 DEBUG("rlm_ldap (%s): Connecting to %s:%d", inst->xlat_name, inst->server, inst->port);
1006
1007                 handle = ldap_init(inst->server, inst->port);
1008                 if (!handle) {
1009                         LDAP_ERR("ldap_init() failed");
1010                         goto error;
1011                 }
1012         }
1013
1014         /*
1015          *      We now have a connection structure, but no actual TCP connection.
1016          *
1017          *      Set a bunch of LDAP options, using common code.
1018          */
1019 #define do_ldap_option(_option, _name, _value) \
1020         if (ldap_set_option(handle, _option, _value) != LDAP_OPT_SUCCESS) { \
1021                 ldap_get_option(handle, LDAP_OPT_ERROR_NUMBER, &ldap_errno); \
1022                 LDAP_ERR("Could not set %s: %s", _name, ldap_err2string(ldap_errno)); \
1023         }
1024
1025         if (inst->ldap_debug) {
1026                 do_ldap_option(LDAP_OPT_DEBUG_LEVEL, "ldap_debug", &(inst->ldap_debug));
1027         }
1028
1029         /*
1030          *      Leave "chase_referrals" unset to use the OpenLDAP default.
1031          */
1032         if (inst->chase_referrals != 2) {
1033                 if (inst->chase_referrals) {
1034                         do_ldap_option(LDAP_OPT_REFERRALS, "chase_referrals", LDAP_OPT_ON);
1035
1036                         if (inst->rebind == 1) {
1037 #if LDAP_SET_REBIND_PROC_ARGS == 3
1038                                 ldap_set_rebind_proc(handle, rlm_ldap_rebind, inst);
1039 #else
1040                                 DEBUGW("The flag 'rebind = yes' is not supported by the system LDAP library. "
1041                                        "Ignoring.");
1042 #endif
1043                         }
1044                 } else {
1045                         do_ldap_option(LDAP_OPT_REFERRALS, "chase_referrals", LDAP_OPT_OFF);
1046                 }
1047         }
1048
1049         tv.tv_sec = inst->net_timeout;
1050         tv.tv_usec = 0;
1051         do_ldap_option(LDAP_OPT_NETWORK_TIMEOUT, "net_timeout", &tv);
1052
1053         do_ldap_option(LDAP_OPT_TIMELIMIT, "timelimit", &(inst->timelimit));
1054
1055         ldap_version = LDAP_VERSION3;
1056         do_ldap_option(LDAP_OPT_PROTOCOL_VERSION, "ldap_version", &ldap_version);
1057
1058 #ifdef LDAP_OPT_X_KEEPALIVE_IDLE
1059         do_ldap_option(LDAP_OPT_X_KEEPALIVE_IDLE, "keepalive idle", &(inst->keepalive_idle));
1060 #endif
1061
1062 #ifdef LDAP_OPT_X_KEEPALIVE_PROBES
1063         do_ldap_option(LDAP_OPT_X_KEEPALIVE_PROBES, "keepalive probes", &(inst->keepalive_probes));
1064 #endif
1065
1066 #ifdef LDAP_OPT_X_KEEPALIVE_INTERVAL
1067         do_ldap_option(LDAP_OPT_X_KEEPALIVE_INTERVAL, "keepalive interval", &(inst->keepalive_interval));
1068 #endif
1069
1070 #ifdef HAVE_LDAP_START_TLS
1071         /*
1072          *      Set all of the TLS options
1073          */
1074         if (inst->tls_mode) {
1075                 do_ldap_option(LDAP_OPT_X_TLS, "tls_mode", &(inst->tls_mode));
1076         }
1077
1078 #  define maybe_ldap_option(_option, _name, _value) \
1079         if (_value) do_ldap_option(_option, _name, _value)
1080
1081         maybe_ldap_option(LDAP_OPT_X_TLS_CACERTFILE, "cacertfile", inst->tls_cacertfile);
1082         maybe_ldap_option(LDAP_OPT_X_TLS_CACERTDIR, "cacertdir", inst->tls_cacertdir);
1083
1084 #  ifdef HAVE_LDAP_INT_TLS_CONFIG
1085         if (ldap_int_tls_config(NULL, LDAP_OPT_X_TLS_REQUIRE_CERT, inst->tls_require_cert) != LDAP_OPT_SUCCESS) {
1086                 ldap_get_option(handle, LDAP_OPT_ERROR_NUMBER, &ldap_errno);
1087
1088                 LDAP_ERR("Could not set LDAP_OPT_X_TLS_REQUIRE_CERT option to %s: %s", inst->tls_require_cert,
1089                          ldap_err2string(ldap_errno));
1090         }
1091 #  endif
1092
1093         /*
1094          *      Set certificate options
1095          */
1096         maybe_ldap_option(LDAP_OPT_X_TLS_CERTFILE, "certfile", inst->tls_certfile);
1097         maybe_ldap_option(LDAP_OPT_X_TLS_KEYFILE, "keyfile", inst->tls_keyfile);
1098         maybe_ldap_option(LDAP_OPT_X_TLS_RANDOM_FILE, "randfile", inst->tls_randfile);
1099
1100         /*
1101          *      And finally start the TLS code.
1102          */
1103         if (inst->start_tls) {
1104                 if (inst->port == 636) {
1105                         DEBUGW("Told to Start TLS on LDAPS port this will probably fail, please correct the "
1106                                "configuration");
1107                 }
1108
1109                 if (ldap_start_tls_s(handle, NULL, NULL) != LDAP_SUCCESS) {
1110                         ldap_get_option(handle, LDAP_OPT_ERROR_NUMBER, &ldap_errno);
1111
1112                         LDAP_ERR("Could not start TLS: %s", ldap_err2string(ldap_errno));
1113                         goto error;
1114                 }
1115         }
1116 #endif /* HAVE_LDAP_START_TLS */
1117
1118         /*
1119          *      Allocate memory for the handle.
1120          */
1121         conn = talloc_zero(ctx, ldap_handle_t);
1122         conn->inst = inst;
1123         conn->handle = handle;
1124         conn->rebound = FALSE;
1125         conn->referred = FALSE;
1126
1127         rcode = rlm_ldap_bind(inst, NULL, &conn, inst->login, inst->password, FALSE);
1128         if (rcode != RLM_MODULE_OK) {
1129                 goto error;
1130         }
1131
1132         return conn;
1133
1134         error:
1135         if (handle) ldap_unbind_s(handle);
1136         if (conn) talloc_free(conn);
1137
1138         return NULL;
1139 }
1140
1141
1142 /** Close and delete a connection
1143  *
1144  * Unbinds the LDAP connection, informing the server and freeing any memory, then releases the memory used by the
1145  * connection handle.
1146  *
1147  * @param ctx unused.
1148  * @param connection to destroy.
1149  * @return always indicates success.
1150  */
1151 int rlm_ldap_conn_delete(UNUSED void *ctx, void *connection)
1152 {
1153         ldap_handle_t *conn = connection;
1154
1155         ldap_unbind_s(conn->handle);
1156         talloc_free(conn);
1157
1158         return 0;
1159 }
1160
1161
1162 /** Gets an LDAP socket from the connection pool
1163  *
1164  * Retrieve a socket from the connection pool, or NULL on error (of if no sockets are available).
1165  *
1166  * @param inst rlm_ldap configuration.
1167  * @param request Current request.
1168  */
1169 ldap_handle_t *rlm_ldap_get_socket(const ldap_instance_t *inst, REQUEST *request)
1170 {
1171         ldap_handle_t *conn;
1172
1173         conn = fr_connection_get(inst->pool);
1174         if (!conn) {
1175                 RDEBUGE("All ldap connections are in use");
1176
1177                 return NULL;
1178         }
1179
1180         return conn;
1181 }
1182
1183 /** Frees an LDAP socket back to the connection pool
1184  *
1185  * If the socket was rebound chasing a referral onto another server then we destroy it.
1186  * If the socket was rebound to another user on the same server, we let the next caller rebind it.
1187  *
1188  * @param inst rlm_ldap configuration.
1189  * @param conn to release.
1190  */
1191 void rlm_ldap_release_socket(const ldap_instance_t *inst, ldap_handle_t *conn)
1192 {
1193         /*
1194          *      Could have already been free'd due to a previous error.
1195          */
1196         if (!conn) return;
1197
1198         /*
1199          *      We chased a referral to another server.
1200          *
1201          *      This connection is no longer part of the pool which is connected to and bound to the configured server.
1202          *      Close it.
1203          *
1204          *      Note that we do NOT close it if it was bound to another user.  Instead, we let the next caller do the
1205          *      rebind.
1206          */
1207         if (conn->referred) {
1208                 fr_connection_del(inst->pool, conn);
1209                 return;
1210         }
1211
1212         fr_connection_release(inst->pool, conn);
1213         return;
1214 }