gpg: Make preferred keyservers work.
[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 /* Data used to associate an session with dirmngr contexts.  We can't
82    use a simple one to one mapping because we sometimes need two
83    connections to the dirmngr; for example while doing a listing and
84    being in a data callback we may want to retrieve a key.  The local
85    dirmngr data takes care of this.  At the end of the session the
86    function dirmngr_deinit_session_data is called by gpg.c to cleanup
87    these resources.  Note that gpg.h defines a typedef dirmngr_local_t
88    for this structure. */
89 struct dirmngr_local_s
90 {
91   /* Link to other contexts which are used simultaneously.  */
92   struct dirmngr_local_s *next;
93
94   /* The active Assuan context. */
95   assuan_context_t ctx;
96
97   /* Flag set when the keyserver names have been send.  */
98   int set_keyservers_done;
99
100   /* Flag set to true while an operation is running on CTX.  */
101   int is_active;
102 };
103
104
105 \f
106 /* Deinitialize all session data of dirmngr pertaining to CTRL.  */
107 void
108 gpg_dirmngr_deinit_session_data (ctrl_t ctrl)
109 {
110   dirmngr_local_t dml;
111
112   while ((dml = ctrl->dirmngr_local))
113     {
114       ctrl->dirmngr_local = dml->next;
115       if (dml->is_active)
116         log_error ("oops: trying to cleanup an active dirmngr context\n");
117       else
118         assuan_release (dml->ctx);
119       xfree (dml);
120     }
121 }
122
123
124 /* Try to connect to the Dirmngr via a socket or spawn it if possible.
125    Handle the server's initial greeting and set global options.  */
126 static gpg_error_t
127 create_context (ctrl_t ctrl, assuan_context_t *r_ctx)
128 {
129   gpg_error_t err;
130   assuan_context_t ctx;
131
132   *r_ctx = NULL;
133   err = start_new_dirmngr (&ctx,
134                            GPG_ERR_SOURCE_DEFAULT,
135                            opt.homedir,
136                            opt.dirmngr_program,
137                            opt.autostart, opt.verbose, DBG_IPC,
138                            NULL /*gpg_status2*/, ctrl);
139   if (!opt.autostart && gpg_err_code (err) == GPG_ERR_NO_DIRMNGR)
140     {
141       static int shown;
142
143       if (!shown)
144         {
145           shown = 1;
146           log_info (_("no dirmngr running in this session\n"));
147         }
148     }
149   else if (!err)
150     {
151       /* Tell the dirmngr that we want to collect audit event. */
152       /* err = assuan_transact (agent_ctx, "OPTION audit-events=1", */
153       /*                        NULL, NULL, NULL, NULL, NULL, NULL); */
154     }
155
156   if (err)
157     assuan_release (ctx);
158   else
159     {
160       /* audit_log_ok (ctrl->audit, AUDIT_DIRMNGR_READY, err); */
161       *r_ctx = ctx;
162     }
163
164   return err;
165 }
166
167
168 /* Get a context for accessing dirmngr.  If no context is available a
169    new one is created and - if required - dirmngr started.  On success
170    an assuan context is stored at R_CTX.  This context may only be
171    released by means of close_context.  Note that NULL is stored at
172    R_CTX on error.  */
173 static gpg_error_t
174 open_context (ctrl_t ctrl, assuan_context_t *r_ctx)
175 {
176   gpg_error_t err;
177   dirmngr_local_t dml;
178
179   *r_ctx = NULL;
180   for (;;)
181     {
182       for (dml = ctrl->dirmngr_local; dml && dml->is_active; dml = dml->next)
183         ;
184       if (dml)
185         {
186           /* Found an inactive local session - return that.  */
187           assert (!dml->is_active);
188
189           /* But first do the per session init if not yet done.  */
190           if (!dml->set_keyservers_done)
191             {
192               keyserver_spec_t ksi;
193
194               /* Set all configured keyservers.  We clear existing
195                  keyservers so that any keyserver configured in GPG
196                  overrides keyservers possibly still configured in Dirmngr
197                  for the session (Note that the keyserver list of a
198                  session in Dirmngr survives a RESET. */
199               for (ksi = opt.keyserver; ksi; ksi = ksi->next)
200                 {
201                   char *line;
202
203                   line = xtryasprintf
204                     ("KEYSERVER%s %s",
205                      ksi == opt.keyserver? " --clear":"", ksi->uri);
206                   if (!line)
207                     err = gpg_error_from_syserror ();
208                   else
209                     {
210                       err = assuan_transact (dml->ctx, line, NULL, NULL, NULL,
211                                              NULL, NULL, NULL);
212                       xfree (line);
213                     }
214
215                   if (err)
216                     return err;
217                 }
218
219               dml->set_keyservers_done = 1;
220             }
221
222           dml->is_active = 1;
223
224           *r_ctx = dml->ctx;
225           return 0;
226         }
227
228       dml = xtrycalloc (1, sizeof *dml);
229       if (!dml)
230         return gpg_error_from_syserror ();
231       err = create_context (ctrl, &dml->ctx);
232       if (err)
233         {
234           xfree (dml);
235           return err;
236         }
237
238       /* To be on the nPth thread safe site we need to add it to a
239          list; this is far easier than to have a lock for this
240          function.  It should not happen anyway but the code is free
241          because we need it for the is_active check above.  */
242       dml->next = ctrl->dirmngr_local;
243       ctrl->dirmngr_local = dml;
244     }
245 }
246
247
248 /* Close the assuan context CTX or return it to a pool of unused
249    contexts.  If CTX is NULL, the function does nothing.  */
250 static void
251 close_context (ctrl_t ctrl, assuan_context_t ctx)
252 {
253   dirmngr_local_t dml;
254
255   if (!ctx)
256     return;
257
258   for (dml = ctrl->dirmngr_local; dml; dml = dml->next)
259     {
260       if (dml->ctx == ctx)
261         {
262           if (!dml->is_active)
263             log_fatal ("closing inactive dirmngr context %p\n", ctx);
264           dml->is_active = 0;
265           return;
266         }
267     }
268   log_fatal ("closing unknown dirmngr ctx %p\n", ctx);
269 }
270
271
272 /* Clear the set_keyservers_done flag on context CTX.  */
273 static void
274 clear_context_flags (ctrl_t ctrl, assuan_context_t ctx)
275 {
276   dirmngr_local_t dml;
277
278   if (!ctx)
279     return;
280
281   for (dml = ctrl->dirmngr_local; dml; dml = dml->next)
282     {
283       if (dml->ctx == ctx)
284         {
285           if (!dml->is_active)
286             log_fatal ("clear_context_flags on inactive dirmngr ctx %p\n", ctx);
287           dml->set_keyservers_done = 0;
288           return;
289         }
290     }
291   log_fatal ("clear_context_flags on unknown dirmngr ctx %p\n", ctx);
292 }
293
294
295 \f
296 /* Status callback for ks_get and ks_search.  */
297 static gpg_error_t
298 ks_status_cb (void *opaque, const char *line)
299 {
300   struct ks_status_parm_s *parm = opaque;
301   gpg_error_t err = 0;
302   const char *s;
303
304   if ((s = has_leading_keyword (line, "SOURCE")))
305     {
306       if (!parm->source)
307         {
308           parm->source = xtrystrdup (s);
309           if (!parm->source)
310             err = gpg_error_from_syserror ();
311         }
312     }
313
314   return err;
315 }
316
317
318 \f
319 /* Data callback for the KS_SEARCH command. */
320 static gpg_error_t
321 ks_search_data_cb (void *opaque, const void *data, size_t datalen)
322 {
323   gpg_error_t err = 0;
324   struct ks_search_parm_s *parm = opaque;
325   const char *line, *s;
326   size_t rawlen, linelen;
327   char fixedbuf[256];
328
329   if (parm->lasterr)
330     return 0;
331
332   if (parm->stparm->source)
333     {
334       err = parm->data_cb (parm->data_cb_value, 1, parm->stparm->source);
335       if (err)
336         {
337           parm->lasterr = err;
338           return err;
339         }
340       /* Clear it so that we won't get back here unless the server
341          accidentally sends a second source status line.  Note that
342          will not see all accidentally sent source lines because it
343          depends on whether data lines have been send in between.  */
344       xfree (parm->stparm->source);
345       parm->stparm->source = NULL;
346     }
347
348   if (!data)
349     return 0;  /* Ignore END commands.  */
350
351   put_membuf (&parm->saveddata, data, datalen);
352
353  again:
354   line = peek_membuf (&parm->saveddata, &rawlen);
355   if (!line)
356     {
357       parm->lasterr = gpg_error_from_syserror ();
358       return parm->lasterr; /* Tell the server about our problem.  */
359     }
360   if ((s = memchr (line, '\n', rawlen)))
361     {
362       linelen = s - line;  /* That is the length excluding the LF.  */
363       if (linelen + 1 < sizeof fixedbuf)
364         {
365           /* We can use the static buffer.  */
366           memcpy (fixedbuf, line, linelen);
367           fixedbuf[linelen] = 0;
368           if (linelen && fixedbuf[linelen-1] == '\r')
369             fixedbuf[linelen-1] = 0;
370           err = parm->data_cb (parm->data_cb_value, 0, fixedbuf);
371         }
372       else
373         {
374           if (linelen + 1 >= parm->helpbufsize)
375             {
376               xfree (parm->helpbuf);
377               parm->helpbufsize = linelen + 1 + 1024;
378               parm->helpbuf = xtrymalloc (parm->helpbufsize);
379               if (!parm->helpbuf)
380                 {
381                   parm->lasterr = gpg_error_from_syserror ();
382                   return parm->lasterr;
383                 }
384             }
385           memcpy (parm->helpbuf, line, linelen);
386           parm->helpbuf[linelen] = 0;
387           if (linelen && parm->helpbuf[linelen-1] == '\r')
388             parm->helpbuf[linelen-1] = 0;
389           err = parm->data_cb (parm->data_cb_value, 0, parm->helpbuf);
390         }
391       if (err)
392         parm->lasterr = err;
393       else
394         {
395           clear_membuf (&parm->saveddata, linelen+1);
396           goto again;  /* There might be another complete line.  */
397         }
398     }
399
400   return err;
401 }
402
403
404 /* Run the KS_SEARCH command using the search string SEARCHSTR.  All
405    data lines are passed to the CB function.  That function is called
406    with CB_VALUE as its first argument, a 0 as second argument, and
407    the decoded data line as third argument.  The callback function may
408    modify the data line and it is guaranteed that this data line is a
409    complete line with a terminating 0 character but without the
410    linefeed.  NULL is passed to the callback to indicate EOF.  */
411 gpg_error_t
412 gpg_dirmngr_ks_search (ctrl_t ctrl, const char *searchstr,
413                        gpg_error_t (*cb)(void*, int, char *), void *cb_value)
414 {
415   gpg_error_t err;
416   assuan_context_t ctx;
417   struct ks_status_parm_s stparm;
418   struct ks_search_parm_s parm;
419   char line[ASSUAN_LINELENGTH];
420
421   err = open_context (ctrl, &ctx);
422   if (err)
423     return err;
424
425   {
426     char *escsearchstr = percent_plus_escape (searchstr);
427     if (!escsearchstr)
428       {
429         err = gpg_error_from_syserror ();
430         close_context (ctrl, ctx);
431         return err;
432       }
433     snprintf (line, sizeof line, "KS_SEARCH -- %s", escsearchstr);
434     xfree (escsearchstr);
435   }
436
437   memset (&stparm, 0, sizeof stparm);
438   memset (&parm, 0, sizeof parm);
439   init_membuf (&parm.saveddata, 1024);
440   parm.data_cb = cb;
441   parm.data_cb_value = cb_value;
442   parm.stparm = &stparm;
443
444   err = assuan_transact (ctx, line, ks_search_data_cb, &parm,
445                         NULL, NULL, ks_status_cb, &stparm);
446   if (!err)
447     err = cb (cb_value, 0, NULL);  /* Send EOF.  */
448
449   xfree (get_membuf (&parm.saveddata, NULL));
450   xfree (parm.helpbuf);
451   xfree (stparm.source);
452
453   close_context (ctrl, ctx);
454   return err;
455 }
456
457
458 \f
459 /* Data callback for the KS_GET and KS_FETCH commands. */
460 static gpg_error_t
461 ks_get_data_cb (void *opaque, const void *data, size_t datalen)
462 {
463   gpg_error_t err = 0;
464   struct ks_get_parm_s *parm = opaque;
465   size_t nwritten;
466
467   if (!data)
468     return 0;  /* Ignore END commands.  */
469
470   if (es_write (parm->memfp, data, datalen, &nwritten))
471     err = gpg_error_from_syserror ();
472
473   return err;
474 }
475
476
477 /* Run the KS_GET command using the patterns in the array PATTERN.  On
478    success an estream object is returned to retrieve the keys.  On
479    error an error code is returned and NULL stored at R_FP.
480
481    The pattern may only use search specification which a keyserver can
482    use to retrieve keys.  Because we know the format of the pattern we
483    don't need to escape the patterns before sending them to the
484    server.
485
486    If R_SOURCE is not NULL the source of the data is stored as a
487    malloced string there.  If a source is not known NULL is stored.
488
489    If there are too many patterns the function returns an error.  That
490    could be fixed by issuing several search commands or by
491    implementing a different interface.  However with long keyids we
492    are able to ask for (1000-10-1)/(2+8+1) = 90 keys at once.  */
493 gpg_error_t
494 gpg_dirmngr_ks_get (ctrl_t ctrl, char **pattern,
495                     keyserver_spec_t override_keyserver,
496                     estream_t *r_fp, char **r_source)
497 {
498   gpg_error_t err;
499   assuan_context_t ctx;
500   struct ks_status_parm_s stparm;
501   struct ks_get_parm_s parm;
502   char *line = NULL;
503   size_t linelen;
504   membuf_t mb;
505   int idx;
506
507   memset (&stparm, 0, sizeof stparm);
508   memset (&parm, 0, sizeof parm);
509
510   *r_fp = NULL;
511   if (r_source)
512     *r_source = NULL;
513
514   err = open_context (ctrl, &ctx);
515   if (err)
516     return err;
517
518   /* If we have an override keyserver we first indicate that the next
519      user of the context needs to again setup the global keyservers and
520      them we send the override keyserver.  */
521   if (override_keyserver)
522     {
523       clear_context_flags (ctrl, ctx);
524       line = xtryasprintf ("KEYSERVER --clear %s", override_keyserver->uri);
525       if (!line)
526         {
527           err = gpg_error_from_syserror ();
528           goto leave;
529         }
530       err = assuan_transact (ctx, line, NULL, NULL, NULL,
531                              NULL, NULL, NULL);
532       if (err)
533         goto leave;
534
535       xfree (line);
536       line = NULL;
537     }
538
539   /* Lump all patterns into one string.  */
540   init_membuf (&mb, 1024);
541   put_membuf_str (&mb, "KS_GET --");
542   for (idx=0; pattern[idx]; idx++)
543     {
544       put_membuf (&mb, " ", 1); /* Append Delimiter.  */
545       put_membuf_str (&mb, pattern[idx]);
546     }
547   put_membuf (&mb, "", 1); /* Append Nul.  */
548   line = get_membuf (&mb, &linelen);
549   if (!line)
550     {
551       err = gpg_error_from_syserror ();
552       goto leave;
553     }
554   if (linelen + 2 >= ASSUAN_LINELENGTH)
555     {
556       err = gpg_error (GPG_ERR_TOO_MANY);
557       goto leave;
558     }
559
560   parm.memfp = es_fopenmem (0, "rwb");
561   if (!parm.memfp)
562     {
563       err = gpg_error_from_syserror ();
564       goto leave;
565     }
566   err = assuan_transact (ctx, line, ks_get_data_cb, &parm,
567                          NULL, NULL, ks_status_cb, &stparm);
568   if (err)
569     goto leave;
570
571   es_rewind (parm.memfp);
572   *r_fp = parm.memfp;
573   parm.memfp = NULL;
574
575   if (r_source)
576     {
577       *r_source = stparm.source;
578       stparm.source = NULL;
579     }
580
581  leave:
582   es_fclose (parm.memfp);
583   xfree (stparm.source);
584   xfree (line);
585   close_context (ctrl, ctx);
586   return err;
587 }
588
589
590 /* Run the KS_FETCH and pass URL as argument.  On success an estream
591    object is returned to retrieve the keys.  On error an error code is
592    returned and NULL stored at R_FP.
593
594    The url is expected to point to a small set of keys; in many cases
595    only to one key.  However, schemes like finger may return several
596    keys.  Note that the configured keyservers are ignored by the
597    KS_FETCH command.  */
598 gpg_error_t
599 gpg_dirmngr_ks_fetch (ctrl_t ctrl, const char *url, estream_t *r_fp)
600 {
601   gpg_error_t err;
602   assuan_context_t ctx;
603   struct ks_get_parm_s parm;
604   char *line = NULL;
605
606   memset (&parm, 0, sizeof parm);
607
608   *r_fp = NULL;
609
610   err = open_context (ctrl, &ctx);
611   if (err)
612     return err;
613
614   line = strconcat ("KS_FETCH -- ", url, NULL);
615   if (!line)
616     {
617       err = gpg_error_from_syserror ();
618       goto leave;
619     }
620   if (strlen (line) + 2 >= ASSUAN_LINELENGTH)
621     {
622       err = gpg_error (GPG_ERR_TOO_LARGE);
623       goto leave;
624     }
625
626   parm.memfp = es_fopenmem (0, "rwb");
627   if (!parm.memfp)
628     {
629       err = gpg_error_from_syserror ();
630       goto leave;
631     }
632   err = assuan_transact (ctx, line, ks_get_data_cb, &parm,
633                          NULL, NULL, NULL, NULL);
634   if (err)
635     goto leave;
636
637   es_rewind (parm.memfp);
638   *r_fp = parm.memfp;
639   parm.memfp = NULL;
640
641  leave:
642   es_fclose (parm.memfp);
643   xfree (line);
644   close_context (ctrl, ctx);
645   return err;
646 }
647
648
649 \f
650 static void
651 record_output (estream_t output,
652                pkttype_t type,
653                const char *validity,
654                /* The public key length or -1.  */
655                int pub_key_length,
656                /* The public key algo or -1.  */
657                int pub_key_algo,
658                /* 2 ulongs or NULL.  */
659                const u32 *keyid,
660                /* The creation / expiration date or 0.  */
661                u32 creation_date,
662                u32 expiration_date,
663                const char *userid)
664 {
665   const char *type_str = NULL;
666   char *pub_key_length_str = NULL;
667   char *pub_key_algo_str = NULL;
668   char *keyid_str = NULL;
669   char *creation_date_str = NULL;
670   char *expiration_date_str = NULL;
671   char *userid_escaped = NULL;
672
673   switch (type)
674     {
675     case PKT_PUBLIC_KEY:
676       type_str = "pub";
677       break;
678     case PKT_PUBLIC_SUBKEY:
679       type_str = "sub";
680       break;
681     case PKT_USER_ID:
682       type_str = "uid";
683       break;
684     case PKT_SIGNATURE:
685       type_str = "sig";
686       break;
687     default:
688       assert (! "Unhandled type.");
689     }
690
691   if (pub_key_length > 0)
692     pub_key_length_str = xasprintf ("%d", pub_key_length);
693
694   if (pub_key_algo != -1)
695     pub_key_algo_str = xasprintf ("%d", pub_key_algo);
696
697   if (keyid)
698     keyid_str = xasprintf ("%08lX%08lX", (ulong) keyid[0], (ulong) keyid[1]);
699
700   if (creation_date)
701     creation_date_str = xstrdup (colon_strtime (creation_date));
702
703   if (expiration_date)
704     expiration_date_str = xstrdup (colon_strtime (expiration_date));
705
706   /* Quote ':', '%', and any 8-bit characters.  */
707   if (userid)
708     {
709       int r;
710       int w = 0;
711
712       int len = strlen (userid);
713       /* A 100k character limit on the uid should be way more than
714          enough.  */
715       if (len > 100 * 1024)
716         len = 100 * 1024;
717
718       /* The minimum amount of space that we need.  */
719       userid_escaped = xmalloc (len * 3 + 1);
720
721       for (r = 0; r < len; r++)
722         {
723           if (userid[r] == ':' || userid[r]== '%' || (userid[r] & 0x80))
724             {
725               sprintf (&userid_escaped[w], "%%%02X", (byte) userid[r]);
726               w += 3;
727             }
728           else
729             userid_escaped[w ++] = userid[r];
730         }
731       userid_escaped[w] = '\0';
732     }
733
734   es_fprintf (output, "%s:%s:%s:%s:%s:%s:%s:%s:%s:%s:%s:%s:%s:%s:%s:%s:%s\n",
735               type_str,
736               validity ?: "",
737               pub_key_length_str ?: "",
738               pub_key_algo_str ?: "",
739               keyid_str ?: "",
740               creation_date_str ?: "",
741               expiration_date_str ?: "",
742               "" /* Certificate S/N */,
743               "" /* Ownertrust.  */,
744               userid_escaped ?: "",
745               "" /* Signature class.  */,
746               "" /* Key capabilities.  */,
747               "" /* Issuer certificate fingerprint.  */,
748               "" /* Flag field.  */,
749               "" /* S/N of a token.  */,
750               "" /* Hash algo.  */,
751               "" /* Curve name.  */);
752
753   xfree (userid_escaped);
754   xfree (expiration_date_str);
755   xfree (creation_date_str);
756   xfree (keyid_str);
757   xfree (pub_key_algo_str);
758   xfree (pub_key_length_str);
759 }
760
761 /* Handle the KS_PUT inquiries. */
762 static gpg_error_t
763 ks_put_inq_cb (void *opaque, const char *line)
764 {
765   struct ks_put_parm_s *parm = opaque;
766   gpg_error_t err = 0;
767
768   if (has_leading_keyword (line, "KEYBLOCK"))
769     {
770       if (parm->data)
771         err = assuan_send_data (parm->ctx, parm->data, parm->datalen);
772     }
773   else if (has_leading_keyword (line, "KEYBLOCK_INFO"))
774     {
775       kbnode_t node;
776       estream_t fp;
777
778       /* Parse the keyblock and send info lines back to the server.  */
779       fp = es_fopenmem (0, "rw,samethread");
780       if (!fp)
781         err = gpg_error_from_syserror ();
782
783       /* Note: the output format for the INFO block follows the colon
784          format as described in doc/DETAILS.  We don't actually reuse
785          the functionality from g10/keylist.c to produce the output,
786          because we don't need all of it and some of it is quite
787          expensive to generate.
788
789          The fields are (the starred fields are the ones we need):
790
791            * Field 1 - Type of record
792            * Field 2 - Validity
793            * Field 3 - Key length
794            * Field 4 - Public key algorithm
795            * Field 5 - KeyID
796            * Field 6 - Creation date
797            * Field 7 - Expiration date
798              Field 8 - Certificate S/N, UID hash, trust signature info
799              Field 9 -  Ownertrust
800            * Field 10 - User-ID
801              Field 11 - Signature class
802              Field 12 - Key capabilities
803              Field 13 - Issuer certificate fingerprint or other info
804              Field 14 - Flag field
805              Field 15 - S/N of a token
806              Field 16 - Hash algorithm
807              Field 17 - Curve name
808        */
809       for (node = parm->keyblock; !err && node; node=node->next)
810         {
811           switch (node->pkt->pkttype)
812             {
813             case PKT_PUBLIC_KEY:
814             case PKT_PUBLIC_SUBKEY:
815               {
816                 PKT_public_key *pk = node->pkt->pkt.public_key;
817
818                 char validity[3];
819                 int i;
820
821                 i = 0;
822                 if (pk->flags.revoked)
823                   validity[i ++] = 'r';
824                 if (pk->has_expired)
825                   validity[i ++] = 'e';
826                 validity[i] = '\0';
827
828                 keyid_from_pk (pk, NULL);
829
830                 record_output (fp, node->pkt->pkttype, validity,
831                                nbits_from_pk (pk), pk->pubkey_algo,
832                                pk->keyid, pk->timestamp, pk->expiredate,
833                                NULL);
834               }
835               break;
836
837             case PKT_USER_ID:
838               {
839                 PKT_user_id *uid = node->pkt->pkt.user_id;
840
841                 if (!uid->attrib_data)
842                   {
843                     char validity[3];
844                     int i;
845
846                     i = 0;
847                     if (uid->is_revoked)
848                       validity[i ++] = 'r';
849                     if (uid->is_expired)
850                       validity[i ++] = 'e';
851                     validity[i] = '\0';
852
853                     record_output (fp, node->pkt->pkttype, validity,
854                                    -1, -1, NULL,
855                                    uid->created, uid->expiredate,
856                                    uid->name);
857                   }
858               }
859               break;
860
861               /* This bit is really for the benefit of people who
862                  store their keys in LDAP servers.  It makes it easy
863                  to do queries for things like "all keys signed by
864                  Isabella".  */
865             case PKT_SIGNATURE:
866               {
867                 PKT_signature *sig = node->pkt->pkt.signature;
868
869                 if (IS_UID_SIG (sig))
870                   record_output (fp, node->pkt->pkttype, NULL,
871                                  -1, -1, sig->keyid,
872                                  sig->timestamp, sig->expiredate, NULL);
873               }
874               break;
875
876             default:
877               continue;
878             }
879           /* Given that the last operation was an es_fprintf we should
880              get the correct ERRNO if ferror indicates an error.  */
881           if (es_ferror (fp))
882             err = gpg_error_from_syserror ();
883         }
884
885       /* Without an error and if we have an keyblock at all, send the
886          data back.  */
887       if (!err && parm->keyblock)
888         {
889           int rc;
890           char buffer[512];
891           size_t nread;
892
893           es_rewind (fp);
894           while (!(rc=es_read (fp, buffer, sizeof buffer, &nread)) && nread)
895             {
896               err = assuan_send_data (parm->ctx, buffer, nread);
897               if (err)
898                 break;
899             }
900           if (!err && rc)
901             err = gpg_error_from_syserror ();
902         }
903       es_fclose (fp);
904     }
905   else
906     return gpg_error (GPG_ERR_ASS_UNKNOWN_INQUIRE);
907
908   return err;
909 }
910
911
912 /* Send a key to the configured server.  {DATA,DATLEN} contains the
913    key in OpenPGP binary transport format.  If KEYBLOCK is not NULL it
914    has the internal representaion of that key; this is for example
915    used to convey meta data to LDAP keyservers.  */
916 gpg_error_t
917 gpg_dirmngr_ks_put (ctrl_t ctrl, void *data, size_t datalen, kbnode_t keyblock)
918 {
919   gpg_error_t err;
920   assuan_context_t ctx;
921   struct ks_put_parm_s parm;
922
923   memset (&parm, 0, sizeof parm);
924
925   /* We are going to parse the keyblock, thus we better make sure the
926      all information is readily available.  */
927   if (keyblock)
928     merge_keys_and_selfsig (keyblock);
929
930   err = open_context (ctrl, &ctx);
931   if (err)
932     return err;
933
934   parm.ctx = ctx;
935   parm.keyblock = keyblock;
936   parm.data = data;
937   parm.datalen = datalen;
938
939   err = assuan_transact (ctx, "KS_PUT", NULL, NULL,
940                          ks_put_inq_cb, &parm, NULL, NULL);
941
942   close_context (ctrl, ctx);
943   return err;
944 }