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