gpgme/posix-io.c

   1 /* posix-io.c - Posix I/O functions
   2  *      Copyright (C) 2000 Werner Koch (dd9jn)
   3  *
   4  * This file is part of GPGME.
   5  *
   6  * GPGME is free software; you can redistribute it and/or modify
   7  * it under the terms of the GNU General Public License as published by
   8  * the Free Software Foundation; either version 2 of the License, or
   9  * (at your option) any later version.
  10  *
  11  * GPGME is distributed in the hope that it will be useful,
  12  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  13  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  14  * GNU General Public License for more details.
  15  *
  16  * You should have received a copy of the GNU General Public License
  17  * along with this program; if not, write to the Free Software
  18  * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA
  19  */
  20
  21 #include <config.h>
  22 #ifndef HAVE_DOSISH_SYSTEM
  23
  24 #include <stdio.h>
  25 #include <stdlib.h>
  26 #include <string.h>
  27 #include <assert.h>
  28 #include <errno.h>
  29 #include <sys/time.h>
  30 #include <sys/types.h>
  31 #include <sys/wait.h>
  32 #include <signal.h>
  33 #include <fcntl.h>
  34 #include "syshdr.h"
  35
  36 #include "io.h"
  37
  38 #define DEBUG_SELECT_ENABLED 0
  39
  40 #if DEBUG_SELECT_ENABLED
  41 # define DEBUG_SELECT(a) fprintf a
  42 #else
  43 # define DEBUG_SELECT(a) do { } while(0)
  44 #endif
  45
  46
  47 int
  48 _gpgme_io_read ( int fd, void *buffer, size_t count )
  49 {
  50     int nread;
  51
  52     do {
  53         nread = read (fd, buffer, count);
  54     } while (nread == -1 && errno == EINTR );
  55     return nread;
  56 }
  57
  58
  59 int
  60 _gpgme_io_write ( int fd, const void *buffer, size_t count )
  61 {
  62     int nwritten;
  63
  64     do {
  65         nwritten = write (fd, buffer, count);
  66     } while (nwritten == -1 && errno == EINTR );
  67     return nwritten;
  68 }
  69
  70 int
  71 _gpgme_io_pipe ( int filedes[2], int inherit_idx )
  72 {
  73     /* we don't need inherit_idx in this implementation */
  74     return pipe ( filedes );
  75 }
  76
  77 int
  78 _gpgme_io_close ( int fd )
  79 {
  80     if ( fd == -1 )
  81         return -1;
  82     return close (fd);
  83 }
  84
  85 int
  86 _gpgme_io_set_nonblocking ( int fd )
  87 {
  88     int flags;
  89
  90     flags = fcntl (fd, F_GETFL, 0);
  91     if (flags == -1)
  92         return -1;
  93     flags |= O_NONBLOCK;
  94     return fcntl (fd, F_SETFL, flags);
  95 }
  96
  97
  98 int
  99 _gpgme_io_spawn ( const char *path, char **argv,
 100                   struct spawn_fd_item_s *fd_child_list,
 101                   struct spawn_fd_item_s *fd_parent_list )
 102 {
 103     static volatile int fixed_signals;
 104     pid_t pid;
 105     int i;
 106
 107     if ( !fixed_signals ) {
 108         struct sigaction act;
 109
 110         sigaction( SIGPIPE, NULL, &act );
 111         if( act.sa_handler == SIG_DFL ) {
 112             act.sa_handler = SIG_IGN;
 113             sigemptyset( &act.sa_mask );
 114             act.sa_flags = 0;
 115             sigaction( SIGPIPE, &act, NULL);
 116         }
 117         fixed_signals = 1;
 118         /* fixme: This is not really MT safe */
 119     }
 120
 121
 122     pid = fork ();
 123     if (pid == -1)
 124         return -1;
 125
 126     if ( !pid ) { /* child */
 127         int duped_stdin = 0;
 128         int duped_stderr = 0;
 129
 130         /* first close all fds which will not be duped */
 131         for (i=0; fd_child_list[i].fd != -1; i++ ) {
 132             if (fd_child_list[i].dup_to == -1 )
 133                 close (fd_child_list[i].fd);
 134         }
 135         /* and now dup and close the rest */
 136         for (i=0; fd_child_list[i].fd != -1; i++ ) {
 137             if (fd_child_list[i].dup_to != -1 ) {
 138                 if ( dup2 (fd_child_list[i].fd,
 139                            fd_child_list[i].dup_to ) == -1 ) {
 140                     fprintf (stderr, "dup2 failed in child: %s\n",
 141                              strerror (errno));
 142                     _exit (8);
 143                 }
 144                 if ( fd_child_list[i].dup_to == 0 )
 145                     duped_stdin=1;
 146                 if ( fd_child_list[i].dup_to == 2 )
 147                     duped_stderr=1;
 148                 close (fd_child_list[i].fd);
 149             }
 150         }
 151
 152         if( !duped_stdin || !duped_stderr ) {
 153             int fd = open ( "/dev/null", O_RDWR );
 154             if ( fd == -1 ) {
 155                 fprintf (stderr,"can't open `/dev/null': %s\n",
 156                          strerror (errno) );
 157                 _exit (8);
 158             }
 159             /* Make sure that the process has a connected stdin */
 160             if ( !duped_stdin ) {
 161                 if ( dup2 ( fd, 0 ) == -1 ) {
 162                     fprintf (stderr,"dup2(/dev/null, 0) failed: %s\n",
 163                              strerror (errno) );
 164                     _exit (8);
 165                 }
 166             }
 167             /* We normally don't want all the normal output */
 168             if ( !duped_stderr ) {
 169                 if (!getenv ("GPGME_DEBUG") ) {
 170                     if ( dup2 ( fd, 2 ) == -1 ) {
 171                         fprintf (stderr,"dup2(dev/null, 2) failed: %s\n",
 172                                  strerror (errno) );
 173                         _exit (8);
 174                     }
 175                 }
 176             }
 177             close (fd);
 178         }
 179
 180         execv ( path, argv );
 181         /* Hmm: in that case we could write a special status code to the
 182          * status-pipe */
 183         fprintf (stderr,"exec of `%s' failed\n", path );
 184         _exit (8);
 185     } /* end child */
 186
 187     /* .dup_to is not used in the parent list */
 188     for (i=0; fd_parent_list[i].fd != -1; i++ ) {
 189         close (fd_parent_list[i].fd);
 190     }
 191
 192     return (int)pid;
 193 }
 194
 195
 196 int
 197 _gpgme_io_waitpid ( int pid, int hang, int *r_status, int *r_signal )
 198 {
 199     int status;
 200
 201     *r_status = 0;
 202     *r_signal = 0;
 203     if ( waitpid ( pid, &status, hang? 0 : WNOHANG ) == pid ) {
 204         if ( WIFSIGNALED (status) ) {
 205             *r_status = 4; /* Need some value here */
 206             *r_signal = WTERMSIG (status);
 207         }
 208         else if ( WIFEXITED (status) ) {
 209             *r_status = WEXITSTATUS (status);
 210         }
 211         else {
 212             *r_status = 4; /* oops */
 213         }
 214         return 1;
 215     }
 216     return 0;
 217 }
 218
 219
 220 /*
 221  * Select on the list of fds.
 222  * Returns: -1 = error
 223  *           0 = timeout or nothing to select
 224  *          >0 = number of signaled fds
 225  */
 226 int
 227 _gpgme_io_select ( struct io_select_fd_s *fds, size_t nfds )
 228 {
 229     static fd_set readfds;
 230     static fd_set writefds;
 231     int any, i, max_fd, n, count;
 232     struct timeval timeout = { 1, 0 }; /* Use a one second timeout */
 233
 234     FD_ZERO ( &readfds );
 235     FD_ZERO ( &writefds );
 236     max_fd = 0;
 237
 238     DEBUG_SELECT ((stderr, "gpgme:select on [ "));
 239     any = 0;
 240     for ( i=0; i < nfds; i++ ) {
 241         if ( fds[i].fd == -1 )
 242             continue;
 243         if ( fds[i].for_read ) {
 244             assert ( !FD_ISSET ( fds[i].fd, &readfds ) );
 245             FD_SET ( fds[i].fd, &readfds );
 246             if ( fds[i].fd > max_fd )
 247                 max_fd = fds[i].fd;
 248             DEBUG_SELECT ((stderr, "r%d ", fds[i].fd ));
 249             any = 1;
 250         }
 251         else if ( fds[i].for_write ) {
 252             assert ( !FD_ISSET ( fds[i].fd, &writefds ) );
 253             FD_SET ( fds[i].fd, &writefds );
 254             if ( fds[i].fd > max_fd )
 255                 max_fd = fds[i].fd;
 256             DEBUG_SELECT ((stderr, "w%d ", fds[i].fd ));
 257             any = 1;
 258         }
 259         fds[i].signaled = 0;
 260     }
 261     DEBUG_SELECT ((stderr, "]\n" ));
 262     if ( !any )
 263         return 0;
 264
 265     do {
 266         count = select ( max_fd+1, &readfds, &writefds, NULL, &timeout );
 267     } while ( count < 0 && errno == EINTR);
 268     if ( count < 0 ) {
 269         fprintf (stderr, "_gpgme_io_select failed: %s\n", strerror (errno) );
 270         return -1; /* error */
 271     }
 272
 273 #if DEBUG_SELECT_ENABLED
 274     fprintf (stderr, "gpgme:select OK [ " );
 275     for (i=0; i <= max_fd; i++ ) {
 276         if (FD_ISSET (i, &readfds) )
 277             fprintf (stderr, "r%d ", i );
 278         if (FD_ISSET (i, &writefds) )
 279             fprintf (stderr, "w%d ", i );
 280     }
 281     fprintf (stderr, "]\n" );
 282 #endif
 283
 284     /* n is used to optimize it a little bit */
 285     for ( n=count, i=0; i < nfds && n ; i++ ) {
 286         if ( fds[i].fd == -1 )
 287             ;
 288         else if ( fds[i].for_read ) {
 289             if ( FD_ISSET ( fds[i].fd, &readfds ) ) {
 290                 fds[i].signaled = 1;
 291                 n--;
 292             }
 293         }
 294         else if ( fds[i].for_write ) {
 295             if ( FD_ISSET ( fds[i].fd, &writefds ) ) {
 296                 fds[i].signaled = 1;
 297                 n--;
 298             }
 299         }
 300     }
 301     return count;
 302 }
 303
 304
 305 #endif /*!HAVE_DOSISH_SYSTEM*/
 306
 307
 308