mirror of
git://git.gnupg.org/gnupg.git
synced 2024-09-07 12:56:21 +02:00
Use gpgrt_process_spawn API from libgpg-error.
* agent/genkey.c (do_check_passphrase_pattern): Use the gpgrt API. * common/asshelp.c (start_new_service): Ditto. * common/exechelp.h: Remove gnupg_process_spawn API. * common/exechelp-posix.c: Remove gnupg_process_spawn implementation. * common/exechelp-w32.c: Likewise. * common/exectool.c (gnupg_exec_tool_stream): Use the gpgrt API. * common/t-exechelp.c (test_pipe_stream): Remove. * dirmngr/ldap-wrapper.c (destroy_wrapper, ldap_reaper_thread): Use the gpgrt API. (ldap_wrapper_connection_cleanup, ldap_wrapper): Ditto. * dirmngr/ldap.c, g10/call-keyboxd.c: No need to include exechelp.h. * g10/photoid.c (run_with_pipe, show_photo): Use the gpgrt API. * g13/be-encfs.c (run_umount_helper, run_encfs_tool): Ditto. * g13/g13.c, g13/mount.c, g13/runner.c: No need to include exechelp.h. * scd/apdu.c: No need to include exechelp.h. * scd/app.c (report_change): Use the gpgrt API. * sm/export.c, sm/import.c: No need to include exechelp.h. * tests/gpgscm/ffi.c (proc_object_finalize, proc_wrap) (do_process_spawn_io, do_process_spawn_fd, do_process_wait): Use the gpgrt API. * tools/gpg-auth.c: No need to include exechelp.h. * tools/gpg-card.c (cmd_gpg): Use the gpgrt API. * tools/gpg-connect-agent.c: No need to include exechelp.h. * tools/gpg-mail-tube.c (mail_tube_encrypt, prepare_for_appimage) (start_gpg_encrypt): Use the gpgrt API. * tools/gpgconf-comp.c (gpg_agent_runtime_change) (scdaemon_runtime_change, tpm2daemon_runtime_change) (dirmngr_runtime_change, keyboxd_runtime_change) (gc_component_launch, gc_component_check_options) (retrieve_options_from_program): Ditto. * tools/gpgconf.c (show_versions_via_dirmngr): Ditto. * tools/gpgtar-create.c (gpgtar_create): Ditto. * tools/gpgtar-extract.c (gpgtar_extract): Ditto. * tools/gpgtar-list.c (gpgtar_list): Ditto. -- GnuPG-bug-id: 7192 Signed-off-by: NIIBE Yutaka <gniibe@fsij.org>
This commit is contained in:
parent
c333e9dad6
commit
953dd67368
@ -27,7 +27,6 @@
|
||||
|
||||
#include "agent.h"
|
||||
#include "../common/i18n.h"
|
||||
#include "../common/exechelp.h"
|
||||
#include "../common/sysutils.h"
|
||||
|
||||
|
||||
@ -162,7 +161,7 @@ do_check_passphrase_pattern (ctrl_t ctrl, const char *pw, unsigned int flags)
|
||||
const char *pgmname = gnupg_module_name (GNUPG_MODULE_NAME_CHECK_PATTERN);
|
||||
estream_t stream_to_check_pattern = NULL;
|
||||
const char *argv[10];
|
||||
gnupg_process_t proc;
|
||||
gpgrt_process_t proc;
|
||||
int result, i;
|
||||
const char *pattern;
|
||||
char *patternfname;
|
||||
@ -205,15 +204,15 @@ do_check_passphrase_pattern (ctrl_t ctrl, const char *pw, unsigned int flags)
|
||||
argv[i] = NULL;
|
||||
log_assert (i < sizeof argv);
|
||||
|
||||
if (gnupg_process_spawn (pgmname, argv,
|
||||
GNUPG_PROCESS_STDIN_PIPE,
|
||||
if (gpgrt_process_spawn (pgmname, argv,
|
||||
GPGRT_PROCESS_STDIN_PIPE,
|
||||
NULL, &proc))
|
||||
result = 1; /* Execute error - assume password should no be used. */
|
||||
else
|
||||
{
|
||||
int status;
|
||||
|
||||
gnupg_process_get_streams (proc, 0, &stream_to_check_pattern,
|
||||
gpgrt_process_get_streams (proc, 0, &stream_to_check_pattern,
|
||||
NULL, NULL);
|
||||
|
||||
es_set_binary (stream_to_check_pattern);
|
||||
@ -226,13 +225,13 @@ do_check_passphrase_pattern (ctrl_t ctrl, const char *pw, unsigned int flags)
|
||||
else
|
||||
es_fflush (stream_to_check_pattern);
|
||||
es_fclose (stream_to_check_pattern);
|
||||
gnupg_process_wait (proc, 1);
|
||||
gnupg_process_ctl (proc, GNUPG_PROCESS_GET_EXIT_ID, &status);
|
||||
gpgrt_process_wait (proc, 1);
|
||||
gpgrt_process_ctl (proc, GPGRT_PROCESS_GET_EXIT_ID, &status);
|
||||
if (status)
|
||||
result = 1; /* Helper returned an error - probably a match. */
|
||||
else
|
||||
result = 0; /* Success; i.e. no match. */
|
||||
gnupg_process_release (proc);
|
||||
gpgrt_process_release (proc);
|
||||
}
|
||||
|
||||
xfree (patternfname);
|
||||
|
@ -39,7 +39,6 @@
|
||||
|
||||
#include "i18n.h"
|
||||
#include "util.h"
|
||||
#include "exechelp.h"
|
||||
#include "sysutils.h"
|
||||
#include "status.h"
|
||||
#include "membuf.h"
|
||||
@ -524,10 +523,10 @@ start_new_service (assuan_context_t *r_ctx,
|
||||
&& assuan_socket_connect (ctx, sockname, 0, connect_flags))
|
||||
{
|
||||
#ifdef HAVE_W32_SYSTEM
|
||||
err = gnupg_process_spawn (program? program : program_name, argv,
|
||||
GNUPG_PROCESS_DETACHED, NULL, NULL);
|
||||
err = gpgrt_process_spawn (program? program : program_name, argv,
|
||||
GPGRT_PROCESS_DETACHED, NULL, NULL);
|
||||
#else /*!W32*/
|
||||
err = gnupg_process_spawn (program? program : program_name, argv,
|
||||
err = gpgrt_process_spawn (program? program : program_name, argv,
|
||||
0, NULL, NULL);
|
||||
#endif /*!W32*/
|
||||
if (err)
|
||||
|
@ -357,728 +357,3 @@ gnupg_close_pipe (int fd)
|
||||
if (fd != -1)
|
||||
close (fd);
|
||||
}
|
||||
|
||||
#include <sys/socket.h>
|
||||
|
||||
struct gnupg_process {
|
||||
const char *pgmname;
|
||||
unsigned int terminated :1; /* or detached */
|
||||
unsigned int flags;
|
||||
pid_t pid;
|
||||
int fd_in;
|
||||
int fd_out;
|
||||
int fd_err;
|
||||
int wstatus;
|
||||
};
|
||||
|
||||
static int gnupg_process_syscall_func_initialized;
|
||||
|
||||
/* Functions called before and after blocking syscalls. */
|
||||
static void (*pre_syscall_func) (void);
|
||||
static void (*post_syscall_func) (void);
|
||||
|
||||
static void
|
||||
check_syscall_func (void)
|
||||
{
|
||||
if (!gnupg_process_syscall_func_initialized)
|
||||
{
|
||||
gpgrt_get_syscall_clamp (&pre_syscall_func, &post_syscall_func);
|
||||
gnupg_process_syscall_func_initialized = 1;
|
||||
}
|
||||
}
|
||||
|
||||
static void
|
||||
pre_syscall (void)
|
||||
{
|
||||
if (pre_syscall_func)
|
||||
pre_syscall_func ();
|
||||
}
|
||||
|
||||
static void
|
||||
post_syscall (void)
|
||||
{
|
||||
if (post_syscall_func)
|
||||
post_syscall_func ();
|
||||
}
|
||||
|
||||
|
||||
static gpg_err_code_t
|
||||
do_create_socketpair (int filedes[2])
|
||||
{
|
||||
gpg_error_t err = 0;
|
||||
|
||||
pre_syscall ();
|
||||
if (socketpair (AF_LOCAL, SOCK_STREAM, 0, filedes) == -1)
|
||||
{
|
||||
err = gpg_err_code_from_syserror ();
|
||||
filedes[0] = filedes[1] = -1;
|
||||
}
|
||||
post_syscall ();
|
||||
|
||||
return err;
|
||||
}
|
||||
|
||||
static int
|
||||
posix_open_null (int for_write)
|
||||
{
|
||||
int fd;
|
||||
|
||||
fd = open ("/dev/null", for_write? O_WRONLY : O_RDONLY);
|
||||
if (fd == -1)
|
||||
log_fatal ("failed to open '/dev/null': %s\n", strerror (errno));
|
||||
return fd;
|
||||
}
|
||||
|
||||
struct gnupg_spawn_actions {
|
||||
int fd[3];
|
||||
const int *except_fds;
|
||||
char **environ;
|
||||
void (*atfork) (void *);
|
||||
void *atfork_arg;
|
||||
};
|
||||
|
||||
gpg_err_code_t
|
||||
gnupg_spawn_actions_new (gnupg_spawn_actions_t *r_act)
|
||||
{
|
||||
gnupg_spawn_actions_t act;
|
||||
int i;
|
||||
|
||||
*r_act = NULL;
|
||||
|
||||
act = xtrycalloc (1, sizeof (struct gnupg_spawn_actions));
|
||||
if (act == NULL)
|
||||
return gpg_err_code_from_syserror ();
|
||||
|
||||
for (i = 0; i <= 2; i++)
|
||||
act->fd[i] = -1;
|
||||
|
||||
*r_act = act;
|
||||
return 0;
|
||||
}
|
||||
|
||||
void
|
||||
gnupg_spawn_actions_release (gnupg_spawn_actions_t act)
|
||||
{
|
||||
if (!act)
|
||||
return;
|
||||
|
||||
xfree (act);
|
||||
}
|
||||
|
||||
void
|
||||
gnupg_spawn_actions_set_environ (gnupg_spawn_actions_t act,
|
||||
char **environ_for_child)
|
||||
{
|
||||
act->environ = environ_for_child;
|
||||
}
|
||||
|
||||
void
|
||||
gnupg_spawn_actions_set_atfork (gnupg_spawn_actions_t act,
|
||||
void (*atfork)(void *), void *arg)
|
||||
{
|
||||
act->atfork = atfork;
|
||||
act->atfork_arg = arg;
|
||||
}
|
||||
|
||||
void
|
||||
gnupg_spawn_actions_set_redirect (gnupg_spawn_actions_t act,
|
||||
int in, int out, int err)
|
||||
{
|
||||
act->fd[0] = in;
|
||||
act->fd[1] = out;
|
||||
act->fd[2] = err;
|
||||
}
|
||||
|
||||
void
|
||||
gnupg_spawn_actions_set_inherit_fds (gnupg_spawn_actions_t act,
|
||||
const int *fds)
|
||||
{
|
||||
act->except_fds = fds;
|
||||
}
|
||||
|
||||
static void
|
||||
my_exec (const char *pgmname, const char *argv[], gnupg_spawn_actions_t act)
|
||||
{
|
||||
int i;
|
||||
|
||||
/* Assign /dev/null to unused FDs. */
|
||||
for (i = 0; i <= 2; i++)
|
||||
if (act->fd[i] == -1)
|
||||
act->fd[i] = posix_open_null (i);
|
||||
|
||||
/* Connect the standard files. */
|
||||
for (i = 0; i <= 2; i++)
|
||||
if (act->fd[i] != i)
|
||||
{
|
||||
if (dup2 (act->fd[i], i) == -1)
|
||||
log_fatal ("dup2 std%s failed: %s\n",
|
||||
i==0?"in":i==1?"out":"err", strerror (errno));
|
||||
/*
|
||||
* We don't close act->fd[i] here, but close them by
|
||||
* close_all_fds. Note that there may be same one in three of
|
||||
* act->fd[i].
|
||||
*/
|
||||
}
|
||||
|
||||
/* Close all other files. */
|
||||
close_all_fds (3, act->except_fds);
|
||||
|
||||
if (act->environ)
|
||||
environ = act->environ;
|
||||
|
||||
if (act->atfork)
|
||||
act->atfork (act->atfork_arg);
|
||||
|
||||
execv (pgmname, (char *const *)argv);
|
||||
/* No way to print anything, as we have may have closed all streams. */
|
||||
_exit (127);
|
||||
}
|
||||
|
||||
static gpg_err_code_t
|
||||
spawn_detached (const char *pgmname, const char *argv[],
|
||||
gnupg_spawn_actions_t act)
|
||||
{
|
||||
gpg_err_code_t ec;
|
||||
pid_t pid;
|
||||
|
||||
/* FIXME: Is this GnuPG specific or should we keep it. */
|
||||
if (getuid() != geteuid())
|
||||
{
|
||||
xfree (argv);
|
||||
return GPG_ERR_BUG;
|
||||
}
|
||||
|
||||
if (access (pgmname, X_OK))
|
||||
{
|
||||
ec = gpg_err_code_from_syserror ();
|
||||
xfree (argv);
|
||||
return ec;
|
||||
}
|
||||
|
||||
pre_syscall ();
|
||||
pid = fork ();
|
||||
post_syscall ();
|
||||
if (pid == (pid_t)(-1))
|
||||
{
|
||||
ec = gpg_err_code_from_syserror ();
|
||||
log_error (_("error forking process: %s\n"), gpg_strerror (ec));
|
||||
xfree (argv);
|
||||
return ec;
|
||||
}
|
||||
|
||||
if (!pid)
|
||||
{
|
||||
pid_t pid2;
|
||||
|
||||
if (setsid() == -1 || chdir ("/"))
|
||||
_exit (1);
|
||||
|
||||
pid2 = fork (); /* Double fork to let init take over the new child. */
|
||||
if (pid2 == (pid_t)(-1))
|
||||
_exit (1);
|
||||
if (pid2)
|
||||
_exit (0); /* Let the parent exit immediately. */
|
||||
|
||||
my_exec (pgmname, argv, act);
|
||||
/*NOTREACHED*/
|
||||
}
|
||||
|
||||
pre_syscall ();
|
||||
if (waitpid (pid, NULL, 0) == -1)
|
||||
{
|
||||
post_syscall ();
|
||||
ec = gpg_err_code_from_syserror ();
|
||||
log_error ("waitpid failed in spawn_detached: %s",
|
||||
gpg_strerror (ec));
|
||||
return ec;
|
||||
}
|
||||
else
|
||||
post_syscall ();
|
||||
|
||||
return 0;
|
||||
}
|
||||
|
||||
gpg_err_code_t
|
||||
gnupg_process_spawn (const char *pgmname, const char *argv1[],
|
||||
unsigned int flags, gnupg_spawn_actions_t act,
|
||||
gnupg_process_t *r_process)
|
||||
{
|
||||
gpg_err_code_t ec;
|
||||
gnupg_process_t process;
|
||||
int fd_in[2];
|
||||
int fd_out[2];
|
||||
int fd_err[2];
|
||||
pid_t pid;
|
||||
const char **argv;
|
||||
int i, j;
|
||||
struct gnupg_spawn_actions act_default;
|
||||
|
||||
if (!act)
|
||||
{
|
||||
memset (&act_default, 0, sizeof (act_default));
|
||||
for (i = 0; i <= 2; i++)
|
||||
act_default.fd[i] = -1;
|
||||
act = &act_default;
|
||||
}
|
||||
|
||||
check_syscall_func ();
|
||||
|
||||
if (r_process)
|
||||
*r_process = NULL;
|
||||
|
||||
/* Create the command line argument array. */
|
||||
i = 0;
|
||||
if (argv1)
|
||||
while (argv1[i])
|
||||
i++;
|
||||
argv = xtrycalloc (i+2, sizeof *argv);
|
||||
if (!argv)
|
||||
return gpg_err_code_from_syserror ();
|
||||
argv[0] = strrchr (pgmname, '/');
|
||||
if (argv[0])
|
||||
argv[0]++;
|
||||
else
|
||||
argv[0] = pgmname;
|
||||
|
||||
if (argv1)
|
||||
for (i=0, j=1; argv1[i]; i++, j++)
|
||||
argv[j] = argv1[i];
|
||||
|
||||
if ((flags & GNUPG_PROCESS_DETACHED))
|
||||
{
|
||||
if ((flags & GNUPG_PROCESS_STDFDS_SETTING))
|
||||
{
|
||||
xfree (argv);
|
||||
return GPG_ERR_INV_FLAG;
|
||||
}
|
||||
|
||||
/* In detached case, it must be no R_PROCESS. */
|
||||
if (r_process)
|
||||
{
|
||||
xfree (argv);
|
||||
return GPG_ERR_INV_ARG;
|
||||
}
|
||||
|
||||
return spawn_detached (pgmname, argv, act);
|
||||
}
|
||||
|
||||
process = xtrycalloc (1, sizeof (struct gnupg_process));
|
||||
if (process == NULL)
|
||||
{
|
||||
xfree (argv);
|
||||
return gpg_err_code_from_syserror ();
|
||||
}
|
||||
|
||||
process->pgmname = pgmname;
|
||||
process->flags = flags;
|
||||
|
||||
if ((flags & GNUPG_PROCESS_STDINOUT_SOCKETPAIR))
|
||||
{
|
||||
ec = do_create_socketpair (fd_in);
|
||||
if (ec)
|
||||
{
|
||||
xfree (process);
|
||||
xfree (argv);
|
||||
return ec;
|
||||
}
|
||||
fd_out[0] = dup (fd_in[0]);
|
||||
fd_out[1] = dup (fd_in[1]);
|
||||
}
|
||||
else
|
||||
{
|
||||
if ((flags & GNUPG_PROCESS_STDIN_PIPE))
|
||||
{
|
||||
ec = do_create_pipe (fd_in);
|
||||
if (ec)
|
||||
{
|
||||
xfree (process);
|
||||
xfree (argv);
|
||||
return ec;
|
||||
}
|
||||
}
|
||||
else if ((flags & GNUPG_PROCESS_STDIN_KEEP))
|
||||
{
|
||||
fd_in[0] = 0;
|
||||
fd_in[1] = -1;
|
||||
}
|
||||
else
|
||||
{
|
||||
fd_in[0] = -1;
|
||||
fd_in[1] = -1;
|
||||
}
|
||||
|
||||
if ((flags & GNUPG_PROCESS_STDOUT_PIPE))
|
||||
{
|
||||
ec = do_create_pipe (fd_out);
|
||||
if (ec)
|
||||
{
|
||||
if (fd_in[0] >= 0 && fd_in[0] != 0)
|
||||
close (fd_in[0]);
|
||||
if (fd_in[1] >= 0)
|
||||
close (fd_in[1]);
|
||||
xfree (process);
|
||||
xfree (argv);
|
||||
return ec;
|
||||
}
|
||||
}
|
||||
else if ((flags & GNUPG_PROCESS_STDOUT_KEEP))
|
||||
{
|
||||
fd_out[0] = -1;
|
||||
fd_out[1] = 1;
|
||||
}
|
||||
else
|
||||
{
|
||||
fd_out[0] = -1;
|
||||
fd_out[1] = -1;
|
||||
}
|
||||
}
|
||||
|
||||
if ((flags & GNUPG_PROCESS_STDERR_PIPE))
|
||||
{
|
||||
ec = do_create_pipe (fd_err);
|
||||
if (ec)
|
||||
{
|
||||
if (fd_in[0] >= 0 && fd_in[0] != 0)
|
||||
close (fd_in[0]);
|
||||
if (fd_in[1] >= 0)
|
||||
close (fd_in[1]);
|
||||
if (fd_out[0] >= 0)
|
||||
close (fd_out[0]);
|
||||
if (fd_out[1] >= 0 && fd_out[1] != 1)
|
||||
close (fd_out[1]);
|
||||
xfree (process);
|
||||
xfree (argv);
|
||||
return ec;
|
||||
}
|
||||
}
|
||||
else if ((flags & GNUPG_PROCESS_STDERR_KEEP))
|
||||
{
|
||||
fd_err[0] = -1;
|
||||
fd_err[1] = 2;
|
||||
}
|
||||
else
|
||||
{
|
||||
fd_err[0] = -1;
|
||||
fd_err[1] = -1;
|
||||
}
|
||||
|
||||
pre_syscall ();
|
||||
pid = fork ();
|
||||
post_syscall ();
|
||||
if (pid == (pid_t)(-1))
|
||||
{
|
||||
ec = gpg_err_code_from_syserror ();
|
||||
log_error (_("error forking process: %s\n"), gpg_strerror (ec));
|
||||
if (fd_in[0] >= 0 && fd_in[0] != 0)
|
||||
close (fd_in[0]);
|
||||
if (fd_in[1] >= 0)
|
||||
close (fd_in[1]);
|
||||
if (fd_out[0] >= 0)
|
||||
close (fd_out[0]);
|
||||
if (fd_out[1] >= 0 && fd_out[1] != 1)
|
||||
close (fd_out[1]);
|
||||
if (fd_err[0] >= 0)
|
||||
close (fd_err[0]);
|
||||
if (fd_err[1] >= 0 && fd_err[1] != 2)
|
||||
close (fd_err[1]);
|
||||
xfree (process);
|
||||
xfree (argv);
|
||||
return ec;
|
||||
}
|
||||
|
||||
if (!pid)
|
||||
{
|
||||
if (fd_in[1] >= 0)
|
||||
close (fd_in[1]);
|
||||
if (fd_out[0] >= 0)
|
||||
close (fd_out[0]);
|
||||
if (fd_err[0] >= 0)
|
||||
close (fd_err[0]);
|
||||
|
||||
if (act->fd[0] < 0)
|
||||
act->fd[0] = fd_in[0];
|
||||
if (act->fd[1] < 0)
|
||||
act->fd[1] = fd_out[1];
|
||||
if (act->fd[2] < 0)
|
||||
act->fd[2] = fd_err[1];
|
||||
|
||||
/* Run child. */
|
||||
my_exec (pgmname, argv, act);
|
||||
/*NOTREACHED*/
|
||||
}
|
||||
|
||||
xfree (argv);
|
||||
process->pid = pid;
|
||||
|
||||
if (fd_in[0] >= 0 && fd_in[0] != 0)
|
||||
close (fd_in[0]);
|
||||
if (fd_out[1] >= 0 && fd_out[1] != 1)
|
||||
close (fd_out[1]);
|
||||
if (fd_err[1] >= 0 && fd_err[1] != 2)
|
||||
close (fd_err[1]);
|
||||
process->fd_in = fd_in[1];
|
||||
process->fd_out = fd_out[0];
|
||||
process->fd_err = fd_err[0];
|
||||
process->wstatus = -1;
|
||||
process->terminated = 0;
|
||||
|
||||
if (r_process == NULL)
|
||||
{
|
||||
ec = gnupg_process_wait (process, 1);
|
||||
gnupg_process_release (process);
|
||||
return ec;
|
||||
}
|
||||
|
||||
*r_process = process;
|
||||
return 0;
|
||||
}
|
||||
|
||||
static gpg_err_code_t
|
||||
process_kill (gnupg_process_t process, int sig)
|
||||
{
|
||||
gpg_err_code_t ec = 0;
|
||||
pid_t pid = process->pid;
|
||||
|
||||
pre_syscall ();
|
||||
if (kill (pid, sig) < 0)
|
||||
ec = gpg_err_code_from_syserror ();
|
||||
post_syscall ();
|
||||
return ec;
|
||||
}
|
||||
|
||||
gpg_err_code_t
|
||||
gnupg_process_terminate (gnupg_process_t process)
|
||||
{
|
||||
return process_kill (process, SIGTERM);
|
||||
}
|
||||
|
||||
gpg_err_code_t
|
||||
gnupg_process_get_fds (gnupg_process_t process, unsigned int flags,
|
||||
int *r_fd_in, int *r_fd_out, int *r_fd_err)
|
||||
{
|
||||
(void)flags;
|
||||
if (r_fd_in)
|
||||
{
|
||||
*r_fd_in = process->fd_in;
|
||||
process->fd_in = -1;
|
||||
}
|
||||
if (r_fd_out)
|
||||
{
|
||||
*r_fd_out = process->fd_out;
|
||||
process->fd_out = -1;
|
||||
}
|
||||
if (r_fd_err)
|
||||
{
|
||||
*r_fd_err = process->fd_err;
|
||||
process->fd_err = -1;
|
||||
}
|
||||
|
||||
return 0;
|
||||
}
|
||||
|
||||
gpg_err_code_t
|
||||
gnupg_process_get_streams (gnupg_process_t process, unsigned int flags,
|
||||
gpgrt_stream_t *r_fp_in, gpgrt_stream_t *r_fp_out,
|
||||
gpgrt_stream_t *r_fp_err)
|
||||
{
|
||||
int nonblock = (flags & GNUPG_PROCESS_STREAM_NONBLOCK)? 1: 0;
|
||||
|
||||
if (r_fp_in)
|
||||
{
|
||||
*r_fp_in = es_fdopen (process->fd_in, nonblock? "w,nonblock" : "w");
|
||||
process->fd_in = -1;
|
||||
}
|
||||
if (r_fp_out)
|
||||
{
|
||||
*r_fp_out = es_fdopen (process->fd_out, nonblock? "r,nonblock" : "r");
|
||||
process->fd_out = -1;
|
||||
}
|
||||
if (r_fp_err)
|
||||
{
|
||||
*r_fp_err = es_fdopen (process->fd_err, nonblock? "r,nonblock" : "r");
|
||||
process->fd_err = -1;
|
||||
}
|
||||
return 0;
|
||||
}
|
||||
|
||||
static gpg_err_code_t
|
||||
process_vctl (gnupg_process_t process, unsigned int request, va_list arg_ptr)
|
||||
{
|
||||
switch (request)
|
||||
{
|
||||
case GNUPG_PROCESS_NOP:
|
||||
return 0;
|
||||
|
||||
case GNUPG_PROCESS_GET_PROC_ID:
|
||||
{
|
||||
int *r_id = va_arg (arg_ptr, int *);
|
||||
|
||||
if (r_id == NULL)
|
||||
return GPG_ERR_INV_VALUE;
|
||||
|
||||
*r_id = (int)process->pid;
|
||||
return 0;
|
||||
}
|
||||
|
||||
case GNUPG_PROCESS_GET_EXIT_ID:
|
||||
{
|
||||
int status = process->wstatus;
|
||||
int *r_exit_status = va_arg (arg_ptr, int *);
|
||||
|
||||
if (!process->terminated)
|
||||
return GPG_ERR_UNFINISHED;
|
||||
|
||||
if (WIFEXITED (status))
|
||||
{
|
||||
if (r_exit_status)
|
||||
*r_exit_status = WEXITSTATUS (status);
|
||||
}
|
||||
else
|
||||
*r_exit_status = -1;
|
||||
|
||||
return 0;
|
||||
}
|
||||
|
||||
case GNUPG_PROCESS_GET_PID:
|
||||
{
|
||||
pid_t *r_pid = va_arg (arg_ptr, pid_t *);
|
||||
|
||||
if (r_pid == NULL)
|
||||
return GPG_ERR_INV_VALUE;
|
||||
|
||||
*r_pid = process->pid;
|
||||
return 0;
|
||||
}
|
||||
|
||||
case GNUPG_PROCESS_GET_WSTATUS:
|
||||
{
|
||||
int status = process->wstatus;
|
||||
int *r_if_exited = va_arg (arg_ptr, int *);
|
||||
int *r_if_signaled = va_arg (arg_ptr, int *);
|
||||
int *r_exit_status = va_arg (arg_ptr, int *);
|
||||
int *r_termsig = va_arg (arg_ptr, int *);
|
||||
|
||||
if (!process->terminated)
|
||||
return GPG_ERR_UNFINISHED;
|
||||
|
||||
if (WIFEXITED (status))
|
||||
{
|
||||
if (r_if_exited)
|
||||
*r_if_exited = 1;
|
||||
if (r_if_signaled)
|
||||
*r_if_signaled = 0;
|
||||
if (r_exit_status)
|
||||
*r_exit_status = WEXITSTATUS (status);
|
||||
if (r_termsig)
|
||||
*r_termsig = 0;
|
||||
}
|
||||
else if (WIFSIGNALED (status))
|
||||
{
|
||||
if (r_if_exited)
|
||||
*r_if_exited = 0;
|
||||
if (r_if_signaled)
|
||||
*r_if_signaled = 1;
|
||||
if (r_exit_status)
|
||||
*r_exit_status = 0;
|
||||
if (r_termsig)
|
||||
*r_termsig = WTERMSIG (status);
|
||||
}
|
||||
|
||||
return 0;
|
||||
}
|
||||
|
||||
case GNUPG_PROCESS_KILL:
|
||||
{
|
||||
int sig = va_arg (arg_ptr, int);
|
||||
|
||||
return process_kill (process, sig);
|
||||
}
|
||||
|
||||
default:
|
||||
break;
|
||||
}
|
||||
|
||||
return GPG_ERR_UNKNOWN_COMMAND;
|
||||
}
|
||||
|
||||
gpg_err_code_t
|
||||
gnupg_process_ctl (gnupg_process_t process, unsigned int request, ...)
|
||||
{
|
||||
va_list arg_ptr;
|
||||
gpg_err_code_t ec;
|
||||
|
||||
va_start (arg_ptr, request);
|
||||
ec = process_vctl (process, request, arg_ptr);
|
||||
va_end (arg_ptr);
|
||||
return ec;
|
||||
}
|
||||
|
||||
gpg_err_code_t
|
||||
gnupg_process_wait (gnupg_process_t process, int hang)
|
||||
{
|
||||
gpg_err_code_t ec;
|
||||
int status;
|
||||
pid_t pid;
|
||||
|
||||
if (process->terminated)
|
||||
/* Already terminated. */
|
||||
return 0;
|
||||
|
||||
pre_syscall ();
|
||||
while ((pid = waitpid (process->pid, &status, hang? 0: WNOHANG))
|
||||
== (pid_t)(-1) && errno == EINTR);
|
||||
post_syscall ();
|
||||
|
||||
if (pid == (pid_t)(-1))
|
||||
{
|
||||
ec = gpg_err_code_from_syserror ();
|
||||
log_error (_("waiting for process %d to terminate failed: %s\n"),
|
||||
(int)pid, gpg_strerror (ec));
|
||||
}
|
||||
else if (!pid)
|
||||
{
|
||||
ec = GPG_ERR_TIMEOUT; /* Still running. */
|
||||
}
|
||||
else
|
||||
{
|
||||
process->terminated = 1;
|
||||
process->wstatus = status;
|
||||
ec = 0;
|
||||
}
|
||||
|
||||
return ec;
|
||||
}
|
||||
|
||||
void
|
||||
gnupg_process_release (gnupg_process_t process)
|
||||
{
|
||||
if (!process)
|
||||
return;
|
||||
|
||||
if (!process->terminated)
|
||||
{
|
||||
gnupg_process_terminate (process);
|
||||
gnupg_process_wait (process, 1);
|
||||
}
|
||||
|
||||
xfree (process);
|
||||
}
|
||||
|
||||
gpg_err_code_t
|
||||
gnupg_process_wait_list (gnupg_process_t *process_list, int count, int hang)
|
||||
{
|
||||
gpg_err_code_t ec = 0;
|
||||
int i;
|
||||
|
||||
for (i = 0; i < count; i++)
|
||||
{
|
||||
if (process_list[i]->terminated)
|
||||
continue;
|
||||
|
||||
ec = gnupg_process_wait (process_list[i], hang);
|
||||
if (ec)
|
||||
break;
|
||||
}
|
||||
|
||||
return ec;
|
||||
}
|
||||
|
@ -184,77 +184,6 @@ get_all_open_fds (void)
|
||||
return array;
|
||||
}
|
||||
|
||||
|
||||
/* Helper function to build_w32_commandline. */
|
||||
static char *
|
||||
build_w32_commandline_copy (char *buffer, const char *string)
|
||||
{
|
||||
char *p = buffer;
|
||||
const char *s;
|
||||
|
||||
if (!*string) /* Empty string. */
|
||||
p = stpcpy (p, "\"\"");
|
||||
else if (strpbrk (string, " \t\n\v\f\""))
|
||||
{
|
||||
/* Need to do some kind of quoting. */
|
||||
p = stpcpy (p, "\"");
|
||||
for (s=string; *s; s++)
|
||||
{
|
||||
*p++ = *s;
|
||||
if (*s == '\"')
|
||||
*p++ = *s;
|
||||
}
|
||||
*p++ = '\"';
|
||||
*p = 0;
|
||||
}
|
||||
else
|
||||
p = stpcpy (p, string);
|
||||
|
||||
return p;
|
||||
}
|
||||
|
||||
/* Build a command line for use with W32's CreateProcess. On success
|
||||
CMDLINE gets the address of a newly allocated string. */
|
||||
static gpg_error_t
|
||||
build_w32_commandline (const char *pgmname, const char * const *argv,
|
||||
char **cmdline)
|
||||
{
|
||||
int i, n;
|
||||
const char *s;
|
||||
char *buf, *p;
|
||||
|
||||
*cmdline = NULL;
|
||||
n = 0;
|
||||
s = pgmname;
|
||||
n += strlen (s) + 1 + 2; /* (1 space, 2 quoting */
|
||||
for (; *s; s++)
|
||||
if (*s == '\"')
|
||||
n++; /* Need to double inner quotes. */
|
||||
for (i=0; (s=argv[i]); i++)
|
||||
{
|
||||
n += strlen (s) + 1 + 2; /* (1 space, 2 quoting */
|
||||
for (; *s; s++)
|
||||
if (*s == '\"')
|
||||
n++; /* Need to double inner quotes. */
|
||||
}
|
||||
n++;
|
||||
|
||||
buf = p = xtrymalloc (n);
|
||||
if (!buf)
|
||||
return my_error_from_syserror ();
|
||||
|
||||
p = build_w32_commandline_copy (p, pgmname);
|
||||
for (i=0; argv[i]; i++)
|
||||
{
|
||||
*p++ = ' ';
|
||||
p = build_w32_commandline_copy (p, argv[i]);
|
||||
}
|
||||
|
||||
*cmdline= buf;
|
||||
return 0;
|
||||
}
|
||||
|
||||
|
||||
#define INHERIT_READ 1
|
||||
#define INHERIT_WRITE 2
|
||||
#define INHERIT_BOTH (INHERIT_READ|INHERIT_WRITE)
|
||||
@ -293,21 +222,6 @@ create_inheritable_pipe (HANDLE filedes[2], int flags)
|
||||
}
|
||||
|
||||
|
||||
static HANDLE
|
||||
w32_open_null (int for_write)
|
||||
{
|
||||
HANDLE hfile;
|
||||
|
||||
hfile = CreateFileW (L"nul",
|
||||
for_write? GENERIC_WRITE : GENERIC_READ,
|
||||
FILE_SHARE_READ | FILE_SHARE_WRITE,
|
||||
NULL, OPEN_EXISTING, 0, NULL);
|
||||
if (hfile == INVALID_HANDLE_VALUE)
|
||||
log_debug ("can't open 'nul': %s\n", w32_strerror (-1));
|
||||
return hfile;
|
||||
}
|
||||
|
||||
|
||||
static gpg_error_t
|
||||
create_pipe_and_estream (int filedes[2], int flags,
|
||||
estream_t *r_fp, int outbound, int nonblock)
|
||||
@ -408,891 +322,3 @@ gnupg_close_pipe (int fd)
|
||||
if (fd != -1)
|
||||
close (fd);
|
||||
}
|
||||
|
||||
struct gnupg_spawn_actions {
|
||||
void *hd[3];
|
||||
void **inherit_hds;
|
||||
char *env;
|
||||
};
|
||||
|
||||
struct gnupg_process {
|
||||
const char *pgmname;
|
||||
unsigned int terminated :1; /* or detached */
|
||||
unsigned int flags;
|
||||
HANDLE hProcess;
|
||||
HANDLE hd_in;
|
||||
HANDLE hd_out;
|
||||
HANDLE hd_err;
|
||||
int exitcode;
|
||||
};
|
||||
|
||||
static int gnupg_process_syscall_func_initialized;
|
||||
|
||||
/* Functions called before and after blocking syscalls. */
|
||||
static void (*pre_syscall_func) (void);
|
||||
static void (*post_syscall_func) (void);
|
||||
|
||||
static void
|
||||
check_syscall_func (void)
|
||||
{
|
||||
if (!gnupg_process_syscall_func_initialized)
|
||||
{
|
||||
gpgrt_get_syscall_clamp (&pre_syscall_func, &post_syscall_func);
|
||||
gnupg_process_syscall_func_initialized = 1;
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
static void
|
||||
pre_syscall (void)
|
||||
{
|
||||
if (pre_syscall_func)
|
||||
pre_syscall_func ();
|
||||
}
|
||||
|
||||
|
||||
static void
|
||||
post_syscall (void)
|
||||
{
|
||||
if (post_syscall_func)
|
||||
post_syscall_func ();
|
||||
}
|
||||
|
||||
|
||||
/*
|
||||
* Check if STARTUPINFOEXW supports PROC_THREAD_ATTRIBUTE_HANDLE_LIST.
|
||||
*/
|
||||
static int
|
||||
check_windows_version (void)
|
||||
{
|
||||
static int is_vista_or_later = -1;
|
||||
|
||||
OSVERSIONINFO osvi;
|
||||
|
||||
if (is_vista_or_later == -1)
|
||||
{
|
||||
memset (&osvi,0,sizeof(osvi));
|
||||
osvi.dwOSVersionInfoSize = sizeof(osvi);
|
||||
GetVersionEx (&osvi);
|
||||
|
||||
/* The feature is available on Vista or later. */
|
||||
is_vista_or_later = (osvi.dwMajorVersion >= 6);
|
||||
}
|
||||
|
||||
return is_vista_or_later;
|
||||
}
|
||||
|
||||
|
||||
static gpg_err_code_t
|
||||
spawn_detached (const char *pgmname, char *cmdline, gnupg_spawn_actions_t act)
|
||||
{
|
||||
SECURITY_ATTRIBUTES sec_attr;
|
||||
PROCESS_INFORMATION pi = { NULL, 0, 0, 0 };
|
||||
STARTUPINFOEXW si;
|
||||
int cr_flags;
|
||||
wchar_t *wcmdline = NULL;
|
||||
wchar_t *wpgmname = NULL;
|
||||
gpg_err_code_t ec;
|
||||
int ret;
|
||||
BOOL ask_inherit = FALSE;
|
||||
int i;
|
||||
|
||||
ec = gnupg_access (pgmname, X_OK);
|
||||
if (ec)
|
||||
{
|
||||
xfree (cmdline);
|
||||
return ec;
|
||||
}
|
||||
|
||||
memset (&si, 0, sizeof si);
|
||||
|
||||
i = 0;
|
||||
if (act->hd[0] != INVALID_HANDLE_VALUE)
|
||||
i++;
|
||||
if (act->hd[1] != INVALID_HANDLE_VALUE)
|
||||
i++;
|
||||
if (act->hd[2] != INVALID_HANDLE_VALUE)
|
||||
i++;
|
||||
|
||||
if (i != 0 || act->inherit_hds)
|
||||
{
|
||||
SIZE_T attr_list_size = 0;
|
||||
HANDLE hd[16];
|
||||
HANDLE *hd_p = act->inherit_hds;
|
||||
int j = 0;
|
||||
|
||||
if (act->hd[0] != INVALID_HANDLE_VALUE)
|
||||
hd[j++] = act->hd[0];
|
||||
if (act->hd[1] != INVALID_HANDLE_VALUE)
|
||||
hd[j++] = act->hd[1];
|
||||
if (act->hd[1] != INVALID_HANDLE_VALUE)
|
||||
hd[j++] = act->hd[2];
|
||||
if (hd_p)
|
||||
{
|
||||
while (*hd_p != INVALID_HANDLE_VALUE)
|
||||
if (j < DIM (hd))
|
||||
hd[j++] = *hd_p++;
|
||||
else
|
||||
{
|
||||
log_error ("Too much handles\n");
|
||||
break;
|
||||
}
|
||||
}
|
||||
|
||||
if (j)
|
||||
{
|
||||
if (check_windows_version ())
|
||||
{
|
||||
InitializeProcThreadAttributeList (NULL, 1, 0, &attr_list_size);
|
||||
si.lpAttributeList = xtrymalloc (attr_list_size);
|
||||
if (si.lpAttributeList == NULL)
|
||||
{
|
||||
xfree (cmdline);
|
||||
return gpg_err_code_from_syserror ();
|
||||
}
|
||||
InitializeProcThreadAttributeList (si.lpAttributeList, 1, 0,
|
||||
&attr_list_size);
|
||||
UpdateProcThreadAttribute (si.lpAttributeList, 0,
|
||||
PROC_THREAD_ATTRIBUTE_HANDLE_LIST,
|
||||
hd, sizeof (HANDLE) * j, NULL, NULL);
|
||||
}
|
||||
|
||||
ask_inherit = TRUE;
|
||||
}
|
||||
}
|
||||
|
||||
/* Prepare security attributes. */
|
||||
memset (&sec_attr, 0, sizeof sec_attr );
|
||||
sec_attr.nLength = sizeof sec_attr;
|
||||
sec_attr.bInheritHandle = FALSE;
|
||||
|
||||
/* Start the process. */
|
||||
si.StartupInfo.cb = sizeof (si);
|
||||
si.StartupInfo.dwFlags = ((i > 0 ? STARTF_USESTDHANDLES : 0)
|
||||
| STARTF_USESHOWWINDOW);
|
||||
si.StartupInfo.wShowWindow = DEBUG_W32_SPAWN? SW_SHOW : SW_MINIMIZE;
|
||||
|
||||
cr_flags = (CREATE_DEFAULT_ERROR_MODE
|
||||
| GetPriorityClass (GetCurrentProcess ())
|
||||
| CREATE_NEW_PROCESS_GROUP
|
||||
| DETACHED_PROCESS);
|
||||
|
||||
/* Take care: CreateProcessW may modify wpgmname */
|
||||
if (!(wpgmname = utf8_to_wchar (pgmname)))
|
||||
ret = 0;
|
||||
else if (!(wcmdline = utf8_to_wchar (cmdline)))
|
||||
ret = 0;
|
||||
else
|
||||
ret = CreateProcessW (wpgmname, /* Program to start. */
|
||||
wcmdline, /* Command line arguments. */
|
||||
&sec_attr, /* Process security attributes. */
|
||||
&sec_attr, /* Thread security attributes. */
|
||||
ask_inherit, /* Inherit handles. */
|
||||
cr_flags, /* Creation flags. */
|
||||
act->env, /* Environment. */
|
||||
NULL, /* Use current drive/directory. */
|
||||
(STARTUPINFOW *)&si, /* Startup information. */
|
||||
&pi /* Returns process information. */
|
||||
);
|
||||
if (!ret)
|
||||
{
|
||||
if (!wpgmname || !wcmdline)
|
||||
log_error ("CreateProcess failed (utf8_to_wchar): %s\n",
|
||||
strerror (errno));
|
||||
else
|
||||
log_error ("CreateProcess(detached) failed: %d\n",
|
||||
(int)GetLastError ());
|
||||
xfree (wpgmname);
|
||||
xfree (wcmdline);
|
||||
xfree (cmdline);
|
||||
return GPG_ERR_GENERAL;
|
||||
}
|
||||
if (si.lpAttributeList)
|
||||
DeleteProcThreadAttributeList (si.lpAttributeList);
|
||||
xfree (wpgmname);
|
||||
xfree (wcmdline);
|
||||
xfree (cmdline);
|
||||
|
||||
/* log_debug ("CreateProcess(detached) ready: hProcess=%p hThread=%p" */
|
||||
/* " dwProcessID=%d dwThreadId=%d\n", */
|
||||
/* pi.hProcess, pi.hThread, */
|
||||
/* (int) pi.dwProcessId, (int) pi.dwThreadId); */
|
||||
|
||||
/* Note: AllowSetForegroundWindow doesn't make sense for background
|
||||
process. */
|
||||
|
||||
CloseHandle (pi.hThread);
|
||||
CloseHandle (pi.hProcess);
|
||||
return 0;
|
||||
}
|
||||
|
||||
|
||||
gpg_err_code_t
|
||||
gnupg_spawn_actions_new (gnupg_spawn_actions_t *r_act)
|
||||
{
|
||||
gnupg_spawn_actions_t act;
|
||||
int i;
|
||||
|
||||
*r_act = NULL;
|
||||
|
||||
act = xtrycalloc (1, sizeof (struct gnupg_spawn_actions));
|
||||
if (act == NULL)
|
||||
return gpg_err_code_from_syserror ();
|
||||
|
||||
for (i = 0; i <= 2; i++)
|
||||
act->hd[i] = INVALID_HANDLE_VALUE;
|
||||
|
||||
*r_act = act;
|
||||
return 0;
|
||||
}
|
||||
|
||||
void
|
||||
gnupg_spawn_actions_release (gnupg_spawn_actions_t act)
|
||||
{
|
||||
if (!act)
|
||||
return;
|
||||
|
||||
xfree (act);
|
||||
}
|
||||
|
||||
void
|
||||
gnupg_spawn_actions_set_envvars (gnupg_spawn_actions_t act, char *env)
|
||||
{
|
||||
act->env = env;
|
||||
}
|
||||
|
||||
void
|
||||
gnupg_spawn_actions_set_redirect (gnupg_spawn_actions_t act,
|
||||
void *in, void *out, void *err)
|
||||
{
|
||||
act->hd[0] = in;
|
||||
act->hd[1] = out;
|
||||
act->hd[2] = err;
|
||||
}
|
||||
|
||||
void
|
||||
gnupg_spawn_actions_set_inherit_handles (gnupg_spawn_actions_t act,
|
||||
void **handles)
|
||||
{
|
||||
act->inherit_hds = handles;
|
||||
}
|
||||
|
||||
|
||||
gpg_err_code_t
|
||||
gnupg_process_spawn (const char *pgmname, const char *argv[],
|
||||
unsigned int flags, gnupg_spawn_actions_t act,
|
||||
gnupg_process_t *r_process)
|
||||
{
|
||||
gpg_err_code_t ec;
|
||||
gnupg_process_t process;
|
||||
SECURITY_ATTRIBUTES sec_attr;
|
||||
PROCESS_INFORMATION pi = { NULL, 0, 0, 0 };
|
||||
STARTUPINFOEXW si;
|
||||
int cr_flags;
|
||||
char *cmdline;
|
||||
wchar_t *wcmdline = NULL;
|
||||
wchar_t *wpgmname = NULL;
|
||||
int ret;
|
||||
HANDLE hd_in[2];
|
||||
HANDLE hd_out[2];
|
||||
HANDLE hd_err[2];
|
||||
int i;
|
||||
BOOL ask_inherit = FALSE;
|
||||
BOOL allow_foreground_window = FALSE;
|
||||
struct gnupg_spawn_actions act_default;
|
||||
|
||||
if (!act)
|
||||
{
|
||||
memset (&act_default, 0, sizeof (act_default));
|
||||
for (i = 0; i <= 2; i++)
|
||||
act_default.hd[i] = INVALID_HANDLE_VALUE;
|
||||
act = &act_default;
|
||||
}
|
||||
|
||||
check_syscall_func ();
|
||||
|
||||
/* Build the command line. */
|
||||
ec = build_w32_commandline (pgmname, argv, &cmdline);
|
||||
if (ec)
|
||||
return ec;
|
||||
|
||||
if ((flags & GNUPG_PROCESS_DETACHED))
|
||||
{
|
||||
if ((flags & GNUPG_PROCESS_STDFDS_SETTING))
|
||||
{
|
||||
xfree (cmdline);
|
||||
return GPG_ERR_INV_FLAG;
|
||||
}
|
||||
|
||||
/* In detached case, it must be no R_PROCESS. */
|
||||
if (r_process)
|
||||
{
|
||||
xfree (cmdline);
|
||||
return GPG_ERR_INV_ARG;
|
||||
}
|
||||
|
||||
return spawn_detached (pgmname, cmdline, act);
|
||||
}
|
||||
|
||||
if (r_process)
|
||||
*r_process = NULL;
|
||||
|
||||
process = xtrymalloc (sizeof (struct gnupg_process));
|
||||
if (process == NULL)
|
||||
{
|
||||
xfree (cmdline);
|
||||
return gpg_err_code_from_syserror ();
|
||||
}
|
||||
|
||||
process->pgmname = pgmname;
|
||||
process->flags = flags;
|
||||
|
||||
if ((flags & GNUPG_PROCESS_STDINOUT_SOCKETPAIR))
|
||||
{
|
||||
xfree (process);
|
||||
xfree (cmdline);
|
||||
return GPG_ERR_NOT_SUPPORTED;
|
||||
}
|
||||
|
||||
if ((flags & GNUPG_PROCESS_STDIN_PIPE))
|
||||
{
|
||||
ec = create_inheritable_pipe (hd_in, INHERIT_READ);
|
||||
if (ec)
|
||||
{
|
||||
xfree (process);
|
||||
xfree (cmdline);
|
||||
return ec;
|
||||
}
|
||||
}
|
||||
else if ((flags & GNUPG_PROCESS_STDIN_KEEP))
|
||||
{
|
||||
hd_in[0] = GetStdHandle (STD_INPUT_HANDLE);
|
||||
hd_in[1] = INVALID_HANDLE_VALUE;
|
||||
}
|
||||
else
|
||||
{
|
||||
hd_in[0] = w32_open_null (0);
|
||||
hd_in[1] = INVALID_HANDLE_VALUE;
|
||||
}
|
||||
|
||||
if ((flags & GNUPG_PROCESS_STDOUT_PIPE))
|
||||
{
|
||||
ec = create_inheritable_pipe (hd_out, INHERIT_WRITE);
|
||||
if (ec)
|
||||
{
|
||||
if (hd_in[0] != INVALID_HANDLE_VALUE)
|
||||
CloseHandle (hd_in[0]);
|
||||
if (hd_in[1] != INVALID_HANDLE_VALUE)
|
||||
CloseHandle (hd_in[1]);
|
||||
xfree (process);
|
||||
xfree (cmdline);
|
||||
return ec;
|
||||
}
|
||||
}
|
||||
else if ((flags & GNUPG_PROCESS_STDOUT_KEEP))
|
||||
{
|
||||
hd_out[0] = INVALID_HANDLE_VALUE;
|
||||
hd_out[1] = GetStdHandle (STD_OUTPUT_HANDLE);
|
||||
}
|
||||
else
|
||||
{
|
||||
hd_out[0] = INVALID_HANDLE_VALUE;
|
||||
hd_out[1] = w32_open_null (1);
|
||||
}
|
||||
|
||||
if ((flags & GNUPG_PROCESS_STDERR_PIPE))
|
||||
{
|
||||
ec = create_inheritable_pipe (hd_err, INHERIT_WRITE);
|
||||
if (ec)
|
||||
{
|
||||
if (hd_in[0] != INVALID_HANDLE_VALUE)
|
||||
CloseHandle (hd_in[0]);
|
||||
if (hd_in[1] != INVALID_HANDLE_VALUE)
|
||||
CloseHandle (hd_in[1]);
|
||||
if (hd_out[0] != INVALID_HANDLE_VALUE)
|
||||
CloseHandle (hd_out[0]);
|
||||
if (hd_out[1] != INVALID_HANDLE_VALUE)
|
||||
CloseHandle (hd_out[1]);
|
||||
xfree (process);
|
||||
xfree (cmdline);
|
||||
return ec;
|
||||
}
|
||||
}
|
||||
else if ((flags & GNUPG_PROCESS_STDERR_KEEP))
|
||||
{
|
||||
hd_err[0] = INVALID_HANDLE_VALUE;
|
||||
hd_err[1] = GetStdHandle (STD_ERROR_HANDLE);
|
||||
}
|
||||
else
|
||||
{
|
||||
hd_err[0] = INVALID_HANDLE_VALUE;
|
||||
hd_err[1] = w32_open_null (1);
|
||||
}
|
||||
|
||||
memset (&si, 0, sizeof si);
|
||||
|
||||
if (act->hd[0] == INVALID_HANDLE_VALUE)
|
||||
act->hd[0] = hd_in[0];
|
||||
if (act->hd[1] == INVALID_HANDLE_VALUE)
|
||||
act->hd[1] = hd_out[1];
|
||||
if (act->hd[2] == INVALID_HANDLE_VALUE)
|
||||
act->hd[2] = hd_err[1];
|
||||
|
||||
i = 0;
|
||||
if (act->hd[0] != INVALID_HANDLE_VALUE)
|
||||
i++;
|
||||
if (act->hd[1] != INVALID_HANDLE_VALUE)
|
||||
i++;
|
||||
if (act->hd[2] != INVALID_HANDLE_VALUE)
|
||||
i++;
|
||||
|
||||
if (i != 0 || act->inherit_hds)
|
||||
{
|
||||
SIZE_T attr_list_size = 0;
|
||||
HANDLE hd[16];
|
||||
HANDLE *hd_p = act->inherit_hds;
|
||||
int j = 0;
|
||||
|
||||
if (act->hd[0] != INVALID_HANDLE_VALUE)
|
||||
hd[j++] = act->hd[0];
|
||||
if (act->hd[1] != INVALID_HANDLE_VALUE)
|
||||
hd[j++] = act->hd[1];
|
||||
if (act->hd[1] != INVALID_HANDLE_VALUE)
|
||||
hd[j++] = act->hd[2];
|
||||
if (hd_p)
|
||||
{
|
||||
while (*hd_p != INVALID_HANDLE_VALUE)
|
||||
if (j < DIM (hd))
|
||||
hd[j++] = *hd_p++;
|
||||
else
|
||||
{
|
||||
log_error ("Too much handles\n");
|
||||
break;
|
||||
}
|
||||
}
|
||||
|
||||
if (j)
|
||||
{
|
||||
if (check_windows_version ())
|
||||
{
|
||||
InitializeProcThreadAttributeList (NULL, 1, 0, &attr_list_size);
|
||||
si.lpAttributeList = xtrymalloc (attr_list_size);
|
||||
if (si.lpAttributeList == NULL)
|
||||
{
|
||||
if ((flags & GNUPG_PROCESS_STDIN_PIPE)
|
||||
|| !(flags & GNUPG_PROCESS_STDIN_KEEP))
|
||||
CloseHandle (hd_in[0]);
|
||||
if ((flags & GNUPG_PROCESS_STDIN_PIPE))
|
||||
CloseHandle (hd_in[1]);
|
||||
if ((flags & GNUPG_PROCESS_STDOUT_PIPE))
|
||||
CloseHandle (hd_out[0]);
|
||||
if ((flags & GNUPG_PROCESS_STDOUT_PIPE)
|
||||
|| !(flags & GNUPG_PROCESS_STDOUT_KEEP))
|
||||
CloseHandle (hd_out[1]);
|
||||
if ((flags & GNUPG_PROCESS_STDERR_PIPE))
|
||||
CloseHandle (hd_err[0]);
|
||||
if ((flags & GNUPG_PROCESS_STDERR_PIPE)
|
||||
|| !(flags & GNUPG_PROCESS_STDERR_KEEP))
|
||||
CloseHandle (hd_err[1]);
|
||||
xfree (process);
|
||||
xfree (cmdline);
|
||||
return gpg_err_code_from_syserror ();
|
||||
}
|
||||
InitializeProcThreadAttributeList (si.lpAttributeList, 1, 0,
|
||||
&attr_list_size);
|
||||
UpdateProcThreadAttribute (si.lpAttributeList, 0,
|
||||
PROC_THREAD_ATTRIBUTE_HANDLE_LIST,
|
||||
hd, sizeof (HANDLE) * j, NULL, NULL);
|
||||
}
|
||||
ask_inherit = TRUE;
|
||||
}
|
||||
}
|
||||
|
||||
/* Prepare security attributes. */
|
||||
memset (&sec_attr, 0, sizeof sec_attr );
|
||||
sec_attr.nLength = sizeof sec_attr;
|
||||
sec_attr.bInheritHandle = FALSE;
|
||||
|
||||
/* Start the process. */
|
||||
si.StartupInfo.cb = sizeof (si);
|
||||
si.StartupInfo.dwFlags = STARTF_USESTDHANDLES | STARTF_USESHOWWINDOW;
|
||||
si.StartupInfo.wShowWindow = DEBUG_W32_SPAWN? SW_SHOW : SW_HIDE;
|
||||
si.StartupInfo.hStdInput = act->hd[0];
|
||||
si.StartupInfo.hStdOutput = act->hd[1];
|
||||
si.StartupInfo.hStdError = act->hd[2];
|
||||
|
||||
/* log_debug ("CreateProcess, path='%s' cmdline='%s'\n", pgmname, cmdline); */
|
||||
cr_flags = (CREATE_DEFAULT_ERROR_MODE
|
||||
| GetPriorityClass (GetCurrentProcess ())
|
||||
| CREATE_SUSPENDED);
|
||||
if (!(wpgmname = utf8_to_wchar (pgmname)))
|
||||
ret = 0;
|
||||
else if (!(wcmdline = utf8_to_wchar (cmdline)))
|
||||
ret = 0;
|
||||
else
|
||||
ret = CreateProcessW (wpgmname, /* Program to start. */
|
||||
wcmdline, /* Command line arguments. */
|
||||
&sec_attr, /* Process security attributes. */
|
||||
&sec_attr, /* Thread security attributes. */
|
||||
ask_inherit, /* Inherit handles. */
|
||||
cr_flags, /* Creation flags. */
|
||||
act->env, /* Environment. */
|
||||
NULL, /* Use current drive/directory. */
|
||||
(STARTUPINFOW *)&si, /* Startup information. */
|
||||
&pi /* Returns process information. */
|
||||
);
|
||||
if (!ret)
|
||||
{
|
||||
if (!wpgmname || !wcmdline)
|
||||
log_error ("CreateProcess failed (utf8_to_wchar): %s\n",
|
||||
strerror (errno));
|
||||
else
|
||||
log_error ("CreateProcess failed: ec=%d\n",
|
||||
(int)GetLastError ());
|
||||
if ((flags & GNUPG_PROCESS_STDIN_PIPE)
|
||||
|| !(flags & GNUPG_PROCESS_STDIN_KEEP))
|
||||
CloseHandle (hd_in[0]);
|
||||
if ((flags & GNUPG_PROCESS_STDIN_PIPE))
|
||||
CloseHandle (hd_in[1]);
|
||||
if ((flags & GNUPG_PROCESS_STDOUT_PIPE))
|
||||
CloseHandle (hd_out[0]);
|
||||
if ((flags & GNUPG_PROCESS_STDOUT_PIPE)
|
||||
|| !(flags & GNUPG_PROCESS_STDOUT_KEEP))
|
||||
CloseHandle (hd_out[1]);
|
||||
if ((flags & GNUPG_PROCESS_STDERR_PIPE))
|
||||
CloseHandle (hd_err[0]);
|
||||
if ((flags & GNUPG_PROCESS_STDERR_PIPE)
|
||||
|| !(flags & GNUPG_PROCESS_STDERR_KEEP))
|
||||
CloseHandle (hd_err[1]);
|
||||
xfree (wpgmname);
|
||||
xfree (wcmdline);
|
||||
xfree (process);
|
||||
xfree (cmdline);
|
||||
return GPG_ERR_GENERAL;
|
||||
}
|
||||
|
||||
if (si.lpAttributeList)
|
||||
DeleteProcThreadAttributeList (si.lpAttributeList);
|
||||
xfree (wpgmname);
|
||||
xfree (wcmdline);
|
||||
xfree (cmdline);
|
||||
|
||||
if ((flags & GNUPG_PROCESS_STDIN_PIPE)
|
||||
|| !(flags & GNUPG_PROCESS_STDIN_KEEP))
|
||||
CloseHandle (hd_in[0]);
|
||||
if ((flags & GNUPG_PROCESS_STDOUT_PIPE)
|
||||
|| !(flags & GNUPG_PROCESS_STDOUT_KEEP))
|
||||
CloseHandle (hd_out[1]);
|
||||
if ((flags & GNUPG_PROCESS_STDERR_PIPE)
|
||||
|| !(flags & GNUPG_PROCESS_STDERR_KEEP))
|
||||
CloseHandle (hd_err[1]);
|
||||
|
||||
/* log_debug ("CreateProcess ready: hProcess=%p hThread=%p" */
|
||||
/* " dwProcessID=%d dwThreadId=%d\n", */
|
||||
/* pi.hProcess, pi.hThread, */
|
||||
/* (int) pi.dwProcessId, (int) pi.dwThreadId); */
|
||||
|
||||
if (allow_foreground_window)
|
||||
{
|
||||
/* Fixme: For unknown reasons AllowSetForegroundWindow returns
|
||||
* an invalid argument error if we pass it the correct
|
||||
* processID. As a workaround we use -1 (ASFW_ANY). */
|
||||
if (!AllowSetForegroundWindow (ASFW_ANY /*pi.dwProcessId*/))
|
||||
log_info ("AllowSetForegroundWindow() failed: ec=%d\n",
|
||||
(int)GetLastError ());
|
||||
}
|
||||
|
||||
/* Process has been created suspended; resume it now. */
|
||||
pre_syscall ();
|
||||
ResumeThread (pi.hThread);
|
||||
CloseHandle (pi.hThread);
|
||||
post_syscall ();
|
||||
|
||||
process->hProcess = pi.hProcess;
|
||||
process->hd_in = hd_in[1];
|
||||
process->hd_out = hd_out[0];
|
||||
process->hd_err = hd_err[0];
|
||||
process->exitcode = -1;
|
||||
process->terminated = 0;
|
||||
|
||||
if (r_process == NULL)
|
||||
{
|
||||
ec = gnupg_process_wait (process, 1);
|
||||
gnupg_process_release (process);
|
||||
return ec;
|
||||
}
|
||||
|
||||
*r_process = process;
|
||||
return 0;
|
||||
}
|
||||
|
||||
gpg_err_code_t
|
||||
gnupg_process_get_fds (gnupg_process_t process, unsigned int flags,
|
||||
int *r_fd_in, int *r_fd_out, int *r_fd_err)
|
||||
{
|
||||
(void)flags;
|
||||
if (r_fd_in)
|
||||
{
|
||||
*r_fd_in = _open_osfhandle ((intptr_t)process->hd_in, O_APPEND);
|
||||
process->hd_in = INVALID_HANDLE_VALUE;
|
||||
}
|
||||
if (r_fd_out)
|
||||
{
|
||||
*r_fd_out = _open_osfhandle ((intptr_t)process->hd_out, O_RDONLY);
|
||||
process->hd_out = INVALID_HANDLE_VALUE;
|
||||
}
|
||||
if (r_fd_err)
|
||||
{
|
||||
*r_fd_err = _open_osfhandle ((intptr_t)process->hd_err, O_RDONLY);
|
||||
process->hd_err = INVALID_HANDLE_VALUE;
|
||||
}
|
||||
|
||||
return 0;
|
||||
}
|
||||
|
||||
gpg_err_code_t
|
||||
gnupg_process_get_streams (gnupg_process_t process, unsigned int flags,
|
||||
estream_t *r_fp_in, estream_t *r_fp_out,
|
||||
estream_t *r_fp_err)
|
||||
{
|
||||
int nonblock = (flags & GNUPG_PROCESS_STREAM_NONBLOCK)? 1: 0;
|
||||
es_syshd_t syshd;
|
||||
|
||||
syshd.type = ES_SYSHD_HANDLE;
|
||||
if (r_fp_in)
|
||||
{
|
||||
syshd.u.handle = process->hd_in;
|
||||
*r_fp_in = es_sysopen (&syshd, nonblock? "w,nonblock" : "w");
|
||||
process->hd_in = INVALID_HANDLE_VALUE;
|
||||
}
|
||||
if (r_fp_out)
|
||||
{
|
||||
syshd.u.handle = process->hd_out;
|
||||
*r_fp_out = es_sysopen (&syshd, nonblock? "r,nonblock" : "r");
|
||||
process->hd_out = INVALID_HANDLE_VALUE;
|
||||
}
|
||||
if (r_fp_err)
|
||||
{
|
||||
syshd.u.handle = process->hd_err;
|
||||
*r_fp_err = es_sysopen (&syshd, nonblock? "r,nonblock" : "r");
|
||||
process->hd_err = INVALID_HANDLE_VALUE;
|
||||
}
|
||||
return 0;
|
||||
}
|
||||
|
||||
static gpg_err_code_t
|
||||
process_kill (gnupg_process_t process, unsigned int exitcode)
|
||||
{
|
||||
gpg_err_code_t ec = 0;
|
||||
|
||||
pre_syscall ();
|
||||
if (TerminateProcess (process->hProcess, exitcode))
|
||||
ec = gpg_err_code_from_syserror ();
|
||||
post_syscall ();
|
||||
return ec;
|
||||
}
|
||||
|
||||
static gpg_err_code_t
|
||||
process_vctl (gnupg_process_t process, unsigned int request, va_list arg_ptr)
|
||||
{
|
||||
switch (request)
|
||||
{
|
||||
case GNUPG_PROCESS_NOP:
|
||||
return 0;
|
||||
|
||||
case GNUPG_PROCESS_GET_PROC_ID:
|
||||
{
|
||||
int *r_id = va_arg (arg_ptr, int *);
|
||||
|
||||
if (r_id == NULL)
|
||||
return GPG_ERR_INV_VALUE;
|
||||
|
||||
*r_id = (int)GetProcessId (process->hProcess);
|
||||
return 0;
|
||||
}
|
||||
|
||||
case GNUPG_PROCESS_GET_EXIT_ID:
|
||||
{
|
||||
int *r_exit_status = va_arg (arg_ptr, int *);
|
||||
unsigned long exit_code;
|
||||
|
||||
*r_exit_status = -1;
|
||||
|
||||
if (!process->terminated)
|
||||
return GPG_ERR_UNFINISHED;
|
||||
|
||||
if (process->hProcess == INVALID_HANDLE_VALUE)
|
||||
return 0;
|
||||
|
||||
if (GetExitCodeProcess (process->hProcess, &exit_code) == 0)
|
||||
return gpg_err_code_from_syserror ();
|
||||
|
||||
*r_exit_status = (int)exit_code;
|
||||
return 0;
|
||||
}
|
||||
|
||||
case GNUPG_PROCESS_GET_P_HANDLE:
|
||||
{
|
||||
HANDLE *r_hProcess = va_arg (arg_ptr, HANDLE *);
|
||||
|
||||
if (r_hProcess == NULL)
|
||||
return GPG_ERR_INV_VALUE;
|
||||
|
||||
*r_hProcess = process->hProcess;
|
||||
process->hProcess = INVALID_HANDLE_VALUE;
|
||||
return 0;
|
||||
}
|
||||
|
||||
case GNUPG_PROCESS_GET_HANDLES:
|
||||
{
|
||||
HANDLE *r_hd_in = va_arg (arg_ptr, HANDLE *);
|
||||
HANDLE *r_hd_out = va_arg (arg_ptr, HANDLE *);
|
||||
HANDLE *r_hd_err = va_arg (arg_ptr, HANDLE *);
|
||||
|
||||
if (r_hd_in)
|
||||
{
|
||||
*r_hd_in = process->hd_in;
|
||||
process->hd_in = INVALID_HANDLE_VALUE;
|
||||
}
|
||||
if (r_hd_out)
|
||||
{
|
||||
*r_hd_out = process->hd_out;
|
||||
process->hd_out = INVALID_HANDLE_VALUE;
|
||||
}
|
||||
if (r_hd_err)
|
||||
{
|
||||
*r_hd_err = process->hd_err;
|
||||
process->hd_err = INVALID_HANDLE_VALUE;
|
||||
}
|
||||
return 0;
|
||||
}
|
||||
|
||||
case GNUPG_PROCESS_GET_EXIT_CODE:
|
||||
{
|
||||
unsigned long *r_exitcode = va_arg (arg_ptr, unsigned long *);
|
||||
|
||||
if (!process->terminated)
|
||||
return GPG_ERR_UNFINISHED;
|
||||
|
||||
if (process->hProcess == INVALID_HANDLE_VALUE)
|
||||
{
|
||||
*r_exitcode = (unsigned long)-1;
|
||||
return 0;
|
||||
}
|
||||
|
||||
if (GetExitCodeProcess (process->hProcess, r_exitcode) == 0)
|
||||
return gpg_err_code_from_syserror ();
|
||||
return 0;
|
||||
}
|
||||
|
||||
case GNUPG_PROCESS_KILL_WITH_EC:
|
||||
{
|
||||
unsigned int exitcode = va_arg (arg_ptr, unsigned int);
|
||||
|
||||
if (process->terminated)
|
||||
return 0;
|
||||
|
||||
if (process->hProcess == INVALID_HANDLE_VALUE)
|
||||
return 0;
|
||||
|
||||
return process_kill (process, exitcode);
|
||||
}
|
||||
|
||||
default:
|
||||
break;
|
||||
}
|
||||
|
||||
return GPG_ERR_UNKNOWN_COMMAND;
|
||||
}
|
||||
|
||||
gpg_err_code_t
|
||||
gnupg_process_ctl (gnupg_process_t process, unsigned int request, ...)
|
||||
{
|
||||
va_list arg_ptr;
|
||||
gpg_err_code_t ec;
|
||||
|
||||
va_start (arg_ptr, request);
|
||||
ec = process_vctl (process, request, arg_ptr);
|
||||
va_end (arg_ptr);
|
||||
return ec;
|
||||
}
|
||||
|
||||
gpg_err_code_t
|
||||
gnupg_process_wait (gnupg_process_t process, int hang)
|
||||
{
|
||||
gpg_err_code_t ec;
|
||||
int code;
|
||||
|
||||
if (process->hProcess == INVALID_HANDLE_VALUE)
|
||||
return 0;
|
||||
|
||||
pre_syscall ();
|
||||
code = WaitForSingleObject (process->hProcess, hang? INFINITE : 0);
|
||||
post_syscall ();
|
||||
|
||||
switch (code)
|
||||
{
|
||||
case WAIT_TIMEOUT:
|
||||
ec = GPG_ERR_TIMEOUT; /* Still running. */
|
||||
break;
|
||||
|
||||
case WAIT_FAILED:
|
||||
log_error (_("waiting for process to terminate failed: ec=%d\n"),
|
||||
(int)GetLastError ());
|
||||
ec = GPG_ERR_GENERAL;
|
||||
break;
|
||||
|
||||
case WAIT_OBJECT_0:
|
||||
process->terminated = 1;
|
||||
ec = 0;
|
||||
break;
|
||||
|
||||
default:
|
||||
log_debug ("WaitForSingleObject returned unexpected code %d\n", code);
|
||||
ec = GPG_ERR_GENERAL;
|
||||
break;
|
||||
}
|
||||
|
||||
return ec;
|
||||
}
|
||||
|
||||
gpg_err_code_t
|
||||
gnupg_process_terminate (gnupg_process_t process)
|
||||
{
|
||||
return process_kill (process, 1);
|
||||
}
|
||||
|
||||
void
|
||||
gnupg_process_release (gnupg_process_t process)
|
||||
{
|
||||
if (!process)
|
||||
return;
|
||||
|
||||
if (!process->terminated)
|
||||
{
|
||||
gnupg_process_terminate (process);
|
||||
gnupg_process_wait (process, 1);
|
||||
}
|
||||
|
||||
CloseHandle (process->hProcess);
|
||||
xfree (process);
|
||||
}
|
||||
|
||||
gpg_err_code_t
|
||||
gnupg_process_wait_list (gnupg_process_t *process_list, int count, int hang)
|
||||
{
|
||||
gpg_err_code_t ec = 0;
|
||||
int i;
|
||||
|
||||
for (i = 0; i < count; i++)
|
||||
{
|
||||
if (process_list[i]->terminated)
|
||||
continue;
|
||||
|
||||
ec = gnupg_process_wait (process_list[i], hang);
|
||||
if (ec)
|
||||
break;
|
||||
}
|
||||
|
||||
return ec;
|
||||
}
|
||||
|
@ -72,99 +72,4 @@ gpg_error_t gnupg_create_pipe (int filedes[2]);
|
||||
/* Close the end of a pipe. */
|
||||
void gnupg_close_pipe (int fd);
|
||||
|
||||
|
||||
/* The opaque type for a subprocess. */
|
||||
typedef struct gnupg_process *gnupg_process_t;
|
||||
typedef struct gnupg_spawn_actions *gnupg_spawn_actions_t;
|
||||
gpg_err_code_t gnupg_spawn_actions_new (gnupg_spawn_actions_t *r_act);
|
||||
void gnupg_spawn_actions_release (gnupg_spawn_actions_t act);
|
||||
#ifdef HAVE_W32_SYSTEM
|
||||
void gnupg_spawn_actions_set_envvars (gnupg_spawn_actions_t, char *);
|
||||
void gnupg_spawn_actions_set_redirect (gnupg_spawn_actions_t,
|
||||
void *, void *, void *);
|
||||
void gnupg_spawn_actions_set_inherit_handles (gnupg_spawn_actions_t, void **);
|
||||
#else
|
||||
void gnupg_spawn_actions_set_environ (gnupg_spawn_actions_t, char **);
|
||||
void gnupg_spawn_actions_set_redirect (gnupg_spawn_actions_t, int, int, int);
|
||||
void gnupg_spawn_actions_set_inherit_fds (gnupg_spawn_actions_t,
|
||||
const int *);
|
||||
void gnupg_spawn_actions_set_atfork (gnupg_spawn_actions_t,
|
||||
void (*atfork)(void *), void *arg);
|
||||
#endif
|
||||
|
||||
#define GNUPG_PROCESS_DETACHED (1 << 1)
|
||||
|
||||
/* Specify how to keep/connect standard fds. */
|
||||
#define GNUPG_PROCESS_STDIN_PIPE (1 << 8)
|
||||
#define GNUPG_PROCESS_STDOUT_PIPE (1 << 9)
|
||||
#define GNUPG_PROCESS_STDERR_PIPE (1 << 10)
|
||||
#define GNUPG_PROCESS_STDINOUT_SOCKETPAIR (1 << 11)
|
||||
#define GNUPG_PROCESS_STDIN_KEEP (1 << 12)
|
||||
#define GNUPG_PROCESS_STDOUT_KEEP (1 << 13)
|
||||
#define GNUPG_PROCESS_STDERR_KEEP (1 << 14)
|
||||
#define GNUPG_PROCESS_STDFDS_SETTING ( GNUPG_PROCESS_STDIN_PIPE \
|
||||
| GNUPG_PROCESS_STDOUT_PIPE | GNUPG_PROCESS_STDERR_PIPE \
|
||||
| GNUPG_PROCESS_STDINOUT_SOCKETPAIR | GNUPG_PROCESS_STDIN_KEEP \
|
||||
| GNUPG_PROCESS_STDOUT_KEEP | GNUPG_PROCESS_STDERR_KEEP)
|
||||
|
||||
#define GNUPG_PROCESS_STREAM_NONBLOCK (1 << 16)
|
||||
|
||||
/* Spawn PGMNAME. */
|
||||
gpg_err_code_t gnupg_process_spawn (const char *pgmname, const char *argv1[],
|
||||
unsigned int flags,
|
||||
gnupg_spawn_actions_t act,
|
||||
gnupg_process_t *r_process);
|
||||
|
||||
/* Get FDs for subprocess I/O. It is the caller which should care
|
||||
FDs (closing FDs). */
|
||||
gpg_err_code_t gnupg_process_get_fds (gnupg_process_t process,
|
||||
unsigned int flags,
|
||||
int *r_fd_in, int *r_fd_out,
|
||||
int *r_fd_err);
|
||||
|
||||
/* Get STREAMs for subprocess I/O. It is the caller which should care
|
||||
STREAMs (closing STREAMs). */
|
||||
gpg_err_code_t gnupg_process_get_streams (gnupg_process_t process,
|
||||
unsigned int flags,
|
||||
gpgrt_stream_t *r_fp_in,
|
||||
gpgrt_stream_t *r_fp_out,
|
||||
gpgrt_stream_t *r_fp_err);
|
||||
|
||||
enum gnupg_process_requests
|
||||
{
|
||||
/* Portable requests */
|
||||
GNUPG_PROCESS_NOP = 0,
|
||||
GNUPG_PROCESS_GET_PROC_ID = 1,
|
||||
GNUPG_PROCESS_GET_EXIT_ID = 2,
|
||||
|
||||
/* POSIX only */
|
||||
GNUPG_PROCESS_GET_PID = 16,
|
||||
GNUPG_PROCESS_GET_WSTATUS = 17,
|
||||
GNUPG_PROCESS_KILL = 18,
|
||||
|
||||
/* Windows only */
|
||||
GNUPG_PROCESS_GET_P_HANDLE = 32,
|
||||
GNUPG_PROCESS_GET_HANDLES = 33,
|
||||
GNUPG_PROCESS_GET_EXIT_CODE = 34,
|
||||
GNUPG_PROCESS_KILL_WITH_EC = 35
|
||||
};
|
||||
|
||||
/* Control of a process. */
|
||||
gpg_err_code_t gnupg_process_ctl (gnupg_process_t process,
|
||||
unsigned int request, ...);
|
||||
|
||||
/* Wait for a single PROCESS. */
|
||||
gpg_err_code_t gnupg_process_wait (gnupg_process_t process, int hang);
|
||||
|
||||
/* Terminate a PROCESS. */
|
||||
gpg_err_code_t gnupg_process_terminate (gnupg_process_t process);
|
||||
|
||||
/* Release PROCESS resources. */
|
||||
void gnupg_process_release (gnupg_process_t process);
|
||||
|
||||
/* Wait for a multiple processes. */
|
||||
gpg_err_code_t gnupg_process_wait_list (gnupg_process_t *process_list,
|
||||
int count, int hang);
|
||||
|
||||
|
||||
#endif /*GNUPG_COMMON_EXECHELP_H*/
|
||||
|
@ -43,11 +43,8 @@
|
||||
#include "logging.h"
|
||||
#include "membuf.h"
|
||||
#include "mischelp.h"
|
||||
#ifdef HAVE_W32_SYSTEM
|
||||
#define NEED_STRUCT_SPAWN_CB_ARG 1
|
||||
#endif
|
||||
#include "exechelp.h"
|
||||
#include "sysutils.h"
|
||||
#include "exechelp.h"
|
||||
#include "util.h"
|
||||
#include "exectool.h"
|
||||
|
||||
@ -324,7 +321,7 @@ gnupg_exec_tool_stream (const char *pgmname, const char *argv[],
|
||||
void *status_cb_value)
|
||||
{
|
||||
gpg_error_t err;
|
||||
gnupg_process_t proc = NULL;
|
||||
gpgrt_process_t proc = NULL;
|
||||
estream_t infp = NULL;
|
||||
estream_t extrafp = NULL;
|
||||
estream_t outfp = NULL, errfp = NULL;
|
||||
@ -342,7 +339,7 @@ gnupg_exec_tool_stream (const char *pgmname, const char *argv[],
|
||||
read_and_log_buffer_t fderrstate;
|
||||
struct copy_buffer *cpbuf_in = NULL, *cpbuf_out = NULL, *cpbuf_extra = NULL;
|
||||
int quiet = 0;
|
||||
gnupg_spawn_actions_t act = NULL;
|
||||
gpgrt_spawn_actions_t act = NULL;
|
||||
int i = 0;
|
||||
|
||||
memset (fds, 0, sizeof fds);
|
||||
@ -433,22 +430,22 @@ gnupg_exec_tool_stream (const char *pgmname, const char *argv[],
|
||||
exceptclose[i] = -1;
|
||||
#endif
|
||||
|
||||
err = gnupg_spawn_actions_new (&act);
|
||||
err = gpgrt_spawn_actions_new (&act);
|
||||
if (err)
|
||||
goto leave;
|
||||
|
||||
#ifdef HAVE_W32_SYSTEM
|
||||
gnupg_spawn_actions_set_inherit_handles (act, exceptclose);
|
||||
gpgrt_spawn_actions_set_inherit_handles (act, exceptclose);
|
||||
#else
|
||||
gnupg_spawn_actions_set_inherit_fds (act, exceptclose);
|
||||
gpgrt_spawn_actions_set_inherit_fds (act, exceptclose);
|
||||
#endif
|
||||
err = gnupg_process_spawn (pgmname, argv,
|
||||
err = gpgrt_process_spawn (pgmname, argv,
|
||||
((input
|
||||
? GNUPG_PROCESS_STDIN_PIPE
|
||||
? GPGRT_PROCESS_STDIN_PIPE
|
||||
: 0)
|
||||
| GNUPG_PROCESS_STDOUT_PIPE
|
||||
| GNUPG_PROCESS_STDERR_PIPE), act, &proc);
|
||||
gnupg_process_get_streams (proc, GNUPG_PROCESS_STREAM_NONBLOCK,
|
||||
| GPGRT_PROCESS_STDOUT_PIPE
|
||||
| GPGRT_PROCESS_STDERR_PIPE), act, &proc);
|
||||
gpgrt_process_get_streams (proc, GPGRT_PROCESS_STREAM_NONBLOCK,
|
||||
input? &infp : NULL, &outfp, &errfp);
|
||||
if (extrapipe[0] != -1)
|
||||
close (extrapipe[0]);
|
||||
@ -581,26 +578,26 @@ gnupg_exec_tool_stream (const char *pgmname, const char *argv[],
|
||||
es_fclose (outfp); outfp = NULL;
|
||||
es_fclose (errfp); errfp = NULL;
|
||||
|
||||
err = gnupg_process_wait (proc, 1);
|
||||
err = gpgrt_process_wait (proc, 1);
|
||||
if (!err)
|
||||
{ /* To be compatible to old wait_process. */
|
||||
int status;
|
||||
|
||||
gnupg_process_ctl (proc, GNUPG_PROCESS_GET_EXIT_ID, &status);
|
||||
gpgrt_process_ctl (proc, GPGRT_PROCESS_GET_EXIT_ID, &status);
|
||||
if (status)
|
||||
err = gpg_error (GPG_ERR_GENERAL);
|
||||
}
|
||||
|
||||
leave:
|
||||
if (err && proc)
|
||||
gnupg_process_terminate (proc);
|
||||
gpgrt_process_terminate (proc);
|
||||
|
||||
es_fclose (infp);
|
||||
es_fclose (extrafp);
|
||||
es_fclose (outfp);
|
||||
es_fclose (errfp);
|
||||
gnupg_process_release (proc);
|
||||
gnupg_spawn_actions_release (act);
|
||||
gpgrt_process_release (proc);
|
||||
gpgrt_spawn_actions_release (act);
|
||||
|
||||
copy_buffer_shred (cpbuf_in);
|
||||
xfree (cpbuf_in);
|
||||
|
@ -25,6 +25,7 @@
|
||||
#include <unistd.h>
|
||||
|
||||
#include "util.h"
|
||||
#include "sysutils.h"
|
||||
#include "exechelp.h"
|
||||
|
||||
static int verbose;
|
||||
@ -248,75 +249,11 @@ run_server (void)
|
||||
}
|
||||
|
||||
|
||||
static void
|
||||
test_pipe_stream (const char *pgmname)
|
||||
{
|
||||
gpg_error_t err;
|
||||
gnupg_process_t proc;
|
||||
estream_t outfp;
|
||||
const char *argv[2];
|
||||
unsigned int len;
|
||||
size_t n;
|
||||
off_t o;
|
||||
int ret;
|
||||
|
||||
argv[0] = "--server";
|
||||
argv[1] = NULL;
|
||||
|
||||
err = gnupg_process_spawn (pgmname, argv,
|
||||
(GNUPG_PROCESS_STDOUT_PIPE
|
||||
|GNUPG_PROCESS_STDERR_KEEP),
|
||||
NULL, &proc);
|
||||
if (err)
|
||||
{
|
||||
fprintf (stderr, "gnupg_process_spawn failed\n");
|
||||
exit (1);
|
||||
}
|
||||
|
||||
gnupg_process_get_streams (proc, 0, NULL, &outfp, NULL);
|
||||
|
||||
ret = es_read (outfp, (void *)&len, sizeof (len), NULL);
|
||||
if (ret)
|
||||
{
|
||||
fprintf (stderr, "es_read (1) failed\n");
|
||||
exit (1);
|
||||
}
|
||||
|
||||
o = 0;
|
||||
while (1)
|
||||
{
|
||||
if (es_feof (outfp))
|
||||
break;
|
||||
|
||||
ret = es_read (outfp, buff4k, sizeof (buff4k), &n);
|
||||
if (ret)
|
||||
{
|
||||
fprintf (stderr, "es_read (2) failed\n");
|
||||
exit (1);
|
||||
}
|
||||
|
||||
memcpy (buff12k + o, buff4k, n);
|
||||
o += n;
|
||||
}
|
||||
|
||||
if (o != sizeof (buff12k))
|
||||
{
|
||||
fprintf (stderr, "received data with wrong length %d\n", (int)o);
|
||||
exit (1);
|
||||
}
|
||||
es_fclose (outfp);
|
||||
gnupg_process_release (proc);
|
||||
}
|
||||
|
||||
|
||||
int
|
||||
main (int argc, char **argv)
|
||||
{
|
||||
const char *myname = "no-pgm";
|
||||
|
||||
if (argc)
|
||||
{
|
||||
myname = argv[0];
|
||||
argc--; argv++;
|
||||
}
|
||||
if (argc && !strcmp (argv[0], "--verbose"))
|
||||
@ -330,7 +267,6 @@ main (int argc, char **argv)
|
||||
#ifndef HAVE_W32_SYSTEM
|
||||
test_close_all_fds ();
|
||||
#endif
|
||||
test_pipe_stream (myname);
|
||||
|
||||
return 0;
|
||||
}
|
||||
|
@ -60,7 +60,6 @@
|
||||
#include <npth.h>
|
||||
|
||||
#include "dirmngr.h"
|
||||
#include "../common/exechelp.h"
|
||||
#include "misc.h"
|
||||
#include "ldap-wrapper.h"
|
||||
|
||||
@ -87,7 +86,7 @@ struct wrapper_context_s
|
||||
{
|
||||
struct wrapper_context_s *next;
|
||||
|
||||
gnupg_process_t proc;/* The wrapper process. */
|
||||
gpgrt_process_t proc;/* The wrapper process. */
|
||||
int printable_pid; /* Helper to print diagnostics after the process has
|
||||
* been cleaned up. */
|
||||
estream_t fp; /* Connected with stdout of the ldap wrapper. */
|
||||
@ -172,8 +171,8 @@ destroy_wrapper (struct wrapper_context_s *ctx)
|
||||
{
|
||||
if (ctx->proc)
|
||||
{
|
||||
gnupg_process_terminate (ctx->proc);
|
||||
gnupg_process_release (ctx->proc);
|
||||
gpgrt_process_terminate (ctx->proc);
|
||||
gpgrt_process_release (ctx->proc);
|
||||
}
|
||||
ksba_reader_release (ctx->reader);
|
||||
SAFE_CLOSE (ctx->fp);
|
||||
@ -440,17 +439,17 @@ ldap_reaper_thread (void *dummy)
|
||||
/* Check whether the process is still running. */
|
||||
if (ctx->proc)
|
||||
{
|
||||
err = gnupg_process_wait (ctx->proc, 0);
|
||||
err = gpgrt_process_wait (ctx->proc, 0);
|
||||
if (!err)
|
||||
{
|
||||
int status;
|
||||
|
||||
gnupg_process_ctl (ctx->proc, GNUPG_PROCESS_GET_EXIT_ID,
|
||||
gpgrt_process_ctl (ctx->proc, GPGRT_PROCESS_GET_EXIT_ID,
|
||||
&status);
|
||||
if (DBG_EXTPROG)
|
||||
log_info (_("ldap wrapper %d ready"), ctx->printable_pid);
|
||||
ctx->ready = 1;
|
||||
gnupg_process_release (ctx->proc);
|
||||
gpgrt_process_release (ctx->proc);
|
||||
ctx->proc = NULL;
|
||||
any_action = 1;
|
||||
|
||||
@ -472,7 +471,7 @@ ldap_reaper_thread (void *dummy)
|
||||
/* Check whether we should terminate the process. */
|
||||
if (ctx->proc && ctx->stamp != (time_t)(-1) && ctx->stamp < exptime)
|
||||
{
|
||||
gnupg_process_terminate (ctx->proc);
|
||||
gpgrt_process_terminate (ctx->proc);
|
||||
ctx->stamp = (time_t)(-1);
|
||||
log_info (_("ldap wrapper %d stalled - killing\n"),
|
||||
ctx->printable_pid);
|
||||
@ -634,7 +633,7 @@ ldap_wrapper_connection_cleanup (ctrl_t ctrl)
|
||||
ctx->ctrl->refcount--;
|
||||
ctx->ctrl = NULL;
|
||||
if (ctx->proc)
|
||||
gnupg_process_terminate (ctx->proc);
|
||||
gpgrt_process_terminate (ctx->proc);
|
||||
if (ctx->fp_err)
|
||||
log_info ("%s: reading from ldap wrapper %d failed: %s\n",
|
||||
__func__, ctx->printable_pid, gpg_strerror (ctx->fp_err));
|
||||
@ -792,7 +791,7 @@ gpg_error_t
|
||||
ldap_wrapper (ctrl_t ctrl, ksba_reader_t *reader, const char *argv[])
|
||||
{
|
||||
gpg_error_t err;
|
||||
gnupg_process_t process;
|
||||
gpgrt_process_t process;
|
||||
struct wrapper_context_s *ctx;
|
||||
int i;
|
||||
int j;
|
||||
@ -848,9 +847,9 @@ ldap_wrapper (ctrl_t ctrl, ksba_reader_t *reader, const char *argv[])
|
||||
return err;
|
||||
}
|
||||
|
||||
err = gnupg_process_spawn (pgmname, arg_list,
|
||||
(GNUPG_PROCESS_STDOUT_PIPE
|
||||
| GNUPG_PROCESS_STDERR_PIPE),
|
||||
err = gpgrt_process_spawn (pgmname, arg_list,
|
||||
(GPGRT_PROCESS_STDOUT_PIPE
|
||||
| GPGRT_PROCESS_STDERR_PIPE),
|
||||
NULL, &process);
|
||||
if (err)
|
||||
{
|
||||
@ -859,9 +858,9 @@ ldap_wrapper (ctrl_t ctrl, ksba_reader_t *reader, const char *argv[])
|
||||
log_error ("error running '%s': %s\n", pgmname, gpg_strerror (err));
|
||||
return err;
|
||||
}
|
||||
gnupg_process_get_streams (process, GNUPG_PROCESS_STREAM_NONBLOCK,
|
||||
gpgrt_process_get_streams (process, GPGRT_PROCESS_STREAM_NONBLOCK,
|
||||
NULL, &outfp, &errfp);
|
||||
gnupg_process_ctl (process, GNUPG_PROCESS_GET_PROC_ID, &ctx->printable_pid);
|
||||
gpgrt_process_ctl (process, GPGRT_PROCESS_GET_PROC_ID, &ctx->printable_pid);
|
||||
|
||||
ctx->proc = process;
|
||||
ctx->fp = outfp;
|
||||
|
@ -31,7 +31,6 @@
|
||||
#include <npth.h>
|
||||
|
||||
#include "dirmngr.h"
|
||||
#include "../common/exechelp.h"
|
||||
#include "crlfetch.h"
|
||||
#include "ldapserver.h"
|
||||
#include "misc.h"
|
||||
|
@ -38,7 +38,6 @@
|
||||
#include "../common/i18n.h"
|
||||
#include "../common/asshelp.h"
|
||||
#include "../common/host2net.h"
|
||||
#include "../common/exechelp.h"
|
||||
#include "../common/status.h"
|
||||
#include "../kbx/kbx-client-util.h"
|
||||
#include "keydb.h"
|
||||
|
@ -424,7 +424,6 @@ show_photo (const char *command, const char *name, const void *image, u32 len)
|
||||
}
|
||||
#else /* ! NO_EXEC */
|
||||
#include "../common/membuf.h"
|
||||
#include "../common/exechelp.h"
|
||||
|
||||
/* Makes a temp directory and filenames */
|
||||
static int
|
||||
@ -597,10 +596,10 @@ run_with_pipe (struct spawn_info *info, const void *image, u32 len)
|
||||
#else /* !EXEC_TEMPFILE_ONLY */
|
||||
gpg_error_t err;
|
||||
const char *argv[4];
|
||||
gnupg_process_t proc;
|
||||
gpgrt_process_t proc;
|
||||
|
||||
fill_command_argv (argv, info->command);
|
||||
err = gnupg_process_spawn (argv[0], argv+1, GNUPG_PROCESS_STDIN_PIPE,
|
||||
err = gpgrt_process_spawn (argv[0], argv+1, GPGRT_PROCESS_STDIN_PIPE,
|
||||
NULL, &proc);
|
||||
if (err)
|
||||
log_error (_("unable to execute shell '%s': %s\n"),
|
||||
@ -609,7 +608,7 @@ run_with_pipe (struct spawn_info *info, const void *image, u32 len)
|
||||
{
|
||||
int fd_in;
|
||||
|
||||
err = gnupg_process_get_fds (proc, 0, &fd_in, NULL, NULL);
|
||||
err = gpgrt_process_get_fds (proc, 0, &fd_in, NULL, NULL);
|
||||
if (err)
|
||||
log_error ("unable to get pipe connection '%s': %s\n",
|
||||
argv[2], gpg_strerror (err));
|
||||
@ -619,11 +618,11 @@ run_with_pipe (struct spawn_info *info, const void *image, u32 len)
|
||||
close (fd_in);
|
||||
}
|
||||
|
||||
err = gnupg_process_wait (proc, 1);
|
||||
err = gpgrt_process_wait (proc, 1);
|
||||
if (err)
|
||||
log_error (_("unnatural exit of external program\n"));
|
||||
|
||||
gnupg_process_release (proc);
|
||||
gpgrt_process_release (proc);
|
||||
}
|
||||
#endif /* !EXEC_TEMPFILE_ONLY */
|
||||
}
|
||||
@ -695,7 +694,7 @@ show_photo (const char *command, const char *name, const void *image, u32 len)
|
||||
const char *argv[4];
|
||||
|
||||
fill_command_argv (argv, spawn->command);
|
||||
err = gnupg_process_spawn (argv[0], argv+1, 0, NULL, NULL);
|
||||
err = gpgrt_process_spawn (argv[0], argv+1, 0, NULL, NULL);
|
||||
if (err)
|
||||
log_error (_("unnatural exit of external program\n"));
|
||||
#endif
|
||||
|
@ -29,7 +29,6 @@
|
||||
#include "../common/i18n.h"
|
||||
#include "keyblob.h"
|
||||
#include "../common/sysutils.h"
|
||||
#include "../common/exechelp.h"
|
||||
#include "runner.h"
|
||||
#include "be-encfs.h"
|
||||
|
||||
@ -81,8 +80,8 @@ run_umount_helper (const char *mountpoint)
|
||||
args[1] = mountpoint;
|
||||
args[2] = NULL;
|
||||
|
||||
err = gnupg_process_spawn (pgmname, args,
|
||||
GNUPG_PROCESS_DETACHED,
|
||||
err = gpgrt_process_spawn (pgmname, args,
|
||||
GPGRT_PROCESS_DETACHED,
|
||||
NULL, NULL);
|
||||
if (err)
|
||||
log_error ("failed to run '%s': %s\n",
|
||||
@ -223,7 +222,7 @@ run_encfs_tool (ctrl_t ctrl, enum encfs_cmds cmd,
|
||||
const char *pgmname;
|
||||
const char *argv[10];
|
||||
int idx;
|
||||
gnupg_process_t proc;
|
||||
gpgrt_process_t proc;
|
||||
int inbound, outbound;
|
||||
|
||||
(void)ctrl;
|
||||
@ -259,9 +258,9 @@ run_encfs_tool (ctrl_t ctrl, enum encfs_cmds cmd,
|
||||
argv[idx++] = NULL;
|
||||
assert (idx <= DIM (argv));
|
||||
|
||||
err = gnupg_process_spawn (pgmname, argv,
|
||||
(GNUPG_PROCESS_STDIN_PIPE
|
||||
| GNUPG_PROCESS_STDERR_PIPE),
|
||||
err = gpgrt_process_spawn (pgmname, argv,
|
||||
(GPGRT_PROCESS_STDIN_PIPE
|
||||
| GPGRT_PROCESS_STDERR_PIPE),
|
||||
NULL, &proc);
|
||||
if (err)
|
||||
{
|
||||
@ -269,11 +268,11 @@ run_encfs_tool (ctrl_t ctrl, enum encfs_cmds cmd,
|
||||
goto leave;
|
||||
}
|
||||
|
||||
err = gnupg_process_get_fds (proc, 0, &outbound, NULL, &inbound);
|
||||
err = gpgrt_process_get_fds (proc, 0, &outbound, NULL, &inbound);
|
||||
if (err)
|
||||
{
|
||||
log_error ("error get fds '%s': %s\n", pgmname, gpg_strerror (err));
|
||||
gnupg_process_release (proc);
|
||||
gpgrt_process_release (proc);
|
||||
goto leave;
|
||||
}
|
||||
|
||||
@ -287,7 +286,7 @@ run_encfs_tool (ctrl_t ctrl, enum encfs_cmds cmd,
|
||||
err = runner_spawn (runner);
|
||||
if (err)
|
||||
{
|
||||
gnupg_process_release (proc);
|
||||
gpgrt_process_release (proc);
|
||||
goto leave;
|
||||
}
|
||||
|
||||
|
@ -40,7 +40,6 @@
|
||||
#include "../common/gc-opt-flags.h"
|
||||
#include "../common/asshelp.h"
|
||||
#include "../common/init.h"
|
||||
#include "../common/exechelp.h"
|
||||
#include "keyblob.h"
|
||||
#include "server.h"
|
||||
#include "runner.h"
|
||||
|
@ -37,7 +37,6 @@
|
||||
#include "../common/host2net.h"
|
||||
#include "server.h" /*(g13_keyblob_decrypt)*/
|
||||
#include "../common/sysutils.h"
|
||||
#include "../common/exechelp.h"
|
||||
#include "runner.h"
|
||||
#include "call-syshelp.h"
|
||||
|
||||
|
@ -29,7 +29,6 @@
|
||||
#include "g13.h"
|
||||
#include "../common/i18n.h"
|
||||
#include "keyblob.h"
|
||||
#include "../common/exechelp.h"
|
||||
#include "runner.h"
|
||||
#include "mountinfo.h"
|
||||
|
||||
|
@ -43,7 +43,6 @@
|
||||
|
||||
#if defined(GNUPG_MAJOR_VERSION)
|
||||
# include "scdaemon.h"
|
||||
# include "../common/exechelp.h"
|
||||
#endif /*GNUPG_MAJOR_VERSION*/
|
||||
|
||||
#include "../common/host2net.h"
|
||||
|
10
scd/app.c
10
scd/app.c
@ -2498,7 +2498,7 @@ report_change (int slot, int old_status, int cur_status)
|
||||
gpg_error_t err;
|
||||
const char *args[9];
|
||||
char numbuf1[30], numbuf2[30], numbuf3[30];
|
||||
gnupg_spawn_actions_t act = NULL;
|
||||
gpgrt_spawn_actions_t act = NULL;
|
||||
|
||||
sprintf (numbuf1, "%d", slot);
|
||||
sprintf (numbuf2, "0x%04X", old_status);
|
||||
@ -2516,15 +2516,15 @@ report_change (int slot, int old_status, int cur_status)
|
||||
args[8] = NULL;
|
||||
|
||||
fname = make_filename (gnupg_homedir (), "scd-event", NULL);
|
||||
err = gnupg_spawn_actions_new (&act);
|
||||
err = gpgrt_spawn_actions_new (&act);
|
||||
if (!err)
|
||||
{
|
||||
#ifndef HAVE_W32_SYSTEM
|
||||
gnupg_spawn_actions_set_atfork (act, setup_env, envstr);
|
||||
gpgrt_spawn_actions_set_atfork (act, setup_env, envstr);
|
||||
#endif
|
||||
err = gnupg_process_spawn (fname, args, GNUPG_PROCESS_DETACHED,
|
||||
err = gpgrt_process_spawn (fname, args, GPGRT_PROCESS_DETACHED,
|
||||
act, NULL);
|
||||
gnupg_spawn_actions_release (act);
|
||||
gpgrt_spawn_actions_release (act);
|
||||
}
|
||||
if (err && gpg_err_code (err) != GPG_ERR_ENOENT)
|
||||
log_error ("failed to run event handler '%s': %s\n",
|
||||
|
@ -30,7 +30,6 @@
|
||||
#include <ksba.h>
|
||||
|
||||
#include "keydb.h"
|
||||
#include "../common/exechelp.h"
|
||||
#include "../common/i18n.h"
|
||||
#include "../common/sysutils.h"
|
||||
#include "minip12.h"
|
||||
|
@ -30,7 +30,6 @@
|
||||
#include <ksba.h>
|
||||
|
||||
#include "keydb.h"
|
||||
#include "../common/exechelp.h"
|
||||
#include "../common/i18n.h"
|
||||
#include "../common/sysutils.h"
|
||||
#include "../kbx/keybox.h" /* for KEYBOX_FLAG_* */
|
||||
|
@ -42,11 +42,8 @@
|
||||
#endif
|
||||
|
||||
#include "../../common/util.h"
|
||||
#ifdef HAVE_W32_SYSTEM
|
||||
#define NEED_STRUCT_SPAWN_CB_ARG
|
||||
#endif
|
||||
#include "../../common/exechelp.h"
|
||||
#include "../../common/sysutils.h"
|
||||
#include "../../common/exechelp.h"
|
||||
|
||||
#ifdef HAVE_W32_SYSTEM
|
||||
#include <windows.h>
|
||||
@ -762,7 +759,7 @@ do_es_write (scheme *sc, pointer args)
|
||||
|
||||
struct proc_object_box
|
||||
{
|
||||
gnupg_process_t proc;
|
||||
gpgrt_process_t proc;
|
||||
};
|
||||
|
||||
static void
|
||||
@ -772,7 +769,7 @@ proc_object_finalize (scheme *sc, void *data)
|
||||
(void) sc;
|
||||
|
||||
if (!box->proc)
|
||||
gnupg_process_release (box->proc);
|
||||
gpgrt_process_release (box->proc);
|
||||
xfree (box);
|
||||
}
|
||||
|
||||
@ -792,7 +789,7 @@ static struct foreign_object_vtable proc_object_vtable =
|
||||
};
|
||||
|
||||
static pointer
|
||||
proc_wrap (scheme *sc, gnupg_process_t proc)
|
||||
proc_wrap (scheme *sc, gpgrt_process_t proc)
|
||||
{
|
||||
struct proc_object_box *box = xmalloc (sizeof *box);
|
||||
if (box == NULL)
|
||||
@ -897,7 +894,7 @@ do_process_spawn_io (scheme *sc, pointer args)
|
||||
char **argv;
|
||||
size_t len;
|
||||
unsigned int flags;
|
||||
gnupg_process_t proc = NULL;
|
||||
gpgrt_process_t proc = NULL;
|
||||
estream_t infp;
|
||||
#ifdef HAVE_W32_SYSTEM
|
||||
HANDLE out_hd, err_hd;
|
||||
@ -915,9 +912,9 @@ do_process_spawn_io (scheme *sc, pointer args)
|
||||
|
||||
FFI_ARG_OR_RETURN (sc, pointer, arguments, list, args);
|
||||
FFI_ARG_OR_RETURN (sc, char *, a_input, string, args);
|
||||
flags = (GNUPG_PROCESS_STDIN_PIPE
|
||||
| GNUPG_PROCESS_STDOUT_PIPE
|
||||
| GNUPG_PROCESS_STDERR_PIPE);
|
||||
flags = (GPGRT_PROCESS_STDIN_PIPE
|
||||
| GPGRT_PROCESS_STDOUT_PIPE
|
||||
| GPGRT_PROCESS_STDERR_PIPE);
|
||||
FFI_ARGS_DONE_OR_RETURN (sc, args);
|
||||
|
||||
err = ffi_list2argv (sc, arguments, &argv, &len);
|
||||
@ -937,28 +934,28 @@ do_process_spawn_io (scheme *sc, pointer args)
|
||||
fprintf (stderr, "\n");
|
||||
}
|
||||
|
||||
err = gnupg_process_spawn (argv[0], (const char **) &argv[1],
|
||||
err = gpgrt_process_spawn (argv[0], (const char **) &argv[1],
|
||||
flags, NULL, &proc);
|
||||
err = gnupg_process_get_streams (proc, 0, &infp, NULL, NULL);
|
||||
err = gpgrt_process_get_streams (proc, 0, &infp, NULL, NULL);
|
||||
|
||||
err = es_write (infp, a_input, strlen (a_input), NULL);
|
||||
es_fclose (infp);
|
||||
if (err)
|
||||
{
|
||||
gnupg_process_release (proc);
|
||||
gpgrt_process_release (proc);
|
||||
xfree (argv);
|
||||
FFI_RETURN_ERR (sc, err);
|
||||
}
|
||||
|
||||
#ifdef HAVE_W32_SYSTEM
|
||||
err = gnupg_process_ctl (proc, GNUPG_PROCESS_GET_HANDLES,
|
||||
err = gpgrt_process_ctl (proc, GPGRT_PROCESS_GET_HANDLES,
|
||||
NULL, &out_hd, &err_hd);
|
||||
#else
|
||||
err = gnupg_process_get_fds (proc, 0, NULL, &out_fd, &err_fd);
|
||||
err = gpgrt_process_get_fds (proc, 0, NULL, &out_fd, &err_fd);
|
||||
#endif
|
||||
if (err)
|
||||
{
|
||||
gnupg_process_release (proc);
|
||||
gpgrt_process_release (proc);
|
||||
xfree (argv);
|
||||
FFI_RETURN_ERR (sc, err);
|
||||
}
|
||||
@ -1101,11 +1098,11 @@ do_process_spawn_io (scheme *sc, pointer args)
|
||||
}
|
||||
#endif
|
||||
|
||||
err = gnupg_process_wait (proc, 1);
|
||||
err = gpgrt_process_wait (proc, 1);
|
||||
if (!err)
|
||||
err = gnupg_process_ctl (proc, GNUPG_PROCESS_GET_EXIT_ID, &retcode);
|
||||
err = gpgrt_process_ctl (proc, GPGRT_PROCESS_GET_EXIT_ID, &retcode);
|
||||
|
||||
gnupg_process_release (proc);
|
||||
gpgrt_process_release (proc);
|
||||
xfree (argv);
|
||||
|
||||
p0 = sc->vptr->mk_integer (sc, (unsigned long)retcode);
|
||||
@ -1132,7 +1129,7 @@ do_process_spawn_io (scheme *sc, pointer args)
|
||||
if (err_fd >= 0)
|
||||
close (err_fd);
|
||||
#endif
|
||||
gnupg_process_release (proc);
|
||||
gpgrt_process_release (proc);
|
||||
xfree (argv);
|
||||
FFI_RETURN_ERR (sc, err);
|
||||
}
|
||||
@ -1145,8 +1142,8 @@ do_process_spawn_fd (scheme *sc, pointer args)
|
||||
char **argv;
|
||||
size_t len;
|
||||
int std_fds[3];
|
||||
gnupg_process_t proc = NULL;
|
||||
gnupg_spawn_actions_t act = NULL;
|
||||
gpgrt_process_t proc = NULL;
|
||||
gpgrt_spawn_actions_t act = NULL;
|
||||
|
||||
FFI_ARG_OR_RETURN (sc, pointer, arguments, list, args);
|
||||
FFI_ARG_OR_RETURN (sc, int, std_fds[0], number, args);
|
||||
@ -1171,7 +1168,7 @@ do_process_spawn_fd (scheme *sc, pointer args)
|
||||
fprintf (stderr, " (%d %d %d)\n", std_fds[0], std_fds[1], std_fds[2]);
|
||||
}
|
||||
|
||||
err = gnupg_spawn_actions_new (&act);
|
||||
err = gpgrt_spawn_actions_new (&act);
|
||||
if (err)
|
||||
{
|
||||
FFI_RETURN_ERR (sc, err);
|
||||
@ -1193,13 +1190,13 @@ do_process_spawn_fd (scheme *sc, pointer args)
|
||||
else
|
||||
std_err = (HANDLE)_get_osfhandle (std_fds[2]);
|
||||
|
||||
gnupg_spawn_actions_set_redirect (act, std_in, std_out, std_err);
|
||||
gpgrt_spawn_actions_set_redirect (act, std_in, std_out, std_err);
|
||||
}
|
||||
#else
|
||||
gnupg_spawn_actions_set_redirect (act, std_fds[0], std_fds[1], std_fds[2]);
|
||||
gpgrt_spawn_actions_set_redirect (act, std_fds[0], std_fds[1], std_fds[2]);
|
||||
#endif
|
||||
err = gnupg_process_spawn (argv[0], (const char **)&argv[1], 0, act, &proc);
|
||||
gnupg_spawn_actions_release (act);
|
||||
err = gpgrt_process_spawn (argv[0], (const char **)&argv[1], 0, act, &proc);
|
||||
gpgrt_spawn_actions_release (act);
|
||||
xfree (argv);
|
||||
FFI_RETURN_POINTER (sc, proc_wrap (sc, proc));
|
||||
}
|
||||
@ -1215,9 +1212,9 @@ do_process_wait (scheme *sc, pointer args)
|
||||
FFI_ARG_OR_RETURN (sc, struct proc_object_box *, box, proc, args);
|
||||
FFI_ARG_OR_RETURN (sc, int, hang, bool, args);
|
||||
FFI_ARGS_DONE_OR_RETURN (sc, args);
|
||||
err = gnupg_process_wait (box->proc, hang);
|
||||
err = gpgrt_process_wait (box->proc, hang);
|
||||
if (!err)
|
||||
err = gnupg_process_ctl (box->proc, GNUPG_PROCESS_GET_EXIT_ID, &retcode);
|
||||
err = gpgrt_process_ctl (box->proc, GPGRT_PROCESS_GET_EXIT_ID, &retcode);
|
||||
if (err == GPG_ERR_TIMEOUT)
|
||||
err = 0;
|
||||
|
||||
|
@ -33,7 +33,6 @@
|
||||
#include "../common/asshelp.h"
|
||||
#include "../common/session-env.h"
|
||||
#include "../common/membuf.h"
|
||||
#include "../common/exechelp.h"
|
||||
|
||||
|
||||
/* We keep all global options in the structure OPT. */
|
||||
|
@ -39,7 +39,6 @@
|
||||
#include "../common/userids.h"
|
||||
#include "../common/ccparray.h"
|
||||
#include "../common/exectool.h"
|
||||
#include "../common/exechelp.h"
|
||||
#include "../common/ttyio.h"
|
||||
#include "../common/server-help.h"
|
||||
#include "../common/openpgpdefs.h"
|
||||
@ -3803,7 +3802,7 @@ cmd_gpg (card_info_t info, char *argstr, int use_gpgsm)
|
||||
char **argarray;
|
||||
ccparray_t ccp;
|
||||
const char **argv = NULL;
|
||||
gnupg_process_t proc;
|
||||
gpgrt_process_t proc;
|
||||
int i;
|
||||
|
||||
if (!info)
|
||||
@ -3831,15 +3830,15 @@ cmd_gpg (card_info_t info, char *argstr, int use_gpgsm)
|
||||
goto leave;
|
||||
}
|
||||
|
||||
err = gnupg_process_spawn (use_gpgsm? opt.gpgsm_program:opt.gpg_program,
|
||||
err = gpgrt_process_spawn (use_gpgsm? opt.gpgsm_program:opt.gpg_program,
|
||||
argv,
|
||||
(GNUPG_PROCESS_STDOUT_KEEP
|
||||
| GNUPG_PROCESS_STDERR_KEEP),
|
||||
(GPGRT_PROCESS_STDOUT_KEEP
|
||||
| GPGRT_PROCESS_STDERR_KEEP),
|
||||
NULL, &proc);
|
||||
if (!err)
|
||||
{
|
||||
err = gnupg_process_wait (proc, 1);
|
||||
gnupg_process_release (proc);
|
||||
err = gpgrt_process_wait (proc, 1);
|
||||
gpgrt_process_release (proc);
|
||||
}
|
||||
|
||||
|
||||
|
@ -36,9 +36,6 @@
|
||||
#include "../common/sysutils.h"
|
||||
#include "../common/membuf.h"
|
||||
#include "../common/ttyio.h"
|
||||
#ifdef HAVE_W32_SYSTEM
|
||||
# include "../common/exechelp.h"
|
||||
#endif
|
||||
#include "../common/init.h"
|
||||
#include "../common/comopt.h"
|
||||
|
||||
|
@ -35,7 +35,6 @@
|
||||
#include "../common/init.h"
|
||||
#include "../common/sysutils.h"
|
||||
#include "../common/ccparray.h"
|
||||
#include "../common/exechelp.h"
|
||||
#include "../common/mbox-util.h"
|
||||
#include "../common/zb32.h"
|
||||
#include "rfc822parse.h"
|
||||
@ -151,7 +150,7 @@ struct parser_context_s
|
||||
static gpg_error_t mail_tube_encrypt (estream_t fpin, strlist_t recipients);
|
||||
static void prepare_for_appimage (void);
|
||||
static gpg_error_t start_gpg_encrypt (estream_t *r_input,
|
||||
gnupg_process_t *r_proc,
|
||||
gpgrt_process_t *r_proc,
|
||||
strlist_t recipients);
|
||||
|
||||
|
||||
@ -405,7 +404,7 @@ mail_tube_encrypt (estream_t fpin, strlist_t recipients)
|
||||
const char *s;
|
||||
char *boundary = NULL; /* Actually only the random part of it. */
|
||||
estream_t gpginfp = NULL;
|
||||
gnupg_process_t proc = NULL;
|
||||
gpgrt_process_t proc = NULL;
|
||||
int exitcode;
|
||||
int i, found;
|
||||
|
||||
@ -562,14 +561,14 @@ mail_tube_encrypt (estream_t fpin, strlist_t recipients)
|
||||
if (err)
|
||||
log_error ("error closing pipe: %s\n", gpg_strerror (err));
|
||||
|
||||
err = gnupg_process_wait (proc, 1 /* hang */);
|
||||
err = gpgrt_process_wait (proc, 1 /* hang */);
|
||||
if (err)
|
||||
{
|
||||
log_error ("waiting for process %s failed: %s\n",
|
||||
opt.gpg_program, gpg_strerror (err));
|
||||
goto leave;
|
||||
}
|
||||
gnupg_process_ctl (proc, GNUPG_PROCESS_GET_EXIT_ID, &exitcode);
|
||||
gpgrt_process_ctl (proc, GPGRT_PROCESS_GET_EXIT_ID, &exitcode);
|
||||
if (exitcode)
|
||||
{
|
||||
log_error ("running %s failed: exitcode=%d\n",
|
||||
@ -577,7 +576,7 @@ mail_tube_encrypt (estream_t fpin, strlist_t recipients)
|
||||
goto leave;
|
||||
}
|
||||
|
||||
gnupg_process_release (proc);
|
||||
gpgrt_process_release (proc);
|
||||
proc = NULL;
|
||||
|
||||
/* Output the final boundary. */
|
||||
@ -597,7 +596,7 @@ mail_tube_encrypt (estream_t fpin, strlist_t recipients)
|
||||
|
||||
leave:
|
||||
gpgrt_fcancel (gpginfp);
|
||||
gnupg_process_release (proc);
|
||||
gpgrt_process_release (proc);
|
||||
rfc822parse_cancel (ctx->msg);
|
||||
xfree (boundary);
|
||||
return err;
|
||||
@ -688,16 +687,16 @@ prepare_for_appimage (void)
|
||||
{
|
||||
/* Run the sleep program for 2^30 seconds (34 years). */
|
||||
static const char *args[4] = { "-c", "sleep", "1073741824", NULL };
|
||||
gnupg_spawn_actions_t act;
|
||||
gpgrt_spawn_actions_t act;
|
||||
|
||||
fname = make_filename ("~/.gnupg-vsd/gnupg-vs-desktop.AppImage", NULL);
|
||||
|
||||
err = gnupg_spawn_actions_new (&act);
|
||||
err = gpgrt_spawn_actions_new (&act);
|
||||
if (!err)
|
||||
{
|
||||
err = gnupg_process_spawn (fname, args,
|
||||
GNUPG_PROCESS_DETACHED, act, NULL);
|
||||
gnupg_spawn_actions_release (act);
|
||||
err = gpgrt_process_spawn (fname, args,
|
||||
GPGRT_PROCESS_DETACHED, act, NULL);
|
||||
gpgrt_spawn_actions_release (act);
|
||||
}
|
||||
if (err)
|
||||
{
|
||||
@ -730,7 +729,7 @@ prepare_for_appimage (void)
|
||||
* is stored at R_INPUT and the process objectat R_PROC. The gpg
|
||||
* output is sent to stdout and is always armored. */
|
||||
static gpg_error_t
|
||||
start_gpg_encrypt (estream_t *r_input, gnupg_process_t *r_proc,
|
||||
start_gpg_encrypt (estream_t *r_input, gpgrt_process_t *r_proc,
|
||||
strlist_t recipients)
|
||||
{
|
||||
gpg_error_t err;
|
||||
@ -742,7 +741,7 @@ start_gpg_encrypt (estream_t *r_input, gnupg_process_t *r_proc,
|
||||
int except[2] = { -1, -1 };
|
||||
#endif
|
||||
const char **argv;
|
||||
gnupg_spawn_actions_t act = NULL;
|
||||
gpgrt_spawn_actions_t act = NULL;
|
||||
char *logfilebuf = NULL;
|
||||
|
||||
*r_input = NULL;
|
||||
@ -786,7 +785,7 @@ start_gpg_encrypt (estream_t *r_input, gnupg_process_t *r_proc,
|
||||
goto leave;
|
||||
}
|
||||
|
||||
err = gnupg_spawn_actions_new (&act);
|
||||
err = gpgrt_spawn_actions_new (&act);
|
||||
if (err)
|
||||
{
|
||||
xfree (argv);
|
||||
@ -794,24 +793,24 @@ start_gpg_encrypt (estream_t *r_input, gnupg_process_t *r_proc,
|
||||
}
|
||||
|
||||
#ifdef HAVE_W32_SYSTEM
|
||||
gnupg_spawn_actions_set_inherit_handles (act, except);
|
||||
gpgrt_spawn_actions_set_inherit_handles (act, except);
|
||||
#else
|
||||
gnupg_spawn_actions_set_inherit_fds (act, except);
|
||||
gpgrt_spawn_actions_set_inherit_fds (act, except);
|
||||
#endif
|
||||
err = gnupg_process_spawn (opt.gpg_program, argv,
|
||||
(GNUPG_PROCESS_STDIN_PIPE
|
||||
| GNUPG_PROCESS_STDOUT_KEEP
|
||||
| GNUPG_PROCESS_STDERR_KEEP), act, r_proc);
|
||||
gnupg_spawn_actions_release (act);
|
||||
err = gpgrt_process_spawn (opt.gpg_program, argv,
|
||||
(GPGRT_PROCESS_STDIN_PIPE
|
||||
| GPGRT_PROCESS_STDOUT_KEEP
|
||||
| GPGRT_PROCESS_STDERR_KEEP), act, r_proc);
|
||||
gpgrt_spawn_actions_release (act);
|
||||
xfree (argv);
|
||||
if (err)
|
||||
goto leave;
|
||||
gnupg_process_get_streams (*r_proc, 0, r_input, NULL, NULL);
|
||||
gpgrt_process_get_streams (*r_proc, 0, r_input, NULL, NULL);
|
||||
|
||||
leave:
|
||||
if (err)
|
||||
{
|
||||
gnupg_process_release (*r_proc);
|
||||
gpgrt_process_release (*r_proc);
|
||||
*r_proc = NULL;
|
||||
}
|
||||
xfree (logfilebuf);
|
||||
|
@ -46,7 +46,6 @@
|
||||
|
||||
#include "../common/util.h"
|
||||
#include "../common/i18n.h"
|
||||
#include "../common/exechelp.h"
|
||||
#include "../common/sysutils.h"
|
||||
#include "../common/status.h"
|
||||
|
||||
@ -747,7 +746,7 @@ gpg_agent_runtime_change (int killflag)
|
||||
gpg_error_t err = 0;
|
||||
const char *pgmname;
|
||||
const char *argv[5];
|
||||
gnupg_process_t proc = NULL;
|
||||
gpgrt_process_t proc = NULL;
|
||||
int i = 0;
|
||||
int cmdidx;
|
||||
|
||||
@ -764,13 +763,13 @@ gpg_agent_runtime_change (int killflag)
|
||||
log_assert (i < DIM(argv));
|
||||
|
||||
if (!err)
|
||||
err = gnupg_process_spawn (pgmname, argv, 0, NULL, &proc);
|
||||
err = gpgrt_process_spawn (pgmname, argv, 0, NULL, &proc);
|
||||
if (!err)
|
||||
err = gnupg_process_wait (proc, 1);
|
||||
err = gpgrt_process_wait (proc, 1);
|
||||
if (err)
|
||||
gc_error (0, 0, "error running '%s %s': %s",
|
||||
pgmname, argv[cmdidx], gpg_strerror (err));
|
||||
gnupg_process_release (proc);
|
||||
gpgrt_process_release (proc);
|
||||
}
|
||||
|
||||
|
||||
@ -780,7 +779,7 @@ scdaemon_runtime_change (int killflag)
|
||||
gpg_error_t err = 0;
|
||||
const char *pgmname;
|
||||
const char *argv[9];
|
||||
gnupg_process_t proc = NULL;
|
||||
gpgrt_process_t proc = NULL;
|
||||
int i = 0;
|
||||
int cmdidx;
|
||||
|
||||
@ -808,13 +807,13 @@ scdaemon_runtime_change (int killflag)
|
||||
log_assert (i < DIM(argv));
|
||||
|
||||
if (!err)
|
||||
err = gnupg_process_spawn (pgmname, argv, 0, NULL, &proc);
|
||||
err = gpgrt_process_spawn (pgmname, argv, 0, NULL, &proc);
|
||||
if (!err)
|
||||
err = gnupg_process_wait (proc, 1);
|
||||
err = gpgrt_process_wait (proc, 1);
|
||||
if (err)
|
||||
gc_error (0, 0, "error running '%s %s': %s",
|
||||
pgmname, argv[cmdidx], gpg_strerror (err));
|
||||
gnupg_process_release (proc);
|
||||
gpgrt_process_release (proc);
|
||||
}
|
||||
|
||||
|
||||
@ -825,7 +824,7 @@ tpm2daemon_runtime_change (int killflag)
|
||||
gpg_error_t err = 0;
|
||||
const char *pgmname;
|
||||
const char *argv[9];
|
||||
gnupg_process_t proc = NULL;
|
||||
gpgrt_process_t proc = NULL;
|
||||
int i = 0;
|
||||
int cmdidx;
|
||||
|
||||
@ -853,13 +852,13 @@ tpm2daemon_runtime_change (int killflag)
|
||||
log_assert (i < DIM(argv));
|
||||
|
||||
if (!err)
|
||||
err = gnupg_process_spawn (pgmname, argv, 0, NULL, &proc);
|
||||
err = gpgrt_process_spawn (pgmname, argv, 0, NULL, &proc);
|
||||
if (!err)
|
||||
err = gnupg_process_wait (proc, 1);
|
||||
err = gpgrt_process_wait (proc, 1);
|
||||
if (err)
|
||||
gc_error (0, 0, "error running '%s %s': %s",
|
||||
pgmname, argv[cmdidx], gpg_strerror (err));
|
||||
gnupg_process_release (proc);
|
||||
gpgrt_process_release (proc);
|
||||
}
|
||||
#endif
|
||||
|
||||
@ -870,7 +869,7 @@ dirmngr_runtime_change (int killflag)
|
||||
gpg_error_t err = 0;
|
||||
const char *pgmname;
|
||||
const char *argv[6];
|
||||
gnupg_process_t proc = NULL;
|
||||
gpgrt_process_t proc = NULL;
|
||||
int i = 0;
|
||||
int cmdidx;
|
||||
|
||||
@ -888,13 +887,13 @@ dirmngr_runtime_change (int killflag)
|
||||
log_assert (i < DIM(argv));
|
||||
|
||||
if (!err)
|
||||
err = gnupg_process_spawn (pgmname, argv, 0, NULL, &proc);
|
||||
err = gpgrt_process_spawn (pgmname, argv, 0, NULL, &proc);
|
||||
if (!err)
|
||||
err = gnupg_process_wait (proc, 1);
|
||||
err = gpgrt_process_wait (proc, 1);
|
||||
if (err)
|
||||
gc_error (0, 0, "error running '%s %s': %s",
|
||||
pgmname, argv[cmdidx], gpg_strerror (err));
|
||||
gnupg_process_release (proc);
|
||||
gpgrt_process_release (proc);
|
||||
}
|
||||
|
||||
|
||||
@ -904,7 +903,7 @@ keyboxd_runtime_change (int killflag)
|
||||
gpg_error_t err = 0;
|
||||
const char *pgmname;
|
||||
const char *argv[6];
|
||||
gnupg_process_t proc = NULL;
|
||||
gpgrt_process_t proc = NULL;
|
||||
int i = 0;
|
||||
int cmdidx;
|
||||
|
||||
@ -922,13 +921,13 @@ keyboxd_runtime_change (int killflag)
|
||||
log_assert (i < DIM(argv));
|
||||
|
||||
if (!err)
|
||||
err = gnupg_process_spawn (pgmname, argv, 0, NULL, &proc);
|
||||
err = gpgrt_process_spawn (pgmname, argv, 0, NULL, &proc);
|
||||
if (!err)
|
||||
err = gnupg_process_wait (proc, 1);
|
||||
err = gpgrt_process_wait (proc, 1);
|
||||
if (err)
|
||||
gc_error (0, 0, "error running '%s %s': %s",
|
||||
pgmname, argv[cmdidx], gpg_strerror (err));
|
||||
gnupg_process_release (proc);
|
||||
gpgrt_process_release (proc);
|
||||
}
|
||||
|
||||
|
||||
@ -940,7 +939,7 @@ gc_component_launch (int component)
|
||||
const char *pgmname;
|
||||
const char *argv[6];
|
||||
int i;
|
||||
gnupg_process_t proc = NULL;
|
||||
gpgrt_process_t proc = NULL;
|
||||
|
||||
if (component < 0)
|
||||
{
|
||||
@ -988,9 +987,9 @@ gc_component_launch (int component)
|
||||
argv[i] = NULL;
|
||||
log_assert (i < DIM(argv));
|
||||
|
||||
err = gnupg_process_spawn (pgmname, argv, 0, NULL, &proc);
|
||||
err = gpgrt_process_spawn (pgmname, argv, 0, NULL, &proc);
|
||||
if (!err)
|
||||
err = gnupg_process_wait (proc, 1);
|
||||
err = gpgrt_process_wait (proc, 1);
|
||||
if (err)
|
||||
gc_error (0, 0, "error running '%s%s%s': %s",
|
||||
pgmname,
|
||||
@ -998,7 +997,7 @@ gc_component_launch (int component)
|
||||
: component == GC_COMPONENT_KEYBOXD? " --keyboxd":"",
|
||||
" NOP",
|
||||
gpg_strerror (err));
|
||||
gnupg_process_release (proc);
|
||||
gpgrt_process_release (proc);
|
||||
return err;
|
||||
}
|
||||
|
||||
@ -1339,7 +1338,7 @@ gc_component_check_options (int component, estream_t out, const char *conf_file)
|
||||
const char *pgmname;
|
||||
const char *argv[6];
|
||||
int i;
|
||||
gnupg_process_t proc;
|
||||
gpgrt_process_t proc;
|
||||
estream_t errfp;
|
||||
error_line_t errlines;
|
||||
|
||||
@ -1372,27 +1371,27 @@ gc_component_check_options (int component, estream_t out, const char *conf_file)
|
||||
|
||||
result = 0;
|
||||
errlines = NULL;
|
||||
err = gnupg_process_spawn (pgmname, argv, GNUPG_PROCESS_STDERR_PIPE,
|
||||
err = gpgrt_process_spawn (pgmname, argv, GPGRT_PROCESS_STDERR_PIPE,
|
||||
NULL, &proc);
|
||||
if (err)
|
||||
result |= 1; /* Program could not be run. */
|
||||
else
|
||||
{
|
||||
gnupg_process_get_streams (proc, 0, NULL, NULL, &errfp);
|
||||
gpgrt_process_get_streams (proc, 0, NULL, NULL, &errfp);
|
||||
errlines = collect_error_output (errfp,
|
||||
gc_component[component].name);
|
||||
if (!gnupg_process_wait (proc, 1))
|
||||
if (!gpgrt_process_wait (proc, 1))
|
||||
{
|
||||
int exitcode;
|
||||
|
||||
gnupg_process_ctl (proc, GNUPG_PROCESS_GET_EXIT_ID, &exitcode);
|
||||
gpgrt_process_ctl (proc, GPGRT_PROCESS_GET_EXIT_ID, &exitcode);
|
||||
if (exitcode == -1)
|
||||
result |= 1; /* Program could not be run or it
|
||||
terminated abnormally. */
|
||||
else if (exitcode)
|
||||
result |= 2; /* Program returned an error. */
|
||||
}
|
||||
gnupg_process_release (proc);
|
||||
gpgrt_process_release (proc);
|
||||
es_fclose (errfp);
|
||||
}
|
||||
|
||||
@ -1732,7 +1731,7 @@ retrieve_options_from_program (gc_component_id_t component, int only_installed)
|
||||
const char *pgmname;
|
||||
const char *argv[2];
|
||||
estream_t outfp;
|
||||
gnupg_process_t proc;
|
||||
gpgrt_process_t proc;
|
||||
known_option_t *known_option;
|
||||
gc_option_t *option;
|
||||
char *line = NULL;
|
||||
@ -1765,7 +1764,7 @@ retrieve_options_from_program (gc_component_id_t component, int only_installed)
|
||||
/* First we need to read the option table from the program. */
|
||||
argv[0] = "--dump-option-table";
|
||||
argv[1] = NULL;
|
||||
err = gnupg_process_spawn (pgmname, argv, GNUPG_PROCESS_STDOUT_PIPE,
|
||||
err = gpgrt_process_spawn (pgmname, argv, GPGRT_PROCESS_STDOUT_PIPE,
|
||||
NULL, &proc);
|
||||
if (err)
|
||||
{
|
||||
@ -1773,7 +1772,7 @@ retrieve_options_from_program (gc_component_id_t component, int only_installed)
|
||||
pgmname, gpg_strerror (err));
|
||||
}
|
||||
|
||||
gnupg_process_get_streams (proc, 0, NULL, &outfp, NULL);
|
||||
gpgrt_process_get_streams (proc, 0, NULL, &outfp, NULL);
|
||||
|
||||
read_line_parm.pgmname = pgmname;
|
||||
read_line_parm.fp = outfp;
|
||||
@ -1933,17 +1932,17 @@ retrieve_options_from_program (gc_component_id_t component, int only_installed)
|
||||
line_len = read_line_parm.line_len;
|
||||
log_assert (opt_table_used + pseudo_count == opt_info_used);
|
||||
|
||||
err = gnupg_process_wait (proc, 1);
|
||||
err = gpgrt_process_wait (proc, 1);
|
||||
if (!err)
|
||||
{
|
||||
int exitcode;
|
||||
|
||||
gnupg_process_ctl (proc, GNUPG_PROCESS_GET_EXIT_ID, &exitcode);
|
||||
gpgrt_process_ctl (proc, GPGRT_PROCESS_GET_EXIT_ID, &exitcode);
|
||||
if (exitcode)
|
||||
gc_error (1, 0, "running %s failed (exitcode=%d): %s",
|
||||
pgmname, exitcode, gpg_strerror (err));
|
||||
}
|
||||
gnupg_process_release (proc);
|
||||
gpgrt_process_release (proc);
|
||||
|
||||
/* Make the gpgrt option table and the internal option table available. */
|
||||
gc_component[component].opt_table = opt_table;
|
||||
@ -1953,7 +1952,7 @@ retrieve_options_from_program (gc_component_id_t component, int only_installed)
|
||||
/* Now read the default options. */
|
||||
argv[0] = "--gpgconf-list";
|
||||
argv[1] = NULL;
|
||||
err = gnupg_process_spawn (pgmname, argv, GNUPG_PROCESS_STDOUT_PIPE,
|
||||
err = gpgrt_process_spawn (pgmname, argv, GPGRT_PROCESS_STDOUT_PIPE,
|
||||
NULL, &proc);
|
||||
if (err)
|
||||
{
|
||||
@ -1961,7 +1960,7 @@ retrieve_options_from_program (gc_component_id_t component, int only_installed)
|
||||
pgmname, gpg_strerror (err));
|
||||
}
|
||||
|
||||
gnupg_process_get_streams (proc, 0, NULL, &outfp, NULL);
|
||||
gpgrt_process_get_streams (proc, 0, NULL, &outfp, NULL);
|
||||
|
||||
while ((length = es_read_line (outfp, &line, &line_len, NULL)) > 0)
|
||||
{
|
||||
@ -2045,17 +2044,17 @@ retrieve_options_from_program (gc_component_id_t component, int only_installed)
|
||||
if (es_fclose (outfp))
|
||||
gc_error (1, errno, "error closing %s", pgmname);
|
||||
|
||||
err = gnupg_process_wait (proc, 1);
|
||||
err = gpgrt_process_wait (proc, 1);
|
||||
if (!err)
|
||||
{
|
||||
int exitcode;
|
||||
|
||||
gnupg_process_ctl (proc, GNUPG_PROCESS_GET_EXIT_ID, &exitcode);
|
||||
gpgrt_process_ctl (proc, GPGRT_PROCESS_GET_EXIT_ID, &exitcode);
|
||||
if (exitcode)
|
||||
gc_error (1, 0, "running %s failed (exitcode=%d): %s",
|
||||
pgmname, exitcode, gpg_strerror (err));
|
||||
}
|
||||
gnupg_process_release (proc);
|
||||
gpgrt_process_release (proc);
|
||||
|
||||
|
||||
/* At this point, we can parse the configuration file. */
|
||||
|
@ -33,7 +33,6 @@
|
||||
#include "../common/sysutils.h"
|
||||
#include "../common/init.h"
|
||||
#include "../common/status.h"
|
||||
#include "../common/exechelp.h"
|
||||
#include "../common/dotlock.h"
|
||||
|
||||
#ifdef HAVE_W32_SYSTEM
|
||||
@ -1303,7 +1302,7 @@ show_versions_via_dirmngr (estream_t fp)
|
||||
const char *pgmname;
|
||||
const char *argv[2];
|
||||
estream_t outfp;
|
||||
gnupg_process_t proc;
|
||||
gpgrt_process_t proc;
|
||||
char *line = NULL;
|
||||
size_t line_len = 0;
|
||||
ssize_t length;
|
||||
@ -1311,7 +1310,7 @@ show_versions_via_dirmngr (estream_t fp)
|
||||
pgmname = gnupg_module_name (GNUPG_MODULE_NAME_DIRMNGR);
|
||||
argv[0] = "--gpgconf-versions";
|
||||
argv[1] = NULL;
|
||||
err = gnupg_process_spawn (pgmname, argv, GNUPG_PROCESS_STDOUT_PIPE,
|
||||
err = gpgrt_process_spawn (pgmname, argv, GPGRT_PROCESS_STDOUT_PIPE,
|
||||
NULL, &proc);
|
||||
if (err)
|
||||
{
|
||||
@ -1320,7 +1319,7 @@ show_versions_via_dirmngr (estream_t fp)
|
||||
return;
|
||||
}
|
||||
|
||||
gnupg_process_get_streams (proc, 0, NULL, &outfp, NULL);
|
||||
gpgrt_process_get_streams (proc, 0, NULL, &outfp, NULL);
|
||||
while ((length = es_read_line (outfp, &line, &line_len, NULL)) > 0)
|
||||
{
|
||||
/* Strip newline and carriage return, if present. */
|
||||
@ -1341,12 +1340,12 @@ show_versions_via_dirmngr (estream_t fp)
|
||||
pgmname, gpg_strerror (err));
|
||||
}
|
||||
|
||||
err = gnupg_process_wait (proc, 1);
|
||||
err = gpgrt_process_wait (proc, 1);
|
||||
if (!err)
|
||||
{
|
||||
int exitcode;
|
||||
|
||||
gnupg_process_ctl (proc, GNUPG_PROCESS_GET_EXIT_ID, &exitcode);
|
||||
gpgrt_process_ctl (proc, GPGRT_PROCESS_GET_EXIT_ID, &exitcode);
|
||||
if (exitcode)
|
||||
{
|
||||
log_error ("running %s failed (exitcode=%d): %s\n",
|
||||
@ -1354,7 +1353,7 @@ show_versions_via_dirmngr (estream_t fp)
|
||||
es_fprintf (fp, "[error: can't get further info]\n");
|
||||
}
|
||||
}
|
||||
gnupg_process_release (proc);
|
||||
gpgrt_process_release (proc);
|
||||
xfree (line);
|
||||
}
|
||||
|
||||
|
@ -39,7 +39,6 @@
|
||||
|
||||
#include "../common/i18n.h"
|
||||
#include <gpg-error.h>
|
||||
#include "../common/exechelp.h"
|
||||
#include "../common/sysutils.h"
|
||||
#include "../common/ccparray.h"
|
||||
#include "../common/membuf.h"
|
||||
@ -1069,7 +1068,7 @@ gpgtar_create (char **inpattern, const char *files_from, int null_names,
|
||||
estream_t files_from_stream = NULL;
|
||||
estream_t outstream = NULL;
|
||||
int eof_seen = 0;
|
||||
gnupg_process_t proc = NULL;
|
||||
gpgrt_process_t proc = NULL;
|
||||
unsigned int skipped_open = 0;
|
||||
|
||||
memset (scanctrl, 0, sizeof *scanctrl);
|
||||
@ -1234,7 +1233,7 @@ gpgtar_create (char **inpattern, const char *files_from, int null_names,
|
||||
int except[2] = { -1, -1 };
|
||||
#endif
|
||||
const char **argv;
|
||||
gnupg_spawn_actions_t act = NULL;
|
||||
gpgrt_spawn_actions_t act = NULL;
|
||||
|
||||
/* '--encrypt' may be combined with '--symmetric', but 'encrypt'
|
||||
* is set either way. Clear it if no recipients are specified.
|
||||
@ -1297,7 +1296,7 @@ gpgtar_create (char **inpattern, const char *files_from, int null_names,
|
||||
goto leave;
|
||||
}
|
||||
|
||||
err = gnupg_spawn_actions_new (&act);
|
||||
err = gpgrt_spawn_actions_new (&act);
|
||||
if (err)
|
||||
{
|
||||
xfree (argv);
|
||||
@ -1305,20 +1304,20 @@ gpgtar_create (char **inpattern, const char *files_from, int null_names,
|
||||
}
|
||||
|
||||
#ifdef HAVE_W32_SYSTEM
|
||||
gnupg_spawn_actions_set_inherit_handles (act, except);
|
||||
gpgrt_spawn_actions_set_inherit_handles (act, except);
|
||||
#else
|
||||
gnupg_spawn_actions_set_inherit_fds (act, except);
|
||||
gpgrt_spawn_actions_set_inherit_fds (act, except);
|
||||
#endif
|
||||
err = gnupg_process_spawn (opt.gpg_program, argv,
|
||||
(GNUPG_PROCESS_STDIN_PIPE
|
||||
| GNUPG_PROCESS_STDOUT_KEEP
|
||||
| GNUPG_PROCESS_STDERR_KEEP), act, &proc);
|
||||
gnupg_spawn_actions_release (act);
|
||||
err = gpgrt_process_spawn (opt.gpg_program, argv,
|
||||
(GPGRT_PROCESS_STDIN_PIPE
|
||||
| GPGRT_PROCESS_STDOUT_KEEP
|
||||
| GPGRT_PROCESS_STDERR_KEEP), act, &proc);
|
||||
gpgrt_spawn_actions_release (act);
|
||||
xfree (argv);
|
||||
if (err)
|
||||
goto leave;
|
||||
/* Note that OUTSTREAM is our tar output which is fed to gpg. */
|
||||
gnupg_process_get_streams (proc, 0, &outstream, NULL, NULL);
|
||||
gpgrt_process_get_streams (proc, 0, &outstream, NULL, NULL);
|
||||
es_set_binary (outstream);
|
||||
}
|
||||
else if (opt.outfile) /* No crypto */
|
||||
@ -1364,17 +1363,17 @@ gpgtar_create (char **inpattern, const char *files_from, int null_names,
|
||||
if (err)
|
||||
log_error ("error closing pipe: %s\n", gpg_strerror (err));
|
||||
|
||||
err = gnupg_process_wait (proc, 1);
|
||||
err = gpgrt_process_wait (proc, 1);
|
||||
if (!err)
|
||||
{
|
||||
int exitcode;
|
||||
|
||||
gnupg_process_ctl (proc, GNUPG_PROCESS_GET_EXIT_ID, &exitcode);
|
||||
gpgrt_process_ctl (proc, GPGRT_PROCESS_GET_EXIT_ID, &exitcode);
|
||||
if (exitcode)
|
||||
log_error ("running %s failed (exitcode=%d): %s",
|
||||
opt.gpg_program, exitcode, gpg_strerror (err));
|
||||
}
|
||||
gnupg_process_release (proc);
|
||||
gpgrt_process_release (proc);
|
||||
proc = NULL;
|
||||
}
|
||||
|
||||
|
@ -31,7 +31,6 @@
|
||||
|
||||
#include "../common/i18n.h"
|
||||
#include <gpg-error.h>
|
||||
#include "../common/exechelp.h"
|
||||
#include "../common/sysutils.h"
|
||||
#include "../common/ccparray.h"
|
||||
#include "gpgtar.h"
|
||||
@ -339,7 +338,7 @@ gpgtar_extract (const char *filename, int decrypt)
|
||||
char *dirname = NULL;
|
||||
struct tarinfo_s tarinfo_buffer;
|
||||
tarinfo_t tarinfo = &tarinfo_buffer;
|
||||
gnupg_process_t proc;
|
||||
gpgrt_process_t proc;
|
||||
char *logfilename = NULL;
|
||||
unsigned long long notextracted;
|
||||
|
||||
@ -390,7 +389,7 @@ gpgtar_extract (const char *filename, int decrypt)
|
||||
int except[2] = { -1, -1 };
|
||||
#endif
|
||||
const char **argv;
|
||||
gnupg_spawn_actions_t act = NULL;
|
||||
gpgrt_spawn_actions_t act = NULL;
|
||||
|
||||
ccparray_init (&ccp, 0);
|
||||
if (opt.batch)
|
||||
@ -436,7 +435,7 @@ gpgtar_extract (const char *filename, int decrypt)
|
||||
goto leave;
|
||||
}
|
||||
|
||||
err = gnupg_spawn_actions_new (&act);
|
||||
err = gpgrt_spawn_actions_new (&act);
|
||||
if (err)
|
||||
{
|
||||
xfree (argv);
|
||||
@ -444,18 +443,18 @@ gpgtar_extract (const char *filename, int decrypt)
|
||||
}
|
||||
|
||||
#ifdef HAVE_W32_SYSTEM
|
||||
gnupg_spawn_actions_set_inherit_handles (act, except);
|
||||
gpgrt_spawn_actions_set_inherit_handles (act, except);
|
||||
#else
|
||||
gnupg_spawn_actions_set_inherit_fds (act, except);
|
||||
gpgrt_spawn_actions_set_inherit_fds (act, except);
|
||||
#endif
|
||||
err = gnupg_process_spawn (opt.gpg_program, argv,
|
||||
((filename ? 0 : GNUPG_PROCESS_STDIN_KEEP)
|
||||
| GNUPG_PROCESS_STDOUT_PIPE), act, &proc);
|
||||
gnupg_spawn_actions_release (act);
|
||||
err = gpgrt_process_spawn (opt.gpg_program, argv,
|
||||
((filename ? 0 : GPGRT_PROCESS_STDIN_KEEP)
|
||||
| GPGRT_PROCESS_STDOUT_PIPE), act, &proc);
|
||||
gpgrt_spawn_actions_release (act);
|
||||
xfree (argv);
|
||||
if (err)
|
||||
goto leave;
|
||||
gnupg_process_get_streams (proc, 0, NULL, &stream, NULL);
|
||||
gpgrt_process_get_streams (proc, 0, NULL, &stream, NULL);
|
||||
es_set_binary (stream);
|
||||
}
|
||||
else if (filename)
|
||||
@ -502,17 +501,17 @@ gpgtar_extract (const char *filename, int decrypt)
|
||||
if (err)
|
||||
log_error ("error closing pipe: %s\n", gpg_strerror (err));
|
||||
|
||||
err = gnupg_process_wait (proc, 1);
|
||||
err = gpgrt_process_wait (proc, 1);
|
||||
if (!err)
|
||||
{
|
||||
int exitcode;
|
||||
|
||||
gnupg_process_ctl (proc, GNUPG_PROCESS_GET_EXIT_ID, &exitcode);
|
||||
gpgrt_process_ctl (proc, GPGRT_PROCESS_GET_EXIT_ID, &exitcode);
|
||||
if (exitcode)
|
||||
log_error ("running %s failed (exitcode=%d): %s",
|
||||
opt.gpg_program, exitcode, gpg_strerror (err));
|
||||
}
|
||||
gnupg_process_release (proc);
|
||||
gpgrt_process_release (proc);
|
||||
proc = NULL;
|
||||
}
|
||||
|
||||
|
@ -29,7 +29,6 @@
|
||||
#include "../common/i18n.h"
|
||||
#include <gpg-error.h>
|
||||
#include "gpgtar.h"
|
||||
#include "../common/exechelp.h"
|
||||
#include "../common/sysutils.h"
|
||||
#include "../common/ccparray.h"
|
||||
|
||||
@ -460,7 +459,7 @@ gpgtar_list (const char *filename, int decrypt)
|
||||
strlist_t extheader = NULL;
|
||||
struct tarinfo_s tarinfo_buffer;
|
||||
tarinfo_t tarinfo = &tarinfo_buffer;
|
||||
gnupg_process_t proc = NULL;
|
||||
gpgrt_process_t proc = NULL;
|
||||
|
||||
memset (&tarinfo_buffer, 0, sizeof tarinfo_buffer);
|
||||
|
||||
@ -474,7 +473,7 @@ gpgtar_list (const char *filename, int decrypt)
|
||||
int except[2] = { -1, -1 };
|
||||
#endif
|
||||
const char **argv;
|
||||
gnupg_spawn_actions_t act = NULL;
|
||||
gpgrt_spawn_actions_t act = NULL;
|
||||
|
||||
ccparray_init (&ccp, 0);
|
||||
if (opt.batch)
|
||||
@ -514,7 +513,7 @@ gpgtar_list (const char *filename, int decrypt)
|
||||
goto leave;
|
||||
}
|
||||
|
||||
err = gnupg_spawn_actions_new (&act);
|
||||
err = gpgrt_spawn_actions_new (&act);
|
||||
if (err)
|
||||
{
|
||||
xfree (argv);
|
||||
@ -522,18 +521,18 @@ gpgtar_list (const char *filename, int decrypt)
|
||||
}
|
||||
|
||||
#ifdef HAVE_W32_SYSTEM
|
||||
gnupg_spawn_actions_set_inherit_handles (act, except);
|
||||
gpgrt_spawn_actions_set_inherit_handles (act, except);
|
||||
#else
|
||||
gnupg_spawn_actions_set_inherit_fds (act, except);
|
||||
gpgrt_spawn_actions_set_inherit_fds (act, except);
|
||||
#endif
|
||||
err = gnupg_process_spawn (opt.gpg_program, argv,
|
||||
((filename ? 0 : GNUPG_PROCESS_STDIN_KEEP)
|
||||
| GNUPG_PROCESS_STDOUT_PIPE), act, &proc);
|
||||
gnupg_spawn_actions_release (act);
|
||||
err = gpgrt_process_spawn (opt.gpg_program, argv,
|
||||
((filename ? 0 : GPGRT_PROCESS_STDIN_KEEP)
|
||||
| GPGRT_PROCESS_STDOUT_PIPE), act, &proc);
|
||||
gpgrt_spawn_actions_release (act);
|
||||
xfree (argv);
|
||||
if (err)
|
||||
goto leave;
|
||||
gnupg_process_get_streams (proc, 0, NULL, &stream, NULL);
|
||||
gpgrt_process_get_streams (proc, 0, NULL, &stream, NULL);
|
||||
es_set_binary (stream);
|
||||
}
|
||||
else if (filename) /* No decryption requested. */
|
||||
@ -580,16 +579,16 @@ gpgtar_list (const char *filename, int decrypt)
|
||||
if (err)
|
||||
log_error ("error closing pipe: %s\n", gpg_strerror (err));
|
||||
|
||||
err = gnupg_process_wait (proc, 1);
|
||||
err = gpgrt_process_wait (proc, 1);
|
||||
if (!err)
|
||||
{
|
||||
int exitcode;
|
||||
|
||||
gnupg_process_ctl (proc, GNUPG_PROCESS_GET_EXIT_ID, &exitcode);
|
||||
gpgrt_process_ctl (proc, GPGRT_PROCESS_GET_EXIT_ID, &exitcode);
|
||||
log_error ("running %s failed (exitcode=%d): %s",
|
||||
opt.gpg_program, exitcode, gpg_strerror (err));
|
||||
}
|
||||
gnupg_process_release (proc);
|
||||
gpgrt_process_release (proc);
|
||||
proc = NULL;
|
||||
}
|
||||
|
||||
|
Loading…
Reference in New Issue
Block a user