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