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