Return to commands.c CVS log

Up to [Qemu by Fabrice Bellard] / qemu / qga

Annotation of qemu/qga/commands.c, revision 1.1.1.1

1.1       root        1: /*
                      2:  * QEMU Guest Agent common/cross-platform command implementations
                      3:  *
                      4:  * Copyright IBM Corp. 2012
                      5:  *
                      6:  * Authors:
                      7:  *  Michael Roth      <[email protected]>
                      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: 
                     13: #include <glib.h>
                     14: #include "qga/guest-agent-core.h"
                     15: #include "qga-qmp-commands.h"
                     16: #include "qerror.h"
                     17: 
                     18: /* Note: in some situations, like with the fsfreeze, logging may be
                     19:  * temporarilly disabled. if it is necessary that a command be able
                     20:  * to log for accounting purposes, check ga_logging_enabled() beforehand,
                     21:  * and use the QERR_QGA_LOGGING_DISABLED to generate an error
                     22:  */
                     23: void slog(const gchar *fmt, ...)
                     24: {
                     25:     va_list ap;
                     26: 
                     27:     va_start(ap, fmt);
                     28:     g_logv("syslog", G_LOG_LEVEL_INFO, fmt, ap);
                     29:     va_end(ap);
                     30: }
                     31: 
                     32: int64_t qmp_guest_sync_delimited(int64_t id, Error **errp)
                     33: {
                     34:     ga_set_response_delimited(ga_state);
                     35:     return id;
                     36: }
                     37: 
                     38: int64_t qmp_guest_sync(int64_t id, Error **errp)
                     39: {
                     40:     return id;
                     41: }
                     42: 
                     43: void qmp_guest_ping(Error **err)
                     44: {
                     45:     slog("guest-ping called");
                     46: }
                     47: 
                     48: struct GuestAgentInfo *qmp_guest_info(Error **err)
                     49: {
                     50:     GuestAgentInfo *info = g_malloc0(sizeof(GuestAgentInfo));
                     51:     GuestAgentCommandInfo *cmd_info;
                     52:     GuestAgentCommandInfoList *cmd_info_list;
                     53:     char **cmd_list_head, **cmd_list;
                     54: 
                     55:     info->version = g_strdup(QEMU_VERSION);
                     56: 
                     57:     cmd_list_head = cmd_list = qmp_get_command_list();
                     58:     if (*cmd_list_head == NULL) {
                     59:         goto out;
                     60:     }
                     61: 
                     62:     while (*cmd_list) {
                     63:         cmd_info = g_malloc0(sizeof(GuestAgentCommandInfo));
                     64:         cmd_info->name = strdup(*cmd_list);
                     65:         cmd_info->enabled = qmp_command_is_enabled(cmd_info->name);
                     66: 
                     67:         cmd_info_list = g_malloc0(sizeof(GuestAgentCommandInfoList));
                     68:         cmd_info_list->value = cmd_info;
                     69:         cmd_info_list->next = info->supported_commands;
                     70:         info->supported_commands = cmd_info_list;
                     71: 
                     72:         g_free(*cmd_list);
                     73:         cmd_list++;
                     74:     }
                     75: 
                     76: out:
                     77:     g_free(cmd_list_head);
                     78:     return info;
                     79: }

This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.