From patchwork Thu Nov 19 15:13:34 2009
Content-Type: text/plain; charset="utf-8"
MIME-Version: 1.0
Content-Transfer-Encoding: 7bit
Subject: [06/15] QMP: Output support
Date: Thu, 19 Nov 2009 05:13:34 -0000
From: Luiz Capitulino <lcapitulino@redhat.com>
X-Patchwork-Id: 38849
Message-Id: <1258643623-8636-7-git-send-email-lcapitulino@redhat.com>
To: qemu-devel@nongnu.org
Cc: aliguori@us.ibm.com, avi@redhat.com

In the new Monitor, output is always done by only two
functions: do_info() and monitor_call_handler().

To support QMP output, we modify those functions to test if we
are in control mode. If so, we call monitor_protocol_emitter()
to emit QMP output, otherwise we do regular output.

QMP has two types of responses to issued commands: success and
error. The outputed data is always a JSON object.

Success responses have the following format:

{ "return": json-value, "id": json-value }

Error responses have the following format:

{ "error": { "class": json-string,
             "desc": json-string,
             "data": json-value } "id": json-value }

Please, note that the "id" key is part of the input code, and
thus is not added in this commit.

Signed-off-by: Luiz Capitulino <lcapitulino@redhat.com>

---
monitor.c |   56 +++++++++++++++++++++++++++++++++++++++++++++++++-------
 1 files changed, 49 insertions(+), 7 deletions(-)

diff --git a/monitor.c b/monitor.c
index be68dd5..e81f9e6 100644
--- a/monitor.c
+++ b/monitor.c
@@ -273,6 +273,33 @@ static void monitor_json_emitter(Monitor *mon, const QObject *data)
     QDECREF(json);
 }
 
+static void monitor_protocol_emitter(Monitor *mon, QObject *data)
+{
+    QDict *qmp;
+
+    qmp = qdict_new();
+
+    if (!monitor_has_error(mon)) {
+        /* success response */
+        if (data) {
+            qobject_incref(data);
+            qdict_put_obj(qmp, "return", data);
+        } else {
+            // FIXME: should we return json-null here?
+            qdict_put(qmp, "return", qstring_from_str("OK"));
+        }
+    } else {
+        /* error response */
+        QINCREF(mon->error->error);
+        qdict_put(qmp, "error", mon->error->error);
+        QDECREF(mon->error);
+        mon->error = NULL;
+    }
+
+    monitor_json_emitter(mon, QOBJECT(qmp));
+    QDECREF(qmp);
+}
+
 static int compare_cmd(const char *name, const char *list)
 {
     const char *p, *pstart;
@@ -360,8 +387,15 @@ static void do_info(Monitor *mon, const QDict *qdict, QObject **ret_data)
 
     if (monitor_handler_ported(cmd)) {
         cmd->mhandler.info_new(mon, ret_data);
-        if (*ret_data)
-            cmd->user_print(mon, *ret_data);
+
+        if (!monitor_ctrl_mode(mon)) {
+            /*
+             * User Protocol function is called here, Monitor Protocol is
+             * handled by monitor_handle_command()
+             */
+            if (*ret_data)
+                cmd->user_print(mon, *ret_data);
+        }
     } else {
         cmd->mhandler.info(mon);
     }
@@ -3292,8 +3326,15 @@ static void monitor_call_handler(Monitor *mon, const mon_cmd_t *cmd,
     QObject *data = NULL;
 
     cmd->mhandler.cmd_new(mon, params, &data);
-    if (data)
-        cmd->user_print(mon, data);
+
+    if (monitor_ctrl_mode(mon)) {
+        /* Monitor Protocol */
+        monitor_protocol_emitter(mon, data);
+    } else {
+        /* User Protocol */
+         if (data)
+            cmd->user_print(mon, data);
+    }
 
     qobject_decref(data);
 }
@@ -3315,10 +3356,11 @@ static void monitor_handle_command(Monitor *mon, const char *cmdline)
         monitor_call_handler(mon, cmd, qdict);
     } else {
         cmd->mhandler.cmd(mon, qdict);
-    }
 
-    if (monitor_has_error(mon))
-        monitor_print_error(mon);
+        if (monitor_has_error(mon)) {
+            monitor_print_error(mon);
+        }
+    }
 
     qemu_errors_to_previous();