g10, sm, dirmngr, common: Add comment for fall through.
[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  * Copyright (C) 2015 g10 Code GmbH
5  *
6  * This file is part of GnuPG.
7  *
8  * GnuPG is free software; you can redistribute it and/or modify
9  * it under the terms of the GNU General Public License as published by
10  * the Free Software Foundation; either version 3 of the License, or
11  * (at your option) any later version.
12  *
13  * GnuPG is distributed in the hope that it will be useful,
14  * but WITHOUT ANY WARRANTY; without even the implied warranty of
15  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
16  * GNU General Public License for more details.
17  *
18  * You should have received a copy of the GNU General Public License
19  * along with this program; if not, see <https://www.gnu.org/licenses/>.
20  */
21
22 #include <config.h>
23
24 #include <stdio.h>
25 #include <stdlib.h>
26 #include <string.h>
27 #include <assert.h>
28
29 #include "dirmngr.h"
30 #include "misc.h"
31 #include "ks-engine.h"
32 #include "ks-action.h"
33 #if USE_LDAP
34 # include "ldap-parse-uri.h"
35 #endif
36
37 /* Called by the engine's help functions to print the actual help.  */
38 gpg_error_t
39 ks_print_help (ctrl_t ctrl, const char *text)
40 {
41   return dirmngr_status_help (ctrl, text);
42 }
43
44
45 /* Called by the engine's help functions to print the actual help.  */
46 gpg_error_t
47 ks_printf_help (ctrl_t ctrl, const char *format, ...)
48 {
49   va_list arg_ptr;
50   gpg_error_t err;
51   char *buf;
52
53   va_start (arg_ptr, format);
54   buf = es_vbsprintf (format, arg_ptr);
55   err = buf? 0 : gpg_error_from_syserror ();
56   va_end (arg_ptr);
57   if (!err)
58     err = dirmngr_status_help (ctrl, buf);
59   es_free (buf);
60   return err;
61 }
62
63
64 /* Run the help command for the engine responsible for URI.  */
65 gpg_error_t
66 ks_action_help (ctrl_t ctrl, const char *url)
67 {
68   gpg_error_t err;
69   parsed_uri_t parsed_uri;  /* The broken down URI.  */
70
71   if (!url || !*url)
72     {
73       ks_print_help (ctrl, "Known schemata:\n");
74       parsed_uri = NULL;
75     }
76   else
77     {
78 #if USE_LDAP
79       if (ldap_uri_p (url))
80         err = ldap_parse_uri (&parsed_uri, url);
81       else
82 #endif
83         {
84           err = http_parse_uri (&parsed_uri, url, 1);
85         }
86
87       if (err)
88         return err;
89     }
90
91   /* Call all engines to give them a chance to print a help sting.  */
92   err = ks_hkp_help (ctrl, parsed_uri);
93   if (!err)
94     err = ks_http_help (ctrl, parsed_uri);
95   if (!err)
96     err = ks_finger_help (ctrl, parsed_uri);
97   if (!err)
98     err = ks_kdns_help (ctrl, parsed_uri);
99 #if USE_LDAP
100   if (!err)
101     err = ks_ldap_help (ctrl, parsed_uri);
102 #endif
103
104   if (!parsed_uri)
105     ks_print_help (ctrl,
106                    "(Use an URL for engine specific help.)");
107   else
108     http_release_parsed_uri (parsed_uri);
109   return err;
110 }
111
112
113 /* Resolve all host names.  This is useful for looking at the status
114    of configured keyservers.  */
115 gpg_error_t
116 ks_action_resolve (ctrl_t ctrl, uri_item_t keyservers)
117 {
118   gpg_error_t err = 0;
119   int any_server = 0;
120   uri_item_t uri;
121
122   for (uri = keyservers; !err && uri; uri = uri->next)
123     {
124       if (uri->parsed_uri->is_http)
125         {
126           any_server = 1;
127           err = ks_hkp_resolve (ctrl, uri->parsed_uri);
128           if (err)
129             break;
130         }
131     }
132
133   if (!any_server)
134     err = gpg_error (GPG_ERR_NO_KEYSERVER);
135   return err;
136 }
137
138
139 /* Search all configured keyservers for keys matching PATTERNS and
140    write the result to the provided output stream.  */
141 gpg_error_t
142 ks_action_search (ctrl_t ctrl, uri_item_t keyservers,
143                   strlist_t patterns, estream_t outfp)
144 {
145   gpg_error_t err = 0;
146   int any_server = 0;
147   int any_results = 0;
148   uri_item_t uri;
149   estream_t infp;
150
151   if (!patterns)
152     return gpg_error (GPG_ERR_NO_USER_ID);
153
154   /* FIXME: We only take care of the first pattern.  To fully support
155      multiple patterns we might either want to run several queries in
156      parallel and merge them.  We also need to decide what to do with
157      errors - it might not be the best idea to ignore an error from
158      one server and silently continue with another server.  For now we
159      stop at the first error, unless the server responds with '404 Not
160      Found', in which case we try the next server.  */
161   for (uri = keyservers; !err && uri; uri = uri->next)
162     {
163       int is_http = uri->parsed_uri->is_http;
164       int is_ldap = 0;
165       unsigned int http_status = 0;
166 #if USE_LDAP
167       is_ldap = (strcmp (uri->parsed_uri->scheme, "ldap") == 0
168                  || strcmp (uri->parsed_uri->scheme, "ldaps") == 0
169                  || strcmp (uri->parsed_uri->scheme, "ldapi") == 0);
170 #endif
171       if (is_http || is_ldap)
172         {
173           any_server = 1;
174 #if USE_LDAP
175           if (is_ldap)
176             err = ks_ldap_search (ctrl, uri->parsed_uri, patterns->d, &infp);
177           else
178 #endif
179             {
180               err = ks_hkp_search (ctrl, uri->parsed_uri, patterns->d,
181                                    &infp, &http_status);
182             }
183
184           if (err == gpg_error (GPG_ERR_NO_DATA)
185               && http_status == 404 /* not found */)
186             {
187               /* No record found.  Clear error and try next server.  */
188               err = 0;
189               continue;
190             }
191
192           if (!err)
193             {
194               err = copy_stream (infp, outfp);
195               es_fclose (infp);
196               any_results = 1;
197               break;
198             }
199         }
200     }
201
202   if (!any_server)
203     err = gpg_error (GPG_ERR_NO_KEYSERVER);
204   else if (err == 0 && !any_results)
205     err = gpg_error (GPG_ERR_NO_DATA);
206   return err;
207 }
208
209
210 /* Get the requested keys (matching PATTERNS) using all configured
211    keyservers and write the result to the provided output stream.  */
212 gpg_error_t
213 ks_action_get (ctrl_t ctrl, uri_item_t keyservers,
214                strlist_t patterns, estream_t outfp)
215 {
216   gpg_error_t err = 0;
217   gpg_error_t first_err = 0;
218   int any_server = 0;
219   int any_data = 0;
220   strlist_t sl;
221   uri_item_t uri;
222   estream_t infp;
223
224   if (!patterns)
225     return gpg_error (GPG_ERR_NO_USER_ID);
226
227   /* FIXME: We only take care of the first keyserver.  To fully
228      support multiple keyservers we need to track the result for each
229      pattern and use the next keyserver if one key was not found.  The
230      keyservers might not all be fully synced thus it is not clear
231      whether the first keyserver has the freshest copy of the key.
232      Need to think about a better strategy.  */
233   for (uri = keyservers; !err && uri; uri = uri->next)
234     {
235       int is_http = uri->parsed_uri->is_http;
236       int is_ldap = 0;
237
238 #if USE_LDAP
239       is_ldap = (strcmp (uri->parsed_uri->scheme, "ldap") == 0
240                  || strcmp (uri->parsed_uri->scheme, "ldaps") == 0
241                  || strcmp (uri->parsed_uri->scheme, "ldapi") == 0);
242 #endif
243
244       if (is_http || is_ldap)
245         {
246           any_server = 1;
247           for (sl = patterns; !err && sl; sl = sl->next)
248             {
249 #if USE_LDAP
250               if (is_ldap)
251                 err = ks_ldap_get (ctrl, uri->parsed_uri, sl->d, &infp);
252               else
253 #endif
254                 {
255                   err = ks_hkp_get (ctrl, uri->parsed_uri, sl->d, &infp);
256                 }
257
258               if (err)
259                 {
260                   /* It is possible that a server does not carry a
261                      key, thus we only save the error and continue
262                      with the next pattern.  FIXME: It is an open
263                      question how to return such an error condition to
264                      the caller.  */
265                   first_err = err;
266                   err = 0;
267                 }
268               else
269                 {
270                   err = copy_stream (infp, outfp);
271                   /* Reading from the keyserver should never fail, thus
272                      return this error.  */
273                   if (!err)
274                     any_data = 1;
275                   es_fclose (infp);
276                   infp = NULL;
277                 }
278             }
279         }
280       if (any_data)
281         break; /* Stop loop after a keyserver returned something.  */
282     }
283
284   if (!any_server)
285     err = gpg_error (GPG_ERR_NO_KEYSERVER);
286   else if (!err && first_err && !any_data)
287     err = first_err;
288   return err;
289 }
290
291
292 /* Retrieve keys from URL and write the result to the provided output
293    stream OUTFP.  */
294 gpg_error_t
295 ks_action_fetch (ctrl_t ctrl, const char *url, estream_t outfp)
296 {
297   gpg_error_t err = 0;
298   estream_t infp;
299   parsed_uri_t parsed_uri;  /* The broken down URI.  */
300
301   if (!url)
302     return gpg_error (GPG_ERR_INV_URI);
303
304   err = http_parse_uri (&parsed_uri, url, 1);
305   if (err)
306     return err;
307
308   if (parsed_uri->is_http)
309     {
310       err = ks_http_fetch (ctrl, url, &infp);
311       if (!err)
312         {
313           err = copy_stream (infp, outfp);
314           es_fclose (infp);
315         }
316     }
317   else if (!parsed_uri->opaque)
318     {
319       err = gpg_error (GPG_ERR_INV_URI);
320     }
321   else if (!strcmp (parsed_uri->scheme, "finger"))
322     {
323       err = ks_finger_fetch (ctrl, parsed_uri, &infp);
324       if (!err)
325         {
326           err = copy_stream (infp, outfp);
327           es_fclose (infp);
328         }
329     }
330   else if (!strcmp (parsed_uri->scheme, "kdns"))
331     {
332       err = ks_kdns_fetch (ctrl, parsed_uri, &infp);
333       if (!err)
334         {
335           err = copy_stream (infp, outfp);
336           es_fclose (infp);
337         }
338     }
339   else
340     err = gpg_error (GPG_ERR_INV_URI);
341
342   http_release_parsed_uri (parsed_uri);
343   return err;
344 }
345
346
347
348 /* Send an OpenPGP key to all keyservers.  The key in {DATA,DATALEN}
349    is expected to be in OpenPGP binary transport format.  The metadata
350    in {INFO,INFOLEN} is in colon-separated format (concretely, it is
351    the output of 'for x in keys sigs; do gpg --list-$x --with-colons
352    KEYID; done'.  This function may modify DATA and INFO.  If this is
353    a problem, then the caller should create a copy.  */
354 gpg_error_t
355 ks_action_put (ctrl_t ctrl, uri_item_t keyservers,
356                void *data, size_t datalen,
357                void *info, size_t infolen)
358 {
359   gpg_error_t err = 0;
360   gpg_error_t first_err = 0;
361   int any_server = 0;
362   uri_item_t uri;
363
364   (void) info;
365   (void) infolen;
366
367   for (uri = keyservers; !err && uri; uri = uri->next)
368     {
369       int is_http = uri->parsed_uri->is_http;
370       int is_ldap = 0;
371
372 #if USE_LDAP
373       is_ldap = (strcmp (uri->parsed_uri->scheme, "ldap") == 0
374                 || strcmp (uri->parsed_uri->scheme, "ldaps") == 0
375                 || strcmp (uri->parsed_uri->scheme, "ldapi") == 0);
376 #endif
377
378       if (is_http || is_ldap)
379         {
380           any_server = 1;
381 #if USE_LDAP
382           if (is_ldap)
383             err = ks_ldap_put (ctrl, uri->parsed_uri, data, datalen,
384                                info, infolen);
385           else
386 #endif
387             {
388               err = ks_hkp_put (ctrl, uri->parsed_uri, data, datalen);
389             }
390           if (err)
391             {
392               first_err = err;
393               err = 0;
394             }
395         }
396     }
397
398   if (!any_server)
399     err = gpg_error (GPG_ERR_NO_KEYSERVER);
400   else if (!err && first_err)
401     err = first_err;
402   return err;
403 }