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 /* Define this to get (very) verbose logging of all channels */
  33 /* #define G_IO_WIN32_DEBUG */
  34
  35 #include "config.h"
  36
  37 #include "galias.h"
  38 #include "glib.h"
  39
  40 #include <stdlib.h>
  41 #include <windows.h>
  42 #include <winsock2.h>
  43 #include <fcntl.h>
  44 #include <io.h>
  45 #include <process.h>
  46 #include <errno.h>
  47 #include <sys/stat.h>
  48
  49 #include "gstdio.h"
  50 #include "glibintl.h"
  51
  52 typedef struct _GIOWin32Channel GIOWin32Channel;
  53 typedef struct _GIOWin32Watch GIOWin32Watch;
  54
  55 #define BUFFER_SIZE 4096
  56
  57 typedef enum {
  58   G_IO_WIN32_WINDOWS_MESSAGES,  /* Windows messages */
  59   G_IO_WIN32_FILE_DESC,         /* Unix-like file descriptors from
  60                                  * _open() or _pipe(). Read with read().
  61                                  * Have to create separate thread to read.
  62                                  */
  63   G_IO_WIN32_SOCKET             /* Sockets. A separate thread is blocked
  64                                  * in select() most of the time.
  65                                  */
  66 } GIOWin32ChannelType;
  67
  68 struct _GIOWin32Channel {
  69   GIOChannel channel;
  70   gint fd;                      /* Either a Unix-like file handle as provided
  71                                  * by the Microsoft C runtime, or a SOCKET
  72                                  * as provided by WinSock.
  73                                  */
  74   GIOWin32ChannelType type;
  75
  76   gboolean debug;
  77
  78   CRITICAL_SECTION mutex;
  79
  80   /* This is used by G_IO_WIN32_WINDOWS_MESSAGES channels */
  81   HWND hwnd;                    /* handle of window, or NULL */
  82
  83   /* Following fields are used by both fd and socket channels. */
  84   gboolean running;             /* Is reader thread running. FALSE if
  85                                  * EOF has been reached.
  86                                  */
  87   gboolean needs_close;         /* If the channel has been closed while
  88                                  * the reader thread was still running.
  89                                  */
  90   guint thread_id;              /* If non-NULL has a reader thread, or has
  91                                  * had.*/
  92   HANDLE data_avail_event;
  93
  94   gushort revents;
  95
  96   /* Following fields used by fd channels for input */
  97
  98   /* Data is kept in a circular buffer. To be able to distinguish between
  99    * empty and full buffer, we cannot fill it completely, but have to
 100    * leave a one character gap.
 101    *
 102    * Data available is between indexes rdp and wrp-1 (modulo BUFFER_SIZE).
 103    *
 104    * Empty:    wrp == rdp
 105    * Full:     (wrp + 1) % BUFFER_SIZE == rdp
 106    * Partial:  otherwise
 107    */
 108   guchar *buffer;               /* (Circular) buffer */
 109   gint wrp, rdp;                /* Buffer indices for writing and reading */
 110   HANDLE space_avail_event;
 111
 112   /* Following fields used by socket channels */
 113   GSList *watches;
 114   HANDLE data_avail_noticed_event;
 115   gint reset_send; /* socket used to send data so select_thread() can reset/re-loop */
 116   gint reset_recv; /* socket used to recv data so select_thread() can reset/re-loop */
 117 };
 118
 119 #define LOCK(mutex) EnterCriticalSection (&mutex)
 120 #define UNLOCK(mutex) LeaveCriticalSection (&mutex)
 121
 122 struct _GIOWin32Watch {
 123   GSource       source;
 124   GPollFD       pollfd;
 125   GIOChannel   *channel;
 126   GIOCondition  condition;
 127 };
 128
 129 static void
 130 g_win32_print_access_mode (int flags)
 131 {
 132   g_print ("%s%s%s%s%s%s%s%s%s%s",
 133            ((flags & 0x3) == _O_RDWR ? "O_RDWR" :
 134             ((flags & 0x3) == _O_RDONLY ? "O_RDONLY" :
 135              ((flags & 0x3) == _O_WRONLY ? "O_WRONLY" : "0"))),
 136            (flags & _O_APPEND ? "|O_APPEND" : ""),
 137            (flags & _O_RANDOM ? "|O_RANDOM" : ""),
 138            (flags & _O_SEQUENTIAL ? "|O_SEQUENTIAL" : ""),
 139            (flags & _O_TEMPORARY ? "|O_TEMPORARY" : ""),
 140            (flags & _O_CREAT ? "|O_CREAT" : ""),
 141            (flags & _O_TRUNC ? "|O_TRUNC" : ""),
 142            (flags & _O_EXCL ? "|O_EXCL" : ""),
 143            (flags & _O_TEXT ? "|O_TEXT" : ""),
 144            (flags & _O_BINARY ? "|O_BINARY" : ""));
 145 }
 146
 147 static void
 148 g_win32_print_gioflags (GIOFlags flags)
 149 {
 150   char *bar = "";
 151
 152   if (flags & G_IO_FLAG_APPEND)
 153     bar = "|", g_print ("APPEND");
 154   if (flags & G_IO_FLAG_NONBLOCK)
 155     g_print ("%sNONBLOCK", bar), bar = "|";
 156   if (flags & G_IO_FLAG_IS_READABLE)
 157     g_print ("%sREADABLE", bar), bar = "|";
 158   if (flags & G_IO_FLAG_IS_WRITEABLE)
 159     g_print ("%sWRITEABLE", bar), bar = "|";
 160   if (flags & G_IO_FLAG_IS_SEEKABLE)
 161     g_print ("%sSEEKABLE", bar), bar = "|";
 162 }
 163
 164 static gboolean
 165 g_io_win32_get_debug_flag (void)
 166 {
 167 #ifdef G_IO_WIN32_DEBUG
 168   return TRUE;
 169 #else
 170   if (getenv ("G_IO_WIN32_DEBUG") != NULL)
 171     return TRUE;
 172   else
 173     return FALSE;
 174 #endif
 175 }
 176
 177 static void
 178 g_io_channel_win32_init (GIOWin32Channel *channel)
 179 {
 180   channel->debug = g_io_win32_get_debug_flag ();
 181   channel->buffer = NULL;
 182   channel->running = FALSE;
 183   channel->needs_close = FALSE;
 184   channel->thread_id = 0;
 185   channel->data_avail_event = NULL;
 186   channel->revents = 0;
 187   channel->space_avail_event = NULL;
 188   channel->reset_send = INVALID_SOCKET;
 189   channel->reset_recv = INVALID_SOCKET;
 190   channel->data_avail_noticed_event = NULL;
 191   channel->watches = NULL;
 192   InitializeCriticalSection (&channel->mutex);
 193 }
 194
 195 static void
 196 create_events (GIOWin32Channel *channel)
 197 {
 198   SECURITY_ATTRIBUTES sec_attrs;
 199
 200   sec_attrs.nLength = sizeof (SECURITY_ATTRIBUTES);
 201   sec_attrs.lpSecurityDescriptor = NULL;
 202   sec_attrs.bInheritHandle = FALSE;
 203
 204   /* The data available event is manual reset, the space available event
 205    * is automatic reset.
 206    */
 207   if (!(channel->data_avail_event = CreateEvent (&sec_attrs, TRUE, FALSE, NULL))
 208       || !(channel->space_avail_event = CreateEvent (&sec_attrs, FALSE, FALSE, NULL))
 209       || !(channel->data_avail_noticed_event = CreateEvent (&sec_attrs, FALSE, FALSE, NULL)))
 210     {
 211       gchar *emsg = g_win32_error_message (GetLastError ());
 212       g_error ("Error creating event: %s", emsg);
 213       g_free (emsg);
 214     }
 215 }
 216
 217 static unsigned __stdcall
 218 read_thread (void *parameter)
 219 {
 220   GIOWin32Channel *channel = parameter;
 221   guchar *buffer;
 222   guint nbytes;
 223
 224   g_io_channel_ref ((GIOChannel *)channel);
 225
 226   if (channel->debug)
 227     g_print ("read_thread %#x: start fd:%d, data_avail:%#x space_avail:%#x\n",
 228              channel->thread_id,
 229              channel->fd,
 230              (guint) channel->data_avail_event,
 231              (guint) channel->space_avail_event);
 232
 233   channel->buffer = g_malloc (BUFFER_SIZE);
 234   channel->rdp = channel->wrp = 0;
 235   channel->running = TRUE;
 236
 237   SetEvent (channel->space_avail_event);
 238
 239   LOCK (channel->mutex);
 240   while (channel->running)
 241     {
 242       if (channel->debug)
 243         g_print ("read_thread %#x: rdp=%d, wrp=%d\n",
 244                  channel->thread_id, channel->rdp, channel->wrp);
 245       if ((channel->wrp + 1) % BUFFER_SIZE == channel->rdp)
 246         {
 247           /* Buffer is full */
 248           if (channel->debug)
 249             g_print ("read_thread %#x: resetting space_avail\n",
 250                      channel->thread_id);
 251           ResetEvent (channel->space_avail_event);
 252           if (channel->debug)
 253             g_print ("read_thread %#x: waiting for space\n",
 254                      channel->thread_id);
 255           UNLOCK (channel->mutex);
 256           WaitForSingleObject (channel->space_avail_event, INFINITE);
 257           LOCK (channel->mutex);
 258           if (channel->debug)
 259             g_print ("read_thread %#x: rdp=%d, wrp=%d\n",
 260                      channel->thread_id, channel->rdp, channel->wrp);
 261         }
 262
 263       buffer = channel->buffer + channel->wrp;
 264
 265       /* Always leave at least one byte unused gap to be able to
 266        * distinguish between the full and empty condition...
 267        */
 268       nbytes = MIN ((channel->rdp + BUFFER_SIZE - channel->wrp - 1) % BUFFER_SIZE,
 269                     BUFFER_SIZE - channel->wrp);
 270
 271       if (channel->debug)
 272         g_print ("read_thread %#x: calling read() for %d bytes\n",
 273                  channel->thread_id, nbytes);
 274
 275       UNLOCK (channel->mutex);
 276
 277       nbytes = read (channel->fd, buffer, nbytes);
 278
 279       LOCK (channel->mutex);
 280
 281       channel->revents = G_IO_IN;
 282       if (nbytes == 0)
 283         channel->revents |= G_IO_HUP;
 284       else if (nbytes < 0)
 285         channel->revents |= G_IO_ERR;
 286
 287       if (channel->debug)
 288         g_print ("read_thread %#x: read() returned %d, rdp=%d, wrp=%d\n",
 289                  channel->thread_id, nbytes, channel->rdp, channel->wrp);
 290
 291       if (nbytes <= 0)
 292         break;
 293
 294       channel->wrp = (channel->wrp + nbytes) % BUFFER_SIZE;
 295       if (channel->debug)
 296         g_print ("read_thread %#x: rdp=%d, wrp=%d, setting data_avail\n",
 297                  channel->thread_id, channel->rdp, channel->wrp);
 298       SetEvent (channel->data_avail_event);
 299     }
 300
 301   channel->running = FALSE;
 302   if (channel->needs_close)
 303     {
 304       if (channel->debug)
 305         g_print ("read_thread %#x: channel fd %d needs closing\n",
 306                  channel->thread_id, channel->fd);
 307       close (channel->fd);
 308       channel->fd = -1;
 309     }
 310
 311   if (channel->debug)
 312     g_print ("read_thread %#x: EOF, rdp=%d, wrp=%d, setting data_avail\n",
 313              channel->thread_id, channel->rdp, channel->wrp);
 314   SetEvent (channel->data_avail_event);
 315   UNLOCK (channel->mutex);
 316
 317   g_io_channel_unref ((GIOChannel *)channel);
 318
 319   /* No need to call _endthreadex(), the actual thread starter routine
 320    * in MSVCRT (see crt/src/threadex.c:_threadstartex) calls
 321    * _endthreadex() for us.
 322    */
 323
 324   return 0;
 325 }
 326
 327 static void
 328 create_thread (GIOWin32Channel     *channel,
 329                GIOCondition         condition,
 330                unsigned (__stdcall *thread) (void *parameter))
 331 {
 332   HANDLE thread_handle;
 333
 334   thread_handle = (HANDLE) _beginthreadex (NULL, 0, thread, channel, 0,
 335                                            &channel->thread_id);
 336   if (thread_handle == 0)
 337     g_warning (G_STRLOC ": Error creating reader thread: %s",
 338                g_strerror (errno));
 339   else if (!CloseHandle (thread_handle))
 340     g_warning (G_STRLOC ": Error closing thread handle: %s\n",
 341                g_win32_error_message (GetLastError ()));
 342
 343   WaitForSingleObject (channel->space_avail_event, INFINITE);
 344 }
 345
 346 static void
 347 init_reset_sockets (GIOWin32Channel *channel)
 348 {
 349   struct sockaddr_in local, local2, server;
 350   int len;
 351
 352   channel->reset_send = (gint) socket (AF_INET, SOCK_DGRAM, 0);
 353   if (channel->reset_send == INVALID_SOCKET)
 354     {
 355       g_warning (G_STRLOC ": Error creating reset_send socket: %s\n",
 356                  g_win32_error_message (WSAGetLastError ()));
 357     }
 358
 359   local.sin_family = AF_INET;
 360   local.sin_port = 0;
 361   local.sin_addr.s_addr = htonl (INADDR_LOOPBACK);
 362
 363   if (bind (channel->reset_send, (struct sockaddr *)&local, sizeof (local)) == SOCKET_ERROR)
 364     {
 365       g_warning (G_STRLOC ": Error binding to reset_send socket: %s\n",
 366                  g_win32_error_message (WSAGetLastError ()));
 367   }
 368
 369   local2.sin_family = AF_INET;
 370   local2.sin_port = 0;
 371   local2.sin_addr.s_addr = htonl (INADDR_LOOPBACK);
 372
 373   channel->reset_recv = (gint) socket (AF_INET, SOCK_DGRAM, 0);
 374   if (channel->reset_recv == INVALID_SOCKET)
 375     {
 376       g_warning (G_STRLOC ": Error creating reset_recv socket: %s\n",
 377                  g_win32_error_message (WSAGetLastError ()));
 378   }
 379
 380   if (bind (channel->reset_recv, (struct sockaddr *)&local2, sizeof (local)) == SOCKET_ERROR)
 381     {
 382       g_warning (G_STRLOC ": Error binding to reset_recv socket: %s\n",
 383                  g_win32_error_message (WSAGetLastError ()));
 384     }
 385
 386   len = sizeof (local2);
 387   if (getsockname (channel->reset_recv, (struct sockaddr *)&local2, &len) == SOCKET_ERROR)
 388     {
 389       g_warning (G_STRLOC ": Error getsockname with reset_recv socket: %s\n",
 390                  g_win32_error_message (WSAGetLastError ()));
 391     }
 392
 393   memset (&server, 0, sizeof (server));
 394   server.sin_addr.s_addr = htonl (INADDR_LOOPBACK);
 395   server.sin_family = AF_INET;
 396   server.sin_port = local2.sin_port;
 397
 398   if (connect (channel->reset_send, (struct sockaddr  *)&server, sizeof (server)) == SOCKET_ERROR)
 399     {
 400       g_warning (G_STRLOC ": connect to reset_recv socket: %s\n",
 401                  g_win32_error_message (WSAGetLastError ()));
 402   }
 403
 404 }
 405
 406 static GIOStatus
 407 buffer_read (GIOWin32Channel *channel,
 408              guchar          *dest,
 409              gsize            count,
 410              gsize           *bytes_read,
 411              GError         **err)
 412 {
 413   guint nbytes;
 414   guint left = count;
 415
 416   LOCK (channel->mutex);
 417   if (channel->debug)
 418     g_print ("reading from thread %#x %d bytes, rdp=%d, wrp=%d\n",
 419              channel->thread_id, count, channel->rdp, channel->wrp);
 420
 421   if (channel->wrp == channel->rdp)
 422     {
 423       UNLOCK (channel->mutex);
 424       if (channel->debug)
 425         g_print ("waiting for data from thread %#x\n", channel->thread_id);
 426       WaitForSingleObject (channel->data_avail_event, INFINITE);
 427       if (channel->debug)
 428         g_print ("done waiting for data from thread %#x\n", channel->thread_id);
 429       LOCK (channel->mutex);
 430       if (channel->wrp == channel->rdp && !channel->running)
 431         {
 432           if (channel->debug)
 433             g_print ("wrp==rdp, !running\n");
 434           UNLOCK (channel->mutex);
 435           *bytes_read = 0;
 436           return G_IO_STATUS_EOF;
 437         }
 438     }
 439
 440   if (channel->rdp < channel->wrp)
 441     nbytes = channel->wrp - channel->rdp;
 442   else
 443     nbytes = BUFFER_SIZE - channel->rdp;
 444   UNLOCK (channel->mutex);
 445   nbytes = MIN (left, nbytes);
 446   if (channel->debug)
 447     g_print ("moving %d bytes from thread %#x\n",
 448              nbytes, channel->thread_id);
 449   memcpy (dest, channel->buffer + channel->rdp, nbytes);
 450   dest += nbytes;
 451   left -= nbytes;
 452   LOCK (channel->mutex);
 453   channel->rdp = (channel->rdp + nbytes) % BUFFER_SIZE;
 454   if (channel->debug)
 455     g_print ("setting space_avail for thread %#x\n", channel->thread_id);
 456   SetEvent (channel->space_avail_event);
 457   if (channel->debug)
 458     g_print ("for thread %#x: rdp=%d, wrp=%d\n",
 459              channel->thread_id, channel->rdp, channel->wrp);
 460   if (channel->running && channel->wrp == channel->rdp)
 461     {
 462       if (channel->debug)
 463         g_print ("resetting data_avail of thread %#x\n",
 464                  channel->thread_id);
 465       ResetEvent (channel->data_avail_event);
 466     };
 467   UNLOCK (channel->mutex);
 468
 469   /* We have no way to indicate any errors form the actual
 470    * read() or recv() call in the reader thread. Should we have?
 471    */
 472   *bytes_read = count - left;
 473   return (*bytes_read > 0) ? G_IO_STATUS_NORMAL : G_IO_STATUS_EOF;
 474 }
 475
 476 static unsigned __stdcall
 477 select_thread (void *parameter)
 478 {
 479   GIOWin32Channel *channel = parameter;
 480   fd_set read_fds, write_fds, except_fds;
 481   GSList *tmp;
 482   int n;
 483   char buffer[8];
 484
 485   g_io_channel_ref ((GIOChannel *)channel);
 486
 487   if (channel->debug)
 488     g_print ("select_thread %#x: start fd:%d data_avail:%#x data_avail_noticed:%#x\n",
 489              channel->thread_id,
 490              channel->fd,
 491              (guint) channel->data_avail_event,
 492              (guint) channel->data_avail_noticed_event);
 493
 494   channel->rdp = channel->wrp = 0;
 495   channel->running = TRUE;
 496
 497   SetEvent (channel->space_avail_event);
 498
 499   while (channel->running)
 500     {
 501       FD_ZERO (&read_fds);
 502       FD_ZERO (&write_fds);
 503       FD_ZERO (&except_fds);
 504       FD_SET (channel->reset_recv, &read_fds);
 505
 506       LOCK (channel->mutex);
 507       tmp = channel->watches;
 508       while (tmp)
 509         {
 510           GIOWin32Watch *watch = (GIOWin32Watch *)tmp->data;
 511
 512           if (watch->condition & (G_IO_IN | G_IO_HUP))
 513             FD_SET (channel->fd, &read_fds);
 514           if (watch->condition & G_IO_OUT)
 515             FD_SET (channel->fd, &write_fds);
 516           if (watch->condition & G_IO_ERR)
 517             FD_SET (channel->fd, &except_fds);
 518
 519           tmp = tmp->next;
 520         }
 521       UNLOCK (channel->mutex);
 522
 523       if (channel->debug)
 524         g_print ("select_thread %#x: calling select() for%s%s%s\n",
 525                  channel->thread_id,
 526                  (FD_ISSET (channel->fd, &read_fds) ? " IN" : ""),
 527                  (FD_ISSET (channel->fd, &write_fds) ? " OUT" : ""),
 528                  (FD_ISSET (channel->fd, &except_fds) ? " ERR" : ""));
 529
 530       n = select (1, &read_fds, &write_fds, &except_fds, NULL);
 531
 532       LOCK (channel->mutex);
 533       if (channel->needs_close)
 534         {
 535           UNLOCK (channel->mutex);
 536           break;
 537         }
 538       UNLOCK (channel->mutex);
 539
 540       if (n == SOCKET_ERROR)
 541         {
 542           if (channel->debug)
 543             g_print ("select_thread %#x: select returned SOCKET_ERROR\n",
 544                      channel->thread_id);
 545           break;
 546         }
 547
 548     if (FD_ISSET (channel->reset_recv, &read_fds))
 549     {
 550       if (channel->debug)
 551         g_print ("select_thread %#x: re-looping\n",
 552             channel->thread_id);
 553       recv (channel->reset_recv,  (char *)&buffer, (int) sizeof (buffer), 0);
 554       continue;
 555     }
 556
 557     if (channel->debug)
 558       g_print ("select_thread %#x: got%s%s%s\n",
 559                channel->thread_id,
 560                (FD_ISSET (channel->fd, &read_fds) ? " IN" : ""),
 561                (FD_ISSET (channel->fd, &write_fds) ? " OUT" : ""),
 562                (FD_ISSET (channel->fd, &except_fds) ? " ERR" : ""));
 563
 564     if (FD_ISSET (channel->fd, &read_fds))
 565       channel->revents |= G_IO_IN;
 566     if (FD_ISSET (channel->fd, &write_fds))
 567       channel->revents |= G_IO_OUT;
 568     if (FD_ISSET (channel->fd, &except_fds))
 569       channel->revents |= G_IO_ERR;
 570
 571     if (channel->debug)
 572       g_print ("select_thread %#x: resetting data_avail_noticed, setting data_avail\n",
 573                channel->thread_id);
 574
 575     LOCK (channel->mutex);
 576     ResetEvent (channel->data_avail_noticed_event);
 577     SetEvent (channel->data_avail_event);
 578     if (channel->needs_close)
 579       {
 580         UNLOCK (channel->mutex);
 581         break;
 582       }
 583     UNLOCK (channel->mutex);
 584
 585     if (channel->debug)
 586       g_print ("select_thread %#x: waiting for data_avail_noticed\n",
 587         channel->thread_id);
 588
 589     WaitForSingleObject (channel->data_avail_noticed_event, INFINITE);
 590     if (channel->debug)
 591       g_print ("select_thread %#x: got data_avail_noticed\n",
 592                  channel->thread_id);
 593     }
 594
 595   LOCK (channel->mutex);
 596   channel->running = FALSE;
 597   if (channel->debug)
 598     g_print ("select_thread %#x: got error, setting data_avail\n",
 599              channel->thread_id);
 600   SetEvent (channel->data_avail_event);
 601   g_io_channel_unref ((GIOChannel *)channel);
 602   UNLOCK (channel->mutex);
 603
 604   /* No need to call _endthreadex(), the actual thread starter routine
 605    * in MSVCRT (see crt/src/threadex.c:_threadstartex) calls
 606    * _endthreadex() for us.
 607    */
 608
 609   return 0;
 610 }
 611
 612 static gboolean
 613 g_io_win32_prepare (GSource *source,
 614                     gint    *timeout)
 615 {
 616   GIOWin32Watch *watch = (GIOWin32Watch *)source;
 617   GIOCondition buffer_condition = g_io_channel_get_buffer_condition (watch->channel);
 618   GIOWin32Channel *channel = (GIOWin32Channel *)watch->channel;
 619
 620   *timeout = -1;
 621
 622   if (channel->debug)
 623     g_print ("g_io_win32_prepare: for thread %#x buffer_condition:%#x\n"
 624              "  watch->pollfd.events:%#x watch->pollfd.revents:%#x channel->revents:%#x\n",
 625              channel->thread_id, buffer_condition,
 626              watch->pollfd.events, watch->pollfd.revents, channel->revents);
 627
 628   if (channel->type == G_IO_WIN32_FILE_DESC)
 629     {
 630       LOCK (channel->mutex);
 631       if (channel->running && channel->wrp == channel->rdp)
 632         {
 633           if (channel->debug)
 634             g_print ("g_io_win32_prepare: for thread %#x, setting channel->revents = 0\n",
 635                      channel->thread_id);
 636           channel->revents = 0;
 637         }
 638       UNLOCK (channel->mutex);
 639     }
 640   else if (channel->type == G_IO_WIN32_SOCKET)
 641     {
 642       LOCK (channel->mutex);
 643       channel->revents = 0;
 644       if (channel->debug)
 645         g_print ("g_io_win32_prepare: for thread %#x, setting data_avail_noticed\n",
 646                  channel->thread_id);
 647       SetEvent (channel->data_avail_noticed_event);
 648       if (channel->debug)
 649         g_print ("g_io_win32_prepare: thread %#x, there.\n",
 650                  channel->thread_id);
 651       UNLOCK (channel->mutex);
 652     }
 653
 654   return ((watch->condition & buffer_condition) == watch->condition);
 655 }
 656
 657 static gboolean
 658 g_io_win32_check (GSource *source)
 659 {
 660   MSG msg;
 661   GIOWin32Watch *watch = (GIOWin32Watch *)source;
 662   GIOWin32Channel *channel = (GIOWin32Channel *)watch->channel;
 663   GIOCondition buffer_condition = g_io_channel_get_buffer_condition (watch->channel);
 664
 665   if (channel->debug)
 666     g_print ("g_io_win32_check: for thread %#x buffer_condition:%#x\n"
 667              "  watch->pollfd.events:%#x watch->pollfd.revents:%#x channel->revents:%#x\n",
 668              channel->thread_id, buffer_condition,
 669              watch->pollfd.events, watch->pollfd.revents, channel->revents);
 670
 671   if (channel->type != G_IO_WIN32_WINDOWS_MESSAGES)
 672     {
 673       watch->pollfd.revents = (watch->pollfd.events & channel->revents);
 674     }
 675   else
 676     {
 677       return (PeekMessage (&msg, channel->hwnd, 0, 0, PM_NOREMOVE));
 678     }
 679
 680   if (channel->type == G_IO_WIN32_SOCKET)
 681     {
 682       LOCK (channel->mutex);
 683       if (channel->debug)
 684         g_print ("g_io_win32_check: thread %#x, resetting data_avail\n",
 685                  channel->thread_id);
 686       ResetEvent (channel->data_avail_event);
 687       if (channel->debug)
 688         g_print ("g_io_win32_check: thread %#x, there.\n",
 689                  channel->thread_id);
 690       UNLOCK (channel->mutex);
 691     }
 692
 693   return ((watch->pollfd.revents | buffer_condition) & watch->condition);
 694 }
 695
 696 static gboolean
 697 g_io_win32_dispatch (GSource     *source,
 698                      GSourceFunc  callback,
 699                      gpointer     user_data)
 700 {
 701   GIOFunc func = (GIOFunc)callback;
 702   GIOWin32Watch *watch = (GIOWin32Watch *)source;
 703   GIOCondition buffer_condition = g_io_channel_get_buffer_condition (watch->channel);
 704
 705   if (!func)
 706     {
 707       g_warning (G_STRLOC ": GIOWin32Watch dispatched without callback\n"
 708                  "You must call g_source_connect().");
 709       return FALSE;
 710     }
 711
 712   return (*func) (watch->channel,
 713                   (watch->pollfd.revents | buffer_condition) & watch->condition,
 714                   user_data);
 715 }
 716
 717 static void
 718 g_io_win32_finalize (GSource *source)
 719 {
 720   GIOWin32Watch *watch = (GIOWin32Watch *)source;
 721   GIOWin32Channel *channel = (GIOWin32Channel *)watch->channel;
 722   char send_buffer[] = "f";
 723
 724   LOCK (channel->mutex);
 725   if (channel->debug)
 726     g_print ("g_io_win32_finalize: channel with thread %#x\n",
 727              channel->thread_id);
 728
 729   channel->watches = g_slist_remove (channel->watches, watch);
 730
 731   SetEvent (channel->data_avail_noticed_event);
 732   if (channel->type == G_IO_WIN32_SOCKET)
 733   {
 734     /* Tell select_thread() to exit */
 735     channel->needs_close = 1;
 736     /* Wake up select_thread() from its blocking select() */
 737     send (channel->reset_send, send_buffer, sizeof (send_buffer), 0);
 738   }
 739
 740   UNLOCK (channel->mutex);
 741   g_io_channel_unref (watch->channel);
 742 }
 743
 744 GSourceFuncs g_io_watch_funcs = {
 745   g_io_win32_prepare,
 746   g_io_win32_check,
 747   g_io_win32_dispatch,
 748   g_io_win32_finalize
 749 };
 750
 751 static GSource *
 752 g_io_win32_create_watch (GIOChannel    *channel,
 753                          GIOCondition   condition,
 754                          unsigned (__stdcall *thread) (void *parameter))
 755 {
 756   GIOWin32Channel *win32_channel = (GIOWin32Channel *)channel;
 757   GIOWin32Watch *watch;
 758   GSource *source;
 759   char send_buffer[] = "c";
 760
 761   source = g_source_new (&g_io_watch_funcs, sizeof (GIOWin32Watch));
 762   watch = (GIOWin32Watch *)source;
 763
 764   watch->channel = channel;
 765   g_io_channel_ref (channel);
 766
 767   watch->condition = condition;
 768
 769   if (win32_channel->data_avail_event == NULL)
 770     create_events (win32_channel);
 771
 772   watch->pollfd.fd = (gint) win32_channel->data_avail_event;
 773   watch->pollfd.events = condition;
 774
 775   if (win32_channel->debug)
 776     g_print ("g_io_win32_create_watch: fd:%d condition:%#x handle:%#x\n",
 777              win32_channel->fd, condition, watch->pollfd.fd);
 778
 779   LOCK (win32_channel->mutex);
 780   win32_channel->watches = g_slist_append (win32_channel->watches, watch);
 781
 782   if (win32_channel->thread_id == 0)
 783     create_thread (win32_channel, condition, thread);
 784   else
 785     send (win32_channel->reset_send, send_buffer, sizeof (send_buffer), 0);
 786
 787   g_source_add_poll (source, &watch->pollfd);
 788   UNLOCK (win32_channel->mutex);
 789
 790   return source;
 791 }
 792
 793 static GIOStatus
 794 g_io_win32_msg_read (GIOChannel *channel,
 795                      gchar      *buf,
 796                      gsize       count,
 797                      gsize      *bytes_read,
 798                      GError    **err)
 799 {
 800   GIOWin32Channel *win32_channel = (GIOWin32Channel *)channel;
 801   MSG msg;               /* In case of alignment problems */
 802
 803   if (count < sizeof (MSG))
 804     {
 805       g_set_error (err, G_IO_CHANNEL_ERROR, G_IO_CHANNEL_ERROR_INVAL,
 806                    "Incorrect message size"); /* Informative enough error message? */
 807       return G_IO_STATUS_ERROR;
 808     }
 809
 810   if (win32_channel->debug)
 811     g_print ("g_io_win32_msg_read: for %#x\n",
 812              (guint) win32_channel->hwnd);
 813   if (!PeekMessage (&msg, win32_channel->hwnd, 0, 0, PM_REMOVE))
 814     return G_IO_STATUS_AGAIN;
 815
 816   memmove (buf, &msg, sizeof (MSG));
 817   *bytes_read = sizeof (MSG);
 818
 819   return G_IO_STATUS_NORMAL;
 820 }
 821
 822 static GIOStatus
 823 g_io_win32_msg_write (GIOChannel  *channel,
 824                       const gchar *buf,
 825                       gsize        count,
 826                       gsize       *bytes_written,
 827                       GError     **err)
 828 {
 829   GIOWin32Channel *win32_channel = (GIOWin32Channel *)channel;
 830   MSG msg;
 831
 832   if (count != sizeof (MSG))
 833     {
 834       g_set_error (err, G_IO_CHANNEL_ERROR, G_IO_CHANNEL_ERROR_INVAL,
 835                    "Incorrect message size"); /* Informative enough error message? */
 836       return G_IO_STATUS_ERROR;
 837     }
 838
 839   /* In case of alignment problems */
 840   memmove (&msg, buf, sizeof (MSG));
 841   if (!PostMessage (win32_channel->hwnd, msg.message, msg.wParam, msg.lParam))
 842     {
 843       gchar *emsg = g_win32_error_message (GetLastError ());
 844       g_set_error (err, G_IO_CHANNEL_ERROR, G_IO_CHANNEL_ERROR_FAILED, emsg);
 845       g_free (emsg);
 846       return G_IO_STATUS_ERROR;
 847     }
 848
 849   *bytes_written = sizeof (MSG);
 850
 851   return G_IO_STATUS_NORMAL;
 852 }
 853
 854 static GIOStatus
 855 g_io_win32_msg_close (GIOChannel *channel,
 856                       GError    **err)
 857 {
 858   /* Nothing to be done. Or should we set hwnd to some invalid value? */
 859
 860   return G_IO_STATUS_NORMAL;
 861 }
 862
 863 static void
 864 g_io_win32_free (GIOChannel *channel)
 865 {
 866   GIOWin32Channel *win32_channel = (GIOWin32Channel *)channel;
 867
 868   if (win32_channel->debug)
 869     g_print ("thread %#x: freeing channel, fd: %d\n",
 870              win32_channel->thread_id,
 871              win32_channel->fd);
 872
 873   if (win32_channel->reset_send && win32_channel->reset_send != INVALID_SOCKET)
 874     closesocket (win32_channel->reset_send);
 875   if (win32_channel->reset_recv && win32_channel->reset_recv != INVALID_SOCKET)
 876     closesocket (win32_channel->reset_recv);
 877   if (win32_channel->data_avail_event)
 878     CloseHandle (win32_channel->data_avail_event);
 879   if (win32_channel->space_avail_event)
 880     CloseHandle (win32_channel->space_avail_event);
 881   if (win32_channel->data_avail_noticed_event)
 882     CloseHandle (win32_channel->data_avail_noticed_event);
 883   DeleteCriticalSection (&win32_channel->mutex);
 884
 885   g_free (win32_channel->buffer);
 886   g_slist_free (win32_channel->watches);
 887   g_free (win32_channel);
 888 }
 889
 890 static GSource *
 891 g_io_win32_msg_create_watch (GIOChannel    *channel,
 892                              GIOCondition   condition)
 893 {
 894   GIOWin32Watch *watch;
 895   GSource *source;
 896
 897   source = g_source_new (&g_io_watch_funcs, sizeof (GIOWin32Watch));
 898   watch = (GIOWin32Watch *)source;
 899
 900   watch->channel = channel;
 901   g_io_channel_ref (channel);
 902
 903   watch->condition = condition;
 904
 905   watch->pollfd.fd = G_WIN32_MSG_HANDLE;
 906   watch->pollfd.events = condition;
 907
 908   g_source_add_poll (source, &watch->pollfd);
 909
 910   return source;
 911 }
 912
 913 static GIOStatus
 914 g_io_win32_fd_read (GIOChannel *channel,
 915                     gchar      *buf,
 916                     gsize       count,
 917                     gsize      *bytes_read,
 918                     GError    **err)
 919 {
 920   GIOWin32Channel *win32_channel = (GIOWin32Channel *)channel;
 921   gint result;
 922
 923   if (win32_channel->debug)
 924     g_print ("g_io_win32_fd_read: fd:%d count:%d\n",
 925              win32_channel->fd, count);
 926
 927   if (win32_channel->thread_id)
 928     {
 929       return buffer_read (win32_channel, buf, count, bytes_read, err);
 930     }
 931
 932   result = read (win32_channel->fd, buf, count);
 933
 934   if (win32_channel->debug)
 935     g_print ("g_io_win32_fd_read: read() = %d\n", result);
 936
 937   if (result < 0)
 938     {
 939       *bytes_read = 0;
 940
 941       switch (errno)
 942         {
 943 #ifdef EAGAIN
 944         case EAGAIN:
 945           return G_IO_STATUS_AGAIN;
 946 #endif
 947         default:
 948           g_set_error (err, G_IO_CHANNEL_ERROR,
 949                        g_io_channel_error_from_errno (errno),
 950                        g_strerror (errno));
 951           return G_IO_STATUS_ERROR;
 952         }
 953     }
 954
 955   *bytes_read = result;
 956
 957   return (result > 0) ? G_IO_STATUS_NORMAL : G_IO_STATUS_EOF;
 958 }
 959
 960 static GIOStatus
 961 g_io_win32_fd_write (GIOChannel  *channel,
 962                      const gchar *buf,
 963                      gsize        count,
 964                      gsize       *bytes_written,
 965                      GError     **err)
 966 {
 967   GIOWin32Channel *win32_channel = (GIOWin32Channel *)channel;
 968   gint result;
 969
 970   result = write (win32_channel->fd, buf, count);
 971   if (win32_channel->debug)
 972     g_print ("g_io_win32_fd_write: fd:%d count:%d = %d\n",
 973              win32_channel->fd, count, result);
 974
 975   if (result < 0)
 976     {
 977       *bytes_written = 0;
 978
 979       switch (errno)
 980         {
 981 #ifdef EAGAIN
 982         case EAGAIN:
 983           return G_IO_STATUS_AGAIN;
 984 #endif
 985         default:
 986           g_set_error (err, G_IO_CHANNEL_ERROR,
 987                        g_io_channel_error_from_errno (errno),
 988                        g_strerror (errno));
 989           return G_IO_STATUS_ERROR;
 990         }
 991     }
 992
 993   *bytes_written = result;
 994
 995   return G_IO_STATUS_NORMAL;
 996 }
 997
 998 static GIOStatus
 999 g_io_win32_fd_seek (GIOChannel *channel,
1000                     gint64      offset,
1001                     GSeekType   type,
1002                     GError    **err)
1003 {
1004   GIOWin32Channel *win32_channel = (GIOWin32Channel *)channel;
1005   int whence;
1006   off_t tmp_offset;
1007   off_t result;
1008
1009   switch (type)
1010     {
1011     case G_SEEK_SET:
1012       whence = SEEK_SET;
1013       break;
1014     case G_SEEK_CUR:
1015       whence = SEEK_CUR;
1016       break;
1017     case G_SEEK_END:
1018       whence = SEEK_END;
1019       break;
1020     default:
1021       whence = -1; /* Keep the compiler quiet */
1022       g_assert_not_reached ();
1023     }
1024
1025   tmp_offset = offset;
1026   if (tmp_offset != offset)
1027     {
1028       g_set_error (err, G_IO_CHANNEL_ERROR,
1029                    g_io_channel_error_from_errno (EINVAL),
1030                    g_strerror (EINVAL));
1031       return G_IO_STATUS_ERROR;
1032     }
1033
1034   result = lseek (win32_channel->fd, tmp_offset, whence);
1035
1036   if (result < 0)
1037     {
1038       g_set_error (err, G_IO_CHANNEL_ERROR,
1039                    g_io_channel_error_from_errno (errno),
1040                    g_strerror (errno));
1041       return G_IO_STATUS_ERROR;
1042     }
1043
1044   return G_IO_STATUS_NORMAL;
1045 }
1046
1047 static GIOStatus
1048 g_io_win32_fd_close (GIOChannel *channel,
1049                      GError    **err)
1050 {
1051   GIOWin32Channel *win32_channel = (GIOWin32Channel *)channel;
1052
1053   if (win32_channel->debug)
1054     g_print ("thread %#x: closing fd %d\n",
1055              win32_channel->thread_id,
1056              win32_channel->fd);
1057   LOCK (win32_channel->mutex);
1058   if (win32_channel->running)
1059     {
1060       if (win32_channel->debug)
1061         g_print ("thread %#x: running, marking fd %d for later close\n",
1062                  win32_channel->thread_id, win32_channel->fd);
1063       win32_channel->running = FALSE;
1064       win32_channel->needs_close = TRUE;
1065       SetEvent (win32_channel->data_avail_event);
1066     }
1067   else
1068     {
1069       if (win32_channel->debug)
1070         g_print ("closing fd %d\n", win32_channel->fd);
1071       close (win32_channel->fd);
1072       if (win32_channel->debug)
1073         g_print ("closed fd %d, setting to -1\n",
1074                  win32_channel->fd);
1075       win32_channel->fd = -1;
1076     }
1077   UNLOCK (win32_channel->mutex);
1078
1079   /* FIXME error detection? */
1080
1081   return G_IO_STATUS_NORMAL;
1082 }
1083
1084 static GSource *
1085 g_io_win32_fd_create_watch (GIOChannel    *channel,
1086                             GIOCondition   condition)
1087 {
1088   return g_io_win32_create_watch (channel, condition, read_thread);
1089 }
1090
1091 static GIOStatus
1092 g_io_win32_sock_read (GIOChannel *channel,
1093                       gchar      *buf,
1094                       gsize       count,
1095                       gsize      *bytes_read,
1096                       GError    **err)
1097 {
1098   GIOWin32Channel *win32_channel = (GIOWin32Channel *)channel;
1099   gint result;
1100   GIOChannelError error = G_IO_STATUS_NORMAL;
1101   GIOStatus internal_status = G_IO_STATUS_NORMAL;
1102   char send_buffer[] = "sr";
1103
1104   if (win32_channel->debug)
1105     g_print ("g_io_win32_sock_read: sockfd:%d count:%d\n",
1106              win32_channel->fd, count);
1107 #ifdef WE_NEED_TO_HANDLE_WSAEINTR
1108 repeat:
1109 #endif
1110   result = recv (win32_channel->fd, buf, count, 0);
1111
1112   if (win32_channel->debug)
1113     g_print ("g_io_win32_sock_read: recv:%d\n", result);
1114
1115   if (result == SOCKET_ERROR)
1116     {
1117       *bytes_read = 0;
1118
1119       switch (WSAGetLastError ())
1120         {
1121         case WSAEINVAL:
1122           error = G_IO_CHANNEL_ERROR_INVAL;
1123           break;
1124         case WSAEWOULDBLOCK:
1125           return G_IO_STATUS_AGAIN;
1126 #ifdef WE_NEED_TO_HANDLE_WSAEINTR /* not anymore with wsock2 ? */
1127         case WSAEINTR:
1128           goto repeat;
1129 #endif
1130         default:
1131           error = G_IO_CHANNEL_ERROR_FAILED;
1132           break;
1133         }
1134       g_set_error (err, G_IO_CHANNEL_ERROR, error, "Socket read error");
1135       internal_status = G_IO_STATUS_ERROR;
1136       /* FIXME get all errors, better error messages */
1137     }
1138   else
1139     {
1140       *bytes_read = result;
1141       if (result == 0)
1142         internal_status = G_IO_STATUS_EOF;
1143     }
1144
1145   if ((internal_status == G_IO_STATUS_EOF) ||
1146       (internal_status == G_IO_STATUS_ERROR))
1147     {
1148       LOCK (win32_channel->mutex);
1149       SetEvent (win32_channel->data_avail_noticed_event);
1150       win32_channel->needs_close = 1;
1151       send (win32_channel->reset_send, send_buffer, sizeof (send_buffer), 0);
1152       UNLOCK (win32_channel->mutex);
1153     }
1154   return internal_status;
1155 }
1156
1157 static GIOStatus
1158 g_io_win32_sock_write (GIOChannel  *channel,
1159                        const gchar *buf,
1160                        gsize        count,
1161                        gsize       *bytes_written,
1162                        GError     **err)
1163 {
1164   GIOWin32Channel *win32_channel = (GIOWin32Channel *)channel;
1165   gint result;
1166   GIOChannelError error = G_IO_STATUS_NORMAL;
1167   char send_buffer[] = "sw";
1168
1169   if (win32_channel->debug)
1170     g_print ("g_io_win32_sock_write: sockfd:%d count:%d\n",
1171              win32_channel->fd, count);
1172 #ifdef WE_NEED_TO_HANDLE_WSAEINTR
1173 repeat:
1174 #endif
1175   result = send (win32_channel->fd, buf, count, 0);
1176
1177   if (win32_channel->debug)
1178     g_print ("g_io_win32_sock_write: send:%d\n", result);
1179
1180   if (result == SOCKET_ERROR)
1181     {
1182       *bytes_written = 0;
1183
1184       switch (WSAGetLastError ())
1185         {
1186         case WSAEINVAL:
1187           error = G_IO_CHANNEL_ERROR_INVAL;
1188           break;
1189         case WSAEWOULDBLOCK:
1190           return G_IO_STATUS_AGAIN;
1191 #ifdef WE_NEED_TO_HANDLE_WSAEINTR /* not anymore with wsock2 ? */
1192         case WSAEINTR:
1193           goto repeat;
1194 #endif
1195         default:
1196           error = G_IO_CHANNEL_ERROR_FAILED;
1197           break;
1198         }
1199       g_set_error (err, G_IO_CHANNEL_ERROR, error, "Socket write error");
1200       LOCK (win32_channel->mutex);
1201       SetEvent (win32_channel->data_avail_noticed_event);
1202       win32_channel->needs_close = 1;
1203       send (win32_channel->reset_send, send_buffer, sizeof (send_buffer), 0);
1204       UNLOCK (win32_channel->mutex);
1205       return G_IO_STATUS_ERROR;
1206       /* FIXME get all errors, better error messages */
1207     }
1208   else
1209     {
1210       *bytes_written = result;
1211
1212       return G_IO_STATUS_NORMAL;
1213     }
1214 }
1215
1216 static GIOStatus
1217 g_io_win32_sock_close (GIOChannel *channel,
1218                        GError    **err)
1219 {
1220   GIOWin32Channel *win32_channel = (GIOWin32Channel *)channel;
1221
1222   LOCK (win32_channel->mutex);
1223   if (win32_channel->running)
1224     {
1225       if (win32_channel->debug)
1226         g_print ("thread %#x: running, marking for later close\n",
1227                  win32_channel->thread_id);
1228       win32_channel->running = FALSE;
1229       win32_channel->needs_close = TRUE;
1230       SetEvent(win32_channel->data_avail_noticed_event);
1231     }
1232   if (win32_channel->fd != -1)
1233     {
1234       if (win32_channel->debug)
1235         g_print ("thread %#x: closing socket %d\n",
1236                  win32_channel->thread_id,
1237                  win32_channel->fd);
1238
1239       closesocket (win32_channel->fd);
1240       win32_channel->fd = -1;
1241     }
1242   UNLOCK (win32_channel->mutex);
1243
1244   /* FIXME error detection? */
1245
1246   return G_IO_STATUS_NORMAL;
1247 }
1248
1249 static GSource *
1250 g_io_win32_sock_create_watch (GIOChannel    *channel,
1251                               GIOCondition   condition)
1252 {
1253   return g_io_win32_create_watch (channel, condition, select_thread);
1254 }
1255
1256 GIOChannel *
1257 g_io_channel_new_file (const gchar  *filename,
1258                        const gchar  *mode,
1259                        GError      **error)
1260 {
1261   int fid, flags, pmode;
1262   GIOChannel *channel;
1263
1264   enum { /* Cheesy hack */
1265     MODE_R = 1 << 0,
1266     MODE_W = 1 << 1,
1267     MODE_A = 1 << 2,
1268     MODE_PLUS = 1 << 3,
1269   } mode_num;
1270
1271   g_return_val_if_fail (filename != NULL, NULL);
1272   g_return_val_if_fail (mode != NULL, NULL);
1273   g_return_val_if_fail ((error == NULL) || (*error == NULL), NULL);
1274
1275   switch (mode[0])
1276     {
1277       case 'r':
1278         mode_num = MODE_R;
1279         break;
1280       case 'w':
1281         mode_num = MODE_W;
1282         break;
1283       case 'a':
1284         mode_num = MODE_A;
1285         break;
1286       default:
1287         g_warning ("Invalid GIOFileMode %s.\n", mode);
1288         return NULL;
1289     }
1290
1291   switch (mode[1])
1292     {
1293       case '\0':
1294         break;
1295       case '+':
1296         if (mode[2] == '\0')
1297           {
1298             mode_num |= MODE_PLUS;
1299             break;
1300           }
1301         /* Fall through */
1302       default:
1303         g_warning ("Invalid GIOFileMode %s.\n", mode);
1304         return NULL;
1305     }
1306
1307   switch (mode_num)
1308     {
1309       case MODE_R:
1310         flags = O_RDONLY;
1311         pmode = _S_IREAD;
1312         break;
1313       case MODE_W:
1314         flags = O_WRONLY | O_TRUNC | O_CREAT;
1315         pmode = _S_IWRITE;
1316         break;
1317       case MODE_A:
1318         flags = O_WRONLY | O_APPEND | O_CREAT;
1319         pmode = _S_IWRITE;
1320         break;
1321       case MODE_R | MODE_PLUS:
1322         flags = O_RDWR;
1323         pmode = _S_IREAD | _S_IWRITE;
1324         break;
1325       case MODE_W | MODE_PLUS:
1326         flags = O_RDWR | O_TRUNC | O_CREAT;
1327         pmode = _S_IREAD | _S_IWRITE;
1328         break;
1329       case MODE_A | MODE_PLUS:
1330         flags = O_RDWR | O_APPEND | O_CREAT;
1331         pmode = _S_IREAD | _S_IWRITE;
1332         break;
1333       default:
1334         g_assert_not_reached ();
1335         flags = 0;
1336         pmode = 0;
1337     }
1338
1339   /* always open 'untranslated' */
1340   fid = g_open (filename, flags | _O_BINARY, pmode);
1341
1342   if (g_io_win32_get_debug_flag ())
1343     {
1344       g_print ("g_io_channel_win32_new_file: open(\"%s\", ", filename);
1345       g_win32_print_access_mode (flags|_O_BINARY);
1346       g_print (",%#o)=%d\n", pmode, fid);
1347     }
1348
1349   if (fid < 0)
1350     {
1351       g_set_error (error, G_FILE_ERROR,
1352                    g_file_error_from_errno (errno),
1353                    g_strerror (errno));
1354       return (GIOChannel *)NULL;
1355     }
1356
1357   channel = g_io_channel_win32_new_fd (fid);
1358
1359   /* XXX: move this to g_io_channel_win32_new_fd () */
1360   channel->close_on_unref = TRUE;
1361   channel->is_seekable = TRUE;
1362
1363   /* g_io_channel_win32_new_fd sets is_readable and is_writeable to
1364    * correspond to actual readability/writeability. Set to FALSE those
1365    * that mode doesn't allow
1366    */
1367   switch (mode_num)
1368     {
1369       case MODE_R:
1370         channel->is_writeable = FALSE;
1371         break;
1372       case MODE_W:
1373       case MODE_A:
1374         channel->is_readable = FALSE;
1375         break;
1376       case MODE_R | MODE_PLUS:
1377       case MODE_W | MODE_PLUS:
1378       case MODE_A | MODE_PLUS:
1379         break;
1380       default:
1381         g_assert_not_reached ();
1382     }
1383
1384   return channel;
1385 }
1386
1387 #ifdef G_OS_WIN32
1388
1389 #undef g_io_channel_new_file
1390
1391 /* Binary compatibility version. Not for newly compiled code. */
1392
1393 GIOChannel *
1394 g_io_channel_new_file (const gchar  *filename,
1395                        const gchar  *mode,
1396                        GError      **error)
1397 {
1398   gchar *utf8_filename = g_locale_to_utf8 (filename, -1, NULL, NULL, error);
1399   GIOChannel *retval;
1400
1401   if (utf8_filename == NULL)
1402     return NULL;
1403
1404   retval = g_io_channel_new_file_utf8 (utf8_filename, mode, error);
1405
1406   g_free (utf8_filename);
1407
1408   return retval;
1409 }
1410
1411 #endif
1412
1413 static GIOStatus
1414 g_io_win32_set_flags (GIOChannel *channel,
1415                       GIOFlags    flags,
1416                       GError    **err)
1417 {
1418   GIOWin32Channel *win32_channel = (GIOWin32Channel *)channel;
1419
1420   if (win32_channel->debug)
1421     {
1422       g_print ("g_io_win32_set_flags: ");
1423       g_win32_print_gioflags (flags);
1424       g_print ("\n");
1425     }
1426
1427   g_warning ("g_io_win32_set_flags () not implemented.\n");
1428
1429   return G_IO_STATUS_NORMAL;
1430 }
1431
1432 static GIOFlags
1433 g_io_win32_fd_get_flags_internal (GIOChannel  *channel,
1434                                   struct stat *st)
1435 {
1436   GIOWin32Channel *win32_channel = (GIOWin32Channel *) channel;
1437   gchar c;
1438   DWORD count;
1439
1440   if (st->st_mode & _S_IFIFO)
1441     {
1442       channel->is_readable =
1443         (PeekNamedPipe ((HANDLE) _get_osfhandle (win32_channel->fd), &c, 0, &count, NULL, NULL) != 0) || GetLastError () == ERROR_BROKEN_PIPE;
1444       channel->is_writeable =
1445         (WriteFile ((HANDLE) _get_osfhandle (win32_channel->fd), &c, 0, &count, NULL) != 0);
1446       channel->is_seekable  = FALSE;
1447     }
1448   else if (st->st_mode & _S_IFCHR)
1449     {
1450       /* XXX Seems there is no way to find out the readability of file
1451        * handles to device files (consoles, mostly) without doing a
1452        * blocking read. So punt, use st->st_mode.
1453        */
1454       channel->is_readable  = !!(st->st_mode & _S_IREAD);
1455
1456       channel->is_writeable =
1457         (WriteFile ((HANDLE) _get_osfhandle (win32_channel->fd), &c, 0, &count, NULL) != 0);
1458
1459       /* XXX What about devices that actually *are* seekable? But
1460        * those would probably not be handled using the C runtime
1461        * anyway, but using Windows-specific code.
1462        */
1463       channel->is_seekable = FALSE;
1464     }
1465   else
1466     {
1467       channel->is_readable =
1468         (ReadFile ((HANDLE) _get_osfhandle (win32_channel->fd), &c, 0, &count, NULL) != 0);
1469       channel->is_writeable =
1470         (WriteFile ((HANDLE) _get_osfhandle (win32_channel->fd), &c, 0, &count, NULL) != 0);
1471       channel->is_seekable = TRUE;
1472     }
1473
1474   /* XXX: G_IO_FLAG_APPEND */
1475   /* XXX: G_IO_FLAG_NONBLOCK */
1476
1477   return 0;
1478 }
1479
1480 static GIOFlags
1481 g_io_win32_fd_get_flags (GIOChannel *channel)
1482 {
1483   struct stat st;
1484   GIOWin32Channel *win32_channel = (GIOWin32Channel *)channel;
1485
1486   g_return_val_if_fail (win32_channel != NULL, 0);
1487   g_return_val_if_fail (win32_channel->type == G_IO_WIN32_FILE_DESC, 0);
1488
1489   if (0 == fstat (win32_channel->fd, &st))
1490     return g_io_win32_fd_get_flags_internal (channel, &st);
1491   else
1492     return 0;
1493 }
1494
1495 static GIOFlags
1496 g_io_win32_msg_get_flags (GIOChannel *channel)
1497 {
1498   return 0;
1499 }
1500
1501 static GIOFlags
1502 g_io_win32_sock_get_flags (GIOChannel *channel)
1503 {
1504   /* XXX Could do something here. */
1505   return 0;
1506 }
1507
1508 static GIOFuncs win32_channel_msg_funcs = {
1509   g_io_win32_msg_read,
1510   g_io_win32_msg_write,
1511   NULL,
1512   g_io_win32_msg_close,
1513   g_io_win32_msg_create_watch,
1514   g_io_win32_free,
1515   g_io_win32_set_flags,
1516   g_io_win32_msg_get_flags,
1517 };
1518
1519 static GIOFuncs win32_channel_fd_funcs = {
1520   g_io_win32_fd_read,
1521   g_io_win32_fd_write,
1522   g_io_win32_fd_seek,
1523   g_io_win32_fd_close,
1524   g_io_win32_fd_create_watch,
1525   g_io_win32_free,
1526   g_io_win32_set_flags,
1527   g_io_win32_fd_get_flags,
1528 };
1529
1530 static GIOFuncs win32_channel_sock_funcs = {
1531   g_io_win32_sock_read,
1532   g_io_win32_sock_write,
1533   NULL,
1534   g_io_win32_sock_close,
1535   g_io_win32_sock_create_watch,
1536   g_io_win32_free,
1537   g_io_win32_set_flags,
1538   g_io_win32_sock_get_flags,
1539 };
1540
1541 GIOChannel *
1542 g_io_channel_win32_new_messages (guint hwnd)
1543 {
1544   GIOWin32Channel *win32_channel = g_new (GIOWin32Channel, 1);
1545   GIOChannel *channel = (GIOChannel *)win32_channel;
1546
1547   g_io_channel_init (channel);
1548   g_io_channel_win32_init (win32_channel);
1549   if (win32_channel->debug)
1550     g_print ("g_io_channel_win32_new_messages: hwnd = %ud\n", hwnd);
1551   channel->funcs = &win32_channel_msg_funcs;
1552   win32_channel->type = G_IO_WIN32_WINDOWS_MESSAGES;
1553   win32_channel->hwnd = (HWND) hwnd;
1554
1555   /* XXX: check this. */
1556   channel->is_readable = IsWindow (win32_channel->hwnd);
1557   channel->is_writeable = IsWindow (win32_channel->hwnd);
1558
1559   channel->is_seekable = FALSE;
1560
1561   return channel;
1562 }
1563
1564 static GIOChannel *
1565 g_io_channel_win32_new_fd_internal (gint         fd,
1566                                     struct stat *st)
1567 {
1568   GIOWin32Channel *win32_channel;
1569   GIOChannel *channel;
1570
1571   win32_channel = g_new (GIOWin32Channel, 1);
1572   channel = (GIOChannel *)win32_channel;
1573
1574   g_io_channel_init (channel);
1575   g_io_channel_win32_init (win32_channel);
1576   if (win32_channel->debug)
1577     g_print ("g_io_channel_win32_new_fd: %u\n", fd);
1578   channel->funcs = &win32_channel_fd_funcs;
1579   win32_channel->type = G_IO_WIN32_FILE_DESC;
1580   win32_channel->fd = fd;
1581
1582   g_io_win32_fd_get_flags_internal (channel, st);
1583
1584   return channel;
1585 }
1586
1587 GIOChannel *
1588 g_io_channel_win32_new_fd (gint fd)
1589 {
1590   struct stat st;
1591
1592   if (fstat (fd, &st) == -1)
1593     {
1594       g_warning (G_STRLOC ": %d isn't a C library file descriptor", fd);
1595       return NULL;
1596     }
1597
1598   return g_io_channel_win32_new_fd_internal (fd, &st);
1599 }
1600
1601 gint
1602 g_io_channel_win32_get_fd (GIOChannel *channel)
1603 {
1604   GIOWin32Channel *win32_channel = (GIOWin32Channel *)channel;
1605
1606   return win32_channel->fd;
1607 }
1608
1609 GIOChannel *
1610 g_io_channel_win32_new_socket (int socket)
1611 {
1612   GIOWin32Channel *win32_channel = g_new (GIOWin32Channel, 1);
1613   GIOChannel *channel = (GIOChannel *)win32_channel;
1614
1615   g_io_channel_init (channel);
1616   g_io_channel_win32_init (win32_channel);
1617   init_reset_sockets (win32_channel);
1618   if (win32_channel->debug)
1619     g_print ("g_io_channel_win32_new_socket: sockfd:%d\n", socket);
1620   channel->funcs = &win32_channel_sock_funcs;
1621   win32_channel->type = G_IO_WIN32_SOCKET;
1622   win32_channel->fd = socket;
1623
1624   /* XXX: check this */
1625   channel->is_readable = TRUE;
1626   channel->is_writeable = TRUE;
1627
1628   channel->is_seekable = FALSE;
1629
1630   return channel;
1631 }
1632
1633 GIOChannel *
1634 g_io_channel_unix_new (gint fd)
1635 {
1636   gboolean is_fd, is_socket;
1637   struct stat st;
1638   int optval, optlen;
1639
1640   is_fd = (fstat (fd, &st) == 0);
1641
1642   optlen = sizeof (optval);
1643   is_socket = (getsockopt (fd, SOL_SOCKET, SO_TYPE, (char *) &optval, &optlen) != SOCKET_ERROR);
1644
1645   if (is_fd && is_socket)
1646     g_warning (G_STRLOC ": %d is both a file descriptor and a socket, file descriptor interpretation assumed.", fd);
1647
1648   if (is_fd)
1649     return g_io_channel_win32_new_fd_internal (fd, &st);
1650
1651   if (is_socket)
1652     return g_io_channel_win32_new_socket(fd);
1653
1654   g_warning (G_STRLOC ": %d is neither a file descriptor or a socket", fd);
1655
1656   return NULL;
1657 }
1658
1659 gint
1660 g_io_channel_unix_get_fd (GIOChannel *channel)
1661 {
1662   return g_io_channel_win32_get_fd (channel);
1663 }
1664
1665 void
1666 g_io_channel_win32_set_debug (GIOChannel *channel,
1667                               gboolean    flag)
1668 {
1669   GIOWin32Channel *win32_channel = (GIOWin32Channel *)channel;
1670
1671   win32_channel->debug = flag;
1672 }
1673
1674 gint
1675 g_io_channel_win32_poll (GPollFD *fds,
1676                          gint     n_fds,
1677                          gint     timeout)
1678 {
1679   int result;
1680
1681   g_return_val_if_fail (n_fds >= 0, 0);
1682
1683   result = (*g_main_context_get_poll_func (NULL)) (fds, n_fds, timeout);
1684
1685   return result;
1686 }
1687
1688 void
1689 g_io_channel_win32_make_pollfd (GIOChannel   *channel,
1690                                 GIOCondition  condition,
1691                                 GPollFD      *fd)
1692 {
1693   GIOWin32Channel *win32_channel = (GIOWin32Channel *)channel;
1694
1695   if (win32_channel->data_avail_event == NULL)
1696     create_events (win32_channel);
1697
1698   fd->fd = (gint) win32_channel->data_avail_event;
1699   fd->events = condition;
1700
1701   if (win32_channel->thread_id == 0)
1702     {
1703       if ((condition & G_IO_IN) && win32_channel->type == G_IO_WIN32_FILE_DESC)
1704         create_thread (win32_channel, condition, read_thread);
1705       else if (win32_channel->type == G_IO_WIN32_SOCKET)
1706         create_thread (win32_channel, condition, select_thread);
1707     }
1708 }
1709
1710 /* Binary compatibility */
1711 GIOChannel *
1712 g_io_channel_win32_new_stream_socket (int socket)
1713 {
1714   return g_io_channel_win32_new_socket (socket);
1715 }