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