LCOV - code coverage report
Current view: top level - src - posix-io.c (source / functions) Hit Total Coverage
Test: coverage.info Lines: 290 346 83.8 %
Date: 2018-11-14 16:53:58 Functions: 17 17 100.0 %

          Line data    Source code
       1             : /* posix-io.c - Posix I/O functions
       2             :    Copyright (C) 2000 Werner Koch (dd9jn)
       3             :    Copyright (C) 2001, 2002, 2004, 2005, 2007, 2010 g10 Code GmbH
       4             : 
       5             :    This file is part of GPGME.
       6             : 
       7             :    GPGME is free software; you can redistribute it and/or modify it
       8             :    under the terms of the GNU Lesser General Public License as
       9             :    published by the Free Software Foundation; either version 2.1 of
      10             :    the License, or (at your option) any later version.
      11             : 
      12             :    GPGME is distributed in the hope that it will be useful, but
      13             :    WITHOUT ANY WARRANTY; without even the implied warranty of
      14             :    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
      15             :    Lesser General Public License for more details.
      16             : 
      17             :    You should have received a copy of the GNU Lesser General Public
      18             :    License along with this program; if not, see <https://www.gnu.org/licenses/>.
      19             :  */
      20             : 
      21             : #ifdef HAVE_CONFIG_H
      22             : #include <config.h>
      23             : #endif
      24             : #include <stdio.h>
      25             : #include <stdlib.h>
      26             : #ifdef HAVE_STDINT_H
      27             : # include <stdint.h>
      28             : #endif
      29             : #include <string.h>
      30             : #include <assert.h>
      31             : #include <errno.h>
      32             : #include <signal.h>
      33             : #include <fcntl.h>
      34             : #ifdef HAVE_UNISTD_H
      35             : # include <unistd.h>
      36             : #endif
      37             : #ifdef HAVE_SYS_TIME_H
      38             : # include <sys/time.h>
      39             : #endif
      40             : #ifdef HAVE_SYS_TYPES_H
      41             : # include <sys/types.h>
      42             : #endif
      43             : #include <sys/wait.h>
      44             : #ifdef HAVE_SYS_UIO_H
      45             : # include <sys/uio.h>
      46             : #endif
      47             : #include <ctype.h>
      48             : #include <sys/resource.h>
      49             : 
      50             : #ifdef USE_LINUX_GETDENTS
      51             : # include <sys/syscall.h>
      52             : # include <sys/types.h>
      53             : # include <dirent.h>
      54             : #endif /*USE_LINUX_GETDENTS*/
      55             : 
      56             : 
      57             : #include "util.h"
      58             : #include "priv-io.h"
      59             : #include "sema.h"
      60             : #include "ath.h"
      61             : #include "debug.h"
      62             : 
      63             : 
      64             : 
      65             : void
      66         100 : _gpgme_io_subsystem_init (void)
      67             : {
      68             :   struct sigaction act;
      69             : 
      70         100 :   sigaction (SIGPIPE, NULL, &act);
      71         100 :   if (act.sa_handler == SIG_DFL)
      72             :     {
      73          34 :       act.sa_handler = SIG_IGN;
      74          34 :       sigemptyset (&act.sa_mask);
      75          34 :       act.sa_flags = 0;
      76          34 :       sigaction (SIGPIPE, &act, NULL);
      77             :     }
      78         100 : }
      79             : 
      80             : 
      81             : /* Write the printable version of FD to the buffer BUF of length
      82             :    BUFLEN.  The printable version is the representation on the command
      83             :    line that the child process expects.  */
      84             : int
      85        1826 : _gpgme_io_fd2str (char *buf, int buflen, int fd)
      86             : {
      87        1826 :   return snprintf (buf, buflen, "%d", fd);
      88             : }
      89             : 
      90             : 
      91             : /* The table to hold notification handlers.  We use a linear search
      92             :    and extend the table as needed.  */
      93             : struct notify_table_item_s
      94             : {
      95             :   int fd;  /* -1 indicates an unused entry.  */
      96             :   _gpgme_close_notify_handler_t handler;
      97             :   void *value;
      98             : };
      99             : typedef struct notify_table_item_s *notify_table_item_t;
     100             : 
     101             : static notify_table_item_t notify_table;
     102             : static size_t notify_table_size;
     103             : DEFINE_STATIC_LOCK (notify_table_lock);
     104             : 
     105             : 
     106             : 
     107             : int
     108       10031 : _gpgme_io_read (int fd, void *buffer, size_t count)
     109             : {
     110             :   int nread;
     111       10031 :   TRACE_BEG2 (DEBUG_SYSIO, "_gpgme_io_read", fd,
     112             :               "buffer=%p, count=%u", buffer, count);
     113             : 
     114             :   do
     115             :     {
     116       10031 :       nread = _gpgme_ath_read (fd, buffer, count);
     117             :     }
     118       10033 :   while (nread == -1 && errno == EINTR);
     119             : 
     120       10033 :   TRACE_LOGBUFX (buffer, nread);
     121       10029 :   return TRACE_SYSRES (nread);
     122             : }
     123             : 
     124             : 
     125             : int
     126         734 : _gpgme_io_write (int fd, const void *buffer, size_t count)
     127             : {
     128             :   int nwritten;
     129         734 :   TRACE_BEG2 (DEBUG_SYSIO, "_gpgme_io_write", fd,
     130             :               "buffer=%p, count=%u", buffer, count);
     131         734 :   TRACE_LOGBUFX (buffer, count);
     132             : 
     133             :   do
     134             :     {
     135         734 :       nwritten = _gpgme_ath_write (fd, buffer, count);
     136             :     }
     137         733 :   while (nwritten == -1 && errno == EINTR);
     138             : 
     139         733 :   return TRACE_SYSRES (nwritten);
     140             : }
     141             : 
     142             : 
     143             : int
     144        3713 : _gpgme_io_pipe (int filedes[2], int inherit_idx)
     145             : {
     146             :   int saved_errno;
     147             :   int err;
     148        3713 :   TRACE_BEG2 (DEBUG_SYSIO, "_gpgme_io_pipe", filedes,
     149             :               "inherit_idx=%i (GPGME uses it for %s)",
     150             :               inherit_idx, inherit_idx ? "reading" : "writing");
     151             : 
     152        3711 :   err = pipe (filedes);
     153        3710 :   if (err < 0)
     154           0 :     return TRACE_SYSRES (err);
     155             : 
     156             :   /* FIXME: Should get the old flags first.  */
     157        3710 :   err = fcntl (filedes[1 - inherit_idx], F_SETFD, FD_CLOEXEC);
     158        3710 :   saved_errno = errno;
     159        3710 :   if (err < 0)
     160             :     {
     161           0 :       close (filedes[0]);
     162           0 :       close (filedes[1]);
     163             :     }
     164        3710 :   errno = saved_errno;
     165        3710 :   if (err)
     166           0 :     return TRACE_SYSRES (err);
     167             : 
     168        3710 :   return TRACE_SUC2 ("read=0x%x, write=0x%x", filedes[0], filedes[1]);
     169             : }
     170             : 
     171             : 
     172             : int
     173        7374 : _gpgme_io_close (int fd)
     174             : {
     175             :   int res;
     176        7374 :   _gpgme_close_notify_handler_t handler = NULL;
     177             :   void *handler_value;
     178             :   int idx;
     179             : 
     180        7374 :   TRACE_BEG (DEBUG_SYSIO, "_gpgme_io_close", fd);
     181             : 
     182        7374 :   if (fd == -1)
     183             :     {
     184           0 :       errno = EINVAL;
     185           0 :       return TRACE_SYSRES (-1);
     186             :     }
     187             : 
     188             :   /* First call the notify handler.  */
     189        7374 :   LOCK (notify_table_lock);
     190       65191 :   for (idx=0; idx < notify_table_size; idx++)
     191             :     {
     192       62549 :       if (notify_table[idx].fd == fd)
     193             :         {
     194        4731 :           handler       = notify_table[idx].handler;
     195        4731 :           handler_value = notify_table[idx].value;
     196        4731 :           notify_table[idx].handler = NULL;
     197        4731 :           notify_table[idx].value = NULL;
     198        4731 :           notify_table[idx].fd = -1; /* Mark slot as free.  */
     199        4731 :           break;
     200             :         }
     201             :     }
     202        7373 :   UNLOCK (notify_table_lock);
     203        7373 :   if (handler)
     204             :     {
     205        4731 :       TRACE_LOG2 ("invoking close handler %p/%p", handler, handler_value);
     206        4731 :       handler (fd, handler_value);
     207             :     }
     208             : 
     209             :   /* Then do the close.  */
     210        7372 :   res = close (fd);
     211        7372 :   return TRACE_SYSRES (res);
     212             : }
     213             : 
     214             : 
     215             : int
     216        4831 : _gpgme_io_set_close_notify (int fd, _gpgme_close_notify_handler_t handler,
     217             :                             void *value)
     218             : {
     219        4831 :   int res = 0;
     220             :   int idx;
     221             : 
     222        4831 :   TRACE_BEG2 (DEBUG_SYSIO, "_gpgme_io_set_close_notify", fd,
     223             :               "close_handler=%p/%p", handler, value);
     224             : 
     225        4833 :   assert (fd != -1);
     226             : 
     227        4833 :   LOCK (notify_table_lock);
     228       27257 :   for (idx=0; idx < notify_table_size; idx++)
     229       27168 :     if (notify_table[idx].fd == -1)
     230        4738 :       break;
     231        4827 :   if (idx == notify_table_size)
     232             :     {
     233             :       /* We need to increase the size of the table.  The approach we
     234             :          take is straightforward to minimize the risk of bugs.  */
     235             :       notify_table_item_t newtbl;
     236          90 :       size_t newsize = notify_table_size + 64;
     237             : 
     238          90 :       newtbl = calloc (newsize, sizeof *newtbl);
     239          90 :       if (!newtbl)
     240             :         {
     241           0 :           res = -1;
     242           0 :           goto leave;
     243             :         }
     244         154 :       for (idx=0; idx < notify_table_size; idx++)
     245          64 :         newtbl[idx] = notify_table[idx];
     246        5850 :       for (; idx < newsize; idx++)
     247             :         {
     248        5760 :           newtbl[idx].fd = -1;
     249        5760 :           newtbl[idx].handler = NULL;
     250        5760 :           newtbl[idx].value = NULL;
     251             :         }
     252          90 :       free (notify_table);
     253          90 :       notify_table = newtbl;
     254          90 :       idx = notify_table_size;
     255          90 :       notify_table_size = newsize;
     256             :     }
     257        4827 :   notify_table[idx].fd = fd;
     258        4827 :   notify_table[idx].handler = handler;
     259        4827 :   notify_table[idx].value = value;
     260             : 
     261             :  leave:
     262        4827 :   UNLOCK (notify_table_lock);
     263             : 
     264        4827 :   return TRACE_SYSRES (res);
     265             : }
     266             : 
     267             : 
     268             : int
     269         360 : _gpgme_io_set_nonblocking (int fd)
     270             : {
     271             :   int flags;
     272             :   int res;
     273         360 :   TRACE_BEG (DEBUG_SYSIO, "_gpgme_io_set_nonblocking", fd);
     274             : 
     275         360 :   flags = fcntl (fd, F_GETFL, 0);
     276         360 :   if (flags == -1)
     277           0 :     return TRACE_SYSRES (-1);
     278         360 :   flags |= O_NONBLOCK;
     279         360 :   res = fcntl (fd, F_SETFL, flags);
     280         360 :   return TRACE_SYSRES (res);
     281             : }
     282             : 
     283             : 
     284             : #ifdef USE_LINUX_GETDENTS
     285             : /* This is not declared in public headers; getdents64(2) says that we must
     286             :  * define it ourselves.  */
     287             : struct linux_dirent64
     288             : {
     289             :   ino64_t d_ino;
     290             :   off64_t d_off;
     291             :   unsigned short d_reclen;
     292             :   unsigned char d_type;
     293             :   char d_name[];
     294             : };
     295             : 
     296             : # define DIR_BUF_SIZE 1024
     297             : #endif /*USE_LINUX_GETDENTS*/
     298             : 
     299             : 
     300             : static long int
     301        1999 : get_max_fds (void)
     302             : {
     303        1999 :   const char *source = NULL;
     304        1999 :   long int fds = -1;
     305             :   int rc;
     306             : 
     307             :   /* Under Linux we can figure out the highest used file descriptor by
     308             :    * reading /proc/self/fd.  This is in the common cases much faster
     309             :    * than for example doing 4096 close calls where almost all of them
     310             :    * will fail.
     311             :    *
     312             :    * We can't use the normal opendir/readdir/closedir interface between
     313             :    * fork and exec in a multi-threaded process because opendir uses
     314             :    * malloc and thus a mutex which may deadlock with a malloc in another
     315             :    * thread.  However, the underlying getdents system call is safe.  */
     316             : #ifdef USE_LINUX_GETDENTS
     317             :   {
     318             :     int dir_fd;
     319             :     char dir_buf[DIR_BUF_SIZE];
     320             :     struct linux_dirent64 *dir_entry;
     321             :     int r, pos;
     322             :     const char *s;
     323             :     int x;
     324             : 
     325        1999 :     dir_fd = open ("/proc/self/fd", O_RDONLY | O_DIRECTORY);
     326        1999 :     if (dir_fd != -1)
     327             :       {
     328             :         for (;;)
     329             :           {
     330        6083 :             r = syscall(SYS_getdents64, dir_fd, dir_buf, DIR_BUF_SIZE);
     331        4041 :             if (r == -1)
     332             :               {
     333             :                 /* Fall back to other methods.  */
     334           0 :                 fds = -1;
     335           0 :                 break;
     336             :               }
     337        4041 :             if (r == 0)
     338        1999 :               break;
     339             : 
     340       25616 :             for (pos = 0; pos < r; pos += dir_entry->d_reclen)
     341             :               {
     342       23574 :                 dir_entry = (struct linux_dirent64 *) (dir_buf + pos);
     343       23574 :                 s = dir_entry->d_name;
     344       23574 :                 if (*s < '0' || *s > '9')
     345        3998 :                   continue;
     346             :                 /* atoi is not guaranteed to be async-signal-safe.  */
     347       43531 :                 for (x = 0; *s >= '0' && *s <= '9'; s++)
     348       23955 :                   x = x * 10 + (*s - '0');
     349       19576 :                 if (!*s && x > fds && x != dir_fd)
     350       17577 :                   fds = x;
     351             :               }
     352             :           }
     353             : 
     354        1999 :         close (dir_fd);
     355             :       }
     356        1999 :     if (fds != -1)
     357             :       {
     358        1999 :         fds++;
     359        1999 :         source = "/proc";
     360             :       }
     361             :     }
     362             : #endif /*USE_LINUX_GETDENTS*/
     363             : 
     364             : #ifdef RLIMIT_NOFILE
     365        1999 :   if (fds == -1)
     366             :     {
     367             :       struct rlimit rl;
     368           0 :       rc = getrlimit (RLIMIT_NOFILE, &rl);
     369           0 :       if (rc == 0)
     370             :         {
     371           0 :           source = "RLIMIT_NOFILE";
     372           0 :           fds = rl.rlim_max;
     373             :         }
     374             :     }
     375             : #endif
     376             : #ifdef RLIMIT_OFILE
     377        1999 :   if (fds == -1)
     378             :     {
     379             :       struct rlimit rl;
     380           0 :       rc = getrlimit (RLIMIT_OFILE, &rl);
     381           0 :       if (rc == 0)
     382             :         {
     383           0 :           source = "RLIMIT_OFILE";
     384           0 :           fds = rl.rlim_max;
     385             :         }
     386             :     }
     387             : #endif
     388             : #ifdef _SC_OPEN_MAX
     389        1999 :   if (fds == -1)
     390             :     {
     391             :       long int scres;
     392           0 :       scres = sysconf (_SC_OPEN_MAX);
     393           0 :       if (scres >= 0)
     394             :         {
     395           0 :           source = "_SC_OPEN_MAX";
     396           0 :           return scres;
     397             :         }
     398             :     }
     399             : #endif
     400             : #ifdef OPEN_MAX
     401             :   if (fds == -1)
     402             :     {
     403             :       source = "OPEN_MAX";
     404             :       fds = OPEN_MAX;
     405             :     }
     406             : #endif
     407             : 
     408             : #if !defined(RLIMIT_NOFILE) && !defined(RLIMIT_OFILE) \
     409             :   && !defined(_SC_OPEN_MAX) && !defined(OPEN_MAX)
     410             : #warning "No known way to get the maximum number of file descriptors."
     411             : #endif
     412        1999 :   if (fds == -1)
     413             :     {
     414           0 :       source = "arbitrary";
     415             :       /* Arbitrary limit.  */
     416           0 :       fds = 1024;
     417             :     }
     418             : 
     419             :   /* AIX returns INT32_MAX instead of a proper value.  We assume that
     420             :    * this is always an error and use a more reasonable limit.  */
     421             : #ifdef INT32_MAX
     422        1999 :   if (fds == INT32_MAX)
     423             :     {
     424           0 :       source = "aix-fix";
     425           0 :       fds = 1024;
     426             :     }
     427             : #endif
     428             : 
     429        1999 :   TRACE2 (DEBUG_SYSIO, "gpgme:max_fds", 0, "max fds=%i (%s)", fds, source);
     430        1999 :   return fds;
     431             : }
     432             : 
     433             : 
     434             : int
     435        1999 : _gpgme_io_waitpid (int pid, int hang, int *r_status, int *r_signal)
     436             : {
     437             :   int status;
     438             :   pid_t ret;
     439             : 
     440        1999 :   *r_status = 0;
     441        1999 :   *r_signal = 0;
     442             :   do
     443        1999 :     ret = _gpgme_ath_waitpid (pid, &status, hang? 0 : WNOHANG);
     444        1974 :   while (ret == (pid_t)(-1) && errno == EINTR);
     445             : 
     446        1974 :   if (ret == pid)
     447             :     {
     448        1974 :       if (WIFSIGNALED (status))
     449             :         {
     450           0 :           *r_status = 4; /* Need some value here.  */
     451           0 :           *r_signal = WTERMSIG (status);
     452             :         }
     453        1974 :       else if (WIFEXITED (status))
     454        1974 :         *r_status = WEXITSTATUS (status);
     455             :       else
     456           0 :         *r_status = 4; /* Oops.  */
     457        1974 :       return 1;
     458             :     }
     459           0 :   return 0;
     460             : }
     461             : 
     462             : 
     463             : /* Returns 0 on success, -1 on error.  */
     464             : int
     465        1985 : _gpgme_io_spawn (const char *path, char *const argv[], unsigned int flags,
     466             :                  struct spawn_fd_item_s *fd_list,
     467             :                  void (*atfork) (void *opaque, int reserved),
     468             :                  void *atforkvalue, pid_t *r_pid)
     469             : {
     470             :   pid_t pid;
     471             :   int i;
     472             :   int status;
     473             :   int signo;
     474             : 
     475        1985 :   TRACE_BEG1 (DEBUG_SYSIO, "_gpgme_io_spawn", path,
     476             :               "path=%s", path);
     477        1985 :   i = 0;
     478       25238 :   while (argv[i])
     479             :     {
     480       21268 :       TRACE_LOG2 ("argv[%2i] = %s", i, argv[i]);
     481       21268 :       i++;
     482             :     }
     483        5662 :   for (i = 0; fd_list[i].fd != -1; i++)
     484        3677 :     if (fd_list[i].dup_to == -1)
     485        1820 :       TRACE_LOG2 ("fd[%i] = 0x%x", i, fd_list[i].fd);
     486             :     else
     487        1857 :       TRACE_LOG3 ("fd[%i] = 0x%x -> 0x%x", i, fd_list[i].fd, fd_list[i].dup_to);
     488             : 
     489        1985 :   pid = fork ();
     490        3998 :   if (pid == -1)
     491           0 :     return TRACE_SYSRES (-1);
     492             : 
     493        3998 :   if (!pid)
     494             :     {
     495             :       /* Intermediate child to prevent zombie processes.  */
     496        1999 :       if ((pid = fork ()) == 0)
     497             :         {
     498             :           /* Child.  */
     499        1999 :           int max_fds = -1;
     500             :           int fd;
     501        1999 :           int seen_stdin = 0;
     502        1999 :           int seen_stdout = 0;
     503        1999 :           int seen_stderr = 0;
     504             : 
     505        1999 :           if (atfork)
     506           8 :             atfork (atforkvalue, 0);
     507             : 
     508             :           /* First close all fds which will not be inherited.  If we
     509             :            * have closefrom(2) we first figure out the highest fd we
     510             :            * do not want to close, then call closefrom, and on success
     511             :            * use the regular code to close all fds up to the start
     512             :            * point of closefrom.  Note that Solaris' and FreeBSD's closefrom do
     513             :            * not return errors.  */
     514             : #ifdef HAVE_CLOSEFROM
     515             :           {
     516             :             fd = -1;
     517             :             for (i = 0; fd_list[i].fd != -1; i++)
     518             :               if (fd_list[i].fd > fd)
     519             :                 fd = fd_list[i].fd;
     520             :             fd++;
     521             : #if defined(__sun) || defined(__FreeBSD__)
     522             :             closefrom (fd);
     523             :             max_fds = fd;
     524             : #else /*!__sun */
     525             :             while ((i = closefrom (fd)) && errno == EINTR)
     526             :               ;
     527             :             if (!i || errno == EBADF)
     528             :               max_fds = fd;
     529             : #endif /*!__sun*/
     530             :           }
     531             : #endif /*HAVE_CLOSEFROM*/
     532        1999 :           if (max_fds == -1)
     533        1999 :             max_fds = get_max_fds ();
     534       21176 :           for (fd = 0; fd < max_fds; fd++)
     535             :             {
     536       58965 :               for (i = 0; fd_list[i].fd != -1; i++)
     537       43516 :                 if (fd_list[i].fd == fd)
     538        3728 :                   break;
     539       19177 :               if (fd_list[i].fd == -1)
     540       15449 :                 close (fd);
     541             :             }
     542             : 
     543             :           /* And now dup and close those to be duplicated.  */
     544        5727 :           for (i = 0; fd_list[i].fd != -1; i++)
     545             :             {
     546             :               int child_fd;
     547             :               int res;
     548             : 
     549        3728 :               if (fd_list[i].dup_to != -1)
     550        1866 :                 child_fd = fd_list[i].dup_to;
     551             :               else
     552        1862 :                 child_fd = fd_list[i].fd;
     553             : 
     554        3728 :               if (child_fd == 0)
     555          42 :                 seen_stdin = 1;
     556        3686 :               else if (child_fd == 1)
     557        1782 :                 seen_stdout = 1;
     558        1904 :               else if (child_fd == 2)
     559          42 :                 seen_stderr = 1;
     560             : 
     561        3728 :               if (fd_list[i].dup_to == -1)
     562        1862 :                 continue;
     563             : 
     564        1866 :               res = dup2 (fd_list[i].fd, fd_list[i].dup_to);
     565        1866 :               if (res < 0)
     566             :                 {
     567             : #if 0
     568             :                   /* FIXME: The debug file descriptor is not
     569             :                      dup'ed anyway, so we can't see this.  */
     570             :                   TRACE_LOG1 ("dup2 failed in child: %s\n",
     571             :                               strerror (errno));
     572             : #endif
     573           0 :                   _exit (8);
     574             :                 }
     575             : 
     576        1866 :               close (fd_list[i].fd);
     577             :             }
     578             : 
     579        1999 :           if (! seen_stdin || ! seen_stdout || !seen_stderr)
     580             :             {
     581        1999 :               fd = open ("/dev/null", O_RDWR);
     582        1999 :               if (fd == -1)
     583             :                 {
     584             :                   /* The debug file descriptor is not dup'ed, so we
     585             :                      can't do a trace output.  */
     586           0 :                   _exit (8);
     587             :                 }
     588             :               /* Make sure that the process has connected stdin.  */
     589        1999 :               if (! seen_stdin && fd != 0)
     590             :                 {
     591           0 :                   if (dup2 (fd, 0) == -1)
     592           0 :                     _exit (8);
     593             :                 }
     594        1999 :               if (! seen_stdout && fd != 1)
     595             :                 {
     596         175 :                   if (dup2 (fd, 1) == -1)
     597           0 :                     _exit (8);
     598             :                 }
     599        1999 :               if (! seen_stderr && fd != 2)
     600             :                 {
     601        1957 :                   if (dup2 (fd, 2) == -1)
     602           0 :                     _exit (8);
     603             :                 }
     604        1999 :               if (fd != 0 && fd != 1 && fd != 2)
     605           0 :                 close (fd);
     606             :             }
     607             : 
     608        1999 :           execv (path, (char *const *) argv);
     609             :           /* Hmm: in that case we could write a special status code to the
     610             :              status-pipe.  */
     611        1999 :           _exit (8);
     612             :           /* End child.  */
     613             :         }
     614           0 :       if (pid == -1)
     615           0 :         _exit (1);
     616             :       else
     617           0 :         _exit (0);
     618             :     }
     619             : 
     620        1999 :   TRACE_LOG1 ("waiting for child process pid=%i", pid);
     621        1999 :   _gpgme_io_waitpid (pid, 1, &status, &signo);
     622        1974 :   if (status)
     623           0 :     return TRACE_SYSRES (-1);
     624             : 
     625        5612 :   for (i = 0; fd_list[i].fd != -1; i++)
     626             :     {
     627        3639 :       if (! (flags & IOSPAWN_FLAG_NOCLOSE))
     628        3631 :         _gpgme_io_close (fd_list[i].fd);
     629             :       /* No handle translation.  */
     630        3638 :       fd_list[i].peer_name = fd_list[i].fd;
     631             :     }
     632             : 
     633        1973 :   if (r_pid)
     634         719 :     *r_pid = pid;
     635             : 
     636        1973 :   return TRACE_SYSRES (0);
     637             : }
     638             : 
     639             : 
     640             : /* Select on the list of fds.  Returns: -1 = error, 0 = timeout or
     641             :    nothing to select, > 0 = number of signaled fds.  */
     642             : int
     643       16783 : _gpgme_io_select (struct io_select_fd_s *fds, size_t nfds, int nonblock)
     644             : {
     645             :   fd_set readfds;
     646             :   fd_set writefds;
     647             :   unsigned int i;
     648             :   int any;
     649             :   int max_fd;
     650             :   int n;
     651             :   int count;
     652             :   /* Use a 1s timeout.  */
     653       16783 :   struct timeval timeout = { 1, 0 };
     654       16783 :   void *dbg_help = NULL;
     655       16783 :   TRACE_BEG2 (DEBUG_SYSIO, "_gpgme_io_select", fds,
     656             :               "nfds=%u, nonblock=%u", nfds, nonblock);
     657             : 
     658       16783 :   FD_ZERO (&readfds);
     659       16784 :   FD_ZERO (&writefds);
     660       16784 :   max_fd = 0;
     661       16784 :   if (nonblock)
     662        9064 :     timeout.tv_sec = 0;
     663             : 
     664       16784 :   TRACE_SEQ (dbg_help, "select on [ ");
     665             : 
     666       16785 :   any = 0;
     667      103050 :   for (i = 0; i < nfds; i++)
     668             :     {
     669       86265 :       if (fds[i].fd == -1)
     670       56670 :         continue;
     671       29595 :       if (fds[i].for_read)
     672             :         {
     673       27666 :           if (fds[i].fd >= FD_SETSIZE)
     674             :             {
     675           0 :               TRACE_END (dbg_help, " -BAD- ]");
     676           0 :               gpg_err_set_errno (EMFILE);
     677           0 :               return TRACE_SYSRES (-1);
     678             :             }
     679       27666 :           assert (!FD_ISSET (fds[i].fd, &readfds));
     680       27666 :           FD_SET (fds[i].fd, &readfds);
     681       27666 :           if (fds[i].fd > max_fd)
     682       27633 :             max_fd = fds[i].fd;
     683       27666 :           TRACE_ADD1 (dbg_help, "r0x%x ", fds[i].fd);
     684       27666 :           any = 1;
     685             :         }
     686        1929 :       else if (fds[i].for_write)
     687             :         {
     688        1929 :           if (fds[i].fd >= FD_SETSIZE)
     689             :             {
     690           0 :               TRACE_END (dbg_help, " -BAD- ]");
     691           0 :               gpg_err_set_errno (EMFILE);
     692           0 :               return TRACE_SYSRES (-1);
     693             :             }
     694        1929 :           assert (!FD_ISSET (fds[i].fd, &writefds));
     695        1929 :           FD_SET (fds[i].fd, &writefds);
     696        1929 :           if (fds[i].fd > max_fd)
     697        1843 :             max_fd = fds[i].fd;
     698        1929 :           TRACE_ADD1 (dbg_help, "w0x%x ", fds[i].fd);
     699        1929 :           any = 1;
     700             :         }
     701       29595 :       fds[i].signaled = 0;
     702             :     }
     703       16785 :   TRACE_END (dbg_help, "]");
     704       16785 :   if (!any)
     705         333 :     return TRACE_SYSRES (0);
     706             : 
     707             :   do
     708             :     {
     709       16451 :       count = _gpgme_ath_select (max_fd + 1, &readfds, &writefds, NULL,
     710             :                                  &timeout);
     711             :     }
     712       16470 :   while (count < 0 && errno == EINTR);
     713       16471 :   if (count < 0)
     714           0 :     return TRACE_SYSRES (-1);
     715             : 
     716       16471 :   TRACE_SEQ (dbg_help, "select OK [ ");
     717       16471 :   if (TRACE_ENABLED (dbg_help))
     718             :     {
     719           0 :       for (i = 0; i <= max_fd; i++)
     720             :         {
     721           0 :           if (FD_ISSET (i, &readfds))
     722           0 :             TRACE_ADD1 (dbg_help, "r0x%x ", i);
     723           0 :           if (FD_ISSET (i, &writefds))
     724           0 :             TRACE_ADD1 (dbg_help, "w0x%x ", i);
     725             :         }
     726           0 :       TRACE_END (dbg_help, "]");
     727             :     }
     728             : 
     729             :   /* The variable N is used to optimize it a little bit.  */
     730       39366 :   for (n = count, i = 0; i < nfds && n; i++)
     731             :     {
     732       22898 :       if (fds[i].fd == -1)
     733             :         ;
     734       22638 :       else if (fds[i].for_read)
     735             :         {
     736       20716 :           if (FD_ISSET (fds[i].fd, &readfds))
     737             :             {
     738       16231 :               fds[i].signaled = 1;
     739       16231 :               n--;
     740             :             }
     741             :         }
     742        1922 :       else if (fds[i].for_write)
     743             :         {
     744        1922 :           if (FD_ISSET (fds[i].fd, &writefds))
     745             :             {
     746        1922 :               fds[i].signaled = 1;
     747        1922 :               n--;
     748             :             }
     749             :         }
     750             :     }
     751       16468 :   return TRACE_SYSRES (count);
     752             : }
     753             : 
     754             : 
     755             : int
     756         122 : _gpgme_io_recvmsg (int fd, struct msghdr *msg, int flags)
     757             : {
     758             :   int nread;
     759             :   int saved_errno;
     760             :   struct iovec *iov;
     761         122 :   TRACE_BEG2 (DEBUG_SYSIO, "_gpgme_io_recvmsg", fd,
     762             :               "msg=%p, flags=%i", msg, flags);
     763             : 
     764         122 :   nread = 0;
     765         122 :   iov = msg->msg_iov;
     766         366 :   while (iov < msg->msg_iov + msg->msg_iovlen)
     767             :     {
     768         122 :       nread += iov->iov_len;
     769         122 :       iov++;
     770             :     }
     771             : 
     772         122 :   TRACE_LOG1 ("about to receive %d bytes", nread);
     773             : 
     774             :   do
     775             :     {
     776         122 :       nread = _gpgme_ath_recvmsg (fd, msg, flags);
     777             :     }
     778         122 :   while (nread == -1 && errno == EINTR);
     779         122 :   saved_errno = errno;
     780         122 :   if (nread > 0)
     781             :     {
     782         122 :       int nr = nread;
     783             : 
     784         122 :       iov = msg->msg_iov;
     785         366 :       while (nr > 0)
     786             :         {
     787         122 :           int len = nr > iov->iov_len ? iov->iov_len : nr;
     788         122 :           TRACE_LOGBUFX (msg->msg_iov->iov_base, len);
     789         122 :           iov++;
     790         122 :           nr -= len;
     791             :         }
     792             :     }
     793         122 :   errno = saved_errno;
     794         122 :   return TRACE_SYSRES (nread);
     795             : }
     796             : 
     797             : 
     798             : int
     799         240 : _gpgme_io_sendmsg (int fd, const struct msghdr *msg, int flags)
     800             : {
     801             :   int nwritten;
     802             :   struct iovec *iov;
     803         240 :   TRACE_BEG2 (DEBUG_SYSIO, "_gpgme_io_sendmsg", fd,
     804             :               "msg=%p, flags=%i", msg, flags);
     805             : 
     806         240 :   nwritten = 0;
     807         240 :   iov = msg->msg_iov;
     808         720 :   while (iov < msg->msg_iov + msg->msg_iovlen)
     809             :     {
     810         240 :       nwritten += iov->iov_len;
     811         240 :       iov++;
     812             :     }
     813             : 
     814         240 :   TRACE_LOG1 ("about to receive %d bytes", nwritten);
     815         240 :   iov = msg->msg_iov;
     816         720 :   while (nwritten > 0)
     817             :     {
     818         240 :       int len = nwritten > iov->iov_len ? iov->iov_len : nwritten;
     819         240 :       TRACE_LOGBUFX (msg->msg_iov->iov_base, len);
     820         240 :       iov++;
     821         240 :       nwritten -= len;
     822             :     }
     823             : 
     824             :   do
     825             :     {
     826         240 :       nwritten = _gpgme_ath_sendmsg (fd, msg, flags);
     827             :     }
     828         240 :   while (nwritten == -1 && errno == EINTR);
     829         240 :   return TRACE_SYSRES (nwritten);
     830             : }
     831             : 
     832             : 
     833             : int
     834          30 : _gpgme_io_dup (int fd)
     835             : {
     836             :   int new_fd;
     837             : 
     838             :   do
     839          30 :     new_fd = dup (fd);
     840          30 :   while (new_fd == -1 && errno == EINTR);
     841             : 
     842          30 :   TRACE1 (DEBUG_SYSIO, "_gpgme_io_dup", fd, "new fd==%i", new_fd);
     843             : 
     844          30 :   return new_fd;
     845             : }
     846             : 
     847             : 
     848             : int
     849          14 : _gpgme_io_socket (int domain, int type, int proto)
     850             : {
     851             :   int res;
     852             : 
     853          14 :   TRACE_BEG2 (DEBUG_SYSIO, "_gpgme_io_socket", domain,
     854             :               "type=%i, proto=%i", type, proto);
     855             : 
     856          14 :   res = socket (domain, type, proto);
     857             : 
     858          14 :   return TRACE_SYSRES (res);
     859             : }
     860             : 
     861             : 
     862             : int
     863          14 : _gpgme_io_connect (int fd, struct sockaddr *addr, int addrlen)
     864             : {
     865             :   int res;
     866             : 
     867          14 :   TRACE_BEG2 (DEBUG_SYSIO, "_gpgme_io_connect", fd,
     868             :               "addr=%p, addrlen=%i", addr, addrlen);
     869             : 
     870             :   do
     871          14 :     res = ath_connect (fd, addr, addrlen);
     872          14 :   while (res == -1 && errno == EINTR);
     873             : 
     874          14 :   return TRACE_SYSRES (res);
     875             : }

Generated by: LCOV version 1.13