scd: Remove old fallback logic from CCID to PC/SC.
[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 <https://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 "../common/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 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(!uri)
310     err = ks_print_help (ctrl, "  ldap");
311   else if (strcmp (uri->scheme, "ldap") == 0
312       || strcmp (uri->scheme, "ldaps") == 0
313       || strcmp (uri->scheme, "ldapi") == 0)
314     err = ks_print_help (ctrl, data);
315   else
316     err = 0;
317
318   return err;
319 }
320 \f
321 /* Convert a keyspec to a filter.  Return an error if the keyspec is
322    bad or is not supported.  The filter is escaped and returned in
323    *filter.  It is the caller's responsibility to free *filter.
324    *filter is only set if this function returns success (i.e., 0).  */
325 static gpg_error_t
326 keyspec_to_ldap_filter (const char *keyspec, char **filter, int only_exact)
327 {
328   /* Remove search type indicator and adjust PATTERN accordingly.
329      Note: don't include a preceding 0x when searching by keyid.  */
330
331   /* XXX: Should we include disabled / revoke options?  */
332   KEYDB_SEARCH_DESC desc;
333   char *f = NULL;
334   char *freeme = NULL;
335
336   gpg_error_t err = classify_user_id (keyspec, &desc, 1);
337   if (err)
338     return err;
339
340   switch (desc.mode)
341     {
342     case KEYDB_SEARCH_MODE_EXACT:
343       f = xasprintf ("(pgpUserID=%s)",
344                      (freeme = ldap_escape_filter (desc.u.name)));
345       break;
346
347     case KEYDB_SEARCH_MODE_SUBSTR:
348       if (! only_exact)
349         f = xasprintf ("(pgpUserID=*%s*)",
350                        (freeme = ldap_escape_filter (desc.u.name)));
351       break;
352
353     case KEYDB_SEARCH_MODE_MAIL:
354       if (! only_exact)
355         f = xasprintf ("(pgpUserID=*<%s>*)",
356                        (freeme = ldap_escape_filter (desc.u.name)));
357       break;
358
359     case KEYDB_SEARCH_MODE_MAILSUB:
360       if (! only_exact)
361         f = xasprintf ("(pgpUserID=*<*%s*>*)",
362                        (freeme = ldap_escape_filter (desc.u.name)));
363       break;
364
365     case KEYDB_SEARCH_MODE_MAILEND:
366       if (! only_exact)
367         f = xasprintf ("(pgpUserID=*<*%s>*)",
368                        (freeme = ldap_escape_filter (desc.u.name)));
369       break;
370
371     case KEYDB_SEARCH_MODE_SHORT_KID:
372       f = xasprintf ("(pgpKeyID=%08lX)", (ulong) desc.u.kid[1]);
373       break;
374     case KEYDB_SEARCH_MODE_LONG_KID:
375       f = xasprintf ("(pgpCertID=%08lX%08lX)",
376                      (ulong) desc.u.kid[0], (ulong) desc.u.kid[1]);
377       break;
378
379     case KEYDB_SEARCH_MODE_FPR:
380     case KEYDB_SEARCH_MODE_ISSUER:
381     case KEYDB_SEARCH_MODE_ISSUER_SN:
382     case KEYDB_SEARCH_MODE_SN:
383     case KEYDB_SEARCH_MODE_SUBJECT:
384     case KEYDB_SEARCH_MODE_KEYGRIP:
385     case KEYDB_SEARCH_MODE_WORDS:
386     case KEYDB_SEARCH_MODE_FIRST:
387     case KEYDB_SEARCH_MODE_NEXT:
388     default:
389       break;
390     }
391
392   xfree (freeme);
393
394   if (! f)
395     {
396       log_error ("Unsupported search mode.\n");
397       return gpg_error (GPG_ERR_NOT_SUPPORTED);
398     }
399
400   *filter = f;
401
402   return 0;
403 }
404
405
406 \f
407 /* Connect to an LDAP server and interrogate it.
408
409      - uri describes the server to connect to and various options
410        including whether to use TLS and the username and password (see
411        ldap_parse_uri for a description of the various fields).
412
413    This function returns:
414
415      - The ldap connection handle in *LDAP_CONNP.
416
417      - The base DN for the PGP key space by querying the
418        pgpBaseKeySpaceDN attribute (This is normally
419        'ou=PGP Keys,dc=EXAMPLE,dc=ORG').
420
421      - The attribute to lookup to find the pgp key.  This is either
422        'pgpKey' or 'pgpKeyV2'.
423
424      - Whether this is a real ldap server.  (It's unclear what this
425        exactly means.)
426
427    The values are returned in the passed variables.  If you pass NULL,
428    then the value won't be returned.  It is the caller's
429    responsibility to release *LDAP_CONNP with ldap_unbind and xfree
430    *BASEDNP and *PGPKEYATTRP.
431
432    If this function successfully interrogated the server, it returns
433    0.  If there was an LDAP error, it returns the LDAP error code.  If
434    an error occurred, *basednp, etc., are undefined (and don't need to
435    be freed.)
436
437    If no LDAP error occurred, you still need to check that *basednp is
438    valid.  If it is NULL, then the server does not appear to be an
439    OpenPGP Keyserver.  In this case, you also do not need to xfree
440    *pgpkeyattrp.  */
441 static int
442 my_ldap_connect (parsed_uri_t uri, LDAP **ldap_connp,
443                  char **basednp, char **pgpkeyattrp, int *real_ldapp)
444 {
445   int err = 0;
446
447   LDAP *ldap_conn = NULL;
448
449   char *user = uri->auth;
450   struct uri_tuple_s *password_param = uri_query_lookup (uri, "password");
451   char *password = password_param ? password_param->value : NULL;
452
453   char *basedn = NULL;
454   /* Whether to look for the pgpKey or pgpKeyv2 attribute.  */
455   char *pgpkeyattr = "pgpKey";
456   int real_ldap = 0;
457
458   log_debug ("my_ldap_connect(%s:%d/%s????%s%s%s%s%s)\n",
459              uri->host, uri->port,
460              uri->path ?: "",
461              uri->auth ? "bindname=" : "", uri->auth ?: "",
462              uri->auth && password ? "," : "",
463              password ? "password=" : "", password ?: "");
464
465   /* If the uri specifies a secure connection and we don't support
466      TLS, then fail; don't silently revert to an insecure
467      connection.  */
468   if (uri->use_tls)
469     {
470 #ifndef HAVE_LDAP_START_TLS_S
471       log_error ("Can't use LDAP to connect to the server: no TLS support.");
472       err = GPG_ERR_LDAP_NOT_SUPPORTED;
473       goto out;
474 #endif
475     }
476
477   ldap_conn = ldap_init (uri->host, uri->port);
478   if (! ldap_conn)
479     {
480       err = gpg_err_code_from_syserror ();
481       log_error ("Failed to open connection to LDAP server (%s://%s:%d)\n",
482                  uri->scheme, uri->host, uri->port);
483       goto out;
484     }
485
486 #ifdef HAVE_LDAP_SET_OPTION
487   {
488     int ver = LDAP_VERSION3;
489
490     err = ldap_set_option (ldap_conn, LDAP_OPT_PROTOCOL_VERSION, &ver);
491     if (err != LDAP_SUCCESS)
492       {
493         log_error ("gpgkeys: unable to go to LDAP 3: %s\n",
494                    ldap_err2string (err));
495         goto out;
496       }
497   }
498 #endif
499
500   /* XXX: It would be nice to have an option to provide the server's
501      certificate.  */
502 #if 0
503 #if defined(LDAP_OPT_X_TLS_CACERTFILE) && defined(HAVE_LDAP_SET_OPTION)
504   err = ldap_set_option (NULL, LDAP_OPT_X_TLS_CACERTFILE, ca_cert_file);
505   if (err)
506     {
507       log_error ("unable to set ca-cert-file to '%s': %s\n",
508                  ca_cert_file, ldap_err2string (err));
509       goto out;
510     }
511 #endif /* LDAP_OPT_X_TLS_CACERTFILE && HAVE_LDAP_SET_OPTION */
512 #endif
513
514 #ifdef HAVE_LDAP_START_TLS_S
515   if (uri->use_tls)
516     {
517       /* XXX: We need an option to determine whether to abort if the
518          certificate is bad or not.  Right now we conservatively
519          default to checking the certificate and aborting.  */
520 #ifndef HAVE_W32_SYSTEM
521       int check_cert = LDAP_OPT_X_TLS_HARD; /* LDAP_OPT_X_TLS_NEVER */
522
523       err = ldap_set_option (ldap_conn,
524                              LDAP_OPT_X_TLS_REQUIRE_CERT, &check_cert);
525       if (err)
526         {
527           log_error ("Failed to set TLS option on LDAP connection.\n");
528           goto out;
529         }
530 #else
531       /* On Windows, the certificates are checked by default.  If the
532          option to disable checking mentioned above is ever
533          implemented, the way to do that on Windows is to install a
534          callback routine using ldap_set_option (..,
535          LDAP_OPT_SERVER_CERTIFICATE, ..); */
536 #endif
537
538       err = ldap_start_tls_s (ldap_conn,
539 #ifdef HAVE_W32_SYSTEM
540                               /* ServerReturnValue, result */
541                               NULL, NULL,
542 #endif
543                               /* ServerControls, ClientControls */
544                               NULL, NULL);
545       if (err)
546         {
547           log_error ("Failed to connect to LDAP server with TLS.\n");
548           goto out;
549         }
550     }
551 #endif
552
553   /* By default we don't bind as there is usually no need to.  */
554   if (uri->auth)
555     {
556       log_debug ("LDAP bind to %s, password %s\n",
557                  user, password ? ">not shown<" : ">none<");
558
559       err = ldap_simple_bind_s (ldap_conn, user, password);
560       if (err != LDAP_SUCCESS)
561         {
562           log_error ("Internal LDAP bind error: %s\n",
563                      ldap_err2string (err));
564           goto out;
565         }
566     }
567
568   if (uri->path && *uri->path)
569     /* User specified base DN.  */
570     {
571       basedn = xstrdup (uri->path);
572
573       /* If the user specifies a base DN, then we know the server is a
574          real LDAP server.  */
575       real_ldap = 1;
576     }
577   else
578     {
579       LDAPMessage *res = NULL;
580       /* Look for namingContexts.  */
581       char *attr[] = { "namingContexts", NULL };
582
583       err = ldap_search_s (ldap_conn, "", LDAP_SCOPE_BASE,
584                            "(objectClass=*)", attr, 0, &res);
585       if (err == LDAP_SUCCESS)
586         {
587           char **context = ldap_get_values (ldap_conn, res, "namingContexts");
588           if (context)
589             /* We found some, so try each namingContext as the search
590                base and look for pgpBaseKeySpaceDN.  Because we found
591                this, we know we're talking to a regular-ish LDAP
592                server and not an LDAP keyserver.  */
593             {
594               int i;
595               char *attr2[] =
596                 { "pgpBaseKeySpaceDN", "pgpVersion", "pgpSoftware", NULL };
597
598               real_ldap = 1;
599
600               for (i = 0; context[i] && ! basedn; i++)
601                 {
602                   char **vals;
603                   LDAPMessage *si_res;
604
605                   {
606                     char *object = xasprintf ("cn=pgpServerInfo,%s",
607                                               context[i]);
608                     err = ldap_search_s (ldap_conn, object, LDAP_SCOPE_BASE,
609                                          "(objectClass=*)", attr2, 0, &si_res);
610                     xfree (object);
611                   }
612
613                   if (err == LDAP_SUCCESS)
614                     {
615                       vals = ldap_get_values (ldap_conn, si_res,
616                                               "pgpBaseKeySpaceDN");
617                       if (vals)
618                         {
619                           basedn = xtrystrdup (vals[0]);
620                           ldap_value_free (vals);
621                         }
622
623                       vals = ldap_get_values (ldap_conn, si_res,
624                                               "pgpSoftware");
625                       if (vals)
626                         {
627                           log_debug ("Server: \t%s\n", vals[0]);
628                           ldap_value_free (vals);
629                         }
630
631                       vals = ldap_get_values (ldap_conn, si_res,
632                                               "pgpVersion");
633                       if (vals)
634                         {
635                           log_debug ("Version:\t%s\n", vals[0]);
636                           ldap_value_free (vals);
637                         }
638                     }
639
640                   /* From man ldap_search_s: "res parameter of
641                      ldap_search_ext_s() and ldap_search_s() should be
642                      freed with ldap_msgfree() regardless of return
643                      value of these functions.  */
644                   ldap_msgfree (si_res);
645                 }
646
647               ldap_value_free (context);
648             }
649         }
650       else
651         {
652           /* We don't have an answer yet, which means the server might
653              be an LDAP keyserver. */
654           char **vals;
655           LDAPMessage *si_res = NULL;
656
657           char *attr2[] = { "pgpBaseKeySpaceDN", "version", "software", NULL };
658
659           err = ldap_search_s (ldap_conn, "cn=pgpServerInfo", LDAP_SCOPE_BASE,
660                                "(objectClass=*)", attr2, 0, &si_res);
661           if (err == LDAP_SUCCESS)
662             {
663               /* For the LDAP keyserver, this is always
664                  "OU=ACTIVE,O=PGP KEYSPACE,C=US", but it might not be
665                  in the future. */
666
667               vals = ldap_get_values (ldap_conn, si_res, "baseKeySpaceDN");
668               if (vals)
669                 {
670                   basedn = xtrystrdup (vals[0]);
671                   ldap_value_free (vals);
672                 }
673
674               vals = ldap_get_values (ldap_conn, si_res, "software");
675               if (vals)
676                 {
677                   log_debug ("ldap: Server: \t%s\n", vals[0]);
678                   ldap_value_free (vals);
679                 }
680
681               vals = ldap_get_values (ldap_conn, si_res, "version");
682               if (vals)
683                 {
684                   log_debug ("ldap: Version:\t%s\n", vals[0]);
685
686                   /* If the version is high enough, use the new
687                      pgpKeyV2 attribute.  This design is iffy at best,
688                      but it matches how PGP does it.  I figure the NAI
689                      folks assumed that there would never be an LDAP
690                      keyserver vendor with a different numbering
691                      scheme. */
692                   if (atoi (vals[0]) > 1)
693                     pgpkeyattr = "pgpKeyV2";
694
695                   ldap_value_free (vals);
696                 }
697             }
698
699           ldap_msgfree (si_res);
700         }
701
702       /* From man ldap_search_s: "res parameter of ldap_search_ext_s()
703          and ldap_search_s() should be freed with ldap_msgfree()
704          regardless of return value of these functions.  */
705       ldap_msgfree (res);
706     }
707
708  out:
709   if (! err)
710     {
711       log_debug ("ldap_conn: %p\n", ldap_conn);
712       log_debug ("real_ldap: %d\n", real_ldap);
713       log_debug ("basedn: %s\n", basedn);
714       log_debug ("pgpkeyattr: %s\n", pgpkeyattr);
715     }
716
717   if (! err && real_ldapp)
718     *real_ldapp = real_ldap;
719
720   if (err)
721     xfree (basedn);
722   else
723     {
724       if (pgpkeyattrp)
725         {
726           if (basedn)
727             *pgpkeyattrp = xstrdup (pgpkeyattr);
728           else
729             *pgpkeyattrp = NULL;
730         }
731
732       if (basednp)
733         *basednp = basedn;
734       else
735         xfree (basedn);
736     }
737
738   if (err)
739     {
740       if (ldap_conn)
741         ldap_unbind (ldap_conn);
742     }
743   else
744     *ldap_connp = ldap_conn;
745
746   return err;
747 }
748
749 /* Extract keys from an LDAP reply and write them out to the output
750    stream OUTPUT in a format GnuPG can import (either the OpenPGP
751    binary format or armored format).  */
752 static void
753 extract_keys (estream_t output,
754               LDAP *ldap_conn, const char *certid, LDAPMessage *message)
755 {
756   char **vals;
757
758   es_fprintf (output, "INFO %s BEGIN\n", certid);
759   es_fprintf (output, "pub:%s:", certid);
760
761   /* Note: ldap_get_values returns a NULL terminates array of
762      strings.  */
763   vals = ldap_get_values (ldap_conn, message, "pgpkeytype");
764   if (vals && vals[0])
765     {
766       if (strcmp (vals[0], "RSA") == 0)
767         es_fprintf  (output, "1");
768       else if (strcmp (vals[0],"DSS/DH") == 0)
769         es_fprintf (output, "17");
770       ldap_value_free (vals);
771     }
772
773   es_fprintf (output, ":");
774
775   vals = ldap_get_values (ldap_conn, message, "pgpkeysize");
776   if (vals && vals[0])
777     {
778       int v = atoi (vals[0]);
779       if (v > 0)
780         es_fprintf (output, "%d", v);
781       ldap_value_free (vals);
782     }
783
784   es_fprintf (output, ":");
785
786   vals = ldap_get_values (ldap_conn, message, "pgpkeycreatetime");
787   if (vals && vals[0])
788     {
789       if (strlen (vals[0]) == 15)
790         es_fprintf (output, "%u", (unsigned int) ldap2epochtime (vals[0]));
791       ldap_value_free (vals);
792     }
793
794   es_fprintf (output, ":");
795
796   vals = ldap_get_values (ldap_conn, message, "pgpkeyexpiretime");
797   if (vals && vals[0])
798     {
799       if (strlen (vals[0]) == 15)
800         es_fprintf (output, "%u", (unsigned int) ldap2epochtime (vals[0]));
801       ldap_value_free (vals);
802     }
803
804   es_fprintf (output, ":");
805
806   vals = ldap_get_values (ldap_conn, message, "pgprevoked");
807   if (vals && vals[0])
808     {
809       if (atoi (vals[0]) == 1)
810         es_fprintf (output, "r");
811       ldap_value_free (vals);
812     }
813
814   es_fprintf (output, "\n");
815
816   vals = ldap_get_values (ldap_conn, message, "pgpuserid");
817   if (vals && vals[0])
818     {
819       int i;
820       for (i = 0; vals[i]; i++)
821         es_fprintf (output, "uid:%s\n", vals[i]);
822       ldap_value_free (vals);
823     }
824
825   es_fprintf (output, "INFO %s END\n", certid);
826 }
827
828 /* Get the key described key the KEYSPEC string from the keyserver
829    identified by URI.  On success R_FP has an open stream to read the
830    data.  */
831 gpg_error_t
832 ks_ldap_get (ctrl_t ctrl, parsed_uri_t uri, const char *keyspec,
833              estream_t *r_fp)
834 {
835   gpg_error_t err = 0;
836   int ldap_err;
837
838   char *filter = NULL;
839
840   LDAP *ldap_conn = NULL;
841
842   char *basedn = NULL;
843   char *pgpkeyattr = NULL;
844
845   estream_t fp = NULL;
846
847   LDAPMessage *message = NULL;
848
849   (void) ctrl;
850
851   if (dirmngr_use_tor ())
852     {
853       /* For now we do not support LDAP over Tor.  */
854       log_error (_("LDAP access not possible due to Tor mode\n"));
855       return gpg_error (GPG_ERR_NOT_SUPPORTED);
856     }
857
858   /* Before connecting to the server, make sure we have a sane
859      keyspec.  If not, there is no need to establish a network
860      connection.  */
861   err = keyspec_to_ldap_filter (keyspec, &filter, 1);
862   if (err)
863     return (err);
864
865   /* Make sure we are talking to an OpenPGP LDAP server.  */
866   ldap_err = my_ldap_connect (uri, &ldap_conn, &basedn, &pgpkeyattr, NULL);
867   if (ldap_err || !basedn)
868     {
869       if (ldap_err)
870         err = ldap_err_to_gpg_err (ldap_err);
871       else
872         err = GPG_ERR_GENERAL;
873       goto out;
874     }
875
876   {
877     /* The ordering is significant.  Specifically, "pgpcertid" needs
878        to be the second item in the list, since everything after it
879        may be discarded we aren't in verbose mode. */
880     char *attrs[] =
881       {
882         pgpkeyattr,
883         "pgpcertid", "pgpuserid", "pgpkeyid", "pgprevoked", "pgpdisabled",
884         "pgpkeycreatetime", "modifytimestamp", "pgpkeysize", "pgpkeytype",
885         NULL
886       };
887     /* 1 if we want just attribute types; 0 if we want both attribute
888        types and values.  */
889     int attrsonly = 0;
890
891     int count;
892
893     ldap_err = ldap_search_s (ldap_conn, basedn, LDAP_SCOPE_SUBTREE,
894                               filter, attrs, attrsonly, &message);
895     if (ldap_err)
896       {
897         err = ldap_err_to_gpg_err (ldap_err);
898
899         log_error ("gpgkeys: LDAP search error: %s\n",
900                    ldap_err2string (ldap_err));
901         goto out;
902       }
903
904     count = ldap_count_entries (ldap_conn, message);
905     if (count < 1)
906       {
907         log_error ("gpgkeys: key %s not found on keyserver\n", keyspec);
908
909         if (count == -1)
910           err = ldap_to_gpg_err (ldap_conn);
911         else
912           err = gpg_error (GPG_ERR_NO_DATA);
913
914         goto out;
915       }
916
917     {
918       /* There may be more than one unique result for a given keyID,
919          so we should fetch them all (test this by fetching short key
920          id 0xDEADBEEF). */
921
922       /* The set of entries that we've seen.  */
923       strlist_t seen = NULL;
924       LDAPMessage *each;
925
926       for (each = ldap_first_entry (ldap_conn, message);
927            each;
928            each = ldap_next_entry (ldap_conn, each))
929         {
930           char **vals;
931           char **certid;
932
933           /* Use the long keyid to remove duplicates.  The LDAP
934              server returns the same keyid more than once if there
935              are multiple user IDs on the key.  Note that this does
936              NOT mean that a keyid that exists multiple times on the
937              keyserver will not be fetched.  It means that each KEY,
938              no matter how many user IDs share its keyid, will be
939              fetched only once.  If a keyid that belongs to more
940              than one key is fetched, the server quite properly
941              responds with all matching keys. -ds */
942
943           certid = ldap_get_values (ldap_conn, each, "pgpcertid");
944           if (certid && certid[0])
945             {
946               if (! strlist_find (seen, certid[0]))
947                 {
948                   /* It's not a duplicate, add it */
949
950                   add_to_strlist (&seen, certid[0]);
951
952                   if (! fp)
953                     fp = es_fopenmem(0, "rw");
954
955                   extract_keys (fp, ldap_conn, certid[0], each);
956
957                   vals = ldap_get_values (ldap_conn, each, pgpkeyattr);
958                   if (! vals)
959                     {
960                       err = ldap_to_gpg_err (ldap_conn);
961                       log_error("gpgkeys: unable to retrieve key %s "
962                                 "from keyserver\n", certid[0]);
963                       goto out;
964                     }
965                   else
966                     {
967                       /* We should strip the new lines.  */
968                       es_fprintf (fp, "KEY 0x%s BEGIN\n", certid[0]);
969                       es_fputs (vals[0], fp);
970                       es_fprintf (fp, "\nKEY 0x%s END\n", certid[0]);
971
972                       ldap_value_free (vals);
973                     }
974                 }
975             }
976
977           ldap_value_free (certid);
978         }
979
980       free_strlist (seen);
981
982       if (! fp)
983         err = gpg_error (GPG_ERR_NO_DATA);
984     }
985   }
986
987  out:
988   if (message)
989     ldap_msgfree (message);
990
991   if (err)
992     {
993       if (fp)
994         es_fclose (fp);
995     }
996   else
997     {
998       if (fp)
999         es_fseek (fp, 0, SEEK_SET);
1000
1001       *r_fp = fp;
1002     }
1003
1004   xfree (pgpkeyattr);
1005   xfree (basedn);
1006
1007   if (ldap_conn)
1008     ldap_unbind (ldap_conn);
1009
1010   xfree (filter);
1011
1012   return err;
1013 }
1014
1015 /* Search the keyserver identified by URI for keys matching PATTERN.
1016    On success R_FP has an open stream to read the data.  */
1017 gpg_error_t
1018 ks_ldap_search (ctrl_t ctrl, parsed_uri_t uri, const char *pattern,
1019                 estream_t *r_fp)
1020 {
1021   gpg_error_t err;
1022   int ldap_err;
1023
1024   char *filter = NULL;
1025
1026   LDAP *ldap_conn = NULL;
1027
1028   char *basedn = NULL;
1029
1030   estream_t fp = NULL;
1031
1032   (void) ctrl;
1033
1034   if (dirmngr_use_tor ())
1035     {
1036       /* For now we do not support LDAP over Tor.  */
1037       log_error (_("LDAP access not possible due to Tor mode\n"));
1038       return gpg_error (GPG_ERR_NOT_SUPPORTED);
1039     }
1040
1041   /* Before connecting to the server, make sure we have a sane
1042      keyspec.  If not, there is no need to establish a network
1043      connection.  */
1044   err = keyspec_to_ldap_filter (pattern, &filter, 0);
1045   if (err)
1046     {
1047       log_error ("Bad search pattern: '%s'\n", pattern);
1048       return (err);
1049     }
1050
1051   /* Make sure we are talking to an OpenPGP LDAP server.  */
1052   ldap_err = my_ldap_connect (uri, &ldap_conn, &basedn, NULL, NULL);
1053   if (ldap_err || !basedn)
1054     {
1055       if (ldap_err)
1056         err = ldap_err_to_gpg_err (ldap_err);
1057       else
1058         err = GPG_ERR_GENERAL;
1059       goto out;
1060     }
1061
1062   /* Even if we have no results, we want to return a stream.  */
1063   fp = es_fopenmem(0, "rw");
1064   if (!fp)
1065     {
1066       err = gpg_error_from_syserror ();
1067       goto out;
1068     }
1069
1070   {
1071     char **vals;
1072     LDAPMessage *res, *each;
1073     int count = 0;
1074     strlist_t dupelist = NULL;
1075
1076     /* The maximum size of the search, including the optional stuff
1077        and the trailing \0 */
1078     char *attrs[] =
1079       {
1080         "pgpcertid", "pgpuserid", "pgprevoked", "pgpdisabled",
1081         "pgpkeycreatetime", "pgpkeyexpiretime", "modifytimestamp",
1082         "pgpkeysize", "pgpkeytype", NULL
1083       };
1084
1085     log_debug ("SEARCH '%s' => '%s' BEGIN\n", pattern, filter);
1086
1087     ldap_err = ldap_search_s (ldap_conn, basedn,
1088                               LDAP_SCOPE_SUBTREE, filter, attrs, 0, &res);
1089
1090     xfree (filter);
1091     filter = NULL;
1092
1093     if (ldap_err != LDAP_SUCCESS && ldap_err != LDAP_SIZELIMIT_EXCEEDED)
1094       {
1095         err = ldap_err_to_gpg_err (ldap_err);
1096
1097         log_error ("SEARCH %s FAILED %d\n", pattern, err);
1098         log_error ("gpgkeys: LDAP search error: %s\n",
1099                    ldap_err2string (err));
1100         goto out;
1101     }
1102
1103     /* The LDAP server doesn't return a real count of unique keys, so we
1104        can't use ldap_count_entries here. */
1105     for (each = ldap_first_entry (ldap_conn, res);
1106          each;
1107          each = ldap_next_entry (ldap_conn, each))
1108       {
1109         char **certid = ldap_get_values (ldap_conn, each, "pgpcertid");
1110         if (certid && certid[0] && ! strlist_find (dupelist, certid[0]))
1111           {
1112             add_to_strlist (&dupelist, certid[0]);
1113             count++;
1114           }
1115       }
1116
1117     if (ldap_err == LDAP_SIZELIMIT_EXCEEDED)
1118       {
1119         if (count == 1)
1120           log_error ("gpgkeys: search results exceeded server limit."
1121                      "  First 1 result shown.\n");
1122         else
1123           log_error ("gpgkeys: search results exceeded server limit."
1124                      "  First %d results shown.\n", count);
1125       }
1126
1127     free_strlist (dupelist);
1128     dupelist = NULL;
1129
1130     if (count < 1)
1131       es_fputs ("info:1:0\n", fp);
1132     else
1133       {
1134         es_fprintf (fp, "info:1:%d\n", count);
1135
1136         for (each = ldap_first_entry (ldap_conn, res);
1137              each;
1138              each = ldap_next_entry (ldap_conn, each))
1139           {
1140             char **certid;
1141             LDAPMessage *uids;
1142
1143             certid = ldap_get_values (ldap_conn, each, "pgpcertid");
1144             if (! certid || ! certid[0])
1145               continue;
1146
1147             /* Have we seen this certid before? */
1148             if (! strlist_find (dupelist, certid[0]))
1149               {
1150                 add_to_strlist (&dupelist, certid[0]);
1151
1152                 es_fprintf (fp, "pub:%s:",certid[0]);
1153
1154                 vals = ldap_get_values (ldap_conn, each, "pgpkeytype");
1155                 if (vals)
1156                   {
1157                     /* The LDAP server doesn't exactly handle this
1158                        well. */
1159                     if (strcasecmp (vals[0], "RSA") == 0)
1160                       es_fputs ("1", fp);
1161                     else if (strcasecmp (vals[0], "DSS/DH") == 0)
1162                       es_fputs ("17", fp);
1163                     ldap_value_free (vals);
1164                   }
1165
1166                 es_fputc (':', fp);
1167
1168                 vals = ldap_get_values (ldap_conn, each, "pgpkeysize");
1169                 if (vals)
1170                   {
1171                     /* Not sure why, but some keys are listed with a
1172                        key size of 0.  Treat that like an unknown. */
1173                     if (atoi (vals[0]) > 0)
1174                       es_fprintf (fp, "%d", atoi (vals[0]));
1175                     ldap_value_free (vals);
1176                   }
1177
1178                 es_fputc (':', fp);
1179
1180                 /* YYYYMMDDHHmmssZ */
1181
1182                 vals = ldap_get_values (ldap_conn, each, "pgpkeycreatetime");
1183                 if(vals && strlen (vals[0]) == 15)
1184                   {
1185                     es_fprintf (fp, "%u",
1186                                 (unsigned int) ldap2epochtime(vals[0]));
1187                     ldap_value_free (vals);
1188                   }
1189
1190                 es_fputc (':', fp);
1191
1192                 vals = ldap_get_values (ldap_conn, each, "pgpkeyexpiretime");
1193                 if (vals && strlen (vals[0]) == 15)
1194                   {
1195                     es_fprintf (fp, "%u",
1196                                 (unsigned int) ldap2epochtime (vals[0]));
1197                     ldap_value_free (vals);
1198                   }
1199
1200                 es_fputc (':', fp);
1201
1202                 vals = ldap_get_values (ldap_conn, each, "pgprevoked");
1203                 if (vals)
1204                   {
1205                     if (atoi (vals[0]) == 1)
1206                       es_fprintf (fp, "r");
1207                     ldap_value_free (vals);
1208                   }
1209
1210                 vals = ldap_get_values (ldap_conn, each, "pgpdisabled");
1211                 if (vals)
1212                   {
1213                     if (atoi (vals[0]) ==1)
1214                       es_fprintf (fp, "d");
1215                     ldap_value_free (vals);
1216                   }
1217
1218 #if 0
1219                 /* This is not yet specified in the keyserver
1220                    protocol, but may be someday. */
1221                 es_fputc (':', fp);
1222
1223                 vals = ldap_get_values (ldap_conn, each, "modifytimestamp");
1224                 if(vals && strlen (vals[0]) == 15)
1225                   {
1226                     es_fprintf (fp, "%u",
1227                                 (unsigned int) ldap2epochtime (vals[0]));
1228                     ldap_value_free (vals);
1229                   }
1230 #endif
1231
1232                 es_fprintf (fp, "\n");
1233
1234                 /* Now print all the uids that have this certid */
1235                 for (uids = ldap_first_entry (ldap_conn, res);
1236                      uids;
1237                      uids = ldap_next_entry (ldap_conn, uids))
1238                   {
1239                     vals = ldap_get_values (ldap_conn, uids, "pgpcertid");
1240                     if (! vals)
1241                       continue;
1242
1243                     if (strcasecmp (certid[0], vals[0]) == 0)
1244                       {
1245                         char **uidvals;
1246
1247                         es_fprintf (fp, "uid:");
1248
1249                         uidvals = ldap_get_values (ldap_conn,
1250                                                    uids, "pgpuserid");
1251                         if (uidvals)
1252                           {
1253                             /* Need to escape any colons */
1254                             char *quoted = percent_escape (uidvals[0], NULL);
1255                             es_fputs (quoted, fp);
1256                             xfree (quoted);
1257                             ldap_value_free (uidvals);
1258                           }
1259
1260                         es_fprintf (fp, "\n");
1261                       }
1262
1263                     ldap_value_free(vals);
1264                   }
1265               }
1266
1267               ldap_value_free (certid);
1268           }
1269       }
1270
1271     ldap_msgfree (res);
1272     free_strlist (dupelist);
1273   }
1274
1275   log_debug ("SEARCH %s END\n", pattern);
1276
1277  out:
1278   if (err)
1279     {
1280       if (fp)
1281         es_fclose (fp);
1282     }
1283   else
1284     {
1285       /* Return the read stream.  */
1286       if (fp)
1287         es_fseek (fp, 0, SEEK_SET);
1288
1289       *r_fp = fp;
1290     }
1291
1292   xfree (basedn);
1293
1294   if (ldap_conn)
1295     ldap_unbind (ldap_conn);
1296
1297   xfree (filter);
1298
1299   return err;
1300 }
1301
1302
1303 \f
1304 /* A modlist describes a set of changes to an LDAP entry.  (An entry
1305    consists of 1 or more attributes.  Attributes are <name, value>
1306    pairs.  Note: an attribute may be multi-valued in which case
1307    multiple values are associated with a single name.)
1308
1309    A modlist is a NULL terminated array of struct LDAPMod's.
1310
1311    Thus, if we have:
1312
1313      LDAPMod **modlist;
1314
1315    Then:
1316
1317      modlist[i]
1318
1319    Is the ith modification.
1320
1321    Each LDAPMod describes a change to a single attribute.  Further,
1322    there is one modification for each attribute that we want to
1323    change.  The attribute's new value is stored in LDAPMod.mod_values.
1324    If the attribute is multi-valued, we still only use a single
1325    LDAPMod structure: mod_values is a NULL-terminated array of
1326    strings.  To delete an attribute from an entry, we set mod_values
1327    to NULL.
1328
1329    Thus, if:
1330
1331      modlist[i]->mod_values == NULL
1332
1333    then we remove the attribute.
1334
1335    (Using LDAP_MOD_DELETE doesn't work here as we don't know if the
1336    attribute in question exists or not.)
1337
1338    Note: this function does NOT copy or free ATTR.  It does copy
1339    VALUE.  */
1340 static void
1341 modlist_add (LDAPMod ***modlistp, char *attr, const char *value)
1342 {
1343   LDAPMod **modlist = *modlistp;
1344
1345   LDAPMod **m;
1346   int nummods = 0;
1347
1348   /* Search modlist for the attribute we're playing with.  If modlist
1349      is NULL, then the list is empty.  Recall: modlist is a NULL
1350      terminated array.  */
1351   for (m = modlist; m && *m; m++, nummods ++)
1352     {
1353       /* The attribute is already on the list.  */
1354       char **ptr;
1355       int numvalues = 0;
1356
1357       if (strcasecmp ((*m)->mod_type, attr) != 0)
1358         continue;
1359
1360       /* We have this attribute already, so when the REPLACE happens,
1361          the server attributes will be replaced anyway. */
1362       if (! value)
1363         return;
1364
1365       /* Attributes can be multi-valued.  See if the value is already
1366          present.  mod_values is a NULL terminated array of pointers.
1367          Note: mod_values can be NULL.  */
1368       for (ptr = (*m)->mod_values; ptr && *ptr; ptr++)
1369         {
1370           if (strcmp (*ptr, value) == 0)
1371             /* Duplicate value, we're done.  */
1372             return;
1373           numvalues ++;
1374         }
1375
1376       /* Append the value.  */
1377       ptr = xrealloc ((*m)->mod_values, sizeof (char *) * (numvalues + 2));
1378
1379       (*m)->mod_values = ptr;
1380       ptr[numvalues] = xstrdup (value);
1381
1382       ptr[numvalues + 1] = NULL;
1383
1384       return;
1385     }
1386
1387   /* We didn't find the attr, so make one and add it to the end */
1388
1389   /* Like attribute values, the list of attributes is NULL terminated
1390      array of pointers.  */
1391   modlist = xrealloc (modlist, sizeof (LDAPMod *) * (nummods + 2));
1392
1393   *modlistp = modlist;
1394   modlist[nummods] = xmalloc (sizeof (LDAPMod));
1395
1396   modlist[nummods]->mod_op = LDAP_MOD_REPLACE;
1397   modlist[nummods]->mod_type = attr;
1398   if (value)
1399     {
1400       modlist[nummods]->mod_values = xmalloc (sizeof(char *) * 2);
1401
1402       modlist[nummods]->mod_values[0] = xstrdup (value);
1403       modlist[nummods]->mod_values[1] = NULL;
1404     }
1405   else
1406     modlist[nummods]->mod_values = NULL;
1407
1408   modlist[nummods + 1] = NULL;
1409
1410   return;
1411 }
1412
1413 /* Look up the value of an attribute in the specified modlist.  If the
1414    attribute is not on the mod list, returns NULL.  The result is a
1415    NULL-terminated array of strings.  Don't change it.  */
1416 static char **
1417 modlist_lookup (LDAPMod **modlist, const char *attr)
1418 {
1419   LDAPMod **m;
1420   for (m = modlist; m && *m; m++)
1421     {
1422       if (strcasecmp ((*m)->mod_type, attr) != 0)
1423         continue;
1424
1425       return (*m)->mod_values;
1426     }
1427
1428   return NULL;
1429 }
1430
1431 /* Dump a modlist to a file.  This is useful for debugging.  */
1432 static estream_t modlist_dump (LDAPMod **modlist, estream_t output)
1433   GPGRT_ATTR_USED;
1434
1435 static estream_t
1436 modlist_dump (LDAPMod **modlist, estream_t output)
1437 {
1438   LDAPMod **m;
1439
1440   int opened = 0;
1441
1442   if (! output)
1443     {
1444       output = es_fopenmem (0, "rw");
1445       if (!output)
1446         return NULL;
1447       opened = 1;
1448     }
1449
1450   for (m = modlist; m && *m; m++)
1451     {
1452       es_fprintf (output, "  %s:", (*m)->mod_type);
1453
1454       if (! (*m)->mod_values)
1455         es_fprintf(output, " delete.\n");
1456       else
1457         {
1458           char **ptr;
1459           int i;
1460
1461           int multi = 0;
1462           if ((*m)->mod_values[0] && (*m)->mod_values[1])
1463             /* Have at least 2.  */
1464             multi = 1;
1465
1466           if (multi)
1467             es_fprintf (output, "\n");
1468
1469           for ((ptr = (*m)->mod_values), (i = 1); ptr && *ptr; ptr++, i ++)
1470             {
1471               /* Assuming terminals are about 80 characters wide,
1472                  display at most about 10 lines of debugging
1473                  output.  If we do trim the buffer, append '...' to
1474                  the end.  */
1475               const int max_len = 10 * 70;
1476               size_t value_len = strlen (*ptr);
1477               int elide = value_len > max_len;
1478
1479               if (multi)
1480                 es_fprintf (output, "    %d. ", i);
1481               es_fprintf (output, "`%.*s", max_len, *ptr);
1482               if (elide)
1483                 es_fprintf (output, "...' (%zd bytes elided)",
1484                             value_len - max_len);
1485               else
1486                 es_fprintf (output, "'");
1487               es_fprintf (output, "\n");
1488             }
1489         }
1490     }
1491
1492   if (opened)
1493     es_fseek (output, 0, SEEK_SET);
1494
1495   return output;
1496 }
1497
1498 /* Free all of the memory allocated by the mod list.  This assumes
1499    that the attribute names don't have to be freed, but the attributes
1500    values do.  (Which is what modlist_add does.)  */
1501 static void
1502 modlist_free (LDAPMod **modlist)
1503 {
1504   LDAPMod **ml;
1505
1506   if (! modlist)
1507     return;
1508
1509   /* Unwind and free the whole modlist structure */
1510
1511   /* The modlist is a NULL terminated array of pointers.  */
1512   for (ml = modlist; *ml; ml++)
1513     {
1514       LDAPMod *mod = *ml;
1515       char **ptr;
1516
1517       /* The list of values is a NULL termianted array of pointers.
1518          If the list is NULL, there are no values.  */
1519
1520       if (mod->mod_values)
1521         {
1522           for (ptr = mod->mod_values; *ptr; ptr++)
1523             xfree (*ptr);
1524
1525           xfree (mod->mod_values);
1526         }
1527
1528       xfree (mod);
1529     }
1530   xfree (modlist);
1531 }
1532
1533 /* Append two onto the end of one.  Two is not freed, but its pointers
1534    are now part of one.  Make sure you don't free them both!
1535
1536    As long as you don't add anything to ONE, TWO is still valid.
1537    After that all bets are off.  */
1538 static void
1539 modlists_join (LDAPMod ***one, LDAPMod **two)
1540 {
1541   int i, one_count = 0, two_count = 0;
1542   LDAPMod **grow;
1543
1544   if (!*two)
1545     /* two is empty.  Nothing to do.  */
1546     return;
1547
1548   if (!*one)
1549     /* one is empty.  Just set it equal to *two.  */
1550     {
1551       *one = two;
1552       return;
1553     }
1554
1555   for (grow = *one; *grow; grow++)
1556     one_count ++;
1557
1558   for (grow = two; *grow; grow++)
1559     two_count ++;
1560
1561   grow = xrealloc (*one, sizeof(LDAPMod *) * (one_count + two_count + 1));
1562
1563   for (i = 0; i < two_count; i++)
1564     grow[one_count + i] = two[i];
1565
1566   grow[one_count + i] = NULL;
1567
1568   *one = grow;
1569 }
1570
1571 /* Given a string, unescape C escapes.  In particular, \xXX.  This
1572    modifies the string in place.  */
1573 static void
1574 uncescape (char *str)
1575 {
1576   size_t r = 0;
1577   size_t w = 0;
1578
1579   char *first = strchr (str, '\\');
1580   if (! first)
1581     /* No backslashes => no escaping.  We're done.  */
1582     return;
1583
1584   /* Start at the first '\\'.  */
1585   r = w = (uintptr_t) first - (uintptr_t) str;
1586
1587   while (str[r])
1588     {
1589       /* XXX: What to do about bad escapes?
1590          XXX: hextobyte already checks the string thus the hexdigitp
1591          could be removed. */
1592       if (str[r] == '\\' && str[r + 1] == 'x'
1593           && str[r+2] && str[r+3]
1594           && hexdigitp (str + r + 2)
1595           && hexdigitp (str + r + 3))
1596         {
1597           int x = hextobyte (&str[r + 2]);
1598           assert (0 <= x && x <= 0xff);
1599
1600           str[w] = x;
1601
1602           /* We consumed 4 characters and wrote 1.  */
1603           r += 4;
1604           w ++;
1605         }
1606       else
1607         str[w ++] = str[r ++];
1608     }
1609
1610   str[w] = '\0';
1611 }
1612
1613 /* Given one line from an info block (`gpg --list-{keys,sigs}
1614    --with-colons KEYID'), pull it apart and fill in the modlist with
1615    the relevant (for the LDAP schema) attributes.  */
1616 static void
1617 extract_attributes (LDAPMod ***modlist, char *line)
1618 {
1619   int field_count;
1620   char **fields;
1621
1622   char *keyid;
1623
1624   int is_pub, is_sub, is_uid, is_sig;
1625
1626   /* Remove trailing whitespace */
1627   trim_trailing_spaces (line);
1628
1629   fields = strsplit (line, ':', '\0', &field_count);
1630   if (field_count == 1)
1631     /* We only have a single field.  There is definitely nothing to
1632        do.  */
1633     goto out;
1634
1635   if (field_count < 7)
1636     goto out;
1637
1638   is_pub = strcasecmp ("pub", fields[0]) == 0;
1639   is_sub = strcasecmp ("sub", fields[0]) == 0;
1640   is_uid = strcasecmp ("uid", fields[0]) == 0;
1641   is_sig = strcasecmp ("sig", fields[0]) == 0;
1642
1643   if (!is_pub && !is_sub && !is_uid && !is_sig)
1644     /* Not a relevant line.  */
1645     goto out;
1646
1647   keyid = fields[4];
1648
1649   if (is_uid && strlen (keyid) == 0)
1650     /* The uid record type can have an empty keyid.  */
1651     ;
1652   else if (strlen (keyid) == 16
1653            && strspn (keyid, "0123456789aAbBcCdDeEfF") == 16)
1654     /* Otherwise, we expect exactly 16 hex characters.  */
1655     ;
1656   else
1657     {
1658       log_error ("malformed record!\n");
1659       goto out;
1660     }
1661
1662   if (is_pub)
1663     {
1664       int disabled = 0;
1665       int revoked = 0;
1666       char *flags;
1667       for (flags = fields[1]; *flags; flags ++)
1668         switch (*flags)
1669           {
1670           case 'r':
1671           case 'R':
1672             revoked = 1;
1673             break;
1674
1675           case 'd':
1676           case 'D':
1677             disabled = 1;
1678             break;
1679           }
1680
1681       /* Note: we always create the pgpDisabled and pgpRevoked
1682         attributes, regardless of whether the key is disabled/revoked
1683         or not.  This is because a very common search is like
1684         "(&(pgpUserID=*isabella*)(pgpDisabled=0))"  */
1685
1686       if (is_pub)
1687         {
1688           modlist_add (modlist,"pgpDisabled", disabled ? "1" : "0");
1689           modlist_add (modlist,"pgpRevoked", revoked ? "1" : "0");
1690         }
1691     }
1692
1693   if (is_pub || is_sub)
1694     {
1695       char padded[6];
1696       int val;
1697
1698       val = atoi (fields[2]);
1699       if (val < 99999 && val > 0)
1700         {
1701           /* We zero pad this on the left to make PGP happy. */
1702           snprintf (padded, sizeof padded, "%05u", val);
1703           modlist_add (modlist, "pgpKeySize", padded);
1704         }
1705     }
1706
1707   if (is_pub)
1708     {
1709       char *algo = fields[3];
1710       int val = atoi (algo);
1711       switch (val)
1712         {
1713         case 1:
1714           algo = "RSA";
1715           break;
1716
1717         case 17:
1718           algo = "DSS/DH";
1719           break;
1720
1721         default:
1722           algo = NULL;
1723           break;
1724         }
1725
1726       if (algo)
1727         modlist_add (modlist, "pgpKeyType", algo);
1728     }
1729
1730   if (is_pub || is_sub || is_sig)
1731     {
1732       if (is_pub)
1733         {
1734           modlist_add (modlist, "pgpCertID", keyid);
1735           modlist_add (modlist, "pgpKeyID", &keyid[8]);
1736         }
1737
1738       if (is_sub)
1739         modlist_add (modlist, "pgpSubKeyID", keyid);
1740
1741       if (is_sig)
1742         modlist_add (modlist, "pgpSignerID", keyid);
1743     }
1744
1745   if (is_pub)
1746     {
1747       char *create_time = fields[5];
1748
1749       if (strlen (create_time) == 0)
1750         create_time = NULL;
1751       else
1752         {
1753           char *create_time_orig = create_time;
1754           struct tm tm;
1755           time_t t;
1756           char *end;
1757
1758           memset (&tm, 0, sizeof (tm));
1759
1760           /* parse_timestamp handles both seconds fromt he epoch and
1761              ISO 8601 format.  We also need to handle YYYY-MM-DD
1762              format (as generated by gpg1 --with-colons --list-key).
1763              Check that first and then if it fails, then try
1764              parse_timestamp.  */
1765
1766           if (!isodate_human_to_tm (create_time, &tm))
1767             create_time = tm2ldaptime (&tm);
1768           else if ((t = parse_timestamp (create_time, &end)) != (time_t) -1
1769                    && *end == '\0')
1770             {
1771
1772               if (!gnupg_gmtime (&t, &tm))
1773                 create_time = NULL;
1774               else
1775                 create_time = tm2ldaptime (&tm);
1776             }
1777           else
1778             create_time = NULL;
1779
1780           if (! create_time)
1781             /* Failed to parse string.  */
1782             log_error ("Failed to parse creation time ('%s')",
1783                        create_time_orig);
1784         }
1785
1786       if (create_time)
1787         {
1788           modlist_add (modlist, "pgpKeyCreateTime", create_time);
1789           xfree (create_time);
1790         }
1791     }
1792
1793   if (is_pub)
1794     {
1795       char *expire_time = fields[6];
1796
1797       if (strlen (expire_time) == 0)
1798         expire_time = NULL;
1799       else
1800         {
1801           char *expire_time_orig = expire_time;
1802           struct tm tm;
1803           time_t t;
1804           char *end;
1805
1806           memset (&tm, 0, sizeof (tm));
1807
1808           /* parse_timestamp handles both seconds fromt he epoch and
1809              ISO 8601 format.  We also need to handle YYYY-MM-DD
1810              format (as generated by gpg1 --with-colons --list-key).
1811              Check that first and then if it fails, then try
1812              parse_timestamp.  */
1813
1814           if (!isodate_human_to_tm (expire_time, &tm))
1815             expire_time = tm2ldaptime (&tm);
1816           else if ((t = parse_timestamp (expire_time, &end)) != (time_t) -1
1817                    && *end == '\0')
1818             {
1819               if (!gnupg_gmtime (&t, &tm))
1820                 expire_time = NULL;
1821               else
1822                 expire_time = tm2ldaptime (&tm);
1823             }
1824           else
1825             expire_time = NULL;
1826
1827           if (! expire_time)
1828             /* Failed to parse string.  */
1829             log_error ("Failed to parse creation time ('%s')",
1830                        expire_time_orig);
1831         }
1832
1833       if (expire_time)
1834         {
1835           modlist_add (modlist, "pgpKeyExpireTime", expire_time);
1836           xfree (expire_time);
1837         }
1838     }
1839
1840   if ((is_uid || is_pub) && field_count >= 10)
1841     {
1842       char *uid = fields[9];
1843
1844       if (is_pub && strlen (uid) == 0)
1845         /* When using gpg --list-keys, the uid is included.  When
1846            passed via gpg, it is not.  It is important to process it
1847            when it is present, because gpg 1 won't print a UID record
1848            if there is only one key.  */
1849         ;
1850       else
1851         {
1852           uncescape (uid);
1853           modlist_add (modlist, "pgpUserID", uid);
1854         }
1855     }
1856
1857  out:
1858   free (fields);
1859 }
1860
1861 /* Send the key in {KEY,KEYLEN} with the metadata {INFO,INFOLEN} to
1862    the keyserver identified by URI.  See server.c:cmd_ks_put for the
1863    format of the data and metadata.  */
1864 gpg_error_t
1865 ks_ldap_put (ctrl_t ctrl, parsed_uri_t uri,
1866              void *data, size_t datalen,
1867              void *info, size_t infolen)
1868 {
1869   gpg_error_t err = 0;
1870   int ldap_err;
1871
1872   LDAP *ldap_conn = NULL;
1873   char *basedn = NULL;
1874   char *pgpkeyattr = NULL;
1875   int real_ldap;
1876
1877   LDAPMod **modlist = NULL;
1878   LDAPMod **addlist = NULL;
1879
1880   char *data_armored = NULL;
1881
1882   /* The last byte of the info block.  */
1883   const char *infoend = (const char *) info + infolen - 1;
1884
1885   /* Enable this code to dump the modlist to /tmp/modlist.txt.  */
1886 #if 0
1887 # warning Disable debug code before checking in.
1888   const int dump_modlist = 1;
1889 #else
1890   const int dump_modlist = 0;
1891 #endif
1892   estream_t dump = NULL;
1893
1894   /* Elide a warning.  */
1895   (void) ctrl;
1896
1897   if (dirmngr_use_tor ())
1898     {
1899       /* For now we do not support LDAP over Tor.  */
1900       log_error (_("LDAP access not possible due to Tor mode\n"));
1901       return gpg_error (GPG_ERR_NOT_SUPPORTED);
1902     }
1903
1904   ldap_err = my_ldap_connect (uri,
1905                               &ldap_conn, &basedn, &pgpkeyattr, &real_ldap);
1906   if (ldap_err || !basedn)
1907     {
1908       if (ldap_err)
1909         err = ldap_err_to_gpg_err (ldap_err);
1910       else
1911         err = GPG_ERR_GENERAL;
1912       goto out;
1913     }
1914
1915   if (! real_ldap)
1916     /* We appear to have an OpenPGP Keyserver, which can unpack the key
1917        on its own (not just a dumb LDAP server).  */
1918     {
1919       LDAPMod mod, *attrs[2];
1920       char *key[] = { data, NULL };
1921       char *dn;
1922
1923       memset (&mod, 0, sizeof (mod));
1924       mod.mod_op = LDAP_MOD_ADD;
1925       mod.mod_type = pgpkeyattr;
1926       mod.mod_values = key;
1927       attrs[0] = &mod;
1928       attrs[1] = NULL;
1929
1930       dn = xasprintf ("pgpCertid=virtual,%s", basedn);
1931       ldap_err = ldap_add_s (ldap_conn, dn, attrs);
1932       xfree (dn);
1933
1934       if (ldap_err != LDAP_SUCCESS)
1935         {
1936           err = ldap_err_to_gpg_err (err);
1937           goto out;
1938         }
1939
1940       goto out;
1941     }
1942
1943   modlist = xmalloc (sizeof (LDAPMod *));
1944   *modlist = NULL;
1945
1946   if (dump_modlist)
1947     {
1948       dump = es_fopen("/tmp/modlist.txt", "w");
1949       if (! dump)
1950         log_error ("Failed to open /tmp/modlist.txt: %s\n",
1951                    strerror (errno));
1952
1953       if (dump)
1954         {
1955           es_fprintf(dump, "data (%zd bytes)\n", datalen);
1956           es_fprintf(dump, "info (%zd bytes): '\n", infolen);
1957           es_fwrite(info, infolen, 1, dump);
1958           es_fprintf(dump, "'\n");
1959         }
1960     }
1961
1962   /* Start by nulling out all attributes.  We try and do a modify
1963      operation first, so this ensures that we don't leave old
1964      attributes lying around. */
1965   modlist_add (&modlist, "pgpDisabled", NULL);
1966   modlist_add (&modlist, "pgpKeyID", NULL);
1967   modlist_add (&modlist, "pgpKeyType", NULL);
1968   modlist_add (&modlist, "pgpUserID", NULL);
1969   modlist_add (&modlist, "pgpKeyCreateTime", NULL);
1970   modlist_add (&modlist, "pgpSignerID", NULL);
1971   modlist_add (&modlist, "pgpRevoked", NULL);
1972   modlist_add (&modlist, "pgpSubKeyID", NULL);
1973   modlist_add (&modlist, "pgpKeySize", NULL);
1974   modlist_add (&modlist, "pgpKeyExpireTime", NULL);
1975   modlist_add (&modlist, "pgpCertID", NULL);
1976
1977   /* Assemble the INFO stuff into LDAP attributes */
1978
1979   while (infolen > 0)
1980     {
1981       char *temp = NULL;
1982
1983       char *newline = memchr (info, '\n', infolen);
1984       if (! newline)
1985         /* The last line is not \n terminated!  Make a copy so we can
1986            add a NUL terminator.  */
1987         {
1988           temp = xmalloc (infolen + 1);
1989           memcpy (temp, info, infolen);
1990           info = temp;
1991           newline = (char *) info + infolen;
1992         }
1993
1994       *newline = '\0';
1995
1996       extract_attributes (&modlist, info);
1997
1998       infolen = infolen - ((uintptr_t) newline - (uintptr_t) info + 1);
1999       info = newline + 1;
2000
2001       /* Sanity check.  */
2002       if (! temp)
2003         assert ((char *) info + infolen - 1 == infoend);
2004       else
2005         {
2006           assert (infolen == -1);
2007           xfree (temp);
2008         }
2009     }
2010
2011   modlist_add (&addlist, "objectClass", "pgpKeyInfo");
2012
2013   err = armor_data (&data_armored, data, datalen);
2014   if (err)
2015     goto out;
2016
2017   modlist_add (&addlist, pgpkeyattr, data_armored);
2018
2019   /* Now append addlist onto modlist.  */
2020   modlists_join (&modlist, addlist);
2021
2022   if (dump)
2023     {
2024       estream_t input = modlist_dump (modlist, NULL);
2025       if (input)
2026         {
2027           copy_stream (input, dump);
2028           es_fclose (input);
2029         }
2030     }
2031
2032   /* Going on the assumption that modify operations are more frequent
2033      than adds, we try a modify first.  If it's not there, we just
2034      turn around and send an add command for the same key.  Otherwise,
2035      the modify brings the server copy into compliance with our copy.
2036      Note that unlike the LDAP keyserver (and really, any other
2037      keyserver) this does NOT merge signatures, but replaces the whole
2038      key.  This should make some people very happy. */
2039   {
2040     char **certid;
2041     char *dn;
2042
2043     certid = modlist_lookup (modlist, "pgpCertID");
2044     if (/* We should have a value.  */
2045         ! certid
2046         /* Exactly one.  */
2047         || !(certid[0] && !certid[1]))
2048       {
2049         log_error ("Bad certid.\n");
2050         err = GPG_ERR_GENERAL;
2051         goto out;
2052       }
2053
2054     dn = xasprintf ("pgpCertID=%s,%s", certid[0], basedn);
2055
2056     err = ldap_modify_s (ldap_conn, dn, modlist);
2057     if (err == LDAP_NO_SUCH_OBJECT)
2058       err = ldap_add_s (ldap_conn, dn, addlist);
2059
2060     xfree (dn);
2061
2062     if (err != LDAP_SUCCESS)
2063       {
2064         log_error ("gpgkeys: error adding key to keyserver: %s\n",
2065                    ldap_err2string (err));
2066         err = ldap_err_to_gpg_err (err);
2067       }
2068   }
2069
2070  out:
2071   if (dump)
2072     es_fclose (dump);
2073
2074   if (ldap_conn)
2075     ldap_unbind (ldap_conn);
2076
2077   xfree (basedn);
2078   xfree (pgpkeyattr);
2079
2080   modlist_free (modlist);
2081   xfree (addlist);
2082
2083   xfree (data_armored);
2084
2085   return err;
2086 }