Nuked almost all trailing white space.
[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 command. */
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 \f
452 /* Handle the KS_PUT inquiries. */
453 static gpg_error_t
454 ks_put_inq_cb (void *opaque, const char *line)
455 {
456   struct ks_put_parm_s *parm = opaque;
457   gpg_error_t err = 0;
458
459   if (!strncmp (line, "KEYBLOCK", 8) && (line[8] == ' ' || !line[8]))
460     {
461       if (parm->data)
462         err = assuan_send_data (parm->ctx, parm->data, parm->datalen);
463     }
464   else if (!strncmp (line, "KEYBLOCK_INFO", 13) && (line[13]==' ' || !line[13]))
465     {
466       kbnode_t node;
467       estream_t fp;
468
469       /* Parse the keyblock and send info lines back to the server.  */
470       fp = es_fopenmem (0, "rw");
471       if (!fp)
472         err = gpg_error_from_syserror ();
473
474       for (node = parm->keyblock; !err && node; node=node->next)
475         {
476           switch(node->pkt->pkttype)
477             {
478             case PKT_PUBLIC_KEY:
479             case PKT_PUBLIC_SUBKEY:
480               {
481                 PKT_public_key *pk = node->pkt->pkt.public_key;
482
483                 keyid_from_pk (pk, NULL);
484
485                 es_fprintf (fp, "%s:%08lX%08lX:%u:%u:%u:%u:%s%s:\n",
486                             node->pkt->pkttype==PKT_PUBLIC_KEY? "pub" : "sub",
487                             (ulong)pk->keyid[0], (ulong)pk->keyid[1],
488                             pk->pubkey_algo,
489                             nbits_from_pk (pk),
490                             pk->timestamp,
491                             pk->expiredate,
492                             pk->flags.revoked? "r":"",
493                             pk->has_expired? "e":"");
494               }
495               break;
496
497             case PKT_USER_ID:
498               {
499                 PKT_user_id *uid = node->pkt->pkt.user_id;
500                 int r;
501
502                 if (!uid->attrib_data)
503                   {
504                     es_fprintf (fp, "uid:");
505
506                     /* Quote ':', '%', and any 8-bit characters.  */
507                     for (r=0; r < uid->len; r++)
508                       {
509                         if (uid->name[r] == ':'
510                             || uid->name[r]== '%'
511                             || (uid->name[r]&0x80))
512                           es_fprintf (fp, "%%%02X", (byte)uid->name[r]);
513                         else
514                           es_putc (uid->name[r], fp);
515                       }
516
517                     es_fprintf (fp, ":%u:%u:%s%s:\n",
518                                 uid->created,uid->expiredate,
519                                 uid->is_revoked? "r":"",
520                                 uid->is_expired? "e":"");
521                   }
522               }
523               break;
524
525               /* This bit is really for the benefit of people who
526                  store their keys in LDAP servers.  It makes it easy
527                  to do queries for things like "all keys signed by
528                  Isabella".  */
529             case PKT_SIGNATURE:
530               {
531                 PKT_signature *sig = node->pkt->pkt.signature;
532
533                 if (IS_UID_SIG (sig))
534                   {
535                     es_fprintf (fp, "sig:%08lX%08lX:%X:%u:%u:\n",
536                                 (ulong)sig->keyid[0],(ulong)sig->keyid[1],
537                                 sig->sig_class, sig->timestamp,
538                                 sig->expiredate);
539                   }
540               }
541               break;
542
543             default:
544               continue;
545             }
546           /* Given that the last operation was an es_fprintf we should
547              get the correct ERRNO if ferror indicates an error.  */
548           if (es_ferror (fp))
549             err = gpg_error_from_syserror ();
550         }
551
552       /* Without an error and if we have an keyblock at all, send the
553          data back.  */
554       if (!err && parm->keyblock)
555         {
556           int rc;
557           char buffer[512];
558           size_t nread;
559
560           es_rewind (fp);
561           while (!(rc=es_read (fp, buffer, sizeof buffer, &nread)) && nread)
562             {
563               err = assuan_send_data (parm->ctx, buffer, nread);
564               if (err)
565                 break;
566             }
567           if (!err && rc)
568             err = gpg_error_from_syserror ();
569         }
570       es_fclose (fp);
571     }
572   else
573     return gpg_error (GPG_ERR_ASS_UNKNOWN_INQUIRE);
574
575   return err;
576 }
577
578
579 /* Send a key to the configured server.  {DATA,DATLEN} contains the
580    key in OpenPGP binary transport format.  If KEYBLOCK is not NULL it
581    has the internal representaion of that key; this is for example
582    used to convey meta data to LDAP keyservers.  */
583 gpg_error_t
584 gpg_dirmngr_ks_put (ctrl_t ctrl, void *data, size_t datalen, kbnode_t keyblock)
585 {
586   gpg_error_t err;
587   assuan_context_t ctx;
588   struct ks_put_parm_s parm;
589
590   memset (&parm, 0, sizeof parm);
591
592   /* We are going to parse the keyblock, thus we better make sure the
593      all information is readily available.  */
594   if (keyblock)
595     merge_keys_and_selfsig (keyblock);
596
597   err = open_context (ctrl, &ctx);
598   if (err)
599     return err;
600
601   parm.ctx = ctx;
602   parm.keyblock = keyblock;
603   parm.data = data;
604   parm.datalen = datalen;
605
606   err = assuan_transact (ctx, "KS_PUT", NULL, NULL,
607                          ks_put_inq_cb, &parm, NULL, NULL);
608
609   close_context (ctrl, ctx);
610   return err;
611 }