mirror of
git://git.gnupg.org/gnupg.git
synced 2024-09-19 14:41:41 +02:00
953dd67368
* 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>
360 lines
8.5 KiB
C
360 lines
8.5 KiB
C
/* exechelp.c - Fork and exec helpers for POSIX
|
|
* Copyright (C) 2004, 2007-2009, 2010 Free Software Foundation, Inc.
|
|
* Copyright (C) 2004, 2006-2012, 2014-2017 g10 Code GmbH
|
|
*
|
|
* This file is part of GnuPG.
|
|
*
|
|
* This file is free software; you can redistribute it and/or modify
|
|
* it under the terms of either
|
|
*
|
|
* - the GNU Lesser General Public License as published by the Free
|
|
* Software Foundation; either version 3 of the License, or (at
|
|
* your option) any later version.
|
|
*
|
|
* or
|
|
*
|
|
* - the GNU General Public License as published by the Free
|
|
* Software Foundation; either version 2 of the License, or (at
|
|
* your option) any later version.
|
|
*
|
|
* or both in parallel, as here.
|
|
*
|
|
* This file is distributed in the hope that it will be useful,
|
|
* but WITHOUT ANY WARRANTY; without even the implied warranty of
|
|
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
|
* GNU General Public License for more details.
|
|
*
|
|
* You should have received a copy of the GNU General Public License
|
|
* along with this program; if not, see <https://www.gnu.org/licenses/>.
|
|
* SPDX-License-Identifier: (LGPL-3.0+ OR GPL-2.0+)
|
|
*/
|
|
|
|
#include <config.h>
|
|
|
|
#if defined(HAVE_W32_SYSTEM)
|
|
#error This code is only used on POSIX
|
|
#endif
|
|
|
|
#include <stdio.h>
|
|
#include <stdlib.h>
|
|
#include <stdint.h>
|
|
#include <string.h>
|
|
#include <errno.h>
|
|
#include <assert.h>
|
|
#ifdef HAVE_SIGNAL_H
|
|
# include <signal.h>
|
|
#endif
|
|
#include <unistd.h>
|
|
#include <fcntl.h>
|
|
|
|
#ifdef WITHOUT_NPTH /* Give the Makefile a chance to build without Pth. */
|
|
#undef HAVE_NPTH
|
|
#undef USE_NPTH
|
|
#endif
|
|
|
|
#ifdef HAVE_NPTH
|
|
#include <npth.h>
|
|
#endif
|
|
#include <sys/wait.h>
|
|
|
|
#ifdef HAVE_GETRLIMIT
|
|
#include <sys/time.h>
|
|
#include <sys/resource.h>
|
|
#endif /*HAVE_GETRLIMIT*/
|
|
|
|
#ifdef HAVE_STAT
|
|
# include <sys/stat.h>
|
|
#endif
|
|
|
|
#if __linux__
|
|
# include <sys/types.h>
|
|
# include <dirent.h>
|
|
#endif /*__linux__ */
|
|
|
|
#include "util.h"
|
|
#include "i18n.h"
|
|
#include "sysutils.h"
|
|
#include "exechelp.h"
|
|
|
|
|
|
/* Helper */
|
|
static inline gpg_error_t
|
|
my_error_from_syserror (void)
|
|
{
|
|
return gpg_err_make (default_errsource, gpg_err_code_from_syserror ());
|
|
}
|
|
|
|
|
|
/* Return the maximum number of currently allowed open file
|
|
descriptors. Only useful on POSIX systems but returns a value on
|
|
other systems too. */
|
|
int
|
|
get_max_fds (void)
|
|
{
|
|
int max_fds = -1;
|
|
#ifdef HAVE_GETRLIMIT
|
|
struct rlimit rl;
|
|
|
|
/* Under Linux we can figure out the highest used file descriptor by
|
|
* reading /proc/PID/fd. This is in the common cases much fast than
|
|
* for example doing 4096 close calls where almost all of them will
|
|
* fail. On a system with a limit of 4096 files and only 8 files
|
|
* open with the highest number being 10, we speedup close_all_fds
|
|
* from 125ms to 0.4ms including readdir.
|
|
*
|
|
* Another option would be to close the file descriptors as returned
|
|
* from reading that directory - however then we need to snapshot
|
|
* that list before starting to close them. */
|
|
#ifdef __linux__
|
|
{
|
|
DIR *dir = NULL;
|
|
struct dirent *dir_entry;
|
|
const char *s;
|
|
int x;
|
|
|
|
dir = opendir ("/proc/self/fd");
|
|
if (dir)
|
|
{
|
|
while ((dir_entry = readdir (dir)))
|
|
{
|
|
s = dir_entry->d_name;
|
|
if ( *s < '0' || *s > '9')
|
|
continue;
|
|
x = atoi (s);
|
|
if (x > max_fds)
|
|
max_fds = x;
|
|
}
|
|
closedir (dir);
|
|
}
|
|
if (max_fds != -1)
|
|
return max_fds + 1;
|
|
}
|
|
#endif /* __linux__ */
|
|
|
|
|
|
# ifdef RLIMIT_NOFILE
|
|
if (!getrlimit (RLIMIT_NOFILE, &rl))
|
|
max_fds = rl.rlim_max;
|
|
# endif
|
|
|
|
# ifdef RLIMIT_OFILE
|
|
if (max_fds == -1 && !getrlimit (RLIMIT_OFILE, &rl))
|
|
max_fds = rl.rlim_max;
|
|
|
|
# endif
|
|
#endif /*HAVE_GETRLIMIT*/
|
|
|
|
#ifdef _SC_OPEN_MAX
|
|
if (max_fds == -1)
|
|
{
|
|
long int scres = sysconf (_SC_OPEN_MAX);
|
|
if (scres >= 0)
|
|
max_fds = scres;
|
|
}
|
|
#endif
|
|
|
|
#ifdef _POSIX_OPEN_MAX
|
|
if (max_fds == -1)
|
|
max_fds = _POSIX_OPEN_MAX;
|
|
#endif
|
|
|
|
#ifdef OPEN_MAX
|
|
if (max_fds == -1)
|
|
max_fds = OPEN_MAX;
|
|
#endif
|
|
|
|
if (max_fds == -1)
|
|
max_fds = 256; /* Arbitrary limit. */
|
|
|
|
/* AIX returns INT32_MAX instead of a proper value. We assume that
|
|
this is always an error and use an arbitrary limit. */
|
|
#ifdef INT32_MAX
|
|
if (max_fds == INT32_MAX)
|
|
max_fds = 256;
|
|
#endif
|
|
|
|
return max_fds;
|
|
}
|
|
|
|
|
|
/* Close all file descriptors starting with descriptor FIRST. If
|
|
EXCEPT is not NULL, it is expected to be a list of file descriptors
|
|
which shall not be closed. This list shall be sorted in ascending
|
|
order with the end marked by -1. */
|
|
void
|
|
close_all_fds (int first, const int *except)
|
|
{
|
|
int max_fd = get_max_fds ();
|
|
int fd, i, except_start;
|
|
|
|
if (except)
|
|
{
|
|
except_start = 0;
|
|
for (fd=first; fd < max_fd; fd++)
|
|
{
|
|
for (i=except_start; except[i] != -1; i++)
|
|
{
|
|
if (except[i] == fd)
|
|
{
|
|
/* If we found the descriptor in the exception list
|
|
we can start the next compare run at the next
|
|
index because the exception list is ordered. */
|
|
except_start = i + 1;
|
|
break;
|
|
}
|
|
}
|
|
if (except[i] == -1)
|
|
close (fd);
|
|
}
|
|
}
|
|
else
|
|
{
|
|
for (fd=first; fd < max_fd; fd++)
|
|
close (fd);
|
|
}
|
|
|
|
gpg_err_set_errno (0);
|
|
}
|
|
|
|
|
|
/* Returns an array with all currently open file descriptors. The end
|
|
of the array is marked by -1. The caller needs to release this
|
|
array using the *standard free* and not with xfree. This allow the
|
|
use of this function right at startup even before libgcrypt has
|
|
been initialized. Returns NULL on error and sets ERRNO
|
|
accordingly. */
|
|
int *
|
|
get_all_open_fds (void)
|
|
{
|
|
int *array;
|
|
size_t narray;
|
|
int fd, max_fd, idx;
|
|
#ifndef HAVE_STAT
|
|
array = calloc (1, sizeof *array);
|
|
if (array)
|
|
array[0] = -1;
|
|
#else /*HAVE_STAT*/
|
|
struct stat statbuf;
|
|
|
|
max_fd = get_max_fds ();
|
|
narray = 32; /* If you change this change also t-exechelp.c. */
|
|
array = calloc (narray, sizeof *array);
|
|
if (!array)
|
|
return NULL;
|
|
|
|
/* Note: The list we return is ordered. */
|
|
for (idx=0, fd=0; fd < max_fd; fd++)
|
|
if (!(fstat (fd, &statbuf) == -1 && errno == EBADF))
|
|
{
|
|
if (idx+1 >= narray)
|
|
{
|
|
int *tmp;
|
|
|
|
narray += (narray < 256)? 32:256;
|
|
tmp = realloc (array, narray * sizeof *array);
|
|
if (!tmp)
|
|
{
|
|
free (array);
|
|
return NULL;
|
|
}
|
|
array = tmp;
|
|
}
|
|
array[idx++] = fd;
|
|
}
|
|
array[idx] = -1;
|
|
#endif /*HAVE_STAT*/
|
|
return array;
|
|
}
|
|
|
|
|
|
static gpg_error_t
|
|
do_create_pipe (int filedes[2])
|
|
{
|
|
gpg_error_t err = 0;
|
|
|
|
if (pipe (filedes) == -1)
|
|
{
|
|
err = my_error_from_syserror ();
|
|
filedes[0] = filedes[1] = -1;
|
|
}
|
|
|
|
return err;
|
|
}
|
|
|
|
|
|
static gpg_error_t
|
|
create_pipe_and_estream (int filedes[2], estream_t *r_fp,
|
|
int outbound, int nonblock)
|
|
{
|
|
gpg_error_t err;
|
|
|
|
if (pipe (filedes) == -1)
|
|
{
|
|
err = my_error_from_syserror ();
|
|
log_error (_("error creating a pipe: %s\n"), gpg_strerror (err));
|
|
filedes[0] = filedes[1] = -1;
|
|
*r_fp = NULL;
|
|
return err;
|
|
}
|
|
|
|
if (!outbound)
|
|
*r_fp = es_fdopen (filedes[0], nonblock? "r,nonblock" : "r");
|
|
else
|
|
*r_fp = es_fdopen (filedes[1], nonblock? "w,nonblock" : "w");
|
|
if (!*r_fp)
|
|
{
|
|
err = my_error_from_syserror ();
|
|
log_error (_("error creating a stream for a pipe: %s\n"),
|
|
gpg_strerror (err));
|
|
close (filedes[0]);
|
|
close (filedes[1]);
|
|
filedes[0] = filedes[1] = -1;
|
|
return err;
|
|
}
|
|
return 0;
|
|
}
|
|
|
|
|
|
/* Portable function to create a pipe. Under Windows the write end is
|
|
inheritable. If R_FP is not NULL, an estream is created for the
|
|
read end and stored at R_FP. */
|
|
gpg_error_t
|
|
gnupg_create_inbound_pipe (int filedes[2], estream_t *r_fp, int nonblock)
|
|
{
|
|
if (r_fp)
|
|
return create_pipe_and_estream (filedes, r_fp, 0, nonblock);
|
|
else
|
|
return do_create_pipe (filedes);
|
|
}
|
|
|
|
|
|
/* Portable function to create a pipe. Under Windows the read end is
|
|
inheritable. If R_FP is not NULL, an estream is created for the
|
|
write end and stored at R_FP. */
|
|
gpg_error_t
|
|
gnupg_create_outbound_pipe (int filedes[2], estream_t *r_fp, int nonblock)
|
|
{
|
|
if (r_fp)
|
|
return create_pipe_and_estream (filedes, r_fp, 1, nonblock);
|
|
else
|
|
return do_create_pipe (filedes);
|
|
}
|
|
|
|
|
|
/* Portable function to create a pipe. Under Windows both ends are
|
|
inheritable. */
|
|
gpg_error_t
|
|
gnupg_create_pipe (int filedes[2])
|
|
{
|
|
return do_create_pipe (filedes);
|
|
}
|
|
|
|
|
|
/* Close the end of a pipe. */
|
|
void
|
|
gnupg_close_pipe (int fd)
|
|
{
|
|
if (fd != -1)
|
|
close (fd);
|
|
}
|