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