Use a writer thread under W32 (arggg)
[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 #define WRITEBUF_SIZE 4096
55 #define MAX_READERS 20
56 #define MAX_WRITERS 20
57
58 static struct {
59     int inuse;
60     int fd;
61     void (*handler)(int,void*);
62     void *value;
63 } notify_table[256];
64 DEFINE_STATIC_LOCK (notify_table_lock);
65
66
67 struct reader_context_s {
68     HANDLE file_hd;
69     HANDLE thread_hd;   
70     DECLARE_LOCK (mutex);
71
72     int stop_me;
73     int eof;
74     int eof_shortcut;
75     int error;
76     int error_code;
77
78     HANDLE have_data_ev;  /* manually reset */
79     HANDLE have_space_ev; /* auto reset */
80     HANDLE stopped;
81     size_t readpos, writepos;
82     char buffer[READBUF_SIZE];
83 };
84
85
86 static struct {
87     volatile int used;
88     int fd;
89     struct reader_context_s *context;
90 } reader_table[MAX_READERS];
91 static int reader_table_size= MAX_READERS;
92 DEFINE_STATIC_LOCK (reader_table_lock);
93
94
95 struct writer_context_s {
96     HANDLE file_hd;
97     HANDLE thread_hd;   
98     DECLARE_LOCK (mutex);
99
100     int stop_me;
101     int error;
102     int error_code;
103
104     HANDLE have_data;  /* manually reset */
105     HANDLE is_empty;
106     HANDLE stopped;
107     size_t nbytes; 
108     char buffer[WRITEBUF_SIZE];
109 };
110
111
112 static struct {
113     volatile int used;
114     int fd;
115     struct writer_context_s *context;
116 } writer_table[MAX_WRITERS];
117 static int writer_table_size= MAX_WRITERS;
118 DEFINE_STATIC_LOCK (writer_table_lock);
119
120
121
122 static HANDLE
123 set_synchronize (HANDLE h)
124 {
125     HANDLE tmp;
126     
127     /* For NT we have to set the sync flag.  It seems that the only
128      * way to do it is by duplicating the handle.  Tsss.. */
129     if (!DuplicateHandle( GetCurrentProcess(), h,
130                           GetCurrentProcess(), &tmp,
131                           EVENT_MODIFY_STATE|SYNCHRONIZE, FALSE, 0 ) ) {
132         DEBUG1 ("** Set SYNCRONIZE failed: ec=%d\n", (int)GetLastError());
133     }
134     else {
135         CloseHandle (h);
136         h = tmp;
137     }
138     return h;
139 }
140
141
142
143 static DWORD CALLBACK 
144 reader (void *arg)
145 {
146     struct reader_context_s *c = arg;
147     int nbytes;
148     DWORD nread;
149
150     DEBUG2 ("reader thread %p for file %p started", c->thread_hd, c->file_hd );
151     for (;;) {
152         LOCK (c->mutex);
153         /* leave a 1 byte gap so that we can see whether it is empty or full*/
154         if ((c->writepos + 1) % READBUF_SIZE == c->readpos) { 
155             /* wait for space */
156             if (!ResetEvent (c->have_space_ev) )
157                 DEBUG1 ("ResetEvent failed: ec=%d", (int)GetLastError ());
158             UNLOCK (c->mutex);
159             DEBUG1 ("reader thread %p: waiting for space ...", c->thread_hd );
160             WaitForSingleObject (c->have_space_ev, INFINITE);
161             DEBUG1 ("reader thread %p: got space", c->thread_hd );
162             LOCK (c->mutex);
163         }
164         if ( c->stop_me ) {
165             UNLOCK (c->mutex);
166             break;
167         }
168         nbytes = (c->readpos + READBUF_SIZE - c->writepos-1) % READBUF_SIZE;
169         if ( nbytes > READBUF_SIZE - c->writepos )
170             nbytes = READBUF_SIZE - c->writepos;
171         UNLOCK (c->mutex);
172
173         DEBUG2 ("reader thread %p: reading %d bytes", c->thread_hd, nbytes );
174         if ( !ReadFile ( c->file_hd,
175                          c->buffer+c->writepos, nbytes, &nread, NULL) ) {
176             c->error_code = (int)GetLastError ();
177             if (c->error_code == ERROR_BROKEN_PIPE ) {
178                 c->eof=1;
179                 DEBUG1 ("reader thread %p: got eof (broken pipe)",
180                         c->thread_hd );
181             }
182             else {
183                 c->error = 1;
184                 DEBUG2 ("reader thread %p: read error: ec=%d",
185                         c->thread_hd, c->error_code );
186             }
187             break;
188         }
189         if ( !nread ) {
190             c->eof = 1;
191             DEBUG1 ("reader thread %p: got eof", c->thread_hd );
192             break;
193         }
194         DEBUG2 ("reader thread %p: got %d bytes", c->thread_hd, (int)nread );
195       
196         LOCK (c->mutex);
197         if (c->stop_me) {
198             UNLOCK (c->mutex);
199             break;
200         }
201         c->writepos = (c->writepos + nread) % READBUF_SIZE;
202         if ( !SetEvent (c->have_data_ev) )
203             DEBUG1 ("SetEvent failed: ec=%d", (int)GetLastError ());
204         UNLOCK (c->mutex);
205     }
206     /* indicate that we have an error or eof */
207     if ( !SetEvent (c->have_data_ev) )
208         DEBUG1 ("SetEvent failed: ec=%d", (int)GetLastError ());
209     DEBUG1 ("reader thread %p ended", c->thread_hd );
210     SetEvent (c->stopped);
211
212     return 0;
213 }
214
215
216 static struct reader_context_s *
217 create_reader (HANDLE fd)
218 {
219     struct reader_context_s *c;
220     SECURITY_ATTRIBUTES sec_attr;
221     DWORD tid;
222
223     DEBUG1 ("creating new read thread for file handle %p", fd );
224     memset (&sec_attr, 0, sizeof sec_attr );
225     sec_attr.nLength = sizeof sec_attr;
226     sec_attr.bInheritHandle = FALSE;
227
228     c = xtrycalloc (1, sizeof *c );
229     if (!c)
230         return NULL;
231
232     c->file_hd = fd;
233     c->have_data_ev = CreateEvent (&sec_attr, TRUE, FALSE, NULL);
234     c->have_space_ev = CreateEvent (&sec_attr, FALSE, TRUE, NULL);
235     c->stopped = CreateEvent (&sec_attr, TRUE, FALSE, NULL);
236     if (!c->have_data_ev || !c->have_space_ev || !c->stopped ) {
237         DEBUG1 ("** CreateEvent failed: ec=%d\n", (int)GetLastError ());
238         if (c->have_data_ev)
239             CloseHandle (c->have_data_ev);
240         if (c->have_space_ev)
241             CloseHandle (c->have_space_ev);
242         if (c->stopped)
243             CloseHandle (c->stopped);
244         xfree (c);
245         return NULL;
246     }
247
248     c->have_data_ev = set_synchronize (c->have_data_ev);
249     INIT_LOCK (c->mutex);
250
251     c->thread_hd = CreateThread (&sec_attr, 0, reader, c, 0, &tid );
252     if (!c->thread_hd) {
253         DEBUG1 ("** failed to create reader thread: ec=%d\n",
254                  (int)GetLastError ());
255         DESTROY_LOCK (c->mutex);
256         if (c->have_data_ev)
257             CloseHandle (c->have_data_ev);
258         if (c->have_space_ev)
259             CloseHandle (c->have_space_ev);
260         if (c->stopped)
261             CloseHandle (c->stopped);
262         xfree (c);
263         return NULL;
264     }    
265
266     return c;
267 }
268
269 static void
270 destroy_reader (struct reader_context_s *c)
271 {
272     c->stop_me = 1;
273     if (c->have_space_ev) 
274         SetEvent (c->have_space_ev);
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     xfree (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 = xtrycalloc (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         xfree (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         xfree (c);
514         return NULL;
515     }    
516
517     return c;
518 }
519
520 static void
521 destroy_writer (struct writer_context_s *c)
522 {
523     c->stop_me = 1;
524     if (c->have_data) 
525         SetEvent (c->have_data);
526
527     DEBUG1 ("waiting for thread %p termination ...", c->thread_hd );
528     WaitForSingleObject (c->stopped, INFINITE);
529     DEBUG1 ("thread %p has terminated", c->thread_hd );
530     
531     if (c->stopped)
532         CloseHandle (c->stopped);
533     if (c->have_data)
534         CloseHandle (c->have_data);
535     if (c->is_empty)
536         CloseHandle (c->is_empty);
537     CloseHandle (c->thread_hd);
538     DESTROY_LOCK (c->mutex);
539     xfree (c);
540 }
541
542
543 /* 
544  * Find a writer context or create a new one 
545  * Note that the writer context will last until a io_close.
546  */
547 static struct writer_context_s *
548 find_writer (int fd, int start_it)
549 {
550     int i;
551
552     for (i=0; i < writer_table_size ; i++ ) {
553         if ( writer_table[i].used && writer_table[i].fd == fd )
554             return writer_table[i].context;
555     }
556     if (!start_it)
557         return NULL;
558
559     LOCK (writer_table_lock);
560     for (i=0; i < writer_table_size; i++ ) {
561         if (!writer_table[i].used) {
562             writer_table[i].fd = fd;
563             writer_table[i].context = create_writer (fd_to_handle (fd));
564             writer_table[i].used = 1;
565             UNLOCK (writer_table_lock);
566             return writer_table[i].context;
567         }
568     }
569     UNLOCK (writer_table_lock);
570     return NULL;
571 }
572
573
574 static void
575 kill_writer (int fd)
576 {
577     int i;
578
579     LOCK (writer_table_lock);
580     for (i=0; i < writer_table_size; i++ ) {
581         if (writer_table[i].used && writer_table[i].fd == fd ) {
582             destroy_writer (writer_table[i].context);
583             writer_table[i].context = NULL;
584             writer_table[i].used = 0;
585             break;
586         }
587     }
588     UNLOCK (writer_table_lock);
589 }
590
591
592
593
594 int
595 _gpgme_io_write ( int fd, const void *buffer, size_t count )
596 {
597     struct writer_context_s *c = find_writer (fd,1);
598
599     DEBUG2 ("fd %d: about to write %d bytes\n", fd, (int)count );
600     if ( !c ) {
601         DEBUG0 ( "no writer thread\n");
602         return -1;
603     }
604
605     LOCK (c->mutex);
606     if ( c->nbytes ) { /* bytes are pending for send */
607         UNLOCK (c->mutex);
608         DEBUG2 ("fd %d: waiting for empty buffer in thread %p",
609                 fd, c->thread_hd);
610         WaitForSingleObject (c->is_empty, INFINITE);
611         DEBUG2 ("fd %d: thread %p buffer is empty", fd, c->thread_hd);
612         assert (!c->nbytes);
613         LOCK (c->mutex);
614     }
615     
616     if ( c->error) {
617         UNLOCK (c->mutex);
618         DEBUG1 ("fd %d: write error", fd );
619         return -1;
620     }
621       
622     if (count > WRITEBUF_SIZE)
623         count = WRITEBUF_SIZE;
624     memcpy (c->buffer, buffer, count);
625     c->nbytes = count;
626     if (!SetEvent (c->have_data))
627         DEBUG1 ("SetEvent failed: ec=%d", (int)GetLastError ());
628     UNLOCK (c->mutex);
629
630     DEBUG2 ("fd %d:         copied %d bytes\n",
631                    fd, (int)count );
632     return (int)count;
633 }
634
635
636 int
637 _gpgme_io_pipe ( int filedes[2], int inherit_idx )
638 {
639     HANDLE r, w;
640     SECURITY_ATTRIBUTES sec_attr;
641
642     memset (&sec_attr, 0, sizeof sec_attr );
643     sec_attr.nLength = sizeof sec_attr;
644     sec_attr.bInheritHandle = FALSE;
645     
646     if (!CreatePipe ( &r, &w, &sec_attr, 0))
647         return -1;
648     /* make one end inheritable */
649     if ( inherit_idx == 0 ) {
650         HANDLE h;
651         if (!DuplicateHandle( GetCurrentProcess(), r,
652                               GetCurrentProcess(), &h, 0,
653                               TRUE, DUPLICATE_SAME_ACCESS ) ) {
654             DEBUG1 ("DuplicateHandle failed: ec=%d\n", (int)GetLastError());
655             CloseHandle (r);
656             CloseHandle (w);
657             return -1;
658         }
659         CloseHandle (r);
660         r = h;
661     }
662     else if ( inherit_idx == 1 ) {
663         HANDLE h;
664         if (!DuplicateHandle( GetCurrentProcess(), w,
665                               GetCurrentProcess(), &h, 0,
666                               TRUE, DUPLICATE_SAME_ACCESS ) ) {
667             DEBUG1 ("DuplicateHandle failed: ec=%d\n", (int)GetLastError());
668             CloseHandle (r);
669             CloseHandle (w);
670             return -1;
671         }
672         CloseHandle (w);
673         w = h;
674     }
675
676     filedes[0] = handle_to_fd (r);
677     filedes[1] = handle_to_fd (w);
678     DEBUG5 ("CreatePipe %p %p %d %d inherit=%d\n", r, w,
679                    filedes[0], filedes[1], inherit_idx );
680     return 0;
681 }
682
683 int
684 _gpgme_io_close ( int fd )
685 {
686     int i;
687     void (*handler)(int, void*) = NULL;
688     void *value = NULL;
689
690     if ( fd == -1 )
691         return -1;
692
693     DEBUG1 ("** closing handle for fd %d\n", fd);
694     kill_reader (fd);
695     kill_writer (fd);
696     LOCK (notify_table_lock);
697     for ( i=0; i < DIM (notify_table); i++ ) {
698         if (notify_table[i].inuse && notify_table[i].fd == fd) {
699             handler = notify_table[i].handler;
700             value   = notify_table[i].value;
701             notify_table[i].handler = NULL;
702             notify_table[i].value = NULL;
703             notify_table[i].inuse = 0;
704             break;
705         }
706     }
707     UNLOCK (notify_table_lock);
708     if (handler)
709         handler (fd, value);
710
711     if ( !CloseHandle (fd_to_handle (fd)) ) { 
712         DEBUG2 ("CloseHandle for fd %d failed: ec=%d\n",
713                  fd, (int)GetLastError ());
714         return -1;
715     }
716
717     return 0;
718 }
719
720 int
721 _gpgme_io_set_close_notify (int fd, void (*handler)(int, void*), void *value)
722 {
723     int i;
724
725     assert (fd != -1);
726
727     LOCK (notify_table_lock);
728     for (i=0; i < DIM (notify_table); i++ ) {
729         if ( notify_table[i].inuse && notify_table[i].fd == fd )
730             break;
731     }
732     if ( i == DIM (notify_table) ) {
733         for (i=0; i < DIM (notify_table); i++ ) {
734             if ( !notify_table[i].inuse )
735                 break;
736         }
737     }
738     if ( i == DIM (notify_table) ) {
739         UNLOCK (notify_table_lock);
740         return -1;
741     }
742     notify_table[i].fd = fd;
743     notify_table[i].handler = handler;
744     notify_table[i].value = value;
745     notify_table[i].inuse = 1;
746     UNLOCK (notify_table_lock);
747     DEBUG2 ("set notification for fd %d (idx=%d)", fd, i );
748     return 0;
749 }
750
751
752 int
753 _gpgme_io_set_nonblocking ( int fd )
754 {
755     return 0;
756 }
757
758
759 static char *
760 build_commandline ( char **argv )
761 {
762     int i, n = 0;
763     char *buf, *p;
764
765     /* FIXME: we have to quote some things because under Windows the 
766      * program parses the commandline and does some unquoting */
767     for (i=0; argv[i]; i++)
768         n += strlen (argv[i]) + 1;
769     buf = p = xtrymalloc (n);
770     if ( !buf )
771         return NULL;
772     *buf = 0;
773     if ( argv[0] )
774         p = stpcpy (p, argv[0]);
775     for (i = 1; argv[i]; i++)
776         p = stpcpy (stpcpy (p, " "), argv[i]);
777
778     return buf;
779 }
780
781
782 int
783 _gpgme_io_spawn ( const char *path, char **argv,
784                   struct spawn_fd_item_s *fd_child_list,
785                   struct spawn_fd_item_s *fd_parent_list )
786 {
787     SECURITY_ATTRIBUTES sec_attr;
788     PROCESS_INFORMATION pi = {
789         NULL,      /* returns process handle */
790         0,         /* returns primary thread handle */
791         0,         /* returns pid */
792         0         /* returns tid */
793     };
794     STARTUPINFO si;
795     char *envblock = NULL;
796     int cr_flags = CREATE_DEFAULT_ERROR_MODE
797                  | GetPriorityClass (GetCurrentProcess ());
798     int i;
799     char *arg_string;
800     int duped_stdin = 0;
801     int duped_stderr = 0;
802     HANDLE hnul = INVALID_HANDLE_VALUE;
803     int debug_me = !!getenv ("GPGME_DEBUG");
804
805     memset (&sec_attr, 0, sizeof sec_attr );
806     sec_attr.nLength = sizeof sec_attr;
807     sec_attr.bInheritHandle = FALSE;
808
809     arg_string = build_commandline ( argv );
810     if (!arg_string )
811         return -1; 
812
813     memset (&si, 0, sizeof si);
814     si.cb = sizeof (si);
815     si.dwFlags = STARTF_USESTDHANDLES | STARTF_USESHOWWINDOW;
816     si.wShowWindow = debug_me? SW_SHOW : SW_MINIMIZE;
817     si.hStdInput = GetStdHandle (STD_INPUT_HANDLE);
818     si.hStdOutput = GetStdHandle (STD_OUTPUT_HANDLE);
819     si.hStdError = GetStdHandle (STD_ERROR_HANDLE);
820
821     for (i=0; fd_child_list[i].fd != -1; i++ ) {
822         if (fd_child_list[i].dup_to == 0 ) {
823             si.hStdInput = fd_to_handle (fd_child_list[i].fd);
824             DEBUG1 ("using %d for stdin", fd_child_list[i].fd );
825             duped_stdin=1;
826         }
827         else if (fd_child_list[i].dup_to == 1 ) {
828             si.hStdOutput = fd_to_handle (fd_child_list[i].fd);
829             DEBUG1 ("using %d for stdout", fd_child_list[i].fd );
830         }
831         else if (fd_child_list[i].dup_to == 2 ) {
832             si.hStdError = fd_to_handle (fd_child_list[i].fd);
833             DEBUG1 ("using %d for stderr", fd_child_list[i].fd );
834             duped_stderr = 1;
835         }
836     }
837
838     if( !duped_stdin || !duped_stderr ) {
839         SECURITY_ATTRIBUTES sa;
840
841         memset (&sa, 0, sizeof sa );
842         sa.nLength = sizeof sa;
843         sa.bInheritHandle = TRUE;
844         hnul = CreateFile ( "nul",
845                             GENERIC_READ|GENERIC_WRITE,
846                             FILE_SHARE_READ|FILE_SHARE_WRITE,
847                             &sa,
848                             OPEN_EXISTING,
849                             FILE_ATTRIBUTE_NORMAL,
850                             NULL );
851         if ( hnul == INVALID_HANDLE_VALUE ) {
852             DEBUG1 ("can't open `nul': ec=%d\n", (int)GetLastError ());
853             xfree (arg_string);
854             return -1;
855         }
856         /* Make sure that the process has a connected stdin */
857         if ( !duped_stdin ) {
858             si.hStdInput = hnul;
859             DEBUG1 ("using %d for dummy stdin", (int)hnul );
860         }
861         /* We normally don't want all the normal output */
862         if ( !duped_stderr ) {
863             si.hStdError = hnul;
864             DEBUG1 ("using %d for dummy stderr", (int)hnul );
865         }
866     }
867
868     DEBUG2 ("CreateProcess, path=`%s' args=`%s'", path, arg_string);
869     cr_flags |= CREATE_SUSPENDED; 
870     if ( !CreateProcessA (path,
871                           arg_string,
872                           &sec_attr,     /* process security attributes */
873                           &sec_attr,     /* thread security attributes */
874                           TRUE,          /* inherit handles */
875                           cr_flags,      /* creation flags */
876                           envblock,      /* environment */
877                           NULL,          /* use current drive/directory */
878                           &si,           /* startup information */
879                           &pi            /* returns process information */
880         ) ) {
881         DEBUG1 ("CreateProcess failed: ec=%d\n", (int) GetLastError ());
882         xfree (arg_string);
883         return -1;
884     }
885
886     /* close the /dev/nul handle if used */
887     if (hnul != INVALID_HANDLE_VALUE ) {
888         if ( !CloseHandle ( hnul ) )
889             DEBUG1 ("CloseHandle(hnul) failed: ec=%d\n", (int)GetLastError());
890     }
891
892     /* Close the other ends of the pipes */
893     for (i=0; fd_parent_list[i].fd != -1; i++ ) {
894         DEBUG1 ("Closing fd %d\n", fd_parent_list[i].fd );
895         if ( !CloseHandle ( fd_to_handle (fd_parent_list[i].fd) ) )
896             DEBUG1 ("CloseHandle failed: ec=%d", (int)GetLastError());
897     }
898
899     DEBUG4 ("CreateProcess ready\n"
900             "-   hProcess=%p  hThread=%p\n"
901             "-   dwProcessID=%d dwThreadId=%d\n",
902             pi.hProcess, pi.hThread, 
903             (int) pi.dwProcessId, (int) pi.dwThreadId);
904
905     if ( ResumeThread ( pi.hThread ) < 0 ) {
906         DEBUG1 ("ResumeThread failed: ec=%d\n", (int)GetLastError ());
907     }
908
909     if ( !CloseHandle (pi.hThread) ) { 
910         DEBUG1 ("CloseHandle of thread failed: ec=%d\n",
911                  (int)GetLastError ());
912     }
913
914     return handle_to_pid (pi.hProcess);
915 }
916
917
918
919
920 int
921 _gpgme_io_waitpid ( int pid, int hang, int *r_status, int *r_signal )
922 {
923     HANDLE proc = fd_to_handle (pid);
924     int code, ret = 0;
925     DWORD exc;
926
927     *r_status = 0;
928     *r_signal = 0;
929     code = WaitForSingleObject ( proc, hang? INFINITE : 0 );
930     switch (code) {
931       case WAIT_FAILED:
932         DEBUG2 ("WFSO pid=%d failed: %d\n", (int)pid, (int)GetLastError () );
933         break;
934
935       case WAIT_OBJECT_0:
936         if (!GetExitCodeProcess (proc, &exc)) {
937             DEBUG2 ("** GECP pid=%d failed: ec=%d\n",
938                     (int)pid, (int)GetLastError () );
939             *r_status = 4; 
940         }
941         else {
942             DEBUG2 ("GECP pid=%d exit code=%d\n", (int)pid,  exc);
943             *r_status = exc;
944         }
945         ret = 1;
946         break;
947
948       case WAIT_TIMEOUT:
949         if (hang)
950             DEBUG1 ("WFSO pid=%d timed out\n", (int)pid);
951         break;
952
953       default:
954         DEBUG2 ("WFSO pid=%d returned %d\n", (int)pid, code );
955         break;
956     }
957     return ret;
958 }
959
960 int
961 _gpgme_io_kill ( int pid, int hard )
962 {
963     HANDLE proc = fd_to_handle (pid);
964
965     #warning I am not sure how to kill a process
966     /* fixme: figure out how this can be done */
967     return 0;
968 }
969
970
971
972 /*
973  * Select on the list of fds.
974  * Returns: -1 = error
975  *           0 = timeout or nothing to select
976  *          >0 = number of signaled fds
977  */
978 int
979 _gpgme_io_select ( struct io_select_fd_s *fds, size_t nfds )
980 {
981     HANDLE waitbuf[MAXIMUM_WAIT_OBJECTS];
982     int    waitidx[MAXIMUM_WAIT_OBJECTS];
983     int code, nwait;
984     int i, any;
985     int count;
986     void *dbg_help;
987
988  restart:
989     DEBUG_BEGIN (dbg_help, "select on [ ");
990     any = 0;
991     nwait = 0;
992     count = 0;
993     for ( i=0; i < nfds; i++ ) {
994         if ( fds[i].fd == -1 ) 
995             continue;
996         fds[i].signaled = 0;
997         if ( fds[i].for_read || fds[i].for_write ) {
998             if ( fds[i].frozen ) {
999                 DEBUG_ADD1 (dbg_help, "f%d ", fds[i].fd );
1000             }
1001             else if ( fds[i].for_read ) {
1002                 struct reader_context_s *c = find_reader (fds[i].fd,1);
1003                 
1004                 if (!c) { 
1005                     DEBUG1 ("oops: no reader thread for fd %d", fds[i].fd);
1006                 }
1007                 else {
1008                     if ( nwait >= DIM (waitbuf) ) {
1009                         DEBUG_END (dbg_help, "oops ]");
1010                         DEBUG0 ("Too many objects for WFMO!" );
1011                         return -1;
1012                     }
1013                     waitidx[nwait]   = i;
1014                     waitbuf[nwait++] = c->have_data_ev;
1015                 }
1016                 DEBUG_ADD1 (dbg_help, "r%d ", fds[i].fd );
1017                 any = 1;
1018             }
1019             else if ( fds[i].for_write ) {
1020                 struct writer_context_s *c = find_writer (fds[i].fd,1);
1021                 
1022                 if (!c) { 
1023                     DEBUG1 ("oops: no writer thread for fd %d", fds[i].fd);
1024                 }
1025                 else {
1026                     if ( nwait >= DIM (waitbuf) ) {
1027                         DEBUG_END (dbg_help, "oops ]");
1028                         DEBUG0 ("Too many objects for WFMO!" );
1029                         return -1;
1030                     }
1031                     waitidx[nwait]   = i;
1032                     waitbuf[nwait++] = c->is_empty;
1033                 }
1034                 DEBUG_ADD1 (dbg_help, "w%d ", fds[i].fd );
1035                 any = 1;
1036             }
1037         }
1038     }
1039     DEBUG_END (dbg_help, "]");
1040     if (!any) 
1041         return 0;
1042
1043     code = WaitForMultipleObjects ( nwait, waitbuf, 0, 1000);
1044     if ( code >= WAIT_OBJECT_0 && code < WAIT_OBJECT_0 + nwait ) {
1045         /* This WFMO is a really silly function:  It does return either
1046          * the index of the signaled object or if 2 objects have been
1047          * signalled at the same time, the index of the object with the
1048          * lowest object is returned - so and how do we find out
1049          * how many objects have been signaled???.
1050          * The only solution I can imagine is to test each object starting
1051          * with the returned index individually - how dull.
1052          */
1053         any = 0;
1054         for (i=code - WAIT_OBJECT_0; i < nwait; i++ ) {
1055             if (WaitForSingleObject ( waitbuf[i], NULL ) == WAIT_OBJECT_0) {
1056                 assert (waitidx[i] >=0 && waitidx[i] < nfds);
1057                 fds[waitidx[i]].signaled = 1;
1058                 any = 1;
1059                 count++;
1060             }
1061         }
1062         if (!any) {
1063             DEBUG0 ("Oops: No signaled objects found after WFMO");
1064             count = -1;
1065         }
1066     }
1067     else if ( code == WAIT_TIMEOUT ) {
1068         DEBUG0 ("WFMO timed out\n" );
1069     }  
1070     else if (code == WAIT_FAILED ) {
1071         int le = (int)GetLastError ();
1072         if ( le == ERROR_INVALID_HANDLE ) {
1073             int k, j = handle_to_fd (waitbuf[i]);
1074                     
1075             DEBUG1 ("WFMO invalid handle %d removed\n", j);
1076             for (k=0 ; k < nfds; i++ ) {
1077                 if ( fds[k].fd == j ) {
1078                     fds[k].for_read = fds[k].for_write = 0;
1079                     goto restart;
1080                 }
1081             }
1082             DEBUG0 (" oops, or not???\n");
1083         }
1084         DEBUG1 ("WFMO failed: %d\n", le );
1085         count = -1;
1086     }
1087     else {
1088         DEBUG1 ("WFMO returned %d\n", code );
1089         count = -1;
1090     }
1091
1092     if ( count ) {
1093         DEBUG_BEGIN (dbg_help, " signaled [ ");
1094         for ( i=0; i < nfds; i++ ) {
1095             if ( fds[i].fd == -1 ) 
1096                 continue;
1097             if ( (fds[i].for_read || fds[i].for_write) && fds[i].signaled ) {
1098                 DEBUG_ADD2 (dbg_help, "%c%d ",
1099                             fds[i].for_read? 'r':'w',fds[i].fd );
1100             }
1101         }
1102         DEBUG_END (dbg_help, "]");
1103     }
1104     
1105     return count;
1106 }
1107
1108 #endif /*HAVE_DOSISH_SYSTEM*/
1109
1110
1111
1112
1113
1114
1115
1116
1117