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