2007-07-13 Marcus Brinkmann <marcus@g10code.de>
[gpgme.git] / gpgme / w32-glib-io.c
index 0867b04..8f56eee 100644 (file)
@@ -32,6 +32,7 @@
 #include <unistd.h>
 #include <sys/time.h>
 #include <sys/types.h>
+#include <glib.h>
 #include <windows.h>
 #include <io.h>
 
 #include "sema.h"
 #include "debug.h"
 
-#include <glib.h>
+#ifndef O_BINARY
+#ifdef _O_BINARY
+#define O_BINARY       _O_BINARY
+#else
+#define O_BINARY       0
+#endif
+#endif
 
 \f
-static GIOChannel *giochannel_table[256];
+/* This file is an ugly hack to get GPGME working with glib on Windows
+   targets.  On Windows, you can not select() on file descriptors.
+   The only way to check if there is something to read is to read
+   something.  This means that GPGME can not let glib check for data
+   without letting glib also handle the data on Windows targets.
+
+   The ugly consequence is that we need to work on GIOChannels in
+   GPGME, creating a glib dependency.  Also, we need to export an
+   interface for the application to get at GPGME's GIOChannel.  There
+   is no good way to abstract all this with callbacks, because the
+   whole thing is also interconnected with the creation of pipes and
+   child processes.
+
+   The following rule applies only to this I/O backend:
+
+   * ALL operations must use the user defined event loop.  GPGME can
+   not anymore provide its own event loop.  This is mostly a sanity
+   requirement: Although we have in theory all information we need to
+   make the GPGME W32 code for select still work, it would be a big
+   complication and require changes throughout GPGME.
+
+   Eventually, we probably have to bite the bullet and make some
+   really nice callback interfaces to let the user control all this at
+   a per-context level.  */
+
+\f
+#define MAX_SLAFD 256
+
+GIOChannel *giochannel_table[MAX_SLAFD];
 
-static HANDLE handle_table[256];
-#define fd_to_handle(x) handle_table[x]
 
 static GIOChannel *
 find_channel (int fd, int create)
 {
-  if (fd < 0 || fd > (int) DIM (giochannel_table))
+  if (fd < 0 || fd >= MAX_SLAFD)
     return NULL;
 
-  if (giochannel_table[fd] == NULL && create)
-    giochannel_table[fd] = g_io_channel_unix_new (fd);
+  if (create && !giochannel_table[fd])
+    {
+      giochannel_table[fd] = g_io_channel_win32_new_fd (fd);
+      g_io_channel_set_encoding (giochannel_table[fd], NULL, NULL);
+      g_io_channel_set_buffered (giochannel_table[fd], FALSE);
+    }
 
   return giochannel_table[fd];
 }
 
-
-/* Look up the giochannel for file descriptor FD.  */
+/* Look up the giochannel for "file descriptor" FD.  */
 GIOChannel *
 gpgme_get_giochannel (int fd)
 {
   return find_channel (fd, 0);
 }
 
+
+/* Write the printable version of FD to the buffer BUF of length
+   BUFLEN.  The printable version is the representation on the command
+   line that the child process expects.  */
+int
+_gpgme_io_fd2str (char *buf, int buflen, int fd)
+{
+  return snprintf (buf, buflen, "%ld", (long) _get_osfhandle (fd));
+}
+
 \f
 void
 _gpgme_io_subsystem_init (void)
@@ -77,9 +123,10 @@ _gpgme_io_subsystem_init (void)
 \f
 static struct
 {
-  void (*handler) (int,void*);
+  _gpgme_close_notify_handler_t handler;
   void *value;
-} notify_table[256];
+} notify_table[MAX_SLAFD];
+
 
 int
 _gpgme_io_read (int fd, void *buffer, size_t count)
@@ -98,13 +145,24 @@ _gpgme_io_read (int fd, void *buffer, size_t count)
       errno = EINVAL;
       return -1;
     }
+  DEBUG2 ("fd %d: channel %p\n", fd, chan);
+
+  {
+    GError *err = NULL;
+    status = g_io_channel_read_chars (chan, (gchar *) buffer,
+                                     count, &nread, &err);
+    if (err)
+      {
+       DEBUG3 ("fd %d: status %i, err %s\n", fd, status, err->message);
+       g_error_free (err);
+      }
+  }
 
-  status = g_io_channel_read_chars (chan, (gchar *) buffer,
-                                   count, &nread, NULL);
   if (status == G_IO_STATUS_EOF)
     nread = 0;
   else if (status != G_IO_STATUS_NORMAL)
     {
+      DEBUG2 ("fd %d: status %d\n", fd, status);
       nread = -1;
       saved_errno = EIO;
     }
@@ -151,96 +209,61 @@ _gpgme_io_write (int fd, const void *buffer, size_t count)
 
 
 int
-_gpgme_io_pipe ( int filedes[2], int inherit_idx )
+_gpgme_io_pipe (int filedes[2], int inherit_idx)
 {
-    HANDLE r, w;
-    SECURITY_ATTRIBUTES sec_attr;
+  GIOChannel *chan;
 
-    memset (&sec_attr, 0, sizeof sec_attr );
-    sec_attr.nLength = sizeof sec_attr;
-    sec_attr.bInheritHandle = FALSE;
-    
 #define PIPEBUF_SIZE  4096
-    if (!CreatePipe ( &r, &w, &sec_attr, PIPEBUF_SIZE))
-        return -1;
-    /* Make one end inheritable. */
-    if ( inherit_idx == 0 ) {
-        HANDLE h;
-        if (!DuplicateHandle( GetCurrentProcess(), r,
-                              GetCurrentProcess(), &h, 0,
-                              TRUE, DUPLICATE_SAME_ACCESS ) ) {
-            DEBUG1 ("DuplicateHandle failed: ec=%d\n", (int)GetLastError());
-            CloseHandle (r);
-            CloseHandle (w);
-            return -1;
-        }
-        CloseHandle (r);
-        r = h;
-    }
-    else if ( inherit_idx == 1 ) {
-        HANDLE h;
-        if (!DuplicateHandle( GetCurrentProcess(), w,
-                              GetCurrentProcess(), &h, 0,
-                              TRUE, DUPLICATE_SAME_ACCESS ) ) {
-            DEBUG1 ("DuplicateHandle failed: ec=%d\n", (int)GetLastError());
-            CloseHandle (r);
-            CloseHandle (w);
-            return -1;
-        }
-        CloseHandle (w);
-        w = h;
+  if (_pipe (filedes, PIPEBUF_SIZE, O_NOINHERIT | O_BINARY) == -1)
+    return -1;
+
+  /* Make one end inheritable. */
+  if (inherit_idx == 0)
+    {
+      int new_read;
+
+      new_read = _dup (filedes[0]);
+      _close (filedes[0]);
+      filedes[0] = new_read;
+
+      if (new_read < 0)
+       {
+         _close (filedes[1]);
+         return -1;
+       }
     }
-    filedes[0] = _open_osfhandle ((long) r, 0 );
-    if (filedes[0] == -1)
-      {
-       DEBUG1 ("_open_osfhandle failed: ec=%d\n", errno);
-       CloseHandle (r);
-       CloseHandle (w);
-       return -1;
-      }
-    filedes[1] = _open_osfhandle ((long) w, 0 );
-      {
-       DEBUG1 ("_open_osfhandle failed: ec=%d\n", errno);
-       _gpgme_io_close (filedes[0]);
-       CloseHandle (r);
-       CloseHandle (w);
-       return -1;
-      }
+  else if (inherit_idx == 1)
+    {
+      int new_write;
 
-    /* The fd that is not inherited will be used locally.  Create a
-       channel for it.  */
-    if (inherit_idx == 0)
-      {
-       if (!find_channel (filedes[1], 1))
-         {
-           DEBUG1 ("channel creation failed for %d\n", filedes[1]);
-           _gpgme_io_close (filedes[0]);
-           _gpgme_io_close (filedes[1]);
-           CloseHandle (r);
-           CloseHandle (w);
-           return -1;
-         }
-      }
-    else
-      {
-       if (!find_channel (filedes[0], 1))
-         {
-           DEBUG1 ("channel creation failed for %d\n", filedes[1]);
-           _gpgme_io_close (filedes[0]);
-           _gpgme_io_close (filedes[1]);
-           CloseHandle (r);
-           CloseHandle (w);
-           return -1;
-         }
-      }
+      new_write = _dup (filedes[1]);
+      _close (filedes[1]);
+      filedes[1] = new_write;
 
-    /* Remember the handles for later.  */
-    handle_table[filedes[0]] = r;
-    handle_table[filedes[1]] = w;
+      if (new_write < 0)
+       {
+         _close (filedes[0]);
+         return -1;
+       }
+    }
 
-    DEBUG5 ("CreatePipe %p %p %d %d inherit=%d\n", r, w,
-                   filedes[0], filedes[1], inherit_idx );
-    return 0;
+  /* Now we have a pipe with the right end inheritable.  The other end
+     should have a giochannel.  */
+  chan = find_channel (filedes[1 - inherit_idx], 1);
+  if (!chan)
+    {
+      DEBUG2 ("channel creation for %d failed: ec=%d\n",
+             filedes[1 - inherit_idx], errno);
+      _close (filedes[0]);
+      _close (filedes[1]);
+      return -1;
+    }
+
+  DEBUG5 ("CreatePipe %d (%p) %d (%p) inherit=%p\n",
+         filedes[0], (HANDLE) _get_osfhandle (filedes[0]),
+         filedes[1], (HANDLE) _get_osfhandle (filedes[1]),
+         chan);
+  return 0;
 }
 
 
@@ -249,36 +272,39 @@ _gpgme_io_close (int fd)
 {
   GIOChannel *chan;
 
-  if (fd == -1)
-    return -1;
+  if (fd < 0 || fd >= MAX_SLAFD)
+    {
+      errno = EBADF;
+      return -1;
+    }
 
   /* First call the notify handler.  */
   DEBUG1 ("closing fd %d", fd);
-  if (fd >= 0 && fd < (int) DIM (notify_table))
+  if (notify_table[fd].handler)
     {
-      if (notify_table[fd].handler)
-       {
-         notify_table[fd].handler (fd, notify_table[fd].value);
-         notify_table[fd].handler = NULL;
-         notify_table[fd].value = NULL;
-        }
+      notify_table[fd].handler (fd, notify_table[fd].value);
+      notify_table[fd].handler = NULL;
+      notify_table[fd].value = NULL;
     }
+
   /* Then do the close.  */    
-  chan = find_channel (fd, 0);
+  chan = giochannel_table[fd];
   if (chan)
     {
       g_io_channel_shutdown (chan, 1, NULL);
       g_io_channel_unref (chan);
       giochannel_table[fd] = NULL;
-      return 0;
     }
   else
-    return close (fd);
+    _close (fd);
+
+  return 0;
 }
 
 
 int
-_gpgme_io_set_close_notify (int fd, void (*handler)(int, void*), void *value)
+_gpgme_io_set_close_notify (int fd, _gpgme_close_notify_handler_t handler,
+                           void *value)
 {
   assert (fd != -1);
 
@@ -296,21 +322,25 @@ _gpgme_io_set_nonblocking (int fd)
 {
   GIOChannel *chan;
   GIOStatus status;
-
   chan = find_channel (fd, 0);
   if (!chan)
     {
+      DEBUG1 ("set nonblocking for fd %d failed: channel not found", fd);
       errno = EIO;
       return -1;
     }
 
-  status = g_io_channel_set_flags (chan,
+   status = g_io_channel_set_flags (chan,
                                   g_io_channel_get_flags (chan) |
                                   G_IO_FLAG_NONBLOCK, NULL);
   if (status != G_IO_STATUS_NORMAL)
     {
-      errno = EIO;
-      return -1;
+      /* glib 1.9.2 does not implement set_flags and returns an error. */
+      DEBUG2 ("set nonblocking for fd %d failed: status=%d - ignored",
+              fd, status);
+/*       errno = EIO; */
+/*       return -1; */
     }
 
   return 0;
@@ -318,37 +348,57 @@ _gpgme_io_set_nonblocking (int fd)
 
 
 static char *
-build_commandline ( char **argv )
+build_commandline (char **argv)
 {
-  int i, n = 0;
-  char *buf, *p;
+  int i;
+  int j;
+  int n = 0;
+  char *buf;
+  char *p;
   
-  /* FIXME: we have to quote some things because under Windows the
-   * program parses the commandline and does some unquoting.  For now
-   * we only do very basic quoting to the first argument because this
-   * one often contains a space (e.g. C:\\Program Files\GNU\GnuPG\gpg.exe) 
-   * and we would produce an invalid line in that case.  */
-  for (i=0; argv[i]; i++)
-    n += strlen (argv[i]) + 2 + 1; /* 2 extra bytes for possible quoting */
+  /* We have to quote some things because under Windows the program
+     parses the commandline and does some unquoting.  We enclose the
+     whole argument in double-quotes, and escape literal double-quotes
+     as well as backslashes with a backslash.  We end up with a
+     trailing space at the end of the line, but that is harmless.  */
+  for (i = 0; argv[i]; i++)
+    {
+      p = argv[i];
+      /* The leading double-quote.  */
+      n++;
+      while (*p)
+       {
+         /* An extra one for each literal that must be escaped.  */
+         if (*p == '\\' || *p == '"')
+           n++;
+         n++;
+         p++;
+       }
+      /* The trailing double-quote and the delimiter.  */
+      n += 2;
+    }
+  /* And a trailing zero.  */
+  n++;
+
   buf = p = malloc (n);
-  if ( !buf )
+  if (!buf)
     return NULL;
-  *buf = 0;
-  if ( argv[0] )
+  for (i = 0; argv[i]; i++)
     {
-      if (strpbrk (argv[0], " \t"))
-        p = stpcpy (stpcpy (stpcpy (p, "\""), argv[0]), "\"");
-      else
-        p = stpcpy (p, argv[0]);
-      for (i = 1; argv[i]; i++)
-        {
-          if (!*argv[i])
-            p = stpcpy (p, " \"\"");
-          else
-            p = stpcpy (stpcpy (p, " "), argv[i]);
-        }
+      char *argvp = argv[i];
+
+      *(p++) = '"';
+      while (*argvp)
+       {
+         if (*argvp == '\\' || *argvp == '"')
+           *(p++) = '\\';
+         *(p++) = *(argvp++);
+       }
+      *(p++) = '"';
+      *(p++) = ' ';
     }
-  
+  *(p++) = 0;
+
   return buf;
 }
 
@@ -377,11 +427,11 @@ _gpgme_io_spawn ( const char *path, char **argv,
     /* FIXME.  */
     int debug_me = 0;
 
-    memset (&sec_attr, 0, sizeof sec_attr );
+    memset (&sec_attr, 0, sizeof sec_attr);
     sec_attr.nLength = sizeof sec_attr;
     sec_attr.bInheritHandle = FALSE;
 
-    arg_string = build_commandline ( argv );
+    arg_string = build_commandline (argv);
     if (!arg_string )
         return -1; 
 
@@ -395,17 +445,20 @@ _gpgme_io_spawn ( const char *path, char **argv,
 
     for (i=0; fd_child_list[i].fd != -1; i++ ) {
         if (fd_child_list[i].dup_to == 0 ) {
-            si.hStdInput = fd_to_handle (fd_child_list[i].fd);
-            DEBUG1 ("using %d for stdin", fd_child_list[i].fd );
+            si.hStdInput = (HANDLE) _get_osfhandle (fd_child_list[i].fd);
+            DEBUG2 ("using %d (%p) for stdin", fd_child_list[i].fd,
+                   _get_osfhandle (fd_child_list[i].fd));
             duped_stdin=1;
         }
         else if (fd_child_list[i].dup_to == 1 ) {
-            si.hStdOutput = fd_to_handle (fd_child_list[i].fd);
-            DEBUG1 ("using %d for stdout", fd_child_list[i].fd );
+            si.hStdOutput = (HANDLE) _get_osfhandle (fd_child_list[i].fd);
+            DEBUG2 ("using %d (%p) for stdout", fd_child_list[i].fd,
+                   _get_osfhandle (fd_child_list[i].fd));
         }
         else if (fd_child_list[i].dup_to == 2 ) {
-            si.hStdError = fd_to_handle (fd_child_list[i].fd);
-            DEBUG1 ("using %d for stderr", fd_child_list[i].fd );
+            si.hStdError = (HANDLE) _get_osfhandle (fd_child_list[i].fd);
+            DEBUG2 ("using %d (%p) for stderr", fd_child_list[i].fd,
+                   _get_osfhandle (fd_child_list[i].fd));
             duped_stderr = 1;
         }
     }
@@ -496,7 +549,115 @@ _gpgme_io_spawn ( const char *path, char **argv,
 int
 _gpgme_io_select (struct io_select_fd_s *fds, size_t nfds, int nonblock)
 {
-  assert (!"ARGH!  The user of this library MUST define io callbacks!");
-  errno = EINVAL;
-  return -1;
+  int     npollfds;
+  GPollFD *pollfds;
+  int     *pollfds_map; 
+  int i, j;
+  int any, n, count;
+  int timeout = 1000;  /* Use a 1s timeout.  */
+  void *dbg_help = NULL;
+
+  if (nonblock)
+    timeout = 0;
+
+  pollfds = calloc (nfds, sizeof *pollfds);
+  if (!pollfds)
+    return -1;
+  pollfds_map = calloc (nfds, sizeof *pollfds_map);
+  if (!pollfds_map)
+    {
+      free (pollfds);
+      return -1;
+    }
+  npollfds = 0;
+
+  DEBUG_BEGIN (dbg_help, 3, "gpgme:select on [ ");
+  any = 0;
+  for (i = 0; i < nfds; i++)
+    {
+      if (fds[i].fd == -1) 
+       continue;
+      if (fds[i].frozen)
+       DEBUG_ADD1 (dbg_help, "f%d ", fds[i].fd);
+      else if (fds[i].for_read )
+       {
+          GIOChannel *chan = find_channel (fds[i].fd, 0);
+          assert (chan);
+          g_io_channel_win32_make_pollfd (chan, G_IO_IN, pollfds + npollfds);
+          pollfds_map[npollfds] = i;
+         DEBUG_ADD2 (dbg_help, "r%d<%d> ", fds[i].fd, pollfds[npollfds].fd);
+          npollfds++;
+         any = 1;
+        }
+      else if (fds[i].for_write)
+       {
+          GIOChannel *chan = find_channel (fds[i].fd, 0);
+          assert (chan);
+          g_io_channel_win32_make_pollfd (chan, G_IO_OUT, pollfds + npollfds);
+          pollfds_map[npollfds] = i;
+         DEBUG_ADD2 (dbg_help, "w%d<%d> ", fds[i].fd, pollfds[npollfds].fd);
+          npollfds++;
+         any = 1;
+        }
+      fds[i].signaled = 0;
+    }
+  DEBUG_END (dbg_help, "]"); 
+  if (!any)
+    {
+      count = 0;
+      goto leave;
+    }
+
+
+  count = g_io_channel_win32_poll (pollfds, npollfds, timeout);
+  if (count < 0)
+    {
+      int saved_errno = errno;
+      DEBUG1 ("_gpgme_io_select failed: %s\n", strerror (errno));
+      errno = saved_errno;
+      goto leave;
+    }
+
+  DEBUG_BEGIN (dbg_help, 3, "select OK [ ");
+  if (DEBUG_ENABLED (dbg_help))
+    {
+      for (i = 0; i < npollfds; i++)
+       {
+         if ((pollfds[i].revents & G_IO_IN))
+           DEBUG_ADD1 (dbg_help, "r%d ", fds[pollfds_map[i]].fd);
+          if ((pollfds[i].revents & G_IO_OUT))
+            DEBUG_ADD1 (dbg_help, "w%d ", fds[pollfds_map[i]].fd);
+        }
+      DEBUG_END (dbg_help, "]");
+    }
+    
+  /* COUNT is used to stop the lop as soon as possible.  */
+  for (n = count, i = 0; i < npollfds && n; i++)
+    {
+      j = pollfds_map[i];
+      assert (j >= 0 && j < nfds);
+      if (fds[j].fd == -1)
+       ;
+      else if (fds[j].for_read)
+       {
+         if ((pollfds[i].revents & G_IO_IN))
+           {
+             fds[j].signaled = 1;
+             n--;
+            }
+        }
+      else if (fds[j].for_write)
+       {
+         if ((pollfds[i].revents & G_IO_OUT))
+           {
+             fds[j].signaled = 1;
+             n--;
+            }
+        }
+    }
+
+leave:
+  free (pollfds);
+  free (pollfds_map);
+  return count;
 }