Revamp to be like makefile.mingw.in, make the MSVC build actually work
[platform/upstream/glib.git] / 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  *
8  * This library is free software; you can redistribute it and/or
9  * modify it under the terms of the GNU Lesser General Public
10  * License as published by the Free Software Foundation; either
11  * version 2 of the License, or (at your option) any later version.
12  *
13  * This library is distributed in the hope that it will be useful,
14  * but WITHOUT ANY WARRANTY; without even the implied warranty of
15  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
16  * Lesser General Public License for more details.
17  *
18  * You should have received a copy of the GNU Lesser General Public
19  * License along with this library; if not, write to the
20  * Free Software Foundation, Inc., 59 Temple Place - Suite 330,
21  * Boston, MA 02111-1307, USA.
22  */
23
24 /*
25  * Modified by the GLib Team and others 1997-2000.  See the AUTHORS
26  * file for a list of people on the GLib Team.  See the ChangeLog
27  * files for a list of changes.  These files are distributed with
28  * GLib at ftp://ftp.gtk.org/pub/gtk/.
29  */
30
31 /* Define this to get (very) verbose logging of all channels */
32 /* #define G_IO_WIN32_DEBUG */
33
34 #include "glib.h"
35
36 #include <stdlib.h>
37 #include <windows.h>
38 #include <winsock.h>          /* Not everybody has winsock2 */
39 #include <fcntl.h>
40 #include <io.h>
41 #include <process.h>
42 #include <errno.h>
43 #include <sys/stat.h>
44
45 typedef struct _GIOWin32Channel GIOWin32Channel;
46 typedef struct _GIOWin32Watch GIOWin32Watch;
47
48 #define BUFFER_SIZE 4096
49
50 typedef enum {
51   G_IO_WINDOWS_MESSAGES,        /* Windows messages */
52   G_IO_FILE_DESC,               /* Unix-like file descriptors from
53                                  * _open() or _pipe(). Read with read().
54                                  * Have to create separate thread to read.
55                                  */
56   G_IO_STREAM_SOCKET            /* Stream sockets. Similar as fds, but
57                                  * read with recv().
58                                  */
59 } GIOWin32ChannelType;
60
61 struct _GIOWin32Channel {
62   GIOChannel channel;
63   gint fd;                      /* Either a Unix-like file handle as provided
64                                  * by the Microsoft C runtime, or a SOCKET
65                                  * as provided by WinSock.
66                                  */
67   GIOWin32ChannelType type;
68   
69   gboolean debug;
70
71   /* This is used by G_IO_WINDOWS_MESSAGES channels */
72   HWND hwnd;                    /* handle of window, or NULL */
73   
74   /* Following fields used by fd and socket channels for input */
75   
76   /* Data is kept in a circular buffer. To be able to distinguish between
77    * empty and full buffer, we cannot fill it completely, but have to
78    * leave a one character gap.
79    *
80    * Data available is between indexes rdp and wrp-1 (modulo BUFFER_SIZE).
81    *
82    * Empty:    wrp == rdp
83    * Full:     (wrp + 1) % BUFFER_SIZE == rdp
84    * Partial:  otherwise
85    */
86   guchar *buffer;               /* (Circular) buffer */
87   gint wrp, rdp;                /* Buffer indices for writing and reading */
88   gboolean running;             /* Is reader thread running. FALSE if
89                                  * EOF has been reached.
90                                  */
91   guint thread_id;              /* If non-NULL has a reader thread, or has
92                                  * had.*/
93   HANDLE data_avail_event;
94   HANDLE space_avail_event;
95   CRITICAL_SECTION mutex;
96   
97   /* Function that actually reads from fd */
98   int (*reader) (int fd, guchar *buf, int len);
99 };
100
101 #define LOCK(mutex) EnterCriticalSection (&mutex)
102 #define UNLOCK(mutex) LeaveCriticalSection (&mutex)
103
104 struct _GIOWin32Watch {
105   GPollFD       pollfd;
106   GIOChannel   *channel;
107   GIOCondition  condition;
108   GIOFunc       callback;
109 };
110
111 static void
112 g_io_channel_win32_init (GIOWin32Channel *channel)
113 {
114 #ifdef G_IO_WIN32_DEBUG
115   channel->debug = TRUE;
116 #else
117   if (getenv ("G_IO_WIN32_DEBUG") != NULL)
118     channel->debug = TRUE;
119   else
120     channel->debug = FALSE;
121 #endif
122   channel->buffer = NULL;
123   channel->running = FALSE;
124   channel->thread_id = 0;
125   channel->data_avail_event = NULL;
126   channel->space_avail_event = NULL;
127 }
128
129 static void
130 create_events (GIOWin32Channel *channel)
131 {
132   SECURITY_ATTRIBUTES sec_attrs;
133   
134   sec_attrs.nLength = sizeof(SECURITY_ATTRIBUTES);
135   sec_attrs.lpSecurityDescriptor = NULL;
136   sec_attrs.bInheritHandle = FALSE;
137
138   /* The data available event is manual reset, the space available event
139    * is automatic reset.
140    */
141   if (!(channel->data_avail_event = CreateEvent (&sec_attrs, TRUE, FALSE, NULL))
142       || !(channel->space_avail_event = CreateEvent (&sec_attrs, FALSE, FALSE, NULL)))
143     {
144       gchar *msg = g_win32_error_message (GetLastError ());
145       g_error ("Error creating event: %s", msg);
146     }
147   InitializeCriticalSection (&channel->mutex);
148 }
149
150 static unsigned __stdcall
151 reader_thread (void *parameter)
152 {
153   GIOWin32Channel *channel = parameter;
154   guchar *buffer;
155   guint nbytes;
156
157   g_io_channel_ref ((GIOChannel *) channel);
158
159   if (channel->debug)
160     g_print ("thread %#x: starting. pid:%#x, fd:%d, data_avail:%#x, space_avail:%#x\n",
161              channel->thread_id,
162              (guint) GetCurrentProcessId (),
163              channel->fd,
164              (guint) channel->data_avail_event,
165              (guint) channel->space_avail_event);
166   
167   channel->buffer = g_malloc (BUFFER_SIZE);
168   channel->rdp = channel->wrp = 0;
169   channel->running = TRUE;
170
171   SetEvent (channel->space_avail_event);
172   
173   while (channel->running)
174     {
175       LOCK (channel->mutex);
176       if (channel->debug)
177         g_print ("thread %#x: rdp=%d, wrp=%d\n",
178                  channel->thread_id, channel->rdp, channel->wrp);
179       if ((channel->wrp + 1) % BUFFER_SIZE == channel->rdp)
180         {
181           /* Buffer is full */
182           if (channel->debug)
183             g_print ("thread %#x: resetting space_available\n",
184                      channel->thread_id);
185           ResetEvent (channel->space_avail_event);
186           if (channel->debug)
187             g_print ("thread %#x: waiting for space\n", channel->thread_id);
188           UNLOCK (channel->mutex);
189           WaitForSingleObject (channel->space_avail_event, INFINITE);
190           LOCK (channel->mutex);
191           if (channel->debug)
192             g_print ("thread %#x: rdp=%d, wrp=%d\n",
193                      channel->thread_id, channel->rdp, channel->wrp);
194         }
195       
196       buffer = channel->buffer + channel->wrp;
197       
198       /* Always leave at least one byte unused gap to be able to
199        * distinguish between the full and empty condition...
200        */
201       nbytes = MIN ((channel->rdp + BUFFER_SIZE - channel->wrp - 1) % BUFFER_SIZE,
202                     BUFFER_SIZE - channel->wrp);
203
204       UNLOCK (channel->mutex);
205
206       nbytes = (*channel->reader) (channel->fd, buffer, nbytes);
207       
208       if (nbytes <= 0)
209         break;
210
211       LOCK (channel->mutex);
212       if (channel->debug)
213         g_print ("thread %#x: got %d bytes, rdp=%d, wrp=%d\n",
214                  channel->thread_id, nbytes, channel->rdp, channel->wrp);
215       channel->wrp = (channel->wrp + nbytes) % BUFFER_SIZE;
216       if (channel->debug)
217         g_print ("thread %#x: rdp=%d, wrp=%d, setting data available\n",
218                  channel->thread_id, channel->rdp, channel->wrp);
219       SetEvent (channel->data_avail_event);
220       UNLOCK (channel->mutex);
221     }
222   
223   LOCK (channel->mutex);
224   channel->running = FALSE;
225   if (channel->debug)
226     g_print ("thread %#x: got EOF, rdp=%d, wrp=%d, setting data available\n",
227              channel->thread_id, channel->rdp, channel->wrp);
228   SetEvent (channel->data_avail_event);
229   UNLOCK (channel->mutex);
230   
231   g_io_channel_unref((GIOChannel *) channel);
232   
233   /* All of the Microsoft docs say we should explicitly
234    * end the thread...
235    */
236   _endthreadex(1);
237   
238   return 0;
239 }
240
241 static void
242 create_reader_thread (GIOWin32Channel *channel,
243                       gpointer         reader)
244 {
245   channel->reader = reader;
246
247   if (_beginthreadex (NULL, 0, reader_thread, channel, 0,
248                       &channel->thread_id) == 0)
249     g_warning ("Error creating reader thread: %s", strerror (errno));
250   WaitForSingleObject (channel->space_avail_event, INFINITE);
251 }
252
253 static int
254 buffer_read (GIOWin32Channel *channel,
255              guchar          *dest,
256              guint            count,
257              GIOError        *error)
258 {
259   guint nbytes;
260   guint left = count;
261   
262   LOCK (channel->mutex);
263   if (channel->debug)
264     g_print ("reading from thread %#x %d bytes, rdp=%d, wrp=%d\n",
265              channel->thread_id, count, channel->rdp, channel->wrp);
266   
267   if (channel->rdp == channel->wrp)
268     {
269       UNLOCK (channel->mutex);
270       if (channel->debug)
271         g_print ("waiting for data from thread %#x\n", channel->thread_id);
272       WaitForSingleObject (channel->data_avail_event, INFINITE);
273       LOCK (channel->mutex);
274       if (channel->rdp == channel->wrp && !channel->running)
275         {
276           UNLOCK (channel->mutex);
277           return 0;
278         }
279     }
280   
281   if (channel->rdp < channel->wrp)
282     nbytes = channel->wrp - channel->rdp;
283   else
284     nbytes = BUFFER_SIZE - channel->rdp;
285   UNLOCK (channel->mutex);
286   nbytes = MIN (left, nbytes);
287   if (channel->debug)
288     g_print ("moving %d bytes from thread %#x\n",
289              nbytes, channel->thread_id);
290   memcpy (dest, channel->buffer + channel->rdp, nbytes);
291   dest += nbytes;
292   left -= nbytes;
293   LOCK (channel->mutex);
294   channel->rdp = (channel->rdp + nbytes) % BUFFER_SIZE;
295   if (channel->debug)
296     g_print ("setting space available for thread %#x\n", channel->thread_id);
297   SetEvent (channel->space_avail_event);
298   if (channel->debug)
299     g_print ("for thread %#x: rdp=%d, wrp=%d\n",
300              channel->thread_id, channel->rdp, channel->wrp);
301   if (channel->running && channel->rdp == channel->wrp)
302     {
303       if (channel->debug)
304         g_print ("resetting data_available of thread %#x\n",
305                  channel->thread_id);
306       ResetEvent (channel->data_avail_event);
307     };
308   UNLOCK (channel->mutex);
309   
310   /* We have no way to indicate any errors form the actual
311    * read() or recv() call in the reader thread. Should we have?
312    */
313   *error = G_IO_ERROR_NONE;
314   return count - left;
315 }
316
317 static gboolean
318 g_io_win32_prepare (gpointer  source_data,
319                     GTimeVal *current_time,
320                     gint     *timeout,
321                     gpointer  user_data)
322 {
323   *timeout = -1;
324   
325   return FALSE;
326 }
327
328 static gboolean
329 g_io_win32_check (gpointer  source_data,
330                   GTimeVal *current_time,
331                   gpointer  user_data)
332 {
333   GIOWin32Watch *data = source_data;
334   GIOWin32Channel *channel = (GIOWin32Channel *) data->channel;
335   
336   /* If the thread has died, we have encountered EOF. If the buffer
337    * also is emtpty set the HUP bit.
338    */
339   if (!channel->running && channel->rdp == channel->wrp)
340     {
341       if (channel->debug)
342         g_print ("g_io_win32_check: setting G_IO_HUP thread %#x rdp=%d wrp=%d\n",
343                  channel->thread_id, channel->rdp, channel->wrp);
344       data->pollfd.revents |= G_IO_HUP;
345       return TRUE;
346     }
347   
348   return (data->pollfd.revents & data->condition);
349 }
350
351 static gboolean
352 g_io_win32_dispatch (gpointer  source_data,
353                      GTimeVal *current_time,
354                      gpointer  user_data)
355      
356 {
357   GIOWin32Watch *data = source_data;
358   
359   return (*data->callback) (data->channel,
360                             data->pollfd.revents & data->condition,
361                             user_data);
362 }
363
364 static void
365 g_io_win32_destroy (gpointer source_data)
366 {
367   GIOWin32Watch *data = source_data;
368   
369   g_main_remove_poll (&data->pollfd);
370   g_io_channel_unref (data->channel);
371   g_free (data);
372 }
373
374 static GSourceFuncs win32_watch_funcs = {
375   g_io_win32_prepare,
376   g_io_win32_check,
377   g_io_win32_dispatch,
378   g_io_win32_destroy
379 };
380
381 static guint
382 g_io_win32_add_watch (GIOChannel    *channel,
383                       gint           priority,
384                       GIOCondition   condition,
385                       GIOFunc        func,
386                       gpointer       user_data,
387                       GDestroyNotify notify,
388                       int (*reader) (int, guchar *, int))
389 {
390   GIOWin32Watch *watch = g_new (GIOWin32Watch, 1);
391   GIOWin32Channel *win32_channel = (GIOWin32Channel *) channel;
392   
393   watch->channel = channel;
394   g_io_channel_ref (channel);
395   
396   watch->callback = func;
397   watch->condition = condition;
398   
399   if (win32_channel->data_avail_event == NULL)
400     create_events (win32_channel);
401
402   watch->pollfd.fd = (gint) win32_channel->data_avail_event;
403   watch->pollfd.events = condition;
404   
405   if (win32_channel->debug)
406     g_print ("g_io_win32_add_watch: fd:%d handle:%#x\n",
407              win32_channel->fd, watch->pollfd.fd);
408   
409   if (win32_channel->thread_id == 0)
410     create_reader_thread (win32_channel, reader);
411
412   g_main_add_poll (&watch->pollfd, priority);
413   
414   return g_source_add (priority, TRUE, &win32_watch_funcs, watch,
415                        user_data, notify);
416 }
417
418 static GIOError
419 g_io_win32_msg_read (GIOChannel *channel,
420                      gchar      *buf,
421                      guint       count,
422                      guint      *bytes_read)
423 {
424   GIOWin32Channel *win32_channel = (GIOWin32Channel *) channel;
425   MSG msg;               /* In case of alignment problems */
426   
427   if (count < sizeof (MSG))
428     return G_IO_ERROR_INVAL;
429   
430   if (!PeekMessage (&msg, win32_channel->hwnd, 0, 0, PM_REMOVE))
431     return G_IO_ERROR_AGAIN;
432   
433   memmove (buf, &msg, sizeof (MSG));
434   *bytes_read = sizeof (MSG);
435   return G_IO_ERROR_NONE;
436 }
437
438 static GIOError
439 g_io_win32_msg_write (GIOChannel *channel,
440                       gchar      *buf,
441                       guint       count,
442                       guint      *bytes_written)
443 {
444   GIOWin32Channel *win32_channel = (GIOWin32Channel *) channel;
445   MSG msg;
446   
447   if (count != sizeof (MSG))
448     return G_IO_ERROR_INVAL;
449   
450   /* In case of alignment problems */
451   memmove (&msg, buf, sizeof (MSG));
452   if (!PostMessage (win32_channel->hwnd, msg.message, msg.wParam, msg.lParam))
453     return G_IO_ERROR_UNKNOWN;
454   
455   *bytes_written = sizeof (MSG);
456   return G_IO_ERROR_NONE;
457 }
458
459 static GIOError
460 g_io_win32_no_seek (GIOChannel *channel,
461                     gint        offset,
462                     GSeekType   type)
463 {
464   return G_IO_ERROR_UNKNOWN;
465 }
466
467 static void
468 g_io_win32_msg_close (GIOChannel *channel)
469 {
470   /* Nothing to be done. Or should we set hwnd to some invalid value? */
471 }
472
473 static void
474 g_io_win32_free (GIOChannel *channel)
475 {
476   GIOWin32Channel *win32_channel = (GIOWin32Channel *) channel;
477   
478   if (win32_channel->buffer)
479     {
480       CloseHandle (win32_channel->data_avail_event);
481       CloseHandle (win32_channel->space_avail_event);
482       DeleteCriticalSection (&win32_channel->mutex);
483     }
484
485   g_free (win32_channel->buffer);
486   g_free (win32_channel);
487 }
488
489 static guint
490 g_io_win32_msg_add_watch (GIOChannel    *channel,
491                           gint           priority,
492                           GIOCondition   condition,
493                           GIOFunc        func,
494                           gpointer       user_data,
495                           GDestroyNotify notify)
496 {
497   GIOWin32Watch *watch = g_new (GIOWin32Watch, 1);
498   
499   watch->channel = channel;
500   g_io_channel_ref (channel);
501   
502   watch->callback = func;
503   watch->condition = condition;
504   
505   watch->pollfd.fd = G_WIN32_MSG_HANDLE;
506   watch->pollfd.events = condition;
507   
508   g_main_add_poll (&watch->pollfd, priority);
509   
510   return g_source_add (priority, TRUE, &win32_watch_funcs,
511                        watch, user_data, notify);
512 }
513
514 static GIOError
515 g_io_win32_fd_read (GIOChannel *channel,
516                     gchar      *buf,
517                     guint       count,
518                     guint      *bytes_read)
519 {
520   GIOWin32Channel *win32_channel = (GIOWin32Channel *) channel;
521   gint result;
522   GIOError error;
523   
524   if (win32_channel->debug)
525     g_print ("g_io_win32_fd_read: fd:%d count:%d\n",
526              win32_channel->fd, count);
527   
528   if (win32_channel->thread_id)
529     {
530       result = buffer_read (win32_channel, buf, count, &error);
531       if (result < 0)
532         {
533           *bytes_read = 0;
534           return error;
535         }
536       else
537         {
538           *bytes_read = result;
539           return G_IO_ERROR_NONE;
540         }
541     }
542
543   result = read (win32_channel->fd, buf, count);
544
545   if (result < 0)
546     {
547       *bytes_read = 0;
548       if (errno == EINVAL)
549         return G_IO_ERROR_INVAL;
550       else
551         return G_IO_ERROR_UNKNOWN;
552     }
553   else
554     {
555       *bytes_read = result;
556       return G_IO_ERROR_NONE;
557     }
558 }
559
560 static GIOError
561 g_io_win32_fd_write (GIOChannel *channel,
562                      gchar      *buf,
563                      guint       count,
564                      guint      *bytes_written)
565 {
566   GIOWin32Channel *win32_channel = (GIOWin32Channel *) channel;
567   gint result;
568   
569   result = write (win32_channel->fd, buf, count);
570   if (win32_channel->debug)
571     g_print ("g_io_win32_fd_write: fd:%d count:%d = %d\n",
572              win32_channel->fd, count, result);
573   
574   if (result < 0)
575     {
576       *bytes_written = 0;
577       switch (errno)
578         {
579         case EINVAL:
580           return G_IO_ERROR_INVAL;
581         case EAGAIN:
582           return G_IO_ERROR_AGAIN;
583         default:
584           return G_IO_ERROR_UNKNOWN;
585         }
586     }
587   else
588     {
589       *bytes_written = result;
590       return G_IO_ERROR_NONE;
591     }
592 }
593
594 static GIOError
595 g_io_win32_fd_seek (GIOChannel *channel,
596                     gint        offset,
597                     GSeekType   type)
598 {
599   GIOWin32Channel *win32_channel = (GIOWin32Channel *) channel;
600   int whence;
601   off_t result;
602   
603   switch (type)
604     {
605     case G_SEEK_SET:
606       whence = SEEK_SET;
607       break;
608     case G_SEEK_CUR:
609       whence = SEEK_CUR;
610       break;
611     case G_SEEK_END:
612       whence = SEEK_END;
613       break;
614     default:
615       g_warning ("g_io_win32_fd_seek: unknown seek type");
616       return G_IO_ERROR_UNKNOWN;
617     }
618   
619   result = lseek (win32_channel->fd, offset, whence);
620   
621   if (result < 0)
622     {
623       switch (errno)
624         {
625         case EINVAL:
626           return G_IO_ERROR_INVAL;
627         default:
628           return G_IO_ERROR_UNKNOWN;
629         }
630     }
631   else
632     return G_IO_ERROR_NONE;
633 }
634
635 static void
636 g_io_win32_fd_close (GIOChannel *channel)
637 {
638   GIOWin32Channel *win32_channel = (GIOWin32Channel *) channel;
639   
640   close (win32_channel->fd);
641   return;
642 }
643
644 static int
645 fd_reader (int     fd,
646            guchar *buf,
647            int     len)
648 {
649   return read (fd, buf, len);
650 }
651
652 static guint
653 g_io_win32_fd_add_watch (GIOChannel    *channel,
654                          gint           priority,
655                          GIOCondition   condition,
656                          GIOFunc        func,
657                          gpointer       user_data,
658                          GDestroyNotify notify)
659 {
660   return g_io_win32_add_watch (channel, priority, condition,
661                                func, user_data, notify, fd_reader);
662 }
663
664 static GIOError
665 g_io_win32_sock_read (GIOChannel *channel,
666                       gchar      *buf,
667                       guint       count,
668                       guint      *bytes_read)
669 {
670   GIOWin32Channel *win32_channel = (GIOWin32Channel *) channel;
671   gint result;
672   GIOError error;
673   
674   if (win32_channel->thread_id)
675     {
676       result = buffer_read (win32_channel, buf, count, &error);
677       if (result < 0)
678         {
679           *bytes_read = 0;
680           return error;
681         }
682       else
683         {
684           *bytes_read = result;
685           return G_IO_ERROR_NONE;
686         }
687     }
688
689   result = recv (win32_channel->fd, buf, count, 0);
690
691   if (result < 0)
692     {
693       *bytes_read = 0;
694       return G_IO_ERROR_UNKNOWN;
695     }
696   else
697     {
698       *bytes_read = result;
699       return G_IO_ERROR_NONE;
700     }
701 }
702
703 static GIOError
704 g_io_win32_sock_write (GIOChannel *channel,
705                        gchar      *buf,
706                        guint       count,
707                        guint      *bytes_written)
708 {
709   GIOWin32Channel *win32_channel = (GIOWin32Channel *) channel;
710   gint result;
711   
712   result = send (win32_channel->fd, buf, count, 0);
713   
714   if (result == SOCKET_ERROR)
715     {
716       *bytes_written = 0;
717       switch (WSAGetLastError ())
718         {
719         case WSAEINVAL:
720           return G_IO_ERROR_INVAL;
721         case WSAEWOULDBLOCK:
722         case WSAEINTR:
723           return G_IO_ERROR_AGAIN;
724         default:
725           return G_IO_ERROR_UNKNOWN;
726         }
727     }
728   else
729     {
730       *bytes_written = result;
731       return G_IO_ERROR_NONE;
732     }
733 }
734
735 static void
736 g_io_win32_sock_close (GIOChannel *channel)
737 {
738   GIOWin32Channel *win32_channel = (GIOWin32Channel *) channel;
739
740   closesocket (win32_channel->fd);
741 }
742
743 static int
744 sock_reader (int     fd,
745              guchar *buf,
746              int     len)
747 {
748   return recv (fd, buf, len, 0);
749 }
750
751 static guint
752 g_io_win32_sock_add_watch (GIOChannel    *channel,
753                            gint           priority,
754                            GIOCondition   condition,
755                            GIOFunc        func,
756                            gpointer       user_data,
757                            GDestroyNotify notify)
758 {
759   return g_io_win32_add_watch (channel, priority, condition,
760                                func, user_data, notify, sock_reader);
761 }
762
763 static GIOFuncs win32_channel_msg_funcs = {
764   g_io_win32_msg_read,
765   g_io_win32_msg_write,
766   g_io_win32_no_seek,
767   g_io_win32_msg_close,
768   g_io_win32_msg_add_watch,
769   g_io_win32_free
770 };
771
772 static GIOFuncs win32_channel_fd_funcs = {
773   g_io_win32_fd_read,
774   g_io_win32_fd_write,
775   g_io_win32_fd_seek,
776   g_io_win32_fd_close,
777   g_io_win32_fd_add_watch,
778   g_io_win32_free
779 };
780
781 static GIOFuncs win32_channel_sock_funcs = {
782   g_io_win32_sock_read,
783   g_io_win32_sock_write,
784   g_io_win32_no_seek,
785   g_io_win32_sock_close,
786   g_io_win32_sock_add_watch,
787   g_io_win32_free
788 };
789
790 GIOChannel *
791 g_io_channel_win32_new_messages (guint hwnd)
792 {
793   GIOWin32Channel *win32_channel = g_new (GIOWin32Channel, 1);
794   GIOChannel *channel = (GIOChannel *) win32_channel;
795
796   g_io_channel_init (channel);
797   g_io_channel_win32_init (win32_channel);
798   channel->funcs = &win32_channel_msg_funcs;
799   win32_channel->type = G_IO_WINDOWS_MESSAGES;
800   win32_channel->hwnd = (HWND) hwnd;
801
802   return channel;
803 }
804
805 GIOChannel *
806 g_io_channel_win32_new_fd (gint fd)
807 {
808   GIOWin32Channel *win32_channel;
809   GIOChannel *channel;
810   struct stat st;
811
812   if (fstat (fd, &st) == -1)
813     {
814       g_warning ("%d isn't a (emulated) file descriptor", fd);
815       return NULL;
816     }
817
818   win32_channel = g_new (GIOWin32Channel, 1);
819   channel = (GIOChannel *) win32_channel;
820
821   g_io_channel_init (channel);
822   g_io_channel_win32_init (win32_channel);
823   channel->funcs = &win32_channel_fd_funcs;
824   win32_channel->type = G_IO_FILE_DESC;
825   win32_channel->fd = fd;
826
827   return channel;
828 }
829
830 gint
831 g_io_channel_win32_get_fd (GIOChannel *channel)
832 {
833   GIOWin32Channel *win32_channel = (GIOWin32Channel *) channel;
834
835   return win32_channel->fd;
836 }
837
838 GIOChannel *
839 g_io_channel_win32_new_stream_socket (int socket)
840 {
841   GIOWin32Channel *win32_channel = g_new (GIOWin32Channel, 1);
842   GIOChannel *channel = (GIOChannel *) win32_channel;
843
844   g_io_channel_init (channel);
845   g_io_channel_win32_init (win32_channel);
846   channel->funcs = &win32_channel_sock_funcs;
847   win32_channel->type = G_IO_STREAM_SOCKET;
848   win32_channel->fd = socket;
849
850   return channel;
851 }
852
853 GIOChannel *
854 g_io_channel_unix_new (gint fd)
855 {
856   return g_io_channel_win32_new_fd (fd);
857 }
858
859 gint
860 g_io_channel_unix_get_fd (GIOChannel *channel)
861 {
862   return g_io_channel_win32_get_fd (channel);
863 }
864
865 void
866 g_io_channel_win32_set_debug (GIOChannel *channel,
867                               gboolean    flag)
868 {
869   GIOWin32Channel *win32_channel = (GIOWin32Channel *) channel;
870
871   win32_channel->debug = flag;
872 }
873
874 gint
875 g_io_channel_win32_poll (GPollFD *fds,
876                          gint     n_fds,
877                          gint     timeout)
878 {
879   int i;
880   int result;
881   gboolean debug = FALSE;
882
883   g_return_val_if_fail (n_fds >= 0, 0);
884
885   result = (*g_main_win32_get_poll_func ()) (fds, n_fds, timeout);
886
887   return result;
888 }
889
890 void
891 g_io_channel_win32_make_pollfd (GIOChannel   *channel,
892                                 GIOCondition  condition,
893                                 GPollFD      *fd)
894 {
895   GIOWin32Channel *win32_channel = (GIOWin32Channel *) channel;
896
897   if (win32_channel->data_avail_event == NULL)
898     create_events (win32_channel);
899   
900   fd->fd = (gint) win32_channel->data_avail_event;
901   fd->events = condition;
902
903   if (win32_channel->thread_id == 0)
904     if (win32_channel->type == G_IO_FILE_DESC)
905       create_reader_thread (win32_channel, fd_reader);
906     else if (win32_channel->type == G_IO_STREAM_SOCKET)
907       create_reader_thread (win32_channel, sock_reader);
908 }
909
910 gint
911 g_io_channel_win32_wait_for_condition (GIOChannel  *channel,
912                                        GIOCondition condition,
913                                        gint         timeout)
914 {
915   GPollFD pollfd;
916   GIOWin32Channel *win32_channel = (GIOWin32Channel *) channel;
917
918   g_io_channel_win32_make_pollfd (channel, condition, &pollfd);
919   
920   return g_io_channel_win32_poll (&pollfd, 1, timeout);
921 }
922
923 /* This variable and the functions below are present just to be 
924  * binary compatible with old clients... But note that in GIMP, the
925  * libgimp/gimp.c:gimp_extension_process() function will have to be modified
926  * anyhow for this new approach.
927  *
928  * These will be removed after some weeks.
929  */
930 guint g_pipe_readable_msg = 0;
931
932 GIOChannel *
933 g_io_channel_win32_new_pipe (int fd)
934 {
935   return g_io_channel_win32_new_fd (fd);
936 }
937
938 GIOChannel *
939 g_io_channel_win32_new_pipe_with_wakeups (int   fd,
940                                           guint peer,
941                                           int   peer_fd)
942 {
943   return g_io_channel_win32_new_fd (fd);
944 }
945
946 void
947 g_io_channel_win32_pipe_request_wakeups (GIOChannel *channel,
948                                          guint       peer,
949                                          int         peer_fd)
950 {
951   /* Nothing needed now */
952 }
953
954 void
955 g_io_channel_win32_pipe_readable (gint  fd,
956                                   guint offset)
957 {
958   /* Nothing needed now */
959 }
960