glib/giowin32.c

   1 /* GLIB - Library of useful routines for C programming
   2  * Copyright (C) 1995-1997  Peter Mattis, Spencer Kimball and Josh MacDonald
   3  *
   4  * giowin32.c: IO Channels for Win32.
   5  * Copyright 1998 Owen Taylor and Tor Lillqvist
   6  * Copyright 1999-2000 Tor Lillqvist and Craig Setera
   7  * Copyright 2001-2003 Andrew Lanoix
   8  *
   9  * This library is free software; you can redistribute it and/or
  10  * modify it under the terms of the GNU Lesser General Public
  11  * License as published by the Free Software Foundation; either
  12  * version 2 of the License, or (at your option) any later version.
  13  *
  14  * This library is distributed in the hope that it will be useful,
  15  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  16  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  17  * Lesser General Public License for more details.
  18  *
  19  * You should have received a copy of the GNU Lesser General Public
  20  * License along with this library; if not, write to the
  21  * Free Software Foundation, Inc., 59 Temple Place - Suite 330,
  22  * Boston, MA 02111-1307, USA.
  23  */
  24
  25 /*
  26  * Modified by the GLib Team and others 1997-2000.  See the AUTHORS
  27  * file for a list of people on the GLib Team.  See the ChangeLog
  28  * files for a list of changes.  These files are distributed with
  29  * GLib at ftp://ftp.gtk.org/pub/gtk/.
  30  */
  31
  32 /*
  33  * Bugs that are related to the code in this file:
  34  *
  35  * Bug 137968 - Sometimes a GIOFunc on Win32 is called with zero condition
  36  * http://bugzilla.gnome.org/show_bug.cgi?id=137968
  37  *
  38  * Bug 324234 - Using g_io_add_watch_full() to wait for connect() to return on a non-blocking socket returns prematurely
  39  * http://bugzilla.gnome.org/show_bug.cgi?id=324234
  40  *
  41  * Bug 331214 - g_io_channel async socket io stalls
  42  * http://bugzilla.gnome.org/show_bug.cgi?id=331214
  43  *
  44  * Bug 338943 - Multiple watches on the same socket
  45  * http://bugzilla.gnome.org/show_bug.cgi?id=338943
  46  *
  47  * Bug 357674 - 2 serious bugs in giowin32.c making glib iochannels useless
  48  * http://bugzilla.gnome.org/show_bug.cgi?id=357674
  49  *
  50  * Bug 425156 - GIOChannel deadlocks on a win32 socket
  51  * http://bugzilla.gnome.org/show_bug.cgi?id=425156
  52  *
  53  * Bug 468910 - giofunc condition=0
  54  * http://bugzilla.gnome.org/show_bug.cgi?id=468910
  55  *
  56  * Bug 500246 - Bug fixes for giowin32
  57  * http://bugzilla.gnome.org/show_bug.cgi?id=500246
  58  *
  59  * Bug 548278 - Async GETs connections are always terminated unexpectedly on windows
  60  * http://bugzilla.gnome.org/show_bug.cgi?id=548278
  61  *
  62  * Bug 548536 - giowin32 problem when adding and removing watches
  63  * http://bugzilla.gnome.org/show_bug.cgi?id=548536
  64  *
  65  * When fixing bugs related to the code in this file, either the above
  66  * bugs or others, make sure that the test programs attached to the
  67  * above bugs continue to work.
  68  */
  69
  70 #include "config.h"
  71
  72 #include "glib.h"
  73
  74 #include <stdlib.h>
  75 #include <winsock2.h>
  76 #include <windows.h>
  77 #include <conio.h>
  78 #include <fcntl.h>
  79 #include <io.h>
  80 #include <process.h>
  81 #include <errno.h>
  82 #include <sys/stat.h>
  83
  84 #include "gstdio.h"
  85 #include "glibintl.h"
  86
  87 #include "galias.h"
  88
  89 typedef struct _GIOWin32Channel GIOWin32Channel;
  90 typedef struct _GIOWin32Watch GIOWin32Watch;
  91
  92 #define BUFFER_SIZE 4096
  93
  94 typedef enum {
  95   G_IO_WIN32_WINDOWS_MESSAGES,  /* Windows messages */
  96
  97   G_IO_WIN32_FILE_DESC,         /* Unix-like file descriptors from
  98                                  * _open() or _pipe(), except for
  99                                  * console IO. Separate thread to read
 100                                  * or write.
 101                                  */
 102
 103   G_IO_WIN32_CONSOLE,           /* Console IO (usually stdin, stdout, stderr) */
 104
 105   G_IO_WIN32_SOCKET             /* Sockets. No separate thread. */
 106 } GIOWin32ChannelType;
 107
 108 struct _GIOWin32Channel {
 109   GIOChannel channel;
 110   gint fd;                      /* Either a Unix-like file handle as provided
 111                                  * by the Microsoft C runtime, or a SOCKET
 112                                  * as provided by WinSock.
 113                                  */
 114   GIOWin32ChannelType type;
 115
 116   gboolean debug;
 117
 118   /* Field used by G_IO_WIN32_WINDOWS_MESSAGES channels */
 119   HWND hwnd;                    /* Handle of window, or NULL */
 120
 121   /* Fields used by G_IO_WIN32_FILE_DESC channels. */
 122   CRITICAL_SECTION mutex;
 123
 124   int direction;                /* 0 means we read from it,
 125                                  * 1 means we write to it.
 126                                  */
 127
 128   gboolean running;             /* Is reader or writer thread
 129                                  * running. FALSE if EOF has been
 130                                  * reached by the reader thread.
 131                                  */
 132
 133   gboolean needs_close;         /* If the channel has been closed while
 134                                  * the reader thread was still running.
 135                                  */
 136
 137   guint thread_id;              /* If non-NULL the channel has or has
 138                                  * had a reader or writer thread.
 139                                  */
 140   HANDLE data_avail_event;
 141
 142   gushort revents;
 143
 144   /* Data is kept in a circular buffer. To be able to distinguish between
 145    * empty and full buffers, we cannot fill it completely, but have to
 146    * leave a one character gap.
 147    *
 148    * Data available is between indexes rdp and wrp-1 (modulo BUFFER_SIZE).
 149    *
 150    * Empty:    wrp == rdp
 151    * Full:     (wrp + 1) % BUFFER_SIZE == rdp
 152    * Partial:  otherwise
 153    */
 154   guchar *buffer;               /* (Circular) buffer */
 155   gint wrp, rdp;                /* Buffer indices for writing and reading */
 156   HANDLE space_avail_event;
 157
 158   /* Fields used by G_IO_WIN32_SOCKET channels */
 159   int event_mask;
 160   int last_events;
 161   HANDLE event;
 162   gboolean write_would_have_blocked;
 163   gboolean ever_writable;
 164 };
 165
 166 #define LOCK(mutex) EnterCriticalSection (&mutex)
 167 #define UNLOCK(mutex) LeaveCriticalSection (&mutex)
 168
 169 struct _GIOWin32Watch {
 170   GSource       source;
 171   GPollFD       pollfd;
 172   GIOChannel   *channel;
 173   GIOCondition  condition;
 174 };
 175
 176 static void
 177 g_win32_print_access_mode (int flags)
 178 {
 179   g_print ("%s%s%s%s%s%s%s%s%s%s",
 180            ((flags & 0x3) == _O_RDWR ? "O_RDWR" :
 181             ((flags & 0x3) == _O_RDONLY ? "O_RDONLY" :
 182              ((flags & 0x3) == _O_WRONLY ? "O_WRONLY" : "0"))),
 183            (flags & _O_APPEND ? "|O_APPEND" : ""),
 184            (flags & _O_RANDOM ? "|O_RANDOM" : ""),
 185            (flags & _O_SEQUENTIAL ? "|O_SEQUENTIAL" : ""),
 186            (flags & _O_TEMPORARY ? "|O_TEMPORARY" : ""),
 187            (flags & _O_CREAT ? "|O_CREAT" : ""),
 188            (flags & _O_TRUNC ? "|O_TRUNC" : ""),
 189            (flags & _O_EXCL ? "|O_EXCL" : ""),
 190            (flags & _O_TEXT ? "|O_TEXT" : ""),
 191            (flags & _O_BINARY ? "|O_BINARY" : ""));
 192 }
 193
 194 static void
 195 g_win32_print_gioflags (GIOFlags flags)
 196 {
 197   char *bar = "";
 198
 199   if (flags & G_IO_FLAG_APPEND)
 200     bar = "|", g_print ("APPEND");
 201   if (flags & G_IO_FLAG_NONBLOCK)
 202     g_print ("%sNONBLOCK", bar), bar = "|";
 203   if (flags & G_IO_FLAG_IS_READABLE)
 204     g_print ("%sREADABLE", bar), bar = "|";
 205   if (flags & G_IO_FLAG_IS_WRITEABLE)
 206     g_print ("%sWRITEABLE", bar), bar = "|";
 207   if (flags & G_IO_FLAG_IS_SEEKABLE)
 208     g_print ("%sSEEKABLE", bar), bar = "|";
 209 }
 210
 211 static const char *
 212 event_mask_to_string (int mask)
 213 {
 214   char buf[100];
 215   int checked_bits = 0;
 216   char *bufp = buf;
 217
 218   if (mask == 0)
 219     return "";
 220
 221 #define BIT(n) checked_bits |= FD_##n; if (mask & FD_##n) bufp += sprintf (bufp, "%s" #n, (bufp>buf ? "|" : ""))
 222
 223   BIT (READ);
 224   BIT (WRITE);
 225   BIT (OOB);
 226   BIT (ACCEPT);
 227   BIT (CONNECT);
 228   BIT (CLOSE);
 229   BIT (QOS);
 230   BIT (GROUP_QOS);
 231   BIT (ROUTING_INTERFACE_CHANGE);
 232   BIT (ADDRESS_LIST_CHANGE);
 233
 234 #undef BIT
 235
 236   if ((mask & ~checked_bits) != 0)
 237           bufp += sprintf (bufp, "|%#x", mask & ~checked_bits);
 238
 239   return g_quark_to_string (g_quark_from_string (buf));
 240 }
 241
 242 static const char *
 243 condition_to_string (GIOCondition condition)
 244 {
 245   char buf[100];
 246   int checked_bits = 0;
 247   char *bufp = buf;
 248
 249   if (condition == 0)
 250     return "";
 251
 252 #define BIT(n) checked_bits |= G_IO_##n; if (condition & G_IO_##n) bufp += sprintf (bufp, "%s" #n, (bufp>buf ? "|" : ""))
 253
 254   BIT (IN);
 255   BIT (OUT);
 256   BIT (PRI);
 257   BIT (ERR);
 258   BIT (HUP);
 259   BIT (NVAL);
 260
 261 #undef BIT
 262
 263   if ((condition & ~checked_bits) != 0)
 264           bufp += sprintf (bufp, "|%#x", condition & ~checked_bits);
 265
 266   return g_quark_to_string (g_quark_from_string (buf));
 267 }
 268
 269 static gboolean
 270 g_io_win32_get_debug_flag (void)
 271 {
 272   return (getenv ("G_IO_WIN32_DEBUG") != NULL);
 273 }
 274
 275 static void
 276 g_io_channel_win32_init (GIOWin32Channel *channel)
 277 {
 278   channel->debug = g_io_win32_get_debug_flag ();
 279   channel->buffer = NULL;
 280   channel->running = FALSE;
 281   channel->needs_close = FALSE;
 282   channel->thread_id = 0;
 283   channel->data_avail_event = NULL;
 284   channel->revents = 0;
 285   channel->space_avail_event = NULL;
 286   channel->event_mask = 0;
 287   channel->last_events = 0;
 288   channel->event = NULL;
 289   channel->write_would_have_blocked = FALSE;
 290   channel->ever_writable = FALSE;
 291   InitializeCriticalSection (&channel->mutex);
 292 }
 293
 294 static void
 295 create_events (GIOWin32Channel *channel)
 296 {
 297   SECURITY_ATTRIBUTES sec_attrs;
 298
 299   sec_attrs.nLength = sizeof (SECURITY_ATTRIBUTES);
 300   sec_attrs.lpSecurityDescriptor = NULL;
 301   sec_attrs.bInheritHandle = FALSE;
 302
 303   /* The data available event is manual reset, the space available event
 304    * is automatic reset.
 305    */
 306   if (!(channel->data_avail_event = CreateEvent (&sec_attrs, TRUE, FALSE, NULL))
 307       || !(channel->space_avail_event = CreateEvent (&sec_attrs, FALSE, FALSE, NULL)))
 308     {
 309       gchar *emsg = g_win32_error_message (GetLastError ());
 310       g_error ("Error creating event: %s", emsg);
 311       g_free (emsg);
 312     }
 313 }
 314
 315 static unsigned __stdcall
 316 read_thread (void *parameter)
 317 {
 318   GIOWin32Channel *channel = parameter;
 319   guchar *buffer;
 320   gint nbytes;
 321
 322   g_io_channel_ref ((GIOChannel *)channel);
 323
 324   if (channel->debug)
 325     g_print ("read_thread %#x: start fd=%d, data_avail=%p space_avail=%p\n",
 326              channel->thread_id,
 327              channel->fd,
 328              channel->data_avail_event,
 329              channel->space_avail_event);
 330
 331   channel->direction = 0;
 332   channel->buffer = g_malloc (BUFFER_SIZE);
 333   channel->rdp = channel->wrp = 0;
 334   channel->running = TRUE;
 335
 336   SetEvent (channel->space_avail_event);
 337
 338   LOCK (channel->mutex);
 339   while (channel->running)
 340     {
 341       if (channel->debug)
 342         g_print ("read_thread %#x: rdp=%d, wrp=%d\n",
 343                  channel->thread_id, channel->rdp, channel->wrp);
 344       if ((channel->wrp + 1) % BUFFER_SIZE == channel->rdp)
 345         {
 346           /* Buffer is full */
 347           if (channel->debug)
 348             g_print ("read_thread %#x: resetting space_avail\n",
 349                      channel->thread_id);
 350           ResetEvent (channel->space_avail_event);
 351           if (channel->debug)
 352             g_print ("read_thread %#x: waiting for space\n",
 353                      channel->thread_id);
 354           UNLOCK (channel->mutex);
 355           WaitForSingleObject (channel->space_avail_event, INFINITE);
 356           LOCK (channel->mutex);
 357           if (channel->debug)
 358             g_print ("read_thread %#x: rdp=%d, wrp=%d\n",
 359                      channel->thread_id, channel->rdp, channel->wrp);
 360         }
 361
 362       buffer = channel->buffer + channel->wrp;
 363
 364       /* Always leave at least one byte unused gap to be able to
 365        * distinguish between the full and empty condition...
 366        */
 367       nbytes = MIN ((channel->rdp + BUFFER_SIZE - channel->wrp - 1) % BUFFER_SIZE,
 368                     BUFFER_SIZE - channel->wrp);
 369
 370       if (channel->debug)
 371         g_print ("read_thread %#x: calling read() for %d bytes\n",
 372                  channel->thread_id, nbytes);
 373
 374       UNLOCK (channel->mutex);
 375
 376       nbytes = read (channel->fd, buffer, nbytes);
 377
 378       LOCK (channel->mutex);
 379
 380       channel->revents = G_IO_IN;
 381       if (nbytes == 0)
 382         channel->revents |= G_IO_HUP;
 383       else if (nbytes < 0)
 384         channel->revents |= G_IO_ERR;
 385
 386       if (channel->debug)
 387         g_print ("read_thread %#x: read() returned %d, rdp=%d, wrp=%d\n",
 388                  channel->thread_id, nbytes, channel->rdp, channel->wrp);
 389
 390       if (nbytes <= 0)
 391         break;
 392
 393       channel->wrp = (channel->wrp + nbytes) % BUFFER_SIZE;
 394       if (channel->debug)
 395         g_print ("read_thread %#x: rdp=%d, wrp=%d, setting data_avail\n",
 396                  channel->thread_id, channel->rdp, channel->wrp);
 397       SetEvent (channel->data_avail_event);
 398     }
 399
 400   channel->running = FALSE;
 401   if (channel->needs_close)
 402     {
 403       if (channel->debug)
 404         g_print ("read_thread %#x: channel fd %d needs closing\n",
 405                  channel->thread_id, channel->fd);
 406       close (channel->fd);
 407       channel->fd = -1;
 408     }
 409
 410   if (channel->debug)
 411     g_print ("read_thread %#x: EOF, rdp=%d, wrp=%d, setting data_avail\n",
 412              channel->thread_id, channel->rdp, channel->wrp);
 413   SetEvent (channel->data_avail_event);
 414   UNLOCK (channel->mutex);
 415
 416   g_io_channel_unref ((GIOChannel *)channel);
 417
 418   /* No need to call _endthreadex(), the actual thread starter routine
 419    * in MSVCRT (see crt/src/threadex.c:_threadstartex) calls
 420    * _endthreadex() for us.
 421    */
 422
 423   return 0;
 424 }
 425
 426 static unsigned __stdcall
 427 write_thread (void *parameter)
 428 {
 429   GIOWin32Channel *channel = parameter;
 430   guchar *buffer;
 431   gint nbytes;
 432
 433   g_io_channel_ref ((GIOChannel *)channel);
 434
 435   if (channel->debug)
 436     g_print ("write_thread %#x: start fd=%d, data_avail=%p space_avail=%p\n",
 437              channel->thread_id,
 438              channel->fd,
 439              channel->data_avail_event,
 440              channel->space_avail_event);
 441
 442   channel->direction = 1;
 443   channel->buffer = g_malloc (BUFFER_SIZE);
 444   channel->rdp = channel->wrp = 0;
 445   channel->running = TRUE;
 446
 447   SetEvent (channel->space_avail_event);
 448
 449   /* We use the same event objects as for a reader thread, but with
 450    * reversed meaning. So, space_avail is used if data is available
 451    * for writing, and data_avail is used if space is available in the
 452    * write buffer.
 453    */
 454
 455   LOCK (channel->mutex);
 456   while (channel->running || channel->rdp != channel->wrp)
 457     {
 458       if (channel->debug)
 459         g_print ("write_thread %#x: rdp=%d, wrp=%d\n",
 460                  channel->thread_id, channel->rdp, channel->wrp);
 461       if (channel->wrp == channel->rdp)
 462         {
 463           /* Buffer is empty. */
 464           if (channel->debug)
 465             g_print ("write_thread %#x: resetting space_avail\n",
 466                      channel->thread_id);
 467           ResetEvent (channel->space_avail_event);
 468           if (channel->debug)
 469             g_print ("write_thread %#x: waiting for data\n",
 470                      channel->thread_id);
 471           channel->revents = G_IO_OUT;
 472           SetEvent (channel->data_avail_event);
 473           UNLOCK (channel->mutex);
 474           WaitForSingleObject (channel->space_avail_event, INFINITE);
 475
 476           LOCK (channel->mutex);
 477           if (channel->rdp == channel->wrp)
 478             break;
 479
 480           if (channel->debug)
 481             g_print ("write_thread %#x: rdp=%d, wrp=%d\n",
 482                      channel->thread_id, channel->rdp, channel->wrp);
 483         }
 484
 485       buffer = channel->buffer + channel->rdp;
 486       if (channel->rdp < channel->wrp)
 487         nbytes = channel->wrp - channel->rdp;
 488       else
 489         nbytes = BUFFER_SIZE - channel->rdp;
 490
 491       if (channel->debug)
 492         g_print ("write_thread %#x: calling write() for %d bytes\n",
 493                  channel->thread_id, nbytes);
 494
 495       UNLOCK (channel->mutex);
 496       nbytes = write (channel->fd, buffer, nbytes);
 497       LOCK (channel->mutex);
 498
 499       if (channel->debug)
 500         g_print ("write_thread %#x: write(%i) returned %d, rdp=%d, wrp=%d\n",
 501                  channel->thread_id, channel->fd, nbytes, channel->rdp, channel->wrp);
 502
 503       channel->revents = 0;
 504       if (nbytes > 0)
 505         channel->revents |= G_IO_OUT;
 506       else if (nbytes <= 0)
 507         channel->revents |= G_IO_ERR;
 508
 509       channel->rdp = (channel->rdp + nbytes) % BUFFER_SIZE;
 510
 511       if (nbytes <= 0)
 512         break;
 513
 514       if (channel->debug)
 515         g_print ("write_thread: setting data_avail for thread %#x\n",
 516                  channel->thread_id);
 517       SetEvent (channel->data_avail_event);
 518     }
 519
 520   channel->running = FALSE;
 521   if (channel->needs_close)
 522     {
 523       if (channel->debug)
 524         g_print ("write_thread %#x: channel fd %d needs closing\n",
 525                  channel->thread_id, channel->fd);
 526       close (channel->fd);
 527       channel->fd = -1;
 528     }
 529
 530   UNLOCK (channel->mutex);
 531
 532   g_io_channel_unref ((GIOChannel *)channel);
 533
 534   return 0;
 535 }
 536
 537 static void
 538 create_thread (GIOWin32Channel     *channel,
 539                GIOCondition         condition,
 540                unsigned (__stdcall *thread) (void *parameter))
 541 {
 542   HANDLE thread_handle;
 543
 544   thread_handle = (HANDLE) _beginthreadex (NULL, 0, thread, channel, 0,
 545                                            &channel->thread_id);
 546   if (thread_handle == 0)
 547     g_warning ("Error creating thread: %s.",
 548                g_strerror (errno));
 549   else if (!CloseHandle (thread_handle))
 550     g_warning ("Error closing thread handle: %s.\n",
 551                g_win32_error_message (GetLastError ()));
 552
 553   WaitForSingleObject (channel->space_avail_event, INFINITE);
 554 }
 555
 556 static GIOStatus
 557 buffer_read (GIOWin32Channel *channel,
 558              gchar           *dest,
 559              gsize            count,
 560              gsize           *bytes_read,
 561              GError         **err)
 562 {
 563   guint nbytes;
 564   guint left = count;
 565
 566   LOCK (channel->mutex);
 567   if (channel->debug)
 568     g_print ("reading from thread %#x %" G_GSIZE_FORMAT " bytes, rdp=%d, wrp=%d\n",
 569              channel->thread_id, count, channel->rdp, channel->wrp);
 570
 571   if (channel->wrp == channel->rdp)
 572     {
 573       UNLOCK (channel->mutex);
 574       if (channel->debug)
 575         g_print ("waiting for data from thread %#x\n", channel->thread_id);
 576       WaitForSingleObject (channel->data_avail_event, INFINITE);
 577       if (channel->debug)
 578         g_print ("done waiting for data from thread %#x\n", channel->thread_id);
 579       LOCK (channel->mutex);
 580       if (channel->wrp == channel->rdp && !channel->running)
 581         {
 582           if (channel->debug)
 583             g_print ("wrp==rdp, !running\n");
 584           UNLOCK (channel->mutex);
 585           *bytes_read = 0;
 586           return G_IO_STATUS_EOF;
 587         }
 588     }
 589
 590   if (channel->rdp < channel->wrp)
 591     nbytes = channel->wrp - channel->rdp;
 592   else
 593     nbytes = BUFFER_SIZE - channel->rdp;
 594   UNLOCK (channel->mutex);
 595   nbytes = MIN (left, nbytes);
 596   if (channel->debug)
 597     g_print ("moving %d bytes from thread %#x\n",
 598              nbytes, channel->thread_id);
 599   memcpy (dest, channel->buffer + channel->rdp, nbytes);
 600   dest += nbytes;
 601   left -= nbytes;
 602   LOCK (channel->mutex);
 603   channel->rdp = (channel->rdp + nbytes) % BUFFER_SIZE;
 604   if (channel->debug)
 605     g_print ("setting space_avail for thread %#x\n", channel->thread_id);
 606   SetEvent (channel->space_avail_event);
 607   if (channel->debug)
 608     g_print ("for thread %#x: rdp=%d, wrp=%d\n",
 609              channel->thread_id, channel->rdp, channel->wrp);
 610   if (channel->running && channel->wrp == channel->rdp)
 611     {
 612       if (channel->debug)
 613         g_print ("resetting data_avail of thread %#x\n",
 614                  channel->thread_id);
 615       ResetEvent (channel->data_avail_event);
 616     };
 617   UNLOCK (channel->mutex);
 618
 619   /* We have no way to indicate any errors form the actual
 620    * read() or recv() call in the reader thread. Should we have?
 621    */
 622   *bytes_read = count - left;
 623   return (*bytes_read > 0) ? G_IO_STATUS_NORMAL : G_IO_STATUS_EOF;
 624 }
 625
 626
 627 static GIOStatus
 628 buffer_write (GIOWin32Channel *channel,
 629               const gchar     *dest,
 630               gsize            count,
 631               gsize           *bytes_written,
 632               GError         **err)
 633 {
 634   guint nbytes;
 635   guint left = count;
 636
 637   LOCK (channel->mutex);
 638   if (channel->debug)
 639     g_print ("buffer_write: writing to thread %#x %" G_GSIZE_FORMAT " bytes, rdp=%d, wrp=%d\n",
 640              channel->thread_id, count, channel->rdp, channel->wrp);
 641
 642   if ((channel->wrp + 1) % BUFFER_SIZE == channel->rdp)
 643     {
 644       /* Buffer is full */
 645       if (channel->debug)
 646         g_print ("buffer_write: tid %#x: resetting data_avail\n",
 647                  channel->thread_id);
 648       ResetEvent (channel->data_avail_event);
 649       if (channel->debug)
 650         g_print ("buffer_write: tid %#x: waiting for space\n",
 651                  channel->thread_id);
 652       UNLOCK (channel->mutex);
 653       WaitForSingleObject (channel->data_avail_event, INFINITE);
 654       LOCK (channel->mutex);
 655       if (channel->debug)
 656         g_print ("buffer_write: tid %#x: rdp=%d, wrp=%d\n",
 657                  channel->thread_id, channel->rdp, channel->wrp);
 658     }
 659
 660   nbytes = MIN ((channel->rdp + BUFFER_SIZE - channel->wrp - 1) % BUFFER_SIZE,
 661                 BUFFER_SIZE - channel->wrp);
 662
 663   UNLOCK (channel->mutex);
 664   nbytes = MIN (left, nbytes);
 665   if (channel->debug)
 666     g_print ("buffer_write: tid %#x: writing %d bytes\n",
 667              channel->thread_id, nbytes);
 668   memcpy (channel->buffer + channel->wrp, dest, nbytes);
 669   dest += nbytes;
 670   left -= nbytes;
 671   LOCK (channel->mutex);
 672
 673   channel->wrp = (channel->wrp + nbytes) % BUFFER_SIZE;
 674   if (channel->debug)
 675     g_print ("buffer_write: tid %#x: rdp=%d, wrp=%d, setting space_avail\n",
 676              channel->thread_id, channel->rdp, channel->wrp);
 677   SetEvent (channel->space_avail_event);
 678
 679   if ((channel->wrp + 1) % BUFFER_SIZE == channel->rdp)
 680     {
 681       /* Buffer is full */
 682       if (channel->debug)
 683         g_print ("buffer_write: tid %#x: resetting data_avail\n",
 684                  channel->thread_id);
 685       ResetEvent (channel->data_avail_event);
 686     }
 687
 688   UNLOCK (channel->mutex);
 689
 690   /* We have no way to indicate any errors form the actual
 691    * write() call in the writer thread. Should we have?
 692    */
 693   *bytes_written = count - left;
 694   return (*bytes_written > 0) ? G_IO_STATUS_NORMAL : G_IO_STATUS_EOF;
 695 }
 696
 697
 698 static gboolean
 699 g_io_win32_prepare (GSource *source,
 700                     gint    *timeout)
 701 {
 702   GIOWin32Watch *watch = (GIOWin32Watch *)source;
 703   GIOCondition buffer_condition = g_io_channel_get_buffer_condition (watch->channel);
 704   GIOWin32Channel *channel = (GIOWin32Channel *)watch->channel;
 705   int event_mask;
 706
 707   *timeout = -1;
 708
 709   if (channel->debug)
 710     g_print ("g_io_win32_prepare: source=%p channel=%p", source, channel);
 711
 712   switch (channel->type)
 713     {
 714     case G_IO_WIN32_WINDOWS_MESSAGES:
 715       if (channel->debug)
 716         g_print (" MSG");
 717       break;
 718
 719     case G_IO_WIN32_CONSOLE:
 720       if (channel->debug)
 721         g_print (" CON");
 722       break;
 723
 724     case G_IO_WIN32_FILE_DESC:
 725       if (channel->debug)
 726         g_print (" FD thread=%#x buffer_condition:{%s}"
 727                  "\n  watch->pollfd.events:{%s} watch->pollfd.revents:{%s} channel->revents:{%s}",
 728                  channel->thread_id, condition_to_string (buffer_condition),
 729                  condition_to_string (watch->pollfd.events),
 730                  condition_to_string (watch->pollfd.revents),
 731                  condition_to_string (channel->revents));
 732
 733       LOCK (channel->mutex);
 734       if (channel->running)
 735         {
 736           if (channel->direction == 0 && channel->wrp == channel->rdp)
 737             {
 738               if (channel->debug)
 739                 g_print ("\n  setting revents=0");
 740               channel->revents = 0;
 741             }
 742         }
 743       else
 744         {
 745           if (channel->direction == 1
 746               && (channel->wrp + 1) % BUFFER_SIZE == channel->rdp)
 747             {
 748               if (channel->debug)
 749                 g_print ("\n setting revents=0");
 750               channel->revents = 0;
 751             }
 752         }
 753       UNLOCK (channel->mutex);
 754       break;
 755
 756     case G_IO_WIN32_SOCKET:
 757       if (channel->debug)
 758         g_print (" SOCK");
 759       event_mask = 0;
 760       if (watch->condition & G_IO_IN)
 761         event_mask |= (FD_READ | FD_ACCEPT);
 762       if (watch->condition & G_IO_OUT)
 763         event_mask |= (FD_WRITE | FD_CONNECT);
 764       event_mask |= FD_CLOSE;
 765
 766       if (channel->event_mask != event_mask)
 767         {
 768           if (channel->debug)
 769             g_print ("\n  WSAEventSelect(%d,%p,{%s})",
 770                      channel->fd, (HANDLE) watch->pollfd.fd,
 771                      event_mask_to_string (event_mask));
 772           if (WSAEventSelect (channel->fd, (HANDLE) watch->pollfd.fd,
 773                               event_mask) == SOCKET_ERROR)
 774             ;                   /* What? */
 775           channel->event_mask = event_mask;
 776 #if 0
 777           channel->event = watch->pollfd.fd;
 778 #endif
 779           if (channel->debug)
 780             g_print ("\n  setting last_events=0");
 781           channel->last_events = 0;
 782
 783           if ((event_mask & FD_WRITE) &&
 784               channel->ever_writable &&
 785               !channel->write_would_have_blocked)
 786             {
 787               if (channel->debug)
 788                 g_print (" WSASetEvent(%p)", (WSAEVENT) watch->pollfd.fd);
 789               WSASetEvent ((WSAEVENT) watch->pollfd.fd);
 790             }
 791         }
 792       break;
 793
 794     default:
 795       g_assert_not_reached ();
 796       abort ();
 797     }
 798   if (channel->debug)
 799     g_print ("\n");
 800
 801   return ((watch->condition & buffer_condition) == watch->condition);
 802 }
 803
 804 static gboolean
 805 g_io_win32_check (GSource *source)
 806 {
 807   MSG msg;
 808   GIOWin32Watch *watch = (GIOWin32Watch *)source;
 809   GIOWin32Channel *channel = (GIOWin32Channel *)watch->channel;
 810   GIOCondition buffer_condition = g_io_channel_get_buffer_condition (watch->channel);
 811   WSANETWORKEVENTS events;
 812
 813   if (channel->debug)
 814     g_print ("g_io_win32_check: source=%p channel=%p", source, channel);
 815
 816   switch (channel->type)
 817     {
 818     case G_IO_WIN32_WINDOWS_MESSAGES:
 819       if (channel->debug)
 820         g_print (" MSG\n");
 821       return (PeekMessage (&msg, channel->hwnd, 0, 0, PM_NOREMOVE));
 822
 823     case G_IO_WIN32_FILE_DESC:
 824       if (channel->debug)
 825         g_print (" FD thread=%#x buffer_condition=%s\n"
 826                  "  watch->pollfd.events={%s} watch->pollfd.revents={%s} channel->revents={%s}\n",
 827                  channel->thread_id, condition_to_string (buffer_condition),
 828                  condition_to_string (watch->pollfd.events),
 829                  condition_to_string (watch->pollfd.revents),
 830                  condition_to_string (channel->revents));
 831
 832       watch->pollfd.revents = (watch->pollfd.events & channel->revents);
 833
 834       return ((watch->pollfd.revents | buffer_condition) & watch->condition);
 835
 836     case G_IO_WIN32_CONSOLE:
 837       if (channel->debug)
 838         g_print (" CON\n");
 839       if (watch->channel->is_writeable)
 840         return TRUE;
 841       else if (watch->channel->is_readable)
 842         {
 843           INPUT_RECORD buffer;
 844           DWORD n;
 845           if (PeekConsoleInput ((HANDLE) watch->pollfd.fd, &buffer, 1, &n) &&
 846               n == 1)
 847             {
 848               /* _kbhit() does quite complex processing to find out
 849                * whether at least one of the key events pending corresponds
 850                * to a "real" character that can be read.
 851                */
 852               if (_kbhit ())
 853                 return TRUE;
 854
 855               /* Discard all other kinds of events */
 856               ReadConsoleInput ((HANDLE) watch->pollfd.fd, &buffer, 1, &n);
 857             }
 858         }
 859       return FALSE;
 860
 861     case G_IO_WIN32_SOCKET:
 862       if (channel->debug)
 863         g_print (" SOCK");
 864       if (channel->last_events & FD_WRITE)
 865         {
 866           if (channel->debug)
 867             g_print (" sock=%d event=%p last_events has FD_WRITE",
 868                      channel->fd, (HANDLE) watch->pollfd.fd);
 869         }
 870       else
 871         {
 872           WSAEnumNetworkEvents (channel->fd, 0, &events);
 873
 874           if (channel->debug)
 875             g_print ("\n  revents={%s} condition={%s}"
 876                      "\n  WSAEnumNetworkEvents(%d,0) sets events={%s}",
 877                      condition_to_string (watch->pollfd.revents),
 878                      condition_to_string (watch->condition),
 879                      channel->fd,
 880                      event_mask_to_string (events.lNetworkEvents));
 881
 882           if (watch->pollfd.revents != 0 &&
 883               events.lNetworkEvents == 0 &&
 884               !(channel->event_mask & FD_WRITE))
 885             {
 886               channel->event_mask = 0;
 887               if (channel->debug)
 888                 g_print ("\n  WSAEventSelect(%d,%p,{})",
 889                          channel->fd, (HANDLE) watch->pollfd.fd);
 890               WSAEventSelect (channel->fd, (HANDLE) watch->pollfd.fd, 0);
 891               if (channel->debug)
 892                 g_print ("  ResetEvent(%p)",
 893                          (HANDLE) watch->pollfd.fd);
 894               ResetEvent ((HANDLE) watch->pollfd.fd);
 895             }
 896           else if (events.lNetworkEvents & FD_WRITE)
 897             channel->ever_writable = TRUE;
 898           channel->last_events = events.lNetworkEvents;
 899         }
 900
 901       watch->pollfd.revents = 0;
 902       if (channel->last_events & (FD_READ | FD_ACCEPT))
 903         watch->pollfd.revents |= G_IO_IN;
 904
 905       if (channel->last_events & FD_WRITE)
 906         watch->pollfd.revents |= G_IO_OUT;
 907       else
 908         {
 909           /* We have called WSAEnumNetworkEvents() above but it didn't
 910            * set FD_WRITE.
 911            */
 912           if (events.lNetworkEvents & FD_CONNECT)
 913             {
 914               if (events.iErrorCode[FD_CONNECT_BIT] == 0)
 915                 watch->pollfd.revents |= G_IO_OUT;
 916               else
 917                 watch->pollfd.revents |= (G_IO_HUP | G_IO_ERR);
 918             }
 919           if (watch->pollfd.revents == 0 && (channel->last_events & (FD_CLOSE)))
 920             watch->pollfd.revents |= G_IO_HUP;
 921         }
 922
 923       /* Regardless of WSAEnumNetworkEvents() result, if watching for
 924        * writability, and if we have ever got a FD_WRITE event, and
 925        * unless last write would have blocked, set G_IO_OUT. But never
 926        * set both G_IO_OUT and G_IO_HUP.
 927        */
 928       if (!(watch->pollfd.revents & G_IO_HUP) &&
 929           channel->ever_writable &&
 930           !channel->write_would_have_blocked &&
 931           (channel->event_mask & FD_WRITE))
 932         watch->pollfd.revents |= G_IO_OUT;
 933
 934       if (channel->debug)
 935         g_print ("\n  revents={%s} retval={%s}\n",
 936                  condition_to_string (watch->pollfd.revents),
 937                  condition_to_string ((watch->pollfd.revents | buffer_condition) & watch->condition));
 938
 939       return ((watch->pollfd.revents | buffer_condition) & watch->condition);
 940
 941     default:
 942       g_assert_not_reached ();
 943       abort ();
 944     }
 945 }
 946
 947 static gboolean
 948 g_io_win32_dispatch (GSource     *source,
 949                      GSourceFunc  callback,
 950                      gpointer     user_data)
 951 {
 952   GIOFunc func = (GIOFunc)callback;
 953   GIOWin32Watch *watch = (GIOWin32Watch *)source;
 954   GIOWin32Channel *channel = (GIOWin32Channel *)watch->channel;
 955   GIOCondition buffer_condition = g_io_channel_get_buffer_condition (watch->channel);
 956
 957   if (!func)
 958     {
 959       g_warning ("IO Watch dispatched without callback\n"
 960                  "You must call g_source_connect().");
 961       return FALSE;
 962     }
 963
 964   if (channel->debug)
 965     g_print ("g_io_win32_dispatch: pollfd.revents=%s condition=%s result=%s\n",
 966              condition_to_string (watch->pollfd.revents),
 967              condition_to_string (watch->condition),
 968              condition_to_string ((watch->pollfd.revents | buffer_condition) & watch->condition));
 969
 970   return (*func) (watch->channel,
 971                   (watch->pollfd.revents | buffer_condition) & watch->condition,
 972                   user_data);
 973 }
 974
 975 static void
 976 g_io_win32_finalize (GSource *source)
 977 {
 978   GIOWin32Watch *watch = (GIOWin32Watch *)source;
 979   GIOWin32Channel *channel = (GIOWin32Channel *)watch->channel;
 980
 981   if (channel->debug)
 982     g_print ("g_io_win32_finalize: source=%p channel=%p", source, channel);
 983
 984   switch (channel->type)
 985     {
 986     case G_IO_WIN32_WINDOWS_MESSAGES:
 987       if (channel->debug)
 988         g_print (" MSG");
 989       break;
 990
 991     case G_IO_WIN32_CONSOLE:
 992       if (channel->debug)
 993         g_print (" CON");
 994       break;
 995
 996     case G_IO_WIN32_FILE_DESC:
 997       if (channel->debug)
 998         g_print (" FD thread=%#x", channel->thread_id);
 999       break;
1000
1001     case G_IO_WIN32_SOCKET:
1002       if (channel->debug)
1003         g_print (" SOCK sock=%d", channel->fd);
1004       break;
1005
1006     default:
1007       g_assert_not_reached ();
1008       abort ();
1009     }
1010   if (channel->debug)
1011     g_print ("\n");
1012   g_io_channel_unref (watch->channel);
1013 }
1014
1015 GSourceFuncs g_io_watch_funcs = {
1016   g_io_win32_prepare,
1017   g_io_win32_check,
1018   g_io_win32_dispatch,
1019   g_io_win32_finalize
1020 };
1021
1022 static GIOStatus
1023 g_io_win32_msg_read (GIOChannel *channel,
1024                      gchar      *buf,
1025                      gsize       count,
1026                      gsize      *bytes_read,
1027                      GError    **err)
1028 {
1029   GIOWin32Channel *win32_channel = (GIOWin32Channel *)channel;
1030   MSG msg;               /* In case of alignment problems */
1031
1032   if (count < sizeof (MSG))
1033     {
1034       g_set_error_literal (err, G_IO_CHANNEL_ERROR, G_IO_CHANNEL_ERROR_INVAL,
1035                            "Incorrect message size"); /* Informative enough error message? */
1036       return G_IO_STATUS_ERROR;
1037     }
1038
1039   if (win32_channel->debug)
1040     g_print ("g_io_win32_msg_read: channel=%p hwnd=%p\n",
1041              channel, win32_channel->hwnd);
1042   if (!PeekMessage (&msg, win32_channel->hwnd, 0, 0, PM_REMOVE))
1043     return G_IO_STATUS_AGAIN;
1044
1045   memmove (buf, &msg, sizeof (MSG));
1046   *bytes_read = sizeof (MSG);
1047
1048   return G_IO_STATUS_NORMAL;
1049 }
1050
1051 static GIOStatus
1052 g_io_win32_msg_write (GIOChannel  *channel,
1053                       const gchar *buf,
1054                       gsize        count,
1055                       gsize       *bytes_written,
1056                       GError     **err)
1057 {
1058   GIOWin32Channel *win32_channel = (GIOWin32Channel *)channel;
1059   MSG msg;
1060
1061   if (count != sizeof (MSG))
1062     {
1063       g_set_error_literal (err, G_IO_CHANNEL_ERROR, G_IO_CHANNEL_ERROR_INVAL,
1064                            "Incorrect message size"); /* Informative enough error message? */
1065       return G_IO_STATUS_ERROR;
1066     }
1067
1068   /* In case of alignment problems */
1069   memmove (&msg, buf, sizeof (MSG));
1070   if (!PostMessage (win32_channel->hwnd, msg.message, msg.wParam, msg.lParam))
1071     {
1072       gchar *emsg = g_win32_error_message (GetLastError ());
1073       g_set_error_literal (err, G_IO_CHANNEL_ERROR, G_IO_CHANNEL_ERROR_FAILED, emsg);
1074       g_free (emsg);
1075       return G_IO_STATUS_ERROR;
1076     }
1077
1078   *bytes_written = sizeof (MSG);
1079
1080   return G_IO_STATUS_NORMAL;
1081 }
1082
1083 static GIOStatus
1084 g_io_win32_msg_close (GIOChannel *channel,
1085                       GError    **err)
1086 {
1087   /* Nothing to be done. Or should we set hwnd to some invalid value? */
1088
1089   return G_IO_STATUS_NORMAL;
1090 }
1091
1092 static void
1093 g_io_win32_free (GIOChannel *channel)
1094 {
1095   GIOWin32Channel *win32_channel = (GIOWin32Channel *)channel;
1096
1097   if (win32_channel->debug)
1098     g_print ("g_io_win32_free channel=%p fd=%d\n", channel, win32_channel->fd);
1099
1100   if (win32_channel->data_avail_event)
1101     CloseHandle (win32_channel->data_avail_event);
1102   if (win32_channel->space_avail_event)
1103     CloseHandle (win32_channel->space_avail_event);
1104   if (win32_channel->type == G_IO_WIN32_SOCKET)
1105     WSAEventSelect (win32_channel->fd, NULL, 0);
1106   DeleteCriticalSection (&win32_channel->mutex);
1107
1108   g_free (win32_channel->buffer);
1109   g_free (win32_channel);
1110 }
1111
1112 static GSource *
1113 g_io_win32_msg_create_watch (GIOChannel   *channel,
1114                              GIOCondition  condition)
1115 {
1116   GIOWin32Watch *watch;
1117   GSource *source;
1118
1119   source = g_source_new (&g_io_watch_funcs, sizeof (GIOWin32Watch));
1120   watch = (GIOWin32Watch *)source;
1121
1122   watch->channel = channel;
1123   g_io_channel_ref (channel);
1124
1125   watch->condition = condition;
1126
1127   watch->pollfd.fd = (gintptr) G_WIN32_MSG_HANDLE;
1128   watch->pollfd.events = condition;
1129
1130   g_source_add_poll (source, &watch->pollfd);
1131
1132   return source;
1133 }
1134
1135 static GIOStatus
1136 g_io_win32_fd_and_console_read (GIOChannel *channel,
1137                                 gchar      *buf,
1138                                 gsize       count,
1139                                 gsize      *bytes_read,
1140                                 GError    **err)
1141 {
1142   GIOWin32Channel *win32_channel = (GIOWin32Channel *)channel;
1143   gint result;
1144
1145   if (win32_channel->debug)
1146     g_print ("g_io_win32_fd_read: fd=%d count=%" G_GSIZE_FORMAT "\n",
1147              win32_channel->fd, count);
1148
1149   if (win32_channel->thread_id)
1150     {
1151       return buffer_read (win32_channel, buf, count, bytes_read, err);
1152     }
1153
1154   result = read (win32_channel->fd, buf, count);
1155
1156   if (win32_channel->debug)
1157     g_print ("g_io_win32_fd_read: read() => %d\n", result);
1158
1159   if (result < 0)
1160     {
1161       *bytes_read = 0;
1162
1163       switch (errno)
1164         {
1165 #ifdef EAGAIN
1166         case EAGAIN:
1167           return G_IO_STATUS_AGAIN;
1168 #endif
1169         default:
1170           g_set_error_literal (err, G_IO_CHANNEL_ERROR,
1171                                g_io_channel_error_from_errno (errno),
1172                                g_strerror (errno));
1173           return G_IO_STATUS_ERROR;
1174         }
1175     }
1176
1177   *bytes_read = result;
1178
1179   return (result > 0) ? G_IO_STATUS_NORMAL : G_IO_STATUS_EOF;
1180 }
1181
1182 static GIOStatus
1183 g_io_win32_fd_and_console_write (GIOChannel  *channel,
1184                                  const gchar *buf,
1185                                  gsize        count,
1186                                  gsize       *bytes_written,
1187                                  GError     **err)
1188 {
1189   GIOWin32Channel *win32_channel = (GIOWin32Channel *)channel;
1190   gint result;
1191
1192   if (win32_channel->thread_id)
1193     {
1194       return buffer_write (win32_channel, buf, count, bytes_written, err);
1195     }
1196
1197   result = write (win32_channel->fd, buf, count);
1198   if (win32_channel->debug)
1199     g_print ("g_io_win32_fd_write: fd=%d count=%" G_GSIZE_FORMAT " => %d\n",
1200              win32_channel->fd, count, result);
1201
1202   if (result < 0)
1203     {
1204       *bytes_written = 0;
1205
1206       switch (errno)
1207         {
1208 #ifdef EAGAIN
1209         case EAGAIN:
1210           return G_IO_STATUS_AGAIN;
1211 #endif
1212         default:
1213           g_set_error_literal (err, G_IO_CHANNEL_ERROR,
1214                                g_io_channel_error_from_errno (errno),
1215                                g_strerror (errno));
1216           return G_IO_STATUS_ERROR;
1217         }
1218     }
1219
1220   *bytes_written = result;
1221
1222   return G_IO_STATUS_NORMAL;
1223 }
1224
1225 static GIOStatus
1226 g_io_win32_fd_seek (GIOChannel *channel,
1227                     gint64      offset,
1228                     GSeekType   type,
1229                     GError    **err)
1230 {
1231   GIOWin32Channel *win32_channel = (GIOWin32Channel *)channel;
1232   int whence;
1233   off_t tmp_offset;
1234   off_t result;
1235
1236   switch (type)
1237     {
1238     case G_SEEK_SET:
1239       whence = SEEK_SET;
1240       break;
1241     case G_SEEK_CUR:
1242       whence = SEEK_CUR;
1243       break;
1244     case G_SEEK_END:
1245       whence = SEEK_END;
1246       break;
1247     default:
1248       whence = -1; /* Keep the compiler quiet */
1249       g_assert_not_reached ();
1250       abort ();
1251     }
1252
1253   tmp_offset = offset;
1254   if (tmp_offset != offset)
1255     {
1256       g_set_error_literal (err, G_IO_CHANNEL_ERROR,
1257                            g_io_channel_error_from_errno (EINVAL),
1258                            g_strerror (EINVAL));
1259       return G_IO_STATUS_ERROR;
1260     }
1261
1262   result = lseek (win32_channel->fd, tmp_offset, whence);
1263
1264   if (result < 0)
1265     {
1266       g_set_error_literal (err, G_IO_CHANNEL_ERROR,
1267                            g_io_channel_error_from_errno (errno),
1268                            g_strerror (errno));
1269       return G_IO_STATUS_ERROR;
1270     }
1271
1272   return G_IO_STATUS_NORMAL;
1273 }
1274
1275 static GIOStatus
1276 g_io_win32_fd_close (GIOChannel *channel,
1277                      GError    **err)
1278 {
1279   GIOWin32Channel *win32_channel = (GIOWin32Channel *)channel;
1280
1281   if (win32_channel->debug)
1282     g_print ("g_io_win32_fd_close: thread=%#x: fd=%d\n",
1283              win32_channel->thread_id,
1284              win32_channel->fd);
1285   LOCK (win32_channel->mutex);
1286   if (win32_channel->running)
1287     {
1288       if (win32_channel->debug)
1289         g_print ("thread %#x: running, marking fd %d for later close\n",
1290                  win32_channel->thread_id, win32_channel->fd);
1291       win32_channel->running = FALSE;
1292       win32_channel->needs_close = TRUE;
1293       if (win32_channel->direction == 0)
1294         SetEvent (win32_channel->data_avail_event);
1295       else
1296         SetEvent (win32_channel->space_avail_event);
1297     }
1298   else
1299     {
1300       if (win32_channel->debug)
1301         g_print ("closing fd %d\n", win32_channel->fd);
1302       close (win32_channel->fd);
1303       if (win32_channel->debug)
1304         g_print ("closed fd %d, setting to -1\n",
1305                  win32_channel->fd);
1306       win32_channel->fd = -1;
1307     }
1308   UNLOCK (win32_channel->mutex);
1309
1310   /* FIXME error detection? */
1311
1312   return G_IO_STATUS_NORMAL;
1313 }
1314
1315 static GSource *
1316 g_io_win32_fd_create_watch (GIOChannel    *channel,
1317                             GIOCondition   condition)
1318 {
1319   GIOWin32Channel *win32_channel = (GIOWin32Channel *)channel;
1320   GSource *source = g_source_new (&g_io_watch_funcs, sizeof (GIOWin32Watch));
1321   GIOWin32Watch *watch = (GIOWin32Watch *)source;
1322
1323   watch->channel = channel;
1324   g_io_channel_ref (channel);
1325
1326   watch->condition = condition;
1327
1328   if (win32_channel->data_avail_event == NULL)
1329     create_events (win32_channel);
1330
1331   watch->pollfd.fd = (gintptr) win32_channel->data_avail_event;
1332   watch->pollfd.events = condition;
1333
1334   if (win32_channel->debug)
1335     g_print ("g_io_win32_fd_create_watch: channel=%p fd=%d condition={%s} event=%p\n",
1336              channel, win32_channel->fd,
1337              condition_to_string (condition), (HANDLE) watch->pollfd.fd);
1338
1339   LOCK (win32_channel->mutex);
1340   if (win32_channel->thread_id == 0)
1341     {
1342       if (condition & G_IO_IN)
1343         create_thread (win32_channel, condition, read_thread);
1344       else if (condition & G_IO_OUT)
1345         create_thread (win32_channel, condition, write_thread);
1346     }
1347
1348   g_source_add_poll (source, &watch->pollfd);
1349   UNLOCK (win32_channel->mutex);
1350
1351   return source;
1352 }
1353
1354 static GIOStatus
1355 g_io_win32_console_close (GIOChannel *channel,
1356                           GError    **err)
1357 {
1358   GIOWin32Channel *win32_channel = (GIOWin32Channel *)channel;
1359
1360   if (close (win32_channel->fd) < 0)
1361     {
1362       g_set_error_literal (err, G_IO_CHANNEL_ERROR,
1363                            g_io_channel_error_from_errno (errno),
1364                            g_strerror (errno));
1365       return G_IO_STATUS_ERROR;
1366     }
1367
1368   return G_IO_STATUS_NORMAL;
1369 }
1370
1371 static GSource *
1372 g_io_win32_console_create_watch (GIOChannel    *channel,
1373                                  GIOCondition   condition)
1374 {
1375   GIOWin32Channel *win32_channel = (GIOWin32Channel *)channel;
1376   GSource *source = g_source_new (&g_io_watch_funcs, sizeof (GIOWin32Watch));
1377   GIOWin32Watch *watch = (GIOWin32Watch *)source;
1378
1379   watch->channel = channel;
1380   g_io_channel_ref (channel);
1381
1382   watch->condition = condition;
1383
1384   watch->pollfd.fd = _get_osfhandle (win32_channel->fd);
1385   watch->pollfd.events = condition;
1386
1387   g_source_add_poll (source, &watch->pollfd);
1388
1389   return source;
1390 }
1391
1392 static GIOStatus
1393 g_io_win32_sock_read (GIOChannel *channel,
1394                       gchar      *buf,
1395                       gsize       count,
1396                       gsize      *bytes_read,
1397                       GError    **err)
1398 {
1399   GIOWin32Channel *win32_channel = (GIOWin32Channel *)channel;
1400   gint result;
1401   GIOChannelError error;
1402   int winsock_error;
1403
1404   if (win32_channel->debug)
1405     g_print ("g_io_win32_sock_read: channel=%p sock=%d count=%" G_GSIZE_FORMAT,
1406              channel, win32_channel->fd, count);
1407
1408   result = recv (win32_channel->fd, buf, count, 0);
1409   if (result == SOCKET_ERROR)
1410     winsock_error = WSAGetLastError ();
1411
1412   if (win32_channel->debug)
1413     g_print (" recv=%d", result);
1414
1415   if (result == SOCKET_ERROR)
1416     {
1417       gchar *emsg = g_win32_error_message (winsock_error);
1418
1419       if (win32_channel->debug)
1420         g_print (" %s\n", emsg);
1421
1422       *bytes_read = 0;
1423
1424       switch (winsock_error)
1425         {
1426         case WSAEINVAL:
1427           error = G_IO_CHANNEL_ERROR_INVAL;
1428           break;
1429         case WSAEWOULDBLOCK:
1430           g_free (emsg);
1431           return G_IO_STATUS_AGAIN;
1432         default:
1433           error = G_IO_CHANNEL_ERROR_FAILED;
1434           break;
1435         }
1436       g_set_error_literal (err, G_IO_CHANNEL_ERROR, error, emsg);
1437       g_free (emsg);
1438
1439       return G_IO_STATUS_ERROR;
1440     }
1441   else
1442     {
1443       if (win32_channel->debug)
1444         g_print ("\n");
1445       *bytes_read = result;
1446       if (result == 0)
1447         return G_IO_STATUS_EOF;
1448       else
1449         return G_IO_STATUS_NORMAL;
1450     }
1451 }
1452
1453 static GIOStatus
1454 g_io_win32_sock_write (GIOChannel  *channel,
1455                        const gchar *buf,
1456                        gsize        count,
1457                        gsize       *bytes_written,
1458                        GError     **err)
1459 {
1460   GIOWin32Channel *win32_channel = (GIOWin32Channel *)channel;
1461   gint result;
1462   GIOChannelError error;
1463   int winsock_error;
1464
1465   if (win32_channel->debug)
1466     g_print ("g_io_win32_sock_write: channel=%p sock=%d count=%" G_GSIZE_FORMAT,
1467              channel, win32_channel->fd, count);
1468
1469   result = send (win32_channel->fd, buf, count, 0);
1470   if (result == SOCKET_ERROR)
1471     winsock_error = WSAGetLastError ();
1472
1473   if (win32_channel->debug)
1474     g_print (" send=%d", result);
1475
1476   if (result == SOCKET_ERROR)
1477     {
1478       gchar *emsg = g_win32_error_message (winsock_error);
1479
1480       if (win32_channel->debug)
1481         g_print (" %s\n", emsg);
1482
1483       *bytes_written = 0;
1484
1485       switch (winsock_error)
1486         {
1487         case WSAEINVAL:
1488           error = G_IO_CHANNEL_ERROR_INVAL;
1489           break;
1490         case WSAEWOULDBLOCK:
1491           win32_channel->write_would_have_blocked = TRUE;
1492           win32_channel->last_events = 0;
1493           g_free (emsg);
1494           return G_IO_STATUS_AGAIN;
1495         default:
1496           error = G_IO_CHANNEL_ERROR_FAILED;
1497           break;
1498         }
1499       g_set_error_literal (err, G_IO_CHANNEL_ERROR, error, emsg);
1500       g_free (emsg);
1501
1502       return G_IO_STATUS_ERROR;
1503     }
1504   else
1505     {
1506       if (win32_channel->debug)
1507         g_print ("\n");
1508       *bytes_written = result;
1509       win32_channel->write_would_have_blocked = FALSE;
1510
1511       return G_IO_STATUS_NORMAL;
1512     }
1513 }
1514
1515 static GIOStatus
1516 g_io_win32_sock_close (GIOChannel *channel,
1517                        GError    **err)
1518 {
1519   GIOWin32Channel *win32_channel = (GIOWin32Channel *)channel;
1520
1521   if (win32_channel->fd != -1)
1522     {
1523       if (win32_channel->debug)
1524         g_print ("g_io_win32_sock_close: channel=%p sock=%d\n",
1525                  channel, win32_channel->fd);
1526
1527       closesocket (win32_channel->fd);
1528       win32_channel->fd = -1;
1529     }
1530
1531   /* FIXME error detection? */
1532
1533   return G_IO_STATUS_NORMAL;
1534 }
1535
1536 static GSource *
1537 g_io_win32_sock_create_watch (GIOChannel    *channel,
1538                               GIOCondition   condition)
1539 {
1540   GIOWin32Channel *win32_channel = (GIOWin32Channel *)channel;
1541   GSource *source = g_source_new (&g_io_watch_funcs, sizeof (GIOWin32Watch));
1542   GIOWin32Watch *watch = (GIOWin32Watch *)source;
1543
1544   watch->channel = channel;
1545   g_io_channel_ref (channel);
1546
1547   watch->condition = condition;
1548
1549   if (win32_channel->event == 0)
1550     win32_channel->event = WSACreateEvent ();
1551
1552   watch->pollfd.fd = (gintptr) win32_channel->event;
1553   watch->pollfd.events = condition;
1554
1555   if (win32_channel->debug)
1556     g_print ("g_io_win32_sock_create_watch: channel=%p sock=%d event=%p condition={%s}\n",
1557              channel, win32_channel->fd, (HANDLE) watch->pollfd.fd,
1558              condition_to_string (watch->condition));
1559
1560   g_source_add_poll (source, &watch->pollfd);
1561
1562   return source;
1563 }
1564
1565 GIOChannel *
1566 g_io_channel_new_file (const gchar  *filename,
1567                        const gchar  *mode,
1568                        GError      **error)
1569 {
1570   int fid, flags, pmode;
1571   GIOChannel *channel;
1572
1573   enum { /* Cheesy hack */
1574     MODE_R = 1 << 0,
1575     MODE_W = 1 << 1,
1576     MODE_A = 1 << 2,
1577     MODE_PLUS = 1 << 3,
1578   } mode_num;
1579
1580   g_return_val_if_fail (filename != NULL, NULL);
1581   g_return_val_if_fail (mode != NULL, NULL);
1582   g_return_val_if_fail ((error == NULL) || (*error == NULL), NULL);
1583
1584   switch (mode[0])
1585     {
1586       case 'r':
1587         mode_num = MODE_R;
1588         break;
1589       case 'w':
1590         mode_num = MODE_W;
1591         break;
1592       case 'a':
1593         mode_num = MODE_A;
1594         break;
1595       default:
1596         g_warning ("Invalid GIOFileMode %s.\n", mode);
1597         return NULL;
1598     }
1599
1600   switch (mode[1])
1601     {
1602       case '\0':
1603         break;
1604       case '+':
1605         if (mode[2] == '\0')
1606           {
1607             mode_num |= MODE_PLUS;
1608             break;
1609           }
1610         /* Fall through */
1611       default:
1612         g_warning ("Invalid GIOFileMode %s.\n", mode);
1613         return NULL;
1614     }
1615
1616   switch (mode_num)
1617     {
1618       case MODE_R:
1619         flags = O_RDONLY;
1620         pmode = _S_IREAD;
1621         break;
1622       case MODE_W:
1623         flags = O_WRONLY | O_TRUNC | O_CREAT;
1624         pmode = _S_IWRITE;
1625         break;
1626       case MODE_A:
1627         flags = O_WRONLY | O_APPEND | O_CREAT;
1628         pmode = _S_IWRITE;
1629         break;
1630       case MODE_R | MODE_PLUS:
1631         flags = O_RDWR;
1632         pmode = _S_IREAD | _S_IWRITE;
1633         break;
1634       case MODE_W | MODE_PLUS:
1635         flags = O_RDWR | O_TRUNC | O_CREAT;
1636         pmode = _S_IREAD | _S_IWRITE;
1637         break;
1638       case MODE_A | MODE_PLUS:
1639         flags = O_RDWR | O_APPEND | O_CREAT;
1640         pmode = _S_IREAD | _S_IWRITE;
1641         break;
1642       default:
1643         g_assert_not_reached ();
1644         abort ();
1645     }
1646
1647   /* always open 'untranslated' */
1648   fid = g_open (filename, flags | _O_BINARY, pmode);
1649
1650   if (g_io_win32_get_debug_flag ())
1651     {
1652       g_print ("g_io_channel_win32_new_file: open(\"%s\",", filename);
1653       g_win32_print_access_mode (flags|_O_BINARY);
1654       g_print (",%#o)=%d\n", pmode, fid);
1655     }
1656
1657   if (fid < 0)
1658     {
1659       g_set_error_literal (error, G_FILE_ERROR,
1660                            g_file_error_from_errno (errno),
1661                            g_strerror (errno));
1662       return (GIOChannel *)NULL;
1663     }
1664
1665   channel = g_io_channel_win32_new_fd (fid);
1666
1667   /* XXX: move this to g_io_channel_win32_new_fd () */
1668   channel->close_on_unref = TRUE;
1669   channel->is_seekable = TRUE;
1670
1671   /* g_io_channel_win32_new_fd sets is_readable and is_writeable to
1672    * correspond to actual readability/writeability. Set to FALSE those
1673    * that mode doesn't allow
1674    */
1675   switch (mode_num)
1676     {
1677       case MODE_R:
1678         channel->is_writeable = FALSE;
1679         break;
1680       case MODE_W:
1681       case MODE_A:
1682         channel->is_readable = FALSE;
1683         break;
1684       case MODE_R | MODE_PLUS:
1685       case MODE_W | MODE_PLUS:
1686       case MODE_A | MODE_PLUS:
1687         break;
1688       default:
1689         g_assert_not_reached ();
1690         abort ();
1691     }
1692
1693   return channel;
1694 }
1695
1696 #if !defined (_WIN64)
1697
1698 #undef g_io_channel_new_file
1699
1700 /* Binary compatibility version. Not for newly compiled code. */
1701
1702 GIOChannel *
1703 g_io_channel_new_file (const gchar  *filename,
1704                        const gchar  *mode,
1705                        GError      **error)
1706 {
1707   gchar *utf8_filename = g_locale_to_utf8 (filename, -1, NULL, NULL, error);
1708   GIOChannel *retval;
1709
1710   if (utf8_filename == NULL)
1711     return NULL;
1712
1713   retval = g_io_channel_new_file_utf8 (utf8_filename, mode, error);
1714
1715   g_free (utf8_filename);
1716
1717   return retval;
1718 }
1719
1720 #endif
1721
1722 static GIOStatus
1723 g_io_win32_unimpl_set_flags (GIOChannel *channel,
1724                              GIOFlags    flags,
1725                              GError    **err)
1726 {
1727   GIOWin32Channel *win32_channel = (GIOWin32Channel *)channel;
1728
1729   if (win32_channel->debug)
1730     {
1731       g_print ("g_io_win32_unimpl_set_flags: ");
1732       g_win32_print_gioflags (flags);
1733       g_print ("\n");
1734     }
1735
1736   g_set_error_literal (err, G_IO_CHANNEL_ERROR,
1737                        G_IO_CHANNEL_ERROR_FAILED,
1738                        "Not implemented on Win32");
1739
1740   return G_IO_STATUS_ERROR;
1741 }
1742
1743 static GIOFlags
1744 g_io_win32_fd_get_flags_internal (GIOChannel  *channel,
1745                                   struct stat *st)
1746 {
1747   GIOWin32Channel *win32_channel = (GIOWin32Channel *) channel;
1748   gchar c;
1749   DWORD count;
1750
1751   if (st->st_mode & _S_IFIFO)
1752     {
1753       channel->is_readable =
1754         (PeekNamedPipe ((HANDLE) _get_osfhandle (win32_channel->fd), &c, 0, &count, NULL, NULL) != 0) || GetLastError () == ERROR_BROKEN_PIPE;
1755       channel->is_writeable =
1756         (WriteFile ((HANDLE) _get_osfhandle (win32_channel->fd), &c, 0, &count, NULL) != 0);
1757       channel->is_seekable  = FALSE;
1758     }
1759   else
1760     {
1761       channel->is_readable =
1762         (ReadFile ((HANDLE) _get_osfhandle (win32_channel->fd), &c, 0, &count, NULL) != 0);
1763       channel->is_writeable =
1764         (WriteFile ((HANDLE) _get_osfhandle (win32_channel->fd), &c, 0, &count, NULL) != 0);
1765       channel->is_seekable = TRUE;
1766     }
1767
1768   /* XXX: G_IO_FLAG_APPEND */
1769   /* XXX: G_IO_FLAG_NONBLOCK */
1770
1771   return 0;
1772 }
1773
1774 static GIOFlags
1775 g_io_win32_fd_get_flags (GIOChannel *channel)
1776 {
1777   struct stat st;
1778   GIOWin32Channel *win32_channel = (GIOWin32Channel *)channel;
1779
1780   g_return_val_if_fail (win32_channel != NULL, 0);
1781   g_return_val_if_fail (win32_channel->type == G_IO_WIN32_FILE_DESC, 0);
1782
1783   if (0 == fstat (win32_channel->fd, &st))
1784     return g_io_win32_fd_get_flags_internal (channel, &st);
1785   else
1786     return 0;
1787 }
1788
1789 static GIOFlags
1790 g_io_win32_console_get_flags_internal (GIOChannel  *channel)
1791 {
1792   GIOWin32Channel *win32_channel = (GIOWin32Channel *) channel;
1793   HANDLE handle = (HANDLE) _get_osfhandle (win32_channel->fd);
1794   gchar c;
1795   DWORD count;
1796   INPUT_RECORD record;
1797
1798   channel->is_readable = PeekConsoleInput (handle, &record, 1, &count);
1799   channel->is_writeable = WriteFile (handle, &c, 0, &count, NULL);
1800   channel->is_seekable = FALSE;
1801
1802   return 0;
1803 }
1804
1805 static GIOFlags
1806 g_io_win32_console_get_flags (GIOChannel *channel)
1807 {
1808   GIOWin32Channel *win32_channel = (GIOWin32Channel *)channel;
1809
1810   g_return_val_if_fail (win32_channel != NULL, 0);
1811   g_return_val_if_fail (win32_channel->type == G_IO_WIN32_CONSOLE, 0);
1812
1813   return g_io_win32_console_get_flags_internal (channel);
1814 }
1815
1816 static GIOFlags
1817 g_io_win32_msg_get_flags (GIOChannel *channel)
1818 {
1819   return 0;
1820 }
1821
1822 static GIOStatus
1823 g_io_win32_sock_set_flags (GIOChannel *channel,
1824                            GIOFlags    flags,
1825                            GError    **err)
1826 {
1827   GIOWin32Channel *win32_channel = (GIOWin32Channel *)channel;
1828   u_long arg;
1829
1830   if (win32_channel->debug)
1831     {
1832       g_print ("g_io_win32_sock_set_flags: ");
1833       g_win32_print_gioflags (flags);
1834       g_print ("\n");
1835     }
1836
1837   if (flags & G_IO_FLAG_NONBLOCK)
1838     {
1839       arg = 1;
1840       if (ioctlsocket (win32_channel->fd, FIONBIO, &arg) == SOCKET_ERROR)
1841         {
1842           gchar *emsg = g_win32_error_message (WSAGetLastError ());
1843
1844           g_set_error_literal (err, G_IO_CHANNEL_ERROR,
1845                                G_IO_CHANNEL_ERROR_FAILED,
1846                                emsg);
1847           g_free (emsg);
1848
1849           return G_IO_STATUS_ERROR;
1850         }
1851     }
1852   else
1853     {
1854       arg = 0;
1855       if (ioctlsocket (win32_channel->fd, FIONBIO, &arg) == SOCKET_ERROR)
1856         {
1857           gchar *emsg = g_win32_error_message (WSAGetLastError ());
1858
1859           g_set_error_literal (err, G_IO_CHANNEL_ERROR,
1860                                G_IO_CHANNEL_ERROR_FAILED,
1861                                emsg);
1862           g_free (emsg);
1863
1864           return G_IO_STATUS_ERROR;
1865         }
1866     }
1867
1868   return G_IO_STATUS_NORMAL;
1869 }
1870
1871 static GIOFlags
1872 g_io_win32_sock_get_flags (GIOChannel *channel)
1873 {
1874   /* Could we do something here? */
1875   return 0;
1876 }
1877
1878 static GIOFuncs win32_channel_msg_funcs = {
1879   g_io_win32_msg_read,
1880   g_io_win32_msg_write,
1881   NULL,
1882   g_io_win32_msg_close,
1883   g_io_win32_msg_create_watch,
1884   g_io_win32_free,
1885   g_io_win32_unimpl_set_flags,
1886   g_io_win32_msg_get_flags,
1887 };
1888
1889 static GIOFuncs win32_channel_fd_funcs = {
1890   g_io_win32_fd_and_console_read,
1891   g_io_win32_fd_and_console_write,
1892   g_io_win32_fd_seek,
1893   g_io_win32_fd_close,
1894   g_io_win32_fd_create_watch,
1895   g_io_win32_free,
1896   g_io_win32_unimpl_set_flags,
1897   g_io_win32_fd_get_flags,
1898 };
1899
1900 static GIOFuncs win32_channel_console_funcs = {
1901   g_io_win32_fd_and_console_read,
1902   g_io_win32_fd_and_console_write,
1903   NULL,
1904   g_io_win32_console_close,
1905   g_io_win32_console_create_watch,
1906   g_io_win32_free,
1907   g_io_win32_unimpl_set_flags,
1908   g_io_win32_console_get_flags,
1909 };
1910
1911 static GIOFuncs win32_channel_sock_funcs = {
1912   g_io_win32_sock_read,
1913   g_io_win32_sock_write,
1914   NULL,
1915   g_io_win32_sock_close,
1916   g_io_win32_sock_create_watch,
1917   g_io_win32_free,
1918   g_io_win32_sock_set_flags,
1919   g_io_win32_sock_get_flags,
1920 };
1921
1922 GIOChannel *
1923 #if GLIB_SIZEOF_VOID_P == 8
1924 g_io_channel_win32_new_messages (gsize hwnd)
1925 #else
1926 g_io_channel_win32_new_messages (guint hwnd)
1927 #endif
1928 {
1929   GIOWin32Channel *win32_channel = g_new (GIOWin32Channel, 1);
1930   GIOChannel *channel = (GIOChannel *)win32_channel;
1931
1932   g_io_channel_init (channel);
1933   g_io_channel_win32_init (win32_channel);
1934   if (win32_channel->debug)
1935     g_print ("g_io_channel_win32_new_messages: channel=%p hwnd=%p\n",
1936              channel, (HWND) hwnd);
1937   channel->funcs = &win32_channel_msg_funcs;
1938   win32_channel->type = G_IO_WIN32_WINDOWS_MESSAGES;
1939   win32_channel->hwnd = (HWND) hwnd;
1940
1941   /* XXX: check this. */
1942   channel->is_readable = IsWindow (win32_channel->hwnd);
1943   channel->is_writeable = IsWindow (win32_channel->hwnd);
1944
1945   channel->is_seekable = FALSE;
1946
1947   return channel;
1948 }
1949
1950 static GIOChannel *
1951 g_io_channel_win32_new_fd_internal (gint         fd,
1952                                     struct stat *st)
1953 {
1954   GIOWin32Channel *win32_channel;
1955   GIOChannel *channel;
1956
1957   win32_channel = g_new (GIOWin32Channel, 1);
1958   channel = (GIOChannel *)win32_channel;
1959
1960   g_io_channel_init (channel);
1961   g_io_channel_win32_init (win32_channel);
1962
1963   win32_channel->fd = fd;
1964
1965   if (win32_channel->debug)
1966     g_print ("g_io_channel_win32_new_fd: channel=%p fd=%u\n",
1967              channel, fd);
1968
1969   if (st->st_mode & _S_IFCHR) /* console */
1970     {
1971       channel->funcs = &win32_channel_console_funcs;
1972       win32_channel->type = G_IO_WIN32_CONSOLE;
1973       g_io_win32_console_get_flags_internal (channel);
1974     }
1975   else
1976     {
1977       channel->funcs = &win32_channel_fd_funcs;
1978       win32_channel->type = G_IO_WIN32_FILE_DESC;
1979       g_io_win32_fd_get_flags_internal (channel, st);
1980     }
1981
1982   return channel;
1983 }
1984
1985 GIOChannel *
1986 g_io_channel_win32_new_fd (gint fd)
1987 {
1988   struct stat st;
1989
1990   if (fstat (fd, &st) == -1)
1991     {
1992       g_warning ("g_io_channel_win32_new_fd: %d isn't an open file descriptor in the C library GLib uses.", fd);
1993       return NULL;
1994     }
1995
1996   return g_io_channel_win32_new_fd_internal (fd, &st);
1997 }
1998
1999 gint
2000 g_io_channel_win32_get_fd (GIOChannel *channel)
2001 {
2002   GIOWin32Channel *win32_channel = (GIOWin32Channel *)channel;
2003
2004   return win32_channel->fd;
2005 }
2006
2007 GIOChannel *
2008 g_io_channel_win32_new_socket (int socket)
2009 {
2010   GIOWin32Channel *win32_channel = g_new (GIOWin32Channel, 1);
2011   GIOChannel *channel = (GIOChannel *)win32_channel;
2012
2013   g_io_channel_init (channel);
2014   g_io_channel_win32_init (win32_channel);
2015   if (win32_channel->debug)
2016     g_print ("g_io_channel_win32_new_socket: channel=%p sock=%d\n",
2017              channel, socket);
2018   channel->funcs = &win32_channel_sock_funcs;
2019   win32_channel->type = G_IO_WIN32_SOCKET;
2020   win32_channel->fd = socket;
2021
2022   channel->is_readable = TRUE;
2023   channel->is_writeable = TRUE;
2024   channel->is_seekable = FALSE;
2025
2026   return channel;
2027 }
2028
2029 GIOChannel *
2030 g_io_channel_unix_new (gint fd)
2031 {
2032   gboolean is_fd, is_socket;
2033   struct stat st;
2034   int optval, optlen;
2035
2036   is_fd = (fstat (fd, &st) == 0);
2037
2038   optlen = sizeof (optval);
2039   is_socket = (getsockopt (fd, SOL_SOCKET, SO_TYPE, (char *) &optval, &optlen) != SOCKET_ERROR);
2040
2041   if (is_fd && is_socket)
2042     g_warning ("g_io_channel_unix_new: %d is both a file descriptor and a socket. File descriptor interpretation assumed. To avoid ambiguity, call either g_io_channel_win32_new_fd() or g_io_channel_win32_new_socket() instead.", fd);
2043
2044   if (is_fd)
2045     return g_io_channel_win32_new_fd_internal (fd, &st);
2046
2047   if (is_socket)
2048     return g_io_channel_win32_new_socket(fd);
2049
2050   g_warning ("g_io_channel_unix_new: %d is neither a file descriptor or a socket.", fd);
2051
2052   return NULL;
2053 }
2054
2055 gint
2056 g_io_channel_unix_get_fd (GIOChannel *channel)
2057 {
2058   return g_io_channel_win32_get_fd (channel);
2059 }
2060
2061 void
2062 g_io_channel_win32_set_debug (GIOChannel *channel,
2063                               gboolean    flag)
2064 {
2065   GIOWin32Channel *win32_channel = (GIOWin32Channel *)channel;
2066
2067   win32_channel->debug = flag;
2068 }
2069
2070 gint
2071 g_io_channel_win32_poll (GPollFD *fds,
2072                          gint     n_fds,
2073                          gint     timeout)
2074 {
2075   int result;
2076
2077   g_return_val_if_fail (n_fds >= 0, 0);
2078
2079   result = (*g_main_context_get_poll_func (NULL)) (fds, n_fds, timeout);
2080
2081   return result;
2082 }
2083
2084 void
2085 g_io_channel_win32_make_pollfd (GIOChannel   *channel,
2086                                 GIOCondition  condition,
2087                                 GPollFD      *fd)
2088 {
2089   GIOWin32Channel *win32_channel = (GIOWin32Channel *)channel;
2090
2091   switch (win32_channel->type)
2092     {
2093     case G_IO_WIN32_FILE_DESC:
2094       if (win32_channel->data_avail_event == NULL)
2095         create_events (win32_channel);
2096
2097       fd->fd = (gintptr) win32_channel->data_avail_event;
2098
2099       if (win32_channel->thread_id == 0)
2100         {
2101           /* Is it meaningful for a file descriptor to be polled for
2102            * both IN and OUT? For what kind of file descriptor would
2103            * that be? Doesn't seem to make sense, in practise the file
2104            * descriptors handled here are always read or write ends of
2105            * pipes surely, and thus unidirectional.
2106            */
2107           if (condition & G_IO_IN)
2108             create_thread (win32_channel, condition, read_thread);
2109           else if (condition & G_IO_OUT)
2110             create_thread (win32_channel, condition, write_thread);
2111         }
2112       break;
2113
2114     case G_IO_WIN32_CONSOLE:
2115       fd->fd = _get_osfhandle (win32_channel->fd);
2116       break;
2117
2118     case G_IO_WIN32_SOCKET:
2119       fd->fd = (gintptr) WSACreateEvent ();
2120       break;
2121
2122     case G_IO_WIN32_WINDOWS_MESSAGES:
2123       fd->fd = G_WIN32_MSG_HANDLE;
2124       break;
2125
2126     default:
2127       g_assert_not_reached ();
2128       abort ();
2129     }
2130
2131   fd->events = condition;
2132 }
2133
2134 /* Binary compatibility */
2135 GIOChannel *
2136 g_io_channel_win32_new_stream_socket (int socket)
2137 {
2138   return g_io_channel_win32_new_socket (socket);
2139 }
2140
2141 #define __G_IO_WIN32_C__
2142 #include "galiasdef.c"