gpg: More fix of get_best_pubkey_byname.
[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   else if (parm.stparm->source)
612     {
613       /* Error but we received a SOURCE status.  Tell via callback but
614        * ignore errors.  */
615       parm.data_cb (parm.data_cb_value, 1, parm.stparm->source);
616     }
617
618   xfree (get_membuf (&parm.saveddata, NULL));
619   xfree (parm.helpbuf);
620   xfree (stparm.source);
621
622   close_context (ctrl, ctx);
623   return err;
624 }
625
626
627 \f
628 /* Data callback for the KS_GET and KS_FETCH commands. */
629 static gpg_error_t
630 ks_get_data_cb (void *opaque, const void *data, size_t datalen)
631 {
632   gpg_error_t err = 0;
633   struct ks_get_parm_s *parm = opaque;
634   size_t nwritten;
635
636   if (!data)
637     return 0;  /* Ignore END commands.  */
638
639   if (es_write (parm->memfp, data, datalen, &nwritten))
640     err = gpg_error_from_syserror ();
641
642   return err;
643 }
644
645
646 /* Run the KS_GET command using the patterns in the array PATTERN.  On
647    success an estream object is returned to retrieve the keys.  On
648    error an error code is returned and NULL stored at R_FP.
649
650    The pattern may only use search specification which a keyserver can
651    use to retrieve keys.  Because we know the format of the pattern we
652    don't need to escape the patterns before sending them to the
653    server.
654
655    If QUICK is set the dirmngr is advised to use a shorter timeout.
656
657    If R_SOURCE is not NULL the source of the data is stored as a
658    malloced string there.  If a source is not known NULL is stored.
659    Note that this may even be returned after an error.
660
661    If there are too many patterns the function returns an error.  That
662    could be fixed by issuing several search commands or by
663    implementing a different interface.  However with long keyids we
664    are able to ask for (1000-10-1)/(2+8+1) = 90 keys at once.  */
665 gpg_error_t
666 gpg_dirmngr_ks_get (ctrl_t ctrl, char **pattern,
667                     keyserver_spec_t override_keyserver, int quick,
668                     estream_t *r_fp, char **r_source)
669 {
670   gpg_error_t err;
671   assuan_context_t ctx;
672   struct ks_status_parm_s stparm;
673   struct ks_get_parm_s parm;
674   char *line = NULL;
675   size_t linelen;
676   membuf_t mb;
677   int idx;
678
679   memset (&stparm, 0, sizeof stparm);
680   memset (&parm, 0, sizeof parm);
681
682   *r_fp = NULL;
683   if (r_source)
684     *r_source = NULL;
685
686   err = open_context (ctrl, &ctx);
687   if (err)
688     return err;
689
690   /* If we have an override keyserver we first indicate that the next
691      user of the context needs to again setup the global keyservers and
692      them we send the override keyserver.  */
693   if (override_keyserver)
694     {
695       clear_context_flags (ctrl, ctx);
696       line = xtryasprintf ("KEYSERVER --clear %s", override_keyserver->uri);
697       if (!line)
698         {
699           err = gpg_error_from_syserror ();
700           goto leave;
701         }
702       err = assuan_transact (ctx, line, NULL, NULL, NULL,
703                              NULL, NULL, NULL);
704       if (err)
705         goto leave;
706
707       xfree (line);
708       line = NULL;
709     }
710
711   /* Lump all patterns into one string.  */
712   init_membuf (&mb, 1024);
713   put_membuf_str (&mb, quick? "KS_GET --quick --" : "KS_GET --");
714   for (idx=0; pattern[idx]; idx++)
715     {
716       put_membuf (&mb, " ", 1); /* Append Delimiter.  */
717       put_membuf_str (&mb, pattern[idx]);
718     }
719   put_membuf (&mb, "", 1); /* Append Nul.  */
720   line = get_membuf (&mb, &linelen);
721   if (!line)
722     {
723       err = gpg_error_from_syserror ();
724       goto leave;
725     }
726   if (linelen + 2 >= ASSUAN_LINELENGTH)
727     {
728       err = gpg_error (GPG_ERR_TOO_MANY);
729       goto leave;
730     }
731
732   parm.memfp = es_fopenmem (0, "rwb");
733   if (!parm.memfp)
734     {
735       err = gpg_error_from_syserror ();
736       goto leave;
737     }
738   err = assuan_transact (ctx, line, ks_get_data_cb, &parm,
739                          NULL, NULL, ks_status_cb, &stparm);
740   if (err)
741     goto leave;
742
743   es_rewind (parm.memfp);
744   *r_fp = parm.memfp;
745   parm.memfp = NULL;
746
747
748  leave:
749   if (r_source && stparm.source)
750     {
751       *r_source = stparm.source;
752       stparm.source = NULL;
753     }
754   es_fclose (parm.memfp);
755   xfree (stparm.source);
756   xfree (line);
757   close_context (ctrl, ctx);
758   return err;
759 }
760
761
762 /* Run the KS_FETCH and pass URL as argument.  On success an estream
763    object is returned to retrieve the keys.  On error an error code is
764    returned and NULL stored at R_FP.
765
766    The url is expected to point to a small set of keys; in many cases
767    only to one key.  However, schemes like finger may return several
768    keys.  Note that the configured keyservers are ignored by the
769    KS_FETCH command.  */
770 gpg_error_t
771 gpg_dirmngr_ks_fetch (ctrl_t ctrl, const char *url, estream_t *r_fp)
772 {
773   gpg_error_t err;
774   assuan_context_t ctx;
775   struct ks_get_parm_s parm;
776   char *line = NULL;
777
778   memset (&parm, 0, sizeof parm);
779
780   *r_fp = NULL;
781
782   err = open_context (ctrl, &ctx);
783   if (err)
784     return err;
785
786   line = strconcat ("KS_FETCH -- ", url, NULL);
787   if (!line)
788     {
789       err = gpg_error_from_syserror ();
790       goto leave;
791     }
792   if (strlen (line) + 2 >= ASSUAN_LINELENGTH)
793     {
794       err = gpg_error (GPG_ERR_TOO_LARGE);
795       goto leave;
796     }
797
798   parm.memfp = es_fopenmem (0, "rwb");
799   if (!parm.memfp)
800     {
801       err = gpg_error_from_syserror ();
802       goto leave;
803     }
804   err = assuan_transact (ctx, line, ks_get_data_cb, &parm,
805                          NULL, NULL, NULL, NULL);
806   if (err)
807     goto leave;
808
809   es_rewind (parm.memfp);
810   *r_fp = parm.memfp;
811   parm.memfp = NULL;
812
813  leave:
814   es_fclose (parm.memfp);
815   xfree (line);
816   close_context (ctrl, ctx);
817   return err;
818 }
819
820
821 \f
822 static void
823 record_output (estream_t output,
824                pkttype_t type,
825                const char *validity,
826                /* The public key length or -1.  */
827                int pub_key_length,
828                /* The public key algo or -1.  */
829                int pub_key_algo,
830                /* 2 ulongs or NULL.  */
831                const u32 *keyid,
832                /* The creation / expiration date or 0.  */
833                u32 creation_date,
834                u32 expiration_date,
835                const char *userid)
836 {
837   const char *type_str = NULL;
838   char *pub_key_length_str = NULL;
839   char *pub_key_algo_str = NULL;
840   char *keyid_str = NULL;
841   char *creation_date_str = NULL;
842   char *expiration_date_str = NULL;
843   char *userid_escaped = NULL;
844
845   switch (type)
846     {
847     case PKT_PUBLIC_KEY:
848       type_str = "pub";
849       break;
850     case PKT_PUBLIC_SUBKEY:
851       type_str = "sub";
852       break;
853     case PKT_USER_ID:
854       type_str = "uid";
855       break;
856     case PKT_SIGNATURE:
857       type_str = "sig";
858       break;
859     default:
860       log_assert (! "Unhandled type.");
861     }
862
863   if (pub_key_length > 0)
864     pub_key_length_str = xasprintf ("%d", pub_key_length);
865
866   if (pub_key_algo != -1)
867     pub_key_algo_str = xasprintf ("%d", pub_key_algo);
868
869   if (keyid)
870     keyid_str = xasprintf ("%08lX%08lX", (ulong) keyid[0], (ulong) keyid[1]);
871
872   if (creation_date)
873     creation_date_str = xstrdup (colon_strtime (creation_date));
874
875   if (expiration_date)
876     expiration_date_str = xstrdup (colon_strtime (expiration_date));
877
878   /* Quote ':', '%', and any 8-bit characters.  */
879   if (userid)
880     {
881       int r;
882       int w = 0;
883
884       int len = strlen (userid);
885       /* A 100k character limit on the uid should be way more than
886          enough.  */
887       if (len > 100 * 1024)
888         len = 100 * 1024;
889
890       /* The minimum amount of space that we need.  */
891       userid_escaped = xmalloc (len * 3 + 1);
892
893       for (r = 0; r < len; r++)
894         {
895           if (userid[r] == ':' || userid[r]== '%' || (userid[r] & 0x80))
896             {
897               sprintf (&userid_escaped[w], "%%%02X", (byte) userid[r]);
898               w += 3;
899             }
900           else
901             userid_escaped[w ++] = userid[r];
902         }
903       userid_escaped[w] = '\0';
904     }
905
906   es_fprintf (output, "%s:%s:%s:%s:%s:%s:%s:%s:%s:%s:%s:%s:%s:%s:%s:%s:%s\n",
907               type_str,
908               validity ?: "",
909               pub_key_length_str ?: "",
910               pub_key_algo_str ?: "",
911               keyid_str ?: "",
912               creation_date_str ?: "",
913               expiration_date_str ?: "",
914               "" /* Certificate S/N */,
915               "" /* Ownertrust.  */,
916               userid_escaped ?: "",
917               "" /* Signature class.  */,
918               "" /* Key capabilities.  */,
919               "" /* Issuer certificate fingerprint.  */,
920               "" /* Flag field.  */,
921               "" /* S/N of a token.  */,
922               "" /* Hash algo.  */,
923               "" /* Curve name.  */);
924
925   xfree (userid_escaped);
926   xfree (expiration_date_str);
927   xfree (creation_date_str);
928   xfree (keyid_str);
929   xfree (pub_key_algo_str);
930   xfree (pub_key_length_str);
931 }
932
933 /* Handle the KS_PUT inquiries. */
934 static gpg_error_t
935 ks_put_inq_cb (void *opaque, const char *line)
936 {
937   struct ks_put_parm_s *parm = opaque;
938   gpg_error_t err = 0;
939
940   if (has_leading_keyword (line, "KEYBLOCK"))
941     {
942       if (parm->data)
943         err = assuan_send_data (parm->ctx, parm->data, parm->datalen);
944     }
945   else if (has_leading_keyword (line, "KEYBLOCK_INFO"))
946     {
947       kbnode_t node;
948       estream_t fp;
949
950       /* Parse the keyblock and send info lines back to the server.  */
951       fp = es_fopenmem (0, "rw,samethread");
952       if (!fp)
953         err = gpg_error_from_syserror ();
954
955       /* Note: the output format for the INFO block follows the colon
956          format as described in doc/DETAILS.  We don't actually reuse
957          the functionality from g10/keylist.c to produce the output,
958          because we don't need all of it and some of it is quite
959          expensive to generate.
960
961          The fields are (the starred fields are the ones we need):
962
963            * Field 1 - Type of record
964            * Field 2 - Validity
965            * Field 3 - Key length
966            * Field 4 - Public key algorithm
967            * Field 5 - KeyID
968            * Field 6 - Creation date
969            * Field 7 - Expiration date
970              Field 8 - Certificate S/N, UID hash, trust signature info
971              Field 9 -  Ownertrust
972            * Field 10 - User-ID
973              Field 11 - Signature class
974              Field 12 - Key capabilities
975              Field 13 - Issuer certificate fingerprint or other info
976              Field 14 - Flag field
977              Field 15 - S/N of a token
978              Field 16 - Hash algorithm
979              Field 17 - Curve name
980        */
981       for (node = parm->keyblock; !err && node; node=node->next)
982         {
983           switch (node->pkt->pkttype)
984             {
985             case PKT_PUBLIC_KEY:
986             case PKT_PUBLIC_SUBKEY:
987               {
988                 PKT_public_key *pk = node->pkt->pkt.public_key;
989
990                 char validity[3];
991                 int i;
992
993                 i = 0;
994                 if (pk->flags.revoked)
995                   validity[i ++] = 'r';
996                 if (pk->has_expired)
997                   validity[i ++] = 'e';
998                 validity[i] = '\0';
999
1000                 keyid_from_pk (pk, NULL);
1001
1002                 record_output (fp, node->pkt->pkttype, validity,
1003                                nbits_from_pk (pk), pk->pubkey_algo,
1004                                pk->keyid, pk->timestamp, pk->expiredate,
1005                                NULL);
1006               }
1007               break;
1008
1009             case PKT_USER_ID:
1010               {
1011                 PKT_user_id *uid = node->pkt->pkt.user_id;
1012
1013                 if (!uid->attrib_data)
1014                   {
1015                     char validity[3];
1016                     int i;
1017
1018                     i = 0;
1019                     if (uid->flags.revoked)
1020                       validity[i ++] = 'r';
1021                     if (uid->flags.expired)
1022                       validity[i ++] = 'e';
1023                     validity[i] = '\0';
1024
1025                     record_output (fp, node->pkt->pkttype, validity,
1026                                    -1, -1, NULL,
1027                                    uid->created, uid->expiredate,
1028                                    uid->name);
1029                   }
1030               }
1031               break;
1032
1033               /* This bit is really for the benefit of people who
1034                  store their keys in LDAP servers.  It makes it easy
1035                  to do queries for things like "all keys signed by
1036                  Isabella".  */
1037             case PKT_SIGNATURE:
1038               {
1039                 PKT_signature *sig = node->pkt->pkt.signature;
1040
1041                 if (IS_UID_SIG (sig))
1042                   record_output (fp, node->pkt->pkttype, NULL,
1043                                  -1, -1, sig->keyid,
1044                                  sig->timestamp, sig->expiredate, NULL);
1045               }
1046               break;
1047
1048             default:
1049               continue;
1050             }
1051           /* Given that the last operation was an es_fprintf we should
1052              get the correct ERRNO if ferror indicates an error.  */
1053           if (es_ferror (fp))
1054             err = gpg_error_from_syserror ();
1055         }
1056
1057       /* Without an error and if we have an keyblock at all, send the
1058          data back.  */
1059       if (!err && parm->keyblock)
1060         {
1061           int rc;
1062           char buffer[512];
1063           size_t nread;
1064
1065           es_rewind (fp);
1066           while (!(rc=es_read (fp, buffer, sizeof buffer, &nread)) && nread)
1067             {
1068               err = assuan_send_data (parm->ctx, buffer, nread);
1069               if (err)
1070                 break;
1071             }
1072           if (!err && rc)
1073             err = gpg_error_from_syserror ();
1074         }
1075       es_fclose (fp);
1076     }
1077   else
1078     return gpg_error (GPG_ERR_ASS_UNKNOWN_INQUIRE);
1079
1080   return err;
1081 }
1082
1083
1084 /* Send a key to the configured server.  {DATA,DATLEN} contains the
1085    key in OpenPGP binary transport format.  If KEYBLOCK is not NULL it
1086    has the internal representation of that key; this is for example
1087    used to convey meta data to LDAP keyservers.  */
1088 gpg_error_t
1089 gpg_dirmngr_ks_put (ctrl_t ctrl, void *data, size_t datalen, kbnode_t keyblock)
1090 {
1091   gpg_error_t err;
1092   assuan_context_t ctx;
1093   struct ks_put_parm_s parm;
1094
1095   memset (&parm, 0, sizeof parm);
1096
1097   /* We are going to parse the keyblock, thus we better make sure the
1098      all information is readily available.  */
1099   if (keyblock)
1100     merge_keys_and_selfsig (ctrl, keyblock);
1101
1102   err = open_context (ctrl, &ctx);
1103   if (err)
1104     return err;
1105
1106   parm.ctx = ctx;
1107   parm.keyblock = keyblock;
1108   parm.data = data;
1109   parm.datalen = datalen;
1110
1111   err = assuan_transact (ctx, "KS_PUT", NULL, NULL,
1112                          ks_put_inq_cb, &parm, NULL, NULL);
1113
1114   close_context (ctrl, ctx);
1115   return err;
1116 }
1117
1118
1119 \f
1120 /* Data callback for the DNS_CERT and WKD_GET commands. */
1121 static gpg_error_t
1122 dns_cert_data_cb (void *opaque, const void *data, size_t datalen)
1123 {
1124   struct dns_cert_parm_s *parm = opaque;
1125   gpg_error_t err = 0;
1126   size_t nwritten;
1127
1128   if (!data)
1129     return 0;  /* Ignore END commands.  */
1130   if (!parm->memfp)
1131     return 0;  /* Data is not required.  */
1132
1133   if (es_write (parm->memfp, data, datalen, &nwritten))
1134     err = gpg_error_from_syserror ();
1135
1136   return err;
1137 }
1138
1139
1140 /* Status callback for the DNS_CERT command.  */
1141 static gpg_error_t
1142 dns_cert_status_cb (void *opaque, const char *line)
1143 {
1144   struct dns_cert_parm_s *parm = opaque;
1145   gpg_error_t err = 0;
1146   const char *s;
1147   size_t nbytes;
1148
1149   if ((s = has_leading_keyword (line, "FPR")))
1150     {
1151       char *buf;
1152
1153       if (!(buf = xtrystrdup (s)))
1154         err = gpg_error_from_syserror ();
1155       else if (parm->fpr)
1156         err = gpg_error (GPG_ERR_DUP_KEY);
1157       else if (!hex2str (buf, buf, strlen (buf)+1, &nbytes))
1158         err = gpg_error_from_syserror ();
1159       else if (nbytes < 20)
1160         err = gpg_error (GPG_ERR_TOO_SHORT);
1161       else
1162         {
1163           parm->fpr = xtrymalloc (nbytes);
1164           if (!parm->fpr)
1165             err = gpg_error_from_syserror ();
1166           else
1167             memcpy (parm->fpr, buf, (parm->fprlen = nbytes));
1168         }
1169       xfree (buf);
1170     }
1171   else if ((s = has_leading_keyword (line, "URL")) && *s)
1172     {
1173       if (parm->url)
1174         err = gpg_error (GPG_ERR_DUP_KEY);
1175       else if (!(parm->url = xtrystrdup (s)))
1176         err = gpg_error_from_syserror ();
1177     }
1178
1179   return err;
1180 }
1181
1182 /* Ask the dirmngr for a DNS CERT record.  Depending on the found
1183    subtypes different return values are set:
1184
1185    - For a PGP subtype a new estream with that key will be returned at
1186      R_KEY and the other return parameters are set to NULL/0.
1187
1188    - For an IPGP subtype the fingerprint is stored as a malloced block
1189      at (R_FPR,R_FPRLEN).  If an URL is available it is stored as a
1190      malloced string at R_URL; NULL is stored if there is no URL.
1191
1192    If CERTTYPE is DNS_CERTTYPE_ANY this function returns the first
1193    CERT record found with a supported type; it is expected that only
1194    one CERT record is used.  If CERTTYPE is one of the supported
1195    certtypes, only records with this certtype are considered and the
1196    first one found is returned.  All R_* args are optional.
1197
1198    If CERTTYPE is NULL the DANE method is used to fetch the key.
1199  */
1200 gpg_error_t
1201 gpg_dirmngr_dns_cert (ctrl_t ctrl, const char *name, const char *certtype,
1202                       estream_t *r_key,
1203                       unsigned char **r_fpr, size_t *r_fprlen,
1204                       char **r_url)
1205 {
1206   gpg_error_t err;
1207   assuan_context_t ctx;
1208   struct dns_cert_parm_s parm;
1209   char *line = NULL;
1210
1211   memset (&parm, 0, sizeof parm);
1212   if (r_key)
1213     *r_key = NULL;
1214   if (r_fpr)
1215     *r_fpr = NULL;
1216   if (r_fprlen)
1217     *r_fprlen = 0;
1218   if (r_url)
1219     *r_url = NULL;
1220
1221   err = open_context (ctrl, &ctx);
1222   if (err)
1223     return err;
1224
1225   line = es_bsprintf ("DNS_CERT %s %s", certtype? certtype : "--dane", name);
1226   if (!line)
1227     {
1228       err = gpg_error_from_syserror ();
1229       goto leave;
1230     }
1231   if (strlen (line) + 2 >= ASSUAN_LINELENGTH)
1232     {
1233       err = gpg_error (GPG_ERR_TOO_LARGE);
1234       goto leave;
1235     }
1236
1237   parm.memfp = es_fopenmem (0, "rwb");
1238   if (!parm.memfp)
1239     {
1240       err = gpg_error_from_syserror ();
1241       goto leave;
1242     }
1243   err = assuan_transact (ctx, line, dns_cert_data_cb, &parm,
1244                          NULL, NULL, dns_cert_status_cb, &parm);
1245   if (err)
1246     goto leave;
1247
1248   if (r_key)
1249     {
1250       es_rewind (parm.memfp);
1251       *r_key = parm.memfp;
1252       parm.memfp = NULL;
1253     }
1254
1255   if (r_fpr && parm.fpr)
1256     {
1257       *r_fpr = parm.fpr;
1258       parm.fpr = NULL;
1259     }
1260   if (r_fprlen)
1261     *r_fprlen = parm.fprlen;
1262
1263   if (r_url && parm.url)
1264     {
1265       *r_url = parm.url;
1266       parm.url = NULL;
1267     }
1268
1269  leave:
1270   xfree (parm.fpr);
1271   xfree (parm.url);
1272   es_fclose (parm.memfp);
1273   xfree (line);
1274   close_context (ctrl, ctx);
1275   return err;
1276 }
1277
1278
1279 /* Ask the dirmngr for PKA info.  On success the retrieved fingerprint
1280    is returned in a malloced buffer at R_FPR and its length is stored
1281    at R_FPRLEN.  If an URL is available it is stored as a malloced
1282    string at R_URL.  On error all return values are set to NULL/0.  */
1283 gpg_error_t
1284 gpg_dirmngr_get_pka (ctrl_t ctrl, const char *userid,
1285                      unsigned char **r_fpr, size_t *r_fprlen,
1286                      char **r_url)
1287 {
1288   gpg_error_t err;
1289   assuan_context_t ctx;
1290   struct dns_cert_parm_s parm;
1291   char *line = NULL;
1292
1293   memset (&parm, 0, sizeof parm);
1294   if (r_fpr)
1295     *r_fpr = NULL;
1296   if (r_fprlen)
1297     *r_fprlen = 0;
1298   if (r_url)
1299     *r_url = NULL;
1300
1301   err = open_context (ctrl, &ctx);
1302   if (err)
1303     return err;
1304
1305   line = es_bsprintf ("DNS_CERT --pka -- %s", userid);
1306   if (!line)
1307     {
1308       err = gpg_error_from_syserror ();
1309       goto leave;
1310     }
1311   if (strlen (line) + 2 >= ASSUAN_LINELENGTH)
1312     {
1313       err = gpg_error (GPG_ERR_TOO_LARGE);
1314       goto leave;
1315     }
1316
1317   err = assuan_transact (ctx, line, dns_cert_data_cb, &parm,
1318                          NULL, NULL, dns_cert_status_cb, &parm);
1319   if (err)
1320     goto leave;
1321
1322   if (r_fpr && parm.fpr)
1323     {
1324       *r_fpr = parm.fpr;
1325       parm.fpr = NULL;
1326     }
1327   if (r_fprlen)
1328     *r_fprlen = parm.fprlen;
1329
1330   if (r_url && parm.url)
1331     {
1332       *r_url = parm.url;
1333       parm.url = NULL;
1334     }
1335
1336  leave:
1337   xfree (parm.fpr);
1338   xfree (parm.url);
1339   xfree (line);
1340   close_context (ctrl, ctx);
1341   return err;
1342 }
1343
1344
1345 \f
1346 /* Ask the dirmngr to retrieve a key via the Web Key Directory
1347  * protocol.  If QUICK is set the dirmngr is advised to use a shorter
1348  * timeout.  On success a new estream with the key stored at R_KEY and the
1349  * url of the lookup (if any) stored at R_URL.  Note that
1350  */
1351 gpg_error_t
1352 gpg_dirmngr_wkd_get (ctrl_t ctrl, const char *name, int quick,
1353                      estream_t *r_key, char **r_url)
1354 {
1355   gpg_error_t err;
1356   assuan_context_t ctx;
1357   struct ks_status_parm_s stparm = { NULL };
1358   struct dns_cert_parm_s parm = { NULL };
1359   char *line = NULL;
1360
1361   if (r_key)
1362     *r_key = NULL;
1363
1364   if (r_url)
1365     *r_url = NULL;
1366
1367   err = open_context (ctrl, &ctx);
1368   if (err)
1369     return err;
1370
1371   line = es_bsprintf ("WKD_GET%s -- %s", quick?" --quick":"", name);
1372   if (!line)
1373     {
1374       err = gpg_error_from_syserror ();
1375       goto leave;
1376     }
1377   if (strlen (line) + 2 >= ASSUAN_LINELENGTH)
1378     {
1379       err = gpg_error (GPG_ERR_TOO_LARGE);
1380       goto leave;
1381     }
1382
1383   parm.memfp = es_fopenmem (MAX_WKD_RESULT_LENGTH, "rwb");
1384   if (!parm.memfp)
1385     {
1386       err = gpg_error_from_syserror ();
1387       goto leave;
1388     }
1389   err = assuan_transact (ctx, line, dns_cert_data_cb, &parm,
1390                          NULL, NULL, ks_status_cb, &stparm);
1391   if (gpg_err_code (err) == GPG_ERR_ENOSPC)
1392     err = gpg_error (GPG_ERR_TOO_LARGE);
1393   if (err)
1394     goto leave;
1395
1396   if (r_key)
1397     {
1398       es_rewind (parm.memfp);
1399       *r_key = parm.memfp;
1400       parm.memfp = NULL;
1401     }
1402
1403   if (r_url)
1404     {
1405       *r_url = stparm.source;
1406       stparm.source = NULL;
1407     }
1408
1409  leave:
1410   xfree (stparm.source);
1411   xfree (parm.fpr);
1412   xfree (parm.url);
1413   es_fclose (parm.memfp);
1414   xfree (line);
1415   close_context (ctrl, ctx);
1416   return err;
1417 }