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