#include <stdbool.h>
#include <glib.h>
#include <getopt.h>
-#include <termios.h>
+#ifndef _WIN32
#include <syslog.h>
-#include "qemu_socket.h"
+#include <sys/wait.h>
+#endif
#include "json-streamer.h"
#include "json-parser.h"
#include "qint.h"
#include "qerror.h"
#include "error_int.h"
#include "qapi/qmp-core.h"
+#include "qga/channel.h"
+#ifdef _WIN32
+#include "qga/service-win32.h"
+#include <windows.h>
+#endif
+#ifndef _WIN32
#define QGA_VIRTIO_PATH_DEFAULT "/dev/virtio-ports/org.qemu.guest_agent.0"
+#else
+#define QGA_VIRTIO_PATH_DEFAULT "\\\\.\\Global\\org.qemu.guest_agent.0"
+#endif
#define QGA_PIDFILE_DEFAULT "/var/run/qemu-ga.pid"
-#define QGA_BAUDRATE_DEFAULT B38400 /* for isa-serial channels */
-#define QGA_TIMEOUT_DEFAULT 30*1000 /* ms */
+#define QGA_SENTINEL_BYTE 0xFF
struct GAState {
JSONMessageParser parser;
GMainLoop *main_loop;
- GIOChannel *conn_channel;
- GIOChannel *listen_channel;
- const char *path;
- const char *method;
+ GAChannel *channel;
bool virtio; /* fastpath to check for virtio to deal with poll() quirks */
GACommandState *command_state;
GLogLevelFlags log_level;
FILE *log_file;
bool logging_enabled;
+#ifdef _WIN32
+ GAService service;
+#endif
+ bool delimit_response;
};
-static struct GAState *ga_state;
+struct GAState *ga_state;
+
+#ifdef _WIN32
+DWORD WINAPI service_ctrl_handler(DWORD ctrl, DWORD type, LPVOID data,
+ LPVOID ctx);
+VOID WINAPI service_main(DWORD argc, TCHAR *argv[]);
+#endif
static void quit_handler(int sig)
{
}
}
-static void register_signal_handlers(void)
+#ifndef _WIN32
+/* reap _all_ terminated children */
+static void child_handler(int sig)
+{
+ int status;
+ while (waitpid(-1, &status, WNOHANG) > 0) /* NOTHING */;
+}
+
+static gboolean register_signal_handlers(void)
{
- struct sigaction sigact;
+ struct sigaction sigact, sigact_chld;
int ret;
memset(&sigact, 0, sizeof(struct sigaction));
ret = sigaction(SIGINT, &sigact, NULL);
if (ret == -1) {
g_error("error configuring signal handler: %s", strerror(errno));
- exit(EXIT_FAILURE);
+ return false;
}
ret = sigaction(SIGTERM, &sigact, NULL);
if (ret == -1) {
g_error("error configuring signal handler: %s", strerror(errno));
+ return false;
}
+
+ memset(&sigact_chld, 0, sizeof(struct sigaction));
+ sigact_chld.sa_handler = child_handler;
+ sigact_chld.sa_flags = SA_NOCLDSTOP;
+ ret = sigaction(SIGCHLD, &sigact_chld, NULL);
+ if (ret == -1) {
+ g_error("error configuring signal handler: %s", strerror(errno));
+ }
+
+ return true;
}
+#endif
static void usage(const char *cmd)
{
" -v, --verbose log extra debugging information\n"
" -V, --version print version information and exit\n"
" -d, --daemonize become a daemon\n"
+#ifdef _WIN32
+" -s, --service service commands: install, uninstall\n"
+#endif
" -b, --blacklist comma-separated list of RPCs to disable (no spaces, \"?\""
" to list available RPCs)\n"
" -h, --help display this help and exit\n"
, cmd, QGA_VERSION, QGA_VIRTIO_PATH_DEFAULT, QGA_PIDFILE_DEFAULT);
}
-static void conn_channel_close(GAState *s);
-
static const char *ga_log_level_str(GLogLevelFlags level)
{
switch (level & G_LOG_LEVEL_MASK) {
}
level &= G_LOG_LEVEL_MASK;
+#ifndef _WIN32
if (domain && strcmp(domain, "syslog") == 0) {
syslog(LOG_INFO, "%s: %s", level_str, msg);
} else if (level & s->log_level) {
+#else
+ if (level & s->log_level) {
+#endif
g_get_current_time(&time);
fprintf(s->log_file,
"%lu.%lu: %s: %s\n", time.tv_sec, time.tv_usec, level_str, msg);
}
}
+void ga_set_response_delimited(GAState *s)
+{
+ s->delimit_response = true;
+}
+
+#ifndef _WIN32
static void become_daemon(const char *pidfile)
{
pid_t pid, sid;
g_critical("failed to daemonize");
exit(EXIT_FAILURE);
}
+#endif
-static int conn_channel_send_buf(GIOChannel *channel, const char *buf,
- gsize count)
+static int send_response(GAState *s, QObject *payload)
{
- GError *err = NULL;
- gsize written = 0;
- GIOStatus status;
-
- while (count) {
- status = g_io_channel_write_chars(channel, buf, count, &written, &err);
- g_debug("sending data, count: %d", (int)count);
- if (err != NULL) {
- g_warning("error sending newline: %s", err->message);
- return err->code;
- }
- if (status == G_IO_STATUS_ERROR || status == G_IO_STATUS_EOF) {
- return -EPIPE;
- }
-
- if (status == G_IO_STATUS_NORMAL) {
- count -= written;
- }
- }
-
- return 0;
-}
-
-static int conn_channel_send_payload(GIOChannel *channel, QObject *payload)
-{
- int ret = 0;
const char *buf;
- QString *payload_qstr;
- GError *err = NULL;
+ QString *payload_qstr, *response_qstr;
+ GIOStatus status;
- g_assert(payload && channel);
+ g_assert(payload && s->channel);
payload_qstr = qobject_to_json(payload);
if (!payload_qstr) {
return -EINVAL;
}
- qstring_append_chr(payload_qstr, '\n');
- buf = qstring_get_str(payload_qstr);
- ret = conn_channel_send_buf(channel, buf, strlen(buf));
- if (ret) {
- goto out_free;
+ if (s->delimit_response) {
+ s->delimit_response = false;
+ response_qstr = qstring_new();
+ qstring_append_chr(response_qstr, QGA_SENTINEL_BYTE);
+ qstring_append(response_qstr, qstring_get_str(payload_qstr));
+ QDECREF(payload_qstr);
+ } else {
+ response_qstr = payload_qstr;
}
- g_io_channel_flush(channel, &err);
- if (err != NULL) {
- g_warning("error flushing payload: %s", err->message);
- ret = err->code;
- goto out_free;
+ qstring_append_chr(response_qstr, '\n');
+ buf = qstring_get_str(response_qstr);
+ status = ga_channel_write_all(s->channel, buf, strlen(buf));
+ QDECREF(response_qstr);
+ if (status != G_IO_STATUS_NORMAL) {
+ return -EIO;
}
-out_free:
- QDECREF(payload_qstr);
- if (err) {
- g_error_free(err);
- }
- return ret;
+ return 0;
}
static void process_command(GAState *s, QDict *req)
g_debug("processing command");
rsp = qmp_dispatch(QOBJECT(req));
if (rsp) {
- ret = conn_channel_send_payload(s->conn_channel, rsp);
+ ret = send_response(s, rsp);
if (ret) {
- g_warning("error sending payload: %s", strerror(ret));
+ g_warning("error sending response: %s", strerror(ret));
}
qobject_decref(rsp);
} else {
qdict_put_obj(qdict, "error", error_get_qobject(err));
error_free(err);
}
- ret = conn_channel_send_payload(s->conn_channel, QOBJECT(qdict));
+ ret = send_response(s, QOBJECT(qdict));
if (ret) {
- g_warning("error sending payload: %s", strerror(ret));
+ g_warning("error sending error response: %s", strerror(ret));
}
}
QDECREF(qdict);
}
-static gboolean conn_channel_read(GIOChannel *channel, GIOCondition condition,
- gpointer data)
+/* false return signals GAChannel to close the current client connection */
+static gboolean channel_event_cb(GIOCondition condition, gpointer data)
{
GAState *s = data;
- gchar buf[1024];
+ gchar buf[QGA_READ_COUNT_DEFAULT+1];
gsize count;
GError *err = NULL;
- memset(buf, 0, 1024);
- GIOStatus status = g_io_channel_read_chars(channel, buf, 1024,
- &count, &err);
+ GIOStatus status = ga_channel_read(s->channel, buf, QGA_READ_COUNT_DEFAULT, &count);
if (err != NULL) {
g_warning("error reading channel: %s", err->message);
- conn_channel_close(s);
g_error_free(err);
return false;
}
switch (status) {
case G_IO_STATUS_ERROR:
- g_warning("problem");
+ g_warning("error reading channel");
return false;
case G_IO_STATUS_NORMAL:
+ buf[count] = 0;
g_debug("read data, count: %d, data: %s", (int)count, buf);
json_message_parser_feed(&s->parser, (char *)buf, (int)count);
+ break;
+ case G_IO_STATUS_EOF:
+ g_debug("received EOF");
+ if (!s->virtio) {
+ return false;
+ }
case G_IO_STATUS_AGAIN:
/* virtio causes us to spin here when no process is attached to
* host-side chardev. sleep a bit to mitigate this
usleep(100*1000);
}
return true;
- case G_IO_STATUS_EOF:
- g_debug("received EOF");
- conn_channel_close(s);
- if (s->virtio) {
- return true;
- }
- return false;
default:
g_warning("unknown channel read status, closing");
- conn_channel_close(s);
return false;
}
return true;
}
-static int conn_channel_add(GAState *s, int fd)
+static gboolean channel_init(GAState *s, const gchar *method, const gchar *path)
{
- GIOChannel *conn_channel;
- GError *err = NULL;
+ GAChannelMethod channel_method;
- g_assert(s && !s->conn_channel);
- conn_channel = g_io_channel_unix_new(fd);
- g_assert(conn_channel);
- g_io_channel_set_encoding(conn_channel, NULL, &err);
- if (err != NULL) {
- g_warning("error setting channel encoding to binary");
- g_error_free(err);
- return -1;
+ if (method == NULL) {
+ method = "virtio-serial";
}
- g_io_add_watch(conn_channel, G_IO_IN | G_IO_HUP,
- conn_channel_read, s);
- s->conn_channel = conn_channel;
- return 0;
-}
-static gboolean listen_channel_accept(GIOChannel *channel,
- GIOCondition condition, gpointer data)
-{
- GAState *s = data;
- g_assert(channel != NULL);
- int ret, conn_fd;
- bool accepted = false;
- struct sockaddr_un addr;
- socklen_t addrlen = sizeof(addr);
-
- conn_fd = qemu_accept(g_io_channel_unix_get_fd(s->listen_channel),
- (struct sockaddr *)&addr, &addrlen);
- if (conn_fd == -1) {
- g_warning("error converting fd to gsocket: %s", strerror(errno));
- goto out;
- }
- fcntl(conn_fd, F_SETFL, O_NONBLOCK);
- ret = conn_channel_add(s, conn_fd);
- if (ret) {
- g_warning("error setting up connection");
- goto out;
- }
- accepted = true;
-
-out:
- /* only accept 1 connection at a time */
- return !accepted;
-}
+ if (path == NULL) {
+ if (strcmp(method, "virtio-serial") != 0) {
+ g_critical("must specify a path for this channel");
+ return false;
+ }
+ /* try the default path for the virtio-serial port */
+ path = QGA_VIRTIO_PATH_DEFAULT;
+ }
-/* start polling for readable events on listen fd, new==true
- * indicates we should use the existing s->listen_channel
- */
-static int listen_channel_add(GAState *s, int listen_fd, bool new)
-{
- if (new) {
- s->listen_channel = g_io_channel_unix_new(listen_fd);
+ if (strcmp(method, "virtio-serial") == 0) {
+ s->virtio = true; /* virtio requires special handling in some cases */
+ channel_method = GA_CHANNEL_VIRTIO_SERIAL;
+ } else if (strcmp(method, "isa-serial") == 0) {
+ channel_method = GA_CHANNEL_ISA_SERIAL;
+ } else if (strcmp(method, "unix-listen") == 0) {
+ channel_method = GA_CHANNEL_UNIX_LISTEN;
+ } else {
+ g_critical("unsupported channel method/type: %s", method);
+ return false;
}
- g_io_add_watch(s->listen_channel, G_IO_IN,
- listen_channel_accept, s);
- return 0;
+
+ s->channel = ga_channel_new(channel_method, path, channel_event_cb, s);
+ if (!s->channel) {
+ g_critical("failed to create guest agent channel");
+ return false;
+ }
+
+ return true;
}
-/* cleanup state for closed connection/session, start accepting new
- * connections if we're in listening mode
- */
-static void conn_channel_close(GAState *s)
+#ifdef _WIN32
+DWORD WINAPI service_ctrl_handler(DWORD ctrl, DWORD type, LPVOID data,
+ LPVOID ctx)
{
- if (strcmp(s->method, "unix-listen") == 0) {
- g_io_channel_shutdown(s->conn_channel, true, NULL);
- listen_channel_add(s, 0, false);
- } else if (strcmp(s->method, "virtio-serial") == 0) {
- /* we spin on EOF for virtio-serial, so back off a bit. also,
- * dont close the connection in this case, it'll resume normal
- * operation when another process connects to host chardev
- */
- usleep(100*1000);
- goto out_noclose;
+ DWORD ret = NO_ERROR;
+ GAService *service = &ga_state->service;
+
+ switch (ctrl)
+ {
+ case SERVICE_CONTROL_STOP:
+ case SERVICE_CONTROL_SHUTDOWN:
+ quit_handler(SIGTERM);
+ service->status.dwCurrentState = SERVICE_STOP_PENDING;
+ SetServiceStatus(service->status_handle, &service->status);
+ break;
+
+ default:
+ ret = ERROR_CALL_NOT_IMPLEMENTED;
}
- g_io_channel_unref(s->conn_channel);
- s->conn_channel = NULL;
-out_noclose:
- return;
+ return ret;
}
-static void init_guest_agent(GAState *s)
+VOID WINAPI service_main(DWORD argc, TCHAR *argv[])
{
- struct termios tio;
- int ret, fd;
+ GAService *service = &ga_state->service;
- if (s->method == NULL) {
- /* try virtio-serial as our default */
- s->method = "virtio-serial";
- }
+ service->status_handle = RegisterServiceCtrlHandlerEx(QGA_SERVICE_NAME,
+ service_ctrl_handler, NULL);
- if (s->path == NULL) {
- if (strcmp(s->method, "virtio-serial") != 0) {
- g_critical("must specify a path for this channel");
- exit(EXIT_FAILURE);
- }
- /* try the default path for the virtio-serial port */
- s->path = QGA_VIRTIO_PATH_DEFAULT;
+ if (service->status_handle == 0) {
+ g_critical("Failed to register extended requests function!\n");
+ return;
}
- if (strcmp(s->method, "virtio-serial") == 0) {
- s->virtio = true;
- fd = qemu_open(s->path, O_RDWR | O_NONBLOCK | O_ASYNC);
- if (fd == -1) {
- g_critical("error opening channel: %s", strerror(errno));
- exit(EXIT_FAILURE);
- }
- ret = conn_channel_add(s, fd);
- if (ret) {
- g_critical("error adding channel to main loop");
- exit(EXIT_FAILURE);
- }
- } else if (strcmp(s->method, "isa-serial") == 0) {
- fd = qemu_open(s->path, O_RDWR | O_NOCTTY);
- if (fd == -1) {
- g_critical("error opening channel: %s", strerror(errno));
- exit(EXIT_FAILURE);
- }
- tcgetattr(fd, &tio);
- /* set up serial port for non-canonical, dumb byte streaming */
- tio.c_iflag &= ~(IGNBRK | BRKINT | IGNPAR | PARMRK | INPCK | ISTRIP |
- INLCR | IGNCR | ICRNL | IXON | IXOFF | IXANY |
- IMAXBEL);
- tio.c_oflag = 0;
- tio.c_lflag = 0;
- tio.c_cflag |= QGA_BAUDRATE_DEFAULT;
- /* 1 available byte min or reads will block (we'll set non-blocking
- * elsewhere, else we have to deal with read()=0 instead)
- */
- tio.c_cc[VMIN] = 1;
- tio.c_cc[VTIME] = 0;
- /* flush everything waiting for read/xmit, it's garbage at this point */
- tcflush(fd, TCIFLUSH);
- tcsetattr(fd, TCSANOW, &tio);
- ret = conn_channel_add(s, fd);
- if (ret) {
- g_error("error adding channel to main loop");
- }
- } else if (strcmp(s->method, "unix-listen") == 0) {
- fd = unix_listen(s->path, NULL, strlen(s->path));
- if (fd == -1) {
- g_critical("error opening path: %s", strerror(errno));
- exit(EXIT_FAILURE);
- }
- ret = listen_channel_add(s, fd, true);
- if (ret) {
- g_critical("error binding/listening to specified socket");
- exit(EXIT_FAILURE);
- }
- } else {
- g_critical("unsupported channel method/type: %s", s->method);
- exit(EXIT_FAILURE);
- }
+ service->status.dwServiceType = SERVICE_WIN32;
+ service->status.dwCurrentState = SERVICE_RUNNING;
+ service->status.dwControlsAccepted = SERVICE_ACCEPT_STOP | SERVICE_ACCEPT_SHUTDOWN;
+ service->status.dwWin32ExitCode = NO_ERROR;
+ service->status.dwServiceSpecificExitCode = NO_ERROR;
+ service->status.dwCheckPoint = 0;
+ service->status.dwWaitHint = 0;
+ SetServiceStatus(service->status_handle, &service->status);
- json_message_parser_init(&s->parser, process_event);
- s->main_loop = g_main_loop_new(NULL, false);
+ g_main_loop_run(ga_state->main_loop);
+
+ service->status.dwCurrentState = SERVICE_STOPPED;
+ SetServiceStatus(service->status_handle, &service->status);
}
+#endif
int main(int argc, char **argv)
{
- const char *sopt = "hVvdm:p:l:f:b:";
+ const char *sopt = "hVvdm:p:l:f:b:s:";
const char *method = NULL, *path = NULL, *pidfile = QGA_PIDFILE_DEFAULT;
+ const char *log_file_name = NULL;
+#ifdef _WIN32
+ const char *service = NULL;
+#endif
const struct option lopt[] = {
{ "help", 0, NULL, 'h' },
{ "version", 0, NULL, 'V' },
- { "logfile", 0, NULL, 'l' },
- { "pidfile", 0, NULL, 'f' },
+ { "logfile", 1, NULL, 'l' },
+ { "pidfile", 1, NULL, 'f' },
{ "verbose", 0, NULL, 'v' },
- { "method", 0, NULL, 'm' },
- { "path", 0, NULL, 'p' },
+ { "method", 1, NULL, 'm' },
+ { "path", 1, NULL, 'p' },
{ "daemonize", 0, NULL, 'd' },
- { "blacklist", 0, NULL, 'b' },
+ { "blacklist", 1, NULL, 'b' },
+#ifdef _WIN32
+ { "service", 1, NULL, 's' },
+#endif
{ NULL, 0, NULL, 0 }
};
int opt_ind = 0, ch, daemonize = 0, i, j, len;
path = optarg;
break;
case 'l':
- log_file = fopen(optarg, "a");
+ log_file_name = optarg;
+ log_file = fopen(log_file_name, "a");
if (!log_file) {
g_critical("unable to open specified log file: %s",
strerror(errno));
}
break;
}
+#ifdef _WIN32
+ case 's':
+ service = optarg;
+ if (strcmp(service, "install") == 0) {
+ return ga_install_service(path, log_file_name);
+ } else if (strcmp(service, "uninstall") == 0) {
+ return ga_uninstall_service();
+ } else {
+ printf("Unknown service command.\n");
+ return EXIT_FAILURE;
+ }
+ break;
+#endif
case 'h':
usage(argv[0]);
return 0;
}
}
+#ifndef _WIN32
if (daemonize) {
g_debug("starting daemon");
become_daemon(pidfile);
}
+#endif
s = g_malloc0(sizeof(GAState));
- s->conn_channel = NULL;
- s->path = path;
- s->method = method;
s->log_file = log_file;
s->log_level = log_level;
g_log_set_default_handler(ga_log, s);
s->command_state = ga_command_state_new();
ga_command_state_init(s, s->command_state);
ga_command_state_init_all(s->command_state);
+ json_message_parser_init(&s->parser, process_event);
ga_state = s;
+#ifndef _WIN32
+ if (!register_signal_handlers()) {
+ g_critical("failed to register signal handlers");
+ goto out_bad;
+ }
+#endif
- init_guest_agent(ga_state);
- register_signal_handlers();
-
+ s->main_loop = g_main_loop_new(NULL, false);
+ if (!channel_init(ga_state, method, path)) {
+ g_critical("failed to initialize guest agent channel");
+ goto out_bad;
+ }
+#ifndef _WIN32
g_main_loop_run(ga_state->main_loop);
+#else
+ if (daemonize) {
+ SERVICE_TABLE_ENTRY service_table[] = {
+ { (char *)QGA_SERVICE_NAME, service_main }, { NULL, NULL } };
+ StartServiceCtrlDispatcher(service_table);
+ } else {
+ g_main_loop_run(ga_state->main_loop);
+ }
+#endif
ga_command_state_cleanup_all(ga_state->command_state);
- unlink(pidfile);
+ ga_channel_free(ga_state->channel);
+ if (daemonize) {
+ unlink(pidfile);
+ }
return 0;
+
+out_bad:
+ if (daemonize) {
+ unlink(pidfile);
+ }
+ return EXIT_FAILURE;
}
projects / mirror_qemu.git / blobdiff