auto updated version number.
[gpgme.git] / gpgme / w32-io.c
index 92dac0a..602be1f 100644 (file)
@@ -1,5 +1,6 @@
 /* w32-io.c - W32 API I/O functions
  *     Copyright (C) 2000 Werner Koch (dd9jn)
+ *      Copyright (C) 2001, 2002 g10 Code GmbH
  *
  * This file is part of GPGME.
  *
  * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA
  */
 
+#ifdef HAVE_CONFIG_H
 #include <config.h>
-#ifdef HAVE_DOSISH_SYSTEM
-
+#endif
 #include <stdio.h>
 #include <stdlib.h>
 #include <string.h>
 #include <assert.h>
 #include <errno.h>
-#include <sys/time.h>
-#include <sys/types.h>
 #include <signal.h>
 #include <fcntl.h>
+#include <sys/time.h>
+#include <sys/types.h>
 #include <windows.h>
-#include "syshdr.h"
+#include <io.h>
 
 #include "util.h"
 #include "sema.h"
 #define handle_to_pid(a) ((int)(a))
 
 #define READBUF_SIZE 4096
+#define WRITEBUF_SIZE 4096
+#define MAX_READERS 20
+#define MAX_WRITERS 20
+
+static struct {
+    int inuse;
+    int fd;
+    void (*handler)(int,void*);
+    void *value;
+} notify_table[256];
+DEFINE_STATIC_LOCK (notify_table_lock);
+
 
 struct reader_context_s {
     HANDLE file_hd;
     HANDLE thread_hd;  
     DECLARE_LOCK (mutex);
-    
+
+    int stop_me;
     int eof;
     int eof_shortcut;
     int error;
@@ -64,12 +78,12 @@ struct reader_context_s {
 
     HANDLE have_data_ev;  /* manually reset */
     HANDLE have_space_ev; /* auto reset */
+    HANDLE stopped;
     size_t readpos, writepos;
     char buffer[READBUF_SIZE];
 };
 
 
-#define MAX_READERS 20
 static struct {
     volatile int used;
     int fd;
@@ -78,6 +92,34 @@ static struct {
 static int reader_table_size= MAX_READERS;
 DEFINE_STATIC_LOCK (reader_table_lock);
 
+
+struct writer_context_s {
+    HANDLE file_hd;
+    HANDLE thread_hd;  
+    DECLARE_LOCK (mutex);
+
+    int stop_me;
+    int error;
+    int error_code;
+
+    HANDLE have_data;  /* manually reset */
+    HANDLE is_empty;
+    HANDLE stopped;
+    size_t nbytes; 
+    char buffer[WRITEBUF_SIZE];
+};
+
+
+static struct {
+    volatile int used;
+    int fd;
+    struct writer_context_s *context;
+} writer_table[MAX_WRITERS];
+static int writer_table_size= MAX_WRITERS;
+DEFINE_STATIC_LOCK (writer_table_lock);
+
+
+
 static HANDLE
 set_synchronize (HANDLE h)
 {
@@ -109,7 +151,7 @@ reader (void *arg)
     DEBUG2 ("reader thread %p for file %p started", c->thread_hd, c->file_hd );
     for (;;) {
         LOCK (c->mutex);
-        /* leave a one byte gap so that we can see wheter it is empty or full*/
+        /* leave a 1 byte gap so that we can see whether it is empty or full*/
         if ((c->writepos + 1) % READBUF_SIZE == c->readpos) { 
             /* wait for space */
             if (!ResetEvent (c->have_space_ev) )
@@ -120,6 +162,10 @@ reader (void *arg)
             DEBUG1 ("reader thread %p: got space", c->thread_hd );
             LOCK (c->mutex);
                }
+        if ( c->stop_me ) {
+            UNLOCK (c->mutex);
+            break;
+        }
         nbytes = (c->readpos + READBUF_SIZE - c->writepos-1) % READBUF_SIZE;
         if ( nbytes > READBUF_SIZE - c->writepos )
             nbytes = READBUF_SIZE - c->writepos;
@@ -149,6 +195,10 @@ reader (void *arg)
         DEBUG2 ("reader thread %p: got %d bytes", c->thread_hd, (int)nread );
       
         LOCK (c->mutex);
+        if (c->stop_me) {
+            UNLOCK (c->mutex);
+            break;
+        }
         c->writepos = (c->writepos + nread) % READBUF_SIZE;
         if ( !SetEvent (c->have_data_ev) )
             DEBUG1 ("SetEvent failed: ec=%d", (int)GetLastError ());
@@ -158,6 +208,7 @@ reader (void *arg)
     if ( !SetEvent (c->have_data_ev) )
         DEBUG1 ("SetEvent failed: ec=%d", (int)GetLastError ());
     DEBUG1 ("reader thread %p ended", c->thread_hd );
+    SetEvent (c->stopped);
 
     return 0;
 }
@@ -182,12 +233,15 @@ create_reader (HANDLE fd)
     c->file_hd = fd;
     c->have_data_ev = CreateEvent (&sec_attr, TRUE, FALSE, NULL);
     c->have_space_ev = CreateEvent (&sec_attr, FALSE, TRUE, NULL);
-    if (!c->have_data_ev || !c->have_space_ev) {
+    c->stopped = CreateEvent (&sec_attr, TRUE, FALSE, NULL);
+    if (!c->have_data_ev || !c->have_space_ev || !c->stopped ) {
         DEBUG1 ("** CreateEvent failed: ec=%d\n", (int)GetLastError ());
         if (c->have_data_ev)
             CloseHandle (c->have_data_ev);
         if (c->have_space_ev)
             CloseHandle (c->have_space_ev);
+        if (c->stopped)
+            CloseHandle (c->stopped);
         xfree (c);
         return NULL;
     }
@@ -204,6 +258,8 @@ create_reader (HANDLE fd)
             CloseHandle (c->have_data_ev);
         if (c->have_space_ev)
             CloseHandle (c->have_space_ev);
+        if (c->stopped)
+            CloseHandle (c->stopped);
         xfree (c);
         return NULL;
     }    
@@ -211,6 +267,30 @@ create_reader (HANDLE fd)
     return c;
 }
 
+static void
+destroy_reader (struct reader_context_s *c)
+{
+    LOCK (c->mutex);
+    c->stop_me = 1;
+    if (c->have_space_ev) 
+        SetEvent (c->have_space_ev);
+    UNLOCK (c->mutex);
+
+    DEBUG1 ("waiting for thread %p termination ...", c->thread_hd );
+    WaitForSingleObject (c->stopped, INFINITE);
+    DEBUG1 ("thread %p has terminated", c->thread_hd );
+    
+    if (c->stopped)
+        CloseHandle (c->stopped);
+    if (c->have_data_ev)
+        CloseHandle (c->have_data_ev);
+    if (c->have_space_ev)
+        CloseHandle (c->have_space_ev);
+    CloseHandle (c->thread_hd);
+    DESTROY_LOCK (c->mutex);
+    xfree (c);
+}
+
 
 /* 
  * Find a reader context or create a new one 
@@ -243,6 +323,24 @@ find_reader (int fd, int start_it)
 }
 
 
+static void
+kill_reader (int fd)
+{
+    int i;
+
+    LOCK (reader_table_lock);
+    for (i=0; i < reader_table_size; i++ ) {
+        if (reader_table[i].used && reader_table[i].fd == fd ) {
+            destroy_reader (reader_table[i].context);
+            reader_table[i].context = NULL;
+            reader_table[i].used = 0;
+            break;
+        }
+    }
+    UNLOCK (reader_table_lock);
+}
+
+
 
 int
 _gpgme_io_read ( int fd, void *buffer, size_t count )
@@ -304,27 +402,242 @@ _gpgme_io_read ( int fd, void *buffer, size_t count )
 }
 
 
-int
-_gpgme_io_write ( int fd, const void *buffer, size_t count )
+
+/*
+ * The writer does use a simple buffering strategy so that we are
+ * informed about write errors as soon as possible (i.e. with the the
+ * next call to the write function
+ */
+static DWORD CALLBACK 
+writer (void *arg)
 {
+    struct writer_context_s *c = arg;
     DWORD nwritten;
-    HANDLE h = fd_to_handle (fd);
 
-    /* writing blocks for large counts, so we limit it here. */
-    if (count > 1024)
-        count = 1024;
+    DEBUG2 ("writer thread %p for file %p started", c->thread_hd, c->file_hd );
+    for (;;) {
+        LOCK (c->mutex);
+        if ( !c->nbytes ) { 
+            if (!ResetEvent (c->have_data) )
+                DEBUG1 ("ResetEvent failed: ec=%d", (int)GetLastError ());
+            UNLOCK (c->mutex);
+            DEBUG1 ("writer thread %p: idle ...", c->thread_hd );
+            WaitForSingleObject (c->have_data, INFINITE);
+            DEBUG1 ("writer thread %p: got data to send", c->thread_hd );
+            LOCK (c->mutex);
+               }
+        if ( c->stop_me ) {
+            UNLOCK (c->mutex);
+            break;
+        }
+        UNLOCK (c->mutex);
+
+        DEBUG2 ("writer thread %p: writing %d bytes",
+                c->thread_hd, c->nbytes );
+        if ( c->nbytes && !WriteFile ( c->file_hd,  c->buffer, c->nbytes,
+                                       &nwritten, NULL)) {
+            c->error_code = (int)GetLastError ();
+            c->error = 1;
+            DEBUG2 ("writer thread %p: write error: ec=%d",
+                    c->thread_hd, c->error_code );
+            break;
+        }
+        DEBUG2 ("writer thread %p: wrote %d bytes",
+                c->thread_hd, (int)nwritten );
+      
+        LOCK (c->mutex);
+        c->nbytes -= nwritten;
+        if (c->stop_me) {
+            UNLOCK (c->mutex);
+            break;
+        }
+        if ( !c->nbytes ) {
+            if ( !SetEvent (c->is_empty) )
+                DEBUG1 ("SetEvent failed: ec=%d", (int)GetLastError ());
+        }
+        UNLOCK (c->mutex);
+    }
+    /* indicate that we have an error  */
+    if ( !SetEvent (c->is_empty) )
+        DEBUG1 ("SetEvent failed: ec=%d", (int)GetLastError ());
+    DEBUG1 ("writer thread %p ended", c->thread_hd );
+    SetEvent (c->stopped);
+
+    return 0;
+}
+
+
+static struct writer_context_s *
+create_writer (HANDLE fd)
+{
+    struct writer_context_s *c;
+    SECURITY_ATTRIBUTES sec_attr;
+    DWORD tid;
+
+    DEBUG1 ("creating new write thread for file handle %p", fd );
+    memset (&sec_attr, 0, sizeof sec_attr );
+    sec_attr.nLength = sizeof sec_attr;
+    sec_attr.bInheritHandle = FALSE;
+
+    c = xtrycalloc (1, sizeof *c );
+    if (!c)
+        return NULL;
+
+    c->file_hd = fd;
+    c->have_data = CreateEvent (&sec_attr, FALSE, FALSE, NULL);
+    c->is_empty  = CreateEvent (&sec_attr, TRUE, TRUE, NULL);
+    c->stopped = CreateEvent (&sec_attr, TRUE, FALSE, NULL);
+    if (!c->have_data || !c->is_empty || !c->stopped ) {
+        DEBUG1 ("** CreateEvent failed: ec=%d\n", (int)GetLastError ());
+        if (c->have_data)
+            CloseHandle (c->have_data);
+        if (c->is_empty)
+            CloseHandle (c->is_empty);
+        if (c->stopped)
+            CloseHandle (c->stopped);
+        xfree (c);
+        return NULL;
+    }
+
+    c->is_empty = set_synchronize (c->is_empty);
+    INIT_LOCK (c->mutex);
+
+    c->thread_hd = CreateThread (&sec_attr, 0, writer, c, 0, &tid );
+    if (!c->thread_hd) {
+        DEBUG1 ("** failed to create writer thread: ec=%d\n",
+                 (int)GetLastError ());
+        DESTROY_LOCK (c->mutex);
+        if (c->have_data)
+            CloseHandle (c->have_data);
+        if (c->is_empty)
+            CloseHandle (c->is_empty);
+        if (c->stopped)
+            CloseHandle (c->stopped);
+        xfree (c);
+        return NULL;
+    }    
+
+    return c;
+}
+
+static void
+destroy_writer (struct writer_context_s *c)
+{
+    LOCK (c->mutex);
+    c->stop_me = 1;
+    if (c->have_data) 
+        SetEvent (c->have_data);
+    UNLOCK (c->mutex);
+
+    DEBUG1 ("waiting for thread %p termination ...", c->thread_hd );
+    WaitForSingleObject (c->stopped, INFINITE);
+    DEBUG1 ("thread %p has terminated", c->thread_hd );
+    
+    if (c->stopped)
+        CloseHandle (c->stopped);
+    if (c->have_data)
+        CloseHandle (c->have_data);
+    if (c->is_empty)
+        CloseHandle (c->is_empty);
+    CloseHandle (c->thread_hd);
+    DESTROY_LOCK (c->mutex);
+    xfree (c);
+}
+
+
+/* 
+ * Find a writer context or create a new one 
+ * Note that the writer context will last until a io_close.
+ */
+static struct writer_context_s *
+find_writer (int fd, int start_it)
+{
+    int i;
+
+    for (i=0; i < writer_table_size ; i++ ) {
+        if ( writer_table[i].used && writer_table[i].fd == fd )
+            return writer_table[i].context;
+    }
+    if (!start_it)
+        return NULL;
+
+    LOCK (writer_table_lock);
+    for (i=0; i < writer_table_size; i++ ) {
+        if (!writer_table[i].used) {
+            writer_table[i].fd = fd;
+            writer_table[i].context = create_writer (fd_to_handle (fd));
+            writer_table[i].used = 1;
+            UNLOCK (writer_table_lock);
+            return writer_table[i].context;
+        }
+    }
+    UNLOCK (writer_table_lock);
+    return NULL;
+}
+
+
+static void
+kill_writer (int fd)
+{
+    int i;
+
+    LOCK (writer_table_lock);
+    for (i=0; i < writer_table_size; i++ ) {
+        if (writer_table[i].used && writer_table[i].fd == fd ) {
+            destroy_writer (writer_table[i].context);
+            writer_table[i].context = NULL;
+            writer_table[i].used = 0;
+            break;
+        }
+    }
+    UNLOCK (writer_table_lock);
+}
+
+
+
+
+int
+_gpgme_io_write ( int fd, const void *buffer, size_t count )
+{
+    struct writer_context_s *c = find_writer (fd,1);
 
     DEBUG2 ("fd %d: about to write %d bytes\n", fd, (int)count );
-    if ( !WriteFile ( h, buffer, count, &nwritten, NULL) ) {
-        DEBUG1 ("WriteFile failed: ec=%d\n", (int)GetLastError ());
+    if ( !c ) {
+        DEBUG0 ( "no writer thread\n");
         return -1;
     }
-    DEBUG2 ("fd %d:          wrote %d bytes\n",
-                   fd, (int)nwritten );
 
-    return (int)nwritten;
+    LOCK (c->mutex);
+    if ( c->nbytes ) { /* bytes are pending for send */
+        UNLOCK (c->mutex);
+        DEBUG2 ("fd %d: waiting for empty buffer in thread %p",
+                fd, c->thread_hd);
+        WaitForSingleObject (c->is_empty, INFINITE);
+        DEBUG2 ("fd %d: thread %p buffer is empty", fd, c->thread_hd);
+        assert (!c->nbytes);
+        LOCK (c->mutex);
+    }
+    
+    if ( c->error) {
+        UNLOCK (c->mutex);
+        DEBUG1 ("fd %d: write error", fd );
+        return -1;
+    }
+      
+    if (count > WRITEBUF_SIZE)
+        count = WRITEBUF_SIZE;
+    memcpy (c->buffer, buffer, count);
+    c->nbytes = count;
+    if (!SetEvent (c->have_data))
+        DEBUG1 ("SetEvent failed: ec=%d", (int)GetLastError ());
+    UNLOCK (c->mutex);
+
+    DEBUG2 ("fd %d:         copied %d bytes\n",
+                   fd, (int)count );
+    return (int)count;
 }
 
+
 int
 _gpgme_io_pipe ( int filedes[2], int inherit_idx )
 {
@@ -375,11 +688,30 @@ _gpgme_io_pipe ( int filedes[2], int inherit_idx )
 int
 _gpgme_io_close ( int fd )
 {
+    int i;
+    void (*handler)(int, void*) = NULL;
+    void *value = NULL;
+
     if ( fd == -1 )
         return -1;
 
     DEBUG1 ("** closing handle for fd %d\n", fd);
-    /* fixme: destroy thread */
+    kill_reader (fd);
+    kill_writer (fd);
+    LOCK (notify_table_lock);
+    for ( i=0; i < DIM (notify_table); i++ ) {
+        if (notify_table[i].inuse && notify_table[i].fd == fd) {
+            handler = notify_table[i].handler;
+            value   = notify_table[i].value;
+            notify_table[i].handler = NULL;
+            notify_table[i].value = NULL;
+            notify_table[i].inuse = 0;
+            break;
+        }
+    }
+    UNLOCK (notify_table_lock);
+    if (handler)
+        handler (fd, value);
 
     if ( !CloseHandle (fd_to_handle (fd)) ) { 
         DEBUG2 ("CloseHandle for fd %d failed: ec=%d\n",
@@ -390,6 +722,37 @@ _gpgme_io_close ( int fd )
     return 0;
 }
 
+int
+_gpgme_io_set_close_notify (int fd, void (*handler)(int, void*), void *value)
+{
+    int i;
+
+    assert (fd != -1);
+
+    LOCK (notify_table_lock);
+    for (i=0; i < DIM (notify_table); i++ ) {
+        if ( notify_table[i].inuse && notify_table[i].fd == fd )
+            break;
+    }
+    if ( i == DIM (notify_table) ) {
+        for (i=0; i < DIM (notify_table); i++ ) {
+            if ( !notify_table[i].inuse )
+                break;
+        }
+    }
+    if ( i == DIM (notify_table) ) {
+        UNLOCK (notify_table_lock);
+        return -1;
+    }
+    notify_table[i].fd = fd;
+    notify_table[i].handler = handler;
+    notify_table[i].value = value;
+    notify_table[i].inuse = 1;
+    UNLOCK (notify_table_lock);
+    DEBUG2 ("set notification for fd %d (idx=%d)", fd, i );
+    return 0;
+}
+
 
 int
 _gpgme_io_set_nonblocking ( int fd )
@@ -407,15 +770,19 @@ build_commandline ( char **argv )
     /* FIXME: we have to quote some things because under Windows the 
      * program parses the commandline and does some unquoting */
     for (i=0; argv[i]; i++)
-        n += strlen (argv[i]) + 1;
+        n += strlen (argv[i]) + 2 + 1; /* 2 extra bytes for possible quoting */
     buf = p = xtrymalloc (n);
     if ( !buf )
         return NULL;
     *buf = 0;
     if ( argv[0] )
         p = stpcpy (p, argv[0]);
-    for (i = 1; argv[i]; i++)
-        p = stpcpy (stpcpy (p, " "), argv[i]);
+    for (i = 1; argv[i]; i++) {
+        if (!*argv[i])
+            p = stpcpy (p, " \"\"");
+        else
+            p = stpcpy (stpcpy (p, " "), argv[i]);
+    }
 
     return buf;
 }
@@ -563,7 +930,8 @@ int
 _gpgme_io_waitpid ( int pid, int hang, int *r_status, int *r_signal )
 {
     HANDLE proc = fd_to_handle (pid);
-    int code, exc, ret = 0;
+    int code, ret = 0;
+    DWORD exc;
 
     *r_status = 0;
     *r_signal = 0;
@@ -619,23 +987,27 @@ _gpgme_io_kill ( int pid, int hard )
 int
 _gpgme_io_select ( struct io_select_fd_s *fds, size_t nfds )
 {
-#if 1
     HANDLE waitbuf[MAXIMUM_WAIT_OBJECTS];
     int    waitidx[MAXIMUM_WAIT_OBJECTS];
     int code, nwait;
-    int i, any, any_write;
+    int i, any;
     int count;
     void *dbg_help;
 
  restart:
     DEBUG_BEGIN (dbg_help, "select on [ ");
-    any = any_write = 0;
+    any = 0;
     nwait = 0;
+    count = 0;
     for ( i=0; i < nfds; i++ ) {
         if ( fds[i].fd == -1 ) 
             continue;
+        fds[i].signaled = 0;
         if ( fds[i].for_read || fds[i].for_write ) {
-            if ( fds[i].for_read ) {
+            if ( fds[i].frozen ) {
+                DEBUG_ADD1 (dbg_help, "f%d ", fds[i].fd );
+            }
+            else if ( fds[i].for_read ) {
                 struct reader_context_s *c = find_reader (fds[i].fd,1);
                 
                 if (!c) { 
@@ -650,29 +1022,41 @@ _gpgme_io_select ( struct io_select_fd_s *fds, size_t nfds )
                     waitidx[nwait]   = i;
                     waitbuf[nwait++] = c->have_data_ev;
                 }
+                DEBUG_ADD1 (dbg_help, "r%d ", fds[i].fd );
+                any = 1;
+            }
+            else if ( fds[i].for_write ) {
+                struct writer_context_s *c = find_writer (fds[i].fd,1);
+                
+                if (!c) { 
+                    DEBUG1 ("oops: no writer thread for fd %d", fds[i].fd);
+                }
+                else {
+                    if ( nwait >= DIM (waitbuf) ) {
+                        DEBUG_END (dbg_help, "oops ]");
+                        DEBUG0 ("Too many objects for WFMO!" );
+                        return -1;
+                    }
+                    LOCK (c->mutex);
+                    if ( !c->nbytes ) {
+                        waitidx[nwait]   = i;
+                        waitbuf[nwait++] = c->is_empty;
+                        DEBUG_ADD1 (dbg_help, "w%d ", fds[i].fd );
+                        any = 1;
+                    }
+                    else {
+                        DEBUG_ADD1 (dbg_help, "w%d(ignored) ", fds[i].fd );
+                    }
+                    UNLOCK (c->mutex);
+                }
             }
-            DEBUG_ADD2 (dbg_help, "%c%d ",
-                        fds[i].for_read? 'r':'w',fds[i].fd );
-            any = 1;
         }
-        fds[i].signaled = 0;
     }
     DEBUG_END (dbg_help, "]");
     if (!any) 
         return 0;
 
-    count = 0;
-    /* no way to see whether a handle is ready for writing, signal all */
-    for ( i=0; i < nfds; i++ ) {
-        if ( fds[i].fd == -1 ) 
-            continue;
-        if ( fds[i].for_write ) {
-            fds[i].signaled = 1;
-            any_write =1;
-            count++;
-        }
-    }
-    code = WaitForMultipleObjects ( nwait, waitbuf, 0, any_write? 200:1000);
+    code = WaitForMultipleObjects ( nwait, waitbuf, 0, 1000);
     if ( code >= WAIT_OBJECT_0 && code < WAIT_OBJECT_0 + nwait ) {
         /* This WFMO is a really silly function:  It does return either
          * the index of the signaled object or if 2 objects have been
@@ -735,88 +1119,4 @@ _gpgme_io_select ( struct io_select_fd_s *fds, size_t nfds )
     }
     
     return count;
-#else  /* This is the code we use */
-    int i, any, count;
-    int once_more = 0;
-
-    DEBUG_SELECT ((stderr, "gpgme:fakedselect on [ "));
-    any = 0;
-    for ( i=0; i < nfds; i++ ) {
-        if ( fds[i].fd == -1 ) 
-            continue;
-        if ( fds[i].for_read || fds[i].for_write ) {
-            DEBUG_SELECT ((stderr, "%c%d ",
-                           fds[i].for_read? 'r':'w',fds[i].fd ));
-            any = 1;
-        }
-        fds[i].signaled = 0;
-    }
-    DEBUG_SELECT ((stderr, "]\n" ));
-    if (!any) 
-        return 0;
-
- restart:
-    count = 0;
-    /* no way to see whether a handle is ready fro writing, signal all */
-    for ( i=0; i < nfds; i++ ) {
-        if ( fds[i].fd == -1 ) 
-            continue;
-        if ( fds[i].for_write ) {
-            fds[i].signaled = 1;
-            count++;
-        }
-    }
-
-    /* now peek on all read handles */
-    for ( i=0; i < nfds; i++ ) {
-        if ( fds[i].fd == -1 ) 
-            continue;
-        if ( fds[i].for_read ) {
-            int navail;
-            
-            if ( !PeekNamedPipe (fd_to_handle (fds[i].fd),
-                                 NULL, 0, NULL, &navail, NULL) ) {
-                DEBUG1 ("select: PeekFile failed: ec=%d\n",
-                        (int)GetLastError ());
-            }
-            else if ( navail ) {
-                DEBUG2 ("fd %d has %d bytes to read\n",  fds[i].fd, navail );
-                fds[i].signaled = 1;
-                count++;
-            }
-        }
-    }
-    if ( !once_more && !count ) {
-        /* once more but after relinquishing our timeslot */
-        once_more = 1;
-        Sleep (0);
-        goto restart;
-    }
-
-    if ( count ) {
-        DEBUG_SELECT ((stderr, "gpgme:      signaled [ "));
-        for ( i=0; i < nfds; i++ ) {
-            if ( fds[i].fd == -1 ) 
-                continue;
-            if ( (fds[i].for_read || fds[i].for_write) && fds[i].signaled ) {
-                DEBUG_SELECT ((stderr, "%c%d ",
-                               fds[i].for_read? 'r':'w',fds[i].fd ));
-            }
-        }
-        DEBUG_SELECT ((stderr, "]\n" ));
-    }
-    
-    return count;
-#endif
 }
-
-#endif /*HAVE_DOSISH_SYSTEM*/
-
-
-
-
-
-
-
-
-