2003-09-13 Marcus Brinkmann <marcus@g10code.de>
[gpgme.git] / gpgme / w32-io.c
1 /* w32-io.c - W32 API I/O functions.
2    Copyright (C) 2000 Werner Koch (dd9jn)
3    Copyright (C) 2001, 2002, 2003 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 General Public License as published by
9    the Free Software Foundation; either version 2 of the License, or
10    (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    General Public License for more details.
16  
17    You should have received a copy of the GNU General Public License
18    along with GPGME; if not, write to the Free Software Foundation,
19    Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.  */
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 #include <sys/time.h>
32 #include <sys/types.h>
33 #include <windows.h>
34 #include <io.h>
35
36 #include "util.h"
37 #include "sema.h"
38 #include "io.h"
39
40
41 /* We assume that a HANDLE can be represented by an int which should
42    be true for all i386 systems (HANDLE is defined as void *) and
43    these are the only systems for which Windows is available.  Further
44    we assume that -1 denotes an invalid handle.  */
45
46 #define fd_to_handle(a)  ((HANDLE)(a))
47 #define handle_to_fd(a)  ((int)(a))
48 #define pid_to_handle(a) ((HANDLE)(a))
49 #define handle_to_pid(a) ((int)(a))
50
51 #define READBUF_SIZE 4096
52 #define WRITEBUF_SIZE 4096
53 #define MAX_READERS 20
54 #define MAX_WRITERS 20
55
56 static struct {
57     int inuse;
58     int fd;
59     void (*handler)(int,void*);
60     void *value;
61 } notify_table[256];
62 DEFINE_STATIC_LOCK (notify_table_lock);
63
64
65 struct reader_context_s {
66     HANDLE file_hd;
67     HANDLE thread_hd;   
68     DECLARE_LOCK (mutex);
69
70     int stop_me;
71     int eof;
72     int eof_shortcut;
73     int error;
74     int error_code;
75
76     HANDLE have_data_ev;  /* manually reset */
77     HANDLE have_space_ev; /* auto reset */
78     HANDLE stopped;
79     size_t readpos, writepos;
80     char buffer[READBUF_SIZE];
81 };
82
83
84 static struct {
85     volatile int used;
86     int fd;
87     struct reader_context_s *context;
88 } reader_table[MAX_READERS];
89 static int reader_table_size= MAX_READERS;
90 DEFINE_STATIC_LOCK (reader_table_lock);
91
92
93 struct writer_context_s {
94     HANDLE file_hd;
95     HANDLE thread_hd;   
96     DECLARE_LOCK (mutex);
97
98     int stop_me;
99     int error;
100     int error_code;
101
102     HANDLE have_data;  /* manually reset */
103     HANDLE is_empty;
104     HANDLE stopped;
105     size_t nbytes; 
106     char buffer[WRITEBUF_SIZE];
107 };
108
109
110 static struct {
111     volatile int used;
112     int fd;
113     struct writer_context_s *context;
114 } writer_table[MAX_WRITERS];
115 static int writer_table_size= MAX_WRITERS;
116 DEFINE_STATIC_LOCK (writer_table_lock);
117
118
119
120 static HANDLE
121 set_synchronize (HANDLE h)
122 {
123     HANDLE tmp;
124     
125     /* For NT we have to set the sync flag.  It seems that the only
126      * way to do it is by duplicating the handle.  Tsss.. */
127     if (!DuplicateHandle( GetCurrentProcess(), h,
128                           GetCurrentProcess(), &tmp,
129                           EVENT_MODIFY_STATE|SYNCHRONIZE, FALSE, 0 ) ) {
130         DEBUG1 ("** Set SYNCRONIZE failed: ec=%d\n", (int)GetLastError());
131     }
132     else {
133         CloseHandle (h);
134         h = tmp;
135     }
136     return h;
137 }
138
139
140
141 static DWORD CALLBACK 
142 reader (void *arg)
143 {
144     struct reader_context_s *c = arg;
145     int nbytes;
146     DWORD nread;
147
148     DEBUG2 ("reader thread %p for file %p started", c->thread_hd, c->file_hd );
149     for (;;) {
150         LOCK (c->mutex);
151         /* leave a 1 byte gap so that we can see whether it is empty or full*/
152         if ((c->writepos + 1) % READBUF_SIZE == c->readpos) { 
153             /* wait for space */
154             if (!ResetEvent (c->have_space_ev) )
155                 DEBUG1 ("ResetEvent failed: ec=%d", (int)GetLastError ());
156             UNLOCK (c->mutex);
157             DEBUG1 ("reader thread %p: waiting for space ...", c->thread_hd );
158             WaitForSingleObject (c->have_space_ev, INFINITE);
159             DEBUG1 ("reader thread %p: got space", c->thread_hd );
160             LOCK (c->mutex);
161         }
162         if ( c->stop_me ) {
163             UNLOCK (c->mutex);
164             break;
165         }
166         nbytes = (c->readpos + READBUF_SIZE - c->writepos-1) % READBUF_SIZE;
167         if ( nbytes > READBUF_SIZE - c->writepos )
168             nbytes = READBUF_SIZE - c->writepos;
169         UNLOCK (c->mutex);
170
171         DEBUG2 ("reader thread %p: reading %d bytes", c->thread_hd, nbytes );
172         if ( !ReadFile ( c->file_hd,
173                          c->buffer+c->writepos, nbytes, &nread, NULL) ) {
174             c->error_code = (int)GetLastError ();
175             if (c->error_code == ERROR_BROKEN_PIPE ) {
176                 c->eof=1;
177                 DEBUG1 ("reader thread %p: got eof (broken pipe)",
178                         c->thread_hd );
179             }
180             else {
181                 c->error = 1;
182                 DEBUG2 ("reader thread %p: read error: ec=%d",
183                         c->thread_hd, c->error_code );
184             }
185             break;
186         }
187         if ( !nread ) {
188             c->eof = 1;
189             DEBUG1 ("reader thread %p: got eof", c->thread_hd );
190             break;
191         }
192         DEBUG2 ("reader thread %p: got %d bytes", c->thread_hd, (int)nread );
193       
194         LOCK (c->mutex);
195         if (c->stop_me) {
196             UNLOCK (c->mutex);
197             break;
198         }
199         c->writepos = (c->writepos + nread) % READBUF_SIZE;
200         if ( !SetEvent (c->have_data_ev) )
201             DEBUG1 ("SetEvent failed: ec=%d", (int)GetLastError ());
202         UNLOCK (c->mutex);
203     }
204     /* indicate that we have an error or eof */
205     if ( !SetEvent (c->have_data_ev) )
206         DEBUG1 ("SetEvent failed: ec=%d", (int)GetLastError ());
207     DEBUG1 ("reader thread %p ended", c->thread_hd );
208     SetEvent (c->stopped);
209
210     return 0;
211 }
212
213
214 static struct reader_context_s *
215 create_reader (HANDLE fd)
216 {
217     struct reader_context_s *c;
218     SECURITY_ATTRIBUTES sec_attr;
219     DWORD tid;
220
221     DEBUG1 ("creating new read thread for file handle %p", fd );
222     memset (&sec_attr, 0, sizeof sec_attr );
223     sec_attr.nLength = sizeof sec_attr;
224     sec_attr.bInheritHandle = FALSE;
225
226     c = calloc (1, sizeof *c );
227     if (!c)
228         return NULL;
229
230     c->file_hd = fd;
231     c->have_data_ev = CreateEvent (&sec_attr, TRUE, FALSE, NULL);
232     c->have_space_ev = CreateEvent (&sec_attr, FALSE, TRUE, NULL);
233     c->stopped = CreateEvent (&sec_attr, TRUE, FALSE, NULL);
234     if (!c->have_data_ev || !c->have_space_ev || !c->stopped ) {
235         DEBUG1 ("** CreateEvent failed: ec=%d\n", (int)GetLastError ());
236         if (c->have_data_ev)
237             CloseHandle (c->have_data_ev);
238         if (c->have_space_ev)
239             CloseHandle (c->have_space_ev);
240         if (c->stopped)
241             CloseHandle (c->stopped);
242         free (c);
243         return NULL;
244     }
245
246     c->have_data_ev = set_synchronize (c->have_data_ev);
247     INIT_LOCK (c->mutex);
248
249     c->thread_hd = CreateThread (&sec_attr, 0, reader, c, 0, &tid );
250     if (!c->thread_hd) {
251         DEBUG1 ("** failed to create reader thread: ec=%d\n",
252                  (int)GetLastError ());
253         DESTROY_LOCK (c->mutex);
254         if (c->have_data_ev)
255             CloseHandle (c->have_data_ev);
256         if (c->have_space_ev)
257             CloseHandle (c->have_space_ev);
258         if (c->stopped)
259             CloseHandle (c->stopped);
260         free (c);
261         return NULL;
262     }    
263
264     return c;
265 }
266
267 static void
268 destroy_reader (struct reader_context_s *c)
269 {
270     LOCK (c->mutex);
271     c->stop_me = 1;
272     if (c->have_space_ev) 
273         SetEvent (c->have_space_ev);
274     UNLOCK (c->mutex);
275
276     DEBUG1 ("waiting for thread %p termination ...", c->thread_hd );
277     WaitForSingleObject (c->stopped, INFINITE);
278     DEBUG1 ("thread %p has terminated", c->thread_hd );
279     
280     if (c->stopped)
281         CloseHandle (c->stopped);
282     if (c->have_data_ev)
283         CloseHandle (c->have_data_ev);
284     if (c->have_space_ev)
285         CloseHandle (c->have_space_ev);
286     CloseHandle (c->thread_hd);
287     DESTROY_LOCK (c->mutex);
288     free (c);
289 }
290
291
292 /* 
293  * Find a reader context or create a new one 
294  * Note that the reader context will last until a io_close.
295  */
296 static struct reader_context_s *
297 find_reader (int fd, int start_it)
298 {
299     int i;
300
301     for (i=0; i < reader_table_size ; i++ ) {
302         if ( reader_table[i].used && reader_table[i].fd == fd )
303             return reader_table[i].context;
304     }
305     if (!start_it)
306         return NULL;
307
308     LOCK (reader_table_lock);
309     for (i=0; i < reader_table_size; i++ ) {
310         if (!reader_table[i].used) {
311             reader_table[i].fd = fd;
312             reader_table[i].context = create_reader (fd_to_handle (fd));
313             reader_table[i].used = 1;
314             UNLOCK (reader_table_lock);
315             return reader_table[i].context;
316         }
317     }
318     UNLOCK (reader_table_lock);
319     return NULL;
320 }
321
322
323 static void
324 kill_reader (int fd)
325 {
326     int i;
327
328     LOCK (reader_table_lock);
329     for (i=0; i < reader_table_size; i++ ) {
330         if (reader_table[i].used && reader_table[i].fd == fd ) {
331             destroy_reader (reader_table[i].context);
332             reader_table[i].context = NULL;
333             reader_table[i].used = 0;
334             break;
335         }
336     }
337     UNLOCK (reader_table_lock);
338 }
339
340
341
342 int
343 _gpgme_io_read ( int fd, void *buffer, size_t count )
344 {
345     int nread;
346     struct reader_context_s *c = find_reader (fd,1);
347
348     DEBUG2 ("fd %d: about to read %d bytes\n", fd, (int)count );
349     if ( !c ) {
350         DEBUG0 ( "no reader thread\n");
351         return -1;
352     }
353     if (c->eof_shortcut) {
354         DEBUG1 ("fd %d: EOF (again)", fd );
355         return 0;
356     }
357
358     LOCK (c->mutex);
359     if (c->readpos == c->writepos && !c->error) { /*no data avail*/
360         UNLOCK (c->mutex);
361         DEBUG2 ("fd %d: waiting for data from thread %p", fd, c->thread_hd);
362         WaitForSingleObject (c->have_data_ev, INFINITE);
363         DEBUG2 ("fd %d: data from thread %p available", fd, c->thread_hd);
364         LOCK (c->mutex);
365     }
366     
367     if (c->readpos == c->writepos || c->error) {
368         UNLOCK (c->mutex);
369         c->eof_shortcut = 1;
370         if (c->eof) {
371             DEBUG1 ("fd %d: EOF", fd );
372             return 0;
373         }
374         if (!c->error) {
375             DEBUG1 ("fd %d: EOF but eof flag not set", fd );
376             return 0;
377         }
378         DEBUG1 ("fd %d: read error", fd );
379         return -1;
380     }
381       
382     nread = c->readpos < c->writepos? c->writepos - c->readpos
383                                     : READBUF_SIZE - c->readpos;
384     if (nread > count)
385         nread = count;
386     memcpy (buffer, c->buffer+c->readpos, nread);
387     c->readpos = (c->readpos + nread) % READBUF_SIZE;
388     if (c->readpos == c->writepos && !c->eof) {
389         if ( !ResetEvent (c->have_data_ev) )
390             DEBUG1 ("ResetEvent failed: ec=%d", (int)GetLastError ());
391     }
392     if (!SetEvent (c->have_space_ev))
393         DEBUG1 ("SetEvent failed: ec=%d", (int)GetLastError ());
394     UNLOCK (c->mutex);
395
396     DEBUG2 ("fd %d: got %d bytes\n", fd, nread );
397
398     return nread;
399 }
400
401
402
403 /*
404  * The writer does use a simple buffering strategy so that we are
405  * informed about write errors as soon as possible (i.e. with the the
406  * next call to the write function
407  */
408 static DWORD CALLBACK 
409 writer (void *arg)
410 {
411     struct writer_context_s *c = arg;
412     DWORD nwritten;
413
414     DEBUG2 ("writer thread %p for file %p started", c->thread_hd, c->file_hd );
415     for (;;) {
416         LOCK (c->mutex);
417         if ( !c->nbytes ) { 
418             if (!ResetEvent (c->have_data) )
419                 DEBUG1 ("ResetEvent failed: ec=%d", (int)GetLastError ());
420             UNLOCK (c->mutex);
421             DEBUG1 ("writer thread %p: idle ...", c->thread_hd );
422             WaitForSingleObject (c->have_data, INFINITE);
423             DEBUG1 ("writer thread %p: got data to send", c->thread_hd );
424             LOCK (c->mutex);
425         }
426         if ( c->stop_me ) {
427             UNLOCK (c->mutex);
428             break;
429         }
430         UNLOCK (c->mutex);
431
432         DEBUG2 ("writer thread %p: writing %d bytes",
433                 c->thread_hd, c->nbytes );
434         if ( c->nbytes && !WriteFile ( c->file_hd,  c->buffer, c->nbytes,
435                                        &nwritten, NULL)) {
436             c->error_code = (int)GetLastError ();
437             c->error = 1;
438             DEBUG2 ("writer thread %p: write error: ec=%d",
439                     c->thread_hd, c->error_code );
440             break;
441         }
442         DEBUG2 ("writer thread %p: wrote %d bytes",
443                 c->thread_hd, (int)nwritten );
444       
445         LOCK (c->mutex);
446         c->nbytes -= nwritten;
447         if (c->stop_me) {
448             UNLOCK (c->mutex);
449             break;
450         }
451         if ( !c->nbytes ) {
452             if ( !SetEvent (c->is_empty) )
453                 DEBUG1 ("SetEvent failed: ec=%d", (int)GetLastError ());
454         }
455         UNLOCK (c->mutex);
456     }
457     /* indicate that we have an error  */
458     if ( !SetEvent (c->is_empty) )
459         DEBUG1 ("SetEvent failed: ec=%d", (int)GetLastError ());
460     DEBUG1 ("writer thread %p ended", c->thread_hd );
461     SetEvent (c->stopped);
462
463     return 0;
464 }
465
466
467 static struct writer_context_s *
468 create_writer (HANDLE fd)
469 {
470     struct writer_context_s *c;
471     SECURITY_ATTRIBUTES sec_attr;
472     DWORD tid;
473
474     DEBUG1 ("creating new write thread for file handle %p", fd );
475     memset (&sec_attr, 0, sizeof sec_attr );
476     sec_attr.nLength = sizeof sec_attr;
477     sec_attr.bInheritHandle = FALSE;
478
479     c = calloc (1, sizeof *c );
480     if (!c)
481         return NULL;
482
483     c->file_hd = fd;
484     c->have_data = CreateEvent (&sec_attr, FALSE, FALSE, NULL);
485     c->is_empty  = CreateEvent (&sec_attr, TRUE, TRUE, NULL);
486     c->stopped = CreateEvent (&sec_attr, TRUE, FALSE, NULL);
487     if (!c->have_data || !c->is_empty || !c->stopped ) {
488         DEBUG1 ("** CreateEvent failed: ec=%d\n", (int)GetLastError ());
489         if (c->have_data)
490             CloseHandle (c->have_data);
491         if (c->is_empty)
492             CloseHandle (c->is_empty);
493         if (c->stopped)
494             CloseHandle (c->stopped);
495         free (c);
496         return NULL;
497     }
498
499     c->is_empty = set_synchronize (c->is_empty);
500     INIT_LOCK (c->mutex);
501
502     c->thread_hd = CreateThread (&sec_attr, 0, writer, c, 0, &tid );
503     if (!c->thread_hd) {
504         DEBUG1 ("** failed to create writer thread: ec=%d\n",
505                  (int)GetLastError ());
506         DESTROY_LOCK (c->mutex);
507         if (c->have_data)
508             CloseHandle (c->have_data);
509         if (c->is_empty)
510             CloseHandle (c->is_empty);
511         if (c->stopped)
512             CloseHandle (c->stopped);
513         free (c);
514         return NULL;
515     }    
516
517     return c;
518 }
519
520 static void
521 destroy_writer (struct writer_context_s *c)
522 {
523     LOCK (c->mutex);
524     c->stop_me = 1;
525     if (c->have_data) 
526         SetEvent (c->have_data);
527     UNLOCK (c->mutex);
528
529     DEBUG1 ("waiting for thread %p termination ...", c->thread_hd );
530     WaitForSingleObject (c->stopped, INFINITE);
531     DEBUG1 ("thread %p has terminated", c->thread_hd );
532     
533     if (c->stopped)
534         CloseHandle (c->stopped);
535     if (c->have_data)
536         CloseHandle (c->have_data);
537     if (c->is_empty)
538         CloseHandle (c->is_empty);
539     CloseHandle (c->thread_hd);
540     DESTROY_LOCK (c->mutex);
541     free (c);
542 }
543
544
545 /* 
546  * Find a writer context or create a new one 
547  * Note that the writer context will last until a io_close.
548  */
549 static struct writer_context_s *
550 find_writer (int fd, int start_it)
551 {
552     int i;
553
554     for (i=0; i < writer_table_size ; i++ ) {
555         if ( writer_table[i].used && writer_table[i].fd == fd )
556             return writer_table[i].context;
557     }
558     if (!start_it)
559         return NULL;
560
561     LOCK (writer_table_lock);
562     for (i=0; i < writer_table_size; i++ ) {
563         if (!writer_table[i].used) {
564             writer_table[i].fd = fd;
565             writer_table[i].context = create_writer (fd_to_handle (fd));
566             writer_table[i].used = 1;
567             UNLOCK (writer_table_lock);
568             return writer_table[i].context;
569         }
570     }
571     UNLOCK (writer_table_lock);
572     return NULL;
573 }
574
575
576 static void
577 kill_writer (int fd)
578 {
579     int i;
580
581     LOCK (writer_table_lock);
582     for (i=0; i < writer_table_size; i++ ) {
583         if (writer_table[i].used && writer_table[i].fd == fd ) {
584             destroy_writer (writer_table[i].context);
585             writer_table[i].context = NULL;
586             writer_table[i].used = 0;
587             break;
588         }
589     }
590     UNLOCK (writer_table_lock);
591 }
592
593
594
595
596 int
597 _gpgme_io_write ( int fd, const void *buffer, size_t count )
598 {
599     struct writer_context_s *c = find_writer (fd,1);
600
601     DEBUG2 ("fd %d: about to write %d bytes\n", fd, (int)count );
602     if ( !c ) {
603         DEBUG0 ( "no writer thread\n");
604         return -1;
605     }
606
607     LOCK (c->mutex);
608     if ( c->nbytes ) { /* bytes are pending for send */
609         UNLOCK (c->mutex);
610         DEBUG2 ("fd %d: waiting for empty buffer in thread %p",
611                 fd, c->thread_hd);
612         WaitForSingleObject (c->is_empty, INFINITE);
613         DEBUG2 ("fd %d: thread %p buffer is empty", fd, c->thread_hd);
614         assert (!c->nbytes);
615         LOCK (c->mutex);
616     }
617     
618     if ( c->error) {
619         UNLOCK (c->mutex);
620         DEBUG1 ("fd %d: write error", fd );
621         return -1;
622     }
623       
624     if (count > WRITEBUF_SIZE)
625         count = WRITEBUF_SIZE;
626     memcpy (c->buffer, buffer, count);
627     c->nbytes = count;
628     if (!SetEvent (c->have_data))
629         DEBUG1 ("SetEvent failed: ec=%d", (int)GetLastError ());
630     UNLOCK (c->mutex);
631
632     DEBUG2 ("fd %d:         copied %d bytes\n",
633                    fd, (int)count );
634     return (int)count;
635 }
636
637
638 int
639 _gpgme_io_pipe ( int filedes[2], int inherit_idx )
640 {
641     HANDLE r, w;
642     SECURITY_ATTRIBUTES sec_attr;
643
644     memset (&sec_attr, 0, sizeof sec_attr );
645     sec_attr.nLength = sizeof sec_attr;
646     sec_attr.bInheritHandle = FALSE;
647     
648     if (!CreatePipe ( &r, &w, &sec_attr, 0))
649         return -1;
650     /* make one end inheritable */
651     if ( inherit_idx == 0 ) {
652         HANDLE h;
653         if (!DuplicateHandle( GetCurrentProcess(), r,
654                               GetCurrentProcess(), &h, 0,
655                               TRUE, DUPLICATE_SAME_ACCESS ) ) {
656             DEBUG1 ("DuplicateHandle failed: ec=%d\n", (int)GetLastError());
657             CloseHandle (r);
658             CloseHandle (w);
659             return -1;
660         }
661         CloseHandle (r);
662         r = h;
663     }
664     else if ( inherit_idx == 1 ) {
665         HANDLE h;
666         if (!DuplicateHandle( GetCurrentProcess(), w,
667                               GetCurrentProcess(), &h, 0,
668                               TRUE, DUPLICATE_SAME_ACCESS ) ) {
669             DEBUG1 ("DuplicateHandle failed: ec=%d\n", (int)GetLastError());
670             CloseHandle (r);
671             CloseHandle (w);
672             return -1;
673         }
674         CloseHandle (w);
675         w = h;
676     }
677
678     filedes[0] = handle_to_fd (r);
679     filedes[1] = handle_to_fd (w);
680     DEBUG5 ("CreatePipe %p %p %d %d inherit=%d\n", r, w,
681                    filedes[0], filedes[1], inherit_idx );
682     return 0;
683 }
684
685 int
686 _gpgme_io_close ( int fd )
687 {
688     int i;
689     void (*handler)(int, void*) = NULL;
690     void *value = NULL;
691
692     if ( fd == -1 )
693         return -1;
694
695     DEBUG1 ("** closing handle for fd %d\n", fd);
696     kill_reader (fd);
697     kill_writer (fd);
698     LOCK (notify_table_lock);
699     for ( i=0; i < DIM (notify_table); i++ ) {
700         if (notify_table[i].inuse && notify_table[i].fd == fd) {
701             handler = notify_table[i].handler;
702             value   = notify_table[i].value;
703             notify_table[i].handler = NULL;
704             notify_table[i].value = NULL;
705             notify_table[i].inuse = 0;
706             break;
707         }
708     }
709     UNLOCK (notify_table_lock);
710     if (handler)
711         handler (fd, value);
712
713     if ( !CloseHandle (fd_to_handle (fd)) ) { 
714         DEBUG2 ("CloseHandle for fd %d failed: ec=%d\n",
715                  fd, (int)GetLastError ());
716         return -1;
717     }
718
719     return 0;
720 }
721
722 int
723 _gpgme_io_set_close_notify (int fd, void (*handler)(int, void*), void *value)
724 {
725     int i;
726
727     assert (fd != -1);
728
729     LOCK (notify_table_lock);
730     for (i=0; i < DIM (notify_table); i++ ) {
731         if ( notify_table[i].inuse && notify_table[i].fd == fd )
732             break;
733     }
734     if ( i == DIM (notify_table) ) {
735         for (i=0; i < DIM (notify_table); i++ ) {
736             if ( !notify_table[i].inuse )
737                 break;
738         }
739     }
740     if ( i == DIM (notify_table) ) {
741         UNLOCK (notify_table_lock);
742         return -1;
743     }
744     notify_table[i].fd = fd;
745     notify_table[i].handler = handler;
746     notify_table[i].value = value;
747     notify_table[i].inuse = 1;
748     UNLOCK (notify_table_lock);
749     DEBUG2 ("set notification for fd %d (idx=%d)", fd, i );
750     return 0;
751 }
752
753
754 int
755 _gpgme_io_set_nonblocking ( int fd )
756 {
757     return 0;
758 }
759
760
761 static char *
762 build_commandline ( char **argv )
763 {
764     int i, n = 0;
765     char *buf, *p;
766
767     /* FIXME: we have to quote some things because under Windows the 
768      * program parses the commandline and does some unquoting */
769     for (i=0; argv[i]; i++)
770         n += strlen (argv[i]) + 2 + 1; /* 2 extra bytes for possible quoting */
771     buf = p = malloc (n);
772     if ( !buf )
773         return NULL;
774     *buf = 0;
775     if ( argv[0] )
776         p = stpcpy (p, argv[0]);
777     for (i = 1; argv[i]; i++) {
778         if (!*argv[i])
779             p = stpcpy (p, " \"\"");
780         else
781             p = stpcpy (stpcpy (p, " "), argv[i]);
782     }
783
784     return buf;
785 }
786
787
788 int
789 _gpgme_io_spawn ( const char *path, char **argv,
790                   struct spawn_fd_item_s *fd_child_list,
791                   struct spawn_fd_item_s *fd_parent_list )
792 {
793     SECURITY_ATTRIBUTES sec_attr;
794     PROCESS_INFORMATION pi = {
795         NULL,      /* returns process handle */
796         0,         /* returns primary thread handle */
797         0,         /* returns pid */
798         0         /* returns tid */
799     };
800     STARTUPINFO si;
801     char *envblock = NULL;
802     int cr_flags = CREATE_DEFAULT_ERROR_MODE
803                  | GetPriorityClass (GetCurrentProcess ());
804     int i;
805     char *arg_string;
806     int duped_stdin = 0;
807     int duped_stderr = 0;
808     HANDLE hnul = INVALID_HANDLE_VALUE;
809     /* FIXME.  */
810     int debug_me = 0;
811
812     memset (&sec_attr, 0, sizeof sec_attr );
813     sec_attr.nLength = sizeof sec_attr;
814     sec_attr.bInheritHandle = FALSE;
815
816     arg_string = build_commandline ( argv );
817     if (!arg_string )
818         return -1; 
819
820     memset (&si, 0, sizeof si);
821     si.cb = sizeof (si);
822     si.dwFlags = STARTF_USESTDHANDLES | STARTF_USESHOWWINDOW;
823     si.wShowWindow = debug_me? SW_SHOW : SW_MINIMIZE;
824     si.hStdInput = GetStdHandle (STD_INPUT_HANDLE);
825     si.hStdOutput = GetStdHandle (STD_OUTPUT_HANDLE);
826     si.hStdError = GetStdHandle (STD_ERROR_HANDLE);
827
828     for (i=0; fd_child_list[i].fd != -1; i++ ) {
829         if (fd_child_list[i].dup_to == 0 ) {
830             si.hStdInput = fd_to_handle (fd_child_list[i].fd);
831             DEBUG1 ("using %d for stdin", fd_child_list[i].fd );
832             duped_stdin=1;
833         }
834         else if (fd_child_list[i].dup_to == 1 ) {
835             si.hStdOutput = fd_to_handle (fd_child_list[i].fd);
836             DEBUG1 ("using %d for stdout", fd_child_list[i].fd );
837         }
838         else if (fd_child_list[i].dup_to == 2 ) {
839             si.hStdError = fd_to_handle (fd_child_list[i].fd);
840             DEBUG1 ("using %d for stderr", fd_child_list[i].fd );
841             duped_stderr = 1;
842         }
843     }
844
845     if( !duped_stdin || !duped_stderr ) {
846         SECURITY_ATTRIBUTES sa;
847
848         memset (&sa, 0, sizeof sa );
849         sa.nLength = sizeof sa;
850         sa.bInheritHandle = TRUE;
851         hnul = CreateFile ( "nul",
852                             GENERIC_READ|GENERIC_WRITE,
853                             FILE_SHARE_READ|FILE_SHARE_WRITE,
854                             &sa,
855                             OPEN_EXISTING,
856                             FILE_ATTRIBUTE_NORMAL,
857                             NULL );
858         if ( hnul == INVALID_HANDLE_VALUE ) {
859             DEBUG1 ("can't open `nul': ec=%d\n", (int)GetLastError ());
860             free (arg_string);
861             return -1;
862         }
863         /* Make sure that the process has a connected stdin */
864         if ( !duped_stdin ) {
865             si.hStdInput = hnul;
866             DEBUG1 ("using %d for dummy stdin", (int)hnul );
867         }
868         /* We normally don't want all the normal output */
869         if ( !duped_stderr ) {
870             si.hStdError = hnul;
871             DEBUG1 ("using %d for dummy stderr", (int)hnul );
872         }
873     }
874
875     DEBUG2 ("CreateProcess, path=`%s' args=`%s'", path, arg_string);
876     cr_flags |= CREATE_SUSPENDED; 
877     if ( !CreateProcessA (path,
878                           arg_string,
879                           &sec_attr,     /* process security attributes */
880                           &sec_attr,     /* thread security attributes */
881                           TRUE,          /* inherit handles */
882                           cr_flags,      /* creation flags */
883                           envblock,      /* environment */
884                           NULL,          /* use current drive/directory */
885                           &si,           /* startup information */
886                           &pi            /* returns process information */
887         ) ) {
888         DEBUG1 ("CreateProcess failed: ec=%d\n", (int) GetLastError ());
889         free (arg_string);
890         return -1;
891     }
892
893     /* close the /dev/nul handle if used */
894     if (hnul != INVALID_HANDLE_VALUE ) {
895         if ( !CloseHandle ( hnul ) )
896             DEBUG1 ("CloseHandle(hnul) failed: ec=%d\n", (int)GetLastError());
897     }
898
899     /* Close the other ends of the pipes */
900     for (i = 0; fd_parent_list[i].fd != -1; i++)
901       _gpgme_io_close (fd_parent_list[i].fd);
902
903     DEBUG4 ("CreateProcess ready\n"
904             "-   hProcess=%p  hThread=%p\n"
905             "-   dwProcessID=%d dwThreadId=%d\n",
906             pi.hProcess, pi.hThread, 
907             (int) pi.dwProcessId, (int) pi.dwThreadId);
908
909     if ( ResumeThread ( pi.hThread ) < 0 ) {
910         DEBUG1 ("ResumeThread failed: ec=%d\n", (int)GetLastError ());
911     }
912
913     if ( !CloseHandle (pi.hThread) ) { 
914         DEBUG1 ("CloseHandle of thread failed: ec=%d\n",
915                  (int)GetLastError ());
916     }
917
918     return handle_to_pid (pi.hProcess);
919 }
920
921
922
923
924 int
925 _gpgme_io_waitpid ( int pid, int hang, int *r_status, int *r_signal )
926 {
927     HANDLE proc = fd_to_handle (pid);
928     int code, ret = 0;
929     DWORD exc;
930
931     *r_status = 0;
932     *r_signal = 0;
933     code = WaitForSingleObject ( proc, hang? INFINITE : 0 );
934     switch (code) {
935       case WAIT_FAILED:
936         DEBUG2 ("WFSO pid=%d failed: %d\n", (int)pid, (int)GetLastError () );
937         break;
938
939       case WAIT_OBJECT_0:
940         if (!GetExitCodeProcess (proc, &exc)) {
941             DEBUG2 ("** GECP pid=%d failed: ec=%d\n",
942                     (int)pid, (int)GetLastError () );
943             *r_status = 4; 
944         }
945         else {
946             DEBUG2 ("GECP pid=%d exit code=%d\n", (int)pid,  exc);
947             *r_status = exc;
948         }
949         ret = 1;
950         break;
951
952       case WAIT_TIMEOUT:
953         if (hang)
954             DEBUG1 ("WFSO pid=%d timed out\n", (int)pid);
955         break;
956
957       default:
958         DEBUG2 ("WFSO pid=%d returned %d\n", (int)pid, code );
959         break;
960     }
961     return ret;
962 }
963
964 int
965 _gpgme_io_kill ( int pid, int hard )
966 {
967     HANDLE proc = fd_to_handle (pid);
968
969     #warning I am not sure how to kill a process
970     /* fixme: figure out how this can be done */
971     return 0;
972 }
973
974
975
976 /*
977  * Select on the list of fds.
978  * Returns: -1 = error
979  *           0 = timeout or nothing to select
980  *          >0 = number of signaled fds
981  */
982 int
983 _gpgme_io_select ( struct io_select_fd_s *fds, size_t nfds, int nonblock )
984 {
985     HANDLE waitbuf[MAXIMUM_WAIT_OBJECTS];
986     int    waitidx[MAXIMUM_WAIT_OBJECTS];
987     int code, nwait;
988     int i, any;
989     int count;
990     void *dbg_help;
991
992  restart:
993     DEBUG_BEGIN (dbg_help, 3, "select on [ ");
994     any = 0;
995     nwait = 0;
996     count = 0;
997     for ( i=0; i < nfds; i++ ) {
998         if ( fds[i].fd == -1 ) 
999             continue;
1000         fds[i].signaled = 0;
1001         if ( fds[i].for_read || fds[i].for_write ) {
1002             if ( fds[i].frozen ) {
1003                 DEBUG_ADD1 (dbg_help, "f%d ", fds[i].fd );
1004             }
1005             else if ( fds[i].for_read ) {
1006                 struct reader_context_s *c = find_reader (fds[i].fd,1);
1007                 
1008                 if (!c) { 
1009                     DEBUG1 ("oops: no reader thread for fd %d", fds[i].fd);
1010                 }
1011                 else {
1012                     if ( nwait >= DIM (waitbuf) ) {
1013                         DEBUG_END (dbg_help, "oops ]");
1014                         DEBUG0 ("Too many objects for WFMO!" );
1015                         return -1;
1016                     }
1017                     waitidx[nwait]   = i;
1018                     waitbuf[nwait++] = c->have_data_ev;
1019                 }
1020                 DEBUG_ADD1 (dbg_help, "r%d ", fds[i].fd );
1021                 any = 1;
1022             }
1023             else if ( fds[i].for_write ) {
1024                 struct writer_context_s *c = find_writer (fds[i].fd,1);
1025                 
1026                 if (!c) { 
1027                     DEBUG1 ("oops: no writer thread for fd %d", fds[i].fd);
1028                 }
1029                 else {
1030                     if ( nwait >= DIM (waitbuf) ) {
1031                         DEBUG_END (dbg_help, "oops ]");
1032                         DEBUG0 ("Too many objects for WFMO!" );
1033                         return -1;
1034                     }
1035                     LOCK (c->mutex);
1036                     if ( !c->nbytes ) {
1037                         waitidx[nwait]   = i;
1038                         waitbuf[nwait++] = c->is_empty;
1039                         DEBUG_ADD1 (dbg_help, "w%d ", fds[i].fd );
1040                         any = 1;
1041                     }
1042                     else {
1043                         DEBUG_ADD1 (dbg_help, "w%d(ignored) ", fds[i].fd );
1044                     }
1045                     UNLOCK (c->mutex);
1046                 }
1047             }
1048         }
1049     }
1050     DEBUG_END (dbg_help, "]");
1051     if (!any) 
1052         return 0;
1053
1054     code = WaitForMultipleObjects ( nwait, waitbuf, 0, nonblock ? 0 : 1000);
1055     if ( code >= WAIT_OBJECT_0 && code < WAIT_OBJECT_0 + nwait ) {
1056         /* This WFMO is a really silly function:  It does return either
1057          * the index of the signaled object or if 2 objects have been
1058          * signalled at the same time, the index of the object with the
1059          * lowest object is returned - so and how do we find out
1060          * how many objects have been signaled???.
1061          * The only solution I can imagine is to test each object starting
1062          * with the returned index individually - how dull.
1063          */
1064         any = 0;
1065         for (i=code - WAIT_OBJECT_0; i < nwait; i++ ) {
1066             if (WaitForSingleObject ( waitbuf[i], NULL ) == WAIT_OBJECT_0) {
1067                 assert (waitidx[i] >=0 && waitidx[i] < nfds);
1068                 fds[waitidx[i]].signaled = 1;
1069                 any = 1;
1070                 count++;
1071             }
1072         }
1073         if (!any) {
1074             DEBUG0 ("Oops: No signaled objects found after WFMO");
1075             count = -1;
1076         }
1077     }
1078     else if ( code == WAIT_TIMEOUT ) {
1079         DEBUG0 ("WFMO timed out\n" );
1080     }  
1081     else if (code == WAIT_FAILED ) {
1082         int le = (int)GetLastError ();
1083         if ( le == ERROR_INVALID_HANDLE ) {
1084             int k, j = handle_to_fd (waitbuf[i]);
1085                     
1086             DEBUG1 ("WFMO invalid handle %d removed\n", j);
1087             for (k=0 ; k < nfds; i++ ) {
1088                 if ( fds[k].fd == j ) {
1089                     fds[k].for_read = fds[k].for_write = 0;
1090                     goto restart;
1091                 }
1092             }
1093             DEBUG0 (" oops, or not???\n");
1094         }
1095         DEBUG1 ("WFMO failed: %d\n", le );
1096         count = -1;
1097     }
1098     else {
1099         DEBUG1 ("WFMO returned %d\n", code );
1100         count = -1;
1101     }
1102
1103     if ( count ) {
1104         DEBUG_BEGIN (dbg_help, 3, " signaled [ ");
1105         for ( i=0; i < nfds; i++ ) {
1106             if ( fds[i].fd == -1 ) 
1107                 continue;
1108             if ( (fds[i].for_read || fds[i].for_write) && fds[i].signaled ) {
1109                 DEBUG_ADD2 (dbg_help, "%c%d ",
1110                             fds[i].for_read? 'r':'w',fds[i].fd );
1111             }
1112         }
1113         DEBUG_END (dbg_help, "]");
1114     }
1115     
1116     return count;
1117 }