gpgme/w32-io.c

   1 /* w32-io.c - W32 API I/O functions.
   2    Copyright (C) 2000 Werner Koch (dd9jn)
   3    Copyright (C) 2001, 2002, 2003 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 General Public License as published by
   9    the Free Software Foundation; either version 2 of the License, or
  10    (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    General Public License for more details.
  16
  17    You should have received a copy of the GNU General Public License
  18    along with GPGME; if not, write to the Free Software Foundation,
  19    Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.  */
  20
  21 #ifdef HAVE_CONFIG_H
  22 #include <config.h>
  23 #endif
  24 #include <stdio.h>
  25 #include <stdlib.h>
  26 #include <string.h>
  27 #include <assert.h>
  28 #include <errno.h>
  29 #include <signal.h>
  30 #include <fcntl.h>
  31 #include <sys/time.h>
  32 #include <sys/types.h>
  33 #include <windows.h>
  34 #include <io.h>
  35
  36 #include "util.h"
  37 #include "sema.h"
  38 #include "io.h"
  39
  40
  41 /* We assume that a HANDLE can be represented by an int which should
  42    be true for all i386 systems (HANDLE is defined as void *) and
  43    these are the only systems for which Windows is available.  Further
  44    we assume that -1 denotes an invalid handle.  */
  45
  46 #define fd_to_handle(a)  ((HANDLE)(a))
  47 #define handle_to_fd(a)  ((int)(a))
  48 #define pid_to_handle(a) ((HANDLE)(a))
  49 #define handle_to_pid(a) ((int)(a))
  50
  51 #define READBUF_SIZE 4096
  52 #define WRITEBUF_SIZE 4096
  53 #define MAX_READERS 20
  54 #define MAX_WRITERS 20
  55
  56 static struct {
  57     int inuse;
  58     int fd;
  59     void (*handler)(int,void*);
  60     void *value;
  61 } notify_table[256];
  62 DEFINE_STATIC_LOCK (notify_table_lock);
  63
  64
  65 struct reader_context_s {
  66     HANDLE file_hd;
  67     HANDLE thread_hd;
  68     DECLARE_LOCK (mutex);
  69
  70     int stop_me;
  71     int eof;
  72     int eof_shortcut;
  73     int error;
  74     int error_code;
  75
  76     HANDLE have_data_ev;  /* manually reset */
  77     HANDLE have_space_ev; /* auto reset */
  78     HANDLE stopped;
  79     size_t readpos, writepos;
  80     char buffer[READBUF_SIZE];
  81 };
  82
  83
  84 static struct {
  85     volatile int used;
  86     int fd;
  87     struct reader_context_s *context;
  88 } reader_table[MAX_READERS];
  89 static int reader_table_size= MAX_READERS;
  90 DEFINE_STATIC_LOCK (reader_table_lock);
  91
  92
  93 struct writer_context_s {
  94     HANDLE file_hd;
  95     HANDLE thread_hd;
  96     DECLARE_LOCK (mutex);
  97
  98     int stop_me;
  99     int error;
 100     int error_code;
 101
 102     HANDLE have_data;  /* manually reset */
 103     HANDLE is_empty;
 104     HANDLE stopped;
 105     size_t nbytes;
 106     char buffer[WRITEBUF_SIZE];
 107 };
 108
 109
 110 static struct {
 111     volatile int used;
 112     int fd;
 113     struct writer_context_s *context;
 114 } writer_table[MAX_WRITERS];
 115 static int writer_table_size= MAX_WRITERS;
 116 DEFINE_STATIC_LOCK (writer_table_lock);
 117
 118
 119
 120 static HANDLE
 121 set_synchronize (HANDLE h)
 122 {
 123     HANDLE tmp;
 124
 125     /* For NT we have to set the sync flag.  It seems that the only
 126      * way to do it is by duplicating the handle.  Tsss.. */
 127     if (!DuplicateHandle( GetCurrentProcess(), h,
 128                           GetCurrentProcess(), &tmp,
 129                           EVENT_MODIFY_STATE|SYNCHRONIZE, FALSE, 0 ) ) {
 130         DEBUG1 ("** Set SYNCRONIZE failed: ec=%d\n", (int)GetLastError());
 131     }
 132     else {
 133         CloseHandle (h);
 134         h = tmp;
 135     }
 136     return h;
 137 }
 138
 139
 140
 141 static DWORD CALLBACK
 142 reader (void *arg)
 143 {
 144     struct reader_context_s *c = arg;
 145     int nbytes;
 146     DWORD nread;
 147
 148     DEBUG2 ("reader thread %p for file %p started", c->thread_hd, c->file_hd );
 149     for (;;) {
 150         LOCK (c->mutex);
 151         /* leave a 1 byte gap so that we can see whether it is empty or full*/
 152         if ((c->writepos + 1) % READBUF_SIZE == c->readpos) {
 153             /* wait for space */
 154             if (!ResetEvent (c->have_space_ev) )
 155                 DEBUG1 ("ResetEvent failed: ec=%d", (int)GetLastError ());
 156             UNLOCK (c->mutex);
 157             DEBUG1 ("reader thread %p: waiting for space ...", c->thread_hd );
 158             WaitForSingleObject (c->have_space_ev, INFINITE);
 159             DEBUG1 ("reader thread %p: got space", c->thread_hd );
 160             LOCK (c->mutex);
 161         }
 162         if ( c->stop_me ) {
 163             UNLOCK (c->mutex);
 164             break;
 165         }
 166         nbytes = (c->readpos + READBUF_SIZE - c->writepos-1) % READBUF_SIZE;
 167         if ( nbytes > READBUF_SIZE - c->writepos )
 168             nbytes = READBUF_SIZE - c->writepos;
 169         UNLOCK (c->mutex);
 170
 171         DEBUG2 ("reader thread %p: reading %d bytes", c->thread_hd, nbytes );
 172         if ( !ReadFile ( c->file_hd,
 173                          c->buffer+c->writepos, nbytes, &nread, NULL) ) {
 174             c->error_code = (int)GetLastError ();
 175             if (c->error_code == ERROR_BROKEN_PIPE ) {
 176                 c->eof=1;
 177                 DEBUG1 ("reader thread %p: got eof (broken pipe)",
 178                         c->thread_hd );
 179             }
 180             else {
 181                 c->error = 1;
 182                 DEBUG2 ("reader thread %p: read error: ec=%d",
 183                         c->thread_hd, c->error_code );
 184             }
 185             break;
 186         }
 187         if ( !nread ) {
 188             c->eof = 1;
 189             DEBUG1 ("reader thread %p: got eof", c->thread_hd );
 190             break;
 191         }
 192         DEBUG2 ("reader thread %p: got %d bytes", c->thread_hd, (int)nread );
 193
 194         LOCK (c->mutex);
 195         if (c->stop_me) {
 196             UNLOCK (c->mutex);
 197             break;
 198         }
 199         c->writepos = (c->writepos + nread) % READBUF_SIZE;
 200         if ( !SetEvent (c->have_data_ev) )
 201             DEBUG1 ("SetEvent failed: ec=%d", (int)GetLastError ());
 202         UNLOCK (c->mutex);
 203     }
 204     /* indicate that we have an error or eof */
 205     if ( !SetEvent (c->have_data_ev) )
 206         DEBUG1 ("SetEvent failed: ec=%d", (int)GetLastError ());
 207     DEBUG1 ("reader thread %p ended", c->thread_hd );
 208     SetEvent (c->stopped);
 209
 210     return 0;
 211 }
 212
 213
 214 static struct reader_context_s *
 215 create_reader (HANDLE fd)
 216 {
 217     struct reader_context_s *c;
 218     SECURITY_ATTRIBUTES sec_attr;
 219     DWORD tid;
 220
 221     DEBUG1 ("creating new read thread for file handle %p", fd );
 222     memset (&sec_attr, 0, sizeof sec_attr );
 223     sec_attr.nLength = sizeof sec_attr;
 224     sec_attr.bInheritHandle = FALSE;
 225
 226     c = calloc (1, sizeof *c );
 227     if (!c)
 228         return NULL;
 229
 230     c->file_hd = fd;
 231     c->have_data_ev = CreateEvent (&sec_attr, TRUE, FALSE, NULL);
 232     c->have_space_ev = CreateEvent (&sec_attr, FALSE, TRUE, NULL);
 233     c->stopped = CreateEvent (&sec_attr, TRUE, FALSE, NULL);
 234     if (!c->have_data_ev || !c->have_space_ev || !c->stopped ) {
 235         DEBUG1 ("** CreateEvent failed: ec=%d\n", (int)GetLastError ());
 236         if (c->have_data_ev)
 237             CloseHandle (c->have_data_ev);
 238         if (c->have_space_ev)
 239             CloseHandle (c->have_space_ev);
 240         if (c->stopped)
 241             CloseHandle (c->stopped);
 242         free (c);
 243         return NULL;
 244     }
 245
 246     c->have_data_ev = set_synchronize (c->have_data_ev);
 247     INIT_LOCK (c->mutex);
 248
 249     c->thread_hd = CreateThread (&sec_attr, 0, reader, c, 0, &tid );
 250     if (!c->thread_hd) {
 251         DEBUG1 ("** failed to create reader thread: ec=%d\n",
 252                  (int)GetLastError ());
 253         DESTROY_LOCK (c->mutex);
 254         if (c->have_data_ev)
 255             CloseHandle (c->have_data_ev);
 256         if (c->have_space_ev)
 257             CloseHandle (c->have_space_ev);
 258         if (c->stopped)
 259             CloseHandle (c->stopped);
 260         free (c);
 261         return NULL;
 262     }
 263
 264     return c;
 265 }
 266
 267 static void
 268 destroy_reader (struct reader_context_s *c)
 269 {
 270     LOCK (c->mutex);
 271     c->stop_me = 1;
 272     if (c->have_space_ev)
 273         SetEvent (c->have_space_ev);
 274     UNLOCK (c->mutex);
 275
 276     DEBUG1 ("waiting for thread %p termination ...", c->thread_hd );
 277     WaitForSingleObject (c->stopped, INFINITE);
 278     DEBUG1 ("thread %p has terminated", c->thread_hd );
 279
 280     if (c->stopped)
 281         CloseHandle (c->stopped);
 282     if (c->have_data_ev)
 283         CloseHandle (c->have_data_ev);
 284     if (c->have_space_ev)
 285         CloseHandle (c->have_space_ev);
 286     CloseHandle (c->thread_hd);
 287     DESTROY_LOCK (c->mutex);
 288     free (c);
 289 }
 290
 291
 292 /*
 293  * Find a reader context or create a new one
 294  * Note that the reader context will last until a io_close.
 295  */
 296 static struct reader_context_s *
 297 find_reader (int fd, int start_it)
 298 {
 299     int i;
 300
 301     for (i=0; i < reader_table_size ; i++ ) {
 302         if ( reader_table[i].used && reader_table[i].fd == fd )
 303             return reader_table[i].context;
 304     }
 305     if (!start_it)
 306         return NULL;
 307
 308     LOCK (reader_table_lock);
 309     for (i=0; i < reader_table_size; i++ ) {
 310         if (!reader_table[i].used) {
 311             reader_table[i].fd = fd;
 312             reader_table[i].context = create_reader (fd_to_handle (fd));
 313             reader_table[i].used = 1;
 314             UNLOCK (reader_table_lock);
 315             return reader_table[i].context;
 316         }
 317     }
 318     UNLOCK (reader_table_lock);
 319     return NULL;
 320 }
 321
 322
 323 static void
 324 kill_reader (int fd)
 325 {
 326     int i;
 327
 328     LOCK (reader_table_lock);
 329     for (i=0; i < reader_table_size; i++ ) {
 330         if (reader_table[i].used && reader_table[i].fd == fd ) {
 331             destroy_reader (reader_table[i].context);
 332             reader_table[i].context = NULL;
 333             reader_table[i].used = 0;
 334             break;
 335         }
 336     }
 337     UNLOCK (reader_table_lock);
 338 }
 339
 340
 341
 342 int
 343 _gpgme_io_read ( int fd, void *buffer, size_t count )
 344 {
 345     int nread;
 346     struct reader_context_s *c = find_reader (fd,1);
 347
 348     DEBUG2 ("fd %d: about to read %d bytes\n", fd, (int)count );
 349     if ( !c ) {
 350         DEBUG0 ( "no reader thread\n");
 351         return -1;
 352     }
 353     if (c->eof_shortcut) {
 354         DEBUG1 ("fd %d: EOF (again)", fd );
 355         return 0;
 356     }
 357
 358     LOCK (c->mutex);
 359     if (c->readpos == c->writepos && !c->error) { /*no data avail*/
 360         UNLOCK (c->mutex);
 361         DEBUG2 ("fd %d: waiting for data from thread %p", fd, c->thread_hd);
 362         WaitForSingleObject (c->have_data_ev, INFINITE);
 363         DEBUG2 ("fd %d: data from thread %p available", fd, c->thread_hd);
 364         LOCK (c->mutex);
 365     }
 366
 367     if (c->readpos == c->writepos || c->error) {
 368         UNLOCK (c->mutex);
 369         c->eof_shortcut = 1;
 370         if (c->eof) {
 371             DEBUG1 ("fd %d: EOF", fd );
 372             return 0;
 373         }
 374         if (!c->error) {
 375             DEBUG1 ("fd %d: EOF but eof flag not set", fd );
 376             return 0;
 377         }
 378         DEBUG1 ("fd %d: read error", fd );
 379         return -1;
 380     }
 381
 382     nread = c->readpos < c->writepos? c->writepos - c->readpos
 383                                     : READBUF_SIZE - c->readpos;
 384     if (nread > count)
 385         nread = count;
 386     memcpy (buffer, c->buffer+c->readpos, nread);
 387     c->readpos = (c->readpos + nread) % READBUF_SIZE;
 388     if (c->readpos == c->writepos && !c->eof) {
 389         if ( !ResetEvent (c->have_data_ev) )
 390             DEBUG1 ("ResetEvent failed: ec=%d", (int)GetLastError ());
 391     }
 392     if (!SetEvent (c->have_space_ev))
 393         DEBUG1 ("SetEvent failed: ec=%d", (int)GetLastError ());
 394     UNLOCK (c->mutex);
 395
 396     DEBUG2 ("fd %d: got %d bytes\n", fd, nread );
 397
 398     return nread;
 399 }
 400
 401
 402
 403 /*
 404  * The writer does use a simple buffering strategy so that we are
 405  * informed about write errors as soon as possible (i.e. with the the
 406  * next call to the write function
 407  */
 408 static DWORD CALLBACK
 409 writer (void *arg)
 410 {
 411     struct writer_context_s *c = arg;
 412     DWORD nwritten;
 413
 414     DEBUG2 ("writer thread %p for file %p started", c->thread_hd, c->file_hd );
 415     for (;;) {
 416         LOCK (c->mutex);
 417         if ( !c->nbytes ) {
 418             if (!ResetEvent (c->have_data) )
 419                 DEBUG1 ("ResetEvent failed: ec=%d", (int)GetLastError ());
 420             UNLOCK (c->mutex);
 421             DEBUG1 ("writer thread %p: idle ...", c->thread_hd );
 422             WaitForSingleObject (c->have_data, INFINITE);
 423             DEBUG1 ("writer thread %p: got data to send", c->thread_hd );
 424             LOCK (c->mutex);
 425         }
 426         if ( c->stop_me ) {
 427             UNLOCK (c->mutex);
 428             break;
 429         }
 430         UNLOCK (c->mutex);
 431
 432         DEBUG2 ("writer thread %p: writing %d bytes",
 433                 c->thread_hd, c->nbytes );
 434         if ( c->nbytes && !WriteFile ( c->file_hd,  c->buffer, c->nbytes,
 435                                        &nwritten, NULL)) {
 436             c->error_code = (int)GetLastError ();
 437             c->error = 1;
 438             DEBUG2 ("writer thread %p: write error: ec=%d",
 439                     c->thread_hd, c->error_code );
 440             break;
 441         }
 442         DEBUG2 ("writer thread %p: wrote %d bytes",
 443                 c->thread_hd, (int)nwritten );
 444
 445         LOCK (c->mutex);
 446         c->nbytes -= nwritten;
 447         if (c->stop_me) {
 448             UNLOCK (c->mutex);
 449             break;
 450         }
 451         if ( !c->nbytes ) {
 452             if ( !SetEvent (c->is_empty) )
 453                 DEBUG1 ("SetEvent failed: ec=%d", (int)GetLastError ());
 454         }
 455         UNLOCK (c->mutex);
 456     }
 457     /* indicate that we have an error  */
 458     if ( !SetEvent (c->is_empty) )
 459         DEBUG1 ("SetEvent failed: ec=%d", (int)GetLastError ());
 460     DEBUG1 ("writer thread %p ended", c->thread_hd );
 461     SetEvent (c->stopped);
 462
 463     return 0;
 464 }
 465
 466
 467 static struct writer_context_s *
 468 create_writer (HANDLE fd)
 469 {
 470     struct writer_context_s *c;
 471     SECURITY_ATTRIBUTES sec_attr;
 472     DWORD tid;
 473
 474     DEBUG1 ("creating new write thread for file handle %p", fd );
 475     memset (&sec_attr, 0, sizeof sec_attr );
 476     sec_attr.nLength = sizeof sec_attr;
 477     sec_attr.bInheritHandle = FALSE;
 478
 479     c = calloc (1, sizeof *c );
 480     if (!c)
 481         return NULL;
 482
 483     c->file_hd = fd;
 484     c->have_data = CreateEvent (&sec_attr, FALSE, FALSE, NULL);
 485     c->is_empty  = CreateEvent (&sec_attr, TRUE, TRUE, NULL);
 486     c->stopped = CreateEvent (&sec_attr, TRUE, FALSE, NULL);
 487     if (!c->have_data || !c->is_empty || !c->stopped ) {
 488         DEBUG1 ("** CreateEvent failed: ec=%d\n", (int)GetLastError ());
 489         if (c->have_data)
 490             CloseHandle (c->have_data);
 491         if (c->is_empty)
 492             CloseHandle (c->is_empty);
 493         if (c->stopped)
 494             CloseHandle (c->stopped);
 495         free (c);
 496         return NULL;
 497     }
 498
 499     c->is_empty = set_synchronize (c->is_empty);
 500     INIT_LOCK (c->mutex);
 501
 502     c->thread_hd = CreateThread (&sec_attr, 0, writer, c, 0, &tid );
 503     if (!c->thread_hd) {
 504         DEBUG1 ("** failed to create writer thread: ec=%d\n",
 505                  (int)GetLastError ());
 506         DESTROY_LOCK (c->mutex);
 507         if (c->have_data)
 508             CloseHandle (c->have_data);
 509         if (c->is_empty)
 510             CloseHandle (c->is_empty);
 511         if (c->stopped)
 512             CloseHandle (c->stopped);
 513         free (c);
 514         return NULL;
 515     }
 516
 517     return c;
 518 }
 519
 520 static void
 521 destroy_writer (struct writer_context_s *c)
 522 {
 523     LOCK (c->mutex);
 524     c->stop_me = 1;
 525     if (c->have_data)
 526         SetEvent (c->have_data);
 527     UNLOCK (c->mutex);
 528
 529     DEBUG1 ("waiting for thread %p termination ...", c->thread_hd );
 530     WaitForSingleObject (c->stopped, INFINITE);
 531     DEBUG1 ("thread %p has terminated", c->thread_hd );
 532
 533     if (c->stopped)
 534         CloseHandle (c->stopped);
 535     if (c->have_data)
 536         CloseHandle (c->have_data);
 537     if (c->is_empty)
 538         CloseHandle (c->is_empty);
 539     CloseHandle (c->thread_hd);
 540     DESTROY_LOCK (c->mutex);
 541     free (c);
 542 }
 543
 544
 545 /*
 546  * Find a writer context or create a new one
 547  * Note that the writer context will last until a io_close.
 548  */
 549 static struct writer_context_s *
 550 find_writer (int fd, int start_it)
 551 {
 552     int i;
 553
 554     for (i=0; i < writer_table_size ; i++ ) {
 555         if ( writer_table[i].used && writer_table[i].fd == fd )
 556             return writer_table[i].context;
 557     }
 558     if (!start_it)
 559         return NULL;
 560
 561     LOCK (writer_table_lock);
 562     for (i=0; i < writer_table_size; i++ ) {
 563         if (!writer_table[i].used) {
 564             writer_table[i].fd = fd;
 565             writer_table[i].context = create_writer (fd_to_handle (fd));
 566             writer_table[i].used = 1;
 567             UNLOCK (writer_table_lock);
 568             return writer_table[i].context;
 569         }
 570     }
 571     UNLOCK (writer_table_lock);
 572     return NULL;
 573 }
 574
 575
 576 static void
 577 kill_writer (int fd)
 578 {
 579     int i;
 580
 581     LOCK (writer_table_lock);
 582     for (i=0; i < writer_table_size; i++ ) {
 583         if (writer_table[i].used && writer_table[i].fd == fd ) {
 584             destroy_writer (writer_table[i].context);
 585             writer_table[i].context = NULL;
 586             writer_table[i].used = 0;
 587             break;
 588         }
 589     }
 590     UNLOCK (writer_table_lock);
 591 }
 592
 593
 594
 595
 596 int
 597 _gpgme_io_write ( int fd, const void *buffer, size_t count )
 598 {
 599     struct writer_context_s *c = find_writer (fd,1);
 600
 601     DEBUG2 ("fd %d: about to write %d bytes\n", fd, (int)count );
 602     if ( !c ) {
 603         DEBUG0 ( "no writer thread\n");
 604         return -1;
 605     }
 606
 607     LOCK (c->mutex);
 608     if ( c->nbytes ) { /* bytes are pending for send */
 609         UNLOCK (c->mutex);
 610         DEBUG2 ("fd %d: waiting for empty buffer in thread %p",
 611                 fd, c->thread_hd);
 612         WaitForSingleObject (c->is_empty, INFINITE);
 613         DEBUG2 ("fd %d: thread %p buffer is empty", fd, c->thread_hd);
 614         assert (!c->nbytes);
 615         LOCK (c->mutex);
 616     }
 617
 618     if ( c->error) {
 619         UNLOCK (c->mutex);
 620         DEBUG1 ("fd %d: write error", fd );
 621         return -1;
 622     }
 623
 624     if (count > WRITEBUF_SIZE)
 625         count = WRITEBUF_SIZE;
 626     memcpy (c->buffer, buffer, count);
 627     c->nbytes = count;
 628     if (!SetEvent (c->have_data))
 629         DEBUG1 ("SetEvent failed: ec=%d", (int)GetLastError ());
 630     UNLOCK (c->mutex);
 631
 632     DEBUG2 ("fd %d:         copied %d bytes\n",
 633                    fd, (int)count );
 634     return (int)count;
 635 }
 636
 637
 638 int
 639 _gpgme_io_pipe ( int filedes[2], int inherit_idx )
 640 {
 641     HANDLE r, w;
 642     SECURITY_ATTRIBUTES sec_attr;
 643
 644     memset (&sec_attr, 0, sizeof sec_attr );
 645     sec_attr.nLength = sizeof sec_attr;
 646     sec_attr.bInheritHandle = FALSE;
 647
 648     if (!CreatePipe ( &r, &w, &sec_attr, 0))
 649         return -1;
 650     /* make one end inheritable */
 651     if ( inherit_idx == 0 ) {
 652         HANDLE h;
 653         if (!DuplicateHandle( GetCurrentProcess(), r,
 654                               GetCurrentProcess(), &h, 0,
 655                               TRUE, DUPLICATE_SAME_ACCESS ) ) {
 656             DEBUG1 ("DuplicateHandle failed: ec=%d\n", (int)GetLastError());
 657             CloseHandle (r);
 658             CloseHandle (w);
 659             return -1;
 660         }
 661         CloseHandle (r);
 662         r = h;
 663     }
 664     else if ( inherit_idx == 1 ) {
 665         HANDLE h;
 666         if (!DuplicateHandle( GetCurrentProcess(), w,
 667                               GetCurrentProcess(), &h, 0,
 668                               TRUE, DUPLICATE_SAME_ACCESS ) ) {
 669             DEBUG1 ("DuplicateHandle failed: ec=%d\n", (int)GetLastError());
 670             CloseHandle (r);
 671             CloseHandle (w);
 672             return -1;
 673         }
 674         CloseHandle (w);
 675         w = h;
 676     }
 677
 678     filedes[0] = handle_to_fd (r);
 679     filedes[1] = handle_to_fd (w);
 680     DEBUG5 ("CreatePipe %p %p %d %d inherit=%d\n", r, w,
 681                    filedes[0], filedes[1], inherit_idx );
 682     return 0;
 683 }
 684
 685 int
 686 _gpgme_io_close ( int fd )
 687 {
 688     int i;
 689     void (*handler)(int, void*) = NULL;
 690     void *value = NULL;
 691
 692     if ( fd == -1 )
 693         return -1;
 694
 695     DEBUG1 ("** closing handle for fd %d\n", fd);
 696     kill_reader (fd);
 697     kill_writer (fd);
 698     LOCK (notify_table_lock);
 699     for ( i=0; i < DIM (notify_table); i++ ) {
 700         if (notify_table[i].inuse && notify_table[i].fd == fd) {
 701             handler = notify_table[i].handler;
 702             value   = notify_table[i].value;
 703             notify_table[i].handler = NULL;
 704             notify_table[i].value = NULL;
 705             notify_table[i].inuse = 0;
 706             break;
 707         }
 708     }
 709     UNLOCK (notify_table_lock);
 710     if (handler)
 711         handler (fd, value);
 712
 713     if ( !CloseHandle (fd_to_handle (fd)) ) {
 714         DEBUG2 ("CloseHandle for fd %d failed: ec=%d\n",
 715                  fd, (int)GetLastError ());
 716         return -1;
 717     }
 718
 719     return 0;
 720 }
 721
 722 int
 723 _gpgme_io_set_close_notify (int fd, void (*handler)(int, void*), void *value)
 724 {
 725     int i;
 726
 727     assert (fd != -1);
 728
 729     LOCK (notify_table_lock);
 730     for (i=0; i < DIM (notify_table); i++ ) {
 731         if ( notify_table[i].inuse && notify_table[i].fd == fd )
 732             break;
 733     }
 734     if ( i == DIM (notify_table) ) {
 735         for (i=0; i < DIM (notify_table); i++ ) {
 736             if ( !notify_table[i].inuse )
 737                 break;
 738         }
 739     }
 740     if ( i == DIM (notify_table) ) {
 741         UNLOCK (notify_table_lock);
 742         return -1;
 743     }
 744     notify_table[i].fd = fd;
 745     notify_table[i].handler = handler;
 746     notify_table[i].value = value;
 747     notify_table[i].inuse = 1;
 748     UNLOCK (notify_table_lock);
 749     DEBUG2 ("set notification for fd %d (idx=%d)", fd, i );
 750     return 0;
 751 }
 752
 753
 754 int
 755 _gpgme_io_set_nonblocking ( int fd )
 756 {
 757     return 0;
 758 }
 759
 760
 761 static char *
 762 build_commandline ( char **argv )
 763 {
 764     int i, n = 0;
 765     char *buf, *p;
 766
 767     /* FIXME: we have to quote some things because under Windows the
 768      * program parses the commandline and does some unquoting */
 769     for (i=0; argv[i]; i++)
 770         n += strlen (argv[i]) + 2 + 1; /* 2 extra bytes for possible quoting */
 771     buf = p = malloc (n);
 772     if ( !buf )
 773         return NULL;
 774     *buf = 0;
 775     if ( argv[0] )
 776         p = stpcpy (p, argv[0]);
 777     for (i = 1; argv[i]; i++) {
 778         if (!*argv[i])
 779             p = stpcpy (p, " \"\"");
 780         else
 781             p = stpcpy (stpcpy (p, " "), argv[i]);
 782     }
 783
 784     return buf;
 785 }
 786
 787
 788 int
 789 _gpgme_io_spawn ( const char *path, char **argv,
 790                   struct spawn_fd_item_s *fd_child_list,
 791                   struct spawn_fd_item_s *fd_parent_list )
 792 {
 793     SECURITY_ATTRIBUTES sec_attr;
 794     PROCESS_INFORMATION pi = {
 795         NULL,      /* returns process handle */
 796         0,         /* returns primary thread handle */
 797         0,         /* returns pid */
 798         0         /* returns tid */
 799     };
 800     STARTUPINFO si;
 801     char *envblock = NULL;
 802     int cr_flags = CREATE_DEFAULT_ERROR_MODE
 803                  | GetPriorityClass (GetCurrentProcess ());
 804     int i;
 805     char *arg_string;
 806     int duped_stdin = 0;
 807     int duped_stderr = 0;
 808     HANDLE hnul = INVALID_HANDLE_VALUE;
 809     /* FIXME.  */
 810     int debug_me = 0;
 811
 812     memset (&sec_attr, 0, sizeof sec_attr );
 813     sec_attr.nLength = sizeof sec_attr;
 814     sec_attr.bInheritHandle = FALSE;
 815
 816     arg_string = build_commandline ( argv );
 817     if (!arg_string )
 818         return -1;
 819
 820     memset (&si, 0, sizeof si);
 821     si.cb = sizeof (si);
 822     si.dwFlags = STARTF_USESTDHANDLES | STARTF_USESHOWWINDOW;
 823     si.wShowWindow = debug_me? SW_SHOW : SW_MINIMIZE;
 824     si.hStdInput = GetStdHandle (STD_INPUT_HANDLE);
 825     si.hStdOutput = GetStdHandle (STD_OUTPUT_HANDLE);
 826     si.hStdError = GetStdHandle (STD_ERROR_HANDLE);
 827
 828     for (i=0; fd_child_list[i].fd != -1; i++ ) {
 829         if (fd_child_list[i].dup_to == 0 ) {
 830             si.hStdInput = fd_to_handle (fd_child_list[i].fd);
 831             DEBUG1 ("using %d for stdin", fd_child_list[i].fd );
 832             duped_stdin=1;
 833         }
 834         else if (fd_child_list[i].dup_to == 1 ) {
 835             si.hStdOutput = fd_to_handle (fd_child_list[i].fd);
 836             DEBUG1 ("using %d for stdout", fd_child_list[i].fd );
 837         }
 838         else if (fd_child_list[i].dup_to == 2 ) {
 839             si.hStdError = fd_to_handle (fd_child_list[i].fd);
 840             DEBUG1 ("using %d for stderr", fd_child_list[i].fd );
 841             duped_stderr = 1;
 842         }
 843     }
 844
 845     if( !duped_stdin || !duped_stderr ) {
 846         SECURITY_ATTRIBUTES sa;
 847
 848         memset (&sa, 0, sizeof sa );
 849         sa.nLength = sizeof sa;
 850         sa.bInheritHandle = TRUE;
 851         hnul = CreateFile ( "nul",
 852                             GENERIC_READ|GENERIC_WRITE,
 853                             FILE_SHARE_READ|FILE_SHARE_WRITE,
 854                             &sa,
 855                             OPEN_EXISTING,
 856                             FILE_ATTRIBUTE_NORMAL,
 857                             NULL );
 858         if ( hnul == INVALID_HANDLE_VALUE ) {
 859             DEBUG1 ("can't open `nul': ec=%d\n", (int)GetLastError ());
 860             free (arg_string);
 861             return -1;
 862         }
 863         /* Make sure that the process has a connected stdin */
 864         if ( !duped_stdin ) {
 865             si.hStdInput = hnul;
 866             DEBUG1 ("using %d for dummy stdin", (int)hnul );
 867         }
 868         /* We normally don't want all the normal output */
 869         if ( !duped_stderr ) {
 870             si.hStdError = hnul;
 871             DEBUG1 ("using %d for dummy stderr", (int)hnul );
 872         }
 873     }
 874
 875     DEBUG2 ("CreateProcess, path=`%s' args=`%s'", path, arg_string);
 876     cr_flags |= CREATE_SUSPENDED;
 877     if ( !CreateProcessA (path,
 878                           arg_string,
 879                           &sec_attr,     /* process security attributes */
 880                           &sec_attr,     /* thread security attributes */
 881                           TRUE,          /* inherit handles */
 882                           cr_flags,      /* creation flags */
 883                           envblock,      /* environment */
 884                           NULL,          /* use current drive/directory */
 885                           &si,           /* startup information */
 886                           &pi            /* returns process information */
 887         ) ) {
 888         DEBUG1 ("CreateProcess failed: ec=%d\n", (int) GetLastError ());
 889         free (arg_string);
 890         return -1;
 891     }
 892
 893     /* close the /dev/nul handle if used */
 894     if (hnul != INVALID_HANDLE_VALUE ) {
 895         if ( !CloseHandle ( hnul ) )
 896             DEBUG1 ("CloseHandle(hnul) failed: ec=%d\n", (int)GetLastError());
 897     }
 898
 899     /* Close the other ends of the pipes */
 900     for (i = 0; fd_parent_list[i].fd != -1; i++)
 901       _gpgme_io_close (fd_parent_list[i].fd);
 902
 903     DEBUG4 ("CreateProcess ready\n"
 904             "-   hProcess=%p  hThread=%p\n"
 905             "-   dwProcessID=%d dwThreadId=%d\n",
 906             pi.hProcess, pi.hThread,
 907             (int) pi.dwProcessId, (int) pi.dwThreadId);
 908
 909     if ( ResumeThread ( pi.hThread ) < 0 ) {
 910         DEBUG1 ("ResumeThread failed: ec=%d\n", (int)GetLastError ());
 911     }
 912
 913     if ( !CloseHandle (pi.hThread) ) {
 914         DEBUG1 ("CloseHandle of thread failed: ec=%d\n",
 915                  (int)GetLastError ());
 916     }
 917
 918     return handle_to_pid (pi.hProcess);
 919 }
 920
 921
 922
 923
 924 int
 925 _gpgme_io_waitpid ( int pid, int hang, int *r_status, int *r_signal )
 926 {
 927     HANDLE proc = fd_to_handle (pid);
 928     int code, ret = 0;
 929     DWORD exc;
 930
 931     *r_status = 0;
 932     *r_signal = 0;
 933     code = WaitForSingleObject ( proc, hang? INFINITE : 0 );
 934     switch (code) {
 935       case WAIT_FAILED:
 936         DEBUG2 ("WFSO pid=%d failed: %d\n", (int)pid, (int)GetLastError () );
 937         break;
 938
 939       case WAIT_OBJECT_0:
 940         if (!GetExitCodeProcess (proc, &exc)) {
 941             DEBUG2 ("** GECP pid=%d failed: ec=%d\n",
 942                     (int)pid, (int)GetLastError () );
 943             *r_status = 4;
 944         }
 945         else {
 946             DEBUG2 ("GECP pid=%d exit code=%d\n", (int)pid,  exc);
 947             *r_status = exc;
 948         }
 949         ret = 1;
 950         break;
 951
 952       case WAIT_TIMEOUT:
 953         if (hang)
 954             DEBUG1 ("WFSO pid=%d timed out\n", (int)pid);
 955         break;
 956
 957       default:
 958         DEBUG2 ("WFSO pid=%d returned %d\n", (int)pid, code );
 959         break;
 960     }
 961     return ret;
 962 }
 963
 964 int
 965 _gpgme_io_kill ( int pid, int hard )
 966 {
 967     HANDLE proc = fd_to_handle (pid);
 968
 969     #warning I am not sure how to kill a process
 970     /* fixme: figure out how this can be done */
 971     return 0;
 972 }
 973
 974
 975
 976 /*
 977  * Select on the list of fds.
 978  * Returns: -1 = error
 979  *           0 = timeout or nothing to select
 980  *          >0 = number of signaled fds
 981  */
 982 int
 983 _gpgme_io_select ( struct io_select_fd_s *fds, size_t nfds, int nonblock )
 984 {
 985     HANDLE waitbuf[MAXIMUM_WAIT_OBJECTS];
 986     int    waitidx[MAXIMUM_WAIT_OBJECTS];
 987     int code, nwait;
 988     int i, any;
 989     int count;
 990     void *dbg_help;
 991
 992  restart:
 993     DEBUG_BEGIN (dbg_help, 3, "select on [ ");
 994     any = 0;
 995     nwait = 0;
 996     count = 0;
 997     for ( i=0; i < nfds; i++ ) {
 998         if ( fds[i].fd == -1 )
 999             continue;
1000         fds[i].signaled = 0;
1001         if ( fds[i].for_read || fds[i].for_write ) {
1002             if ( fds[i].frozen ) {
1003                 DEBUG_ADD1 (dbg_help, "f%d ", fds[i].fd );
1004             }
1005             else if ( fds[i].for_read ) {
1006                 struct reader_context_s *c = find_reader (fds[i].fd,1);
1007
1008                 if (!c) {
1009                     DEBUG1 ("oops: no reader thread for fd %d", fds[i].fd);
1010                 }
1011                 else {
1012                     if ( nwait >= DIM (waitbuf) ) {
1013                         DEBUG_END (dbg_help, "oops ]");
1014                         DEBUG0 ("Too many objects for WFMO!" );
1015                         return -1;
1016                     }
1017                     waitidx[nwait]   = i;
1018                     waitbuf[nwait++] = c->have_data_ev;
1019                 }
1020                 DEBUG_ADD1 (dbg_help, "r%d ", fds[i].fd );
1021                 any = 1;
1022             }
1023             else if ( fds[i].for_write ) {
1024                 struct writer_context_s *c = find_writer (fds[i].fd,1);
1025
1026                 if (!c) {
1027                     DEBUG1 ("oops: no writer thread for fd %d", fds[i].fd);
1028                 }
1029                 else {
1030                     if ( nwait >= DIM (waitbuf) ) {
1031                         DEBUG_END (dbg_help, "oops ]");
1032                         DEBUG0 ("Too many objects for WFMO!" );
1033                         return -1;
1034                     }
1035                     LOCK (c->mutex);
1036                     if ( !c->nbytes ) {
1037                         waitidx[nwait]   = i;
1038                         waitbuf[nwait++] = c->is_empty;
1039                         DEBUG_ADD1 (dbg_help, "w%d ", fds[i].fd );
1040                         any = 1;
1041                     }
1042                     else {
1043                         DEBUG_ADD1 (dbg_help, "w%d(ignored) ", fds[i].fd );
1044                     }
1045                     UNLOCK (c->mutex);
1046                 }
1047             }
1048         }
1049     }
1050     DEBUG_END (dbg_help, "]");
1051     if (!any)
1052         return 0;
1053
1054     code = WaitForMultipleObjects ( nwait, waitbuf, 0, nonblock ? 0 : 1000);
1055     if ( code >= WAIT_OBJECT_0 && code < WAIT_OBJECT_0 + nwait ) {
1056         /* This WFMO is a really silly function:  It does return either
1057          * the index of the signaled object or if 2 objects have been
1058          * signalled at the same time, the index of the object with the
1059          * lowest object is returned - so and how do we find out
1060          * how many objects have been signaled???.
1061          * The only solution I can imagine is to test each object starting
1062          * with the returned index individually - how dull.
1063          */
1064         any = 0;
1065         for (i=code - WAIT_OBJECT_0; i < nwait; i++ ) {
1066             if (WaitForSingleObject ( waitbuf[i], NULL ) == WAIT_OBJECT_0) {
1067                 assert (waitidx[i] >=0 && waitidx[i] < nfds);
1068                 fds[waitidx[i]].signaled = 1;
1069                 any = 1;
1070                 count++;
1071             }
1072         }
1073         if (!any) {
1074             DEBUG0 ("Oops: No signaled objects found after WFMO");
1075             count = -1;
1076         }
1077     }
1078     else if ( code == WAIT_TIMEOUT ) {
1079         DEBUG0 ("WFMO timed out\n" );
1080     }
1081     else if (code == WAIT_FAILED ) {
1082         int le = (int)GetLastError ();
1083         if ( le == ERROR_INVALID_HANDLE ) {
1084             int k, j = handle_to_fd (waitbuf[i]);
1085
1086             DEBUG1 ("WFMO invalid handle %d removed\n", j);
1087             for (k=0 ; k < nfds; i++ ) {
1088                 if ( fds[k].fd == j ) {
1089                     fds[k].for_read = fds[k].for_write = 0;
1090                     goto restart;
1091                 }
1092             }
1093             DEBUG0 (" oops, or not???\n");
1094         }
1095         DEBUG1 ("WFMO failed: %d\n", le );
1096         count = -1;
1097     }
1098     else {
1099         DEBUG1 ("WFMO returned %d\n", code );
1100         count = -1;
1101     }
1102
1103     if ( count ) {
1104         DEBUG_BEGIN (dbg_help, 3, " signaled [ ");
1105         for ( i=0; i < nfds; i++ ) {
1106             if ( fds[i].fd == -1 )
1107                 continue;
1108             if ( (fds[i].for_read || fds[i].for_write) && fds[i].signaled ) {
1109                 DEBUG_ADD2 (dbg_help, "%c%d ",
1110                             fds[i].for_read? 'r':'w',fds[i].fd );
1111             }
1112         }
1113         DEBUG_END (dbg_help, "]");
1114     }
1115
1116     return count;
1117 }