src/src/lookups/ldap.c

   1 /*************************************************
   2 *     Exim - an Internet mail transport agent    *
   3 *************************************************/
   4
   5 /* Copyright (c) University of Cambridge 1995 - 2009 */
   6 /* See the file NOTICE for conditions of use and distribution. */
   7
   8 /* Many thanks to Stuart Lynne for contributing the original code for this
   9 driver. Further contibutions from Michael Haardt, Brian Candler, Barry
  10 Pederson, Peter Savitch and Christian Kellner. Particular thanks to Brian for
  11 researching how to handle the different kinds of error. */
  12
  13
  14 #include "../exim.h"
  15 #include "lf_functions.h"
  16
  17
  18 /* Include LDAP headers. The code below uses some "old" LDAP interfaces that
  19 are deprecated in OpenLDAP. I don't know their status in other LDAP
  20 implementations. LDAP_DEPRECATED causes their prototypes to be defined in
  21 ldap.h. */
  22
  23 #define LDAP_DEPRECATED 1
  24
  25 #include <lber.h>
  26 #include <ldap.h>
  27
  28
  29 /* Annoyingly, the different LDAP libraries handle errors in different ways,
  30 and some other things too. There doesn't seem to be an automatic way of
  31 distinguishing between them. Local/Makefile should contain a setting of
  32 LDAP_LIB_TYPE, which in turn causes appropriate macros to be defined for the
  33 different kinds. Those that matter are:
  34
  35 LDAP_LIB_NETSCAPE
  36 LDAP_LIB_SOLARIS   with synonym LDAP_LIB_SOLARIS7
  37 LDAP_LIB_OPENLDAP2
  38
  39 These others may be defined, but are in fact the default, so are not tested:
  40
  41 LDAP_LIB_UMICHIGAN
  42 LDAP_LIB_OPENLDAP1
  43 */
  44
  45 #if defined(LDAP_LIB_SOLARIS7) && ! defined(LDAP_LIB_SOLARIS)
  46 #define LDAP_LIB_SOLARIS
  47 #endif
  48
  49
  50 /* Just in case LDAP_NO_LIMIT is not defined by some of these libraries. */
  51
  52 #ifndef LDAP_NO_LIMIT
  53 #define LDAP_NO_LIMIT 0
  54 #endif
  55
  56
  57 /* Just in case LDAP_DEREF_NEVER is not defined */
  58
  59 #ifndef LDAP_DEREF_NEVER
  60 #define LDAP_DEREF_NEVER 0
  61 #endif
  62
  63
  64 /* Four types of LDAP search are implemented */
  65
  66 #define SEARCH_LDAP_MULTIPLE 0       /* Get attributes from multiple entries */
  67 #define SEARCH_LDAP_SINGLE 1         /* Get attributes from one entry only */
  68 #define SEARCH_LDAP_DN 2             /* Get just the DN from one entry */
  69 #define SEARCH_LDAP_AUTH 3           /* Just checking for authentication */
  70
  71 /* In all 4 cases, the DN is left in $ldap_dn (which post-dates the
  72 SEARCH_LDAP_DN lookup). */
  73
  74
  75 /* Structure and anchor for caching connections. */
  76
  77 typedef struct ldap_connection {
  78   struct ldap_connection *next;
  79   uschar *host;
  80   uschar *user;
  81   uschar *password;
  82   BOOL  bound;
  83   int   port;
  84   LDAP *ld;
  85 } LDAP_CONNECTION;
  86
  87 static LDAP_CONNECTION *ldap_connections = NULL;
  88
  89
  90
  91 /*************************************************
  92 *         Internal search function               *
  93 *************************************************/
  94
  95 /* This is the function that actually does the work. It is called (indirectly
  96 via control_ldap_search) from eldap_find(), eldapauth_find(), eldapdn_find(),
  97 and eldapm_find(), with a difference in the "search_type" argument.
  98
  99 The case of eldapauth_find() is special in that all it does is do
 100 authentication, returning OK or FAIL as appropriate. This isn't used as a
 101 lookup. Instead, it is called from expand.c as an expansion condition test.
 102
 103 The DN from a successful lookup is placed in $ldap_dn. This feature postdates
 104 the provision of the SEARCH_LDAP_DN facility for returning just the DN as the
 105 data.
 106
 107 Arguments:
 108   ldap_url      the URL to be looked up
 109   server        server host name, when URL contains none
 110   s_port        server port, used when URL contains no name
 111   search_type   SEARCH_LDAP_MULTIPLE allows values from multiple entries
 112                 SEARCH_LDAP_SINGLE allows values from one entry only
 113                 SEARCH_LDAP_DN gets the DN from one entry
 114   res           set to point at the result (not used for ldapauth)
 115   errmsg        set to point a message if result is not OK
 116   defer_break   set TRUE if no more servers to be tried after a DEFER
 117   user          user name for authentication, or NULL
 118   password      password for authentication, or NULL
 119   sizelimit     max number of entries returned, or 0 for no limit
 120   timelimit     max time to wait, or 0 for no limit
 121   tcplimit      max time for network activity, e.g. connect, or 0 for OS default
 122   deference     the dereference option, which is one of
 123                   LDAP_DEREF_{NEVER,SEARCHING,FINDING,ALWAYS}
 124   referrals     the referral option, which is LDAP_OPT_ON or LDAP_OPT_OFF
 125
 126 Returns:        OK or FAIL or DEFER
 127                 FAIL is given only if a lookup was performed successfully, but
 128                 returned no data.
 129 */
 130
 131 static int
 132 perform_ldap_search(uschar *ldap_url, uschar *server, int s_port, int search_type,
 133   uschar **res, uschar **errmsg, BOOL *defer_break, uschar *user, uschar *password,
 134   int sizelimit, int timelimit, int tcplimit, int dereference, void *referrals)
 135 {
 136 LDAPURLDesc     *ludp = NULL;
 137 LDAPMessage     *result = NULL;
 138 BerElement      *ber;
 139 LDAP_CONNECTION *lcp;
 140
 141 struct timeval timeout;
 142 struct timeval *timeoutptr = NULL;
 143
 144 uschar *attr;
 145 uschar **attrp;
 146 uschar *data = NULL;
 147 uschar *dn = NULL;
 148 uschar *host;
 149 uschar **values;
 150 uschar **firstval;
 151 uschar porttext[16];
 152
 153 uschar *error1 = NULL;   /* string representation of errcode (static) */
 154 uschar *error2 = NULL;   /* error message from the server */
 155 uschar *matched = NULL;  /* partially matched DN */
 156
 157 int    attr_count = 0;
 158 int    error_yield = DEFER;
 159 int    msgid;
 160 int    rc, ldap_rc, ldap_parse_rc;
 161 int    port;
 162 int    ptr = 0;
 163 int    rescount = 0;
 164 int    size = 0;
 165 BOOL   attribute_found = FALSE;
 166 BOOL   ldapi = FALSE;
 167
 168 DEBUG(D_lookup)
 169   debug_printf("perform_ldap_search: ldap%s URL = \"%s\" server=%s port=%d "
 170     "sizelimit=%d timelimit=%d tcplimit=%d\n",
 171     (search_type == SEARCH_LDAP_MULTIPLE)? "m" :
 172     (search_type == SEARCH_LDAP_DN)? "dn" :
 173     (search_type == SEARCH_LDAP_AUTH)? "auth" : "",
 174     ldap_url, server, s_port, sizelimit, timelimit, tcplimit);
 175
 176 /* Check if LDAP thinks the URL is a valid LDAP URL. We assume that if the LDAP
 177 library that is in use doesn't recognize, say, "ldapi", it will barf here. */
 178
 179 if (!ldap_is_ldap_url(CS ldap_url))
 180   {
 181   *errmsg = string_sprintf("ldap_is_ldap_url: not an LDAP url \"%s\"\n",
 182     ldap_url);
 183   goto RETURN_ERROR_BREAK;
 184   }
 185
 186 /* Parse the URL */
 187
 188 if ((rc = ldap_url_parse(CS ldap_url, &ludp)) != 0)
 189   {
 190   *errmsg = string_sprintf("ldap_url_parse: (error %d) parsing \"%s\"\n", rc,
 191     ldap_url);
 192   goto RETURN_ERROR_BREAK;
 193   }
 194
 195 /* If the host name is empty, take it from the separate argument, if one is
 196 given. OpenLDAP 2.0.6 sets an unset hostname to "" rather than empty, but
 197 expects NULL later in ldap_init() to mean "default", annoyingly. In OpenLDAP
 198 2.0.11 this has changed (it uses NULL). */
 199
 200 if ((ludp->lud_host == NULL || ludp->lud_host[0] == 0) && server != NULL)
 201   {
 202   host = server;
 203   port = s_port;
 204   }
 205 else
 206   {
 207   host = US ludp->lud_host;
 208   if (host != NULL && host[0] == 0) host = NULL;
 209   port = ludp->lud_port;
 210   }
 211
 212 DEBUG(D_lookup) debug_printf("after ldap_url_parse: host=%s port=%d\n",
 213   host, port);
 214
 215 if (port == 0) port = LDAP_PORT;      /* Default if none given */
 216 sprintf(CS porttext, ":%d", port);    /* For messages */
 217
 218 /* If the "host name" is actually a path, we are going to connect using a Unix
 219 socket, regardless of whether "ldapi" was actually specified or not. This means
 220 that a Unix socket can be declared in eldap_default_servers, and "traditional"
 221 LDAP queries using just "ldap" can be used ("ldaps" is similarly overridden).
 222 The path may start with "/" or it may already be escaped as "%2F" if it was
 223 actually declared that way in eldap_default_servers. (I did it that way the
 224 first time.) If the host name is not a path, the use of "ldapi" causes an
 225 error, except in the default case. (But lud_scheme doesn't seem to exist in
 226 older libraries.) */
 227
 228 if (host != NULL)
 229   {
 230   if ((host[0] == '/' || Ustrncmp(host, "%2F", 3) == 0))
 231     {
 232     ldapi = TRUE;
 233     porttext[0] = 0;    /* Remove port from messages */
 234     }
 235
 236   #if defined LDAP_LIB_OPENLDAP2
 237   else if (strncmp(ludp->lud_scheme, "ldapi", 5) == 0)
 238     {
 239     *errmsg = string_sprintf("ldapi requires an absolute path (\"%s\" given)",
 240       host);
 241     goto RETURN_ERROR;
 242     }
 243   #endif
 244   }
 245
 246 /* Count the attributes; we need this later to tell us how to format results */
 247
 248 for (attrp = USS ludp->lud_attrs; attrp != NULL && *attrp != NULL; attrp++)
 249   attr_count++;
 250
 251 /* See if we can find a cached connection to this host. The port is not
 252 relevant for ldapi. The host name pointer is set to NULL if no host was given
 253 (implying the library default), rather than to the empty string. Note that in
 254 this case, there is no difference between ldap and ldapi. */
 255
 256 for (lcp = ldap_connections; lcp != NULL; lcp = lcp->next)
 257   {
 258   if ((host == NULL) != (lcp->host == NULL) ||
 259       (host != NULL && strcmpic(lcp->host, host) != 0))
 260     continue;
 261   if (ldapi || port == lcp->port) break;
 262   }
 263
 264 /* Use this network timeout in any requests. */
 265
 266 if (tcplimit > 0)
 267   {
 268   timeout.tv_sec = tcplimit;
 269   timeout.tv_usec = 0;
 270   timeoutptr = &timeout;
 271   }
 272
 273 /* If no cached connection found, we must open a connection to the server. If
 274 the server name is actually an absolute path, we set ldapi=TRUE above. This
 275 requests connection via a Unix socket. However, as far as I know, only OpenLDAP
 276 supports the use of sockets, and the use of ldap_initialize(). */
 277
 278 if (lcp == NULL)
 279   {
 280   LDAP *ld;
 281
 282
 283   /* --------------------------- OpenLDAP ------------------------ */
 284
 285   /* There seems to be a preference under OpenLDAP for ldap_initialize()
 286   instead of ldap_init(), though I have as yet been unable to find
 287   documentation that says this. (OpenLDAP documentation is sparse to
 288   non-existent). So we handle OpenLDAP differently here. Also, support for
 289   ldapi seems to be OpenLDAP-only at present. */
 290
 291   #ifdef LDAP_LIB_OPENLDAP2
 292
 293   /* We now need an empty string for the default host. Get some store in which
 294   to build a URL for ldap_initialize(). In the ldapi case, it can't be bigger
 295   than (9 + 3*Ustrlen(shost)), whereas in the other cases it can't be bigger
 296   than the host name + "ldaps:///" plus : and a port number, say 20 + the
 297   length of the host name. What we get should accommodate both, easily. */
 298
 299   uschar *shost = (host == NULL)? US"" : host;
 300   uschar *init_url = store_get(20 + 3 * Ustrlen(shost));
 301   uschar *init_ptr;
 302
 303   /* Handle connection via Unix socket ("ldapi"). We build a basic LDAP URI to
 304   contain the path name, with slashes escaped as %2F. */
 305
 306   if (ldapi)
 307     {
 308     int ch;
 309     init_ptr = init_url + 8;
 310     Ustrcpy(init_url, "ldapi://");
 311     while ((ch = *shost++) != 0)
 312       {
 313       if (ch == '/')
 314         {
 315         Ustrncpy(init_ptr, "%2F", 3);
 316         init_ptr += 3;
 317         }
 318       else *init_ptr++ = ch;
 319       }
 320     *init_ptr = 0;
 321     }
 322
 323   /* This is not an ldapi call. Just build a URI with the protocol type, host
 324   name, and port. */
 325
 326   else
 327     {
 328     init_ptr = Ustrchr(ldap_url, '/');
 329     Ustrncpy(init_url, ldap_url, init_ptr - ldap_url);
 330     init_ptr = init_url + (init_ptr - ldap_url);
 331     sprintf(CS init_ptr, "//%s:%d/", shost, port);
 332     }
 333
 334   /* Call ldap_initialize() and check the result */
 335
 336   DEBUG(D_lookup) debug_printf("ldap_initialize with URL %s\n", init_url);
 337   rc = ldap_initialize(&ld, CS init_url);
 338   if (rc != LDAP_SUCCESS)
 339     {
 340     *errmsg = string_sprintf("ldap_initialize: (error %d) URL \"%s\"\n",
 341       rc, init_url);
 342     goto RETURN_ERROR;
 343     }
 344   store_reset(init_url);   /* Might as well save memory when we can */
 345
 346
 347   /* ------------------------- Not OpenLDAP ---------------------- */
 348
 349   /* For libraries other than OpenLDAP, use ldap_init(). */
 350
 351   #else   /* LDAP_LIB_OPENLDAP2 */
 352   ld = ldap_init(CS host, port);
 353   #endif  /* LDAP_LIB_OPENLDAP2 */
 354
 355   /* -------------------------------------------------------------- */
 356
 357
 358   /* Handle failure to initialize */
 359
 360   if (ld == NULL)
 361     {
 362     *errmsg = string_sprintf("failed to initialize for LDAP server %s%s - %s",
 363       host, porttext, strerror(errno));
 364     goto RETURN_ERROR;
 365     }
 366
 367   /* Set the TCP connect time limit if available. This is something that is
 368   in Netscape SDK v4.1; I don't know about other libraries. */
 369
 370   #ifdef LDAP_X_OPT_CONNECT_TIMEOUT
 371   if (tcplimit > 0)
 372     {
 373     int timeout1000 = tcplimit*1000;
 374     ldap_set_option(ld, LDAP_X_OPT_CONNECT_TIMEOUT, (void *)&timeout1000);
 375     }
 376   else
 377     {
 378     int notimeout = LDAP_X_IO_TIMEOUT_NO_TIMEOUT;
 379     ldap_set_option(ld, LDAP_X_OPT_CONNECT_TIMEOUT, (void *)&notimeout);
 380     }
 381   #endif
 382
 383   /* Set the TCP connect timeout. This works with OpenLDAP 2.2.14. */
 384
 385   #ifdef LDAP_OPT_NETWORK_TIMEOUT
 386   if (tcplimit > 0)
 387     ldap_set_option(ld, LDAP_OPT_NETWORK_TIMEOUT, (void *)timeoutptr);
 388   #endif
 389
 390   /* I could not get TLS to work until I set the version to 3. That version
 391   seems to be the default nowadays. The RFC is dated 1997, so I would hope
 392   that all the LDAP libraries support it. Therefore, if eldap_version hasn't
 393   been set, go for v3 if we can. */
 394
 395   if (eldap_version < 0)
 396     {
 397     #ifdef LDAP_VERSION3
 398     eldap_version = LDAP_VERSION3;
 399     #else
 400     eldap_version = 2;
 401     #endif
 402     }
 403
 404   #ifdef LDAP_OPT_PROTOCOL_VERSION
 405   ldap_set_option(ld, LDAP_OPT_PROTOCOL_VERSION, (void *)&eldap_version);
 406   #endif
 407
 408   DEBUG(D_lookup) debug_printf("initialized for LDAP (v%d) server %s%s\n",
 409     eldap_version, host, porttext);
 410
 411   /* If not using ldapi and TLS is available, set appropriate TLS options: hard
 412   for "ldaps" and soft otherwise. */
 413
 414   #ifdef LDAP_OPT_X_TLS
 415   if (!ldapi)
 416     {
 417     int tls_option;
 418     if (strncmp(ludp->lud_scheme, "ldaps", 5) == 0)
 419       {
 420       tls_option = LDAP_OPT_X_TLS_HARD;
 421       DEBUG(D_lookup) debug_printf("LDAP_OPT_X_TLS_HARD set\n");
 422       }
 423     else
 424       {
 425       tls_option = LDAP_OPT_X_TLS_TRY;
 426       DEBUG(D_lookup) debug_printf("LDAP_OPT_X_TLS_TRY set\n");
 427       }
 428     ldap_set_option(ld, LDAP_OPT_X_TLS, (void *)&tls_option);
 429     }
 430   #endif  /* LDAP_OPT_X_TLS */
 431
 432   #ifdef LDAP_OPT_X_TLS_CACERTFILE
 433   if (eldap_ca_cert_file != NULL)
 434     {
 435     ldap_set_option(ld, LDAP_OPT_X_TLS_CACERTFILE, eldap_ca_cert_file);
 436     }
 437   #endif
 438   #ifdef LDAP_OPT_X_TLS_CACERTDIR
 439   if (eldap_ca_cert_dir != NULL)
 440     {
 441     ldap_set_option(ld, LDAP_OPT_X_TLS_CACERTDIR, eldap_ca_cert_dir);
 442     }
 443   #endif
 444   #ifdef LDAP_OPT_X_TLS_CERTFILE
 445   if (eldap_cert_file != NULL)
 446     {
 447     ldap_set_option(ld, LDAP_OPT_X_TLS_CERTFILE, eldap_cert_file);
 448     }
 449   #endif
 450   #ifdef LDAP_OPT_X_TLS_KEYFILE
 451   if (eldap_cert_key != NULL)
 452     {
 453     ldap_set_option(ld, LDAP_OPT_X_TLS_KEYFILE, eldap_cert_key);
 454     }
 455   #endif
 456   #ifdef LDAP_OPT_X_TLS_CIPHER_SUITE
 457   if (eldap_cipher_suite != NULL)
 458     {
 459     ldap_set_option(ld, LDAP_OPT_X_TLS_CIPHER_SUITE, eldap_cipher_suite);
 460     }
 461   #endif
 462   #ifdef LDAP_OPT_X_TLS_REQUIRE_CERT
 463   if (eldap_require_cert != NULL)
 464     {
 465     int cert_option = LDAP_OPT_X_TLS_NEVER;
 466     if (Ustrcmp(eldap_require_cert, "hard") == 0)
 467       {
 468       cert_option = LDAP_OPT_X_TLS_HARD;
 469       }
 470     else if (Ustrcmp(eldap_require_cert, "demand") == 0)
 471       {
 472       cert_option = LDAP_OPT_X_TLS_DEMAND;
 473       }
 474     else if (Ustrcmp(eldap_require_cert, "allow") == 0)
 475       {
 476       cert_option = LDAP_OPT_X_TLS_ALLOW;
 477       }
 478     else if (Ustrcmp(eldap_require_cert, "try") == 0)
 479       {
 480       cert_option = LDAP_OPT_X_TLS_TRY;
 481       }
 482     ldap_set_option(ld, LDAP_OPT_X_TLS_REQUIRE_CERT, &cert_option);
 483     }
 484   #endif
 485
 486   /* Now add this connection to the chain of cached connections */
 487
 488   lcp = store_get(sizeof(LDAP_CONNECTION));
 489   lcp->host = (host == NULL)? NULL : string_copy(host);
 490   lcp->bound = FALSE;
 491   lcp->user = NULL;
 492   lcp->password = NULL;
 493   lcp->port = port;
 494   lcp->ld = ld;
 495   lcp->next = ldap_connections;
 496   ldap_connections = lcp;
 497   }
 498
 499 /* Found cached connection */
 500
 501 else
 502   {
 503   DEBUG(D_lookup)
 504     debug_printf("re-using cached connection to LDAP server %s%s\n",
 505       host, porttext);
 506   }
 507
 508 /* Bind with the user/password supplied, or an anonymous bind if these values
 509 are NULL, unless a cached connection is already bound with the same values. */
 510
 511 if (!lcp->bound ||
 512     (lcp->user == NULL && user != NULL) ||
 513     (lcp->user != NULL && user == NULL) ||
 514     (lcp->user != NULL && user != NULL && Ustrcmp(lcp->user, user) != 0) ||
 515     (lcp->password == NULL && password != NULL) ||
 516     (lcp->password != NULL && password == NULL) ||
 517     (lcp->password != NULL && password != NULL &&
 518       Ustrcmp(lcp->password, password) != 0))
 519   {
 520   DEBUG(D_lookup) debug_printf("%sbinding with user=%s password=%s\n",
 521     (lcp->bound)? "re-" : "", user, password);
 522 #ifdef LDAP_OPT_X_TLS
 523   /* The Oracle LDAP libraries (LDAP_LIB_TYPE=SOLARIS) don't support this: */
 524   if (eldap_start_tls)
 525     {
 526     ldap_start_tls_s(lcp->ld, NULL, NULL);
 527     }
 528 #endif
 529   if ((msgid = ldap_bind(lcp->ld, CS user, CS password, LDAP_AUTH_SIMPLE))
 530        == -1)
 531     {
 532     *errmsg = string_sprintf("failed to bind the LDAP connection to server "
 533       "%s%s - ldap_bind() returned -1", host, porttext);
 534     goto RETURN_ERROR;
 535     }
 536
 537   if ((rc = ldap_result( lcp->ld, msgid, 1, timeoutptr, &result )) <= 0)
 538     {
 539     *errmsg = string_sprintf("failed to bind the LDAP connection to server "
 540       "%s%s - LDAP error: %s", host, porttext,
 541       rc == -1 ? "result retrieval failed" : "timeout" );
 542     result = NULL;
 543     goto RETURN_ERROR;
 544     }
 545
 546   rc = ldap_result2error( lcp->ld, result, 0 );
 547
 548   /* Invalid credentials when just checking credentials returns FAIL. This
 549   stops any further servers being tried. */
 550
 551   if (search_type == SEARCH_LDAP_AUTH && rc == LDAP_INVALID_CREDENTIALS)
 552     {
 553     DEBUG(D_lookup)
 554       debug_printf("Invalid credentials: ldapauth returns FAIL\n");
 555     error_yield = FAIL;
 556     goto RETURN_ERROR_NOMSG;
 557     }
 558
 559   /* Otherwise we have a problem that doesn't stop further servers from being
 560   tried. */
 561
 562   if (rc != LDAP_SUCCESS)
 563     {
 564     *errmsg = string_sprintf("failed to bind the LDAP connection to server "
 565       "%s%s - LDAP error %d: %s", host, porttext, rc, ldap_err2string(rc));
 566     goto RETURN_ERROR;
 567     }
 568
 569   /* Successful bind */
 570
 571   lcp->bound = TRUE;
 572   lcp->user = (user == NULL)? NULL : string_copy(user);
 573   lcp->password = (password == NULL)? NULL : string_copy(password);
 574
 575   ldap_msgfree(result);
 576   result = NULL;
 577   }
 578
 579 /* If we are just checking credentials, return OK. */
 580
 581 if (search_type == SEARCH_LDAP_AUTH)
 582   {
 583   DEBUG(D_lookup) debug_printf("Bind succeeded: ldapauth returns OK\n");
 584   goto RETURN_OK;
 585   }
 586
 587 /* Before doing the search, set the time and size limits (if given). Here again
 588 the different implementations of LDAP have chosen to do things differently. */
 589
 590 #if defined(LDAP_OPT_SIZELIMIT)
 591 ldap_set_option(lcp->ld, LDAP_OPT_SIZELIMIT, (void *)&sizelimit);
 592 ldap_set_option(lcp->ld, LDAP_OPT_TIMELIMIT, (void *)&timelimit);
 593 #else
 594 lcp->ld->ld_sizelimit = sizelimit;
 595 lcp->ld->ld_timelimit = timelimit;
 596 #endif
 597
 598 /* Similarly for dereferencing aliases. Don't know if this is possible on
 599 an LDAP library without LDAP_OPT_DEREF. */
 600
 601 #if defined(LDAP_OPT_DEREF)
 602 ldap_set_option(lcp->ld, LDAP_OPT_DEREF, (void *)&dereference);
 603 #endif
 604
 605 /* Similarly for the referral setting; should the library follow referrals that
 606 the LDAP server returns? The conditional is just in case someone uses a library
 607 without it. */
 608
 609 #if defined(LDAP_OPT_REFERRALS)
 610 ldap_set_option(lcp->ld, LDAP_OPT_REFERRALS, referrals);
 611 #endif
 612
 613 /* Start the search on the server. */
 614
 615 DEBUG(D_lookup) debug_printf("Start search\n");
 616
 617 msgid = ldap_search(lcp->ld, ludp->lud_dn, ludp->lud_scope, ludp->lud_filter,
 618   ludp->lud_attrs, 0);
 619
 620 if (msgid == -1)
 621   {
 622   #if defined LDAP_LIB_SOLARIS || defined LDAP_LIB_OPENLDAP2
 623   int err;
 624   ldap_get_option(lcp->ld, LDAP_OPT_ERROR_NUMBER, &err);
 625   *errmsg = string_sprintf("ldap_search failed: %d, %s", err,
 626     ldap_err2string(err));
 627
 628   #else
 629   *errmsg = string_sprintf("ldap_search failed");
 630   #endif
 631
 632   goto RETURN_ERROR;
 633   }
 634
 635 /* Loop to pick up results as they come in, setting a timeout if one was
 636 given. */
 637
 638 while ((rc = ldap_result(lcp->ld, msgid, 0, timeoutptr, &result)) ==
 639         LDAP_RES_SEARCH_ENTRY)
 640   {
 641   LDAPMessage  *e;
 642
 643   DEBUG(D_lookup) debug_printf("ldap_result loop\n");
 644
 645   for(e = ldap_first_entry(lcp->ld, result);
 646       e != NULL;
 647       e = ldap_next_entry(lcp->ld, e))
 648     {
 649     uschar *new_dn;
 650     BOOL insert_space = FALSE;
 651
 652     DEBUG(D_lookup) debug_printf("LDAP entry loop\n");
 653
 654     rescount++;   /* Count results */
 655
 656     /* Results for multiple entries values are separated by newlines. */
 657
 658     if (data != NULL) data = string_cat(data, &size, &ptr, US"\n", 1);
 659
 660     /* Get the DN from the last result. */
 661
 662     new_dn = US ldap_get_dn(lcp->ld, e);
 663     if (new_dn != NULL)
 664       {
 665       if (dn != NULL)
 666         {
 667         #if defined LDAP_LIB_NETSCAPE || defined LDAP_LIB_OPENLDAP2
 668         ldap_memfree(dn);
 669         #else   /* OPENLDAP 1, UMich, Solaris */
 670         free(dn);
 671         #endif
 672         }
 673       /* Save for later */
 674       dn = new_dn;
 675       }
 676
 677     /* If the data we want is actually the DN rather than any attribute values,
 678     (an "ldapdn" search) add it to the data string. If there are multiple
 679     entries, the DNs will be concatenated, but we test for this case below, as
 680     for SEARCH_LDAP_SINGLE, and give an error. */
 681
 682     if (search_type == SEARCH_LDAP_DN)   /* Do not amalgamate these into one */
 683       {                                  /* condition, because of the else */
 684       if (new_dn != NULL)                /* below, that's for the first only */
 685         {
 686         data = string_cat(data, &size, &ptr, new_dn, Ustrlen(new_dn));
 687         data[ptr] = 0;
 688         attribute_found = TRUE;
 689         }
 690       }
 691
 692     /* Otherwise, loop through the entry, grabbing attribute values. If there's
 693     only one attribute being retrieved, no attribute name is given, and the
 694     result is not quoted. Multiple values are separated by (comma, space).
 695     If more than one attribute is being retrieved, the data is given as a
 696     sequence of name=value pairs, with the value always in quotes. If there are
 697     multiple values, they are given within the quotes, comma separated. */
 698
 699     else for (attr = US ldap_first_attribute(lcp->ld, e, &ber);
 700               attr != NULL;
 701               attr = US ldap_next_attribute(lcp->ld, e, ber))
 702       {
 703       if (attr[0] != 0)
 704         {
 705         /* Get array of values for this attribute. */
 706
 707         if ((firstval = values = USS ldap_get_values(lcp->ld, e, CS attr))
 708              != NULL)
 709           {
 710           if (attr_count != 1)
 711             {
 712             if (insert_space)
 713               data = string_cat(data, &size, &ptr, US" ", 1);
 714             else
 715               insert_space = TRUE;
 716             data = string_cat(data, &size, &ptr, attr, Ustrlen(attr));
 717             data = string_cat(data, &size, &ptr, US"=\"", 2);
 718             }
 719
 720           while (*values != NULL)
 721             {
 722             uschar *value = *values;
 723             int len = Ustrlen(value);
 724
 725             DEBUG(D_lookup) debug_printf("LDAP attr loop %s:%s\n", attr, value);
 726
 727             if (values != firstval)
 728               data = string_cat(data, &size, &ptr, US",", 1);
 729
 730             /* For multiple attributes, the data is in quotes. We must escape
 731             internal quotes, backslashes, newlines, and must double commas. */
 732
 733             if (attr_count != 1)
 734               {
 735               int j;
 736               for (j = 0; j < len; j++)
 737                 {
 738                 if (value[j] == '\n')
 739                   data = string_cat(data, &size, &ptr, US"\\n", 2);
 740                 else if (value[j] == ',')
 741                   data = string_cat(data, &size, &ptr, US",,", 2);
 742                 else
 743                   {
 744                   if (value[j] == '\"' || value[j] == '\\')
 745                     data = string_cat(data, &size, &ptr, US"\\", 1);
 746                   data = string_cat(data, &size, &ptr, value+j, 1);
 747                   }
 748                 }
 749               }
 750
 751             /* For single attributes, just double commas */
 752
 753             else
 754               {
 755               int j;
 756               for (j = 0; j < len; j++)
 757                 {
 758                 if (value[j] == ',')
 759                   data = string_cat(data, &size, &ptr, US",,", 2);
 760                 else
 761                   data = string_cat(data, &size, &ptr, value+j, 1);
 762                 }
 763               }
 764
 765
 766             /* Move on to the next value */
 767
 768             values++;
 769             attribute_found = TRUE;
 770             }
 771
 772           /* Closing quote at the end of the data for a named attribute. */
 773
 774           if (attr_count != 1)
 775             data = string_cat(data, &size, &ptr, US"\"", 1);
 776
 777           /* Free the values */
 778
 779           ldap_value_free(CSS firstval);
 780           }
 781         }
 782
 783       #if defined LDAP_LIB_NETSCAPE || defined LDAP_LIB_OPENLDAP2
 784
 785       /* Netscape and OpenLDAP2 LDAP's attrs are dynamically allocated and need
 786       to be freed. UMich LDAP stores them in static storage and does not require
 787       this. */
 788
 789       ldap_memfree(attr);
 790       #endif
 791       }        /* End "for" loop for extracting attributes from an entry */
 792     }          /* End "for" loop for extracting entries from a result */
 793
 794   /* Free the result */
 795
 796   ldap_msgfree(result);
 797   result = NULL;
 798   }            /* End "while" loop for multiple results */
 799
 800 /* Terminate the dynamic string that we have built and reclaim unused store */
 801
 802 if (data != NULL)
 803   {
 804   data[ptr] = 0;
 805   store_reset(data + ptr + 1);
 806   }
 807
 808 /* Copy the last dn into eldap_dn */
 809
 810 if (dn != NULL)
 811   {
 812   eldap_dn = string_copy(dn);
 813   #if defined LDAP_LIB_NETSCAPE || defined LDAP_LIB_OPENLDAP2
 814   ldap_memfree(dn);
 815   #else   /* OPENLDAP 1, UMich, Solaris */
 816   free(dn);
 817   #endif
 818   }
 819
 820 DEBUG(D_lookup) debug_printf("search ended by ldap_result yielding %d\n",rc);
 821
 822 if (rc == 0)
 823   {
 824   *errmsg = US"ldap_result timed out";
 825   goto RETURN_ERROR;
 826   }
 827
 828 /* A return code of -1 seems to mean "ldap_result failed internally or couldn't
 829 provide you with a message". Other error states seem to exist where
 830 ldap_result() didn't give us any message from the server at all, leaving result
 831 set to NULL. Apparently, "the error parameters of the LDAP session handle will
 832 be set accordingly". That's the best we can do to retrieve an error status; we
 833 can't use functions like ldap_result2error because they parse a message from
 834 the server, which we didn't get.
 835
 836 Annoyingly, the different implementations of LDAP have gone for different
 837 methods of handling error codes and generating error messages. */
 838
 839 if (rc == -1 || result == NULL)
 840   {
 841   int err;
 842   DEBUG(D_lookup) debug_printf("ldap_result failed\n");
 843
 844   #if defined LDAP_LIB_SOLARIS || defined LDAP_LIB_OPENLDAP2
 845     ldap_get_option(lcp->ld, LDAP_OPT_ERROR_NUMBER, &err);
 846     *errmsg = string_sprintf("ldap_result failed: %d, %s",
 847       err, ldap_err2string(err));
 848
 849   #elif defined LDAP_LIB_NETSCAPE
 850     /* Dubious (surely 'matched' is spurious here?) */
 851     (void)ldap_get_lderrno(lcp->ld, &matched, &error1);
 852     *errmsg = string_sprintf("ldap_result failed: %s (%s)", error1, matched);
 853
 854   #else                             /* UMich LDAP aka OpenLDAP 1.x */
 855     *errmsg = string_sprintf("ldap_result failed: %d, %s",
 856       lcp->ld->ld_errno, ldap_err2string(lcp->ld->ld_errno));
 857   #endif
 858
 859   goto RETURN_ERROR;
 860   }
 861
 862 /* A return code that isn't -1 doesn't necessarily mean there were no problems
 863 with the search. The message must be an LDAP_RES_SEARCH_RESULT or
 864 LDAP_RES_SEARCH_REFERENCE or else it's something we can't handle. Some versions
 865 of LDAP do not define LDAP_RES_SEARCH_REFERENCE (LDAP v1 is one, it seems). So
 866 we don't provide that functionality when we can't. :-) */
 867
 868 if (rc != LDAP_RES_SEARCH_RESULT
 869 #ifdef LDAP_RES_SEARCH_REFERENCE
 870     && rc != LDAP_RES_SEARCH_REFERENCE
 871 #endif
 872    )
 873   {
 874   *errmsg = string_sprintf("ldap_result returned unexpected code %d", rc);
 875   goto RETURN_ERROR;
 876   }
 877
 878 /* We have a result message from the server. This doesn't yet mean all is well.
 879 We need to parse the message to find out exactly what's happened. */
 880
 881 #if defined LDAP_LIB_SOLARIS || defined LDAP_LIB_OPENLDAP2
 882   ldap_rc = rc;
 883   ldap_parse_rc = ldap_parse_result(lcp->ld, result, &rc, CSS &matched,
 884     CSS &error2, NULL, NULL, 0);
 885   DEBUG(D_lookup) debug_printf("ldap_parse_result: %d\n", ldap_parse_rc);
 886   if (ldap_parse_rc < 0 &&
 887       (ldap_parse_rc != LDAP_NO_RESULTS_RETURNED
 888       #ifdef LDAP_RES_SEARCH_REFERENCE
 889       || ldap_rc != LDAP_RES_SEARCH_REFERENCE
 890       #endif
 891      ))
 892     {
 893     *errmsg = string_sprintf("ldap_parse_result failed %d", ldap_parse_rc);
 894     goto RETURN_ERROR;
 895     }
 896   error1 = US ldap_err2string(rc);
 897
 898 #elif defined LDAP_LIB_NETSCAPE
 899   /* Dubious (it doesn't reference 'result' at all!) */
 900   rc = ldap_get_lderrno(lcp->ld, &matched, &error1);
 901
 902 #else                             /* UMich LDAP aka OpenLDAP 1.x */
 903   rc = ldap_result2error(lcp->ld, result, 0);
 904   error1 = ldap_err2string(rc);
 905   error2 = lcp->ld->ld_error;
 906   matched = lcp->ld->ld_matched;
 907 #endif
 908
 909 /* Process the status as follows:
 910
 911   (1) If we get LDAP_SIZELIMIT_EXCEEDED, just carry on, to return the
 912       truncated result list.
 913
 914   (2) If we get LDAP_RES_SEARCH_REFERENCE, also just carry on. This was a
 915       submitted patch that is reported to "do the right thing" with Solaris
 916       LDAP libraries. (The problem it addresses apparently does not occur with
 917       Open LDAP.)
 918
 919   (3) The range of errors defined by LDAP_NAME_ERROR generally mean "that
 920       object does not, or cannot, exist in the database". For those cases we
 921       fail the lookup.
 922
 923   (4) All other non-successes here are treated as some kind of problem with
 924       the lookup, so return DEFER (which is the default in error_yield).
 925 */
 926
 927 DEBUG(D_lookup) debug_printf("ldap_parse_result yielded %d: %s\n",
 928   rc, ldap_err2string(rc));
 929
 930 if (rc != LDAP_SUCCESS && rc != LDAP_SIZELIMIT_EXCEEDED
 931     #ifdef LDAP_RES_SEARCH_REFERENCE
 932     && rc != LDAP_RES_SEARCH_REFERENCE
 933     #endif
 934     )
 935   {
 936   *errmsg = string_sprintf("LDAP search failed - error %d: %s%s%s%s%s",
 937     rc,
 938     (error1 != NULL)?                       error1  : US"",
 939     (error2 != NULL && error2[0] != 0)?     US"/"   : US"",
 940     (error2 != NULL)?                       error2  : US"",
 941     (matched != NULL && matched[0] != 0)?   US"/"   : US"",
 942     (matched != NULL)?                      matched : US"");
 943
 944   #if defined LDAP_NAME_ERROR
 945   if (LDAP_NAME_ERROR(rc))
 946   #elif defined NAME_ERROR    /* OPENLDAP1 calls it this */
 947   if (NAME_ERROR(rc))
 948   #else
 949   if (rc == LDAP_NO_SUCH_OBJECT)
 950   #endif
 951
 952     {
 953     DEBUG(D_lookup) debug_printf("lookup failure forced\n");
 954     error_yield = FAIL;
 955     }
 956   goto RETURN_ERROR;
 957   }
 958
 959 /* The search succeeded. Check if we have too many results */
 960
 961 if (search_type != SEARCH_LDAP_MULTIPLE && rescount > 1)
 962   {
 963   *errmsg = string_sprintf("LDAP search: more than one entry (%d) was returned "
 964     "(filter not specific enough?)", rescount);
 965   goto RETURN_ERROR_BREAK;
 966   }
 967
 968 /* Check if we have too few (zero) entries */
 969
 970 if (rescount < 1)
 971   {
 972   *errmsg = string_sprintf("LDAP search: no results");
 973   error_yield = FAIL;
 974   goto RETURN_ERROR_BREAK;
 975   }
 976
 977 /* If an entry was found, but it had no attributes, we behave as if no entries
 978 were found, that is, the lookup failed. */
 979
 980 if (!attribute_found)
 981   {
 982   *errmsg = US"LDAP search: found no attributes";
 983   error_yield = FAIL;
 984   goto RETURN_ERROR;
 985   }
 986
 987 /* Otherwise, it's all worked */
 988
 989 DEBUG(D_lookup) debug_printf("LDAP search: returning: %s\n", data);
 990 *res = data;
 991
 992 RETURN_OK:
 993 if (result != NULL) ldap_msgfree(result);
 994 ldap_free_urldesc(ludp);
 995 return OK;
 996
 997 /* Error returns */
 998
 999 RETURN_ERROR_BREAK:
1000 *defer_break = TRUE;
1001
1002 RETURN_ERROR:
1003 DEBUG(D_lookup) debug_printf("%s\n", *errmsg);
1004
1005 RETURN_ERROR_NOMSG:
1006 if (result != NULL) ldap_msgfree(result);
1007 if (ludp != NULL) ldap_free_urldesc(ludp);
1008
1009 #if defined LDAP_LIB_OPENLDAP2
1010   if (error2 != NULL)  ldap_memfree(error2);
1011   if (matched != NULL) ldap_memfree(matched);
1012 #endif
1013
1014 return error_yield;
1015 }
1016
1017
1018
1019 /*************************************************
1020 *        Internal search control function        *
1021 *************************************************/
1022
1023 /* This function is called from eldap_find(), eldapauth_find(), eldapdn_find(),
1024 and eldapm_find() with a difference in the "search_type" argument. It controls
1025 calls to perform_ldap_search() which actually does the work. We call that
1026 repeatedly for certain types of defer in the case when the URL contains no host
1027 name and eldap_default_servers is set to a list of servers to try. This gives
1028 more control than just passing over a list of hosts to ldap_open() because it
1029 handles other kinds of defer as well as just a failure to open. Note that the
1030 URL is defined to contain either zero or one "hostport" only.
1031
1032 Parameter data in addition to the URL can be passed as preceding text in the
1033 string, as items of the form XXX=yyy. The URL itself can be detected because it
1034 must begin "ldapx://", where x is empty, s, or i.
1035
1036 Arguments:
1037   ldap_url      the URL to be looked up, optionally preceded by other parameter
1038                 settings
1039   search_type   SEARCH_LDAP_MULTIPLE allows values from multiple entries
1040                 SEARCH_LDAP_SINGLE allows values from one entry only
1041                 SEARCH_LDAP_DN gets the DN from one entry
1042   res           set to point at the result
1043   errmsg        set to point a message if result is not OK
1044
1045 Returns:        OK or FAIL or DEFER
1046 */
1047
1048 static int
1049 control_ldap_search(uschar *ldap_url, int search_type, uschar **res,
1050   uschar **errmsg)
1051 {
1052 BOOL defer_break = FALSE;
1053 int timelimit = LDAP_NO_LIMIT;
1054 int sizelimit = LDAP_NO_LIMIT;
1055 int tcplimit = 0;
1056 int sep = 0;
1057 int dereference = LDAP_DEREF_NEVER;
1058 void* referrals = LDAP_OPT_ON;
1059 uschar *url = ldap_url;
1060 uschar *p;
1061 uschar *user = NULL;
1062 uschar *password = NULL;
1063 uschar *server, *list;
1064 uschar buffer[512];
1065
1066 while (isspace(*url)) url++;
1067
1068 /* Until the string begins "ldap", search for the other parameter settings that
1069 are recognized. They are of the form NAME=VALUE, with the value being
1070 optionally double-quoted. There must still be a space after it, however. No
1071 NAME has the value "ldap". */
1072
1073 while (strncmpic(url, US"ldap", 4) != 0)
1074   {
1075   uschar *name = url;
1076   while (*url != 0 && *url != '=') url++;
1077   if (*url == '=')
1078     {
1079     int namelen;
1080     uschar *value;
1081     namelen = ++url - name;
1082     value = string_dequote(&url);
1083     if (isspace(*url))
1084       {
1085       if (strncmpic(name, US"USER=", namelen) == 0) user = value;
1086       else if (strncmpic(name, US"PASS=", namelen) == 0) password = value;
1087       else if (strncmpic(name, US"SIZE=", namelen) == 0) sizelimit = Uatoi(value);
1088       else if (strncmpic(name, US"TIME=", namelen) == 0) timelimit = Uatoi(value);
1089       else if (strncmpic(name, US"CONNECT=", namelen) == 0) tcplimit = Uatoi(value);
1090       else if (strncmpic(name, US"NETTIME=", namelen) == 0) tcplimit = Uatoi(value);
1091
1092       /* Don't know if all LDAP libraries have LDAP_OPT_DEREF */
1093
1094       #ifdef LDAP_OPT_DEREF
1095       else if (strncmpic(name, US"DEREFERENCE=", namelen) == 0)
1096         {
1097         if (strcmpic(value, US"never") == 0) dereference = LDAP_DEREF_NEVER;
1098         else if (strcmpic(value, US"searching") == 0)
1099           dereference = LDAP_DEREF_SEARCHING;
1100         else if (strcmpic(value, US"finding") == 0)
1101           dereference = LDAP_DEREF_FINDING;
1102         if (strcmpic(value, US"always") == 0) dereference = LDAP_DEREF_ALWAYS;
1103         }
1104       #else
1105       else if (strncmpic(name, US"DEREFERENCE=", namelen) == 0)
1106         {
1107         *errmsg = string_sprintf("LDAP_OP_DEREF not defined in this LDAP "
1108           "library - cannot use \"dereference\"");
1109         DEBUG(D_lookup) debug_printf("%s\n", *errmsg);
1110         return DEFER;
1111         }
1112       #endif
1113
1114       #ifdef LDAP_OPT_REFERRALS
1115       else if (strncmpic(name, US"REFERRALS=", namelen) == 0)
1116         {
1117         if (strcmpic(value, US"follow") == 0) referrals = LDAP_OPT_ON;
1118         else if (strcmpic(value, US"nofollow") == 0) referrals = LDAP_OPT_OFF;
1119         else
1120           {
1121           *errmsg = string_sprintf("LDAP option REFERRALS is not \"follow\" "
1122             "or \"nofollow\"");
1123           DEBUG(D_lookup) debug_printf("%s\n", *errmsg);
1124           return DEFER;
1125           }
1126         }
1127       #else
1128       else if (strncmpic(name, US"REFERRALS=", namelen) == 0)
1129         {
1130         *errmsg = string_sprintf("LDAP_OP_REFERRALS not defined in this LDAP "
1131           "library - cannot use \"referrals\"");
1132         DEBUG(D_lookup) debug_printf("%s\n", *errmsg);
1133         return DEFER;
1134         }
1135       #endif
1136
1137       else
1138         {
1139         *errmsg =
1140           string_sprintf("unknown parameter \"%.*s\" precedes LDAP URL",
1141             namelen, name);
1142         DEBUG(D_lookup) debug_printf("LDAP query error: %s\n", *errmsg);
1143         return DEFER;
1144         }
1145       while (isspace(*url)) url++;
1146       continue;
1147       }
1148     }
1149   *errmsg = US"malformed parameter setting precedes LDAP URL";
1150   DEBUG(D_lookup) debug_printf("LDAP query error: %s\n", *errmsg);
1151   return DEFER;
1152   }
1153
1154 /* If user is set, de-URL-quote it. Some LDAP libraries do this for themselves,
1155 but it seems that not all behave like this. The DN for the user is often the
1156 result of ${quote_ldap_dn:...} quoting, which does apply URL quoting, because
1157 that is needed when the DN is used as a base DN in a query. Sigh. This is all
1158 far too complicated. */
1159
1160 if (user != NULL)
1161   {
1162   uschar *s;
1163   uschar *t = user;
1164   for (s = user; *s != 0; s++)
1165     {
1166     int c, d;
1167     if (*s == '%' && isxdigit(c=s[1]) && isxdigit(d=s[2]))
1168       {
1169       c = tolower(c);
1170       d = tolower(d);
1171       *t++ =
1172         (((c >= 'a')? (10 + c - 'a') : c - '0') << 4) |
1173          ((d >= 'a')? (10 + d - 'a') : d - '0');
1174       s += 2;
1175       }
1176     else *t++ = *s;
1177     }
1178   *t = 0;
1179   }
1180
1181 DEBUG(D_lookup)
1182   debug_printf("LDAP parameters: user=%s pass=%s size=%d time=%d connect=%d "
1183     "dereference=%d referrals=%s\n", user, password, sizelimit, timelimit,
1184     tcplimit, dereference, (referrals == LDAP_OPT_ON)? "on" : "off");
1185
1186 /* If the request is just to check authentication, some credentials must
1187 be given. The password must not be empty because LDAP binds with an empty
1188 password are considered anonymous, and will succeed on most installations. */
1189
1190 if (search_type == SEARCH_LDAP_AUTH)
1191   {
1192   if (user == NULL || password == NULL)
1193     {
1194     *errmsg = US"ldapauth lookups must specify the username and password";
1195     return DEFER;
1196     }
1197   if (password[0] == 0)
1198     {
1199     DEBUG(D_lookup) debug_printf("Empty password: ldapauth returns FAIL\n");
1200     return FAIL;
1201     }
1202   }
1203
1204 /* Check for valid ldap url starters */
1205
1206 p = url + 4;
1207 if (tolower(*p) == 's' || tolower(*p) == 'i') p++;
1208 if (Ustrncmp(p, "://", 3) != 0)
1209   {
1210   *errmsg = string_sprintf("LDAP URL does not start with \"ldap://\", "
1211     "\"ldaps://\", or \"ldapi://\" (it starts with \"%.16s...\")", url);
1212   DEBUG(D_lookup) debug_printf("LDAP query error: %s\n", *errmsg);
1213   return DEFER;
1214   }
1215
1216 /* No default servers, or URL contains a server name: just one attempt */
1217
1218 if (eldap_default_servers == NULL || p[3] != '/')
1219   {
1220   return perform_ldap_search(url, NULL, 0, search_type, res, errmsg,
1221     &defer_break, user, password, sizelimit, timelimit, tcplimit, dereference,
1222     referrals);
1223   }
1224
1225 /* Loop through the default servers until OK or FAIL */
1226
1227 list = eldap_default_servers;
1228 while ((server = string_nextinlist(&list, &sep, buffer, sizeof(buffer))) != NULL)
1229   {
1230   int rc;
1231   int port = 0;
1232   uschar *colon = Ustrchr(server, ':');
1233   if (colon != NULL)
1234     {
1235     *colon = 0;
1236     port = Uatoi(colon+1);
1237     }
1238   rc = perform_ldap_search(url, server, port, search_type, res, errmsg,
1239     &defer_break, user, password, sizelimit, timelimit, tcplimit, dereference,
1240     referrals);
1241   if (rc != DEFER || defer_break) return rc;
1242   }
1243
1244 return DEFER;
1245 }
1246
1247
1248
1249 /*************************************************
1250 *               Find entry point                 *
1251 *************************************************/
1252
1253 /* See local README for interface description. The different kinds of search
1254 are handled by a common function, with a flag to differentiate between them.
1255 The handle and filename arguments are not used. */
1256
1257 static int
1258 eldap_find(void *handle, uschar *filename, uschar *ldap_url, int length,
1259   uschar **result, uschar **errmsg, BOOL *do_cache)
1260 {
1261 /* Keep picky compilers happy */
1262 do_cache = do_cache;
1263 return(control_ldap_search(ldap_url, SEARCH_LDAP_SINGLE, result, errmsg));
1264 }
1265
1266 static int
1267 eldapm_find(void *handle, uschar *filename, uschar *ldap_url, int length,
1268   uschar **result, uschar **errmsg, BOOL *do_cache)
1269 {
1270 /* Keep picky compilers happy */
1271 do_cache = do_cache;
1272 return(control_ldap_search(ldap_url, SEARCH_LDAP_MULTIPLE, result, errmsg));
1273 }
1274
1275 static int
1276 eldapdn_find(void *handle, uschar *filename, uschar *ldap_url, int length,
1277   uschar **result, uschar **errmsg, BOOL *do_cache)
1278 {
1279 /* Keep picky compilers happy */
1280 do_cache = do_cache;
1281 return(control_ldap_search(ldap_url, SEARCH_LDAP_DN, result, errmsg));
1282 }
1283
1284 int
1285 eldapauth_find(void *handle, uschar *filename, uschar *ldap_url, int length,
1286   uschar **result, uschar **errmsg, BOOL *do_cache)
1287 {
1288 /* Keep picky compilers happy */
1289 do_cache = do_cache;
1290 return(control_ldap_search(ldap_url, SEARCH_LDAP_AUTH, result, errmsg));
1291 }
1292
1293
1294
1295 /*************************************************
1296 *              Open entry point                  *
1297 *************************************************/
1298
1299 /* See local README for interface description. */
1300
1301 static void *
1302 eldap_open(uschar *filename, uschar **errmsg)
1303 {
1304 return (void *)(1);    /* Just return something non-null */
1305 }
1306
1307
1308
1309 /*************************************************
1310 *               Tidy entry point                 *
1311 *************************************************/
1312
1313 /* See local README for interface description.
1314 Make sure that eldap_dn does not refer to reclaimed or worse, freed store */
1315
1316 static void
1317 eldap_tidy(void)
1318 {
1319 LDAP_CONNECTION *lcp = NULL;
1320 eldap_dn = NULL;
1321
1322 while ((lcp = ldap_connections) != NULL)
1323   {
1324   DEBUG(D_lookup) debug_printf("unbind LDAP connection to %s:%d\n", lcp->host,
1325     lcp->port);
1326   ldap_unbind(lcp->ld);
1327   ldap_connections = lcp->next;
1328   }
1329 }
1330
1331
1332
1333 /*************************************************
1334 *               Quote entry point                *
1335 *************************************************/
1336
1337 /* LDAP quoting is unbelievably messy. For a start, two different levels of
1338 quoting have to be done: LDAP quoting, and URL quoting. The current
1339 specification is the result of a suggestion by Brian Candler. It recognizes
1340 two separate cases:
1341
1342 (1) For text that appears in a search filter, the following escapes are
1343     required (see RFC 2254):
1344
1345       *    ->   \2A
1346       (    ->   \28
1347       )    ->   \29
1348       \    ->   \5C
1349      NULL  ->   \00
1350
1351     Then the entire filter text must be URL-escaped. This kind of quoting is
1352     implemented by ${quote_ldap:....}. Note that we can never have a NULL
1353     in the input string, because that's a terminator.
1354
1355 (2) For a DN that is part of a URL (i.e. the base DN), the characters
1356
1357       , + " \ < > ;
1358
1359     must be quoted by backslashing. See RFC 2253. Leading and trailing spaces
1360     must be escaped, as must a leading #. Then the string must be URL-quoted.
1361     This type of quoting is implemented by ${quote_ldap_dn:....}.
1362
1363 For URL quoting, the only characters that need not be quoted are the
1364 alphamerics and
1365
1366   ! $ ' ( ) * + - . _
1367
1368 All the others must be hexified and preceded by %. This includes the
1369 backslashes used for LDAP quoting.
1370
1371 For a DN that is given in the USER parameter for authentication, we need the
1372 same initial quoting as (2) but in this case, the result must NOT be
1373 URL-escaped, because it isn't a URL. The way this is handled is by
1374 de-URL-quoting the text when processing the USER parameter in
1375 control_ldap_search() above. That means that the same quote operator can be
1376 used. This has the additional advantage that spaces in the DN won't cause
1377 parsing problems. For example:
1378
1379   USER=cn=${quote_ldap_dn:$1},%20dc=example,%20dc=com
1380
1381 should be safe if there are spaces in $1.
1382
1383
1384 Arguments:
1385   s          the string to be quoted
1386   opt        additional option text or NULL if none
1387              only "dn" is recognized
1388
1389 Returns:     the processed string or NULL for a bad option
1390 */
1391
1392
1393
1394 /* The characters in this string, together with alphanumerics, never need
1395 quoting in any way. */
1396
1397 #define ALWAYS_LITERAL  "!$'-._"
1398
1399 /* The special characters in this string do not need to be URL-quoted. The set
1400 is a bit larger than the general literals. */
1401
1402 #define URL_NONQUOTE    ALWAYS_LITERAL "()*+"
1403
1404 /* The following macros define the characters that are quoted by quote_ldap and
1405 quote_ldap_dn, respectively. */
1406
1407 #define LDAP_QUOTE      "*()\\"
1408 #define LDAP_DN_QUOTE   ",+\"\\<>;"
1409
1410
1411
1412 static uschar *
1413 eldap_quote(uschar *s, uschar *opt)
1414 {
1415 register int c;
1416 int count = 0;
1417 int len = 0;
1418 BOOL dn = FALSE;
1419 uschar *t = s;
1420 uschar *quoted;
1421
1422 /* Test for a DN quotation. */
1423
1424 if (opt != NULL)
1425   {
1426   if (Ustrcmp(opt, "dn") != 0) return NULL;    /* No others recognized */
1427   dn = TRUE;
1428   }
1429
1430 /* Compute how much extra store we need for the string. This doesn't have to be
1431 exact as long as it isn't an underestimate. The worst case is the addition of 5
1432 extra bytes for a single character. This occurs for certain characters in DNs,
1433 where, for example, < turns into %5C%3C. For simplicity, we just add 5 for each
1434 possibly escaped character. The really fast way would be just to test for
1435 non-alphanumerics, but it is probably better to spot a few others that are
1436 never escaped, because if there are no specials at all, we can avoid copying
1437 the string. */
1438
1439 while ((c = *t++) != 0)
1440   {
1441   len++;
1442   if (!isalnum(c) && Ustrchr(ALWAYS_LITERAL, c) == NULL) count += 5;
1443   }
1444 if (count == 0) return s;
1445
1446 /* Get sufficient store to hold the quoted string */
1447
1448 t = quoted = store_get(len + count + 1);
1449
1450 /* Handle plain quote_ldap */
1451
1452 if (!dn)
1453   {
1454   while ((c = *s++) != 0)
1455     {
1456     if (!isalnum(c))
1457       {
1458       if (Ustrchr(LDAP_QUOTE, c) != NULL)
1459         {
1460         sprintf(CS t, "%%5C%02X", c);        /* e.g. * => %5C2A */
1461         t += 5;
1462         continue;
1463         }
1464       if (Ustrchr(URL_NONQUOTE, c) == NULL)  /* e.g. ] => %5D */
1465         {
1466         sprintf(CS t, "%%%02X", c);
1467         t += 3;
1468         continue;
1469         }
1470       }
1471     *t++ = c;                                /* unquoted character */
1472     }
1473   }
1474
1475 /* Handle quote_ldap_dn */
1476
1477 else
1478   {
1479   uschar *ss = s + len;
1480
1481   /* Find the last char before any trailing spaces */
1482
1483   while (ss > s && ss[-1] == ' ') ss--;
1484
1485   /* Quote leading spaces and sharps */
1486
1487   for (; s < ss; s++)
1488     {
1489     if (*s != ' ' && *s != '#') break;
1490     sprintf(CS t, "%%5C%%%02X", *s);
1491     t += 6;
1492     }
1493
1494   /* Handle the rest of the string, up to the trailing spaces */
1495
1496   while (s < ss)
1497     {
1498     c = *s++;
1499     if (!isalnum(c))
1500       {
1501       if (Ustrchr(LDAP_DN_QUOTE, c) != NULL)
1502         {
1503         Ustrncpy(t, "%5C", 3);               /* insert \ where needed */
1504         t += 3;                              /* fall through to check URL */
1505         }
1506       if (Ustrchr(URL_NONQUOTE, c) == NULL)  /* e.g. ] => %5D */
1507         {
1508         sprintf(CS t, "%%%02X", c);
1509         t += 3;
1510         continue;
1511         }
1512       }
1513     *t++ = c;    /* unquoted character, or non-URL quoted after %5C */
1514     }
1515
1516   /* Handle the trailing spaces */
1517
1518   while (*ss++ != 0)
1519     {
1520     Ustrncpy(t, "%5C%20", 6);
1521     t += 6;
1522     }
1523   }
1524
1525 /* Terminate the new string and return */
1526
1527 *t = 0;
1528 return quoted;
1529 }
1530
1531
1532
1533 /*************************************************
1534 *         Version reporting entry point          *
1535 *************************************************/
1536
1537 /* See local README for interface description. */
1538
1539 #include "../version.h"
1540
1541 void
1542 ldap_version_report(FILE *f)
1543 {
1544 #ifdef DYNLOOKUP
1545 fprintf(f, "Library version: LDAP: Exim version %s\n", EXIM_VERSION_STR);
1546 #endif
1547 }
1548
1549
1550 static lookup_info ldap_lookup_info = {
1551   US"ldap",                      /* lookup name */
1552   lookup_querystyle,             /* query-style lookup */
1553   eldap_open,                    /* open function */
1554   NULL,                          /* check function */
1555   eldap_find,                    /* find function */
1556   NULL,                          /* no close function */
1557   eldap_tidy,                    /* tidy function */
1558   eldap_quote,                   /* quoting function */
1559   ldap_version_report            /* version reporting */
1560 };
1561
1562 static lookup_info ldapdn_lookup_info = {
1563   US"ldapdn",                     /* lookup name */
1564   lookup_querystyle,             /* query-style lookup */
1565   eldap_open,       /* sic */    /* open function */
1566   NULL,                          /* check function */
1567   eldapdn_find,                  /* find function */
1568   NULL,                          /* no close function */
1569   eldap_tidy,       /* sic */    /* tidy function */
1570   eldap_quote,      /* sic */    /* quoting function */
1571   NULL                           /* no version reporting (redundant) */
1572 };
1573
1574 static lookup_info ldapm_lookup_info = {
1575   US"ldapm",                     /* lookup name */
1576   lookup_querystyle,             /* query-style lookup */
1577   eldap_open,       /* sic */    /* open function */
1578   NULL,                          /* check function */
1579   eldapm_find,                   /* find function */
1580   NULL,                          /* no close function */
1581   eldap_tidy,       /* sic */    /* tidy function */
1582   eldap_quote,      /* sic */    /* quoting function */
1583   NULL                           /* no version reporting (redundant) */
1584 };
1585
1586 #ifdef DYNLOOKUP
1587 #define ldap_lookup_module_info _lookup_module_info
1588 #endif
1589
1590 static lookup_info *_lookup_list[] = { &ldap_lookup_info, &ldapdn_lookup_info, &ldapm_lookup_info };
1591 lookup_module_info ldap_lookup_module_info = { LOOKUP_MODULE_INFO_MAGIC, _lookup_list, 3 };
1592
1593 /* End of lookups/ldap.c */