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