Add 2 missing files and other changes
[gpgme.git] / gpgme / w32-io.c
1 /* w32-io.c - W32 API I/O functions
2  *      Copyright (C) 2000 Werner Koch (dd9jn)
3  *
4  * This file is part of GPGME.
5  *
6  * GPGME is free software; you can redistribute it and/or modify
7  * it under the terms of the GNU General Public License as published by
8  * the Free Software Foundation; either version 2 of the License, or
9  * (at your option) any later version.
10  *
11  * GPGME is distributed in the hope that it will be useful,
12  * but WITHOUT ANY WARRANTY; without even the implied warranty of
13  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
14  * GNU General Public License for more details.
15  *
16  * You should have received a copy of the GNU General Public License
17  * along with this program; if not, write to the Free Software
18  * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA
19  */
20
21 #include <config.h>
22 #ifdef HAVE_DOSISH_SYSTEM
23
24 #include <stdio.h>
25 #include <stdlib.h>
26 #include <string.h>
27 #include <assert.h>
28 #include <errno.h>
29 #include <sys/time.h>
30 #include <sys/types.h>
31 #include <signal.h>
32 #include <fcntl.h>
33 #include <windows.h>
34 #include "syshdr.h"
35
36 #include "util.h"
37 #include "io.h"
38
39 #define DEBUG_SELECT_ENABLED 1
40
41 #if DEBUG_SELECT_ENABLED
42 # define DEBUG_SELECT(a) fprintf a
43 #else
44 # define DEBUG_SELECT(a) do { } while(0)
45 #endif
46
47
48
49 /* 
50  * We assume that a HANDLE can be represented by an int which should be true   
51  * for all i386 systems (HANDLE is defined as void *) and these are the only
52  * systems for which Windows is available.
53  * Further we assume that -1 denotes an invalid handle.
54  */
55
56 #define fd_to_handle(a)  ((HANDLE)(a))
57 #define handle_to_fd(a)  ((int)(a))
58 #define pid_to_handle(a) ((HANDLE)(a))
59 #define handle_to_pid(a) ((int)(a))
60
61
62 int
63 _gpgme_io_read ( int fd, void *buffer, size_t count )
64 {
65     int nread = 0;
66     HANDLE h = fd_to_handle (fd);
67
68     DEBUG_SELECT ((stderr,"** fd %d: about to read %d bytes\n", fd, (int)count ));
69     if ( !ReadFile ( h, buffer, count, &nread, NULL) ) {
70         fprintf (stderr, "** ReadFile failed: ec=%d\n", (int)GetLastError ());
71         return -1;
72     }
73     DEBUG_SELECT ((stderr,"** fd %d:           got %d bytes\n", fd, nread ));
74
75     return nread;
76 }
77
78
79 int
80 _gpgme_io_write ( int fd, const void *buffer, size_t count )
81 {
82     int nwritten;
83     HANDLE h = fd_to_handle (fd);
84
85     DEBUG_SELECT ((stderr,"** fd %d: about to write %d bytes\n", fd, (int)count ));
86     if ( !WriteFile ( h, buffer, count, &nwritten, NULL) ) {
87         fprintf (stderr, "** WriteFile failed: ec=%d\n", (int)GetLastError ());
88         return -1;
89     }
90     DEBUG_SELECT ((stderr,"** fd %d:          wrote %d bytes\n", fd, nwritten ));
91
92     return nwritten;
93 }
94
95 int
96 _gpgme_io_pipe ( int filedes[2], int inherit_idx )
97 {
98     HANDLE r, w;
99     SECURITY_ATTRIBUTES sec_attr;
100
101     memset (&sec_attr, 0, sizeof sec_attr );
102     sec_attr.nLength = sizeof sec_attr;
103     sec_attr.bInheritHandle = FALSE;
104     
105     if (!CreatePipe ( &r, &w, &sec_attr, 0))
106         return -1;
107     /* make one end inheritable */
108     if ( inherit_idx == 0 ) {
109         HANDLE h;
110         if (!DuplicateHandle( GetCurrentProcess(), r,
111                               GetCurrentProcess(), &h, 0,
112                               TRUE, DUPLICATE_SAME_ACCESS ) ) {
113             fprintf (stderr, "** DuplicateHandle failed: ec=%d\n",
114                      (int)GetLastError());
115             CloseHandle (r);
116             CloseHandle (w);
117             return -1;
118         }
119         CloseHandle (r);
120         r = h;
121     }
122     else if ( inherit_idx == 1 ) {
123         HANDLE h;
124         if (!DuplicateHandle( GetCurrentProcess(), w,
125                               GetCurrentProcess(), &h, 0,
126                               TRUE, DUPLICATE_SAME_ACCESS ) ) {
127             fprintf (stderr, "** DuplicateHandle failed: ec=%d\n",
128                      (int)GetLastError());
129             CloseHandle (r);
130             CloseHandle (w);
131             return -1;
132         }
133         CloseHandle (w);
134         w = h;
135     }
136
137     filedes[0] = handle_to_fd (r);
138     filedes[1] = handle_to_fd (w);
139     DEBUG_SELECT ((stderr,"** create pipe %p %p %d %d inherit=%d\n", r, w,
140                    filedes[0], filedes[1], inherit_idx ));
141     return 0;
142 }
143
144 int
145 _gpgme_io_close ( int fd )
146 {
147     if ( fd == -1 )
148         return -1;
149
150     DEBUG_SELECT ((stderr,"** closing handle for fd %d\n", fd));
151     if ( !CloseHandle (fd_to_handle (fd)) ) { 
152         fprintf (stderr, "** CloseHandle for fd %d failed: ec=%d\n",
153                  fd, (int)GetLastError ());
154         return -1;
155     }
156
157     return 0;
158 }
159
160
161 int
162 _gpgme_io_set_nonblocking ( int fd )
163 {
164     return 0;
165 }
166
167
168 static char *
169 build_commandline ( char **argv )
170 {
171     int i, n = 0;
172     char *buf, *p;
173
174     /* FIXME: we have to quote some things because under Windows the 
175      * program parses the commandline and does some unquoting */
176     for (i=0; argv[i]; i++)
177         n += strlen (argv[i]) + 1;
178     buf = p = xtrymalloc (n);
179     if ( !buf )
180         return NULL;
181     *buf = 0;
182     if ( argv[0] )
183         p = stpcpy (p, argv[0]);
184     for (i = 1; argv[i]; i++)
185         p = stpcpy (stpcpy (p, " "), argv[i]);
186
187     return buf;
188 }
189
190
191 int
192 _gpgme_io_spawn ( const char *path, char **argv,
193                   struct spawn_fd_item_s *fd_child_list,
194                   struct spawn_fd_item_s *fd_parent_list )
195 {
196     SECURITY_ATTRIBUTES sec_attr;
197     PROCESS_INFORMATION pi = {
198         NULL,      /* returns process handle */
199         0,         /* returns primary thread handle */
200         0,         /* returns pid */
201         0         /* returns tid */
202     };
203     STARTUPINFO si;
204     char *envblock = NULL;
205     int cr_flags = CREATE_DEFAULT_ERROR_MODE
206                  | GetPriorityClass (GetCurrentProcess ());
207     int i;
208     char *arg_string;
209     int duped_stdin = 0;
210     int duped_stderr = 0;
211     HANDLE hnul = INVALID_HANDLE_VALUE;
212     int debug_me = !!getenv ("GPGME_DEBUG");
213
214     memset (&sec_attr, 0, sizeof sec_attr );
215     sec_attr.nLength = sizeof sec_attr;
216     sec_attr.bInheritHandle = FALSE;
217
218     arg_string = build_commandline ( argv );
219     if (!arg_string )
220         return -1; 
221
222     memset (&si, 0, sizeof si);
223     si.cb = sizeof (si);
224     si.dwFlags = STARTF_USESTDHANDLES | STARTF_USESHOWWINDOW;
225     si.wShowWindow = debug_me? SW_SHOW : SW_MINIMIZE;
226     si.hStdInput = GetStdHandle (STD_INPUT_HANDLE);
227     si.hStdOutput = GetStdHandle (STD_OUTPUT_HANDLE);
228     si.hStdError = GetStdHandle (STD_ERROR_HANDLE);
229
230     for (i=0; fd_child_list[i].fd != -1; i++ ) {
231         if (fd_child_list[i].dup_to == 0 ) {
232             si.hStdInput = fd_to_handle (fd_child_list[i].fd);
233             DEBUG_SELECT ((stderr,"** using %d for stdin\n", fd_child_list[i].fd ));
234             duped_stdin=1;
235         }
236         else if (fd_child_list[i].dup_to == 1 ) {
237             si.hStdOutput = fd_to_handle (fd_child_list[i].fd);
238             DEBUG_SELECT ((stderr,"** using %d for stdout\n", fd_child_list[i].fd ));
239         }
240         else if (fd_child_list[i].dup_to == 2 ) {
241             si.hStdError = fd_to_handle (fd_child_list[i].fd);
242             DEBUG_SELECT ((stderr,"** using %d for stderr\n", fd_child_list[i].fd ));
243             duped_stderr = 1;
244         }
245     }
246
247     if( !duped_stdin || !duped_stderr ) {
248         SECURITY_ATTRIBUTES sa;
249
250         memset (&sa, 0, sizeof sa );
251         sa.nLength = sizeof sa;
252         sa.bInheritHandle = TRUE;
253         hnul = CreateFile ( "/dev/nul",
254                             GENERIC_READ|GENERIC_WRITE,
255                             FILE_SHARE_READ|FILE_SHARE_WRITE,
256                             &sa,
257                             OPEN_EXISTING,
258                             FILE_ATTRIBUTE_NORMAL,
259                             NULL );
260         if ( hnul == INVALID_HANDLE_VALUE ) {
261             fprintf (stderr,"can't open `/dev/nul': ec=%d\n",
262                      (int)GetLastError () );
263             xfree (arg_string);
264             return -1;
265         }
266         /* Make sure that the process has a connected stdin */
267         if ( !duped_stdin ) {
268             si.hStdInput = hnul;
269             DEBUG_SELECT ((stderr,"** using %d for stdin\n", (int)hnul ));
270         }
271         /* We normally don't want all the normal output */
272         if ( !duped_stderr ) {
273             if (!debug_me) {
274                 si.hStdError = hnul;
275                 DEBUG_SELECT ((stderr,"** using %d for stderr\n", (int)hnul ));
276             }
277         }
278     }
279
280     DEBUG_SELECT ((stderr,"** CreateProcess ...\n"));
281     DEBUG_SELECT ((stderr,"** args=`%s'\n", arg_string));
282     cr_flags |= CREATE_SUSPENDED; 
283     if ( !CreateProcessA (GPG_PATH,
284                           arg_string,
285                           &sec_attr,     /* process security attributes */
286                           &sec_attr,     /* thread security attributes */
287                           TRUE,          /* inherit handles */
288                           cr_flags,      /* creation flags */
289                           envblock,      /* environment */
290                           NULL,          /* use current drive/directory */
291                           &si,           /* startup information */
292                           &pi            /* returns process information */
293         ) ) {
294         fprintf (stderr, "** CreateProcess failed: ec=%d\n",
295                  (int) GetLastError ());
296         xfree (arg_string);
297         return -1;
298     }
299
300     /* close the /dev/nul handle if used */
301     if (hnul != INVALID_HANDLE_VALUE ) {
302         if ( !CloseHandle ( hnul ) )
303             fprintf (stderr, "** CloseHandle(hnul) failed: ec=%d\n", 
304                      (int)GetLastError());
305     }
306
307     /* Close the other ends of the pipes */
308     for (i=0; fd_parent_list[i].fd != -1; i++ ) {
309         DEBUG_SELECT ((stderr,"** Closing fd %d\n", fd_parent_list[i].fd ));
310         if ( !CloseHandle ( fd_to_handle (fd_parent_list[i].fd) ) )
311             fprintf (stderr, "** CloseHandle failed: ec=%d\n",                 
312                      (int)GetLastError());
313     }
314
315     DEBUG_SELECT ((stderr,"** CreateProcess ready\n"
316                    "**   hProcess=%p  hThread=%p\n"
317                    "**   dwProcessID=%d dwThreadId=%d\n",
318                    pi.hProcess, pi.hThread, 
319                    (int) pi.dwProcessId, (int) pi.dwThreadId));
320
321     if ( ResumeThread ( pi.hThread ) < 0 ) {
322         fprintf (stderr, "** ResumeThread failed: ec=%d\n",
323                  (int)GetLastError ());
324     }
325
326     if ( !CloseHandle (pi.hThread) ) { 
327         fprintf (stderr, "** CloseHandle of thread failed: ec=%d\n",
328                  (int)GetLastError ());
329     }
330
331     return handle_to_pid (pi.hProcess);
332 }
333
334
335
336
337 int
338 _gpgme_io_waitpid ( int pid, int hang, int *r_status, int *r_signal )
339 {
340     HANDLE proc = fd_to_handle (pid);
341     int code, exc, ret = 0;
342
343     *r_status = 0;
344     *r_signal = 0;
345     code = WaitForSingleObject ( proc, hang? INFINITE : 0 );
346     switch (code) {
347       case WAIT_FAILED:
348         fprintf (stderr, "** WFSO pid=%d failed: %d\n",
349                  (int)pid, (int)GetLastError () );
350         break;
351
352       case WAIT_OBJECT_0:
353         if (!GetExitCodeProcess (proc, &exc)) {
354             fprintf (stderr, "** GECP pid=%d failed: ec=%d\n",
355                      (int)pid, (int)GetLastError () );
356             *r_status = 4; 
357         }
358         else {
359             DEBUG_SELECT ((stderr,"** GECP pid=%d exit code=%d\n",
360                            (int)pid,  exc));
361             *r_status = exc;
362         }
363         ret = 1;
364         break;
365
366       case WAIT_TIMEOUT:
367         DEBUG_SELECT ((stderr,"** WFSO pid=%d timed out\n", (int)pid));
368         break;
369
370       default:
371         fprintf (stderr, "** WFSO pid=%d returned %d\n", (int)pid, code );
372         break;
373     }
374     return ret;
375 }
376
377
378 /*
379  * Select on the list of fds.
380  * Returns: -1 = error
381  *           0 = timeout or nothing to select
382  *          >0 = number of signaled fds
383  */
384 int
385 _gpgme_io_select ( struct io_select_fd_s *fds, size_t nfds )
386 {
387 #if 0 /* We can't use WFMO becaus a pipe handle is not a suitable object */
388     HANDLE waitbuf[MAXIMUM_WAIT_OBJECTS];
389     int code, nwait;
390     int i, any, any_write;
391     int count;
392
393  restart:
394     DEBUG_SELECT ((stderr, "gpgme:select on [ "));
395     any = any_write = 0;
396     nwait = 0;
397     for ( i=0; i < nfds; i++ ) {
398         if ( fds[i].fd == -1 ) 
399             continue;
400         if ( fds[i].for_read || fds[i].for_write ) {
401             if ( nwait >= DIM (waitbuf) ) {
402                 DEBUG_SELECT ((stderr,stderr, "oops ]\n" ));
403                 fprintf (stderr, "** Too many objects for WFMO!\n" );
404                 return -1;
405             }
406             else {
407                 if ( fds[i].for_read ) 
408                     waitbuf[nwait++] = fd_to_handle (fds[i].fd);
409                 DEBUG_SELECT ((stderr, "%c%d ",
410                                fds[i].for_read? 'r':'w',fds[i].fd ));
411                 any = 1;
412             }
413         }
414         fds[i].signaled = 0;
415     }
416     DEBUG_SELECT ((stderr, "]\n" ));
417     if (!any) 
418         return 0;
419
420     count = 0;
421     for ( i=0; i < nfds; i++ ) {
422         if ( fds[i].fd == -1 ) 
423             continue;
424         if ( fds[i].for_write ) {
425             fds[i].signaled = 1;
426             any_write =1;
427             count++;
428         }
429     }
430     code = WaitForMultipleObjects ( nwait, waitbuf, 0, any_write? 0:1000);
431     if (code == WAIT_FAILED ) {
432         int le = (int)GetLastError ();
433         if ( le == ERROR_INVALID_HANDLE  || le == ERROR_INVALID_EVENT_COUNT ) {
434             any = 0;
435             for ( i=0; i < nfds; i++ ) {
436                 if ( fds[i].fd == -1 ) 
437                     continue;
438                 if ( fds[i].for_read /*|| fds[i].for_write*/ ) {
439                     int navail;
440                     if (PeekNamedPipe (fd_to_handle (fds[i].fd), 
441                                        NULL, 0, NULL,
442                                        &navail, NULL) && navail ) {
443                         fds[i].signaled = 1;
444                         any = 1;
445                         count++;
446                     }
447                 }
448             }
449             if (any)
450                 return count;
451             /* find that handle and remove it from the list*/
452             for (i=0; i < nwait; i++ ) {
453                 code = WaitForSingleObject ( waitbuf[i], NULL );
454                 if (!code) {
455                     int k, j = handle_to_fd (waitbuf[i]);
456
457                     fprintf (stderr, "** handle meanwhile signaled %d\n", j);
458                     for (k=0 ; k < nfds; k++ ) {
459                         if ( fds[k].fd == j ) {
460                             fds[k].signaled = 1;
461                             count++;
462                             return count; 
463                         }
464                     }
465                     fprintf (stderr, "** oops, or not???\n");
466                 }
467                 if ( GetLastError () == ERROR_INVALID_HANDLE) {
468                     int k, j = handle_to_fd (waitbuf[i]);
469                     
470                     fprintf (stderr, "** WFMO invalid handle %d removed\n", j);
471                     for (k=0 ; k < nfds; i++ ) {
472                         if ( fds[k].fd == j ) {
473                             fds[k].for_read = fds[k].for_write = 0;
474                             goto restart;
475                         }
476                     }
477                     fprintf (stderr, "** oops, or not???\n");
478                 }
479             }
480         }
481
482         fprintf (stderr, "** WFMO failed: %d\n", le );
483         count = -1;
484     }
485     else if ( code == WAIT_TIMEOUT ) {
486         fprintf (stderr, "** WFMO timed out\n" );
487     }  
488     else if ( code >= WAIT_OBJECT_0 && code < WAIT_OBJECT_0 + nwait ) {
489         /* This WFMO is a really silly function:  It does return either
490          * the index of the signaled object or if 2 objects have been
491          * signalled at the same time, the index of the object with the
492          * lowest object is returned - so and how do we find out
493          * how many objects have been signaled???.
494          * The only solution I can imagine is to test each object starting
495          * with the returned index individually - how dull.
496          */
497         any = 0;
498         for (i=code - WAIT_OBJECT_0; i < nwait; i++ ) {
499             if (WaitForSingleObject ( waitbuf[i], NULL ) == WAIT_OBJECT_0) {
500                 fds[i].signaled = 1;
501                 any = 1;
502                 count++;
503             }
504         }
505         if (!any) {
506             fprintf (stderr,
507                      "** Oops: No signaled objects found after WFMO\n");
508             count = -1;
509         }
510     }
511     else {
512         fprintf (stderr, "** WFMO returned %d\n", code );
513         count = -1;
514     }
515
516     return count;
517 #else  /* This is the code we use */
518     int i, any, count;
519     int once_more = 0;
520
521     DEBUG_SELECT ((stderr, "gpgme:fakedselect on [ "));
522     any = 0;
523     for ( i=0; i < nfds; i++ ) {
524         if ( fds[i].fd == -1 ) 
525             continue;
526         if ( fds[i].for_read || fds[i].for_write ) {
527             DEBUG_SELECT ((stderr, "%c%d ",
528                            fds[i].for_read? 'r':'w',fds[i].fd ));
529             any = 1;
530         }
531         fds[i].signaled = 0;
532     }
533     DEBUG_SELECT ((stderr, "]\n" ));
534     if (!any) 
535         return 0;
536
537  restart:
538     count = 0;
539     /* no way to see whether a handle is ready fro writing, signal all */
540     for ( i=0; i < nfds; i++ ) {
541         if ( fds[i].fd == -1 ) 
542             continue;
543         if ( fds[i].for_write ) {
544             fds[i].signaled = 1;
545             count++;
546         }
547     }
548
549     /* now peek on all read handles */
550     for ( i=0; i < nfds; i++ ) {
551         if ( fds[i].fd == -1 ) 
552             continue;
553         if ( fds[i].for_read ) {
554             int navail;
555
556             if ( !PeekNamedPipe (fd_to_handle (fds[i].fd),
557                                  NULL, 0, NULL, &navail, NULL) ) {
558                 fprintf (stderr, "** select: PeekFile failed: ec=%d\n",
559                          (int)GetLastError ());
560             }
561             else if ( navail ) {
562                 /*fprintf (stderr, "** fd %d has %d bytes to read\n",
563                   fds[i].fd, navail );*/
564                 fds[i].signaled = 1;
565                 count++;
566             }
567         }
568     }
569     if ( !once_more && !count ) {
570         /* once more but after relinquishing our timeslot */
571         once_more = 1;
572         Sleep (0);
573         goto restart;
574     }
575
576     if ( count ) {
577         DEBUG_SELECT ((stderr, "gpgme:      signaled [ "));
578         for ( i=0; i < nfds; i++ ) {
579             if ( fds[i].fd == -1 ) 
580                 continue;
581             if ( (fds[i].for_read || fds[i].for_write) && fds[i].signaled ) {
582                 DEBUG_SELECT ((stderr, "%c%d ",
583                                fds[i].for_read? 'r':'w',fds[i].fd ));
584             }
585         }
586         DEBUG_SELECT ((stderr, "]\n" ));
587     }
588     
589     return count;
590 #endif
591 }
592
593 #endif /*HAVE_DOSISH_SYSTEM*/
594
595
596
597
598
599
600
601
602