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