]>
Commit | Line | Data |
---|---|---|
42074a9d MR |
1 | /* |
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 | ||
4459bf38 | 13 | #include "qemu/osdep.h" |
1329651f | 14 | #include "qemu/units.h" |
dc03272d | 15 | #include "guest-agent-core.h" |
eb815e24 | 16 | #include "qga-qapi-commands.h" |
e688df6b | 17 | #include "qapi/error.h" |
7b1b5d19 | 18 | #include "qapi/qmp/qerror.h" |
920639ca | 19 | #include "qemu/base64.h" |
f348b6d1 | 20 | #include "qemu/cutils.h" |
ead83a13 | 21 | #include "commands-common.h" |
42074a9d | 22 | |
a1853dca | 23 | /* Maximum captured guest-exec out_data/err_data - 16MB */ |
0697e9ed | 24 | #define GUEST_EXEC_MAX_OUTPUT (16 * 1024 * 1024) |
a1853dca | 25 | /* Allocation and I/O buffer for reading guest-exec out_data/err_data - 4KB */ |
0697e9ed | 26 | #define GUEST_EXEC_IO_SIZE (4 * 1024) |
1329651f PMD |
27 | /* |
28 | * Maximum file size to read - 48MB | |
29 | * | |
30 | * (48MB + Base64 3:4 overhead = JSON parser 64 MB limit) | |
31 | */ | |
32 | #define GUEST_FILE_READ_COUNT_MAX (48 * MiB) | |
a1853dca | 33 | |
42074a9d | 34 | /* Note: in some situations, like with the fsfreeze, logging may be |
c4023359 MA |
35 | * temporarily disabled. if it is necessary that a command be able |
36 | * to log for accounting purposes, check ga_logging_enabled() beforehand. | |
42074a9d MR |
37 | */ |
38 | void slog(const gchar *fmt, ...) | |
39 | { | |
40 | va_list ap; | |
41 | ||
42 | va_start(ap, fmt); | |
43 | g_logv("syslog", G_LOG_LEVEL_INFO, fmt, ap); | |
44 | va_end(ap); | |
45 | } | |
46 | ||
3cf0bed8 MR |
47 | int64_t qmp_guest_sync_delimited(int64_t id, Error **errp) |
48 | { | |
49 | ga_set_response_delimited(ga_state); | |
50 | return id; | |
51 | } | |
52 | ||
42074a9d MR |
53 | int64_t qmp_guest_sync(int64_t id, Error **errp) |
54 | { | |
55 | return id; | |
56 | } | |
57 | ||
77dbc81b | 58 | void qmp_guest_ping(Error **errp) |
42074a9d MR |
59 | { |
60 | slog("guest-ping called"); | |
61 | } | |
62 | ||
f0ccc00b | 63 | static void qmp_command_info(const QmpCommand *cmd, void *opaque) |
42074a9d | 64 | { |
8dc4d915 | 65 | GuestAgentInfo *info = opaque; |
42074a9d | 66 | GuestAgentCommandInfo *cmd_info; |
42074a9d | 67 | |
f3a06403 | 68 | cmd_info = g_new0(GuestAgentCommandInfo, 1); |
8dc4d915 MW |
69 | cmd_info->name = g_strdup(qmp_command_name(cmd)); |
70 | cmd_info->enabled = qmp_command_is_enabled(cmd); | |
0106dc4f | 71 | cmd_info->success_response = qmp_has_success_response(cmd); |
42074a9d | 72 | |
54aa3de7 | 73 | QAPI_LIST_PREPEND(info->supported_commands, cmd_info); |
8dc4d915 | 74 | } |
42074a9d | 75 | |
77dbc81b | 76 | struct GuestAgentInfo *qmp_guest_info(Error **errp) |
8dc4d915 | 77 | { |
f3a06403 | 78 | GuestAgentInfo *info = g_new0(GuestAgentInfo, 1); |
42074a9d | 79 | |
8dc4d915 | 80 | info->version = g_strdup(QEMU_VERSION); |
1527badb | 81 | qmp_for_each_command(&ga_commands, qmp_command_info, info); |
42074a9d MR |
82 | return info; |
83 | } | |
d697e30c | 84 | |
a1853dca YP |
85 | struct GuestExecIOData { |
86 | guchar *data; | |
87 | gsize size; | |
88 | gsize length; | |
a31393e7 | 89 | bool closed; |
a1853dca YP |
90 | bool truncated; |
91 | const char *name; | |
92 | }; | |
93 | typedef struct GuestExecIOData GuestExecIOData; | |
94 | ||
d697e30c YP |
95 | struct GuestExecInfo { |
96 | GPid pid; | |
97 | int64_t pid_numeric; | |
98 | gint status; | |
a1853dca | 99 | bool has_output; |
a31393e7 | 100 | bool finished; |
a1853dca YP |
101 | GuestExecIOData in; |
102 | GuestExecIOData out; | |
103 | GuestExecIOData err; | |
d697e30c YP |
104 | QTAILQ_ENTRY(GuestExecInfo) next; |
105 | }; | |
106 | typedef struct GuestExecInfo GuestExecInfo; | |
107 | ||
108 | static struct { | |
109 | QTAILQ_HEAD(, GuestExecInfo) processes; | |
110 | } guest_exec_state = { | |
111 | .processes = QTAILQ_HEAD_INITIALIZER(guest_exec_state.processes), | |
112 | }; | |
113 | ||
114 | static int64_t gpid_to_int64(GPid pid) | |
115 | { | |
116 | #ifdef G_OS_WIN32 | |
117 | return GetProcessId(pid); | |
118 | #else | |
119 | return (int64_t)pid; | |
120 | #endif | |
121 | } | |
122 | ||
123 | static GuestExecInfo *guest_exec_info_add(GPid pid) | |
124 | { | |
125 | GuestExecInfo *gei; | |
126 | ||
127 | gei = g_new0(GuestExecInfo, 1); | |
128 | gei->pid = pid; | |
129 | gei->pid_numeric = gpid_to_int64(pid); | |
130 | QTAILQ_INSERT_TAIL(&guest_exec_state.processes, gei, next); | |
131 | ||
132 | return gei; | |
133 | } | |
134 | ||
135 | static GuestExecInfo *guest_exec_info_find(int64_t pid_numeric) | |
136 | { | |
137 | GuestExecInfo *gei; | |
138 | ||
139 | QTAILQ_FOREACH(gei, &guest_exec_state.processes, next) { | |
140 | if (gei->pid_numeric == pid_numeric) { | |
141 | return gei; | |
142 | } | |
143 | } | |
144 | ||
145 | return NULL; | |
146 | } | |
147 | ||
b90abbac | 148 | GuestExecStatus *qmp_guest_exec_status(int64_t pid, Error **errp) |
d697e30c YP |
149 | { |
150 | GuestExecInfo *gei; | |
151 | GuestExecStatus *ges; | |
152 | ||
153 | slog("guest-exec-status called, pid: %u", (uint32_t)pid); | |
154 | ||
155 | gei = guest_exec_info_find(pid); | |
156 | if (gei == NULL) { | |
b6651659 | 157 | error_setg(errp, "PID " PRId64 " does not exist"); |
d697e30c YP |
158 | return NULL; |
159 | } | |
160 | ||
161 | ges = g_new0(GuestExecStatus, 1); | |
d697e30c | 162 | |
c267d750 | 163 | bool finished = gei->finished; |
a1853dca YP |
164 | |
165 | /* need to wait till output channels are closed | |
166 | * to be sure we captured all output at this point */ | |
167 | if (gei->has_output) { | |
c267d750 | 168 | finished &= gei->out.closed && gei->err.closed; |
a1853dca YP |
169 | } |
170 | ||
171 | ges->exited = finished; | |
172 | if (finished) { | |
d697e30c YP |
173 | /* Glib has no portable way to parse exit status. |
174 | * On UNIX, we can get either exit code from normal termination | |
175 | * or signal number. | |
176 | * On Windows, it is either the same exit code or the exception | |
177 | * value for an unhandled exception that caused the process | |
178 | * to terminate. | |
179 | * See MSDN for GetExitCodeProcess() and ntstatus.h for possible | |
180 | * well-known codes, e.g. C0000005 ACCESS_DENIED - analog of SIGSEGV | |
181 | * References: | |
182 | * https://msdn.microsoft.com/en-us/library/windows/desktop/ms683189(v=vs.85).aspx | |
183 | * https://msdn.microsoft.com/en-us/library/aa260331(v=vs.60).aspx | |
184 | */ | |
185 | #ifdef G_OS_WIN32 | |
186 | /* Additionally WIN32 does not provide any additional information | |
cb8d4c8f SW |
187 | * on whether the child exited or terminated via signal. |
188 | * We use this simple range check to distinguish application exit code | |
d697e30c YP |
189 | * (usually value less then 256) and unhandled exception code with |
190 | * ntstatus (always value greater then 0xC0000005). */ | |
191 | if ((uint32_t)gei->status < 0xC0000000U) { | |
192 | ges->has_exitcode = true; | |
193 | ges->exitcode = gei->status; | |
194 | } else { | |
195 | ges->has_signal = true; | |
196 | ges->signal = gei->status; | |
197 | } | |
198 | #else | |
199 | if (WIFEXITED(gei->status)) { | |
200 | ges->has_exitcode = true; | |
201 | ges->exitcode = WEXITSTATUS(gei->status); | |
202 | } else if (WIFSIGNALED(gei->status)) { | |
203 | ges->has_signal = true; | |
204 | ges->signal = WTERMSIG(gei->status); | |
205 | } | |
206 | #endif | |
a1853dca | 207 | if (gei->out.length > 0) { |
a1853dca | 208 | ges->out_data = g_base64_encode(gei->out.data, gei->out.length); |
a1853dca YP |
209 | ges->has_out_truncated = gei->out.truncated; |
210 | } | |
d6f67b83 | 211 | g_free(gei->out.data); |
a1853dca YP |
212 | |
213 | if (gei->err.length > 0) { | |
a1853dca | 214 | ges->err_data = g_base64_encode(gei->err.data, gei->err.length); |
a1853dca YP |
215 | ges->has_err_truncated = gei->err.truncated; |
216 | } | |
d6f67b83 | 217 | g_free(gei->err.data); |
a1853dca | 218 | |
d697e30c YP |
219 | QTAILQ_REMOVE(&guest_exec_state.processes, gei, next); |
220 | g_free(gei); | |
221 | } | |
222 | ||
223 | return ges; | |
224 | } | |
225 | ||
226 | /* Get environment variables or arguments array for execve(). */ | |
227 | static char **guest_exec_get_args(const strList *entry, bool log) | |
228 | { | |
229 | const strList *it; | |
230 | int count = 1, i = 0; /* reserve for NULL terminator */ | |
231 | char **args; | |
232 | char *str; /* for logging array of arguments */ | |
233 | size_t str_size = 1; | |
234 | ||
235 | for (it = entry; it != NULL; it = it->next) { | |
236 | count++; | |
237 | str_size += 1 + strlen(it->value); | |
238 | } | |
239 | ||
240 | str = g_malloc(str_size); | |
241 | *str = 0; | |
b21e2380 | 242 | args = g_new(char *, count); |
d697e30c YP |
243 | for (it = entry; it != NULL; it = it->next) { |
244 | args[i++] = it->value; | |
245 | pstrcat(str, str_size, it->value); | |
246 | if (it->next) { | |
247 | pstrcat(str, str_size, " "); | |
248 | } | |
249 | } | |
250 | args[i] = NULL; | |
251 | ||
252 | if (log) { | |
253 | slog("guest-exec called: \"%s\"", str); | |
254 | } | |
255 | g_free(str); | |
256 | ||
257 | return args; | |
258 | } | |
259 | ||
260 | static void guest_exec_child_watch(GPid pid, gint status, gpointer data) | |
261 | { | |
262 | GuestExecInfo *gei = (GuestExecInfo *)data; | |
263 | ||
264 | g_debug("guest_exec_child_watch called, pid: %d, status: %u", | |
265 | (int32_t)gpid_to_int64(pid), (uint32_t)status); | |
266 | ||
267 | gei->status = status; | |
c267d750 | 268 | gei->finished = true; |
d697e30c YP |
269 | |
270 | g_spawn_close_pid(pid); | |
271 | } | |
272 | ||
4005b473 DL |
273 | static void guest_exec_task_setup(gpointer data) |
274 | { | |
275 | #if !defined(G_OS_WIN32) | |
810f677a | 276 | bool has_merge = *(bool *)data; |
4005b473 DL |
277 | struct sigaction sigact; |
278 | ||
810f677a DX |
279 | if (has_merge) { |
280 | /* | |
281 | * FIXME: When `GLIB_VERSION_MIN_REQUIRED` is bumped to 2.58+, use | |
282 | * g_spawn_async_with_fds() to be portable on windows. The current | |
283 | * logic does not work on windows b/c `GSpawnChildSetupFunc` is run | |
284 | * inside the parent, not the child. | |
285 | */ | |
286 | if (dup2(STDOUT_FILENO, STDERR_FILENO) != 0) { | |
287 | slog("dup2() failed to merge stderr into stdout: %s", | |
288 | strerror(errno)); | |
289 | } | |
290 | } | |
291 | ||
292 | /* Reset ignored signals back to default. */ | |
4005b473 DL |
293 | memset(&sigact, 0, sizeof(struct sigaction)); |
294 | sigact.sa_handler = SIG_DFL; | |
295 | ||
296 | if (sigaction(SIGPIPE, &sigact, NULL) != 0) { | |
297 | slog("sigaction() failed to reset child process's SIGPIPE: %s", | |
298 | strerror(errno)); | |
299 | } | |
300 | #endif | |
301 | } | |
302 | ||
a1853dca YP |
303 | static gboolean guest_exec_input_watch(GIOChannel *ch, |
304 | GIOCondition cond, gpointer p_) | |
305 | { | |
306 | GuestExecIOData *p = (GuestExecIOData *)p_; | |
307 | gsize bytes_written = 0; | |
308 | GIOStatus status; | |
309 | GError *gerr = NULL; | |
310 | ||
311 | /* nothing left to write */ | |
312 | if (p->size == p->length) { | |
313 | goto done; | |
314 | } | |
315 | ||
316 | status = g_io_channel_write_chars(ch, (gchar *)p->data + p->length, | |
317 | p->size - p->length, &bytes_written, &gerr); | |
318 | ||
319 | /* can be not 0 even if not G_IO_STATUS_NORMAL */ | |
320 | if (bytes_written != 0) { | |
321 | p->length += bytes_written; | |
322 | } | |
323 | ||
324 | /* continue write, our callback will be called again */ | |
325 | if (status == G_IO_STATUS_NORMAL || status == G_IO_STATUS_AGAIN) { | |
326 | return true; | |
327 | } | |
328 | ||
329 | if (gerr) { | |
330 | g_warning("qga: i/o error writing to input_data channel: %s", | |
331 | gerr->message); | |
332 | g_error_free(gerr); | |
333 | } | |
334 | ||
335 | done: | |
336 | g_io_channel_shutdown(ch, true, NULL); | |
337 | g_io_channel_unref(ch); | |
c267d750 | 338 | p->closed = true; |
a1853dca YP |
339 | g_free(p->data); |
340 | ||
341 | return false; | |
342 | } | |
343 | ||
344 | static gboolean guest_exec_output_watch(GIOChannel *ch, | |
345 | GIOCondition cond, gpointer p_) | |
346 | { | |
347 | GuestExecIOData *p = (GuestExecIOData *)p_; | |
348 | gsize bytes_read; | |
349 | GIOStatus gstatus; | |
350 | ||
351 | if (cond == G_IO_HUP || cond == G_IO_ERR) { | |
352 | goto close; | |
353 | } | |
354 | ||
355 | if (p->size == p->length) { | |
356 | gpointer t = NULL; | |
357 | if (!p->truncated && p->size < GUEST_EXEC_MAX_OUTPUT) { | |
358 | t = g_try_realloc(p->data, p->size + GUEST_EXEC_IO_SIZE); | |
359 | } | |
360 | if (t == NULL) { | |
361 | /* ignore truncated output */ | |
362 | gchar buf[GUEST_EXEC_IO_SIZE]; | |
363 | ||
364 | p->truncated = true; | |
365 | gstatus = g_io_channel_read_chars(ch, buf, sizeof(buf), | |
366 | &bytes_read, NULL); | |
367 | if (gstatus == G_IO_STATUS_EOF || gstatus == G_IO_STATUS_ERROR) { | |
368 | goto close; | |
369 | } | |
370 | ||
371 | return true; | |
372 | } | |
373 | p->size += GUEST_EXEC_IO_SIZE; | |
374 | p->data = t; | |
375 | } | |
376 | ||
377 | /* Calling read API once. | |
378 | * On next available data our callback will be called again */ | |
379 | gstatus = g_io_channel_read_chars(ch, (gchar *)p->data + p->length, | |
380 | p->size - p->length, &bytes_read, NULL); | |
381 | if (gstatus == G_IO_STATUS_EOF || gstatus == G_IO_STATUS_ERROR) { | |
382 | goto close; | |
383 | } | |
384 | ||
385 | p->length += bytes_read; | |
386 | ||
387 | return true; | |
388 | ||
389 | close: | |
3005c2c2 | 390 | g_io_channel_shutdown(ch, true, NULL); |
a1853dca | 391 | g_io_channel_unref(ch); |
c267d750 | 392 | p->closed = true; |
a1853dca YP |
393 | return false; |
394 | } | |
395 | ||
9c5ccc52 DX |
396 | static GuestExecCaptureOutputMode ga_parse_capture_output( |
397 | GuestExecCaptureOutput *capture_output) | |
398 | { | |
399 | if (!capture_output) | |
400 | return GUEST_EXEC_CAPTURE_OUTPUT_MODE_NONE; | |
401 | else if (capture_output->type == QTYPE_QBOOL) | |
402 | return capture_output->u.flag ? GUEST_EXEC_CAPTURE_OUTPUT_MODE_SEPARATED | |
403 | : GUEST_EXEC_CAPTURE_OUTPUT_MODE_NONE; | |
404 | else | |
405 | return capture_output->u.mode; | |
406 | } | |
407 | ||
d697e30c YP |
408 | GuestExec *qmp_guest_exec(const char *path, |
409 | bool has_arg, strList *arg, | |
410 | bool has_env, strList *env, | |
91eab32a | 411 | const char *input_data, |
9c5ccc52 | 412 | GuestExecCaptureOutput *capture_output, |
b90abbac | 413 | Error **errp) |
d697e30c YP |
414 | { |
415 | GPid pid; | |
416 | GuestExec *ge = NULL; | |
417 | GuestExecInfo *gei; | |
418 | char **argv, **envp; | |
419 | strList arglist; | |
420 | gboolean ret; | |
421 | GError *gerr = NULL; | |
a1853dca YP |
422 | gint in_fd, out_fd, err_fd; |
423 | GIOChannel *in_ch, *out_ch, *err_ch; | |
424 | GSpawnFlags flags; | |
9c5ccc52 | 425 | bool has_output = false; |
810f677a | 426 | bool has_merge = false; |
9c5ccc52 | 427 | GuestExecCaptureOutputMode output_mode; |
057489dd | 428 | g_autofree uint8_t *input = NULL; |
920639ca | 429 | size_t ninput = 0; |
d697e30c YP |
430 | |
431 | arglist.value = (char *)path; | |
432 | arglist.next = has_arg ? arg : NULL; | |
433 | ||
91eab32a | 434 | if (input_data) { |
b90abbac | 435 | input = qbase64_decode(input_data, -1, &ninput, errp); |
920639ca DB |
436 | if (!input) { |
437 | return NULL; | |
438 | } | |
439 | } | |
440 | ||
d697e30c | 441 | argv = guest_exec_get_args(&arglist, true); |
02a4d82e | 442 | envp = has_env ? guest_exec_get_args(env, false) : NULL; |
d697e30c | 443 | |
e7b3af81 DB |
444 | flags = G_SPAWN_SEARCH_PATH | G_SPAWN_DO_NOT_REAP_CHILD | |
445 | G_SPAWN_SEARCH_PATH_FROM_ENVP; | |
9c5ccc52 DX |
446 | |
447 | output_mode = ga_parse_capture_output(capture_output); | |
448 | switch (output_mode) { | |
449 | case GUEST_EXEC_CAPTURE_OUTPUT_MODE_NONE: | |
a1853dca | 450 | flags |= G_SPAWN_STDOUT_TO_DEV_NULL | G_SPAWN_STDERR_TO_DEV_NULL; |
9c5ccc52 DX |
451 | break; |
452 | case GUEST_EXEC_CAPTURE_OUTPUT_MODE_STDOUT: | |
453 | has_output = true; | |
454 | flags |= G_SPAWN_STDERR_TO_DEV_NULL; | |
455 | break; | |
456 | case GUEST_EXEC_CAPTURE_OUTPUT_MODE_STDERR: | |
457 | has_output = true; | |
458 | flags |= G_SPAWN_STDOUT_TO_DEV_NULL; | |
459 | break; | |
460 | case GUEST_EXEC_CAPTURE_OUTPUT_MODE_SEPARATED: | |
461 | has_output = true; | |
462 | break; | |
810f677a DX |
463 | #if !defined(G_OS_WIN32) |
464 | case GUEST_EXEC_CAPTURE_OUTPUT_MODE_MERGED: | |
465 | has_output = true; | |
466 | has_merge = true; | |
467 | break; | |
468 | #endif | |
9c5ccc52 DX |
469 | case GUEST_EXEC_CAPTURE_OUTPUT_MODE__MAX: |
470 | /* Silence warning; impossible branch */ | |
471 | break; | |
a1853dca YP |
472 | } |
473 | ||
474 | ret = g_spawn_async_with_pipes(NULL, argv, envp, flags, | |
810f677a | 475 | guest_exec_task_setup, &has_merge, &pid, input_data ? &in_fd : NULL, |
a1853dca | 476 | has_output ? &out_fd : NULL, has_output ? &err_fd : NULL, &gerr); |
d697e30c | 477 | if (!ret) { |
b90abbac | 478 | error_setg(errp, QERR_QGA_COMMAND_FAILED, gerr->message); |
d697e30c YP |
479 | g_error_free(gerr); |
480 | goto done; | |
481 | } | |
482 | ||
483 | ge = g_new0(GuestExec, 1); | |
484 | ge->pid = gpid_to_int64(pid); | |
485 | ||
486 | gei = guest_exec_info_add(pid); | |
a1853dca | 487 | gei->has_output = has_output; |
d697e30c YP |
488 | g_child_watch_add(pid, guest_exec_child_watch, gei); |
489 | ||
91eab32a | 490 | if (input_data) { |
057489dd | 491 | gei->in.data = g_steal_pointer(&input); |
920639ca | 492 | gei->in.size = ninput; |
a1853dca YP |
493 | #ifdef G_OS_WIN32 |
494 | in_ch = g_io_channel_win32_new_fd(in_fd); | |
495 | #else | |
496 | in_ch = g_io_channel_unix_new(in_fd); | |
497 | #endif | |
498 | g_io_channel_set_encoding(in_ch, NULL, NULL); | |
499 | g_io_channel_set_buffered(in_ch, false); | |
500 | g_io_channel_set_flags(in_ch, G_IO_FLAG_NONBLOCK, NULL); | |
3005c2c2 | 501 | g_io_channel_set_close_on_unref(in_ch, true); |
a1853dca YP |
502 | g_io_add_watch(in_ch, G_IO_OUT, guest_exec_input_watch, &gei->in); |
503 | } | |
504 | ||
505 | if (has_output) { | |
506 | #ifdef G_OS_WIN32 | |
507 | out_ch = g_io_channel_win32_new_fd(out_fd); | |
508 | err_ch = g_io_channel_win32_new_fd(err_fd); | |
509 | #else | |
510 | out_ch = g_io_channel_unix_new(out_fd); | |
511 | err_ch = g_io_channel_unix_new(err_fd); | |
512 | #endif | |
513 | g_io_channel_set_encoding(out_ch, NULL, NULL); | |
514 | g_io_channel_set_encoding(err_ch, NULL, NULL); | |
515 | g_io_channel_set_buffered(out_ch, false); | |
516 | g_io_channel_set_buffered(err_ch, false); | |
3005c2c2 YP |
517 | g_io_channel_set_close_on_unref(out_ch, true); |
518 | g_io_channel_set_close_on_unref(err_ch, true); | |
a1853dca YP |
519 | g_io_add_watch(out_ch, G_IO_IN | G_IO_HUP, |
520 | guest_exec_output_watch, &gei->out); | |
521 | g_io_add_watch(err_ch, G_IO_IN | G_IO_HUP, | |
522 | guest_exec_output_watch, &gei->err); | |
523 | } | |
524 | ||
d697e30c YP |
525 | done: |
526 | g_free(argv); | |
527 | g_free(envp); | |
528 | ||
529 | return ge; | |
530 | } | |
0b4b4938 EB |
531 | |
532 | /* Convert GuestFileWhence (either a raw integer or an enum value) into | |
533 | * the guest's SEEK_ constants. */ | |
534 | int ga_parse_whence(GuestFileWhence *whence, Error **errp) | |
535 | { | |
a23f38a7 EB |
536 | /* |
537 | * Exploit the fact that we picked values to match QGA_SEEK_*; | |
538 | * however, we have to use a temporary variable since the union | |
539 | * members may have different size. | |
540 | */ | |
0b4b4938 | 541 | if (whence->type == QTYPE_QSTRING) { |
a23f38a7 | 542 | int value = whence->u.name; |
01b2ffce | 543 | whence->type = QTYPE_QNUM; |
a23f38a7 | 544 | whence->u.value = value; |
0b4b4938 EB |
545 | } |
546 | switch (whence->u.value) { | |
547 | case QGA_SEEK_SET: | |
548 | return SEEK_SET; | |
549 | case QGA_SEEK_CUR: | |
550 | return SEEK_CUR; | |
551 | case QGA_SEEK_END: | |
552 | return SEEK_END; | |
553 | } | |
554 | error_setg(errp, "invalid whence code %"PRId64, whence->u.value); | |
555 | return -1; | |
556 | } | |
0a3d197a | 557 | |
b90abbac | 558 | GuestHostName *qmp_guest_get_host_name(Error **errp) |
0a3d197a VF |
559 | { |
560 | GuestHostName *result = NULL; | |
548fb0da | 561 | g_autofree char *hostname = qga_get_host_name(errp); |
0d3a8f32 MP |
562 | |
563 | /* | |
564 | * We want to avoid using g_get_host_name() because that | |
565 | * caches the result and we wouldn't reflect changes in the | |
566 | * host name. | |
567 | */ | |
568 | ||
569 | if (!hostname) { | |
570 | hostname = g_strdup("localhost"); | |
0a3d197a | 571 | } |
0d3a8f32 MP |
572 | |
573 | result = g_new0(GuestHostName, 1); | |
574 | result->host_name = g_steal_pointer(&hostname); | |
0a3d197a VF |
575 | return result; |
576 | } | |
53c58e64 VF |
577 | |
578 | GuestTimezone *qmp_guest_get_timezone(Error **errp) | |
579 | { | |
53c58e64 VF |
580 | GuestTimezone *info = NULL; |
581 | GTimeZone *tz = NULL; | |
582 | gint64 now = 0; | |
583 | gint32 intv = 0; | |
584 | gchar const *name = NULL; | |
585 | ||
586 | info = g_new0(GuestTimezone, 1); | |
587 | tz = g_time_zone_new_local(); | |
588 | if (tz == NULL) { | |
589 | error_setg(errp, QERR_QGA_COMMAND_FAILED, | |
590 | "Couldn't retrieve local timezone"); | |
591 | goto error; | |
592 | } | |
593 | ||
594 | now = g_get_real_time() / G_USEC_PER_SEC; | |
595 | intv = g_time_zone_find_interval(tz, G_TIME_TYPE_UNIVERSAL, now); | |
596 | info->offset = g_time_zone_get_offset(tz, intv); | |
597 | name = g_time_zone_get_abbreviation(tz, intv); | |
598 | if (name != NULL) { | |
53c58e64 VF |
599 | info->zone = g_strdup(name); |
600 | } | |
601 | g_time_zone_unref(tz); | |
602 | ||
603 | return info; | |
604 | ||
605 | error: | |
606 | g_free(info); | |
607 | return NULL; | |
53c58e64 | 608 | } |
ead83a13 PMD |
609 | |
610 | GuestFileRead *qmp_guest_file_read(int64_t handle, bool has_count, | |
611 | int64_t count, Error **errp) | |
612 | { | |
613 | GuestFileHandle *gfh = guest_file_handle_find(handle, errp); | |
614 | GuestFileRead *read_data; | |
615 | ||
616 | if (!gfh) { | |
617 | return NULL; | |
618 | } | |
619 | if (!has_count) { | |
620 | count = QGA_READ_COUNT_DEFAULT; | |
1329651f | 621 | } else if (count < 0 || count > GUEST_FILE_READ_COUNT_MAX) { |
ead83a13 PMD |
622 | error_setg(errp, "value '%" PRId64 "' is invalid for argument count", |
623 | count); | |
624 | return NULL; | |
625 | } | |
626 | ||
627 | read_data = guest_file_read_unsafe(gfh, count, errp); | |
628 | if (!read_data) { | |
629 | slog("guest-file-write failed, handle: %" PRId64, handle); | |
630 | } | |
631 | ||
632 | return read_data; | |
633 | } | |
287698e5 MAL |
634 | |
635 | int64_t qmp_guest_get_time(Error **errp) | |
636 | { | |
637 | return g_get_real_time() * 1000; | |
638 | } |