--- /dev/null
+#include <stdlib.h>
+#include <stdio.h>
+#include <stdbool.h>
+#include <glib.h>
+#include <windows.h>
+#include <errno.h>
+#include <io.h>
+#include "qga/guest-agent-core.h"
+#include "qga/channel.h"
+
+typedef struct GAChannelReadState {
+ guint thread_id;
+ uint8_t *buf;
+ size_t buf_size;
+ size_t cur; /* current buffer start */
+ size_t pending; /* pending buffered bytes to read */
+ OVERLAPPED ov;
+ bool ov_pending; /* whether on async read is outstanding */
+} GAChannelReadState;
+
+struct GAChannel {
+ HANDLE handle;
+ GAChannelCallback cb;
+ gpointer user_data;
+ GAChannelReadState rstate;
+ GIOCondition pending_events; /* TODO: use GAWatch.pollfd.revents */
+ GSource *source;
+};
+
+typedef struct GAWatch {
+ GSource source;
+ GPollFD pollfd;
+ GAChannel *channel;
+ GIOCondition events_mask;
+} GAWatch;
+
+/*
+ * Called by glib prior to polling to set up poll events if polling is needed.
+ *
+ */
+static gboolean ga_channel_prepare(GSource *source, gint *timeout_ms)
+{
+ GAWatch *watch = (GAWatch *)source;
+ GAChannel *c = (GAChannel *)watch->channel;
+ GAChannelReadState *rs = &c->rstate;
+ DWORD count_read, count_to_read = 0;
+ bool success;
+ GIOCondition new_events = 0;
+
+ g_debug("prepare");
+ /* go ahead and submit another read if there's room in the buffer
+ * and no previous reads are outstanding
+ */
+ if (!rs->ov_pending) {
+ if (rs->cur + rs->pending >= rs->buf_size) {
+ if (rs->cur) {
+ memmove(rs->buf, rs->buf + rs->cur, rs->pending);
+ rs->cur = 0;
+ }
+ }
+ count_to_read = rs->buf_size - rs->cur - rs->pending;
+ }
+
+ if (rs->ov_pending || count_to_read <= 0) {
+ goto out;
+ }
+
+ /* submit the read */
+ success = ReadFile(c->handle, rs->buf + rs->cur + rs->pending,
+ count_to_read, &count_read, &rs->ov);
+ if (success) {
+ rs->pending += count_read;
+ rs->ov_pending = false;
+ } else {
+ if (GetLastError() == ERROR_IO_PENDING) {
+ rs->ov_pending = true;
+ } else {
+ new_events |= G_IO_ERR;
+ }
+ }
+
+out:
+ /* dont block forever, iterate the main loop every once and a while */
+ *timeout_ms = 500;
+ /* if there's data in the read buffer, or another event is pending,
+ * skip polling and issue user cb.
+ */
+ if (rs->pending) {
+ new_events |= G_IO_IN;
+ }
+ c->pending_events |= new_events;
+ return !!c->pending_events;
+}
+
+/*
+ * Called by glib after an outstanding read request is completed.
+ */
+static gboolean ga_channel_check(GSource *source)
+{
+ GAWatch *watch = (GAWatch *)source;
+ GAChannel *c = (GAChannel *)watch->channel;
+ GAChannelReadState *rs = &c->rstate;
+ DWORD count_read, error;
+ BOOL success;
+
+ GIOCondition new_events = 0;
+
+ g_debug("check");
+
+ /* failing this implies we issued a read that completed immediately,
+ * yet no data was placed into the buffer (and thus we did not skip
+ * polling). but since EOF is not obtainable until we retrieve an
+ * overlapped result, it must be the case that there was data placed
+ * into the buffer, or an error was generated by Readfile(). in either
+ * case, we should've skipped the polling for this round.
+ */
+ g_assert(rs->ov_pending);
+
+ success = GetOverlappedResult(c->handle, &rs->ov, &count_read, FALSE);
+ if (success) {
+ g_debug("thread: overlapped result, count_read: %d", (int)count_read);
+ rs->pending += count_read;
+ new_events |= G_IO_IN;
+ } else {
+ error = GetLastError();
+ if (error == 0 || error == ERROR_HANDLE_EOF ||
+ error == ERROR_NO_SYSTEM_RESOURCES ||
+ error == ERROR_OPERATION_ABORTED) {
+ /* note: On WinXP SP3 with rhel6ga virtio-win-1.1.16 vioser drivers,
+ * ENSR seems to be synonymous with when we'd normally expect
+ * ERROR_HANDLE_EOF. So treat it as such. Microsoft's
+ * recommendation for ERROR_NO_SYSTEM_RESOURCES is to
+ * retry the read, so this happens to work out anyway. On newer
+ * virtio-win driver, this seems to be replaced with EOA, so
+ * handle that in the same fashion.
+ */
+ new_events |= G_IO_HUP;
+ } else if (error != ERROR_IO_INCOMPLETE) {
+ g_critical("error retrieving overlapped result: %d", (int)error);
+ new_events |= G_IO_ERR;
+ }
+ }
+
+ if (new_events) {
+ rs->ov_pending = 0;
+ }
+ c->pending_events |= new_events;
+
+ return !!c->pending_events;
+}
+
+/*
+ * Called by glib after either prepare or check routines signal readiness
+ */
+static gboolean ga_channel_dispatch(GSource *source, GSourceFunc unused,
+ gpointer user_data)
+{
+ GAWatch *watch = (GAWatch *)source;
+ GAChannel *c = (GAChannel *)watch->channel;
+ GAChannelReadState *rs = &c->rstate;
+ gboolean success;
+
+ g_debug("dispatch");
+ success = c->cb(watch->pollfd.revents, c->user_data);
+
+ if (c->pending_events & G_IO_ERR) {
+ g_critical("channel error, removing source");
+ return false;
+ }
+
+ /* TODO: replace rs->pending with watch->revents */
+ c->pending_events &= ~G_IO_HUP;
+ if (!rs->pending) {
+ c->pending_events &= ~G_IO_IN;
+ } else {
+ c->pending_events = 0;
+ }
+ return success;
+}
+
+static void ga_channel_finalize(GSource *source)
+{
+ g_debug("finalize");
+}
+
+GSourceFuncs ga_channel_watch_funcs = {
+ ga_channel_prepare,
+ ga_channel_check,
+ ga_channel_dispatch,
+ ga_channel_finalize
+};
+
+static GSource *ga_channel_create_watch(GAChannel *c)
+{
+ GSource *source = g_source_new(&ga_channel_watch_funcs, sizeof(GAWatch));
+ GAWatch *watch = (GAWatch *)source;
+
+ watch->channel = c;
+ watch->pollfd.fd = (gintptr) c->rstate.ov.hEvent;
+ g_source_add_poll(source, &watch->pollfd);
+
+ return source;
+}
+
+GIOStatus ga_channel_read(GAChannel *c, char *buf, size_t size, gsize *count)
+{
+ GAChannelReadState *rs = &c->rstate;
+ GIOStatus status;
+ size_t to_read = 0;
+
+ if (c->pending_events & G_IO_ERR) {
+ return G_IO_STATUS_ERROR;
+ }
+
+ *count = to_read = MIN(size, rs->pending);
+ if (to_read) {
+ memcpy(buf, rs->buf + rs->cur, to_read);
+ rs->cur += to_read;
+ rs->pending -= to_read;
+ status = G_IO_STATUS_NORMAL;
+ } else {
+ status = G_IO_STATUS_AGAIN;
+ }
+
+ return status;
+}
+
+static GIOStatus ga_channel_write(GAChannel *c, const char *buf, size_t size,
+ size_t *count)
+{
+ GIOStatus status;
+ OVERLAPPED ov = {0};
+ BOOL ret;
+ DWORD written;
+
+ ov.hEvent = CreateEvent(NULL, FALSE, FALSE, NULL);
+ ret = WriteFile(c->handle, buf, size, &written, &ov);
+ if (!ret) {
+ if (GetLastError() == ERROR_IO_PENDING) {
+ /* write is pending */
+ ret = GetOverlappedResult(c->handle, &ov, &written, TRUE);
+ if (!ret) {
+ if (!GetLastError()) {
+ status = G_IO_STATUS_AGAIN;
+ } else {
+ status = G_IO_STATUS_ERROR;
+ }
+ } else {
+ /* write is complete */
+ status = G_IO_STATUS_NORMAL;
+ *count = written;
+ }
+ } else {
+ status = G_IO_STATUS_ERROR;
+ }
+ } else {
+ /* write returned immediately */
+ status = G_IO_STATUS_NORMAL;
+ *count = written;
+ }
+
+ if (ov.hEvent) {
+ CloseHandle(ov.hEvent);
+ ov.hEvent = NULL;
+ }
+ return status;
+}
+
+GIOStatus ga_channel_write_all(GAChannel *c, const char *buf, size_t size)
+{
+ GIOStatus status = G_IO_STATUS_NORMAL;
+ size_t count;
+
+ while (size) {
+ status = ga_channel_write(c, buf, size, &count);
+ if (status == G_IO_STATUS_NORMAL) {
+ size -= count;
+ buf += count;
+ } else if (status != G_IO_STATUS_AGAIN) {
+ break;
+ }
+ }
+
+ return status;
+}
+
+static gboolean ga_channel_open(GAChannel *c, GAChannelMethod method,
+ const gchar *path)
+{
+ COMMTIMEOUTS comTimeOut = {0};
+ gchar newpath[MAXPATHLEN] = {0};
+ comTimeOut.ReadIntervalTimeout = 1;
+
+ if (method != GA_CHANNEL_VIRTIO_SERIAL && method != GA_CHANNEL_ISA_SERIAL) {
+ g_critical("unsupported communication method");
+ return false;
+ }
+
+ if (method == GA_CHANNEL_ISA_SERIAL){
+ snprintf(newpath, sizeof(newpath), "\\\\.\\%s", path);
+ }else {
+ g_strlcpy(newpath, path, sizeof(newpath));
+ }
+
+ c->handle = CreateFile(newpath, GENERIC_READ | GENERIC_WRITE, 0, NULL,
+ OPEN_EXISTING,
+ FILE_FLAG_NO_BUFFERING | FILE_FLAG_OVERLAPPED, NULL);
+ if (c->handle == INVALID_HANDLE_VALUE) {
+ g_critical("error opening path %s", newpath);
+ return false;
+ }
+
+ if (method == GA_CHANNEL_ISA_SERIAL && !SetCommTimeouts(c->handle,&comTimeOut)) {
+ g_critical("error setting timeout for com port: %lu",GetLastError());
+ CloseHandle(c->handle);
+ return false;
+ }
+
+ return true;
+}
+
+GAChannel *ga_channel_new(GAChannelMethod method, const gchar *path,
+ GAChannelCallback cb, gpointer opaque)
+{
+ GAChannel *c = g_malloc0(sizeof(GAChannel));
+ SECURITY_ATTRIBUTES sec_attrs;
+
+ if (!ga_channel_open(c, method, path)) {
+ g_critical("error opening channel");
+ g_free(c);
+ return NULL;
+ }
+
+ c->cb = cb;
+ c->user_data = opaque;
+
+ sec_attrs.nLength = sizeof(SECURITY_ATTRIBUTES);
+ sec_attrs.lpSecurityDescriptor = NULL;
+ sec_attrs.bInheritHandle = false;
+
+ c->rstate.buf_size = QGA_READ_COUNT_DEFAULT;
+ c->rstate.buf = g_malloc(QGA_READ_COUNT_DEFAULT);
+ c->rstate.ov.hEvent = CreateEvent(&sec_attrs, FALSE, FALSE, NULL);
+
+ c->source = ga_channel_create_watch(c);
+ g_source_attach(c->source, NULL);
+ return c;
+}
+
+void ga_channel_free(GAChannel *c)
+{
+ if (c->source) {
+ g_source_destroy(c->source);
+ }
+ if (c->rstate.ov.hEvent) {
+ CloseHandle(c->rstate.ov.hEvent);
+ }
+ g_free(c->rstate.buf);
+ g_free(c);
+}
Code Review / kvmfornfv.git / blobdiff