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