unixctl: New JSON RPC back-end.
authorEthan Jackson <ethan@nicira.com>
Wed, 15 Feb 2012 04:53:59 +0000 (20:53 -0800)
committerEthan Jackson <ethan@nicira.com>
Tue, 21 Feb 2012 08:02:20 +0000 (00:02 -0800)
The unixctl library had used the vde2 management protocol since the
early days of Open vSwitch.  As Open vSwitch has matured, several
Python daemons have been added to the code base which would benefit
from a unixctl implementations.  Instead of implementing the old
unixctl protocol in Python, this patch changes unixctl to use JSON
RPC for which we already have an implementation in both Python and
C.  Future patches will need to implement a unixctl library in
Python on top of JSON RPC.

Signed-off-by: Ethan Jackson <ethan@nicira.com>
22 files changed:
lib/bond.c
lib/cfm.c
lib/coverage.c
lib/lacp.c
lib/netdev-dummy.c
lib/stp.c
lib/stress.c
lib/timeval.c
lib/unixctl.c
lib/unixctl.h
lib/vlog.c
ofproto/ofproto-dpif.c
ofproto/ofproto.c
ovsdb/automake.mk
ovsdb/ovsdb-server.c
tests/automake.mk
tests/test-netflow.c
utilities/automake.mk
utilities/ovs-appctl.c
utilities/ovs-ofctl.c
vswitchd/bridge.c
vswitchd/ovs-vswitchd.c

index 1ad2367d48c808d513e340cd4cf0057cabd8f0ff..3b86ee486f05de10685835fc9f85f921ef82e9d6 100644 (file)
@@ -941,7 +941,7 @@ bond_unixctl_list(struct unixctl_conn *conn,
         }
         ds_put_char(&ds, '\n');
     }
         }
         ds_put_char(&ds, '\n');
     }
-    unixctl_command_reply(conn, 200, ds_cstr(&ds));
+    unixctl_command_reply(conn, ds_cstr(&ds));
     ds_destroy(&ds);
 }
 
     ds_destroy(&ds);
 }
 
@@ -1042,7 +1042,7 @@ bond_unixctl_show(struct unixctl_conn *conn,
         const struct bond *bond = bond_find(argv[1]);
 
         if (!bond) {
         const struct bond *bond = bond_find(argv[1]);
 
         if (!bond) {
-            unixctl_command_reply(conn, 501, "no such bond");
+            unixctl_command_reply_error(conn, "no such bond");
             return;
         }
         bond_print_details(&ds, bond);
             return;
         }
         bond_print_details(&ds, bond);
@@ -1054,7 +1054,7 @@ bond_unixctl_show(struct unixctl_conn *conn,
         }
     }
 
         }
     }
 
-    unixctl_command_reply(conn, 200, ds_cstr(&ds));
+    unixctl_command_reply(conn, ds_cstr(&ds));
     ds_destroy(&ds);
 }
 
     ds_destroy(&ds);
 }
 
@@ -1073,30 +1073,30 @@ bond_unixctl_migrate(struct unixctl_conn *conn,
 
     bond = bond_find(bond_s);
     if (!bond) {
 
     bond = bond_find(bond_s);
     if (!bond) {
-        unixctl_command_reply(conn, 501, "no such bond");
+        unixctl_command_reply_error(conn, "no such bond");
         return;
     }
 
     if (bond->balance != BM_SLB) {
         return;
     }
 
     if (bond->balance != BM_SLB) {
-        unixctl_command_reply(conn, 501, "not an SLB bond");
+        unixctl_command_reply_error(conn, "not an SLB bond");
         return;
     }
 
     if (strspn(hash_s, "0123456789") == strlen(hash_s)) {
         hash = atoi(hash_s) & BOND_MASK;
     } else {
         return;
     }
 
     if (strspn(hash_s, "0123456789") == strlen(hash_s)) {
         hash = atoi(hash_s) & BOND_MASK;
     } else {
-        unixctl_command_reply(conn, 501, "bad hash");
+        unixctl_command_reply_error(conn, "bad hash");
         return;
     }
 
     slave = bond_lookup_slave(bond, slave_s);
     if (!slave) {
         return;
     }
 
     slave = bond_lookup_slave(bond, slave_s);
     if (!slave) {
-        unixctl_command_reply(conn, 501, "no such slave");
+        unixctl_command_reply_error(conn, "no such slave");
         return;
     }
 
     if (!slave->enabled) {
         return;
     }
 
     if (!slave->enabled) {
-        unixctl_command_reply(conn, 501, "cannot migrate to disabled slave");
+        unixctl_command_reply_error(conn, "cannot migrate to disabled slave");
         return;
     }
 
         return;
     }
 
@@ -1104,7 +1104,7 @@ bond_unixctl_migrate(struct unixctl_conn *conn,
     tag_set_add(&bond->unixctl_tags, entry->tag);
     entry->slave = slave;
     entry->tag = tag_create_random();
     tag_set_add(&bond->unixctl_tags, entry->tag);
     entry->slave = slave;
     entry->tag = tag_create_random();
-    unixctl_command_reply(conn, 200, "migrated");
+    unixctl_command_reply(conn, "migrated");
 }
 
 static void
 }
 
 static void
@@ -1119,18 +1119,18 @@ bond_unixctl_set_active_slave(struct unixctl_conn *conn,
 
     bond = bond_find(bond_s);
     if (!bond) {
 
     bond = bond_find(bond_s);
     if (!bond) {
-        unixctl_command_reply(conn, 501, "no such bond");
+        unixctl_command_reply_error(conn, "no such bond");
         return;
     }
 
     slave = bond_lookup_slave(bond, slave_s);
     if (!slave) {
         return;
     }
 
     slave = bond_lookup_slave(bond, slave_s);
     if (!slave) {
-        unixctl_command_reply(conn, 501, "no such slave");
+        unixctl_command_reply_error(conn, "no such slave");
         return;
     }
 
     if (!slave->enabled) {
         return;
     }
 
     if (!slave->enabled) {
-        unixctl_command_reply(conn, 501, "cannot make disabled slave active");
+        unixctl_command_reply_error(conn, "cannot make disabled slave active");
         return;
     }
 
         return;
     }
 
@@ -1141,9 +1141,9 @@ bond_unixctl_set_active_slave(struct unixctl_conn *conn,
         VLOG_INFO("bond %s: active interface is now %s",
                   bond->name, slave->name);
         bond->send_learning_packets = true;
         VLOG_INFO("bond %s: active interface is now %s",
                   bond->name, slave->name);
         bond->send_learning_packets = true;
-        unixctl_command_reply(conn, 200, "done");
+        unixctl_command_reply(conn, "done");
     } else {
     } else {
-        unixctl_command_reply(conn, 200, "no change");
+        unixctl_command_reply(conn, "no change");
     }
 }
 
     }
 }
 
@@ -1157,18 +1157,18 @@ enable_slave(struct unixctl_conn *conn, const char *argv[], bool enable)
 
     bond = bond_find(bond_s);
     if (!bond) {
 
     bond = bond_find(bond_s);
     if (!bond) {
-        unixctl_command_reply(conn, 501, "no such bond");
+        unixctl_command_reply_error(conn, "no such bond");
         return;
     }
 
     slave = bond_lookup_slave(bond, slave_s);
     if (!slave) {
         return;
     }
 
     slave = bond_lookup_slave(bond, slave_s);
     if (!slave) {
-        unixctl_command_reply(conn, 501, "no such slave");
+        unixctl_command_reply_error(conn, "no such slave");
         return;
     }
 
     bond_enable_slave(slave, enable, &bond->unixctl_tags);
         return;
     }
 
     bond_enable_slave(slave, enable, &bond->unixctl_tags);
-    unixctl_command_reply(conn, 200, enable ? "enabled" : "disabled");
+    unixctl_command_reply(conn, enable ? "enabled" : "disabled");
 }
 
 static void
 }
 
 static void
@@ -1202,7 +1202,7 @@ bond_unixctl_hash(struct unixctl_conn *conn, int argc, const char *argv[],
 
     if (vlan_s) {
         if (sscanf(vlan_s, "%u", &vlan) != 1) {
 
     if (vlan_s) {
         if (sscanf(vlan_s, "%u", &vlan) != 1) {
-            unixctl_command_reply(conn, 501, "invalid vlan");
+            unixctl_command_reply_error(conn, "invalid vlan");
             return;
         }
     } else {
             return;
         }
     } else {
@@ -1211,7 +1211,7 @@ bond_unixctl_hash(struct unixctl_conn *conn, int argc, const char *argv[],
 
     if (basis_s) {
         if (sscanf(basis_s, "%"PRIu32, &basis) != 1) {
 
     if (basis_s) {
         if (sscanf(basis_s, "%"PRIu32, &basis) != 1) {
-            unixctl_command_reply(conn, 501, "invalid basis");
+            unixctl_command_reply_error(conn, "invalid basis");
             return;
         }
     } else {
             return;
         }
     } else {
@@ -1223,10 +1223,10 @@ bond_unixctl_hash(struct unixctl_conn *conn, int argc, const char *argv[],
         hash = bond_hash_src(mac, vlan, basis) & BOND_MASK;
 
         hash_cstr = xasprintf("%u", hash);
         hash = bond_hash_src(mac, vlan, basis) & BOND_MASK;
 
         hash_cstr = xasprintf("%u", hash);
-        unixctl_command_reply(conn, 200, hash_cstr);
+        unixctl_command_reply(conn, hash_cstr);
         free(hash_cstr);
     } else {
         free(hash_cstr);
     } else {
-        unixctl_command_reply(conn, 501, "invalid mac");
+        unixctl_command_reply_error(conn, "invalid mac");
     }
 }
 
     }
 }
 
index d373f4229a5dfafe531048d3a32bd4583538e212..8d90829a77122521b1e3aa069b1e178a714a3e37 100644 (file)
--- a/lib/cfm.c
+++ b/lib/cfm.c
@@ -677,7 +677,7 @@ cfm_unixctl_show(struct unixctl_conn *conn, int argc, const char *argv[],
     if (argc > 1) {
         cfm = cfm_find(argv[1]);
         if (!cfm) {
     if (argc > 1) {
         cfm = cfm_find(argv[1]);
         if (!cfm) {
-            unixctl_command_reply(conn, 501, "no such CFM object");
+            unixctl_command_reply_error(conn, "no such CFM object");
             return;
         }
         cfm_print_details(&ds, cfm);
             return;
         }
         cfm_print_details(&ds, cfm);
@@ -687,7 +687,7 @@ cfm_unixctl_show(struct unixctl_conn *conn, int argc, const char *argv[],
         }
     }
 
         }
     }
 
-    unixctl_command_reply(conn, 200, ds_cstr(&ds));
+    unixctl_command_reply(conn, ds_cstr(&ds));
     ds_destroy(&ds);
 }
 
     ds_destroy(&ds);
 }
 
@@ -706,14 +706,14 @@ cfm_unixctl_set_fault(struct unixctl_conn *conn, int argc, const char *argv[],
     } else if (!strcasecmp("normal", fault_str)) {
         fault_override = -1;
     } else {
     } else if (!strcasecmp("normal", fault_str)) {
         fault_override = -1;
     } else {
-        unixctl_command_reply(conn, 501, "unknown fault string");
+        unixctl_command_reply_error(conn, "unknown fault string");
         return;
     }
 
     if (argc > 2) {
         cfm = cfm_find(argv[1]);
         if (!cfm) {
         return;
     }
 
     if (argc > 2) {
         cfm = cfm_find(argv[1]);
         if (!cfm) {
-            unixctl_command_reply(conn, 501, "no such CFM object");
+            unixctl_command_reply_error(conn, "no such CFM object");
             return;
         }
         cfm->fault_override = fault_override;
             return;
         }
         cfm->fault_override = fault_override;
@@ -723,5 +723,5 @@ cfm_unixctl_set_fault(struct unixctl_conn *conn, int argc, const char *argv[],
         }
     }
 
         }
     }
 
-    unixctl_command_reply(conn, 200, "OK");
+    unixctl_command_reply(conn, "OK");
 }
 }
index 08b496103c1aa5a5375c783359cbc3760e0a6503..0deb5265a4a3e8e6bd480bdbff413bc5feeec7e6 100644 (file)
@@ -53,7 +53,7 @@ coverage_unixctl_log(struct unixctl_conn *conn, int argc OVS_UNUSED,
                      const char *argv[] OVS_UNUSED, void *aux OVS_UNUSED)
 {
     coverage_log(VLL_WARN, false);
                      const char *argv[] OVS_UNUSED, void *aux OVS_UNUSED)
 {
     coverage_log(VLL_WARN, false);
-    unixctl_command_reply(conn, 200, NULL);
+    unixctl_command_reply(conn, NULL);
 }
 
 void
 }
 
 void
index c51fac69da3b792af2566097809c5b5869793298..f7d5a82ff1839a7f7486ed1b8f31b84a135d9e7d 100644 (file)
@@ -878,7 +878,7 @@ lacp_unixctl_show(struct unixctl_conn *conn, int argc, const char *argv[],
     if (argc > 1) {
         lacp = lacp_find(argv[1]);
         if (!lacp) {
     if (argc > 1) {
         lacp = lacp_find(argv[1]);
         if (!lacp) {
-            unixctl_command_reply(conn, 501, "no such lacp object");
+            unixctl_command_reply_error(conn, "no such lacp object");
             return;
         }
         lacp_print_details(&ds, lacp);
             return;
         }
         lacp_print_details(&ds, lacp);
@@ -888,6 +888,6 @@ lacp_unixctl_show(struct unixctl_conn *conn, int argc, const char *argv[],
         }
     }
 
         }
     }
 
-    unixctl_command_reply(conn, 200, ds_cstr(&ds));
+    unixctl_command_reply(conn, ds_cstr(&ds));
     ds_destroy(&ds);
 }
     ds_destroy(&ds);
 }
index 57962d10e273242d7a5af7421fb6920c425fe7e9..5c6563ccb1b43296801895531705b3fd80bbeb77 100644 (file)
@@ -410,7 +410,7 @@ netdev_dummy_receive(struct unixctl_conn *conn,
 
     dummy_dev = shash_find_data(&dummy_netdev_devs, argv[1]);
     if (!dummy_dev) {
 
     dummy_dev = shash_find_data(&dummy_netdev_devs, argv[1]);
     if (!dummy_dev) {
-        unixctl_command_reply(conn, 501, "no such dummy netdev");
+        unixctl_command_reply_error(conn, "no such dummy netdev");
         return;
     }
 
         return;
     }
 
@@ -421,7 +421,7 @@ netdev_dummy_receive(struct unixctl_conn *conn,
 
         packet = eth_from_packet_or_flow(argv[i]);
         if (!packet) {
 
         packet = eth_from_packet_or_flow(argv[i]);
         if (!packet) {
-            unixctl_command_reply(conn, 501, "bad packet syntax");
+            unixctl_command_reply_error(conn, "bad packet syntax");
             return;
         }
 
             return;
         }
 
@@ -437,9 +437,9 @@ netdev_dummy_receive(struct unixctl_conn *conn,
     }
 
     if (!n_listeners) {
     }
 
     if (!n_listeners) {
-        unixctl_command_reply(conn, 202, "packets queued but nobody listened");
+        unixctl_command_reply(conn, "packets queued but nobody listened");
     } else {
     } else {
-        unixctl_command_reply(conn, 200, "success");
+        unixctl_command_reply(conn, "success");
     }
 }
 
     }
 }
 
index 06ac0019bfa807f78d3978589edbffe95f9ddfdc..e92305314ddad5faecf5c6b505df8bef712855aa 100644 (file)
--- a/lib/stp.c
+++ b/lib/stp.c
@@ -1371,7 +1371,7 @@ stp_unixctl_tcn(struct unixctl_conn *conn, int argc,
         struct stp *stp = stp_find(argv[1]);
 
         if (!stp) {
         struct stp *stp = stp_find(argv[1]);
 
         if (!stp) {
-            unixctl_command_reply(conn, 501, "no such stp object");
+            unixctl_command_reply_error(conn, "no such stp object");
             return;
         }
         stp_topology_change_detection(stp);
             return;
         }
         stp_topology_change_detection(stp);
@@ -1383,5 +1383,5 @@ stp_unixctl_tcn(struct unixctl_conn *conn, int argc,
         }
     }
 
         }
     }
 
-    unixctl_command_reply(conn, 200, "OK");
+    unixctl_command_reply(conn, "OK");
 }
 }
index 0fdc79aa0a6e77cf0788852e4b1554b828e4223c..dfd0099090f82d04b139aecc1fd74d22d355d836 100644 (file)
@@ -154,9 +154,9 @@ stress_unixctl_list(struct unixctl_conn *conn, int argc OVS_UNUSED,
         }
     }
     if (found) {
         }
     }
     if (found) {
-        unixctl_command_reply(conn, 200, ds_cstr(&results));
+        unixctl_command_reply(conn, ds_cstr(&results));
     } else {
     } else {
-        unixctl_command_reply(conn, 404, "");
+        unixctl_command_reply_error(conn, NULL);
     }
     ds_destroy(&results);
 }
     }
     ds_destroy(&results);
 }
@@ -166,7 +166,7 @@ stress_unixctl_enable(struct unixctl_conn *conn, int argc OVS_UNUSED,
                       const char *argv[] OVS_UNUSED, void *aux OVS_UNUSED)
 {
     stress_enable(true);
                       const char *argv[] OVS_UNUSED, void *aux OVS_UNUSED)
 {
     stress_enable(true);
-    unixctl_command_reply(conn, 200, "");
+    unixctl_command_reply(conn, NULL);
 }
 
 static void
 }
 
 static void
@@ -174,14 +174,13 @@ stress_unixctl_disable(struct unixctl_conn *conn, int argc OVS_UNUSED,
                        const char *argv[] OVS_UNUSED, void *aux OVS_UNUSED)
 {
     stress_enable(false);
                        const char *argv[] OVS_UNUSED, void *aux OVS_UNUSED)
 {
     stress_enable(false);
-    unixctl_command_reply(conn, 200, "");
+    unixctl_command_reply(conn, NULL);
 }
 
 static void
 stress_unixctl_set(struct unixctl_conn *conn, int argc OVS_UNUSED,
                    const char *argv[], void *aux OVS_UNUSED)
 {
 }
 
 static void
 stress_unixctl_set(struct unixctl_conn *conn, int argc OVS_UNUSED,
                    const char *argv[], void *aux OVS_UNUSED)
 {
-    int code = 404;
     const char *option_name = argv[1];
     const char *option_val = argv[2];
     int i;
     const char *option_name = argv[1];
     const char *option_val = argv[2];
     int i;
@@ -193,11 +192,12 @@ stress_unixctl_set(struct unixctl_conn *conn, int argc OVS_UNUSED,
             bool random = !strcmp(argv[3], "random");
 
             stress_set(option, period, random);
             bool random = !strcmp(argv[3], "random");
 
             stress_set(option, period, random);
-            code = 200;
-            break;
+            unixctl_command_reply(conn, NULL);
+            return;
         }
     }
         }
     }
-    unixctl_command_reply(conn, code, "");
+
+    unixctl_command_reply_error(conn, NULL);
 }
 
 /* Exposes ovs-appctl access to the stress options.
 }
 
 /* Exposes ovs-appctl access to the stress options.
index 8097ce806b413f21e429ebbca4fcef01555c6a94..35819edd35e938ebd49e02eda2e70dd7180131b6 100644 (file)
@@ -570,14 +570,14 @@ timeval_warp_cb(struct unixctl_conn *conn,
 
     msecs = atoi(argv[1]);
     if (msecs <= 0) {
 
     msecs = atoi(argv[1]);
     if (msecs <= 0) {
-        unixctl_command_reply(conn, 501, "invalid MSECS");
+        unixctl_command_reply_error(conn, "invalid MSECS");
         return;
     }
 
     ts.tv_sec = msecs / 1000;
     ts.tv_nsec = (msecs % 1000) * 1000 * 1000;
     timespec_add(&warp_offset, &warp_offset, &ts);
         return;
     }
 
     ts.tv_sec = msecs / 1000;
     ts.tv_nsec = (msecs % 1000) * 1000 * 1000;
     timespec_add(&warp_offset, &warp_offset, &ts);
-    unixctl_command_reply(conn, 200, "warped");
+    unixctl_command_reply(conn, "warped");
 }
 
 void
 }
 
 void
index caaf252dff7213623a782de3ed23d7521ccca5cb..054ce49c0cfad72bd1b42211db713f69b971c604 100644 (file)
@@ -1,5 +1,5 @@
 /*
 /*
- * Copyright (c) 2008, 2009, 2010, 2011 Nicira Networks.
+ * Copyright (c) 2008, 2009, 2010, 2011, 2012 Nicira Networks.
  *
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
  *
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
 #include <config.h>
 #include "unixctl.h"
 #include <assert.h>
 #include <config.h>
 #include "unixctl.h"
 #include <assert.h>
-#include <ctype.h>
 #include <errno.h>
 #include <errno.h>
-#include <poll.h>
-#include <stdlib.h>
-#include <string.h>
-#include <sys/socket.h>
-#include <sys/stat.h>
 #include <unistd.h>
 #include "coverage.h"
 #include "dirs.h"
 #include "dynamic-string.h"
 #include <unistd.h>
 #include "coverage.h"
 #include "dirs.h"
 #include "dynamic-string.h"
-#include "fatal-signal.h"
+#include "json.h"
+#include "jsonrpc.h"
 #include "list.h"
 #include "list.h"
-#include "ofpbuf.h"
 #include "poll-loop.h"
 #include "shash.h"
 #include "poll-loop.h"
 #include "shash.h"
-#include "socket-util.h"
+#include "stream.h"
 #include "svec.h"
 #include "svec.h"
-#include "util.h"
 #include "vlog.h"
 
 #include "vlog.h"
 
-#ifndef SCM_CREDENTIALS
-#include <time.h>
-#endif
-
 VLOG_DEFINE_THIS_MODULE(unixctl);
 
 COVERAGE_DEFINE(unixctl_received);
 VLOG_DEFINE_THIS_MODULE(unixctl);
 
 COVERAGE_DEFINE(unixctl_received);
@@ -56,28 +45,19 @@ struct unixctl_command {
 
 struct unixctl_conn {
     struct list node;
 
 struct unixctl_conn {
     struct list node;
-    int fd;
+    struct jsonrpc *rpc;
 
 
-    enum { S_RECV, S_PROCESS, S_SEND } state;
-    struct ofpbuf in;
-    struct ds out;
-    size_t out_pos;
+    /* Only one request can be in progress at a time.  While the request is
+     * being processed, 'request_id' is populated, otherwise it is null. */
+    struct json *request_id;   /* ID of the currently active request. */
 };
 
 /* Server for control connection. */
 struct unixctl_server {
 };
 
 /* Server for control connection. */
 struct unixctl_server {
-    char *path;
-    int fd;
+    struct pstream *listener;
     struct list conns;
 };
 
     struct list conns;
 };
 
-/* Client for control connection. */
-struct unixctl_client {
-    char *connect_path;
-    char *bind_path;
-    FILE *stream;
-};
-
 static struct vlog_rate_limit rl = VLOG_RATE_LIMIT_INIT(5, 5);
 
 static struct shash commands = SHASH_INITIALIZER(&commands);
 static struct vlog_rate_limit rl = VLOG_RATE_LIMIT_INIT(5, 5);
 
 static struct shash commands = SHASH_INITIALIZER(&commands);
@@ -95,12 +75,12 @@ unixctl_help(struct unixctl_conn *conn, int argc OVS_UNUSED,
     for (i = 0; i < shash_count(&commands); i++) {
         const struct shash_node *node = nodes[i];
         const struct unixctl_command *command = node->data;
     for (i = 0; i < shash_count(&commands); i++) {
         const struct shash_node *node = nodes[i];
         const struct unixctl_command *command = node->data;
-        
+
         ds_put_format(&ds, "  %-23s %s\n", node->name, command->usage);
     }
     free(nodes);
 
         ds_put_format(&ds, "  %-23s %s\n", node->name, command->usage);
     }
     free(nodes);
 
-    unixctl_command_reply(conn, 214, ds_cstr(&ds));
+    unixctl_command_reply(conn, ds_cstr(&ds));
     ds_destroy(&ds);
 }
 
     ds_destroy(&ds);
 }
 
@@ -108,7 +88,7 @@ static void
 unixctl_version(struct unixctl_conn *conn, int argc OVS_UNUSED,
                 const char *argv[] OVS_UNUSED, void *aux OVS_UNUSED)
 {
 unixctl_version(struct unixctl_conn *conn, int argc OVS_UNUSED,
                 const char *argv[] OVS_UNUSED, void *aux OVS_UNUSED)
 {
-    unixctl_command_reply(conn, 200, get_program_version());
+    unixctl_command_reply(conn, get_program_version());
 }
 
 /* Registers a unixctl command with the given 'name'.  'usage' describes the
 }
 
 /* Registers a unixctl command with the given 'name'.  'usage' describes the
@@ -117,11 +97,11 @@ unixctl_version(struct unixctl_conn *conn, int argc OVS_UNUSED,
  *
  * 'cb' is called when the command is received.  It is passed the actual set of
  * arguments, as a text string, plus a copy of 'aux'.  Normally 'cb' should
  *
  * 'cb' is called when the command is received.  It is passed the actual set of
  * arguments, as a text string, plus a copy of 'aux'.  Normally 'cb' should
- * call unixctl_command_reply() before it returns, but if the command cannot be
- * handled immediately then it can defer the reply until later.  A given
- * connection can only process a single request at a time, so
- * unixctl_command_reply() must be called eventually to avoid blocking that
- * connection. */
+ * reply by calling unixctl_command_reply() or unixctl_command_reply_error()
+ * before it returns, but if the command cannot be handled immediately then it
+ * can defer the reply until later.  A given connection can only process a
+ * single request at a time, so a reply must be made eventually to avoid
+ * blocking that connection. */
 void
 unixctl_command_register(const char *name, const char *usage,
                          int min_args, int max_args,
 void
 unixctl_command_register(const char *name, const char *usage,
                          int min_args, int max_args,
@@ -145,57 +125,57 @@ unixctl_command_register(const char *name, const char *usage,
     shash_add(&commands, name, command);
 }
 
     shash_add(&commands, name, command);
 }
 
-static const char *
-translate_reply_code(int code)
+static void
+unixctl_command_reply__(struct unixctl_conn *conn,
+                        bool success, const char *body)
 {
 {
-    switch (code) {
-    case 200: return "OK";
-    case 201: return "Created";
-    case 202: return "Accepted";
-    case 204: return "No Content";
-    case 211: return "System Status";
-    case 214: return "Help";
-    case 400: return "Bad Request";
-    case 401: return "Unauthorized";
-    case 403: return "Forbidden";
-    case 404: return "Not Found";
-    case 500: return "Internal Server Error";
-    case 501: return "Invalid Argument";
-    case 503: return "Service Unavailable";
-    default: return "Unknown";
+    struct json *body_json;
+    struct jsonrpc_msg *reply;
+
+    COVERAGE_INC(unixctl_replied);
+    assert(conn->request_id);
+
+    if (!body) {
+        body = "";
     }
     }
+
+    if (body[0] && body[strlen(body) - 1] != '\n') {
+        body_json = json_string_create_nocopy(xasprintf("%s\n", body));
+    } else {
+        body_json = json_string_create(body);
+    }
+
+    if (success) {
+        reply = jsonrpc_create_reply(body_json, conn->request_id);
+    } else {
+        reply = jsonrpc_create_error(body_json, conn->request_id);
+    }
+
+    /* If jsonrpc_send() returns an error, the run loop will take care of the
+     * problem eventually. */
+    jsonrpc_send(conn->rpc, reply);
+    json_destroy(conn->request_id);
+    conn->request_id = NULL;
 }
 
 }
 
+/* Replies to the active unixctl connection 'conn'.  'result' is sent to the
+ * client indicating the command was processed successfully.  Only one call to
+ * unixctl_command_reply() or unixctl_command_reply_error() may be made per
+ * request. */
 void
 void
-unixctl_command_reply(struct unixctl_conn *conn,
-                      int code, const char *body)
+unixctl_command_reply(struct unixctl_conn *conn, const char *result)
 {
 {
-    struct ds *out = &conn->out;
+    unixctl_command_reply__(conn, true, result);
+}
 
 
-    COVERAGE_INC(unixctl_replied);
-    assert(conn->state == S_PROCESS);
-    conn->state = S_SEND;
-    conn->out_pos = 0;
-
-    ds_clear(out);
-    ds_put_format(out, "%03d %s\n", code, translate_reply_code(code));
-    if (body) {
-        const char *p;
-        for (p = body; *p != '\0'; ) {
-            size_t n = strcspn(p, "\n");
-
-            if (*p == '.') {
-                ds_put_char(out, '.');
-            }
-            ds_put_buffer(out, p, n);
-            ds_put_char(out, '\n');
-            p += n;
-            if (*p == '\n') {
-                p++;
-            }
-        }
-    }
-    ds_put_cstr(out, ".\n");
+/* Replies to the active unixctl connection 'conn'. 'error' is sent to the
+ * client indicating an error occured processing the command.  Only one call to
+ * unixctl_command_reply() or unixctl_command_reply_error() may be made per
+ * request. */
+void
+unixctl_command_reply_error(struct unixctl_conn *conn, const char *error)
+{
+    unixctl_command_reply__(conn, false, error);
 }
 
 /* Creates a unixctl server listening on 'path', which may be:
 }
 
 /* Creates a unixctl server listening on 'path', which may be:
@@ -223,229 +203,135 @@ int
 unixctl_server_create(const char *path, struct unixctl_server **serverp)
 {
     struct unixctl_server *server;
 unixctl_server_create(const char *path, struct unixctl_server **serverp)
 {
     struct unixctl_server *server;
+    struct pstream *listener;
+    char *punix_path;
     int error;
 
     int error;
 
+    *serverp = NULL;
     if (path && !strcmp(path, "none")) {
     if (path && !strcmp(path, "none")) {
-        *serverp = NULL;
         return 0;
     }
 
         return 0;
     }
 
-    unixctl_command_register("help", "", 0, 0, unixctl_help, NULL);
-    unixctl_command_register("version", "", 0, 0, unixctl_version, NULL);
-
-    server = xmalloc(sizeof *server);
-    list_init(&server->conns);
-
     if (path) {
     if (path) {
-        server->path = abs_file_name(ovs_rundir(), path);
+        char *abs_path = abs_file_name(ovs_rundir(), path);
+        punix_path = xasprintf("punix:%s", abs_path);
+        free(abs_path);
     } else {
     } else {
-        server->path = xasprintf("%s/%s.%ld.ctl", ovs_rundir(),
-                                 program_name, (long int) getpid());
+        punix_path = xasprintf("punix:%s/%s.%ld.ctl", ovs_rundir(),
+                               program_name, (long int) getpid());
     }
 
     }
 
-    server->fd = make_unix_socket(SOCK_STREAM, true, false, server->path,
-                                  NULL);
-    if (server->fd < 0) {
-        error = -server->fd;
-        ovs_error(error, "could not initialize control socket %s",
-                  server->path);
-        goto error;
-    }
+    error = pstream_open(punix_path, &listener);
+    free(punix_path);
+    punix_path = NULL;
 
 
-    if (chmod(server->path, S_IRUSR | S_IWUSR) < 0) {
-        error = errno;
-        ovs_error(error, "failed to chmod control socket %s", server->path);
-        goto error;
+    if (error) {
+        ovs_error(error, "could not initialize control socket %s", path);
+        return error;
     }
 
     }
 
-    if (listen(server->fd, 10) < 0) {
-        error = errno;
-        ovs_error(error, "Failed to listen on control socket %s",
-                  server->path);
-        goto error;
-    }
+    unixctl_command_register("help", "", 0, 0, unixctl_help, NULL);
+    unixctl_command_register("version", "", 0, 0, unixctl_version, NULL);
 
 
+    server = xmalloc(sizeof *server);
+    server->listener = listener;
+    list_init(&server->conns);
     *serverp = server;
     return 0;
     *serverp = server;
     return 0;
-
-error:
-    if (server->fd >= 0) {
-        close(server->fd);
-    }
-    free(server->path);
-    free(server);
-    *serverp = NULL;
-    return error;
 }
 
 static void
 }
 
 static void
-new_connection(struct unixctl_server *server, int fd)
-{
-    struct unixctl_conn *conn;
-
-    set_nonblocking(fd);
-
-    conn = xmalloc(sizeof *conn);
-    list_push_back(&server->conns, &conn->node);
-    conn->fd = fd;
-    conn->state = S_RECV;
-    ofpbuf_init(&conn->in, 128);
-    ds_init(&conn->out);
-    conn->out_pos = 0;
-}
-
-static int
-run_connection_output(struct unixctl_conn *conn)
+process_command(struct unixctl_conn *conn, struct jsonrpc_msg *request)
 {
 {
-    while (conn->out_pos < conn->out.length) {
-        size_t bytes_written;
-        int error;
-
-        error = write_fully(conn->fd, conn->out.string + conn->out_pos,
-                            conn->out.length - conn->out_pos, &bytes_written);
-        conn->out_pos += bytes_written;
-        if (error) {
-            return error;
-        }
-    }
-    conn->state = S_RECV;
-    return 0;
-}
+    char *error = NULL;
 
 
-static void
-process_command(struct unixctl_conn *conn, char *s)
-{
     struct unixctl_command *command;
     struct unixctl_command *command;
-    struct svec argv;
+    struct json_array *params;
 
     COVERAGE_INC(unixctl_received);
 
     COVERAGE_INC(unixctl_received);
-    conn->state = S_PROCESS;
-
-    svec_init(&argv);
-    svec_parse_words(&argv, s);
-    svec_terminate(&argv);
-
-    if (argv.n == 0) {
-        unixctl_command_reply(conn, 400, "missing command name in request");
+    conn->request_id = json_clone(request->id);
+
+    params = json_array(request->params);
+    command = shash_find_data(&commands, request->method);
+    if (!command) {
+        error = xasprintf("\"%s\" is not a valid command", request->method);
+    } else if (params->n < command->min_args) {
+        error = xasprintf("\"%s\" command requires at least %d arguments",
+                          request->method, command->min_args);
+    } else if (params->n > command->max_args) {
+        error = xasprintf("\"%s\" command takes at most %d arguments",
+                          request->method, command->max_args);
     } else {
     } else {
-        const char *name = argv.names[0];
-        char *error;
-
-        command = shash_find_data(&commands, name);
-        if (!command) {
-            error = xasprintf("\"%s\" is not a valid command", name);
-        } else if (argv.n - 1 < command->min_args) {
-            error = xasprintf("\"%s\" command requires at least %d arguments",
-                              name, command->min_args);
-        } else if (argv.n - 1 > command->max_args) {
-            error = xasprintf("\"%s\" command takes at most %d arguments",
-                              name, command->max_args);
-        } else {
-            error = NULL;
+        struct svec argv = SVEC_EMPTY_INITIALIZER;
+        int  i;
+
+        svec_add(&argv, request->method);
+        for (i = 0; i < params->n; i++) {
+            if (params->elems[i]->type != JSON_STRING) {
+                error = xasprintf("\"%s\" command has non-string argument",
+                                  request->method);
+                break;
+            }
+            svec_add(&argv, json_string(params->elems[i]));
+        }
+        svec_terminate(&argv);
+
+        if (!error) {
             command->cb(conn, argv.n, (const char **) argv.names,
                         command->aux);
         }
 
             command->cb(conn, argv.n, (const char **) argv.names,
                         command->aux);
         }
 
-        if (error) {
-            unixctl_command_reply(conn, 400, error);
-            free(error);
-        }
+        svec_destroy(&argv);
     }
 
     }
 
-    svec_destroy(&argv);
+    if (error) {
+        unixctl_command_reply_error(conn, error);
+        free(error);
+    }
 }
 
 static int
 }
 
 static int
-run_connection_input(struct unixctl_conn *conn)
+run_connection(struct unixctl_conn *conn)
 {
 {
-    for (;;) {
-        size_t bytes_read;
-        char *newline;
-        int error;
-
-        newline = memchr(conn->in.data, '\n', conn->in.size);
-        if (newline) {
-            char *command = conn->in.data;
-            size_t n = newline - command + 1;
+    int error, i;
 
 
-            if (n > 0 && newline[-1] == '\r') {
-                newline--;
-            }
-            *newline = '\0';
+    jsonrpc_run(conn->rpc);
+    error = jsonrpc_get_status(conn->rpc);
+    if (error || jsonrpc_get_backlog(conn->rpc)) {
+        return error;
+    }
 
 
-            process_command(conn, command);
+    for (i = 0; i < 10; i++) {
+        struct jsonrpc_msg *msg;
 
 
-            ofpbuf_pull(&conn->in, n);
-            if (!conn->in.size) {
-                ofpbuf_clear(&conn->in);
-            }
-            return 0;
+        if (error || conn->request_id) {
+            break;
         }
 
         }
 
-        ofpbuf_prealloc_tailroom(&conn->in, 128);
-        error = read_fully(conn->fd, ofpbuf_tail(&conn->in),
-                           ofpbuf_tailroom(&conn->in), &bytes_read);
-        conn->in.size += bytes_read;
-        if (conn->in.size > 65536) {
-            VLOG_WARN_RL(&rl, "excess command length, killing connection");
-            return EPROTO;
-        }
-        if (error) {
-            if (error == EAGAIN || error == EWOULDBLOCK) {
-                if (!bytes_read) {
-                    return EAGAIN;
-                }
+        jsonrpc_recv(conn->rpc, &msg);
+        if (msg) {
+            if (msg->type == JSONRPC_REQUEST) {
+                process_command(conn, msg);
             } else {
             } else {
-                if (error != EOF || conn->in.size != 0) {
-                    VLOG_WARN_RL(&rl, "read failed: %s",
-                                 (error == EOF
-                                  ? "connection dropped mid-command"
-                                  : strerror(error)));
-                }
-                return error;
+                VLOG_WARN_RL(&rl, "%s: received unexpected %s message",
+                             jsonrpc_get_name(conn->rpc),
+                             jsonrpc_msg_type_to_string(msg->type));
+                error = EINVAL;
             }
             }
+            jsonrpc_msg_destroy(msg);
         }
         }
+        error = error ? error : jsonrpc_get_status(conn->rpc);
     }
     }
-}
-
-static int
-run_connection(struct unixctl_conn *conn)
-{
-    int old_state;
-    do {
-        int error;
 
 
-        old_state = conn->state;
-        switch (conn->state) {
-        case S_RECV:
-            error = run_connection_input(conn);
-            break;
-
-        case S_PROCESS:
-            error = 0;
-            break;
-
-        case S_SEND:
-            error = run_connection_output(conn);
-            break;
-
-        default:
-            NOT_REACHED();
-        }
-        if (error) {
-            return error;
-        }
-    } while (conn->state != old_state);
-    return 0;
+    return error;
 }
 
 static void
 kill_connection(struct unixctl_conn *conn)
 {
     list_remove(&conn->node);
 }
 
 static void
 kill_connection(struct unixctl_conn *conn)
 {
     list_remove(&conn->node);
-    ofpbuf_uninit(&conn->in);
-    ds_destroy(&conn->out);
-    close(conn->fd);
+    jsonrpc_close(conn->rpc);
+    json_destroy(conn->request_id);
     free(conn);
 }
 
     free(conn);
 }
 
@@ -460,14 +346,21 @@ unixctl_server_run(struct unixctl_server *server)
     }
 
     for (i = 0; i < 10; i++) {
     }
 
     for (i = 0; i < 10; i++) {
-        int fd = accept(server->fd, NULL, NULL);
-        if (fd < 0) {
-            if (errno != EAGAIN && errno != EWOULDBLOCK) {
-                VLOG_WARN_RL(&rl, "accept failed: %s", strerror(errno));
-            }
+        struct stream *stream;
+        int error;
+
+        error = pstream_accept(server->listener, &stream);
+        if (!error) {
+            struct unixctl_conn *conn = xzalloc(sizeof *conn);
+            list_push_back(&server->conns, &conn->node);
+            conn->rpc = jsonrpc_open(stream);
+        } else if (error == EAGAIN) {
             break;
             break;
+        } else {
+            VLOG_WARN_RL(&rl, "%s: accept failed: %s",
+                         pstream_get_name(server->listener),
+                         strerror(error));
         }
         }
-        new_connection(server, fd);
     }
 
     LIST_FOR_EACH_SAFE (conn, next, node, &server->conns) {
     }
 
     LIST_FOR_EACH_SAFE (conn, next, node, &server->conns) {
@@ -487,12 +380,11 @@ unixctl_server_wait(struct unixctl_server *server)
         return;
     }
 
         return;
     }
 
-    poll_fd_wait(server->fd, POLLIN);
+    pstream_wait(server->listener);
     LIST_FOR_EACH (conn, node, &server->conns) {
     LIST_FOR_EACH (conn, node, &server->conns) {
-        if (conn->state == S_RECV) {
-            poll_fd_wait(conn->fd, POLLIN);
-        } else if (conn->state == S_SEND) {
-            poll_fd_wait(conn->fd, POLLOUT);
+        jsonrpc_wait(conn->rpc);
+        if (!jsonrpc_get_backlog(conn->rpc)) {
+            jsonrpc_recv_wait(conn->rpc);
         }
     }
 }
         }
     }
 }
@@ -508,151 +400,92 @@ unixctl_server_destroy(struct unixctl_server *server)
             kill_connection(conn);
         }
 
             kill_connection(conn);
         }
 
-        close(server->fd);
-        fatal_signal_unlink_file_now(server->path);
-        free(server->path);
+        pstream_close(server->listener);
         free(server);
     }
 }
 \f
         free(server);
     }
 }
 \f
-/* Connects to a Vlog server socket.  'path' should be the name of a Vlog
- * server socket.  If it does not start with '/', it will be prefixed with
- * the rundir (e.g. /usr/local/var/run/openvswitch).
+/* Connects to a unixctl server socket.  'path' should be the name of a unixctl
+ * server socket.  If it does not start with '/', it will be prefixed with the
+ * rundir (e.g. /usr/local/var/run/openvswitch).
  *
  * Returns 0 if successful, otherwise a positive errno value.  If successful,
  *
  * Returns 0 if successful, otherwise a positive errno value.  If successful,
- * sets '*clientp' to the new unixctl_client, otherwise to NULL. */
+ * sets '*client' to the new jsonrpc, otherwise to NULL. */
 int
 int
-unixctl_client_create(const char *path, struct unixctl_client **clientp)
+unixctl_client_create(const char *path, struct jsonrpc **client)
 {
 {
-    static int counter;
-    struct unixctl_client *client;
+    char *abs_path, *unix_path;
+    struct stream *stream;
     int error;
     int error;
-    int fd = -1;
-
-    /* Determine location. */
-    client = xmalloc(sizeof *client);
-    client->connect_path = abs_file_name(ovs_rundir(), path);
-    client->bind_path = xasprintf("/tmp/vlog.%ld.%d",
-                                  (long int) getpid(), counter++);
-
-    /* Open socket. */
-    fd = make_unix_socket(SOCK_STREAM, false, false,
-                          client->bind_path, client->connect_path);
-    if (fd < 0) {
-        error = -fd;
-        goto error;
-    }
 
 
-    /* Bind socket to stream. */
-    client->stream = fdopen(fd, "r+");
-    if (!client->stream) {
-        error = errno;
-        VLOG_WARN("%s: fdopen failed (%s)",
-                  client->connect_path, strerror(error));
-        goto error;
-    }
-    *clientp = client;
-    return 0;
+    *client = NULL;
 
 
-error:
-    if (fd >= 0) {
-        close(fd);
-    }
-    free(client->connect_path);
-    free(client->bind_path);
-    free(client);
-    *clientp = NULL;
-    return error;
-}
+    abs_path = abs_file_name(ovs_rundir(), path);
+    unix_path = xasprintf("unix:%s", abs_path);
+    error = stream_open_block(stream_open(unix_path, &stream), &stream);
+    free(unix_path);
+    free(abs_path);
 
 
-/* Destroys 'client'. */
-void
-unixctl_client_destroy(struct unixctl_client *client)
-{
-    if (client) {
-        fatal_signal_unlink_file_now(client->bind_path);
-        free(client->bind_path);
-        free(client->connect_path);
-        fclose(client->stream);
-        free(client);
+    if (error) {
+        VLOG_WARN("failed to connect to %s", path);
+        return error;
     }
     }
+
+    *client = jsonrpc_open(stream);
+    return 0;
 }
 
 }
 
-/* Sends 'request' to the server socket and waits for a reply.  Returns 0 if
- * successful, otherwise to a positive errno value.  If successful, sets
- * '*reply' to the reply, which the caller must free, otherwise to NULL. */
+/* Executes 'command' on the server with an argument vector 'argv' containing
+ * 'argc' elements.  If successfully communicated with the server, returns 0
+ * and sets '*result', or '*err' (not both) to the result or error the server
+ * returned.  Otherwise, sets '*result' and '*err' to NULL and returns a
+ * positive errno value.  The caller is responsible for freeing '*result' or
+ * '*err' if not NULL. */
 int
 int
-unixctl_client_transact(struct unixctl_client *client,
-                        const char *request,
-                        int *reply_code, char **reply_body)
+unixctl_client_transact(struct jsonrpc *client, const char *command, int argc,
+                        char *argv[], char **result, char **err)
 {
 {
-    struct ds line = DS_EMPTY_INITIALIZER;
-    struct ds reply = DS_EMPTY_INITIALIZER;
-    int error;
+    struct jsonrpc_msg *request, *reply;
+    struct json **json_args, *params;
+    int error, i;
 
 
-    /* Send 'request' to server.  Add a new-line if 'request' didn't end in
-     * one. */
-    fputs(request, client->stream);
-    if (request[0] == '\0' || request[strlen(request) - 1] != '\n') {
-        putc('\n', client->stream);
+    *result = NULL;
+    *err = NULL;
+
+    json_args = xmalloc(argc * sizeof *json_args);
+    for (i = 0; i < argc; i++) {
+        json_args[i] = json_string_create(argv[i]);
     }
     }
-    if (ferror(client->stream)) {
-        VLOG_WARN("error sending request to %s: %s",
-                  client->connect_path, strerror(errno));
-        return errno;
+    params = json_array_create(json_args, argc);
+    request = jsonrpc_create_request(command, params, NULL);
+
+    error = jsonrpc_transact_block(client, request, &reply);
+    if (error) {
+        VLOG_WARN("error communicating with %s: %s", jsonrpc_get_name(client),
+                  strerror(error));
+        return error;
     }
 
     }
 
-    /* Wait for response. */
-    *reply_code = -1;
-    for (;;) {
-        const char *s;
-
-        error = ds_get_line(&line, client->stream);
-        if (error) {
-            VLOG_WARN("error reading reply from %s: %s",
-                      client->connect_path,
-                      ovs_retval_to_string(error));
-            goto error;
+    if (reply->error) {
+        if (reply->error->type == JSON_STRING) {
+            *err = xstrdup(json_string(reply->error));
+        } else {
+            VLOG_WARN("%s: unexpected error type in JSON RPC reply: %s",
+                      jsonrpc_get_name(client),
+                      json_type_to_string(reply->error->type));
+            error = EINVAL;
         }
         }
-
-        s = ds_cstr(&line);
-        if (*reply_code == -1) {
-            if (!isdigit((unsigned char)s[0])
-                    || !isdigit((unsigned char)s[1])
-                    || !isdigit((unsigned char)s[2])) {
-                VLOG_WARN("reply from %s does not start with 3-digit code",
-                          client->connect_path);
-                error = EPROTO;
-                goto error;
-            }
-            sscanf(s, "%3d", reply_code);
+    } else if (reply->result) {
+        if (reply->result->type == JSON_STRING) {
+            *result = xstrdup(json_string(reply->result));
         } else {
         } else {
-            if (s[0] == '.') {
-                if (s[1] == '\0') {
-                    break;
-                }
-                s++;
-            }
-            ds_put_cstr(&reply, s);
-            ds_put_char(&reply, '\n');
+            VLOG_WARN("%s: unexpected result type in JSON rpc reply: %s",
+                      jsonrpc_get_name(client),
+                      json_type_to_string(reply->result->type));
+            error = EINVAL;
         }
     }
         }
     }
-    *reply_body = ds_cstr(&reply);
-    ds_destroy(&line);
-    return 0;
 
 
-error:
-    ds_destroy(&line);
-    ds_destroy(&reply);
-    *reply_code = 0;
-    *reply_body = NULL;
-    return error == EOF ? EPROTO : error;
-}
-
-/* Returns the path of the server socket to which 'client' is connected.  The
- * caller must not modify or free the returned string. */
-const char *
-unixctl_client_target(const struct unixctl_client *client)
-{
-    return client->connect_path;
+    jsonrpc_msg_destroy(reply);
+    return error;
 }
 }
index 8eb190b0b01377ab1753a58c7eec35adff5b1eae..13a8096e80ee55e606f560b7cbfcbd1130f66bc7 100644 (file)
@@ -29,13 +29,12 @@ void unixctl_server_wait(struct unixctl_server *);
 void unixctl_server_destroy(struct unixctl_server *);
 
 /* Client for Unix domain socket control connection. */
 void unixctl_server_destroy(struct unixctl_server *);
 
 /* Client for Unix domain socket control connection. */
-struct unixctl_client;
-int unixctl_client_create(const char *path, struct unixctl_client **);
-void unixctl_client_destroy(struct unixctl_client *);
-int unixctl_client_transact(struct unixctl_client *,
-                            const char *request,
-                            int *reply_code, char **reply_body);
-const char *unixctl_client_target(const struct unixctl_client *);
+struct jsonrpc;
+int unixctl_client_create(const char *path, struct jsonrpc **client);
+int unixctl_client_transact(struct jsonrpc *client,
+                            const char *command,
+                            int argc, char *argv[],
+                            char **result, char **error);
 
 /* Command registration. */
 struct unixctl_conn;
 
 /* Command registration. */
 struct unixctl_conn;
@@ -44,8 +43,8 @@ typedef void unixctl_cb_func(struct unixctl_conn *,
 void unixctl_command_register(const char *name, const char *usage,
                               int min_args, int max_args,
                               unixctl_cb_func *cb, void *aux);
 void unixctl_command_register(const char *name, const char *usage,
                               int min_args, int max_args,
                               unixctl_cb_func *cb, void *aux);
-void unixctl_command_reply(struct unixctl_conn *, int code,
-                           const char *body);
+void unixctl_command_reply_error(struct unixctl_conn *, const char *error);
+void unixctl_command_reply(struct unixctl_conn *, const char *body);
 
 #ifdef  __cplusplus
 }
 
 #ifdef  __cplusplus
 }
index 07ba5e029092456abd59371e27e945fdb25816b4..4c97ef40b39bfdc613513cce37befb43915475bf 100644 (file)
@@ -439,12 +439,12 @@ vlog_unixctl_set(struct unixctl_conn *conn, int argc, const char *argv[],
     for (i = 1; i < argc; i++) {
         char *msg = vlog_set_levels_from_string(argv[i]);
         if (msg) {
     for (i = 1; i < argc; i++) {
         char *msg = vlog_set_levels_from_string(argv[i]);
         if (msg) {
-            unixctl_command_reply(conn, 501, msg);
+            unixctl_command_reply_error(conn, msg);
             free(msg);
             return;
         }
     }
             free(msg);
             return;
         }
     }
-    unixctl_command_reply(conn, 202, NULL);
+    unixctl_command_reply(conn, NULL);
 }
 
 static void
 }
 
 static void
@@ -452,7 +452,7 @@ vlog_unixctl_list(struct unixctl_conn *conn, int argc OVS_UNUSED,
                   const char *argv[] OVS_UNUSED, void *aux OVS_UNUSED)
 {
     char *msg = vlog_get_levels();
                   const char *argv[] OVS_UNUSED, void *aux OVS_UNUSED)
 {
     char *msg = vlog_get_levels();
-    unixctl_command_reply(conn, 200, msg);
+    unixctl_command_reply(conn, msg);
     free(msg);
 }
 
     free(msg);
 }
 
@@ -463,12 +463,12 @@ vlog_unixctl_reopen(struct unixctl_conn *conn, int argc OVS_UNUSED,
     if (log_file_name) {
         int error = vlog_reopen_log_file();
         if (error) {
     if (log_file_name) {
         int error = vlog_reopen_log_file();
         if (error) {
-            unixctl_command_reply(conn, 503, strerror(errno));
+            unixctl_command_reply_error(conn, strerror(errno));
         } else {
         } else {
-            unixctl_command_reply(conn, 202, NULL);
+            unixctl_command_reply(conn, NULL);
         }
     } else {
         }
     } else {
-        unixctl_command_reply(conn, 403, "Logging to file not configured");
+        unixctl_command_reply_error(conn, "Logging to file not configured");
     }
 }
 
     }
 }
 
index feb1342eb22240df1f5d56ddf772312728e4926a..d8d1e38430fb4e4ca6663c925b2efa7cb9dbf89a 100644 (file)
@@ -5898,7 +5898,7 @@ ofproto_unixctl_fdb_flush(struct unixctl_conn *conn, int argc,
     if (argc > 1) {
         ofproto = ofproto_dpif_lookup(argv[1]);
         if (!ofproto) {
     if (argc > 1) {
         ofproto = ofproto_dpif_lookup(argv[1]);
         if (!ofproto) {
-            unixctl_command_reply(conn, 501, "no such bridge");
+            unixctl_command_reply_error(conn, "no such bridge");
             return;
         }
         mac_learning_flush(ofproto->ml, &ofproto->revalidate_set);
             return;
         }
         mac_learning_flush(ofproto->ml, &ofproto->revalidate_set);
@@ -5908,7 +5908,7 @@ ofproto_unixctl_fdb_flush(struct unixctl_conn *conn, int argc,
         }
     }
 
         }
     }
 
-    unixctl_command_reply(conn, 200, "table successfully flushed");
+    unixctl_command_reply(conn, "table successfully flushed");
 }
 
 static void
 }
 
 static void
@@ -5921,7 +5921,7 @@ ofproto_unixctl_fdb_show(struct unixctl_conn *conn, int argc OVS_UNUSED,
 
     ofproto = ofproto_dpif_lookup(argv[1]);
     if (!ofproto) {
 
     ofproto = ofproto_dpif_lookup(argv[1]);
     if (!ofproto) {
-        unixctl_command_reply(conn, 501, "no such bridge");
+        unixctl_command_reply_error(conn, "no such bridge");
         return;
     }
 
         return;
     }
 
@@ -5933,7 +5933,7 @@ ofproto_unixctl_fdb_show(struct unixctl_conn *conn, int argc OVS_UNUSED,
                       e->vlan, ETH_ADDR_ARGS(e->mac),
                       mac_entry_age(ofproto->ml, e));
     }
                       e->vlan, ETH_ADDR_ARGS(e->mac),
                       mac_entry_age(ofproto->ml, e));
     }
-    unixctl_command_reply(conn, 200, ds_cstr(&ds));
+    unixctl_command_reply(conn, ds_cstr(&ds));
     ds_destroy(&ds);
 }
 
     ds_destroy(&ds);
 }
 
@@ -6038,8 +6038,8 @@ ofproto_unixctl_trace(struct unixctl_conn *conn, int argc, const char *argv[],
 
     ofproto = ofproto_dpif_lookup(dpname);
     if (!ofproto) {
 
     ofproto = ofproto_dpif_lookup(dpname);
     if (!ofproto) {
-        unixctl_command_reply(conn, 501, "Unknown ofproto (use ofproto/list "
-                              "for help)");
+        unixctl_command_reply_error(conn, "Unknown ofproto (use ofproto/list "
+                                    "for help)");
         goto exit;
     }
     if (argc == 3 || (argc == 4 && !strcmp(argv[3], "-generate"))) {
         goto exit;
     }
     if (argc == 3 || (argc == 4 && !strcmp(argv[3], "-generate"))) {
@@ -6052,7 +6052,7 @@ ofproto_unixctl_trace(struct unixctl_conn *conn, int argc, const char *argv[],
         ofpbuf_init(&odp_key, 0);
         error = odp_flow_key_from_string(flow_s, NULL, &odp_key);
         if (error) {
         ofpbuf_init(&odp_key, 0);
         error = odp_flow_key_from_string(flow_s, NULL, &odp_key);
         if (error) {
-            unixctl_command_reply(conn, 501, "Bad flow syntax");
+            unixctl_command_reply_error(conn, "Bad flow syntax");
             goto exit;
         }
 
             goto exit;
         }
 
@@ -6061,7 +6061,7 @@ ofproto_unixctl_trace(struct unixctl_conn *conn, int argc, const char *argv[],
                                               odp_key.size, &flow,
                                               &initial_tci, NULL);
         if (error == ODP_FIT_ERROR) {
                                               odp_key.size, &flow,
                                               &initial_tci, NULL);
         if (error == ODP_FIT_ERROR) {
-            unixctl_command_reply(conn, 501, "Invalid flow");
+            unixctl_command_reply_error(conn, "Invalid flow");
             goto exit;
         }
 
             goto exit;
         }
 
@@ -6083,7 +6083,7 @@ ofproto_unixctl_trace(struct unixctl_conn *conn, int argc, const char *argv[],
 
         msg = eth_from_hex(packet_s, &packet);
         if (msg) {
 
         msg = eth_from_hex(packet_s, &packet);
         if (msg) {
-            unixctl_command_reply(conn, 501, msg);
+            unixctl_command_reply_error(conn, msg);
             goto exit;
         }
 
             goto exit;
         }
 
@@ -6095,7 +6095,7 @@ ofproto_unixctl_trace(struct unixctl_conn *conn, int argc, const char *argv[],
         flow_extract(packet, priority, tun_id, in_port, &flow);
         initial_tci = flow.vlan_tci;
     } else {
         flow_extract(packet, priority, tun_id, in_port, &flow);
         initial_tci = flow.vlan_tci;
     } else {
-        unixctl_command_reply(conn, 501, "Bad command syntax");
+        unixctl_command_reply_error(conn, "Bad command syntax");
         goto exit;
     }
 
         goto exit;
     }
 
@@ -6135,7 +6135,7 @@ ofproto_unixctl_trace(struct unixctl_conn *conn, int argc, const char *argv[],
         }
     }
 
         }
     }
 
-    unixctl_command_reply(conn, 200, ds_cstr(&result));
+    unixctl_command_reply(conn, ds_cstr(&result));
 
 exit:
     ds_destroy(&result);
 
 exit:
     ds_destroy(&result);
@@ -6148,7 +6148,7 @@ ofproto_dpif_clog(struct unixctl_conn *conn OVS_UNUSED, int argc OVS_UNUSED,
                   const char *argv[] OVS_UNUSED, void *aux OVS_UNUSED)
 {
     clogged = true;
                   const char *argv[] OVS_UNUSED, void *aux OVS_UNUSED)
 {
     clogged = true;
-    unixctl_command_reply(conn, 200, NULL);
+    unixctl_command_reply(conn, NULL);
 }
 
 static void
 }
 
 static void
@@ -6156,7 +6156,7 @@ ofproto_dpif_unclog(struct unixctl_conn *conn OVS_UNUSED, int argc OVS_UNUSED,
                     const char *argv[] OVS_UNUSED, void *aux OVS_UNUSED)
 {
     clogged = false;
                     const char *argv[] OVS_UNUSED, void *aux OVS_UNUSED)
 {
     clogged = false;
-    unixctl_command_reply(conn, 200, NULL);
+    unixctl_command_reply(conn, NULL);
 }
 
 /* Runs a self-check of flow translations in 'ofproto'.  Appends a message to
 }
 
 /* Runs a self-check of flow translations in 'ofproto'.  Appends a message to
@@ -6195,8 +6195,8 @@ ofproto_dpif_self_check(struct unixctl_conn *conn,
     if (argc > 1) {
         ofproto = ofproto_dpif_lookup(argv[1]);
         if (!ofproto) {
     if (argc > 1) {
         ofproto = ofproto_dpif_lookup(argv[1]);
         if (!ofproto) {
-            unixctl_command_reply(conn, 501, "Unknown ofproto (use "
-                                  "ofproto/list for help)");
+            unixctl_command_reply_error(conn, "Unknown ofproto (use "
+                                        "ofproto/list for help)");
             return;
         }
         ofproto_dpif_self_check__(ofproto, &reply);
             return;
         }
         ofproto_dpif_self_check__(ofproto, &reply);
@@ -6206,7 +6206,7 @@ ofproto_dpif_self_check(struct unixctl_conn *conn,
         }
     }
 
         }
     }
 
-    unixctl_command_reply(conn, 200, ds_cstr(&reply));
+    unixctl_command_reply(conn, ds_cstr(&reply));
     ds_destroy(&reply);
 }
 
     ds_destroy(&reply);
 }
 
index 08a18a465b7f82e7b8cc7240f1ea6b2d594fcf97..ce36d95691c786931f4fa19ce2880a99d5937208 100644 (file)
@@ -3983,7 +3983,7 @@ ofproto_unixctl_list(struct unixctl_conn *conn, int argc OVS_UNUSED,
     HMAP_FOR_EACH (ofproto, hmap_node, &all_ofprotos) {
         ds_put_format(&results, "%s\n", ofproto->name);
     }
     HMAP_FOR_EACH (ofproto, hmap_node, &all_ofprotos) {
         ds_put_format(&results, "%s\n", ofproto->name);
     }
-    unixctl_command_reply(conn, 200, ds_cstr(&results));
+    unixctl_command_reply(conn, ds_cstr(&results));
     ds_destroy(&results);
 }
 
     ds_destroy(&results);
 }
 
index 3840ffce894f02f3a12639e32ebeb15a56d56252..d2e3f9ad920974ee6cec50a30182f21330d85e3f 100644 (file)
@@ -36,7 +36,7 @@ MAN_FRAGMENTS += \
 # ovsdb-tool
 bin_PROGRAMS += ovsdb/ovsdb-tool
 ovsdb_ovsdb_tool_SOURCES = ovsdb/ovsdb-tool.c
 # ovsdb-tool
 bin_PROGRAMS += ovsdb/ovsdb-tool
 ovsdb_ovsdb_tool_SOURCES = ovsdb/ovsdb-tool.c
-ovsdb_ovsdb_tool_LDADD = ovsdb/libovsdb.a lib/libopenvswitch.a
+ovsdb_ovsdb_tool_LDADD = ovsdb/libovsdb.a lib/libopenvswitch.a $(SSL_LIBS)
 # ovsdb-tool.1
 man_MANS += ovsdb/ovsdb-tool.1
 DISTCLEANFILES += ovsdb/ovsdb-tool.1
 # ovsdb-tool.1
 man_MANS += ovsdb/ovsdb-tool.1
 DISTCLEANFILES += ovsdb/ovsdb-tool.1
index 41238fbb80d47e48006b9062a7850f7ddfc43e2c..9e0636e9c0136f69cf63076f54164a1909b5075a 100644 (file)
@@ -618,7 +618,7 @@ ovsdb_server_exit(struct unixctl_conn *conn, int argc OVS_UNUSED,
 {
     bool *exiting = exiting_;
     *exiting = true;
 {
     bool *exiting = exiting_;
     *exiting = true;
-    unixctl_command_reply(conn, 200, NULL);
+    unixctl_command_reply(conn, NULL);
 }
 
 static void
 }
 
 static void
@@ -631,11 +631,11 @@ ovsdb_server_compact(struct unixctl_conn *conn, int argc OVS_UNUSED,
     VLOG_INFO("compacting database by user request");
     error = ovsdb_file_compact(file);
     if (!error) {
     VLOG_INFO("compacting database by user request");
     error = ovsdb_file_compact(file);
     if (!error) {
-        unixctl_command_reply(conn, 200, NULL);
+        unixctl_command_reply(conn, NULL);
     } else {
         char *s = ovsdb_error_to_string(error);
         ovsdb_error_destroy(error);
     } else {
         char *s = ovsdb_error_to_string(error);
         ovsdb_error_destroy(error);
-        unixctl_command_reply(conn, 503, s);
+        unixctl_command_reply_error(conn, s);
         free(s);
     }
 }
         free(s);
     }
 }
@@ -649,7 +649,7 @@ ovsdb_server_reconnect(struct unixctl_conn *conn, int argc OVS_UNUSED,
     struct ovsdb_jsonrpc_server *jsonrpc = jsonrpc_;
 
     ovsdb_jsonrpc_server_reconnect(jsonrpc);
     struct ovsdb_jsonrpc_server *jsonrpc = jsonrpc_;
 
     ovsdb_jsonrpc_server_reconnect(jsonrpc);
-    unixctl_command_reply(conn, 200, NULL);
+    unixctl_command_reply(conn, NULL);
 }
 
 static void
 }
 
 static void
index 28b2749a3711f2c664ed8bc7fbcf9c0a80aaee83..b133467c9613ab4b34d813e373d686ebfde71795 100644 (file)
@@ -203,27 +203,27 @@ $(srcdir)/package.m4: $(top_srcdir)/configure.ac
 
 noinst_PROGRAMS += tests/test-aes128
 tests_test_aes128_SOURCES = tests/test-aes128.c
 
 noinst_PROGRAMS += tests/test-aes128
 tests_test_aes128_SOURCES = tests/test-aes128.c
-tests_test_aes128_LDADD = lib/libopenvswitch.a
+tests_test_aes128_LDADD = lib/libopenvswitch.a $(SSL_LIBS)
 
 noinst_PROGRAMS += tests/test-bundle
 tests_test_bundle_SOURCES = tests/test-bundle.c
 
 noinst_PROGRAMS += tests/test-bundle
 tests_test_bundle_SOURCES = tests/test-bundle.c
-tests_test_bundle_LDADD = lib/libopenvswitch.a
+tests_test_bundle_LDADD = lib/libopenvswitch.a $(SSL_LIBS)
 
 noinst_PROGRAMS += tests/test-classifier
 tests_test_classifier_SOURCES = tests/test-classifier.c
 
 noinst_PROGRAMS += tests/test-classifier
 tests_test_classifier_SOURCES = tests/test-classifier.c
-tests_test_classifier_LDADD = lib/libopenvswitch.a
+tests_test_classifier_LDADD = lib/libopenvswitch.a $(SSL_LIBS)
 
 noinst_PROGRAMS += tests/test-csum
 tests_test_csum_SOURCES = tests/test-csum.c
 
 noinst_PROGRAMS += tests/test-csum
 tests_test_csum_SOURCES = tests/test-csum.c
-tests_test_csum_LDADD = lib/libopenvswitch.a
+tests_test_csum_LDADD = lib/libopenvswitch.a $(SSL_LIBS)
 
 noinst_PROGRAMS += tests/test-file_name
 tests_test_file_name_SOURCES = tests/test-file_name.c
 
 noinst_PROGRAMS += tests/test-file_name
 tests_test_file_name_SOURCES = tests/test-file_name.c
-tests_test_file_name_LDADD = lib/libopenvswitch.a
+tests_test_file_name_LDADD = lib/libopenvswitch.a $(SSL_LIBS)
 
 noinst_PROGRAMS += tests/test-flows
 tests_test_flows_SOURCES = tests/test-flows.c
 
 noinst_PROGRAMS += tests/test-flows
 tests_test_flows_SOURCES = tests/test-flows.c
-tests_test_flows_LDADD = lib/libopenvswitch.a
+tests_test_flows_LDADD = lib/libopenvswitch.a $(SSL_LIBS)
 dist_check_SCRIPTS = tests/flowgen.pl
 
 noinst_PROGRAMS += tests/test-hash
 dist_check_SCRIPTS = tests/flowgen.pl
 
 noinst_PROGRAMS += tests/test-hash
@@ -232,15 +232,15 @@ tests_test_hash_LDADD = lib/libopenvswitch.a
 
 noinst_PROGRAMS += tests/test-heap
 tests_test_heap_SOURCES = tests/test-heap.c
 
 noinst_PROGRAMS += tests/test-heap
 tests_test_heap_SOURCES = tests/test-heap.c
-tests_test_heap_LDADD = lib/libopenvswitch.a
+tests_test_heap_LDADD = lib/libopenvswitch.a $(SSL_LIBS)
 
 noinst_PROGRAMS += tests/test-hmap
 tests_test_hmap_SOURCES = tests/test-hmap.c
 
 noinst_PROGRAMS += tests/test-hmap
 tests_test_hmap_SOURCES = tests/test-hmap.c
-tests_test_hmap_LDADD = lib/libopenvswitch.a
+tests_test_hmap_LDADD = lib/libopenvswitch.a $(SSL_LIBS)
 
 noinst_PROGRAMS += tests/test-json
 tests_test_json_SOURCES = tests/test-json.c
 
 noinst_PROGRAMS += tests/test-json
 tests_test_json_SOURCES = tests/test-json.c
-tests_test_json_LDADD = lib/libopenvswitch.a
+tests_test_json_LDADD = lib/libopenvswitch.a $(SSL_LIBS)
 
 noinst_PROGRAMS += tests/test-jsonrpc
 tests_test_jsonrpc_SOURCES = tests/test-jsonrpc.c
 
 noinst_PROGRAMS += tests/test-jsonrpc
 tests_test_jsonrpc_SOURCES = tests/test-jsonrpc.c
@@ -252,35 +252,35 @@ tests_test_list_LDADD = lib/libopenvswitch.a
 
 noinst_PROGRAMS += tests/test-lockfile
 tests_test_lockfile_SOURCES = tests/test-lockfile.c
 
 noinst_PROGRAMS += tests/test-lockfile
 tests_test_lockfile_SOURCES = tests/test-lockfile.c
-tests_test_lockfile_LDADD = lib/libopenvswitch.a
+tests_test_lockfile_LDADD = lib/libopenvswitch.a $(SSL_LIBS)
 
 noinst_PROGRAMS += tests/test-multipath
 tests_test_multipath_SOURCES = tests/test-multipath.c
 
 noinst_PROGRAMS += tests/test-multipath
 tests_test_multipath_SOURCES = tests/test-multipath.c
-tests_test_multipath_LDADD = lib/libopenvswitch.a
+tests_test_multipath_LDADD = lib/libopenvswitch.a $(SSL_LIBS)
 
 noinst_PROGRAMS += tests/test-packets
 tests_test_packets_SOURCES = tests/test-packets.c
 
 noinst_PROGRAMS += tests/test-packets
 tests_test_packets_SOURCES = tests/test-packets.c
-tests_test_packets_LDADD = lib/libopenvswitch.a
+tests_test_packets_LDADD = lib/libopenvswitch.a $(SSL_LIBS)
 
 noinst_PROGRAMS += tests/test-random
 tests_test_random_SOURCES = tests/test-random.c
 
 noinst_PROGRAMS += tests/test-random
 tests_test_random_SOURCES = tests/test-random.c
-tests_test_random_LDADD = lib/libopenvswitch.a
+tests_test_random_LDADD = lib/libopenvswitch.a $(SSL_LIBS)
 
 noinst_PROGRAMS += tests/test-stp
 tests_test_stp_SOURCES = tests/test-stp.c
 
 noinst_PROGRAMS += tests/test-stp
 tests_test_stp_SOURCES = tests/test-stp.c
-tests_test_stp_LDADD = lib/libopenvswitch.a
+tests_test_stp_LDADD = lib/libopenvswitch.a $(SSL_LIBS)
 
 noinst_PROGRAMS += tests/test-netflow
 tests_test_netflow_SOURCES = tests/test-netflow.c
 
 noinst_PROGRAMS += tests/test-netflow
 tests_test_netflow_SOURCES = tests/test-netflow.c
-tests_test_netflow_LDADD = lib/libopenvswitch.a
+tests_test_netflow_LDADD = lib/libopenvswitch.a $(SSL_LIBS)
 
 noinst_PROGRAMS += tests/test-unix-socket
 tests_test_unix_socket_SOURCES = tests/test-unix-socket.c
 
 noinst_PROGRAMS += tests/test-unix-socket
 tests_test_unix_socket_SOURCES = tests/test-unix-socket.c
-tests_test_unix_socket_LDADD = lib/libopenvswitch.a
+tests_test_unix_socket_LDADD = lib/libopenvswitch.a $(SSL_LIBS)
 
 noinst_PROGRAMS += tests/test-odp
 tests_test_odp_SOURCES = tests/test-odp.c
 
 noinst_PROGRAMS += tests/test-odp
 tests_test_odp_SOURCES = tests/test-odp.c
-tests_test_odp_LDADD = lib/libopenvswitch.a
+tests_test_odp_LDADD = lib/libopenvswitch.a $(SSL_LIBS)
 
 noinst_PROGRAMS += tests/test-ovsdb
 tests_test_ovsdb_SOURCES = \
 
 noinst_PROGRAMS += tests/test-ovsdb
 tests_test_ovsdb_SOURCES = \
@@ -302,15 +302,15 @@ tests/idltest.c: tests/idltest.h
 
 noinst_PROGRAMS += tests/test-reconnect
 tests_test_reconnect_SOURCES = tests/test-reconnect.c
 
 noinst_PROGRAMS += tests/test-reconnect
 tests_test_reconnect_SOURCES = tests/test-reconnect.c
-tests_test_reconnect_LDADD = lib/libopenvswitch.a
+tests_test_reconnect_LDADD = lib/libopenvswitch.a $(SSL_LIBS)
 
 noinst_PROGRAMS += tests/test-sha1
 tests_test_sha1_SOURCES = tests/test-sha1.c
 
 noinst_PROGRAMS += tests/test-sha1
 tests_test_sha1_SOURCES = tests/test-sha1.c
-tests_test_sha1_LDADD = lib/libopenvswitch.a
+tests_test_sha1_LDADD = lib/libopenvswitch.a $(SSL_LIBS)
 
 noinst_PROGRAMS += tests/test-timeval
 tests_test_timeval_SOURCES = tests/test-timeval.c
 
 noinst_PROGRAMS += tests/test-timeval
 tests_test_timeval_SOURCES = tests/test-timeval.c
-tests_test_timeval_LDADD = lib/libopenvswitch.a
+tests_test_timeval_LDADD = lib/libopenvswitch.a $(SSL_LIBS)
 
 noinst_PROGRAMS += tests/test-strtok_r
 tests_test_strtok_r_SOURCES = tests/test-strtok_r.c
 
 noinst_PROGRAMS += tests/test-strtok_r
 tests_test_strtok_r_SOURCES = tests/test-strtok_r.c
@@ -320,11 +320,11 @@ tests_test_type_props_SOURCES = tests/test-type-props.c
 
 noinst_PROGRAMS += tests/test-util
 tests_test_util_SOURCES = tests/test-util.c
 
 noinst_PROGRAMS += tests/test-util
 tests_test_util_SOURCES = tests/test-util.c
-tests_test_util_LDADD = lib/libopenvswitch.a
+tests_test_util_LDADD = lib/libopenvswitch.a $(SSL_LIBS)
 
 noinst_PROGRAMS += tests/test-uuid
 tests_test_uuid_SOURCES = tests/test-uuid.c
 
 noinst_PROGRAMS += tests/test-uuid
 tests_test_uuid_SOURCES = tests/test-uuid.c
-tests_test_uuid_LDADD = lib/libopenvswitch.a
+tests_test_uuid_LDADD = lib/libopenvswitch.a $(SSL_LIBS)
 
 noinst_PROGRAMS += tests/test-vconn
 tests_test_vconn_SOURCES = tests/test-vconn.c
 
 noinst_PROGRAMS += tests/test-vconn
 tests_test_vconn_SOURCES = tests/test-vconn.c
index b85c663e4d0d798256446d02d591cb99236d95bb..8b474ea91fd853c05e52972c05ca7b70a4849210 100644 (file)
@@ -312,5 +312,5 @@ test_netflow_exit(struct unixctl_conn *conn,
 {
     bool *exiting = exiting_;
     *exiting = true;
 {
     bool *exiting = exiting_;
     *exiting = true;
-    unixctl_command_reply(conn, 200, "");
+    unixctl_command_reply(conn, NULL);
 }
 }
index 89078cb813a2330d1d98fbef6a4b874b7714699e..3e66aee1307920bb0874a56a258975c3bfb823b2 100644 (file)
@@ -83,13 +83,13 @@ man_MANS += \
 dist_man_MANS += utilities/ovs-ctl.8
 
 utilities_ovs_appctl_SOURCES = utilities/ovs-appctl.c
 dist_man_MANS += utilities/ovs-ctl.8
 
 utilities_ovs_appctl_SOURCES = utilities/ovs-appctl.c
-utilities_ovs_appctl_LDADD = lib/libopenvswitch.a
+utilities_ovs_appctl_LDADD = lib/libopenvswitch.a $(SSL_LIBS)
 
 utilities_ovs_controller_SOURCES = utilities/ovs-controller.c
 utilities_ovs_controller_LDADD = lib/libopenvswitch.a $(SSL_LIBS)
 
 utilities_ovs_dpctl_SOURCES = utilities/ovs-dpctl.c
 
 utilities_ovs_controller_SOURCES = utilities/ovs-controller.c
 utilities_ovs_controller_LDADD = lib/libopenvswitch.a $(SSL_LIBS)
 
 utilities_ovs_dpctl_SOURCES = utilities/ovs-dpctl.c
-utilities_ovs_dpctl_LDADD = lib/libopenvswitch.a
+utilities_ovs_dpctl_LDADD = lib/libopenvswitch.a $(SSL_LIBS)
 
 utilities_ovs_ofctl_SOURCES = utilities/ovs-ofctl.c
 utilities_ovs_ofctl_LDADD = \
 
 utilities_ovs_ofctl_SOURCES = utilities/ovs-ofctl.c
 utilities_ovs_ofctl_LDADD = \
@@ -103,15 +103,15 @@ utilities_ovs_vsctl_LDADD = lib/libopenvswitch.a $(SSL_LIBS)
 if HAVE_NETLINK
 sbin_PROGRAMS += utilities/ovs-vlan-bug-workaround
 utilities_ovs_vlan_bug_workaround_SOURCES = utilities/ovs-vlan-bug-workaround.c
 if HAVE_NETLINK
 sbin_PROGRAMS += utilities/ovs-vlan-bug-workaround
 utilities_ovs_vlan_bug_workaround_SOURCES = utilities/ovs-vlan-bug-workaround.c
-utilities_ovs_vlan_bug_workaround_LDADD = lib/libopenvswitch.a
+utilities_ovs_vlan_bug_workaround_LDADD = lib/libopenvswitch.a $(SSL_LIBS)
 
 noinst_PROGRAMS += utilities/nlmon
 utilities_nlmon_SOURCES = utilities/nlmon.c
 
 noinst_PROGRAMS += utilities/nlmon
 utilities_nlmon_SOURCES = utilities/nlmon.c
-utilities_nlmon_LDADD = lib/libopenvswitch.a
+utilities_nlmon_LDADD = lib/libopenvswitch.a $(SSL_LIBS)
 endif
 
 bin_PROGRAMS += utilities/ovs-benchmark
 utilities_ovs_benchmark_SOURCES = utilities/ovs-benchmark.c
 endif
 
 bin_PROGRAMS += utilities/ovs-benchmark
 utilities_ovs_benchmark_SOURCES = utilities/ovs-benchmark.c
-utilities_ovs_benchmark_LDADD = lib/libopenvswitch.a
+utilities_ovs_benchmark_LDADD = lib/libopenvswitch.a $(SSL_LIBS)
 
 include utilities/bugtool/automake.mk
 
 include utilities/bugtool/automake.mk
index ebfd54a1790ec1ebf9426e1d1e210440188f8ebc..241b6c04377be5be9fba3b75e78efde4c07ab541 100644 (file)
@@ -26,6 +26,7 @@
 #include "daemon.h"
 #include "dirs.h"
 #include "dynamic-string.h"
 #include "daemon.h"
 #include "dirs.h"
 #include "dynamic-string.h"
+#include "jsonrpc.h"
 #include "process.h"
 #include "timeval.h"
 #include "unixctl.h"
 #include "process.h"
 #include "timeval.h"
 #include "unixctl.h"
 
 static void usage(void);
 static const char *parse_command_line(int argc, char *argv[]);
 
 static void usage(void);
 static const char *parse_command_line(int argc, char *argv[]);
-static struct unixctl_client *connect_to_target(const char *target);
+static struct jsonrpc *connect_to_target(const char *target);
 
 int
 main(int argc, char *argv[])
 {
 
 int
 main(int argc, char *argv[])
 {
-    struct unixctl_client *client;
+    char *cmd_result, *cmd_error;
+    struct jsonrpc *client;
+    char *cmd, **cmd_argv;
     const char *target;
     const char *target;
-    int code, error;
-    char *request;
-    char *reply;
+    int cmd_argc;
+    int error;
 
     set_program_name(argv[0]);
 
 
     set_program_name(argv[0]);
 
@@ -51,22 +53,28 @@ main(int argc, char *argv[])
     client = connect_to_target(target);
 
     /* Transact request and process reply. */
     client = connect_to_target(target);
 
     /* Transact request and process reply. */
-    request = process_escape_args(argv + optind);
-    error = unixctl_client_transact(client, request, &code, &reply);
-    free(request);
+    cmd = argv[optind++];
+    cmd_argc = argc - optind;
+    cmd_argv = cmd_argc ? argv + optind : NULL;
+    error = unixctl_client_transact(client, cmd, cmd_argc, cmd_argv,
+                                    &cmd_result, &cmd_error);
     if (error) {
         ovs_fatal(error, "%s: transaction error", target);
     }
     if (error) {
         ovs_fatal(error, "%s: transaction error", target);
     }
-    if (code / 100 != 2) {
-        fputs(reply, stderr);
-        ovs_error(0, "%s: server returned reply code %03d", target, code);
+
+    if (cmd_error) {
+        fputs(cmd_error, stderr);
+        ovs_error(0, "%s: server returned an error", target);
         exit(2);
         exit(2);
+    } else if (cmd_result) {
+        fputs(cmd_result, stdout);
+    } else {
+        NOT_REACHED();
     }
     }
-    fputs(reply, stdout);
-
-    unixctl_client_destroy(client);
-    free(reply);
 
 
+    jsonrpc_close(client);
+    free(cmd_result);
+    free(cmd_error);
     return 0;
 }
 
     return 0;
 }
 
@@ -159,10 +167,10 @@ parse_command_line(int argc, char *argv[])
     return target ? target : "ovs-vswitchd";
 }
 
     return target ? target : "ovs-vswitchd";
 }
 
-static struct unixctl_client *
+static struct jsonrpc *
 connect_to_target(const char *target)
 {
 connect_to_target(const char *target)
 {
-    struct unixctl_client *client;
+    struct jsonrpc *client;
     char *socket_name;
     int error;
 
     char *socket_name;
     int error;
 
index bf7a2c126019de4a9b7fae7764f1afab8a1bf3b3..fd0829eaa42922b098a2b41f690d380d011a8293 100644 (file)
@@ -254,7 +254,7 @@ ofctl_exit(struct unixctl_conn *conn, int argc OVS_UNUSED,
 {
     bool *exiting = exiting_;
     *exiting = true;
 {
     bool *exiting = exiting_;
     *exiting = true;
-    unixctl_command_reply(conn, 200, "");
+    unixctl_command_reply(conn, NULL);
 }
 
 static void run(int retval, const char *message, ...)
 }
 
 static void run(int retval, const char *message, ...)
@@ -910,7 +910,12 @@ ofctl_send(struct unixctl_conn *conn, int argc,
             ds_put_cstr(&reply, "sent\n");
         }
     }
             ds_put_cstr(&reply, "sent\n");
         }
     }
-    unixctl_command_reply(conn, ok ? 200 : 501, ds_cstr(&reply));
+
+    if (ok) {
+        unixctl_command_reply(conn, ds_cstr(&reply));
+    } else {
+        unixctl_command_reply_error(conn, ds_cstr(&reply));
+    }
     ds_destroy(&reply);
 }
 
     ds_destroy(&reply);
 }
 
@@ -928,7 +933,7 @@ ofctl_barrier(struct unixctl_conn *conn, int argc OVS_UNUSED,
     int error;
 
     if (aux->conn) {
     int error;
 
     if (aux->conn) {
-        unixctl_command_reply(conn, 501, "already waiting for barrier reply");
+        unixctl_command_reply_error(conn, "already waiting for barrier reply");
         return;
     }
 
         return;
     }
 
@@ -939,7 +944,7 @@ ofctl_barrier(struct unixctl_conn *conn, int argc OVS_UNUSED,
     error = vconn_send_block(aux->vconn, msg);
     if (error) {
         ofpbuf_delete(msg);
     error = vconn_send_block(aux->vconn, msg);
     if (error) {
         ofpbuf_delete(msg);
-        unixctl_command_reply(conn, 501, strerror(error));
+        unixctl_command_reply_error(conn, strerror(error));
     } else {
         aux->conn = conn;
     }
     } else {
         aux->conn = conn;
     }
@@ -953,14 +958,14 @@ ofctl_set_output_file(struct unixctl_conn *conn, int argc OVS_UNUSED,
 
     fd = open(argv[1], O_CREAT | O_TRUNC | O_WRONLY, 0666);
     if (fd < 0) {
 
     fd = open(argv[1], O_CREAT | O_TRUNC | O_WRONLY, 0666);
     if (fd < 0) {
-        unixctl_command_reply(conn, 501, strerror(errno));
+        unixctl_command_reply_error(conn, strerror(errno));
         return;
     }
 
     fflush(stderr);
     dup2(fd, STDERR_FILENO);
     close(fd);
         return;
     }
 
     fflush(stderr);
     dup2(fd, STDERR_FILENO);
     close(fd);
-    unixctl_command_reply(conn, 200, "");
+    unixctl_command_reply(conn, NULL);
 }
 
 static void
 }
 
 static void
@@ -1013,7 +1018,7 @@ monitor_vconn(struct vconn *vconn)
             ofpbuf_delete(b);
 
             if (barrier_aux.conn && msg_type == OFPT_BARRIER_REPLY) {
             ofpbuf_delete(b);
 
             if (barrier_aux.conn && msg_type == OFPT_BARRIER_REPLY) {
-                unixctl_command_reply(barrier_aux.conn, 200, "");
+                unixctl_command_reply(barrier_aux.conn, NULL);
                 barrier_aux.conn = NULL;
             }
         }
                 barrier_aux.conn = NULL;
             }
         }
index e857077a86292ca35ef34d89335dd4155a9fd979..5b0f66fe8bce79f4b050ed2bc640cb0995ea09b6 100644 (file)
@@ -2084,7 +2084,7 @@ qos_unixctl_show(struct unixctl_conn *conn, int argc OVS_UNUSED,
 
     iface = iface_find(argv[1]);
     if (!iface) {
 
     iface = iface_find(argv[1]);
     if (!iface) {
-        unixctl_command_reply(conn, 501, "no such interface");
+        unixctl_command_reply_error(conn, "no such interface");
         return;
     }
 
         return;
     }
 
@@ -2104,10 +2104,10 @@ qos_unixctl_show(struct unixctl_conn *conn, int argc OVS_UNUSED,
         if (error) {
             ds_put_format(&ds, "failed to dump queues: %s", strerror(error));
         }
         if (error) {
             ds_put_format(&ds, "failed to dump queues: %s", strerror(error));
         }
-        unixctl_command_reply(conn, 200, ds_cstr(&ds));
+        unixctl_command_reply(conn, ds_cstr(&ds));
     } else {
         ds_put_format(&ds, "QoS not configured on %s\n", iface->name);
     } else {
         ds_put_format(&ds, "QoS not configured on %s\n", iface->name);
-        unixctl_command_reply(conn, 501, ds_cstr(&ds));
+        unixctl_command_reply_error(conn, ds_cstr(&ds));
     }
 
     shash_destroy_free_data(&sh);
     }
 
     shash_destroy_free_data(&sh);
@@ -2189,14 +2189,14 @@ bridge_unixctl_dump_flows(struct unixctl_conn *conn, int argc OVS_UNUSED,
 
     br = bridge_lookup(argv[1]);
     if (!br) {
 
     br = bridge_lookup(argv[1]);
     if (!br) {
-        unixctl_command_reply(conn, 501, "Unknown bridge");
+        unixctl_command_reply_error(conn, "Unknown bridge");
         return;
     }
 
     ds_init(&results);
     ofproto_get_all_flows(br->ofproto, &results);
 
         return;
     }
 
     ds_init(&results);
     ofproto_get_all_flows(br->ofproto, &results);
 
-    unixctl_command_reply(conn, 200, ds_cstr(&results));
+    unixctl_command_reply(conn, ds_cstr(&results));
     ds_destroy(&results);
 }
 
     ds_destroy(&results);
 }
 
@@ -2211,7 +2211,7 @@ bridge_unixctl_reconnect(struct unixctl_conn *conn, int argc,
     if (argc > 1) {
         br = bridge_lookup(argv[1]);
         if (!br) {
     if (argc > 1) {
         br = bridge_lookup(argv[1]);
         if (!br) {
-            unixctl_command_reply(conn, 501, "Unknown bridge");
+            unixctl_command_reply_error(conn,  "Unknown bridge");
             return;
         }
         ofproto_reconnect_controllers(br->ofproto);
             return;
         }
         ofproto_reconnect_controllers(br->ofproto);
@@ -2220,7 +2220,7 @@ bridge_unixctl_reconnect(struct unixctl_conn *conn, int argc,
             ofproto_reconnect_controllers(br->ofproto);
         }
     }
             ofproto_reconnect_controllers(br->ofproto);
         }
     }
-    unixctl_command_reply(conn, 200, NULL);
+    unixctl_command_reply(conn, NULL);
 }
 
 static size_t
 }
 
 static size_t
index 2360086c19a9f1a5e6df4ea5e2b789f2091245d0..76dc52bb531b9278cd86273c2d3f823a4cca30fb 100644 (file)
@@ -247,5 +247,5 @@ ovs_vswitchd_exit(struct unixctl_conn *conn, int argc OVS_UNUSED,
 {
     bool *exiting = exiting_;
     *exiting = true;
 {
     bool *exiting = exiting_;
     *exiting = true;
-    unixctl_command_reply(conn, 200, NULL);
+    unixctl_command_reply(conn, NULL);
 }
 }