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