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