blob: 5a5fad31f89eeeed8b03579237c9420423437818 [file] [log] [blame]
Michael Roth42074a92012-01-19 22:19:27 -06001/*
2 * QEMU Guest Agent common/cross-platform command implementations
3 *
4 * Copyright IBM Corp. 2012
5 *
6 * Authors:
7 * Michael Roth <mdroth@linux.vnet.ibm.com>
8 *
9 * This work is licensed under the terms of the GNU GPL, version 2 or later.
10 * See the COPYING file in the top-level directory.
11 */
12
Peter Maydell4459bf32016-01-29 17:49:58 +000013#include "qemu/osdep.h"
Philippe Mathieu-Daudé1329651f2020-04-14 15:30:44 +020014#include "qemu/units.h"
Michael S. Tsirkindc032722018-05-03 22:50:57 +030015#include "guest-agent-core.h"
Markus Armbrustereb815e22018-02-11 10:36:05 +010016#include "qga-qapi-commands.h"
Markus Armbrustere688df62018-02-01 12:18:31 +010017#include "qapi/error.h"
Daniel P. Berrange920639c2015-11-23 15:37:07 +000018#include "qemu/base64.h"
Veronia Bahaaf348b6d2016-03-20 19:16:19 +020019#include "qemu/cutils.h"
Philippe Mathieu-Daudéead83a12020-04-14 15:30:43 +020020#include "commands-common.h"
Michael Roth42074a92012-01-19 22:19:27 -060021
Yuri Pudgorodskiya1853dc2015-10-13 18:41:23 +030022/* Maximum captured guest-exec out_data/err_data - 16MB */
AlexChen0697e9e2020-10-26 17:05:38 +080023#define GUEST_EXEC_MAX_OUTPUT (16 * 1024 * 1024)
Yuri Pudgorodskiya1853dc2015-10-13 18:41:23 +030024/* Allocation and I/O buffer for reading guest-exec out_data/err_data - 4KB */
AlexChen0697e9e2020-10-26 17:05:38 +080025#define GUEST_EXEC_IO_SIZE (4 * 1024)
Philippe Mathieu-Daudé1329651f2020-04-14 15:30:44 +020026/*
27 * Maximum file size to read - 48MB
28 *
29 * (48MB + Base64 3:4 overhead = JSON parser 64 MB limit)
30 */
31#define GUEST_FILE_READ_COUNT_MAX (48 * MiB)
Yuri Pudgorodskiya1853dc2015-10-13 18:41:23 +030032
Michael Roth42074a92012-01-19 22:19:27 -060033/* Note: in some situations, like with the fsfreeze, logging may be
Markus Armbrusterc4023352023-02-07 08:51:11 +010034 * temporarily disabled. if it is necessary that a command be able
35 * to log for accounting purposes, check ga_logging_enabled() beforehand.
Michael Roth42074a92012-01-19 22:19:27 -060036 */
37void slog(const gchar *fmt, ...)
38{
39 va_list ap;
40
41 va_start(ap, fmt);
42 g_logv("syslog", G_LOG_LEVEL_INFO, fmt, ap);
43 va_end(ap);
44}
45
Michael Roth3cf0bed2012-02-07 13:56:48 -060046int64_t qmp_guest_sync_delimited(int64_t id, Error **errp)
47{
48 ga_set_response_delimited(ga_state);
49 return id;
50}
51
Michael Roth42074a92012-01-19 22:19:27 -060052int64_t qmp_guest_sync(int64_t id, Error **errp)
53{
54 return id;
55}
56
Markus Armbruster77dbc812014-05-02 13:26:30 +020057void qmp_guest_ping(Error **errp)
Michael Roth42074a92012-01-19 22:19:27 -060058{
59 slog("guest-ping called");
60}
61
Marc-André Lureauf0ccc002020-03-16 18:18:24 +010062static void qmp_command_info(const QmpCommand *cmd, void *opaque)
Mark Wu8dc4d912013-10-09 11:25:07 +080063{
64 GuestAgentInfo *info = opaque;
65 GuestAgentCommandInfo *cmd_info;
Mark Wu8dc4d912013-10-09 11:25:07 +080066
Markus Armbrusterf3a06402015-09-14 13:50:44 +020067 cmd_info = g_new0(GuestAgentCommandInfo, 1);
Mark Wu8dc4d912013-10-09 11:25:07 +080068 cmd_info->name = g_strdup(qmp_command_name(cmd));
69 cmd_info->enabled = qmp_command_is_enabled(cmd);
Mark Wu0106dc42013-10-09 10:37:26 +080070 cmd_info->success_response = qmp_has_success_response(cmd);
Mark Wu8dc4d912013-10-09 11:25:07 +080071
Eric Blake54aa3de2020-11-12 19:13:37 -060072 QAPI_LIST_PREPEND(info->supported_commands, cmd_info);
Mark Wu8dc4d912013-10-09 11:25:07 +080073}
74
Markus Armbruster77dbc812014-05-02 13:26:30 +020075struct GuestAgentInfo *qmp_guest_info(Error **errp)
Michael Roth42074a92012-01-19 22:19:27 -060076{
Markus Armbrusterf3a06402015-09-14 13:50:44 +020077 GuestAgentInfo *info = g_new0(GuestAgentInfo, 1);
Michael Roth42074a92012-01-19 22:19:27 -060078
Michael Roth8efacc42012-05-14 09:33:48 -050079 info->version = g_strdup(QEMU_VERSION);
Markus Armbruster1527bad2017-03-03 13:32:25 +010080 qmp_for_each_command(&ga_commands, qmp_command_info, info);
Michael Roth42074a92012-01-19 22:19:27 -060081 return info;
82}
Yuri Pudgorodskiyd697e302015-10-13 18:41:20 +030083
Yuri Pudgorodskiya1853dc2015-10-13 18:41:23 +030084struct GuestExecIOData {
85 guchar *data;
86 gsize size;
87 gsize length;
Alex Bennéea31393e2016-09-30 22:31:02 +010088 bool closed;
Yuri Pudgorodskiya1853dc2015-10-13 18:41:23 +030089 bool truncated;
90 const char *name;
91};
92typedef struct GuestExecIOData GuestExecIOData;
93
Yuri Pudgorodskiyd697e302015-10-13 18:41:20 +030094struct GuestExecInfo {
95 GPid pid;
96 int64_t pid_numeric;
97 gint status;
Yuri Pudgorodskiya1853dc2015-10-13 18:41:23 +030098 bool has_output;
Alex Bennéea31393e2016-09-30 22:31:02 +010099 bool finished;
Yuri Pudgorodskiya1853dc2015-10-13 18:41:23 +0300100 GuestExecIOData in;
101 GuestExecIOData out;
102 GuestExecIOData err;
Yuri Pudgorodskiyd697e302015-10-13 18:41:20 +0300103 QTAILQ_ENTRY(GuestExecInfo) next;
104};
105typedef struct GuestExecInfo GuestExecInfo;
106
107static struct {
108 QTAILQ_HEAD(, GuestExecInfo) processes;
109} guest_exec_state = {
110 .processes = QTAILQ_HEAD_INITIALIZER(guest_exec_state.processes),
111};
112
113static int64_t gpid_to_int64(GPid pid)
114{
115#ifdef G_OS_WIN32
116 return GetProcessId(pid);
117#else
118 return (int64_t)pid;
119#endif
120}
121
122static GuestExecInfo *guest_exec_info_add(GPid pid)
123{
124 GuestExecInfo *gei;
125
126 gei = g_new0(GuestExecInfo, 1);
127 gei->pid = pid;
128 gei->pid_numeric = gpid_to_int64(pid);
129 QTAILQ_INSERT_TAIL(&guest_exec_state.processes, gei, next);
130
131 return gei;
132}
133
134static GuestExecInfo *guest_exec_info_find(int64_t pid_numeric)
135{
136 GuestExecInfo *gei;
137
138 QTAILQ_FOREACH(gei, &guest_exec_state.processes, next) {
139 if (gei->pid_numeric == pid_numeric) {
140 return gei;
141 }
142 }
143
144 return NULL;
145}
146
Vladimir Sementsov-Ogievskiyb90abba2019-12-05 20:46:26 +0300147GuestExecStatus *qmp_guest_exec_status(int64_t pid, Error **errp)
Yuri Pudgorodskiyd697e302015-10-13 18:41:20 +0300148{
149 GuestExecInfo *gei;
150 GuestExecStatus *ges;
151
152 slog("guest-exec-status called, pid: %u", (uint32_t)pid);
153
154 gei = guest_exec_info_find(pid);
155 if (gei == NULL) {
Markus Armbrusterb6651652023-10-31 12:10:55 +0100156 error_setg(errp, "PID " PRId64 " does not exist");
Yuri Pudgorodskiyd697e302015-10-13 18:41:20 +0300157 return NULL;
158 }
159
160 ges = g_new0(GuestExecStatus, 1);
Yuri Pudgorodskiyd697e302015-10-13 18:41:20 +0300161
Marc-André Lureauc267d752022-04-20 17:26:22 +0400162 bool finished = gei->finished;
Yuri Pudgorodskiya1853dc2015-10-13 18:41:23 +0300163
164 /* need to wait till output channels are closed
165 * to be sure we captured all output at this point */
166 if (gei->has_output) {
Marc-André Lureauc267d752022-04-20 17:26:22 +0400167 finished &= gei->out.closed && gei->err.closed;
Yuri Pudgorodskiya1853dc2015-10-13 18:41:23 +0300168 }
169
170 ges->exited = finished;
171 if (finished) {
Yuri Pudgorodskiyd697e302015-10-13 18:41:20 +0300172 /* Glib has no portable way to parse exit status.
173 * On UNIX, we can get either exit code from normal termination
174 * or signal number.
175 * On Windows, it is either the same exit code or the exception
176 * value for an unhandled exception that caused the process
177 * to terminate.
178 * See MSDN for GetExitCodeProcess() and ntstatus.h for possible
179 * well-known codes, e.g. C0000005 ACCESS_DENIED - analog of SIGSEGV
180 * References:
181 * https://msdn.microsoft.com/en-us/library/windows/desktop/ms683189(v=vs.85).aspx
182 * https://msdn.microsoft.com/en-us/library/aa260331(v=vs.60).aspx
183 */
184#ifdef G_OS_WIN32
185 /* Additionally WIN32 does not provide any additional information
Stefan Weilcb8d4c82016-03-23 15:59:57 +0100186 * on whether the child exited or terminated via signal.
187 * We use this simple range check to distinguish application exit code
Yuri Pudgorodskiyd697e302015-10-13 18:41:20 +0300188 * (usually value less then 256) and unhandled exception code with
189 * ntstatus (always value greater then 0xC0000005). */
190 if ((uint32_t)gei->status < 0xC0000000U) {
191 ges->has_exitcode = true;
192 ges->exitcode = gei->status;
193 } else {
194 ges->has_signal = true;
195 ges->signal = gei->status;
196 }
197#else
198 if (WIFEXITED(gei->status)) {
199 ges->has_exitcode = true;
200 ges->exitcode = WEXITSTATUS(gei->status);
201 } else if (WIFSIGNALED(gei->status)) {
202 ges->has_signal = true;
203 ges->signal = WTERMSIG(gei->status);
204 }
205#endif
Yuri Pudgorodskiya1853dc2015-10-13 18:41:23 +0300206 if (gei->out.length > 0) {
Yuri Pudgorodskiya1853dc2015-10-13 18:41:23 +0300207 ges->out_data = g_base64_encode(gei->out.data, gei->out.length);
Yuri Pudgorodskiya1853dc2015-10-13 18:41:23 +0300208 ges->has_out_truncated = gei->out.truncated;
209 }
Daniel Xud6f67b82023-10-01 12:38:25 -0600210 g_free(gei->out.data);
Yuri Pudgorodskiya1853dc2015-10-13 18:41:23 +0300211
212 if (gei->err.length > 0) {
Yuri Pudgorodskiya1853dc2015-10-13 18:41:23 +0300213 ges->err_data = g_base64_encode(gei->err.data, gei->err.length);
Yuri Pudgorodskiya1853dc2015-10-13 18:41:23 +0300214 ges->has_err_truncated = gei->err.truncated;
215 }
Daniel Xud6f67b82023-10-01 12:38:25 -0600216 g_free(gei->err.data);
Yuri Pudgorodskiya1853dc2015-10-13 18:41:23 +0300217
Yuri Pudgorodskiyd697e302015-10-13 18:41:20 +0300218 QTAILQ_REMOVE(&guest_exec_state.processes, gei, next);
219 g_free(gei);
220 }
221
222 return ges;
223}
224
225/* Get environment variables or arguments array for execve(). */
226static char **guest_exec_get_args(const strList *entry, bool log)
227{
228 const strList *it;
229 int count = 1, i = 0; /* reserve for NULL terminator */
230 char **args;
231 char *str; /* for logging array of arguments */
232 size_t str_size = 1;
233
234 for (it = entry; it != NULL; it = it->next) {
235 count++;
236 str_size += 1 + strlen(it->value);
237 }
238
239 str = g_malloc(str_size);
240 *str = 0;
Markus Armbrusterb21e2382022-03-15 15:41:56 +0100241 args = g_new(char *, count);
Yuri Pudgorodskiyd697e302015-10-13 18:41:20 +0300242 for (it = entry; it != NULL; it = it->next) {
243 args[i++] = it->value;
244 pstrcat(str, str_size, it->value);
245 if (it->next) {
246 pstrcat(str, str_size, " ");
247 }
248 }
249 args[i] = NULL;
250
251 if (log) {
252 slog("guest-exec called: \"%s\"", str);
253 }
254 g_free(str);
255
256 return args;
257}
258
259static void guest_exec_child_watch(GPid pid, gint status, gpointer data)
260{
261 GuestExecInfo *gei = (GuestExecInfo *)data;
262
263 g_debug("guest_exec_child_watch called, pid: %d, status: %u",
264 (int32_t)gpid_to_int64(pid), (uint32_t)status);
265
266 gei->status = status;
Marc-André Lureauc267d752022-04-20 17:26:22 +0400267 gei->finished = true;
Yuri Pudgorodskiyd697e302015-10-13 18:41:20 +0300268
269 g_spawn_close_pid(pid);
270}
271
Denis V. Lunev4005b472015-10-13 18:41:21 +0300272static void guest_exec_task_setup(gpointer data)
273{
274#if !defined(G_OS_WIN32)
Daniel Xu810f6772023-03-22 18:19:27 -0600275 bool has_merge = *(bool *)data;
Denis V. Lunev4005b472015-10-13 18:41:21 +0300276 struct sigaction sigact;
277
Daniel Xu810f6772023-03-22 18:19:27 -0600278 if (has_merge) {
279 /*
280 * FIXME: When `GLIB_VERSION_MIN_REQUIRED` is bumped to 2.58+, use
281 * g_spawn_async_with_fds() to be portable on windows. The current
282 * logic does not work on windows b/c `GSpawnChildSetupFunc` is run
283 * inside the parent, not the child.
284 */
285 if (dup2(STDOUT_FILENO, STDERR_FILENO) != 0) {
286 slog("dup2() failed to merge stderr into stdout: %s",
287 strerror(errno));
288 }
289 }
290
291 /* Reset ignored signals back to default. */
Denis V. Lunev4005b472015-10-13 18:41:21 +0300292 memset(&sigact, 0, sizeof(struct sigaction));
293 sigact.sa_handler = SIG_DFL;
294
295 if (sigaction(SIGPIPE, &sigact, NULL) != 0) {
296 slog("sigaction() failed to reset child process's SIGPIPE: %s",
297 strerror(errno));
298 }
299#endif
300}
301
Yuri Pudgorodskiya1853dc2015-10-13 18:41:23 +0300302static gboolean guest_exec_input_watch(GIOChannel *ch,
303 GIOCondition cond, gpointer p_)
304{
305 GuestExecIOData *p = (GuestExecIOData *)p_;
306 gsize bytes_written = 0;
307 GIOStatus status;
308 GError *gerr = NULL;
309
310 /* nothing left to write */
311 if (p->size == p->length) {
312 goto done;
313 }
314
315 status = g_io_channel_write_chars(ch, (gchar *)p->data + p->length,
316 p->size - p->length, &bytes_written, &gerr);
317
318 /* can be not 0 even if not G_IO_STATUS_NORMAL */
319 if (bytes_written != 0) {
320 p->length += bytes_written;
321 }
322
323 /* continue write, our callback will be called again */
324 if (status == G_IO_STATUS_NORMAL || status == G_IO_STATUS_AGAIN) {
325 return true;
326 }
327
328 if (gerr) {
329 g_warning("qga: i/o error writing to input_data channel: %s",
330 gerr->message);
331 g_error_free(gerr);
332 }
333
334done:
335 g_io_channel_shutdown(ch, true, NULL);
336 g_io_channel_unref(ch);
Marc-André Lureauc267d752022-04-20 17:26:22 +0400337 p->closed = true;
Yuri Pudgorodskiya1853dc2015-10-13 18:41:23 +0300338 g_free(p->data);
339
340 return false;
341}
342
343static gboolean guest_exec_output_watch(GIOChannel *ch,
344 GIOCondition cond, gpointer p_)
345{
346 GuestExecIOData *p = (GuestExecIOData *)p_;
347 gsize bytes_read;
348 GIOStatus gstatus;
349
350 if (cond == G_IO_HUP || cond == G_IO_ERR) {
351 goto close;
352 }
353
354 if (p->size == p->length) {
355 gpointer t = NULL;
356 if (!p->truncated && p->size < GUEST_EXEC_MAX_OUTPUT) {
357 t = g_try_realloc(p->data, p->size + GUEST_EXEC_IO_SIZE);
358 }
359 if (t == NULL) {
360 /* ignore truncated output */
361 gchar buf[GUEST_EXEC_IO_SIZE];
362
363 p->truncated = true;
364 gstatus = g_io_channel_read_chars(ch, buf, sizeof(buf),
365 &bytes_read, NULL);
366 if (gstatus == G_IO_STATUS_EOF || gstatus == G_IO_STATUS_ERROR) {
367 goto close;
368 }
369
370 return true;
371 }
372 p->size += GUEST_EXEC_IO_SIZE;
373 p->data = t;
374 }
375
376 /* Calling read API once.
377 * On next available data our callback will be called again */
378 gstatus = g_io_channel_read_chars(ch, (gchar *)p->data + p->length,
379 p->size - p->length, &bytes_read, NULL);
380 if (gstatus == G_IO_STATUS_EOF || gstatus == G_IO_STATUS_ERROR) {
381 goto close;
382 }
383
384 p->length += bytes_read;
385
386 return true;
387
388close:
Yuriy Pudgorodskiy3005c2c2016-04-06 08:43:30 +0300389 g_io_channel_shutdown(ch, true, NULL);
Yuri Pudgorodskiya1853dc2015-10-13 18:41:23 +0300390 g_io_channel_unref(ch);
Marc-André Lureauc267d752022-04-20 17:26:22 +0400391 p->closed = true;
Yuri Pudgorodskiya1853dc2015-10-13 18:41:23 +0300392 return false;
393}
394
Daniel Xu9c5ccc52023-03-22 18:19:26 -0600395static GuestExecCaptureOutputMode ga_parse_capture_output(
396 GuestExecCaptureOutput *capture_output)
397{
398 if (!capture_output)
399 return GUEST_EXEC_CAPTURE_OUTPUT_MODE_NONE;
400 else if (capture_output->type == QTYPE_QBOOL)
401 return capture_output->u.flag ? GUEST_EXEC_CAPTURE_OUTPUT_MODE_SEPARATED
402 : GUEST_EXEC_CAPTURE_OUTPUT_MODE_NONE;
403 else
404 return capture_output->u.mode;
405}
406
Yuri Pudgorodskiyd697e302015-10-13 18:41:20 +0300407GuestExec *qmp_guest_exec(const char *path,
408 bool has_arg, strList *arg,
409 bool has_env, strList *env,
Markus Armbruster91eab322022-11-04 17:07:11 +0100410 const char *input_data,
Daniel Xu9c5ccc52023-03-22 18:19:26 -0600411 GuestExecCaptureOutput *capture_output,
Vladimir Sementsov-Ogievskiyb90abba2019-12-05 20:46:26 +0300412 Error **errp)
Yuri Pudgorodskiyd697e302015-10-13 18:41:20 +0300413{
414 GPid pid;
415 GuestExec *ge = NULL;
416 GuestExecInfo *gei;
417 char **argv, **envp;
418 strList arglist;
419 gboolean ret;
420 GError *gerr = NULL;
Yuri Pudgorodskiya1853dc2015-10-13 18:41:23 +0300421 gint in_fd, out_fd, err_fd;
422 GIOChannel *in_ch, *out_ch, *err_ch;
423 GSpawnFlags flags;
Daniel Xu9c5ccc52023-03-22 18:19:26 -0600424 bool has_output = false;
Daniel Xu810f6772023-03-22 18:19:27 -0600425 bool has_merge = false;
Daniel Xu9c5ccc52023-03-22 18:19:26 -0600426 GuestExecCaptureOutputMode output_mode;
Daniel P. Berrangé057489d2021-08-09 14:10:29 +0100427 g_autofree uint8_t *input = NULL;
Daniel P. Berrange920639c2015-11-23 15:37:07 +0000428 size_t ninput = 0;
Yuri Pudgorodskiyd697e302015-10-13 18:41:20 +0300429
430 arglist.value = (char *)path;
431 arglist.next = has_arg ? arg : NULL;
432
Markus Armbruster91eab322022-11-04 17:07:11 +0100433 if (input_data) {
Vladimir Sementsov-Ogievskiyb90abba2019-12-05 20:46:26 +0300434 input = qbase64_decode(input_data, -1, &ninput, errp);
Daniel P. Berrange920639c2015-11-23 15:37:07 +0000435 if (!input) {
436 return NULL;
437 }
438 }
439
Yuri Pudgorodskiyd697e302015-10-13 18:41:20 +0300440 argv = guest_exec_get_args(&arglist, true);
Yuri Pudgorodskiy02a4d822015-11-12 16:36:20 +0300441 envp = has_env ? guest_exec_get_args(env, false) : NULL;
Yuri Pudgorodskiyd697e302015-10-13 18:41:20 +0300442
Daniel P. Berrangée7b3af82018-05-04 15:34:46 +0100443 flags = G_SPAWN_SEARCH_PATH | G_SPAWN_DO_NOT_REAP_CHILD |
444 G_SPAWN_SEARCH_PATH_FROM_ENVP;
Daniel Xu9c5ccc52023-03-22 18:19:26 -0600445
446 output_mode = ga_parse_capture_output(capture_output);
447 switch (output_mode) {
448 case GUEST_EXEC_CAPTURE_OUTPUT_MODE_NONE:
Yuri Pudgorodskiya1853dc2015-10-13 18:41:23 +0300449 flags |= G_SPAWN_STDOUT_TO_DEV_NULL | G_SPAWN_STDERR_TO_DEV_NULL;
Daniel Xu9c5ccc52023-03-22 18:19:26 -0600450 break;
451 case GUEST_EXEC_CAPTURE_OUTPUT_MODE_STDOUT:
452 has_output = true;
453 flags |= G_SPAWN_STDERR_TO_DEV_NULL;
454 break;
455 case GUEST_EXEC_CAPTURE_OUTPUT_MODE_STDERR:
456 has_output = true;
457 flags |= G_SPAWN_STDOUT_TO_DEV_NULL;
458 break;
459 case GUEST_EXEC_CAPTURE_OUTPUT_MODE_SEPARATED:
460 has_output = true;
461 break;
Daniel Xu810f6772023-03-22 18:19:27 -0600462#if !defined(G_OS_WIN32)
463 case GUEST_EXEC_CAPTURE_OUTPUT_MODE_MERGED:
464 has_output = true;
465 has_merge = true;
466 break;
467#endif
Daniel Xu9c5ccc52023-03-22 18:19:26 -0600468 case GUEST_EXEC_CAPTURE_OUTPUT_MODE__MAX:
469 /* Silence warning; impossible branch */
470 break;
Yuri Pudgorodskiya1853dc2015-10-13 18:41:23 +0300471 }
472
473 ret = g_spawn_async_with_pipes(NULL, argv, envp, flags,
Daniel Xu810f6772023-03-22 18:19:27 -0600474 guest_exec_task_setup, &has_merge, &pid, input_data ? &in_fd : NULL,
Yuri Pudgorodskiya1853dc2015-10-13 18:41:23 +0300475 has_output ? &out_fd : NULL, has_output ? &err_fd : NULL, &gerr);
Yuri Pudgorodskiyd697e302015-10-13 18:41:20 +0300476 if (!ret) {
Markus Armbrustercec07c72024-05-14 12:58:27 +0200477 error_setg(errp, "%s", gerr->message);
Yuri Pudgorodskiyd697e302015-10-13 18:41:20 +0300478 g_error_free(gerr);
479 goto done;
480 }
481
482 ge = g_new0(GuestExec, 1);
483 ge->pid = gpid_to_int64(pid);
484
485 gei = guest_exec_info_add(pid);
Yuri Pudgorodskiya1853dc2015-10-13 18:41:23 +0300486 gei->has_output = has_output;
Yuri Pudgorodskiyd697e302015-10-13 18:41:20 +0300487 g_child_watch_add(pid, guest_exec_child_watch, gei);
488
Markus Armbruster91eab322022-11-04 17:07:11 +0100489 if (input_data) {
Daniel P. Berrangé057489d2021-08-09 14:10:29 +0100490 gei->in.data = g_steal_pointer(&input);
Daniel P. Berrange920639c2015-11-23 15:37:07 +0000491 gei->in.size = ninput;
Yuri Pudgorodskiya1853dc2015-10-13 18:41:23 +0300492#ifdef G_OS_WIN32
493 in_ch = g_io_channel_win32_new_fd(in_fd);
494#else
495 in_ch = g_io_channel_unix_new(in_fd);
496#endif
497 g_io_channel_set_encoding(in_ch, NULL, NULL);
498 g_io_channel_set_buffered(in_ch, false);
499 g_io_channel_set_flags(in_ch, G_IO_FLAG_NONBLOCK, NULL);
Yuriy Pudgorodskiy3005c2c2016-04-06 08:43:30 +0300500 g_io_channel_set_close_on_unref(in_ch, true);
Yuri Pudgorodskiya1853dc2015-10-13 18:41:23 +0300501 g_io_add_watch(in_ch, G_IO_OUT, guest_exec_input_watch, &gei->in);
502 }
503
504 if (has_output) {
505#ifdef G_OS_WIN32
506 out_ch = g_io_channel_win32_new_fd(out_fd);
507 err_ch = g_io_channel_win32_new_fd(err_fd);
508#else
509 out_ch = g_io_channel_unix_new(out_fd);
510 err_ch = g_io_channel_unix_new(err_fd);
511#endif
512 g_io_channel_set_encoding(out_ch, NULL, NULL);
513 g_io_channel_set_encoding(err_ch, NULL, NULL);
514 g_io_channel_set_buffered(out_ch, false);
515 g_io_channel_set_buffered(err_ch, false);
Yuriy Pudgorodskiy3005c2c2016-04-06 08:43:30 +0300516 g_io_channel_set_close_on_unref(out_ch, true);
517 g_io_channel_set_close_on_unref(err_ch, true);
Yuri Pudgorodskiya1853dc2015-10-13 18:41:23 +0300518 g_io_add_watch(out_ch, G_IO_IN | G_IO_HUP,
519 guest_exec_output_watch, &gei->out);
520 g_io_add_watch(err_ch, G_IO_IN | G_IO_HUP,
521 guest_exec_output_watch, &gei->err);
522 }
523
Yuri Pudgorodskiyd697e302015-10-13 18:41:20 +0300524done:
525 g_free(argv);
526 g_free(envp);
527
528 return ge;
529}
Eric Blake0b4b4932016-02-09 14:27:16 -0700530
531/* Convert GuestFileWhence (either a raw integer or an enum value) into
532 * the guest's SEEK_ constants. */
533int ga_parse_whence(GuestFileWhence *whence, Error **errp)
534{
Eric Blakea23f38a2020-03-20 10:05:07 -0500535 /*
536 * Exploit the fact that we picked values to match QGA_SEEK_*;
537 * however, we have to use a temporary variable since the union
538 * members may have different size.
539 */
Eric Blake0b4b4932016-02-09 14:27:16 -0700540 if (whence->type == QTYPE_QSTRING) {
Eric Blakea23f38a2020-03-20 10:05:07 -0500541 int value = whence->u.name;
Marc-André Lureau01b2ffc2017-06-07 20:35:58 +0400542 whence->type = QTYPE_QNUM;
Eric Blakea23f38a2020-03-20 10:05:07 -0500543 whence->u.value = value;
Eric Blake0b4b4932016-02-09 14:27:16 -0700544 }
545 switch (whence->u.value) {
546 case QGA_SEEK_SET:
547 return SEEK_SET;
548 case QGA_SEEK_CUR:
549 return SEEK_CUR;
550 case QGA_SEEK_END:
551 return SEEK_END;
552 }
553 error_setg(errp, "invalid whence code %"PRId64, whence->u.value);
554 return -1;
555}
Vinzenz Feenstra0a3d1972017-04-04 08:46:31 +0200556
Vladimir Sementsov-Ogievskiyb90abba2019-12-05 20:46:26 +0300557GuestHostName *qmp_guest_get_host_name(Error **errp)
Vinzenz Feenstra0a3d1972017-04-04 08:46:31 +0200558{
559 GuestHostName *result = NULL;
Marc-André Lureau548fb0d2022-04-20 17:26:14 +0400560 g_autofree char *hostname = qga_get_host_name(errp);
Michal Privoznik0d3a8f32020-06-22 20:19:36 +0200561
562 /*
563 * We want to avoid using g_get_host_name() because that
564 * caches the result and we wouldn't reflect changes in the
565 * host name.
566 */
567
568 if (!hostname) {
569 hostname = g_strdup("localhost");
Vinzenz Feenstra0a3d1972017-04-04 08:46:31 +0200570 }
Michal Privoznik0d3a8f32020-06-22 20:19:36 +0200571
572 result = g_new0(GuestHostName, 1);
573 result->host_name = g_steal_pointer(&hostname);
Vinzenz Feenstra0a3d1972017-04-04 08:46:31 +0200574 return result;
575}
Vinzenz Feenstra53c58e62017-04-19 12:52:58 +0200576
577GuestTimezone *qmp_guest_get_timezone(Error **errp)
578{
Vinzenz Feenstra53c58e62017-04-19 12:52:58 +0200579 GuestTimezone *info = NULL;
580 GTimeZone *tz = NULL;
581 gint64 now = 0;
582 gint32 intv = 0;
583 gchar const *name = NULL;
584
585 info = g_new0(GuestTimezone, 1);
586 tz = g_time_zone_new_local();
587 if (tz == NULL) {
Markus Armbrustercec07c72024-05-14 12:58:27 +0200588 error_setg(errp, "Couldn't retrieve local timezone");
Vinzenz Feenstra53c58e62017-04-19 12:52:58 +0200589 goto error;
590 }
591
592 now = g_get_real_time() / G_USEC_PER_SEC;
593 intv = g_time_zone_find_interval(tz, G_TIME_TYPE_UNIVERSAL, now);
594 info->offset = g_time_zone_get_offset(tz, intv);
595 name = g_time_zone_get_abbreviation(tz, intv);
596 if (name != NULL) {
Vinzenz Feenstra53c58e62017-04-19 12:52:58 +0200597 info->zone = g_strdup(name);
598 }
599 g_time_zone_unref(tz);
600
601 return info;
602
603error:
604 g_free(info);
605 return NULL;
Vinzenz Feenstra53c58e62017-04-19 12:52:58 +0200606}
Philippe Mathieu-Daudéead83a12020-04-14 15:30:43 +0200607
608GuestFileRead *qmp_guest_file_read(int64_t handle, bool has_count,
609 int64_t count, Error **errp)
610{
611 GuestFileHandle *gfh = guest_file_handle_find(handle, errp);
612 GuestFileRead *read_data;
613
614 if (!gfh) {
615 return NULL;
616 }
617 if (!has_count) {
618 count = QGA_READ_COUNT_DEFAULT;
Philippe Mathieu-Daudé1329651f2020-04-14 15:30:44 +0200619 } else if (count < 0 || count > GUEST_FILE_READ_COUNT_MAX) {
Philippe Mathieu-Daudéead83a12020-04-14 15:30:43 +0200620 error_setg(errp, "value '%" PRId64 "' is invalid for argument count",
621 count);
622 return NULL;
623 }
624
625 read_data = guest_file_read_unsafe(gfh, count, errp);
626 if (!read_data) {
627 slog("guest-file-write failed, handle: %" PRId64, handle);
628 }
629
630 return read_data;
631}
Marc-André Lureau287698e2022-03-07 11:03:59 +0400632
633int64_t qmp_guest_get_time(Error **errp)
634{
635 return g_get_real_time() * 1000;
636}