/* w32-io.c - W32 API I/O functions.

   Copyright (C) 2000 Werner Koch (dd9jn)

   Copyright (C) 2001, 2002, 2003, 2004, 2007, 2010 g10 Code GmbH

   This file is part of GPGME.

   GPGME is free software; you can redistribute it and/or modify it

   under the terms of the GNU Lesser General Public License as

   published by the Free Software Foundation; either version 2.1 of

   the License, or (at your option) any later version.

   GPGME is distributed in the hope that it will be useful, but

   WITHOUT ANY WARRANTY; without even the implied warranty of

   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU

   Lesser General Public License for more details.

   You should have received a copy of the GNU Lesser General Public

   License along with this program; if not, write to the Free Software

   Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA

   02111-1307, USA.  */

#ifdef HAVE_CONFIG_H

#include <config.h>

#endif

#include <stdio.h>

#include <stdlib.h>

#include <string.h>

#include <assert.h>

#include <errno.h>

#include <fcntl.h>

#ifdef HAVE_SYS_TIME_H

# include <sys/time.h>

#endif

#ifdef HAVE_SYS_TYPES_H

# include <sys/types.h>

#endif

#include <io.h>

#include "util.h"

#ifdef HAVE_W32CE_SYSTEM

#include <assuan.h>

#include <winioctl.h>

#define GPGCEDEV_IOCTL_UNBLOCK                                        \

  CTL_CODE (FILE_DEVICE_STREAMS, 2050, METHOD_BUFFERED, FILE_ANY_ACCESS)

#define GPGCEDEV_IOCTL_ASSIGN_RVID                                    \

  CTL_CODE (FILE_DEVICE_STREAMS, 2051, METHOD_BUFFERED, FILE_ANY_ACCESS)

#endif

#include "sema.h"

#include "priv-io.h"

#include "debug.h"

#include "sys-util.h"

/* FIXME: Optimize.  */

#define MAX_SLAFD 512

static struct

{

  int used;

  /* If this is not INVALID_HANDLE_VALUE, then it's a handle.  */

  HANDLE handle;

  /* If this is not INVALID_SOCKET, then it's a Windows socket.  */

  int socket;

  /* If this is not 0, then it's a rendezvous ID for the pipe server.  */

  int rvid;

  /* DUP_FROM is -1 if this file descriptor was allocated by pipe or

     socket functions.  Only then should the handle or socket be

     destroyed when this FD is closed.  This, together with the fact

     that dup'ed file descriptors are closed before the file

     descriptors from which they are dup'ed are closed, ensures that

     the handle or socket is always valid, and shared among all file

     descriptors referring to the same underlying object.

     The logic behind this is that there is only one reason for us to

     dup file descriptors anyway: to allow simpler book-keeping of

     file descriptors shared between GPGME and libassuan, which both

     want to close something.  Using the same handle for these

     duplicates works just fine.  */

  int dup_from;

} fd_table[MAX_SLAFD];

DEFINE_STATIC_LOCK (fd_table_lock);

/* Returns the FD or -1 on resource limit.  */

int

new_fd (void)

{

  int idx;

  LOCK (fd_table_lock);

  for (idx = 0; idx < MAX_SLAFD; idx++)

    if (! fd_table[idx].used)

      break;

  if (idx == MAX_SLAFD)

    {

      gpg_err_set_errno (EIO);

      idx = -1;

    }

  else

    {

      fd_table[idx].used = 1;

      fd_table[idx].handle = INVALID_HANDLE_VALUE;

      fd_table[idx].socket = INVALID_SOCKET;

      fd_table[idx].rvid = 0;

      fd_table[idx].dup_from = -1;

    }

  UNLOCK (fd_table_lock);

  return idx;

}

void

release_fd (int fd)

{

  if (fd < 0 || fd >= MAX_SLAFD)

    return;

  LOCK (fd_table_lock);

  if (fd_table[fd].used)

    {

      fd_table[fd].used = 0;

      fd_table[fd].handle = INVALID_HANDLE_VALUE;

      fd_table[fd].socket = INVALID_SOCKET;

      fd_table[fd].rvid = 0;

      fd_table[fd].dup_from = -1;

    }

  UNLOCK (fd_table_lock);

}

#define handle_to_fd(a)  ((int)(a))

#define READBUF_SIZE 4096

#define WRITEBUF_SIZE 4096

#define PIPEBUF_SIZE  4096

#define MAX_READERS 64

#define MAX_WRITERS 64

static struct

{

  int inuse;

  int fd;

  _gpgme_close_notify_handler_t handler;

  void *value;

} notify_table[MAX_SLAFD];

DEFINE_STATIC_LOCK (notify_table_lock);

struct reader_context_s

{

  HANDLE file_hd;

  int file_sock;

  HANDLE thread_hd;

  int refcount;

  DECLARE_LOCK (mutex);

  int stop_me;

  int eof;

  int eof_shortcut;

  int error;

  int error_code;

  /* This is manually reset.  */

  HANDLE have_data_ev;

  /* This is automatically reset.  */

  HANDLE have_space_ev;

  /* This is manually reset but actually only triggered once.  */

  HANDLE close_ev;

  size_t readpos, writepos;

  char buffer[READBUF_SIZE];

};

static struct

{

  volatile int used;

  int fd;

  struct reader_context_s *context;

} reader_table[MAX_READERS];

static int reader_table_size= MAX_READERS;

DEFINE_STATIC_LOCK (reader_table_lock);

struct writer_context_s

{

  HANDLE file_hd;

  int file_sock;

  HANDLE thread_hd;

  int refcount;

  DECLARE_LOCK (mutex);

  int stop_me;

  int error;

  int error_code;

  /* This is manually reset.  */

  HANDLE have_data;

  HANDLE is_empty;

  HANDLE close_ev;

  size_t nbytes;

  char buffer[WRITEBUF_SIZE];

};

static struct

{

  volatile int used;

  int fd;

  struct writer_context_s *context;

} writer_table[MAX_WRITERS];

static int writer_table_size= MAX_WRITERS;

DEFINE_STATIC_LOCK (writer_table_lock);

static int

get_desired_thread_priority (void)

{

  int value;

  if (!_gpgme_get_conf_int ("IOThreadPriority", &value))

    {

      value = THREAD_PRIORITY_HIGHEST;

      TRACE1 (DEBUG_SYSIO, "gpgme:get_desired_thread_priority", 0,

	      "%d (default)", value);

    }

  else

    {

      TRACE1 (DEBUG_SYSIO, "gpgme:get_desired_thread_priority", 0,

	      "%d (configured)", value);

    }

  return value;

}

static HANDLE

set_synchronize (HANDLE hd)

{

#ifdef HAVE_W32CE_SYSTEM

  return hd;

#else

  HANDLE new_hd;

  /* For NT we have to set the sync flag.  It seems that the only way

     to do it is by duplicating the handle.  Tsss...  */

  if (!DuplicateHandle (GetCurrentProcess (), hd,

			GetCurrentProcess (), &new_hd,

			EVENT_MODIFY_STATE | SYNCHRONIZE, FALSE, 0))

    {

      TRACE1 (DEBUG_SYSIO, "gpgme:set_synchronize", hd,

	      "DuplicateHandle failed: ec=%d", (int) GetLastError ());

      /* FIXME: Should translate the error code.  */

      gpg_err_set_errno (EIO);

      return INVALID_HANDLE_VALUE;

    }

  CloseHandle (hd);

  return new_hd;

#endif

}

static DWORD CALLBACK

reader (void *arg)

{

  struct reader_context_s *ctx = arg;

  int nbytes;

  DWORD nread;

  int sock;

  TRACE_BEG2 (DEBUG_SYSIO, "gpgme:reader", ctx->file_hd,

	      "file_sock=%d, thread=%p", ctx->file_sock, ctx->thread_hd);

  if (ctx->file_hd != INVALID_HANDLE_VALUE)

    sock = 0;

  else

    sock = 1;

  for (;;)

    {

      LOCK (ctx->mutex);

      /* Leave a 1 byte gap so that we can see whether it is empty or

	 full.  */

      if ((ctx->writepos + 1) % READBUF_SIZE == ctx->readpos)

	{

	  /* Wait for space.  */

	  if (!ResetEvent (ctx->have_space_ev))

	    TRACE_LOG1 ("ResetEvent failed: ec=%d", (int) GetLastError ());

	  UNLOCK (ctx->mutex);

	  TRACE_LOG ("waiting for space");

	  WaitForSingleObject (ctx->have_space_ev, INFINITE);

	  TRACE_LOG ("got space");

	  LOCK (ctx->mutex);

       	}

      if (ctx->stop_me)

	{

	  UNLOCK (ctx->mutex);

	  break;

        }

      nbytes = (ctx->readpos + READBUF_SIZE

		- ctx->writepos - 1) % READBUF_SIZE;

      if (nbytes > READBUF_SIZE - ctx->writepos)

	nbytes = READBUF_SIZE - ctx->writepos;

      UNLOCK (ctx->mutex);

      TRACE_LOG2 ("%s %d bytes", sock? "receiving":"reading", nbytes);

      if (sock)

        {

          int n;

          n = recv (ctx->file_sock, ctx->buffer + ctx->writepos, nbytes, 0);

          if (n < 0)

            {

              ctx->error_code = (int) WSAGetLastError ();

              if (ctx->error_code == ERROR_BROKEN_PIPE)

                {

                  ctx->eof = 1;

                  TRACE_LOG ("got EOF (broken connection)");

                }

              else

                {

                  /* Check whether the shutdown triggered the error -

                     no need to to print a warning in this case.  */

                  if ( ctx->error_code == WSAECONNABORTED

                       || ctx->error_code == WSAECONNRESET)

                    {

                      LOCK (ctx->mutex);

                      if (ctx->stop_me)

                        {

                          UNLOCK (ctx->mutex);

                          TRACE_LOG ("got shutdown");

                          break;

                        }

                      UNLOCK (ctx->mutex);

                    }

                  ctx->error = 1;

                  TRACE_LOG1 ("recv error: ec=%d", ctx->error_code);

                }

              break;

            }

          nread = n;

        }

      else

        {

          if (!ReadFile (ctx->file_hd,

                         ctx->buffer + ctx->writepos, nbytes, &nread, NULL))

            {

              ctx->error_code = (int) GetLastError ();

	      /* NOTE (W32CE): Do not ignore ERROR_BUSY!  Check at

		 least stop_me if that happens.  */

              if (ctx->error_code == ERROR_BROKEN_PIPE)

                {

                  ctx->eof = 1;

                  TRACE_LOG ("got EOF (broken pipe)");

                }

              else

                {

                  ctx->error = 1;

                  TRACE_LOG1 ("read error: ec=%d", ctx->error_code);

                }

              break;

            }

        }

      LOCK (ctx->mutex);

      if (ctx->stop_me)

	{

	  UNLOCK (ctx->mutex);

	  break;

        }

      if (!nread)

	{

	  ctx->eof = 1;

	  TRACE_LOG ("got eof");

	  UNLOCK (ctx->mutex);

	  break;

        }

      TRACE_LOG1 ("got %u bytes", nread);

      ctx->writepos = (ctx->writepos + nread) % READBUF_SIZE;

      if (!SetEvent (ctx->have_data_ev))

	TRACE_LOG2 ("SetEvent (0x%x) failed: ec=%d", ctx->have_data_ev,

		    (int) GetLastError ());

      UNLOCK (ctx->mutex);

    }

  /* Indicate that we have an error or EOF.  */

  if (!SetEvent (ctx->have_data_ev))

    TRACE_LOG2 ("SetEvent (0x%x) failed: ec=%d", ctx->have_data_ev,

                (int) GetLastError ());

  TRACE_LOG ("waiting for close");

  WaitForSingleObject (ctx->close_ev, INFINITE);

  CloseHandle (ctx->close_ev);

  CloseHandle (ctx->have_data_ev);

  CloseHandle (ctx->have_space_ev);

  CloseHandle (ctx->thread_hd);

  DESTROY_LOCK (ctx->mutex);

  free (ctx);

  return TRACE_SUC ();

}

static struct reader_context_s *

create_reader (int fd)

{

  struct reader_context_s *ctx;

  SECURITY_ATTRIBUTES sec_attr;

  DWORD tid;

  TRACE_BEG (DEBUG_SYSIO, "gpgme:create_reader", fd);

  memset (&sec_attr, 0, sizeof sec_attr);

  sec_attr.nLength = sizeof sec_attr;

  sec_attr.bInheritHandle = FALSE;

  ctx = calloc (1, sizeof *ctx);

  if (!ctx)

    {

      TRACE_SYSERR (errno);

      return NULL;

    }

  if (fd < 0 || fd >= MAX_SLAFD || !fd_table[fd].used)

    {

      TRACE_SYSERR (EIO);

      free (ctx);

      return NULL;

    }

  TRACE_LOG4 ("fd=%d -> handle=%p socket=%d dupfrom=%d",

              fd, fd_table[fd].handle, fd_table[fd].socket,

              fd_table[fd].dup_from);

  ctx->file_hd = fd_table[fd].handle;

  ctx->file_sock = fd_table[fd].socket;

  ctx->refcount = 1;

  ctx->have_data_ev = CreateEvent (&sec_attr, TRUE, FALSE, NULL);

  if (ctx->have_data_ev)

    ctx->have_space_ev = CreateEvent (&sec_attr, FALSE, TRUE, NULL);

  if (ctx->have_space_ev)

    ctx->close_ev = CreateEvent (&sec_attr, TRUE, FALSE, NULL);

  if (!ctx->have_data_ev || !ctx->have_space_ev || !ctx->close_ev)

    {

      TRACE_LOG1 ("CreateEvent failed: ec=%d", (int) GetLastError ());

      if (ctx->have_data_ev)

	CloseHandle (ctx->have_data_ev);

      if (ctx->have_space_ev)

	CloseHandle (ctx->have_space_ev);

      if (ctx->close_ev)

	CloseHandle (ctx->close_ev);

      free (ctx);

      /* FIXME: Translate the error code.  */

      TRACE_SYSERR (EIO);

      return NULL;

    }

  ctx->have_data_ev = set_synchronize (ctx->have_data_ev);

  INIT_LOCK (ctx->mutex);

#ifdef HAVE_W32CE_SYSTEM

  ctx->thread_hd = CreateThread (&sec_attr, 64 * 1024, reader, ctx,

				 STACK_SIZE_PARAM_IS_A_RESERVATION, &tid;;

#else

  ctx->thread_hd = CreateThread (&sec_attr, 0, reader, ctx, 0, &tid;;

#endif

  if (!ctx->thread_hd)

    {

      TRACE_LOG1 ("CreateThread failed: ec=%d", (int) GetLastError ());

      DESTROY_LOCK (ctx->mutex);

      if (ctx->have_data_ev)

	CloseHandle (ctx->have_data_ev);

      if (ctx->have_space_ev)

	CloseHandle (ctx->have_space_ev);

      if (ctx->close_ev)

	CloseHandle (ctx->close_ev);

      free (ctx);

      TRACE_SYSERR (EIO);

      return NULL;

    }

  else

    {

      /* We set the priority of the thread higher because we know that

         it only runs for a short time.  This greatly helps to

         increase the performance of the I/O.  */

      SetThreadPriority (ctx->thread_hd, get_desired_thread_priority ());

    }

  TRACE_SUC ();

  return ctx;

}

/* Prepare destruction of the reader thread for CTX.  Returns 0 if a

   call to this function is sufficient and destroy_reader_finish shall

   not be called.  */

static void

destroy_reader (struct reader_context_s *ctx)

{

  LOCK (ctx->mutex);

  ctx->refcount--;

  if (ctx->refcount != 0)

    {

      UNLOCK (ctx->mutex);

      return;

    }

  ctx->stop_me = 1;

  if (ctx->have_space_ev)

    SetEvent (ctx->have_space_ev);

  UNLOCK (ctx->mutex);

#ifdef HAVE_W32CE_SYSTEM

  /* Scenario: We never create a full pipe, but already started

     reading.  Then we need to unblock the reader in the pipe driver

     to make our reader thread notice that we want it to go away.  */

  if (ctx->file_hd != INVALID_HANDLE_VALUE)

    {

      if (!DeviceIoControl (ctx->file_hd, GPGCEDEV_IOCTL_UNBLOCK,

			NULL, 0, NULL, 0, NULL, NULL))

	{

	  TRACE1 (DEBUG_SYSIO, "gpgme:destroy_reader", ctx->file_hd,

		  "unblock control call failed for thread %p", ctx->thread_hd);

	}

    }

#endif

  /* The reader thread is usually blocking in recv or ReadFile.  If

     the peer does not send an EOF or breaks the pipe the WFSO might

     get stuck waiting for the termination of the reader thread.  This

     happens quite often with sockets, thus we definitely need to get

     out of the recv.  A shutdown does this nicely.  For handles

     (i.e. pipes) it would also be nice to cancel the operation, but

     such a feature is only available since Vista.  Thus we need to

     dlopen that syscall.  */

  if (ctx->file_hd != INVALID_HANDLE_VALUE)

    {

      /* Fixme: Call CancelSynchronousIo (handle_of_thread).  */

    }

  else if (ctx->file_sock != INVALID_SOCKET)

    {

      if (shutdown (ctx->file_sock, 2))

        TRACE2 (DEBUG_SYSIO, "gpgme:destroy_reader", ctx->file_hd,

                "shutdown socket %d failed: %s",

                ctx->file_sock, (int) WSAGetLastError ());

    }

  /* After setting this event CTX is void. */

  SetEvent (ctx->close_ev);

}

/* Find a reader context or create a new one.  Note that the reader

   context will last until a _gpgme_io_close.  */

static struct reader_context_s *

find_reader (int fd, int start_it)

{

  struct reader_context_s *rd = NULL;

  int i;

  LOCK (reader_table_lock);

  for (i = 0; i < reader_table_size; i++)

    if (reader_table[i].used && reader_table[i].fd == fd)

      rd = reader_table[i].context;

  if (rd || !start_it)

    {

      UNLOCK (reader_table_lock);

      return rd;

    }

  for (i = 0; i < reader_table_size; i++)

    if (!reader_table[i].used)

      break;

  if (i != reader_table_size)

    {

      rd = create_reader (fd);

      reader_table[i].fd = fd;

      reader_table[i].context = rd;

      reader_table[i].used = 1;

    }

  UNLOCK (reader_table_lock);

  return rd;

}

int

_gpgme_io_read (int fd, void *buffer, size_t count)

{

  int nread;

  struct reader_context_s *ctx;

  TRACE_BEG2 (DEBUG_SYSIO, "_gpgme_io_read", fd,

	      "buffer=%p, count=%u", buffer, count);

  ctx = find_reader (fd, 1);

  if (!ctx)

    {

      gpg_err_set_errno (EBADF);

      return TRACE_SYSRES (-1);

    }

  if (ctx->eof_shortcut)

    return TRACE_SYSRES (0);

  LOCK (ctx->mutex);

  if (ctx->readpos == ctx->writepos && !ctx->error)

    {

      /* No data available.  */

      UNLOCK (ctx->mutex);

      TRACE_LOG1 ("waiting for data from thread %p", ctx->thread_hd);

      WaitForSingleObject (ctx->have_data_ev, INFINITE);

      TRACE_LOG1 ("data from thread %p available", ctx->thread_hd);

      LOCK (ctx->mutex);

    }

  if (ctx->readpos == ctx->writepos || ctx->error)

    {

      UNLOCK (ctx->mutex);

      ctx->eof_shortcut = 1;

      if (ctx->eof)

	return TRACE_SYSRES (0);

      if (!ctx->error)

	{

	  TRACE_LOG ("EOF but ctx->eof flag not set");

	  return 0;

	}

      gpg_err_set_errno (ctx->error_code);

      return TRACE_SYSRES (-1);

    }

  nread = ctx->readpos < ctx->writepos

    ? ctx->writepos - ctx->readpos

    : READBUF_SIZE - ctx->readpos;

  if (nread > count)

    nread = count;

  memcpy (buffer, ctx->buffer + ctx->readpos, nread);

  ctx->readpos = (ctx->readpos + nread) % READBUF_SIZE;

  if (ctx->readpos == ctx->writepos && !ctx->eof)

    {

      if (!ResetEvent (ctx->have_data_ev))

	{

	  TRACE_LOG1 ("ResetEvent failed: ec=%d", (int) GetLastError ());

	  UNLOCK (ctx->mutex);

	  /* FIXME: Should translate the error code.  */

	  gpg_err_set_errno (EIO);

	  return TRACE_SYSRES (-1);

	}

    }

  if (!SetEvent (ctx->have_space_ev))

    {

      TRACE_LOG2 ("SetEvent (0x%x) failed: ec=%d",

		  ctx->have_space_ev, (int) GetLastError ());

      UNLOCK (ctx->mutex);

      /* FIXME: Should translate the error code.  */

      gpg_err_set_errno (EIO);

      return TRACE_SYSRES (-1);

    }

  UNLOCK (ctx->mutex);

  TRACE_LOGBUF (buffer, nread);

  return TRACE_SYSRES (nread);

}

/* The writer does use a simple buffering strategy so that we are

   informed about write errors as soon as possible (i. e. with the the

   next call to the write function.  */

static DWORD CALLBACK

writer (void *arg)

{

  struct writer_context_s *ctx = arg;

  DWORD nwritten;

  int sock;

  TRACE_BEG2 (DEBUG_SYSIO, "gpgme:writer", ctx->file_hd,

	      "file_sock=%d, thread=%p", ctx->file_sock, ctx->thread_hd);

  if (ctx->file_hd != INVALID_HANDLE_VALUE)

    sock = 0;

  else

    sock = 1;

  for (;;)

    {

      LOCK (ctx->mutex);

      if (ctx->stop_me && !ctx->nbytes)

	{

	  UNLOCK (ctx->mutex);

	  break;

        }

      if (!ctx->nbytes)

	{

	  if (!SetEvent (ctx->is_empty))

	    TRACE_LOG1 ("SetEvent failed: ec=%d", (int) GetLastError ());

	  if (!ResetEvent (ctx->have_data))

	    TRACE_LOG1 ("ResetEvent failed: ec=%d", (int) GetLastError ());

	  UNLOCK (ctx->mutex);

	  TRACE_LOG ("idle");

	  WaitForSingleObject (ctx->have_data, INFINITE);

	  TRACE_LOG ("got data to send");

	  LOCK (ctx->mutex);

       	}

      if (ctx->stop_me && !ctx->nbytes)

	{

	  UNLOCK (ctx->mutex);

	  break;

        }

      UNLOCK (ctx->mutex);

      TRACE_LOG2 ("%s %d bytes", sock?"sending":"writing", ctx->nbytes);

      /* Note that CTX->nbytes is not zero at this point, because

	 _gpgme_io_write always writes at least 1 byte before waking

	 us up, unless CTX->stop_me is true, which we catch above.  */

      if (sock)

        {

          /* We need to try send first because a socket handle can't

             be used with WriteFile.  */

          int n;

          n = send (ctx->file_sock, ctx->buffer, ctx->nbytes, 0);

          if (n < 0)

            {

              ctx->error_code = (int) WSAGetLastError ();

              ctx->error = 1;

              TRACE_LOG1 ("send error: ec=%d", ctx->error_code);

              break;

            }

          nwritten = n;

        }

      else

        {

          if (!WriteFile (ctx->file_hd, ctx->buffer,

                          ctx->nbytes, &nwritten, NULL))

            {

	      if (GetLastError () == ERROR_BUSY)

		{

		  /* Probably stop_me is set now.  */

                  TRACE_LOG ("pipe busy (unblocked?)");

		  continue;

                }

              ctx->error_code = (int) GetLastError ();

              ctx->error = 1;

              TRACE_LOG1 ("write error: ec=%d", ctx->error_code);

              break;

            }

        }

      TRACE_LOG1 ("wrote %d bytes", (int) nwritten);

      LOCK (ctx->mutex);

      ctx->nbytes -= nwritten;

      UNLOCK (ctx->mutex);

    }

  /* Indicate that we have an error.  */

  if (!SetEvent (ctx->is_empty))

    TRACE_LOG1 ("SetEvent failed: ec=%d", (int) GetLastError ());

  TRACE_LOG ("waiting for close");

  WaitForSingleObject (ctx->close_ev, INFINITE);

  if (ctx->nbytes)

    TRACE_LOG1 ("still %d bytes in buffer at close time", ctx->nbytes);

  CloseHandle (ctx->close_ev);

  CloseHandle (ctx->have_data);

  CloseHandle (ctx->is_empty);

  CloseHandle (ctx->thread_hd);

  DESTROY_LOCK (ctx->mutex);

  free (ctx);

  return TRACE_SUC ();

}

static struct writer_context_s *

create_writer (int fd)

{

  struct writer_context_s *ctx;

  SECURITY_ATTRIBUTES sec_attr;

  DWORD tid;

  TRACE_BEG (DEBUG_SYSIO, "gpgme:create_writer", fd);

  memset (&sec_attr, 0, sizeof sec_attr);

  sec_attr.nLength = sizeof sec_attr;

  sec_attr.bInheritHandle = FALSE;

  ctx = calloc (1, sizeof *ctx);

  if (!ctx)

    {

      TRACE_SYSERR (errno);

      return NULL;

    }

  if (fd < 0 || fd >= MAX_SLAFD || !fd_table[fd].used)

    {

      TRACE_SYSERR (EIO);

      free (ctx);

      return NULL;

    }

  TRACE_LOG4 ("fd=%d -> handle=%p socket=%d dupfrom=%d",

              fd, fd_table[fd].handle, fd_table[fd].socket,

              fd_table[fd].dup_from);

  ctx->file_hd = fd_table[fd].handle;

  ctx->file_sock = fd_table[fd].socket;

  ctx->refcount = 1;

  ctx->have_data = CreateEvent (&sec_attr, TRUE, FALSE, NULL);

  if (ctx->have_data)

    ctx->is_empty  = CreateEvent (&sec_attr, TRUE, TRUE, NULL);

  if (ctx->is_empty)

    ctx->close_ev = CreateEvent (&sec_attr, TRUE, FALSE, NULL);

  if (!ctx->have_data || !ctx->is_empty || !ctx->close_ev)

    {

      TRACE_LOG1 ("CreateEvent failed: ec=%d", (int) GetLastError ());

      if (ctx->have_data)

	CloseHandle (ctx->have_data);

      if (ctx->is_empty)

	CloseHandle (ctx->is_empty);

      if (ctx->close_ev)

	CloseHandle (ctx->close_ev);

      free (ctx);

      /* FIXME: Translate the error code.  */

      TRACE_SYSERR (EIO);

      return NULL;

    }

  ctx->is_empty = set_synchronize (ctx->is_empty);

  INIT_LOCK (ctx->mutex);

#ifdef HAVE_W32CE_SYSTEM

  ctx->thread_hd = CreateThread (&sec_attr, 64 * 1024, writer, ctx,

				 STACK_SIZE_PARAM_IS_A_RESERVATION, &tid;;

#else

  ctx->thread_hd = CreateThread (&sec_attr, 0, writer, ctx, 0, &tid );

#endif

  if (!ctx->thread_hd)

    {

      TRACE_LOG1 ("CreateThread failed: ec=%d", (int) GetLastError ());

      DESTROY_LOCK (ctx->mutex);

      if (ctx->have_data)

	CloseHandle (ctx->have_data);

      if (ctx->is_empty)

	CloseHandle (ctx->is_empty);

      if (ctx->close_ev)

	CloseHandle (ctx->close_ev);

      free (ctx);

      TRACE_SYSERR (EIO);

      return NULL;

    }

  else

    {

      /* We set the priority of the thread higher because we know

	 that it only runs for a short time.  This greatly helps to

	 increase the performance of the I/O.  */

      SetThreadPriority (ctx->thread_hd, get_desired_thread_priority ());

    }

  TRACE_SUC ();

  return ctx;

}