diff -up patch-2.7.6/lib/execute.c.switch-from-fork-execlp-to-execute patch-2.7.6/lib/execute.c

--- patch-2.7.6/lib/execute.c.switch-from-fork-execlp-to-execute	2019-07-29 14:40:53.264464824 +0200

+++ patch-2.7.6/lib/execute.c	2019-07-29 14:40:53.264464824 +0200

@@ -0,0 +1,273 @@

+/* Creation of autonomous subprocesses.

+   Copyright (C) 2001-2004, 2006-2018 Free Software Foundation, Inc.

+   Written by Bruno Haible <haible@clisp.cons.org>, 2001.

+

+   This program is free software: you can redistribute it and/or modify

+   it under the terms of the GNU General Public License as published by

+   the Free Software Foundation; either version 3 of the License, or

+   (at your option) any later version.

+

+   This program 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/>.  */

+

+

+#include <config.h>

+

+/* Specification.  */

+#include "execute.h"

+

+#include <errno.h>

+#include <fcntl.h>

+#include <stdbool.h>

+#include <stdlib.h>

+#include <signal.h>

+#include <unistd.h>

+

+#include "error.h"

+#include "fatal-signal.h"

+#include "wait-process.h"

+#include "gettext.h"

+

+#define _(str) gettext (str)

+

+#if (defined _WIN32 || defined __WIN32__) && ! defined __CYGWIN__

+

+/* Native Windows API.  */

+# include <process.h>

+# include "w32spawn.h"

+

+#else

+

+/* Unix API.  */

+# include <spawn.h>

+

+#endif

+

+

+#if defined EINTR && ((defined _WIN32 || defined __WIN32__) && ! defined __CYGWIN__)

+

+/* EINTR handling for close(), open().

+   These functions can return -1/EINTR even though we don't have any

+   signal handlers set up, namely when we get interrupted via SIGSTOP.  */

+

+static int

+nonintr_close (int fd)

+{

+  int retval;

+

+  do

+    retval = close (fd);

+  while (retval < 0 && errno == EINTR);

+

+  return retval;

+}

+#define close nonintr_close

+

+static int

+nonintr_open (const char *pathname, int oflag, mode_t mode)

+{

+  int retval;

+

+  do

+    retval = open (pathname, oflag, mode);

+  while (retval < 0 && errno == EINTR);

+

+  return retval;

+}

+#undef open /* avoid warning on VMS */

+#define open nonintr_open

+

+#endif

+

+

+/* Execute a command, optionally redirecting any of the three standard file

+   descriptors to /dev/null.  Return its exit code.

+   If it didn't terminate correctly, exit if exit_on_error is true, otherwise

+   return 127.

+   If slave_process is true, the child process will be terminated when its

+   creator receives a catchable fatal signal.  */

+int

+execute (const char *progname,

+         const char *prog_path, char **prog_argv,

+         bool ignore_sigpipe,

+         bool null_stdin, bool null_stdout, bool null_stderr,

+         bool slave_process, bool exit_on_error,

+         int *termsigp)

+{

+#if (defined _WIN32 || defined __WIN32__) && ! defined __CYGWIN__

+

+  /* Native Windows API.  */

+  int orig_stdin;

+  int orig_stdout;

+  int orig_stderr;

+  int exitcode;

+  int nullinfd;

+  int nulloutfd;

+

+  /* FIXME: Need to free memory allocated by prepare_spawn.  */

+  prog_argv = prepare_spawn (prog_argv);

+

+  /* Save standard file handles of parent process.  */

+  if (null_stdin)

+    orig_stdin = dup_safer_noinherit (STDIN_FILENO);

+  if (null_stdout)

+    orig_stdout = dup_safer_noinherit (STDOUT_FILENO);

+  if (null_stderr)

+    orig_stderr = dup_safer_noinherit (STDERR_FILENO);

+  exitcode = -1;

+

+  /* Create standard file handles of child process.  */

+  nullinfd = -1;

+  nulloutfd = -1;

+  if ((!null_stdin

+       || ((nullinfd = open ("NUL", O_RDONLY, 0)) >= 0

+           && (nullinfd == STDIN_FILENO

+               || (dup2 (nullinfd, STDIN_FILENO) >= 0

+                   && close (nullinfd) >= 0))))

+      && (!(null_stdout || null_stderr)

+          || ((nulloutfd = open ("NUL", O_RDWR, 0)) >= 0

+              && (!null_stdout

+                  || nulloutfd == STDOUT_FILENO

+                  || dup2 (nulloutfd, STDOUT_FILENO) >= 0)

+              && (!null_stderr

+                  || nulloutfd == STDERR_FILENO

+                  || dup2 (nulloutfd, STDERR_FILENO) >= 0)

+              && ((null_stdout && nulloutfd == STDOUT_FILENO)

+                  || (null_stderr && nulloutfd == STDERR_FILENO)

+                  || close (nulloutfd) >= 0))))

+    /* Use spawnvpe and pass the environment explicitly.  This is needed if

+       the program has modified the environment using putenv() or [un]setenv().

+       On Windows, programs have two environments, one in the "environment

+       block" of the process and managed through SetEnvironmentVariable(), and

+       one inside the process, in the location retrieved by the 'environ'

+       macro.  When using spawnvp() without 'e', the child process inherits a

+       copy of the environment block - ignoring the effects of putenv() and

+       [un]setenv().  */

+    {

+      exitcode = spawnvpe (P_WAIT, prog_path, (const char **) prog_argv,

+                           (const char **) environ);

+      if (exitcode < 0 && errno == ENOEXEC)

+        {

+          /* prog is not a native executable.  Try to execute it as a

+             shell script.  Note that prepare_spawn() has already prepended

+             a hidden element "sh.exe" to prog_argv.  */

+          --prog_argv;

+          exitcode = spawnvpe (P_WAIT, prog_argv[0], (const char **) prog_argv,

+                               (const char **) environ);

+        }

+    }

+  if (nulloutfd >= 0)

+    close (nulloutfd);

+  if (nullinfd >= 0)

+    close (nullinfd);

+

+  /* Restore standard file handles of parent process.  */

+  if (null_stderr)

+    undup_safer_noinherit (orig_stderr, STDERR_FILENO);

+  if (null_stdout)

+    undup_safer_noinherit (orig_stdout, STDOUT_FILENO);

+  if (null_stdin)

+    undup_safer_noinherit (orig_stdin, STDIN_FILENO);

+

+  if (termsigp != NULL)

+    *termsigp = 0;

+

+  if (exitcode == -1)

+    {

+      if (exit_on_error || !null_stderr)

+        error (exit_on_error ? EXIT_FAILURE : 0, errno,

+               _("%s subprocess failed"), progname);

+      return 127;

+    }

+

+  return exitcode;

+

+#else

+

+  /* Unix API.  */

+  /* Note about 127: Some errors during posix_spawnp() cause the function

+     posix_spawnp() to return an error code; some other errors cause the

+     subprocess to exit with return code 127.  It is implementation

+     dependent which error is reported which way.  We treat both cases as

+     equivalent.  */

+  sigset_t blocked_signals;

+  posix_spawn_file_actions_t actions;

+  bool actions_allocated;

+  posix_spawnattr_t attrs;

+  bool attrs_allocated;

+  int err;

+  pid_t child;

+

+  if (slave_process)

+    {

+      sigprocmask (SIG_SETMASK, NULL, &blocked_signals);

+      block_fatal_signals ();

+    }

+  actions_allocated = false;

+  attrs_allocated = false;

+  if ((err = posix_spawn_file_actions_init (&actions)) != 0

+      || (actions_allocated = true,

+          (null_stdin

+            && (err = posix_spawn_file_actions_addopen (&actions,

+                                                        STDIN_FILENO,

+                                                        "/dev/null", O_RDONLY,

+                                                        0))

+               != 0)

+          || (null_stdout

+              && (err = posix_spawn_file_actions_addopen (&actions,

+                                                          STDOUT_FILENO,

+                                                          "/dev/null", O_RDWR,

+                                                          0))

+                 != 0)

+          || (null_stderr

+              && (err = posix_spawn_file_actions_addopen (&actions,

+                                                          STDERR_FILENO,

+                                                          "/dev/null", O_RDWR,

+                                                          0))

+                 != 0)

+          || (slave_process

+              && ((err = posix_spawnattr_init (&attrs)) != 0

+                  || (attrs_allocated = true,

+                      (err = posix_spawnattr_setsigmask (&attrs,

+                                                         &blocked_signals))

+                      != 0

+                      || (err = posix_spawnattr_setflags (&attrs,

+                                                        POSIX_SPAWN_SETSIGMASK))

+                         != 0)))

+          || (err = posix_spawnp (&child, prog_path, &actions,

+                                  attrs_allocated ? &attrs : NULL, prog_argv,

+                                  environ))

+             != 0))

+    {

+      if (actions_allocated)

+        posix_spawn_file_actions_destroy (&actions);

+      if (attrs_allocated)

+        posix_spawnattr_destroy (&attrs);

+      if (slave_process)

+        unblock_fatal_signals ();

+      if (termsigp != NULL)

+        *termsigp = 0;

+      if (exit_on_error || !null_stderr)

+        error (exit_on_error ? EXIT_FAILURE : 0, err,

+               _("%s subprocess failed"), progname);

+      return 127;

+    }

+  posix_spawn_file_actions_destroy (&actions);

+  if (attrs_allocated)

+    posix_spawnattr_destroy (&attrs);

+  if (slave_process)

+    {

+      register_slave_subprocess (child);

+      unblock_fatal_signals ();

+    }

+

+  return wait_subprocess (child, progname, ignore_sigpipe, null_stderr,

+                          slave_process, exit_on_error, termsigp);

+

+#endif

+}

diff -up patch-2.7.6/lib/execute.h.switch-from-fork-execlp-to-execute patch-2.7.6/lib/execute.h

--- patch-2.7.6/lib/execute.h.switch-from-fork-execlp-to-execute	2019-07-29 14:40:53.264464824 +0200

+++ patch-2.7.6/lib/execute.h	2019-07-29 14:40:53.264464824 +0200

@@ -0,0 +1,44 @@

+/* Creation of autonomous subprocesses.

+   Copyright (C) 2001-2003, 2008-2018 Free Software Foundation, Inc.

+   Written by Bruno Haible <haible@clisp.cons.org>, 2001.

+

+   This program is free software: you can redistribute it and/or modify

+   it under the terms of the GNU General Public License as published by

+   the Free Software Foundation; either version 3 of the License, or

+   (at your option) any later version.

+

+   This program 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/>.  */

+

+#ifndef _EXECUTE_H

+#define _EXECUTE_H

+

+#include <stdbool.h>

+

+/* Execute a command, optionally redirecting any of the three standard file

+   descriptors to /dev/null.  Return its exit code.

+   If it didn't terminate correctly, exit if exit_on_error is true, otherwise

+   return 127.

+   If ignore_sigpipe is true, consider a subprocess termination due to SIGPIPE

+   as equivalent to a success.  This is suitable for processes whose only

+   purpose is to write to standard output.

+   If slave_process is true, the child process will be terminated when its

+   creator receives a catchable fatal signal.

+   If termsigp is not NULL, *termsig will be set to the signal that terminated

+   the subprocess (if supported by the platform: not on native Windows

+   platforms), otherwise 0.

+   It is recommended that no signal is blocked or ignored while execute()

+   is called.  See pipe.h for the reason.  */

+extern int execute (const char *progname,

+                    const char *prog_path, char **prog_argv,

+                    bool ignore_sigpipe,

+                    bool null_stdin, bool null_stdout, bool null_stderr,

+                    bool slave_process, bool exit_on_error,

+                    int *termsigp);

+

+#endif /* _EXECUTE_H */

diff -up patch-2.7.6/lib/fatal-signal.c.switch-from-fork-execlp-to-execute patch-2.7.6/lib/fatal-signal.c

--- patch-2.7.6/lib/fatal-signal.c.switch-from-fork-execlp-to-execute	2019-07-29 14:51:00.441882754 +0200

+++ patch-2.7.6/lib/fatal-signal.c	2019-07-29 14:51:00.441882754 +0200

@@ -0,0 +1,286 @@

+/* Emergency actions in case of a fatal signal.

+   Copyright (C) 2003-2004, 2006-2018 Free Software Foundation, Inc.

+   Written by Bruno Haible <bruno@clisp.org>, 2003.

+

+   This program is free software: you can redistribute it and/or modify

+   it under the terms of the GNU General Public License as published by

+   the Free Software Foundation; either version 3 of the License, or

+   (at your option) any later version.

+

+   This program 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/>.  */

+

+

+#include <config.h>

+

+/* Specification.  */

+#include "fatal-signal.h"

+

+#include <stdbool.h>

+#include <stdlib.h>

+#include <signal.h>

+#include <unistd.h>

+

+#include "sig-handler.h"

+#include "xalloc.h"

+

+#define SIZEOF(a) (sizeof(a) / sizeof(a[0]))

+

+/* ========================================================================= */

+

+

+/* The list of fatal signals.

+   These are those signals whose default action is to terminate the process

+   without a core dump, except

+     SIGKILL - because it cannot be caught,

+     SIGALRM SIGUSR1 SIGUSR2 SIGPOLL SIGIO SIGLOST - because applications

+       often use them for their own purpose,

+     SIGPROF SIGVTALRM - because they are used for profiling,

+     SIGSTKFLT - because it is more similar to SIGFPE, SIGSEGV, SIGBUS,

+     SIGSYS - because it is more similar to SIGABRT, SIGSEGV,

+     SIGPWR - because it of too special use,

+     SIGRTMIN...SIGRTMAX - because they are reserved for application use.

+   plus

+     SIGXCPU, SIGXFSZ - because they are quite similar to SIGTERM.  */

+

+static int fatal_signals[] =

+  {

+    /* ISO C 99 signals.  */

+#ifdef SIGINT

+    SIGINT,

+#endif

+#ifdef SIGTERM

+    SIGTERM,

+#endif

+    /* POSIX:2001 signals.  */

+#ifdef SIGHUP

+    SIGHUP,

+#endif

+#ifdef SIGPIPE

+    SIGPIPE,

+#endif

+    /* BSD signals.  */

+#ifdef SIGXCPU

+    SIGXCPU,

+#endif

+#ifdef SIGXFSZ

+    SIGXFSZ,

+#endif

+    /* Native Windows signals.  */

+#ifdef SIGBREAK

+    SIGBREAK,

+#endif

+    0

+  };

+

+#define num_fatal_signals (SIZEOF (fatal_signals) - 1)

+

+/* Eliminate signals whose signal handler is SIG_IGN.  */

+

+static void

+init_fatal_signals (void)

+{

+  static bool fatal_signals_initialized = false;

+  if (!fatal_signals_initialized)

+    {

+      size_t i;

+

+      for (i = 0; i < num_fatal_signals; i++)

+        {

+          struct sigaction action;

+

+          if (sigaction (fatal_signals[i], NULL, &action) >= 0

+              && get_handler (&action) == SIG_IGN)

+            fatal_signals[i] = -1;

+        }

+

+      fatal_signals_initialized = true;

+    }

+}

+

+

+/* ========================================================================= */

+

+

+typedef void (*action_t) (void);

+

+/* Type of an entry in the actions array.

+   The 'action' field is accessed from within the fatal_signal_handler(),

+   therefore we mark it as 'volatile'.  */

+typedef struct

+{

+  volatile action_t action;

+}

+actions_entry_t;

+

+/* The registered cleanup actions.  */

+static actions_entry_t static_actions[32];

+static actions_entry_t * volatile actions = static_actions;

+static sig_atomic_t volatile actions_count = 0;

+static size_t actions_allocated = SIZEOF (static_actions);

+

+

+/* The saved signal handlers.

+   Size 32 would not be sufficient: On HP-UX, SIGXCPU = 33, SIGXFSZ = 34.  */

+static struct sigaction saved_sigactions[64];

+

+

+/* Uninstall the handlers.  */

+static void

+uninstall_handlers (void)

+{

+  size_t i;

+

+  for (i = 0; i < num_fatal_signals; i++)

+    if (fatal_signals[i] >= 0)

+      {

+        int sig = fatal_signals[i];

+        if (saved_sigactions[sig].sa_handler == SIG_IGN)

+          saved_sigactions[sig].sa_handler = SIG_DFL;

+        sigaction (sig, &saved_sigactions[sig], NULL);

+      }

+}

+

+

+/* The signal handler.  It gets called asynchronously.  */

+static void

+fatal_signal_handler (int sig)

+{

+  for (;;)

+    {

+      /* Get the last registered cleanup action, in a reentrant way.  */

+      action_t action;

+      size_t n = actions_count;

+      if (n == 0)

+        break;

+      n--;

+      actions_count = n;

+      action = actions[n].action;

+      /* Execute the action.  */

+      action ();

+    }

+

+  /* Now execute the signal's default action.

+     If the signal being delivered was blocked, the re-raised signal would be

+     delivered when this handler returns.  But the way we install this handler,

+     no signal is blocked, and the re-raised signal is delivered already

+     during raise().  */

+  uninstall_handlers ();

+  raise (sig);

+}

+

+

+/* Install the handlers.  */

+static void

+install_handlers (void)

+{

+  size_t i;

+  struct sigaction action;

+

+  action.sa_handler = &fatal_signal_handler;

+  /* If we get a fatal signal while executing fatal_signal_handler, enter

+     fatal_signal_handler recursively, since it is reentrant.  Hence no

+     SA_RESETHAND.  */

+  action.sa_flags = SA_NODEFER;

+  sigemptyset (&action.sa_mask);

+  for (i = 0; i < num_fatal_signals; i++)

+    if (fatal_signals[i] >= 0)

+      {

+        int sig = fatal_signals[i];

+

+        if (!(sig < sizeof (saved_sigactions) / sizeof (saved_sigactions[0])))

+          abort ();

+        sigaction (sig, &action, &saved_sigactions[sig]);

+      }

+}

+

+

+/* Register a cleanup function to be executed when a catchable fatal signal

+   occurs.  */

+void

+at_fatal_signal (action_t action)

+{

+  static bool cleanup_initialized = false;

+  if (!cleanup_initialized)

+    {

+      init_fatal_signals ();

+      install_handlers ();

+      cleanup_initialized = true;

+    }

+

+  if (actions_count == actions_allocated)

+    {

+      /* Extend the actions array.  Note that we cannot use xrealloc(),

+         because then the cleanup() function could access an already

+         deallocated array.  */

+      actions_entry_t *old_actions = actions;

+      size_t old_actions_allocated = actions_allocated;

+      size_t new_actions_allocated = 2 * actions_allocated;

+      actions_entry_t *new_actions =

+        XNMALLOC (new_actions_allocated, actions_entry_t);

+      size_t k;

+

+      /* Don't use memcpy() here, because memcpy takes non-volatile arguments

+         and is therefore not guaranteed to complete all memory stores before

+         the next statement.  */

+      for (k = 0; k < old_actions_allocated; k++)

+        new_actions[k] = old_actions[k];

+      actions = new_actions;

+      actions_allocated = new_actions_allocated;

+      /* Now we can free the old actions array.  */

+      if (old_actions != static_actions)

+        free (old_actions);

+    }

+  /* The two uses of 'volatile' in the types above (and ISO C 99 section

+     5.1.2.3.(5)) ensure that we increment the actions_count only after

+     the new action has been written to the memory location

+     actions[actions_count].  */

+  actions[actions_count].action = action;

+  actions_count++;

+}

+

+

+/* ========================================================================= */

+

+

+static sigset_t fatal_signal_set;

+

+static void

+init_fatal_signal_set (void)

+{

+  static bool fatal_signal_set_initialized = false;

+  if (!fatal_signal_set_initialized)

+    {

+      size_t i;

+

+      init_fatal_signals ();

+

+      sigemptyset (&fatal_signal_set);

+      for (i = 0; i < num_fatal_signals; i++)

+        if (fatal_signals[i] >= 0)

+          sigaddset (&fatal_signal_set, fatal_signals[i]);

+

+      fatal_signal_set_initialized = true;

+    }

+}

+

+/* Temporarily delay the catchable fatal signals.  */

+void

+block_fatal_signals (void)

+{

+  init_fatal_signal_set ();

+  sigprocmask (SIG_BLOCK, &fatal_signal_set, NULL);

+}

+

+/* Stop delaying the catchable fatal signals.  */

+void

+unblock_fatal_signals (void)

+{

+  init_fatal_signal_set ();

+  sigprocmask (SIG_UNBLOCK, &fatal_signal_set, NULL);

+}

diff -up patch-2.7.6/lib/fatal-signal.h.switch-from-fork-execlp-to-execute patch-2.7.6/lib/fatal-signal.h

--- patch-2.7.6/lib/fatal-signal.h.switch-from-fork-execlp-to-execute	2019-07-29 14:51:09.977920729 +0200

+++ patch-2.7.6/lib/fatal-signal.h	2019-07-29 14:51:09.977920729 +0200

@@ -0,0 +1,76 @@

+/* Emergency actions in case of a fatal signal.

+   Copyright (C) 2003-2004, 2009-2018 Free Software Foundation, Inc.

+   Written by Bruno Haible <bruno@clisp.org>, 2003.

+

+   This program is free software: you can redistribute it and/or modify

+   it under the terms of the GNU General Public License as published by

+   the Free Software Foundation; either version 3 of the License, or

+   (at your option) any later version.

+

+   This program 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/>.  */

+

+

+#ifdef __cplusplus

+extern "C" {

+#endif

+

+

+/* It is often useful to do some cleanup action when a usually fatal signal

+   terminates the process, like removing a temporary file or killing a

+   subprocess that may be stuck waiting for a device, pipe or network input.

+   Such signals are SIGHUP, SIGINT, SIGPIPE, SIGTERM, and possibly others.

+   The limitation of this facility is that it cannot work for SIGKILL.

+

+   Signals with a SIG_IGN handler are considered to be non-fatal.  The

+   functions in this file assume that when a SIG_IGN handler is installed

+   for a signal, it was installed before any functions in this file were

+   called and it stays so for the whole lifetime of the process.  */

+

+/* Register a cleanup function to be executed when a catchable fatal signal

+   occurs.

+

+   Restrictions for the cleanup function:

+     - The cleanup function can do all kinds of system calls.

+     - It can also access application dependent memory locations and data

+       structures provided they are in a consistent state. One way to ensure

+       this is through block_fatal_signals()/unblock_fatal_signals(), see

+       below.  Another - more tricky - way to ensure this is the careful use

+       of 'volatile'.

+   However,

+     - malloc() and similarly complex facilities are not safe to be called

+       because they are not guaranteed to be in a consistent state.

+     - Also, the cleanup function must not block the catchable fatal signals

+       and leave them blocked upon return.

+

+   The cleanup function is executed asynchronously.  It is unspecified

+   whether during its execution the catchable fatal signals are blocked

+   or not.  */

+extern void at_fatal_signal (void (*function) (void));

+

+

+/* Sometimes it is necessary to block the usually fatal signals while the

+   data structures being accessed by the cleanup action are being built or

+   reorganized.  This is the case, for example, when a temporary file or

+   directory is created through mkstemp() or mkdtemp(), because these

+   functions create the temporary file or directory _before_ returning its

+   name to the application.  */

+

+/* Temporarily delay the catchable fatal signals.

+   The signals will be blocked (= delayed) until the next call to

+   unblock_fatal_signals().  If the signals are already blocked, a further

+   call to block_fatal_signals() has no effect.  */

+extern void block_fatal_signals (void);

+

+/* Stop delaying the catchable fatal signals.  */

+extern void unblock_fatal_signals (void);

+

+

+#ifdef __cplusplus

+}

+#endif

diff -up patch-2.7.6/lib/gnulib.mk.switch-from-fork-execlp-to-execute patch-2.7.6/lib/gnulib.mk

--- patch-2.7.6/lib/gnulib.mk.switch-from-fork-execlp-to-execute	2018-02-03 14:31:15.000000000 +0100

+++ patch-2.7.6/lib/gnulib.mk	2019-07-29 14:49:33.437536285 +0200

@@ -21,7 +21,7 @@

 # the same distribution terms as the rest of that program.

 #

 # Generated by gnulib-tool.

-# Reproduce by: gnulib-tool --import --local-dir=gl --lib=libpatch --source-base=lib --m4-base=m4 --doc-base=doc --tests-base=tests --aux-dir=build-aux --makefile-name=gnulib.mk --no-conditional-dependencies --no-libtool --macro-prefix=gl argmatch backupfile clock-time diffseq dirname dup2 errno exitfail extensions faccessat fchmodat fchownat fcntl-h fstatat full-write getdate getopt-gnu gettime git-version-gen gitlog-to-changelog gnupload hash ignore-value intprops largefile linked-list maintainer-makefile malloc manywarnings memchr minmax mkdirat nstrftime openat progname quotearg readlinkat realloc renameat setenv signal size_max ssize_t stat-time stdbool stdlib symlinkat sys_stat tempname time unistd unlinkat update-copyright utimensat verror xalloc xlist xmemdup0

+# Reproduce by: gnulib-tool --import --local-dir=gl --lib=libpatch --source-base=lib --m4-base=m4 --doc-base=doc --tests-base=tests --aux-dir=build-aux --makefile-name=gnulib.mk --no-conditional-dependencies --no-libtool --macro-prefix=gl argmatch backupfile clock-time diffseq dirname dup2 errno execute exitfail extensions faccessat fchmodat fchownat fcntl-h fstatat full-write getdate getopt-gnu gettime git-version-gen gitlog-to-changelog gnupload hash ignore-value intprops largefile linked-list maintainer-makefile malloc manywarnings memchr minmax mkdirat nstrftime openat progname quotearg readlinkat realloc renameat setenv signal size_max ssize_t stat-time stdbool stdlib symlinkat sys_stat tempname time unistd unlinkat update-copyright utimensat verror xalloc xlist xmemdup0 wait-process fatal-signal

 MOSTLYCLEANFILES += core *.stackdump

@@ -378,6 +378,12 @@ EXTRA_libpatch_a_SOURCES += euidaccess.c

 ## end   gnulib module euidaccess

+## begin gnulib module execute

+

+libpatch_a_SOURCES += execute.h execute.c w32spawn.h

+

+## end   gnulib module execute

+