gpg: Add option --dirmngr-program.
[gnupg.git] / g10 / call-dirmngr.c
1 /* call-dirmngr.c - GPG operations to the Dirmngr.
2  * Copyright (C) 2011 Free Software Foundation, Inc.
3  *
4  * This file is part of GnuPG.
5  *
6  * GnuPG is free software; you can redistribute it and/or modify
7  * it under the terms of the GNU General Public License as published by
8  * the Free Software Foundation; either version 3 of the License, or
9  * (at your option) any later version.
10  *
11  * GnuPG is distributed in the hope that it will be useful,
12  * but WITHOUT ANY WARRANTY; without even the implied warranty of
13  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
14  * GNU General Public License for more details.
15  *
16  * You should have received a copy of the GNU General Public License
17  * along with this program; if not, see <http://www.gnu.org/licenses/>.
18  */
19
20 #include <config.h>
21 #include <stdio.h>
22 #include <stdlib.h>
23 #include <string.h>
24 #include <errno.h>
25 #include <unistd.h>
26 #include <time.h>
27 #include <assert.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 "call-dirmngr.h"
41
42
43 /* Parameter structure used with the KS_SEARCH command.  */
44 struct ks_search_parm_s
45 {
46   gpg_error_t lasterr;  /* Last error code.  */
47   membuf_t saveddata;   /* Buffer to build complete lines.  */
48   char *helpbuf;        /* NULL or malloced buffer.  */
49   size_t helpbufsize;   /* Allocated size of HELPBUF.  */
50   gpg_error_t (*data_cb)(void*, char*);  /* Callback.  */
51   void *data_cb_value;  /* First argument for DATA_CB.  */
52 };
53
54
55 /* Parameter structure used with the KS_GET command.  */
56 struct ks_get_parm_s
57 {
58   estream_t memfp;
59 };
60
61
62 /* Parameter structure used with the KS_PUT command.  */
63 struct ks_put_parm_s
64 {
65   assuan_context_t ctx;
66   kbnode_t keyblock;  /* The optional keyblock.  */
67   const void *data;   /* The key in OpenPGP binary format.  */
68   size_t datalen;     /* The length of DATA.  */
69 };
70
71
72 /* Data used to associate an session with dirmngr contexts.  We can't
73    use a simple one to one mapping because we sometimes need two
74    connections to the dirmngr; for example while doing a listing and
75    being in a data callback we may want to retrieve a key.  The local
76    dirmngr data takes care of this.  At the end of the session the
77    function dirmngr_deinit_session_data is called by gpg.c to cleanup
78    these resources.  Note that gpg.h defines a typedef dirmngr_local_t
79    for this structure. */
80 struct dirmngr_local_s
81 {
82   /* Link to other contexts which are used simultaneously.  */
83   struct dirmngr_local_s *next;
84
85   /* The active Assuan context. */
86   assuan_context_t ctx;
87
88   /* Flag set to true while an operation is running on CTX.  */
89   int is_active;
90 };
91
92
93 \f
94 /* Deinitialize all session data of dirmngr pertaining to CTRL.  */
95 void
96 gpg_dirmngr_deinit_session_data (ctrl_t ctrl)
97 {
98   dirmngr_local_t dml;
99
100   while ((dml = ctrl->dirmngr_local))
101     {
102       ctrl->dirmngr_local = dml->next;
103       if (dml->is_active)
104         log_error ("oops: trying to cleanup an active dirmngr context\n");
105       else
106         assuan_release (dml->ctx);
107       xfree (dml);
108     }
109 }
110
111
112 /* Try to connect to the Dirmngr via a socket or spawn it if possible.
113    Handle the server's initial greeting and set global options.  */
114 static gpg_error_t
115 create_context (ctrl_t ctrl, assuan_context_t *r_ctx)
116 {
117   gpg_error_t err;
118   assuan_context_t ctx;
119
120   *r_ctx = NULL;
121   err = start_new_dirmngr (&ctx,
122                            GPG_ERR_SOURCE_DEFAULT,
123                            opt.homedir,
124                            opt.dirmngr_program,
125                            opt.verbose, DBG_ASSUAN,
126                            NULL /*gpg_status2*/, ctrl);
127   if (!err)
128     {
129       keyserver_spec_t ksi;
130
131       /* Tell the dirmngr that we want to collect audit event. */
132       /* err = assuan_transact (agent_ctx, "OPTION audit-events=1", */
133       /*                        NULL, NULL, NULL, NULL, NULL, NULL); */
134
135       /* Set all configured keyservers.  We clear existing keyservers
136          so that any keyserver configured in GPG overrides keyservers
137          possibly still configured in Dirmngr for the session (Note
138          that the keyserver list of a session in Dirmngr survives a
139          RESET. */
140       for (ksi = opt.keyserver; !err && ksi; ksi = ksi->next)
141         {
142           char *line;
143
144           line = xtryasprintf ("KEYSERVER%s %s",
145                                ksi == opt.keyserver? " --clear":"", ksi->uri);
146           if (!line)
147             err = gpg_error_from_syserror ();
148           else
149             {
150               err = assuan_transact (ctx, line,
151                                      NULL, NULL, NULL, NULL, NULL, NULL);
152               xfree (line);
153             }
154         }
155     }
156
157   if (err)
158     assuan_release (ctx);
159   else
160     {
161       /* audit_log_ok (ctrl->audit, AUDIT_DIRMNGR_READY, err); */
162       *r_ctx = ctx;
163     }
164
165   return err;
166 }
167
168
169 /* Get a context for accessing dirmngr.  If no context is available a
170    new one is created and - if required - dirmngr started.  On success
171    an assuan context is stored at R_CTX.  This context may only be
172    released by means of close_context.  Note that NULL is stored at
173    R_CTX on error.  */
174 static gpg_error_t
175 open_context (ctrl_t ctrl, assuan_context_t *r_ctx)
176 {
177   gpg_error_t err;
178   dirmngr_local_t dml;
179
180   *r_ctx = NULL;
181   for (;;)
182     {
183       for (dml = ctrl->dirmngr_local; dml && dml->is_active; dml = dml->next)
184         ;
185       if (dml)
186         {
187           /* Found an inactive local session - return that.  */
188           assert (!dml->is_active);
189           dml->is_active = 1;
190           *r_ctx = dml->ctx;
191           return 0;
192         }
193
194       dml = xtrycalloc (1, sizeof *dml);
195       if (!dml)
196         return gpg_error_from_syserror ();
197       err = create_context (ctrl, &dml->ctx);
198       if (err)
199         {
200           xfree (dml);
201           return err;
202         }
203       /* To be on the nPth thread safe site we need to add it to a
204          list; this is far easier than to have a lock for this
205          function.  It should not happen anyway but the code is free
206          because we need it for the is_active check above.  */
207       dml->next = ctrl->dirmngr_local;
208       ctrl->dirmngr_local = dml;
209     }
210 }
211
212
213 /* Close the assuan context CTX or return it to a pool of unused
214    contexts.  If CTX is NULL, the function does nothing.  */
215 static void
216 close_context (ctrl_t ctrl, assuan_context_t ctx)
217 {
218   dirmngr_local_t dml;
219
220   if (!ctx)
221     return;
222
223   for (dml = ctrl->dirmngr_local; dml; dml = dml->next)
224     {
225       if (dml->ctx == ctx)
226         {
227           if (!dml->is_active)
228             log_fatal ("closing inactive dirmngr context %p\n", ctx);
229           dml->is_active = 0;
230           return;
231         }
232     }
233   log_fatal ("closing unknown dirmngr ctx %p\n", ctx);
234 }
235
236
237 \f
238 /* Data callback for the KS_SEARCH command. */
239 static gpg_error_t
240 ks_search_data_cb (void *opaque, const void *data, size_t datalen)
241 {
242   gpg_error_t err = 0;
243   struct ks_search_parm_s *parm = opaque;
244   const char *line, *s;
245   size_t rawlen, linelen;
246   char fixedbuf[256];
247
248   if (parm->lasterr)
249     return 0;
250
251   if (!data)
252     return 0;  /* Ignore END commands.  */
253
254   put_membuf (&parm->saveddata, data, datalen);
255
256  again:
257   line = peek_membuf (&parm->saveddata, &rawlen);
258   if (!line)
259     {
260       parm->lasterr = gpg_error_from_syserror ();
261       return parm->lasterr; /* Tell the server about our problem.  */
262     }
263   if ((s = memchr (line, '\n', rawlen)))
264     {
265       linelen = s - line;  /* That is the length excluding the LF.  */
266       if (linelen + 1 < sizeof fixedbuf)
267         {
268           /* We can use the static buffer.  */
269           memcpy (fixedbuf, line, linelen);
270           fixedbuf[linelen] = 0;
271           if (linelen && fixedbuf[linelen-1] == '\r')
272             fixedbuf[linelen-1] = 0;
273           err = parm->data_cb (parm->data_cb_value, fixedbuf);
274         }
275       else
276         {
277           if (linelen + 1 >= parm->helpbufsize)
278             {
279               xfree (parm->helpbuf);
280               parm->helpbufsize = linelen + 1 + 1024;
281               parm->helpbuf = xtrymalloc (parm->helpbufsize);
282               if (!parm->helpbuf)
283                 {
284                   parm->lasterr = gpg_error_from_syserror ();
285                   return parm->lasterr;
286                 }
287             }
288           memcpy (parm->helpbuf, line, linelen);
289           parm->helpbuf[linelen] = 0;
290           if (linelen && parm->helpbuf[linelen-1] == '\r')
291             parm->helpbuf[linelen-1] = 0;
292           err = parm->data_cb (parm->data_cb_value, parm->helpbuf);
293         }
294       if (err)
295         parm->lasterr = err;
296       else
297         {
298           clear_membuf (&parm->saveddata, linelen+1);
299           goto again;  /* There might be another complete line.  */
300         }
301     }
302
303   return err;
304 }
305
306
307 /* Run the KS_SEARCH command using the search string SEARCHSTR.  All
308    data lines are passed to the CB function.  That function is called
309    with CB_VALUE as its first argument and the decoded data line as
310    second argument.  The callback function may modify the data line
311    and it is guaranteed that this data line is a complete line with a
312    terminating 0 character but without the linefeed.  NULL is passed
313    to the callback to indicate EOF.  */
314 gpg_error_t
315 gpg_dirmngr_ks_search (ctrl_t ctrl, const char *searchstr,
316                        gpg_error_t (*cb)(void*, char *), void *cb_value)
317 {
318   gpg_error_t err;
319   assuan_context_t ctx;
320   struct ks_search_parm_s parm;
321   char line[ASSUAN_LINELENGTH];
322
323   err = open_context (ctrl, &ctx);
324   if (err)
325     return err;
326
327   {
328     char *escsearchstr = percent_plus_escape (searchstr);
329     if (!escsearchstr)
330       {
331         err = gpg_error_from_syserror ();
332         close_context (ctrl, ctx);
333         return err;
334       }
335     snprintf (line, sizeof line, "KS_SEARCH -- %s", escsearchstr);
336     xfree (escsearchstr);
337   }
338
339   memset (&parm, 0, sizeof parm);
340   init_membuf (&parm.saveddata, 1024);
341   parm.data_cb = cb;
342   parm.data_cb_value = cb_value;
343
344   err = assuan_transact (ctx, line, ks_search_data_cb, &parm,
345                         NULL, NULL, NULL, NULL);
346   if (!err)
347     err = cb (cb_value, NULL);  /* Send EOF.  */
348
349   xfree (get_membuf (&parm.saveddata, NULL));
350   xfree (parm.helpbuf);
351
352   close_context (ctrl, ctx);
353   return err;
354 }
355
356
357 \f
358 /* Data callback for the KS_GET and KS_FETCH commands. */
359 static gpg_error_t
360 ks_get_data_cb (void *opaque, const void *data, size_t datalen)
361 {
362   gpg_error_t err = 0;
363   struct ks_get_parm_s *parm = opaque;
364   size_t nwritten;
365
366   if (!data)
367     return 0;  /* Ignore END commands.  */
368
369   if (es_write (parm->memfp, data, datalen, &nwritten))
370     err = gpg_error_from_syserror ();
371
372   return err;
373 }
374
375
376 /* Run the KS_GET command using the patterns in the array PATTERN.  On
377    success an estream object is returned to retrieve the keys.  On
378    error an error code is returned and NULL stored at R_FP.
379
380    The pattern may only use search specification which a keyserver can
381    use to retriev keys.  Because we know the format of the pattern we
382    don't need to escape the patterns before sending them to the
383    server.
384
385    If there are too many patterns the function returns an error.  That
386    could be fixed by issuing several search commands or by
387    implementing a different interface.  However with long keyids we
388    are able to ask for (1000-10-1)/(2+8+1) = 90 keys at once.  */
389 gpg_error_t
390 gpg_dirmngr_ks_get (ctrl_t ctrl, char **pattern, estream_t *r_fp)
391 {
392   gpg_error_t err;
393   assuan_context_t ctx;
394   struct ks_get_parm_s parm;
395   char *line = NULL;
396   size_t linelen;
397   membuf_t mb;
398   int idx;
399
400   memset (&parm, 0, sizeof parm);
401
402   *r_fp = NULL;
403
404   err = open_context (ctrl, &ctx);
405   if (err)
406     return err;
407
408   /* Lump all patterns into one string.  */
409   init_membuf (&mb, 1024);
410   put_membuf_str (&mb, "KS_GET --");
411   for (idx=0; pattern[idx]; idx++)
412     {
413       put_membuf (&mb, " ", 1); /* Append Delimiter.  */
414       put_membuf_str (&mb, pattern[idx]);
415     }
416   put_membuf (&mb, "", 1); /* Append Nul.  */
417   line = get_membuf (&mb, &linelen);
418   if (!line)
419     {
420       err = gpg_error_from_syserror ();
421       goto leave;
422     }
423   if (linelen + 2 >= ASSUAN_LINELENGTH)
424     {
425       err = gpg_error (GPG_ERR_TOO_MANY);
426       goto leave;
427     }
428
429   parm.memfp = es_fopenmem (0, "rwb");
430   if (!parm.memfp)
431     {
432       err = gpg_error_from_syserror ();
433       goto leave;
434     }
435   err = assuan_transact (ctx, line, ks_get_data_cb, &parm,
436                          NULL, NULL, NULL, NULL);
437   if (err)
438     goto leave;
439
440   es_rewind (parm.memfp);
441   *r_fp = parm.memfp;
442   parm.memfp = NULL;
443
444  leave:
445   es_fclose (parm.memfp);
446   xfree (line);
447   close_context (ctrl, ctx);
448   return err;
449 }
450
451
452 /* Run the KS_FETCH and pass URL as argument.  On success an estream
453    object is returned to retrieve the keys.  On error an error code is
454    returned and NULL stored at R_FP.
455
456    The url is expected to point to a small set of keys; in many cases
457    only to one key.  However, schemes like finger may return several
458    keys.  Note that the configured keyservers are ignored by the
459    KS_FETCH command.  */
460 gpg_error_t
461 gpg_dirmngr_ks_fetch (ctrl_t ctrl, const char *url, estream_t *r_fp)
462 {
463   gpg_error_t err;
464   assuan_context_t ctx;
465   struct ks_get_parm_s parm;
466   char *line = NULL;
467
468   memset (&parm, 0, sizeof parm);
469
470   *r_fp = NULL;
471
472   err = open_context (ctrl, &ctx);
473   if (err)
474     return err;
475
476   line = strconcat ("KS_FETCH -- ", url, NULL);
477   if (!line)
478     {
479       err = gpg_error_from_syserror ();
480       goto leave;
481     }
482   if (strlen (line) + 2 >= ASSUAN_LINELENGTH)
483     {
484       err = gpg_error (GPG_ERR_TOO_LARGE);
485       goto leave;
486     }
487
488   parm.memfp = es_fopenmem (0, "rwb");
489   if (!parm.memfp)
490     {
491       err = gpg_error_from_syserror ();
492       goto leave;
493     }
494   err = assuan_transact (ctx, line, ks_get_data_cb, &parm,
495                          NULL, NULL, NULL, NULL);
496   if (err)
497     goto leave;
498
499   es_rewind (parm.memfp);
500   *r_fp = parm.memfp;
501   parm.memfp = NULL;
502
503  leave:
504   es_fclose (parm.memfp);
505   xfree (line);
506   close_context (ctrl, ctx);
507   return err;
508 }
509
510
511 \f
512 /* Handle the KS_PUT inquiries. */
513 static gpg_error_t
514 ks_put_inq_cb (void *opaque, const char *line)
515 {
516   struct ks_put_parm_s *parm = opaque;
517   gpg_error_t err = 0;
518
519   if (has_leading_keyword (line, "KEYBLOCK"))
520     {
521       if (parm->data)
522         err = assuan_send_data (parm->ctx, parm->data, parm->datalen);
523     }
524   else if (has_leading_keyword (line, "KEYBLOCK_INFO"))
525     {
526       kbnode_t node;
527       estream_t fp;
528
529       /* Parse the keyblock and send info lines back to the server.  */
530       fp = es_fopenmem (0, "rw");
531       if (!fp)
532         err = gpg_error_from_syserror ();
533
534       for (node = parm->keyblock; !err && node; node=node->next)
535         {
536           switch(node->pkt->pkttype)
537             {
538             case PKT_PUBLIC_KEY:
539             case PKT_PUBLIC_SUBKEY:
540               {
541                 PKT_public_key *pk = node->pkt->pkt.public_key;
542
543                 keyid_from_pk (pk, NULL);
544
545                 es_fprintf (fp, "%s:%08lX%08lX:%u:%u:%u:%u:%s%s:\n",
546                             node->pkt->pkttype==PKT_PUBLIC_KEY? "pub" : "sub",
547                             (ulong)pk->keyid[0], (ulong)pk->keyid[1],
548                             pk->pubkey_algo,
549                             nbits_from_pk (pk),
550                             pk->timestamp,
551                             pk->expiredate,
552                             pk->flags.revoked? "r":"",
553                             pk->has_expired? "e":"");
554               }
555               break;
556
557             case PKT_USER_ID:
558               {
559                 PKT_user_id *uid = node->pkt->pkt.user_id;
560                 int r;
561
562                 if (!uid->attrib_data)
563                   {
564                     es_fprintf (fp, "uid:");
565
566                     /* Quote ':', '%', and any 8-bit characters.  */
567                     for (r=0; r < uid->len; r++)
568                       {
569                         if (uid->name[r] == ':'
570                             || uid->name[r]== '%'
571                             || (uid->name[r]&0x80))
572                           es_fprintf (fp, "%%%02X", (byte)uid->name[r]);
573                         else
574                           es_putc (uid->name[r], fp);
575                       }
576
577                     es_fprintf (fp, ":%u:%u:%s%s:\n",
578                                 uid->created,uid->expiredate,
579                                 uid->is_revoked? "r":"",
580                                 uid->is_expired? "e":"");
581                   }
582               }
583               break;
584
585               /* This bit is really for the benefit of people who
586                  store their keys in LDAP servers.  It makes it easy
587                  to do queries for things like "all keys signed by
588                  Isabella".  */
589             case PKT_SIGNATURE:
590               {
591                 PKT_signature *sig = node->pkt->pkt.signature;
592
593                 if (IS_UID_SIG (sig))
594                   {
595                     es_fprintf (fp, "sig:%08lX%08lX:%X:%u:%u:\n",
596                                 (ulong)sig->keyid[0],(ulong)sig->keyid[1],
597                                 sig->sig_class, sig->timestamp,
598                                 sig->expiredate);
599                   }
600               }
601               break;
602
603             default:
604               continue;
605             }
606           /* Given that the last operation was an es_fprintf we should
607              get the correct ERRNO if ferror indicates an error.  */
608           if (es_ferror (fp))
609             err = gpg_error_from_syserror ();
610         }
611
612       /* Without an error and if we have an keyblock at all, send the
613          data back.  */
614       if (!err && parm->keyblock)
615         {
616           int rc;
617           char buffer[512];
618           size_t nread;
619
620           es_rewind (fp);
621           while (!(rc=es_read (fp, buffer, sizeof buffer, &nread)) && nread)
622             {
623               err = assuan_send_data (parm->ctx, buffer, nread);
624               if (err)
625                 break;
626             }
627           if (!err && rc)
628             err = gpg_error_from_syserror ();
629         }
630       es_fclose (fp);
631     }
632   else
633     return gpg_error (GPG_ERR_ASS_UNKNOWN_INQUIRE);
634
635   return err;
636 }
637
638
639 /* Send a key to the configured server.  {DATA,DATLEN} contains the
640    key in OpenPGP binary transport format.  If KEYBLOCK is not NULL it
641    has the internal representaion of that key; this is for example
642    used to convey meta data to LDAP keyservers.  */
643 gpg_error_t
644 gpg_dirmngr_ks_put (ctrl_t ctrl, void *data, size_t datalen, kbnode_t keyblock)
645 {
646   gpg_error_t err;
647   assuan_context_t ctx;
648   struct ks_put_parm_s parm;
649
650   memset (&parm, 0, sizeof parm);
651
652   /* We are going to parse the keyblock, thus we better make sure the
653      all information is readily available.  */
654   if (keyblock)
655     merge_keys_and_selfsig (keyblock);
656
657   err = open_context (ctrl, &ctx);
658   if (err)
659     return err;
660
661   parm.ctx = ctx;
662   parm.keyblock = keyblock;
663   parm.data = data;
664   parm.datalen = datalen;
665
666   err = assuan_transact (ctx, "KS_PUT", NULL, NULL,
667                          ks_put_inq_cb, &parm, NULL, NULL);
668
669   close_context (ctrl, ctx);
670   return err;
671 }