src/src/lookups/ldap.c

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