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