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