src/src/lookups/ldap.c

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