gpg: Set a limit for a WKD import of 256 KiB.
[gnupg.git] / g10 / call-dirmngr.c
1 /* call-dirmngr.c - GPG operations to the Dirmngr.
2  * Copyright (C) 2011 Free Software Foundation, Inc.
3  * Copyright (C) 2015  g10 Code GmbH
4  *
5  * This file is part of GnuPG.
6  *
7  * GnuPG is free software; you can redistribute it and/or modify
8  * it under the terms of the GNU General Public License as published by
9  * the Free Software Foundation; either version 3 of the License, or
10  * (at your option) any later version.
11  *
12  * GnuPG is distributed in the hope that it will be useful,
13  * but WITHOUT ANY WARRANTY; without even the implied warranty of
14  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
15  * GNU General Public License for more details.
16  *
17  * You should have received a copy of the GNU General Public License
18  * along with this program; if not, see <https://www.gnu.org/licenses/>.
19  */
20
21 #include <config.h>
22 #include <stdio.h>
23 #include <stdlib.h>
24 #include <string.h>
25 #include <errno.h>
26 #include <unistd.h>
27 #include <time.h>
28 #ifdef HAVE_LOCALE_H
29 # include <locale.h>
30 #endif
31
32 #include "gpg.h"
33 #include <assuan.h>
34 #include "../common/util.h"
35 #include "../common/membuf.h"
36 #include "options.h"
37 #include "../common/i18n.h"
38 #include "../common/asshelp.h"
39 #include "../common/keyserver.h"
40 #include "../common/status.h"
41 #include "call-dirmngr.h"
42
43
44 /* Keys retrieved from the web key directory should be small.  There
45  * is only one UID and we can expect that the number of subkeys is
46  * reasonable.  So we set a generous limit of 256 KiB.  */
47 #define MAX_WKD_RESULT_LENGTH   (256 * 1024)
48
49
50 /* Parameter structure used to gather status info.  Note that it is
51  * also used for WKD requests.  */
52 struct ks_status_parm_s
53 {
54   const char *keyword; /* Look for this keyword or NULL for "SOURCE". */
55   char *source;
56 };
57
58
59 /* Parameter structure used with the KS_SEARCH command.  */
60 struct ks_search_parm_s
61 {
62   gpg_error_t lasterr;  /* Last error code.  */
63   membuf_t saveddata;   /* Buffer to build complete lines.  */
64   char *helpbuf;        /* NULL or malloced buffer.  */
65   size_t helpbufsize;   /* Allocated size of HELPBUF.  */
66   gpg_error_t (*data_cb)(void*, int, char*);  /* Callback.  */
67   void *data_cb_value;  /* First argument for DATA_CB.  */
68   struct ks_status_parm_s *stparm; /* Link to the status parameter.  */
69 };
70
71
72 /* Parameter structure used with the KS_GET command.  */
73 struct ks_get_parm_s
74 {
75   estream_t memfp;
76 };
77
78
79 /* Parameter structure used with the KS_PUT command.  */
80 struct ks_put_parm_s
81 {
82   assuan_context_t ctx;
83   kbnode_t keyblock;  /* The optional keyblock.  */
84   const void *data;   /* The key in OpenPGP binary format.  */
85   size_t datalen;     /* The length of DATA.  */
86 };
87
88
89 /* Parameter structure used with the DNS_CERT command.  */
90 struct dns_cert_parm_s
91 {
92   estream_t memfp;
93   unsigned char *fpr;
94   size_t fprlen;
95   char *url;
96 };
97
98
99 /* Data used to associate an session with dirmngr contexts.  We can't
100    use a simple one to one mapping because we sometimes need two
101    connections to the dirmngr; for example while doing a listing and
102    being in a data callback we may want to retrieve a key.  The local
103    dirmngr data takes care of this.  At the end of the session the
104    function dirmngr_deinit_session_data is called by gpg.c to cleanup
105    these resources.  Note that gpg.h defines a typedef dirmngr_local_t
106    for this structure. */
107 struct dirmngr_local_s
108 {
109   /* Link to other contexts which are used simultaneously.  */
110   struct dirmngr_local_s *next;
111
112   /* The active Assuan context. */
113   assuan_context_t ctx;
114
115   /* Flag set when the keyserver names have been send.  */
116   int set_keyservers_done;
117
118   /* Flag set to true while an operation is running on CTX.  */
119   int is_active;
120 };
121
122
123 \f
124 /* Deinitialize all session data of dirmngr pertaining to CTRL.  */
125 void
126 gpg_dirmngr_deinit_session_data (ctrl_t ctrl)
127 {
128   dirmngr_local_t dml;
129
130   while ((dml = ctrl->dirmngr_local))
131     {
132       ctrl->dirmngr_local = dml->next;
133       if (dml->is_active)
134         log_error ("oops: trying to cleanup an active dirmngr context\n");
135       else
136         assuan_release (dml->ctx);
137       xfree (dml);
138     }
139 }
140
141
142 /* Print a warning if the server's version number is less than our
143    version number.  Returns an error code on a connection problem.  */
144 static gpg_error_t
145 warn_version_mismatch (assuan_context_t ctx, const char *servername)
146 {
147   gpg_error_t err;
148   char *serverversion;
149   const char *myversion = strusage (13);
150
151   err = get_assuan_server_version (ctx, 0, &serverversion);
152   if (err)
153     log_error (_("error getting version from '%s': %s\n"),
154                servername, gpg_strerror (err));
155   else if (compare_version_strings (serverversion, myversion) < 0)
156     {
157       char *warn;
158
159       warn = xtryasprintf (_("server '%s' is older than us (%s < %s)"),
160                            servername, serverversion, myversion);
161       if (!warn)
162         err = gpg_error_from_syserror ();
163       else
164         {
165           log_info (_("WARNING: %s\n"), warn);
166           if (!opt.quiet)
167             {
168               log_info (_("Note: Outdated servers may lack important"
169                           " security fixes.\n"));
170               log_info (_("Note: Use the command \"%s\" to restart them.\n"),
171                         "gpgconf --kill all");
172             }
173
174           write_status_strings (STATUS_WARNING, "server_version_mismatch 0",
175                                 " ", warn, NULL);
176           xfree (warn);
177         }
178     }
179   xfree (serverversion);
180   return err;
181 }
182
183
184 /* Try to connect to the Dirmngr via a socket or spawn it if possible.
185    Handle the server's initial greeting and set global options.  */
186 static gpg_error_t
187 create_context (ctrl_t ctrl, assuan_context_t *r_ctx)
188 {
189   gpg_error_t err;
190   assuan_context_t ctx;
191
192   *r_ctx = NULL;
193
194   if (opt.disable_dirmngr)
195     return gpg_error (GPG_ERR_NO_DIRMNGR);
196
197   err = start_new_dirmngr (&ctx,
198                            GPG_ERR_SOURCE_DEFAULT,
199                            opt.dirmngr_program,
200                            opt.autostart, opt.verbose, DBG_IPC,
201                            NULL /*gpg_status2*/, ctrl);
202   if (!opt.autostart && gpg_err_code (err) == GPG_ERR_NO_DIRMNGR)
203     {
204       static int shown;
205
206       if (!shown)
207         {
208           shown = 1;
209           log_info (_("no dirmngr running in this session\n"));
210         }
211     }
212   else if (!err && !(err = warn_version_mismatch (ctx, DIRMNGR_NAME)))
213     {
214       char *line;
215
216       /* Tell the dirmngr that we want to collect audit event. */
217       /* err = assuan_transact (agent_ctx, "OPTION audit-events=1", */
218       /*                        NULL, NULL, NULL, NULL, NULL, NULL); */
219       if (opt.keyserver_options.http_proxy)
220         {
221           line = xtryasprintf ("OPTION http-proxy=%s",
222                                opt.keyserver_options.http_proxy);
223           if (!line)
224             err = gpg_error_from_syserror ();
225           else
226             {
227               err = assuan_transact (ctx, line, NULL, NULL, NULL,
228                                      NULL, NULL, NULL);
229               xfree (line);
230             }
231         }
232
233       if (err)
234         ;
235       else if ((opt.keyserver_options.options & KEYSERVER_HONOR_KEYSERVER_URL))
236         {
237           /* Tell the dirmngr that this possibly privacy invading
238              option is in use.  If Dirmngr is running in Tor mode, it
239              will return an error.  */
240           err = assuan_transact (ctx, "OPTION honor-keyserver-url-used",
241                                  NULL, NULL, NULL, NULL, NULL, NULL);
242           if (gpg_err_code (err) == GPG_ERR_FORBIDDEN)
243             log_error (_("keyserver option \"honor-keyserver-url\""
244                          " may not be used in Tor mode\n"));
245           else if (gpg_err_code (err) == GPG_ERR_UNKNOWN_OPTION)
246             err = 0; /* Old dirmngr versions do not support this option.  */
247         }
248     }
249
250   if (err)
251     assuan_release (ctx);
252   else
253     {
254       /* audit_log_ok (ctrl->audit, AUDIT_DIRMNGR_READY, err); */
255       *r_ctx = ctx;
256     }
257
258   return err;
259 }
260
261
262 /* Get a context for accessing dirmngr.  If no context is available a
263    new one is created and - if required - dirmngr started.  On success
264    an assuan context is stored at R_CTX.  This context may only be
265    released by means of close_context.  Note that NULL is stored at
266    R_CTX on error.  */
267 static gpg_error_t
268 open_context (ctrl_t ctrl, assuan_context_t *r_ctx)
269 {
270   gpg_error_t err;
271   dirmngr_local_t dml;
272
273   *r_ctx = NULL;
274   for (;;)
275     {
276       for (dml = ctrl->dirmngr_local; dml && dml->is_active; dml = dml->next)
277         ;
278       if (dml)
279         {
280           /* Found an inactive local session - return that.  */
281           log_assert (!dml->is_active);
282
283           /* But first do the per session init if not yet done.  */
284           if (!dml->set_keyservers_done)
285             {
286               keyserver_spec_t ksi;
287
288               /* Set all configured keyservers.  We clear existing
289                  keyservers so that any keyserver configured in GPG
290                  overrides keyservers possibly still configured in Dirmngr
291                  for the session (Note that the keyserver list of a
292                  session in Dirmngr survives a RESET. */
293               for (ksi = opt.keyserver; ksi; ksi = ksi->next)
294                 {
295                   char *line;
296
297                   line = xtryasprintf
298                     ("KEYSERVER%s %s",
299                      ksi == opt.keyserver? " --clear":"", ksi->uri);
300                   if (!line)
301                     err = gpg_error_from_syserror ();
302                   else
303                     {
304                       err = assuan_transact (dml->ctx, line, NULL, NULL, NULL,
305                                              NULL, NULL, NULL);
306                       xfree (line);
307                     }
308
309                   if (err)
310                     return err;
311                 }
312
313               dml->set_keyservers_done = 1;
314             }
315
316           dml->is_active = 1;
317
318           *r_ctx = dml->ctx;
319           return 0;
320         }
321
322       dml = xtrycalloc (1, sizeof *dml);
323       if (!dml)
324         return gpg_error_from_syserror ();
325       err = create_context (ctrl, &dml->ctx);
326       if (err)
327         {
328           xfree (dml);
329           return err;
330         }
331
332       /* To be on the nPth thread safe site we need to add it to a
333          list; this is far easier than to have a lock for this
334          function.  It should not happen anyway but the code is free
335          because we need it for the is_active check above.  */
336       dml->next = ctrl->dirmngr_local;
337       ctrl->dirmngr_local = dml;
338     }
339 }
340
341
342 /* Close the assuan context CTX or return it to a pool of unused
343    contexts.  If CTX is NULL, the function does nothing.  */
344 static void
345 close_context (ctrl_t ctrl, assuan_context_t ctx)
346 {
347   dirmngr_local_t dml;
348
349   if (!ctx)
350     return;
351
352   for (dml = ctrl->dirmngr_local; dml; dml = dml->next)
353     {
354       if (dml->ctx == ctx)
355         {
356           if (!dml->is_active)
357             log_fatal ("closing inactive dirmngr context %p\n", ctx);
358           dml->is_active = 0;
359           return;
360         }
361     }
362   log_fatal ("closing unknown dirmngr ctx %p\n", ctx);
363 }
364
365
366 /* Clear the set_keyservers_done flag on context CTX.  */
367 static void
368 clear_context_flags (ctrl_t ctrl, assuan_context_t ctx)
369 {
370   dirmngr_local_t dml;
371
372   if (!ctx)
373     return;
374
375   for (dml = ctrl->dirmngr_local; dml; dml = dml->next)
376     {
377       if (dml->ctx == ctx)
378         {
379           if (!dml->is_active)
380             log_fatal ("clear_context_flags on inactive dirmngr ctx %p\n", ctx);
381           dml->set_keyservers_done = 0;
382           return;
383         }
384     }
385   log_fatal ("clear_context_flags on unknown dirmngr ctx %p\n", ctx);
386 }
387
388
389 \f
390 /* Status callback for ks_list, ks_get, ks_search, and wkd_get  */
391 static gpg_error_t
392 ks_status_cb (void *opaque, const char *line)
393 {
394   struct ks_status_parm_s *parm = opaque;
395   gpg_error_t err = 0;
396   const char *s, *s2;
397   const char *warn;
398
399   if ((s = has_leading_keyword (line, parm->keyword? parm->keyword : "SOURCE")))
400     {
401       /* Note that the arg for "S SOURCE" is the URL of a keyserver.  */
402       if (!parm->source)
403         {
404           parm->source = xtrystrdup (s);
405           if (!parm->source)
406             err = gpg_error_from_syserror ();
407         }
408     }
409   else if ((s = has_leading_keyword (line, "WARNING")))
410     {
411       if ((s2 = has_leading_keyword (s, "tor_not_running")))
412         warn = _("Tor is not running");
413       else if ((s2 = has_leading_keyword (s, "tor_config_problem")))
414         warn = _("Tor is not properly configured");
415       else if ((s2 = has_leading_keyword (s, "dns_config_problem")))
416         warn = _("DNS is not properly configured");
417       else
418         warn = NULL;
419
420       if (warn)
421         {
422           log_info (_("WARNING: %s\n"), warn);
423           if (s2)
424             {
425               while (*s2 && !spacep (s2))
426                 s2++;
427               while (*s2 && spacep (s2))
428                 s2++;
429               if (*s2)
430                 print_further_info ("%s", s2);
431             }
432         }
433     }
434
435   return err;
436 }
437
438
439 \f
440 /* Run the "KEYSERVER" command to return the name of the used
441    keyserver at R_KEYSERVER.  */
442 gpg_error_t
443 gpg_dirmngr_ks_list (ctrl_t ctrl, char **r_keyserver)
444 {
445   gpg_error_t err;
446   assuan_context_t ctx;
447   struct ks_status_parm_s stparm;
448
449   memset (&stparm, 0, sizeof stparm);
450   stparm.keyword = "KEYSERVER";
451   if (r_keyserver)
452     *r_keyserver = NULL;
453
454   err = open_context (ctrl, &ctx);
455   if (err)
456     return err;
457
458   err = assuan_transact (ctx, "KEYSERVER", NULL, NULL,
459                          NULL, NULL, ks_status_cb, &stparm);
460   if (err)
461     goto leave;
462   if (!stparm.source)
463     {
464       err = gpg_error (GPG_ERR_NO_KEYSERVER);
465       goto leave;
466     }
467
468   if (r_keyserver)
469     *r_keyserver = stparm.source;
470   else
471     xfree (stparm.source);
472   stparm.source = NULL;
473
474  leave:
475   xfree (stparm.source);
476   close_context (ctrl, ctx);
477   return err;
478 }
479
480
481 \f
482 /* Data callback for the KS_SEARCH command. */
483 static gpg_error_t
484 ks_search_data_cb (void *opaque, const void *data, size_t datalen)
485 {
486   gpg_error_t err = 0;
487   struct ks_search_parm_s *parm = opaque;
488   const char *line, *s;
489   size_t rawlen, linelen;
490   char fixedbuf[256];
491
492   if (parm->lasterr)
493     return 0;
494
495   if (parm->stparm->source)
496     {
497       err = parm->data_cb (parm->data_cb_value, 1, parm->stparm->source);
498       if (err)
499         {
500           parm->lasterr = err;
501           return err;
502         }
503       /* Clear it so that we won't get back here unless the server
504          accidentally sends a second source status line.  Note that
505          will not see all accidentally sent source lines because it
506          depends on whether data lines have been send in between.  */
507       xfree (parm->stparm->source);
508       parm->stparm->source = NULL;
509     }
510
511   if (!data)
512     return 0;  /* Ignore END commands.  */
513
514   put_membuf (&parm->saveddata, data, datalen);
515
516  again:
517   line = peek_membuf (&parm->saveddata, &rawlen);
518   if (!line)
519     {
520       parm->lasterr = gpg_error_from_syserror ();
521       return parm->lasterr; /* Tell the server about our problem.  */
522     }
523   if ((s = memchr (line, '\n', rawlen)))
524     {
525       linelen = s - line;  /* That is the length excluding the LF.  */
526       if (linelen + 1 < sizeof fixedbuf)
527         {
528           /* We can use the static buffer.  */
529           memcpy (fixedbuf, line, linelen);
530           fixedbuf[linelen] = 0;
531           if (linelen && fixedbuf[linelen-1] == '\r')
532             fixedbuf[linelen-1] = 0;
533           err = parm->data_cb (parm->data_cb_value, 0, fixedbuf);
534         }
535       else
536         {
537           if (linelen + 1 >= parm->helpbufsize)
538             {
539               xfree (parm->helpbuf);
540               parm->helpbufsize = linelen + 1 + 1024;
541               parm->helpbuf = xtrymalloc (parm->helpbufsize);
542               if (!parm->helpbuf)
543                 {
544                   parm->lasterr = gpg_error_from_syserror ();
545                   return parm->lasterr;
546                 }
547             }
548           memcpy (parm->helpbuf, line, linelen);
549           parm->helpbuf[linelen] = 0;
550           if (linelen && parm->helpbuf[linelen-1] == '\r')
551             parm->helpbuf[linelen-1] = 0;
552           err = parm->data_cb (parm->data_cb_value, 0, parm->helpbuf);
553         }
554       if (err)
555         parm->lasterr = err;
556       else
557         {
558           clear_membuf (&parm->saveddata, linelen+1);
559           goto again;  /* There might be another complete line.  */
560         }
561     }
562
563   return err;
564 }
565
566
567 /* Run the KS_SEARCH command using the search string SEARCHSTR.  All
568    data lines are passed to the CB function.  That function is called
569    with CB_VALUE as its first argument, a 0 as second argument, and
570    the decoded data line as third argument.  The callback function may
571    modify the data line and it is guaranteed that this data line is a
572    complete line with a terminating 0 character but without the
573    linefeed.  NULL is passed to the callback to indicate EOF.  */
574 gpg_error_t
575 gpg_dirmngr_ks_search (ctrl_t ctrl, const char *searchstr,
576                        gpg_error_t (*cb)(void*, int, char *), void *cb_value)
577 {
578   gpg_error_t err;
579   assuan_context_t ctx;
580   struct ks_status_parm_s stparm;
581   struct ks_search_parm_s parm;
582   char line[ASSUAN_LINELENGTH];
583
584   err = open_context (ctrl, &ctx);
585   if (err)
586     return err;
587
588   {
589     char *escsearchstr = percent_plus_escape (searchstr);
590     if (!escsearchstr)
591       {
592         err = gpg_error_from_syserror ();
593         close_context (ctrl, ctx);
594         return err;
595       }
596     snprintf (line, sizeof line, "KS_SEARCH -- %s", escsearchstr);
597     xfree (escsearchstr);
598   }
599
600   memset (&stparm, 0, sizeof stparm);
601   memset (&parm, 0, sizeof parm);
602   init_membuf (&parm.saveddata, 1024);
603   parm.data_cb = cb;
604   parm.data_cb_value = cb_value;
605   parm.stparm = &stparm;
606
607   err = assuan_transact (ctx, line, ks_search_data_cb, &parm,
608                         NULL, NULL, ks_status_cb, &stparm);
609   if (!err)
610     err = cb (cb_value, 0, NULL);  /* Send EOF.  */
611
612   xfree (get_membuf (&parm.saveddata, NULL));
613   xfree (parm.helpbuf);
614   xfree (stparm.source);
615
616   close_context (ctrl, ctx);
617   return err;
618 }
619
620
621 \f
622 /* Data callback for the KS_GET and KS_FETCH commands. */
623 static gpg_error_t
624 ks_get_data_cb (void *opaque, const void *data, size_t datalen)
625 {
626   gpg_error_t err = 0;
627   struct ks_get_parm_s *parm = opaque;
628   size_t nwritten;
629
630   if (!data)
631     return 0;  /* Ignore END commands.  */
632
633   if (es_write (parm->memfp, data, datalen, &nwritten))
634     err = gpg_error_from_syserror ();
635
636   return err;
637 }
638
639
640 /* Run the KS_GET command using the patterns in the array PATTERN.  On
641    success an estream object is returned to retrieve the keys.  On
642    error an error code is returned and NULL stored at R_FP.
643
644    The pattern may only use search specification which a keyserver can
645    use to retrieve keys.  Because we know the format of the pattern we
646    don't need to escape the patterns before sending them to the
647    server.
648
649    If QUICK is set the dirmngr is advised to use a shorter timeout.
650
651    If R_SOURCE is not NULL the source of the data is stored as a
652    malloced string there.  If a source is not known NULL is stored.
653
654    If there are too many patterns the function returns an error.  That
655    could be fixed by issuing several search commands or by
656    implementing a different interface.  However with long keyids we
657    are able to ask for (1000-10-1)/(2+8+1) = 90 keys at once.  */
658 gpg_error_t
659 gpg_dirmngr_ks_get (ctrl_t ctrl, char **pattern,
660                     keyserver_spec_t override_keyserver, int quick,
661                     estream_t *r_fp, char **r_source)
662 {
663   gpg_error_t err;
664   assuan_context_t ctx;
665   struct ks_status_parm_s stparm;
666   struct ks_get_parm_s parm;
667   char *line = NULL;
668   size_t linelen;
669   membuf_t mb;
670   int idx;
671
672   memset (&stparm, 0, sizeof stparm);
673   memset (&parm, 0, sizeof parm);
674
675   *r_fp = NULL;
676   if (r_source)
677     *r_source = NULL;
678
679   err = open_context (ctrl, &ctx);
680   if (err)
681     return err;
682
683   /* If we have an override keyserver we first indicate that the next
684      user of the context needs to again setup the global keyservers and
685      them we send the override keyserver.  */
686   if (override_keyserver)
687     {
688       clear_context_flags (ctrl, ctx);
689       line = xtryasprintf ("KEYSERVER --clear %s", override_keyserver->uri);
690       if (!line)
691         {
692           err = gpg_error_from_syserror ();
693           goto leave;
694         }
695       err = assuan_transact (ctx, line, NULL, NULL, NULL,
696                              NULL, NULL, NULL);
697       if (err)
698         goto leave;
699
700       xfree (line);
701       line = NULL;
702     }
703
704   /* Lump all patterns into one string.  */
705   init_membuf (&mb, 1024);
706   put_membuf_str (&mb, quick? "KS_GET --quick --" : "KS_GET --");
707   for (idx=0; pattern[idx]; idx++)
708     {
709       put_membuf (&mb, " ", 1); /* Append Delimiter.  */
710       put_membuf_str (&mb, pattern[idx]);
711     }
712   put_membuf (&mb, "", 1); /* Append Nul.  */
713   line = get_membuf (&mb, &linelen);
714   if (!line)
715     {
716       err = gpg_error_from_syserror ();
717       goto leave;
718     }
719   if (linelen + 2 >= ASSUAN_LINELENGTH)
720     {
721       err = gpg_error (GPG_ERR_TOO_MANY);
722       goto leave;
723     }
724
725   parm.memfp = es_fopenmem (0, "rwb");
726   if (!parm.memfp)
727     {
728       err = gpg_error_from_syserror ();
729       goto leave;
730     }
731   err = assuan_transact (ctx, line, ks_get_data_cb, &parm,
732                          NULL, NULL, ks_status_cb, &stparm);
733   if (err)
734     goto leave;
735
736   es_rewind (parm.memfp);
737   *r_fp = parm.memfp;
738   parm.memfp = NULL;
739
740   if (r_source)
741     {
742       *r_source = stparm.source;
743       stparm.source = NULL;
744     }
745
746  leave:
747   es_fclose (parm.memfp);
748   xfree (stparm.source);
749   xfree (line);
750   close_context (ctrl, ctx);
751   return err;
752 }
753
754
755 /* Run the KS_FETCH and pass URL as argument.  On success an estream
756    object is returned to retrieve the keys.  On error an error code is
757    returned and NULL stored at R_FP.
758
759    The url is expected to point to a small set of keys; in many cases
760    only to one key.  However, schemes like finger may return several
761    keys.  Note that the configured keyservers are ignored by the
762    KS_FETCH command.  */
763 gpg_error_t
764 gpg_dirmngr_ks_fetch (ctrl_t ctrl, const char *url, estream_t *r_fp)
765 {
766   gpg_error_t err;
767   assuan_context_t ctx;
768   struct ks_get_parm_s parm;
769   char *line = NULL;
770
771   memset (&parm, 0, sizeof parm);
772
773   *r_fp = NULL;
774
775   err = open_context (ctrl, &ctx);
776   if (err)
777     return err;
778
779   line = strconcat ("KS_FETCH -- ", url, NULL);
780   if (!line)
781     {
782       err = gpg_error_from_syserror ();
783       goto leave;
784     }
785   if (strlen (line) + 2 >= ASSUAN_LINELENGTH)
786     {
787       err = gpg_error (GPG_ERR_TOO_LARGE);
788       goto leave;
789     }
790
791   parm.memfp = es_fopenmem (0, "rwb");
792   if (!parm.memfp)
793     {
794       err = gpg_error_from_syserror ();
795       goto leave;
796     }
797   err = assuan_transact (ctx, line, ks_get_data_cb, &parm,
798                          NULL, NULL, NULL, NULL);
799   if (err)
800     goto leave;
801
802   es_rewind (parm.memfp);
803   *r_fp = parm.memfp;
804   parm.memfp = NULL;
805
806  leave:
807   es_fclose (parm.memfp);
808   xfree (line);
809   close_context (ctrl, ctx);
810   return err;
811 }
812
813
814 \f
815 static void
816 record_output (estream_t output,
817                pkttype_t type,
818                const char *validity,
819                /* The public key length or -1.  */
820                int pub_key_length,
821                /* The public key algo or -1.  */
822                int pub_key_algo,
823                /* 2 ulongs or NULL.  */
824                const u32 *keyid,
825                /* The creation / expiration date or 0.  */
826                u32 creation_date,
827                u32 expiration_date,
828                const char *userid)
829 {
830   const char *type_str = NULL;
831   char *pub_key_length_str = NULL;
832   char *pub_key_algo_str = NULL;
833   char *keyid_str = NULL;
834   char *creation_date_str = NULL;
835   char *expiration_date_str = NULL;
836   char *userid_escaped = NULL;
837
838   switch (type)
839     {
840     case PKT_PUBLIC_KEY:
841       type_str = "pub";
842       break;
843     case PKT_PUBLIC_SUBKEY:
844       type_str = "sub";
845       break;
846     case PKT_USER_ID:
847       type_str = "uid";
848       break;
849     case PKT_SIGNATURE:
850       type_str = "sig";
851       break;
852     default:
853       log_assert (! "Unhandled type.");
854     }
855
856   if (pub_key_length > 0)
857     pub_key_length_str = xasprintf ("%d", pub_key_length);
858
859   if (pub_key_algo != -1)
860     pub_key_algo_str = xasprintf ("%d", pub_key_algo);
861
862   if (keyid)
863     keyid_str = xasprintf ("%08lX%08lX", (ulong) keyid[0], (ulong) keyid[1]);
864
865   if (creation_date)
866     creation_date_str = xstrdup (colon_strtime (creation_date));
867
868   if (expiration_date)
869     expiration_date_str = xstrdup (colon_strtime (expiration_date));
870
871   /* Quote ':', '%', and any 8-bit characters.  */
872   if (userid)
873     {
874       int r;
875       int w = 0;
876
877       int len = strlen (userid);
878       /* A 100k character limit on the uid should be way more than
879          enough.  */
880       if (len > 100 * 1024)
881         len = 100 * 1024;
882
883       /* The minimum amount of space that we need.  */
884       userid_escaped = xmalloc (len * 3 + 1);
885
886       for (r = 0; r < len; r++)
887         {
888           if (userid[r] == ':' || userid[r]== '%' || (userid[r] & 0x80))
889             {
890               sprintf (&userid_escaped[w], "%%%02X", (byte) userid[r]);
891               w += 3;
892             }
893           else
894             userid_escaped[w ++] = userid[r];
895         }
896       userid_escaped[w] = '\0';
897     }
898
899   es_fprintf (output, "%s:%s:%s:%s:%s:%s:%s:%s:%s:%s:%s:%s:%s:%s:%s:%s:%s\n",
900               type_str,
901               validity ?: "",
902               pub_key_length_str ?: "",
903               pub_key_algo_str ?: "",
904               keyid_str ?: "",
905               creation_date_str ?: "",
906               expiration_date_str ?: "",
907               "" /* Certificate S/N */,
908               "" /* Ownertrust.  */,
909               userid_escaped ?: "",
910               "" /* Signature class.  */,
911               "" /* Key capabilities.  */,
912               "" /* Issuer certificate fingerprint.  */,
913               "" /* Flag field.  */,
914               "" /* S/N of a token.  */,
915               "" /* Hash algo.  */,
916               "" /* Curve name.  */);
917
918   xfree (userid_escaped);
919   xfree (expiration_date_str);
920   xfree (creation_date_str);
921   xfree (keyid_str);
922   xfree (pub_key_algo_str);
923   xfree (pub_key_length_str);
924 }
925
926 /* Handle the KS_PUT inquiries. */
927 static gpg_error_t
928 ks_put_inq_cb (void *opaque, const char *line)
929 {
930   struct ks_put_parm_s *parm = opaque;
931   gpg_error_t err = 0;
932
933   if (has_leading_keyword (line, "KEYBLOCK"))
934     {
935       if (parm->data)
936         err = assuan_send_data (parm->ctx, parm->data, parm->datalen);
937     }
938   else if (has_leading_keyword (line, "KEYBLOCK_INFO"))
939     {
940       kbnode_t node;
941       estream_t fp;
942
943       /* Parse the keyblock and send info lines back to the server.  */
944       fp = es_fopenmem (0, "rw,samethread");
945       if (!fp)
946         err = gpg_error_from_syserror ();
947
948       /* Note: the output format for the INFO block follows the colon
949          format as described in doc/DETAILS.  We don't actually reuse
950          the functionality from g10/keylist.c to produce the output,
951          because we don't need all of it and some of it is quite
952          expensive to generate.
953
954          The fields are (the starred fields are the ones we need):
955
956            * Field 1 - Type of record
957            * Field 2 - Validity
958            * Field 3 - Key length
959            * Field 4 - Public key algorithm
960            * Field 5 - KeyID
961            * Field 6 - Creation date
962            * Field 7 - Expiration date
963              Field 8 - Certificate S/N, UID hash, trust signature info
964              Field 9 -  Ownertrust
965            * Field 10 - User-ID
966              Field 11 - Signature class
967              Field 12 - Key capabilities
968              Field 13 - Issuer certificate fingerprint or other info
969              Field 14 - Flag field
970              Field 15 - S/N of a token
971              Field 16 - Hash algorithm
972              Field 17 - Curve name
973        */
974       for (node = parm->keyblock; !err && node; node=node->next)
975         {
976           switch (node->pkt->pkttype)
977             {
978             case PKT_PUBLIC_KEY:
979             case PKT_PUBLIC_SUBKEY:
980               {
981                 PKT_public_key *pk = node->pkt->pkt.public_key;
982
983                 char validity[3];
984                 int i;
985
986                 i = 0;
987                 if (pk->flags.revoked)
988                   validity[i ++] = 'r';
989                 if (pk->has_expired)
990                   validity[i ++] = 'e';
991                 validity[i] = '\0';
992
993                 keyid_from_pk (pk, NULL);
994
995                 record_output (fp, node->pkt->pkttype, validity,
996                                nbits_from_pk (pk), pk->pubkey_algo,
997                                pk->keyid, pk->timestamp, pk->expiredate,
998                                NULL);
999               }
1000               break;
1001
1002             case PKT_USER_ID:
1003               {
1004                 PKT_user_id *uid = node->pkt->pkt.user_id;
1005
1006                 if (!uid->attrib_data)
1007                   {
1008                     char validity[3];
1009                     int i;
1010
1011                     i = 0;
1012                     if (uid->flags.revoked)
1013                       validity[i ++] = 'r';
1014                     if (uid->flags.expired)
1015                       validity[i ++] = 'e';
1016                     validity[i] = '\0';
1017
1018                     record_output (fp, node->pkt->pkttype, validity,
1019                                    -1, -1, NULL,
1020                                    uid->created, uid->expiredate,
1021                                    uid->name);
1022                   }
1023               }
1024               break;
1025
1026               /* This bit is really for the benefit of people who
1027                  store their keys in LDAP servers.  It makes it easy
1028                  to do queries for things like "all keys signed by
1029                  Isabella".  */
1030             case PKT_SIGNATURE:
1031               {
1032                 PKT_signature *sig = node->pkt->pkt.signature;
1033
1034                 if (IS_UID_SIG (sig))
1035                   record_output (fp, node->pkt->pkttype, NULL,
1036                                  -1, -1, sig->keyid,
1037                                  sig->timestamp, sig->expiredate, NULL);
1038               }
1039               break;
1040
1041             default:
1042               continue;
1043             }
1044           /* Given that the last operation was an es_fprintf we should
1045              get the correct ERRNO if ferror indicates an error.  */
1046           if (es_ferror (fp))
1047             err = gpg_error_from_syserror ();
1048         }
1049
1050       /* Without an error and if we have an keyblock at all, send the
1051          data back.  */
1052       if (!err && parm->keyblock)
1053         {
1054           int rc;
1055           char buffer[512];
1056           size_t nread;
1057
1058           es_rewind (fp);
1059           while (!(rc=es_read (fp, buffer, sizeof buffer, &nread)) && nread)
1060             {
1061               err = assuan_send_data (parm->ctx, buffer, nread);
1062               if (err)
1063                 break;
1064             }
1065           if (!err && rc)
1066             err = gpg_error_from_syserror ();
1067         }
1068       es_fclose (fp);
1069     }
1070   else
1071     return gpg_error (GPG_ERR_ASS_UNKNOWN_INQUIRE);
1072
1073   return err;
1074 }
1075
1076
1077 /* Send a key to the configured server.  {DATA,DATLEN} contains the
1078    key in OpenPGP binary transport format.  If KEYBLOCK is not NULL it
1079    has the internal representaion of that key; this is for example
1080    used to convey meta data to LDAP keyservers.  */
1081 gpg_error_t
1082 gpg_dirmngr_ks_put (ctrl_t ctrl, void *data, size_t datalen, kbnode_t keyblock)
1083 {
1084   gpg_error_t err;
1085   assuan_context_t ctx;
1086   struct ks_put_parm_s parm;
1087
1088   memset (&parm, 0, sizeof parm);
1089
1090   /* We are going to parse the keyblock, thus we better make sure the
1091      all information is readily available.  */
1092   if (keyblock)
1093     merge_keys_and_selfsig (ctrl, keyblock);
1094
1095   err = open_context (ctrl, &ctx);
1096   if (err)
1097     return err;
1098
1099   parm.ctx = ctx;
1100   parm.keyblock = keyblock;
1101   parm.data = data;
1102   parm.datalen = datalen;
1103
1104   err = assuan_transact (ctx, "KS_PUT", NULL, NULL,
1105                          ks_put_inq_cb, &parm, NULL, NULL);
1106
1107   close_context (ctrl, ctx);
1108   return err;
1109 }
1110
1111
1112 \f
1113 /* Data callback for the DNS_CERT and WKD_GET commands. */
1114 static gpg_error_t
1115 dns_cert_data_cb (void *opaque, const void *data, size_t datalen)
1116 {
1117   struct dns_cert_parm_s *parm = opaque;
1118   gpg_error_t err = 0;
1119   size_t nwritten;
1120
1121   if (!data)
1122     return 0;  /* Ignore END commands.  */
1123   if (!parm->memfp)
1124     return 0;  /* Data is not required.  */
1125
1126   if (es_write (parm->memfp, data, datalen, &nwritten))
1127     err = gpg_error_from_syserror ();
1128
1129   return err;
1130 }
1131
1132
1133 /* Status callback for the DNS_CERT command.  */
1134 static gpg_error_t
1135 dns_cert_status_cb (void *opaque, const char *line)
1136 {
1137   struct dns_cert_parm_s *parm = opaque;
1138   gpg_error_t err = 0;
1139   const char *s;
1140   size_t nbytes;
1141
1142   if ((s = has_leading_keyword (line, "FPR")))
1143     {
1144       char *buf;
1145
1146       if (!(buf = xtrystrdup (s)))
1147         err = gpg_error_from_syserror ();
1148       else if (parm->fpr)
1149         err = gpg_error (GPG_ERR_DUP_KEY);
1150       else if (!hex2str (buf, buf, strlen (buf)+1, &nbytes))
1151         err = gpg_error_from_syserror ();
1152       else if (nbytes < 20)
1153         err = gpg_error (GPG_ERR_TOO_SHORT);
1154       else
1155         {
1156           parm->fpr = xtrymalloc (nbytes);
1157           if (!parm->fpr)
1158             err = gpg_error_from_syserror ();
1159           else
1160             memcpy (parm->fpr, buf, (parm->fprlen = nbytes));
1161         }
1162       xfree (buf);
1163     }
1164   else if ((s = has_leading_keyword (line, "URL")) && *s)
1165     {
1166       if (parm->url)
1167         err = gpg_error (GPG_ERR_DUP_KEY);
1168       else if (!(parm->url = xtrystrdup (s)))
1169         err = gpg_error_from_syserror ();
1170     }
1171
1172   return err;
1173 }
1174
1175 /* Ask the dirmngr for a DNS CERT record.  Depending on the found
1176    subtypes different return values are set:
1177
1178    - For a PGP subtype a new estream with that key will be returned at
1179      R_KEY and the other return parameters are set to NULL/0.
1180
1181    - For an IPGP subtype the fingerprint is stored as a malloced block
1182      at (R_FPR,R_FPRLEN).  If an URL is available it is stored as a
1183      malloced string at R_URL; NULL is stored if there is no URL.
1184
1185    If CERTTYPE is DNS_CERTTYPE_ANY this function returns the first
1186    CERT record found with a supported type; it is expected that only
1187    one CERT record is used.  If CERTTYPE is one of the supported
1188    certtypes, only records with this certtype are considered and the
1189    first one found is returned.  All R_* args are optional.
1190
1191    If CERTTYPE is NULL the DANE method is used to fetch the key.
1192  */
1193 gpg_error_t
1194 gpg_dirmngr_dns_cert (ctrl_t ctrl, const char *name, const char *certtype,
1195                       estream_t *r_key,
1196                       unsigned char **r_fpr, size_t *r_fprlen,
1197                       char **r_url)
1198 {
1199   gpg_error_t err;
1200   assuan_context_t ctx;
1201   struct dns_cert_parm_s parm;
1202   char *line = NULL;
1203
1204   memset (&parm, 0, sizeof parm);
1205   if (r_key)
1206     *r_key = NULL;
1207   if (r_fpr)
1208     *r_fpr = NULL;
1209   if (r_fprlen)
1210     *r_fprlen = 0;
1211   if (r_url)
1212     *r_url = NULL;
1213
1214   err = open_context (ctrl, &ctx);
1215   if (err)
1216     return err;
1217
1218   line = es_bsprintf ("DNS_CERT %s %s", certtype? certtype : "--dane", name);
1219   if (!line)
1220     {
1221       err = gpg_error_from_syserror ();
1222       goto leave;
1223     }
1224   if (strlen (line) + 2 >= ASSUAN_LINELENGTH)
1225     {
1226       err = gpg_error (GPG_ERR_TOO_LARGE);
1227       goto leave;
1228     }
1229
1230   parm.memfp = es_fopenmem (0, "rwb");
1231   if (!parm.memfp)
1232     {
1233       err = gpg_error_from_syserror ();
1234       goto leave;
1235     }
1236   err = assuan_transact (ctx, line, dns_cert_data_cb, &parm,
1237                          NULL, NULL, dns_cert_status_cb, &parm);
1238   if (err)
1239     goto leave;
1240
1241   if (r_key)
1242     {
1243       es_rewind (parm.memfp);
1244       *r_key = parm.memfp;
1245       parm.memfp = NULL;
1246     }
1247
1248   if (r_fpr && parm.fpr)
1249     {
1250       *r_fpr = parm.fpr;
1251       parm.fpr = NULL;
1252     }
1253   if (r_fprlen)
1254     *r_fprlen = parm.fprlen;
1255
1256   if (r_url && parm.url)
1257     {
1258       *r_url = parm.url;
1259       parm.url = NULL;
1260     }
1261
1262  leave:
1263   xfree (parm.fpr);
1264   xfree (parm.url);
1265   es_fclose (parm.memfp);
1266   xfree (line);
1267   close_context (ctrl, ctx);
1268   return err;
1269 }
1270
1271
1272 /* Ask the dirmngr for PKA info.  On success the retrieved fingerprint
1273    is returned in a malloced buffer at R_FPR and its length is stored
1274    at R_FPRLEN.  If an URL is available it is stored as a malloced
1275    string at R_URL.  On error all return values are set to NULL/0.  */
1276 gpg_error_t
1277 gpg_dirmngr_get_pka (ctrl_t ctrl, const char *userid,
1278                      unsigned char **r_fpr, size_t *r_fprlen,
1279                      char **r_url)
1280 {
1281   gpg_error_t err;
1282   assuan_context_t ctx;
1283   struct dns_cert_parm_s parm;
1284   char *line = NULL;
1285
1286   memset (&parm, 0, sizeof parm);
1287   if (r_fpr)
1288     *r_fpr = NULL;
1289   if (r_fprlen)
1290     *r_fprlen = 0;
1291   if (r_url)
1292     *r_url = NULL;
1293
1294   err = open_context (ctrl, &ctx);
1295   if (err)
1296     return err;
1297
1298   line = es_bsprintf ("DNS_CERT --pka -- %s", userid);
1299   if (!line)
1300     {
1301       err = gpg_error_from_syserror ();
1302       goto leave;
1303     }
1304   if (strlen (line) + 2 >= ASSUAN_LINELENGTH)
1305     {
1306       err = gpg_error (GPG_ERR_TOO_LARGE);
1307       goto leave;
1308     }
1309
1310   err = assuan_transact (ctx, line, dns_cert_data_cb, &parm,
1311                          NULL, NULL, dns_cert_status_cb, &parm);
1312   if (err)
1313     goto leave;
1314
1315   if (r_fpr && parm.fpr)
1316     {
1317       *r_fpr = parm.fpr;
1318       parm.fpr = NULL;
1319     }
1320   if (r_fprlen)
1321     *r_fprlen = parm.fprlen;
1322
1323   if (r_url && parm.url)
1324     {
1325       *r_url = parm.url;
1326       parm.url = NULL;
1327     }
1328
1329  leave:
1330   xfree (parm.fpr);
1331   xfree (parm.url);
1332   xfree (line);
1333   close_context (ctrl, ctx);
1334   return err;
1335 }
1336
1337
1338 \f
1339 /* Ask the dirmngr to retrieve a key via the Web Key Directory
1340  * protocol.  If QUICK is set the dirmngr is advised to use a shorter
1341  * timeout.  On success a new estream with the key stored at R_KEY and the
1342  * url of the lookup (if any) stored at R_URL.  Note that
1343  */
1344 gpg_error_t
1345 gpg_dirmngr_wkd_get (ctrl_t ctrl, const char *name, int quick,
1346                      estream_t *r_key, char **r_url)
1347 {
1348   gpg_error_t err;
1349   assuan_context_t ctx;
1350   struct ks_status_parm_s stparm = { NULL };
1351   struct dns_cert_parm_s parm = { NULL };
1352   char *line = NULL;
1353
1354   if (r_key)
1355     *r_key = NULL;
1356
1357   if (r_url)
1358     *r_url = NULL;
1359
1360   err = open_context (ctrl, &ctx);
1361   if (err)
1362     return err;
1363
1364   line = es_bsprintf ("WKD_GET%s -- %s", quick?" --quick":"", name);
1365   if (!line)
1366     {
1367       err = gpg_error_from_syserror ();
1368       goto leave;
1369     }
1370   if (strlen (line) + 2 >= ASSUAN_LINELENGTH)
1371     {
1372       err = gpg_error (GPG_ERR_TOO_LARGE);
1373       goto leave;
1374     }
1375
1376   parm.memfp = es_fopenmem (MAX_WKD_RESULT_LENGTH, "rwb");
1377   if (!parm.memfp)
1378     {
1379       err = gpg_error_from_syserror ();
1380       goto leave;
1381     }
1382   err = assuan_transact (ctx, line, dns_cert_data_cb, &parm,
1383                          NULL, NULL, ks_status_cb, &stparm);
1384   if (gpg_err_code (err) == GPG_ERR_ENOSPC)
1385     err = gpg_error (GPG_ERR_TOO_LARGE);
1386   if (err)
1387     goto leave;
1388
1389   if (r_key)
1390     {
1391       es_rewind (parm.memfp);
1392       *r_key = parm.memfp;
1393       parm.memfp = NULL;
1394     }
1395
1396   if (r_url)
1397     {
1398       *r_url = stparm.source;
1399       stparm.source = NULL;
1400     }
1401
1402  leave:
1403   xfree (stparm.source);
1404   xfree (parm.fpr);
1405   xfree (parm.url);
1406   es_fclose (parm.memfp);
1407   xfree (line);
1408   close_context (ctrl, ctx);
1409   return err;
1410 }