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