dirmngr: Correct indentation.
[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 unknown. */
1145                     if (atoi (vals[0]) > 0)
1146                       es_fprintf (fp, "%d", atoi (vals[0]));
1147                     ldap_value_free (vals);
1148                   }
1149
1150                 es_fputc (':', fp);
1151
1152                 /* YYYYMMDDHHmmssZ */
1153
1154                 vals = ldap_get_values (ldap_conn, each, "pgpkeycreatetime");
1155                 if(vals && strlen (vals[0]) == 15)
1156                   {
1157                     es_fprintf (fp, "%u",
1158                                 (unsigned int) ldap2epochtime(vals[0]));
1159                     ldap_value_free (vals);
1160                   }
1161
1162                 es_fputc (':', fp);
1163
1164                 vals = ldap_get_values (ldap_conn, each, "pgpkeyexpiretime");
1165                 if (vals && strlen (vals[0]) == 15)
1166                   {
1167                     es_fprintf (fp, "%u",
1168                                 (unsigned int) ldap2epochtime (vals[0]));
1169                     ldap_value_free (vals);
1170                   }
1171
1172                 es_fputc (':', fp);
1173
1174                 vals = ldap_get_values (ldap_conn, each, "pgprevoked");
1175                 if (vals)
1176                   {
1177                     if (atoi (vals[0]) == 1)
1178                       es_fprintf (fp, "r");
1179                     ldap_value_free (vals);
1180                   }
1181
1182                 vals = ldap_get_values (ldap_conn, each, "pgpdisabled");
1183                 if (vals)
1184                   {
1185                     if (atoi (vals[0]) ==1)
1186                       es_fprintf (fp, "d");
1187                     ldap_value_free (vals);
1188                   }
1189
1190 #if 0
1191                 /* This is not yet specified in the keyserver
1192                    protocol, but may be someday. */
1193                 es_fputc (':', fp);
1194
1195                 vals = ldap_get_values (ldap_conn, each, "modifytimestamp");
1196                 if(vals && strlen (vals[0]) == 15)
1197                   {
1198                     es_fprintf (fp, "%u",
1199                                 (unsigned int) ldap2epochtime (vals[0]));
1200                     ldap_value_free (vals);
1201                   }
1202 #endif
1203
1204                 es_fprintf (fp, "\n");
1205
1206                 /* Now print all the uids that have this certid */
1207                 for (uids = ldap_first_entry (ldap_conn, res);
1208                      uids;
1209                      uids = ldap_next_entry (ldap_conn, uids))
1210                   {
1211                     vals = ldap_get_values (ldap_conn, uids, "pgpcertid");
1212                     if (! vals)
1213                       continue;
1214
1215                     if (strcasecmp (certid[0], vals[0]) == 0)
1216                       {
1217                         char **uidvals;
1218
1219                         es_fprintf (fp, "uid:");
1220
1221                         uidvals = ldap_get_values (ldap_conn,
1222                                                    uids, "pgpuserid");
1223                         if (uidvals)
1224                           {
1225                             /* Need to escape any colons */
1226                             char *quoted = percent_escape (uidvals[0], NULL);
1227                             es_fputs (quoted, fp);
1228                             xfree (quoted);
1229                             ldap_value_free (uidvals);
1230                           }
1231
1232                         es_fprintf (fp, "\n");
1233                       }
1234
1235                     ldap_value_free(vals);
1236                   }
1237               }
1238
1239               ldap_value_free (certid);
1240           }
1241       }
1242
1243     ldap_msgfree (res);
1244     free_strlist (dupelist);
1245   }
1246
1247   log_debug ("SEARCH %s END\n", pattern);
1248
1249  out:
1250   if (err)
1251     {
1252       if (fp)
1253         es_fclose (fp);
1254     }
1255   else
1256     {
1257       /* Return the read stream.  */
1258       if (fp)
1259         es_fseek (fp, 0, SEEK_SET);
1260
1261       *r_fp = fp;
1262     }
1263
1264   xfree (basedn);
1265
1266   if (ldap_conn)
1267     ldap_unbind (ldap_conn);
1268
1269   xfree (filter);
1270
1271   return err;
1272 }
1273
1274
1275 \f
1276 /* A modlist describes a set of changes to an LDAP entry.  (An entry
1277    consists of 1 or more attributes.  Attributes are <name, value>
1278    pairs.  Note: an attribute may be multi-valued in which case
1279    multiple values are associated with a single name.)
1280
1281    A modlist is a NULL terminated array of struct LDAPMod's.
1282
1283    Thus, if we have:
1284
1285      LDAPMod **modlist;
1286
1287    Then:
1288
1289      modlist[i]
1290
1291    Is the ith modification.
1292
1293    Each LDAPMod describes a change to a single attribute.  Further,
1294    there is one modification for each attribute that we want to
1295    change.  The attribute's new value is stored in LDAPMod.mod_values.
1296    If the attribute is multi-valued, we still only use a single
1297    LDAPMod structure: mod_values is a NULL-terminated array of
1298    strings.  To delete an attribute from an entry, we set mod_values
1299    to NULL.
1300
1301    Thus, if:
1302
1303      modlist[i]->mod_values == NULL
1304
1305    then we remove the attribute.
1306
1307    (Using LDAP_MOD_DELETE doesn't work here as we don't know if the
1308    attribute in question exists or not.)
1309
1310    Note: this function does NOT copy or free ATTR.  It does copy
1311    VALUE.  */
1312 static void
1313 modlist_add (LDAPMod ***modlistp, char *attr, const char *value)
1314 {
1315   LDAPMod **modlist = *modlistp;
1316
1317   LDAPMod **m;
1318   int nummods = 0;
1319
1320   /* Search modlist for the attribute we're playing with.  If modlist
1321      is NULL, then the list is empty.  Recall: modlist is a NULL
1322      terminated array.  */
1323   for (m = modlist; m && *m; m++, nummods ++)
1324     {
1325       /* The attribute is already on the list.  */
1326       char **ptr;
1327       int numvalues = 0;
1328
1329       if (strcasecmp ((*m)->mod_type, attr) != 0)
1330         continue;
1331
1332       /* We have this attribute already, so when the REPLACE happens,
1333          the server attributes will be replaced anyway. */
1334       if (! value)
1335         return;
1336
1337       /* Attributes can be multi-valued.  See if the value is already
1338          present.  mod_values is a NULL terminated array of pointers.
1339          Note: mod_values can be NULL.  */
1340       for (ptr = (*m)->mod_values; ptr && *ptr; ptr++)
1341         {
1342           if (strcmp (*ptr, value) == 0)
1343             /* Duplicate value, we're done.  */
1344             return;
1345           numvalues ++;
1346         }
1347
1348       /* Append the value.  */
1349       ptr = xrealloc ((*m)->mod_values, sizeof (char *) * (numvalues + 2));
1350
1351       (*m)->mod_values = ptr;
1352       ptr[numvalues] = xstrdup (value);
1353
1354       ptr[numvalues + 1] = NULL;
1355
1356       return;
1357     }
1358
1359   /* We didn't find the attr, so make one and add it to the end */
1360
1361   /* Like attribute values, the list of attributes is NULL terminated
1362      array of pointers.  */
1363   modlist = xrealloc (modlist, sizeof (LDAPMod *) * (nummods + 2));
1364
1365   *modlistp = modlist;
1366   modlist[nummods] = xmalloc (sizeof (LDAPMod));
1367
1368   modlist[nummods]->mod_op = LDAP_MOD_REPLACE;
1369   modlist[nummods]->mod_type = attr;
1370   if (value)
1371     {
1372       modlist[nummods]->mod_values = xmalloc (sizeof(char *) * 2);
1373
1374       modlist[nummods]->mod_values[0] = xstrdup (value);
1375       modlist[nummods]->mod_values[1] = NULL;
1376     }
1377   else
1378     modlist[nummods]->mod_values = NULL;
1379
1380   modlist[nummods + 1] = NULL;
1381
1382   return;
1383 }
1384
1385 /* Look up the value of an attribute in the specified modlist.  If the
1386    attribute is not on the mod list, returns NULL.  The result is a
1387    NULL-terminated array of strings.  Don't change it.  */
1388 static char **
1389 modlist_lookup (LDAPMod **modlist, const char *attr)
1390 {
1391   LDAPMod **m;
1392   for (m = modlist; m && *m; m++)
1393     {
1394       if (strcasecmp ((*m)->mod_type, attr) != 0)
1395         continue;
1396
1397       return (*m)->mod_values;
1398     }
1399
1400   return NULL;
1401 }
1402
1403 /* Dump a modlist to a file.  This is useful for debugging.  */
1404 static estream_t modlist_dump (LDAPMod **modlist, estream_t output)
1405   GNUPG_GCC_A_USED;
1406
1407 static estream_t
1408 modlist_dump (LDAPMod **modlist, estream_t output)
1409 {
1410   LDAPMod **m;
1411
1412   int opened = 0;
1413
1414   if (! output)
1415     {
1416       output = es_fopenmem (0, "rw");
1417       if (!output)
1418         return NULL;
1419       opened = 1;
1420     }
1421
1422   for (m = modlist; m && *m; m++)
1423     {
1424       es_fprintf (output, "  %s:", (*m)->mod_type);
1425
1426       if (! (*m)->mod_values)
1427         es_fprintf(output, " delete.\n");
1428       else
1429         {
1430           char **ptr;
1431           int i;
1432
1433           int multi = 0;
1434           if ((*m)->mod_values[0] && (*m)->mod_values[1])
1435             /* Have at least 2.  */
1436             multi = 1;
1437
1438           if (multi)
1439             es_fprintf (output, "\n");
1440
1441           for ((ptr = (*m)->mod_values), (i = 1); ptr && *ptr; ptr++, i ++)
1442             {
1443               /* At most about 10 lines.  */
1444               const int max_len = 10 * 70;
1445               size_t value_len = strlen (*ptr);
1446               char buffer[max_len + 4];
1447               char *temp;
1448               int elided = 0;
1449               if (value_len > max_len)
1450                 {
1451                   temp = buffer;
1452                   memcpy (temp, *ptr, max_len);
1453                   temp[max_len] = temp[max_len + 1] = temp[max_len + 2] = '.';
1454                   temp[max_len + 3] = 0;
1455                   elided = 1;
1456                 }
1457               else
1458                 temp = *ptr;
1459
1460               if (multi)
1461                 es_fprintf (output, "    %d. ", i);
1462               es_fprintf (output, "`%s'", temp);
1463               if (elided)
1464                 es_fprintf (output, " (%zd bytes elided)",
1465                             value_len - max_len);
1466               es_fprintf (output, "\n");
1467             }
1468         }
1469     }
1470
1471   if (opened)
1472     es_fseek (output, 0, SEEK_SET);
1473
1474   return output;
1475 }
1476
1477 /* Free all of the memory allocated by the mod list.  This assumes
1478    that the attribute names don't have to be freed, but the attributes
1479    values do.  (Which is what modlist_add does.)  */
1480 static void
1481 modlist_free (LDAPMod **modlist)
1482 {
1483   LDAPMod **ml;
1484
1485   if (! modlist)
1486     return;
1487
1488   /* Unwind and free the whole modlist structure */
1489
1490   /* The modlist is a NULL terminated array of pointers.  */
1491   for (ml = modlist; *ml; ml++)
1492     {
1493       LDAPMod *mod = *ml;
1494       char **ptr;
1495
1496       /* The list of values is a NULL termianted array of pointers.
1497          If the list is NULL, there are no values.  */
1498
1499       if (mod->mod_values)
1500         {
1501           for (ptr = mod->mod_values; *ptr; ptr++)
1502             xfree (*ptr);
1503
1504           xfree (mod->mod_values);
1505         }
1506
1507       xfree (mod);
1508     }
1509   xfree (modlist);
1510 }
1511
1512 /* Append two onto the end of one.  Two is not freed, but its pointers
1513    are now part of one.  Make sure you don't free them both!
1514
1515    As long as you don't add anything to ONE, TWO is still valid.
1516    After that all bets are off.  */
1517 static void
1518 modlists_join (LDAPMod ***one, LDAPMod **two)
1519 {
1520   int i, one_count = 0, two_count = 0;
1521   LDAPMod **grow;
1522
1523   if (!*two)
1524     /* two is empty.  Nothing to do.  */
1525     return;
1526
1527   if (!*one)
1528     /* one is empty.  Just set it equal to *two.  */
1529     {
1530       *one = two;
1531       return;
1532     }
1533
1534   for (grow = *one; *grow; grow++)
1535     one_count ++;
1536
1537   for (grow = two; *grow; grow++)
1538     two_count ++;
1539
1540   grow = xrealloc (*one, sizeof(LDAPMod *) * (one_count + two_count + 1));
1541
1542   for (i = 0; i < two_count; i++)
1543     grow[one_count + i] = two[i];
1544
1545   grow[one_count + i] = NULL;
1546
1547   *one = grow;
1548 }
1549
1550 /* Given a string, unescape C escapes.  In particular, \xXX.  This
1551    modifies the string in place.  */
1552 static void
1553 uncescape (char *str)
1554 {
1555   size_t r = 0;
1556   size_t w = 0;
1557
1558   char *first = strchr (str, '\\');
1559   if (! first)
1560     /* No backslashes => no escaping.  We're done.  */
1561     return;
1562
1563   /* Start at the first '\\'.  */
1564   r = w = (uintptr_t) first - (uintptr_t) str;
1565
1566   while (str[r])
1567     {
1568       /* XXX: What to do about bad escapes?
1569          XXX: hextobyte already checks the string thus the hexdigitp
1570          could be removed. */
1571       if (str[r] == '\\' && str[r + 1] == 'x'
1572           && str[r+2] && str[r+3]
1573           && hexdigitp (str + r + 2)
1574           && hexdigitp (str + r + 3))
1575         {
1576           int x = hextobyte (&str[r + 2]);
1577           assert (0 <= x && x <= 0xff);
1578
1579           str[w] = x;
1580
1581           /* We consumed 4 characters and wrote 1.  */
1582           r += 4;
1583           w ++;
1584         }
1585       else
1586         str[w ++] = str[r ++];
1587     }
1588
1589   str[w] = '\0';
1590 }
1591
1592 /* Given one line from an info block (`gpg --list-{keys,sigs}
1593    --with-colons KEYID'), pull it apart and fill in the modlist with
1594    the relevant (for the LDAP schema) attributes.  */
1595 static void
1596 extract_attributes (LDAPMod ***modlist, char *line)
1597 {
1598   int field_count;
1599   char **fields;
1600
1601   char *keyid;
1602
1603   int is_pub, is_sub, is_uid, is_sig;
1604
1605   /* Remove trailing whitespace */
1606   trim_trailing_spaces (line);
1607
1608   fields = strsplit (line, ':', '\0', &field_count);
1609   if (field_count == 1)
1610     /* We only have a single field.  There is definately nothing to
1611        do.  */
1612     goto out;
1613
1614   if (field_count < 7)
1615     goto out;
1616
1617   is_pub = strcasecmp ("pub", fields[0]) == 0;
1618   is_sub = strcasecmp ("sub", fields[0]) == 0;
1619   is_uid = strcasecmp ("uid", fields[0]) == 0;
1620   is_sig = strcasecmp ("sig", fields[0]) == 0;
1621
1622   if (!is_pub && !is_sub && !is_uid && !is_sig)
1623     /* Not a relevant line.  */
1624     goto out;
1625
1626   keyid = fields[4];
1627
1628   if (is_uid && strlen (keyid) == 0)
1629     /* The uid record type can have an empty keyid.  */
1630     ;
1631   else if (strlen (keyid) == 16
1632            && strspn (keyid, "0123456789aAbBcCdDeEfF") == 16)
1633     /* Otherwise, we expect exactly 16 hex characters.  */
1634     ;
1635   else
1636     {
1637       log_error ("malformed record!\n");
1638       goto out;
1639     }
1640
1641   if (is_pub)
1642     {
1643       int disabled = 0;
1644       int revoked = 0;
1645       char *flags;
1646       for (flags = fields[1]; *flags; flags ++)
1647         switch (*flags)
1648           {
1649           case 'r':
1650           case 'R':
1651             revoked = 1;
1652             break;
1653
1654           case 'd':
1655           case 'D':
1656             disabled = 1;
1657             break;
1658           }
1659
1660       /* Note: we always create the pgpDisabled and pgpRevoked
1661         attributes, regardless of whether the key is disabled/revoked
1662         or not.  This is because a very common search is like
1663         "(&(pgpUserID=*isabella*)(pgpDisabled=0))"  */
1664
1665       if (is_pub)
1666         {
1667           modlist_add (modlist,"pgpDisabled", disabled ? "1" : "0");
1668           modlist_add (modlist,"pgpRevoked", revoked ? "1" : "0");
1669         }
1670     }
1671
1672   if (is_pub || is_sub)
1673     {
1674       char *size = fields[2];
1675       int val = atoi (size);
1676       size = NULL;
1677
1678       if (val > 0)
1679         {
1680           /* We zero pad this on the left to make PGP happy. */
1681           char padded[6];
1682           if (val < 99999 && val > 0)
1683             {
1684               snprintf (padded, sizeof padded, "%05u", val);
1685               size = padded;
1686             }
1687         }
1688
1689       if (size)
1690         {
1691           if (is_pub || is_sub)
1692             modlist_add (modlist, "pgpKeySize", size);
1693         }
1694     }
1695
1696   if (is_pub)
1697     {
1698       char *algo = fields[3];
1699       int val = atoi (algo);
1700       switch (val)
1701         {
1702         case 1:
1703           algo = "RSA";
1704           break;
1705
1706         case 17:
1707           algo = "DSS/DH";
1708           break;
1709
1710         default:
1711           algo = NULL;
1712           break;
1713         }
1714
1715       if (algo)
1716         {
1717           if (is_pub)
1718             modlist_add (modlist, "pgpKeyType", algo);
1719         }
1720     }
1721
1722   if (is_pub || is_sub || is_sig)
1723     {
1724       if (is_pub)
1725         {
1726           modlist_add (modlist, "pgpCertID", keyid);
1727           modlist_add (modlist, "pgpKeyID", &keyid[8]);
1728         }
1729
1730       if (is_sub)
1731         modlist_add (modlist, "pgpSubKeyID", keyid);
1732
1733       if (is_sig)
1734         modlist_add (modlist, "pgpSignerID", keyid);
1735     }
1736
1737   if (is_pub)
1738     {
1739       char *create_time = fields[5];
1740
1741       if (strlen (create_time) == 0)
1742         create_time = NULL;
1743       else
1744         {
1745           char *create_time_orig = create_time;
1746           struct tm tm;
1747           time_t t;
1748           char *end;
1749
1750           memset (&tm, 0, sizeof (tm));
1751
1752           /* parse_timestamp handles both seconds fromt he epoch and
1753              ISO 8601 format.  We also need to handle YYYY-MM-DD
1754              format (as generated by gpg1 --with-colons --list-key).
1755              Check that first and then if it fails, then try
1756              parse_timestamp.  */
1757
1758           if (strptime (create_time, "%Y-%m-%d", &tm))
1759             create_time = tm2ldaptime (&tm);
1760           else if ((t = parse_timestamp (create_time, &end)) != (time_t) -1
1761                    && *end == '\0')
1762             {
1763               if (! gmtime_r (&t, &tm))
1764                 create_time = NULL;
1765               else
1766                 create_time = tm2ldaptime (&tm);
1767             }
1768           else
1769             create_time = NULL;
1770
1771           if (! create_time)
1772             /* Failed to parse string.  */
1773             log_error ("Failed to parse creation time ('%s')",
1774                        create_time_orig);
1775         }
1776
1777       if (create_time)
1778         {
1779           modlist_add (modlist, "pgpKeyCreateTime", create_time);
1780           xfree (create_time);
1781         }
1782     }
1783
1784   if (is_pub)
1785     {
1786       char *expire_time = fields[6];
1787
1788       if (strlen (expire_time) == 0)
1789         expire_time = NULL;
1790       else
1791         {
1792           char *expire_time_orig = expire_time;
1793           struct tm tm;
1794           time_t t;
1795           char *end;
1796
1797           memset (&tm, 0, sizeof (tm));
1798
1799           /* parse_timestamp handles both seconds fromt he epoch and
1800              ISO 8601 format.  We also need to handle YYYY-MM-DD
1801              format (as generated by gpg1 --with-colons --list-key).
1802              Check that first and then if it fails, then try
1803              parse_timestamp.  */
1804
1805           if (strptime (expire_time, "%Y-%m-%d", &tm))
1806             expire_time = tm2ldaptime (&tm);
1807           else if ((t = parse_timestamp (expire_time, &end)) != (time_t) -1
1808                    && *end == '\0')
1809             {
1810               if (! gmtime_r (&t, &tm))
1811                 expire_time = NULL;
1812               else
1813                 expire_time = tm2ldaptime (&tm);
1814             }
1815           else
1816             expire_time = NULL;
1817
1818           if (! expire_time)
1819             /* Failed to parse string.  */
1820             log_error ("Failed to parse creation time ('%s')",
1821                        expire_time_orig);
1822         }
1823
1824       if (expire_time)
1825         {
1826           modlist_add (modlist, "pgpKeyExpireTime", expire_time);
1827           xfree (expire_time);
1828         }
1829     }
1830
1831   if ((is_uid || is_pub) && field_count >= 10)
1832     {
1833       char *uid = fields[9];
1834
1835       if (is_pub && strlen (uid) == 0)
1836         /* When using gpg --list-keys, the uid is included.  When
1837            passed via gpg, it is not.  It is important to process it
1838            when it is present, because gpg 1 won't print a UID record
1839            if there is only one key.  */
1840         ;
1841       else
1842         {
1843           uncescape (uid);
1844           modlist_add (modlist, "pgpUserID", uid);
1845         }
1846     }
1847
1848  out:
1849   free (fields);
1850 }
1851
1852 /* Send the key in {KEY,KEYLEN} with the metadata {INFO,INFOLEN} to
1853    the keyserver identified by URI.  See server.c:cmd_ks_put for the
1854    format of the data and metadata.  */
1855 gpg_error_t
1856 ks_ldap_put (ctrl_t ctrl, parsed_uri_t uri,
1857              void *data, size_t datalen,
1858              void *info, size_t infolen)
1859 {
1860   gpg_error_t err = 0;
1861   int ldap_err;
1862
1863   LDAP *ldap_conn = NULL;
1864   char *basedn = NULL;
1865   char *pgpkeyattr = NULL;
1866   int real_ldap;
1867
1868   LDAPMod **modlist = NULL;
1869   LDAPMod **addlist = NULL;
1870
1871   char *data_armored = NULL;
1872
1873   /* The last byte of the info block.  */
1874   const char *infoend = (const char *) info + infolen - 1;
1875
1876   /* Enable this code to dump the modlist to /tmp/modlist.txt.  */
1877 #if 0
1878 # warning Disable debug code before checking in.
1879   const int dump_modlist = 1;
1880 #else
1881   const int dump_modlist = 0;
1882 #endif
1883   estream_t dump = NULL;
1884
1885   /* Elide a warning.  */
1886   (void) ctrl;
1887
1888   ldap_err = ldap_connect (uri, &ldap_conn, &basedn, &pgpkeyattr, &real_ldap);
1889   if (ldap_err || !basedn)
1890     {
1891       if (ldap_err)
1892         err = ldap_err_to_gpg_err (ldap_err);
1893       else
1894         err = GPG_ERR_GENERAL;
1895       goto out;
1896     }
1897
1898   if (! real_ldap)
1899     /* We appear to have an OpenPGP Keyserver, which can unpack the key
1900        on its own (not just a dumb LDAP server).  */
1901     {
1902       LDAPMod mod, *attrs[2];
1903       char *key[] = { data, NULL };
1904       char *dn;
1905
1906       memset (&mod, 0, sizeof (mod));
1907       mod.mod_op = LDAP_MOD_ADD;
1908       mod.mod_type = pgpkeyattr;
1909       mod.mod_values = key;
1910       attrs[0] = &mod;
1911       attrs[1] = NULL;
1912
1913       dn = xasprintf ("pgpCertid=virtual,%s", basedn);
1914       ldap_err = ldap_add_s (ldap_conn, dn, attrs);
1915       xfree (dn);
1916
1917       if (ldap_err != LDAP_SUCCESS)
1918         {
1919           err = ldap_err_to_gpg_err (err);
1920           goto out;
1921         }
1922
1923       goto out;
1924     }
1925
1926   modlist = xmalloc (sizeof (LDAPMod *));
1927   *modlist = NULL;
1928
1929   if (dump_modlist)
1930     {
1931       dump = es_fopen("/tmp/modlist.txt", "w");
1932       if (! dump)
1933         log_error ("Failed to open /tmp/modlist.txt: %s\n",
1934                    strerror (errno));
1935
1936       if (dump)
1937         {
1938           es_fprintf(dump, "data (%zd bytes)\n", datalen);
1939           es_fprintf(dump, "info (%zd bytes): '\n", infolen);
1940           es_fwrite(info, infolen, 1, dump);
1941           es_fprintf(dump, "'\n");
1942         }
1943     }
1944
1945   /* Start by nulling out all attributes.  We try and do a modify
1946      operation first, so this ensures that we don't leave old
1947      attributes lying around. */
1948   modlist_add (&modlist, "pgpDisabled", NULL);
1949   modlist_add (&modlist, "pgpKeyID", NULL);
1950   modlist_add (&modlist, "pgpKeyType", NULL);
1951   modlist_add (&modlist, "pgpUserID", NULL);
1952   modlist_add (&modlist, "pgpKeyCreateTime", NULL);
1953   modlist_add (&modlist, "pgpSignerID", NULL);
1954   modlist_add (&modlist, "pgpRevoked", NULL);
1955   modlist_add (&modlist, "pgpSubKeyID", NULL);
1956   modlist_add (&modlist, "pgpKeySize", NULL);
1957   modlist_add (&modlist, "pgpKeyExpireTime", NULL);
1958   modlist_add (&modlist, "pgpCertID", NULL);
1959
1960   /* Assemble the INFO stuff into LDAP attributes */
1961
1962   while (infolen > 0)
1963     {
1964       char *temp = NULL;
1965
1966       char *newline = memchr (info, '\n', infolen);
1967       if (! newline)
1968         /* The last line is not \n terminated!  Make a copy so we can
1969            add a NUL terminator.  */
1970         {
1971           temp = alloca (infolen + 1);
1972           memcpy (temp, info, infolen);
1973           info = temp;
1974           newline = (char *) info + infolen;
1975         }
1976
1977       *newline = '\0';
1978
1979       extract_attributes (&modlist, info);
1980
1981       infolen = infolen - ((uintptr_t) newline - (uintptr_t) info + 1);
1982       info = newline + 1;
1983
1984       /* Sanity check.  */
1985       if (! temp)
1986         assert ((char *) info + infolen - 1 == infoend);
1987       else
1988         assert (infolen == -1);
1989     }
1990
1991   modlist_add (&addlist, "objectClass", "pgpKeyInfo");
1992
1993   err = armor_data (&data_armored, data, datalen);
1994   if (err)
1995     goto out;
1996
1997   modlist_add (&addlist, pgpkeyattr, data_armored);
1998
1999   /* Now append addlist onto modlist.  */
2000   modlists_join (&modlist, addlist);
2001
2002   if (dump)
2003     {
2004       estream_t input = modlist_dump (modlist, NULL);
2005       if (input)
2006         {
2007           copy_stream (input, dump);
2008           es_fclose (input);
2009         }
2010     }
2011
2012   /* Going on the assumption that modify operations are more frequent
2013      than adds, we try a modify first.  If it's not there, we just
2014      turn around and send an add command for the same key.  Otherwise,
2015      the modify brings the server copy into compliance with our copy.
2016      Note that unlike the LDAP keyserver (and really, any other
2017      keyserver) this does NOT merge signatures, but replaces the whole
2018      key.  This should make some people very happy. */
2019   {
2020     char **certid;
2021     char *dn;
2022
2023     certid = modlist_lookup (modlist, "pgpCertID");
2024     if (/* We should have a value.  */
2025         ! certid
2026         /* Exactly one.  */
2027         || !(certid[0] && !certid[1]))
2028       {
2029         log_error ("Bad certid.\n");
2030         err = GPG_ERR_GENERAL;
2031         goto out;
2032       }
2033
2034     dn = xasprintf ("pgpCertID=%s,%s", certid[0], basedn);
2035
2036     err = ldap_modify_s (ldap_conn, dn, modlist);
2037     if (err == LDAP_NO_SUCH_OBJECT)
2038       err = ldap_add_s (ldap_conn, dn, addlist);
2039
2040     xfree (dn);
2041
2042     if (err != LDAP_SUCCESS)
2043       {
2044         log_error ("gpgkeys: error adding key to keyserver: %s\n",
2045                    ldap_err2string (err));
2046         err = ldap_err_to_gpg_err (err);
2047       }
2048   }
2049
2050  out:
2051   if (dump)
2052     es_fclose (dump);
2053
2054   if (ldap_conn)
2055     ldap_unbind (ldap_conn);
2056
2057   xfree (basedn);
2058   xfree (pgpkeyattr);
2059
2060   modlist_free (modlist);
2061   xfree (addlist);
2062
2063   xfree (data_armored);
2064
2065   return err;
2066 }