# HG changeset patch # User Daniel Atallah # Date 1161018881 0 # Node ID 5b389aacc06b83d811d18d747441992904e8f4a5 # Parent b7e145ea9076e5c0a677bbbd9e64dde8f123a0fa [gaim-migrate @ 17486] Add the thread-based win32 giochannel implementation from glib 2.6.6 to our src tree. This way we can use GTK+ >= 2.8.0 and still use the iochannel implementation that works for us. Hopefully at some point we can use the more efficient 2.8.x giochannel implementation. committer: Tailor Script diff -r b7e145ea9076 -r 5b389aacc06b gtk/gtkeventloop.c --- a/gtk/gtkeventloop.c Mon Oct 16 14:50:20 2006 +0000 +++ b/gtk/gtkeventloop.c Mon Oct 16 17:14:41 2006 +0000 @@ -26,6 +26,7 @@ #include #include "gtkeventloop.h" #include "eventloop.h" +#include "win32dep.h" #define GAIM_GTK_READ_COND (G_IO_IN | G_IO_HUP | G_IO_ERR) #define GAIM_GTK_WRITE_COND (G_IO_OUT | G_IO_HUP | G_IO_ERR | G_IO_NVAL) @@ -92,7 +93,11 @@ if (condition & GAIM_INPUT_WRITE) cond |= GAIM_GTK_WRITE_COND; +#ifdef _WIN32 + channel = wgaim_g_io_channel_win32_new_socket(fd); +#else channel = g_io_channel_unix_new(fd); +#endif closure->result = g_io_add_watch_full(channel, G_PRIORITY_DEFAULT, cond, gaim_gtk_io_invoke, closure, gaim_gtk_io_destroy); diff -r b7e145ea9076 -r 5b389aacc06b libgaim/Makefile.am --- a/libgaim/Makefile.am Mon Oct 16 14:50:20 2006 +0000 +++ b/libgaim/Makefile.am Mon Oct 16 17:14:41 2006 +0000 @@ -16,6 +16,7 @@ win32/targets.mak \ win32/wgaimerror.h \ win32/win32dep.c \ + win32/giowin32.c \ win32/win32dep.h if USE_GCONFTOOL diff -r b7e145ea9076 -r 5b389aacc06b libgaim/Makefile.mingw --- a/libgaim/Makefile.mingw Mon Oct 16 14:50:20 2006 +0000 +++ b/libgaim/Makefile.mingw Mon Oct 16 17:14:41 2006 +0000 @@ -73,6 +73,7 @@ value.c \ xmlnode.c \ whiteboard.c \ + win32/giowin32.c \ win32/libc_interface.c \ win32/win32dep.c diff -r b7e145ea9076 -r 5b389aacc06b libgaim/win32/giowin32.c --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/libgaim/win32/giowin32.c Mon Oct 16 17:14:41 2006 +0000 @@ -0,0 +1,857 @@ +/* GLIB - Library of useful routines for C programming + * Copyright (C) 1995-1997 Peter Mattis, Spencer Kimball and Josh MacDonald + * + * giowin32.c: IO Channels for Win32. + * Copyright 1998 Owen Taylor and Tor Lillqvist + * Copyright 1999-2000 Tor Lillqvist and Craig Setera + * Copyright 2001-2003 Andrew Lanoix + * + * This library is free software; you can redistribute it and/or + * modify it under the terms of the GNU Lesser General Public + * License as published by the Free Software Foundation; either + * version 2 of the License, or (at your option) any later version. + * + * This library is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU + * Lesser General Public License for more details. + * + * You should have received a copy of the GNU Lesser General Public + * License along with this library; if not, write to the + * Free Software Foundation, Inc., 59 Temple Place - Suite 330, + * Boston, MA 02111-1307, USA. + */ + +/* + * Modified by the GLib Team and others 1997-2000. See the AUTHORS + * file for a list of people on the GLib Team. See the ChangeLog + * files for a list of changes. These files are distributed with + * GLib at ftp://ftp.gtk.org/pub/gtk/. + */ + +/* Define this to get (very) verbose logging of all channels */ +/* #define G_IO_WIN32_DEBUG */ + +//#include "config.h" + +#include + +#include +#include +#include /* Not everybody has winsock2 */ +#include +#include +#include +#include +#include + +#include + +typedef struct _GIOWin32Channel GIOWin32Channel; +typedef struct _GIOWin32Watch GIOWin32Watch; + +#define BUFFER_SIZE 4096 + +typedef enum { + G_IO_WIN32_WINDOWS_MESSAGES, /* Windows messages */ + G_IO_WIN32_FILE_DESC, /* Unix-like file descriptors from + * _open() or _pipe(). Read with read(). + * Have to create separate thread to read. + */ + G_IO_WIN32_SOCKET /* Sockets. A separate thread is blocked + * in select() most of the time. + */ +} GIOWin32ChannelType; + +struct _GIOWin32Channel { + GIOChannel channel; + gint fd; /* Either a Unix-like file handle as provided + * by the Microsoft C runtime, or a SOCKET + * as provided by WinSock. + */ + GIOWin32ChannelType type; + + gboolean debug; + + CRITICAL_SECTION mutex; + + /* This is used by G_IO_WIN32_WINDOWS_MESSAGES channels */ + HWND hwnd; /* handle of window, or NULL */ + + /* Following fields are used by both fd and socket channels. */ + gboolean running; /* Is reader thread running. FALSE if + * EOF has been reached. + */ + gboolean needs_close; /* If the channel has been closed while + * the reader thread was still running. + */ + guint thread_id; /* If non-NULL has a reader thread, or has + * had.*/ + HANDLE data_avail_event; + + gushort revents; + + /* Following fields used by fd channels for input */ + + /* Data is kept in a circular buffer. To be able to distinguish between + * empty and full buffer, we cannot fill it completely, but have to + * leave a one character gap. + * + * Data available is between indexes rdp and wrp-1 (modulo BUFFER_SIZE). + * + * Empty: wrp == rdp + * Full: (wrp + 1) % BUFFER_SIZE == rdp + * Partial: otherwise + */ + guchar *buffer; /* (Circular) buffer */ + gint wrp, rdp; /* Buffer indices for writing and reading */ + HANDLE space_avail_event; + + /* Following fields used by socket channels */ + GSList *watches; + HANDLE data_avail_noticed_event; + gint reset_send; /* socket used to send data so select_thread() can reset/re-loop */ + gint reset_recv; /* socket used to recv data so select_thread() can reset/re-loop */ +}; + +#define LOCK(mutex) EnterCriticalSection (&mutex) +#define UNLOCK(mutex) LeaveCriticalSection (&mutex) + +struct _GIOWin32Watch { + GSource source; + GPollFD pollfd; + GIOChannel *channel; + GIOCondition condition; +}; + +static void +g_win32_print_gioflags (GIOFlags flags) +{ + char *bar = ""; + + if (flags & G_IO_FLAG_APPEND) + bar = "|", g_print ("APPEND"); + if (flags & G_IO_FLAG_NONBLOCK) + g_print ("%sNONBLOCK", bar), bar = "|"; + if (flags & G_IO_FLAG_IS_READABLE) + g_print ("%sREADABLE", bar), bar = "|"; + if (flags & G_IO_FLAG_IS_WRITEABLE) + g_print ("%sWRITEABLE", bar), bar = "|"; + if (flags & G_IO_FLAG_IS_SEEKABLE) + g_print ("%sSEEKABLE", bar), bar = "|"; +} + +static gboolean +g_io_win32_get_debug_flag (void) +{ +#ifdef G_IO_WIN32_DEBUG + return TRUE; +#else + if (getenv ("G_IO_WIN32_DEBUG") != NULL) + return TRUE; + else + return FALSE; +#endif +} + +static void +g_io_channel_win32_init (GIOWin32Channel *channel) +{ + channel->debug = g_io_win32_get_debug_flag (); + channel->buffer = NULL; + channel->running = FALSE; + channel->needs_close = FALSE; + channel->thread_id = 0; + channel->data_avail_event = NULL; + channel->revents = 0; + channel->space_avail_event = NULL; + channel->reset_send = INVALID_SOCKET; + channel->reset_recv = INVALID_SOCKET; + channel->data_avail_noticed_event = NULL; + channel->watches = NULL; + InitializeCriticalSection (&channel->mutex); +} + +static void +create_events (GIOWin32Channel *channel) +{ + SECURITY_ATTRIBUTES sec_attrs; + + sec_attrs.nLength = sizeof (SECURITY_ATTRIBUTES); + sec_attrs.lpSecurityDescriptor = NULL; + sec_attrs.bInheritHandle = FALSE; + + /* The data available event is manual reset, the space available event + * is automatic reset. + */ + if (!(channel->data_avail_event = CreateEvent (&sec_attrs, TRUE, FALSE, NULL)) + || !(channel->space_avail_event = CreateEvent (&sec_attrs, FALSE, FALSE, NULL)) + || !(channel->data_avail_noticed_event = CreateEvent (&sec_attrs, FALSE, FALSE, NULL))) + { + gchar *emsg = g_win32_error_message (GetLastError ()); + g_error ("Error creating event: %s", emsg); + g_free (emsg); + } +} + +static void +create_thread (GIOWin32Channel *channel, + GIOCondition condition, + unsigned (__stdcall *thread) (void *parameter)) +{ + HANDLE thread_handle; + + thread_handle = (HANDLE) _beginthreadex (NULL, 0, thread, channel, 0, + &channel->thread_id); + if (thread_handle == 0) + g_warning (G_STRLOC ": Error creating reader thread: %s", + g_strerror (errno)); + else if (!CloseHandle (thread_handle)) + g_warning (G_STRLOC ": Error closing thread handle: %s\n", + g_win32_error_message (GetLastError ())); + + WaitForSingleObject (channel->space_avail_event, INFINITE); +} + +static void +init_reset_sockets (GIOWin32Channel *channel) +{ + struct sockaddr_in local, local2, server; + int len; + + channel->reset_send = (gint) socket (AF_INET, SOCK_DGRAM, 0); + if (channel->reset_send == INVALID_SOCKET) + { + g_warning (G_STRLOC ": Error creating reset_send socket: %s\n", + g_win32_error_message (WSAGetLastError ())); + } + + local.sin_family = AF_INET; + local.sin_port = 0; + local.sin_addr.s_addr = htonl (INADDR_LOOPBACK); + + if (bind (channel->reset_send, (struct sockaddr *)&local, sizeof (local)) == SOCKET_ERROR) + { + g_warning (G_STRLOC ": Error binding to reset_send socket: %s\n", + g_win32_error_message (WSAGetLastError ())); + } + + local2.sin_family = AF_INET; + local2.sin_port = 0; + local2.sin_addr.s_addr = htonl (INADDR_LOOPBACK); + + channel->reset_recv = (gint) socket (AF_INET, SOCK_DGRAM, 0); + if (channel->reset_recv == INVALID_SOCKET) + { + g_warning (G_STRLOC ": Error creating reset_recv socket: %s\n", + g_win32_error_message (WSAGetLastError ())); + } + + if (bind (channel->reset_recv, (struct sockaddr *)&local2, sizeof (local)) == SOCKET_ERROR) + { + g_warning (G_STRLOC ": Error binding to reset_recv socket: %s\n", + g_win32_error_message (WSAGetLastError ())); + } + + len = sizeof (local2); + if (getsockname (channel->reset_recv, (struct sockaddr *)&local2, &len) == SOCKET_ERROR) + { + g_warning (G_STRLOC ": Error getsockname with reset_recv socket: %s\n", + g_win32_error_message (WSAGetLastError ())); + } + + memset (&server, 0, sizeof (server)); + server.sin_addr.s_addr = htonl (INADDR_LOOPBACK); + server.sin_family = AF_INET; + server.sin_port = local2.sin_port; + + if (connect (channel->reset_send, (struct sockaddr *)&server, sizeof (server)) == SOCKET_ERROR) + { + g_warning (G_STRLOC ": connect to reset_recv socket: %s\n", + g_win32_error_message (WSAGetLastError ())); + } + +} + +static unsigned __stdcall +select_thread (void *parameter) +{ + GIOWin32Channel *channel = parameter; + fd_set read_fds, write_fds, except_fds; + GSList *tmp; + int n; + char buffer[8]; + + g_io_channel_ref ((GIOChannel *)channel); + + if (channel->debug) + g_print ("select_thread %#x: start fd:%d data_avail:%#x data_avail_noticed:%#x\n", + channel->thread_id, + channel->fd, + (guint) channel->data_avail_event, + (guint) channel->data_avail_noticed_event); + + channel->rdp = channel->wrp = 0; + channel->running = TRUE; + + SetEvent (channel->space_avail_event); + + while (channel->running) + { + FD_ZERO (&read_fds); + FD_ZERO (&write_fds); + FD_ZERO (&except_fds); + FD_SET (channel->reset_recv, &read_fds); + + LOCK (channel->mutex); + tmp = channel->watches; + while (tmp) + { + GIOWin32Watch *watch = (GIOWin32Watch *)tmp->data; + + if (watch->condition & (G_IO_IN | G_IO_HUP)) + FD_SET (channel->fd, &read_fds); + if (watch->condition & G_IO_OUT) + FD_SET (channel->fd, &write_fds); + if (watch->condition & G_IO_ERR) + FD_SET (channel->fd, &except_fds); + + tmp = tmp->next; + } + UNLOCK (channel->mutex); + + if (channel->debug) + g_print ("select_thread %#x: calling select() for%s%s%s\n", + channel->thread_id, + (FD_ISSET (channel->fd, &read_fds) ? " IN" : ""), + (FD_ISSET (channel->fd, &write_fds) ? " OUT" : ""), + (FD_ISSET (channel->fd, &except_fds) ? " ERR" : "")); + + n = select (1, &read_fds, &write_fds, &except_fds, NULL); + + LOCK (channel->mutex); + if (channel->needs_close) + { + UNLOCK (channel->mutex); + break; + } + UNLOCK (channel->mutex); + + if (n == SOCKET_ERROR) + { + if (channel->debug) + g_print ("select_thread %#x: select returned SOCKET_ERROR\n", + channel->thread_id); + break; + } + + if (FD_ISSET (channel->reset_recv, &read_fds)) + { + if (channel->debug) + g_print ("select_thread %#x: re-looping\n", + channel->thread_id); + recv (channel->reset_recv, (char *)&buffer, (int) sizeof (buffer), 0); + continue; + } + + if (channel->debug) + g_print ("select_thread %#x: got%s%s%s\n", + channel->thread_id, + (FD_ISSET (channel->fd, &read_fds) ? " IN" : ""), + (FD_ISSET (channel->fd, &write_fds) ? " OUT" : ""), + (FD_ISSET (channel->fd, &except_fds) ? " ERR" : "")); + + if (FD_ISSET (channel->fd, &read_fds)) + channel->revents |= G_IO_IN; + if (FD_ISSET (channel->fd, &write_fds)) + channel->revents |= G_IO_OUT; + if (FD_ISSET (channel->fd, &except_fds)) + channel->revents |= G_IO_ERR; + + if (channel->debug) + g_print ("select_thread %#x: resetting data_avail_noticed, setting data_avail\n", + channel->thread_id); + + LOCK (channel->mutex); + ResetEvent (channel->data_avail_noticed_event); + SetEvent (channel->data_avail_event); + if (channel->needs_close) + { + UNLOCK (channel->mutex); + break; + } + UNLOCK (channel->mutex); + + if (channel->debug) + g_print ("select_thread %#x: waiting for data_avail_noticed\n", + channel->thread_id); + + WaitForSingleObject (channel->data_avail_noticed_event, INFINITE); + if (channel->debug) + g_print ("select_thread %#x: got data_avail_noticed\n", + channel->thread_id); + } + + LOCK (channel->mutex); + channel->running = FALSE; + if (channel->debug) + g_print ("select_thread %#x: got error, setting data_avail\n", + channel->thread_id); + SetEvent (channel->data_avail_event); + g_io_channel_unref ((GIOChannel *)channel); + UNLOCK (channel->mutex); + + /* No need to call _endthreadex(), the actual thread starter routine + * in MSVCRT (see crt/src/threadex.c:_threadstartex) calls + * _endthreadex() for us. + */ + + return 0; +} + +static gboolean +g_io_win32_prepare (GSource *source, + gint *timeout) +{ + GIOWin32Watch *watch = (GIOWin32Watch *)source; + GIOCondition buffer_condition = g_io_channel_get_buffer_condition (watch->channel); + GIOWin32Channel *channel = (GIOWin32Channel *)watch->channel; + + *timeout = -1; + + if (channel->debug) + g_print ("g_io_win32_prepare: for thread %#x buffer_condition:%#x\n" + " watch->pollfd.events:%#x watch->pollfd.revents:%#x channel->revents:%#x\n", + channel->thread_id, buffer_condition, + watch->pollfd.events, watch->pollfd.revents, channel->revents); + + if (channel->type == G_IO_WIN32_FILE_DESC) + { + LOCK (channel->mutex); + if (channel->running && channel->wrp == channel->rdp) + { + if (channel->debug) + g_print ("g_io_win32_prepare: for thread %#x, setting channel->revents = 0\n", + channel->thread_id); + channel->revents = 0; + } + UNLOCK (channel->mutex); + } + else if (channel->type == G_IO_WIN32_SOCKET) + { + LOCK (channel->mutex); + channel->revents = 0; + if (channel->debug) + g_print ("g_io_win32_prepare: for thread %#x, setting data_avail_noticed\n", + channel->thread_id); + SetEvent (channel->data_avail_noticed_event); + if (channel->debug) + g_print ("g_io_win32_prepare: thread %#x, there.\n", + channel->thread_id); + UNLOCK (channel->mutex); + } + + return ((watch->condition & buffer_condition) == watch->condition); +} + +static gboolean +g_io_win32_check (GSource *source) +{ + MSG msg; + GIOWin32Watch *watch = (GIOWin32Watch *)source; + GIOWin32Channel *channel = (GIOWin32Channel *)watch->channel; + GIOCondition buffer_condition = g_io_channel_get_buffer_condition (watch->channel); + + if (channel->debug) + g_print ("g_io_win32_check: for thread %#x buffer_condition:%#x\n" + " watch->pollfd.events:%#x watch->pollfd.revents:%#x channel->revents:%#x\n", + channel->thread_id, buffer_condition, + watch->pollfd.events, watch->pollfd.revents, channel->revents); + + if (channel->type != G_IO_WIN32_WINDOWS_MESSAGES) + { + watch->pollfd.revents = (watch->pollfd.events & channel->revents); + } + else + { + return (PeekMessage (&msg, channel->hwnd, 0, 0, PM_NOREMOVE)); + } + + if (channel->type == G_IO_WIN32_SOCKET) + { + LOCK (channel->mutex); + if (channel->debug) + g_print ("g_io_win32_check: thread %#x, resetting data_avail\n", + channel->thread_id); + ResetEvent (channel->data_avail_event); + if (channel->debug) + g_print ("g_io_win32_check: thread %#x, there.\n", + channel->thread_id); + UNLOCK (channel->mutex); + } + + return ((watch->pollfd.revents | buffer_condition) & watch->condition); +} + +static gboolean +g_io_win32_dispatch (GSource *source, + GSourceFunc callback, + gpointer user_data) +{ + GIOFunc func = (GIOFunc)callback; + GIOWin32Watch *watch = (GIOWin32Watch *)source; + GIOCondition buffer_condition = g_io_channel_get_buffer_condition (watch->channel); + + if (!func) + { + g_warning (G_STRLOC ": GIOWin32Watch dispatched without callback\n" + "You must call g_source_connect()."); + return FALSE; + } + + return (*func) (watch->channel, + (watch->pollfd.revents | buffer_condition) & watch->condition, + user_data); +} + +static void +g_io_win32_finalize (GSource *source) +{ + GIOWin32Watch *watch = (GIOWin32Watch *)source; + GIOWin32Channel *channel = (GIOWin32Channel *)watch->channel; + char send_buffer[] = "f"; + + LOCK (channel->mutex); + if (channel->debug) + g_print ("g_io_win32_finalize: channel with thread %#x\n", + channel->thread_id); + + channel->watches = g_slist_remove (channel->watches, watch); + + SetEvent (channel->data_avail_noticed_event); + if (channel->type == G_IO_WIN32_SOCKET) + { + /* Tell select_thread() to exit */ + channel->needs_close = 1; + /* Wake up select_thread() from its blocking select() */ + send (channel->reset_send, send_buffer, sizeof (send_buffer), 0); + } + + UNLOCK (channel->mutex); + g_io_channel_unref (watch->channel); +} + +GSourceFuncs g_io_watch_funcs = { + g_io_win32_prepare, + g_io_win32_check, + g_io_win32_dispatch, + g_io_win32_finalize, + NULL, NULL +}; + +static GSource * +g_io_win32_create_watch (GIOChannel *channel, + GIOCondition condition, + unsigned (__stdcall *thread) (void *parameter)) +{ + GIOWin32Channel *win32_channel = (GIOWin32Channel *)channel; + GIOWin32Watch *watch; + GSource *source; + char send_buffer[] = "c"; + + source = g_source_new (&g_io_watch_funcs, sizeof (GIOWin32Watch)); + watch = (GIOWin32Watch *)source; + + watch->channel = channel; + g_io_channel_ref (channel); + + watch->condition = condition; + + if (win32_channel->data_avail_event == NULL) + create_events (win32_channel); + + watch->pollfd.fd = (gint) win32_channel->data_avail_event; + watch->pollfd.events = condition; + + if (win32_channel->debug) + g_print ("g_io_win32_create_watch: fd:%d condition:%#x handle:%#x\n", + win32_channel->fd, condition, watch->pollfd.fd); + + LOCK (win32_channel->mutex); + win32_channel->watches = g_slist_append (win32_channel->watches, watch); + + if (win32_channel->thread_id == 0) + create_thread (win32_channel, condition, thread); + else + send (win32_channel->reset_send, send_buffer, sizeof (send_buffer), 0); + + g_source_add_poll (source, &watch->pollfd); + UNLOCK (win32_channel->mutex); + + return source; +} + +static void +g_io_win32_free (GIOChannel *channel) +{ + GIOWin32Channel *win32_channel = (GIOWin32Channel *)channel; + + if (win32_channel->debug) + g_print ("thread %#x: freeing channel, fd: %d\n", + win32_channel->thread_id, + win32_channel->fd); + + if (win32_channel->reset_send && win32_channel->reset_send != INVALID_SOCKET) + closesocket (win32_channel->reset_send); + if (win32_channel->reset_recv && win32_channel->reset_recv != INVALID_SOCKET) + closesocket (win32_channel->reset_recv); + if (win32_channel->data_avail_event) + CloseHandle (win32_channel->data_avail_event); + if (win32_channel->space_avail_event) + CloseHandle (win32_channel->space_avail_event); + if (win32_channel->data_avail_noticed_event) + CloseHandle (win32_channel->data_avail_noticed_event); + DeleteCriticalSection (&win32_channel->mutex); + + g_free (win32_channel->buffer); + g_slist_free (win32_channel->watches); + g_free (win32_channel); +} + +static GIOStatus +g_io_win32_sock_read (GIOChannel *channel, + gchar *buf, + gsize count, + gsize *bytes_read, + GError **err) +{ + GIOWin32Channel *win32_channel = (GIOWin32Channel *)channel; + gint result; + GIOChannelError error = G_IO_STATUS_NORMAL; + GIOStatus internal_status = G_IO_STATUS_NORMAL; + char send_buffer[] = "sr"; + + if (win32_channel->debug) + g_print ("g_io_win32_sock_read: sockfd:%d count:%d\n", + win32_channel->fd, count); +#ifdef WE_NEED_TO_HANDLE_WSAEINTR +repeat: +#endif + result = recv (win32_channel->fd, buf, count, 0); + + if (win32_channel->debug) + g_print ("g_io_win32_sock_read: recv:%d\n", result); + + if (result == SOCKET_ERROR) + { + *bytes_read = 0; + + switch (WSAGetLastError ()) + { + case WSAEINVAL: + error = G_IO_CHANNEL_ERROR_INVAL; + break; + case WSAEWOULDBLOCK: + return G_IO_STATUS_AGAIN; +#ifdef WE_NEED_TO_HANDLE_WSAEINTR /* not anymore with wsock2 ? */ + case WSAEINTR: + goto repeat; +#endif + default: + error = G_IO_CHANNEL_ERROR_FAILED; + break; + } + g_set_error (err, G_IO_CHANNEL_ERROR, error, "Socket read error"); + internal_status = G_IO_STATUS_ERROR; + /* FIXME get all errors, better error messages */ + } + else + { + *bytes_read = result; + if (result == 0) + internal_status = G_IO_STATUS_EOF; + } + + if ((internal_status == G_IO_STATUS_EOF) || + (internal_status == G_IO_STATUS_ERROR)) + { + LOCK (win32_channel->mutex); + SetEvent (win32_channel->data_avail_noticed_event); + win32_channel->needs_close = 1; + send (win32_channel->reset_send, send_buffer, sizeof (send_buffer), 0); + UNLOCK (win32_channel->mutex); + } + return internal_status; +} + +static GIOStatus +g_io_win32_sock_write (GIOChannel *channel, + const gchar *buf, + gsize count, + gsize *bytes_written, + GError **err) +{ + GIOWin32Channel *win32_channel = (GIOWin32Channel *)channel; + gint result; + GIOChannelError error = G_IO_STATUS_NORMAL; + char send_buffer[] = "sw"; + + if (win32_channel->debug) + g_print ("g_io_win32_sock_write: sockfd:%d count:%d\n", + win32_channel->fd, count); +#ifdef WE_NEED_TO_HANDLE_WSAEINTR +repeat: +#endif + result = send (win32_channel->fd, buf, count, 0); + + if (win32_channel->debug) + g_print ("g_io_win32_sock_write: send:%d\n", result); + + if (result == SOCKET_ERROR) + { + *bytes_written = 0; + + switch (WSAGetLastError ()) + { + case WSAEINVAL: + error = G_IO_CHANNEL_ERROR_INVAL; + break; + case WSAEWOULDBLOCK: + return G_IO_STATUS_AGAIN; +#ifdef WE_NEED_TO_HANDLE_WSAEINTR /* not anymore with wsock2 ? */ + case WSAEINTR: + goto repeat; +#endif + default: + error = G_IO_CHANNEL_ERROR_FAILED; + break; + } + g_set_error (err, G_IO_CHANNEL_ERROR, error, "Socket write error"); + LOCK (win32_channel->mutex); + SetEvent (win32_channel->data_avail_noticed_event); + win32_channel->needs_close = 1; + send (win32_channel->reset_send, send_buffer, sizeof (send_buffer), 0); + UNLOCK (win32_channel->mutex); + return G_IO_STATUS_ERROR; + /* FIXME get all errors, better error messages */ + } + else + { + *bytes_written = result; + + return G_IO_STATUS_NORMAL; + } +} + +static GIOStatus +g_io_win32_sock_close (GIOChannel *channel, + GError **err) +{ + GIOWin32Channel *win32_channel = (GIOWin32Channel *)channel; + + LOCK (win32_channel->mutex); + if (win32_channel->running) + { + if (win32_channel->debug) + g_print ("thread %#x: running, marking for later close\n", + win32_channel->thread_id); + win32_channel->running = FALSE; + win32_channel->needs_close = TRUE; + SetEvent(win32_channel->data_avail_noticed_event); + } + if (win32_channel->fd != -1) + { + if (win32_channel->debug) + g_print ("thread %#x: closing socket %d\n", + win32_channel->thread_id, + win32_channel->fd); + + closesocket (win32_channel->fd); + win32_channel->fd = -1; + } + UNLOCK (win32_channel->mutex); + + /* FIXME error detection? */ + + return G_IO_STATUS_NORMAL; +} + +static GSource * +g_io_win32_sock_create_watch (GIOChannel *channel, + GIOCondition condition) +{ + return g_io_win32_create_watch (channel, condition, select_thread); +} + +static GIOStatus +g_io_win32_set_flags (GIOChannel *channel, + GIOFlags flags, + GError **err) +{ + GIOWin32Channel *win32_channel = (GIOWin32Channel *)channel; + + if (win32_channel->debug) + { + g_print ("g_io_win32_set_flags: "); + g_win32_print_gioflags (flags); + g_print ("\n"); + } + + g_warning ("g_io_win32_set_flags () not implemented.\n"); + + return G_IO_STATUS_NORMAL; +} + +static GIOFlags +g_io_win32_sock_get_flags (GIOChannel *channel) +{ + /* XXX Could do something here. */ + return 0; +} + +static GIOFuncs win32_channel_sock_funcs = { + g_io_win32_sock_read, + g_io_win32_sock_write, + NULL, + g_io_win32_sock_close, + g_io_win32_sock_create_watch, + g_io_win32_free, + g_io_win32_set_flags, + g_io_win32_sock_get_flags, +}; + +GIOChannel * +wgaim_g_io_channel_win32_new_socket (int socket) +{ + GIOWin32Channel *win32_channel = g_new (GIOWin32Channel, 1); + GIOChannel *channel = (GIOChannel *)win32_channel; + + g_io_channel_init (channel); + g_io_channel_win32_init (win32_channel); + init_reset_sockets (win32_channel); + if (win32_channel->debug) + g_print ("g_io_channel_win32_new_socket: sockfd:%d\n", socket); + channel->funcs = &win32_channel_sock_funcs; + win32_channel->type = G_IO_WIN32_SOCKET; + win32_channel->fd = socket; + + /* XXX: check this */ + channel->is_readable = TRUE; + channel->is_writeable = TRUE; + + channel->is_seekable = FALSE; + + return channel; +} + +#if 0 +void +g_io_channel_win32_set_debug (GIOChannel *channel, + gboolean flag) +{ + GIOWin32Channel *win32_channel = (GIOWin32Channel *)channel; + + win32_channel->debug = flag; +} +#endif + diff -r b7e145ea9076 -r 5b389aacc06b libgaim/win32/win32dep.h --- a/libgaim/win32/win32dep.h Mon Oct 16 14:50:20 2006 +0000 +++ b/libgaim/win32/win32dep.h Mon Oct 16 17:14:41 2006 +0000 @@ -40,6 +40,7 @@ char *wgaim_read_reg_string(HKEY rootkey, const char *subkey, const char *valname); /* needs to be g_free'd */ gboolean wgaim_write_reg_string(HKEY rootkey, const char *subkey, const char *valname, const char *value); char *wgaim_escape_dirsep(const char *filename); /* needs to be g_free'd */ +GIOChannel *wgaim_g_io_channel_win32_new_socket(int socket); /* Until we get the post-2.8 glib win32 giochannel implementation working, use the thread-based one */ /* Determine Gaim paths */ char *wgaim_get_special_folder(int folder_type); /* needs to be g_free'd */