Move copy_stream function to misc.c.
[gnupg.git] / dirmngr / ks-action.c
1 /* ks-action.c - OpenPGP keyserver actions
2  * Copyright (C) 2011 Free Software Foundation, Inc.
3  * Copyright (C) 2011, 2014 Werner Koch
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 <http://www.gnu.org/licenses/>.
19  */
20
21 #include <config.h>
22
23 #include <stdio.h>
24 #include <stdlib.h>
25 #include <string.h>
26 #include <assert.h>
27
28 #include "dirmngr.h"
29 #include "misc.h"
30 #include "ks-engine.h"
31 #include "ks-action.h"
32
33
34 /* Called by the engine's help functions to print the actual help.  */
35 gpg_error_t
36 ks_print_help (ctrl_t ctrl, const char *text)
37 {
38   return dirmngr_status_help (ctrl, text);
39 }
40
41
42 /* Called by the engine's help functions to print the actual help.  */
43 gpg_error_t
44 ks_printf_help (ctrl_t ctrl, const char *format, ...)
45 {
46   va_list arg_ptr;
47   gpg_error_t err;
48   char *buf;
49
50   va_start (arg_ptr, format);
51   buf = es_vbsprintf (format, arg_ptr);
52   err = buf? 0 : gpg_error_from_syserror ();
53   va_end (arg_ptr);
54   if (!err)
55     err = dirmngr_status_help (ctrl, buf);
56   es_free (buf);
57   return err;
58 }
59
60
61 /* Run the help command for the engine responsible for URI.  */
62 gpg_error_t
63 ks_action_help (ctrl_t ctrl, const char *url)
64 {
65   gpg_error_t err;
66   parsed_uri_t parsed_uri;  /* The broken down URI.  */
67
68   if (!url || !*url)
69     {
70       ks_print_help (ctrl, "Known schemata:\n");
71       parsed_uri = NULL;
72     }
73   else
74     {
75       err = http_parse_uri (&parsed_uri, url, 1);
76       if (err)
77         return err;
78     }
79
80   /* Call all engines to give them a chance to print a help sting.  */
81   err = ks_hkp_help (ctrl, parsed_uri);
82   if (!err)
83     err = ks_http_help (ctrl, parsed_uri);
84   if (!err)
85     err = ks_finger_help (ctrl, parsed_uri);
86   if (!err)
87     err = ks_kdns_help (ctrl, parsed_uri);
88
89   if (!parsed_uri)
90     ks_print_help (ctrl,
91                    "(Use an URL for engine specific help.)");
92   else
93     http_release_parsed_uri (parsed_uri);
94   return err;
95 }
96
97
98 /* Resolve all host names.  This is useful for looking at the status
99    of configured keyservers.  */
100 gpg_error_t
101 ks_action_resolve (ctrl_t ctrl)
102 {
103   gpg_error_t err = 0;
104   int any_server = 0;
105   uri_item_t uri;
106
107   for (uri = ctrl->keyservers; !err && uri; uri = uri->next)
108     {
109       if (uri->parsed_uri->is_http)
110         {
111           any_server = 1;
112           err = ks_hkp_resolve (ctrl, uri->parsed_uri);
113           if (err)
114             break;
115         }
116     }
117
118   if (!any_server)
119     err = gpg_error (GPG_ERR_NO_KEYSERVER);
120   return err;
121 }
122
123
124 /* Search all configured keyservers for keys matching PATTERNS and
125    write the result to the provided output stream.  */
126 gpg_error_t
127 ks_action_search (ctrl_t ctrl, strlist_t patterns, estream_t outfp)
128 {
129   gpg_error_t err = 0;
130   int any_server = 0;
131   uri_item_t uri;
132   estream_t infp;
133
134   if (!patterns)
135     return gpg_error (GPG_ERR_NO_USER_ID);
136
137   /* FIXME: We only take care of the first pattern.  To fully support
138      multiple patterns we might either want to run several queries in
139      parallel and merge them.  We also need to decide what to do with
140      errors - it might not be the best idea to ignore an error from
141      one server and silently continue with another server.  For now we
142      stop at the first error. */
143   for (uri = ctrl->keyservers; !err && uri; uri = uri->next)
144     {
145       if (uri->parsed_uri->is_http)
146         {
147           any_server = 1;
148           err = ks_hkp_search (ctrl, uri->parsed_uri, patterns->d, &infp);
149           if (!err)
150             {
151               err = copy_stream (infp, outfp);
152               es_fclose (infp);
153               break;
154             }
155         }
156     }
157
158   if (!any_server)
159     err = gpg_error (GPG_ERR_NO_KEYSERVER);
160   return err;
161 }
162
163
164 /* Get the requested keys (matching PATTERNS) using all configured
165    keyservers and write the result to the provided output stream.  */
166 gpg_error_t
167 ks_action_get (ctrl_t ctrl, strlist_t patterns, estream_t outfp)
168 {
169   gpg_error_t err = 0;
170   gpg_error_t first_err = 0;
171   int any_server = 0;
172   int any_data = 0;
173   strlist_t sl;
174   uri_item_t uri;
175   estream_t infp;
176
177   if (!patterns)
178     return gpg_error (GPG_ERR_NO_USER_ID);
179
180   /* FIXME: We only take care of the first keyserver.  To fully
181      support multiple keyservers we need to track the result for each
182      pattern and use the next keyserver if one key was not found.  The
183      keyservers might not all be fully synced thus it is not clear
184      whether the first keyserver has the freshest copy of the key.
185      Need to think about a better strategy.  */
186   for (uri = ctrl->keyservers; !err && uri; uri = uri->next)
187     {
188       if (uri->parsed_uri->is_http)
189         {
190           any_server = 1;
191           for (sl = patterns; !err && sl; sl = sl->next)
192             {
193               err = ks_hkp_get (ctrl, uri->parsed_uri, sl->d, &infp);
194               if (err)
195                 {
196                   /* It is possible that a server does not carry a
197                      key, thus we only save the error and continue
198                      with the next pattern.  FIXME: It is an open
199                      question how to return such an error condition to
200                      the caller.  */
201                   first_err = err;
202                   err = 0;
203                 }
204               else
205                 {
206                   err = copy_stream (infp, outfp);
207                   /* Reading from the keyserver should never fail, thus
208                      return this error.  */
209                   if (!err)
210                     any_data = 1;
211                   es_fclose (infp);
212                   infp = NULL;
213                 }
214             }
215         }
216       if (any_data)
217         break; /* Stop loop after a keyserver returned something.  */
218     }
219
220   if (!any_server)
221     err = gpg_error (GPG_ERR_NO_KEYSERVER);
222   else if (!err && first_err && !any_data)
223     err = first_err;
224   return err;
225 }
226
227
228 /* Retrieve keys from URL and write the result to the provided output
229    stream OUTFP.  */
230 gpg_error_t
231 ks_action_fetch (ctrl_t ctrl, const char *url, estream_t outfp)
232 {
233   gpg_error_t err = 0;
234   estream_t infp;
235   parsed_uri_t parsed_uri;  /* The broken down URI.  */
236
237   if (!url)
238     return gpg_error (GPG_ERR_INV_URI);
239
240   err = http_parse_uri (&parsed_uri, url, 1);
241   if (err)
242     return err;
243
244   if (parsed_uri->is_http)
245     {
246       err = ks_http_fetch (ctrl, url, &infp);
247       if (!err)
248         {
249           err = copy_stream (infp, outfp);
250           es_fclose (infp);
251         }
252     }
253   else if (!parsed_uri->opaque)
254     {
255       err = gpg_error (GPG_ERR_INV_URI);
256     }
257   else if (!strcmp (parsed_uri->scheme, "finger"))
258     {
259       err = ks_finger_fetch (ctrl, parsed_uri, &infp);
260       if (!err)
261         {
262           err = copy_stream (infp, outfp);
263           es_fclose (infp);
264         }
265     }
266   else if (!strcmp (parsed_uri->scheme, "kdns"))
267     {
268       err = ks_kdns_fetch (ctrl, parsed_uri, &infp);
269       if (!err)
270         {
271           err = copy_stream (infp, outfp);
272           es_fclose (infp);
273         }
274     }
275   else
276     err = gpg_error (GPG_ERR_INV_URI);
277
278   http_release_parsed_uri (parsed_uri);
279   return err;
280 }
281
282
283
284 /* Send an OpenPGP key to all keyservers.  The key in {DATA,DATALEN}
285    is expected in OpenPGP binary transport format.  */
286 gpg_error_t
287 ks_action_put (ctrl_t ctrl, const void *data, size_t datalen)
288 {
289   gpg_error_t err = 0;
290   gpg_error_t first_err = 0;
291   int any_server = 0;
292   uri_item_t uri;
293
294   for (uri = ctrl->keyservers; !err && uri; uri = uri->next)
295     {
296       if (uri->parsed_uri->is_http)
297         {
298           any_server = 1;
299           err = ks_hkp_put (ctrl, uri->parsed_uri, data, datalen);
300           if (err)
301             {
302               first_err = err;
303               err = 0;
304             }
305         }
306     }
307
308   if (!any_server)
309     err = gpg_error (GPG_ERR_NO_KEYSERVER);
310   else if (!err && first_err)
311     err = first_err;
312   return err;
313 }