dirmngr: Minor cleanups.
[gnupg.git] / dirmngr / ks-engine-ldap.c
1 /* ks-engine-ldap.c - talk to a LDAP keyserver
2  * Copyright (C) 2001, 2002, 2004, 2005, 2006
3  *               2007  Free Software Foundation, Inc.
4  * Copyright (C) 2015  g10 Code GmbH
5  *
6  * This file is part of GnuPG.
7  *
8  * GnuPG is free software; you can redistribute it and/or modify
9  * it under the terms of the GNU General Public License as published by
10  * the Free Software Foundation; either version 3 of the License, or
11  * (at your option) any later version.
12  *
13  * GnuPG is distributed in the hope that it will be useful,
14  * but WITHOUT ANY WARRANTY; without even the implied warranty of
15  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
16  * GNU General Public License for more details.
17  *
18  * You should have received a copy of the GNU General Public License
19  * along with this program; if not, see <http://www.gnu.org/licenses/>.
20  */
21
22 #include <config.h>
23 #include <stdio.h>
24 #include <string.h>
25 #include <time.h>
26 #include <unistd.h>
27 #ifdef HAVE_GETOPT_H
28 # include <getopt.h>
29 #endif
30 #include <stdlib.h>
31 #include <errno.h>
32 #include <assert.h>
33
34 #ifdef _WIN32
35 # include <winsock2.h>
36 # include <winldap.h>
37 #else
38 # ifdef NEED_LBER_H
39 #  include <lber.h>
40 # endif
41 /* For OpenLDAP, to enable the API that we're using. */
42 # define LDAP_DEPRECATED 1
43 # include <ldap.h>
44 #endif
45
46 #include "dirmngr.h"
47 #include "misc.h"
48 #include "userids.h"
49 #include "ks-engine.h"
50 #include "ldap-parse-uri.h"
51
52 #ifndef HAVE_TIMEGM
53 time_t timegm(struct tm *tm);
54 #endif
55 \f
56 /* Convert an LDAP error to a GPG error.  */
57 static int
58 ldap_err_to_gpg_err (int code)
59 {
60   gpg_err_code_t ec;
61
62   switch (code)
63     {
64 #ifdef LDAP_X_CONNECTING
65     case LDAP_X_CONNECTING: ec = GPG_ERR_LDAP_X_CONNECTING; break;
66 #endif
67
68     case LDAP_REFERRAL_LIMIT_EXCEEDED: ec = GPG_ERR_LDAP_REFERRAL_LIMIT; break;
69     case LDAP_CLIENT_LOOP: ec = GPG_ERR_LDAP_CLIENT_LOOP; break;
70     case LDAP_NO_RESULTS_RETURNED: ec = GPG_ERR_LDAP_NO_RESULTS; break;
71     case LDAP_CONTROL_NOT_FOUND: ec = GPG_ERR_LDAP_CONTROL_NOT_FOUND; break;
72     case LDAP_NOT_SUPPORTED: ec = GPG_ERR_LDAP_NOT_SUPPORTED; break;
73     case LDAP_CONNECT_ERROR: ec = GPG_ERR_LDAP_CONNECT; break;
74     case LDAP_NO_MEMORY: ec = GPG_ERR_LDAP_NO_MEMORY; break;
75     case LDAP_PARAM_ERROR: ec = GPG_ERR_LDAP_PARAM; break;
76     case LDAP_USER_CANCELLED: ec = GPG_ERR_LDAP_USER_CANCELLED; break;
77     case LDAP_FILTER_ERROR: ec = GPG_ERR_LDAP_FILTER; break;
78     case LDAP_AUTH_UNKNOWN: ec = GPG_ERR_LDAP_AUTH_UNKNOWN; break;
79     case LDAP_TIMEOUT: ec = GPG_ERR_LDAP_TIMEOUT; break;
80     case LDAP_DECODING_ERROR: ec = GPG_ERR_LDAP_DECODING; break;
81     case LDAP_ENCODING_ERROR: ec = GPG_ERR_LDAP_ENCODING; break;
82     case LDAP_LOCAL_ERROR: ec = GPG_ERR_LDAP_LOCAL; break;
83     case LDAP_SERVER_DOWN: ec = GPG_ERR_LDAP_SERVER_DOWN; break;
84
85     case LDAP_SUCCESS: ec = GPG_ERR_LDAP_SUCCESS; break;
86
87     case LDAP_OPERATIONS_ERROR: ec = GPG_ERR_LDAP_OPERATIONS; break;
88     case LDAP_PROTOCOL_ERROR: ec = GPG_ERR_LDAP_PROTOCOL; break;
89     case LDAP_TIMELIMIT_EXCEEDED: ec = GPG_ERR_LDAP_TIMELIMIT; break;
90     case LDAP_SIZELIMIT_EXCEEDED: ec = GPG_ERR_LDAP_SIZELIMIT; break;
91     case LDAP_COMPARE_FALSE: ec = GPG_ERR_LDAP_COMPARE_FALSE; break;
92     case LDAP_COMPARE_TRUE: ec = GPG_ERR_LDAP_COMPARE_TRUE; break;
93     case LDAP_AUTH_METHOD_NOT_SUPPORTED: ec=GPG_ERR_LDAP_UNSUPPORTED_AUTH;break;
94     case LDAP_STRONG_AUTH_REQUIRED: ec = GPG_ERR_LDAP_STRONG_AUTH_RQRD; break;
95     case LDAP_PARTIAL_RESULTS: ec = GPG_ERR_LDAP_PARTIAL_RESULTS; break;
96     case LDAP_REFERRAL: ec = GPG_ERR_LDAP_REFERRAL; break;
97
98 #ifdef LDAP_ADMINLIMIT_EXCEEDED
99     case LDAP_ADMINLIMIT_EXCEEDED: ec = GPG_ERR_LDAP_ADMINLIMIT; break;
100 #endif
101
102 #ifdef LDAP_UNAVAILABLE_CRITICAL_EXTENSION
103     case LDAP_UNAVAILABLE_CRITICAL_EXTENSION:
104                                ec = GPG_ERR_LDAP_UNAVAIL_CRIT_EXTN; break;
105 #endif
106
107     case LDAP_CONFIDENTIALITY_REQUIRED: ec = GPG_ERR_LDAP_CONFIDENT_RQRD; break;
108     case LDAP_SASL_BIND_IN_PROGRESS: ec = GPG_ERR_LDAP_SASL_BIND_INPROG; break;
109     case LDAP_NO_SUCH_ATTRIBUTE: ec = GPG_ERR_LDAP_NO_SUCH_ATTRIBUTE; break;
110     case LDAP_UNDEFINED_TYPE: ec = GPG_ERR_LDAP_UNDEFINED_TYPE; break;
111     case LDAP_INAPPROPRIATE_MATCHING: ec = GPG_ERR_LDAP_BAD_MATCHING; break;
112     case LDAP_CONSTRAINT_VIOLATION: ec = GPG_ERR_LDAP_CONST_VIOLATION; break;
113
114 #ifdef LDAP_TYPE_OR_VALUE_EXISTS
115     case LDAP_TYPE_OR_VALUE_EXISTS: ec = GPG_ERR_LDAP_TYPE_VALUE_EXISTS; break;
116 #endif
117
118     case LDAP_INVALID_SYNTAX: ec = GPG_ERR_LDAP_INV_SYNTAX; break;
119     case LDAP_NO_SUCH_OBJECT: ec = GPG_ERR_LDAP_NO_SUCH_OBJ; break;
120     case LDAP_ALIAS_PROBLEM: ec = GPG_ERR_LDAP_ALIAS_PROBLEM; break;
121     case LDAP_INVALID_DN_SYNTAX: ec = GPG_ERR_LDAP_INV_DN_SYNTAX; break;
122     case LDAP_IS_LEAF: ec = GPG_ERR_LDAP_IS_LEAF; break;
123     case LDAP_ALIAS_DEREF_PROBLEM: ec = GPG_ERR_LDAP_ALIAS_DEREF; break;
124
125 #ifdef LDAP_X_PROXY_AUTHZ_FAILURE
126     case LDAP_X_PROXY_AUTHZ_FAILURE: ec = GPG_ERR_LDAP_X_PROXY_AUTH_FAIL; break;
127 #endif
128
129     case LDAP_INAPPROPRIATE_AUTH: ec = GPG_ERR_LDAP_BAD_AUTH; break;
130     case LDAP_INVALID_CREDENTIALS: ec = GPG_ERR_LDAP_INV_CREDENTIALS; break;
131
132 #ifdef LDAP_INSUFFICIENT_ACCESS
133     case LDAP_INSUFFICIENT_ACCESS: ec = GPG_ERR_LDAP_INSUFFICIENT_ACC; break;
134 #endif
135
136     case LDAP_BUSY: ec = GPG_ERR_LDAP_BUSY; break;
137     case LDAP_UNAVAILABLE: ec = GPG_ERR_LDAP_UNAVAILABLE; break;
138     case LDAP_UNWILLING_TO_PERFORM: ec = GPG_ERR_LDAP_UNWILL_TO_PERFORM; break;
139     case LDAP_LOOP_DETECT: ec = GPG_ERR_LDAP_LOOP_DETECT; break;
140     case LDAP_NAMING_VIOLATION: ec = GPG_ERR_LDAP_NAMING_VIOLATION; break;
141     case LDAP_OBJECT_CLASS_VIOLATION: ec = GPG_ERR_LDAP_OBJ_CLS_VIOLATION; break;
142     case LDAP_NOT_ALLOWED_ON_NONLEAF: ec=GPG_ERR_LDAP_NOT_ALLOW_NONLEAF;break;
143     case LDAP_NOT_ALLOWED_ON_RDN: ec = GPG_ERR_LDAP_NOT_ALLOW_ON_RDN; break;
144     case LDAP_ALREADY_EXISTS: ec = GPG_ERR_LDAP_ALREADY_EXISTS; break;
145     case LDAP_NO_OBJECT_CLASS_MODS: ec = GPG_ERR_LDAP_NO_OBJ_CLASS_MODS; break;
146     case LDAP_RESULTS_TOO_LARGE: ec = GPG_ERR_LDAP_RESULTS_TOO_LARGE; break;
147     case LDAP_AFFECTS_MULTIPLE_DSAS: ec = GPG_ERR_LDAP_AFFECTS_MULT_DSAS; break;
148
149 #ifdef LDAP_VLV_ERROR
150     case LDAP_VLV_ERROR: ec = GPG_ERR_LDAP_VLV; break;
151 #endif
152
153     case LDAP_OTHER: ec = GPG_ERR_LDAP_OTHER; break;
154
155 #ifdef LDAP_CUP_RESOURCES_EXHAUSTED
156     case LDAP_CUP_RESOURCES_EXHAUSTED: ec=GPG_ERR_LDAP_CUP_RESOURCE_LIMIT;break;
157     case LDAP_CUP_SECURITY_VIOLATION: ec=GPG_ERR_LDAP_CUP_SEC_VIOLATION; break;
158     case LDAP_CUP_INVALID_DATA: ec = GPG_ERR_LDAP_CUP_INV_DATA; break;
159     case LDAP_CUP_UNSUPPORTED_SCHEME: ec = GPG_ERR_LDAP_CUP_UNSUP_SCHEME; break;
160     case LDAP_CUP_RELOAD_REQUIRED: ec = GPG_ERR_LDAP_CUP_RELOAD; break;
161 #endif
162
163 #ifdef LDAP_CANCELLED
164     case LDAP_CANCELLED: ec = GPG_ERR_LDAP_CANCELLED; break;
165 #endif
166
167 #ifdef LDAP_NO_SUCH_OPERATION
168     case LDAP_NO_SUCH_OPERATION: ec = GPG_ERR_LDAP_NO_SUCH_OPERATION; break;
169 #endif
170
171 #ifdef LDAP_TOO_LATE
172     case LDAP_TOO_LATE: ec = GPG_ERR_LDAP_TOO_LATE; break;
173 #endif
174
175 #ifdef LDAP_CANNOT_CANCEL
176     case LDAP_CANNOT_CANCEL: ec = GPG_ERR_LDAP_CANNOT_CANCEL; break;
177 #endif
178
179 #ifdef LDAP_ASSERTION_FAILED
180     case LDAP_ASSERTION_FAILED: ec = GPG_ERR_LDAP_ASSERTION_FAILED; break;
181 #endif
182
183 #ifdef LDAP_PROXIED_AUTHORIZATION_DENIED
184     case LDAP_PROXIED_AUTHORIZATION_DENIED:
185                                       ec = GPG_ERR_LDAP_PROX_AUTH_DENIED; break;
186 #endif
187
188     default:
189 #if defined(LDAP_E_ERROR) && defined(LDAP_X_ERROR)
190       if (LDAP_E_ERROR (code))
191         ec = GPG_ERR_LDAP_E_GENERAL;
192       else if (LDAP_X_ERROR (code))
193         ec = GPG_ERR_LDAP_X_GENERAL;
194       else
195 #endif
196         ec = GPG_ERR_LDAP_GENERAL;
197       break;
198     }
199
200   return ec;
201 }
202
203 /* Retrieve an LDAP error and return it's GPG equivalent.  */
204 static int
205 ldap_to_gpg_err (LDAP *ld)
206 {
207 #if defined(HAVE_LDAP_GET_OPTION) && defined(LDAP_OPT_ERROR_NUMBER)
208   int err;
209
210   if (ldap_get_option (ld, LDAP_OPT_ERROR_NUMBER, &err) == 0)
211     return ldap_err_to_gpg_err (err);
212   else
213     return GPG_ERR_GENERAL;
214 #elif defined(HAVE_LDAP_LD_ERRNO)
215   return ldap_err_to_gpg_err (ld->ld_errno);
216 #else
217   /* We should never get here since the LDAP library should always
218      have either ldap_get_option or ld_errno, but just in case... */
219   return GPG_ERR_INTERNAL;
220 #endif
221 }
222 \f
223 static time_t
224 ldap2epochtime (const char *timestr)
225 {
226   struct tm pgptime;
227   time_t answer;
228
229   memset (&pgptime, 0, sizeof(pgptime));
230
231   /* YYYYMMDDHHmmssZ */
232
233   sscanf (timestr, "%4d%2d%2d%2d%2d%2d",
234           &pgptime.tm_year,
235           &pgptime.tm_mon,
236           &pgptime.tm_mday,
237           &pgptime.tm_hour,
238           &pgptime.tm_min,
239           &pgptime.tm_sec);
240
241   pgptime.tm_year -= 1900;
242   pgptime.tm_isdst = -1;
243   pgptime.tm_mon--;
244
245   /* mktime() takes the timezone into account, so we use timegm() */
246
247   answer = timegm (&pgptime);
248
249   return answer;
250 }
251
252 /* Caller must free the result.  */
253 static char *
254 tm2ldaptime (struct tm *tm)
255 {
256   struct tm tmp = *tm;
257   char buf[16];
258
259   /* YYYYMMDDHHmmssZ */
260
261   tmp.tm_year += 1900;
262   tmp.tm_mon ++;
263
264   snprintf (buf, sizeof buf, "%04d%02d%02d%02d%02d%02dZ",
265            tmp.tm_year,
266            tmp.tm_mon,
267            tmp.tm_mday,
268            tmp.tm_hour,
269            tmp.tm_min,
270            tmp.tm_sec);
271
272   return xstrdup (buf);
273 }
274
275 #if 0
276 /* Caller must free */
277 static char *
278 epoch2ldaptime (time_t stamp)
279 {
280   struct tm tm;
281   if (gmtime_r (&stamp, &tm))
282     return tm2ldaptime (&tm);
283   else
284     return xstrdup ("INVALID TIME");
285 }
286 #endif
287 \f
288 /* Print a help output for the schemata supported by this module. */
289 gpg_error_t
290 ks_ldap_help (ctrl_t ctrl, parsed_uri_t uri)
291 {
292   const char const data[] =
293     "Handler for LDAP URLs:\n"
294     "  ldap://host:port/[BASEDN]???[bindname=BINDNAME,password=PASSWORD]\n"
295     "\n"
296     "Note: basedn, bindname and password need to be percent escaped. In\n"
297     "particular, spaces need to be replaced with %20 and commas with %2c.\n"
298     "bindname will typically be of the form:\n"
299     "\n"
300     "  uid=user%2cou=PGP%20Users%2cdc=EXAMPLE%2cdc=ORG\n"
301     "\n"
302     "The ldaps:// and ldapi:// schemes are also supported.  If ldaps is used\n"
303     "then the server's certificate will be checked.  If it is not valid, any\n"
304     "operation will be aborted.\n"
305     "\n"
306     "Supported methods: search, get, put\n";
307   gpg_error_t err;
308
309   if (strcmp (uri->scheme, "ldap") == 0
310       || strcmp (uri->scheme, "ldaps") == 0
311       || strcmp (uri->scheme, "ldapi") == 0)
312     err = ks_print_help (ctrl, data);
313   else
314     err = 0;
315
316   return err;
317 }
318 \f
319 /* Convert a keyspec to a filter.  Return an error if the keyspec is
320    bad or is not supported.  The filter is escaped and returned in
321    *filter.  It is the caller's responsibility to free *filter.
322    *filter is only set if this function returns success (i.e., 0).  */
323 static gpg_error_t
324 keyspec_to_ldap_filter (const char *keyspec, char **filter, int only_exact)
325 {
326   /* Remove search type indicator and adjust PATTERN accordingly.
327      Note: don't include a preceding 0x when searching by keyid.  */
328
329   /* XXX: Should we include disabled / revoke options?  */
330   KEYDB_SEARCH_DESC desc;
331   char *f = NULL;
332
333   gpg_error_t err = classify_user_id (keyspec, &desc, 1);
334   if (err)
335     return err;
336
337   switch (desc.mode)
338     {
339     case KEYDB_SEARCH_MODE_EXACT:
340       f = xasprintf ("(pgpUserID=%s)",
341                      ldap_escape_filter (desc.u.name));
342       break;
343
344     case KEYDB_SEARCH_MODE_SUBSTR:
345       if (! only_exact)
346         f = xasprintf ("(pgpUserID=*%s*)",
347                        ldap_escape_filter (desc.u.name));
348       break;
349
350     case KEYDB_SEARCH_MODE_MAIL:
351       if (! only_exact)
352         f = xasprintf ("(pgpUserID=*<%s>*)",
353                        ldap_escape_filter (desc.u.name));
354       break;
355
356     case KEYDB_SEARCH_MODE_MAILSUB:
357       if (! only_exact)
358         f = xasprintf ("(pgpUserID=*<*%s*>*)",
359                        ldap_escape_filter (desc.u.name));
360       break;
361
362     case KEYDB_SEARCH_MODE_MAILEND:
363       if (! only_exact)
364         f = xasprintf ("(pgpUserID=*<*%s>*)",
365                        ldap_escape_filter (desc.u.name));
366       break;
367
368     case KEYDB_SEARCH_MODE_SHORT_KID:
369       f = xasprintf ("(pgpKeyID=%08lX)", (ulong) desc.u.kid[1]);
370       break;
371     case KEYDB_SEARCH_MODE_LONG_KID:
372       f = xasprintf ("(pgpCertID=%08lX%08lX)",
373                      (ulong) desc.u.kid[0], (ulong) desc.u.kid[1]);
374       break;
375
376     case KEYDB_SEARCH_MODE_FPR16:
377     case KEYDB_SEARCH_MODE_FPR20:
378     case KEYDB_SEARCH_MODE_FPR:
379     case KEYDB_SEARCH_MODE_ISSUER:
380     case KEYDB_SEARCH_MODE_ISSUER_SN:
381     case KEYDB_SEARCH_MODE_SN:
382     case KEYDB_SEARCH_MODE_SUBJECT:
383     case KEYDB_SEARCH_MODE_KEYGRIP:
384     case KEYDB_SEARCH_MODE_WORDS:
385     case KEYDB_SEARCH_MODE_FIRST:
386     case KEYDB_SEARCH_MODE_NEXT:
387     default:
388       break;
389     }
390
391   if (! f)
392     {
393       log_error ("Unsupported search mode.\n");
394       return gpg_error (GPG_ERR_NOT_SUPPORTED);
395     }
396
397   *filter = f;
398
399   return 0;
400 }
401 \f
402 /* Connect to an LDAP server and interrogate it.
403
404      - uri describes the server to connect to and various options
405        including whether to use TLS and the username and password (see
406        ldap_parse_uri for a description of the various fields).
407
408    This function returns:
409
410      - The ldap connection handle in *LDAP_CONNP.
411
412      - The base DN for the PGP key space by querying the
413        pgpBaseKeySpaceDN attribute (This is normally
414        'ou=PGP Keys,dc=EXAMPLE,dc=ORG').
415
416      - The attribute to lookup to find the pgp key.  This is either
417        'pgpKey' or 'pgpKeyV2'.
418
419      - Whether this is a real ldap server.  (It's unclear what this
420        exactly means.)
421
422    The values are returned in the passed variables.  If you pass NULL,
423    then the value won't be returned.  It is the caller's
424    responsibility to release *LDAP_CONNP with ldap_unbind and xfree
425    *BASEDNP and *PGPKEYATTRP.
426
427    If this function successfully interrogated the server, it returns
428    0.  If there was an LDAP error, it returns the LDAP error code.  If
429    an error occured, *basednp, etc., are undefined (and don't need to
430    be freed.)
431
432    If no LDAP error occured, you still need to check that *basednp is
433    valid.  If it is NULL, then the server does not appear to be an
434    OpenPGP Keyserver.  In this case, you also do not need to xfree
435    *pgpkeyattrp.  */
436 static int
437 ldap_connect (parsed_uri_t uri, LDAP **ldap_connp,
438               char **basednp, char **pgpkeyattrp, int *real_ldapp)
439 {
440   int err = 0;
441
442   LDAP *ldap_conn = NULL;
443
444   char *user = uri->auth;
445   struct uri_tuple_s *password_param = uri_query_lookup (uri, "password");
446   char *password = password_param ? password_param->value : NULL;
447
448   char *basedn = NULL;
449   /* Whether to look for the pgpKey or pgpKeyv2 attribute.  */
450   char *pgpkeyattr = "pgpKey";
451   int real_ldap = 0;
452
453   log_debug ("ldap_connect(%s:%d/%s????%s%s%s%s%s)\n",
454              uri->host, uri->port,
455              uri->path ?: "",
456              uri->auth ? "bindname=" : "", uri->auth ?: "",
457              uri->auth && password ? "," : "",
458              password ? "password=" : "", password ?: "");
459
460   /* If the uri specifies a secure connection and we don't support
461      TLS, then fail; don't silently revert to an insecure
462      connection.  */
463   if (uri->use_tls)
464     {
465 #ifndef HAVE_LDAP_START_TLS_S
466       log_error ("Can't use LDAP to connect to the server: no TLS support.");
467       err = GPG_ERR_LDAP_NOT_SUPPORTED;
468       goto out;
469 #endif
470     }
471
472   ldap_conn = ldap_init (uri->host, uri->port);
473   if (! ldap_conn)
474     {
475       err = gpg_err_code_from_syserror ();
476       log_error ("Failed to open connection to LDAP server (%s://%s:%d)\n",
477                  uri->scheme, uri->host, uri->port);
478       goto out;
479     }
480
481 #ifdef HAVE_LDAP_SET_OPTION
482   {
483     int ver = LDAP_VERSION3;
484
485     err = ldap_set_option (ldap_conn, LDAP_OPT_PROTOCOL_VERSION, &ver);
486     if (err != LDAP_SUCCESS)
487       {
488         log_error ("gpgkeys: unable to go to LDAP 3: %s\n",
489                    ldap_err2string (err));
490         goto out;
491       }
492   }
493 #endif
494
495   /* XXX: It would be nice to have an option to provide the server's
496      certificate.  */
497 #if 0
498 #if defined(LDAP_OPT_X_TLS_CACERTFILE) && defined(HAVE_LDAP_SET_OPTION)
499   err = ldap_set_option (NULL, LDAP_OPT_X_TLS_CACERTFILE, ca_cert_file);
500   if (err)
501     {
502       log_error ("unable to set ca-cert-file to '%s': %s\n",
503                  ca_cert_file, ldap_err2string (err));
504       goto out;
505     }
506 #endif /* LDAP_OPT_X_TLS_CACERTFILE && HAVE_LDAP_SET_OPTION */
507 #endif
508
509 #ifndef HAVE_LDAP_START_TLS_S
510   if (uri->use_tls)
511     {
512       /* XXX: We need an option to determine whether to abort if the
513          certificate is bad or not.  Right now we conservatively
514          default to checking the certificate and aborting.  */
515       int check_cert = LDAP_OPT_X_TLS_HARD; /* LDAP_OPT_X_TLS_NEVER */
516
517       err = ldap_set_option (ldap_conn,
518                              LDAP_OPT_X_TLS_REQUIRE_CERT, &check_cert);
519       if (err)
520         {
521           log_error ("Failed to set TLS option on LDAP connection.\n");
522           goto out;
523         }
524
525       err = ldap_start_tls_s (ldap_conn, NULL, NULL);
526       if (err)
527         {
528           log_error ("Failed to connect to LDAP server with TLS.\n");
529           goto out;
530         }
531     }
532 #endif
533
534   /* By default we don't bind as there is usually no need to.  */
535   if (uri->auth)
536     {
537       log_debug ("LDAP bind to %s, password %s\n",
538                  user, password ? ">not shown<" : ">none<");
539
540       err = ldap_simple_bind_s (ldap_conn, user, password);
541       if (err != LDAP_SUCCESS)
542         {
543           log_error ("Internal LDAP bind error: %s\n",
544                      ldap_err2string (err));
545           goto out;
546         }
547     }
548
549   if (uri->path && *uri->path)
550     /* User specified base DN.  */
551     {
552       basedn = xstrdup (uri->path);
553
554       /* If the user specifies a base DN, then we know the server is a
555          real LDAP server.  */
556       real_ldap = 1;
557     }
558   else
559     {
560       LDAPMessage *res = NULL;
561       /* Look for namingContexts.  */
562       char *attr[] = { "namingContexts", NULL };
563
564       err = ldap_search_s (ldap_conn, "", LDAP_SCOPE_BASE,
565                            "(objectClass=*)", attr, 0, &res);
566       if (err == LDAP_SUCCESS)
567         {
568           char **context = ldap_get_values (ldap_conn, res, "namingContexts");
569           if (context)
570             /* We found some, so try each namingContext as the search
571                base and look for pgpBaseKeySpaceDN.  Because we found
572                this, we know we're talking to a regular-ish LDAP
573                server and not an LDAP keyserver.  */
574             {
575               int i;
576               char *attr2[] =
577                 { "pgpBaseKeySpaceDN", "pgpVersion", "pgpSoftware", NULL };
578
579               real_ldap = 1;
580
581               for (i = 0; context[i] && ! basedn; i++)
582                 {
583                   char **vals;
584                   LDAPMessage *si_res;
585
586                   {
587                     char *object = xasprintf ("cn=pgpServerInfo,%s",
588                                               context[i]);
589                     err = ldap_search_s (ldap_conn, object, LDAP_SCOPE_BASE,
590                                          "(objectClass=*)", attr2, 0, &si_res);
591                     xfree (object);
592                   }
593
594                   if (err == LDAP_SUCCESS)
595                     {
596                       vals = ldap_get_values (ldap_conn, si_res,
597                                               "pgpBaseKeySpaceDN");
598                       if (vals)
599                         {
600                           basedn = xtrystrdup (vals[0]);
601                           ldap_value_free (vals);
602                         }
603
604                       vals = ldap_get_values (ldap_conn, si_res,
605                                               "pgpSoftware");
606                       if (vals)
607                         {
608                           log_debug ("Server: \t%s\n", vals[0]);
609                           ldap_value_free (vals);
610                         }
611
612                       vals = ldap_get_values (ldap_conn, si_res,
613                                               "pgpVersion");
614                       if (vals)
615                         {
616                           log_debug ("Version:\t%s\n", vals[0]);
617                           ldap_value_free (vals);
618                         }
619                     }
620
621                   /* From man ldap_search_s: "res parameter of
622                      ldap_search_ext_s() and ldap_search_s() should be
623                      freed with ldap_msgfree() regardless of return
624                      value of these functions.  */
625                   ldap_msgfree (si_res);
626                 }
627
628               ldap_value_free (context);
629             }
630         }
631       else
632         {
633           /* We don't have an answer yet, which means the server might
634              be an LDAP keyserver. */
635           char **vals;
636           LDAPMessage *si_res = NULL;
637
638           char *attr2[] = { "pgpBaseKeySpaceDN", "version", "software", NULL };
639
640           err = ldap_search_s (ldap_conn, "cn=pgpServerInfo", LDAP_SCOPE_BASE,
641                                "(objectClass=*)", attr2, 0, &si_res);
642           if (err == LDAP_SUCCESS)
643             {
644               /* For the LDAP keyserver, this is always
645                  "OU=ACTIVE,O=PGP KEYSPACE,C=US", but it might not be
646                  in the future. */
647
648               vals = ldap_get_values (ldap_conn, si_res, "baseKeySpaceDN");
649               if (vals)
650                 {
651                   basedn = xtrystrdup (vals[0]);
652                   ldap_value_free (vals);
653                 }
654
655               vals = ldap_get_values (ldap_conn, si_res, "software");
656               if (vals)
657                 {
658                   log_debug ("ldap: Server: \t%s\n", vals[0]);
659                   ldap_value_free (vals);
660                 }
661
662               vals = ldap_get_values (ldap_conn, si_res, "version");
663               if (vals)
664                 {
665                   log_debug ("ldap: Version:\t%s\n", vals[0]);
666
667                   /* If the version is high enough, use the new
668                      pgpKeyV2 attribute.  This design is iffy at best,
669                      but it matches how PGP does it.  I figure the NAI
670                      folks assumed that there would never be an LDAP
671                      keyserver vendor with a different numbering
672                      scheme. */
673                   if (atoi (vals[0]) > 1)
674                     pgpkeyattr = "pgpKeyV2";
675
676                   ldap_value_free (vals);
677                 }
678             }
679
680           ldap_msgfree (si_res);
681         }
682
683       /* From man ldap_search_s: "res parameter of ldap_search_ext_s()
684          and ldap_search_s() should be freed with ldap_msgfree()
685          regardless of return value of these functions.  */
686       ldap_msgfree (res);
687     }
688
689  out:
690   if (! err)
691     {
692       log_debug ("ldap_conn: %p\n", ldap_conn);
693       log_debug ("real_ldap: %d\n", real_ldap);
694       log_debug ("basedn: %s\n", basedn);
695       log_debug ("pgpkeyattr: %s\n", pgpkeyattr);
696     }
697
698   if (! err && real_ldapp)
699     *real_ldapp = real_ldap;
700
701   if (err)
702     xfree (basedn);
703   else
704     {
705       if (pgpkeyattrp)
706         {
707           if (basedn)
708             *pgpkeyattrp = xstrdup (pgpkeyattr);
709           else
710             *pgpkeyattrp = NULL;
711         }
712
713       if (basednp)
714         *basednp = basedn;
715       else
716         xfree (basedn);
717     }
718
719   if (err)
720     {
721       if (ldap_conn)
722         ldap_unbind (ldap_conn);
723     }
724   else
725     *ldap_connp = ldap_conn;
726
727   return err;
728 }
729
730 /* Extract keys from an LDAP reply and write them out to the output
731    stream OUTPUT in a format GnuPG can import (either the OpenPGP
732    binary format or armored format).  */
733 static void
734 extract_keys (estream_t output,
735               LDAP *ldap_conn, const char *certid, LDAPMessage *message)
736 {
737   char **vals;
738
739   es_fprintf (output, "INFO %s BEGIN\n", certid);
740   es_fprintf (output, "pub:%s:", certid);
741
742   /* Note: ldap_get_values returns a NULL terminates array of
743      strings.  */
744   vals = ldap_get_values (ldap_conn, message, "pgpkeytype");
745   if (vals && vals[0])
746     {
747       if (strcmp (vals[0], "RSA") == 0)
748         es_fprintf  (output, "1");
749       else if (strcmp (vals[0],"DSS/DH") == 0)
750         es_fprintf (output, "17");
751       ldap_value_free (vals);
752     }
753
754   es_fprintf (output, ":");
755
756   vals = ldap_get_values (ldap_conn, message, "pgpkeysize");
757   if (vals && vals[0])
758     {
759       int v = atoi (vals[0]);
760       if (v > 0)
761         es_fprintf (output, "%d", v);
762       ldap_value_free (vals);
763     }
764
765   es_fprintf (output, ":");
766
767   vals = ldap_get_values (ldap_conn, message, "pgpkeycreatetime");
768   if (vals && vals[0])
769     {
770       if (strlen (vals[0]) == 15)
771         es_fprintf (output, "%u", (unsigned int) ldap2epochtime (vals[0]));
772       ldap_value_free (vals);
773     }
774
775   es_fprintf (output, ":");
776
777   vals = ldap_get_values (ldap_conn, message, "pgpkeyexpiretime");
778   if (vals && vals[0])
779     {
780       if (strlen (vals[0]) == 15)
781         es_fprintf (output, "%u", (unsigned int) ldap2epochtime (vals[0]));
782       ldap_value_free (vals);
783     }
784
785   es_fprintf (output, ":");
786
787   vals = ldap_get_values (ldap_conn, message, "pgprevoked");
788   if (vals && vals[0])
789     {
790       if (atoi (vals[0]) == 1)
791         es_fprintf (output, "r");
792       ldap_value_free (vals);
793     }
794
795   es_fprintf (output, "\n");
796
797   vals = ldap_get_values (ldap_conn, message, "pgpuserid");
798   if (vals && vals[0])
799     {
800       int i;
801       for (i = 0; vals[i]; i++)
802         es_fprintf (output, "uid:%s\n", vals[i]);
803       ldap_value_free (vals);
804     }
805
806   es_fprintf (output, "INFO %s END\n", certid);
807 }
808
809 /* Get the key described key the KEYSPEC string from the keyserver
810    identified by URI.  On success R_FP has an open stream to read the
811    data.  */
812 gpg_error_t
813 ks_ldap_get (ctrl_t ctrl, parsed_uri_t uri, const char *keyspec,
814              estream_t *r_fp)
815 {
816   gpg_error_t err = 0;
817   int ldap_err;
818
819   char *filter = NULL;
820
821   LDAP *ldap_conn = NULL;
822
823   char *basedn = NULL;
824   char *pgpkeyattr = NULL;
825
826   estream_t fp = NULL;
827
828   LDAPMessage *message = NULL;
829
830   (void) ctrl;
831
832   /* Before connecting to the server, make sure we have a sane
833      keyspec.  If not, there is no need to establish a network
834      connection.  */
835   err = keyspec_to_ldap_filter (keyspec, &filter, 1);
836   if (err)
837     return (err);
838
839   /* Make sure we are talking to an OpenPGP LDAP server.  */
840   ldap_err = ldap_connect (uri, &ldap_conn, &basedn, &pgpkeyattr, NULL);
841   if (ldap_err || !basedn)
842     {
843       if (ldap_err)
844         err = ldap_err_to_gpg_err (ldap_err);
845       else
846         err = GPG_ERR_GENERAL;
847       goto out;
848     }
849
850   {
851     /* The ordering is significant.  Specifically, "pgpcertid" needs
852        to be the second item in the list, since everything after it
853        may be discarded we aren't in verbose mode. */
854     char *attrs[] =
855       {
856         pgpkeyattr,
857         "pgpcertid", "pgpuserid", "pgpkeyid", "pgprevoked", "pgpdisabled",
858         "pgpkeycreatetime", "modifytimestamp", "pgpkeysize", "pgpkeytype",
859         NULL
860       };
861     /* 1 if we want just attribute types; 0 if we want both attribute
862        types and values.  */
863     int attrsonly = 0;
864
865     int count;
866
867     ldap_err = ldap_search_s (ldap_conn, basedn, LDAP_SCOPE_SUBTREE,
868                               filter, attrs, attrsonly, &message);
869     if (ldap_err)
870       {
871         err = ldap_err_to_gpg_err (ldap_err);
872
873         log_error ("gpgkeys: LDAP search error: %s\n",
874                    ldap_err2string (ldap_err));
875         goto out;
876       }
877
878     count = ldap_count_entries (ldap_conn, message);
879     if (count < 1)
880       {
881         log_error ("gpgkeys: key %s not found on keyserver\n", keyspec);
882
883         if (count == -1)
884           err = ldap_to_gpg_err (ldap_conn);
885         else
886           err = gpg_error (GPG_ERR_NO_DATA);
887
888         goto out;
889       }
890
891     {
892       /* There may be more than one unique result for a given keyID,
893          so we should fetch them all (test this by fetching short key
894          id 0xDEADBEEF). */
895
896       /* The set of entries that we've seen.  */
897       strlist_t seen = NULL;
898       LDAPMessage *each;
899
900       for (each = ldap_first_entry (ldap_conn, message);
901            each;
902            each = ldap_next_entry (ldap_conn, each))
903         {
904           char **vals;
905           char **certid;
906
907           /* Use the long keyid to remove duplicates.  The LDAP
908              server returns the same keyid more than once if there
909              are multiple user IDs on the key.  Note that this does
910              NOT mean that a keyid that exists multiple times on the
911              keyserver will not be fetched.  It means that each KEY,
912              no matter how many user IDs share its keyid, will be
913              fetched only once.  If a keyid that belongs to more
914              than one key is fetched, the server quite properly
915              responds with all matching keys. -ds */
916
917           certid = ldap_get_values (ldap_conn, each, "pgpcertid");
918           if (certid && certid[0])
919             {
920               if (! strlist_find (seen, certid[0]))
921                 {
922                   /* It's not a duplicate, add it */
923
924                   add_to_strlist (&seen, certid[0]);
925
926                   if (! fp)
927                     fp = es_fopenmem(0, "rw");
928
929                   extract_keys (fp, ldap_conn, certid[0], each);
930
931                   vals = ldap_get_values (ldap_conn, each, pgpkeyattr);
932                   if (! vals)
933                     {
934                       err = ldap_to_gpg_err (ldap_conn);
935                       log_error("gpgkeys: unable to retrieve key %s "
936                                 "from keyserver\n", certid[0]);
937                       goto out;
938                     }
939                   else
940                     {
941                       /* We should strip the new lines.  */
942                       es_fprintf (fp, "KEY 0x%s BEGIN\n", certid[0]);
943                       es_fputs (vals[0], fp);
944                       es_fprintf (fp, "\nKEY 0x%s END\n", certid[0]);
945
946                       ldap_value_free (vals);
947                     }
948                 }
949             }
950
951           ldap_value_free (certid);
952         }
953
954       free_strlist (seen);
955
956       if (! fp)
957         err = gpg_error (GPG_ERR_NO_DATA);
958     }
959   }
960
961  out:
962   if (message)
963     ldap_msgfree (message);
964
965   if (err)
966     {
967       if (fp)
968         es_fclose (fp);
969     }
970   else
971     {
972       if (fp)
973         es_fseek (fp, 0, SEEK_SET);
974
975       *r_fp = fp;
976     }
977
978   xfree (pgpkeyattr);
979   xfree (basedn);
980
981   if (ldap_conn)
982     ldap_unbind (ldap_conn);
983
984   xfree (filter);
985
986   return err;
987 }
988
989 /* Search the keyserver identified by URI for keys matching PATTERN.
990    On success R_FP has an open stream to read the data.  */
991 gpg_error_t
992 ks_ldap_search (ctrl_t ctrl, parsed_uri_t uri, const char *pattern,
993                 estream_t *r_fp)
994 {
995   gpg_error_t err;
996   int ldap_err;
997
998   char *filter = NULL;
999
1000   LDAP *ldap_conn = NULL;
1001
1002   char *basedn = NULL;
1003
1004   estream_t fp = NULL;
1005
1006   (void) ctrl;
1007
1008   /* Before connecting to the server, make sure we have a sane
1009      keyspec.  If not, there is no need to establish a network
1010      connection.  */
1011   err = keyspec_to_ldap_filter (pattern, &filter, 0);
1012   if (err)
1013     {
1014       log_error ("Bad search pattern: '%s'\n", pattern);
1015       return (err);
1016     }
1017
1018   /* Make sure we are talking to an OpenPGP LDAP server.  */
1019   ldap_err = ldap_connect (uri, &ldap_conn, &basedn, NULL, NULL);
1020   if (ldap_err || !basedn)
1021     {
1022       if (ldap_err)
1023         err = ldap_err_to_gpg_err (ldap_err);
1024       else
1025         err = GPG_ERR_GENERAL;
1026       goto out;
1027     }
1028
1029   /* Even if we have no results, we want to return a stream.  */
1030   fp = es_fopenmem(0, "rw");
1031
1032   {
1033     char **vals;
1034     LDAPMessage *res, *each;
1035     int count = 0;
1036     strlist_t dupelist = NULL;
1037
1038     /* The maximum size of the search, including the optional stuff
1039        and the trailing \0 */
1040     char *attrs[] =
1041       {
1042         "pgpcertid", "pgpuserid", "pgprevoked", "pgpdisabled",
1043         "pgpkeycreatetime", "pgpkeyexpiretime", "modifytimestamp",
1044         "pgpkeysize", "pgpkeytype", NULL
1045       };
1046
1047     log_debug ("SEARCH '%s' => '%s' BEGIN\n", pattern, filter);
1048
1049     ldap_err = ldap_search_s (ldap_conn, basedn,
1050                               LDAP_SCOPE_SUBTREE, filter, attrs, 0, &res);
1051
1052     xfree (filter);
1053     filter = NULL;
1054
1055     if (err != LDAP_SUCCESS && err != LDAP_SIZELIMIT_EXCEEDED)
1056       {
1057         err = ldap_err_to_gpg_err (ldap_err);
1058
1059         log_error ("SEARCH %s FAILED %d\n", pattern, err);
1060         log_error ("gpgkeys: LDAP search error: %s\n",
1061                    ldap_err2string (err));
1062         goto out;
1063     }
1064
1065     /* The LDAP server doesn't return a real count of unique keys, so we
1066        can't use ldap_count_entries here. */
1067     for (each = ldap_first_entry (ldap_conn, res);
1068          each;
1069          each = ldap_next_entry (ldap_conn, each))
1070       {
1071         char **certid = ldap_get_values (ldap_conn, each, "pgpcertid");
1072         if (certid && certid[0] && ! strlist_find (dupelist, certid[0]))
1073           {
1074             add_to_strlist (&dupelist, certid[0]);
1075             count++;
1076           }
1077       }
1078
1079     if (err == LDAP_SIZELIMIT_EXCEEDED)
1080       {
1081         if (count == 1)
1082           log_error ("gpgkeys: search results exceeded server limit."
1083                      "  First 1 result shown.\n");
1084         else
1085           log_error ("gpgkeys: search results exceeded server limit."
1086                      "  First %d results shown.\n", count);
1087       }
1088
1089     free_strlist (dupelist);
1090     dupelist = NULL;
1091
1092     if (count < 1)
1093       es_fputs ("info:1:0\n", fp);
1094     else
1095       {
1096         es_fprintf (fp, "info:1:%d\n", count);
1097
1098         for (each = ldap_first_entry (ldap_conn, res);
1099              each;
1100              each = ldap_next_entry (ldap_conn, each))
1101           {
1102             char **certid;
1103             LDAPMessage *uids;
1104
1105             certid = ldap_get_values (ldap_conn, each, "pgpcertid");
1106             if (! certid || ! certid[0])
1107               continue;
1108
1109             /* Have we seen this certid before? */
1110             if (! strlist_find (dupelist, certid[0]))
1111               {
1112                 add_to_strlist (&dupelist, certid[0]);
1113
1114                 es_fprintf (fp, "pub:%s:",certid[0]);
1115
1116                   vals = ldap_get_values (ldap_conn, each, "pgpkeytype");
1117                   if (vals)
1118                     {
1119                       /* The LDAP server doesn't exactly handle this
1120                          well. */
1121                       if (strcasecmp (vals[0], "RSA") == 0)
1122                         es_fputs ("1", fp);
1123                       else if (strcasecmp (vals[0], "DSS/DH") == 0)
1124                         es_fputs ("17", fp);
1125                       ldap_value_free (vals);
1126                     }
1127
1128                   es_fputc (':', fp);
1129
1130                   vals = ldap_get_values (ldap_conn, each, "pgpkeysize");
1131                   if (vals)
1132                     {
1133                       /* Not sure why, but some keys are listed with a
1134                          key size of 0.  Treat that like an
1135                          unknown. */
1136                       if (atoi (vals[0]) > 0)
1137                         es_fprintf (fp, "%d", atoi (vals[0]));
1138                       ldap_value_free (vals);
1139                     }
1140
1141                   es_fputc (':', fp);
1142
1143                   /* YYYYMMDDHHmmssZ */
1144
1145                   vals = ldap_get_values (ldap_conn, each, "pgpkeycreatetime");
1146                   if(vals && strlen (vals[0]) == 15)
1147                     {
1148                       es_fprintf (fp, "%u",
1149                                   (unsigned int) ldap2epochtime(vals[0]));
1150                       ldap_value_free (vals);
1151                     }
1152
1153                   es_fputc (':', fp);
1154
1155                   vals = ldap_get_values (ldap_conn, each, "pgpkeyexpiretime");
1156                   if (vals && strlen (vals[0]) == 15)
1157                     {
1158                       es_fprintf (fp, "%u",
1159                                   (unsigned int) ldap2epochtime (vals[0]));
1160                       ldap_value_free (vals);
1161                     }
1162
1163                   es_fputc (':', fp);
1164
1165                   vals = ldap_get_values (ldap_conn, each, "pgprevoked");
1166                   if (vals)
1167                     {
1168                       if (atoi (vals[0]) == 1)
1169                         es_fprintf (fp, "r");
1170                       ldap_value_free (vals);
1171                     }
1172
1173                   vals = ldap_get_values (ldap_conn, each, "pgpdisabled");
1174                   if (vals)
1175                     {
1176                       if (atoi (vals[0]) ==1)
1177                         es_fprintf (fp, "d");
1178                       ldap_value_free (vals);
1179                     }
1180
1181 #if 0
1182                   /* This is not yet specified in the keyserver
1183                      protocol, but may be someday. */
1184                   es_fputc (':', fp);
1185
1186                   vals = ldap_get_values (ldap_conn, each, "modifytimestamp");
1187                   if(vals && strlen (vals[0]) == 15)
1188                     {
1189                       es_fprintf (fp, "%u",
1190                                   (unsigned int) ldap2epochtime (vals[0]));
1191                       ldap_value_free (vals);
1192                     }
1193 #endif
1194
1195                   es_fprintf (fp, "\n");
1196
1197                   /* Now print all the uids that have this certid */
1198                   for (uids = ldap_first_entry (ldap_conn, res);
1199                        uids;
1200                        uids = ldap_next_entry (ldap_conn, uids))
1201                     {
1202                       vals = ldap_get_values (ldap_conn, uids, "pgpcertid");
1203                       if (! vals)
1204                         continue;
1205
1206                       if (strcasecmp (certid[0], vals[0]) == 0)
1207                         {
1208                           char **uidvals;
1209
1210                           es_fprintf (fp, "uid:");
1211
1212                           uidvals = ldap_get_values (ldap_conn,
1213                                                      uids, "pgpuserid");
1214                           if (uidvals)
1215                             {
1216                               /* Need to escape any colons */
1217                               char *quoted = percent_escape (uidvals[0], NULL);
1218                               es_fputs (quoted, fp);
1219                               xfree (quoted);
1220                               ldap_value_free (uidvals);
1221                             }
1222
1223                           es_fprintf (fp, "\n");
1224                         }
1225
1226                       ldap_value_free(vals);
1227                     }
1228               }
1229
1230               ldap_value_free (certid);
1231           }
1232       }
1233
1234     ldap_msgfree (res);
1235     free_strlist (dupelist);
1236   }
1237
1238   log_debug ("SEARCH %s END\n", pattern);
1239
1240  out:
1241   if (err)
1242     {
1243       if (fp)
1244         es_fclose (fp);
1245     }
1246   else
1247     {
1248       /* Return the read stream.  */
1249       if (fp)
1250         es_fseek (fp, 0, SEEK_SET);
1251
1252       *r_fp = fp;
1253     }
1254
1255   xfree (basedn);
1256
1257   if (ldap_conn)
1258     ldap_unbind (ldap_conn);
1259
1260   xfree (filter);
1261
1262   return err;
1263 }
1264 \f
1265 /* A modlist describes a set of changes to an LDAP entry.  (An entry
1266    consists of 1 or more attributes.  Attributes are <name, value>
1267    pairs.  Note: an attribute may be multi-valued in which case
1268    multiple values are associated with a single name.)
1269
1270    A modlist is a NULL terminated array of struct LDAPMod's.
1271
1272    Thus, if we have:
1273
1274      LDAPMod **modlist;
1275
1276    Then:
1277
1278      modlist[i]
1279
1280    Is the ith modification.
1281
1282    Each LDAPMod describes a change to a single attribute.  Further,
1283    there is one modification for each attribute that we want to
1284    change.  The attribute's new value is stored in LDAPMod.mod_values.
1285    If the attribute is multi-valued, we still only use a single
1286    LDAPMod structure: mod_values is a NULL-terminated array of
1287    strings.  To delete an attribute from an entry, we set mod_values
1288    to NULL.
1289
1290    Thus, if:
1291
1292      modlist[i]->mod_values == NULL
1293
1294    then we remove the attribute.
1295
1296    (Using LDAP_MOD_DELETE doesn't work here as we don't know if the
1297    attribute in question exists or not.)
1298
1299    Note: this function does NOT copy or free ATTR.  It does copy
1300    VALUE.  */
1301 static void
1302 modlist_add (LDAPMod ***modlistp, char *attr, const char *value)
1303 {
1304   LDAPMod **modlist = *modlistp;
1305
1306   LDAPMod **m;
1307   int nummods = 0;
1308
1309   /* Search modlist for the attribute we're playing with.  If modlist
1310      is NULL, then the list is empty.  Recall: modlist is a NULL
1311      terminated array.  */
1312   for (m = modlist; m && *m; m++, nummods ++)
1313     {
1314       /* The attribute is already on the list.  */
1315       char **ptr;
1316       int numvalues = 0;
1317
1318       if (strcasecmp ((*m)->mod_type, attr) != 0)
1319         continue;
1320
1321       /* We have this attribute already, so when the REPLACE happens,
1322          the server attributes will be replaced anyway. */
1323       if (! value)
1324         return;
1325
1326       /* Attributes can be multi-valued.  See if the value is already
1327          present.  mod_values is a NULL terminated array of pointers.
1328          Note: mod_values can be NULL.  */
1329       for (ptr = (*m)->mod_values; ptr && *ptr; ptr++)
1330         {
1331           if (strcmp (*ptr, value) == 0)
1332             /* Duplicate value, we're done.  */
1333             return;
1334           numvalues ++;
1335         }
1336
1337       /* Append the value.  */
1338       ptr = xrealloc ((*m)->mod_values, sizeof (char *) * (numvalues + 2));
1339
1340       (*m)->mod_values = ptr;
1341       ptr[numvalues] = xstrdup (value);
1342
1343       ptr[numvalues + 1] = NULL;
1344
1345       return;
1346     }
1347
1348   /* We didn't find the attr, so make one and add it to the end */
1349
1350   /* Like attribute values, the list of attributes is NULL terminated
1351      array of pointers.  */
1352   modlist = xrealloc (modlist, sizeof (LDAPMod *) * (nummods + 2));
1353
1354   *modlistp = modlist;
1355   modlist[nummods] = xmalloc (sizeof (LDAPMod));
1356
1357   modlist[nummods]->mod_op = LDAP_MOD_REPLACE;
1358   modlist[nummods]->mod_type = attr;
1359   if (value)
1360     {
1361       modlist[nummods]->mod_values = xmalloc (sizeof(char *) * 2);
1362
1363       modlist[nummods]->mod_values[0] = xstrdup (value);
1364       modlist[nummods]->mod_values[1] = NULL;
1365     }
1366   else
1367     modlist[nummods]->mod_values = NULL;
1368
1369   modlist[nummods + 1] = NULL;
1370
1371   return;
1372 }
1373
1374 /* Look up the value of an attribute in the specified modlist.  If the
1375    attribute is not on the mod list, returns NULL.  The result is a
1376    NULL-terminated array of strings.  Don't change it.  */
1377 static char **
1378 modlist_lookup (LDAPMod **modlist, const char *attr)
1379 {
1380   LDAPMod **m;
1381   for (m = modlist; m && *m; m++)
1382     {
1383       if (strcasecmp ((*m)->mod_type, attr) != 0)
1384         continue;
1385
1386       return (*m)->mod_values;
1387     }
1388
1389   return NULL;
1390 }
1391
1392 /* Dump a modlist to a file.  This is useful for debugging.  */
1393 static estream_t modlist_dump (LDAPMod **modlist, estream_t output)
1394   GNUPG_GCC_A_USED;
1395
1396 static estream_t
1397 modlist_dump (LDAPMod **modlist, estream_t output)
1398 {
1399   LDAPMod **m;
1400
1401   int opened = 0;
1402   if (! output)
1403     {
1404       output = es_fopenmem (0, "rw");
1405       opened = 1;
1406     }
1407
1408   for (m = modlist; m && *m; m++)
1409     {
1410       es_fprintf (output, "  %s:", (*m)->mod_type);
1411
1412       if (! (*m)->mod_values)
1413         es_fprintf(output, " delete.\n");
1414       else
1415         {
1416           char **ptr;
1417           int i;
1418
1419           int multi = 0;
1420           if ((*m)->mod_values[0] && (*m)->mod_values[1])
1421             /* Have at least 2.  */
1422             multi = 1;
1423
1424           if (multi)
1425             es_fprintf (output, "\n");
1426
1427           for ((ptr = (*m)->mod_values), (i = 1); ptr && *ptr; ptr++, i ++)
1428             {
1429               /* At most about 10 lines.  */
1430               const int max_len = 10 * 70;
1431               size_t value_len = strlen (*ptr);
1432               char buffer[max_len + 4];
1433               char *temp;
1434               int elided = 0;
1435               if (value_len > max_len)
1436                 {
1437                   temp = buffer;
1438                   memcpy (temp, *ptr, max_len);
1439                   temp[max_len] = temp[max_len + 1] = temp[max_len + 2] = '.';
1440                   temp[max_len + 3] = 0;
1441                   elided = 1;
1442                 }
1443               else
1444                 temp = *ptr;
1445
1446               if (multi)
1447                 es_fprintf (output, "    %d. ", i);
1448               es_fprintf (output, "`%s'", temp);
1449               if (elided)
1450                 es_fprintf (output, " (%zd bytes elided)",
1451                             value_len - max_len);
1452               es_fprintf (output, "\n");
1453             }
1454         }
1455     }
1456
1457   if (opened)
1458     es_fseek (output, 0, SEEK_SET);
1459
1460   return output;
1461 }
1462
1463 /* Free all of the memory allocated by the mod list.  This assumes
1464    that the attribute names don't have to be freed, but the attributes
1465    values do.  (Which is what modlist_add does.)  */
1466 static void
1467 modlist_free (LDAPMod **modlist)
1468 {
1469   LDAPMod **ml;
1470
1471   if (! modlist)
1472     return;
1473
1474   /* Unwind and free the whole modlist structure */
1475
1476   /* The modlist is a NULL terminated array of pointers.  */
1477   for (ml = modlist; *ml; ml++)
1478     {
1479       LDAPMod *mod = *ml;
1480       char **ptr;
1481
1482       /* The list of values is a NULL termianted array of pointers.
1483          If the list is NULL, there are no values.  */
1484
1485       if (mod->mod_values)
1486         {
1487           for (ptr = mod->mod_values; *ptr; ptr++)
1488             xfree (*ptr);
1489
1490           xfree (mod->mod_values);
1491         }
1492
1493       xfree (mod);
1494     }
1495   xfree (modlist);
1496 }
1497
1498 /* Append two onto the end of one.  Two is not freed, but its pointers
1499    are now part of one.  Make sure you don't free them both!
1500
1501    As long as you don't add anything to ONE, TWO is still valid.
1502    After that all bets are off.  */
1503 static void
1504 modlists_join (LDAPMod ***one, LDAPMod **two)
1505 {
1506   int i, one_count = 0, two_count = 0;
1507   LDAPMod **grow;
1508
1509   if (!*two)
1510     /* two is empty.  Nothing to do.  */
1511     return;
1512
1513   if (!*one)
1514     /* one is empty.  Just set it equal to *two.  */
1515     {
1516       *one = two;
1517       return;
1518     }
1519
1520   for (grow = *one; *grow; grow++)
1521     one_count ++;
1522
1523   for (grow = two; *grow; grow++)
1524     two_count ++;
1525
1526   grow = xrealloc (*one, sizeof(LDAPMod *) * (one_count + two_count + 1));
1527
1528   for (i = 0; i < two_count; i++)
1529     grow[one_count + i] = two[i];
1530
1531   grow[one_count + i] = NULL;
1532
1533   *one = grow;
1534 }
1535
1536 /* Given a string, unescape C escapes.  In particular, \xXX.  This
1537    modifies the string in place.  */
1538 static void
1539 uncescape (char *str)
1540 {
1541   int r = 0;
1542   int w = 0;
1543
1544   char *first = strchr (str, '\\');
1545   if (! first)
1546     /* No backslashes => no escaping.  We're done.  */
1547     return;
1548
1549   /* Start at the first '\\'.  */
1550   r = w = (uintptr_t) first - (uintptr_t) str;
1551
1552   while (str[r])
1553     {
1554       /* XXX: What to do about bad escapes?  */
1555       if (str[r] == '\\' && str[r + 1] == 'x'
1556           && (('0' <= str[r + 2] && str[r + 2] <= '9')
1557               || ('a' <= str[r + 2] && str[r + 2] <= 'f')
1558               || ('A' <= str[r + 2] && str[r + 2] <= 'F'))
1559           && (('0' <= str[r + 3] && str[r + 3] <= '9')
1560               || ('a' <= str[r + 3] && str[r + 3] <= 'f')
1561               || ('A' <= str[r + 3] && str[r + 3] <= 'F')))
1562         {
1563           int x = hextobyte (&str[r + 2]);
1564           assert (0 <= x && x <= 0xff);
1565
1566           str[w] = x;
1567
1568           /* We consumed 4 characters and wrote 1.  */
1569           r += 4;
1570           w ++;
1571         }
1572       else
1573         str[w ++] = str[r ++];
1574     }
1575
1576   str[w] = '\0';
1577 }
1578
1579 /* Given one line from an info block (`gpg --list-{keys,sigs}
1580    --with-colons KEYID'), pull it apart and fill in the modlist with
1581    the relevant (for the LDAP schema) attributes.  */
1582 static void
1583 extract_attributes (LDAPMod ***modlist, char *line)
1584 {
1585   int i;
1586
1587   int field_count;
1588   char **fields;
1589
1590   char *keyid;
1591
1592   int is_pub, is_sub, is_uid, is_sig;
1593
1594   /* Remove trailing whitespace */
1595   for (i = strlen (line) - 1; i >= 0 && ascii_isspace (line[i]); i--)
1596     line[i] = '\0';
1597
1598   fields = strsplit (line, ':', '\0', &field_count);
1599   if (field_count == 1)
1600     /* We only have a single field.  There is definately nothing to
1601        do.  */
1602     goto out;
1603
1604   if (field_count < 7)
1605     goto out;
1606
1607   is_pub = strcasecmp ("pub", fields[0]) == 0;
1608   is_sub = strcasecmp ("sub", fields[0]) == 0;
1609   is_uid = strcasecmp ("uid", fields[0]) == 0;
1610   is_sig = strcasecmp ("sig", fields[0]) == 0;
1611
1612   if (!is_pub && !is_sub && !is_uid && !is_sig)
1613     /* Not a relevant line.  */
1614     goto out;
1615
1616   keyid = fields[4];
1617
1618   if (is_uid && strlen (keyid) == 0)
1619     /* The uid record type can have an empty keyid.  */
1620     ;
1621   else if (strlen (keyid) == 16
1622            && strspn (keyid, "0123456789aAbBcCdDeEfF") == 16)
1623     /* Otherwise, we expect exactly 16 hex characters.  */
1624     ;
1625   else
1626     {
1627       log_error ("malformed record!\n");
1628       goto out;
1629     }
1630
1631   if (is_pub)
1632     {
1633       int disabled = 0;
1634       int revoked = 0;
1635       char *flags;
1636       for (flags = fields[1]; *flags; flags ++)
1637         switch (*flags)
1638           {
1639           case 'r':
1640           case 'R':
1641             revoked = 1;
1642             break;
1643
1644           case 'd':
1645           case 'D':
1646             disabled = 1;
1647             break;
1648           }
1649
1650       /* Note: we always create the pgpDisabled and pgpRevoked
1651         attributes, regardless of whether the key is disabled/revoked
1652         or not.  This is because a very common search is like
1653         "(&(pgpUserID=*isabella*)(pgpDisabled=0))"  */
1654
1655       if (is_pub)
1656         {
1657           modlist_add (modlist,"pgpDisabled", disabled ? "1" : "0");
1658           modlist_add (modlist,"pgpRevoked", revoked ? "1" : "0");
1659         }
1660     }
1661
1662   if (is_pub || is_sub)
1663     {
1664       char *size = fields[2];
1665       int val = atoi (size);
1666       size = NULL;
1667
1668       if (val > 0)
1669         {
1670           /* We zero pad this on the left to make PGP happy. */
1671           char padded[6];
1672           if (val < 99999 && val > 0)
1673             {
1674               sprintf (padded, "%05u", val);
1675               size = padded;
1676             }
1677         }
1678
1679       if (size)
1680         {
1681           if (is_pub || is_sub)
1682             modlist_add (modlist, "pgpKeySize", size);
1683         }
1684     }
1685
1686   if (is_pub)
1687     {
1688       char *algo = fields[3];
1689       int val = atoi (algo);
1690       switch (val)
1691         {
1692         case 1:
1693           algo = "RSA";
1694           break;
1695
1696         case 17:
1697           algo = "DSS/DH";
1698           break;
1699
1700         default:
1701           algo = NULL;
1702           break;
1703         }
1704
1705       if (algo)
1706         {
1707           if (is_pub)
1708             modlist_add (modlist, "pgpKeyType", algo);
1709         }
1710     }
1711
1712   if (is_pub || is_sub || is_sig)
1713     {
1714       if (is_pub)
1715         {
1716           modlist_add (modlist, "pgpCertID", keyid);
1717           modlist_add (modlist, "pgpKeyID", &keyid[8]);
1718         }
1719
1720       if (is_sub)
1721         modlist_add (modlist, "pgpSubKeyID", keyid);
1722
1723       if (is_sig)
1724         modlist_add (modlist, "pgpSignerID", keyid);
1725     }
1726
1727   if (is_pub)
1728     {
1729       char *create_time = fields[5];
1730
1731       if (strlen (create_time) == 0)
1732         create_time = NULL;
1733       else
1734         {
1735           char *create_time_orig = create_time;
1736           struct tm tm;
1737           time_t t;
1738           char *end;
1739
1740           memset (&tm, 0, sizeof (tm));
1741
1742           /* parse_timestamp handles both seconds fromt he epoch and
1743              ISO 8601 format.  We also need to handle YYYY-MM-DD
1744              format (as generated by gpg1 --with-colons --list-key).
1745              Check that first and then if it fails, then try
1746              parse_timestamp.  */
1747
1748           if (strptime (create_time, "%Y-%m-%d", &tm))
1749             create_time = tm2ldaptime (&tm);
1750           else if ((t = parse_timestamp (create_time, &end)) != (time_t) -1
1751                    && *end == '\0')
1752             {
1753               if (! gmtime_r (&t, &tm))
1754                 create_time = NULL;
1755               else
1756                 create_time = tm2ldaptime (&tm);
1757             }
1758           else
1759             create_time = NULL;
1760
1761           if (! create_time)
1762             /* Failed to parse string.  */
1763             log_error ("Failed to parse creation time ('%s')",
1764                        create_time_orig);
1765         }
1766
1767       if (create_time)
1768         {
1769           modlist_add (modlist, "pgpKeyCreateTime", create_time);
1770           xfree (create_time);
1771         }
1772     }
1773
1774   if (is_pub)
1775     {
1776       char *expire_time = fields[6];
1777
1778       if (strlen (expire_time) == 0)
1779         expire_time = NULL;
1780       else
1781         {
1782           char *expire_time_orig = expire_time;
1783           struct tm tm;
1784           time_t t;
1785           char *end;
1786
1787           memset (&tm, 0, sizeof (tm));
1788
1789           /* parse_timestamp handles both seconds fromt he epoch and
1790              ISO 8601 format.  We also need to handle YYYY-MM-DD
1791              format (as generated by gpg1 --with-colons --list-key).
1792              Check that first and then if it fails, then try
1793              parse_timestamp.  */
1794
1795           if (strptime (expire_time, "%Y-%m-%d", &tm))
1796             expire_time = tm2ldaptime (&tm);
1797           else if ((t = parse_timestamp (expire_time, &end)) != (time_t) -1
1798                    && *end == '\0')
1799             {
1800               if (! gmtime_r (&t, &tm))
1801                 expire_time = NULL;
1802               else
1803                 expire_time = tm2ldaptime (&tm);
1804             }
1805           else
1806             expire_time = NULL;
1807
1808           if (! expire_time)
1809             /* Failed to parse string.  */
1810             log_error ("Failed to parse creation time ('%s')",
1811                        expire_time_orig);
1812         }
1813
1814       if (expire_time)
1815         {
1816           modlist_add (modlist, "pgpKeyExpireTime", expire_time);
1817           xfree (expire_time);
1818         }
1819     }
1820
1821   if ((is_uid || is_pub) && field_count >= 10)
1822     {
1823       char *uid = fields[9];
1824
1825       if (is_pub && strlen (uid) == 0)
1826         /* When using gpg --list-keys, the uid is included.  When
1827            passed via gpg, it is not.  It is important to process it
1828            when it is present, because gpg 1 won't print a UID record
1829            if there is only one key.  */
1830         ;
1831       else
1832         {
1833           uncescape (uid);
1834           modlist_add (modlist, "pgpUserID", uid);
1835         }
1836     }
1837
1838  out:
1839   free (fields);
1840 }
1841
1842 /* Send the key in {KEY,KEYLEN} with the metadata {INFO,INFOLEN} to
1843    the keyserver identified by URI.  See server.c:cmd_ks_put for the
1844    format of the data and metadata.  */
1845 gpg_error_t
1846 ks_ldap_put (ctrl_t ctrl, parsed_uri_t uri,
1847              void *data, size_t datalen,
1848              void *info, size_t infolen)
1849 {
1850   gpg_error_t err = 0;
1851   int ldap_err;
1852
1853   LDAP *ldap_conn = NULL;
1854   char *basedn = NULL;
1855   char *pgpkeyattr = NULL;
1856   int real_ldap;
1857
1858   LDAPMod **modlist = NULL;
1859   LDAPMod **addlist = NULL;
1860
1861   char *data_armored = NULL;
1862
1863   /* The last byte of the info block.  */
1864   const char *infoend = (const char *) info + infolen - 1;
1865
1866   /* Enable this code to dump the modlist to /tmp/modlist.txt.  */
1867 #if 0
1868 # warning Disable debug code before checking in.
1869   const int dump_modlist = 1;
1870 #else
1871   const int dump_modlist = 0;
1872 #endif
1873   estream_t dump = NULL;
1874
1875   /* Elide a warning.  */
1876   (void) ctrl;
1877
1878   ldap_err = ldap_connect (uri, &ldap_conn, &basedn, &pgpkeyattr, &real_ldap);
1879   if (ldap_err || !basedn)
1880     {
1881       if (ldap_err)
1882         err = ldap_err_to_gpg_err (ldap_err);
1883       else
1884         err = GPG_ERR_GENERAL;
1885       goto out;
1886     }
1887
1888   if (! real_ldap)
1889     /* We appear to have an OpenPGP Keyserver, which can unpack the key
1890        on its own (not just a dumb LDAP server).  */
1891     {
1892       LDAPMod mod, *attrs[2];
1893       char *key[] = { data, NULL };
1894       char *dn;
1895
1896       memset (&mod, 0, sizeof (mod));
1897       mod.mod_op = LDAP_MOD_ADD;
1898       mod.mod_type = pgpkeyattr;
1899       mod.mod_values = key;
1900       attrs[0] = &mod;
1901       attrs[1] = NULL;
1902
1903       dn = xasprintf ("pgpCertid=virtual,%s", basedn);
1904       ldap_err = ldap_add_s (ldap_conn, dn, attrs);
1905       xfree (dn);
1906
1907       if (ldap_err != LDAP_SUCCESS)
1908         {
1909           err = ldap_err_to_gpg_err (err);
1910           goto out;
1911         }
1912
1913       goto out;
1914     }
1915
1916   modlist = xmalloc (sizeof (LDAPMod *));
1917   *modlist = NULL;
1918
1919   if (dump_modlist)
1920     {
1921       dump = es_fopen("/tmp/modlist.txt", "w");
1922       if (! dump)
1923         log_error ("Failed to open /tmp/modlist.txt: %s\n",
1924                    strerror (errno));
1925
1926       if (dump)
1927         {
1928           es_fprintf(dump, "data (%zd bytes)\n", datalen);
1929           es_fprintf(dump, "info (%zd bytes): '\n", infolen);
1930           es_fwrite(info, infolen, 1, dump);
1931           es_fprintf(dump, "'\n");
1932         }
1933     }
1934
1935   /* Start by nulling out all attributes.  We try and do a modify
1936      operation first, so this ensures that we don't leave old
1937      attributes lying around. */
1938   modlist_add (&modlist, "pgpDisabled", NULL);
1939   modlist_add (&modlist, "pgpKeyID", NULL);
1940   modlist_add (&modlist, "pgpKeyType", NULL);
1941   modlist_add (&modlist, "pgpUserID", NULL);
1942   modlist_add (&modlist, "pgpKeyCreateTime", NULL);
1943   modlist_add (&modlist, "pgpSignerID", NULL);
1944   modlist_add (&modlist, "pgpRevoked", NULL);
1945   modlist_add (&modlist, "pgpSubKeyID", NULL);
1946   modlist_add (&modlist, "pgpKeySize", NULL);
1947   modlist_add (&modlist, "pgpKeyExpireTime", NULL);
1948   modlist_add (&modlist, "pgpCertID", NULL);
1949
1950   /* Assemble the INFO stuff into LDAP attributes */
1951
1952   while (infolen > 0)
1953     {
1954       char *temp = NULL;
1955
1956       char *newline = memchr (info, '\n', infolen);
1957       if (! newline)
1958         /* The last line is not \n terminated!  Make a copy so we can
1959            add a NUL terminator.  */
1960         {
1961           temp = alloca (infolen + 1);
1962           memcpy (temp, info, infolen);
1963           info = temp;
1964           newline = (char *) info + infolen;
1965         }
1966
1967       *newline = '\0';
1968
1969       extract_attributes (&modlist, info);
1970
1971       infolen = infolen - ((uintptr_t) newline - (uintptr_t) info + 1);
1972       info = newline + 1;
1973
1974       /* Sanity check.  */
1975       if (! temp)
1976         assert ((char *) info + infolen - 1 == infoend);
1977       else
1978         assert (infolen == -1);
1979     }
1980
1981   modlist_add (&addlist, "objectClass", "pgpKeyInfo");
1982
1983   err = armor_data (&data_armored, data, datalen);
1984   if (err)
1985     goto out;
1986
1987   modlist_add (&addlist, pgpkeyattr, data_armored);
1988
1989   /* Now append addlist onto modlist.  */
1990   modlists_join (&modlist, addlist);
1991
1992   if (dump)
1993     {
1994       estream_t input = modlist_dump (modlist, NULL);
1995       copy_stream (input, dump);
1996       es_fclose (input);
1997     }
1998
1999   /* Going on the assumption that modify operations are more frequent
2000      than adds, we try a modify first.  If it's not there, we just
2001      turn around and send an add command for the same key.  Otherwise,
2002      the modify brings the server copy into compliance with our copy.
2003      Note that unlike the LDAP keyserver (and really, any other
2004      keyserver) this does NOT merge signatures, but replaces the whole
2005      key.  This should make some people very happy. */
2006   {
2007     char **certid;
2008     char *dn;
2009
2010     certid = modlist_lookup (modlist, "pgpCertID");
2011     if (/* We should have a value.  */
2012         ! certid
2013         /* Exactly one.  */
2014         || !(certid[0] && !certid[1]))
2015       {
2016         log_error ("Bad certid.\n");
2017         err = GPG_ERR_GENERAL;
2018         goto out;
2019       }
2020
2021     dn = xasprintf ("pgpCertID=%s,%s", certid[0], basedn);
2022
2023     err = ldap_modify_s (ldap_conn, dn, modlist);
2024     if (err == LDAP_NO_SUCH_OBJECT)
2025       err = ldap_add_s (ldap_conn, dn, addlist);
2026
2027     xfree (dn);
2028
2029     if (err != LDAP_SUCCESS)
2030       {
2031         log_error ("gpgkeys: error adding key to keyserver: %s\n",
2032                    ldap_err2string (err));
2033         err = ldap_err_to_gpg_err (err);
2034       }
2035   }
2036
2037  out:
2038   if (dump)
2039     es_fclose (dump);
2040
2041   if (ldap_conn)
2042     ldap_unbind (ldap_conn);
2043
2044   xfree (basedn);
2045   xfree (pgpkeyattr);
2046
2047   modlist_free (modlist);
2048   xfree (addlist);
2049
2050   xfree (data_armored);
2051
2052   return err;
2053 }