tc: Support json option in tc-cgroup, tc-flow and tc-route

Fix json corruption when using the "-json" option in some cases

Signed-off-by: Takanori Hirano <me@hrntknr.net>
Signed-off-by: Stephen Hemminger <stephen@networkplumber.org>

diff --git a/tc/f_cgroup.c b/tc/f_cgroup.c
index a4fc03d1432e7c4f13e0d6449ba99f5ac70689f9..291d6e7ebe3347218c854c81a57a06521da460ee 100644 (file)
--- a/tc/f_cgroup.c
+++ b/tc/f_cgroup.c
@@ -86,13 +86,13 @@ static int cgroup_print_opt(struct filter_util *qu, FILE *f,
        parse_rtattr_nested(tb, TCA_CGROUP_MAX, opt);
 
        if (handle)
-               fprintf(f, "handle 0x%x ", handle);
+               print_0xhex(PRINT_ANY, "handle", "handle %#llx ", handle);
 
        if (tb[TCA_CGROUP_EMATCHES])
                print_ematch(f, tb[TCA_CGROUP_EMATCHES]);
 
        if (tb[TCA_CGROUP_POLICE]) {
-               fprintf(f, "\n");
+               print_nl();
                tc_print_police(f, tb[TCA_CGROUP_POLICE]);
        }
 

diff --git a/tc/f_flow.c b/tc/f_flow.c
index 2445aaef51b366b958959101affae9f1897b50cc..4a29af22e99d4d598b4ddea7f5eafdb7bda9e362 100644 (file)
--- a/tc/f_flow.c
+++ b/tc/f_flow.c
@@ -258,6 +258,21 @@ static int flow_parse_opt(struct filter_util *fu, char *handle,
        return 0;
 }
 
+static const char *flow_mode2str(__u32 mode)
+{
+       static char buf[128];
+
+       switch (mode) {
+       case FLOW_MODE_MAP:
+               return "map";
+       case FLOW_MODE_HASH:
+               return "hash";
+       default:
+               snprintf(buf, sizeof(buf), "%#x", mode);
+               return buf;
+       }
+}
+
 static int flow_print_opt(struct filter_util *fu, FILE *f, struct rtattr *opt,
                          __u32 handle)
 {
@@ -272,33 +287,26 @@ static int flow_print_opt(struct filter_util *fu, FILE *f, struct rtattr *opt,
 
        parse_rtattr_nested(tb, TCA_FLOW_MAX, opt);
 
-       fprintf(f, "handle 0x%x ", handle);
+       print_0xhex(PRINT_ANY, "handle", "handle %#llx ", handle);
 
        if (tb[TCA_FLOW_MODE]) {
                __u32 mode = rta_getattr_u32(tb[TCA_FLOW_MODE]);
-
-               switch (mode) {
-               case FLOW_MODE_MAP:
-                       fprintf(f, "map ");
-                       break;
-               case FLOW_MODE_HASH:
-                       fprintf(f, "hash ");
-                       break;
-               }
+               print_string(PRINT_ANY, "mode", "%s ", flow_mode2str(mode));
        }
 
        if (tb[TCA_FLOW_KEYS]) {
                __u32 keymask = rta_getattr_u32(tb[TCA_FLOW_KEYS]);
-               char *sep = "";
+               char *sep = " ";
 
-               fprintf(f, "keys ");
+               open_json_array(PRINT_ANY, "keys");
                for (i = 0; i <= FLOW_KEY_MAX; i++) {
                        if (keymask & (1 << i)) {
-                               fprintf(f, "%s%s", sep, flow_keys[i]);
+                               print_string(PRINT_FP, NULL, "%s", sep);
+                               print_string(PRINT_ANY, NULL, "%s", flow_keys[i]);
                                sep = ",";
                        }
                }
-               fprintf(f, " ");
+               close_json_array(PRINT_ANY, " ");
        }
 
        if (tb[TCA_FLOW_MASK])
@@ -311,37 +319,37 @@ static int flow_print_opt(struct filter_util *fu, FILE *f, struct rtattr *opt,
                __u32 xor = mask & val;
 
                if (mask != ~0)
-                       fprintf(f, "and 0x%.8x ", mask);
+                       print_0xhex(PRINT_ANY, "and", "and 0x%.8x ", mask);
                if (xor != 0)
-                       fprintf(f, "xor 0x%.8x ", xor);
+                       print_0xhex(PRINT_ANY, "xor", "xor 0x%.8x ", xor);
                if (or != 0)
-                       fprintf(f, "or 0x%.8x ", or);
+                       print_0xhex(PRINT_ANY, "or", "or 0x%.8x ", or);
        }
 
        if (tb[TCA_FLOW_RSHIFT])
-               fprintf(f, "rshift %u ",
-                       rta_getattr_u32(tb[TCA_FLOW_RSHIFT]));
+               print_uint(PRINT_ANY, "rshift", "rshift %u ",
+                          rta_getattr_u32(tb[TCA_FLOW_RSHIFT]));
        if (tb[TCA_FLOW_ADDEND])
-               fprintf(f, "addend 0x%x ",
-                       rta_getattr_u32(tb[TCA_FLOW_ADDEND]));
+               print_0xhex(PRINT_ANY, "addend", "addend 0x%x ",
+                           rta_getattr_u32(tb[TCA_FLOW_ADDEND]));
 
        if (tb[TCA_FLOW_DIVISOR])
-               fprintf(f, "divisor %u ",
-                       rta_getattr_u32(tb[TCA_FLOW_DIVISOR]));
+               print_uint(PRINT_ANY, "divisor", "divisor %u ",
+                          rta_getattr_u32(tb[TCA_FLOW_DIVISOR]));
        if (tb[TCA_FLOW_BASECLASS])
-               fprintf(f, "baseclass %s ",
-                       sprint_tc_classid(rta_getattr_u32(tb[TCA_FLOW_BASECLASS]), b1));
+               print_string(PRINT_ANY, "baseclass", "baseclass %s ",
+                            sprint_tc_classid(rta_getattr_u32(tb[TCA_FLOW_BASECLASS]), b1));
 
        if (tb[TCA_FLOW_PERTURB])
-               fprintf(f, "perturb %usec ",
-                       rta_getattr_u32(tb[TCA_FLOW_PERTURB]));
+               print_uint(PRINT_ANY, "perturb", "perturb %usec ",
+                          rta_getattr_u32(tb[TCA_FLOW_PERTURB]));
 
        if (tb[TCA_FLOW_EMATCHES])
                print_ematch(f, tb[TCA_FLOW_EMATCHES]);
        if (tb[TCA_FLOW_POLICE])
                tc_print_police(f, tb[TCA_FLOW_POLICE]);
        if (tb[TCA_FLOW_ACT]) {
-               fprintf(f, "\n");
+               print_nl();
                tc_print_action(f, tb[TCA_FLOW_ACT], 0);
        }
        return 0;

diff --git a/tc/f_route.c b/tc/f_route.c
index e92c798574d8166a9d18bb8c1f2a1b04d35104f1..ca8a8dddc2aa05e5dd7436c13ef0272f042693ab 100644 (file)
--- a/tc/f_route.c
+++ b/tc/f_route.c
@@ -146,20 +146,24 @@ static int route_print_opt(struct filter_util *qu, FILE *f, struct rtattr *opt,
        parse_rtattr_nested(tb, TCA_ROUTE4_MAX, opt);
 
        if (handle)
-               fprintf(f, "fh 0x%08x ", handle);
+               print_0xhex(PRINT_ANY, "fh", "fh 0x%08x ", handle);
        if (handle&0x7F00)
-               fprintf(f, "order %d ", (handle>>8)&0x7F);
+               print_uint(PRINT_ANY, "order", "order %d ", (handle >> 8) & 0x7F);
 
        if (tb[TCA_ROUTE4_CLASSID]) {
                SPRINT_BUF(b1);
-               fprintf(f, "flowid %s ", sprint_tc_classid(rta_getattr_u32(tb[TCA_ROUTE4_CLASSID]), b1));
+               print_string(PRINT_ANY, "flowid", "flowid %s ",
+                            sprint_tc_classid(rta_getattr_u32(tb[TCA_ROUTE4_CLASSID]), b1));
        }
        if (tb[TCA_ROUTE4_TO])
-               fprintf(f, "to %s ", rtnl_rtrealm_n2a(rta_getattr_u32(tb[TCA_ROUTE4_TO]), b1, sizeof(b1)));
+               print_string(PRINT_ANY, "name", "to %s ",
+                       rtnl_rtrealm_n2a(rta_getattr_u32(tb[TCA_ROUTE4_TO]), b1, sizeof(b1)));
        if (tb[TCA_ROUTE4_FROM])
-               fprintf(f, "from %s ", rtnl_rtrealm_n2a(rta_getattr_u32(tb[TCA_ROUTE4_FROM]), b1, sizeof(b1)));
+               print_string(PRINT_ANY, "name", "from %s ",
+                       rtnl_rtrealm_n2a(rta_getattr_u32(tb[TCA_ROUTE4_FROM]), b1, sizeof(b1)));
        if (tb[TCA_ROUTE4_IIF])
-               fprintf(f, "fromif %s", ll_index_to_name(rta_getattr_u32(tb[TCA_ROUTE4_IIF])));
+               print_color_string(PRINT_ANY, COLOR_IFNAME, "fromif", "fromif %s",
+                       ll_index_to_name(rta_getattr_u32(tb[TCA_ROUTE4_IIF])));
        if (tb[TCA_ROUTE4_POLICE])
                tc_print_police(f, tb[TCA_ROUTE4_POLICE]);
        if (tb[TCA_ROUTE4_ACT])