qemu/io/channel-watch.c
Chetan Pant c8198bd5f9 io: Fix Lesser GPL version number
There is no "version 2" of the "Lesser" General Public License.
It is either "GPL version 2.0" or "Lesser GPL version 2.1".
This patch replaces all occurrences of "Lesser GPL version 2" with
"Lesser GPL version 2.1" in comment section.

Signed-off-by: Chetan Pant <chetan4windows@gmail.com>
Acked-by: Daniel P. Berrangé <berrange@redhat.com>
Message-Id: <20201014134033.14095-1-chetan4windows@gmail.com>
Signed-off-by: Laurent Vivier <laurent@vivier.eu>
2020-10-27 16:48:49 +01:00

354 lines
8.7 KiB
C

/*
* QEMU I/O channels watch helper APIs
*
* Copyright (c) 2015 Red Hat, Inc.
*
* 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.1 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, see <http://www.gnu.org/licenses/>.
*
*/
#include "qemu/osdep.h"
#include "io/channel-watch.h"
typedef struct QIOChannelFDSource QIOChannelFDSource;
struct QIOChannelFDSource {
GSource parent;
GPollFD fd;
QIOChannel *ioc;
GIOCondition condition;
};
#ifdef CONFIG_WIN32
typedef struct QIOChannelSocketSource QIOChannelSocketSource;
struct QIOChannelSocketSource {
GSource parent;
GPollFD fd;
QIOChannel *ioc;
SOCKET socket;
int revents;
GIOCondition condition;
};
#endif
typedef struct QIOChannelFDPairSource QIOChannelFDPairSource;
struct QIOChannelFDPairSource {
GSource parent;
GPollFD fdread;
GPollFD fdwrite;
QIOChannel *ioc;
GIOCondition condition;
};
static gboolean
qio_channel_fd_source_prepare(GSource *source G_GNUC_UNUSED,
gint *timeout)
{
*timeout = -1;
return FALSE;
}
static gboolean
qio_channel_fd_source_check(GSource *source)
{
QIOChannelFDSource *ssource = (QIOChannelFDSource *)source;
return ssource->fd.revents & ssource->condition;
}
static gboolean
qio_channel_fd_source_dispatch(GSource *source,
GSourceFunc callback,
gpointer user_data)
{
QIOChannelFunc func = (QIOChannelFunc)callback;
QIOChannelFDSource *ssource = (QIOChannelFDSource *)source;
return (*func)(ssource->ioc,
ssource->fd.revents & ssource->condition,
user_data);
}
static void
qio_channel_fd_source_finalize(GSource *source)
{
QIOChannelFDSource *ssource = (QIOChannelFDSource *)source;
object_unref(OBJECT(ssource->ioc));
}
#ifdef CONFIG_WIN32
static gboolean
qio_channel_socket_source_prepare(GSource *source G_GNUC_UNUSED,
gint *timeout)
{
*timeout = -1;
return FALSE;
}
/*
* NB, this impl only works when the socket is in non-blocking
* mode on Win32
*/
static gboolean
qio_channel_socket_source_check(GSource *source)
{
static struct timeval tv0;
QIOChannelSocketSource *ssource = (QIOChannelSocketSource *)source;
WSANETWORKEVENTS ev;
fd_set rfds, wfds, xfds;
if (!ssource->condition) {
return 0;
}
WSAEnumNetworkEvents(ssource->socket, ssource->ioc->event, &ev);
FD_ZERO(&rfds);
FD_ZERO(&wfds);
FD_ZERO(&xfds);
if (ssource->condition & G_IO_IN) {
FD_SET((SOCKET)ssource->socket, &rfds);
}
if (ssource->condition & G_IO_OUT) {
FD_SET((SOCKET)ssource->socket, &wfds);
}
if (ssource->condition & G_IO_PRI) {
FD_SET((SOCKET)ssource->socket, &xfds);
}
ssource->revents = 0;
if (select(0, &rfds, &wfds, &xfds, &tv0) == 0) {
return 0;
}
if (FD_ISSET(ssource->socket, &rfds)) {
ssource->revents |= G_IO_IN;
}
if (FD_ISSET(ssource->socket, &wfds)) {
ssource->revents |= G_IO_OUT;
}
if (FD_ISSET(ssource->socket, &xfds)) {
ssource->revents |= G_IO_PRI;
}
return ssource->revents;
}
static gboolean
qio_channel_socket_source_dispatch(GSource *source,
GSourceFunc callback,
gpointer user_data)
{
QIOChannelFunc func = (QIOChannelFunc)callback;
QIOChannelSocketSource *ssource = (QIOChannelSocketSource *)source;
return (*func)(ssource->ioc, ssource->revents, user_data);
}
static void
qio_channel_socket_source_finalize(GSource *source)
{
QIOChannelSocketSource *ssource = (QIOChannelSocketSource *)source;
object_unref(OBJECT(ssource->ioc));
}
GSourceFuncs qio_channel_socket_source_funcs = {
qio_channel_socket_source_prepare,
qio_channel_socket_source_check,
qio_channel_socket_source_dispatch,
qio_channel_socket_source_finalize
};
#endif
static gboolean
qio_channel_fd_pair_source_prepare(GSource *source G_GNUC_UNUSED,
gint *timeout)
{
*timeout = -1;
return FALSE;
}
static gboolean
qio_channel_fd_pair_source_check(GSource *source)
{
QIOChannelFDPairSource *ssource = (QIOChannelFDPairSource *)source;
GIOCondition poll_condition = ssource->fdread.revents |
ssource->fdwrite.revents;
return poll_condition & ssource->condition;
}
static gboolean
qio_channel_fd_pair_source_dispatch(GSource *source,
GSourceFunc callback,
gpointer user_data)
{
QIOChannelFunc func = (QIOChannelFunc)callback;
QIOChannelFDPairSource *ssource = (QIOChannelFDPairSource *)source;
GIOCondition poll_condition = ssource->fdread.revents |
ssource->fdwrite.revents;
return (*func)(ssource->ioc,
poll_condition & ssource->condition,
user_data);
}
static void
qio_channel_fd_pair_source_finalize(GSource *source)
{
QIOChannelFDPairSource *ssource = (QIOChannelFDPairSource *)source;
object_unref(OBJECT(ssource->ioc));
}
GSourceFuncs qio_channel_fd_source_funcs = {
qio_channel_fd_source_prepare,
qio_channel_fd_source_check,
qio_channel_fd_source_dispatch,
qio_channel_fd_source_finalize
};
GSourceFuncs qio_channel_fd_pair_source_funcs = {
qio_channel_fd_pair_source_prepare,
qio_channel_fd_pair_source_check,
qio_channel_fd_pair_source_dispatch,
qio_channel_fd_pair_source_finalize
};
GSource *qio_channel_create_fd_watch(QIOChannel *ioc,
int fd,
GIOCondition condition)
{
GSource *source;
QIOChannelFDSource *ssource;
source = g_source_new(&qio_channel_fd_source_funcs,
sizeof(QIOChannelFDSource));
ssource = (QIOChannelFDSource *)source;
ssource->ioc = ioc;
object_ref(OBJECT(ioc));
ssource->condition = condition;
#ifdef CONFIG_WIN32
ssource->fd.fd = (gint64)_get_osfhandle(fd);
#else
ssource->fd.fd = fd;
#endif
ssource->fd.events = condition;
g_source_add_poll(source, &ssource->fd);
return source;
}
#ifdef CONFIG_WIN32
GSource *qio_channel_create_socket_watch(QIOChannel *ioc,
int socket,
GIOCondition condition)
{
GSource *source;
QIOChannelSocketSource *ssource;
#ifdef WIN32
WSAEventSelect(socket, ioc->event,
FD_READ | FD_ACCEPT | FD_CLOSE |
FD_CONNECT | FD_WRITE | FD_OOB);
#endif
source = g_source_new(&qio_channel_socket_source_funcs,
sizeof(QIOChannelSocketSource));
ssource = (QIOChannelSocketSource *)source;
ssource->ioc = ioc;
object_ref(OBJECT(ioc));
ssource->condition = condition;
ssource->socket = socket;
ssource->revents = 0;
ssource->fd.fd = (gintptr)ioc->event;
ssource->fd.events = G_IO_IN;
g_source_add_poll(source, &ssource->fd);
return source;
}
#else
GSource *qio_channel_create_socket_watch(QIOChannel *ioc,
int socket,
GIOCondition condition)
{
return qio_channel_create_fd_watch(ioc, socket, condition);
}
#endif
GSource *qio_channel_create_fd_pair_watch(QIOChannel *ioc,
int fdread,
int fdwrite,
GIOCondition condition)
{
GSource *source;
QIOChannelFDPairSource *ssource;
source = g_source_new(&qio_channel_fd_pair_source_funcs,
sizeof(QIOChannelFDPairSource));
ssource = (QIOChannelFDPairSource *)source;
ssource->ioc = ioc;
object_ref(OBJECT(ioc));
ssource->condition = condition;
#ifdef CONFIG_WIN32
ssource->fdread.fd = (gint64)_get_osfhandle(fdread);
ssource->fdwrite.fd = (gint64)_get_osfhandle(fdwrite);
#else
ssource->fdread.fd = fdread;
ssource->fdwrite.fd = fdwrite;
#endif
ssource->fdread.events = condition & G_IO_IN;
ssource->fdwrite.events = condition & G_IO_OUT;
g_source_add_poll(source, &ssource->fdread);
g_source_add_poll(source, &ssource->fdwrite);
return source;
}