Fixed version string and W32 spawn function
[gpgme.git] / gpgme / w32-io.c
1 /* w32-io.c - W32 API 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 #ifdef 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 <signal.h>
32 #include <fcntl.h>
33 #include <windows.h>
34 #include "syshdr.h"
35
36 #include "util.h"
37 #include "sema.h"
38 #include "io.h"
39
40
41 /* 
42  * We assume that a HANDLE can be represented by an int which should be true   
43  * for all i386 systems (HANDLE is defined as void *) and these are the only
44  * systems for which Windows is available.
45  * Further we assume that -1 denotes an invalid handle.
46  */
47
48 #define fd_to_handle(a)  ((HANDLE)(a))
49 #define handle_to_fd(a)  ((int)(a))
50 #define pid_to_handle(a) ((HANDLE)(a))
51 #define handle_to_pid(a) ((int)(a))
52
53 #define READBUF_SIZE 4096
54
55 struct reader_context_s {
56     HANDLE file_hd;
57     HANDLE thread_hd;   
58     DECLARE_LOCK (mutex);
59     
60     int eof;
61     int error;
62     int error_code;
63
64     HANDLE have_data_ev;  /* manually reset */
65     int    have_data_flag;  /* FIXME: is there another way to check whether
66                                it has been signaled? */
67     HANDLE have_space_ev; /* auto reset */
68     size_t readpos, writepos;
69     char buffer[READBUF_SIZE];
70 };
71
72
73 #define MAX_READERS 20
74 static struct {
75     volatile int used;
76     int fd;
77     struct reader_context_s *context;
78 } reader_table[MAX_READERS];
79 static int reader_table_size= MAX_READERS;
80 DEFINE_STATIC_LOCK (reader_table_lock);
81
82 static HANDLE
83 set_synchronize (HANDLE h)
84 {
85     HANDLE tmp;
86     
87     /* For NT we have to set the sync flag.  It seems that the only
88      * way to do it is by duplicating the handle.  Tsss.. */
89     if (!DuplicateHandle( GetCurrentProcess(), h,
90                           GetCurrentProcess(), &tmp,
91                           SYNCHRONIZE, FALSE, 0 ) ) {
92         DEBUG1 ("** Set SYNCRONIZE failed: ec=%d\n", (int)GetLastError());
93     }
94     else {
95         CloseHandle (h);
96         h = tmp;
97     }
98     return h;
99 }
100
101
102
103 static DWORD CALLBACK 
104 reader (void *arg)
105 {
106     struct reader_context_s *c = arg;
107     int nbytes;
108     DWORD nread;
109
110     DEBUG2 ("reader thread %p for file %p started", c->thread_hd, c->file_hd );
111     for (;;) {
112         LOCK (c->mutex);
113         /* leave a one byte gap so that we can see wheter it is empty or full*/
114         if ((c->writepos + 1) % READBUF_SIZE == c->readpos) { 
115             /* wait for space */
116             ResetEvent (c->have_space_ev);
117             UNLOCK (c->mutex);
118             DEBUG1 ("reader thread %p: waiting for space ...", c->thread_hd );
119             WaitForSingleObject (c->have_space_ev, INFINITE);
120             DEBUG1 ("reader thread %p: got space", c->thread_hd );
121             LOCK (c->mutex);
122         }
123         nbytes = (c->readpos + READBUF_SIZE - c->writepos-1) % READBUF_SIZE;
124         if ( nbytes > READBUF_SIZE - c->writepos )
125             nbytes = READBUF_SIZE - c->writepos;
126         UNLOCK (c->mutex);
127
128         DEBUG2 ("reader thread %p: reading %d bytes", c->thread_hd, nbytes );
129         if ( !ReadFile ( c->file_hd,
130                          c->buffer+c->writepos, nbytes, &nread, NULL) ) {
131             c->error = 1;
132             c->error_code = (int)GetLastError ();
133             DEBUG2 ("reader thread %p: read error: ec=%d",
134                     c->thread_hd, c->error_code );
135             break;
136         }
137         if ( !nread ) {
138             c->eof = 1;
139             DEBUG1 ("reader thread %p: got eof", c->thread_hd );
140             break;
141         }
142         DEBUG2 ("reader thread %p: got %d bytes", c->thread_hd, (int)nread );
143       
144         LOCK (c->mutex);
145         c->writepos = (c->writepos + nread) % READBUF_SIZE;
146         c->have_data_flag = 1;
147         SetEvent (c->have_data_ev);
148         UNLOCK (c->mutex);
149     }
150     DEBUG1 ("reader thread %p ended", c->thread_hd );
151
152     return 0;
153 }
154
155
156 static struct reader_context_s *
157 create_reader (HANDLE fd)
158 {
159     struct reader_context_s *c;
160     SECURITY_ATTRIBUTES sec_attr;
161     DWORD tid;
162
163     DEBUG1 ("creating new read thread for file handle %p", fd );
164     memset (&sec_attr, 0, sizeof sec_attr );
165     sec_attr.nLength = sizeof sec_attr;
166     sec_attr.bInheritHandle = FALSE;
167
168     c = xtrycalloc (1, sizeof *c );
169     if (!c)
170         return NULL;
171
172     c->file_hd = fd;
173     c->have_data_ev = CreateEvent (&sec_attr, TRUE, FALSE, NULL);
174     c->have_space_ev = CreateEvent (&sec_attr, FALSE, TRUE, NULL);
175     if (!c->have_data_ev || !c->have_space_ev) {
176         DEBUG1 ("** CreateEvent failed: ec=%d\n", (int)GetLastError ());
177         if (c->have_data_ev)
178             CloseHandle (c->have_data_ev);
179         if (c->have_space_ev)
180             CloseHandle (c->have_space_ev);
181         xfree (c);
182         return NULL;
183     }
184
185     c->have_data_ev = set_synchronize (c->have_data_ev);
186     INIT_LOCK (c->mutex);
187
188     c->thread_hd = CreateThread (&sec_attr, 0, reader, c, 0, &tid );
189     if (!c->thread_hd) {
190         DEBUG1 ("** failed to create reader thread: ec=%d\n",
191                  (int)GetLastError ());
192         DESTROY_LOCK (c->mutex);
193         if (c->have_data_ev)
194             CloseHandle (c->have_data_ev);
195         if (c->have_space_ev)
196             CloseHandle (c->have_space_ev);
197         xfree (c);
198         return NULL;
199     }    
200
201     return c;
202 }
203
204
205 /* 
206  * Find a reader context or create a new one 
207  * Note that the reader context will last until a io_close.
208  */
209 static struct reader_context_s *
210 find_reader (int fd, int start_it)
211 {
212     int i;
213
214     for (i=0; i < reader_table_size ; i++ ) {
215         if ( reader_table[i].used && reader_table[i].fd == fd )
216             return reader_table[i].context;
217     }
218     if (!start_it)
219         return NULL;
220
221     LOCK (reader_table_lock);
222     for (i=0; i < reader_table_size; i++ ) {
223         if (!reader_table[i].used) {
224             reader_table[i].fd = fd;
225             reader_table[i].context = create_reader (fd_to_handle (fd));
226             reader_table[i].used = 1;
227             UNLOCK (reader_table_lock);
228             return reader_table[i].context;
229         }
230     }
231     UNLOCK (reader_table_lock);
232     return NULL;
233 }
234
235
236
237 int
238 _gpgme_io_read ( int fd, void *buffer, size_t count )
239 {
240     int nread;
241     struct reader_context_s *c = find_reader (fd,1);
242
243     DEBUG2 ("fd %d: about to read %d bytes\n", fd, (int)count );
244     if ( !c ) {
245         DEBUG0 ( "no reader thread\n");
246         return -1;
247     }
248
249     LOCK (c->mutex);
250     if (c->readpos == c->writepos) { /* no data avail */
251         UNLOCK (c->mutex);
252         DEBUG2 ("fd %d: waiting for data from thread %p", fd, c->thread_hd);
253         WaitForSingleObject (c->have_data_ev, INFINITE);
254         DEBUG2 ("fd %d: data from thread %p available", fd, c->thread_hd);
255         LOCK (c->mutex);
256         if (c->readpos == c->writepos && !c->eof && !c->error) {
257             UNLOCK (c->mutex);
258             if (c->eof) 
259                 return 0;
260             return -1;
261         }
262     }
263   
264     nread = c->readpos < c->writepos? c->writepos - c->readpos
265                                     : READBUF_SIZE - c->readpos;
266     if (nread > count)
267         nread = count;
268     memcpy (buffer, c->buffer+c->readpos, nread);
269     c->readpos = (c->readpos + nread) % READBUF_SIZE;
270     if (c->readpos == c->writepos) {
271         c->have_data_flag = 0;
272         ResetEvent (c->have_data_ev);
273     }
274     if (nread)
275         SetEvent (c->have_space_ev);
276     UNLOCK (c->mutex);
277
278     DEBUG2 ("fd %d: got %d bytes\n", fd, nread );
279
280     return nread;
281 }
282
283
284 int
285 _gpgme_io_write ( int fd, const void *buffer, size_t count )
286 {
287     DWORD nwritten;
288     HANDLE h = fd_to_handle (fd);
289
290 #warning writing blocks for large counts, so we limit it here.
291     if (count > 500)
292         count = 500;
293
294     DEBUG2 ("fd %d: about to write %d bytes\n", fd, (int)count );
295     if ( !WriteFile ( h, buffer, count, &nwritten, NULL) ) {
296         DEBUG1 ("WriteFile failed: ec=%d\n", (int)GetLastError ());
297         return -1;
298     }
299     DEBUG2 ("fd %d:          wrote %d bytes\n",
300                    fd, (int)nwritten );
301
302     return (int)nwritten;
303 }
304
305 int
306 _gpgme_io_pipe ( int filedes[2], int inherit_idx )
307 {
308     HANDLE r, w;
309     SECURITY_ATTRIBUTES sec_attr;
310
311     memset (&sec_attr, 0, sizeof sec_attr );
312     sec_attr.nLength = sizeof sec_attr;
313     sec_attr.bInheritHandle = FALSE;
314     
315     if (!CreatePipe ( &r, &w, &sec_attr, 0))
316         return -1;
317     /* make one end inheritable */
318     if ( inherit_idx == 0 ) {
319         HANDLE h;
320         if (!DuplicateHandle( GetCurrentProcess(), r,
321                               GetCurrentProcess(), &h, 0,
322                               TRUE, DUPLICATE_SAME_ACCESS ) ) {
323             DEBUG1 ("DuplicateHandle failed: ec=%d\n", (int)GetLastError());
324             CloseHandle (r);
325             CloseHandle (w);
326             return -1;
327         }
328         CloseHandle (r);
329         r = h;
330     }
331     else if ( inherit_idx == 1 ) {
332         HANDLE h;
333         if (!DuplicateHandle( GetCurrentProcess(), w,
334                               GetCurrentProcess(), &h, 0,
335                               TRUE, DUPLICATE_SAME_ACCESS ) ) {
336             DEBUG1 ("DuplicateHandle failed: ec=%d\n", (int)GetLastError());
337             CloseHandle (r);
338             CloseHandle (w);
339             return -1;
340         }
341         CloseHandle (w);
342         w = h;
343     }
344
345     filedes[0] = handle_to_fd (r);
346     filedes[1] = handle_to_fd (w);
347     DEBUG5 ("CreatePipe %p %p %d %d inherit=%d\n", r, w,
348                    filedes[0], filedes[1], inherit_idx );
349     return 0;
350 }
351
352 int
353 _gpgme_io_close ( int fd )
354 {
355     if ( fd == -1 )
356         return -1;
357
358     DEBUG1 ("** closing handle for fd %d\n", fd);
359     /* fixme: destroy thread */
360
361     if ( !CloseHandle (fd_to_handle (fd)) ) { 
362         DEBUG2 ("CloseHandle for fd %d failed: ec=%d\n",
363                  fd, (int)GetLastError ());
364         return -1;
365     }
366
367     return 0;
368 }
369
370
371 int
372 _gpgme_io_set_nonblocking ( int fd )
373 {
374     return 0;
375 }
376
377
378 static char *
379 build_commandline ( char **argv )
380 {
381     int i, n = 0;
382     char *buf, *p;
383
384     /* FIXME: we have to quote some things because under Windows the 
385      * program parses the commandline and does some unquoting */
386     for (i=0; argv[i]; i++)
387         n += strlen (argv[i]) + 1;
388     buf = p = xtrymalloc (n);
389     if ( !buf )
390         return NULL;
391     *buf = 0;
392     if ( argv[0] )
393         p = stpcpy (p, argv[0]);
394     for (i = 1; argv[i]; i++)
395         p = stpcpy (stpcpy (p, " "), argv[i]);
396
397     return buf;
398 }
399
400
401 int
402 _gpgme_io_spawn ( const char *path, char **argv,
403                   struct spawn_fd_item_s *fd_child_list,
404                   struct spawn_fd_item_s *fd_parent_list )
405 {
406     SECURITY_ATTRIBUTES sec_attr;
407     PROCESS_INFORMATION pi = {
408         NULL,      /* returns process handle */
409         0,         /* returns primary thread handle */
410         0,         /* returns pid */
411         0         /* returns tid */
412     };
413     STARTUPINFO si;
414     char *envblock = NULL;
415     int cr_flags = CREATE_DEFAULT_ERROR_MODE
416                  | GetPriorityClass (GetCurrentProcess ());
417     int i;
418     char *arg_string;
419     int duped_stdin = 0;
420     int duped_stderr = 0;
421     HANDLE hnul = INVALID_HANDLE_VALUE;
422     int debug_me = !!getenv ("GPGME_DEBUG");
423
424     memset (&sec_attr, 0, sizeof sec_attr );
425     sec_attr.nLength = sizeof sec_attr;
426     sec_attr.bInheritHandle = FALSE;
427
428     arg_string = build_commandline ( argv );
429     if (!arg_string )
430         return -1; 
431
432     memset (&si, 0, sizeof si);
433     si.cb = sizeof (si);
434     si.dwFlags = STARTF_USESTDHANDLES | STARTF_USESHOWWINDOW;
435     si.wShowWindow = debug_me? SW_SHOW : SW_MINIMIZE;
436     si.hStdInput = GetStdHandle (STD_INPUT_HANDLE);
437     si.hStdOutput = GetStdHandle (STD_OUTPUT_HANDLE);
438     si.hStdError = GetStdHandle (STD_ERROR_HANDLE);
439
440     for (i=0; fd_child_list[i].fd != -1; i++ ) {
441         if (fd_child_list[i].dup_to == 0 ) {
442             si.hStdInput = fd_to_handle (fd_child_list[i].fd);
443             DEBUG1 ("using %d for stdin", fd_child_list[i].fd );
444             duped_stdin=1;
445         }
446         else if (fd_child_list[i].dup_to == 1 ) {
447             si.hStdOutput = fd_to_handle (fd_child_list[i].fd);
448             DEBUG1 ("using %d for stdout", fd_child_list[i].fd );
449         }
450         else if (fd_child_list[i].dup_to == 2 ) {
451             si.hStdError = fd_to_handle (fd_child_list[i].fd);
452             DEBUG1 ("using %d for stderr", fd_child_list[i].fd );
453             duped_stderr = 1;
454         }
455     }
456
457     if( !duped_stdin || !duped_stderr ) {
458         SECURITY_ATTRIBUTES sa;
459
460         memset (&sa, 0, sizeof sa );
461         sa.nLength = sizeof sa;
462         sa.bInheritHandle = TRUE;
463         hnul = CreateFile ( "nul",
464                             GENERIC_READ|GENERIC_WRITE,
465                             FILE_SHARE_READ|FILE_SHARE_WRITE,
466                             &sa,
467                             OPEN_EXISTING,
468                             FILE_ATTRIBUTE_NORMAL,
469                             NULL );
470         if ( hnul == INVALID_HANDLE_VALUE ) {
471             DEBUG1 ("can't open `nul': ec=%d\n", (int)GetLastError ());
472             xfree (arg_string);
473             return -1;
474         }
475         /* Make sure that the process has a connected stdin */
476         if ( !duped_stdin ) {
477             si.hStdInput = hnul;
478             DEBUG1 ("using %d for dummy stdin", (int)hnul );
479         }
480         /* We normally don't want all the normal output */
481         if ( !duped_stderr ) {
482             si.hStdError = hnul;
483             DEBUG1 ("using %d for dummy stderr", (int)hnul );
484         }
485     }
486
487     DEBUG2 ("CreateProcess, path=`%s' args=`%s'", path, arg_string);
488     cr_flags |= CREATE_SUSPENDED; 
489     if ( !CreateProcessA (path,
490                           arg_string,
491                           &sec_attr,     /* process security attributes */
492                           &sec_attr,     /* thread security attributes */
493                           TRUE,          /* inherit handles */
494                           cr_flags,      /* creation flags */
495                           envblock,      /* environment */
496                           NULL,          /* use current drive/directory */
497                           &si,           /* startup information */
498                           &pi            /* returns process information */
499         ) ) {
500         DEBUG1 ("CreateProcess failed: ec=%d\n", (int) GetLastError ());
501         xfree (arg_string);
502         return -1;
503     }
504
505     /* close the /dev/nul handle if used */
506     if (hnul != INVALID_HANDLE_VALUE ) {
507         if ( !CloseHandle ( hnul ) )
508             DEBUG1 ("CloseHandle(hnul) failed: ec=%d\n", (int)GetLastError());
509     }
510
511     /* Close the other ends of the pipes */
512     for (i=0; fd_parent_list[i].fd != -1; i++ ) {
513         DEBUG1 ("Closing fd %d\n", fd_parent_list[i].fd );
514         if ( !CloseHandle ( fd_to_handle (fd_parent_list[i].fd) ) )
515             DEBUG1 ("CloseHandle failed: ec=%d", (int)GetLastError());
516     }
517
518     DEBUG4 ("CreateProcess ready\n"
519             "-   hProcess=%p  hThread=%p\n"
520             "-   dwProcessID=%d dwThreadId=%d\n",
521             pi.hProcess, pi.hThread, 
522             (int) pi.dwProcessId, (int) pi.dwThreadId);
523
524     if ( ResumeThread ( pi.hThread ) < 0 ) {
525         DEBUG1 ("ResumeThread failed: ec=%d\n", (int)GetLastError ());
526     }
527
528     if ( !CloseHandle (pi.hThread) ) { 
529         DEBUG1 ("CloseHandle of thread failed: ec=%d\n",
530                  (int)GetLastError ());
531     }
532
533     return handle_to_pid (pi.hProcess);
534 }
535
536
537
538
539 int
540 _gpgme_io_waitpid ( int pid, int hang, int *r_status, int *r_signal )
541 {
542     HANDLE proc = fd_to_handle (pid);
543     int code, exc, ret = 0;
544
545     *r_status = 0;
546     *r_signal = 0;
547     code = WaitForSingleObject ( proc, hang? INFINITE : 0 );
548     switch (code) {
549       case WAIT_FAILED:
550         DEBUG2 ("WFSO pid=%d failed: %d\n", (int)pid, (int)GetLastError () );
551         break;
552
553       case WAIT_OBJECT_0:
554         if (!GetExitCodeProcess (proc, &exc)) {
555             DEBUG2 ("** GECP pid=%d failed: ec=%d\n",
556                     (int)pid, (int)GetLastError () );
557             *r_status = 4; 
558         }
559         else {
560             DEBUG2 ("GECP pid=%d exit code=%d\n", (int)pid,  exc);
561             *r_status = exc;
562         }
563         ret = 1;
564         break;
565
566       case WAIT_TIMEOUT:
567         if (hang)
568             DEBUG1 ("WFSO pid=%d timed out\n", (int)pid);
569         break;
570
571       default:
572         DEBUG2 ("WFSO pid=%d returned %d\n", (int)pid, code );
573         break;
574     }
575     return ret;
576 }
577
578
579 /*
580  * Select on the list of fds.
581  * Returns: -1 = error
582  *           0 = timeout or nothing to select
583  *          >0 = number of signaled fds
584  */
585 int
586 _gpgme_io_select ( struct io_select_fd_s *fds, size_t nfds )
587 {
588 #if 1
589     HANDLE waitbuf[MAXIMUM_WAIT_OBJECTS];
590     int code, nwait;
591     int i, any, any_write;
592     int count;
593     void *dbg_help;
594
595  restart:
596     DEBUG_BEGIN (dbg_help, "select on [ ");
597     any = any_write = 0;
598     nwait = 0;
599     for ( i=0; i < nfds; i++ ) {
600         if ( fds[i].fd == -1 ) 
601             continue;
602         if ( fds[i].for_read ) {
603             if ( nwait >= DIM (waitbuf) ) {
604                 DEBUG_END (dbg_help, "oops ]");
605                 DEBUG0 ("Too many objects for WFMO!" );
606                 return -1;
607             }
608             else {
609                 if ( fds[i].for_read ) {
610                     struct reader_context_s *c = find_reader (fds[i].fd,1);
611                     
612                     if (!c) { 
613                         DEBUG1 ("no reader thread for fd %d", fds[i].fd);
614                     }
615                     else {
616                         waitbuf[nwait++] = c->have_data_ev;
617                     }
618                 }
619                 DEBUG_ADD2 (dbg_help, "%c%d ",
620                                fds[i].for_read? 'r':'w',fds[i].fd );
621                 any = 1;
622             }
623         }
624         fds[i].signaled = 0;
625     }
626     DEBUG_END (dbg_help, "]");
627     if (!any) 
628         return 0;
629
630     count = 0;
631     /* no way to see whether a handle is ready for writing, signal all */
632     for ( i=0; i < nfds; i++ ) {
633         if ( fds[i].fd == -1 ) 
634             continue;
635         if ( fds[i].for_write ) {
636             fds[i].signaled = 1;
637             any_write =1;
638             count++;
639         }
640     }
641     code = WaitForMultipleObjects ( nwait, waitbuf, 0, any_write? 0:1000);
642     if ( code >= WAIT_OBJECT_0 && code < WAIT_OBJECT_0 + nwait ) {
643         /* This WFMO is a really silly function:  It does return either
644          * the index of the signaled object or if 2 objects have been
645          * signalled at the same time, the index of the object with the
646          * lowest object is returned - so and how do we find out
647          * how many objects have been signaled???.
648          * The only solution I can imagine is to test each object starting
649          * with the returned index individually - how dull.
650          */
651         any = 0;
652         for (i=code - WAIT_OBJECT_0; i < nwait; i++ ) {
653             if (WaitForSingleObject ( waitbuf[i], NULL ) == WAIT_OBJECT_0) {
654                 fds[i].signaled = 1;
655                 any = 1;
656                 count++;
657             }
658         }
659         if (!any) {
660             DEBUG0 ("Oops: No signaled objects found after WFMO");
661             count = -1;
662         }
663     }
664     else if ( code == WAIT_TIMEOUT ) {
665         DEBUG0 ("WFMO timed out\n" );
666     }  
667     else if (code == WAIT_FAILED ) {
668         int le = (int)GetLastError ();
669         if ( le == ERROR_INVALID_HANDLE ) {
670             int k, j = handle_to_fd (waitbuf[i]);
671                     
672             DEBUG1 ("WFMO invalid handle %d removed\n", j);
673             for (k=0 ; k < nfds; i++ ) {
674                 if ( fds[k].fd == j ) {
675                     fds[k].for_read = fds[k].for_write = 0;
676                     goto restart;
677                 }
678             }
679             DEBUG0 (" oops, or not???\n");
680         }
681         DEBUG1 ("WFMO failed: %d\n", le );
682         count = -1;
683     }
684     else {
685         DEBUG1 ("WFMO returned %d\n", code );
686         count = -1;
687     }
688
689     return count;
690 #else  /* This is the code we use */
691     int i, any, count;
692     int once_more = 0;
693
694     DEBUG_SELECT ((stderr, "gpgme:fakedselect on [ "));
695     any = 0;
696     for ( i=0; i < nfds; i++ ) {
697         if ( fds[i].fd == -1 ) 
698             continue;
699         if ( fds[i].for_read || fds[i].for_write ) {
700             DEBUG_SELECT ((stderr, "%c%d ",
701                            fds[i].for_read? 'r':'w',fds[i].fd ));
702             any = 1;
703         }
704         fds[i].signaled = 0;
705     }
706     DEBUG_SELECT ((stderr, "]\n" ));
707     if (!any) 
708         return 0;
709
710  restart:
711     count = 0;
712     /* no way to see whether a handle is ready fro writing, signal all */
713     for ( i=0; i < nfds; i++ ) {
714         if ( fds[i].fd == -1 ) 
715             continue;
716         if ( fds[i].for_write ) {
717             fds[i].signaled = 1;
718             count++;
719         }
720     }
721
722     /* now peek on all read handles */
723     for ( i=0; i < nfds; i++ ) {
724         if ( fds[i].fd == -1 ) 
725             continue;
726         if ( fds[i].for_read ) {
727             int navail;
728             
729             if ( !PeekNamedPipe (fd_to_handle (fds[i].fd),
730                                  NULL, 0, NULL, &navail, NULL) ) {
731                 DEBUG1 ("select: PeekFile failed: ec=%d\n",
732                         (int)GetLastError ());
733             }
734             else if ( navail ) {
735                 DEBUG2 ("fd %d has %d bytes to read\n",  fds[i].fd, navail );
736                 fds[i].signaled = 1;
737                 count++;
738             }
739         }
740     }
741     if ( !once_more && !count ) {
742         /* once more but after relinquishing our timeslot */
743         once_more = 1;
744         Sleep (0);
745         goto restart;
746     }
747
748     if ( count ) {
749         DEBUG_SELECT ((stderr, "gpgme:      signaled [ "));
750         for ( i=0; i < nfds; i++ ) {
751             if ( fds[i].fd == -1 ) 
752                 continue;
753             if ( (fds[i].for_read || fds[i].for_write) && fds[i].signaled ) {
754                 DEBUG_SELECT ((stderr, "%c%d ",
755                                fds[i].for_read? 'r':'w',fds[i].fd ));
756             }
757         }
758         DEBUG_SELECT ((stderr, "]\n" ));
759     }
760     
761     return count;
762 #endif
763 }
764
765 #endif /*HAVE_DOSISH_SYSTEM*/
766
767
768
769
770
771
772
773
774