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