mirror of
git://git.gnupg.org/gnupg.git
synced 2024-09-21 15:01:41 +02:00
![NIIBE Yutaka](/assets/img/avatar_default.png)
* agent/gpg-agent.c (handle_connections): It's for POSIX.
* kbx/keyboxd.c (handle_connections): Ditto.
* scd/app.c (handle_connections): Ditto.
* scd/scdaemon.c (handle_connections): Ditto.
tpm2d/tpm2daemon.c (handle_connections): Ditto.
* tests/gpgscm/ffi.c (do_pipe): Use GNUPG_PIPE_BOTH.
(do_inbound_pipe): Use GNUPG_PIPE_INBOUND.
(do_outbound_pipe): Use GNUPG_PIPE_OUTBOUND.
* common/call-gpg.c (_gpg_encrypt): Specify outbound and inbound.
(_gpg_decrypt): Likewise.
* common/exechelp-posix.c (gnupg_create_pipe): Add an argument.
* common/exechelp-w32.c (create_pipe_and_estream): Care about
how PIPE handles are inherited to child process.
(gnupg_create_pipe): Add an argument.
* common/exechelp.h: Add enum values.
--
Fixes-commit: af6c47b291
Signed-off-by: NIIBE Yutaka <gniibe@fsij.org>
370 lines
8.8 KiB
C
370 lines
8.8 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 (gnupg_fd_t *r_fd, estream_t *r_fp,
|
|
int outbound, int nonblock)
|
|
{
|
|
gpg_error_t err;
|
|
int filedes[2];
|
|
|
|
if (pipe (filedes) == -1)
|
|
{
|
|
err = my_error_from_syserror ();
|
|
log_error (_("error creating a pipe: %s\n"), gpg_strerror (err));
|
|
*r_fd = -1;
|
|
*r_fp = NULL;
|
|
return err;
|
|
}
|
|
|
|
if (!outbound)
|
|
{
|
|
*r_fd = filedes[1];
|
|
*r_fp = es_fdopen (filedes[0], nonblock? "r,nonblock" : "r");
|
|
}
|
|
else
|
|
{
|
|
*r_fd = filedes[0];
|
|
*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]);
|
|
*r_fd = -1;
|
|
return err;
|
|
}
|
|
return 0;
|
|
}
|
|
|
|
|
|
/* Portable function to create a pipe. Under Windows the write end is
|
|
inheritable. Pipe is created and the read end is stored at R_FD.
|
|
An estream is created for the write end and stored at R_FP. */
|
|
gpg_error_t
|
|
gnupg_create_inbound_pipe (gnupg_fd_t *r_fd, estream_t *r_fp, int nonblock)
|
|
{
|
|
if (!r_fd || !r_fp)
|
|
gpg_error (GPG_ERR_INV_ARG);
|
|
|
|
return create_pipe_and_estream (r_fd, r_fp, 0, nonblock);
|
|
}
|
|
|
|
|
|
/* Portable function to create a pipe. Under Windows the read end is
|
|
inheritable. Pipe is created and the write end is stored at R_FD.
|
|
An estream is created for the write end and stored at R_FP. */
|
|
gpg_error_t
|
|
gnupg_create_outbound_pipe (gnupg_fd_t *r_fd, estream_t *r_fp, int nonblock)
|
|
{
|
|
if (!r_fd || !r_fp)
|
|
gpg_error (GPG_ERR_INV_ARG);
|
|
|
|
return create_pipe_and_estream (r_fd, r_fp, 1, nonblock);
|
|
}
|
|
|
|
|
|
/* Portable function to create a pipe. FLAGS=GNUPG_PIPE_INBOUND for
|
|
ihneritable write-end for Windows, GNUPG_PIPE_OUTBOUND for
|
|
inheritable read-end for Windows, GNUPG_PIPE_BOTH to specify
|
|
both ends may be inheritable. */
|
|
gpg_error_t
|
|
gnupg_create_pipe (int filedes[2], int flags)
|
|
{
|
|
(void)flags;
|
|
return do_create_pipe (filedes);
|
|
}
|
|
|
|
|
|
/* Close the end of a pipe. */
|
|
void
|
|
gnupg_close_pipe (int fd)
|
|
{
|
|
if (fd != -1)
|
|
close (fd);
|
|
}
|