X-Git-Url: http://review.tizen.org/git/?a=blobdiff_plain;f=glib%2Fgiowin32.c;h=171fb6803bffb4a5f1000b1f39fbdfb731759e48;hb=49a5d0f6f2aed99cd78f25655f137f4448e47d92;hp=1f6727f615e131f157177a27f48c4c00dd49cbfb;hpb=55790836fb5304356da4e0de63c5335bef1656db;p=platform%2Fupstream%2Fglib.git diff --git a/glib/giowin32.c b/glib/giowin32.c index 1f6727f..171fb68 100644 --- a/glib/giowin32.c +++ b/glib/giowin32.c @@ -17,9 +17,7 @@ * 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. + * License along with this library; if not, see . */ /* @@ -29,6 +27,44 @@ * GLib at ftp://ftp.gtk.org/pub/gtk/. */ +/* + * Bugs that are related to the code in this file: + * + * Bug 137968 - Sometimes a GIOFunc on Win32 is called with zero condition + * http://bugzilla.gnome.org/show_bug.cgi?id=137968 + * + * Bug 324234 - Using g_io_add_watch_full() to wait for connect() to return on a non-blocking socket returns prematurely + * http://bugzilla.gnome.org/show_bug.cgi?id=324234 + * + * Bug 331214 - g_io_channel async socket io stalls + * http://bugzilla.gnome.org/show_bug.cgi?id=331214 + * + * Bug 338943 - Multiple watches on the same socket + * http://bugzilla.gnome.org/show_bug.cgi?id=338943 + * + * Bug 357674 - 2 serious bugs in giowin32.c making glib iochannels useless + * http://bugzilla.gnome.org/show_bug.cgi?id=357674 + * + * Bug 425156 - GIOChannel deadlocks on a win32 socket + * http://bugzilla.gnome.org/show_bug.cgi?id=425156 + * + * Bug 468910 - giofunc condition=0 + * http://bugzilla.gnome.org/show_bug.cgi?id=468910 + * + * Bug 500246 - Bug fixes for giowin32 + * http://bugzilla.gnome.org/show_bug.cgi?id=500246 + * + * Bug 548278 - Async GETs connections are always terminated unexpectedly on windows + * http://bugzilla.gnome.org/show_bug.cgi?id=548278 + * + * Bug 548536 - giowin32 problem when adding and removing watches + * http://bugzilla.gnome.org/show_bug.cgi?id=548536 + * + * When fixing bugs related to the code in this file, either the above + * bugs or others, make sure that the test programs attached to the + * above bugs continue to work. + */ + #include "config.h" #include "glib.h" @@ -46,7 +82,6 @@ #include "gstdio.h" #include "glibintl.h" -#include "galias.h" typedef struct _GIOWin32Channel GIOWin32Channel; typedef struct _GIOWin32Watch GIOWin32Watch; @@ -55,12 +90,16 @@ typedef struct _GIOWin32Watch GIOWin32Watch; typedef enum { G_IO_WIN32_WINDOWS_MESSAGES, /* Windows messages */ + G_IO_WIN32_FILE_DESC, /* Unix-like file descriptors from - * _open() or _pipe(), except for console IO. - * Have to create separate thread to read. + * _open() or _pipe(), except for + * console IO. Separate thread to read + * or write. */ + G_IO_WIN32_CONSOLE, /* Console IO (usually stdin, stdout, stderr) */ - G_IO_WIN32_SOCKET /* Sockets. No separate thread */ + + G_IO_WIN32_SOCKET /* Sockets. No separate thread. */ } GIOWin32ChannelType; struct _GIOWin32Channel { @@ -73,32 +112,34 @@ struct _GIOWin32Channel { gboolean debug; - /* This is used by G_IO_WIN32_WINDOWS_MESSAGES channels */ - HWND hwnd; /* handle of window, or NULL */ + /* Field used by G_IO_WIN32_WINDOWS_MESSAGES channels */ + HWND hwnd; /* Handle of window, or NULL */ - /* Following fields are used by fd channels. */ + /* Fields used by G_IO_WIN32_FILE_DESC channels. */ CRITICAL_SECTION mutex; int direction; /* 0 means we read from it, * 1 means we write to it. */ - gboolean running; /* Is reader thread running. FALSE if - * EOF has been reached. + gboolean running; /* Is reader or writer thread + * running. FALSE if EOF has been + * reached by the reader thread. */ + 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.*/ + + guint thread_id; /* If non-NULL the channel has or has + * had a reader or writer thread. + */ 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 + * empty and full buffers, 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). @@ -111,16 +152,14 @@ struct _GIOWin32Channel { gint wrp, rdp; /* Buffer indices for writing and reading */ HANDLE space_avail_event; - /* Following fields used by socket channels */ + /* Fields used by G_IO_WIN32_SOCKET channels */ int event_mask; int last_events; - int event; + HANDLE event; gboolean write_would_have_blocked; + gboolean ever_writable; }; -#define LOCK(mutex) EnterCriticalSection (&mutex) -#define UNLOCK(mutex) LeaveCriticalSection (&mutex) - struct _GIOWin32Watch { GSource source; GPollFD pollfd; @@ -157,8 +196,8 @@ g_win32_print_gioflags (GIOFlags flags) 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_WRITABLE) + g_print ("%sWRITABLE", bar), bar = "|"; if (flags & G_IO_FLAG_IS_SEEKABLE) g_print ("%sSEEKABLE", bar), bar = "|"; } @@ -231,18 +270,21 @@ static void g_io_channel_win32_init (GIOWin32Channel *channel) { channel->debug = g_io_win32_get_debug_flag (); - channel->buffer = NULL; + + InitializeCriticalSection (&channel->mutex); channel->running = FALSE; channel->needs_close = FALSE; channel->thread_id = 0; channel->data_avail_event = NULL; channel->revents = 0; + channel->buffer = NULL; channel->space_avail_event = NULL; + channel->event_mask = 0; channel->last_events = 0; - channel->event = 0; + channel->event = NULL; channel->write_would_have_blocked = FALSE; - InitializeCriticalSection (&channel->mutex); + channel->ever_writable = FALSE; } static void @@ -261,6 +303,7 @@ create_events (GIOWin32Channel *channel) || !(channel->space_avail_event = CreateEvent (&sec_attrs, FALSE, FALSE, NULL))) { gchar *emsg = g_win32_error_message (GetLastError ()); + g_error ("Error creating event: %s", emsg); g_free (emsg); } @@ -271,16 +314,16 @@ read_thread (void *parameter) { GIOWin32Channel *channel = parameter; guchar *buffer; - guint nbytes; + gint nbytes; g_io_channel_ref ((GIOChannel *)channel); if (channel->debug) - g_print ("read_thread %#x: start fd=%d, data_avail=%#x space_avail=%#x\n", + g_print ("read_thread %#x: start fd=%d, data_avail=%p space_avail=%p\n", channel->thread_id, channel->fd, - (guint) channel->data_avail_event, - (guint) channel->space_avail_event); + channel->data_avail_event, + channel->space_avail_event); channel->direction = 0; channel->buffer = g_malloc (BUFFER_SIZE); @@ -289,7 +332,7 @@ read_thread (void *parameter) SetEvent (channel->space_avail_event); - LOCK (channel->mutex); + EnterCriticalSection (&channel->mutex); while (channel->running) { if (channel->debug) @@ -305,9 +348,9 @@ read_thread (void *parameter) if (channel->debug) g_print ("read_thread %#x: waiting for space\n", channel->thread_id); - UNLOCK (channel->mutex); + LeaveCriticalSection (&channel->mutex); WaitForSingleObject (channel->space_avail_event, INFINITE); - LOCK (channel->mutex); + EnterCriticalSection (&channel->mutex); if (channel->debug) g_print ("read_thread %#x: rdp=%d, wrp=%d\n", channel->thread_id, channel->rdp, channel->wrp); @@ -325,11 +368,11 @@ read_thread (void *parameter) g_print ("read_thread %#x: calling read() for %d bytes\n", channel->thread_id, nbytes); - UNLOCK (channel->mutex); + LeaveCriticalSection (&channel->mutex); nbytes = read (channel->fd, buffer, nbytes); - LOCK (channel->mutex); + EnterCriticalSection (&channel->mutex); channel->revents = G_IO_IN; if (nbytes == 0) @@ -365,7 +408,7 @@ read_thread (void *parameter) g_print ("read_thread %#x: EOF, rdp=%d, wrp=%d, setting data_avail\n", channel->thread_id, channel->rdp, channel->wrp); SetEvent (channel->data_avail_event); - UNLOCK (channel->mutex); + LeaveCriticalSection (&channel->mutex); g_io_channel_unref ((GIOChannel *)channel); @@ -382,16 +425,16 @@ write_thread (void *parameter) { GIOWin32Channel *channel = parameter; guchar *buffer; - guint nbytes; + gint nbytes; g_io_channel_ref ((GIOChannel *)channel); if (channel->debug) - g_print ("write_thread %#x: start fd=%d, data_avail=%#x space_avail=%#x\n", + g_print ("write_thread %#x: start fd=%d, data_avail=%p space_avail=%p\n", channel->thread_id, channel->fd, - (guint) channel->data_avail_event, - (guint) channel->space_avail_event); + channel->data_avail_event, + channel->space_avail_event); channel->direction = 1; channel->buffer = g_malloc (BUFFER_SIZE); @@ -406,7 +449,7 @@ write_thread (void *parameter) * write buffer. */ - LOCK (channel->mutex); + EnterCriticalSection (&channel->mutex); while (channel->running || channel->rdp != channel->wrp) { if (channel->debug) @@ -424,10 +467,10 @@ write_thread (void *parameter) channel->thread_id); channel->revents = G_IO_OUT; SetEvent (channel->data_avail_event); - UNLOCK (channel->mutex); + LeaveCriticalSection (&channel->mutex); WaitForSingleObject (channel->space_avail_event, INFINITE); - LOCK (channel->mutex); + EnterCriticalSection (&channel->mutex); if (channel->rdp == channel->wrp) break; @@ -446,9 +489,9 @@ write_thread (void *parameter) g_print ("write_thread %#x: calling write() for %d bytes\n", channel->thread_id, nbytes); - UNLOCK (channel->mutex); + LeaveCriticalSection (&channel->mutex); nbytes = write (channel->fd, buffer, nbytes); - LOCK (channel->mutex); + EnterCriticalSection (&channel->mutex); if (channel->debug) g_print ("write_thread %#x: write(%i) returned %d, rdp=%d, wrp=%d\n", @@ -481,7 +524,7 @@ write_thread (void *parameter) channel->fd = -1; } - UNLOCK (channel->mutex); + LeaveCriticalSection (&channel->mutex); g_io_channel_unref ((GIOChannel *)channel); @@ -498,18 +541,22 @@ create_thread (GIOWin32Channel *channel, 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_warning ("Error creating 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 ())); + { + gchar *emsg = g_win32_error_message (GetLastError ()); + + g_warning ("Error closing thread handle: %s.", emsg); + g_free (emsg); + } WaitForSingleObject (channel->space_avail_event, INFINITE); } static GIOStatus buffer_read (GIOWin32Channel *channel, - guchar *dest, + gchar *dest, gsize count, gsize *bytes_read, GError **err) @@ -517,25 +564,25 @@ buffer_read (GIOWin32Channel *channel, guint nbytes; guint left = count; - LOCK (channel->mutex); + EnterCriticalSection (&channel->mutex); if (channel->debug) - g_print ("reading from thread %#x %d bytes, rdp=%d, wrp=%d\n", + g_print ("reading from thread %#x %" G_GSIZE_FORMAT " bytes, rdp=%d, wrp=%d\n", channel->thread_id, count, channel->rdp, channel->wrp); if (channel->wrp == channel->rdp) { - UNLOCK (channel->mutex); + LeaveCriticalSection (&channel->mutex); if (channel->debug) g_print ("waiting for data from thread %#x\n", channel->thread_id); WaitForSingleObject (channel->data_avail_event, INFINITE); if (channel->debug) g_print ("done waiting for data from thread %#x\n", channel->thread_id); - LOCK (channel->mutex); + EnterCriticalSection (&channel->mutex); if (channel->wrp == channel->rdp && !channel->running) { if (channel->debug) g_print ("wrp==rdp, !running\n"); - UNLOCK (channel->mutex); + LeaveCriticalSection (&channel->mutex); *bytes_read = 0; return G_IO_STATUS_EOF; } @@ -545,7 +592,7 @@ buffer_read (GIOWin32Channel *channel, nbytes = channel->wrp - channel->rdp; else nbytes = BUFFER_SIZE - channel->rdp; - UNLOCK (channel->mutex); + LeaveCriticalSection (&channel->mutex); nbytes = MIN (left, nbytes); if (channel->debug) g_print ("moving %d bytes from thread %#x\n", @@ -553,7 +600,7 @@ buffer_read (GIOWin32Channel *channel, memcpy (dest, channel->buffer + channel->rdp, nbytes); dest += nbytes; left -= nbytes; - LOCK (channel->mutex); + EnterCriticalSection (&channel->mutex); channel->rdp = (channel->rdp + nbytes) % BUFFER_SIZE; if (channel->debug) g_print ("setting space_avail for thread %#x\n", channel->thread_id); @@ -568,7 +615,7 @@ buffer_read (GIOWin32Channel *channel, channel->thread_id); ResetEvent (channel->data_avail_event); }; - UNLOCK (channel->mutex); + LeaveCriticalSection (&channel->mutex); /* We have no way to indicate any errors form the actual * read() or recv() call in the reader thread. Should we have? @@ -580,7 +627,7 @@ buffer_read (GIOWin32Channel *channel, static GIOStatus buffer_write (GIOWin32Channel *channel, - const guchar *dest, + const gchar *dest, gsize count, gsize *bytes_written, GError **err) @@ -588,9 +635,9 @@ buffer_write (GIOWin32Channel *channel, guint nbytes; guint left = count; - LOCK (channel->mutex); + EnterCriticalSection (&channel->mutex); if (channel->debug) - g_print ("buffer_write: writing to thread %#x %d bytes, rdp=%d, wrp=%d\n", + g_print ("buffer_write: writing to thread %#x %" G_GSIZE_FORMAT " bytes, rdp=%d, wrp=%d\n", channel->thread_id, count, channel->rdp, channel->wrp); if ((channel->wrp + 1) % BUFFER_SIZE == channel->rdp) @@ -603,9 +650,9 @@ buffer_write (GIOWin32Channel *channel, if (channel->debug) g_print ("buffer_write: tid %#x: waiting for space\n", channel->thread_id); - UNLOCK (channel->mutex); + LeaveCriticalSection (&channel->mutex); WaitForSingleObject (channel->data_avail_event, INFINITE); - LOCK (channel->mutex); + EnterCriticalSection (&channel->mutex); if (channel->debug) g_print ("buffer_write: tid %#x: rdp=%d, wrp=%d\n", channel->thread_id, channel->rdp, channel->wrp); @@ -614,7 +661,7 @@ buffer_write (GIOWin32Channel *channel, nbytes = MIN ((channel->rdp + BUFFER_SIZE - channel->wrp - 1) % BUFFER_SIZE, BUFFER_SIZE - channel->wrp); - UNLOCK (channel->mutex); + LeaveCriticalSection (&channel->mutex); nbytes = MIN (left, nbytes); if (channel->debug) g_print ("buffer_write: tid %#x: writing %d bytes\n", @@ -622,7 +669,7 @@ buffer_write (GIOWin32Channel *channel, memcpy (channel->buffer + channel->wrp, dest, nbytes); dest += nbytes; left -= nbytes; - LOCK (channel->mutex); + EnterCriticalSection (&channel->mutex); channel->wrp = (channel->wrp + nbytes) % BUFFER_SIZE; if (channel->debug) @@ -639,7 +686,7 @@ buffer_write (GIOWin32Channel *channel, ResetEvent (channel->data_avail_event); } - UNLOCK (channel->mutex); + LeaveCriticalSection (&channel->mutex); /* We have no way to indicate any errors form the actual * write() call in the writer thread. Should we have? @@ -684,7 +731,7 @@ g_io_win32_prepare (GSource *source, condition_to_string (watch->pollfd.revents), condition_to_string (channel->revents)); - LOCK (channel->mutex); + EnterCriticalSection (&channel->mutex); if (channel->running) { if (channel->direction == 0 && channel->wrp == channel->rdp) @@ -704,7 +751,7 @@ g_io_win32_prepare (GSource *source, channel->revents = 0; } } - UNLOCK (channel->mutex); + LeaveCriticalSection (&channel->mutex); break; case G_IO_WIN32_SOCKET: @@ -717,27 +764,33 @@ g_io_win32_prepare (GSource *source, event_mask |= (FD_WRITE | FD_CONNECT); event_mask |= FD_CLOSE; - if (channel->event_mask != event_mask /* || channel->event != watch->pollfd.fd*/) + if (channel->event_mask != event_mask) { if (channel->debug) - g_print ("\n WSAEventSelect(%d,%#x,{%s})", - channel->fd, watch->pollfd.fd, + g_print ("\n WSAEventSelect(%d,%p,{%s})", + channel->fd, (HANDLE) watch->pollfd.fd, event_mask_to_string (event_mask)); if (WSAEventSelect (channel->fd, (HANDLE) watch->pollfd.fd, event_mask) == SOCKET_ERROR) - ; /* What? */ + if (channel->debug) + { + gchar *emsg = g_win32_error_message (WSAGetLastError ()); + + g_print (" failed: %s", emsg); + g_free (emsg); + } channel->event_mask = event_mask; -#if 0 - channel->event = watch->pollfd.fd; -#endif + if (channel->debug) g_print ("\n setting last_events=0"); channel->last_events = 0; - if ((event_mask & FD_WRITE) && !channel->write_would_have_blocked) + if ((event_mask & FD_WRITE) && + channel->ever_writable && + !channel->write_would_have_blocked) { if (channel->debug) - g_print (" WSASetEvent(%#x)", watch->pollfd.fd); + g_print (" WSASetEvent(%p)", (WSAEVENT) watch->pollfd.fd); WSASetEvent ((WSAEVENT) watch->pollfd.fd); } } @@ -816,8 +869,8 @@ g_io_win32_check (GSource *source) if (channel->last_events & FD_WRITE) { if (channel->debug) - g_print (" sock=%d event=%#x last_events has FD_WRITE", - channel->fd, watch->pollfd.fd); + g_print (" sock=%d event=%p last_events has FD_WRITE", + channel->fd, (HANDLE) watch->pollfd.fd); } else { @@ -837,19 +890,23 @@ g_io_win32_check (GSource *source) { channel->event_mask = 0; if (channel->debug) - g_print ("\n WSAEventSelect(%d,%#x,{})", - channel->fd, watch->pollfd.fd); + g_print ("\n WSAEventSelect(%d,%p,{})", + channel->fd, (HANDLE) watch->pollfd.fd); WSAEventSelect (channel->fd, (HANDLE) watch->pollfd.fd, 0); if (channel->debug) - g_print (" ResetEvent(%#x)", - watch->pollfd.fd); + g_print (" ResetEvent(%p)", + (HANDLE) watch->pollfd.fd); ResetEvent ((HANDLE) watch->pollfd.fd); } + else if (events.lNetworkEvents & FD_WRITE) + channel->ever_writable = TRUE; channel->last_events = events.lNetworkEvents; } + watch->pollfd.revents = 0; if (channel->last_events & (FD_READ | FD_ACCEPT)) watch->pollfd.revents |= G_IO_IN; + if (channel->last_events & FD_WRITE) watch->pollfd.revents |= G_IO_OUT; else @@ -869,10 +926,12 @@ g_io_win32_check (GSource *source) } /* Regardless of WSAEnumNetworkEvents() result, if watching for - * writability, unless last write would have blocked set - * G_IO_OUT. But never set both G_IO_OUT and G_IO_HUP. + * writability, and if we have ever got a FD_WRITE event, and + * unless last write would have blocked, set G_IO_OUT. But never + * set both G_IO_OUT and G_IO_HUP. */ if (!(watch->pollfd.revents & G_IO_HUP) && + channel->ever_writable && !channel->write_would_have_blocked && (channel->event_mask & FD_WRITE)) watch->pollfd.revents |= G_IO_OUT; @@ -902,7 +961,7 @@ g_io_win32_dispatch (GSource *source, if (!func) { - g_warning (G_STRLOC ": GIOWin32Watch dispatched without callback\n" + g_warning ("IO Watch dispatched without callback\n" "You must call g_source_connect()."); return FALSE; } @@ -947,11 +1006,6 @@ g_io_win32_finalize (GSource *source) case G_IO_WIN32_SOCKET: if (channel->debug) g_print (" SOCK sock=%d", channel->fd); -#if 0 - CloseHandle ((HANDLE) watch->pollfd.fd); - channel->event = 0; - channel->event_mask = 0; -#endif break; default: @@ -988,8 +1042,8 @@ g_io_win32_msg_read (GIOChannel *channel, } if (win32_channel->debug) - g_print ("g_io_win32_msg_read: channel=%p hwnd=%#x\n", - channel, (guint) win32_channel->hwnd); + g_print ("g_io_win32_msg_read: channel=%p hwnd=%p\n", + channel, win32_channel->hwnd); if (!PeekMessage (&msg, win32_channel->hwnd, 0, 0, PM_REMOVE)) return G_IO_STATUS_AGAIN; @@ -1021,8 +1075,10 @@ g_io_win32_msg_write (GIOChannel *channel, if (!PostMessage (win32_channel->hwnd, msg.message, msg.wParam, msg.lParam)) { gchar *emsg = g_win32_error_message (GetLastError ()); + g_set_error_literal (err, G_IO_CHANNEL_ERROR, G_IO_CHANNEL_ERROR_FAILED, emsg); g_free (emsg); + return G_IO_STATUS_ERROR; } @@ -1048,15 +1104,55 @@ g_io_win32_free (GIOChannel *channel) if (win32_channel->debug) g_print ("g_io_win32_free channel=%p fd=%d\n", channel, win32_channel->fd); - 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->type == G_IO_WIN32_SOCKET) - WSAEventSelect (win32_channel->fd, NULL, 0); DeleteCriticalSection (&win32_channel->mutex); + if (win32_channel->data_avail_event) + if (!CloseHandle (win32_channel->data_avail_event)) + if (win32_channel->debug) + { + gchar *emsg = g_win32_error_message (GetLastError ()); + + g_print (" CloseHandle(%p) failed: %s\n", + win32_channel->data_avail_event, emsg); + g_free (emsg); + } + g_free (win32_channel->buffer); + + if (win32_channel->space_avail_event) + if (!CloseHandle (win32_channel->space_avail_event)) + if (win32_channel->debug) + { + gchar *emsg = g_win32_error_message (GetLastError ()); + + g_print (" CloseHandle(%p) failed: %s\n", + win32_channel->space_avail_event, emsg); + g_free (emsg); + } + + if (win32_channel->type == G_IO_WIN32_SOCKET && + win32_channel->fd != -1) + if (WSAEventSelect (win32_channel->fd, NULL, 0) == SOCKET_ERROR) + if (win32_channel->debug) + { + gchar *emsg = g_win32_error_message (WSAGetLastError ()); + + g_print (" WSAEventSelect(%d,NULL,{}) failed: %s\n", + win32_channel->fd, emsg); + g_free (emsg); + } + + if (win32_channel->event) + if (!WSACloseEvent (win32_channel->event)) + if (win32_channel->debug) + { + gchar *emsg = g_win32_error_message (WSAGetLastError ()); + + g_print (" WSACloseEvent(%p) failed: %s\n", + win32_channel->event, emsg); + g_free (emsg); + } + g_free (win32_channel); } @@ -1068,6 +1164,7 @@ g_io_win32_msg_create_watch (GIOChannel *channel, GSource *source; source = g_source_new (&g_io_watch_funcs, sizeof (GIOWin32Watch)); + g_source_set_name (source, "GIOChannel (Win32)"); watch = (GIOWin32Watch *)source; watch->channel = channel; @@ -1075,7 +1172,7 @@ g_io_win32_msg_create_watch (GIOChannel *channel, watch->condition = condition; - watch->pollfd.fd = G_WIN32_MSG_HANDLE; + watch->pollfd.fd = (gintptr) G_WIN32_MSG_HANDLE; watch->pollfd.events = condition; g_source_add_poll (source, &watch->pollfd); @@ -1094,7 +1191,7 @@ g_io_win32_fd_and_console_read (GIOChannel *channel, gint result; if (win32_channel->debug) - g_print ("g_io_win32_fd_read: fd=%d count=%d\n", + g_print ("g_io_win32_fd_read: fd=%d count=%" G_GSIZE_FORMAT "\n", win32_channel->fd, count); if (win32_channel->thread_id) @@ -1147,7 +1244,7 @@ g_io_win32_fd_and_console_write (GIOChannel *channel, result = write (win32_channel->fd, buf, count); if (win32_channel->debug) - g_print ("g_io_win32_fd_write: fd=%d count=%d => %d\n", + g_print ("g_io_win32_fd_write: fd=%d count=%" G_GSIZE_FORMAT " => %d\n", win32_channel->fd, count, result); if (result < 0) @@ -1233,7 +1330,7 @@ g_io_win32_fd_close (GIOChannel *channel, g_print ("g_io_win32_fd_close: thread=%#x: fd=%d\n", win32_channel->thread_id, win32_channel->fd); - LOCK (win32_channel->mutex); + EnterCriticalSection (&win32_channel->mutex); if (win32_channel->running) { if (win32_channel->debug) @@ -1256,7 +1353,7 @@ g_io_win32_fd_close (GIOChannel *channel, win32_channel->fd); win32_channel->fd = -1; } - UNLOCK (win32_channel->mutex); + LeaveCriticalSection (&win32_channel->mutex); /* FIXME error detection? */ @@ -1279,15 +1376,15 @@ g_io_win32_fd_create_watch (GIOChannel *channel, if (win32_channel->data_avail_event == NULL) create_events (win32_channel); - watch->pollfd.fd = (gint) win32_channel->data_avail_event; + watch->pollfd.fd = (gintptr) win32_channel->data_avail_event; watch->pollfd.events = condition; if (win32_channel->debug) - g_print ("g_io_win32_fd_create_watch: channel=%p fd=%d condition={%s} event=%#x\n", + g_print ("g_io_win32_fd_create_watch: channel=%p fd=%d condition={%s} event=%p\n", channel, win32_channel->fd, - condition_to_string (condition), watch->pollfd.fd); + condition_to_string (condition), (HANDLE) watch->pollfd.fd); - LOCK (win32_channel->mutex); + EnterCriticalSection (&win32_channel->mutex); if (win32_channel->thread_id == 0) { if (condition & G_IO_IN) @@ -1297,7 +1394,7 @@ g_io_win32_fd_create_watch (GIOChannel *channel, } g_source_add_poll (source, &watch->pollfd); - UNLOCK (win32_channel->mutex); + LeaveCriticalSection (&win32_channel->mutex); return source; } @@ -1332,7 +1429,7 @@ g_io_win32_console_create_watch (GIOChannel *channel, watch->condition = condition; - watch->pollfd.fd = (gint) _get_osfhandle (win32_channel->fd); + watch->pollfd.fd = _get_osfhandle (win32_channel->fd); watch->pollfd.events = condition; g_source_add_poll (source, &watch->pollfd); @@ -1353,7 +1450,7 @@ g_io_win32_sock_read (GIOChannel *channel, int winsock_error; if (win32_channel->debug) - g_print ("g_io_win32_sock_read: channel=%p sock=%d count=%d", + g_print ("g_io_win32_sock_read: channel=%p sock=%d count=%" G_GSIZE_FORMAT, channel, win32_channel->fd, count); result = recv (win32_channel->fd, buf, count, 0); @@ -1414,7 +1511,7 @@ g_io_win32_sock_write (GIOChannel *channel, int winsock_error; if (win32_channel->debug) - g_print ("g_io_win32_sock_write: channel=%p sock=%d count=%d", + g_print ("g_io_win32_sock_write: channel=%p sock=%d count=%" G_GSIZE_FORMAT, channel, win32_channel->fd, count); result = send (win32_channel->fd, buf, count, 0); @@ -1498,14 +1595,14 @@ g_io_win32_sock_create_watch (GIOChannel *channel, watch->condition = condition; if (win32_channel->event == 0) - win32_channel->event = (int) WSACreateEvent (); + win32_channel->event = WSACreateEvent (); - watch->pollfd.fd = win32_channel->event; + watch->pollfd.fd = (gintptr) win32_channel->event; watch->pollfd.events = condition; if (win32_channel->debug) - g_print ("g_io_win32_sock_create_watch: channel=%p sock=%d event=%#x condition={%s}\n", - channel, win32_channel->fd, watch->pollfd.fd, + g_print ("g_io_win32_sock_create_watch: channel=%p sock=%d event=%p condition={%s}\n", + channel, win32_channel->fd, (HANDLE) watch->pollfd.fd, condition_to_string (watch->condition)); g_source_add_poll (source, &watch->pollfd); @@ -1526,7 +1623,8 @@ g_io_channel_new_file (const gchar *filename, MODE_W = 1 << 1, MODE_A = 1 << 2, MODE_PLUS = 1 << 3, - } mode_num; + }; + int mode_num; g_return_val_if_fail (filename != NULL, NULL); g_return_val_if_fail (mode != NULL, NULL); @@ -1544,7 +1642,7 @@ g_io_channel_new_file (const gchar *filename, mode_num = MODE_A; break; default: - g_warning ("Invalid GIOFileMode %s.\n", mode); + g_warning ("Invalid GIOFileMode %s.", mode); return NULL; } @@ -1560,7 +1658,7 @@ g_io_channel_new_file (const gchar *filename, } /* Fall through */ default: - g_warning ("Invalid GIOFileMode %s.\n", mode); + g_warning ("Invalid GIOFileMode %s.", mode); return NULL; } @@ -1644,7 +1742,7 @@ g_io_channel_new_file (const gchar *filename, return channel; } -#ifdef G_OS_WIN32 +#if !defined (_WIN64) #undef g_io_channel_new_file @@ -1692,8 +1790,8 @@ g_io_win32_unimpl_set_flags (GIOChannel *channel, } static GIOFlags -g_io_win32_fd_get_flags_internal (GIOChannel *channel, - struct stat *st) +g_io_win32_fd_get_flags_internal (GIOChannel *channel, + struct _stati64 *st) { GIOWin32Channel *win32_channel = (GIOWin32Channel *) channel; gchar c; @@ -1725,13 +1823,13 @@ g_io_win32_fd_get_flags_internal (GIOChannel *channel, static GIOFlags g_io_win32_fd_get_flags (GIOChannel *channel) { - struct stat st; + struct _stati64 st; GIOWin32Channel *win32_channel = (GIOWin32Channel *)channel; g_return_val_if_fail (win32_channel != NULL, 0); g_return_val_if_fail (win32_channel->type == G_IO_WIN32_FILE_DESC, 0); - if (0 == fstat (win32_channel->fd, &st)) + if (0 == _fstati64 (win32_channel->fd, &st)) return g_io_win32_fd_get_flags_internal (channel, &st); else return 0; @@ -1870,8 +1968,23 @@ static GIOFuncs win32_channel_sock_funcs = { g_io_win32_sock_get_flags, }; +/** + * g_io_channel_win32_new_messages: + * @hwnd: a window handle. + * + * Creates a new #GIOChannel given a window handle on Windows. + * + * This function creates a #GIOChannel that can be used to poll for + * Windows messages for the window in question. + * + * Returns: a new #GIOChannel. + **/ GIOChannel * +#if GLIB_SIZEOF_VOID_P == 8 +g_io_channel_win32_new_messages (gsize hwnd) +#else g_io_channel_win32_new_messages (guint hwnd) +#endif { GIOWin32Channel *win32_channel = g_new (GIOWin32Channel, 1); GIOChannel *channel = (GIOChannel *)win32_channel; @@ -1879,8 +1992,8 @@ g_io_channel_win32_new_messages (guint hwnd) g_io_channel_init (channel); g_io_channel_win32_init (win32_channel); if (win32_channel->debug) - g_print ("g_io_channel_win32_new_messages: channel=%p hwnd=%#x\n", - channel, hwnd); + g_print ("g_io_channel_win32_new_messages: channel=%p hwnd=%p\n", + channel, (HWND) hwnd); channel->funcs = &win32_channel_msg_funcs; win32_channel->type = G_IO_WIN32_WINDOWS_MESSAGES; win32_channel->hwnd = (HWND) hwnd; @@ -1895,8 +2008,8 @@ g_io_channel_win32_new_messages (guint hwnd) } static GIOChannel * -g_io_channel_win32_new_fd_internal (gint fd, - struct stat *st) +g_io_channel_win32_new_fd_internal (gint fd, + struct _stati64 *st) { GIOWin32Channel *win32_channel; GIOChannel *channel; @@ -1929,14 +2042,43 @@ g_io_channel_win32_new_fd_internal (gint fd, return channel; } +/** + * g_io_channel_win32_new_fd: + * @fd: a C library file descriptor. + * + * Creates a new #GIOChannel given a file descriptor on Windows. This + * works for file descriptors from the C runtime. + * + * This function works for file descriptors as returned by the open(), + * creat(), pipe() and fileno() calls in the Microsoft C runtime. In + * order to meaningfully use this function your code should use the + * same C runtime as GLib uses, which is msvcrt.dll. Note that in + * current Microsoft compilers it is near impossible to convince it to + * build code that would use msvcrt.dll. The last Microsoft compiler + * version that supported using msvcrt.dll as the C runtime was version + * 6. The GNU compiler and toolchain for Windows, also known as Mingw, + * fully supports msvcrt.dll. + * + * If you have created a #GIOChannel for a file descriptor and started + * watching (polling) it, you shouldn't call read() on the file + * descriptor. This is because adding polling for a file descriptor is + * implemented in GLib on Windows by starting a thread that sits + * blocked in a read() from the file descriptor most of the time. All + * reads from the file descriptor should be done by this internal GLib + * thread. Your code should call only g_io_channel_read(). + * + * This function is available only in GLib on Windows. + * + * Returns: a new #GIOChannel. + **/ GIOChannel * g_io_channel_win32_new_fd (gint fd) { - struct stat st; + struct _stati64 st; - if (fstat (fd, &st) == -1) + if (_fstati64 (fd, &st) == -1) { - g_warning (G_STRLOC ": %d isn't a C library file descriptor", fd); + g_warning ("g_io_channel_win32_new_fd: %d isn't an open file descriptor in the C library GLib uses.", fd); return NULL; } @@ -1951,6 +2093,21 @@ g_io_channel_win32_get_fd (GIOChannel *channel) return win32_channel->fd; } +/** + * g_io_channel_win32_new_socket: + * @socket: a Winsock socket + * + * Creates a new #GIOChannel given a socket on Windows. + * + * This function works for sockets created by Winsock. It's available + * only in GLib on Windows. + * + * Polling a #GSource created to watch a channel for a socket puts the + * socket in non-blocking mode. This is a side-effect of the + * implementation and unavoidable. + * + * Returns: a new #GIOChannel + **/ GIOChannel * g_io_channel_win32_new_socket (int socket) { @@ -1977,16 +2134,16 @@ GIOChannel * g_io_channel_unix_new (gint fd) { gboolean is_fd, is_socket; - struct stat st; + struct _stati64 st; int optval, optlen; - is_fd = (fstat (fd, &st) == 0); + is_fd = (_fstati64 (fd, &st) == 0); optlen = sizeof (optval); is_socket = (getsockopt (fd, SOL_SOCKET, SO_TYPE, (char *) &optval, &optlen) != SOCKET_ERROR); if (is_fd && is_socket) - g_warning (G_STRLOC ": %d is both a file descriptor and a socket, file descriptor interpretation assumed.", fd); + g_warning ("g_io_channel_unix_new: %d is both a file descriptor and a socket. File descriptor interpretation assumed. To avoid ambiguity, call either g_io_channel_win32_new_fd() or g_io_channel_win32_new_socket() instead.", fd); if (is_fd) return g_io_channel_win32_new_fd_internal (fd, &st); @@ -1994,7 +2151,7 @@ g_io_channel_unix_new (gint fd) if (is_socket) return g_io_channel_win32_new_socket(fd); - g_warning (G_STRLOC ": %d is neither a file descriptor or a socket", fd); + g_warning ("g_io_channel_unix_new: %d is neither a file descriptor or a socket.", fd); return NULL; } @@ -2019,13 +2176,9 @@ g_io_channel_win32_poll (GPollFD *fds, gint n_fds, gint timeout) { - int result; - g_return_val_if_fail (n_fds >= 0, 0); - result = (*g_main_context_get_poll_func (NULL)) (fds, n_fds, timeout); - - return result; + return g_poll (fds, n_fds, timeout); } void @@ -2041,10 +2194,16 @@ g_io_channel_win32_make_pollfd (GIOChannel *channel, if (win32_channel->data_avail_event == NULL) create_events (win32_channel); - fd->fd = (gint) win32_channel->data_avail_event; + fd->fd = (gintptr) win32_channel->data_avail_event; - if (win32_channel->thread_id == 0 && (condition & G_IO_IN)) + if (win32_channel->thread_id == 0) { + /* Is it meaningful for a file descriptor to be polled for + * both IN and OUT? For what kind of file descriptor would + * that be? Doesn't seem to make sense, in practise the file + * descriptors handled here are always read or write ends of + * pipes surely, and thus unidirectional. + */ if (condition & G_IO_IN) create_thread (win32_channel, condition, read_thread); else if (condition & G_IO_OUT) @@ -2053,11 +2212,11 @@ g_io_channel_win32_make_pollfd (GIOChannel *channel, break; case G_IO_WIN32_CONSOLE: - fd->fd = (gint) _get_osfhandle (win32_channel->fd); + fd->fd = _get_osfhandle (win32_channel->fd); break; case G_IO_WIN32_SOCKET: - fd->fd = (int) WSACreateEvent (); + fd->fd = (gintptr) WSACreateEvent (); break; case G_IO_WIN32_WINDOWS_MESSAGES: @@ -2072,6 +2231,8 @@ g_io_channel_win32_make_pollfd (GIOChannel *channel, fd->events = condition; } +#ifndef _WIN64 + /* Binary compatibility */ GIOChannel * g_io_channel_win32_new_stream_socket (int socket) @@ -2079,5 +2240,4 @@ g_io_channel_win32_new_stream_socket (int socket) return g_io_channel_win32_new_socket (socket); } -#define __G_IO_WIN32_C__ -#include "galiasdef.c" +#endif