Locate engine names only at runtime and prefer GnuPG-2.
[gpgme.git] / src / posix-io.c
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 <http://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 #include <string.h>
27 #include <assert.h>
28 #include <errno.h>
29 #include <signal.h>
30 #include <fcntl.h>
31 #ifdef HAVE_UNISTD_H
32 # include <unistd.h>
33 #endif
34 #ifdef HAVE_SYS_TIME_H
35 # include <sys/time.h>
36 #endif
37 #ifdef HAVE_SYS_TYPES_H
38 # include <sys/types.h>
39 #endif
40 #include <sys/wait.h>
41 #ifdef HAVE_SYS_UIO_H
42 # include <sys/uio.h>
43 #endif
44 #include <ctype.h>
45 #include <sys/resource.h>
46
47 #include "util.h"
48 #include "priv-io.h"
49 #include "sema.h"
50 #include "ath.h"
51 #include "debug.h"
52
53 \f
54 void
55 _gpgme_io_subsystem_init (void)
56 {
57   struct sigaction act;
58
59   sigaction (SIGPIPE, NULL, &act);
60   if (act.sa_handler == SIG_DFL)
61     {
62       act.sa_handler = SIG_IGN;
63       sigemptyset (&act.sa_mask);
64       act.sa_flags = 0;
65       sigaction (SIGPIPE, &act, NULL);
66     }
67 }
68
69
70 /* Write the printable version of FD to the buffer BUF of length
71    BUFLEN.  The printable version is the representation on the command
72    line that the child process expects.  */
73 int
74 _gpgme_io_fd2str (char *buf, int buflen, int fd)
75 {
76   return snprintf (buf, buflen, "%d", fd);
77 }
78
79 \f
80 /* The table to hold notification handlers.  We use a linear search
81    and extend the table as needed.  */
82 struct notify_table_item_s
83 {
84   int fd;  /* -1 indicates an unused entry.  */
85   _gpgme_close_notify_handler_t handler;
86   void *value;
87 };
88 typedef struct notify_table_item_s *notify_table_item_t;
89
90 static notify_table_item_t notify_table;
91 static size_t notify_table_size;
92 DEFINE_STATIC_LOCK (notify_table_lock);
93
94
95 \f
96 int
97 _gpgme_io_read (int fd, void *buffer, size_t count)
98 {
99   int nread;
100   TRACE_BEG2 (DEBUG_SYSIO, "_gpgme_io_read", fd,
101               "buffer=%p, count=%u", buffer, count);
102
103   do
104     {
105       nread = _gpgme_ath_read (fd, buffer, count);
106     }
107   while (nread == -1 && errno == EINTR);
108
109   TRACE_LOGBUF (buffer, nread);
110   return TRACE_SYSRES (nread);
111 }
112
113
114 int
115 _gpgme_io_write (int fd, const void *buffer, size_t count)
116 {
117   int nwritten;
118   TRACE_BEG2 (DEBUG_SYSIO, "_gpgme_io_write", fd,
119               "buffer=%p, count=%u", buffer, count);
120   TRACE_LOGBUF (buffer, count);
121
122   do
123     {
124       nwritten = _gpgme_ath_write (fd, buffer, count);
125     }
126   while (nwritten == -1 && errno == EINTR);
127
128   return TRACE_SYSRES (nwritten);
129 }
130
131
132 int
133 _gpgme_io_pipe (int filedes[2], int inherit_idx)
134 {
135   int saved_errno;
136   int err;
137   TRACE_BEG2 (DEBUG_SYSIO, "_gpgme_io_pipe", filedes,
138               "inherit_idx=%i (GPGME uses it for %s)",
139               inherit_idx, inherit_idx ? "reading" : "writing");
140
141   err = pipe (filedes);
142   if (err < 0)
143     return TRACE_SYSRES (err);
144
145   /* FIXME: Should get the old flags first.  */
146   err = fcntl (filedes[1 - inherit_idx], F_SETFD, FD_CLOEXEC);
147   saved_errno = errno;
148   if (err < 0)
149     {
150       close (filedes[0]);
151       close (filedes[1]);
152     }
153   errno = saved_errno;
154   if (err)
155     return TRACE_SYSRES (err);
156
157   return TRACE_SUC2 ("read=0x%x, write=0x%x", filedes[0], filedes[1]);
158 }
159
160
161 int
162 _gpgme_io_close (int fd)
163 {
164   int res;
165   _gpgme_close_notify_handler_t handler = NULL;
166   void *handler_value;
167   int idx;
168
169   TRACE_BEG (DEBUG_SYSIO, "_gpgme_io_close", fd);
170
171   if (fd == -1)
172     {
173       errno = EINVAL;
174       return TRACE_SYSRES (-1);
175     }
176
177   /* First call the notify handler.  */
178   LOCK (notify_table_lock);
179   for (idx=0; idx < notify_table_size; idx++)
180     {
181       if (notify_table[idx].fd == fd)
182         {
183           handler       = notify_table[idx].handler;
184           handler_value = notify_table[idx].value;
185           notify_table[idx].handler = NULL;
186           notify_table[idx].value = NULL;
187           notify_table[idx].fd = -1; /* Mark slot as free.  */
188           break;
189         }
190     }
191   UNLOCK (notify_table_lock);
192   if (handler)
193     {
194       TRACE_LOG2 ("invoking close handler %p/%p", handler, handler_value);
195       handler (fd, handler_value);
196     }
197
198   /* Then do the close.  */
199   res = close (fd);
200   return TRACE_SYSRES (res);
201 }
202
203
204 int
205 _gpgme_io_set_close_notify (int fd, _gpgme_close_notify_handler_t handler,
206                             void *value)
207 {
208   int res = 0;
209   int idx;
210
211   TRACE_BEG2 (DEBUG_SYSIO, "_gpgme_io_set_close_notify", fd,
212               "close_handler=%p/%p", handler, value);
213
214   assert (fd != -1);
215
216   LOCK (notify_table_lock);
217   for (idx=0; idx < notify_table_size; idx++)
218     if (notify_table[idx].fd == -1)
219       break;
220   if (idx == notify_table_size)
221     {
222       /* We need to increase the size of the table.  The approach we
223          take is straightforward to minimize the risk of bugs.  */
224       notify_table_item_t newtbl;
225       size_t newsize = notify_table_size + 64;
226
227       newtbl = calloc (newsize, sizeof *newtbl);
228       if (!newtbl)
229         {
230           res = -1;
231           goto leave;
232         }
233       for (idx=0; idx < notify_table_size; idx++)
234         newtbl[idx] = notify_table[idx];
235       for (; idx < newsize; idx++)
236         {
237           newtbl[idx].fd = -1;
238           newtbl[idx].handler = NULL;
239           newtbl[idx].value = NULL;
240         }
241       free (notify_table);
242       notify_table = newtbl;
243       idx = notify_table_size;
244       notify_table_size = newsize;
245     }
246   notify_table[idx].fd = fd;
247   notify_table[idx].handler = handler;
248   notify_table[idx].value = value;
249
250  leave:
251   UNLOCK (notify_table_lock);
252
253   return TRACE_SYSRES (res);
254 }
255
256
257 int
258 _gpgme_io_set_nonblocking (int fd)
259 {
260   int flags;
261   int res;
262   TRACE_BEG (DEBUG_SYSIO, "_gpgme_io_set_nonblocking", fd);
263
264   flags = fcntl (fd, F_GETFL, 0);
265   if (flags == -1)
266     return TRACE_SYSRES (-1);
267   flags |= O_NONBLOCK;
268   res = fcntl (fd, F_SETFL, flags);
269   return TRACE_SYSRES (res);
270 }
271
272
273 static long int
274 get_max_fds (void)
275 {
276   char *source = NULL;
277   long int fds = -1;
278   int rc;
279
280 #ifdef RLIMIT_NOFILE
281   {
282     struct rlimit rl;
283     rc = getrlimit (RLIMIT_NOFILE, &rl);
284     if (rc == 0)
285       {
286         source = "RLIMIT_NOFILE";
287         fds = rl.rlim_max;
288       }
289   }
290 #endif
291 #ifdef RLIMIT_OFILE
292   if (fds == -1)
293     {
294       struct rlimit rl;
295       rc = getrlimit (RLIMIT_OFILE, &rl);
296       if (rc == 0)
297         {
298           source = "RLIMIT_OFILE";
299           fds = rl.rlim_max;
300         }
301     }
302 #endif
303 #ifdef _SC_OPEN_MAX
304   if (fds == -1)
305     {
306       long int scres;
307       scres = sysconf (_SC_OPEN_MAX);
308       if (scres >= 0)
309         {
310           source = "_SC_OPEN_MAX";
311           return scres;
312         }
313     }
314 #endif
315 #ifdef OPEN_MAX
316   if (fds == -1)
317     {
318       source = "OPEN_MAX";
319       fds = OPEN_MAX;
320     }
321 #endif
322
323 #if !defined(RLIMIT_NOFILE) && !defined(RLIMIT_OFILE) \
324   && !defined(_SC_OPEN_MAX) && !defined(OPEN_MAX)
325 #warning "No known way to get the maximum number of file descriptors."
326 #endif
327   if (fds == -1)
328     {
329       source = "arbitrary";
330       /* Arbitrary limit.  */
331       fds = 1024;
332     }
333
334   TRACE2 (DEBUG_SYSIO, "gpgme:max_fds", 0, "max fds=%i (%s)", fds, source);
335   return fds;
336 }
337
338
339 int
340 _gpgme_io_waitpid (int pid, int hang, int *r_status, int *r_signal)
341 {
342   int status;
343
344   *r_status = 0;
345   *r_signal = 0;
346   if (_gpgme_ath_waitpid (pid, &status, hang? 0 : WNOHANG) == pid)
347     {
348       if (WIFSIGNALED (status))
349         {
350           *r_status = 4; /* Need some value here.  */
351           *r_signal = WTERMSIG (status);
352         }
353       else if (WIFEXITED (status))
354         *r_status = WEXITSTATUS (status);
355       else
356         *r_status = 4; /* Oops.  */
357       return 1;
358     }
359   return 0;
360 }
361
362
363 /* Returns 0 on success, -1 on error.  */
364 int
365 _gpgme_io_spawn (const char *path, char *const argv[], unsigned int flags,
366                  struct spawn_fd_item_s *fd_list,
367                  void (*atfork) (void *opaque, int reserved),
368                  void *atforkvalue, pid_t *r_pid)
369 {
370   pid_t pid;
371   int i;
372   int status;
373   int signo;
374
375   (void)flags;
376
377   TRACE_BEG1 (DEBUG_SYSIO, "_gpgme_io_spawn", path,
378               "path=%s", path);
379   i = 0;
380   while (argv[i])
381     {
382       TRACE_LOG2 ("argv[%2i] = %s", i, argv[i]);
383       i++;
384     }
385   for (i = 0; fd_list[i].fd != -1; i++)
386     if (fd_list[i].dup_to == -1)
387       TRACE_LOG2 ("fd[%i] = 0x%x", i, fd_list[i].fd);
388     else
389       TRACE_LOG3 ("fd[%i] = 0x%x -> 0x%x", i, fd_list[i].fd, fd_list[i].dup_to);
390
391   pid = fork ();
392   if (pid == -1)
393     return TRACE_SYSRES (-1);
394
395   if (!pid)
396     {
397       /* Intermediate child to prevent zombie processes.  */
398       if ((pid = fork ()) == 0)
399         {
400           int max_fds = get_max_fds ();
401           int fd;
402
403           /* Child.  */
404           int seen_stdin = 0;
405           int seen_stderr = 0;
406
407           if (atfork)
408             atfork (atforkvalue, 0);
409
410           /* First close all fds which will not be inherited.  */
411           for (fd = 0; fd < max_fds; fd++)
412             {
413               for (i = 0; fd_list[i].fd != -1; i++)
414                 if (fd_list[i].fd == fd)
415                   break;
416               if (fd_list[i].fd == -1)
417                 close (fd);
418             }
419
420           /* And now dup and close those to be duplicated.  */
421           for (i = 0; fd_list[i].fd != -1; i++)
422             {
423               int child_fd;
424               int res;
425
426               if (fd_list[i].dup_to != -1)
427                 child_fd = fd_list[i].dup_to;
428               else
429                 child_fd = fd_list[i].fd;
430
431               if (child_fd == 0)
432                 seen_stdin = 1;
433               else if (child_fd == 2)
434                 seen_stderr = 1;
435
436               if (fd_list[i].dup_to == -1)
437                 continue;
438
439               res = dup2 (fd_list[i].fd, fd_list[i].dup_to);
440               if (res < 0)
441                 {
442 #if 0
443                   /* FIXME: The debug file descriptor is not
444                      dup'ed anyway, so we can't see this.  */
445                   TRACE_LOG1 ("dup2 failed in child: %s\n",
446                               strerror (errno));
447 #endif
448                   _exit (8);
449                 }
450
451               close (fd_list[i].fd);
452             }
453
454           if (! seen_stdin || ! seen_stderr)
455             {
456               fd = open ("/dev/null", O_RDWR);
457               if (fd == -1)
458                 {
459 #if 0
460                   /* FIXME: The debug file descriptor is not dup'ed
461                      anyway, so we can't see this.  */
462                   TRACE_LOG1 ("can't open `/dev/null': %s\n",
463                               strerror (errno));
464 #endif
465                   _exit (8);
466                 }
467               /* Make sure that the process has a connected stdin.  */
468               if (! seen_stdin && fd != 0)
469                 {
470                   if (dup2 (fd, 0) == -1)
471                     {
472 #if 0
473                   /* FIXME: The debug file descriptor is not dup'ed
474                      anyway, so we can't see this.  */
475                       TRACE_LOG1 ("dup2(/dev/null, 0) failed: %s\n",
476                                   strerror (errno));
477 #endif
478                       _exit (8);
479                     }
480                 }
481               if (! seen_stderr && fd != 2)
482                 if (dup2 (fd, 2) == -1)
483                   {
484 #if 0
485                     /* FIXME: The debug file descriptor is not dup'ed
486                        anyway, so we can't see this.  */
487                     TRACE_LOG1 ("dup2(dev/null, 2) failed: %s\n",
488                                 strerror (errno));
489 #endif
490                     _exit (8);
491                   }
492               if (fd != 0 && fd != 2)
493                 close (fd);
494             }
495
496           execv (path, (char *const *) argv);
497           /* Hmm: in that case we could write a special status code to the
498              status-pipe.  */
499 #if 0
500           /* FIXME: The debug file descriptor is not dup'ed anyway, so
501              we can't see this.  */
502           TRACE_LOG1 ("exec of `%s' failed\n", path);
503 #endif
504           _exit (8);
505           /* End child.  */
506         }
507       if (pid == -1)
508         _exit (1);
509       else
510         _exit (0);
511     }
512
513   TRACE_LOG1 ("waiting for child process pid=%i", pid);
514   _gpgme_io_waitpid (pid, 1, &status, &signo);
515   if (status)
516     return TRACE_SYSRES (-1);
517
518   for (i = 0; fd_list[i].fd != -1; i++)
519     {
520       if (! (flags & IOSPAWN_FLAG_NOCLOSE))
521         _gpgme_io_close (fd_list[i].fd);
522       /* No handle translation.  */
523       fd_list[i].peer_name = fd_list[i].fd;
524     }
525
526   if (r_pid)
527     *r_pid = pid;
528
529   return TRACE_SYSRES (0);
530 }
531
532
533 /* Select on the list of fds.  Returns: -1 = error, 0 = timeout or
534    nothing to select, > 0 = number of signaled fds.  */
535 int
536 _gpgme_io_select (struct io_select_fd_s *fds, size_t nfds, int nonblock)
537 {
538   fd_set readfds;
539   fd_set writefds;
540   unsigned int i;
541   int any;
542   int max_fd;
543   int n;
544   int count;
545   /* Use a 1s timeout.  */
546   struct timeval timeout = { 1, 0 };
547   void *dbg_help = NULL;
548   TRACE_BEG2 (DEBUG_SYSIO, "_gpgme_io_select", fds,
549               "nfds=%u, nonblock=%u", nfds, nonblock);
550
551   FD_ZERO (&readfds);
552   FD_ZERO (&writefds);
553   max_fd = 0;
554   if (nonblock)
555     timeout.tv_sec = 0;
556
557   TRACE_SEQ (dbg_help, "select on [ ");
558
559   any = 0;
560   for (i = 0; i < nfds; i++)
561     {
562       if (fds[i].fd == -1)
563         continue;
564       if (fds[i].for_read)
565         {
566           assert (!FD_ISSET (fds[i].fd, &readfds));
567           FD_SET (fds[i].fd, &readfds);
568           if (fds[i].fd > max_fd)
569             max_fd = fds[i].fd;
570           TRACE_ADD1 (dbg_help, "r0x%x ", fds[i].fd);
571           any = 1;
572         }
573       else if (fds[i].for_write)
574         {
575           assert (!FD_ISSET (fds[i].fd, &writefds));
576           FD_SET (fds[i].fd, &writefds);
577           if (fds[i].fd > max_fd)
578             max_fd = fds[i].fd;
579           TRACE_ADD1 (dbg_help, "w0x%x ", fds[i].fd);
580           any = 1;
581         }
582       fds[i].signaled = 0;
583     }
584   TRACE_END (dbg_help, "]");
585   if (!any)
586     return TRACE_SYSRES (0);
587
588   do
589     {
590       count = _gpgme_ath_select (max_fd + 1, &readfds, &writefds, NULL,
591                                  &timeout);
592     }
593   while (count < 0 && errno == EINTR);
594   if (count < 0)
595     return TRACE_SYSRES (-1);
596
597   TRACE_SEQ (dbg_help, "select OK [ ");
598   if (TRACE_ENABLED (dbg_help))
599     {
600       for (i = 0; i <= max_fd; i++)
601         {
602           if (FD_ISSET (i, &readfds))
603             TRACE_ADD1 (dbg_help, "r0x%x ", i);
604           if (FD_ISSET (i, &writefds))
605             TRACE_ADD1 (dbg_help, "w0x%x ", i);
606         }
607       TRACE_END (dbg_help, "]");
608     }
609
610   /* The variable N is used to optimize it a little bit.  */
611   for (n = count, i = 0; i < nfds && n; i++)
612     {
613       if (fds[i].fd == -1)
614         ;
615       else if (fds[i].for_read)
616         {
617           if (FD_ISSET (fds[i].fd, &readfds))
618             {
619               fds[i].signaled = 1;
620               n--;
621             }
622         }
623       else if (fds[i].for_write)
624         {
625           if (FD_ISSET (fds[i].fd, &writefds))
626             {
627               fds[i].signaled = 1;
628               n--;
629             }
630         }
631     }
632   return TRACE_SYSRES (count);
633 }
634
635 \f
636 int
637 _gpgme_io_recvmsg (int fd, struct msghdr *msg, int flags)
638 {
639   int nread;
640   int saved_errno;
641   struct iovec *iov;
642   TRACE_BEG2 (DEBUG_SYSIO, "_gpgme_io_recvmsg", fd,
643               "msg=%p, flags=%i", msg, flags);
644
645   nread = 0;
646   iov = msg->msg_iov;
647   while (iov < msg->msg_iov + msg->msg_iovlen)
648     {
649       nread += iov->iov_len;
650       iov++;
651     }
652
653   TRACE_LOG1 ("about to receive %d bytes", nread);
654
655   do
656     {
657       nread = _gpgme_ath_recvmsg (fd, msg, flags);
658     }
659   while (nread == -1 && errno == EINTR);
660   saved_errno = errno;
661   if (nread > 0)
662     {
663       int nr = nread;
664
665       iov = msg->msg_iov;
666       while (nr > 0)
667         {
668           int len = nr > iov->iov_len ? iov->iov_len : nr;
669           TRACE_LOGBUF (msg->msg_iov->iov_base, len);
670           iov++;
671           nr -= len;
672         }
673     }
674   errno = saved_errno;
675   return TRACE_SYSRES (nread);
676 }
677
678
679 int
680 _gpgme_io_sendmsg (int fd, const struct msghdr *msg, int flags)
681 {
682   int nwritten;
683   struct iovec *iov;
684   TRACE_BEG2 (DEBUG_SYSIO, "_gpgme_io_sendmsg", fd,
685               "msg=%p, flags=%i", msg, flags);
686
687   nwritten = 0;
688   iov = msg->msg_iov;
689   while (iov < msg->msg_iov + msg->msg_iovlen)
690     {
691       nwritten += iov->iov_len;
692       iov++;
693     }
694
695   TRACE_LOG1 ("about to receive %d bytes", nwritten);
696   iov = msg->msg_iov;
697   while (nwritten > 0)
698     {
699       int len = nwritten > iov->iov_len ? iov->iov_len : nwritten;
700       TRACE_LOGBUF (msg->msg_iov->iov_base, len);
701       iov++;
702       nwritten -= len;
703     }
704
705   do
706     {
707       nwritten = _gpgme_ath_sendmsg (fd, msg, flags);
708     }
709   while (nwritten == -1 && errno == EINTR);
710   return TRACE_SYSRES (nwritten);
711 }
712
713
714 int
715 _gpgme_io_dup (int fd)
716 {
717   int new_fd = dup (fd);
718
719   TRACE1 (DEBUG_SYSIO, "_gpgme_io_dup", fd, "new fd==%i", new_fd);
720
721   return new_fd;
722 }
723
724 \f
725 int
726 _gpgme_io_socket (int domain, int type, int proto)
727 {
728   int res;
729
730   TRACE_BEG2 (DEBUG_SYSIO, "_gpgme_io_socket", domain,
731               "type=%i, proto=%i", type, proto);
732
733   res = socket (domain, type, proto);
734
735   return TRACE_SYSRES (res);
736 }
737
738
739 int
740 _gpgme_io_connect (int fd, struct sockaddr *addr, int addrlen)
741 {
742   int res;
743
744   TRACE_BEG2 (DEBUG_SYSIO, "_gpgme_io_connect", fd,
745               "addr=%p, addrlen=%i", addr, addrlen);
746
747   res = ath_connect (fd, addr, addrlen);
748
749   return TRACE_SYSRES (res);
750 }