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

 * Copyright (C) 2000 Werner Koch (dd9jn)

 * Copyright (C) 2001-2004, 2007, 2010, 2018 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, see <https://gnu.org/licenses/>.

 * SPDX-License-Identifier: LGPL-2.1+

 */

#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"

#include "sema.h"

#include "priv-io.h"

#include "debug.h"

#include "sys-util.h"

/* The number of entries in our file table.  We may eventually use a

 * lower value and dynamically resize the table.  */

#define MAX_SLAFD 512

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

#define READBUF_SIZE 4096

#define WRITEBUF_SIZE 4096

#define PIPEBUF_SIZE  4096

/* An object to store handles or sockets.  */

struct hddesc_s

{

  HANDLE hd;

  SOCKET sock;

  int refcount;

};

typedef struct hddesc_s *hddesc_t;

/* The context used by a reader thread.  */

struct reader_context_s

{

  hddesc_t hdd;

  HANDLE thread_hd;

  int refcount;   /* Bumped if the FD has been duped and thus we have

                   * another FD referencing this context.  */

  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];

};

/* The context used by a writer thread.  */

struct writer_context_s

{

  hddesc_t hdd;

  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];

};

/* An object to keep track of HANDLEs and sockets and map them to an

 * integer similar to what we use in Unix.  Note that despite this

 * integer is often named "fd", it is not a file descriptor but really

 * only an index into this table.  Never ever pass such an fd to any

 * other function except for those implemented here.  */

static struct

{

  int used;

  /* The handle descriptor.  */

  hddesc_t hdd;

  /* DUP_FROM is just a debug helper to show from which fd this fd was

   * dup-ed. */

  int dup_from;

  /* Two flags to indicate whether a reader or writer (or both) are

   * needed.  This is so that we can delay the actual thread creation

   * until they are needed.  */

  unsigned int want_reader:1;

  unsigned int want_writer:1;

  /* The context of an associated reader object or NULL.  */

  struct reader_context_s *reader;

  /* The context of an associated writer object or NULL.  */

  struct writer_context_s *writer;

  /* A notification handler.  Noet that we current support only one

   * callback per fd.  */

  struct {

    _gpgme_close_notify_handler_t handler;

    void *value;

  } notify;

} fd_table[MAX_SLAFD];

static size_t fd_table_size = MAX_SLAFD;

DEFINE_STATIC_LOCK (fd_table_lock);

/* We use a single global lock for all hddesc_t objects.  */

DEFINE_STATIC_LOCK (hddesc_lock);

/* Wrapper around CloseHandle to print an error.  */

#define close_handle(hd) _close_handle ((hd), __LINE__);

static void

_close_handle (HANDLE hd, int line)

{

  if (!CloseHandle (hd))

    {

      TRACE (DEBUG_INIT, "w32-io", hd, "CloseHandle failed at line %d: ec=%d",

              line, (int) GetLastError ());

    }

}

/* Wrapper around WaitForSingleObject to print an error.  */

#define wait_for_single_object(hd,msec) \

        _wait_for_single_object ((hd), (msec), __LINE__)

static DWORD

_wait_for_single_object (HANDLE hd, DWORD msec, int line)

{

  DWORD res;

  res = WaitForSingleObject (hd, msec);

  if (res == WAIT_FAILED)

    {

      TRACE (DEBUG_INIT, "w32-io", hd,

              "WFSO failed at line %d: ec=%d", line, (int) GetLastError ());

    }

  return res;

}

/* Create a new handle descriptor object.  */

static hddesc_t

new_hddesc (void)

{

  hddesc_t hdd;

  hdd = malloc (sizeof *hdd);

  if (!hdd)

    return NULL;

  hdd->hd = INVALID_HANDLE_VALUE;

  hdd->sock = INVALID_SOCKET;

  hdd->refcount = 0;

  return hdd;

}

static hddesc_t

ref_hddesc (hddesc_t hdd)

{

  LOCK (hddesc_lock);

  hdd->refcount++;

  UNLOCK (hddesc_lock);

  return hdd;

}

/* Release a handle descriptor object and close its handle or socket

 * if needed.  */

static void

release_hddesc (hddesc_t hdd)

{

  if (!hdd)

    return;

  LOCK (hddesc_lock);

  hdd->refcount--;

  if (hdd->refcount < 1)

    {

      /* Holds a valid handle or was never initialized (in which case

       * REFCOUNT would be -1 here).  */

      TRACE_BEG  (DEBUG_SYSIO, "gpgme:release_hddesc", hdd,

                  "hd=%p, sock=%d, refcount=%d",

                  hdd->hd, hdd->sock, hdd->refcount);

      if (hdd->hd != INVALID_HANDLE_VALUE)

        close_handle (hdd->hd);

      if (hdd->sock != INVALID_SOCKET)

        {

          TRACE_LOG  ("closing socket %d", hdd->sock);

          if (closesocket (hdd->sock))

            {

              TRACE_LOG  ("closesocket failed: ec=%d", (int)WSAGetLastError ());

            }

        }

      free (hdd);

      TRACE_SUC ("");

    }

  UNLOCK (hddesc_lock);

}

/* Returns our FD or -1 on resource limit.  The returned integer

 * references a new object which has not been initialized but can be

 * release with release_fd.  */

static int

new_fd (void)

{

  int idx;

  LOCK (fd_table_lock);

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

    if (! fd_table[idx].used)

      break;

  if (idx == fd_table_size)

    {

      gpg_err_set_errno (EIO);

      idx = -1;

    }

  else

    {

      fd_table[idx].used = 1;

      fd_table[idx].hdd = NULL;

      fd_table[idx].dup_from = -1;

      fd_table[idx].want_reader = 0;

      fd_table[idx].want_writer = 0;

      fd_table[idx].reader = NULL;

      fd_table[idx].writer = NULL;

      fd_table[idx].notify.handler = NULL;

      fd_table[idx].notify.value = NULL;

    }

  UNLOCK (fd_table_lock);

  return idx;

}

/* Releases our FD but it this is just this entry.  No close operation

 * is involved here; it must be done prior to calling this

 * function.  */

static void

release_fd (int fd)

{

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

    return;

  LOCK (fd_table_lock);

  if (fd_table[fd].used)

    {

      release_hddesc (fd_table[fd].hdd);

      fd_table[fd].used = 0;

      fd_table[fd].hdd = NULL;

      fd_table[fd].dup_from = -1;

      fd_table[fd].want_reader = 0;

      fd_table[fd].want_writer = 0;

      fd_table[fd].reader = NULL;

      fd_table[fd].writer = NULL;

      fd_table[fd].notify.handler = NULL;

      fd_table[fd].notify.value = NULL;

    }

  UNLOCK (fd_table_lock);

}

static int

get_desired_thread_priority (void)

{

  int value;

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

    {

      value = THREAD_PRIORITY_HIGHEST;

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

	      "%d (default)", value);

    }

  else

    {

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

	      "%d (configured)", value);

    }

  return value;

}

/* The reader thread.  Created on the fly by gpgme_io_read and

 * destroyed by destroy_reader.  Note that this functions works with a

 * copy of the value of the HANDLE variable frm the FS_TABLE.  */

static DWORD CALLBACK

reader (void *arg)

{

  struct reader_context_s *ctx = arg;

  int nbytes;

  DWORD nread;

  int sock;

  TRACE_BEG  (DEBUG_SYSIO, "gpgme:reader", ctx->hdd,

	      "hd=%p, sock=%d, thread=%p, refcount=%d",

              ctx->hdd->hd, ctx->hdd->sock, ctx->thread_hd, ctx->refcount);

  if (ctx->hdd->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_LOG  ("ResetEvent failed: ec=%d", (int) GetLastError ());

            }

	  UNLOCK (ctx->mutex);

	  TRACE_LOG  ("waiting for space (refcnt=%d)", ctx->refcount);

	  wait_for_single_object (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_LOG  ("%s %d bytes", sock? "receiving":"reading", nbytes);

      if (sock)

        {

          int n;

          n = recv (ctx->hdd->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_LOG  ("recv error: ec=%d", ctx->error_code);

                }

              break;

            }

          nread = n;

        }

      else

        {

          if (!ReadFile (ctx->hdd->hd,

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

            {

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

              if (ctx->error_code == ERROR_BROKEN_PIPE)

                {

                  ctx->eof = 1;

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

                }

              else if (ctx->error_code == ERROR_OPERATION_ABORTED)

                {

                  ctx->eof = 1;

                  TRACE_LOG ("got EOF (closed by us)");

                }

              else

                {

                  ctx->error = 1;

                  TRACE_LOG  ("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_LOG  ("got %lu bytes (refcnt=%d)", nread, ctx->refcount);

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

      if (!SetEvent (ctx->have_data_ev))

        {

          TRACE_LOG  ("SetEvent (%p) 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_LOG ("SetEvent (%p) failed: ec=%d", ctx->have_data_ev,

                (int) GetLastError ());

    }

  TRACE_LOG ("waiting for close");

  wait_for_single_object (ctx->close_ev, INFINITE);

  release_hddesc (ctx->hdd);

  close_handle (ctx->close_ev);

  close_handle (ctx->have_data_ev);

  close_handle (ctx->have_space_ev);

  close_handle (ctx->thread_hd);

  DESTROY_LOCK (ctx->mutex);

  free (ctx);

  TRACE_SUC ("");

  return 0;

}

/* Create a new reader thread and return its context object.  The

 * input is the handle descriptor HDD.  This function may not call any

 * fd based functions because the caller already holds a lock on the

 * fd_table.  */

static struct reader_context_s *

create_reader (hddesc_t hdd)

{

  struct reader_context_s *ctx;

  SECURITY_ATTRIBUTES sec_attr;

  DWORD tid;

  TRACE_BEG  (DEBUG_SYSIO, "gpgme:create_reader", hdd,

              "handle=%p sock=%d refhdd=%d",

              hdd->hd, hdd->sock, hdd->refcount);

  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;

    }

  ctx->hdd = ref_hddesc (hdd);

  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_LOG  ("CreateEvent failed: ec=%d", (int) GetLastError ());

      if (ctx->have_data_ev)

	close_handle (ctx->have_data_ev);

      if (ctx->have_space_ev)

	close_handle (ctx->have_space_ev);

      if (ctx->close_ev)

	close_handle (ctx->close_ev);

      release_hddesc (ctx->hdd);

      free (ctx);

      TRACE_SYSERR (EIO);

      return NULL;

    }

  INIT_LOCK (ctx->mutex);

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

  if (!ctx->thread_hd)

    {

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

      DESTROY_LOCK (ctx->mutex);

      if (ctx->have_data_ev)

	close_handle (ctx->have_data_ev);

      if (ctx->have_space_ev)

	close_handle (ctx->have_space_ev);

      if (ctx->close_ev)

	close_handle (ctx->close_ev);

      release_hddesc (ctx->hdd);

      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)

    {

      TRACE (DEBUG_SYSIO, "gpgme:destroy_reader", ctx,

              "hdd=%p refcount now %d", ctx->hdd, ctx->refcount);

      UNLOCK (ctx->mutex);

      return;

    }

  ctx->stop_me = 1;

  if (ctx->have_space_ev)

    SetEvent (ctx->have_space_ev);

  TRACE (DEBUG_SYSIO, "gpgme:destroy_reader", ctx,

          "hdd=%p close triggered", ctx->hdd);

  UNLOCK (ctx->mutex);

  /* 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.  */

  assert (ctx->hdd);

  if (ctx->hdd && ctx->hdd->hd != INVALID_HANDLE_VALUE)

    {

      _gpgme_w32_cancel_synchronous_io (ctx->thread_hd);

    }

  else if (ctx->hdd && ctx->hdd->sock != INVALID_SOCKET)

    {

      if (shutdown (ctx->hdd->sock, 2))

        TRACE (DEBUG_SYSIO, "gpgme:destroy_reader", ctx,

                "shutdown socket %d failed: ec=%d",

                ctx->hdd->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.  NULL is returned for a

 * bad FD or for other errors.  */

static struct reader_context_s *

find_reader (int fd)

{

  struct reader_context_s *rd = NULL;

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

  LOCK (fd_table_lock);

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

    {

      UNLOCK (fd_table_lock);

      gpg_err_set_errno (EBADF);

      TRACE_SUC ("EBADF");

      return NULL;

    }

  rd = fd_table[fd].reader;

  if (rd)

    {

      UNLOCK (fd_table_lock);

      TRACE_SUC ("rd=%p", rd);

      return rd;  /* Return already initialized reader thread object.  */

    }

  /* Create a new reader thread.  */

  TRACE_LOG  ("fd=%d -> hdd=%p dupfrom=%d creating reader",

              fd, fd_table[fd].hdd, fd_table[fd].dup_from);

  rd = create_reader (fd_table[fd].hdd);

  if (!rd)

    gpg_err_set_errno (EIO);

  else

    fd_table[fd].reader = rd;

  UNLOCK (fd_table_lock);

  TRACE_SUC ("rd=%p (new)", rd);

  return rd;

}

int

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

{

  int nread;

  struct reader_context_s *ctx;

  TRACE_BEG  (DEBUG_SYSIO, "_gpgme_io_read", fd,

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

  ctx = find_reader (fd);

  if (!ctx)

    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_LOG  ("waiting for data from thread %p", ctx->thread_hd);

      wait_for_single_object (ctx->have_data_ev, INFINITE);

      TRACE_LOG  ("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_LOG  ("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_LOG  ("SetEvent (%p) 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_LOGBUFX (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_BEG  (DEBUG_SYSIO, "gpgme:writer", ctx->hdd,

	      "hd=%p, sock=%d, thread=%p, refcount=%d",

              ctx->hdd->hd, ctx->hdd->sock, ctx->thread_hd, ctx->refcount);

  if (ctx->hdd->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_LOG  ("SetEvent failed: ec=%d", (int) GetLastError ());

	  if (!ResetEvent (ctx->have_data))

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

	  UNLOCK (ctx->mutex);

	  TRACE_LOG ("idle");

	  wait_for_single_object (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_LOG  ("%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->hdd->sock, ctx->buffer, ctx->nbytes, 0);

          if (n < 0)

            {

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

              ctx->error = 1;

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

              break;

            }

          nwritten = n;

        }

      else

        {

          if (!WriteFile (ctx->hdd->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_LOG  ("write error: ec=%d", ctx->error_code);

              break;

            }

        }

      TRACE_LOG  ("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_LOG  ("SetEvent failed: ec=%d", (int) GetLastError ());

  TRACE_LOG ("waiting for close");

  wait_for_single_object (ctx->close_ev, INFINITE);

  if (ctx->nbytes)

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

  release_hddesc (ctx->hdd);

  close_handle (ctx->close_ev);

  close_handle (ctx->have_data);

  close_handle (ctx->is_empty);

  close_handle (ctx->thread_hd);

  DESTROY_LOCK (ctx->mutex);

  free (ctx);

  TRACE_SUC ("");

  return 0;

}

static struct writer_context_s *

create_writer (hddesc_t hdd)

{

  struct writer_context_s *ctx;

  SECURITY_ATTRIBUTES sec_attr;

  DWORD tid;

TRACE_BEG  (DEBUG_SYSIO, "gpgme:create_writer", hdd,

             "handle=%p sock=%d refhdd=%d",

             hdd->hd, hdd->sock, hdd->refcount);

  memset (&sec_attr, 0, sizeof sec_attr);

  sec_attr.nLength = sizeof sec_attr;

  sec_attr.bInheritHandle = FALSE;

  ctx = calloc (1, sizeof *ctx);