82d6954ff09592620bc2443f72a0046e308996e0
[exim.git] / src / src / lookups / ldap.c
1 /*************************************************
2 *     Exim - an Internet mail transport agent    *
3 *************************************************/
4
5 /* Copyright (c) The Exim Maintainers 2020 - 2022 */
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 from expand.c as an expansion condition test.
105
106 The DN from a successful lookup is placed in $ldap_dn. This feature postdates
107 the provision of the SEARCH_LDAP_DN facility for returning just the DN as the
108 data.
109
110 Arguments:
111   ldap_url      the URL to be looked up
112   server        server host name, when URL contains none
113   s_port        server port, used when URL contains no name
114   search_type   SEARCH_LDAP_MULTIPLE allows values from multiple entries
115                 SEARCH_LDAP_SINGLE allows values from one entry only
116                 SEARCH_LDAP_DN gets the DN from one entry
117   res           set to point at the result (not used for ldapauth)
118   errmsg        set to point a message if result is not OK
119   defer_break   set TRUE if no more servers to be tried after a DEFER
120   user          user name for authentication, or NULL
121   password      password for authentication, or NULL
122   sizelimit     max number of entries returned, or 0 for no limit
123   timelimit     max time to wait, or 0 for no limit
124   tcplimit      max time for network activity, e.g. connect, or 0 for OS default
125   deference     the dereference option, which is one of
126                   LDAP_DEREF_{NEVER,SEARCHING,FINDING,ALWAYS}
127   referrals     the referral option, which is LDAP_OPT_ON or LDAP_OPT_OFF
128
129 Returns:        OK or FAIL or DEFER
130                 FAIL is given only if a lookup was performed successfully, but
131                 returned no data.
132 */
133
134 static int
135 perform_ldap_search(const uschar *ldap_url, uschar *server, int s_port,
136   int search_type, uschar **res, uschar **errmsg, BOOL *defer_break,
137   uschar *user, uschar *password, int sizelimit, int timelimit, int tcplimit,
138   int dereference, void *referrals)
139 {
140 LDAPURLDesc     *ludp = NULL;
141 LDAPMessage     *result = NULL;
142 BerElement      *ber;
143 LDAP_CONNECTION *lcp;
144
145 struct timeval timeout;
146 struct timeval *timeoutptr = NULL;
147
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) debug_printf_indent("perform_ldap_search:"
169     " 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_indent("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 (uschar ** 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 ? host : US"";
307   rmark reset_point = store_mark();
308   gstring * g;
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     g = string_catn(NULL, US"ldapi://", 8);
316     for (uschar ch; (ch = *shost); shost++)
317       g = ch == '/' ? string_catn(g, US"%2F", 3) : string_catn(g, shost, 1);
318     }
319
320   /* This is not an ldapi call. Just build a URI with the protocol type, host
321   name, and port. */
322
323   else
324     {
325     uschar * init_ptr = Ustrchr(ldap_url, '/');
326     g = string_catn(NULL, ldap_url, init_ptr - ldap_url);
327     g = string_fmt_append(g, "//%s:%d/", shost, port);
328     }
329
330   /* Call ldap_initialize() and check the result */
331    {
332     const uschar * s = string_from_gstring(g);
333
334     DEBUG(D_lookup) debug_printf_indent("ldap_initialize with URL %s\n", s);
335     if ((rc = ldap_initialize(&ld, CS s)) != LDAP_SUCCESS)
336       {
337       *errmsg = string_sprintf("ldap_initialize: (error %d) URL \"%s\"\n",
338         rc, s);
339       goto RETURN_ERROR;
340       }
341    }
342   store_reset(reset_point);   /* Might as well save memory when we can */
343
344
345   /* ------------------------- Not OpenLDAP ---------------------- */
346
347   /* For libraries other than OpenLDAP, use ldap_init(). */
348
349 #else   /* LDAP_LIB_OPENLDAP2 */
350   ld = ldap_init(CS host, port);
351 #endif  /* LDAP_LIB_OPENLDAP2 */
352
353   /* -------------------------------------------------------------- */
354
355
356   /* Handle failure to initialize */
357
358   if (!ld)
359     {
360     *errmsg = string_sprintf("failed to initialize for LDAP server %s%s - %s",
361       host, porttext, strerror(errno));
362     goto RETURN_ERROR;
363     }
364
365 #ifdef LDAP_OPT_X_TLS_NEWCTX
366   ldsetctx = ld;
367 #endif
368
369   /* Set the TCP connect time limit if available. This is something that is
370   in Netscape SDK v4.1; I don't know about other libraries. */
371
372 #ifdef LDAP_X_OPT_CONNECT_TIMEOUT
373   if (tcplimit > 0)
374     {
375     int timeout1000 = tcplimit*1000;
376     ldap_set_option(ld, LDAP_X_OPT_CONNECT_TIMEOUT, (void *)&timeout1000);
377     }
378   else
379     {
380     int notimeout = LDAP_X_IO_TIMEOUT_NO_TIMEOUT;
381     ldap_set_option(ld, LDAP_X_OPT_CONNECT_TIMEOUT, (void *)&notimeout);
382     }
383 #endif
384
385   /* Set the TCP connect timeout. This works with OpenLDAP 2.2.14. */
386
387 #ifdef LDAP_OPT_NETWORK_TIMEOUT
388   if (tcplimit > 0)
389     ldap_set_option(ld, LDAP_OPT_NETWORK_TIMEOUT, (void *)timeoutptr);
390 #endif
391
392   /* I could not get TLS to work until I set the version to 3. That version
393   seems to be the default nowadays. The RFC is dated 1997, so I would hope
394   that all the LDAP libraries support it. Therefore, if eldap_version hasn't
395   been set, go for v3 if we can. */
396
397   if (eldap_version < 0)
398     {
399 #ifdef LDAP_VERSION3
400     eldap_version = LDAP_VERSION3;
401 #else
402     eldap_version = 2;
403 #endif
404     }
405
406 #ifdef LDAP_OPT_PROTOCOL_VERSION
407   ldap_set_option(ld, LDAP_OPT_PROTOCOL_VERSION, (void *)&eldap_version);
408 #endif
409
410   DEBUG(D_lookup) debug_printf_indent("initialized for LDAP (v%d) server %s%s\n",
411     eldap_version, host, porttext);
412
413   /* If not using ldapi and TLS is available, set appropriate TLS options: hard
414   for "ldaps" and soft otherwise. */
415
416 #ifdef LDAP_OPT_X_TLS
417   if (!ldapi)
418     {
419     int tls_option;
420 # ifdef LDAP_OPT_X_TLS_REQUIRE_CERT
421     if (eldap_require_cert)
422       {
423       tls_option =
424         Ustrcmp(eldap_require_cert, "hard")     == 0 ? LDAP_OPT_X_TLS_HARD
425         : Ustrcmp(eldap_require_cert, "demand") == 0 ? LDAP_OPT_X_TLS_DEMAND
426         : Ustrcmp(eldap_require_cert, "allow")  == 0 ? LDAP_OPT_X_TLS_ALLOW
427         : Ustrcmp(eldap_require_cert, "try")    == 0 ? LDAP_OPT_X_TLS_TRY
428         : LDAP_OPT_X_TLS_NEVER;
429
430       DEBUG(D_lookup) debug_printf_indent(
431         "Require certificate overrides LDAP_OPT_X_TLS option (%d)\n",
432         tls_option);
433       }
434     else
435 # endif  /* LDAP_OPT_X_TLS_REQUIRE_CERT */
436     if (strncmp(ludp->lud_scheme, "ldaps", 5) == 0)
437       {
438       tls_option = LDAP_OPT_X_TLS_HARD;
439       DEBUG(D_lookup)
440         debug_printf_indent("LDAP_OPT_X_TLS_HARD set due to ldaps:// URI\n");
441       }
442     else
443       {
444       tls_option = LDAP_OPT_X_TLS_TRY;
445       DEBUG(D_lookup)
446         debug_printf_indent("LDAP_OPT_X_TLS_TRY set due to ldap:// URI\n");
447       }
448     ldap_set_option(ld, LDAP_OPT_X_TLS, (void *)&tls_option);
449     }
450 #endif  /* LDAP_OPT_X_TLS */
451
452 #ifdef LDAP_OPT_X_TLS_CACERTFILE
453   if (eldap_ca_cert_file)
454     ldap_set_option(ldsetctx, LDAP_OPT_X_TLS_CACERTFILE, eldap_ca_cert_file);
455 #endif
456 #ifdef LDAP_OPT_X_TLS_CACERTDIR
457   if (eldap_ca_cert_dir)
458     ldap_set_option(ldsetctx, LDAP_OPT_X_TLS_CACERTDIR, eldap_ca_cert_dir);
459 #endif
460 #ifdef LDAP_OPT_X_TLS_CERTFILE
461   if (eldap_cert_file)
462     ldap_set_option(ldsetctx, LDAP_OPT_X_TLS_CERTFILE, eldap_cert_file);
463 #endif
464 #ifdef LDAP_OPT_X_TLS_KEYFILE
465   if (eldap_cert_key)
466     ldap_set_option(ldsetctx, LDAP_OPT_X_TLS_KEYFILE, eldap_cert_key);
467 #endif
468 #ifdef LDAP_OPT_X_TLS_CIPHER_SUITE
469   if (eldap_cipher_suite)
470     ldap_set_option(ldsetctx, LDAP_OPT_X_TLS_CIPHER_SUITE, eldap_cipher_suite);
471 #endif
472 #ifdef LDAP_OPT_X_TLS_REQUIRE_CERT
473   if (eldap_require_cert)
474     {
475     int cert_option =
476       Ustrcmp(eldap_require_cert, "hard")     == 0 ? LDAP_OPT_X_TLS_HARD
477       : Ustrcmp(eldap_require_cert, "demand") == 0 ? LDAP_OPT_X_TLS_DEMAND
478       : Ustrcmp(eldap_require_cert, "allow")  == 0 ? LDAP_OPT_X_TLS_ALLOW
479       : Ustrcmp(eldap_require_cert, "try")    == 0 ? LDAP_OPT_X_TLS_TRY
480       : LDAP_OPT_X_TLS_NEVER;
481
482     /* This ldap handle is set at compile time based on client libs. Older
483      * versions want it to be global and newer versions can force a reload
484      * of the TLS context (to reload these settings we are changing from the
485      * default that loaded at instantiation). */
486     rc = ldap_set_option(ldsetctx, LDAP_OPT_X_TLS_REQUIRE_CERT, &cert_option);
487     if (rc)
488       DEBUG(D_lookup)
489         debug_printf_indent("Unable to set TLS require cert_option(%d) globally: %s\n",
490           cert_option, ldap_err2string(rc));
491     }
492 #endif
493 #ifdef LDAP_OPT_X_TLS_NEWCTX
494   if ((rc = ldap_set_option(ldsetctx, LDAP_OPT_X_TLS_NEWCTX, &am_server)))
495     DEBUG(D_lookup)
496       debug_printf_indent("Unable to reload TLS context %d: %s\n",
497                    rc, ldap_err2string(rc));
498   #endif
499
500   /* Now add this connection to the chain of cached connections */
501
502   lcp = store_get(sizeof(LDAP_CONNECTION), GET_UNTAINTED);
503   lcp->host = host ? string_copy(host) : NULL;
504   lcp->bound = FALSE;
505   lcp->user = NULL;
506   lcp->password = NULL;
507   lcp->port = port;
508   lcp->ld = ld;
509   lcp->next = ldap_connections;
510   lcp->is_start_tls_called = FALSE;
511   ldap_connections = lcp;
512   }
513
514 /* Found cached connection */
515
516 else
517   DEBUG(D_lookup)
518     debug_printf_indent("re-using cached connection to LDAP server %s%s\n",
519       host, porttext);
520
521 /* Bind with the user/password supplied, or an anonymous bind if these values
522 are NULL, unless a cached connection is already bound with the same values. */
523
524 if (  !lcp->bound
525    || !lcp->user && user
526    || lcp->user && !user
527    || lcp->user && user && Ustrcmp(lcp->user, user) != 0
528    || !lcp->password && password
529    || lcp->password && !password
530    || lcp->password && password && Ustrcmp(lcp->password, password) != 0
531    )
532   {
533   DEBUG(D_lookup) debug_printf_indent("%sbinding with user=%s password=%s\n",
534     lcp->bound ? "re-" : "", user, password);
535
536   if (eldap_start_tls && !lcp->is_start_tls_called && !ldapi)
537     {
538 #if defined(LDAP_OPT_X_TLS) && !defined(LDAP_LIB_SOLARIS)
539     /* The Oracle LDAP libraries (LDAP_LIB_TYPE=SOLARIS) don't support this.
540      * Note: moreover, they appear to now define LDAP_OPT_X_TLS and still not
541      *       export an ldap_start_tls_s symbol.
542      */
543     if ( (rc = ldap_start_tls_s(lcp->ld, NULL, NULL)) != LDAP_SUCCESS)
544       {
545       *errmsg = string_sprintf("failed to initiate TLS processing on an "
546           "LDAP session to server %s%s - ldap_start_tls_s() returned %d:"
547           " %s", host, porttext, rc, ldap_err2string(rc));
548       goto RETURN_ERROR;
549       }
550     lcp->is_start_tls_called = TRUE;
551 #else
552     DEBUG(D_lookup) debug_printf_indent("TLS initiation not supported with this Exim"
553       " and your LDAP library.\n");
554 #endif
555     }
556   if ((msgid = ldap_bind(lcp->ld, CS user, CS password, LDAP_AUTH_SIMPLE))
557        == -1)
558     {
559     *errmsg = string_sprintf("failed to bind the LDAP connection to server "
560       "%s%s - ldap_bind() returned -1", host, porttext);
561     goto RETURN_ERROR;
562     }
563
564   if ((rc = ldap_result(lcp->ld, msgid, 1, timeoutptr, &result)) <= 0)
565     {
566     *errmsg = string_sprintf("failed to bind the LDAP connection to server "
567       "%s%s - LDAP error: %s", host, porttext,
568       rc == -1 ? "result retrieval failed" : "timeout" );
569     result = NULL;
570     goto RETURN_ERROR;
571     }
572
573   rc = ldap_result2error(lcp->ld, result, 0);
574
575   /* Invalid credentials when just checking credentials returns FAIL. This
576   stops any further servers being tried. */
577
578   if (search_type == SEARCH_LDAP_AUTH && rc == LDAP_INVALID_CREDENTIALS)
579     {
580     DEBUG(D_lookup)
581       debug_printf_indent("Invalid credentials: ldapauth returns FAIL\n");
582     error_yield = FAIL;
583     goto RETURN_ERROR_NOMSG;
584     }
585
586   /* Otherwise we have a problem that doesn't stop further servers from being
587   tried. */
588
589   if (rc != LDAP_SUCCESS)
590     {
591     *errmsg = string_sprintf("failed to bind the LDAP connection to server "
592       "%s%s - LDAP error %d: %s", host, porttext, rc, ldap_err2string(rc));
593     goto RETURN_ERROR;
594     }
595
596   /* Successful bind */
597
598   lcp->bound = TRUE;
599   lcp->user = !user ? NULL : string_copy(user);
600   lcp->password = !password ? NULL : string_copy(password);
601
602   ldap_msgfree(result);
603   result = NULL;
604   }
605
606 /* If we are just checking credentials, return OK. */
607
608 if (search_type == SEARCH_LDAP_AUTH)
609   {
610   DEBUG(D_lookup) debug_printf_indent("Bind succeeded: ldapauth returns OK\n");
611   goto RETURN_OK;
612   }
613
614 /* Before doing the search, set the time and size limits (if given). Here again
615 the different implementations of LDAP have chosen to do things differently. */
616
617 #if defined(LDAP_OPT_SIZELIMIT)
618 ldap_set_option(lcp->ld, LDAP_OPT_SIZELIMIT, (void *)&sizelimit);
619 ldap_set_option(lcp->ld, LDAP_OPT_TIMELIMIT, (void *)&timelimit);
620 #else
621 lcp->ld->ld_sizelimit = sizelimit;
622 lcp->ld->ld_timelimit = timelimit;
623 #endif
624
625 /* Similarly for dereferencing aliases. Don't know if this is possible on
626 an LDAP library without LDAP_OPT_DEREF. */
627
628 #if defined(LDAP_OPT_DEREF)
629 ldap_set_option(lcp->ld, LDAP_OPT_DEREF, (void *)&dereference);
630 #endif
631
632 /* Similarly for the referral setting; should the library follow referrals that
633 the LDAP server returns? The conditional is just in case someone uses a library
634 without it. */
635
636 #if defined(LDAP_OPT_REFERRALS)
637 ldap_set_option(lcp->ld, LDAP_OPT_REFERRALS, referrals);
638 #endif
639
640 /* Start the search on the server. */
641
642 DEBUG(D_lookup) debug_printf_indent("Start search\n");
643
644 msgid = ldap_search(lcp->ld, ludp->lud_dn, ludp->lud_scope, ludp->lud_filter,
645   ludp->lud_attrs, 0);
646
647 if (msgid == -1)
648   {
649 #if defined LDAP_LIB_SOLARIS || defined LDAP_LIB_OPENLDAP2
650   int err;
651   ldap_get_option(lcp->ld, LDAP_OPT_ERROR_NUMBER, &err);
652   *errmsg = string_sprintf("ldap_search failed: %d, %s", err,
653     ldap_err2string(err));
654 #else
655   *errmsg = string_sprintf("ldap_search failed");
656 #endif
657
658   goto RETURN_ERROR;
659   }
660
661 /* Loop to pick up results as they come in, setting a timeout if one was
662 given. */
663
664 while ((rc = ldap_result(lcp->ld, msgid, 0, timeoutptr, &result)) ==
665         LDAP_RES_SEARCH_ENTRY)
666   {
667   LDAPMessage  *e;
668   int valuecount;   /* We can see an attr spread across several
669                     entries. If B is derived from A and we request
670                     A and the directory contains both, A and B,
671                     then we get two entries, one for A and one for B.
672                     Here we just count the values per entry */
673
674   DEBUG(D_lookup) debug_printf_indent("LDAP result loop\n");
675
676   for(e = ldap_first_entry(lcp->ld, result), valuecount = 0;
677       e;
678       e = ldap_next_entry(lcp->ld, e))
679     {
680     uschar *new_dn;
681     BOOL insert_space = FALSE;
682
683     DEBUG(D_lookup) debug_printf_indent("LDAP entry loop\n");
684
685     rescount++;   /* Count results */
686
687     /* Results for multiple entries values are separated by newlines. */
688
689     if (data) data = string_catn(data, US"\n", 1);
690
691     /* Get the DN from the last result. */
692
693     if ((new_dn = US ldap_get_dn(lcp->ld, e)))
694       {
695       if (dn)
696         {
697 #if defined LDAP_LIB_NETSCAPE || defined LDAP_LIB_OPENLDAP2
698         ldap_memfree(dn);
699 #else   /* OPENLDAP 1, UMich, Solaris */
700         free(dn);
701 #endif
702         }
703       /* Save for later */
704       dn = new_dn;
705       }
706
707     /* If the data we want is actually the DN rather than any attribute values,
708     (an "ldapdn" search) add it to the data string. If there are multiple
709     entries, the DNs will be concatenated, but we test for this case below, as
710     for SEARCH_LDAP_SINGLE, and give an error. */
711
712     if (search_type == SEARCH_LDAP_DN)  /* Do not amalgamate these into one */
713       {                                 /* condition, because of the else */
714       if (new_dn)                       /* below, that's for the first only */
715         {
716         data = string_cat(data, new_dn);
717         (void) string_from_gstring(data);
718         attribute_found = TRUE;
719         }
720       }
721
722     /* Otherwise, loop through the entry, grabbing attribute values. If there's
723     only one attribute being retrieved, no attribute name is given, and the
724     result is not quoted. Multiple values are separated by (comma).
725     If more than one attribute is being retrieved, the data is given as a
726     sequence of name=value pairs, separated by (space), with the value always in quotes.
727     If there are multiple values, they are given within the quotes, comma separated. */
728
729     else for (uschar * attr = US ldap_first_attribute(lcp->ld, e, &ber);
730               attr; attr = US ldap_next_attribute(lcp->ld, e, ber))
731       {
732       DEBUG(D_lookup) debug_printf_indent("LDAP attr loop\n");
733
734       /* In case of attrs_requested == 1 we just count the values, in all other cases
735       (0, >1) we count the values per attribute */
736       if (attrs_requested != 1) valuecount = 0;
737
738       if (attr[0] != 0)
739         {
740         /* Get array of values for this attribute. */
741
742         if ((firstval = values = USS ldap_get_values(lcp->ld, e, CS attr)))
743           {
744           if (attrs_requested != 1)
745             {
746             if (insert_space)
747               data = string_catn(data, US" ", 1);
748             else
749               insert_space = TRUE;
750             data = string_cat(data, attr);
751             data = string_catn(data, US"=\"", 2);
752             }
753
754           while (*values)
755             {
756             uschar *value = *values;
757             int len = Ustrlen(value);
758             ++valuecount;
759
760             DEBUG(D_lookup) debug_printf_indent("LDAP value loop %s:%s\n", attr, value);
761
762             /* In case we requested one attribute only but got several times
763             into that attr loop, we need to append the additional values.
764             (This may happen if you derive attributeTypes B and C from A and
765             then query for A.) In all other cases we detect the different
766             attribute and append only every non first value. */
767
768             if (data && valuecount > 1)
769               data = string_catn(data, US",", 1);
770
771             /* For multiple attributes, the data is in quotes. We must escape
772             internal quotes, backslashes, newlines, and must double commas. */
773
774             if (attrs_requested != 1)
775               for (int j = 0; j < len; j++)
776                 {
777                 if (value[j] == '\n')
778                   data = string_catn(data, US"\\n", 2);
779                 else if (value[j] == ',')
780                   data = string_catn(data, US",,", 2);
781                 else
782                   {
783                   if (value[j] == '\"' || value[j] == '\\')
784                     data = string_catn(data, US"\\", 1);
785                   data = string_catn(data, value+j, 1);
786                   }
787                 }
788
789             /* For single attributes, just double commas */
790
791             else
792               for (int j = 0; j < len; j++)
793                 if (value[j] == ',')
794                   data = string_catn(data, US",,", 2);
795                 else
796                   data = string_catn(data, value+j, 1);
797
798
799             /* Move on to the next value */
800
801             values++;
802             attribute_found = TRUE;
803             }
804
805           /* Closing quote at the end of the data for a named attribute. */
806
807           if (attrs_requested != 1)
808             data = string_catn(data, US"\"", 1);
809
810           /* Free the values */
811
812           ldap_value_free(CSS firstval);
813           }
814         }
815
816 #if defined LDAP_LIB_NETSCAPE || defined LDAP_LIB_OPENLDAP2
817
818       /* Netscape and OpenLDAP2 LDAP's attrs are dynamically allocated and need
819       to be freed. UMich LDAP stores them in static storage and does not require
820       this. */
821
822       ldap_memfree(attr);
823 #endif
824       }        /* End "for" loop for extracting attributes from an entry */
825     }          /* End "for" loop for extracting entries from a result */
826
827   /* Free the result */
828
829   ldap_msgfree(result);
830   result = NULL;
831   }            /* End "while" loop for multiple results */
832
833 /* Terminate the dynamic string that we have built and reclaim unused store.
834 In the odd case of a single attribute with zero-length value, allocate
835 an empty string. */
836
837 if (!data) data = string_get(1);
838 (void) string_from_gstring(data);
839 gstring_release_unused(data);
840
841 /* Copy the last dn into eldap_dn */
842
843 if (dn)
844   {
845   eldap_dn = string_copy(dn);
846 #if defined LDAP_LIB_NETSCAPE || defined LDAP_LIB_OPENLDAP2
847   ldap_memfree(dn);
848 #else   /* OPENLDAP 1, UMich, Solaris */
849   free(dn);
850 #endif
851   }
852
853 DEBUG(D_lookup) debug_printf_indent("search ended by ldap_result yielding %d\n",rc);
854
855 if (rc == 0)
856   {
857   *errmsg = US"ldap_result timed out";
858   goto RETURN_ERROR;
859   }
860
861 /* A return code of -1 seems to mean "ldap_result failed internally or couldn't
862 provide you with a message". Other error states seem to exist where
863 ldap_result() didn't give us any message from the server at all, leaving result
864 set to NULL. Apparently, "the error parameters of the LDAP session handle will
865 be set accordingly". That's the best we can do to retrieve an error status; we
866 can't use functions like ldap_result2error because they parse a message from
867 the server, which we didn't get.
868
869 Annoyingly, the different implementations of LDAP have gone for different
870 methods of handling error codes and generating error messages. */
871
872 if (rc == -1 || !result)
873   {
874   int err;
875   DEBUG(D_lookup) debug_printf_indent("ldap_result failed\n");
876
877 #if defined LDAP_LIB_SOLARIS || defined LDAP_LIB_OPENLDAP2
878     ldap_get_option(lcp->ld, LDAP_OPT_ERROR_NUMBER, &err);
879     *errmsg = string_sprintf("ldap_result failed: %d, %s",
880       err, ldap_err2string(err));
881
882 #elif defined LDAP_LIB_NETSCAPE
883     /* Dubious (surely 'matched' is spurious here?) */
884     (void)ldap_get_lderrno(lcp->ld, &matched, &error1);
885     *errmsg = string_sprintf("ldap_result failed: %s (%s)", error1, matched);
886
887 #else                             /* UMich LDAP aka OpenLDAP 1.x */
888     *errmsg = string_sprintf("ldap_result failed: %d, %s",
889       lcp->ld->ld_errno, ldap_err2string(lcp->ld->ld_errno));
890 #endif
891
892   goto RETURN_ERROR;
893   }
894
895 /* A return code that isn't -1 doesn't necessarily mean there were no problems
896 with the search. The message must be an LDAP_RES_SEARCH_RESULT or
897 LDAP_RES_SEARCH_REFERENCE or else it's something we can't handle. Some versions
898 of LDAP do not define LDAP_RES_SEARCH_REFERENCE (LDAP v1 is one, it seems). So
899 we don't provide that functionality when we can't. :-) */
900
901 if (rc != LDAP_RES_SEARCH_RESULT
902 #ifdef LDAP_RES_SEARCH_REFERENCE
903     && rc != LDAP_RES_SEARCH_REFERENCE
904 #endif
905    )
906   {
907   *errmsg = string_sprintf("ldap_result returned unexpected code %d", rc);
908   goto RETURN_ERROR;
909   }
910
911 /* We have a result message from the server. This doesn't yet mean all is well.
912 We need to parse the message to find out exactly what's happened. */
913
914 #if defined LDAP_LIB_SOLARIS || defined LDAP_LIB_OPENLDAP2
915   ldap_rc = rc;
916   ldap_parse_rc = ldap_parse_result(lcp->ld, result, &rc, CSS &matched,
917     CSS &error2, NULL, NULL, 0);
918   DEBUG(D_lookup) debug_printf_indent("ldap_parse_result: %d\n", ldap_parse_rc);
919   if (ldap_parse_rc < 0 &&
920       (ldap_parse_rc != LDAP_NO_RESULTS_RETURNED
921       #ifdef LDAP_RES_SEARCH_REFERENCE
922       || ldap_rc != LDAP_RES_SEARCH_REFERENCE
923       #endif
924      ))
925     {
926     *errmsg = string_sprintf("ldap_parse_result failed %d", ldap_parse_rc);
927     goto RETURN_ERROR;
928     }
929   error1 = US ldap_err2string(rc);
930
931 #elif defined LDAP_LIB_NETSCAPE
932   /* Dubious (it doesn't reference 'result' at all!) */
933   rc = ldap_get_lderrno(lcp->ld, &matched, &error1);
934
935 #else                             /* UMich LDAP aka OpenLDAP 1.x */
936   rc = ldap_result2error(lcp->ld, result, 0);
937   error1 = ldap_err2string(rc);
938   error2 = lcp->ld->ld_error;
939   matched = lcp->ld->ld_matched;
940 #endif
941
942 /* Process the status as follows:
943
944   (1) If we get LDAP_SIZELIMIT_EXCEEDED, just carry on, to return the
945       truncated result list.
946
947   (2) If we get LDAP_RES_SEARCH_REFERENCE, also just carry on. This was a
948       submitted patch that is reported to "do the right thing" with Solaris
949       LDAP libraries. (The problem it addresses apparently does not occur with
950       Open LDAP.)
951
952   (3) The range of errors defined by LDAP_NAME_ERROR generally mean "that
953       object does not, or cannot, exist in the database". For those cases we
954       fail the lookup.
955
956   (4) All other non-successes here are treated as some kind of problem with
957       the lookup, so return DEFER (which is the default in error_yield).
958 */
959
960 DEBUG(D_lookup) debug_printf_indent("ldap_parse_result yielded %d: %s\n",
961   rc, ldap_err2string(rc));
962
963 if (rc != LDAP_SUCCESS && rc != LDAP_SIZELIMIT_EXCEEDED
964     #ifdef LDAP_RES_SEARCH_REFERENCE
965     && rc != LDAP_RES_SEARCH_REFERENCE
966     #endif
967     )
968   {
969   *errmsg = string_sprintf("LDAP search failed - error %d: %s%s%s%s%s",
970     rc,
971     error1 ?                  error1  : US"",
972     error2 && error2[0] ?     US"/"   : US"",
973     error2 ?                  error2  : US"",
974     matched && matched[0] ?   US"/"   : US"",
975     matched ?                 matched : US"");
976
977 #if defined LDAP_NAME_ERROR
978   if (LDAP_NAME_ERROR(rc))
979 #elif defined NAME_ERROR    /* OPENLDAP1 calls it this */
980   if (NAME_ERROR(rc))
981 #else
982   if (rc == LDAP_NO_SUCH_OBJECT)
983 #endif
984
985     {
986     DEBUG(D_lookup) debug_printf_indent("lookup failure forced\n");
987     error_yield = FAIL;
988     }
989   goto RETURN_ERROR;
990   }
991
992 /* The search succeeded. Check if we have too many results */
993
994 if (search_type != SEARCH_LDAP_MULTIPLE && rescount > 1)
995   {
996   *errmsg = string_sprintf("LDAP search: more than one entry (%d) was returned "
997     "(filter not specific enough?)", rescount);
998   goto RETURN_ERROR_BREAK;
999   }
1000
1001 /* Check if we have too few (zero) entries */
1002
1003 if (rescount < 1)
1004   {
1005   *errmsg = US"LDAP search: no results";
1006   error_yield = FAIL;
1007   goto RETURN_ERROR_BREAK;
1008   }
1009
1010 /* If an entry was found, but it had no attributes, we behave as if no entries
1011 were found, that is, the lookup failed. */
1012
1013 if (!attribute_found)
1014   {
1015   *errmsg = US"LDAP search: found no attributes";
1016   error_yield = FAIL;
1017   goto RETURN_ERROR;
1018   }
1019
1020 /* Otherwise, it's all worked */
1021
1022 DEBUG(D_lookup) debug_printf_indent("LDAP search: returning: %s\n", data->s);
1023 *res = data->s;
1024
1025 RETURN_OK:
1026 if (result) ldap_msgfree(result);
1027 ldap_free_urldesc(ludp);
1028 return OK;
1029
1030 /* Error returns */
1031
1032 RETURN_ERROR_BREAK:
1033 *defer_break = TRUE;
1034
1035 RETURN_ERROR:
1036 DEBUG(D_lookup) debug_printf_indent("%s\n", *errmsg);
1037
1038 RETURN_ERROR_NOMSG:
1039 if (result) ldap_msgfree(result);
1040 if (ludp) ldap_free_urldesc(ludp);
1041
1042 #if defined LDAP_LIB_OPENLDAP2
1043   if (error2)  ldap_memfree(error2);
1044   if (matched) ldap_memfree(matched);
1045 #endif
1046
1047 return error_yield;
1048 }
1049
1050
1051
1052 /*************************************************
1053 *        Internal search control function        *
1054 *************************************************/
1055
1056 /* This function is called from eldap_find(), eldapauth_find(), eldapdn_find(),
1057 and eldapm_find() with a difference in the "search_type" argument. It controls
1058 calls to perform_ldap_search() which actually does the work. We call that
1059 repeatedly for certain types of defer in the case when the URL contains no host
1060 name and eldap_default_servers is set to a list of servers to try. This gives
1061 more control than just passing over a list of hosts to ldap_open() because it
1062 handles other kinds of defer as well as just a failure to open. Note that the
1063 URL is defined to contain either zero or one "hostport" only.
1064
1065 Parameter data in addition to the URL can be passed as preceding text in the
1066 string, as items of the form XXX=yyy. The URL itself can be detected because it
1067 must begin "ldapx://", where x is empty, s, or i.
1068
1069 Arguments:
1070   ldap_url      the URL to be looked up, optionally preceded by other parameter
1071                 settings
1072   search_type   SEARCH_LDAP_MULTIPLE allows values from multiple entries
1073                 SEARCH_LDAP_SINGLE allows values from one entry only
1074                 SEARCH_LDAP_DN gets the DN from one entry
1075   res           set to point at the result
1076   errmsg        set to point a message if result is not OK
1077
1078 Returns:        OK or FAIL or DEFER
1079 */
1080
1081 static int
1082 control_ldap_search(const uschar *ldap_url, int search_type, uschar **res,
1083   uschar **errmsg)
1084 {
1085 BOOL defer_break = FALSE;
1086 int timelimit = LDAP_NO_LIMIT;
1087 int sizelimit = LDAP_NO_LIMIT;
1088 int tcplimit = 0;
1089 int sep = 0;
1090 int dereference = LDAP_DEREF_NEVER;
1091 void* referrals = LDAP_OPT_ON;
1092 const uschar *url = ldap_url;
1093 const uschar *p;
1094 uschar *user = NULL;
1095 uschar *password = NULL;
1096 uschar *local_servers = NULL;
1097 const uschar *list;
1098
1099 while (isspace(*url)) url++;
1100
1101 /* Until the string begins "ldap", search for the other parameter settings that
1102 are recognized. They are of the form NAME=VALUE, with the value being
1103 optionally double-quoted. There must still be a space after it, however. No
1104 NAME has the value "ldap". */
1105
1106 while (strncmpic(url, US"ldap", 4) != 0)
1107   {
1108   const uschar *name = url;
1109   while (*url && *url != '=') url++;
1110   if (*url == '=')
1111     {
1112     int namelen;
1113     uschar *value;
1114     namelen = ++url - name;
1115     value = string_dequote(&url);
1116     if (isspace(*url))
1117       {
1118       if (strncmpic(name, US"USER=", namelen) == 0) user = value;
1119       else if (strncmpic(name, US"PASS=", namelen) == 0) password = value;
1120       else if (strncmpic(name, US"SIZE=", namelen) == 0) sizelimit = Uatoi(value);
1121       else if (strncmpic(name, US"TIME=", namelen) == 0) timelimit = Uatoi(value);
1122       else if (strncmpic(name, US"CONNECT=", namelen) == 0) tcplimit = Uatoi(value);
1123       else if (strncmpic(name, US"NETTIME=", namelen) == 0) tcplimit = Uatoi(value);
1124       else if (strncmpic(name, US"SERVERS=", namelen) == 0) local_servers = value;
1125
1126       /* Don't know if all LDAP libraries have LDAP_OPT_DEREF */
1127
1128       #ifdef LDAP_OPT_DEREF
1129       else if (strncmpic(name, US"DEREFERENCE=", namelen) == 0)
1130         {
1131         if (strcmpic(value, US"never") == 0) dereference = LDAP_DEREF_NEVER;
1132         else if (strcmpic(value, US"searching") == 0)
1133           dereference = LDAP_DEREF_SEARCHING;
1134         else if (strcmpic(value, US"finding") == 0)
1135           dereference = LDAP_DEREF_FINDING;
1136         if (strcmpic(value, US"always") == 0) dereference = LDAP_DEREF_ALWAYS;
1137         }
1138       #else
1139       else if (strncmpic(name, US"DEREFERENCE=", namelen) == 0)
1140         {
1141         *errmsg = string_sprintf("LDAP_OP_DEREF not defined in this LDAP "
1142           "library - cannot use \"dereference\"");
1143         DEBUG(D_lookup) debug_printf_indent("%s\n", *errmsg);
1144         return DEFER;
1145         }
1146       #endif
1147
1148       #ifdef LDAP_OPT_REFERRALS
1149       else if (strncmpic(name, US"REFERRALS=", namelen) == 0)
1150         {
1151         if (strcmpic(value, US"follow") == 0) referrals = LDAP_OPT_ON;
1152         else if (strcmpic(value, US"nofollow") == 0) referrals = LDAP_OPT_OFF;
1153         else
1154           {
1155           *errmsg = US"LDAP option REFERRALS is not \"follow\" or \"nofollow\"";
1156           DEBUG(D_lookup) debug_printf_indent("%s\n", *errmsg);
1157           return DEFER;
1158           }
1159         }
1160       #else
1161       else if (strncmpic(name, US"REFERRALS=", namelen) == 0)
1162         {
1163         *errmsg = string_sprintf("LDAP_OP_REFERRALS not defined in this LDAP "
1164           "library - cannot use \"referrals\"");
1165         DEBUG(D_lookup) debug_printf_indent("%s\n", *errmsg);
1166         return DEFER;
1167         }
1168       #endif
1169
1170       else
1171         {
1172         *errmsg =
1173           string_sprintf("unknown parameter \"%.*s\" precedes LDAP URL",
1174             namelen, name);
1175         DEBUG(D_lookup) debug_printf_indent("LDAP query error: %s\n", *errmsg);
1176         return DEFER;
1177         }
1178       while (isspace(*url)) url++;
1179       continue;
1180       }
1181     }
1182   *errmsg = US"malformed parameter setting precedes LDAP URL";
1183   DEBUG(D_lookup) debug_printf_indent("LDAP query error: %s\n", *errmsg);
1184   return DEFER;
1185   }
1186
1187 /* If user is set, de-URL-quote it. Some LDAP libraries do this for themselves,
1188 but it seems that not all behave like this. The DN for the user is often the
1189 result of ${quote_ldap_dn:...} quoting, which does apply URL quoting, because
1190 that is needed when the DN is used as a base DN in a query. Sigh. This is all
1191 far too complicated. */
1192
1193 if (user)
1194   {
1195   uschar *t = user;
1196   for (uschar * s = user; *s != 0; s++)
1197     {
1198     int c, d;
1199     if (*s == '%' && isxdigit(c=s[1]) && isxdigit(d=s[2]))
1200       {
1201       c = tolower(c);
1202       d = tolower(d);
1203       *t++ =
1204         (((c >= 'a')? (10 + c - 'a') : c - '0') << 4) |
1205          ((d >= 'a')? (10 + d - 'a') : d - '0');
1206       s += 2;
1207       }
1208     else *t++ = *s;
1209     }
1210   *t = 0;
1211   }
1212
1213 DEBUG(D_lookup)
1214   debug_printf_indent("LDAP parameters: user=%s pass=%s size=%d time=%d connect=%d "
1215     "dereference=%d referrals=%s\n", user, password, sizelimit, timelimit,
1216     tcplimit, dereference, referrals == LDAP_OPT_ON ? "on" : "off");
1217
1218 /* If the request is just to check authentication, some credentials must
1219 be given. The password must not be empty because LDAP binds with an empty
1220 password are considered anonymous, and will succeed on most installations. */
1221
1222 if (search_type == SEARCH_LDAP_AUTH)
1223   {
1224   if (!user || !password)
1225     {
1226     *errmsg = US"ldapauth lookups must specify the username and password";
1227     return DEFER;
1228     }
1229   if (!*password)
1230     {
1231     DEBUG(D_lookup) debug_printf_indent("Empty password: ldapauth returns FAIL\n");
1232     return FAIL;
1233     }
1234   }
1235
1236 /* Check for valid ldap url starters */
1237
1238 p = url + 4;
1239 if (tolower(*p) == 's' || tolower(*p) == 'i') p++;
1240 if (Ustrncmp(p, "://", 3) != 0)
1241   {
1242   *errmsg = string_sprintf("LDAP URL does not start with \"ldap://\", "
1243     "\"ldaps://\", or \"ldapi://\" (it starts with \"%.16s...\")", url);
1244   DEBUG(D_lookup) debug_printf_indent("LDAP query error: %s\n", *errmsg);
1245   return DEFER;
1246   }
1247
1248 /* No default servers, or URL contains a server name: just one attempt */
1249
1250 if (!eldap_default_servers && !local_servers  || p[3] != '/')
1251   return perform_ldap_search(url, NULL, 0, search_type, res, errmsg,
1252     &defer_break, user, password, sizelimit, timelimit, tcplimit, dereference,
1253     referrals);
1254
1255 /* Loop through the servers until OK or FAIL. Use local_servers list
1256 if defined in the lookup, otherwise use the global default list */
1257
1258 list = local_servers ? local_servers : eldap_default_servers;
1259 for (uschar * server; server = string_nextinlist(&list, &sep, NULL, 0); )
1260   {
1261   int rc, port = 0;
1262   uschar *colon = Ustrchr(server, ':');
1263   if (colon)
1264     {
1265     *colon = 0;
1266     port = Uatoi(colon+1);
1267     }
1268   rc = perform_ldap_search(url, server, port, search_type, res, errmsg,
1269     &defer_break, user, password, sizelimit, timelimit, tcplimit, dereference,
1270     referrals);
1271   if (rc != DEFER || defer_break) return rc;
1272   }
1273
1274 return DEFER;
1275 }
1276
1277
1278
1279 /*************************************************
1280 *               Find entry point                 *
1281 *************************************************/
1282
1283 /* See local README for interface description. The different kinds of search
1284 are handled by a common function, with a flag to differentiate between them.
1285 The handle and filename arguments are not used. */
1286
1287 static int
1288 eldap_find(void * handle, const uschar * filename, const uschar * ldap_url,
1289   int length, uschar ** result, uschar ** errmsg, uint * do_cache,
1290   const uschar * opts)
1291 {
1292 return(control_ldap_search(ldap_url, SEARCH_LDAP_SINGLE, result, errmsg));
1293 }
1294
1295 static int
1296 eldapm_find(void * handle, const uschar * filename, const uschar * ldap_url,
1297   int length, uschar ** result, uschar ** errmsg, uint * do_cache,
1298   const uschar * opts)
1299 {
1300 return(control_ldap_search(ldap_url, SEARCH_LDAP_MULTIPLE, result, errmsg));
1301 }
1302
1303 static int
1304 eldapdn_find(void * handle, const uschar * filename, const uschar * ldap_url,
1305   int length, uschar ** result, uschar ** errmsg, uint * do_cache,
1306   const uschar * opts)
1307 {
1308 return(control_ldap_search(ldap_url, SEARCH_LDAP_DN, result, errmsg));
1309 }
1310
1311 int
1312 eldapauth_find(void * handle, const uschar * filename, const uschar * ldap_url,
1313   int length, uschar ** result, uschar ** errmsg, uint * do_cache)
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 g = string_fmt_append(g, "Library version: LDAP: Exim version %s\n", EXIM_VERSION_STR);
1568 #endif
1569 return g;
1570 }
1571
1572
1573 static lookup_info ldap_lookup_info = {
1574   .name = US"ldap",                     /* lookup name */
1575   .type = lookup_querystyle,            /* query-style lookup */
1576   .open = eldap_open,                   /* open function */
1577   .check = NULL,                        /* check function */
1578   .find = eldap_find,                   /* find function */
1579   .close = NULL,                        /* no close function */
1580   .tidy = eldap_tidy,                   /* tidy function */
1581   .quote = eldap_quote,                 /* quoting function */
1582   .version_report = ldap_version_report            /* version reporting */
1583 };
1584
1585 static lookup_info ldapdn_lookup_info = {
1586   .name = US"ldapdn",                   /* lookup name */
1587   .type = lookup_querystyle,            /* query-style lookup */
1588   .open = eldap_open,                   /* sic */    /* open function */
1589   .check = NULL,                        /* check function */
1590   .find = eldapdn_find,                 /* find function */
1591   .close = NULL,                        /* no close function */
1592   .tidy = eldap_tidy,                   /* sic */    /* tidy function */
1593   .quote = eldap_quote,                 /* sic */    /* quoting function */
1594   .version_report = NULL                           /* no version reporting (redundant) */
1595 };
1596
1597 static lookup_info ldapm_lookup_info = {
1598   .name = US"ldapm",                    /* lookup name */
1599   .type = lookup_querystyle,            /* query-style lookup */
1600   .open = eldap_open,                   /* sic */    /* open function */
1601   .check = NULL,                        /* check function */
1602   .find = eldapm_find,                  /* find function */
1603   .close = NULL,                        /* no close function */
1604   .tidy = eldap_tidy,                   /* sic */    /* tidy function */
1605   .quote = eldap_quote,                 /* sic */    /* quoting function */
1606   .version_report = NULL                           /* no version reporting (redundant) */
1607 };
1608
1609 #ifdef DYNLOOKUP
1610 #define ldap_lookup_module_info _lookup_module_info
1611 #endif
1612
1613 static lookup_info *_lookup_list[] = { &ldap_lookup_info, &ldapdn_lookup_info, &ldapm_lookup_info };
1614 lookup_module_info ldap_lookup_module_info = { LOOKUP_MODULE_INFO_MAGIC, _lookup_list, 3 };
1615
1616 /* End of lookups/ldap.c */