Python bindings examples: PEP8 conpliance
[gpgme.git] / tests / run-encrypt.c
1 /* run-encrypt.c  - Helper to perform an encrypt operation
2  * Copyright (C) 2016 g10 Code GmbH
3  *
4  * This file is part of GPGME.
5  *
6  * GPGME is free software; you can redistribute it and/or modify it
7  * under the terms of the GNU Lesser General Public License as
8  * published by the Free Software Foundation; either version 2.1 of
9  * the License, or (at your option) any later version.
10  *
11  * GPGME is distributed in the hope that it will be useful, but
12  * WITHOUT ANY WARRANTY; without even the implied warranty of
13  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
14  * Lesser General Public License for more details.
15  *
16  * You should have received a copy of the GNU Lesser General Public
17  * License along with this program; if not, see <https://www.gnu.org/licenses/>.
18  */
19
20 /* We need to include config.h so that we know whether we are building
21    with large file system (LFS) support. */
22 #ifdef HAVE_CONFIG_H
23 #include <config.h>
24 #endif
25
26 #include <stdlib.h>
27 #include <stdio.h>
28 #include <string.h>
29
30 #include <gpgme.h>
31
32 #define PGM "run-encrypt"
33
34 #include "run-support.h"
35
36
37 static int verbose;
38
39
40 static char *
41 xstrdup (const char *string)
42 {
43   char *p = strdup (string);
44   if (!p)
45     {
46       fprintf (stderr, "strdup failed\n");
47       exit (2);
48     }
49   return p;
50 }
51
52
53 static gpg_error_t
54 status_cb (void *opaque, const char *keyword, const char *value)
55 {
56   (void)opaque;
57   fprintf (stderr, "status_cb: %s %s\n", nonnull(keyword), nonnull(value));
58   return 0;
59 }
60
61
62 static void
63 progress_cb (void *opaque, const char *what, int type, int current, int total)
64 {
65   (void)opaque;
66   (void)type;
67
68   if (total)
69     fprintf (stderr, "progress for '%s' %u%% (%d of %d)\n",
70              nonnull (what),
71              (unsigned)(((double)current / total) * 100), current, total);
72   else
73     fprintf (stderr, "progress for '%s' %d\n", nonnull(what), current);
74   fflush (stderr);
75 }
76
77
78 static void
79 print_result (gpgme_encrypt_result_t result)
80 {
81   gpgme_invalid_key_t invkey;
82
83   for (invkey = result->invalid_recipients; invkey; invkey = invkey->next)
84     printf ("Encryption key `%s' not used: %s <%s>\n",
85             nonnull (invkey->fpr),
86             gpg_strerror (invkey->reason), gpg_strsource (invkey->reason));
87 }
88
89
90
91 static int
92 show_usage (int ex)
93 {
94   fputs ("usage: " PGM " [options] FILE\n\n"
95          "Options:\n"
96          "  --verbose          run in verbose mode\n"
97          "  --status           print status lines from the backend\n"
98          "  --progress         print progress info\n"
99          "  --openpgp          use the OpenPGP protocol (default)\n"
100          "  --cms              use the CMS protocol\n"
101          "  --uiserver         use the UI server\n"
102          "  --loopback         use a loopback pinentry\n"
103          "  --key NAME         encrypt to key NAME\n"
104          "  --keystring NAMES  encrypt to ';' delimited NAMES\n"
105          "  --throw-keyids     use this option\n"
106          "  --no-symkey-cache  disable the use of that cache\n"
107          "  --wrap             assume input is valid OpenPGP message\n"
108          "  --symmetric        encrypt symmetric (OpenPGP only)\n"
109          , stderr);
110   exit (ex);
111 }
112
113
114 int
115 main (int argc, char **argv)
116 {
117   int last_argc = -1;
118   gpgme_error_t err;
119   gpgme_ctx_t ctx;
120   gpgme_protocol_t protocol = GPGME_PROTOCOL_OpenPGP;
121   gpgme_data_t in, out;
122   gpgme_encrypt_result_t result;
123   int print_status = 0;
124   int print_progress = 0;
125   int use_loopback = 0;
126   char *keyargs[10];
127   gpgme_key_t keys[10+1];
128   int keycount = 0;
129   char *keystring = NULL;
130   int i;
131   gpgme_encrypt_flags_t flags = GPGME_ENCRYPT_ALWAYS_TRUST;
132   gpgme_off_t offset;
133   int no_symkey_cache = 0;
134
135   if (argc)
136     { argc--; argv++; }
137
138   if (DIM(keys) != DIM(keyargs)+1)
139     abort ();
140
141   while (argc && last_argc != argc )
142     {
143       last_argc = argc;
144       if (!strcmp (*argv, "--"))
145         {
146           argc--; argv++;
147           break;
148         }
149       else if (!strcmp (*argv, "--help"))
150         show_usage (0);
151       else if (!strcmp (*argv, "--verbose"))
152         {
153           verbose = 1;
154           argc--; argv++;
155         }
156       else if (!strcmp (*argv, "--status"))
157         {
158           print_status = 1;
159           argc--; argv++;
160         }
161       else if (!strcmp (*argv, "--progress"))
162         {
163           print_progress = 1;
164           argc--; argv++;
165         }
166       else if (!strcmp (*argv, "--openpgp"))
167         {
168           protocol = GPGME_PROTOCOL_OpenPGP;
169           argc--; argv++;
170         }
171       else if (!strcmp (*argv, "--cms"))
172         {
173           protocol = GPGME_PROTOCOL_CMS;
174           argc--; argv++;
175         }
176       else if (!strcmp (*argv, "--uiserver"))
177         {
178           protocol = GPGME_PROTOCOL_UISERVER;
179           argc--; argv++;
180         }
181       else if (!strcmp (*argv, "--key"))
182         {
183           argc--; argv++;
184           if (!argc)
185             show_usage (1);
186           if (keycount == DIM (keyargs))
187             show_usage (1);
188           keyargs[keycount++] = *argv;
189           argc--; argv++;
190         }
191       else if (!strcmp (*argv, "--keystring"))
192         {
193           argc--; argv++;
194           if (!argc)
195             show_usage (1);
196           keystring = xstrdup (*argv);
197           for (i=0; keystring[i]; i++)
198             if (keystring[i] == ';')
199               keystring[i] = '\n';
200           argc--; argv++;
201         }
202       else if (!strcmp (*argv, "--throw-keyids"))
203         {
204           flags |= GPGME_ENCRYPT_THROW_KEYIDS;
205           argc--; argv++;
206         }
207       else if (!strcmp (*argv, "--wrap"))
208         {
209           flags |= GPGME_ENCRYPT_WRAP;
210           argc--; argv++;
211         }
212       else if (!strcmp (*argv, "--loopback"))
213         {
214           use_loopback = 1;
215           argc--; argv++;
216         }
217       else if (!strcmp (*argv, "--symmetric"))
218         {
219           flags |= GPGME_ENCRYPT_SYMMETRIC;
220           argc--; argv++;
221         }
222       else if (!strcmp (*argv, "--no-symkey-cache"))
223         {
224           no_symkey_cache = 1;
225           argc--; argv++;
226         }
227       else if (!strncmp (*argv, "--", 2))
228         show_usage (1);
229
230     }
231
232   if (argc != 1)
233     show_usage (1);
234
235   init_gpgme (protocol);
236
237   err = gpgme_new (&ctx);
238   fail_if_err (err);
239   gpgme_set_protocol (ctx, protocol);
240   gpgme_set_armor (ctx, 1);
241   if (print_status)
242     {
243       gpgme_set_status_cb (ctx, status_cb, NULL);
244       gpgme_set_ctx_flag (ctx, "full-status", "1");
245     }
246   if (print_progress)
247     gpgme_set_progress_cb (ctx, progress_cb, NULL);
248   if (use_loopback)
249     {
250       gpgme_set_pinentry_mode (ctx, GPGME_PINENTRY_MODE_LOOPBACK);
251       gpgme_set_passphrase_cb (ctx, passphrase_cb, NULL);
252     }
253   if (no_symkey_cache)
254     {
255       err = gpgme_set_ctx_flag (ctx, "no-symkey-cache", "1");
256       if (err)
257         {
258           fprintf (stderr, PGM ": error setting no-symkey-cache:  %s\n",
259                    gpgme_strerror (err));
260           exit (1);
261         }
262     }
263
264   for (i=0; i < keycount; i++)
265     {
266       err = gpgme_get_key (ctx, keyargs[i], &keys[i], 0);
267       fail_if_err (err);
268     }
269   keys[i] = NULL;
270
271   err = gpgme_data_new_from_file (&in, *argv, 1);
272   if (err)
273     {
274       fprintf (stderr, PGM ": error reading `%s': %s\n",
275                *argv, gpg_strerror (err));
276       exit (1);
277     }
278   offset = gpgme_data_seek (in, 0, SEEK_END);
279   if (offset == (gpgme_off_t)(-1))
280     {
281       err = gpg_error_from_syserror ();
282       fprintf (stderr, PGM ": error seeking `%s': %s\n",
283                *argv, gpg_strerror (err));
284       exit (1);
285     }
286   if (gpgme_data_seek (in, 0, SEEK_SET) == (gpgme_off_t)(-1))
287     {
288       err = gpg_error_from_syserror ();
289       fprintf (stderr, PGM ": error seeking `%s': %s\n",
290                *argv, gpg_strerror (err));
291       exit (1);
292     }
293   {
294     char numbuf[50];
295     char *p;
296
297     p = numbuf + sizeof numbuf;
298     *--p = 0;
299     do
300       {
301         *--p = '0' + (offset % 10);
302         offset /= 10;
303       }
304     while (offset);
305     err = gpgme_data_set_flag (in, "size-hint", p);
306     if (err)
307       {
308         fprintf (stderr, PGM ": error setting size-hint for `%s': %s\n",
309                  *argv, gpg_strerror (err));
310         exit (1);
311       }
312   }
313
314   err = gpgme_data_new (&out);
315   fail_if_err (err);
316
317   err = gpgme_op_encrypt_ext (ctx, keycount ? keys : NULL, keystring,
318                               flags, in, out);
319   result = gpgme_op_encrypt_result (ctx);
320   if (result)
321     print_result (result);
322   if (err)
323     {
324       fprintf (stderr, PGM ": encrypting failed: %s\n", gpg_strerror (err));
325       exit (1);
326     }
327
328   fputs ("Begin Output:\n", stdout);
329   print_data (out);
330   fputs ("End Output.\n", stdout);
331   gpgme_data_release (out);
332
333   gpgme_data_release (in);
334
335   for (i=0; i < keycount; i++)
336     gpgme_key_unref (keys[i]);
337   gpgme_release (ctx);
338   free (keystring);
339   return 0;
340 }