/* GLIB - Library of useful routines for C programming

 * Copyright (C) 1995-1997  Peter Mattis, Spencer Kimball and Josh MacDonald

 *

 * giowin32.c: IO Channels for Win32.

 * Copyright 1998 Owen Taylor and Tor Lillqvist

 * Copyright 1999-2000 Tor Lillqvist and Craig Setera

 * Copyright 2001-2003 Andrew Lanoix

 *

 * This library 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.

 *

 * This library 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 library; if not, see <http://www.gnu.org/licenses/>.

 */

/*

 * Modified by the GLib Team and others 1997-2000.  See the AUTHORS

 * file for a list of people on the GLib Team.  See the ChangeLog

 * files for a list of changes.  These files are distributed with

 * GLib at ftp://ftp.gtk.org/pub/gtk/.

 */

/*

 * Bugs that are related to the code in this file:

 *

 * Bug 137968 - Sometimes a GIOFunc on Win32 is called with zero condition

 * http://bugzilla.gnome.org/show_bug.cgi?id=137968

 *

 * Bug 324234 - Using g_io_add_watch_full() to wait for connect() to return on a non-blocking socket returns prematurely

 * http://bugzilla.gnome.org/show_bug.cgi?id=324234

 *

 * Bug 331214 - g_io_channel async socket io stalls

 * http://bugzilla.gnome.org/show_bug.cgi?id=331214

 *

 * Bug 338943 - Multiple watches on the same socket

 * http://bugzilla.gnome.org/show_bug.cgi?id=338943

 *

 * Bug 357674 - 2 serious bugs in giowin32.c making glib iochannels useless

 * http://bugzilla.gnome.org/show_bug.cgi?id=357674

 *

 * Bug 425156 - GIOChannel deadlocks on a win32 socket

 * http://bugzilla.gnome.org/show_bug.cgi?id=425156

 *

 * Bug 468910 - giofunc condition=0

 * http://bugzilla.gnome.org/show_bug.cgi?id=468910

 *

 * Bug 500246 - Bug fixes for giowin32

 * http://bugzilla.gnome.org/show_bug.cgi?id=500246

 *

 * Bug 548278 - Async GETs connections are always terminated unexpectedly on windows

 * http://bugzilla.gnome.org/show_bug.cgi?id=548278

 *

 * Bug 548536 - giowin32 problem when adding and removing watches

 * http://bugzilla.gnome.org/show_bug.cgi?id=548536

 *

 * When fixing bugs related to the code in this file, either the above

 * bugs or others, make sure that the test programs attached to the

 * above bugs continue to work.

 */

#include "config.h"

#include "glib.h"

#include <stdlib.h>

#include <winsock2.h>

#include <windows.h>

#include <conio.h>

#include <fcntl.h>

#include <io.h>

#include <process.h>

#include <errno.h>

#include <sys/stat.h>

#include "gstdio.h"

#include "glibintl.h"

typedef struct _GIOWin32Channel GIOWin32Channel;

typedef struct _GIOWin32Watch GIOWin32Watch;

#define BUFFER_SIZE 4096

typedef enum {

  G_IO_WIN32_WINDOWS_MESSAGES,	/* Windows messages */

  G_IO_WIN32_FILE_DESC,		/* Unix-like file descriptors from

				 * _open() or _pipe(), except for

				 * console IO. Separate thread to read

				 * or write.

				 */

  G_IO_WIN32_CONSOLE,		/* Console IO (usually stdin, stdout, stderr) */

  G_IO_WIN32_SOCKET		/* Sockets. No separate thread. */

} GIOWin32ChannelType;

struct _GIOWin32Channel {

  GIOChannel channel;

  gint fd;			/* Either a Unix-like file handle as provided

				 * by the Microsoft C runtime, or a SOCKET

				 * as provided by WinSock.

				 */

  GIOWin32ChannelType type;

  gboolean debug;

  /* Field used by G_IO_WIN32_WINDOWS_MESSAGES channels */

  HWND hwnd;			/* Handle of window, or NULL */

  /* Fields used by G_IO_WIN32_FILE_DESC channels. */

  CRITICAL_SECTION mutex;

  int direction;		/* 0 means we read from it,

				 * 1 means we write to it.

				 */

  gboolean running;		/* Is reader or writer thread

				 * running. FALSE if EOF has been

				 * reached by the reader thread.

				 */

  gboolean needs_close;		/* If the channel has been closed while

				 * the reader thread was still running.

				 */

  guint thread_id;		/* If non-NULL the channel has or has

				 * had a reader or writer thread.

				 */

  HANDLE data_avail_event;

  gushort revents;

  /* Data is kept in a circular buffer. To be able to distinguish between

   * empty and full buffers, we cannot fill it completely, but have to

   * leave a one character gap.

   *

   * Data available is between indexes rdp and wrp-1 (modulo BUFFER_SIZE).

   *

   * Empty:    wrp == rdp

   * Full:     (wrp + 1) % BUFFER_SIZE == rdp

   * Partial:  otherwise

   */

  guchar *buffer;		/* (Circular) buffer */

  gint wrp, rdp;		/* Buffer indices for writing and reading */

  HANDLE space_avail_event;

  /* Fields used by G_IO_WIN32_SOCKET channels */

  int event_mask;

  int last_events;

  HANDLE event;

  gboolean write_would_have_blocked;

  gboolean ever_writable;

};

struct _GIOWin32Watch {

  GSource       source;

  GPollFD       pollfd;

  GIOChannel   *channel;

  GIOCondition  condition;

};

static void

g_win32_print_access_mode (int flags)

{

  g_print ("%s%s%s%s%s%s%s%s%s%s",

	   ((flags & 0x3) == _O_RDWR ? "O_RDWR" :

	    ((flags & 0x3) == _O_RDONLY ? "O_RDONLY" :

	     ((flags & 0x3) == _O_WRONLY ? "O_WRONLY" : "0"))),

	   (flags & _O_APPEND ? "|O_APPEND" : ""),

	   (flags & _O_RANDOM ? "|O_RANDOM" : ""),

	   (flags & _O_SEQUENTIAL ? "|O_SEQUENTIAL" : ""),

	   (flags & _O_TEMPORARY ? "|O_TEMPORARY" : ""),

	   (flags & _O_CREAT ? "|O_CREAT" : ""),

	   (flags & _O_TRUNC ? "|O_TRUNC" : ""),

	   (flags & _O_EXCL ? "|O_EXCL" : ""),

	   (flags & _O_TEXT ? "|O_TEXT" : ""),

	   (flags & _O_BINARY ? "|O_BINARY" : ""));

}

static void

g_win32_print_gioflags (GIOFlags flags)

{

  char *bar = "";

  if (flags & G_IO_FLAG_APPEND)

    bar = "|", g_print ("APPEND");

  if (flags & G_IO_FLAG_NONBLOCK)

    g_print ("%sNONBLOCK", bar), bar = "|";

  if (flags & G_IO_FLAG_IS_READABLE)

    g_print ("%sREADABLE", bar), bar = "|";

  if (flags & G_IO_FLAG_IS_WRITABLE)

    g_print ("%sWRITABLE", bar), bar = "|";

  if (flags & G_IO_FLAG_IS_SEEKABLE)

    g_print ("%sSEEKABLE", bar), bar = "|";

}

static const char *

event_mask_to_string (int mask)

{

  char buf[100];

  int checked_bits = 0;

  char *bufp = buf;

  if (mask == 0)

    return "";

#define BIT(n) checked_bits |= FD_##n; if (mask & FD_##n) bufp += sprintf (bufp, "%s" #n, (bufp>buf ? "|" : ""))

  BIT (READ);

  BIT (WRITE);

  BIT (OOB);

  BIT (ACCEPT);

  BIT (CONNECT);

  BIT (CLOSE);

  BIT (QOS);

  BIT (GROUP_QOS);

  BIT (ROUTING_INTERFACE_CHANGE);

  BIT (ADDRESS_LIST_CHANGE);

#undef BIT

  if ((mask & ~checked_bits) != 0)

	  bufp += sprintf (bufp, "|%#x", mask & ~checked_bits);

  return g_quark_to_string (g_quark_from_string (buf));

}

static const char *

condition_to_string (GIOCondition condition)

{

  char buf[100];

  int checked_bits = 0;

  char *bufp = buf;

  if (condition == 0)

    return "";

#define BIT(n) checked_bits |= G_IO_##n; if (condition & G_IO_##n) bufp += sprintf (bufp, "%s" #n, (bufp>buf ? "|" : ""))

  BIT (IN);

  BIT (OUT);

  BIT (PRI);

  BIT (ERR);

  BIT (HUP);

  BIT (NVAL);

#undef BIT

  if ((condition & ~checked_bits) != 0)

	  bufp += sprintf (bufp, "|%#x", condition & ~checked_bits);

  return g_quark_to_string (g_quark_from_string (buf));

}

static gboolean

g_io_win32_get_debug_flag (void)

{

  return (getenv ("G_IO_WIN32_DEBUG") != NULL);

}

static void

g_io_channel_win32_init (GIOWin32Channel *channel)

{

  channel->debug = g_io_win32_get_debug_flag ();

  InitializeCriticalSection (&channel->mutex);

  channel->running = FALSE;

  channel->needs_close = FALSE;

  channel->thread_id = 0;

  channel->data_avail_event = NULL;

  channel->revents = 0;

  channel->buffer = NULL;

  channel->space_avail_event = NULL;

  channel->event_mask = 0;

  channel->last_events = 0;

  channel->event = NULL;

  channel->write_would_have_blocked = FALSE;

  channel->ever_writable = FALSE;

}

static void

create_events (GIOWin32Channel *channel)

{

  SECURITY_ATTRIBUTES sec_attrs;

  sec_attrs.nLength = sizeof (SECURITY_ATTRIBUTES);

  sec_attrs.lpSecurityDescriptor = NULL;

  sec_attrs.bInheritHandle = FALSE;

  /* The data available event is manual reset, the space available event

   * is automatic reset.

   */

  if (!(channel->data_avail_event = CreateEvent (&sec_attrs, TRUE, FALSE, NULL))

      || !(channel->space_avail_event = CreateEvent (&sec_attrs, FALSE, FALSE, NULL)))

    {

      gchar *emsg = g_win32_error_message (GetLastError ());

      g_error ("Error creating event: %s", emsg);

      g_free (emsg);

    }

}

static unsigned __stdcall

read_thread (void *parameter)

{

  GIOWin32Channel *channel = parameter;

  guchar *buffer;

  gint nbytes;

  g_io_channel_ref ((GIOChannel *)channel);

  if (channel->debug)

    g_print ("read_thread %#x: start fd=%d, data_avail=%p space_avail=%p\n",

	     channel->thread_id,

	     channel->fd,

	     channel->data_avail_event,

	     channel->space_avail_event);

  channel->direction = 0;

  channel->buffer = g_malloc (BUFFER_SIZE);

  channel->rdp = channel->wrp = 0;

  channel->running = TRUE;

  SetEvent (channel->space_avail_event);

  EnterCriticalSection (&channel->mutex);

  while (channel->running)

    {

      if (channel->debug)

	g_print ("read_thread %#x: rdp=%d, wrp=%d\n",

		 channel->thread_id, channel->rdp, channel->wrp);

      if ((channel->wrp + 1) % BUFFER_SIZE == channel->rdp)

	{

	  /* Buffer is full */

	  if (channel->debug)

	    g_print ("read_thread %#x: resetting space_avail\n",

		     channel->thread_id);

	  ResetEvent (channel->space_avail_event);

	  if (channel->debug)

	    g_print ("read_thread %#x: waiting for space\n",

		     channel->thread_id);

	  LeaveCriticalSection (&channel->mutex);

	  WaitForSingleObject (channel->space_avail_event, INFINITE);

	  EnterCriticalSection (&channel->mutex);

	  if (channel->debug)

	    g_print ("read_thread %#x: rdp=%d, wrp=%d\n",

		     channel->thread_id, channel->rdp, channel->wrp);

	}

      buffer = channel->buffer + channel->wrp;

      /* Always leave at least one byte unused gap to be able to

       * distinguish between the full and empty condition...

       */

      nbytes = MIN ((channel->rdp + BUFFER_SIZE - channel->wrp - 1) % BUFFER_SIZE,

		    BUFFER_SIZE - channel->wrp);

      if (channel->debug)

	g_print ("read_thread %#x: calling read() for %d bytes\n",

		 channel->thread_id, nbytes);

      LeaveCriticalSection (&channel->mutex);

      nbytes = read (channel->fd, buffer, nbytes);

      EnterCriticalSection (&channel->mutex);

      channel->revents = G_IO_IN;

      if (nbytes == 0)

	channel->revents |= G_IO_HUP;

      else if (nbytes < 0)

	channel->revents |= G_IO_ERR;

      if (channel->debug)

	g_print ("read_thread %#x: read() returned %d, rdp=%d, wrp=%d\n",

		 channel->thread_id, nbytes, channel->rdp, channel->wrp);

      if (nbytes <= 0)

	break;

      channel->wrp = (channel->wrp + nbytes) % BUFFER_SIZE;

      if (channel->debug)

	g_print ("read_thread %#x: rdp=%d, wrp=%d, setting data_avail\n",

		 channel->thread_id, channel->rdp, channel->wrp);

      SetEvent (channel->data_avail_event);

    }

  channel->running = FALSE;

  if (channel->needs_close)

    {

      if (channel->debug)

	g_print ("read_thread %#x: channel fd %d needs closing\n",

		 channel->thread_id, channel->fd);

      close (channel->fd);

      channel->fd = -1;

    }

  if (channel->debug)

    g_print ("read_thread %#x: EOF, rdp=%d, wrp=%d, setting data_avail\n",

	     channel->thread_id, channel->rdp, channel->wrp);

  SetEvent (channel->data_avail_event);

  LeaveCriticalSection (&channel->mutex);

  g_io_channel_unref ((GIOChannel *)channel);

  /* No need to call _endthreadex(), the actual thread starter routine

   * in MSVCRT (see crt/src/threadex.c:_threadstartex) calls

   * _endthreadex() for us.

   */

  return 0;

}

static unsigned __stdcall

write_thread (void *parameter)

{

  GIOWin32Channel *channel = parameter;

  guchar *buffer;

  gint nbytes;

  g_io_channel_ref ((GIOChannel *)channel);

  if (channel->debug)

    g_print ("write_thread %#x: start fd=%d, data_avail=%p space_avail=%p\n",

	     channel->thread_id,

	     channel->fd,

	     channel->data_avail_event,

	     channel->space_avail_event);

  channel->direction = 1;

  channel->buffer = g_malloc (BUFFER_SIZE);

  channel->rdp = channel->wrp = 0;

  channel->running = TRUE;

  SetEvent (channel->space_avail_event);

  /* We use the same event objects as for a reader thread, but with

   * reversed meaning. So, space_avail is used if data is available

   * for writing, and data_avail is used if space is available in the

   * write buffer.

   */

  EnterCriticalSection (&channel->mutex);

  while (channel->running || channel->rdp != channel->wrp)

    {

      if (channel->debug)

	g_print ("write_thread %#x: rdp=%d, wrp=%d\n",

		 channel->thread_id, channel->rdp, channel->wrp);

      if (channel->wrp == channel->rdp)

	{

	  /* Buffer is empty. */

	  if (channel->debug)

	    g_print ("write_thread %#x: resetting space_avail\n",

		     channel->thread_id);

	  ResetEvent (channel->space_avail_event);

	  if (channel->debug)

	    g_print ("write_thread %#x: waiting for data\n",

		     channel->thread_id);

	  channel->revents = G_IO_OUT;

	  SetEvent (channel->data_avail_event);

	  LeaveCriticalSection (&channel->mutex);

	  WaitForSingleObject (channel->space_avail_event, INFINITE);

	  EnterCriticalSection (&channel->mutex);

	  if (channel->rdp == channel->wrp)

	    break;

	  if (channel->debug)

	    g_print ("write_thread %#x: rdp=%d, wrp=%d\n",

		     channel->thread_id, channel->rdp, channel->wrp);

	}

      buffer = channel->buffer + channel->rdp;

      if (channel->rdp < channel->wrp)

	nbytes = channel->wrp - channel->rdp;

      else

	nbytes = BUFFER_SIZE - channel->rdp;

      if (channel->debug)

	g_print ("write_thread %#x: calling write() for %d bytes\n",

		 channel->thread_id, nbytes);

      LeaveCriticalSection (&channel->mutex);

      nbytes = write (channel->fd, buffer, nbytes);

      EnterCriticalSection (&channel->mutex);

      if (channel->debug)

	g_print ("write_thread %#x: write(%i) returned %d, rdp=%d, wrp=%d\n",

		 channel->thread_id, channel->fd, nbytes, channel->rdp, channel->wrp);

      channel->revents = 0;

      if (nbytes > 0)

	channel->revents |= G_IO_OUT;

      else if (nbytes <= 0)

	channel->revents |= G_IO_ERR;

      channel->rdp = (channel->rdp + nbytes) % BUFFER_SIZE;

      if (nbytes <= 0)

	break;

      if (channel->debug)

	g_print ("write_thread: setting data_avail for thread %#x\n",

		 channel->thread_id);

      SetEvent (channel->data_avail_event);

    }

  channel->running = FALSE;

  if (channel->needs_close)

    {

      if (channel->debug)

	g_print ("write_thread %#x: channel fd %d needs closing\n",

		 channel->thread_id, channel->fd);

      close (channel->fd);

      channel->fd = -1;

    }

  LeaveCriticalSection (&channel->mutex);

  g_io_channel_unref ((GIOChannel *)channel);

  return 0;

}

static void

create_thread (GIOWin32Channel     *channel,

	       GIOCondition         condition,

	       unsigned (__stdcall *thread) (void *parameter))

{

  HANDLE thread_handle;

  int errsv;

  thread_handle = (HANDLE) _beginthreadex (NULL, 0, thread, channel, 0,

					   &channel->thread_id);

  errsv = errno;

  if (thread_handle == 0)

    g_warning ("Error creating thread: %s.",

	       g_strerror (errsv));

  else if (!CloseHandle (thread_handle))

    {

      gchar *emsg = g_win32_error_message (GetLastError ());

      g_warning ("Error closing thread handle: %s.", emsg);

      g_free (emsg);

    }

  WaitForSingleObject (channel->space_avail_event, INFINITE);

}

static GIOStatus

buffer_read (GIOWin32Channel *channel,

	     gchar           *dest,

	     gsize            count,

	     gsize           *bytes_read,

	     GError         **err)

{

  guint nbytes;

  guint left = count;

  EnterCriticalSection (&channel->mutex);

  if (channel->debug)

    g_print ("reading from thread %#x %" G_GSIZE_FORMAT " bytes, rdp=%d, wrp=%d\n",

	     channel->thread_id, count, channel->rdp, channel->wrp);

  if (channel->wrp == channel->rdp)

    {

      LeaveCriticalSection (&channel->mutex);

      if (channel->debug)

	g_print ("waiting for data from thread %#x\n", channel->thread_id);

      WaitForSingleObject (channel->data_avail_event, INFINITE);

      if (channel->debug)

	g_print ("done waiting for data from thread %#x\n", channel->thread_id);

      EnterCriticalSection (&channel->mutex);

      if (channel->wrp == channel->rdp && !channel->running)

	{

	  if (channel->debug)

	    g_print ("wrp==rdp, !running\n");

	  LeaveCriticalSection (&channel->mutex);

          *bytes_read = 0;

	  return G_IO_STATUS_EOF;

	}

    }

  if (channel->rdp < channel->wrp)

    nbytes = channel->wrp - channel->rdp;

  else

    nbytes = BUFFER_SIZE - channel->rdp;

  LeaveCriticalSection (&channel->mutex);

  nbytes = MIN (left, nbytes);

  if (channel->debug)

    g_print ("moving %d bytes from thread %#x\n",

	     nbytes, channel->thread_id);

  memcpy (dest, channel->buffer + channel->rdp, nbytes);

  dest += nbytes;

  left -= nbytes;

  EnterCriticalSection (&channel->mutex);

  channel->rdp = (channel->rdp + nbytes) % BUFFER_SIZE;

  if (channel->debug)

    g_print ("setting space_avail for thread %#x\n", channel->thread_id);

  SetEvent (channel->space_avail_event);

  if (channel->debug)

    g_print ("for thread %#x: rdp=%d, wrp=%d\n",

	     channel->thread_id, channel->rdp, channel->wrp);

  if (channel->running && channel->wrp == channel->rdp)

    {

      if (channel->debug)

	g_print ("resetting data_avail of thread %#x\n",

		 channel->thread_id);

      ResetEvent (channel->data_avail_event);

    };

  LeaveCriticalSection (&channel->mutex);

  /* We have no way to indicate any errors form the actual

   * read() or recv() call in the reader thread. Should we have?

   */

  *bytes_read = count - left;

  return (*bytes_read > 0) ? G_IO_STATUS_NORMAL : G_IO_STATUS_EOF;

}

static GIOStatus

buffer_write (GIOWin32Channel *channel,

	      const gchar     *dest,

	      gsize            count,

	      gsize           *bytes_written,

	      GError         **err)

{

  guint nbytes;

  guint left = count;

  EnterCriticalSection (&channel->mutex);

  if (channel->debug)

    g_print ("buffer_write: writing to thread %#x %" G_GSIZE_FORMAT " bytes, rdp=%d, wrp=%d\n",

	     channel->thread_id, count, channel->rdp, channel->wrp);

  if ((channel->wrp + 1) % BUFFER_SIZE == channel->rdp)

    {

      /* Buffer is full */

      if (channel->debug)

	g_print ("buffer_write: tid %#x: resetting data_avail\n",

		 channel->thread_id);

      ResetEvent (channel->data_avail_event);

      if (channel->debug)

	g_print ("buffer_write: tid %#x: waiting for space\n",

		 channel->thread_id);

      LeaveCriticalSection (&channel->mutex);

      WaitForSingleObject (channel->data_avail_event, INFINITE);

      EnterCriticalSection (&channel->mutex);

      if (channel->debug)

	g_print ("buffer_write: tid %#x: rdp=%d, wrp=%d\n",

		 channel->thread_id, channel->rdp, channel->wrp);

    }

  nbytes = MIN ((channel->rdp + BUFFER_SIZE - channel->wrp - 1) % BUFFER_SIZE,

		BUFFER_SIZE - channel->wrp);

  LeaveCriticalSection (&channel->mutex);

  nbytes = MIN (left, nbytes);

  if (channel->debug)

    g_print ("buffer_write: tid %#x: writing %d bytes\n",

	     channel->thread_id, nbytes);

  memcpy (channel->buffer + channel->wrp, dest, nbytes);

  dest += nbytes;

  left -= nbytes;

  EnterCriticalSection (&channel->mutex);

  channel->wrp = (channel->wrp + nbytes) % BUFFER_SIZE;

  if (channel->debug)

    g_print ("buffer_write: tid %#x: rdp=%d, wrp=%d, setting space_avail\n",

	     channel->thread_id, channel->rdp, channel->wrp);

  SetEvent (channel->space_avail_event);

  if ((channel->wrp + 1) % BUFFER_SIZE == channel->rdp)

    {

      /* Buffer is full */

      if (channel->debug)

	g_print ("buffer_write: tid %#x: resetting data_avail\n",

		 channel->thread_id);

      ResetEvent (channel->data_avail_event);

    }

  LeaveCriticalSection (&channel->mutex);

  /* We have no way to indicate any errors form the actual

   * write() call in the writer thread. Should we have?

   */

  *bytes_written = count - left;

  return (*bytes_written > 0) ? G_IO_STATUS_NORMAL : G_IO_STATUS_EOF;

}

static gboolean

g_io_win32_prepare (GSource *source,

		    gint    *timeout)

{

  GIOWin32Watch *watch = (GIOWin32Watch *)source;

  GIOCondition buffer_condition = g_io_channel_get_buffer_condition (watch->channel);

  GIOWin32Channel *channel = (GIOWin32Channel *)watch->channel;

  int event_mask;

  *timeout = -1;

  if (channel->debug)

    g_print ("g_io_win32_prepare: source=%p channel=%p", source, channel);

  switch (channel->type)

    {

    case G_IO_WIN32_WINDOWS_MESSAGES:

      if (channel->debug)

	g_print (" MSG");

      break;

    case G_IO_WIN32_CONSOLE:

      if (channel->debug)

	g_print (" CON");

      break;

    case G_IO_WIN32_FILE_DESC:

      if (channel->debug)

	g_print (" FD thread=%#x buffer_condition:{%s}"

		 "\n  watch->pollfd.events:{%s} watch->pollfd.revents:{%s} channel->revents:{%s}",

		 channel->thread_id, condition_to_string (buffer_condition),

		 condition_to_string (watch->pollfd.events),

		 condition_to_string (watch->pollfd.revents),

		 condition_to_string (channel->revents));

      EnterCriticalSection (&channel->mutex);

      if (channel->running)

	{

	  if (channel->direction == 0 && channel->wrp == channel->rdp)

	    {

	      if (channel->debug)

		g_print ("\n  setting revents=0");

	      channel->revents = 0;

	    }

	}

      else

	{

	  if (channel->direction == 1

	      && (channel->wrp + 1) % BUFFER_SIZE == channel->rdp)

	    {

	      if (channel->debug)

		g_print ("\n setting revents=0");

	      channel->revents = 0;

	    }

	}	  

      LeaveCriticalSection (&channel->mutex);

      break;

    case G_IO_WIN32_SOCKET:

      if (channel->debug)

	g_print (" SOCK");

      event_mask = 0;

      if (watch->condition & G_IO_IN)

	event_mask |= (FD_READ | FD_ACCEPT);

      if (watch->condition & G_IO_OUT)

	event_mask |= (FD_WRITE | FD_CONNECT);

      event_mask |= FD_CLOSE;

      if (channel->event_mask != event_mask)

	{

	  if (channel->debug)

	    g_print ("\n  WSAEventSelect(%d,%p,{%s})",

		     channel->fd, (HANDLE) watch->pollfd.fd,

		     event_mask_to_string (event_mask));

	  if (WSAEventSelect (channel->fd, (HANDLE) watch->pollfd.fd,

			      event_mask) == SOCKET_ERROR)

	    if (channel->debug)

	      {

		gchar *emsg = g_win32_error_message (WSAGetLastError ());

		g_print (" failed: %s", emsg);

		g_free (emsg);

	      }

	  channel->event_mask = event_mask;

	  if (channel->debug)

	    g_print ("\n  setting last_events=0");

	  channel->last_events = 0;

	  if ((event_mask & FD_WRITE) &&

	      channel->ever_writable &&

	      !channel->write_would_have_blocked)

	    {

	      if (channel->debug)

		g_print (" WSASetEvent(%p)", (WSAEVENT) watch->pollfd.fd);

	      WSASetEvent ((WSAEVENT) watch->pollfd.fd);

	    }

	}

      break;

    default:

      g_assert_not_reached ();

      g_abort ();

    }

  if (channel->debug)

    g_print ("\n");

  return ((watch->condition & buffer_condition) == watch->condition);

}

static gboolean

g_io_win32_check (GSource *source)

{

  MSG msg;

  GIOWin32Watch *watch = (GIOWin32Watch *)source;

  GIOWin32Channel *channel = (GIOWin32Channel *)watch->channel;

  GIOCondition buffer_condition = g_io_channel_get_buffer_condition (watch->channel);

  WSANETWORKEVENTS events;

  if (channel->debug)

    g_print ("g_io_win32_check: source=%p channel=%p", source, channel);

  switch (channel->type)

    {

    case G_IO_WIN32_WINDOWS_MESSAGES:

      if (channel->debug)

	g_print (" MSG\n");

      return (PeekMessage (&msg, channel->hwnd, 0, 0, PM_NOREMOVE));

    case G_IO_WIN32_FILE_DESC:

      if (channel->debug)

	g_print (" FD thread=%#x buffer_condition=%s\n"

		 "  watch->pollfd.events={%s} watch->pollfd.revents={%s} channel->revents={%s}\n",

		 channel->thread_id, condition_to_string (buffer_condition),

		 condition_to_string (watch->pollfd.events),

		 condition_to_string (watch->pollfd.revents),

		 condition_to_string (channel->revents));

      watch->pollfd.revents = (watch->pollfd.events & channel->revents);

      return ((watch->pollfd.revents | buffer_condition) & watch->condition);

    case G_IO_WIN32_CONSOLE:

      if (channel->debug)

	g_print (" CON\n");

      if (watch->channel->is_writeable)

	return TRUE;

      else if (watch->channel->is_readable)

        {

	  INPUT_RECORD buffer;

	  DWORD n;

	  if (PeekConsoleInput ((HANDLE) watch->pollfd.fd, &buffer, 1, &n) &&

	      n == 1)

	    {

	      /* _kbhit() does quite complex processing to find out

	       * whether at least one of the key events pending corresponds

	       * to a "real" character that can be read.

	       */

	      if (_kbhit ())

		return TRUE;

	      /* Discard all other kinds of events */

	      ReadConsoleInput ((HANDLE) watch->pollfd.fd, &buffer, 1, &n);

	    }

        }

      return FALSE;

    case G_IO_WIN32_SOCKET:

      if (channel->debug)

	g_print (" SOCK");

      if (channel->last_events & FD_WRITE)

	{

	  if (channel->debug)

	    g_print (" sock=%d event=%p last_events has FD_WRITE",

		     channel->fd, (HANDLE) watch->pollfd.fd);

	}

      else

	{

	  WSAEnumNetworkEvents (channel->fd, 0, &events);