luc14n0/glib
1
0
Fork 0
mirror of https://gitlab.gnome.org/GNOME/glib.git synced 2024-11-06 01:16:17 +01:00
Code Issues Packages Projects Releases Wiki Activity
36ea7e4925
glib/giowin32.c
CST 1999 Shawn T. Amundson b9ef2b41db inserted additional note to look for ChangeLog and AUTHORS file for a log 
Wed Feb 24 00:08:42 CST 1999 Shawn T. Amundson <amundson@gtk.org>

        * *.[ch]: inserted additional note to look for ChangeLog and
	  AUTHORS file for a log of modifications.
1999-02-24 06:14:27 +00:00

1036 lines
25 KiB
C
Raw Blame History

/* 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
*
* This library is free software; you can redistribute it and/or
* modify it under the terms of the GNU Library 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
* Library General Public License for more details.
*
* You should have received a copy of the GNU Library 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-1999. 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/.
*/
#include "config.h"
#include "glib.h"
#include <windows.h>
#include <winsock.h> /* Not everybody has winsock2 */
#include <fcntl.h>
#include <io.h>
#include <errno.h>
#include <sys/types.h>
#include <stdio.h>
typedef struct _GIOWin32Channel GIOWin32Channel;
typedef struct _GIOWin32Watch GIOWin32Watch;
guint g_pipe_readable_msg;
typedef enum {
G_IO_WINDOWS_MESSAGES, /* Windows messages */
G_IO_FILE_DESC, /* Unix-like file descriptors from _open*/
G_IO_PIPE, /* pipe, with windows messages for signalling */
G_IO_STREAM_SOCKET /* Stream sockets */
} 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;
/* This is used by G_IO_WINDOWS_MESSAGES channels */
HWND hwnd; /* handle of window, or NULL */
/* This is used by G_IO_PIPE channels */
guint peer; /* thread id of reader */
guint peer_fd; /* fd in the reader */
guint offset; /* counter of accumulated bytes */
guint need_wakeups; /* in output channels whether the
* reader needs wakeups
*/
};
struct _GIOWin32Watch {
GPollFD pollfd;
GIOChannel *channel;
GIOCondition condition;
GIOFunc callback;
};
static gboolean g_io_win32_msg_prepare (gpointer source_data,
GTimeVal *current_time,
gint *timeout);
static gboolean g_io_win32_msg_check (gpointer source_data,
GTimeVal *current_time);
static gboolean g_io_win32_msg_dispatch (gpointer source_data,
GTimeVal *current_time,
gpointer user_data);
static gboolean g_io_win32_fd_prepare (gpointer source_data,
GTimeVal *current_time,
gint *timeout);
static gboolean g_io_win32_fd_check (gpointer source_data,
GTimeVal *current_time);
static gboolean g_io_win32_fd_dispatch (gpointer source_data,
GTimeVal *current_time,
gpointer user_data);
static gboolean g_io_win32_pipe_prepare (gpointer source_data,
GTimeVal *current_time,
gint *timeout);
static gboolean g_io_win32_pipe_check (gpointer source_data,
GTimeVal *current_time);
static gboolean g_io_win32_pipe_dispatch (gpointer source_data,
GTimeVal *current_time,
gpointer user_data);
static void g_io_win32_pipe_destroy (gpointer source_data);
static gboolean g_io_win32_sock_prepare (gpointer source_data,
GTimeVal *current_time,
gint *timeout);
static gboolean g_io_win32_sock_check (gpointer source_data,
GTimeVal *current_time);
static gboolean g_io_win32_sock_dispatch (gpointer source_data,
GTimeVal *current_time,
gpointer user_data);
static void g_io_win32_destroy (gpointer source_data);
static GIOError g_io_win32_msg_read (GIOChannel *channel,
gchar *buf,
guint count,
guint *bytes_written);
static GIOError g_io_win32_msg_write(GIOChannel *channel,
gchar *buf,
guint count,
guint *bytes_written);
static GIOError g_io_win32_msg_seek (GIOChannel *channel,
gint offset,
GSeekType type);
static void g_io_win32_msg_close (GIOChannel *channel);
static guint g_io_win32_msg_add_watch (GIOChannel *channel,
gint priority,
GIOCondition condition,
GIOFunc func,
gpointer user_data,
GDestroyNotify notify);
static GIOError g_io_win32_fd_read (GIOChannel *channel,
gchar *buf,
guint count,
guint *bytes_written);
static GIOError g_io_win32_fd_write(GIOChannel *channel,
gchar *buf,
guint count,
guint *bytes_written);
static GIOError g_io_win32_fd_seek (GIOChannel *channel,
gint offset,
GSeekType type);
static void g_io_win32_fd_close (GIOChannel *channel);
static void g_io_win32_free (GIOChannel *channel);
static guint g_io_win32_fd_add_watch (GIOChannel *channel,
gint priority,
GIOCondition condition,
GIOFunc func,
gpointer user_data,
GDestroyNotify notify);
static GIOError g_io_win32_no_seek (GIOChannel *channel,
gint offset,
GSeekType type);
static GIOError g_io_win32_pipe_read (GIOChannel *channel,
gchar *buf,
guint count,
guint *bytes_written);
static GIOError g_io_win32_pipe_write (GIOChannel *channel,
gchar *buf,
guint count,
guint *bytes_written);
static void g_io_win32_pipe_close (GIOChannel *channel);
static guint g_io_win32_pipe_add_watch (GIOChannel *channel,
gint priority,
GIOCondition condition,
GIOFunc func,
gpointer user_data,
GDestroyNotify notify);
static void g_io_win32_pipe_free (GIOChannel *channel);
static GIOError g_io_win32_sock_read (GIOChannel *channel,
gchar *buf,
guint count,
guint *bytes_written);
static GIOError g_io_win32_sock_write(GIOChannel *channel,
gchar *buf,
guint count,
guint *bytes_written);
static void g_io_win32_sock_close (GIOChannel *channel);
static guint g_io_win32_sock_add_watch (GIOChannel *channel,
gint priority,
GIOCondition condition,
GIOFunc func,
gpointer user_data,
GDestroyNotify notify);
GSourceFuncs win32_watch_msg_funcs = {
g_io_win32_msg_prepare,
g_io_win32_msg_check,
g_io_win32_msg_dispatch,
g_io_win32_destroy
};
GSourceFuncs win32_watch_fd_funcs = {
g_io_win32_fd_prepare,
g_io_win32_fd_check,
g_io_win32_fd_dispatch,
g_io_win32_destroy
};
GSourceFuncs win32_watch_pipe_funcs = {
g_io_win32_pipe_prepare,
g_io_win32_pipe_check,
g_io_win32_pipe_dispatch,
g_io_win32_pipe_destroy
};
GSourceFuncs win32_watch_sock_funcs = {
g_io_win32_sock_prepare,
g_io_win32_sock_check,
g_io_win32_sock_dispatch,
g_io_win32_destroy
};
GIOFuncs win32_channel_msg_funcs = {
g_io_win32_msg_read,
g_io_win32_msg_write,
g_io_win32_no_seek,
g_io_win32_msg_close,
g_io_win32_msg_add_watch,
g_io_win32_free
};
GIOFuncs win32_channel_fd_funcs = {
g_io_win32_fd_read,
g_io_win32_fd_write,
g_io_win32_fd_seek,
g_io_win32_fd_close,
g_io_win32_fd_add_watch,
g_io_win32_free
};
GIOFuncs win32_channel_pipe_funcs = {
g_io_win32_pipe_read,
g_io_win32_pipe_write,
g_io_win32_no_seek,
g_io_win32_pipe_close,
g_io_win32_pipe_add_watch,
g_io_win32_pipe_free
};
GIOFuncs win32_channel_sock_funcs = {
g_io_win32_sock_read,
g_io_win32_sock_write,
g_io_win32_no_seek,
g_io_win32_sock_close,
g_io_win32_sock_add_watch,
g_io_win32_free
};
#define N_WATCHED_PIPES 4
static struct {
gint fd;
GIOWin32Watch *watch;
GIOWin32Channel *channel;
gpointer user_data;
} watched_pipes[N_WATCHED_PIPES];
static gint n_watched_pipes = 0;
static gboolean
g_io_win32_msg_prepare (gpointer source_data,
GTimeVal *current_time,
gint *timeout)
{
GIOWin32Watch *data = source_data;
GIOWin32Channel *win32_channel = (GIOWin32Channel *) data->channel;
MSG msg;
*timeout = -1;
return PeekMessage (&msg, win32_channel->hwnd, 0, 0, PM_NOREMOVE) == TRUE;
}
static gboolean
g_io_win32_msg_check (gpointer source_data,
GTimeVal *current_time)
{
GIOWin32Watch *data = source_data;
GIOWin32Channel *win32_channel = (GIOWin32Channel *) data->channel;
MSG msg;
return PeekMessage (&msg, win32_channel->hwnd, 0, 0, PM_NOREMOVE) == TRUE;
}
static gboolean
g_io_win32_msg_dispatch (gpointer source_data,
GTimeVal *current_time,
gpointer user_data)
{
GIOWin32Watch *data = source_data;
return (*data->callback)(data->channel,
data->pollfd.revents & data->condition,
user_data);
}
static void
g_io_win32_destroy (gpointer source_data)
{
GIOWin32Watch *data = source_data;
g_main_remove_poll (&data->pollfd);
g_io_channel_unref (data->channel);
g_free (data);
}
static gboolean
g_io_win32_fd_prepare (gpointer source_data,
GTimeVal *current_time,
gint *timeout)
{
*timeout = -1;
return FALSE;
}
static gboolean
g_io_win32_fd_check (gpointer source_data,
GTimeVal *current_time)
{
GIOWin32Watch *data = source_data;
return (data->pollfd.revents & data->condition);
}
static gboolean
g_io_win32_fd_dispatch (gpointer source_data,
GTimeVal *current_time,
gpointer user_data)
{
GIOWin32Watch *data = source_data;
return (*data->callback)(data->channel,
data->pollfd.revents & data->condition,
user_data);
}
static GIOError
g_io_win32_msg_read (GIOChannel *channel,
gchar *buf,
guint count,
guint *bytes_read)
{
GIOWin32Channel *win32_channel = (GIOWin32Channel *) channel;
MSG msg; /* In case of alignment problems */
if (count < sizeof (MSG))
return G_IO_ERROR_INVAL;
if (!PeekMessage (&msg, win32_channel->hwnd, 0, 0, PM_REMOVE))
return G_IO_ERROR_AGAIN;
memmove (buf, &msg, sizeof (MSG));
*bytes_read = sizeof (MSG);
return G_IO_ERROR_NONE;
}
static GIOError
g_io_win32_msg_write(GIOChannel *channel,
gchar *buf,
guint count,
guint *bytes_written)
{
GIOWin32Channel *win32_channel = (GIOWin32Channel *) channel;
MSG msg;
gint result;
if (count != sizeof (MSG))
return G_IO_ERROR_INVAL;
/* In case of alignment problems */
memmove (&msg, buf, sizeof (MSG));
if (!PostMessage (win32_channel->hwnd, msg.message, msg.wParam, msg.lParam))
return G_IO_ERROR_UNKNOWN;
*bytes_written = sizeof (MSG);
return G_IO_ERROR_NONE;
}
static GIOError
g_io_win32_no_seek (GIOChannel *channel,
gint offset,
GSeekType type)
{
g_warning ("g_io_win32_no_seek: unseekable IO channel type");
return G_IO_ERROR_UNKNOWN;
}
static void
g_io_win32_msg_close (GIOChannel *channel)
{
/* Nothing to be done. Or should we set hwnd to some invalid value? */
}
static void
g_io_win32_free (GIOChannel *channel)
{
GIOWin32Channel *win32_channel = (GIOWin32Channel *) channel;
g_free (win32_channel);
}
static guint
g_io_win32_msg_add_watch (GIOChannel *channel,
gint priority,
GIOCondition condition,
GIOFunc func,
gpointer user_data,
GDestroyNotify notify)
{
GIOWin32Watch *watch = g_new (GIOWin32Watch, 1);
GIOWin32Channel *win32_channel = (GIOWin32Channel *) channel;
watch->channel = channel;
g_io_channel_ref (channel);
watch->callback = func;
watch->condition = condition;
watch->pollfd.fd = G_WIN32_MSG_HANDLE;
watch->pollfd.events = condition;
g_main_add_poll (&watch->pollfd, priority);
return g_source_add (priority, TRUE, &win32_watch_msg_funcs,
watch, user_data, notify);
}
static gboolean
g_io_win32_pipe_prepare (gpointer source_data,
GTimeVal *current_time,
gint *timeout)
{
*timeout = -1;
return FALSE;
}
static gboolean
g_io_win32_pipe_check (gpointer source_data,
GTimeVal *current_time)
{
GIOWin32Watch *data = source_data;
return FALSE;
}
static gboolean
g_io_win32_pipe_dispatch (gpointer source_data,
GTimeVal *current_time,
gpointer user_data)
{
GIOWin32Watch *data = source_data;
return (*data->callback)(data->channel,
data->pollfd.revents & data->condition,
user_data);
}
static void
g_io_win32_pipe_destroy (gpointer source_data)
{
GIOWin32Watch *data = source_data;
g_io_channel_unref (data->channel);
g_free (data);
}
static gboolean
g_io_win32_sock_prepare (gpointer source_data,
GTimeVal *current_time,
gint *timeout)
{
*timeout = -1;
return FALSE;
}
static gboolean
g_io_win32_sock_check (gpointer source_data,
GTimeVal *current_time)
{
GIOWin32Watch *data = source_data;
return (data->pollfd.revents & data->condition);
}
static gboolean
g_io_win32_sock_dispatch (gpointer source_data,
GTimeVal *current_time,
gpointer user_data)
{
GIOWin32Watch *data = source_data;
return (*data->callback)(data->channel,
data->pollfd.revents & data->condition,
user_data);
}
static GIOError
g_io_win32_fd_read (GIOChannel *channel,
gchar *buf,
guint count,
guint *bytes_read)
{
GIOWin32Channel *win32_channel = (GIOWin32Channel *) channel;
gint result;
result = read (win32_channel->fd, buf, count);
if (result < 0)
{
*bytes_read = 0;
switch (errno)
{
case EINVAL:
return G_IO_ERROR_INVAL;
case EAGAIN:
return G_IO_ERROR_AGAIN;
default:
return G_IO_ERROR_UNKNOWN;
}
}
else
{
*bytes_read = result;
return G_IO_ERROR_NONE;
}
}
static GIOError
g_io_win32_fd_write(GIOChannel *channel,
gchar *buf,
guint count,
guint *bytes_written)
{
GIOWin32Channel *win32_channel = (GIOWin32Channel *) channel;
gint result;
result = write (win32_channel->fd, buf, count);
if (result < 0)
{
*bytes_written = 0;
switch (errno)
{
case EINVAL:
return G_IO_ERROR_INVAL;
case EAGAIN:
return G_IO_ERROR_AGAIN;
default:
return G_IO_ERROR_UNKNOWN;
}
}
else
{
*bytes_written = result;
return G_IO_ERROR_NONE;
}
}
static GIOError
g_io_win32_fd_seek (GIOChannel *channel,
gint offset,
GSeekType type)
{
GIOWin32Channel *win32_channel = (GIOWin32Channel *) channel;
int whence;
off_t result;
switch (type)
{
case G_SEEK_SET:
whence = SEEK_SET;
break;
case G_SEEK_CUR:
whence = SEEK_CUR;
break;
case G_SEEK_END:
whence = SEEK_END;
break;
default:
g_warning ("g_io_win32_fd_seek: unknown seek type");
return G_IO_ERROR_UNKNOWN;
}
result = lseek (win32_channel->fd, offset, whence);
if (result < 0)
{
switch (errno)
{
case EINVAL:
return G_IO_ERROR_INVAL;
default:
return G_IO_ERROR_UNKNOWN;
}
}
else
return G_IO_ERROR_NONE;
}
static void
g_io_win32_fd_close (GIOChannel *channel)
{
GIOWin32Channel *win32_channel = (GIOWin32Channel *) channel;
close (win32_channel->fd);
return;
}
static guint
g_io_win32_fd_add_watch (GIOChannel *channel,
gint priority,
GIOCondition condition,
GIOFunc func,
gpointer user_data,
GDestroyNotify notify)
{
GIOWin32Watch *watch = g_new (GIOWin32Watch, 1);
GIOWin32Channel *win32_channel = (GIOWin32Channel *) channel;
watch->channel = channel;
g_io_channel_ref (channel);
watch->callback = func;
watch->condition = condition;
/* This probably does not work, except for CONIN$. */
watch->pollfd.fd = _get_osfhandle (win32_channel->fd);
watch->pollfd.events = condition;
g_main_add_poll (&watch->pollfd, priority);
return g_source_add (priority, TRUE, &win32_watch_fd_funcs,
watch, user_data, notify);
}
static GIOError
g_io_win32_pipe_read (GIOChannel *channel,
gchar *buf,
guint count,
guint *bytes_read)
{
GIOWin32Channel *win32_channel = (GIOWin32Channel *) channel;
HANDLE handle;
DWORD avail;
gint result;
handle = (HANDLE) _get_osfhandle (win32_channel->fd);
if (!PeekNamedPipe (handle, NULL, 0, NULL, &avail, NULL))
{
return G_IO_ERROR_UNKNOWN;
}
count = MIN (count, avail);
count = MAX (count, 1); /* Must read at least one byte, or
* caller will think it's EOF.
*/
/* g_print ("g_io_win32_pipe_read: %d %d\n", win32_channel->fd, count); */
if (count == 0)
result = 0;
else
result = read (win32_channel->fd, buf, count);
if (result < 0)
{
*bytes_read = 0;
switch (errno)
{
case EINVAL:
return G_IO_ERROR_INVAL;
case EAGAIN:
return G_IO_ERROR_AGAIN;
default:
return G_IO_ERROR_UNKNOWN;
}
}
else
{
*bytes_read = result;
win32_channel->offset += result;
/* g_print ("=%d (%d)\n", result, win32_channel->offset); */
return G_IO_ERROR_NONE;
}
}
static GIOError
g_io_win32_pipe_write(GIOChannel *channel,
gchar *buf,
guint count,
guint *bytes_written)
{
GIOWin32Channel *win32_channel = (GIOWin32Channel *) channel;
LONG prevcnt;
gint result;
/* g_print ("g_io_win32_pipe_write: %d %d\n", win32_channel->fd, count); */
result = write (win32_channel->fd, buf, count);
if (result < 0)
{
*bytes_written = 0;
switch (errno)
{
case EINVAL:
return G_IO_ERROR_INVAL;
case EAGAIN:
return G_IO_ERROR_AGAIN;
default:
return G_IO_ERROR_UNKNOWN;
}
}
else
{
if (g_pipe_readable_msg == 0)
g_pipe_readable_msg = RegisterWindowMessage ("g-pipe-readable");
win32_channel->offset += result;
/* g_print ("=%d (%d)\n", result, win32_channel->offset); */
if (win32_channel->need_wakeups)
{
PostThreadMessage (win32_channel->peer,
g_pipe_readable_msg,
win32_channel->peer_fd,
win32_channel->offset);
}
*bytes_written = result;
return G_IO_ERROR_NONE;
}
}
static void
g_io_win32_pipe_close (GIOChannel *channel)
{
GIOWin32Channel *win32_channel = (GIOWin32Channel *) channel;
/* g_print ("g_io_win32_pipe_close: %#x %d\n", channel, win32_channel->fd); */
close (win32_channel->fd);
return;
}
static guint
g_io_win32_pipe_add_watch (GIOChannel *channel,
gint priority,
GIOCondition condition,
GIOFunc func,
gpointer user_data,
GDestroyNotify notify)
{
GIOWin32Watch *watch = g_new (GIOWin32Watch, 1);
GIOWin32Channel *win32_channel = (GIOWin32Channel *) channel;
gint i;
/* g_print ("g_io_win32_pipe_add_watch: %d\n", win32_channel->fd); */
watch->channel = channel;
g_io_channel_ref (channel);
watch->callback = func;
watch->condition = condition;
watch->pollfd.fd = win32_channel->fd;
watch->pollfd.events = condition;
for (i = 0; i < n_watched_pipes; i++)
if (watched_pipes[i].fd == -1)
break;
if (i == N_WATCHED_PIPES)
g_error ("Too many watched pipes");
else
{
watched_pipes[i].fd = win32_channel->fd;
watched_pipes[i].watch = watch;
watched_pipes[i].channel = win32_channel;
watched_pipes[i].user_data = user_data;
n_watched_pipes = MAX (i + 1, n_watched_pipes);
}
return g_source_add (priority, FALSE, &win32_watch_pipe_funcs, watch, user_data, notify);
}
static void
g_io_win32_pipe_free (GIOChannel *channel)
{
GIOWin32Channel *win32_channel = (GIOWin32Channel *) channel;
gint i;
/* g_print ("g_io_win32_pipe_free: %#x %#x\n", channel, channel->channel_data); */
for (i = 0; i < n_watched_pipes; i++)
if (watched_pipes[i].fd == win32_channel->fd)
{
watched_pipes[i].fd = -1;
break;
}
g_io_win32_free (channel);
}
static GIOError
g_io_win32_sock_read (GIOChannel *channel,
gchar *buf,
guint count,
guint *bytes_read)
{
GIOWin32Channel *win32_channel = (GIOWin32Channel *) channel;
gint result;
result = recv (win32_channel->fd, buf, count, 0);
if (result == SOCKET_ERROR)
{
*bytes_read = 0;
switch (WSAGetLastError ())
{
case WSAEINVAL:
return G_IO_ERROR_INVAL;
case WSAEWOULDBLOCK:
case WSAEINTR:
return G_IO_ERROR_AGAIN;
default:
return G_IO_ERROR_UNKNOWN;
}
}
else
{
*bytes_read = result;
return G_IO_ERROR_NONE;
}
}
static GIOError
g_io_win32_sock_write(GIOChannel *channel,
gchar *buf,
guint count,
guint *bytes_written)
{
GIOWin32Channel *win32_channel = (GIOWin32Channel *) channel;
gint result;
result = send (win32_channel->fd, buf, count, 0);
if (result == SOCKET_ERROR)
{
*bytes_written = 0;
switch (WSAGetLastError ())
{
case WSAEINVAL:
return G_IO_ERROR_INVAL;
case WSAEWOULDBLOCK:
case WSAEINTR:
return G_IO_ERROR_AGAIN;
default:
return G_IO_ERROR_UNKNOWN;
}
}
else
{
*bytes_written = result;
return G_IO_ERROR_NONE;
}
}
static void
g_io_win32_sock_close (GIOChannel *channel)
{
GIOWin32Channel *win32_channel = (GIOWin32Channel *) channel;
closesocket (win32_channel->fd);
return;
}
static guint
g_io_win32_sock_add_watch (GIOChannel *channel,
gint priority,
GIOCondition condition,
GIOFunc func,
gpointer user_data,
GDestroyNotify notify)
{
GIOWin32Watch *watch = g_new (GIOWin32Watch, 1);
GIOWin32Channel *win32_channel = (GIOWin32Channel *) channel;
watch->channel = channel;
g_io_channel_ref (channel);
watch->callback = func;
watch->condition = condition;
watch->pollfd.fd = win32_channel->fd;
watch->pollfd.events = condition;
g_main_add_poll (&watch->pollfd, priority);
return g_source_add (priority, TRUE, &win32_watch_sock_funcs, watch, user_data, notify);
}
GIOChannel *
g_io_channel_win32_new_messages (guint hwnd)
{
GIOWin32Channel *win32_channel = g_new (GIOWin32Channel, 1);
GIOChannel *channel = (GIOChannel *) win32_channel;
g_io_channel_init (channel);
channel->funcs = &win32_channel_msg_funcs;
win32_channel->fd = -1;
win32_channel->type = G_IO_WINDOWS_MESSAGES;
win32_channel->hwnd = (HWND) hwnd;
return channel;
}
GIOChannel *
g_io_channel_unix_new (gint fd)
{
GIOWin32Channel *win32_channel = g_new (GIOWin32Channel, 1);
GIOChannel *channel = (GIOChannel *) win32_channel;
g_io_channel_init (channel);
channel->funcs = &win32_channel_fd_funcs;
win32_channel->fd = fd;
win32_channel->type = G_IO_FILE_DESC;
return channel;
}
gint
g_io_channel_unix_get_fd (GIOChannel *channel)
{
GIOWin32Channel *win32_channel = (GIOWin32Channel *) channel;
return win32_channel->fd;
}
GIOChannel *
g_io_channel_win32_new_pipe_with_wakeups (int fd,
guint peer,
int peer_fd)
{
GIOWin32Channel *win32_channel = g_new (GIOWin32Channel, 1);
GIOChannel *channel = (GIOChannel *) win32_channel;
/* g_print ("g_io_channel_win32_new_pipe_with_wakeups %d %#x %d\n", fd, peer, peer_fd); */
g_io_channel_init (channel);
channel->funcs = &win32_channel_pipe_funcs;
win32_channel->fd = fd;
win32_channel->type = G_IO_PIPE;
win32_channel->peer = peer;
win32_channel->peer_fd = peer_fd;
win32_channel->offset = 0;
win32_channel->need_wakeups = TRUE;
return channel;
}
GIOChannel *
g_io_channel_win32_new_pipe (int fd)
{
GIOWin32Channel *win32_channel = g_new (GIOWin32Channel, 1);
GIOChannel *channel = (GIOChannel *) win32_channel;
g_io_channel_init (channel);
channel->funcs = &win32_channel_pipe_funcs;
win32_channel->fd = fd;
win32_channel->type = G_IO_PIPE;
win32_channel->offset = 0;
win32_channel->need_wakeups = FALSE;
return channel;
}
GIOChannel *
g_io_channel_win32_new_stream_socket (int socket)
{
GIOWin32Channel *win32_channel = g_new (GIOWin32Channel, 1);
GIOChannel *channel = (GIOChannel *) win32_channel;
g_io_channel_init (channel);
channel->funcs = &win32_channel_sock_funcs;
win32_channel->fd = socket;
win32_channel->type = G_IO_STREAM_SOCKET;
return channel;
}
gint
g_io_channel_win32_get_fd (GIOChannel *channel)
{
return g_io_channel_unix_get_fd (channel);
}
void
g_io_channel_win32_pipe_request_wakeups (GIOChannel *channel,
guint peer,
int peer_fd)
{
GIOWin32Channel *win32_channel = (GIOWin32Channel *) channel;
win32_channel->peer = peer;
win32_channel->peer_fd = peer_fd;
win32_channel->need_wakeups = TRUE;
}
void
g_io_channel_win32_pipe_readable (gint fd,
guint offset)
{
gint i;
for (i = 0; i < n_watched_pipes; i++)
if (watched_pipes[i].fd == fd)
{
if (watched_pipes[i].channel->offset < offset)
(*watched_pipes[i].watch->callback) (watched_pipes[i].watch->channel,
G_IO_IN,
watched_pipes[i].user_data);
break;
}
}
Reference in New Issue View Git Blame Copy Permalink