Line data Source code
1 : /* engine-gpg.c - Gpg Engine.
2 : Copyright (C) 2000 Werner Koch (dd9jn)
3 : Copyright (C) 2001, 2002, 2003, 2004, 2005, 2006, 2007,
4 : 2009, 2010, 2012, 2013 g10 Code GmbH
5 :
6 : This file is part of GPGME.
7 :
8 : GPGME is free software; you can redistribute it and/or modify it
9 : under the terms of the GNU Lesser General Public License as
10 : published by the Free Software Foundation; either version 2.1 of
11 : the License, or (at your option) any later version.
12 :
13 : GPGME is distributed in the hope that it will be useful, but
14 : WITHOUT ANY WARRANTY; without even the implied warranty of
15 : MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
16 : Lesser General Public License for more details.
17 :
18 : You should have received a copy of the GNU Lesser General Public
19 : License along with this program; if not, see <https://www.gnu.org/licenses/>.
20 : */
21 :
22 : #if HAVE_CONFIG_H
23 : #include <config.h>
24 : #endif
25 : #include <stdio.h>
26 : #include <stdlib.h>
27 : #include <string.h>
28 : #include <assert.h>
29 : #ifdef HAVE_UNISTD_H
30 : # include <unistd.h>
31 : #endif
32 : #ifdef HAVE_LOCALE_H
33 : #include <locale.h>
34 : #endif
35 :
36 : #include "gpgme.h"
37 : #include "util.h"
38 : #include "ops.h"
39 : #include "wait.h"
40 : #include "context.h" /*temp hack until we have GpmeData methods to do I/O */
41 : #include "priv-io.h"
42 : #include "sema.h"
43 : #include "debug.h"
44 : #include "data.h"
45 : #include "mbox-util.h"
46 :
47 : #include "engine-backend.h"
48 :
49 :
50 : /* This type is used to build a list of gpg arguments and data
51 : sources/sinks. */
52 : struct arg_and_data_s
53 : {
54 : struct arg_and_data_s *next;
55 : gpgme_data_t data; /* If this is not NULL, use arg below. */
56 : int inbound; /* True if this is used for reading from gpg. */
57 : int dup_to;
58 : int print_fd; /* Print the fd number and not the special form of it. */
59 : int *arg_locp; /* Write back the argv idx of this argument when
60 : building command line to this location. */
61 : char arg[1]; /* Used if data above is not used. */
62 : };
63 :
64 :
65 : struct fd_data_map_s
66 : {
67 : gpgme_data_t data;
68 : int inbound; /* true if this is used for reading from gpg */
69 : int dup_to;
70 : int fd; /* the fd to use */
71 : int peer_fd; /* the other side of the pipe */
72 : int arg_loc; /* The index into the argv for translation purposes. */
73 : void *tag;
74 : };
75 :
76 :
77 : /* NB.: R_LINE is allocated an gpgrt function and thus gpgrt_free
78 : * shall be used to release it. This takes care of custom memory
79 : * allocators and avoids problems on Windows with different runtimes
80 : * used for libgpg-error/gpgrt and gpgme. */
81 : typedef gpgme_error_t (*colon_preprocessor_t) (char *line, char **rline);
82 :
83 : struct engine_gpg
84 : {
85 : char *file_name;
86 : char *version;
87 :
88 : char *lc_messages;
89 : char *lc_ctype;
90 :
91 : struct arg_and_data_s *arglist;
92 : struct arg_and_data_s **argtail;
93 :
94 : struct
95 : {
96 : int fd[2];
97 : int arg_loc;
98 : size_t bufsize;
99 : char *buffer;
100 : size_t readpos;
101 : int eof;
102 : engine_status_handler_t fnc;
103 : void *fnc_value;
104 : gpgme_status_cb_t mon_cb;
105 : void *mon_cb_value;
106 : void *tag;
107 : } status;
108 :
109 : /* This is a kludge - see the comment at colon_line_handler. */
110 : struct
111 : {
112 : int fd[2];
113 : int arg_loc;
114 : size_t bufsize;
115 : char *buffer;
116 : size_t readpos;
117 : int eof;
118 : engine_colon_line_handler_t fnc; /* this indicate use of this structrue */
119 : void *fnc_value;
120 : void *tag;
121 : colon_preprocessor_t preprocess_fnc;
122 : } colon;
123 :
124 : char **argv;
125 : struct fd_data_map_s *fd_data_map;
126 :
127 : /* stuff needed for interactive (command) mode */
128 : struct
129 : {
130 : int used;
131 : int fd;
132 : void *cb_data;
133 : int idx; /* Index in fd_data_map */
134 : gpgme_status_code_t code; /* last code */
135 : char *keyword; /* what has been requested (malloced) */
136 : engine_command_handler_t fnc;
137 : void *fnc_value;
138 : } cmd;
139 :
140 : struct gpgme_io_cbs io_cbs;
141 : gpgme_pinentry_mode_t pinentry_mode;
142 : char request_origin[10];
143 : char *auto_key_locate;
144 : char *trust_model;
145 :
146 : struct {
147 : unsigned int no_symkey_cache : 1;
148 : unsigned int offline : 1;
149 : unsigned int ignore_mdc_error : 1;
150 : } flags;
151 :
152 : /* NULL or the data object fed to --override_session_key-fd. */
153 : gpgme_data_t override_session_key;
154 :
155 : /* Memory data containing diagnostics (--logger-fd) of gpg */
156 : gpgme_data_t diagnostics;
157 : };
158 :
159 : typedef struct engine_gpg *engine_gpg_t;
160 :
161 :
162 : static void
163 2698 : gpg_io_event (void *engine, gpgme_event_io_t type, void *type_data)
164 : {
165 2698 : engine_gpg_t gpg = engine;
166 :
167 2698 : TRACE3 (DEBUG_ENGINE, "gpgme:gpg_io_event", gpg,
168 : "event %p, type %d, type_data %p",
169 : gpg->io_cbs.event, type, type_data);
170 2698 : if (gpg->io_cbs.event)
171 2698 : (*gpg->io_cbs.event) (gpg->io_cbs.event_priv, type, type_data);
172 2699 : }
173 :
174 :
175 : static void
176 4737 : close_notify_handler (int fd, void *opaque)
177 : {
178 4737 : engine_gpg_t gpg = opaque;
179 4737 : assert (fd != -1);
180 :
181 4737 : if (gpg->status.fd[0] == fd)
182 : {
183 722 : if (gpg->status.tag)
184 722 : (*gpg->io_cbs.remove) (gpg->status.tag);
185 722 : gpg->status.fd[0] = -1;
186 : }
187 4015 : else if (gpg->status.fd[1] == fd)
188 721 : gpg->status.fd[1] = -1;
189 3294 : else if (gpg->colon.fd[0] == fd)
190 : {
191 328 : if (gpg->colon.tag)
192 328 : (*gpg->io_cbs.remove) (gpg->colon.tag);
193 328 : gpg->colon.fd[0] = -1;
194 : }
195 2966 : else if (gpg->colon.fd[1] == fd)
196 330 : gpg->colon.fd[1] = -1;
197 2636 : else if (gpg->cmd.fd == fd)
198 95 : gpg->cmd.fd = -1;
199 2541 : else if (gpg->fd_data_map)
200 : {
201 : int i;
202 :
203 4433 : for (i = 0; gpg->fd_data_map[i].data; i++)
204 : {
205 4433 : if (gpg->fd_data_map[i].fd == fd)
206 : {
207 1222 : if (gpg->fd_data_map[i].tag)
208 1222 : (*gpg->io_cbs.remove) (gpg->fd_data_map[i].tag);
209 1222 : gpg->fd_data_map[i].fd = -1;
210 1222 : break;
211 : }
212 3211 : if (gpg->fd_data_map[i].peer_fd == fd)
213 : {
214 1319 : gpg->fd_data_map[i].peer_fd = -1;
215 1319 : break;
216 : }
217 : }
218 : }
219 4737 : }
220 :
221 : /* If FRONT is true, push at the front of the list. Use this for
222 : options added late in the process. */
223 : static gpgme_error_t
224 15127 : _add_arg (engine_gpg_t gpg, const char *prefix, const char *arg, size_t arglen,
225 : int front, int *arg_locp)
226 : {
227 : struct arg_and_data_s *a;
228 15127 : size_t prefixlen = prefix? strlen (prefix) : 0;
229 :
230 15127 : assert (gpg);
231 15127 : assert (arg);
232 :
233 15127 : a = malloc (sizeof *a + prefixlen + arglen);
234 15127 : if (!a)
235 0 : return gpg_error_from_syserror ();
236 :
237 15127 : a->data = NULL;
238 15127 : a->dup_to = -1;
239 15127 : a->arg_locp = arg_locp;
240 :
241 15127 : if (prefixlen)
242 10 : memcpy (a->arg, prefix, prefixlen);
243 15127 : memcpy (a->arg + prefixlen, arg, arglen);
244 15127 : a->arg[prefixlen + arglen] = 0;
245 15127 : if (front)
246 : {
247 619 : a->next = gpg->arglist;
248 619 : if (!gpg->arglist)
249 : {
250 : /* If this is the first argument, we need to update the tail
251 : pointer. */
252 0 : gpg->argtail = &a->next;
253 : }
254 619 : gpg->arglist = a;
255 : }
256 : else
257 : {
258 14508 : a->next = NULL;
259 14508 : *gpg->argtail = a;
260 14508 : gpg->argtail = &a->next;
261 : }
262 :
263 15127 : return 0;
264 : }
265 :
266 :
267 : static gpgme_error_t
268 624 : add_arg_ext (engine_gpg_t gpg, const char *arg, int front)
269 : {
270 624 : return _add_arg (gpg, NULL, arg, strlen (arg), front, NULL);
271 : }
272 :
273 : static gpgme_error_t
274 732 : add_arg_with_locp (engine_gpg_t gpg, const char *arg, int *locp)
275 : {
276 732 : return _add_arg (gpg, NULL, arg, strlen (arg), 0, locp);
277 : }
278 :
279 : static gpgme_error_t
280 13753 : add_arg (engine_gpg_t gpg, const char *arg)
281 : {
282 13753 : return _add_arg (gpg, NULL, arg, strlen (arg), 0, NULL);
283 : }
284 :
285 : static gpgme_error_t
286 6 : add_arg_pfx (engine_gpg_t gpg, const char *prefix, const char *arg)
287 : {
288 6 : return _add_arg (gpg, prefix, arg, strlen (arg), 0, NULL);
289 : }
290 :
291 : static gpgme_error_t
292 4 : add_arg_len (engine_gpg_t gpg, const char *prefix,
293 : const char *arg, size_t arglen)
294 : {
295 4 : return _add_arg (gpg, prefix, arg, arglen, 0, NULL);
296 : }
297 :
298 :
299 : static gpgme_error_t
300 1338 : add_data (engine_gpg_t gpg, gpgme_data_t data, int dup_to, int inbound)
301 : {
302 : struct arg_and_data_s *a;
303 :
304 1338 : assert (gpg);
305 1338 : assert (data);
306 :
307 1338 : a = malloc (sizeof *a - 1);
308 1338 : if (!a)
309 0 : return gpg_error_from_syserror ();
310 1338 : a->next = NULL;
311 1338 : a->data = data;
312 1338 : a->inbound = inbound;
313 1338 : a->arg_locp = NULL;
314 :
315 1338 : if (dup_to == -2)
316 : {
317 828 : a->print_fd = 1;
318 828 : a->dup_to = -1;
319 : }
320 : else
321 : {
322 510 : a->print_fd = 0;
323 510 : a->dup_to = dup_to;
324 : }
325 1338 : *gpg->argtail = a;
326 1338 : gpg->argtail = &a->next;
327 1338 : return 0;
328 : }
329 :
330 :
331 : /* Return true if the engine's version is at least VERSION. */
332 : static int
333 1296 : have_gpg_version (engine_gpg_t gpg, const char *version)
334 : {
335 1296 : return _gpgme_compare_versions (gpg->version, version);
336 : }
337 :
338 :
339 :
340 : static char *
341 508 : gpg_get_version (const char *file_name)
342 : {
343 508 : return _gpgme_get_program_version (file_name ? file_name
344 : : _gpgme_get_default_gpg_name ());
345 : }
346 :
347 :
348 : static const char *
349 98 : gpg_get_req_version (void)
350 : {
351 98 : return "1.4.0";
352 : }
353 :
354 :
355 : static void
356 709 : free_argv (char **argv)
357 : {
358 : int i;
359 :
360 18788 : for (i = 0; argv[i]; i++)
361 18079 : free (argv[i]);
362 709 : free (argv);
363 709 : }
364 :
365 :
366 : static void
367 715 : free_fd_data_map (struct fd_data_map_s *fd_data_map)
368 : {
369 : int i;
370 :
371 715 : if (!fd_data_map)
372 0 : return;
373 :
374 2025 : for (i = 0; fd_data_map[i].data; i++)
375 : {
376 1310 : if (fd_data_map[i].fd != -1)
377 56 : _gpgme_io_close (fd_data_map[i].fd);
378 1310 : if (fd_data_map[i].peer_fd != -1)
379 0 : _gpgme_io_close (fd_data_map[i].peer_fd);
380 : /* Don't release data because this is only a reference. */
381 : }
382 715 : free (fd_data_map);
383 : }
384 :
385 :
386 : static gpgme_error_t
387 739 : gpg_cancel (void *engine)
388 : {
389 739 : engine_gpg_t gpg = engine;
390 :
391 739 : if (!gpg)
392 0 : return gpg_error (GPG_ERR_INV_VALUE);
393 :
394 : /* If gpg may be waiting for a cmd, close the cmd fd first. On
395 : Windows, close operations block on the reader/writer thread. */
396 739 : if (gpg->cmd.used)
397 : {
398 99 : if (gpg->cmd.fd != -1)
399 95 : _gpgme_io_close (gpg->cmd.fd);
400 4 : else if (gpg->fd_data_map
401 0 : && gpg->fd_data_map[gpg->cmd.idx].fd != -1)
402 0 : _gpgme_io_close (gpg->fd_data_map[gpg->cmd.idx].fd);
403 : }
404 :
405 739 : if (gpg->status.fd[0] != -1)
406 32 : _gpgme_io_close (gpg->status.fd[0]);
407 739 : if (gpg->status.fd[1] != -1)
408 0 : _gpgme_io_close (gpg->status.fd[1]);
409 739 : if (gpg->colon.fd[0] != -1)
410 6 : _gpgme_io_close (gpg->colon.fd[0]);
411 739 : if (gpg->colon.fd[1] != -1)
412 0 : _gpgme_io_close (gpg->colon.fd[1]);
413 739 : if (gpg->fd_data_map)
414 : {
415 715 : free_fd_data_map (gpg->fd_data_map);
416 715 : gpg->fd_data_map = NULL;
417 : }
418 :
419 739 : return 0;
420 : }
421 :
422 : static void
423 709 : gpg_release (void *engine)
424 : {
425 709 : engine_gpg_t gpg = engine;
426 :
427 709 : if (!gpg)
428 0 : return;
429 :
430 709 : gpg_cancel (engine);
431 :
432 709 : if (gpg->file_name)
433 709 : free (gpg->file_name);
434 709 : if (gpg->version)
435 709 : free (gpg->version);
436 :
437 709 : if (gpg->lc_messages)
438 141 : free (gpg->lc_messages);
439 709 : if (gpg->lc_ctype)
440 141 : free (gpg->lc_ctype);
441 :
442 17385 : while (gpg->arglist)
443 : {
444 15967 : struct arg_and_data_s *next = gpg->arglist->next;
445 :
446 15967 : free (gpg->arglist);
447 15967 : gpg->arglist = next;
448 : }
449 :
450 709 : if (gpg->status.buffer)
451 709 : free (gpg->status.buffer);
452 709 : if (gpg->colon.buffer)
453 326 : free (gpg->colon.buffer);
454 709 : if (gpg->argv)
455 709 : free_argv (gpg->argv);
456 709 : if (gpg->cmd.keyword)
457 41 : free (gpg->cmd.keyword);
458 709 : free (gpg->auto_key_locate);
459 709 : free (gpg->trust_model);
460 :
461 709 : gpgme_data_release (gpg->override_session_key);
462 709 : gpgme_data_release (gpg->diagnostics);
463 :
464 709 : free (gpg);
465 : }
466 :
467 :
468 : static gpgme_error_t
469 732 : gpg_new (void **engine, const char *file_name, const char *home_dir,
470 : const char *version)
471 : {
472 : engine_gpg_t gpg;
473 732 : gpgme_error_t rc = 0;
474 732 : char *dft_display = NULL;
475 : char dft_ttyname[64];
476 732 : char *dft_ttytype = NULL;
477 732 : char *env_tty = NULL;
478 :
479 732 : gpg = calloc (1, sizeof *gpg);
480 732 : if (!gpg)
481 0 : return gpg_error_from_syserror ();
482 :
483 732 : if (file_name)
484 : {
485 731 : gpg->file_name = strdup (file_name);
486 731 : if (!gpg->file_name)
487 : {
488 0 : rc = gpg_error_from_syserror ();
489 0 : goto leave;
490 : }
491 : }
492 :
493 732 : if (version)
494 : {
495 732 : gpg->version = strdup (version);
496 732 : if (!gpg->version)
497 : {
498 0 : rc = gpg_error_from_syserror ();
499 0 : goto leave;
500 : }
501 : }
502 :
503 732 : gpg->argtail = &gpg->arglist;
504 732 : gpg->status.fd[0] = -1;
505 732 : gpg->status.fd[1] = -1;
506 732 : gpg->colon.fd[0] = -1;
507 732 : gpg->colon.fd[1] = -1;
508 732 : gpg->cmd.fd = -1;
509 732 : gpg->cmd.idx = -1;
510 :
511 : /* Allocate the read buffer for the status pipe. */
512 732 : gpg->status.bufsize = 1024;
513 732 : gpg->status.readpos = 0;
514 732 : gpg->status.buffer = malloc (gpg->status.bufsize);
515 732 : if (!gpg->status.buffer)
516 : {
517 0 : rc = gpg_error_from_syserror ();
518 0 : goto leave;
519 : }
520 : /* In any case we need a status pipe - create it right here and
521 : don't handle it with our generic gpgme_data_t mechanism. */
522 732 : if (_gpgme_io_pipe (gpg->status.fd, 1) == -1)
523 : {
524 0 : rc = gpg_error_from_syserror ();
525 0 : goto leave;
526 : }
527 732 : if (_gpgme_io_set_close_notify (gpg->status.fd[0],
528 : close_notify_handler, gpg)
529 732 : || _gpgme_io_set_close_notify (gpg->status.fd[1],
530 : close_notify_handler, gpg))
531 : {
532 0 : rc = gpg_error (GPG_ERR_GENERAL);
533 0 : goto leave;
534 : }
535 732 : gpg->status.eof = 0;
536 :
537 732 : if (home_dir)
538 : {
539 230 : rc = add_arg (gpg, "--homedir");
540 230 : if (!rc)
541 230 : rc = add_arg (gpg, home_dir);
542 230 : if (rc)
543 0 : goto leave;
544 : }
545 :
546 732 : rc = add_arg (gpg, "--status-fd");
547 732 : if (rc)
548 0 : goto leave;
549 :
550 : {
551 : char buf[25];
552 732 : _gpgme_io_fd2str (buf, sizeof (buf), gpg->status.fd[1]);
553 732 : rc = add_arg_with_locp (gpg, buf, &gpg->status.arg_loc);
554 731 : if (rc)
555 0 : goto leave;
556 : }
557 :
558 731 : rc = add_arg (gpg, "--no-tty");
559 732 : if (!rc)
560 732 : rc = add_arg (gpg, "--charset");
561 731 : if (!rc)
562 731 : rc = add_arg (gpg, "utf8");
563 731 : if (!rc)
564 731 : rc = add_arg (gpg, "--enable-progress-filter");
565 732 : if (!rc && have_gpg_version (gpg, "2.1.11"))
566 731 : rc = add_arg (gpg, "--exit-on-status-write-error");
567 732 : if (rc)
568 0 : goto leave;
569 :
570 732 : rc = _gpgme_getenv ("DISPLAY", &dft_display);
571 731 : if (rc)
572 0 : goto leave;
573 731 : if (dft_display)
574 : {
575 731 : rc = add_arg (gpg, "--display");
576 731 : if (!rc)
577 731 : rc = add_arg (gpg, dft_display);
578 :
579 731 : free (dft_display);
580 731 : if (rc)
581 0 : goto leave;
582 : }
583 :
584 731 : rc = _gpgme_getenv ("GPG_TTY", &env_tty);
585 732 : if (isatty (1) || env_tty || rc)
586 : {
587 731 : int err = 0;
588 :
589 731 : if (rc)
590 0 : goto leave;
591 731 : else if (env_tty)
592 : {
593 0 : snprintf (dft_ttyname, sizeof (dft_ttyname), "%s", env_tty);
594 0 : free (env_tty);
595 : }
596 : else
597 731 : err = ttyname_r (1, dft_ttyname, sizeof (dft_ttyname));
598 :
599 : /* Even though isatty() returns 1, ttyname_r() may fail in many
600 : ways, e.g., when /dev/pts is not accessible under chroot. */
601 732 : if (!err)
602 : {
603 732 : if (*dft_ttyname)
604 : {
605 732 : rc = add_arg (gpg, "--ttyname");
606 731 : if (!rc)
607 731 : rc = add_arg (gpg, dft_ttyname);
608 : }
609 : else
610 0 : rc = 0;
611 731 : if (!rc)
612 : {
613 730 : rc = _gpgme_getenv ("TERM", &dft_ttytype);
614 731 : if (rc)
615 0 : goto leave;
616 :
617 731 : if (dft_ttytype)
618 : {
619 731 : rc = add_arg (gpg, "--ttytype");
620 731 : if (!rc)
621 732 : rc = add_arg (gpg, dft_ttytype);
622 : }
623 :
624 731 : free (dft_ttytype);
625 : }
626 732 : if (rc)
627 0 : goto leave;
628 : }
629 : }
630 :
631 733 : rc = gpgme_data_new (&gpg->diagnostics);
632 732 : if (rc)
633 0 : goto leave;
634 :
635 732 : rc = add_arg (gpg, "--logger-fd");
636 732 : if (rc)
637 0 : goto leave;
638 :
639 732 : rc = add_data (gpg, gpg->diagnostics, -2, 1);
640 :
641 : leave:
642 732 : if (rc)
643 0 : gpg_release (gpg);
644 : else
645 732 : *engine = gpg;
646 732 : return rc;
647 : }
648 :
649 :
650 : /* Copy flags from CTX into the engine object. */
651 : static void
652 732 : gpg_set_engine_flags (void *engine, const gpgme_ctx_t ctx)
653 : {
654 732 : engine_gpg_t gpg = engine;
655 :
656 732 : if (ctx->request_origin && have_gpg_version (gpg, "2.2.6"))
657 : {
658 0 : if (strlen (ctx->request_origin) + 1 > sizeof gpg->request_origin)
659 0 : strcpy (gpg->request_origin, "xxx"); /* Too long - force error */
660 : else
661 0 : strcpy (gpg->request_origin, ctx->request_origin);
662 : }
663 : else
664 732 : *gpg->request_origin = 0;
665 :
666 732 : if (ctx->auto_key_locate && have_gpg_version (gpg, "2.1.18"))
667 : {
668 0 : if (gpg->auto_key_locate)
669 0 : free (gpg->auto_key_locate);
670 0 : gpg->auto_key_locate = _gpgme_strconcat ("--auto-key-locate=",
671 : ctx->auto_key_locate, NULL);
672 : }
673 :
674 732 : if (ctx->trust_model && strlen (ctx->trust_model))
675 : {
676 0 : if (gpg->trust_model)
677 0 : free (gpg->trust_model);
678 0 : gpg->trust_model = _gpgme_strconcat ("--trust-model=",
679 : ctx->trust_model, NULL);
680 : }
681 :
682 1464 : gpg->flags.no_symkey_cache = (ctx->no_symkey_cache
683 732 : && have_gpg_version (gpg, "2.2.7"));
684 732 : gpg->flags.offline = (ctx->offline && have_gpg_version (gpg, "2.1.23"));
685 :
686 732 : gpg->flags.ignore_mdc_error = !!ctx->ignore_mdc_error;
687 :
688 732 : }
689 :
690 :
691 : static gpgme_error_t
692 1464 : gpg_set_locale (void *engine, int category, const char *value)
693 : {
694 1464 : engine_gpg_t gpg = engine;
695 :
696 : if (0)
697 : ;
698 : #ifdef LC_CTYPE
699 1464 : else if (category == LC_CTYPE)
700 : {
701 732 : if (gpg->lc_ctype)
702 : {
703 0 : free (gpg->lc_ctype);
704 0 : gpg->lc_ctype = NULL;
705 : }
706 732 : if (value)
707 : {
708 156 : gpg->lc_ctype = strdup (value);
709 156 : if (!gpg->lc_ctype)
710 0 : return gpg_error_from_syserror ();
711 : }
712 : }
713 : #endif
714 : #ifdef LC_MESSAGES
715 732 : else if (category == LC_MESSAGES)
716 : {
717 732 : if (gpg->lc_messages)
718 : {
719 0 : free (gpg->lc_messages);
720 0 : gpg->lc_messages = NULL;
721 : }
722 732 : if (value)
723 : {
724 156 : gpg->lc_messages = strdup (value);
725 156 : if (!gpg->lc_messages)
726 0 : return gpg_error_from_syserror ();
727 : }
728 : }
729 : #endif /* LC_MESSAGES */
730 : else
731 0 : return gpg_error (GPG_ERR_INV_VALUE);
732 :
733 1464 : return 0;
734 : }
735 :
736 : /* This sets a status callback for monitoring status lines before they
737 : * are passed to a caller set handler. */
738 : static void
739 4 : gpg_set_status_cb (void *engine, gpgme_status_cb_t cb, void *cb_value)
740 : {
741 4 : engine_gpg_t gpg = engine;
742 :
743 4 : gpg->status.mon_cb = cb;
744 4 : gpg->status.mon_cb_value = cb_value;
745 4 : }
746 :
747 :
748 : /* Note, that the status_handler is allowed to modify the args
749 : value. */
750 : static void
751 761 : gpg_set_status_handler (void *engine, engine_status_handler_t fnc,
752 : void *fnc_value)
753 : {
754 761 : engine_gpg_t gpg = engine;
755 :
756 761 : gpg->status.fnc = fnc;
757 761 : gpg->status.fnc_value = fnc_value;
758 761 : }
759 :
760 : /* Kludge to process --with-colon output. */
761 : static gpgme_error_t
762 337 : gpg_set_colon_line_handler (void *engine, engine_colon_line_handler_t fnc,
763 : void *fnc_value)
764 : {
765 337 : engine_gpg_t gpg = engine;
766 :
767 337 : gpg->colon.bufsize = 1024;
768 337 : gpg->colon.readpos = 0;
769 337 : gpg->colon.buffer = malloc (gpg->colon.bufsize);
770 337 : if (!gpg->colon.buffer)
771 0 : return gpg_error_from_syserror ();
772 :
773 337 : if (_gpgme_io_pipe (gpg->colon.fd, 1) == -1)
774 : {
775 0 : int saved_err = gpg_error_from_syserror ();
776 0 : free (gpg->colon.buffer);
777 0 : gpg->colon.buffer = NULL;
778 0 : return saved_err;
779 : }
780 337 : if (_gpgme_io_set_close_notify (gpg->colon.fd[0], close_notify_handler, gpg)
781 337 : || _gpgme_io_set_close_notify (gpg->colon.fd[1],
782 : close_notify_handler, gpg))
783 0 : return gpg_error (GPG_ERR_GENERAL);
784 337 : gpg->colon.eof = 0;
785 337 : gpg->colon.fnc = fnc;
786 337 : gpg->colon.fnc_value = fnc_value;
787 337 : return 0;
788 : }
789 :
790 :
791 : static gpgme_error_t
792 84 : command_handler (void *opaque, int fd)
793 : {
794 84 : struct io_cb_data *data = (struct io_cb_data *) opaque;
795 84 : engine_gpg_t gpg = (engine_gpg_t) data->handler_value;
796 : gpgme_error_t err;
797 84 : int processed = 0;
798 84 : assert (gpg->cmd.used);
799 84 : assert (gpg->cmd.code);
800 84 : assert (gpg->cmd.fnc);
801 :
802 84 : err = gpg->cmd.fnc (gpg->cmd.fnc_value, gpg->cmd.code, gpg->cmd.keyword, fd,
803 : &processed);
804 :
805 84 : gpg->cmd.code = 0;
806 : /* And sleep again until read_status will wake us up again. */
807 : /* XXX We must check if there are any more fds active after removing
808 : this one. */
809 84 : (*gpg->io_cbs.remove) (gpg->fd_data_map[gpg->cmd.idx].tag);
810 84 : gpg->cmd.fd = gpg->fd_data_map[gpg->cmd.idx].fd;
811 84 : gpg->fd_data_map[gpg->cmd.idx].fd = -1;
812 :
813 84 : if (err)
814 6 : return err;
815 :
816 : /* We always need to send at least a newline character. */
817 78 : if (!processed)
818 0 : _gpgme_io_write (fd, "\n", 1);
819 :
820 78 : return 0;
821 : }
822 :
823 :
824 :
825 : /* The FNC will be called to get a value for one of the commands with
826 : * a key KEY. If the code passed to FNC is 0, the function may
827 : * release resources associated with the returned value from another
828 : * call. To match such a second call to a first call, the returned
829 : * value from the first call is passed as keyword. */
830 : static gpgme_error_t
831 96 : gpg_set_command_handler (void *engine, engine_command_handler_t fnc,
832 : void *fnc_value)
833 : {
834 96 : engine_gpg_t gpg = engine;
835 : gpgme_error_t rc;
836 :
837 96 : rc = add_arg (gpg, "--command-fd");
838 96 : if (rc)
839 0 : return rc;
840 :
841 : /* This is a hack. We don't have a real data object. The only
842 : thing that matters is that we use something unique, so we use the
843 : address of the cmd structure in the gpg object. */
844 96 : rc = add_data (gpg, (void *) &gpg->cmd, -2, 0);
845 96 : if (rc)
846 0 : return rc;
847 :
848 96 : gpg->cmd.fnc = fnc;
849 96 : gpg->cmd.cb_data = (void *) &gpg->cmd;
850 96 : gpg->cmd.fnc_value = fnc_value;
851 96 : gpg->cmd.used = 1;
852 96 : return 0;
853 : }
854 :
855 :
856 : static gpgme_error_t
857 732 : build_argv (engine_gpg_t gpg, const char *pgmname)
858 : {
859 : gpgme_error_t err;
860 : struct arg_and_data_s *a;
861 : struct fd_data_map_s *fd_data_map;
862 732 : size_t datac=0, argc=0;
863 : char **argv;
864 732 : int need_special = 0;
865 732 : int use_agent = 0;
866 : char *p;
867 :
868 732 : if (_gpgme_in_gpg_one_mode ())
869 : {
870 : /* In GnuPG-1 mode we don't want to use the agent with a
871 : malformed environment variable. This is only a very basic
872 : test but sufficient to make our life in the regression tests
873 : easier. With GnuPG-2 the agent is anyway required and on
874 : modern installations GPG_AGENT_INFO is optional. */
875 0 : err = _gpgme_getenv ("GPG_AGENT_INFO", &p);
876 0 : if (err)
877 0 : return err;
878 0 : use_agent = (p && strchr (p, ':'));
879 0 : if (p)
880 0 : free (p);
881 : }
882 :
883 732 : if (gpg->argv)
884 : {
885 0 : free_argv (gpg->argv);
886 0 : gpg->argv = NULL;
887 : }
888 732 : if (gpg->fd_data_map)
889 : {
890 0 : free_fd_data_map (gpg->fd_data_map);
891 0 : gpg->fd_data_map = NULL;
892 : }
893 :
894 732 : argc++; /* For argv[0]. */
895 17212 : for (a = gpg->arglist; a; a = a->next)
896 : {
897 16480 : argc++;
898 16480 : if (a->data)
899 : {
900 : /*fprintf (stderr, "build_argv: data\n" );*/
901 1338 : datac++;
902 1338 : if (a->dup_to == -1 && !a->print_fd)
903 282 : need_special = 1;
904 : }
905 : else
906 : {
907 : /* fprintf (stderr, "build_argv: arg=`%s'\n", a->arg );*/
908 : }
909 : }
910 732 : if (need_special)
911 257 : argc++;
912 732 : if (use_agent)
913 0 : argc++;
914 732 : if (gpg->pinentry_mode)
915 54 : argc++;
916 732 : if (!gpg->cmd.used)
917 636 : argc++; /* --batch */
918 732 : argc += 4; /* --no-sk-comments, --request-origin, --no-symkey-cache */
919 : /* --disable-dirmngr */
920 :
921 732 : argv = calloc (argc + 1, sizeof *argv);
922 732 : if (!argv)
923 0 : return gpg_error_from_syserror ();
924 732 : fd_data_map = calloc (datac + 1, sizeof *fd_data_map);
925 732 : if (!fd_data_map)
926 : {
927 0 : int saved_err = gpg_error_from_syserror ();
928 0 : free_argv (argv);
929 0 : return saved_err;
930 : }
931 :
932 732 : argc = datac = 0;
933 732 : argv[argc] = strdup (_gpgme_get_basename (pgmname)); /* argv[0] */
934 730 : if (!argv[argc])
935 : {
936 0 : int saved_err = gpg_error_from_syserror ();
937 0 : free (fd_data_map);
938 0 : free_argv (argv);
939 0 : return saved_err;
940 : }
941 730 : argc++;
942 730 : if (need_special)
943 : {
944 257 : argv[argc] = strdup ("--enable-special-filenames");
945 257 : if (!argv[argc])
946 : {
947 0 : int saved_err = gpg_error_from_syserror ();
948 0 : free (fd_data_map);
949 0 : free_argv (argv);
950 0 : return saved_err;
951 : }
952 257 : argc++;
953 : }
954 730 : if (use_agent)
955 : {
956 0 : argv[argc] = strdup ("--use-agent");
957 0 : if (!argv[argc])
958 : {
959 0 : int saved_err = gpg_error_from_syserror ();
960 0 : free (fd_data_map);
961 0 : free_argv (argv);
962 0 : return saved_err;
963 : }
964 0 : argc++;
965 : }
966 :
967 730 : if (*gpg->request_origin)
968 : {
969 0 : argv[argc] = _gpgme_strconcat ("--request-origin=",
970 0 : gpg->request_origin, NULL);
971 0 : if (!argv[argc])
972 : {
973 0 : int saved_err = gpg_error_from_syserror ();
974 0 : free (fd_data_map);
975 0 : free_argv (argv);
976 0 : return saved_err;
977 : }
978 0 : argc++;
979 : }
980 :
981 730 : if (gpg->auto_key_locate)
982 : {
983 0 : argv[argc] = strdup (gpg->auto_key_locate);
984 0 : if (!argv[argc])
985 : {
986 0 : int saved_err = gpg_error_from_syserror ();
987 0 : free (fd_data_map);
988 0 : free_argv (argv);
989 0 : return saved_err;
990 : }
991 0 : argc++;
992 : }
993 :
994 730 : if (gpg->trust_model)
995 : {
996 0 : argv[argc] = strdup (gpg->trust_model);
997 0 : if (!argv[argc])
998 : {
999 0 : int saved_err = gpg_error_from_syserror ();
1000 0 : free (fd_data_map);
1001 0 : free_argv (argv);
1002 0 : return saved_err;
1003 : }
1004 0 : argc++;
1005 : }
1006 :
1007 730 : if (gpg->flags.no_symkey_cache)
1008 : {
1009 0 : argv[argc] = strdup ("--no-symkey-cache");
1010 0 : if (!argv[argc])
1011 : {
1012 0 : int saved_err = gpg_error_from_syserror ();
1013 0 : free (fd_data_map);
1014 0 : free_argv (argv);
1015 0 : return saved_err;
1016 : }
1017 0 : argc++;
1018 : }
1019 :
1020 730 : if (gpg->flags.ignore_mdc_error)
1021 : {
1022 0 : argv[argc] = strdup ("--ignore-mdc-error");
1023 0 : if (!argv[argc])
1024 : {
1025 0 : int saved_err = gpg_error_from_syserror ();
1026 0 : free (fd_data_map);
1027 0 : free_argv (argv);
1028 0 : return saved_err;
1029 : }
1030 0 : argc++;
1031 : }
1032 :
1033 730 : if (gpg->flags.offline)
1034 : {
1035 0 : argv[argc] = strdup ("--disable-dirmngr");
1036 0 : if (!argv[argc])
1037 : {
1038 0 : int saved_err = gpg_error_from_syserror ();
1039 0 : free (fd_data_map);
1040 0 : free_argv (argv);
1041 0 : return saved_err;
1042 : }
1043 0 : argc++;
1044 : }
1045 :
1046 730 : if (gpg->pinentry_mode && have_gpg_version (gpg, "2.1.0"))
1047 : {
1048 54 : const char *s = NULL;
1049 54 : switch (gpg->pinentry_mode)
1050 : {
1051 0 : case GPGME_PINENTRY_MODE_DEFAULT: break;
1052 0 : case GPGME_PINENTRY_MODE_ASK: s = "--pinentry-mode=ask"; break;
1053 0 : case GPGME_PINENTRY_MODE_CANCEL: s = "--pinentry-mode=cancel"; break;
1054 0 : case GPGME_PINENTRY_MODE_ERROR: s = "--pinentry-mode=error"; break;
1055 54 : case GPGME_PINENTRY_MODE_LOOPBACK:s = "--pinentry-mode=loopback"; break;
1056 : }
1057 54 : if (s)
1058 : {
1059 54 : argv[argc] = strdup (s);
1060 54 : if (!argv[argc])
1061 : {
1062 0 : int saved_err = gpg_error_from_syserror ();
1063 0 : free (fd_data_map);
1064 0 : free_argv (argv);
1065 0 : return saved_err;
1066 : }
1067 54 : argc++;
1068 : }
1069 : }
1070 :
1071 730 : if (!gpg->cmd.used)
1072 : {
1073 636 : argv[argc] = strdup ("--batch");
1074 636 : if (!argv[argc])
1075 : {
1076 0 : int saved_err = gpg_error_from_syserror ();
1077 0 : free (fd_data_map);
1078 0 : free_argv (argv);
1079 0 : return saved_err;
1080 : }
1081 636 : argc++;
1082 : }
1083 730 : argv[argc] = strdup ("--no-sk-comments");
1084 730 : if (!argv[argc])
1085 : {
1086 0 : int saved_err = gpg_error_from_syserror ();
1087 0 : free (fd_data_map);
1088 0 : free_argv (argv);
1089 0 : return saved_err;
1090 : }
1091 730 : argc++;
1092 17203 : for (a = gpg->arglist; a; a = a->next)
1093 : {
1094 16471 : if (a->arg_locp)
1095 732 : *(a->arg_locp) = argc;
1096 :
1097 16471 : if (a->data)
1098 : {
1099 : /* Create a pipe to pass it down to gpg. */
1100 1336 : fd_data_map[datac].inbound = a->inbound;
1101 :
1102 : /* Create a pipe. */
1103 : {
1104 : int fds[2];
1105 :
1106 1336 : if (_gpgme_io_pipe (fds, fd_data_map[datac].inbound ? 1 : 0)
1107 : == -1)
1108 : {
1109 0 : int saved_err = gpg_error_from_syserror ();
1110 0 : free (fd_data_map);
1111 0 : free_argv (argv);
1112 0 : return saved_err;
1113 : }
1114 1338 : if (_gpgme_io_set_close_notify (fds[0],
1115 : close_notify_handler, gpg)
1116 1338 : || _gpgme_io_set_close_notify (fds[1],
1117 : close_notify_handler,
1118 : gpg))
1119 : {
1120 : /* We leak fd_data_map and the fds. This is not easy
1121 : to avoid and given that we reach this here only
1122 : after a malloc failure for a small object, it is
1123 : probably better not to do anything. */
1124 0 : return gpg_error (GPG_ERR_GENERAL);
1125 : }
1126 : /* If the data_type is FD, we have to do a dup2 here. */
1127 1337 : if (fd_data_map[datac].inbound)
1128 : {
1129 959 : fd_data_map[datac].fd = fds[0];
1130 959 : fd_data_map[datac].peer_fd = fds[1];
1131 : }
1132 : else
1133 : {
1134 378 : fd_data_map[datac].fd = fds[1];
1135 378 : fd_data_map[datac].peer_fd = fds[0];
1136 : }
1137 : }
1138 :
1139 : /* Hack to get hands on the fd later. */
1140 1337 : if (gpg->cmd.used)
1141 : {
1142 361 : if (gpg->cmd.cb_data == a->data)
1143 : {
1144 96 : assert (gpg->cmd.idx == -1);
1145 96 : gpg->cmd.idx = datac;
1146 : }
1147 : }
1148 :
1149 1337 : fd_data_map[datac].data = a->data;
1150 1337 : fd_data_map[datac].dup_to = a->dup_to;
1151 :
1152 1337 : if (a->dup_to == -1)
1153 : {
1154 : char *ptr;
1155 1109 : int buflen = 25;
1156 :
1157 1109 : argv[argc] = malloc (buflen);
1158 1109 : if (!argv[argc])
1159 : {
1160 0 : int saved_err = gpg_error_from_syserror ();
1161 0 : free (fd_data_map);
1162 0 : free_argv (argv);
1163 0 : return saved_err;
1164 : }
1165 :
1166 1109 : ptr = argv[argc];
1167 1109 : if (!a->print_fd)
1168 : {
1169 282 : *(ptr++) = '-';
1170 282 : *(ptr++) = '&';
1171 282 : buflen -= 2;
1172 : }
1173 :
1174 1109 : _gpgme_io_fd2str (ptr, buflen, fd_data_map[datac].peer_fd);
1175 1110 : fd_data_map[datac].arg_loc = argc;
1176 1110 : argc++;
1177 : }
1178 1338 : datac++;
1179 : }
1180 : else
1181 : {
1182 15135 : argv[argc] = strdup (a->arg);
1183 15135 : if (!argv[argc])
1184 : {
1185 0 : int saved_err = gpg_error_from_syserror ();
1186 0 : free (fd_data_map);
1187 0 : free_argv (argv);
1188 0 : return saved_err;
1189 : }
1190 15135 : argc++;
1191 : }
1192 : }
1193 :
1194 732 : gpg->argv = argv;
1195 732 : gpg->fd_data_map = fd_data_map;
1196 732 : return 0;
1197 : }
1198 :
1199 :
1200 : static gpgme_error_t
1201 2358 : add_io_cb (engine_gpg_t gpg, int fd, int dir, gpgme_io_cb_t handler, void *data,
1202 : void **tag)
1203 : {
1204 : gpgme_error_t err;
1205 :
1206 2358 : err = (*gpg->io_cbs.add) (gpg->io_cbs.add_priv, fd, dir, handler, data, tag);
1207 2358 : if (err)
1208 0 : return err;
1209 2358 : if (!dir)
1210 : /* FIXME Kludge around poll() problem. */
1211 359 : err = _gpgme_io_set_nonblocking (fd);
1212 2358 : return err;
1213 : }
1214 :
1215 :
1216 : /* Handle the status output of GnuPG. This function does read entire
1217 : lines and passes them as C strings to the callback function (we can
1218 : use C Strings because the status output is always UTF-8 encoded).
1219 : Of course we have to buffer the lines to cope with long lines
1220 : e.g. with a large user ID. Note: We can optimize this to only cope
1221 : with status line code we know about and skip all other stuff
1222 : without buffering (i.e. without extending the buffer). */
1223 : static gpgme_error_t
1224 4976 : read_status (engine_gpg_t gpg)
1225 : {
1226 : char *p;
1227 : int nread;
1228 4976 : size_t bufsize = gpg->status.bufsize;
1229 4976 : char *buffer = gpg->status.buffer;
1230 4976 : size_t readpos = gpg->status.readpos;
1231 : gpgme_error_t err;
1232 :
1233 4976 : assert (buffer);
1234 4976 : if (bufsize - readpos < 256)
1235 : {
1236 : /* Need more room for the read. */
1237 0 : bufsize += 1024;
1238 0 : buffer = realloc (buffer, bufsize);
1239 0 : if (!buffer)
1240 0 : return gpg_error_from_syserror ();
1241 : }
1242 :
1243 9952 : nread = _gpgme_io_read (gpg->status.fd[0],
1244 4976 : buffer + readpos, bufsize-readpos);
1245 4974 : if (nread == -1)
1246 0 : return gpg_error_from_syserror ();
1247 :
1248 4974 : if (!nread)
1249 : {
1250 702 : err = 0;
1251 702 : gpg->status.eof = 1;
1252 702 : if (gpg->status.mon_cb)
1253 2 : err = gpg->status.mon_cb (gpg->status.mon_cb_value, "", "");
1254 702 : if (gpg->status.fnc)
1255 : {
1256 702 : char emptystring[1] = {0};
1257 702 : err = gpg->status.fnc (gpg->status.fnc_value,
1258 : GPGME_STATUS_EOF, emptystring);
1259 702 : if (gpg_err_code (err) == GPG_ERR_FALSE)
1260 0 : err = 0; /* Drop special error code. */
1261 : }
1262 :
1263 702 : return err;
1264 : }
1265 :
1266 13624 : while (nread > 0)
1267 : {
1268 231070 : for (p = buffer + readpos; nread; nread--, p++)
1269 : {
1270 231069 : if (*p == '\n')
1271 : {
1272 : /* (we require that the last line is terminated by a LF) */
1273 5092 : if (p > buffer && p[-1] == '\r')
1274 0 : p[-1] = 0;
1275 5092 : *p = 0;
1276 5092 : if (!strncmp (buffer, "[GNUPG:] ", 9)
1277 5093 : && buffer[9] >= 'A' && buffer[9] <= 'Z')
1278 : {
1279 : char *rest;
1280 : gpgme_status_code_t r;
1281 :
1282 5092 : rest = strchr (buffer + 9, ' ');
1283 5092 : if (!rest)
1284 398 : rest = p; /* Set to an empty string. */
1285 : else
1286 4694 : *rest++ = 0;
1287 :
1288 5092 : r = _gpgme_parse_status (buffer + 9);
1289 5093 : if (gpg->status.mon_cb && r != GPGME_STATUS_PROGRESS)
1290 : {
1291 : /* Note that we call the monitor even if we do
1292 : * not know the status code (r < 0). */
1293 16 : err = gpg->status.mon_cb (gpg->status.mon_cb_value,
1294 8 : buffer + 9, rest);
1295 8 : if (err)
1296 2 : return err;
1297 : }
1298 : if (r >= 0)
1299 : {
1300 5091 : if (gpg->cmd.used
1301 1165 : && (r == GPGME_STATUS_GET_BOOL
1302 1157 : || r == GPGME_STATUS_GET_LINE
1303 1113 : || r == GPGME_STATUS_GET_HIDDEN))
1304 : {
1305 84 : gpg->cmd.code = r;
1306 84 : if (gpg->cmd.keyword)
1307 41 : free (gpg->cmd.keyword);
1308 84 : gpg->cmd.keyword = strdup (rest);
1309 84 : if (!gpg->cmd.keyword)
1310 0 : return gpg_error_from_syserror ();
1311 : /* This should be the last thing we have
1312 : received and the next thing will be that
1313 : the command handler does its action. */
1314 84 : if (nread > 1)
1315 0 : TRACE0 (DEBUG_CTX, "gpgme:read_status", 0,
1316 : "error: unexpected data");
1317 :
1318 84 : add_io_cb (gpg, gpg->cmd.fd, 0,
1319 : command_handler, gpg,
1320 84 : &gpg->fd_data_map[gpg->cmd.idx].tag);
1321 84 : gpg->fd_data_map[gpg->cmd.idx].fd = gpg->cmd.fd;
1322 84 : gpg->cmd.fd = -1;
1323 : }
1324 5007 : else if (gpg->status.fnc)
1325 : {
1326 5007 : err = gpg->status.fnc (gpg->status.fnc_value,
1327 : r, rest);
1328 5005 : if (gpg_err_code (err) == GPG_ERR_FALSE)
1329 0 : err = 0; /* Drop special error code. */
1330 5005 : if (err)
1331 10 : return err;
1332 : }
1333 : }
1334 : }
1335 : /* To reuse the buffer for the next line we have to
1336 : shift the remaining data to the buffer start and
1337 : restart the loop Hmmm: We can optimize this function
1338 : by looking forward in the buffer to see whether a
1339 : second complete line is available and in this case
1340 : avoid the memmove for this line. */
1341 5079 : nread--; p++;
1342 5079 : if (nread)
1343 820 : memmove (buffer, p, nread);
1344 5079 : readpos = 0;
1345 5079 : break; /* the for loop */
1346 : }
1347 : else
1348 225977 : readpos++;
1349 : }
1350 : }
1351 :
1352 : /* Update the gpg object. */
1353 4259 : gpg->status.bufsize = bufsize;
1354 4259 : gpg->status.buffer = buffer;
1355 4259 : gpg->status.readpos = readpos;
1356 4259 : return 0;
1357 : }
1358 :
1359 :
1360 : static gpgme_error_t
1361 4976 : status_handler (void *opaque, int fd)
1362 : {
1363 4976 : struct io_cb_data *data = (struct io_cb_data *) opaque;
1364 4976 : engine_gpg_t gpg = (engine_gpg_t) data->handler_value;
1365 : int err;
1366 :
1367 4976 : assert (fd == gpg->status.fd[0]);
1368 4976 : err = read_status (gpg);
1369 4973 : if (err)
1370 24 : return err;
1371 4949 : if (gpg->status.eof)
1372 690 : _gpgme_io_close (fd);
1373 4949 : return 0;
1374 : }
1375 :
1376 :
1377 : static gpgme_error_t
1378 1001 : read_colon_line (engine_gpg_t gpg)
1379 : {
1380 : char *p;
1381 : int nread;
1382 1001 : size_t bufsize = gpg->colon.bufsize;
1383 1001 : char *buffer = gpg->colon.buffer;
1384 1001 : size_t readpos = gpg->colon.readpos;
1385 :
1386 1001 : assert (buffer);
1387 1001 : if (bufsize - readpos < 256)
1388 : {
1389 : /* Need more room for the read. */
1390 0 : bufsize += 1024;
1391 0 : buffer = realloc (buffer, bufsize);
1392 0 : if (!buffer)
1393 0 : return gpg_error_from_syserror ();
1394 : }
1395 :
1396 1001 : nread = _gpgme_io_read (gpg->colon.fd[0], buffer+readpos, bufsize-readpos);
1397 985 : if (nread == -1)
1398 0 : return gpg_error_from_syserror ();
1399 :
1400 985 : if (!nread)
1401 : {
1402 322 : gpg->colon.eof = 1;
1403 322 : assert (gpg->colon.fnc);
1404 322 : gpg->colon.fnc (gpg->colon.fnc_value, NULL);
1405 322 : return 0;
1406 : }
1407 :
1408 7215 : while (nread > 0)
1409 : {
1410 391941 : for (p = buffer + readpos; nread; nread--, p++)
1411 : {
1412 391699 : if ( *p == '\n' )
1413 : {
1414 : /* (we require that the last line is terminated by a LF)
1415 : and we skip empty lines. Note: we use UTF8 encoding
1416 : and escaping of special characters. We require at
1417 : least one colon to cope with some other printed
1418 : information. */
1419 5638 : *p = 0;
1420 5638 : if (*buffer && strchr (buffer, ':'))
1421 : {
1422 5641 : char *line = NULL;
1423 :
1424 5641 : if (gpg->colon.preprocess_fnc)
1425 : {
1426 : gpgme_error_t err;
1427 :
1428 0 : err = gpg->colon.preprocess_fnc (buffer, &line);
1429 0 : if (err)
1430 0 : return err;
1431 : }
1432 :
1433 5653 : assert (gpg->colon.fnc);
1434 5653 : if (line)
1435 : {
1436 0 : char *linep = line;
1437 : char *endp;
1438 :
1439 : do
1440 : {
1441 0 : endp = strchr (linep, '\n');
1442 0 : if (endp)
1443 0 : *endp++ = 0;
1444 0 : gpg->colon.fnc (gpg->colon.fnc_value, linep);
1445 0 : linep = endp;
1446 : }
1447 0 : while (linep && *linep);
1448 :
1449 0 : gpgrt_free (line);
1450 : }
1451 : else
1452 5653 : gpg->colon.fnc (gpg->colon.fnc_value, buffer);
1453 : }
1454 :
1455 : /* To reuse the buffer for the next line we have to
1456 : shift the remaining data to the buffer start and
1457 : restart the loop Hmmm: We can optimize this function
1458 : by looking forward in the buffer to see whether a
1459 : second complete line is available and in this case
1460 : avoid the memmove for this line. */
1461 5647 : nread--; p++;
1462 5647 : if (nread)
1463 5202 : memmove (buffer, p, nread);
1464 5647 : readpos = 0;
1465 5647 : break; /* The for loop. */
1466 : }
1467 : else
1468 386061 : readpos++;
1469 : }
1470 : }
1471 :
1472 : /* Update the gpg object. */
1473 672 : gpg->colon.bufsize = bufsize;
1474 672 : gpg->colon.buffer = buffer;
1475 672 : gpg->colon.readpos = readpos;
1476 672 : return 0;
1477 : }
1478 :
1479 :
1480 : /* This colonline handler thing is not the clean way to do it. It
1481 : might be better to enhance the gpgme_data_t object to act as a wrapper
1482 : for a callback. Same goes for the status thing. For now we use
1483 : this thing here because it is easier to implement. */
1484 : static gpgme_error_t
1485 1001 : colon_line_handler (void *opaque, int fd)
1486 : {
1487 1001 : struct io_cb_data *data = (struct io_cb_data *) opaque;
1488 1001 : engine_gpg_t gpg = (engine_gpg_t) data->handler_value;
1489 1001 : gpgme_error_t rc = 0;
1490 :
1491 1001 : assert (fd == gpg->colon.fd[0]);
1492 1001 : rc = read_colon_line (gpg);
1493 994 : if (rc)
1494 0 : return rc;
1495 994 : if (gpg->colon.eof)
1496 322 : _gpgme_io_close (fd);
1497 994 : return 0;
1498 : }
1499 :
1500 :
1501 : static gpgme_error_t
1502 727 : start (engine_gpg_t gpg)
1503 : {
1504 : gpgme_error_t rc;
1505 : int i, n;
1506 : int status;
1507 : struct spawn_fd_item_s *fd_list;
1508 : pid_t pid;
1509 : const char *pgmname;
1510 :
1511 727 : if (!gpg)
1512 0 : return gpg_error (GPG_ERR_INV_VALUE);
1513 :
1514 727 : if (!gpg->file_name && !_gpgme_get_default_gpg_name ())
1515 0 : return trace_gpg_error (GPG_ERR_INV_ENGINE);
1516 :
1517 727 : if (gpg->lc_ctype)
1518 : {
1519 156 : rc = add_arg_ext (gpg, gpg->lc_ctype, 1);
1520 156 : if (!rc)
1521 156 : rc = add_arg_ext (gpg, "--lc-ctype", 1);
1522 161 : if (rc)
1523 0 : return rc;
1524 : }
1525 :
1526 732 : if (gpg->lc_messages)
1527 : {
1528 156 : rc = add_arg_ext (gpg, gpg->lc_messages, 1);
1529 156 : if (!rc)
1530 156 : rc = add_arg_ext (gpg, "--lc-messages", 1);
1531 156 : if (rc)
1532 0 : return rc;
1533 : }
1534 :
1535 732 : pgmname = gpg->file_name ? gpg->file_name : _gpgme_get_default_gpg_name ();
1536 732 : rc = build_argv (gpg, pgmname);
1537 732 : if (rc)
1538 0 : return rc;
1539 :
1540 : /* status_fd, colon_fd and end of list. */
1541 732 : n = 3;
1542 2070 : for (i = 0; gpg->fd_data_map[i].data; i++)
1543 1338 : n++;
1544 732 : fd_list = calloc (n, sizeof *fd_list);
1545 732 : if (! fd_list)
1546 0 : return gpg_error_from_syserror ();
1547 :
1548 : /* Build the fd list for the child. */
1549 732 : n = 0;
1550 732 : fd_list[n].fd = gpg->status.fd[1];
1551 732 : fd_list[n].dup_to = -1;
1552 732 : fd_list[n].arg_loc = gpg->status.arg_loc;
1553 732 : n++;
1554 732 : if (gpg->colon.fnc)
1555 : {
1556 337 : fd_list[n].fd = gpg->colon.fd[1];
1557 337 : fd_list[n].dup_to = 1;
1558 337 : n++;
1559 : }
1560 2070 : for (i = 0; gpg->fd_data_map[i].data; i++)
1561 : {
1562 1338 : fd_list[n].fd = gpg->fd_data_map[i].peer_fd;
1563 1338 : fd_list[n].dup_to = gpg->fd_data_map[i].dup_to;
1564 1338 : fd_list[n].arg_loc = gpg->fd_data_map[i].arg_loc;
1565 1338 : n++;
1566 : }
1567 732 : fd_list[n].fd = -1;
1568 732 : fd_list[n].dup_to = -1;
1569 :
1570 732 : status = _gpgme_io_spawn (pgmname, gpg->argv,
1571 : (IOSPAWN_FLAG_DETACHED |IOSPAWN_FLAG_ALLOW_SET_FG),
1572 : fd_list, NULL, NULL, &pid);
1573 : {
1574 721 : int saved_err = gpg_error_from_syserror ();
1575 721 : free (fd_list);
1576 721 : if (status == -1)
1577 0 : return saved_err;
1578 : }
1579 :
1580 : /*_gpgme_register_term_handler ( closure, closure_value, pid );*/
1581 :
1582 721 : rc = add_io_cb (gpg, gpg->status.fd[0], 1, status_handler, gpg,
1583 : &gpg->status.tag);
1584 721 : if (rc)
1585 : /* FIXME: kill the child */
1586 0 : return rc;
1587 :
1588 721 : if (gpg->colon.fnc)
1589 : {
1590 330 : assert (gpg->colon.fd[0] != -1);
1591 330 : rc = add_io_cb (gpg, gpg->colon.fd[0], 1, colon_line_handler, gpg,
1592 : &gpg->colon.tag);
1593 330 : if (rc)
1594 : /* FIXME: kill the child */
1595 0 : return rc;
1596 : }
1597 :
1598 2040 : for (i = 0; gpg->fd_data_map[i].data; i++)
1599 : {
1600 1319 : if (gpg->cmd.used && i == gpg->cmd.idx)
1601 : {
1602 : /* Park the cmd fd. */
1603 96 : gpg->cmd.fd = gpg->fd_data_map[i].fd;
1604 96 : gpg->fd_data_map[i].fd = -1;
1605 : }
1606 : else
1607 : {
1608 3669 : rc = add_io_cb (gpg, gpg->fd_data_map[i].fd,
1609 1223 : gpg->fd_data_map[i].inbound,
1610 1223 : gpg->fd_data_map[i].inbound
1611 : ? _gpgme_data_inbound_handler
1612 : : _gpgme_data_outbound_handler,
1613 2446 : gpg->fd_data_map[i].data, &gpg->fd_data_map[i].tag);
1614 :
1615 1223 : if (rc)
1616 : /* FIXME: kill the child */
1617 0 : return rc;
1618 : }
1619 : }
1620 :
1621 721 : gpg_io_event (gpg, GPGME_EVENT_START, NULL);
1622 :
1623 : /* fixme: check what data we can release here */
1624 721 : return 0;
1625 : }
1626 :
1627 :
1628 : /* Add the --input-size-hint option if requested. */
1629 : static gpgme_error_t
1630 232 : add_input_size_hint (engine_gpg_t gpg, gpgme_data_t data)
1631 : {
1632 : gpgme_error_t err;
1633 232 : gpgme_off_t value = _gpgme_data_get_size_hint (data);
1634 : char numbuf[50]; /* Large enough for even 2^128 in base-10. */
1635 : char *p;
1636 :
1637 232 : if (!value || !have_gpg_version (gpg, "2.1.15"))
1638 206 : return 0;
1639 :
1640 26 : err = add_arg (gpg, "--input-size-hint");
1641 26 : if (!err)
1642 : {
1643 26 : p = numbuf + sizeof numbuf;
1644 26 : *--p = 0;
1645 : do
1646 : {
1647 67 : *--p = '0' + (value % 10);
1648 67 : value /= 10;
1649 : }
1650 67 : while (value);
1651 26 : err = add_arg (gpg, p);
1652 : }
1653 26 : return err;
1654 : }
1655 :
1656 :
1657 : static gpgme_error_t
1658 49 : gpg_decrypt (void *engine,
1659 : gpgme_decrypt_flags_t flags,
1660 : gpgme_data_t ciph, gpgme_data_t plain,
1661 : int export_session_key, const char *override_session_key,
1662 : int auto_key_retrieve)
1663 : {
1664 49 : engine_gpg_t gpg = engine;
1665 : gpgme_error_t err;
1666 :
1667 49 : err = add_arg (gpg, "--decrypt");
1668 :
1669 49 : if (!err && (flags & GPGME_DECRYPT_UNWRAP))
1670 : {
1671 1 : if (!have_gpg_version (gpg, "2.1.12"))
1672 0 : err = gpg_error (GPG_ERR_NOT_SUPPORTED);
1673 : else
1674 1 : err = add_arg (gpg, "--unwrap");
1675 : }
1676 :
1677 49 : if (!err && export_session_key)
1678 0 : err = add_arg (gpg, "--show-session-key");
1679 :
1680 49 : if (!err && auto_key_retrieve)
1681 0 : err = add_arg (gpg, "--auto-key-retrieve");
1682 :
1683 49 : if (!err && override_session_key && *override_session_key)
1684 : {
1685 0 : if (have_gpg_version (gpg, "2.1.16"))
1686 : {
1687 0 : gpgme_data_release (gpg->override_session_key);
1688 0 : TRACE2 (DEBUG_ENGINE, "override", gpg, "seskey='%s' len=%zu\n",
1689 : override_session_key,
1690 : strlen (override_session_key));
1691 :
1692 0 : err = gpgme_data_new_from_mem (&gpg->override_session_key,
1693 : override_session_key,
1694 : strlen (override_session_key), 1);
1695 0 : if (!err)
1696 : {
1697 : /* We add --no-keyring because a keyring is not required
1698 : * when we are overriding the session key. It would
1699 : * work without that option but --no-keyring avoids that
1700 : * gpg return a failure due to a missing key log_error()
1701 : * diagnostic. --no-keyring is supported since 2.1.14. */
1702 0 : err = add_arg (gpg, "--no-keyring");
1703 0 : if (!err)
1704 0 : err = add_arg (gpg, "--override-session-key-fd");
1705 0 : if (!err)
1706 0 : err = add_data (gpg, gpg->override_session_key, -2, 0);
1707 : }
1708 : }
1709 : else
1710 : {
1711 : /* Using that option may leak the session key via ps(1). */
1712 0 : err = add_arg (gpg, "--override-session-key");
1713 0 : if (!err)
1714 0 : err = add_arg (gpg, override_session_key);
1715 : }
1716 : }
1717 :
1718 : /* Tell the gpg object about the data. */
1719 49 : if (!err)
1720 49 : err = add_arg (gpg, "--output");
1721 49 : if (!err)
1722 49 : err = add_arg (gpg, "-");
1723 49 : if (!err)
1724 49 : err = add_data (gpg, plain, 1, 1);
1725 49 : if (!err)
1726 49 : err = add_input_size_hint (gpg, ciph);
1727 49 : if (!err)
1728 49 : err = add_arg (gpg, "--");
1729 49 : if (!err)
1730 49 : err = add_data (gpg, ciph, -1, 0);
1731 :
1732 49 : if (!err)
1733 49 : err = start (gpg);
1734 49 : return err;
1735 : }
1736 :
1737 : static gpgme_error_t
1738 0 : gpg_delete (void *engine, gpgme_key_t key, unsigned int flags)
1739 : {
1740 0 : engine_gpg_t gpg = engine;
1741 0 : gpgme_error_t err = 0;
1742 0 : int allow_secret = flags & GPGME_DELETE_ALLOW_SECRET;
1743 0 : int force = flags & GPGME_DELETE_FORCE;
1744 :
1745 0 : if (force)
1746 0 : err = add_arg (gpg, "--yes");
1747 0 : if (!err)
1748 0 : err = add_arg (gpg, allow_secret ? "--delete-secret-and-public-key"
1749 : : "--delete-key");
1750 0 : if (!err)
1751 0 : err = add_arg (gpg, "--");
1752 0 : if (!err)
1753 : {
1754 0 : if (!key->subkeys || !key->subkeys->fpr)
1755 0 : return gpg_error (GPG_ERR_INV_VALUE);
1756 : else
1757 0 : err = add_arg (gpg, key->subkeys->fpr);
1758 : }
1759 :
1760 0 : if (!err)
1761 0 : err = start (gpg);
1762 0 : return err;
1763 : }
1764 :
1765 :
1766 : static gpgme_error_t
1767 0 : gpg_passwd (void *engine, gpgme_key_t key, unsigned int flags)
1768 : {
1769 0 : engine_gpg_t gpg = engine;
1770 : gpgme_error_t err;
1771 :
1772 : (void)flags;
1773 :
1774 0 : if (!key || !key->subkeys || !key->subkeys->fpr)
1775 0 : return gpg_error (GPG_ERR_INV_CERT_OBJ);
1776 :
1777 0 : err = add_arg (gpg, "--passwd");
1778 0 : if (!err)
1779 0 : err = add_arg (gpg, key->subkeys->fpr);
1780 0 : if (!err)
1781 0 : err = start (gpg);
1782 0 : return err;
1783 : }
1784 :
1785 :
1786 : static gpgme_error_t
1787 84 : append_args_from_signers (engine_gpg_t gpg, gpgme_ctx_t ctx /* FIXME */)
1788 : {
1789 84 : gpgme_error_t err = 0;
1790 : int i;
1791 : gpgme_key_t key;
1792 :
1793 139 : for (i = 0; (key = gpgme_signers_enum (ctx, i)); i++)
1794 : {
1795 55 : const char *s = key->subkeys ? key->subkeys->keyid : NULL;
1796 55 : if (s)
1797 : {
1798 55 : if (!err)
1799 55 : err = add_arg (gpg, "-u");
1800 55 : if (!err)
1801 55 : err = add_arg (gpg, s);
1802 : }
1803 55 : gpgme_key_unref (key);
1804 55 : if (err)
1805 0 : break;
1806 : }
1807 84 : return err;
1808 : }
1809 :
1810 :
1811 : static gpgme_error_t
1812 119 : append_args_from_sender (engine_gpg_t gpg, gpgme_ctx_t ctx)
1813 : {
1814 : gpgme_error_t err;
1815 :
1816 119 : if (ctx->sender && have_gpg_version (gpg, "2.1.15"))
1817 : {
1818 1 : err = add_arg (gpg, "--sender");
1819 3 : if (!err)
1820 1 : err = add_arg (gpg, ctx->sender);
1821 : }
1822 : else
1823 118 : err = 0;
1824 120 : return err;
1825 : }
1826 :
1827 :
1828 : static gpgme_error_t
1829 63 : append_args_from_sig_notations (engine_gpg_t gpg, gpgme_ctx_t ctx /* FIXME */)
1830 : {
1831 63 : gpgme_error_t err = 0;
1832 : gpgme_sig_notation_t notation;
1833 :
1834 63 : notation = gpgme_sig_notation_get (ctx);
1835 :
1836 135 : while (!err && notation)
1837 : {
1838 9 : if (notation->name
1839 6 : && !(notation->flags & GPGME_SIG_NOTATION_HUMAN_READABLE))
1840 0 : err = gpg_error (GPG_ERR_INV_VALUE);
1841 9 : else if (notation->name)
1842 : {
1843 : char *arg;
1844 :
1845 : /* Maximum space needed is one byte for the "critical" flag,
1846 : the name, one byte for '=', the value, and a terminating
1847 : '\0'. */
1848 :
1849 6 : arg = malloc (1 + notation->name_len + 1 + notation->value_len + 1);
1850 6 : if (!arg)
1851 0 : err = gpg_error_from_syserror ();
1852 :
1853 6 : if (!err)
1854 : {
1855 6 : char *argp = arg;
1856 :
1857 6 : if (notation->critical)
1858 3 : *(argp++) = '!';
1859 :
1860 6 : memcpy (argp, notation->name, notation->name_len);
1861 6 : argp += notation->name_len;
1862 :
1863 6 : *(argp++) = '=';
1864 :
1865 : /* We know that notation->name is '\0' terminated. */
1866 6 : strcpy (argp, notation->value);
1867 : }
1868 :
1869 6 : if (!err)
1870 6 : err = add_arg (gpg, "--sig-notation");
1871 6 : if (!err)
1872 6 : err = add_arg (gpg, arg);
1873 :
1874 6 : if (arg)
1875 6 : free (arg);
1876 : }
1877 : else
1878 : {
1879 : /* This is a policy URL. */
1880 :
1881 : char *value;
1882 :
1883 3 : if (notation->critical)
1884 : {
1885 0 : value = malloc (1 + notation->value_len + 1);
1886 0 : if (!value)
1887 0 : err = gpg_error_from_syserror ();
1888 : else
1889 : {
1890 0 : value[0] = '!';
1891 : /* We know that notation->value is '\0' terminated. */
1892 0 : strcpy (&value[1], notation->value);
1893 : }
1894 : }
1895 : else
1896 3 : value = notation->value;
1897 :
1898 3 : if (!err)
1899 3 : err = add_arg (gpg, "--sig-policy-url");
1900 3 : if (!err)
1901 3 : err = add_arg (gpg, value);
1902 :
1903 3 : if (value != notation->value)
1904 0 : free (value);
1905 : }
1906 :
1907 9 : notation = notation->next;
1908 : }
1909 63 : return err;
1910 : }
1911 :
1912 :
1913 : static gpgme_error_t
1914 13 : gpg_edit (void *engine, int type, gpgme_key_t key, gpgme_data_t out,
1915 : gpgme_ctx_t ctx /* FIXME */)
1916 : {
1917 13 : engine_gpg_t gpg = engine;
1918 : gpgme_error_t err;
1919 :
1920 13 : err = add_arg (gpg, "--with-colons");
1921 13 : if (!err)
1922 13 : err = append_args_from_signers (gpg, ctx);
1923 13 : if (!err)
1924 13 : err = add_arg (gpg, type == 0 ? "--edit-key" : "--card-edit");
1925 13 : if (!err)
1926 13 : err = add_data (gpg, out, 1, 1);
1927 13 : if (!err)
1928 13 : err = add_arg (gpg, "--");
1929 13 : if (!err && type == 0)
1930 : {
1931 13 : const char *s = key->subkeys ? key->subkeys->fpr : NULL;
1932 13 : if (!s)
1933 0 : err = gpg_error (GPG_ERR_INV_VALUE);
1934 : else
1935 13 : err = add_arg (gpg, s);
1936 : }
1937 13 : if (!err)
1938 13 : err = start (gpg);
1939 :
1940 13 : return err;
1941 : }
1942 :
1943 :
1944 : /* Add a single argument from a key to an -r option. */
1945 : static gpg_error_t
1946 95 : add_arg_recipient (engine_gpg_t gpg, gpgme_encrypt_flags_t flags,
1947 : gpgme_key_t key)
1948 : {
1949 : gpg_error_t err;
1950 :
1951 95 : if ((flags & GPGME_ENCRYPT_WANT_ADDRESS))
1952 : {
1953 : /* We have no way to figure out which mail address was
1954 : * requested. FIXME: It would be possible to figure this out by
1955 : * consulting the SENDER property of the context. */
1956 0 : err = gpg_error (GPG_ERR_INV_USER_ID);
1957 : }
1958 : else
1959 95 : err = add_arg (gpg, key->subkeys->fpr);
1960 :
1961 95 : return err;
1962 : }
1963 :
1964 :
1965 : /* Add a single argument from a USERID string to an -r option. */
1966 : static gpg_error_t
1967 0 : add_arg_recipient_string (engine_gpg_t gpg, gpgme_encrypt_flags_t flags,
1968 : const char *userid, int useridlen)
1969 : {
1970 : gpg_error_t err;
1971 :
1972 0 : if ((flags & GPGME_ENCRYPT_WANT_ADDRESS))
1973 : {
1974 : char *tmpstr, *mbox;
1975 :
1976 0 : tmpstr = malloc (useridlen + 1);
1977 0 : if (!tmpstr)
1978 0 : err = gpg_error_from_syserror ();
1979 : else
1980 : {
1981 0 : memcpy (tmpstr, userid, useridlen);
1982 0 : tmpstr[useridlen] = 0;
1983 :
1984 0 : mbox = _gpgme_mailbox_from_userid (tmpstr);
1985 0 : if (!mbox)
1986 : {
1987 0 : err = gpg_error_from_syserror ();
1988 0 : if (gpg_err_code (err) == GPG_ERR_EINVAL)
1989 0 : err = gpg_error (GPG_ERR_INV_USER_ID);
1990 : }
1991 : else
1992 0 : err = add_arg (gpg, mbox);
1993 :
1994 0 : free (mbox);
1995 0 : free (tmpstr);
1996 : }
1997 : }
1998 : else
1999 0 : err = add_arg_len (gpg, NULL, userid, useridlen);
2000 :
2001 0 : return err;
2002 : }
2003 :
2004 :
2005 : static gpgme_error_t
2006 57 : append_args_from_recipients (engine_gpg_t gpg, gpgme_encrypt_flags_t flags,
2007 : gpgme_key_t recp[])
2008 : {
2009 57 : gpgme_error_t err = 0;
2010 57 : int i = 0;
2011 :
2012 209 : while (recp[i])
2013 : {
2014 95 : if (!recp[i]->subkeys || !recp[i]->subkeys->fpr)
2015 0 : err = gpg_error (GPG_ERR_INV_VALUE);
2016 95 : if (!err)
2017 95 : err = add_arg (gpg, "-r");
2018 95 : if (!err)
2019 95 : err = add_arg_recipient (gpg, flags, recp[i]);
2020 95 : if (err)
2021 0 : break;
2022 95 : i++;
2023 : }
2024 57 : return err;
2025 : }
2026 :
2027 :
2028 : /* Take recipients from the LF delimited STRING and add -r args. */
2029 : static gpg_error_t
2030 0 : append_args_from_recipients_string (engine_gpg_t gpg,
2031 : gpgme_encrypt_flags_t flags,
2032 : const char *string)
2033 : {
2034 0 : gpg_error_t err = 0;
2035 0 : gpgme_encrypt_flags_t orig_flags = flags;
2036 0 : int any = 0;
2037 0 : int ignore = 0;
2038 0 : int hidden = 0;
2039 0 : int file = 0;
2040 : const char *s;
2041 : int n;
2042 :
2043 : do
2044 : {
2045 : /* Skip leading white space */
2046 0 : while (*string == ' ' || *string == '\t')
2047 0 : string++;
2048 0 : if (!*string)
2049 0 : break;
2050 :
2051 : /* Look for the LF. */
2052 0 : s = strchr (string, '\n');
2053 0 : if (s)
2054 0 : n = s - string;
2055 : else
2056 0 : n = strlen (string);
2057 0 : while (n && (string[n-1] == ' ' || string[n-1] == '\t'))
2058 0 : n--;
2059 :
2060 0 : if (!ignore && n == 2 && !memcmp (string, "--", 2))
2061 0 : ignore = 1;
2062 0 : else if (!ignore && n == 8 && !memcmp (string, "--hidden", 8))
2063 0 : hidden = 1;
2064 0 : else if (!ignore && n == 11 && !memcmp (string, "--no-hidden", 11))
2065 0 : hidden = 0;
2066 0 : else if (!ignore && n == 6 && !memcmp (string, "--file", 6))
2067 : {
2068 0 : file = 1;
2069 : /* Because the key is used as is we need to ignore this flag: */
2070 0 : flags &= ~GPGME_ENCRYPT_WANT_ADDRESS;
2071 : }
2072 0 : else if (!ignore && n == 9 && !memcmp (string, "--no-file", 9))
2073 : {
2074 0 : file = 0;
2075 0 : flags = orig_flags;
2076 : }
2077 0 : else if (n) /* Not empty - use it. */
2078 : {
2079 0 : err = add_arg (gpg, file? (hidden? "-F":"-f") : (hidden? "-R":"-r"));
2080 0 : if (!err)
2081 0 : err = add_arg_recipient_string (gpg, flags, string, n);
2082 0 : if (!err)
2083 0 : any = 1;
2084 : }
2085 :
2086 0 : string += n + !!s;
2087 : }
2088 0 : while (!err);
2089 :
2090 0 : if (!err && !any)
2091 0 : err = gpg_error (GPG_ERR_MISSING_KEY);
2092 0 : return err;
2093 : }
2094 :
2095 :
2096 : static gpgme_error_t
2097 63 : gpg_encrypt (void *engine, gpgme_key_t recp[], const char *recpstring,
2098 : gpgme_encrypt_flags_t flags,
2099 : gpgme_data_t plain, gpgme_data_t ciph, int use_armor)
2100 : {
2101 63 : engine_gpg_t gpg = engine;
2102 63 : gpgme_error_t err = 0;
2103 :
2104 63 : if (recp || recpstring)
2105 43 : err = add_arg (gpg, "--encrypt");
2106 :
2107 63 : if (!err && ((flags & GPGME_ENCRYPT_SYMMETRIC) || (!recp && !recpstring)))
2108 21 : err = add_arg (gpg, "--symmetric");
2109 :
2110 63 : if (!err && use_armor)
2111 45 : err = add_arg (gpg, "--armor");
2112 :
2113 63 : if (!err && (flags & GPGME_ENCRYPT_WRAP))
2114 : {
2115 : /* gpg is current not able to detect already compressed
2116 : * packets. Thus when using
2117 : * gpg --unwrap -d | gpg --no-literal -e
2118 : * the encryption would add an additional compression layer.
2119 : * We better suppress that. */
2120 0 : flags |= GPGME_ENCRYPT_NO_COMPRESS;
2121 0 : err = add_arg (gpg, "--no-literal");
2122 : }
2123 :
2124 63 : if (!err && (flags & GPGME_ENCRYPT_NO_COMPRESS))
2125 0 : err = add_arg (gpg, "--compress-algo=none");
2126 :
2127 63 : if (!err && (flags & GPGME_ENCRYPT_THROW_KEYIDS))
2128 0 : err = add_arg (gpg, "--throw-keyids");
2129 :
2130 63 : if (gpgme_data_get_encoding (plain) == GPGME_DATA_ENCODING_MIME
2131 0 : && have_gpg_version (gpg, "2.1.14"))
2132 0 : err = add_arg (gpg, "--mimemode");
2133 :
2134 63 : if (recp || recpstring)
2135 : {
2136 : /* If we know that all recipients are valid (full or ultimate trust)
2137 : we can suppress further checks. */
2138 43 : if (!err && (flags & GPGME_ENCRYPT_ALWAYS_TRUST))
2139 43 : err = add_arg (gpg, "--always-trust");
2140 :
2141 43 : if (!err && (flags & GPGME_ENCRYPT_NO_ENCRYPT_TO))
2142 6 : err = add_arg (gpg, "--no-encrypt-to");
2143 :
2144 43 : if (!err && !recp && recpstring)
2145 0 : err = append_args_from_recipients_string (gpg, flags, recpstring);
2146 43 : else if (!err)
2147 43 : err = append_args_from_recipients (gpg, flags, recp);
2148 : }
2149 :
2150 : /* Tell the gpg object about the data. */
2151 63 : if (!err)
2152 63 : err = add_arg (gpg, "--output");
2153 63 : if (!err)
2154 63 : err = add_arg (gpg, "-");
2155 63 : if (!err)
2156 63 : err = add_data (gpg, ciph, 1, 1);
2157 63 : if (gpgme_data_get_file_name (plain))
2158 : {
2159 3 : if (!err)
2160 3 : err = add_arg (gpg, "--set-filename");
2161 3 : if (!err)
2162 3 : err = add_arg (gpg, gpgme_data_get_file_name (plain));
2163 : }
2164 63 : if (!err)
2165 63 : err = add_input_size_hint (gpg, plain);
2166 63 : if (!err)
2167 63 : err = add_arg (gpg, "--");
2168 63 : if (!err)
2169 63 : err = add_data (gpg, plain, -1, 0);
2170 :
2171 63 : if (!err)
2172 63 : err = start (gpg);
2173 :
2174 62 : return err;
2175 : }
2176 :
2177 :
2178 : static gpgme_error_t
2179 17 : gpg_encrypt_sign (void *engine, gpgme_key_t recp[],
2180 : const char *recpstring,
2181 : gpgme_encrypt_flags_t flags, gpgme_data_t plain,
2182 : gpgme_data_t ciph, int use_armor,
2183 : gpgme_ctx_t ctx /* FIXME */)
2184 : {
2185 17 : engine_gpg_t gpg = engine;
2186 17 : gpgme_error_t err = 0;
2187 :
2188 17 : if (recp || recpstring)
2189 14 : err = add_arg (gpg, "--encrypt");
2190 :
2191 17 : if (!err && ((flags & GPGME_ENCRYPT_SYMMETRIC) || (!recp && !recpstring)))
2192 3 : err = add_arg (gpg, "--symmetric");
2193 :
2194 17 : if (!err)
2195 17 : err = add_arg (gpg, "--sign");
2196 17 : if (!err && use_armor)
2197 13 : err = add_arg (gpg, "--armor");
2198 :
2199 17 : if (!err && (flags & GPGME_ENCRYPT_NO_COMPRESS))
2200 0 : err = add_arg (gpg, "--compress-algo=none");
2201 :
2202 17 : if (!err && (flags & GPGME_ENCRYPT_THROW_KEYIDS))
2203 0 : err = add_arg (gpg, "--throw-keyids");
2204 :
2205 17 : if (gpgme_data_get_encoding (plain) == GPGME_DATA_ENCODING_MIME
2206 0 : && have_gpg_version (gpg, "2.1.14"))
2207 0 : err = add_arg (gpg, "--mimemode");
2208 :
2209 17 : if (recp || recpstring)
2210 : {
2211 : /* If we know that all recipients are valid (full or ultimate trust)
2212 : we can suppress further checks. */
2213 14 : if (!err && (flags & GPGME_ENCRYPT_ALWAYS_TRUST))
2214 10 : err = add_arg (gpg, "--always-trust");
2215 :
2216 14 : if (!err && (flags & GPGME_ENCRYPT_NO_ENCRYPT_TO))
2217 10 : err = add_arg (gpg, "--no-encrypt-to");
2218 :
2219 14 : if (!err && !recp && recpstring)
2220 0 : err = append_args_from_recipients_string (gpg, flags, recpstring);
2221 14 : else if (!err)
2222 14 : err = append_args_from_recipients (gpg, flags, recp);
2223 : }
2224 :
2225 17 : if (!err)
2226 17 : err = append_args_from_signers (gpg, ctx);
2227 :
2228 17 : if (!err)
2229 17 : err = append_args_from_sender (gpg, ctx);
2230 :
2231 17 : if (!err)
2232 17 : err = append_args_from_sig_notations (gpg, ctx);
2233 :
2234 : /* Tell the gpg object about the data. */
2235 17 : if (!err)
2236 17 : err = add_arg (gpg, "--output");
2237 17 : if (!err)
2238 17 : err = add_arg (gpg, "-");
2239 17 : if (!err)
2240 17 : err = add_data (gpg, ciph, 1, 1);
2241 17 : if (gpgme_data_get_file_name (plain))
2242 : {
2243 0 : if (!err)
2244 0 : err = add_arg (gpg, "--set-filename");
2245 0 : if (!err)
2246 0 : err = add_arg (gpg, gpgme_data_get_file_name (plain));
2247 : }
2248 17 : if (!err)
2249 17 : err = add_input_size_hint (gpg, plain);
2250 17 : if (!err)
2251 17 : err = add_arg (gpg, "--");
2252 17 : if (!err)
2253 17 : err = add_data (gpg, plain, -1, 0);
2254 :
2255 17 : if (!err)
2256 17 : err = start (gpg);
2257 :
2258 17 : return err;
2259 : }
2260 :
2261 :
2262 : static gpgme_error_t
2263 8 : export_common (engine_gpg_t gpg, gpgme_export_mode_t mode,
2264 : gpgme_data_t keydata, int use_armor)
2265 : {
2266 8 : gpgme_error_t err = 0;
2267 :
2268 8 : if ((mode & ~(GPGME_EXPORT_MODE_EXTERN
2269 : |GPGME_EXPORT_MODE_MINIMAL
2270 : |GPGME_EXPORT_MODE_SECRET)))
2271 0 : return gpg_error (GPG_ERR_NOT_SUPPORTED);
2272 :
2273 8 : if ((mode & GPGME_EXPORT_MODE_MINIMAL))
2274 : {
2275 0 : if ((mode & GPGME_EXPORT_MODE_NOUID))
2276 0 : err = add_arg (gpg, "--export-options=export-minimal,export-drop-uids");
2277 : else
2278 0 : err = add_arg (gpg, "--export-options=export-minimal");
2279 : }
2280 8 : else if ((mode & GPGME_EXPORT_MODE_NOUID))
2281 0 : err = add_arg (gpg, "--export-options=export-drop-uids");
2282 :
2283 8 : if (err)
2284 : ;
2285 8 : else if ((mode & GPGME_EXPORT_MODE_EXTERN))
2286 : {
2287 0 : err = add_arg (gpg, "--send-keys");
2288 0 : if (!err && (mode & GPGME_EXPORT_MODE_NOUID))
2289 0 : err = add_arg (gpg, "--keyserver-options=export-drop-uids");
2290 : }
2291 : else
2292 : {
2293 8 : if ((mode & GPGME_EXPORT_MODE_SECRET))
2294 0 : err = add_arg (gpg, "--export-secret-keys");
2295 : else
2296 8 : err = add_arg (gpg, "--export");
2297 8 : if (!err && use_armor)
2298 6 : err = add_arg (gpg, "--armor");
2299 8 : if (!err)
2300 8 : err = add_data (gpg, keydata, 1, 1);
2301 : }
2302 8 : if (!err)
2303 8 : err = add_arg (gpg, "--");
2304 :
2305 8 : return err;
2306 : }
2307 :
2308 :
2309 : static gpgme_error_t
2310 0 : gpg_export (void *engine, const char *pattern, gpgme_export_mode_t mode,
2311 : gpgme_data_t keydata, int use_armor)
2312 : {
2313 0 : engine_gpg_t gpg = engine;
2314 : gpgme_error_t err;
2315 :
2316 0 : err = export_common (gpg, mode, keydata, use_armor);
2317 :
2318 0 : if (!err && pattern && *pattern)
2319 0 : err = add_arg (gpg, pattern);
2320 :
2321 0 : if (!err)
2322 0 : err = start (gpg);
2323 :
2324 0 : return err;
2325 : }
2326 :
2327 :
2328 : static gpgme_error_t
2329 8 : gpg_export_ext (void *engine, const char *pattern[], gpgme_export_mode_t mode,
2330 : gpgme_data_t keydata, int use_armor)
2331 : {
2332 8 : engine_gpg_t gpg = engine;
2333 : gpgme_error_t err;
2334 :
2335 8 : err = export_common (gpg, mode, keydata, use_armor);
2336 :
2337 8 : if (pattern)
2338 : {
2339 80 : while (!err && *pattern && **pattern)
2340 64 : err = add_arg (gpg, *(pattern++));
2341 : }
2342 :
2343 8 : if (!err)
2344 8 : err = start (gpg);
2345 :
2346 8 : return err;
2347 : }
2348 :
2349 :
2350 :
2351 : /* Helper to add algo, usage, and expire to the list of args. */
2352 : static gpgme_error_t
2353 74 : gpg_add_algo_usage_expire (engine_gpg_t gpg,
2354 : const char *algo,
2355 : unsigned long expires,
2356 : unsigned int flags)
2357 : {
2358 : gpg_error_t err;
2359 :
2360 : /* This condition is only required to allow the use of gpg < 2.1.16 */
2361 74 : if (algo
2362 46 : || (flags & (GPGME_CREATE_SIGN | GPGME_CREATE_ENCR
2363 : | GPGME_CREATE_CERT | GPGME_CREATE_AUTH
2364 : | GPGME_CREATE_NOEXPIRE))
2365 14 : || expires)
2366 : {
2367 64 : err = add_arg (gpg, algo? algo : "default");
2368 64 : if (!err)
2369 : {
2370 : char tmpbuf[5*4+1];
2371 256 : snprintf (tmpbuf, sizeof tmpbuf, "%s%s%s%s",
2372 64 : (flags & GPGME_CREATE_SIGN)? " sign":"",
2373 64 : (flags & GPGME_CREATE_ENCR)? " encr":"",
2374 64 : (flags & GPGME_CREATE_CERT)? " cert":"",
2375 64 : (flags & GPGME_CREATE_AUTH)? " auth":"");
2376 64 : err = add_arg (gpg, *tmpbuf? tmpbuf : "default");
2377 : }
2378 128 : if (!err)
2379 : {
2380 64 : if ((flags & GPGME_CREATE_NOEXPIRE))
2381 4 : err = add_arg (gpg, "never");
2382 60 : else if (expires == 0)
2383 56 : err = add_arg (gpg, "-");
2384 : else
2385 : {
2386 : char tmpbuf[8+20];
2387 4 : snprintf (tmpbuf, sizeof tmpbuf, "seconds=%lu", expires);
2388 4 : err = add_arg (gpg, tmpbuf);
2389 : }
2390 : }
2391 : }
2392 : else
2393 10 : err = 0;
2394 :
2395 74 : return err;
2396 : }
2397 :
2398 :
2399 : static gpgme_error_t
2400 6 : gpg_createkey_from_param (engine_gpg_t gpg,
2401 : gpgme_data_t help_data, unsigned int extraflags)
2402 : {
2403 : gpgme_error_t err;
2404 :
2405 6 : err = add_arg (gpg, "--gen-key");
2406 6 : if (!err && (extraflags & GENKEY_EXTRAFLAG_ARMOR))
2407 0 : err = add_arg (gpg, "--armor");
2408 6 : if (!err)
2409 6 : err = add_arg (gpg, "--");
2410 6 : if (!err)
2411 6 : err = add_data (gpg, help_data, -1, 0);
2412 6 : if (!err)
2413 6 : err = start (gpg);
2414 6 : return err;
2415 : }
2416 :
2417 :
2418 : static gpgme_error_t
2419 48 : gpg_createkey (engine_gpg_t gpg,
2420 : const char *userid, const char *algo,
2421 : unsigned long expires,
2422 : unsigned int flags,
2423 : unsigned int extraflags)
2424 : {
2425 : gpgme_error_t err;
2426 :
2427 48 : err = add_arg (gpg, "--quick-gen-key");
2428 48 : if (!err && (extraflags & GENKEY_EXTRAFLAG_ARMOR))
2429 0 : err = add_arg (gpg, "--armor");
2430 48 : if (!err && (flags & GPGME_CREATE_NOPASSWD))
2431 : {
2432 46 : err = add_arg (gpg, "--passphrase");
2433 46 : if (!err)
2434 46 : err = add_arg (gpg, "");
2435 46 : if (!err)
2436 46 : err = add_arg (gpg, "--batch");
2437 : }
2438 48 : if (!err && (flags & GPGME_CREATE_FORCE))
2439 2 : err = add_arg (gpg, "--yes");
2440 48 : if (!err)
2441 48 : err = add_arg (gpg, "--");
2442 48 : if (!err)
2443 48 : err = add_arg (gpg, userid);
2444 :
2445 48 : if (!err)
2446 48 : err = gpg_add_algo_usage_expire (gpg, algo, expires, flags);
2447 :
2448 48 : if (!err)
2449 48 : err = start (gpg);
2450 48 : return err;
2451 : }
2452 :
2453 :
2454 : static gpgme_error_t
2455 26 : gpg_addkey (engine_gpg_t gpg,
2456 : const char *algo,
2457 : unsigned long expires,
2458 : gpgme_key_t key,
2459 : unsigned int flags,
2460 : unsigned int extraflags)
2461 : {
2462 : gpgme_error_t err;
2463 :
2464 26 : if (!key || !key->fpr)
2465 0 : return gpg_error (GPG_ERR_INV_ARG);
2466 :
2467 26 : err = add_arg (gpg, "--quick-addkey");
2468 26 : if (!err && (extraflags & GENKEY_EXTRAFLAG_ARMOR))
2469 0 : err = add_arg (gpg, "--armor");
2470 26 : if (!err && (flags & GPGME_CREATE_NOPASSWD))
2471 : {
2472 24 : err = add_arg (gpg, "--passphrase");
2473 24 : if (!err)
2474 24 : err = add_arg (gpg, "");
2475 24 : if (!err)
2476 24 : err = add_arg (gpg, "--batch");
2477 : }
2478 26 : if (!err)
2479 26 : err = add_arg (gpg, "--");
2480 26 : if (!err)
2481 26 : err = add_arg (gpg, key->fpr);
2482 :
2483 26 : if (!err)
2484 26 : err = gpg_add_algo_usage_expire (gpg, algo, expires, flags);
2485 :
2486 26 : if (!err)
2487 26 : err = start (gpg);
2488 26 : return err;
2489 : }
2490 :
2491 :
2492 : static gpgme_error_t
2493 28 : gpg_adduid (engine_gpg_t gpg,
2494 : gpgme_key_t key,
2495 : const char *userid,
2496 : unsigned int extraflags)
2497 : {
2498 : gpgme_error_t err;
2499 :
2500 28 : if (!key || !key->fpr || !userid)
2501 0 : return gpg_error (GPG_ERR_INV_ARG);
2502 :
2503 28 : if ((extraflags & GENKEY_EXTRAFLAG_SETPRIMARY))
2504 : {
2505 0 : if (!have_gpg_version (gpg, "2.1.20"))
2506 0 : err = gpg_error (GPG_ERR_NOT_SUPPORTED);
2507 : else
2508 0 : err = add_arg (gpg, "--quick-set-primary-uid");
2509 : }
2510 28 : else if ((extraflags & GENKEY_EXTRAFLAG_REVOKE))
2511 7 : err = add_arg (gpg, "--quick-revuid");
2512 : else
2513 21 : err = add_arg (gpg, "--quick-adduid");
2514 :
2515 28 : if (!err)
2516 28 : err = add_arg (gpg, "--");
2517 28 : if (!err)
2518 28 : err = add_arg (gpg, key->fpr);
2519 28 : if (!err)
2520 28 : err = add_arg (gpg, userid);
2521 :
2522 28 : if (!err)
2523 28 : err = start (gpg);
2524 28 : return err;
2525 : }
2526 :
2527 :
2528 : static gpgme_error_t
2529 108 : gpg_genkey (void *engine,
2530 : const char *userid, const char *algo,
2531 : unsigned long reserved, unsigned long expires,
2532 : gpgme_key_t key, unsigned int flags,
2533 : gpgme_data_t help_data, unsigned int extraflags,
2534 : gpgme_data_t pubkey, gpgme_data_t seckey)
2535 : {
2536 108 : engine_gpg_t gpg = engine;
2537 : gpgme_error_t err;
2538 :
2539 : (void)reserved;
2540 :
2541 108 : if (!gpg)
2542 0 : return gpg_error (GPG_ERR_INV_VALUE);
2543 :
2544 : /* If HELP_DATA is given the use of the old interface
2545 : * (gpgme_op_genkey) has been requested. The other modes are:
2546 : *
2547 : * USERID && !KEY - Create a new keyblock.
2548 : * !USERID && KEY - Add a new subkey to KEY (gpg >= 2.1.14)
2549 : * USERID && KEY && !ALGO - Add a new user id to KEY (gpg >= 2.1.14).
2550 : * or set a flag on a user id.
2551 : */
2552 108 : if (help_data)
2553 : {
2554 : /* We need a special mechanism to get the fd of a pipe here, so
2555 : that we can use this for the %pubring and %secring
2556 : parameters. We don't have this yet, so we implement only the
2557 : adding to the standard keyrings. */
2558 6 : if (pubkey || seckey)
2559 0 : err = gpg_error (GPG_ERR_NOT_IMPLEMENTED);
2560 : else
2561 6 : err = gpg_createkey_from_param (gpg, help_data, extraflags);
2562 : }
2563 102 : else if (!have_gpg_version (gpg, "2.1.13"))
2564 0 : err = gpg_error (GPG_ERR_NOT_SUPPORTED);
2565 102 : else if (userid && !key)
2566 48 : err = gpg_createkey (gpg, userid, algo, expires, flags, extraflags);
2567 54 : else if (!userid && key)
2568 26 : err = gpg_addkey (gpg, algo, expires, key, flags, extraflags);
2569 28 : else if (userid && key && !algo)
2570 28 : err = gpg_adduid (gpg, key, userid, extraflags);
2571 : else
2572 0 : err = gpg_error (GPG_ERR_INV_VALUE);
2573 :
2574 108 : return err;
2575 : }
2576 :
2577 : /* Return the next DELIM delimited string from DATA as a C-string.
2578 : The caller needs to provide the address of a pointer variable which
2579 : he has to set to NULL before the first call. After the last call
2580 : to this function, this function needs to be called once more with
2581 : DATA set to NULL so that the function can release its internal
2582 : state. After that the pointer variable is free for use again.
2583 : Note that we use a delimiter and thus a trailing delimiter is not
2584 : required. DELIM may not be changed after the first call. */
2585 : static const char *
2586 0 : string_from_data (gpgme_data_t data, int delim,
2587 : void **helpptr, gpgme_error_t *r_err)
2588 : {
2589 : #define MYBUFLEN 2000 /* Fixme: We don't support URLs longer than that. */
2590 : struct {
2591 : int eof_seen;
2592 : int nbytes; /* Length of the last returned string including
2593 : the delimiter. */
2594 : int buflen; /* Valid length of BUF. */
2595 : char buf[MYBUFLEN+1]; /* Buffer with one byte extra space. */
2596 : } *self;
2597 : char *p;
2598 : int nread;
2599 :
2600 0 : *r_err = 0;
2601 0 : if (!data)
2602 : {
2603 0 : if (*helpptr)
2604 : {
2605 0 : free (*helpptr);
2606 0 : *helpptr = NULL;
2607 : }
2608 0 : return NULL;
2609 : }
2610 :
2611 0 : if (*helpptr)
2612 0 : self = *helpptr;
2613 : else
2614 : {
2615 0 : self = malloc (sizeof *self);
2616 0 : if (!self)
2617 : {
2618 0 : *r_err = gpg_error_from_syserror ();
2619 0 : return NULL;
2620 : }
2621 0 : *helpptr = self;
2622 0 : self->eof_seen = 0;
2623 0 : self->nbytes = 0;
2624 0 : self->buflen = 0;
2625 : }
2626 :
2627 0 : if (self->eof_seen)
2628 0 : return NULL;
2629 :
2630 0 : assert (self->nbytes <= self->buflen);
2631 0 : memmove (self->buf, self->buf + self->nbytes, self->buflen - self->nbytes);
2632 0 : self->buflen -= self->nbytes;
2633 0 : self->nbytes = 0;
2634 :
2635 : do
2636 : {
2637 : /* Fixme: This is fairly infective scanning because we may scan
2638 : the buffer several times. */
2639 0 : p = memchr (self->buf, delim, self->buflen);
2640 0 : if (p)
2641 : {
2642 0 : *p = 0;
2643 0 : self->nbytes = p - self->buf + 1;
2644 0 : return self->buf;
2645 : }
2646 :
2647 0 : if ( !(MYBUFLEN - self->buflen) )
2648 : {
2649 : /* Not enough space - URL too long. */
2650 0 : *r_err = gpg_error (GPG_ERR_TOO_LARGE);
2651 0 : return NULL;
2652 : }
2653 :
2654 0 : nread = gpgme_data_read (data, self->buf + self->buflen,
2655 0 : MYBUFLEN - self->buflen);
2656 0 : if (nread < 0)
2657 : {
2658 0 : *r_err = gpg_error_from_syserror ();
2659 0 : return NULL;
2660 : }
2661 0 : self->buflen += nread;
2662 : }
2663 0 : while (nread);
2664 :
2665 : /* EOF reached. If we have anything in the buffer, append a Nul and
2666 : return it. */
2667 0 : self->eof_seen = 1;
2668 0 : if (self->buflen)
2669 : {
2670 0 : self->buf[self->buflen] = 0; /* (we allocated one extra byte) */
2671 0 : return self->buf;
2672 : }
2673 0 : return NULL;
2674 : #undef MYBUFLEN
2675 : }
2676 :
2677 :
2678 :
2679 : static gpgme_error_t
2680 14 : gpg_import (void *engine, gpgme_data_t keydata, gpgme_key_t *keyarray)
2681 : {
2682 14 : engine_gpg_t gpg = engine;
2683 : gpgme_error_t err;
2684 : int idx;
2685 : gpgme_data_encoding_t dataenc;
2686 :
2687 14 : if (keydata && keyarray)
2688 0 : return gpg_error (GPG_ERR_INV_VALUE); /* Only one is allowed. */
2689 :
2690 14 : dataenc = gpgme_data_get_encoding (keydata);
2691 :
2692 14 : if (keyarray)
2693 : {
2694 0 : err = add_arg (gpg, "--recv-keys");
2695 0 : if (!err)
2696 0 : err = add_arg (gpg, "--");
2697 0 : for (idx=0; !err && keyarray[idx]; idx++)
2698 : {
2699 0 : if (keyarray[idx]->protocol != GPGME_PROTOCOL_OpenPGP)
2700 : ;
2701 0 : else if (!keyarray[idx]->subkeys)
2702 : ;
2703 0 : else if (keyarray[idx]->subkeys->fpr && *keyarray[idx]->subkeys->fpr)
2704 0 : err = add_arg (gpg, keyarray[idx]->subkeys->fpr);
2705 0 : else if (*keyarray[idx]->subkeys->keyid)
2706 0 : err = add_arg (gpg, keyarray[idx]->subkeys->keyid);
2707 : }
2708 : }
2709 14 : else if (dataenc == GPGME_DATA_ENCODING_URL
2710 14 : || dataenc == GPGME_DATA_ENCODING_URL0)
2711 0 : {
2712 : void *helpptr;
2713 : const char *string;
2714 : gpgme_error_t xerr;
2715 0 : int delim = (dataenc == GPGME_DATA_ENCODING_URL)? '\n': 0;
2716 :
2717 : /* FIXME: --fetch-keys is probably not correct because it can't
2718 : grok all kinds of URLs. On Unix it should just work but on
2719 : Windows we will build the command line and that may fail for
2720 : some embedded control characters. It is anyway limited to
2721 : the maximum size of the command line. We need another
2722 : command which can take its input from a file. Maybe we
2723 : should use an option to gpg to modify such commands (ala
2724 : --multifile). */
2725 0 : err = add_arg (gpg, "--fetch-keys");
2726 0 : if (!err)
2727 0 : err = add_arg (gpg, "--");
2728 0 : helpptr = NULL;
2729 0 : while (!err
2730 0 : && (string = string_from_data (keydata, delim, &helpptr, &xerr)))
2731 0 : err = add_arg (gpg, string);
2732 0 : if (!err)
2733 0 : err = xerr;
2734 0 : string_from_data (NULL, delim, &helpptr, &xerr);
2735 : }
2736 14 : else if (dataenc == GPGME_DATA_ENCODING_URLESC)
2737 : {
2738 : /* Already escaped URLs are not yet supported. */
2739 0 : err = gpg_error (GPG_ERR_NOT_IMPLEMENTED);
2740 : }
2741 : else
2742 : {
2743 14 : err = add_arg (gpg, "--import");
2744 14 : if (!err)
2745 14 : err = add_arg (gpg, "--");
2746 14 : if (!err)
2747 14 : err = add_data (gpg, keydata, -1, 0);
2748 : }
2749 :
2750 14 : if (!err)
2751 14 : err = start (gpg);
2752 :
2753 14 : return err;
2754 : }
2755 :
2756 :
2757 : /* The output for external keylistings in GnuPG is different from all
2758 : the other key listings. We catch this here with a special
2759 : preprocessor that reformats the colon handler lines. */
2760 : static gpgme_error_t
2761 0 : gpg_keylist_preprocess (char *line, char **r_line)
2762 : {
2763 : enum
2764 : {
2765 : RT_NONE, RT_INFO, RT_PUB, RT_UID
2766 : }
2767 0 : rectype = RT_NONE;
2768 : #define NR_FIELDS 16
2769 : char *field[NR_FIELDS];
2770 0 : int fields = 0;
2771 : size_t n;
2772 :
2773 0 : *r_line = NULL;
2774 :
2775 0 : while (line && fields < NR_FIELDS)
2776 : {
2777 0 : field[fields++] = line;
2778 0 : line = strchr (line, ':');
2779 0 : if (line)
2780 0 : *(line++) = '\0';
2781 : }
2782 :
2783 0 : if (!strcmp (field[0], "info"))
2784 0 : rectype = RT_INFO;
2785 0 : else if (!strcmp (field[0], "pub"))
2786 0 : rectype = RT_PUB;
2787 0 : else if (!strcmp (field[0], "uid"))
2788 0 : rectype = RT_UID;
2789 : else
2790 0 : rectype = RT_NONE;
2791 :
2792 0 : switch (rectype)
2793 : {
2794 : case RT_INFO:
2795 : /* FIXME: Eventually, check the version number at least. */
2796 0 : return 0;
2797 :
2798 : case RT_PUB:
2799 0 : if (fields < 7)
2800 0 : return 0;
2801 :
2802 : /* The format is:
2803 :
2804 : pub:<keyid>:<algo>:<keylen>:<creationdate>:<expirationdate>:<flags>
2805 :
2806 : as defined in 5.2. Machine Readable Indexes of the OpenPGP
2807 : HTTP Keyserver Protocol (draft). Modern versions of the SKS
2808 : keyserver return the fingerprint instead of the keyid. We
2809 : detect this here and use the v4 fingerprint format to convert
2810 : it to a key id.
2811 :
2812 : We want:
2813 : pub:o<flags>:<keylen>:<algo>:<keyid>:<creatdate>:<expdate>::::::::
2814 : */
2815 :
2816 0 : n = strlen (field[1]);
2817 0 : if (n > 16)
2818 : {
2819 0 : if (gpgrt_asprintf (r_line,
2820 : "pub:o%s:%s:%s:%s:%s:%s::::::::\n"
2821 : "fpr:::::::::%s:",
2822 0 : field[6], field[3], field[2], field[1] + n - 16,
2823 : field[4], field[5], field[1]) < 0)
2824 0 : return gpg_error_from_syserror ();
2825 : }
2826 : else
2827 : {
2828 0 : if (gpgrt_asprintf (r_line,
2829 : "pub:o%s:%s:%s:%s:%s:%s::::::::",
2830 : field[6], field[3], field[2], field[1],
2831 : field[4], field[5]) < 0)
2832 0 : return gpg_error_from_syserror ();
2833 : }
2834 :
2835 0 : return 0;
2836 :
2837 : case RT_UID:
2838 : /* The format is:
2839 :
2840 : uid:<escaped uid string>:<creationdate>:<expirationdate>:<flags>
2841 :
2842 : as defined in 5.2. Machine Readable Indexes of the OpenPGP
2843 : HTTP Keyserver Protocol (draft).
2844 :
2845 : For an ldap keyserver the format is:
2846 : uid:<escaped uid string>
2847 :
2848 : We want:
2849 : uid:o<flags>::::<creatdate>:<expdate>:::<c-coded uid>:
2850 : */
2851 :
2852 : {
2853 : /* The user ID is percent escaped, but we want c-coded.
2854 : Because we have to replace each '%HL' by '\xHL', we need at
2855 : most 4/3 th the number of bytes. But because we also need
2856 : to escape the backslashes we allocate twice as much. */
2857 0 : char *uid = malloc (2 * strlen (field[1]) + 1);
2858 : char *src;
2859 : char *dst;
2860 :
2861 0 : if (! uid)
2862 0 : return gpg_error_from_syserror ();
2863 0 : src = field[1];
2864 0 : dst = uid;
2865 0 : while (*src)
2866 : {
2867 0 : if (*src == '%')
2868 : {
2869 0 : *(dst++) = '\\';
2870 0 : *(dst++) = 'x';
2871 0 : src++;
2872 : /* Copy the next two bytes unconditionally. */
2873 0 : if (*src)
2874 0 : *(dst++) = *(src++);
2875 0 : if (*src)
2876 0 : *(dst++) = *(src++);
2877 : }
2878 0 : else if (*src == '\\')
2879 : {
2880 0 : *dst++ = '\\';
2881 0 : *dst++ = '\\';
2882 0 : src++;
2883 : }
2884 : else
2885 0 : *(dst++) = *(src++);
2886 : }
2887 0 : *dst = '\0';
2888 :
2889 0 : if (fields < 4)
2890 : {
2891 0 : if (gpgrt_asprintf (r_line, "uid:o::::::::%s:", uid) < 0)
2892 0 : return gpg_error_from_syserror ();
2893 : }
2894 : else
2895 : {
2896 0 : if (gpgrt_asprintf (r_line, "uid:o%s::::%s:%s:::%s:",
2897 : field[4], field[2], field[3], uid) < 0)
2898 0 : return gpg_error_from_syserror ();
2899 : }
2900 : }
2901 0 : return 0;
2902 :
2903 : case RT_NONE:
2904 : /* Unknown record. */
2905 0 : break;
2906 : }
2907 0 : return 0;
2908 :
2909 : }
2910 :
2911 :
2912 : static gpg_error_t
2913 327 : gpg_keylist_build_options (engine_gpg_t gpg, int secret_only,
2914 : gpgme_keylist_mode_t mode)
2915 : {
2916 : gpg_error_t err;
2917 :
2918 327 : err = add_arg (gpg, "--with-colons");
2919 :
2920 : /* Since gpg 2.1.15 fingerprints are always printed, thus there is
2921 : * no more need to explicitly request them. */
2922 327 : if (!have_gpg_version (gpg, "2.1.15"))
2923 : {
2924 0 : if (!err)
2925 0 : err = add_arg (gpg, "--fixed-list-mode");
2926 0 : if (!err)
2927 0 : err = add_arg (gpg, "--with-fingerprint");
2928 0 : if (!err)
2929 0 : err = add_arg (gpg, "--with-fingerprint");
2930 : }
2931 :
2932 326 : if (!err && (mode & GPGME_KEYLIST_MODE_WITH_TOFU)
2933 28 : && have_gpg_version (gpg, "2.1.16"))
2934 28 : err = add_arg (gpg, "--with-tofu-info");
2935 :
2936 326 : if (!err && (mode & GPGME_KEYLIST_MODE_WITH_SECRET))
2937 0 : err = add_arg (gpg, "--with-secret");
2938 :
2939 326 : if (!err
2940 326 : && (mode & GPGME_KEYLIST_MODE_SIGS)
2941 30 : && (mode & GPGME_KEYLIST_MODE_SIG_NOTATIONS))
2942 : {
2943 8 : err = add_arg (gpg, "--list-options");
2944 8 : if (!err)
2945 8 : err = add_arg (gpg, "show-sig-subpackets=\"20,26\"");
2946 : }
2947 :
2948 326 : if (!err)
2949 : {
2950 326 : if ( (mode & GPGME_KEYLIST_MODE_EXTERN) )
2951 : {
2952 1 : if (secret_only)
2953 0 : err = gpg_error (GPG_ERR_NOT_SUPPORTED);
2954 1 : else if ( (mode & GPGME_KEYLIST_MODE_LOCAL))
2955 : {
2956 : /* The local+extern mode is special. It works only with
2957 : gpg >= 2.0.10. FIXME: We should check that we have
2958 : such a version to that we can return a proper error
2959 : code. The problem is that we don't know the context
2960 : here and thus can't access the cached version number
2961 : for the engine info structure. */
2962 1 : err = add_arg (gpg, "--locate-keys");
2963 1 : if ((mode & GPGME_KEYLIST_MODE_SIGS))
2964 1 : err = add_arg (gpg, "--with-sig-check");
2965 : }
2966 : else
2967 : {
2968 0 : err = add_arg (gpg, "--search-keys");
2969 0 : gpg->colon.preprocess_fnc = gpg_keylist_preprocess;
2970 : }
2971 : }
2972 : else
2973 : {
2974 600 : err = add_arg (gpg, secret_only ? "--list-secret-keys"
2975 275 : : ((mode & GPGME_KEYLIST_MODE_SIGS)
2976 275 : ? "--check-sigs" : "--list-keys"));
2977 : }
2978 : }
2979 :
2980 326 : if (!err)
2981 326 : err = add_arg (gpg, "--");
2982 :
2983 327 : return err;
2984 : }
2985 :
2986 :
2987 : static gpgme_error_t
2988 327 : gpg_keylist (void *engine, const char *pattern, int secret_only,
2989 : gpgme_keylist_mode_t mode, int engine_flags)
2990 : {
2991 327 : engine_gpg_t gpg = engine;
2992 : gpgme_error_t err;
2993 :
2994 : (void)engine_flags;
2995 :
2996 327 : err = gpg_keylist_build_options (gpg, secret_only, mode);
2997 :
2998 327 : if (!err && pattern && *pattern)
2999 291 : err = add_arg (gpg, pattern);
3000 :
3001 327 : if (!err)
3002 327 : err = start (gpg);
3003 :
3004 319 : return err;
3005 : }
3006 :
3007 :
3008 : static gpgme_error_t
3009 0 : gpg_keylist_ext (void *engine, const char *pattern[], int secret_only,
3010 : int reserved, gpgme_keylist_mode_t mode, int engine_flags)
3011 : {
3012 0 : engine_gpg_t gpg = engine;
3013 : gpgme_error_t err;
3014 :
3015 : (void)engine_flags;
3016 :
3017 0 : if (reserved)
3018 0 : return gpg_error (GPG_ERR_INV_VALUE);
3019 :
3020 0 : err = gpg_keylist_build_options (gpg, secret_only, mode);
3021 :
3022 0 : if (pattern)
3023 : {
3024 0 : while (!err && *pattern && **pattern)
3025 0 : err = add_arg (gpg, *(pattern++));
3026 : }
3027 :
3028 0 : if (!err)
3029 0 : err = start (gpg);
3030 :
3031 0 : return err;
3032 : }
3033 :
3034 :
3035 : static gpgme_error_t
3036 5 : gpg_keylist_data (void *engine, gpgme_data_t data)
3037 : {
3038 5 : engine_gpg_t gpg = engine;
3039 : gpgme_error_t err;
3040 :
3041 5 : if (!have_gpg_version (gpg, "2.1.14"))
3042 0 : return gpg_error (GPG_ERR_NOT_SUPPORTED);
3043 :
3044 5 : err = add_arg (gpg, "--with-colons");
3045 5 : if (!err)
3046 5 : err = add_arg (gpg, "--with-fingerprint");
3047 5 : if (!err)
3048 5 : err = add_arg (gpg, "--import-options");
3049 5 : if (!err)
3050 5 : err = add_arg (gpg, "import-show");
3051 5 : if (!err)
3052 5 : err = add_arg (gpg, "--dry-run");
3053 5 : if (!err)
3054 5 : err = add_arg (gpg, "--import");
3055 5 : if (!err)
3056 5 : err = add_arg (gpg, "--");
3057 5 : if (!err)
3058 5 : err = add_data (gpg, data, -1, 0);
3059 :
3060 5 : if (!err)
3061 5 : err = start (gpg);
3062 :
3063 5 : return err;
3064 : }
3065 :
3066 :
3067 : static gpgme_error_t
3068 8 : gpg_keysign (void *engine, gpgme_key_t key, const char *userid,
3069 : unsigned long expire, unsigned int flags,
3070 : gpgme_ctx_t ctx)
3071 : {
3072 8 : engine_gpg_t gpg = engine;
3073 : gpgme_error_t err;
3074 : const char *s;
3075 :
3076 8 : if (!key || !key->fpr)
3077 0 : return gpg_error (GPG_ERR_INV_ARG);
3078 :
3079 8 : if (!have_gpg_version (gpg, "2.1.12"))
3080 0 : return gpg_error (GPG_ERR_NOT_SUPPORTED);
3081 :
3082 8 : if ((flags & GPGME_KEYSIGN_LOCAL))
3083 6 : err = add_arg (gpg, "--quick-lsign-key");
3084 : else
3085 2 : err = add_arg (gpg, "--quick-sign-key");
3086 :
3087 8 : if (!err)
3088 8 : err = append_args_from_signers (gpg, ctx);
3089 :
3090 : /* If an expiration time has been given use that. If none has been
3091 : * given the default from gpg.conf is used. To make sure not to set
3092 : * an expiration time at all the flag GPGME_KEYSIGN_NOEXPIRE can be
3093 : * used. */
3094 8 : if (!err && (expire || (flags & GPGME_KEYSIGN_NOEXPIRE)))
3095 : {
3096 : char tmpbuf[8+20];
3097 :
3098 8 : if ((flags & GPGME_KEYSIGN_NOEXPIRE))
3099 4 : expire = 0;
3100 8 : snprintf (tmpbuf, sizeof tmpbuf, "seconds=%lu", expire);
3101 8 : err = add_arg (gpg, "--default-cert-expire");
3102 8 : if (!err)
3103 8 : err = add_arg (gpg, tmpbuf);
3104 : }
3105 :
3106 8 : if (!err)
3107 8 : err = add_arg (gpg, "--");
3108 :
3109 8 : if (!err)
3110 8 : err = add_arg (gpg, key->fpr);
3111 8 : if (!err && userid)
3112 : {
3113 6 : if ((flags & GPGME_KEYSIGN_LFSEP))
3114 : {
3115 8 : for (; !err && (s = strchr (userid, '\n')); userid = s + 1)
3116 4 : if ((s - userid))
3117 4 : err = add_arg_len (gpg, "=", userid, s - userid);
3118 4 : if (!err && *userid)
3119 4 : err = add_arg_pfx (gpg, "=", userid);
3120 : }
3121 : else
3122 2 : err = add_arg_pfx (gpg, "=", userid);
3123 : }
3124 :
3125 8 : if (!err)
3126 8 : err = start (gpg);
3127 :
3128 8 : return err;
3129 : }
3130 :
3131 :
3132 : static gpgme_error_t
3133 12 : gpg_tofu_policy (void *engine, gpgme_key_t key, gpgme_tofu_policy_t policy)
3134 : {
3135 12 : engine_gpg_t gpg = engine;
3136 : gpgme_error_t err;
3137 12 : const char *policystr = NULL;
3138 :
3139 12 : if (!key || !key->fpr)
3140 0 : return gpg_error (GPG_ERR_INV_ARG);
3141 :
3142 12 : switch (policy)
3143 : {
3144 0 : case GPGME_TOFU_POLICY_NONE: break;
3145 2 : case GPGME_TOFU_POLICY_AUTO: policystr = "auto"; break;
3146 3 : case GPGME_TOFU_POLICY_GOOD: policystr = "good"; break;
3147 3 : case GPGME_TOFU_POLICY_BAD: policystr = "bad"; break;
3148 2 : case GPGME_TOFU_POLICY_ASK: policystr = "ask"; break;
3149 2 : case GPGME_TOFU_POLICY_UNKNOWN: policystr = "unknown"; break;
3150 : }
3151 12 : if (!policystr)
3152 0 : return gpg_error (GPG_ERR_INV_VALUE);
3153 :
3154 12 : if (!have_gpg_version (gpg, "2.1.10"))
3155 0 : return gpg_error (GPG_ERR_NOT_SUPPORTED);
3156 :
3157 12 : err = add_arg (gpg, "--tofu-policy");
3158 12 : if (!err)
3159 12 : err = add_arg (gpg, "--");
3160 12 : if (!err)
3161 12 : err = add_arg (gpg, policystr);
3162 12 : if (!err)
3163 12 : err = add_arg (gpg, key->fpr);
3164 :
3165 12 : if (!err)
3166 12 : err = start (gpg);
3167 :
3168 12 : return err;
3169 : }
3170 :
3171 :
3172 : static gpgme_error_t
3173 46 : gpg_sign (void *engine, gpgme_data_t in, gpgme_data_t out,
3174 : gpgme_sig_mode_t mode, int use_armor, int use_textmode,
3175 : int include_certs, gpgme_ctx_t ctx /* FIXME */)
3176 : {
3177 46 : engine_gpg_t gpg = engine;
3178 : gpgme_error_t err;
3179 :
3180 : (void)include_certs;
3181 :
3182 46 : if (mode == GPGME_SIG_MODE_CLEAR)
3183 10 : err = add_arg (gpg, "--clearsign");
3184 : else
3185 : {
3186 36 : err = add_arg (gpg, "--sign");
3187 36 : if (!err && mode == GPGME_SIG_MODE_DETACH)
3188 10 : err = add_arg (gpg, "--detach");
3189 36 : if (!err && use_armor)
3190 20 : err = add_arg (gpg, "--armor");
3191 36 : if (!err)
3192 : {
3193 36 : if (gpgme_data_get_encoding (in) == GPGME_DATA_ENCODING_MIME
3194 0 : && have_gpg_version (gpg, "2.1.14"))
3195 0 : err = add_arg (gpg, "--mimemode");
3196 36 : else if (use_textmode)
3197 20 : err = add_arg (gpg, "--textmode");
3198 : }
3199 : }
3200 :
3201 46 : if (!err)
3202 46 : err = append_args_from_signers (gpg, ctx);
3203 46 : if (!err)
3204 46 : err = append_args_from_sender (gpg, ctx);
3205 46 : if (!err)
3206 46 : err = append_args_from_sig_notations (gpg, ctx);
3207 :
3208 46 : if (gpgme_data_get_file_name (in))
3209 : {
3210 0 : if (!err)
3211 0 : err = add_arg (gpg, "--set-filename");
3212 0 : if (!err)
3213 0 : err = add_arg (gpg, gpgme_data_get_file_name (in));
3214 : }
3215 :
3216 : /* Tell the gpg object about the data. */
3217 46 : if (!err)
3218 46 : err = add_input_size_hint (gpg, in);
3219 46 : if (!err)
3220 46 : err = add_arg (gpg, "--");
3221 46 : if (!err)
3222 46 : err = add_data (gpg, in, -1, 0);
3223 46 : if (!err)
3224 46 : err = add_data (gpg, out, 1, 1);
3225 :
3226 46 : if (!err)
3227 46 : err = start (gpg);
3228 :
3229 46 : return err;
3230 : }
3231 :
3232 : static gpgme_error_t
3233 5 : gpg_trustlist (void *engine, const char *pattern)
3234 : {
3235 5 : engine_gpg_t gpg = engine;
3236 : gpgme_error_t err;
3237 :
3238 5 : err = add_arg (gpg, "--with-colons");
3239 5 : if (!err)
3240 5 : err = add_arg (gpg, "--list-trust-path");
3241 :
3242 : /* Tell the gpg object about the data. */
3243 5 : if (!err)
3244 5 : err = add_arg (gpg, "--");
3245 5 : if (!err)
3246 5 : err = add_arg (gpg, pattern);
3247 :
3248 5 : if (!err)
3249 5 : err = start (gpg);
3250 :
3251 5 : return err;
3252 : }
3253 :
3254 :
3255 : static gpgme_error_t
3256 57 : gpg_verify (void *engine, gpgme_data_t sig, gpgme_data_t signed_text,
3257 : gpgme_data_t plaintext, gpgme_ctx_t ctx)
3258 : {
3259 57 : engine_gpg_t gpg = engine;
3260 : gpgme_error_t err;
3261 :
3262 57 : err = append_args_from_sender (gpg, ctx);
3263 57 : if (!err && ctx->auto_key_retrieve)
3264 0 : err = add_arg (gpg, "--auto-key-retrieve");
3265 :
3266 57 : if (err)
3267 : ;
3268 57 : else if (plaintext)
3269 : {
3270 : /* Normal or cleartext signature. */
3271 32 : err = add_arg (gpg, "--output");
3272 32 : if (!err)
3273 32 : err = add_arg (gpg, "-");
3274 32 : if (!err)
3275 32 : err = add_input_size_hint (gpg, sig);
3276 32 : if (!err)
3277 32 : err = add_arg (gpg, "--");
3278 32 : if (!err)
3279 32 : err = add_data (gpg, sig, -1, 0);
3280 32 : if (!err)
3281 32 : err = add_data (gpg, plaintext, 1, 1);
3282 : }
3283 : else
3284 : {
3285 25 : err = add_arg (gpg, "--verify");
3286 25 : if (!err)
3287 25 : err = add_input_size_hint (gpg, signed_text);
3288 25 : if (!err)
3289 25 : err = add_arg (gpg, "--");
3290 25 : if (!err)
3291 25 : err = add_data (gpg, sig, -1, 0);
3292 25 : if (!err && signed_text)
3293 25 : err = add_data (gpg, signed_text, -1, 0);
3294 : }
3295 :
3296 57 : if (!err)
3297 57 : err = start (gpg);
3298 :
3299 54 : return err;
3300 : }
3301 :
3302 :
3303 : static void
3304 730 : gpg_set_io_cbs (void *engine, gpgme_io_cbs_t io_cbs)
3305 : {
3306 730 : engine_gpg_t gpg = engine;
3307 :
3308 730 : gpg->io_cbs = *io_cbs;
3309 730 : }
3310 :
3311 :
3312 : static gpgme_error_t
3313 724 : gpg_set_pinentry_mode (void *engine, gpgme_pinentry_mode_t mode)
3314 : {
3315 724 : engine_gpg_t gpg = engine;
3316 :
3317 724 : gpg->pinentry_mode = mode;
3318 724 : return 0;
3319 : }
3320 :
3321 :
3322 : static gpgme_error_t
3323 30 : gpg_getauditlog (void *engine, gpgme_data_t output, unsigned int flags)
3324 : {
3325 30 : engine_gpg_t gpg = engine;
3326 : #define MYBUFLEN 4096
3327 : char buf[MYBUFLEN];
3328 : int nread;
3329 30 : int any_written = 0;
3330 :
3331 30 : if (!(flags & GPGME_AUDITLOG_DIAG))
3332 : {
3333 0 : return gpg_error (GPG_ERR_NOT_IMPLEMENTED);
3334 : }
3335 :
3336 30 : if (!gpg || !output)
3337 : {
3338 0 : return gpg_error (GPG_ERR_INV_VALUE);
3339 : }
3340 :
3341 30 : if (!gpg->diagnostics)
3342 : {
3343 0 : return gpg_error (GPG_ERR_GENERAL);
3344 : }
3345 :
3346 30 : gpgme_data_rewind (gpg->diagnostics);
3347 :
3348 30 : while ((nread = gpgme_data_read (gpg->diagnostics, buf, MYBUFLEN)) > 0)
3349 : {
3350 28 : any_written = 1;
3351 28 : if (gpgme_data_write (output, buf, nread) == -1)
3352 0 : return gpg_error_from_syserror ();
3353 : }
3354 30 : if (!any_written)
3355 : {
3356 2 : return gpg_error (GPG_ERR_NO_DATA);
3357 : }
3358 :
3359 28 : if (nread == -1)
3360 0 : return gpg_error_from_syserror ();
3361 :
3362 28 : gpgme_data_rewind (output);
3363 28 : return 0;
3364 : #undef MYBUFLEN
3365 : }
3366 :
3367 :
3368 :
3369 : struct engine_ops _gpgme_engine_ops_gpg =
3370 : {
3371 : /* Static functions. */
3372 : _gpgme_get_default_gpg_name,
3373 : NULL,
3374 : gpg_get_version,
3375 : gpg_get_req_version,
3376 : gpg_new,
3377 :
3378 : /* Member functions. */
3379 : gpg_release,
3380 : NULL, /* reset */
3381 : gpg_set_status_cb,
3382 : gpg_set_status_handler,
3383 : gpg_set_command_handler,
3384 : gpg_set_colon_line_handler,
3385 : gpg_set_locale,
3386 : NULL, /* set_protocol */
3387 : gpg_set_engine_flags, /* set_engine_flags */
3388 : gpg_decrypt,
3389 : gpg_delete,
3390 : gpg_edit,
3391 : gpg_encrypt,
3392 : gpg_encrypt_sign,
3393 : gpg_export,
3394 : gpg_export_ext,
3395 : gpg_genkey,
3396 : gpg_import,
3397 : gpg_keylist,
3398 : gpg_keylist_ext,
3399 : gpg_keylist_data,
3400 : gpg_keysign,
3401 : gpg_tofu_policy, /* tofu_policy */
3402 : gpg_sign,
3403 : gpg_trustlist,
3404 : gpg_verify,
3405 : gpg_getauditlog,
3406 : NULL, /* opassuan_transact */
3407 : NULL, /* conf_load */
3408 : NULL, /* conf_save */
3409 : NULL, /* conf_dir */
3410 : NULL, /* query_swdb */
3411 : gpg_set_io_cbs,
3412 : gpg_io_event,
3413 : gpg_cancel,
3414 : NULL, /* cancel_op */
3415 : gpg_passwd,
3416 : gpg_set_pinentry_mode,
3417 : NULL /* opspawn */
3418 : };
|
