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