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