1  /* Auxiliary functions for the creation of subprocesses.  OS/2 kLIBC API.
       2     Copyright (C) 2001, 2003-2021 Free Software Foundation, Inc.
       3     Written by Bruno Haible <bruno@clisp.org>, 2003.
       4  
       5     This program is free software: you can redistribute it and/or modify
       6     it under the terms of the GNU General Public License as published by
       7     the Free Software Foundation; either version 3 of the License, or
       8     (at your option) any later version.
       9  
      10     This program is distributed in the hope that it will be useful,
      11     but WITHOUT ANY WARRANTY; without even the implied warranty of
      12     MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
      13     GNU General Public License for more details.
      14  
      15     You should have received a copy of the GNU General Public License
      16     along with this program.  If not, see <https://www.gnu.org/licenses/>.  */
      17  
      18  #include <config.h>
      19  
      20  /* Specification.  */
      21  #include "os2-spawn.h"
      22  
      23  /* Get _open_osfhandle().  */
      24  #include <io.h>
      25  
      26  #include <stdbool.h>
      27  #include <stdlib.h>
      28  #include <string.h>
      29  #include <unistd.h>
      30  #include <errno.h>
      31  
      32  #include "cloexec.h"
      33  #include "error.h"
      34  #include "gettext.h"
      35  
      36  #define _(str) gettext (str)
      37  
      38  
      39  /* Duplicates a file handle, making the copy uninheritable.
      40     Returns -1 for a file handle that is equivalent to closed.  */
      41  static int
      42  dup_noinherit (int fd)
      43  {
      44    fd = dup_cloexec (fd);
      45    if (fd < 0 && errno == EMFILE)
      46      error (EXIT_FAILURE, errno, _("_open_osfhandle failed"));
      47  
      48    return fd;
      49  }
      50  
      51  /* Returns a file descriptor equivalent to FD, except that the resulting file
      52     descriptor is none of STDIN_FILENO, STDOUT_FILENO, STDERR_FILENO.
      53     FD must be open and non-inheritable.  The result will be non-inheritable as
      54     well.
      55     If FD < 0, FD itself is returned.  */
      56  static int
      57  fd_safer_noinherit (int fd)
      58  {
      59    if (STDIN_FILENO <= fd && fd <= STDERR_FILENO)
      60      {
      61        /* The recursion depth is at most 3.  */
      62        int nfd = fd_safer_noinherit (dup_noinherit (fd));
      63        int saved_errno = errno;
      64        close (fd);
      65        errno = saved_errno;
      66        return nfd;
      67      }
      68    return fd;
      69  }
      70  
      71  int
      72  dup_safer_noinherit (int fd)
      73  {
      74    return fd_safer_noinherit (dup_noinherit (fd));
      75  }
      76  
      77  void
      78  undup_safer_noinherit (int tempfd, int origfd)
      79  {
      80    if (tempfd >= 0)
      81      {
      82        if (dup2 (tempfd, origfd) < 0)
      83          error (EXIT_FAILURE, errno, _("cannot restore fd %d: dup2 failed"),
      84                 origfd);
      85        close (tempfd);
      86      }
      87    else
      88      {
      89        /* origfd was closed or open to no handle at all.  Set it to a closed
      90           state.  This is (nearly) equivalent to the original state.  */
      91        close (origfd);
      92      }
      93  }
      94  
      95  const char **
      96  prepare_spawn (const char * const *argv, char **mem_to_free)
      97  {
      98    size_t argc;
      99    const char **new_argv;
     100    size_t i;
     101  
     102    /* Count number of arguments.  */
     103    for (argc = 0; argv[argc] != NULL; argc++)
     104      ;
     105  
     106    /* Allocate new argument vector.  */
     107    new_argv = (const char **) malloc ((1 + argc + 1) * sizeof (const char *));
     108    if (new_argv == NULL)
     109      return NULL;
     110  
     111    /* Add an element upfront that can be used when argv[0] turns out to be a
     112       script, not a program.
     113       On Unix, this would be "/bin/sh".  */
     114    new_argv[0] = "sh.exe";
     115  
     116    /* Put quoted arguments into the new argument vector.  */
     117    size_t needed_size = 0;
     118    for (i = 0; i < argc; i++)
     119      {
     120        const char *string = argv[i];
     121        const char *quoted_string = (string[0] == '\0' ? "\"\"" : string);
     122        size_t length = strlen (quoted_string);
     123        needed_size += length + 1;
     124      }
     125  
     126    char *mem;
     127    if (needed_size == 0)
     128      mem = NULL;
     129    else
     130      {
     131        mem = (char *) malloc (needed_size);
     132        if (mem == NULL)
     133          {
     134            /* Memory allocation failure.  */
     135            free (new_argv);
     136            errno = ENOMEM;
     137            return NULL;
     138          }
     139      }
     140    *mem_to_free = mem;
     141  
     142    for (i = 0; i < argc; i++)
     143      {
     144        const char *string = argv[i];
     145  
     146        new_argv[1 + i] = mem;
     147        const char *quoted_string = (string[0] == '\0' ? "\"\"" : string);
     148        size_t length = strlen (quoted_string);
     149        memcpy (mem, quoted_string, length + 1);
     150        mem += length + 1;
     151      }
     152    new_argv[1 + argc] = NULL;
     153  
     154    return new_argv;
     155  }