fe67e7f0a6f4bc665cc298d79f99970ff5951b77
[exim.git] / src / src / lookups / ldap.c
1 /*************************************************
2 *     Exim - an Internet mail transport agent    *
3 *************************************************/
4
5 /* Copyright (c) University of Cambridge 1995 - 2015 */
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)
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_cat(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, Ustrlen(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_cat(data, &size, &ptr, US" ", 1);
800             else
801               insert_space = TRUE;
802             data = string_cat(data, &size, &ptr, attr, Ustrlen(attr));
803             data = string_cat(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_cat(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_cat(data, &size, &ptr, US"\\n", 2);
833                 else if (value[j] == ',')
834                   data = string_cat(data, &size, &ptr, US",,", 2);
835                 else
836                   {
837                   if (value[j] == '\"' || value[j] == '\\')
838                     data = string_cat(data, &size, &ptr, US"\\", 1);
839                   data = string_cat(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                 {
851                 if (value[j] == ',')
852                   data = string_cat(data, &size, &ptr, US",,", 2);
853                 else
854                   data = string_cat(data, &size, &ptr, value+j, 1);
855                 }
856               }
857
858
859             /* Move on to the next value */
860
861             values++;
862             attribute_found = TRUE;
863             }
864
865           /* Closing quote at the end of the data for a named attribute. */
866
867           if (attrs_requested != 1)
868             data = string_cat(data, &size, &ptr, US"\"", 1);
869
870           /* Free the values */
871
872           ldap_value_free(CSS firstval);
873           }
874         }
875
876       #if defined LDAP_LIB_NETSCAPE || defined LDAP_LIB_OPENLDAP2
877
878       /* Netscape and OpenLDAP2 LDAP's attrs are dynamically allocated and need
879       to be freed. UMich LDAP stores them in static storage and does not require
880       this. */
881
882       ldap_memfree(attr);
883       #endif
884       }        /* End "for" loop for extracting attributes from an entry */
885     }          /* End "for" loop for extracting entries from a result */
886
887   /* Free the result */
888
889   ldap_msgfree(result);
890   result = NULL;
891   }            /* End "while" loop for multiple results */
892
893 /* Terminate the dynamic string that we have built and reclaim unused store */
894
895 if (data != NULL)
896   {
897   data[ptr] = 0;
898   store_reset(data + ptr + 1);
899   }
900
901 /* Copy the last dn into eldap_dn */
902
903 if (dn != NULL)
904   {
905   eldap_dn = string_copy(dn);
906   #if defined LDAP_LIB_NETSCAPE || defined LDAP_LIB_OPENLDAP2
907   ldap_memfree(dn);
908   #else   /* OPENLDAP 1, UMich, Solaris */
909   free(dn);
910   #endif
911   }
912
913 DEBUG(D_lookup) debug_printf("search ended by ldap_result yielding %d\n",rc);
914
915 if (rc == 0)
916   {
917   *errmsg = US"ldap_result timed out";
918   goto RETURN_ERROR;
919   }
920
921 /* A return code of -1 seems to mean "ldap_result failed internally or couldn't
922 provide you with a message". Other error states seem to exist where
923 ldap_result() didn't give us any message from the server at all, leaving result
924 set to NULL. Apparently, "the error parameters of the LDAP session handle will
925 be set accordingly". That's the best we can do to retrieve an error status; we
926 can't use functions like ldap_result2error because they parse a message from
927 the server, which we didn't get.
928
929 Annoyingly, the different implementations of LDAP have gone for different
930 methods of handling error codes and generating error messages. */
931
932 if (rc == -1 || result == NULL)
933   {
934   int err;
935   DEBUG(D_lookup) debug_printf("ldap_result failed\n");
936
937   #if defined LDAP_LIB_SOLARIS || defined LDAP_LIB_OPENLDAP2
938     ldap_get_option(lcp->ld, LDAP_OPT_ERROR_NUMBER, &err);
939     *errmsg = string_sprintf("ldap_result failed: %d, %s",
940       err, ldap_err2string(err));
941
942   #elif defined LDAP_LIB_NETSCAPE
943     /* Dubious (surely 'matched' is spurious here?) */
944     (void)ldap_get_lderrno(lcp->ld, &matched, &error1);
945     *errmsg = string_sprintf("ldap_result failed: %s (%s)", error1, matched);
946
947   #else                             /* UMich LDAP aka OpenLDAP 1.x */
948     *errmsg = string_sprintf("ldap_result failed: %d, %s",
949       lcp->ld->ld_errno, ldap_err2string(lcp->ld->ld_errno));
950   #endif
951
952   goto RETURN_ERROR;
953   }
954
955 /* A return code that isn't -1 doesn't necessarily mean there were no problems
956 with the search. The message must be an LDAP_RES_SEARCH_RESULT or
957 LDAP_RES_SEARCH_REFERENCE or else it's something we can't handle. Some versions
958 of LDAP do not define LDAP_RES_SEARCH_REFERENCE (LDAP v1 is one, it seems). So
959 we don't provide that functionality when we can't. :-) */
960
961 if (rc != LDAP_RES_SEARCH_RESULT
962 #ifdef LDAP_RES_SEARCH_REFERENCE
963     && rc != LDAP_RES_SEARCH_REFERENCE
964 #endif
965    )
966   {
967   *errmsg = string_sprintf("ldap_result returned unexpected code %d", rc);
968   goto RETURN_ERROR;
969   }
970
971 /* We have a result message from the server. This doesn't yet mean all is well.
972 We need to parse the message to find out exactly what's happened. */
973
974 #if defined LDAP_LIB_SOLARIS || defined LDAP_LIB_OPENLDAP2
975   ldap_rc = rc;
976   ldap_parse_rc = ldap_parse_result(lcp->ld, result, &rc, CSS &matched,
977     CSS &error2, NULL, NULL, 0);
978   DEBUG(D_lookup) debug_printf("ldap_parse_result: %d\n", ldap_parse_rc);
979   if (ldap_parse_rc < 0 &&
980       (ldap_parse_rc != LDAP_NO_RESULTS_RETURNED
981       #ifdef LDAP_RES_SEARCH_REFERENCE
982       || ldap_rc != LDAP_RES_SEARCH_REFERENCE
983       #endif
984      ))
985     {
986     *errmsg = string_sprintf("ldap_parse_result failed %d", ldap_parse_rc);
987     goto RETURN_ERROR;
988     }
989   error1 = US ldap_err2string(rc);
990
991 #elif defined LDAP_LIB_NETSCAPE
992   /* Dubious (it doesn't reference 'result' at all!) */
993   rc = ldap_get_lderrno(lcp->ld, &matched, &error1);
994
995 #else                             /* UMich LDAP aka OpenLDAP 1.x */
996   rc = ldap_result2error(lcp->ld, result, 0);
997   error1 = ldap_err2string(rc);
998   error2 = lcp->ld->ld_error;
999   matched = lcp->ld->ld_matched;
1000 #endif
1001
1002 /* Process the status as follows:
1003
1004   (1) If we get LDAP_SIZELIMIT_EXCEEDED, just carry on, to return the
1005       truncated result list.
1006
1007   (2) If we get LDAP_RES_SEARCH_REFERENCE, also just carry on. This was a
1008       submitted patch that is reported to "do the right thing" with Solaris
1009       LDAP libraries. (The problem it addresses apparently does not occur with
1010       Open LDAP.)
1011
1012   (3) The range of errors defined by LDAP_NAME_ERROR generally mean "that
1013       object does not, or cannot, exist in the database". For those cases we
1014       fail the lookup.
1015
1016   (4) All other non-successes here are treated as some kind of problem with
1017       the lookup, so return DEFER (which is the default in error_yield).
1018 */
1019
1020 DEBUG(D_lookup) debug_printf("ldap_parse_result yielded %d: %s\n",
1021   rc, ldap_err2string(rc));
1022
1023 if (rc != LDAP_SUCCESS && rc != LDAP_SIZELIMIT_EXCEEDED
1024     #ifdef LDAP_RES_SEARCH_REFERENCE
1025     && rc != LDAP_RES_SEARCH_REFERENCE
1026     #endif
1027     )
1028   {
1029   *errmsg = string_sprintf("LDAP search failed - error %d: %s%s%s%s%s",
1030     rc,
1031     (error1 != NULL)?                       error1  : US"",
1032     (error2 != NULL && error2[0] != 0)?     US"/"   : US"",
1033     (error2 != NULL)?                       error2  : US"",
1034     (matched != NULL && matched[0] != 0)?   US"/"   : US"",
1035     (matched != NULL)?                      matched : US"");
1036
1037   #if defined LDAP_NAME_ERROR
1038   if (LDAP_NAME_ERROR(rc))
1039   #elif defined NAME_ERROR    /* OPENLDAP1 calls it this */
1040   if (NAME_ERROR(rc))
1041   #else
1042   if (rc == LDAP_NO_SUCH_OBJECT)
1043   #endif
1044
1045     {
1046     DEBUG(D_lookup) debug_printf("lookup failure forced\n");
1047     error_yield = FAIL;
1048     }
1049   goto RETURN_ERROR;
1050   }
1051
1052 /* The search succeeded. Check if we have too many results */
1053
1054 if (search_type != SEARCH_LDAP_MULTIPLE && rescount > 1)
1055   {
1056   *errmsg = string_sprintf("LDAP search: more than one entry (%d) was returned "
1057     "(filter not specific enough?)", rescount);
1058   goto RETURN_ERROR_BREAK;
1059   }
1060
1061 /* Check if we have too few (zero) entries */
1062
1063 if (rescount < 1)
1064   {
1065   *errmsg = string_sprintf("LDAP search: no results");
1066   error_yield = FAIL;
1067   goto RETURN_ERROR_BREAK;
1068   }
1069
1070 /* If an entry was found, but it had no attributes, we behave as if no entries
1071 were found, that is, the lookup failed. */
1072
1073 if (!attribute_found)
1074   {
1075   *errmsg = US"LDAP search: found no attributes";
1076   error_yield = FAIL;
1077   goto RETURN_ERROR;
1078   }
1079
1080 /* Otherwise, it's all worked */
1081
1082 DEBUG(D_lookup) debug_printf("LDAP search: returning: %s\n", data);
1083 *res = data;
1084
1085 RETURN_OK:
1086 if (result != NULL) ldap_msgfree(result);
1087 ldap_free_urldesc(ludp);
1088 return OK;
1089
1090 /* Error returns */
1091
1092 RETURN_ERROR_BREAK:
1093 *defer_break = TRUE;
1094
1095 RETURN_ERROR:
1096 DEBUG(D_lookup) debug_printf("%s\n", *errmsg);
1097
1098 RETURN_ERROR_NOMSG:
1099 if (result != NULL) ldap_msgfree(result);
1100 if (ludp != NULL) ldap_free_urldesc(ludp);
1101
1102 #if defined LDAP_LIB_OPENLDAP2
1103   if (error2 != NULL)  ldap_memfree(error2);
1104   if (matched != NULL) ldap_memfree(matched);
1105 #endif
1106
1107 return error_yield;
1108 }
1109
1110
1111
1112 /*************************************************
1113 *        Internal search control function        *
1114 *************************************************/
1115
1116 /* This function is called from eldap_find(), eldapauth_find(), eldapdn_find(),
1117 and eldapm_find() with a difference in the "search_type" argument. It controls
1118 calls to perform_ldap_search() which actually does the work. We call that
1119 repeatedly for certain types of defer in the case when the URL contains no host
1120 name and eldap_default_servers is set to a list of servers to try. This gives
1121 more control than just passing over a list of hosts to ldap_open() because it
1122 handles other kinds of defer as well as just a failure to open. Note that the
1123 URL is defined to contain either zero or one "hostport" only.
1124
1125 Parameter data in addition to the URL can be passed as preceding text in the
1126 string, as items of the form XXX=yyy. The URL itself can be detected because it
1127 must begin "ldapx://", where x is empty, s, or i.
1128
1129 Arguments:
1130   ldap_url      the URL to be looked up, optionally preceded by other parameter
1131                 settings
1132   search_type   SEARCH_LDAP_MULTIPLE allows values from multiple entries
1133                 SEARCH_LDAP_SINGLE allows values from one entry only
1134                 SEARCH_LDAP_DN gets the DN from one entry
1135   res           set to point at the result
1136   errmsg        set to point a message if result is not OK
1137
1138 Returns:        OK or FAIL or DEFER
1139 */
1140
1141 static int
1142 control_ldap_search(const uschar *ldap_url, int search_type, uschar **res,
1143   uschar **errmsg)
1144 {
1145 BOOL defer_break = FALSE;
1146 int timelimit = LDAP_NO_LIMIT;
1147 int sizelimit = LDAP_NO_LIMIT;
1148 int tcplimit = 0;
1149 int sep = 0;
1150 int dereference = LDAP_DEREF_NEVER;
1151 void* referrals = LDAP_OPT_ON;
1152 const uschar *url = ldap_url;
1153 const uschar *p;
1154 uschar *user = NULL;
1155 uschar *password = NULL;
1156 uschar *local_servers = NULL;
1157 uschar *server;
1158 const uschar *list;
1159 uschar buffer[512];
1160
1161 while (isspace(*url)) url++;
1162
1163 /* Until the string begins "ldap", search for the other parameter settings that
1164 are recognized. They are of the form NAME=VALUE, with the value being
1165 optionally double-quoted. There must still be a space after it, however. No
1166 NAME has the value "ldap". */
1167
1168 while (strncmpic(url, US"ldap", 4) != 0)
1169   {
1170   const uschar *name = url;
1171   while (*url != 0 && *url != '=') url++;
1172   if (*url == '=')
1173     {
1174     int namelen;
1175     uschar *value;
1176     namelen = ++url - name;
1177     value = string_dequote(&url);
1178     if (isspace(*url))
1179       {
1180       if (strncmpic(name, US"USER=", namelen) == 0) user = value;
1181       else if (strncmpic(name, US"PASS=", namelen) == 0) password = value;
1182       else if (strncmpic(name, US"SIZE=", namelen) == 0) sizelimit = Uatoi(value);
1183       else if (strncmpic(name, US"TIME=", namelen) == 0) timelimit = Uatoi(value);
1184       else if (strncmpic(name, US"CONNECT=", namelen) == 0) tcplimit = Uatoi(value);
1185       else if (strncmpic(name, US"NETTIME=", namelen) == 0) tcplimit = Uatoi(value);
1186       else if (strncmpic(name, US"SERVERS=", namelen) == 0) local_servers = value;
1187
1188       /* Don't know if all LDAP libraries have LDAP_OPT_DEREF */
1189
1190       #ifdef LDAP_OPT_DEREF
1191       else if (strncmpic(name, US"DEREFERENCE=", namelen) == 0)
1192         {
1193         if (strcmpic(value, US"never") == 0) dereference = LDAP_DEREF_NEVER;
1194         else if (strcmpic(value, US"searching") == 0)
1195           dereference = LDAP_DEREF_SEARCHING;
1196         else if (strcmpic(value, US"finding") == 0)
1197           dereference = LDAP_DEREF_FINDING;
1198         if (strcmpic(value, US"always") == 0) dereference = LDAP_DEREF_ALWAYS;
1199         }
1200       #else
1201       else if (strncmpic(name, US"DEREFERENCE=", namelen) == 0)
1202         {
1203         *errmsg = string_sprintf("LDAP_OP_DEREF not defined in this LDAP "
1204           "library - cannot use \"dereference\"");
1205         DEBUG(D_lookup) debug_printf("%s\n", *errmsg);
1206         return DEFER;
1207         }
1208       #endif
1209
1210       #ifdef LDAP_OPT_REFERRALS
1211       else if (strncmpic(name, US"REFERRALS=", namelen) == 0)
1212         {
1213         if (strcmpic(value, US"follow") == 0) referrals = LDAP_OPT_ON;
1214         else if (strcmpic(value, US"nofollow") == 0) referrals = LDAP_OPT_OFF;
1215         else
1216           {
1217           *errmsg = string_sprintf("LDAP option REFERRALS is not \"follow\" "
1218             "or \"nofollow\"");
1219           DEBUG(D_lookup) debug_printf("%s\n", *errmsg);
1220           return DEFER;
1221           }
1222         }
1223       #else
1224       else if (strncmpic(name, US"REFERRALS=", namelen) == 0)
1225         {
1226         *errmsg = string_sprintf("LDAP_OP_REFERRALS not defined in this LDAP "
1227           "library - cannot use \"referrals\"");
1228         DEBUG(D_lookup) debug_printf("%s\n", *errmsg);
1229         return DEFER;
1230         }
1231       #endif
1232
1233       else
1234         {
1235         *errmsg =
1236           string_sprintf("unknown parameter \"%.*s\" precedes LDAP URL",
1237             namelen, name);
1238         DEBUG(D_lookup) debug_printf("LDAP query error: %s\n", *errmsg);
1239         return DEFER;
1240         }
1241       while (isspace(*url)) url++;
1242       continue;
1243       }
1244     }
1245   *errmsg = US"malformed parameter setting precedes LDAP URL";
1246   DEBUG(D_lookup) debug_printf("LDAP query error: %s\n", *errmsg);
1247   return DEFER;
1248   }
1249
1250 /* If user is set, de-URL-quote it. Some LDAP libraries do this for themselves,
1251 but it seems that not all behave like this. The DN for the user is often the
1252 result of ${quote_ldap_dn:...} quoting, which does apply URL quoting, because
1253 that is needed when the DN is used as a base DN in a query. Sigh. This is all
1254 far too complicated. */
1255
1256 if (user != NULL)
1257   {
1258   uschar *s;
1259   uschar *t = user;
1260   for (s = user; *s != 0; s++)
1261     {
1262     int c, d;
1263     if (*s == '%' && isxdigit(c=s[1]) && isxdigit(d=s[2]))
1264       {
1265       c = tolower(c);
1266       d = tolower(d);
1267       *t++ =
1268         (((c >= 'a')? (10 + c - 'a') : c - '0') << 4) |
1269          ((d >= 'a')? (10 + d - 'a') : d - '0');
1270       s += 2;
1271       }
1272     else *t++ = *s;
1273     }
1274   *t = 0;
1275   }
1276
1277 DEBUG(D_lookup)
1278   debug_printf("LDAP parameters: user=%s pass=%s size=%d time=%d connect=%d "
1279     "dereference=%d referrals=%s\n", user, password, sizelimit, timelimit,
1280     tcplimit, dereference, (referrals == LDAP_OPT_ON)? "on" : "off");
1281
1282 /* If the request is just to check authentication, some credentials must
1283 be given. The password must not be empty because LDAP binds with an empty
1284 password are considered anonymous, and will succeed on most installations. */
1285
1286 if (search_type == SEARCH_LDAP_AUTH)
1287   {
1288   if (user == NULL || password == NULL)
1289     {
1290     *errmsg = US"ldapauth lookups must specify the username and password";
1291     return DEFER;
1292     }
1293   if (password[0] == 0)
1294     {
1295     DEBUG(D_lookup) debug_printf("Empty password: ldapauth returns FAIL\n");
1296     return FAIL;
1297     }
1298   }
1299
1300 /* Check for valid ldap url starters */
1301
1302 p = url + 4;
1303 if (tolower(*p) == 's' || tolower(*p) == 'i') p++;
1304 if (Ustrncmp(p, "://", 3) != 0)
1305   {
1306   *errmsg = string_sprintf("LDAP URL does not start with \"ldap://\", "
1307     "\"ldaps://\", or \"ldapi://\" (it starts with \"%.16s...\")", url);
1308   DEBUG(D_lookup) debug_printf("LDAP query error: %s\n", *errmsg);
1309   return DEFER;
1310   }
1311
1312 /* No default servers, or URL contains a server name: just one attempt */
1313
1314 if ((eldap_default_servers == NULL && local_servers == NULL) || p[3] != '/')
1315   {
1316   return perform_ldap_search(url, NULL, 0, search_type, res, errmsg,
1317     &defer_break, user, password, sizelimit, timelimit, tcplimit, dereference,
1318     referrals);
1319   }
1320
1321 /* Loop through the default servers until OK or FAIL. Use local_servers list
1322  * if defined in the lookup, otherwise use the global default list */
1323 list = (local_servers == NULL) ? eldap_default_servers : local_servers;
1324 while ((server = string_nextinlist(&list, &sep, buffer, sizeof(buffer))) != NULL)
1325   {
1326   int rc;
1327   int port = 0;
1328   uschar *colon = Ustrchr(server, ':');
1329   if (colon != NULL)
1330     {
1331     *colon = 0;
1332     port = Uatoi(colon+1);
1333     }
1334   rc = perform_ldap_search(url, server, port, search_type, res, errmsg,
1335     &defer_break, user, password, sizelimit, timelimit, tcplimit, dereference,
1336     referrals);
1337   if (rc != DEFER || defer_break) return rc;
1338   }
1339
1340 return DEFER;
1341 }
1342
1343
1344
1345 /*************************************************
1346 *               Find entry point                 *
1347 *************************************************/
1348
1349 /* See local README for interface description. The different kinds of search
1350 are handled by a common function, with a flag to differentiate between them.
1351 The handle and filename arguments are not used. */
1352
1353 static int
1354 eldap_find(void *handle, uschar *filename, const uschar *ldap_url, int length,
1355   uschar **result, uschar **errmsg, uint *do_cache)
1356 {
1357 /* Keep picky compilers happy */
1358 do_cache = do_cache;
1359 return(control_ldap_search(ldap_url, SEARCH_LDAP_SINGLE, result, errmsg));
1360 }
1361
1362 static int
1363 eldapm_find(void *handle, uschar *filename, const uschar *ldap_url, int length,
1364   uschar **result, uschar **errmsg, uint *do_cache)
1365 {
1366 /* Keep picky compilers happy */
1367 do_cache = do_cache;
1368 return(control_ldap_search(ldap_url, SEARCH_LDAP_MULTIPLE, result, errmsg));
1369 }
1370
1371 static int
1372 eldapdn_find(void *handle, uschar *filename, const uschar *ldap_url, int length,
1373   uschar **result, uschar **errmsg, uint *do_cache)
1374 {
1375 /* Keep picky compilers happy */
1376 do_cache = do_cache;
1377 return(control_ldap_search(ldap_url, SEARCH_LDAP_DN, result, errmsg));
1378 }
1379
1380 int
1381 eldapauth_find(void *handle, uschar *filename, const uschar *ldap_url, int length,
1382   uschar **result, uschar **errmsg, uint *do_cache)
1383 {
1384 /* Keep picky compilers happy */
1385 do_cache = do_cache;
1386 return(control_ldap_search(ldap_url, SEARCH_LDAP_AUTH, result, errmsg));
1387 }
1388
1389
1390
1391 /*************************************************
1392 *              Open entry point                  *
1393 *************************************************/
1394
1395 /* See local README for interface description. */
1396
1397 static void *
1398 eldap_open(uschar *filename, uschar **errmsg)
1399 {
1400 return (void *)(1);    /* Just return something non-null */
1401 }
1402
1403
1404
1405 /*************************************************
1406 *               Tidy entry point                 *
1407 *************************************************/
1408
1409 /* See local README for interface description.
1410 Make sure that eldap_dn does not refer to reclaimed or worse, freed store */
1411
1412 static void
1413 eldap_tidy(void)
1414 {
1415 LDAP_CONNECTION *lcp = NULL;
1416 eldap_dn = NULL;
1417
1418 while ((lcp = ldap_connections) != NULL)
1419   {
1420   DEBUG(D_lookup) debug_printf("unbind LDAP connection to %s:%d\n", lcp->host,
1421     lcp->port);
1422   if(lcp->bound == TRUE)
1423     ldap_unbind(lcp->ld);
1424   ldap_connections = lcp->next;
1425   }
1426 }
1427
1428
1429
1430 /*************************************************
1431 *               Quote entry point                *
1432 *************************************************/
1433
1434 /* LDAP quoting is unbelievably messy. For a start, two different levels of
1435 quoting have to be done: LDAP quoting, and URL quoting. The current
1436 specification is the result of a suggestion by Brian Candler. It recognizes
1437 two separate cases:
1438
1439 (1) For text that appears in a search filter, the following escapes are
1440     required (see RFC 2254):
1441
1442       *    ->   \2A
1443       (    ->   \28
1444       )    ->   \29
1445       \    ->   \5C
1446      NULL  ->   \00
1447
1448     Then the entire filter text must be URL-escaped. This kind of quoting is
1449     implemented by ${quote_ldap:....}. Note that we can never have a NULL
1450     in the input string, because that's a terminator.
1451
1452 (2) For a DN that is part of a URL (i.e. the base DN), the characters
1453
1454       , + " \ < > ;
1455
1456     must be quoted by backslashing. See RFC 2253. Leading and trailing spaces
1457     must be escaped, as must a leading #. Then the string must be URL-quoted.
1458     This type of quoting is implemented by ${quote_ldap_dn:....}.
1459
1460 For URL quoting, the only characters that need not be quoted are the
1461 alphamerics and
1462
1463   ! $ ' ( ) * + - . _
1464
1465 All the others must be hexified and preceded by %. This includes the
1466 backslashes used for LDAP quoting.
1467
1468 For a DN that is given in the USER parameter for authentication, we need the
1469 same initial quoting as (2) but in this case, the result must NOT be
1470 URL-escaped, because it isn't a URL. The way this is handled is by
1471 de-URL-quoting the text when processing the USER parameter in
1472 control_ldap_search() above. That means that the same quote operator can be
1473 used. This has the additional advantage that spaces in the DN won't cause
1474 parsing problems. For example:
1475
1476   USER=cn=${quote_ldap_dn:$1},%20dc=example,%20dc=com
1477
1478 should be safe if there are spaces in $1.
1479
1480
1481 Arguments:
1482   s          the string to be quoted
1483   opt        additional option text or NULL if none
1484              only "dn" is recognized
1485
1486 Returns:     the processed string or NULL for a bad option
1487 */
1488
1489
1490
1491 /* The characters in this string, together with alphanumerics, never need
1492 quoting in any way. */
1493
1494 #define ALWAYS_LITERAL  "!$'-._"
1495
1496 /* The special characters in this string do not need to be URL-quoted. The set
1497 is a bit larger than the general literals. */
1498
1499 #define URL_NONQUOTE    ALWAYS_LITERAL "()*+"
1500
1501 /* The following macros define the characters that are quoted by quote_ldap and
1502 quote_ldap_dn, respectively. */
1503
1504 #define LDAP_QUOTE      "*()\\"
1505 #define LDAP_DN_QUOTE   ",+\"\\<>;"
1506
1507
1508
1509 static uschar *
1510 eldap_quote(uschar *s, uschar *opt)
1511 {
1512 register int c;
1513 int count = 0;
1514 int len = 0;
1515 BOOL dn = FALSE;
1516 uschar *t = s;
1517 uschar *quoted;
1518
1519 /* Test for a DN quotation. */
1520
1521 if (opt != NULL)
1522   {
1523   if (Ustrcmp(opt, "dn") != 0) return NULL;    /* No others recognized */
1524   dn = TRUE;
1525   }
1526
1527 /* Compute how much extra store we need for the string. This doesn't have to be
1528 exact as long as it isn't an underestimate. The worst case is the addition of 5
1529 extra bytes for a single character. This occurs for certain characters in DNs,
1530 where, for example, < turns into %5C%3C. For simplicity, we just add 5 for each
1531 possibly escaped character. The really fast way would be just to test for
1532 non-alphanumerics, but it is probably better to spot a few others that are
1533 never escaped, because if there are no specials at all, we can avoid copying
1534 the string. */
1535
1536 while ((c = *t++) != 0)
1537   {
1538   len++;
1539   if (!isalnum(c) && Ustrchr(ALWAYS_LITERAL, c) == NULL) count += 5;
1540   }
1541 if (count == 0) return s;
1542
1543 /* Get sufficient store to hold the quoted string */
1544
1545 t = quoted = store_get(len + count + 1);
1546
1547 /* Handle plain quote_ldap */
1548
1549 if (!dn)
1550   {
1551   while ((c = *s++) != 0)
1552     {
1553     if (!isalnum(c))
1554       {
1555       if (Ustrchr(LDAP_QUOTE, c) != NULL)
1556         {
1557         sprintf(CS t, "%%5C%02X", c);        /* e.g. * => %5C2A */
1558         t += 5;
1559         continue;
1560         }
1561       if (Ustrchr(URL_NONQUOTE, c) == NULL)  /* e.g. ] => %5D */
1562         {
1563         sprintf(CS t, "%%%02X", c);
1564         t += 3;
1565         continue;
1566         }
1567       }
1568     *t++ = c;                                /* unquoted character */
1569     }
1570   }
1571
1572 /* Handle quote_ldap_dn */
1573
1574 else
1575   {
1576   uschar *ss = s + len;
1577
1578   /* Find the last char before any trailing spaces */
1579
1580   while (ss > s && ss[-1] == ' ') ss--;
1581
1582   /* Quote leading spaces and sharps */
1583
1584   for (; s < ss; s++)
1585     {
1586     if (*s != ' ' && *s != '#') break;
1587     sprintf(CS t, "%%5C%%%02X", *s);
1588     t += 6;
1589     }
1590
1591   /* Handle the rest of the string, up to the trailing spaces */
1592
1593   while (s < ss)
1594     {
1595     c = *s++;
1596     if (!isalnum(c))
1597       {
1598       if (Ustrchr(LDAP_DN_QUOTE, c) != NULL)
1599         {
1600         Ustrncpy(t, "%5C", 3);               /* insert \ where needed */
1601         t += 3;                              /* fall through to check URL */
1602         }
1603       if (Ustrchr(URL_NONQUOTE, c) == NULL)  /* e.g. ] => %5D */
1604         {
1605         sprintf(CS t, "%%%02X", c);
1606         t += 3;
1607         continue;
1608         }
1609       }
1610     *t++ = c;    /* unquoted character, or non-URL quoted after %5C */
1611     }
1612
1613   /* Handle the trailing spaces */
1614
1615   while (*ss++ != 0)
1616     {
1617     Ustrncpy(t, "%5C%20", 6);
1618     t += 6;
1619     }
1620   }
1621
1622 /* Terminate the new string and return */
1623
1624 *t = 0;
1625 return quoted;
1626 }
1627
1628
1629
1630 /*************************************************
1631 *         Version reporting entry point          *
1632 *************************************************/
1633
1634 /* See local README for interface description. */
1635
1636 #include "../version.h"
1637
1638 void
1639 ldap_version_report(FILE *f)
1640 {
1641 #ifdef DYNLOOKUP
1642 fprintf(f, "Library version: LDAP: Exim version %s\n", EXIM_VERSION_STR);
1643 #endif
1644 }
1645
1646
1647 static lookup_info ldap_lookup_info = {
1648   US"ldap",                      /* lookup name */
1649   lookup_querystyle,             /* query-style lookup */
1650   eldap_open,                    /* open function */
1651   NULL,                          /* check function */
1652   eldap_find,                    /* find function */
1653   NULL,                          /* no close function */
1654   eldap_tidy,                    /* tidy function */
1655   eldap_quote,                   /* quoting function */
1656   ldap_version_report            /* version reporting */
1657 };
1658
1659 static lookup_info ldapdn_lookup_info = {
1660   US"ldapdn",                     /* lookup name */
1661   lookup_querystyle,             /* query-style lookup */
1662   eldap_open,       /* sic */    /* open function */
1663   NULL,                          /* check function */
1664   eldapdn_find,                  /* find function */
1665   NULL,                          /* no close function */
1666   eldap_tidy,       /* sic */    /* tidy function */
1667   eldap_quote,      /* sic */    /* quoting function */
1668   NULL                           /* no version reporting (redundant) */
1669 };
1670
1671 static lookup_info ldapm_lookup_info = {
1672   US"ldapm",                     /* lookup name */
1673   lookup_querystyle,             /* query-style lookup */
1674   eldap_open,       /* sic */    /* open function */
1675   NULL,                          /* check function */
1676   eldapm_find,                   /* find function */
1677   NULL,                          /* no close function */
1678   eldap_tidy,       /* sic */    /* tidy function */
1679   eldap_quote,      /* sic */    /* quoting function */
1680   NULL                           /* no version reporting (redundant) */
1681 };
1682
1683 #ifdef DYNLOOKUP
1684 #define ldap_lookup_module_info _lookup_module_info
1685 #endif
1686
1687 static lookup_info *_lookup_list[] = { &ldap_lookup_info, &ldapdn_lookup_info, &ldapm_lookup_info };
1688 lookup_module_info ldap_lookup_module_info = { LOOKUP_MODULE_INFO_MAGIC, _lookup_list, 3 };
1689
1690 /* End of lookups/ldap.c */