gpgconf: New command --apply-profile.
[gnupg.git] / tools / call-dirmngr.c
1 /* call-dirmngr.c - Interact with the Dirmngr.
2  * Copyright (C) 2016 g10 Code GmbH
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 <https://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 #ifdef HAVE_LOCALE_H
28 # include <locale.h>
29 #endif
30
31 #include <assuan.h>
32 #include "util.h"
33 #include "i18n.h"
34 #include "asshelp.h"
35 #include "mbox-util.h"
36 #include "./call-dirmngr.h"
37
38 static struct
39 {
40   int verbose;
41   int debug_ipc;
42   int autostart;
43 } opt;
44
45
46
47 void
48 set_dirmngr_options (int verbose, int debug_ipc, int autostart)
49 {
50   opt.verbose = verbose;
51   opt.debug_ipc = debug_ipc;
52   opt.autostart = autostart;
53 }
54
55
56 /* Connect to the Dirmngr and return an assuan context.  */
57 static gpg_error_t
58 connect_dirmngr (assuan_context_t *r_ctx)
59 {
60   gpg_error_t err;
61   assuan_context_t ctx;
62
63   *r_ctx = NULL;
64   err = start_new_dirmngr (&ctx,
65                            GPG_ERR_SOURCE_DEFAULT,
66                            NULL,
67                            opt.autostart, opt.verbose, opt.debug_ipc,
68                            NULL, NULL);
69   if (!opt.autostart && gpg_err_code (err) == GPG_ERR_NO_DIRMNGR)
70     {
71       static int shown;
72
73       if (!shown)
74         {
75           shown = 1;
76           log_info (_("no dirmngr running in this session\n"));
77         }
78     }
79
80   if (err)
81     assuan_release (ctx);
82   else
83     {
84       *r_ctx = ctx;
85     }
86
87   return err;
88 }
89
90
91
92 \f
93 /* Parameter structure used with the WKD_GET command.  */
94 struct wkd_get_parm_s
95 {
96   estream_t memfp;
97 };
98
99
100 /* Data callback for the WKD_GET command. */
101 static gpg_error_t
102 wkd_get_data_cb (void *opaque, const void *data, size_t datalen)
103 {
104   struct wkd_get_parm_s *parm = opaque;
105   gpg_error_t err = 0;
106   size_t nwritten;
107
108   if (!data)
109     return 0;  /* Ignore END commands.  */
110   if (!parm->memfp)
111     return 0;  /* Data is not required.  */
112
113   if (es_write (parm->memfp, data, datalen, &nwritten))
114     err = gpg_error_from_syserror ();
115
116   return err;
117 }
118
119
120 /* Status callback for the WKD_GET command.  */
121 static gpg_error_t
122 wkd_get_status_cb (void *opaque, const char *line)
123 {
124   struct wkd_get_parm_s *parm = opaque;
125   gpg_error_t err = 0;
126
127   (void)line;
128   (void)parm;
129
130   return err;
131 }
132
133
134 /* Ask the dirmngr for the submission address of a WKD server for the
135  * mail address ADDRSPEC.  On success the submission address is stored
136  * at R_ADDRSPEC.  */
137 gpg_error_t
138 wkd_get_submission_address (const char *addrspec, char **r_addrspec)
139 {
140   gpg_error_t err;
141   assuan_context_t ctx;
142   struct wkd_get_parm_s parm;
143   char *line = NULL;
144   void *vp;
145   char *buffer = NULL;
146   char *p;
147
148   memset (&parm, 0, sizeof parm);
149   *r_addrspec = NULL;
150
151   err = connect_dirmngr (&ctx);
152   if (err)
153     return err;
154
155   line = es_bsprintf ("WKD_GET --submission-address -- %s", addrspec);
156   if (!line)
157     {
158       err = gpg_error_from_syserror ();
159       goto leave;
160     }
161   if (strlen (line) + 2 >= ASSUAN_LINELENGTH)
162     {
163       err = gpg_error (GPG_ERR_TOO_LARGE);
164       goto leave;
165     }
166
167   parm.memfp = es_fopenmem (0, "rwb");
168   if (!parm.memfp)
169     {
170       err = gpg_error_from_syserror ();
171       goto leave;
172     }
173   err = assuan_transact (ctx, line, wkd_get_data_cb, &parm,
174                          NULL, NULL, wkd_get_status_cb, &parm);
175   if (err)
176     goto leave;
177
178   es_fputc (0, parm.memfp);
179   if (es_fclose_snatch (parm.memfp, &vp, NULL))
180     {
181       err = gpg_error_from_syserror ();
182       goto leave;
183     }
184   buffer = vp;
185   parm.memfp = NULL;
186   p = strchr (buffer, '\n');
187   if (p)
188     *p = 0;
189   trim_spaces (buffer);
190   if (!is_valid_mailbox (buffer))
191     {
192       err = gpg_error (GPG_ERR_INV_USER_ID);
193       goto leave;
194     }
195   *r_addrspec = xtrystrdup (buffer);
196   if (!*r_addrspec)
197     err = gpg_error_from_syserror ();
198
199  leave:
200   es_free (buffer);
201   es_fclose (parm.memfp);
202   xfree (line);
203   assuan_release (ctx);
204   return err;
205 }
206
207
208 /* Ask the dirmngr for the policy flags and return them as an estream
209  * memory stream.  If no policy flags are set, NULL is stored at
210  * R_BUFFER.  */
211 gpg_error_t
212 wkd_get_policy_flags (const char *addrspec, estream_t *r_buffer)
213 {
214   gpg_error_t err;
215   assuan_context_t ctx;
216   struct wkd_get_parm_s parm;
217   char *line = NULL;
218   char *buffer = NULL;
219
220   memset (&parm, 0, sizeof parm);
221   *r_buffer = NULL;
222
223   err = connect_dirmngr (&ctx);
224   if (err)
225     return err;
226
227   line = es_bsprintf ("WKD_GET --policy-flags -- %s", addrspec);
228   if (!line)
229     {
230       err = gpg_error_from_syserror ();
231       goto leave;
232     }
233   if (strlen (line) + 2 >= ASSUAN_LINELENGTH)
234     {
235       err = gpg_error (GPG_ERR_TOO_LARGE);
236       goto leave;
237     }
238
239   parm.memfp = es_fopenmem (0, "rwb");
240   if (!parm.memfp)
241     {
242       err = gpg_error_from_syserror ();
243       goto leave;
244     }
245   err = assuan_transact (ctx, line, wkd_get_data_cb, &parm,
246                          NULL, NULL, wkd_get_status_cb, &parm);
247   if (err)
248     goto leave;
249
250   es_rewind (parm.memfp);
251   *r_buffer = parm.memfp;
252   parm.memfp = 0;
253
254  leave:
255   es_free (buffer);
256   es_fclose (parm.memfp);
257   xfree (line);
258   assuan_release (ctx);
259   return err;
260 }
261
262
263 /* Ask the dirmngr for the key for ADDRSPEC.  On success a stream with
264  * the key is stored at R_KEY.  */
265 gpg_error_t
266 wkd_get_key (const char *addrspec, estream_t *r_key)
267 {
268   gpg_error_t err;
269   assuan_context_t ctx;
270   struct wkd_get_parm_s parm;
271   char *line = NULL;
272
273   memset (&parm, 0, sizeof parm);
274   *r_key = NULL;
275
276   err = connect_dirmngr (&ctx);
277   if (err)
278     return err;
279
280   line = es_bsprintf ("WKD_GET -- %s", addrspec);
281   if (!line)
282     {
283       err = gpg_error_from_syserror ();
284       goto leave;
285     }
286   if (strlen (line) + 2 >= ASSUAN_LINELENGTH)
287     {
288       err = gpg_error (GPG_ERR_TOO_LARGE);
289       goto leave;
290     }
291
292   parm.memfp = es_fopenmem (0, "rwb");
293   if (!parm.memfp)
294     {
295       err = gpg_error_from_syserror ();
296       goto leave;
297     }
298   err = assuan_transact (ctx, line, wkd_get_data_cb, &parm,
299                          NULL, NULL, wkd_get_status_cb, &parm);
300   if (err)
301     goto leave;
302
303   es_rewind (parm.memfp);
304   *r_key = parm.memfp;
305   parm.memfp = NULL;
306
307  leave:
308   es_fclose (parm.memfp);
309   xfree (line);
310   assuan_release (ctx);
311   return err;
312 }