2009-06-22 Marcus Brinkmann <marcus@g10code.de>
[gpgme.git] / src / w32-glib-io.c
1 /* w32-glib-io.c - W32 Glib I/O functions
2    Copyright (C) 2000 Werner Koch (dd9jn)
3    Copyright (C) 2001, 2002, 2004, 2005 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 <signal.h>
31 #include <fcntl.h>
32 #include <unistd.h>
33 #include <sys/time.h>
34 #include <sys/types.h>
35 #include <glib.h>
36 #include <windows.h>
37 #include <io.h>
38
39 #include "util.h"
40 #include "priv-io.h"
41 #include "sema.h"
42 #include "debug.h"
43
44 #ifndef O_BINARY
45 #ifdef _O_BINARY
46 #define O_BINARY        _O_BINARY
47 #else
48 #define O_BINARY        0
49 #endif
50 #endif
51
52 \f
53 /* This file is an ugly hack to get GPGME working with glib on Windows
54    targets.  On Windows, you can not select() on file descriptors.
55    The only way to check if there is something to read is to read
56    something.  This means that GPGME can not let glib check for data
57    without letting glib also handle the data on Windows targets.
58
59    The ugly consequence is that we need to work on GIOChannels in
60    GPGME, creating a glib dependency.  Also, we need to export an
61    interface for the application to get at GPGME's GIOChannel.  There
62    is no good way to abstract all this with callbacks, because the
63    whole thing is also interconnected with the creation of pipes and
64    child processes.
65
66    The following rule applies only to this I/O backend:
67
68    * ALL operations must use the user defined event loop.  GPGME can
69    not anymore provide its own event loop.  This is mostly a sanity
70    requirement: Although we have in theory all information we need to
71    make the GPGME W32 code for select still work, it would be a big
72    complication and require changes throughout GPGME.
73
74    Eventually, we probably have to bite the bullet and make some
75    really nice callback interfaces to let the user control all this at
76    a per-context level.  */
77
78 \f
79 #define MAX_SLAFD 256
80
81 static struct 
82 {
83   int used;
84
85   /* If this is not -1, then it's a libc file descriptor.  */
86   int fd;
87   /* If fd is -1, this is the Windows socket handle.  */
88   int socket;
89
90   GIOChannel *chan;
91   /* The boolean PRIMARY is true if this file descriptor caused the
92      allocation of CHAN.  Only then should CHAN be destroyed when this
93      FD is closed.  This, together with the fact that dup'ed file
94      descriptors are closed before the file descriptors from which
95      they are dup'ed are closed, ensures that CHAN is always valid,
96      and shared among all file descriptors refering to the same
97      underlying object.
98
99      The logic behind this is that there is only one reason for us to
100      dup file descriptors anyway: to allow simpler book-keeping of
101      file descriptors shared between GPGME and libassuan, which both
102      want to close something.  Using the same channel for these
103      duplicates works just fine (and in fact, using different channels
104      does not work because the W32 backend in glib does not support
105      that: One would end up with several competing reader/writer
106      threads.  */
107   int primary;
108 } giochannel_table[MAX_SLAFD];
109
110
111 static GIOChannel *
112 find_channel (int fd)
113 {
114   if (fd < 0 || fd >= MAX_SLAFD)
115     return NULL;
116
117   return giochannel_table[fd].chan;
118 }
119
120
121 /* Returns the FD or -1 on resource limit.  */
122 int
123 new_dummy_channel_from_fd (int cfd)
124 {
125   int idx;
126
127   for (idx = 0; idx < MAX_SLAFD; idx++)
128     if (! giochannel_table[idx].used)
129       break;
130
131   if (idx == MAX_SLAFD)
132     {
133       errno = EIO;
134       return -1;
135     }
136
137   giochannel_table[idx].used = 1;
138   giochannel_table[idx].chan = NULL;
139   giochannel_table[idx].fd = cfd;
140   giochannel_table[idx].socket = INVALID_SOCKET;
141   giochannel_table[idx].primary = 1;
142
143   return idx;
144 }
145
146
147 /* Returns the FD or -1 on resource limit.  */
148 int
149 new_channel_from_fd (int cfd)
150 {
151   int idx;
152
153   for (idx = 0; idx < MAX_SLAFD; idx++)
154     if (! giochannel_table[idx].used)
155       break;
156
157   if (idx == MAX_SLAFD)
158     {
159       errno = EIO;
160       return -1;
161     }
162
163   giochannel_table[idx].used = 1;
164   giochannel_table[idx].chan = g_io_channel_win32_new_fd (cfd);
165   giochannel_table[idx].fd = cfd;
166   giochannel_table[idx].socket = INVALID_SOCKET;
167   giochannel_table[idx].primary = 1;
168
169   g_io_channel_set_encoding (giochannel_table[idx].chan, NULL, NULL);
170   g_io_channel_set_buffered (giochannel_table[idx].chan, FALSE);
171
172   return idx;
173 }
174
175
176 /* Returns the FD or -1 on resource limit.  */
177 int
178 new_channel_from_socket (int sock)
179 {
180   int idx;
181
182   for (idx = 0; idx < MAX_SLAFD; idx++)
183     if (! giochannel_table[idx].used)
184       break;
185
186   if (idx == MAX_SLAFD)
187     {
188       errno = EIO;
189       return -1;
190     }
191
192   giochannel_table[idx].used = 1;
193   giochannel_table[idx].chan = g_io_channel_win32_new_socket (sock);
194   giochannel_table[idx].fd = -1;
195   giochannel_table[idx].socket = sock;
196   giochannel_table[idx].primary = 1;
197
198   g_io_channel_set_encoding (giochannel_table[idx].chan, NULL, NULL);
199   g_io_channel_set_buffered (giochannel_table[idx].chan, FALSE);
200
201   return idx;
202 }
203
204
205 /* Compatibility interface.  Obsolete.  */
206 void *
207 gpgme_get_giochannel (int fd)
208 {
209   return find_channel (fd);
210 }
211
212
213 /* Look up the giochannel for "file descriptor" FD.  */
214 void *
215 gpgme_get_fdptr (int fd)
216 {
217   return find_channel (fd);
218 }
219
220
221 /* Write the printable version of FD to the buffer BUF of length
222    BUFLEN.  The printable version is the representation on the command
223    line that the child process expects.  */
224 int
225 _gpgme_io_fd2str (char *buf, int buflen, int fd)
226 {
227   HANDLE hndl;
228     
229   TRACE_BEG1 (DEBUG_SYSIO, "_gpgme_io_fd2str", fd, "fd=%d", fd);
230   if (giochannel_table[fd].fd != -1)
231     hndl = (HANDLE) _get_osfhandle (giochannel_table[fd].fd);
232   else
233     hndl = (HANDLE) giochannel_table[fd].socket;
234
235   TRACE_SUC1 ("syshd=%p", hndl);
236   
237   return snprintf (buf, buflen, "%d", (int) hndl);
238 }
239
240 \f
241 void
242 _gpgme_io_subsystem_init (void)
243 {
244 }
245
246 \f
247 static struct
248 {
249   _gpgme_close_notify_handler_t handler;
250   void *value;
251 } notify_table[MAX_SLAFD];
252
253
254 int
255 _gpgme_io_read (int fd, void *buffer, size_t count)
256 {
257   int saved_errno = 0;
258   gsize nread;
259   GIOChannel *chan;
260   GIOStatus status;
261   TRACE_BEG2 (DEBUG_SYSIO, "_gpgme_io_read", fd,
262               "buffer=%p, count=%u", buffer, count);
263
264   chan = find_channel (fd);
265   if (!chan)
266     {
267       TRACE_LOG ("no channel registered");
268       errno = EINVAL;
269       return TRACE_SYSRES (-1);
270     }
271   TRACE_LOG1 ("channel %p", chan);
272
273   {
274     GError *err = NULL;
275     status = g_io_channel_read_chars (chan, (gchar *) buffer,
276                                       count, &nread, &err);
277     if (err)
278       {
279         TRACE_LOG2 ("status %i, err %s", status, err->message);
280         g_error_free (err);
281       }
282   }
283
284   if (status == G_IO_STATUS_EOF)
285     nread = 0;
286   else if (status == G_IO_STATUS_AGAIN)
287     {
288       nread = -1;
289       saved_errno = EAGAIN;
290     }
291   else if (status != G_IO_STATUS_NORMAL)
292     {
293       TRACE_LOG1 ("status %d", status);
294       nread = -1;
295       saved_errno = EIO;
296     }
297   
298   if (nread != 0 && nread != -1)
299     TRACE_LOGBUF (buffer, nread);
300
301   errno = saved_errno;
302   return TRACE_SYSRES (nread);
303 }
304
305
306 int
307 _gpgme_io_write (int fd, const void *buffer, size_t count)
308 {
309   int saved_errno = 0;
310   gsize nwritten;
311   GIOChannel *chan;
312   GIOStatus status;
313   GError *err = NULL;
314
315   TRACE_BEG2 (DEBUG_SYSIO, "_gpgme_io_write", fd,
316               "buffer=%p, count=%u", buffer, count);
317   TRACE_LOGBUF (buffer, count);
318
319   chan = find_channel (fd);
320   if (!chan)
321     {
322       TRACE_LOG ("fd %d: no channel registered");
323       errno = EINVAL;
324       return -1;
325     }
326
327   status = g_io_channel_write_chars (chan, (gchar *) buffer, count,
328                                      &nwritten, &err);
329   if (err)
330     {
331       TRACE_LOG1 ("write error: %s", err->message);
332       g_error_free (err);
333     }
334
335   if (status == G_IO_STATUS_AGAIN)
336     {
337       nwritten = -1;
338       saved_errno = EAGAIN;
339     }
340   else if (status != G_IO_STATUS_NORMAL)
341     {
342       nwritten = -1;
343       saved_errno = EIO;
344     }
345   errno = saved_errno;
346
347   return TRACE_SYSRES (nwritten);
348 }
349
350
351 int
352 _gpgme_io_pipe (int filedes[2], int inherit_idx)
353 {
354   int fds[2];
355
356   TRACE_BEG2 (DEBUG_SYSIO, "_gpgme_io_pipe", filedes,
357               "inherit_idx=%i (GPGME uses it for %s)",
358               inherit_idx, inherit_idx ? "reading" : "writing");
359
360 #define PIPEBUF_SIZE  4096
361   if (_pipe (fds, PIPEBUF_SIZE, O_NOINHERIT | O_BINARY) == -1)
362     return TRACE_SYSRES (-1);
363
364   /* Make one end inheritable. */
365   if (inherit_idx == 0)
366     {
367       int new_read;
368
369       new_read = _dup (fds[0]);
370       _close (fds[0]);
371       fds[0] = new_read;
372
373       if (new_read < 0)
374         {
375           _close (fds[1]);
376           return TRACE_SYSRES (-1);
377         }
378     }
379   else if (inherit_idx == 1)
380     {
381       int new_write;
382
383       new_write = _dup (fds[1]);
384       _close (fds[1]);
385       fds[1] = new_write;
386
387       if (new_write < 0)
388         {
389           _close (fds[0]);
390           return TRACE_SYSRES (-1);
391         }
392     }
393
394   /* For _gpgme_io_close.  */
395   filedes[inherit_idx] = new_dummy_channel_from_fd (fds[inherit_idx]);
396   if (filedes[inherit_idx] < 0)
397     {
398       int saved_errno = errno;
399       
400       _close (fds[0]);
401       _close (fds[1]);
402       errno = saved_errno;
403       return TRACE_SYSRES (-1);
404     }
405
406   /* Now we have a pipe with the correct end inheritable.  The other end
407      should have a giochannel.  */
408   filedes[1 - inherit_idx] = new_channel_from_fd (fds[1 - inherit_idx]);
409   if (filedes[1 - inherit_idx] < 0)
410     {
411       int saved_errno = errno;
412       
413       _gpgme_io_close (fds[inherit_idx]);
414       _close (fds[1 - inherit_idx]);
415       errno = saved_errno;
416       return TRACE_SYSRES (-1);
417     }
418   
419   return TRACE_SUC5 ("read=0x%x/%p, write=0x%x/%p, channel=%p",
420                      filedes[0],
421                      (HANDLE) _get_osfhandle (giochannel_table[filedes[0]].fd),
422                      filedes[1],
423                      (HANDLE) _get_osfhandle (giochannel_table[filedes[1]].fd),
424                      giochannel_table[1 - inherit_idx].chan);
425 }
426
427
428 int
429 _gpgme_io_close (int fd)
430 {
431   TRACE_BEG (DEBUG_SYSIO, "_gpgme_io_close", fd);
432
433   if (fd < 0 || fd >= MAX_SLAFD)
434     {
435       errno = EBADF;
436       return TRACE_SYSRES (-1);
437     }
438
439   assert (giochannel_table[fd].used);
440
441   /* First call the notify handler.  */
442   if (notify_table[fd].handler)
443     {
444       notify_table[fd].handler (fd, notify_table[fd].value);
445       notify_table[fd].handler = NULL;
446       notify_table[fd].value = NULL;
447     }
448
449   /* Then do the close.  */
450   if (giochannel_table[fd].chan)
451     {
452       if (giochannel_table[fd].primary)
453         g_io_channel_shutdown (giochannel_table[fd].chan, 1, NULL);
454       
455       g_io_channel_unref (giochannel_table[fd].chan);
456     }
457   else
458     {
459       /* Dummy entry, just close.  */
460       assert (giochannel_table[fd].fd != -1);
461       _close (giochannel_table[fd].fd);
462     }
463         
464   giochannel_table[fd].used = 0;
465   giochannel_table[fd].fd = -1;
466   giochannel_table[fd].socket = INVALID_SOCKET;
467   giochannel_table[fd].chan = NULL;
468   giochannel_table[fd].primary = 0;
469
470   TRACE_SUC ();
471   return 0;
472 }
473
474
475 int
476 _gpgme_io_set_close_notify (int fd, _gpgme_close_notify_handler_t handler,
477                             void *value)
478 {
479   TRACE_BEG2 (DEBUG_SYSIO, "_gpgme_io_set_close_notify", fd,
480               "close_handler=%p/%p", handler, value);
481
482   assert (fd != -1);
483
484   if (fd < 0 || fd >= (int) DIM (notify_table))
485     {
486       errno = EINVAL;
487       return TRACE_SYSRES (-1);
488     }
489   notify_table[fd].handler = handler;
490   notify_table[fd].value = value;
491   return TRACE_SYSRES (0);
492 }
493
494
495 int
496 _gpgme_io_set_nonblocking (int fd)
497 {
498   GIOChannel *chan;
499   GIOStatus status;
500  
501   TRACE_BEG (DEBUG_SYSIO, "_gpgme_io_set_nonblocking", fd);
502
503   chan = find_channel (fd);
504   if (!chan)
505     {
506       errno = EIO;
507       return TRACE_SYSRES (-1);
508     }
509
510   status = g_io_channel_set_flags (chan,
511                                    g_io_channel_get_flags (chan) |
512                                    G_IO_FLAG_NONBLOCK, NULL);
513
514   if (status != G_IO_STATUS_NORMAL)
515     {
516 #if 0
517       /* glib 1.9.2 does not implement set_flags and returns an
518          error.  */
519       errno = EIO;
520       return TRACE_SYSRES (-1);
521 #else
522       TRACE_LOG1 ("g_io_channel_set_flags failed: status=%d (ignored)",
523                   status);
524 #endif
525     }
526
527   return TRACE_SYSRES (0);
528 }
529
530
531 static char *
532 build_commandline (char **argv)
533 {
534   int i;
535   int n = 0;
536   char *buf;
537   char *p;
538   
539   /* We have to quote some things because under Windows the program
540      parses the commandline and does some unquoting.  We enclose the
541      whole argument in double-quotes, and escape literal double-quotes
542      as well as backslashes with a backslash.  We end up with a
543      trailing space at the end of the line, but that is harmless.  */
544   for (i = 0; argv[i]; i++)
545     {
546       p = argv[i];
547       /* The leading double-quote.  */
548       n++;
549       while (*p)
550         {
551           /* An extra one for each literal that must be escaped.  */
552           if (*p == '\\' || *p == '"')
553             n++;
554           n++;
555           p++;
556         }
557       /* The trailing double-quote and the delimiter.  */
558       n += 2;
559     }
560   /* And a trailing zero.  */
561   n++;
562
563   buf = p = malloc (n);
564   if (!buf)
565     return NULL;
566   for (i = 0; argv[i]; i++)
567     {
568       char *argvp = argv[i];
569
570       *(p++) = '"';
571       while (*argvp)
572         {
573           if (*argvp == '\\' || *argvp == '"')
574             *(p++) = '\\';
575           *(p++) = *(argvp++);
576         }
577       *(p++) = '"';
578       *(p++) = ' ';
579     }
580   *(p++) = 0;
581
582   return buf;
583 }
584
585
586 int
587 _gpgme_io_spawn (const char *path, char * const argv[], unsigned int flags,
588                  struct spawn_fd_item_s *fd_list, pid_t *r_pid)
589 {
590   SECURITY_ATTRIBUTES sec_attr;
591   PROCESS_INFORMATION pi =
592     {
593       NULL,      /* returns process handle */
594       0,         /* returns primary thread handle */
595       0,         /* returns pid */
596       0          /* returns tid */
597     };
598   STARTUPINFO si;
599   int cr_flags = (CREATE_DEFAULT_ERROR_MODE
600                   | GetPriorityClass (GetCurrentProcess ()));
601   int i;
602   char **args;
603   char *arg_string;
604   /* FIXME.  */
605   int debug_me = 0;
606   int tmp_fd;
607   char *tmp_name;
608
609   TRACE_BEG1 (DEBUG_SYSIO, "_gpgme_io_spawn", path,
610               "path=%s", path);
611   i = 0;
612   while (argv[i])
613     {
614       TRACE_LOG2 ("argv[%2i] = %s", i, argv[i]);
615       i++;
616     }
617   
618   /* We do not inherit any handles by default, and just insert those
619      handles we want the child to have afterwards.  But some handle
620      values occur on the command line, and we need to move
621      stdin/out/err to the right location.  So we use a wrapper program
622      which gets the information from a temporary file.  */
623   if (_gpgme_mkstemp (&tmp_fd, &tmp_name) < 0)
624     {
625       TRACE_LOG1 ("_gpgme_mkstemp failed: %s", strerror (errno));
626       return TRACE_SYSRES (-1);
627     }
628   TRACE_LOG1 ("tmp_name = %s", tmp_name);
629
630   args = calloc (2 + i + 1, sizeof (*args));
631   args[0] = (char *) _gpgme_get_w32spawn_path ();
632   args[1] = tmp_name;
633   args[2] = path;
634   memcpy (&args[3], &argv[1], i * sizeof (*args));
635
636   memset (&sec_attr, 0, sizeof sec_attr);
637   sec_attr.nLength = sizeof sec_attr;
638   sec_attr.bInheritHandle = FALSE;
639   
640   arg_string = build_commandline (args);
641   free (args);
642   if (!arg_string)
643     {
644       close (tmp_fd);
645       DeleteFile (tmp_name);
646       return TRACE_SYSRES (-1);
647     }
648
649   memset (&si, 0, sizeof si);
650   si.cb = sizeof (si);
651   si.dwFlags = STARTF_USESTDHANDLES | STARTF_USESHOWWINDOW;
652   si.wShowWindow = debug_me ? SW_SHOW : SW_HIDE;
653   si.hStdInput = INVALID_HANDLE_VALUE;
654   si.hStdOutput = INVALID_HANDLE_VALUE;
655   si.hStdError = INVALID_HANDLE_VALUE;
656
657   cr_flags |= CREATE_SUSPENDED;
658   cr_flags |= DETACHED_PROCESS;
659   if (!CreateProcessA (_gpgme_get_w32spawn_path (),
660                        arg_string,
661                        &sec_attr,     /* process security attributes */
662                        &sec_attr,     /* thread security attributes */
663                        FALSE,         /* inherit handles */
664                        cr_flags,      /* creation flags */
665                        NULL,          /* environment */
666                        NULL,          /* use current drive/directory */
667                        &si,           /* startup information */
668                        &pi))          /* returns process information */
669     {
670       TRACE_LOG1 ("CreateProcess failed: ec=%d", (int) GetLastError ());
671       free (arg_string);
672       close (tmp_fd);
673       DeleteFile (tmp_name);
674
675       /* FIXME: Should translate the error code.  */
676       errno = EIO;
677       return TRACE_SYSRES (-1);
678     }
679
680   free (arg_string);
681   
682   if (flags & IOSPAWN_FLAG_ALLOW_SET_FG)
683     _gpgme_allow_set_foreground_window ((pid_t)pi.dwProcessId);
684
685   /* Insert the inherited handles.  */
686   for (i = 0; fd_list[i].fd != -1; i++)
687     {
688       HANDLE hd;
689
690       /* Make it inheritable for the wrapper process.  */
691       if (!DuplicateHandle (GetCurrentProcess(),
692                             _get_osfhandle (giochannel_table[fd_list[i].fd].fd),
693                             pi.hProcess, &hd, 0, TRUE, DUPLICATE_SAME_ACCESS))
694         {
695           TRACE_LOG1 ("DuplicateHandle failed: ec=%d", (int) GetLastError ());
696           TerminateProcess (pi.hProcess, 0);
697           /* Just in case TerminateProcess didn't work, let the
698              process fail on its own.  */
699           ResumeThread (pi.hThread);
700           CloseHandle (pi.hThread);
701           CloseHandle (pi.hProcess);
702
703           close (tmp_fd);
704           DeleteFile (tmp_name);
705
706           /* FIXME: Should translate the error code.  */
707           errno = EIO;
708           return TRACE_SYSRES (-1);
709         }
710       /* Return the child name of this handle.  */
711       fd_list[i].peer_name = (int) hd;
712     }
713
714   /* Write the handle translation information to the temporary
715      file.  */
716   {
717     /* Hold roughly MAX_TRANS quadruplets of 64 bit numbers in hex
718        notation: "0xFEDCBA9876543210" with an extra white space after
719        every quadruplet.  10*(19*4 + 1) - 1 = 769.  This plans ahead
720        for a time when a HANDLE is 64 bit.  */
721 #define BUFFER_MAX 800
722     char line[BUFFER_MAX + 1];
723     int res;
724     int written;
725     size_t len;
726
727     if ((flags & IOSPAWN_FLAG_ALLOW_SET_FG))
728       strcpy (line, "~1 \n");
729     else
730       strcpy (line, "\n");
731     for (i = 0; fd_list[i].fd != -1; i++)
732       {
733         /* Strip the newline.  */
734         len = strlen (line) - 1;
735         
736         /* Format is: Local name, stdin/stdout/stderr, peer name, argv idx.  */
737         snprintf (&line[len], BUFFER_MAX - len, "0x%x %d 0x%x %d  \n",
738                   fd_list[i].fd, fd_list[i].dup_to,
739                   fd_list[i].peer_name, fd_list[i].arg_loc);
740         /* Rather safe than sorry.  */
741         line[BUFFER_MAX - 1] = '\n';
742         line[BUFFER_MAX] = '\0';
743       }
744     len = strlen (line);
745     written = 0;
746     do
747       {
748         res = write (tmp_fd, &line[written], len - written);
749         if (res > 0)
750           written += res;
751       }
752     while (res > 0 || (res < 0 && errno == EAGAIN));
753   }
754   close (tmp_fd);
755   /* The temporary file is deleted by the gpgme-w32spawn process
756      (hopefully).  */
757     
758   TRACE_LOG4 ("CreateProcess ready: hProcess=%p, hThread=%p, "
759               "dwProcessID=%d, dwThreadId=%d",
760               pi.hProcess, pi.hThread, 
761               (int) pi.dwProcessId, (int) pi.dwThreadId);
762   
763   if (r_pid)
764     *r_pid = (pid_t)pi.dwProcessId;
765
766   if (ResumeThread (pi.hThread) < 0)
767     TRACE_LOG1 ("ResumeThread failed: ec=%d", (int) GetLastError ());
768   
769   if (!CloseHandle (pi.hThread))
770     TRACE_LOG1 ("CloseHandle of thread failed: ec=%d",
771                 (int) GetLastError ());
772
773   TRACE_LOG1 ("process=%p", pi.hProcess);
774
775   /* We don't need to wait for the process.  */
776   if (!CloseHandle (pi.hProcess))
777     TRACE_LOG1 ("CloseHandle of process failed: ec=%d",
778                 (int) GetLastError ());
779
780   for (i = 0; fd_list[i].fd != -1; i++)
781     _gpgme_io_close (fd_list[i].fd);
782
783   for (i = 0; fd_list[i].fd != -1; i++)
784     if (fd_list[i].dup_to == -1)
785       TRACE_LOG3 ("fd[%i] = 0x%x -> 0x%x", i, fd_list[i].fd,
786                   fd_list[i].peer_name);
787     else
788       TRACE_LOG4 ("fd[%i] = 0x%x -> 0x%x (std%s)", i, fd_list[i].fd,
789                   fd_list[i].peer_name, (fd_list[i].dup_to == 0) ? "in" :
790                   ((fd_list[i].dup_to == 1) ? "out" : "err"));
791
792   return TRACE_SYSRES (0);
793 }
794
795
796 /* Select on the list of fds.  Returns: -1 = error, 0 = timeout or
797    nothing to select, > 0 = number of signaled fds.  */
798 int
799 _gpgme_io_select (struct io_select_fd_s *fds, size_t nfds, int nonblock)
800 {
801   int npollfds;
802   GPollFD *pollfds;
803   int *pollfds_map; 
804   int i;
805   int j;
806   int any;
807   int n;
808   int count;
809   /* Use a 1s timeout.  */
810   int timeout = 1000;
811   void *dbg_help = NULL;
812   TRACE_BEG2 (DEBUG_SYSIO, "_gpgme_io_select", fds,
813               "nfds=%u, nonblock=%u", nfds, nonblock);
814
815   if (nonblock)
816     timeout = 0;
817
818   pollfds = calloc (nfds, sizeof *pollfds);
819   if (!pollfds)
820     return -1;
821   pollfds_map = calloc (nfds, sizeof *pollfds_map);
822   if (!pollfds_map)
823     {
824       free (pollfds);
825       return -1;
826     }
827   npollfds = 0;
828
829   TRACE_SEQ (dbg_help, "select on [ ");
830   any = 0;
831   for (i = 0; i < nfds; i++)
832     {
833       GIOChannel *chan = NULL;
834
835       if (fds[i].fd == -1) 
836         continue;
837
838       if ((fds[i].for_read || fds[i].for_write)
839           && !(chan = find_channel (fds[i].fd)))
840         {
841           TRACE_ADD1 (dbg_help, "[BAD0x%x ", fds[i].fd);
842           TRACE_END (dbg_help, "]"); 
843           assert (!"see log file");
844         }
845       else if (fds[i].for_read )
846         {
847           assert(chan);
848           g_io_channel_win32_make_pollfd (chan, G_IO_IN, pollfds + npollfds);
849           pollfds_map[npollfds] = i;
850           TRACE_ADD2 (dbg_help, "r0x%x<%d> ", fds[i].fd, pollfds[npollfds].fd);
851           npollfds++;
852           any = 1;
853         }
854       else if (fds[i].for_write)
855         {
856           assert(chan);
857           g_io_channel_win32_make_pollfd (chan, G_IO_OUT, pollfds + npollfds);
858           pollfds_map[npollfds] = i;
859           TRACE_ADD2 (dbg_help, "w0x%x<%d> ", fds[i].fd, pollfds[npollfds].fd);
860           npollfds++;
861           any = 1;
862         }
863       fds[i].signaled = 0;
864     }
865   TRACE_END (dbg_help, "]"); 
866   if (!any)
867     {
868       count = 0;
869       goto leave;
870     }
871
872
873   count = g_io_channel_win32_poll (pollfds, npollfds, timeout);
874   if (count < 0)
875     {
876       int saved_errno = errno;
877       errno = saved_errno;
878       goto leave;
879     }
880
881   TRACE_SEQ (dbg_help, "select OK [ ");
882   if (TRACE_ENABLED (dbg_help))
883     {
884       for (i = 0; i < npollfds; i++)
885         {
886           if ((pollfds[i].revents & G_IO_IN))
887             TRACE_ADD1 (dbg_help, "r0x%x ", fds[pollfds_map[i]].fd);
888           if ((pollfds[i].revents & G_IO_OUT))
889             TRACE_ADD1 (dbg_help, "w0x%x ", fds[pollfds_map[i]].fd);
890         }
891       TRACE_END (dbg_help, "]");
892     }
893     
894   /* COUNT is used to stop the lop as soon as possible.  */
895   for (n = count, i = 0; i < npollfds && n; i++)
896     {
897       j = pollfds_map[i];
898       assert (j >= 0 && j < nfds);
899       if (fds[j].fd == -1)
900         ;
901       else if (fds[j].for_read)
902         {
903           if ((pollfds[i].revents & G_IO_IN))
904             {
905               fds[j].signaled = 1;
906               n--;
907             }
908         }
909       else if (fds[j].for_write)
910         {
911           if ((pollfds[i].revents & G_IO_OUT))
912             {
913               fds[j].signaled = 1;
914               n--;
915             }
916         }
917     }
918
919 leave:
920   free (pollfds);
921   free (pollfds_map);
922   return TRACE_SYSRES (count);
923 }
924
925
926 int
927 _gpgme_io_dup (int fd)
928 {
929   int newfd;
930   GIOChannel *chan;
931
932   TRACE_BEG (DEBUG_SYSIO, "_gpgme_io_dup", fd);
933
934   if (fd < 0 || fd >= MAX_SLAFD || !giochannel_table[fd].used)
935     {
936       errno = EINVAL;
937       return TRACE_SYSRES (-1);
938     }
939
940   for (newfd = 0; newfd < MAX_SLAFD; newfd++)
941     if (! giochannel_table[newfd].used)
942       break;
943   if (newfd == MAX_SLAFD)
944     {
945       errno = EIO;
946       return TRACE_SYSRES (-1);
947     }
948   
949   chan = giochannel_table[fd].chan;
950   g_io_channel_ref (chan);
951   giochannel_table[newfd].used = 1;
952   giochannel_table[newfd].chan = chan;
953   giochannel_table[newfd].fd = -1;
954   giochannel_table[newfd].socket = INVALID_SOCKET;
955   giochannel_table[newfd].primary = 0;
956
957   return TRACE_SYSRES (newfd);
958 }
959
960 \f
961
962
963 \f
964 static int
965 wsa2errno (int err)
966 {
967   switch (err)
968     {
969     case WSAENOTSOCK:
970       return EINVAL;
971     case WSAEWOULDBLOCK:
972       return EAGAIN;
973     case ERROR_BROKEN_PIPE:
974       return EPIPE;
975     case WSANOTINITIALISED:
976       return ENOSYS;
977     default:
978       return EIO;
979     }
980 }
981
982
983 int
984 _gpgme_io_socket (int domain, int type, int proto)
985 {
986   int res;
987   int fd;
988
989   TRACE_BEG2 (DEBUG_SYSIO, "_gpgme_io_socket", domain,
990               "type=%i, protp=%i", type, proto);
991
992   res = socket (domain, type, proto);
993   if (res == INVALID_SOCKET)
994     {
995       errno = wsa2errno (WSAGetLastError ());
996       return TRACE_SYSRES (-1);
997     }
998
999   fd = new_channel_from_socket (res);
1000   if (fd < 0)
1001     {
1002       int saved_errno = errno;
1003       closesocket (res);
1004       errno = saved_errno;
1005       return TRACE_SYSRES (-1);
1006     }
1007
1008   TRACE_SUC2 ("fd=%i, socket=0x%x", fd, res);
1009   
1010   return fd;
1011 }
1012
1013
1014 int
1015 _gpgme_io_connect (int fd, struct sockaddr *addr, int addrlen)
1016 {
1017   GIOChannel *chan; 
1018   int sockfd;
1019   int res;
1020   GIOFlags flags;
1021   GIOStatus status;
1022   GError *err = NULL;
1023
1024   TRACE_BEG2 (DEBUG_SYSIO, "_gpgme_io_connect", fd,
1025               "addr=%p, addrlen=%i", addr, addrlen);
1026
1027   chan = find_channel (fd);
1028   if (! chan)
1029     {
1030       errno = EINVAL;
1031       return TRACE_SYSRES (-1);
1032     }
1033
1034   flags = g_io_channel_get_flags (chan);
1035   if (flags & G_IO_FLAG_NONBLOCK)
1036     {
1037       status = g_io_channel_set_flags (chan, flags & ~G_IO_FLAG_NONBLOCK, &err);
1038       if (err)
1039         {
1040           TRACE_LOG1 ("setting flags error: %s", err->message);
1041           g_error_free (err);
1042           err = NULL;
1043         }
1044       if (status != G_IO_STATUS_NORMAL)
1045         {
1046           errno = EIO;
1047           return TRACE_SYSRES (-1);
1048         }
1049     }
1050
1051   sockfd = giochannel_table[fd].socket;
1052   if (sockfd == INVALID_SOCKET)
1053     {
1054       errno = EINVAL;
1055       return TRACE_SYSRES (-1);
1056     }
1057
1058   TRACE_LOG1 ("connect sockfd=0x%x", sockfd);
1059   res = connect (sockfd, addr, addrlen);
1060
1061   /* FIXME: Error ignored here.  */
1062   if (! (flags & G_IO_FLAG_NONBLOCK))
1063     g_io_channel_set_flags (chan, flags, NULL);
1064
1065   if (res)
1066     {
1067       TRACE_LOG2 ("connect failed: %i %i", res, WSAGetLastError ());
1068
1069       errno = wsa2errno (WSAGetLastError ());
1070       return TRACE_SYSRES (-1);
1071     }
1072
1073   return TRACE_SUC ();
1074 }