Fix socket implementation on Windows.
[gpgme.git] / src / 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, 2004, 2007, 2010 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 Lesser General Public License as
9    published by the Free Software Foundation; either version 2.1 of
10    the License, or (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    Lesser General Public License for more details.
16    
17    You should have received a copy of the GNU Lesser General Public
18    License along with this program; if not, write to the Free Software
19    Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA
20    02111-1307, USA.  */
21
22 #ifdef HAVE_CONFIG_H
23 #include <config.h>
24 #endif
25 #include <stdio.h>
26 #include <stdlib.h>
27 #include <string.h>
28 #include <assert.h>
29 #include <errno.h>
30 #include <fcntl.h>
31 #ifdef HAVE_SYS_TIME_H
32 # include <sys/time.h>
33 #endif
34 #ifdef HAVE_SYS_TYPES_H
35 # include <sys/types.h>
36 #endif
37 #include <io.h>
38
39 #include "util.h"
40
41 #ifdef HAVE_W32CE_SYSTEM
42 #include <assuan.h>
43 #include <winioctl.h>
44 #define GPGCEDEV_IOCTL_UNBLOCK                                        \
45   CTL_CODE (FILE_DEVICE_STREAMS, 2050, METHOD_BUFFERED, FILE_ANY_ACCESS)
46 #define GPGCEDEV_IOCTL_ASSIGN_RVID                                    \
47   CTL_CODE (FILE_DEVICE_STREAMS, 2051, METHOD_BUFFERED, FILE_ANY_ACCESS)
48 #endif
49
50 #include "sema.h"
51 #include "priv-io.h"
52 #include "debug.h"
53
54
55 /* FIXME: Optimize.  */
56 #define MAX_SLAFD 512
57
58 static struct
59 {
60   int used;
61
62   /* If this is not INVALID_HANDLE_VALUE, then it's a handle.  */
63   HANDLE handle;
64
65   /* If this is not INVALID_SOCKET, then it's a Windows socket.  */
66   int socket;
67
68   /* If this is not 0, then it's a rendezvous ID for the pipe server.  */
69   int rvid;
70
71   /* DUP_FROM is -1 if this file descriptor was allocated by pipe or
72      socket functions.  Only then should the handle or socket be
73      destroyed when this FD is closed.  This, together with the fact
74      that dup'ed file descriptors are closed before the file
75      descriptors from which they are dup'ed are closed, ensures that
76      the handle or socket is always valid, and shared among all file
77      descriptors refering to the same underlying object.
78
79      The logic behind this is that there is only one reason for us to
80      dup file descriptors anyway: to allow simpler book-keeping of
81      file descriptors shared between GPGME and libassuan, which both
82      want to close something.  Using the same handle for these
83      duplicates works just fine.  */
84   int dup_from;
85 } fd_table[MAX_SLAFD];  
86
87
88 /* Returns the FD or -1 on resource limit.  */
89 int
90 new_fd (void)
91 {
92   int idx;
93
94   for (idx = 0; idx < MAX_SLAFD; idx++)
95     if (! fd_table[idx].used)
96       break;
97
98   if (idx == MAX_SLAFD)
99     {
100       gpg_err_set_errno (EIO);
101       return -1;
102     }
103
104   fd_table[idx].used = 1;
105   fd_table[idx].handle = INVALID_HANDLE_VALUE;
106   fd_table[idx].socket = INVALID_SOCKET;
107   fd_table[idx].rvid = 0;
108   fd_table[idx].dup_from = -1;
109
110   return idx;
111 }
112
113
114 void
115 release_fd (int fd)
116 {
117   if (fd < 0 || fd >= MAX_SLAFD || !fd_table[fd].used)
118     return;
119
120   fd_table[fd].used = 0;
121   fd_table[fd].handle = INVALID_HANDLE_VALUE;
122   fd_table[fd].socket = INVALID_SOCKET;
123   fd_table[fd].rvid = 0;
124   fd_table[fd].dup_from = -1;
125 }
126
127
128 #define handle_to_fd(a)  ((int)(a))
129
130 #define READBUF_SIZE 4096
131 #define WRITEBUF_SIZE 4096
132 #define PIPEBUF_SIZE  4096
133 #define MAX_READERS 64
134 #define MAX_WRITERS 64
135
136 static struct
137 {
138   int inuse;
139   int fd;
140   _gpgme_close_notify_handler_t handler;
141   void *value;
142 } notify_table[MAX_SLAFD];
143 DEFINE_STATIC_LOCK (notify_table_lock);
144
145
146 struct reader_context_s
147 {
148   HANDLE file_hd;
149   int file_sock;
150   HANDLE thread_hd;     
151   int refcount;
152
153   DECLARE_LOCK (mutex);
154
155   int stop_me;
156   int eof;
157   int eof_shortcut;
158   int error;
159   int error_code;
160   
161   /* This is manually reset.  */
162   HANDLE have_data_ev;
163   /* This is automatically reset.  */
164   HANDLE have_space_ev;
165   HANDLE stopped;
166   size_t readpos, writepos;
167   char buffer[READBUF_SIZE];
168 };
169
170
171 static struct
172 {
173   volatile int used;
174   int fd;
175   struct reader_context_s *context;
176 } reader_table[MAX_READERS];
177 static int reader_table_size= MAX_READERS;
178 DEFINE_STATIC_LOCK (reader_table_lock);
179
180
181 struct writer_context_s
182 {
183   HANDLE file_hd;
184   int file_sock;
185   HANDLE thread_hd;     
186   int refcount;
187
188   DECLARE_LOCK (mutex);
189   
190   int stop_me;
191   int error;
192   int error_code;
193
194   /* This is manually reset.  */
195   HANDLE have_data;
196   HANDLE is_empty;
197   HANDLE stopped;
198   size_t nbytes; 
199   char buffer[WRITEBUF_SIZE];
200 };
201
202
203 static struct
204 {
205   volatile int used;
206   int fd;
207   struct writer_context_s *context;
208 } writer_table[MAX_WRITERS];
209 static int writer_table_size= MAX_WRITERS;
210 DEFINE_STATIC_LOCK (writer_table_lock);
211
212
213 static int
214 get_desired_thread_priority (void)
215 {
216   int value;
217
218   if (!_gpgme_get_conf_int ("IOThreadPriority", &value))
219     {
220       value = THREAD_PRIORITY_HIGHEST;
221       TRACE1 (DEBUG_SYSIO, "gpgme:get_desired_thread_priority", 0,
222               "%d (default)", value);
223     }
224   else
225     {
226       TRACE1 (DEBUG_SYSIO, "gpgme:get_desired_thread_priority", 0,
227               "%d (configured)", value);
228     }
229   return value;
230 }
231
232
233 static HANDLE
234 set_synchronize (HANDLE hd)
235 {
236 #ifdef HAVE_W32CE_SYSTEM
237   return hd;
238 #else
239   HANDLE new_hd;
240
241   /* For NT we have to set the sync flag.  It seems that the only way
242      to do it is by duplicating the handle.  Tsss...  */
243   if (!DuplicateHandle (GetCurrentProcess (), hd,
244                         GetCurrentProcess (), &new_hd,
245                         EVENT_MODIFY_STATE | SYNCHRONIZE, FALSE, 0))
246     {
247       TRACE1 (DEBUG_SYSIO, "gpgme:set_synchronize", hd,
248               "DuplicateHandle failed: ec=%d", (int) GetLastError ());
249       /* FIXME: Should translate the error code.  */
250       gpg_err_set_errno (EIO);
251       return INVALID_HANDLE_VALUE;
252     }
253
254   CloseHandle (hd);
255   return new_hd;
256 #endif
257 }
258
259
260 static DWORD CALLBACK 
261 reader (void *arg)
262 {
263   struct reader_context_s *ctx = arg;
264   int nbytes;
265   DWORD nread;
266   int sock;
267   TRACE_BEG1 (DEBUG_SYSIO, "gpgme:reader", ctx->file_hd,
268               "thread=%p", ctx->thread_hd);
269
270   if (ctx->file_hd != INVALID_HANDLE_VALUE)
271     sock = 0;
272   else
273     sock = 1;
274
275   for (;;)
276     {
277       LOCK (ctx->mutex);
278       /* Leave a 1 byte gap so that we can see whether it is empty or
279          full.  */
280       if ((ctx->writepos + 1) % READBUF_SIZE == ctx->readpos)
281         { 
282           /* Wait for space.  */
283           if (!ResetEvent (ctx->have_space_ev))
284             TRACE_LOG1 ("ResetEvent failed: ec=%d", (int) GetLastError ());
285           UNLOCK (ctx->mutex);
286           TRACE_LOG ("waiting for space");
287           WaitForSingleObject (ctx->have_space_ev, INFINITE);
288           TRACE_LOG ("got space");
289           LOCK (ctx->mutex);
290         }
291       if (ctx->stop_me)
292         {
293           UNLOCK (ctx->mutex);
294           break;
295         }
296       nbytes = (ctx->readpos + READBUF_SIZE
297                 - ctx->writepos - 1) % READBUF_SIZE;
298       if (nbytes > READBUF_SIZE - ctx->writepos)
299         nbytes = READBUF_SIZE - ctx->writepos;
300       UNLOCK (ctx->mutex);
301       
302       TRACE_LOG2 ("%s %d bytes", sock? "receiving":"reading", nbytes);
303
304       if (sock)
305         {
306           int n;
307
308           n = recv (ctx->file_sock, ctx->buffer + ctx->writepos, nbytes, 0);
309           if (n < 0)
310             {
311               ctx->error_code = (int) WSAGetLastError ();
312               if (ctx->error_code == ERROR_BROKEN_PIPE)
313                 {
314                   ctx->eof = 1;
315                   TRACE_LOG ("got EOF (broken connection)");
316                 }
317               else
318                 {
319                   ctx->error = 1;
320                   TRACE_LOG1 ("recv error: ec=%d", ctx->error_code);
321                 }
322               break;
323             }
324           nread = n;
325         }
326       else
327         {
328           if (!ReadFile (ctx->file_hd,
329                          ctx->buffer + ctx->writepos, nbytes, &nread, NULL))
330             {
331               ctx->error_code = (int) GetLastError ();
332               /* NOTE (W32CE): Do not ignore ERROR_BUSY!  Check at
333                  least stop_me if that happens.  */
334               if (ctx->error_code == ERROR_BROKEN_PIPE)
335                 {
336                   ctx->eof = 1;
337                   TRACE_LOG ("got EOF (broken pipe)");
338                 }
339               else
340                 {
341                   ctx->error = 1;
342                   TRACE_LOG1 ("read error: ec=%d", ctx->error_code);
343                 }
344               break;
345             }
346         }
347       LOCK (ctx->mutex);
348       if (ctx->stop_me)
349         {
350           UNLOCK (ctx->mutex);
351           break;
352         }
353       if (!nread)
354         {
355           ctx->eof = 1;
356           TRACE_LOG ("got eof");
357           UNLOCK (ctx->mutex);
358           break;
359         }
360       TRACE_LOG1 ("got %u bytes", nread);
361       
362       ctx->writepos = (ctx->writepos + nread) % READBUF_SIZE;
363       if (!SetEvent (ctx->have_data_ev))
364         TRACE_LOG2 ("SetEvent (0x%x) failed: ec=%d", ctx->have_data_ev,
365                     (int) GetLastError ());
366       UNLOCK (ctx->mutex);
367     }
368   /* Indicate that we have an error or EOF.  */
369   if (!SetEvent (ctx->have_data_ev))
370         TRACE_LOG2 ("SetEvent (0x%x) failed: ec=%d", ctx->have_data_ev,
371                     (int) GetLastError ());
372   SetEvent (ctx->stopped);
373   
374   return TRACE_SUC ();
375 }
376
377
378 static struct reader_context_s *
379 create_reader (int fd)
380 {
381   struct reader_context_s *ctx;
382   SECURITY_ATTRIBUTES sec_attr;
383   DWORD tid;
384
385   TRACE_BEG (DEBUG_SYSIO, "gpgme:create_reader", fd);
386
387   memset (&sec_attr, 0, sizeof sec_attr);
388   sec_attr.nLength = sizeof sec_attr;
389   sec_attr.bInheritHandle = FALSE;
390   
391   ctx = calloc (1, sizeof *ctx);
392   if (!ctx)
393     {
394       TRACE_SYSERR (errno);
395       return NULL;
396     }
397
398   if (fd < 0 || fd >= MAX_SLAFD || !fd_table[fd].used)
399     {
400       TRACE_SYSERR (EIO);
401       return NULL;
402     }
403   ctx->file_hd = fd_table[fd].handle;
404   ctx->file_sock = fd_table[fd].socket;
405
406   ctx->refcount = 1;
407   ctx->have_data_ev = CreateEvent (&sec_attr, TRUE, FALSE, NULL);
408   if (ctx->have_data_ev)
409     ctx->have_space_ev = CreateEvent (&sec_attr, FALSE, TRUE, NULL);
410   if (ctx->have_space_ev)
411     ctx->stopped = CreateEvent (&sec_attr, TRUE, FALSE, NULL);
412   if (!ctx->have_data_ev || !ctx->have_space_ev || !ctx->stopped)
413     {
414       TRACE_LOG1 ("CreateEvent failed: ec=%d", (int) GetLastError ());
415       if (ctx->have_data_ev)
416         CloseHandle (ctx->have_data_ev);
417       if (ctx->have_space_ev)
418         CloseHandle (ctx->have_space_ev);
419       if (ctx->stopped)
420         CloseHandle (ctx->stopped);
421       free (ctx);
422       /* FIXME: Translate the error code.  */
423       TRACE_SYSERR (EIO);
424       return NULL;
425     }
426
427   ctx->have_data_ev = set_synchronize (ctx->have_data_ev);
428   INIT_LOCK (ctx->mutex);
429
430 #ifdef HAVE_W32CE_SYSTEM
431   ctx->thread_hd = CreateThread (&sec_attr, 64 * 1024, reader, ctx,
432                                  STACK_SIZE_PARAM_IS_A_RESERVATION, &tid);
433 #else
434   ctx->thread_hd = CreateThread (&sec_attr, 0, reader, ctx, 0, &tid);
435 #endif
436
437   if (!ctx->thread_hd)
438     {
439       TRACE_LOG1 ("CreateThread failed: ec=%d", (int) GetLastError ());
440       DESTROY_LOCK (ctx->mutex);
441       if (ctx->have_data_ev)
442         CloseHandle (ctx->have_data_ev);
443       if (ctx->have_space_ev)
444         CloseHandle (ctx->have_space_ev);
445       if (ctx->stopped)
446         CloseHandle (ctx->stopped);
447       free (ctx);
448       TRACE_SYSERR (EIO);
449       return NULL;
450     }    
451   else
452     {
453       /* We set the priority of the thread higher because we know that
454          it only runs for a short time.  This greatly helps to
455          increase the performance of the I/O.  */
456       SetThreadPriority (ctx->thread_hd, get_desired_thread_priority ());
457     }
458
459   TRACE_SUC ();
460   return ctx;
461 }
462
463
464 static void
465 destroy_reader (struct reader_context_s *ctx)
466 {
467   LOCK (ctx->mutex);
468   ctx->refcount--;
469   if (ctx->refcount != 0)
470     {
471       UNLOCK (ctx->mutex);
472       return;
473     }
474   ctx->stop_me = 1;
475   if (ctx->have_space_ev) 
476     SetEvent (ctx->have_space_ev);
477   UNLOCK (ctx->mutex);
478
479 #ifdef HAVE_W32CE_SYSTEM
480   /* Scenario: We never create a full pipe, but already started
481      reading.  Then we need to unblock the reader in the pipe driver
482      to make our reader thread notice that we want it to go away.  */
483
484   if (ctx->file_hd != INVALID_HANDLE_VALUE)
485     {
486       if (!DeviceIoControl (ctx->file_hd, GPGCEDEV_IOCTL_UNBLOCK,
487                         NULL, 0, NULL, 0, NULL, NULL))
488         {
489           TRACE1 (DEBUG_SYSIO, "gpgme:destroy_reader", ctx->file_hd,
490                   "unblock control call failed for thread %p", ctx->thread_hd);
491         }
492     }
493 #endif
494
495   TRACE1 (DEBUG_SYSIO, "gpgme:destroy_reader", ctx->file_hd,
496           "waiting for termination of thread %p", ctx->thread_hd);
497   WaitForSingleObject (ctx->stopped, INFINITE);
498   TRACE1 (DEBUG_SYSIO, "gpgme:destroy_reader", ctx->file_hd,
499           "thread %p has terminated", ctx->thread_hd);
500     
501   if (ctx->stopped)
502     CloseHandle (ctx->stopped);
503   if (ctx->have_data_ev)
504     CloseHandle (ctx->have_data_ev);
505   if (ctx->have_space_ev)
506     CloseHandle (ctx->have_space_ev);
507   CloseHandle (ctx->thread_hd);
508   DESTROY_LOCK (ctx->mutex);
509   free (ctx);
510 }
511
512
513 /* Find a reader context or create a new one.  Note that the reader
514    context will last until a _gpgme_io_close.  */
515 static struct reader_context_s *
516 find_reader (int fd, int start_it)
517 {
518   struct reader_context_s *rd = NULL;
519   int i;
520
521   LOCK (reader_table_lock);
522   for (i = 0; i < reader_table_size; i++)
523     if (reader_table[i].used && reader_table[i].fd == fd)
524       rd = reader_table[i].context;
525
526   if (rd || !start_it)
527     {
528       UNLOCK (reader_table_lock);
529       return rd;
530     }
531
532   for (i = 0; i < reader_table_size; i++)
533     if (!reader_table[i].used)
534       break;
535
536   if (i != reader_table_size)
537     {
538       rd = create_reader (fd);
539       reader_table[i].fd = fd;
540       reader_table[i].context = rd;
541       reader_table[i].used = 1;
542     }
543
544   UNLOCK (reader_table_lock);
545   return rd;
546 }
547
548
549 static void
550 kill_reader (int fd)
551 {
552   int i;
553
554   LOCK (reader_table_lock);
555   for (i = 0; i < reader_table_size; i++)
556     {
557       if (reader_table[i].used && reader_table[i].fd == fd)
558         {
559           destroy_reader (reader_table[i].context);
560           reader_table[i].context = NULL;
561           reader_table[i].used = 0;
562           break;
563         }
564     }
565   UNLOCK (reader_table_lock);
566 }
567
568
569 int
570 _gpgme_io_read (int fd, void *buffer, size_t count)
571 {
572   int nread;
573   struct reader_context_s *ctx;
574   TRACE_BEG2 (DEBUG_SYSIO, "_gpgme_io_read", fd,
575               "buffer=%p, count=%u", buffer, count);
576   
577   ctx = find_reader (fd, 1);
578   if (!ctx)
579     {
580       gpg_err_set_errno (EBADF);
581       return TRACE_SYSRES (-1);
582     }
583   if (ctx->eof_shortcut)
584     return TRACE_SYSRES (0);
585
586   LOCK (ctx->mutex);
587   if (ctx->readpos == ctx->writepos && !ctx->error)
588     {
589       /* No data available.  */
590       UNLOCK (ctx->mutex);
591       TRACE_LOG1 ("waiting for data from thread %p", ctx->thread_hd);
592       WaitForSingleObject (ctx->have_data_ev, INFINITE);
593       TRACE_LOG1 ("data from thread %p available", ctx->thread_hd);
594       LOCK (ctx->mutex);
595     }
596   
597   if (ctx->readpos == ctx->writepos || ctx->error)
598     {
599       UNLOCK (ctx->mutex);
600       ctx->eof_shortcut = 1;
601       if (ctx->eof)
602         return TRACE_SYSRES (0);
603       if (!ctx->error)
604         {
605           TRACE_LOG ("EOF but ctx->eof flag not set");
606           return 0;
607         }
608       gpg_err_set_errno (ctx->error_code);
609       return TRACE_SYSRES (-1);
610     }
611   
612   nread = ctx->readpos < ctx->writepos
613     ? ctx->writepos - ctx->readpos
614     : READBUF_SIZE - ctx->readpos;
615   if (nread > count)
616     nread = count;
617   memcpy (buffer, ctx->buffer + ctx->readpos, nread);
618   ctx->readpos = (ctx->readpos + nread) % READBUF_SIZE;
619   if (ctx->readpos == ctx->writepos && !ctx->eof)
620     {
621       if (!ResetEvent (ctx->have_data_ev))
622         {
623           TRACE_LOG1 ("ResetEvent failed: ec=%d", (int) GetLastError ());
624           UNLOCK (ctx->mutex);
625           /* FIXME: Should translate the error code.  */
626           gpg_err_set_errno (EIO);
627           return TRACE_SYSRES (-1);
628         }
629     }
630   if (!SetEvent (ctx->have_space_ev))
631     {
632       TRACE_LOG2 ("SetEvent (0x%x) failed: ec=%d",
633                   ctx->have_space_ev, (int) GetLastError ());
634       UNLOCK (ctx->mutex);
635       /* FIXME: Should translate the error code.  */
636       gpg_err_set_errno (EIO);
637       return TRACE_SYSRES (-1);
638     }
639   UNLOCK (ctx->mutex);
640   
641   TRACE_LOGBUF (buffer, nread);
642   return TRACE_SYSRES (nread);
643 }
644
645
646 /* The writer does use a simple buffering strategy so that we are
647    informed about write errors as soon as possible (i. e. with the the
648    next call to the write function.  */
649 static DWORD CALLBACK 
650 writer (void *arg)
651 {
652   struct writer_context_s *ctx = arg;
653   DWORD nwritten;
654   int sock;
655   TRACE_BEG1 (DEBUG_SYSIO, "gpgme:writer", ctx->file_hd,
656               "thread=%p", ctx->thread_hd);
657
658   if (ctx->file_hd != INVALID_HANDLE_VALUE)
659     sock = 0;
660   else
661     sock = 1;
662
663   for (;;)
664     {
665       LOCK (ctx->mutex);
666       if (ctx->stop_me)
667         {
668           UNLOCK (ctx->mutex);
669           break;
670         }
671       if (!ctx->nbytes)
672         { 
673           if (!SetEvent (ctx->is_empty))
674             TRACE_LOG1 ("SetEvent failed: ec=%d", (int) GetLastError ());
675           if (!ResetEvent (ctx->have_data))
676             TRACE_LOG1 ("ResetEvent failed: ec=%d", (int) GetLastError ());
677           UNLOCK (ctx->mutex);
678           TRACE_LOG ("idle");
679           WaitForSingleObject (ctx->have_data, INFINITE);
680           TRACE_LOG ("got data to send");
681           LOCK (ctx->mutex);
682         }
683       if (ctx->stop_me)
684         {
685           UNLOCK (ctx->mutex);
686           break;
687         }
688       UNLOCK (ctx->mutex);
689       
690       TRACE_LOG2 ("%s %d bytes", sock?"sending":"writing", ctx->nbytes);
691
692       /* Note that CTX->nbytes is not zero at this point, because
693          _gpgme_io_write always writes at least 1 byte before waking
694          us up, unless CTX->stop_me is true, which we catch above.  */
695       if (sock)
696         {
697           /* We need to try send first because a socket handle can't
698              be used with WriteFile.  */
699           int n;
700
701           n = send (ctx->file_sock, ctx->buffer, ctx->nbytes, 0);
702           if (n < 0)
703             {
704               ctx->error_code = (int) WSAGetLastError ();
705               ctx->error = 1;
706               TRACE_LOG1 ("send error: ec=%d", ctx->error_code);
707               break;
708             }
709           nwritten = n;
710         }
711       else
712         {
713           if (!WriteFile (ctx->file_hd, ctx->buffer,
714                           ctx->nbytes, &nwritten, NULL))
715             {
716               if (GetLastError () == ERROR_BUSY)
717                 {
718                   /* Probably stop_me is set now.  */
719                   TRACE_LOG ("pipe busy (unblocked?)");
720                   continue;
721                 }
722
723               ctx->error_code = (int) GetLastError ();
724               ctx->error = 1;
725               TRACE_LOG1 ("write error: ec=%d", ctx->error_code);
726               break;
727             }
728         }
729       TRACE_LOG1 ("wrote %d bytes", (int) nwritten);
730       
731       LOCK (ctx->mutex);
732       ctx->nbytes -= nwritten;
733       UNLOCK (ctx->mutex);
734     }
735   /* Indicate that we have an error.  */
736   if (!SetEvent (ctx->is_empty))
737     TRACE_LOG1 ("SetEvent failed: ec=%d", (int) GetLastError ());
738   SetEvent (ctx->stopped);
739
740   return TRACE_SUC ();
741 }
742
743
744 static struct writer_context_s *
745 create_writer (int fd)
746 {
747   struct writer_context_s *ctx;
748   SECURITY_ATTRIBUTES sec_attr;
749   DWORD tid;
750
751   TRACE_BEG (DEBUG_SYSIO, "gpgme:create_writer", fd);
752
753   memset (&sec_attr, 0, sizeof sec_attr);
754   sec_attr.nLength = sizeof sec_attr;
755   sec_attr.bInheritHandle = FALSE;
756
757   ctx = calloc (1, sizeof *ctx);
758   if (!ctx)
759     {
760       TRACE_SYSERR (errno);
761       return NULL;
762     }
763   
764   if (fd < 0 || fd >= MAX_SLAFD || !fd_table[fd].used)
765     {
766       TRACE_SYSERR (EIO);
767       return NULL;
768     }
769   ctx->file_hd = fd_table[fd].handle;
770   ctx->file_sock = fd_table[fd].socket;
771
772   ctx->refcount = 1;
773   ctx->have_data = CreateEvent (&sec_attr, TRUE, FALSE, NULL);
774   if (ctx->have_data)
775     ctx->is_empty  = CreateEvent (&sec_attr, TRUE, TRUE, NULL);
776   if (ctx->is_empty)
777     ctx->stopped = CreateEvent (&sec_attr, TRUE, FALSE, NULL);
778   if (!ctx->have_data || !ctx->is_empty || !ctx->stopped)
779     {
780       TRACE_LOG1 ("CreateEvent failed: ec=%d", (int) GetLastError ());
781       if (ctx->have_data)
782         CloseHandle (ctx->have_data);
783       if (ctx->is_empty)
784         CloseHandle (ctx->is_empty);
785       if (ctx->stopped)
786         CloseHandle (ctx->stopped);
787       free (ctx);
788       /* FIXME: Translate the error code.  */
789       TRACE_SYSERR (EIO);
790       return NULL;
791     }
792
793   ctx->is_empty = set_synchronize (ctx->is_empty);
794   INIT_LOCK (ctx->mutex);
795
796 #ifdef HAVE_W32CE_SYSTEM
797   ctx->thread_hd = CreateThread (&sec_attr, 64 * 1024, writer, ctx,
798                                  STACK_SIZE_PARAM_IS_A_RESERVATION, &tid);
799 #else
800   ctx->thread_hd = CreateThread (&sec_attr, 0, writer, ctx, 0, &tid );
801 #endif
802
803   if (!ctx->thread_hd)
804     {
805       TRACE_LOG1 ("CreateThread failed: ec=%d", (int) GetLastError ());
806       DESTROY_LOCK (ctx->mutex);
807       if (ctx->have_data)
808         CloseHandle (ctx->have_data);
809       if (ctx->is_empty)
810         CloseHandle (ctx->is_empty);
811       if (ctx->stopped)
812         CloseHandle (ctx->stopped);
813       free (ctx);
814       TRACE_SYSERR (EIO);
815       return NULL;
816     }    
817   else
818     {
819       /* We set the priority of the thread higher because we know
820          that it only runs for a short time.  This greatly helps to
821          increase the performance of the I/O.  */
822       SetThreadPriority (ctx->thread_hd, get_desired_thread_priority ());
823     }
824
825   TRACE_SUC ();
826   return ctx;
827 }
828
829 static void
830 destroy_writer (struct writer_context_s *ctx)
831 {
832   LOCK (ctx->mutex);
833   ctx->refcount--;
834   if (ctx->refcount != 0)
835     {
836       UNLOCK (ctx->mutex);
837       return;
838     }
839   ctx->stop_me = 1;
840   if (ctx->have_data) 
841     SetEvent (ctx->have_data);
842   UNLOCK (ctx->mutex);
843
844 #ifdef HAVE_W32CE_SYSTEM
845   /* Scenario: We never create a full pipe, but already started
846      writing more than the pipe buffer.  Then we need to unblock the
847      writer in the pipe driver to make our writer thread notice that
848      we want it to go away.  */
849
850   if (!DeviceIoControl (ctx->file_hd, GPGCEDEV_IOCTL_UNBLOCK,
851                         NULL, 0, NULL, 0, NULL, NULL))
852     {
853       TRACE1 (DEBUG_SYSIO, "gpgme:destroy_writer", ctx->file_hd,
854               "unblock control call failed for thread %p", ctx->thread_hd);
855     }
856 #endif
857   
858   TRACE1 (DEBUG_SYSIO, "gpgme:destroy_writer", ctx->file_hd,
859           "waiting for termination of thread %p", ctx->thread_hd);
860   WaitForSingleObject (ctx->stopped, INFINITE);
861   TRACE1 (DEBUG_SYSIO, "gpgme:destroy_writer", ctx->file_hd,
862           "thread %p has terminated", ctx->thread_hd);
863   
864   if (ctx->stopped)
865     CloseHandle (ctx->stopped);
866   if (ctx->have_data)
867     CloseHandle (ctx->have_data);
868   if (ctx->is_empty)
869     CloseHandle (ctx->is_empty);
870   CloseHandle (ctx->thread_hd);
871   DESTROY_LOCK (ctx->mutex);
872   free (ctx);
873 }
874
875
876 /* Find a writer context or create a new one.  Note that the writer
877    context will last until a _gpgme_io_close.  */
878 static struct writer_context_s *
879 find_writer (int fd, int start_it)
880 {
881   struct writer_context_s *wt = NULL;
882   int i;
883
884   LOCK (writer_table_lock);
885   for (i = 0; i < writer_table_size; i++)
886     if (writer_table[i].used && writer_table[i].fd == fd)
887       wt = writer_table[i].context;
888
889   if (wt || !start_it)
890     {
891       UNLOCK (writer_table_lock);
892       return wt;
893     }
894
895   for (i = 0; i < writer_table_size; i++)
896     if (!writer_table[i].used)
897       break;
898
899   if (i != writer_table_size)
900     {
901       wt = create_writer (fd);
902       writer_table[i].fd = fd;
903       writer_table[i].context = wt; 
904       writer_table[i].used = 1;
905     }
906
907   UNLOCK (writer_table_lock);
908   return wt;
909 }
910
911
912 static void
913 kill_writer (int fd)
914 {
915   int i;
916
917   LOCK (writer_table_lock);
918   for (i = 0; i < writer_table_size; i++)
919     {
920       if (writer_table[i].used && writer_table[i].fd == fd)
921         {
922           destroy_writer (writer_table[i].context);
923           writer_table[i].context = NULL;
924           writer_table[i].used = 0;
925           break;
926         }
927     }
928   UNLOCK (writer_table_lock);
929 }
930
931
932 int
933 _gpgme_io_write (int fd, const void *buffer, size_t count)
934 {
935   struct writer_context_s *ctx;
936   TRACE_BEG2 (DEBUG_SYSIO, "_gpgme_io_write", fd,
937               "buffer=%p, count=%u", buffer, count);
938   TRACE_LOGBUF (buffer, count);
939
940   if (count == 0)
941     return TRACE_SYSRES (0);
942
943   ctx = find_writer (fd, 1);
944   if (!ctx)
945     return TRACE_SYSRES (-1);
946
947   LOCK (ctx->mutex);
948   if (!ctx->error && ctx->nbytes)
949     {
950       /* Bytes are pending for send.  */
951
952       /* Reset the is_empty event.  Better safe than sorry.  */
953       if (!ResetEvent (ctx->is_empty))
954         {
955           TRACE_LOG1 ("ResetEvent failed: ec=%d", (int) GetLastError ());
956           UNLOCK (ctx->mutex);
957           /* FIXME: Should translate the error code.  */
958           gpg_err_set_errno (EIO);
959           return TRACE_SYSRES (-1);
960         }
961       UNLOCK (ctx->mutex);
962       TRACE_LOG1 ("waiting for empty buffer in thread %p", ctx->thread_hd);
963       WaitForSingleObject (ctx->is_empty, INFINITE);
964       TRACE_LOG1 ("thread %p buffer is empty", ctx->thread_hd);
965       LOCK (ctx->mutex);
966     }
967
968   if (ctx->error)
969     {
970       UNLOCK (ctx->mutex);
971       if (ctx->error_code == ERROR_NO_DATA)
972         gpg_err_set_errno (EPIPE);
973       else
974         gpg_err_set_errno (EIO);
975       return TRACE_SYSRES (-1);
976     }
977
978   /* If no error occured, the number of bytes in the buffer must be
979      zero.  */
980   assert (!ctx->nbytes);
981
982   if (count > WRITEBUF_SIZE)
983     count = WRITEBUF_SIZE;
984   memcpy (ctx->buffer, buffer, count);
985   ctx->nbytes = count;
986
987   /* We have to reset the is_empty event early, because it is also
988      used by the select() implementation to probe the channel.  */
989   if (!ResetEvent (ctx->is_empty))
990     {
991       TRACE_LOG1 ("ResetEvent failed: ec=%d", (int) GetLastError ());
992       UNLOCK (ctx->mutex);
993       /* FIXME: Should translate the error code.  */
994       gpg_err_set_errno (EIO);
995       return TRACE_SYSRES (-1);
996     }
997   if (!SetEvent (ctx->have_data))
998     {
999       TRACE_LOG1 ("SetEvent failed: ec=%d", (int) GetLastError ());
1000       UNLOCK (ctx->mutex);
1001       /* FIXME: Should translate the error code.  */
1002       gpg_err_set_errno (EIO);
1003       return TRACE_SYSRES (-1);
1004     }
1005   UNLOCK (ctx->mutex);
1006
1007   return TRACE_SYSRES ((int) count);
1008 }
1009
1010
1011 int
1012 _gpgme_io_pipe (int filedes[2], int inherit_idx)
1013 {
1014   int rfd;
1015   int wfd;
1016 #ifdef HAVE_W32CE_SYSTEM
1017   HANDLE hd;
1018   int rvid;
1019 #else
1020   HANDLE rh;
1021   HANDLE wh;
1022   SECURITY_ATTRIBUTES sec_attr;
1023 #endif
1024
1025   TRACE_BEG2 (DEBUG_SYSIO, "_gpgme_io_pipe", filedes,
1026               "inherit_idx=%i (GPGME uses it for %s)",
1027               inherit_idx, inherit_idx ? "reading" : "writing");
1028
1029   rfd = new_fd ();
1030   if (rfd == -1)
1031     return TRACE_SYSRES (-1);
1032   wfd = new_fd ();
1033   if (wfd == -1)
1034     {
1035       release_fd (rfd);
1036       return TRACE_SYSRES (-1);
1037     }
1038
1039 #ifdef HAVE_W32CE_SYSTEM
1040   hd = _assuan_w32ce_prepare_pipe (&rvid, !inherit_idx);
1041   if (hd == INVALID_HANDLE_VALUE)
1042     {
1043       TRACE_LOG1 ("_assuan_w32ce_prepare_pipe failed: ec=%d",
1044                   (int) GetLastError ());
1045       release_fd (rfd);
1046       release_fd (wfd);
1047       /* FIXME: Should translate the error code.  */
1048       gpg_err_set_errno (EIO);
1049       return TRACE_SYSRES (-1);
1050     }
1051
1052   if (inherit_idx == 0)
1053     {
1054       fd_table[rfd].rvid = rvid;
1055       fd_table[wfd].handle = hd;
1056     }
1057   else
1058     {
1059       fd_table[rfd].handle = hd;
1060       fd_table[wfd].rvid = rvid;
1061     }  
1062
1063 #else
1064
1065   memset (&sec_attr, 0, sizeof (sec_attr));
1066   sec_attr.nLength = sizeof (sec_attr);
1067   sec_attr.bInheritHandle = FALSE;
1068   
1069   if (!CreatePipe (&rh, &wh, &sec_attr, PIPEBUF_SIZE))
1070     {
1071       TRACE_LOG1 ("CreatePipe failed: ec=%d", (int) GetLastError ());
1072       release_fd (rfd);
1073       release_fd (wfd);
1074       /* FIXME: Should translate the error code.  */
1075       gpg_err_set_errno (EIO);
1076       return TRACE_SYSRES (-1);
1077     }
1078
1079   /* Make one end inheritable.  */
1080   if (inherit_idx == 0)
1081     {
1082       HANDLE hd;
1083       if (!DuplicateHandle (GetCurrentProcess(), rh,
1084                             GetCurrentProcess(), &hd, 0,
1085                             TRUE, DUPLICATE_SAME_ACCESS))
1086         {
1087           TRACE_LOG1 ("DuplicateHandle failed: ec=%d",
1088                       (int) GetLastError ());
1089           release_fd (rfd);
1090           release_fd (wfd);
1091           CloseHandle (rh);
1092           CloseHandle (wh);
1093           /* FIXME: Should translate the error code.  */
1094           gpg_err_set_errno (EIO);
1095           return TRACE_SYSRES (-1);
1096         }
1097       CloseHandle (rh);
1098       rh = hd;
1099     }
1100   else if (inherit_idx == 1)
1101     {
1102       HANDLE hd;
1103       if (!DuplicateHandle( GetCurrentProcess(), wh,
1104                             GetCurrentProcess(), &hd, 0,
1105                             TRUE, DUPLICATE_SAME_ACCESS))
1106         {
1107           TRACE_LOG1 ("DuplicateHandle failed: ec=%d",
1108                       (int) GetLastError ());
1109           release_fd (rfd);
1110           release_fd (wfd);
1111           CloseHandle (rh);
1112           CloseHandle (wh);
1113           /* FIXME: Should translate the error code.  */
1114           gpg_err_set_errno (EIO);
1115           return TRACE_SYSRES (-1);
1116         }
1117       CloseHandle (wh);
1118       wh = hd;
1119     }
1120   fd_table[rfd].handle = rh;
1121   fd_table[wfd].handle = wh;
1122 #endif
1123
1124   filedes[0] = rfd;
1125   filedes[1] = wfd;
1126   return TRACE_SUC6 ("read=0x%x (%p/0x%x), write=0x%x (%p/0x%x)",
1127                      rfd, fd_table[rfd].handle, fd_table[rfd].rvid,
1128                      wfd, fd_table[wfd].handle, fd_table[wfd].rvid);
1129 }
1130
1131
1132 int
1133 _gpgme_io_close (int fd)
1134 {
1135   int i;
1136   _gpgme_close_notify_handler_t handler = NULL;
1137   void *value = NULL;
1138
1139   TRACE_BEG (DEBUG_SYSIO, "_gpgme_io_close", fd);
1140
1141   if (fd == -1)
1142     {
1143       gpg_err_set_errno (EBADF);
1144       return TRACE_SYSRES (-1);
1145     }
1146   if (fd < 0 || fd >= MAX_SLAFD || !fd_table[fd].used)
1147     {
1148       gpg_err_set_errno (EBADF);
1149       return TRACE_SYSRES (-1);
1150     }
1151
1152   kill_reader (fd);
1153   kill_writer (fd);
1154   LOCK (notify_table_lock);
1155   for (i = 0; i < DIM (notify_table); i++)
1156     {
1157       if (notify_table[i].inuse && notify_table[i].fd == fd)
1158         {
1159           handler = notify_table[i].handler;
1160           value   = notify_table[i].value;
1161           notify_table[i].handler = NULL;
1162           notify_table[i].value = NULL;
1163           notify_table[i].inuse = 0;
1164           break;
1165         }
1166     }
1167   UNLOCK (notify_table_lock);
1168   if (handler)
1169     handler (fd, value);
1170
1171   if (fd_table[fd].dup_from == -1)
1172     {
1173       if (fd_table[fd].handle != INVALID_HANDLE_VALUE)
1174         {
1175           if (!CloseHandle (fd_table[fd].handle))
1176             { 
1177               TRACE_LOG1 ("CloseHandle failed: ec=%d", (int) GetLastError ());
1178               /* FIXME: Should translate the error code.  */
1179               gpg_err_set_errno (EIO);
1180               return TRACE_SYSRES (-1);
1181             }
1182         }
1183       else if (fd_table[fd].socket != INVALID_SOCKET)
1184         {
1185           if (closesocket (fd_table[fd].socket))
1186             { 
1187               TRACE_LOG1 ("closesocket failed: ec=%d", (int) WSAGetLastError ());
1188               /* FIXME: Should translate the error code.  */
1189               gpg_err_set_errno (EIO);
1190               return TRACE_SYSRES (-1);
1191             }
1192         }
1193       /* Nothing to do for RVIDs.  */
1194     }
1195
1196   release_fd (fd);
1197       
1198   return TRACE_SYSRES (0);
1199 }
1200
1201
1202 int
1203 _gpgme_io_set_close_notify (int fd, _gpgme_close_notify_handler_t handler,
1204                             void *value)
1205 {
1206   int i;
1207   TRACE_BEG2 (DEBUG_SYSIO, "_gpgme_io_set_close_notify", fd,
1208               "close_handler=%p/%p", handler, value);
1209
1210   assert (fd != -1);
1211
1212   LOCK (notify_table_lock);
1213   for (i=0; i < DIM (notify_table); i++)
1214     if (notify_table[i].inuse && notify_table[i].fd == fd)
1215       break;
1216   if (i == DIM (notify_table))
1217     for (i = 0; i < DIM (notify_table); i++)
1218       if (!notify_table[i].inuse)
1219         break;
1220   if (i == DIM (notify_table))
1221     {
1222       UNLOCK (notify_table_lock);
1223       gpg_err_set_errno (EINVAL);
1224       return TRACE_SYSRES (-1);
1225     }
1226   notify_table[i].fd = fd;
1227   notify_table[i].handler = handler;
1228   notify_table[i].value = value;
1229   notify_table[i].inuse = 1;
1230   UNLOCK (notify_table_lock);
1231   return TRACE_SYSRES (0);
1232 }
1233
1234
1235 int
1236 _gpgme_io_set_nonblocking (int fd)
1237 {
1238   TRACE (DEBUG_SYSIO, "_gpgme_io_set_nonblocking", fd);
1239   return 0;
1240 }
1241
1242
1243 #ifdef HAVE_W32CE_SYSTEM
1244 static char *
1245 build_commandline (char **argv, int fd0, int fd0_isnull,
1246                    int fd1, int fd1_isnull,
1247                    int fd2, int fd2_isnull)
1248 {
1249   int i, n;
1250   const char *s;
1251   char *buf, *p;
1252   char fdbuf[3*30];
1253
1254   p = fdbuf;
1255   *p = 0;
1256   
1257   if (fd0 != -1)
1258     {
1259       if (fd0_isnull)
1260         strcpy (p, "-&S0=null ");
1261       else
1262         snprintf (p, 25, "-&S0=%d ", fd_table[fd0].rvid);
1263       p += strlen (p);
1264     }
1265   if (fd1 != -1)
1266     {
1267       if (fd1_isnull)
1268         strcpy (p, "-&S1=null ");
1269       else
1270         snprintf (p, 25, "-&S1=%d ", fd_table[fd1].rvid);
1271       p += strlen (p);
1272     }
1273   if (fd2 != -1)
1274     {
1275       if (fd2_isnull)
1276         strcpy (p, "-&S2=null ");
1277       else
1278         snprintf (p, 25, "-&S2=%d ", fd_table[fd2].rvid);
1279       p += strlen (p);
1280     }
1281   strcpy (p, "-&S2=null ");
1282   p += strlen (p);
1283   
1284   n = strlen (fdbuf);
1285   for (i=0; (s = argv[i]); i++)
1286     {
1287       if (!i)
1288         continue; /* Ignore argv[0].  */
1289       n += strlen (s) + 1 + 2;  /* (1 space, 2 quoting) */
1290       for (; *s; s++)
1291         if (*s == '\"')
1292           n++;  /* Need to double inner quotes.  */
1293     }
1294   n++;
1295   buf = p = malloc (n);
1296   if (! buf)
1297     return NULL;
1298
1299   p = stpcpy (p, fdbuf);
1300   for (i = 0; argv[i]; i++) 
1301     {
1302       if (!i)
1303         continue; /* Ignore argv[0].  */
1304       if (i > 1)
1305         p = stpcpy (p, " ");
1306
1307       if (! *argv[i]) /* Empty string. */
1308         p = stpcpy (p, "\"\"");
1309       else if (strpbrk (argv[i], " \t\n\v\f\""))
1310         {
1311           p = stpcpy (p, "\"");
1312           for (s = argv[i]; *s; s++)
1313             {
1314               *p++ = *s;
1315               if (*s == '\"')
1316                 *p++ = *s;
1317             }
1318           *p++ = '\"';
1319           *p = 0;
1320         }
1321       else
1322         p = stpcpy (p, argv[i]);
1323     }
1324
1325   return buf;  
1326 }
1327 #else
1328 static char *
1329 build_commandline (char **argv)
1330 {
1331   int i;
1332   int n = 0;
1333   char *buf;
1334   char *p;
1335   
1336   /* We have to quote some things because under Windows the program
1337      parses the commandline and does some unquoting.  We enclose the
1338      whole argument in double-quotes, and escape literal double-quotes
1339      as well as backslashes with a backslash.  We end up with a
1340      trailing space at the end of the line, but that is harmless.  */
1341   for (i = 0; argv[i]; i++)
1342     {
1343       p = argv[i];
1344       /* The leading double-quote.  */
1345       n++;
1346       while (*p)
1347         {
1348           /* An extra one for each literal that must be escaped.  */
1349           if (*p == '\\' || *p == '"')
1350             n++;
1351           n++;
1352           p++;
1353         }
1354       /* The trailing double-quote and the delimiter.  */
1355       n += 2;
1356     }
1357   /* And a trailing zero.  */
1358   n++;
1359
1360   buf = p = malloc (n);
1361   if (!buf)
1362     return NULL;
1363   for (i = 0; argv[i]; i++)
1364     {
1365       char *argvp = argv[i];
1366
1367       *(p++) = '"';
1368       while (*argvp)
1369         {
1370           if (*argvp == '\\' || *argvp == '"')
1371             *(p++) = '\\';
1372           *(p++) = *(argvp++);
1373         }
1374       *(p++) = '"';
1375       *(p++) = ' ';
1376     }
1377   *(p++) = 0;
1378
1379   return buf;
1380 }
1381 #endif
1382
1383
1384 int
1385 _gpgme_io_spawn (const char *path, char *const argv[], unsigned int flags,
1386                  struct spawn_fd_item_s *fd_list,
1387                  void (*atfork) (void *opaque, int reserved),
1388                  void *atforkvalue, pid_t *r_pid)
1389 {
1390   PROCESS_INFORMATION pi =
1391     {
1392       NULL,      /* returns process handle */
1393       0,         /* returns primary thread handle */
1394       0,         /* returns pid */
1395       0          /* returns tid */
1396     };
1397   int i;
1398
1399 #ifdef HAVE_W32CE_SYSTEM
1400   int fd_in = -1;
1401   int fd_out = -1;
1402   int fd_err = -1;
1403   int fd_in_isnull = 1;
1404   int fd_out_isnull = 1;
1405   int fd_err_isnull = 1;
1406   char *cmdline;
1407   HANDLE hd = INVALID_HANDLE_VALUE;
1408
1409   TRACE_BEG1 (DEBUG_SYSIO, "_gpgme_io_spawn", path,
1410               "path=%s", path);
1411   i = 0;
1412   while (argv[i])
1413     {
1414       TRACE_LOG2 ("argv[%2i] = %s", i, argv[i]);
1415       i++;
1416     }
1417
1418   for (i = 0; fd_list[i].fd != -1; i++)
1419     {
1420       int fd = fd_list[i].fd;
1421
1422       TRACE_LOG3 ("fd_list[%2i] = fd %i, dup_to %i", i, fd, fd_list[i].dup_to);
1423       if (fd < 0 || fd >= MAX_SLAFD || !fd_table[fd].used)
1424         {
1425           TRACE_LOG1 ("invalid fd 0x%x", fd);
1426           gpg_err_set_errno (EBADF);
1427           return TRACE_SYSRES (-1);
1428         }
1429       if (fd_table[fd].rvid == 0)
1430         {
1431           TRACE_LOG1 ("fd 0x%x not inheritable (not an RVID)", fd);
1432           gpg_err_set_errno (EBADF);
1433           return TRACE_SYSRES (-1);
1434         }
1435       
1436       if (fd_list[i].dup_to == 0)
1437         {
1438           fd_in = fd_list[i].fd;
1439           fd_in_isnull = 0;
1440         }
1441       else if (fd_list[i].dup_to == 1)
1442         {
1443           fd_out = fd_list[i].fd;
1444           fd_out_isnull = 0;
1445         }
1446       else if (fd_list[i].dup_to == 2)
1447         {
1448           fd_err = fd_list[i].fd;
1449           fd_err_isnull = 0;
1450         }
1451     }
1452
1453   cmdline = build_commandline (argv, fd_in, fd_in_isnull,
1454                                fd_out, fd_out_isnull, fd_err, fd_err_isnull);
1455   if (!cmdline)
1456     {
1457       TRACE_LOG1 ("build_commandline failed: %s", strerror (errno));
1458       return TRACE_SYSRES (-1);
1459     }
1460
1461   if (!CreateProcessA (path,                /* Program to start.  */
1462                        cmdline,             /* Command line arguments.  */
1463                        NULL,                 /* (not supported)  */
1464                        NULL,                 /* (not supported)  */
1465                        FALSE,                /* (not supported)  */
1466                        (CREATE_SUSPENDED),   /* Creation flags.  */
1467                        NULL,                 /* (not supported)  */
1468                        NULL,                 /* (not supported)  */
1469                        NULL,                 /* (not supported) */
1470                        &pi                   /* Returns process information.*/
1471                        ))
1472     {
1473       TRACE_LOG1 ("CreateProcess failed: ec=%d", (int) GetLastError ());
1474       free (cmdline);
1475       gpg_err_set_errno (EIO);
1476       return TRACE_SYSRES (-1);
1477     }
1478
1479   /* Create arbitrary pipe descriptor to send in ASSIGN_RVID
1480      commands.  Errors are ignored.  We don't need read or write access,
1481      as ASSIGN_RVID works without any permissions, yay!  */
1482   hd = CreateFile (L"GPG1:", 0, 0,
1483                    NULL, OPEN_ALWAYS, FILE_ATTRIBUTE_NORMAL, NULL);
1484   if (hd == INVALID_HANDLE_VALUE)
1485     {
1486       TRACE_LOG1 ("CreateFile failed (ignored): ec=%d",
1487                   (int) GetLastError ());
1488     }
1489
1490   /* Insert the inherited handles.  */
1491   for (i = 0; fd_list[i].fd != -1; i++)
1492     {
1493       /* Return the child name of this handle.  */
1494       fd_list[i].peer_name = fd_table[fd_list[i].fd].rvid;
1495
1496       if (hd != INVALID_HANDLE_VALUE)
1497         {
1498           DWORD data[2];
1499           data[0] = (DWORD) fd_table[fd_list[i].fd].rvid;
1500           data[1] = pi.dwProcessId;
1501           if (!DeviceIoControl (hd, GPGCEDEV_IOCTL_ASSIGN_RVID,
1502                                 data, sizeof (data), NULL, 0, NULL, NULL))
1503             {
1504               TRACE_LOG3 ("ASSIGN_RVID(%i, %i) failed (ignored): %i",
1505                           data[0], data[1], (int) GetLastError ());
1506             }
1507         }
1508     }
1509   if (hd != INVALID_HANDLE_VALUE)
1510     CloseHandle (hd);
1511
1512 #else
1513   SECURITY_ATTRIBUTES sec_attr;
1514   STARTUPINFOA si;
1515   int cr_flags = CREATE_DEFAULT_ERROR_MODE;
1516   char **args;
1517   char *arg_string;
1518   /* FIXME.  */
1519   int debug_me = 0;
1520   int tmp_fd;
1521   char *tmp_name;
1522
1523   TRACE_BEG1 (DEBUG_SYSIO, "_gpgme_io_spawn", path,
1524               "path=%s", path);
1525   i = 0;
1526   while (argv[i])
1527     {
1528       TRACE_LOG2 ("argv[%2i] = %s", i, argv[i]);
1529       i++;
1530     }
1531
1532   /* We do not inherit any handles by default, and just insert those
1533      handles we want the child to have afterwards.  But some handle
1534      values occur on the command line, and we need to move
1535      stdin/out/err to the right location.  So we use a wrapper program
1536      which gets the information from a temporary file.  */
1537   if (_gpgme_mkstemp (&tmp_fd, &tmp_name) < 0)
1538     {
1539       TRACE_LOG1 ("_gpgme_mkstemp failed: %s", strerror (errno));
1540       return TRACE_SYSRES (-1);
1541     }
1542   TRACE_LOG1 ("tmp_name = %s", tmp_name);
1543
1544   args = calloc (2 + i + 1, sizeof (*args));
1545   args[0] = (char *) _gpgme_get_w32spawn_path ();
1546   args[1] = tmp_name;
1547   args[2] = path;
1548   memcpy (&args[3], &argv[1], i * sizeof (*args));
1549
1550   memset (&sec_attr, 0, sizeof sec_attr);
1551   sec_attr.nLength = sizeof sec_attr;
1552   sec_attr.bInheritHandle = FALSE;
1553  
1554   arg_string = build_commandline (args);
1555   free (args);
1556   if (!arg_string)
1557     {
1558       close (tmp_fd);
1559       DeleteFileA (tmp_name);
1560       return TRACE_SYSRES (-1);
1561     }
1562
1563   memset (&si, 0, sizeof si);
1564   si.cb = sizeof (si);
1565   si.dwFlags = STARTF_USESTDHANDLES | STARTF_USESHOWWINDOW;
1566   si.wShowWindow = debug_me ? SW_SHOW : SW_HIDE;
1567   si.hStdInput = INVALID_HANDLE_VALUE;
1568   si.hStdOutput = INVALID_HANDLE_VALUE;
1569   si.hStdError = INVALID_HANDLE_VALUE;
1570
1571   cr_flags |= CREATE_SUSPENDED;
1572   cr_flags |= DETACHED_PROCESS;
1573   cr_flags |= GetPriorityClass (GetCurrentProcess ());
1574   if (!CreateProcessA (_gpgme_get_w32spawn_path (),
1575                        arg_string,
1576                        &sec_attr,     /* process security attributes */
1577                        &sec_attr,     /* thread security attributes */
1578                        FALSE,         /* inherit handles */
1579                        cr_flags,      /* creation flags */
1580                        NULL,          /* environment */
1581                        NULL,          /* use current drive/directory */
1582                        &si,           /* startup information */
1583                        &pi))          /* returns process information */
1584     {
1585       TRACE_LOG1 ("CreateProcess failed: ec=%d", (int) GetLastError ());
1586       free (arg_string);
1587       close (tmp_fd);
1588       DeleteFileA (tmp_name);
1589
1590       /* FIXME: Should translate the error code.  */
1591       gpg_err_set_errno (EIO);
1592       return TRACE_SYSRES (-1);
1593     }
1594
1595   free (arg_string);
1596
1597   if (flags & IOSPAWN_FLAG_ALLOW_SET_FG)
1598     _gpgme_allow_set_foreground_window ((pid_t)pi.dwProcessId);
1599
1600   /* Insert the inherited handles.  */
1601   for (i = 0; fd_list[i].fd != -1; i++)
1602     {
1603       int fd = fd_list[i].fd;
1604       HANDLE ohd = INVALID_HANDLE_VALUE;
1605       HANDLE hd = INVALID_HANDLE_VALUE;
1606       
1607       /* Make it inheritable for the wrapper process.  */
1608       if (fd >= 0 && fd < MAX_SLAFD && fd_table[fd].used)
1609         ohd = fd_table[fd].handle;
1610
1611       if (!DuplicateHandle (GetCurrentProcess(), ohd,
1612                             pi.hProcess, &hd, 0, TRUE, DUPLICATE_SAME_ACCESS))
1613         {
1614           TRACE_LOG1 ("DuplicateHandle failed: ec=%d", (int) GetLastError ());
1615           TerminateProcess (pi.hProcess, 0);
1616           /* Just in case TerminateProcess didn't work, let the
1617              process fail on its own.  */
1618           ResumeThread (pi.hThread);
1619           CloseHandle (pi.hThread);
1620           CloseHandle (pi.hProcess);
1621
1622           close (tmp_fd);
1623           DeleteFileA (tmp_name);
1624
1625           /* FIXME: Should translate the error code.  */
1626           gpg_err_set_errno (EIO);
1627           return TRACE_SYSRES (-1);
1628         }
1629       /* Return the child name of this handle.  */
1630       fd_list[i].peer_name = handle_to_fd (hd);
1631     }
1632   
1633   /* Write the handle translation information to the temporary
1634      file.  */
1635   {
1636     /* Hold roughly MAX_TRANS quadruplets of 64 bit numbers in hex
1637        notation: "0xFEDCBA9876543210" with an extra white space after
1638        every quadruplet.  10*(19*4 + 1) - 1 = 769.  This plans ahead
1639        for a time when a HANDLE is 64 bit.  */
1640 #define BUFFER_MAX 810
1641     char line[BUFFER_MAX + 1];
1642     int res;
1643     int written;
1644     size_t len;
1645
1646     if ((flags & IOSPAWN_FLAG_ALLOW_SET_FG))
1647       strcpy (line, "~1 \n");
1648     else
1649       strcpy (line, "\n");
1650     for (i = 0; fd_list[i].fd != -1; i++)
1651       {
1652         /* Strip the newline.  */
1653         len = strlen (line) - 1;
1654         
1655         /* Format is: Local name, stdin/stdout/stderr, peer name, argv idx.  */
1656         snprintf (&line[len], BUFFER_MAX - len, "0x%x %d 0x%x %d  \n",
1657                   fd_list[i].fd, fd_list[i].dup_to,
1658                   fd_list[i].peer_name, fd_list[i].arg_loc);
1659         /* Rather safe than sorry.  */
1660         line[BUFFER_MAX - 1] = '\n';
1661         line[BUFFER_MAX] = '\0';
1662       }
1663     len = strlen (line);
1664     written = 0;
1665     do
1666       {
1667         res = write (tmp_fd, &line[written], len - written);
1668         if (res > 0)
1669           written += res;
1670       }
1671     while (res > 0 || (res < 0 && errno == EAGAIN));
1672   }
1673   close (tmp_fd);
1674   /* The temporary file is deleted by the gpgme-w32spawn process
1675      (hopefully).  */
1676 #endif
1677
1678
1679   TRACE_LOG4 ("CreateProcess ready: hProcess=%p, hThread=%p, "
1680               "dwProcessID=%d, dwThreadId=%d",
1681               pi.hProcess, pi.hThread, 
1682               (int) pi.dwProcessId, (int) pi.dwThreadId);
1683   
1684   if (r_pid)
1685     *r_pid = (pid_t)pi.dwProcessId;
1686
1687   
1688   if (ResumeThread (pi.hThread) < 0)
1689     TRACE_LOG1 ("ResumeThread failed: ec=%d", (int) GetLastError ());
1690   
1691   if (!CloseHandle (pi.hThread))
1692     TRACE_LOG1 ("CloseHandle of thread failed: ec=%d",
1693                 (int) GetLastError ());
1694
1695   TRACE_LOG1 ("process=%p", pi.hProcess);
1696
1697   /* We don't need to wait for the process.  */
1698   if (!CloseHandle (pi.hProcess))
1699     TRACE_LOG1 ("CloseHandle of process failed: ec=%d",
1700                 (int) GetLastError ());
1701
1702   if (! (flags & IOSPAWN_FLAG_NOCLOSE))
1703     {
1704       for (i = 0; fd_list[i].fd != -1; i++)
1705         _gpgme_io_close (fd_list[i].fd);
1706     }
1707
1708   for (i = 0; fd_list[i].fd != -1; i++)
1709     if (fd_list[i].dup_to == -1)
1710       TRACE_LOG3 ("fd[%i] = 0x%x -> 0x%x", i, fd_list[i].fd,
1711                   fd_list[i].peer_name);
1712     else
1713       TRACE_LOG4 ("fd[%i] = 0x%x -> 0x%x (std%s)", i, fd_list[i].fd,
1714                   fd_list[i].peer_name, (fd_list[i].dup_to == 0) ? "in" :
1715                   ((fd_list[i].dup_to == 1) ? "out" : "err"));
1716
1717   return TRACE_SYSRES (0);
1718 }
1719
1720
1721 /* Select on the list of fds.  Returns: -1 = error, 0 = timeout or
1722    nothing to select, > 0 = number of signaled fds.  */
1723 int
1724 _gpgme_io_select (struct io_select_fd_s *fds, size_t nfds, int nonblock)
1725 {
1726   HANDLE waitbuf[MAXIMUM_WAIT_OBJECTS];
1727   int waitidx[MAXIMUM_WAIT_OBJECTS];
1728   int code;
1729   int nwait;
1730   int i;
1731   int any;
1732   int count;
1733   void *dbg_help;
1734   TRACE_BEG2 (DEBUG_SYSIO, "_gpgme_io_select", fds,
1735               "nfds=%u, nonblock=%u", nfds, nonblock);
1736
1737  restart:
1738   TRACE_SEQ (dbg_help, "select on [ ");
1739   any = 0;
1740   nwait = 0;
1741   count = 0;
1742   for (i=0; i < nfds; i++)
1743     {
1744       if (fds[i].fd == -1)
1745         continue;
1746       fds[i].signaled = 0;
1747       if (fds[i].for_read || fds[i].for_write)
1748         {
1749           if (fds[i].for_read)
1750             {
1751               struct reader_context_s *ctx = find_reader (fds[i].fd,1);
1752               
1753               if (!ctx)
1754                 TRACE_LOG1 ("error: no reader for FD 0x%x (ignored)",
1755                             fds[i].fd);
1756               else
1757                 {
1758                   if (nwait >= DIM (waitbuf))
1759                     {
1760                       TRACE_END (dbg_help, "oops ]");
1761                       TRACE_LOG ("Too many objects for WFMO!");
1762                       /* FIXME: Should translate the error code.  */
1763                       gpg_err_set_errno (EIO);
1764                       return TRACE_SYSRES (-1);
1765                     }
1766                   waitidx[nwait] = i;
1767                   waitbuf[nwait++] = ctx->have_data_ev;
1768                 }
1769               TRACE_ADD1 (dbg_help, "r0x%x ", fds[i].fd);
1770               any = 1;
1771             }
1772           else if (fds[i].for_write)
1773             {
1774               struct writer_context_s *ctx = find_writer (fds[i].fd,1);
1775               
1776               if (!ctx)
1777                 TRACE_LOG1 ("error: no writer for FD 0x%x (ignored)",
1778                             fds[i].fd);
1779               else
1780                 {
1781                   if (nwait >= DIM (waitbuf))
1782                     {
1783                       TRACE_END (dbg_help, "oops ]");
1784                       TRACE_LOG ("Too many objects for WFMO!");
1785                       /* FIXME: Should translate the error code.  */
1786                       gpg_err_set_errno (EIO);
1787                       return TRACE_SYSRES (-1);
1788                     }
1789                   waitidx[nwait] = i;
1790                   waitbuf[nwait++] = ctx->is_empty;
1791                 }
1792               TRACE_ADD1 (dbg_help, "w0x%x ", fds[i].fd);
1793               any = 1;
1794             }
1795         }
1796     }
1797   TRACE_END (dbg_help, "]");
1798   if (!any) 
1799     return TRACE_SYSRES (0);
1800
1801   code = WaitForMultipleObjects (nwait, waitbuf, 0, nonblock ? 0 : 1000);
1802   if (code >= WAIT_OBJECT_0 && code < WAIT_OBJECT_0 + nwait)
1803     {
1804       /* This WFMO is a really silly function: It does return either
1805          the index of the signaled object or if 2 objects have been
1806          signalled at the same time, the index of the object with the
1807          lowest object is returned - so and how do we find out how
1808          many objects have been signaled???.  The only solution I can
1809          imagine is to test each object starting with the returned
1810          index individually - how dull.  */
1811       any = 0;
1812       for (i = code - WAIT_OBJECT_0; i < nwait; i++)
1813         {
1814           if (WaitForSingleObject (waitbuf[i], 0) == WAIT_OBJECT_0)
1815             {
1816               assert (waitidx[i] >=0 && waitidx[i] < nfds);
1817               fds[waitidx[i]].signaled = 1;
1818               any = 1;
1819               count++;
1820             }
1821         }
1822       if (!any)
1823         {
1824           TRACE_LOG ("no signaled objects found after WFMO");
1825           count = -1;
1826         }
1827     }
1828   else if (code == WAIT_TIMEOUT)
1829     TRACE_LOG ("WFMO timed out");
1830   else if (code == WAIT_FAILED)
1831     {
1832       int le = (int) GetLastError ();
1833 #if 0
1834       if (le == ERROR_INVALID_HANDLE)
1835         {
1836           int k;
1837           int j = handle_to_fd (waitbuf[i]);
1838           
1839           TRACE_LOG1 ("WFMO invalid handle %d removed", j);
1840           for (k = 0 ; k < nfds; k++)
1841             {
1842               if (fds[k].fd == j)
1843                 {
1844                   fds[k].for_read = fds[k].for_write = 0;
1845                   goto restart;
1846                 }
1847             }
1848           TRACE_LOG (" oops, or not???");
1849         }
1850 #endif
1851       TRACE_LOG1 ("WFMO failed: %d", le);
1852       count = -1;
1853     }
1854   else
1855     {
1856       TRACE_LOG1 ("WFMO returned %d", code);
1857       count = -1;
1858     }
1859   
1860   if (count > 0)
1861     {
1862       TRACE_SEQ (dbg_help, "select OK [ ");
1863       for (i = 0; i < nfds; i++)
1864         {
1865           if (fds[i].fd == -1)
1866             continue;
1867           if ((fds[i].for_read || fds[i].for_write) && fds[i].signaled)
1868             TRACE_ADD2 (dbg_help, "%c0x%x ",
1869                         fds[i].for_read ? 'r' : 'w', fds[i].fd);
1870         }
1871       TRACE_END (dbg_help, "]");
1872     }
1873
1874   if (count < 0)
1875     {
1876       /* FIXME: Should determine a proper error code.  */
1877       gpg_err_set_errno (EIO);
1878     }
1879   
1880   return TRACE_SYSRES (count);
1881 }
1882
1883
1884 void
1885 _gpgme_io_subsystem_init (void)
1886 {
1887   /* Nothing to do.  */
1888 }
1889
1890
1891 /* Write the printable version of FD to the buffer BUF of length
1892    BUFLEN.  The printable version is the representation on the command
1893    line that the child process expects.  */
1894 int
1895 _gpgme_io_fd2str (char *buf, int buflen, int fd)
1896 {
1897 #ifdef HAVE_W32CE_SYSTEM
1898   /* FIXME: For now. See above.  */
1899   if (fd < 0 || fd >= MAX_SLAFD || !fd_table[fd].used
1900       || fd_table[fd].rvid == 0)
1901     fd = -1;
1902   else
1903     fd = fd_table[fd].rvid;
1904 #endif
1905
1906   return snprintf (buf, buflen, "%d", fd);
1907 }
1908
1909
1910 int
1911 _gpgme_io_dup (int fd)
1912 {
1913   int newfd;
1914   struct reader_context_s *rd_ctx;
1915   struct writer_context_s *wt_ctx;
1916   int i;
1917
1918   TRACE_BEG (DEBUG_SYSIO, "_gpgme_io_dup", fd);
1919
1920   if (fd < 0 || fd >= MAX_SLAFD || !fd_table[fd].used)
1921     {
1922       gpg_err_set_errno (EINVAL);
1923       return TRACE_SYSRES (-1);
1924     }
1925
1926   newfd = new_fd();
1927   if (newfd == -1)
1928     return TRACE_SYSRES (-1);
1929   
1930   fd_table[newfd].handle = fd_table[fd].handle;
1931   fd_table[newfd].socket = fd_table[fd].socket;
1932   fd_table[newfd].rvid = fd_table[fd].rvid;
1933   fd_table[newfd].dup_from = fd;
1934
1935   rd_ctx = find_reader (fd, 1);
1936   if (rd_ctx)
1937     {
1938       /* No need for locking, as the only races are against the reader
1939          thread itself, which doesn't touch refcount.  */
1940       rd_ctx->refcount++;
1941
1942       LOCK (reader_table_lock);
1943       for (i = 0; i < reader_table_size; i++)
1944         if (!reader_table[i].used)
1945           break;
1946       /* FIXME.  */
1947       assert (i != reader_table_size);
1948       reader_table[i].fd = newfd;
1949       reader_table[i].context = rd_ctx;
1950       reader_table[i].used = 1;
1951       UNLOCK (reader_table_lock);
1952     }
1953
1954   wt_ctx = find_writer (fd, 1);
1955   if (wt_ctx)
1956     {
1957       /* No need for locking, as the only races are against the writer
1958          thread itself, which doesn't touch refcount.  */
1959       wt_ctx->refcount++;
1960
1961       LOCK (writer_table_lock);
1962       for (i = 0; i < writer_table_size; i++)
1963         if (!writer_table[i].used)
1964           break;
1965       /* FIXME.  */
1966       assert (i != writer_table_size);
1967       writer_table[i].fd = newfd;
1968       writer_table[i].context = wt_ctx;
1969       writer_table[i].used = 1;
1970       UNLOCK (writer_table_lock);
1971     }
1972
1973   return TRACE_SYSRES (newfd);
1974 }
1975
1976 \f
1977 /* The following interface is only useful for GPGME Glib and Qt.  */
1978
1979 /* Compatibility interface, obsolete.  */
1980 void *
1981 gpgme_get_giochannel (int fd)
1982 {
1983   return NULL;
1984 }
1985
1986
1987 /* Look up the giochannel or qiodevice for file descriptor FD.  */
1988 void *
1989 gpgme_get_fdptr (int fd)
1990 {
1991   return NULL;
1992 }
1993
1994 \f
1995 static int
1996 wsa2errno (int err)
1997 {
1998   switch (err)
1999     {
2000     case WSAENOTSOCK:
2001       return EINVAL;
2002     case WSAEWOULDBLOCK:
2003       return EAGAIN;
2004     case ERROR_BROKEN_PIPE:
2005       return EPIPE;
2006     case WSANOTINITIALISED:
2007       return ENOSYS;
2008     default:
2009       return EIO;
2010     }
2011 }
2012
2013
2014 int
2015 _gpgme_io_socket (int domain, int type, int proto)
2016 {
2017   int res;
2018   int fd;
2019
2020   TRACE_BEG2 (DEBUG_SYSIO, "_gpgme_io_socket", domain,
2021               "type=%i, protp=%i", type, proto);
2022
2023   fd = new_fd();
2024   if (fd == -1)
2025     return TRACE_SYSRES (-1);
2026       
2027   res = socket (domain, type, proto);
2028   if (res == INVALID_SOCKET)
2029     {
2030       release_fd (fd);
2031       gpg_err_set_errno (wsa2errno (WSAGetLastError ()));
2032       return TRACE_SYSRES (-1);
2033     }
2034   fd_table[fd].socket = res;
2035
2036   TRACE_SUC2 ("socket=0x%x (0x%x)", fd, fd_table[fd].socket);
2037   
2038   return fd;
2039 }
2040
2041
2042 int
2043 _gpgme_io_connect (int fd, struct sockaddr *addr, int addrlen)
2044 {
2045   int res;
2046
2047   TRACE_BEG2 (DEBUG_SYSIO, "_gpgme_io_connect", fd,
2048               "addr=%p, addrlen=%i", addr, addrlen);
2049
2050   if (fd < 0 || fd >= MAX_SLAFD || !fd_table[fd].used)
2051     {
2052       gpg_err_set_errno (EBADF);
2053       return TRACE_SYSRES (-1);
2054     }
2055     
2056   res = connect (fd_table[fd].socket, addr, addrlen);
2057   if (res)
2058     {
2059       gpg_err_set_errno (wsa2errno (WSAGetLastError ()));
2060       return TRACE_SYSRES (-1);
2061     }
2062
2063   return TRACE_SUC ();
2064 }