Merge branch 'master' of git://git.kernel.org/pub/scm/network/iproute2/iproute2-next

Resolved conflict in tc/f_flower.c

diff --git a/configure b/configure
index 45fcffb69bb532a876cd9462090f97cb42ff54eb..f415bf4975e710bd1386b68f46a93adc2ff273f2 100755 (executable)
--- a/configure
+++ b/configure
@@ -16,9 +16,11 @@ check_toolchain()
     : ${PKG_CONFIG:=pkg-config}
     : ${AR=ar}
     : ${CC=gcc}
+    : ${YACC=bison}
     echo "PKG_CONFIG:=${PKG_CONFIG}" >>$CONFIG
     echo "AR:=${AR}" >>$CONFIG
     echo "CC:=${CC}" >>$CONFIG
+    echo "YACC:=${YACC}" >>$CONFIG
 }
 
 check_atm()

diff --git a/devlink/devlink.c b/devlink/devlink.c
index 95f05a0b5223fbd594c21652cc7dd796766813c0..73ce98654fd8cd42452e7969dae7d24866069de9 100644 (file)
--- a/devlink/devlink.c
+++ b/devlink/devlink.c
@@ -395,6 +395,17 @@ static void __pr_out_indent_newline(struct dl *dl)
                pr_out(" ");
 }
 
+static void check_indent_newline(struct dl *dl)
+{
+       __pr_out_indent_newline(dl);
+
+       if (g_indent_newline && !is_json_context()) {
+               printf("%s", g_indent_str);
+               g_indent_newline = false;
+       }
+       g_new_line_count = 0;
+}
+
 static const enum mnl_attr_data_type devlink_policy[DEVLINK_ATTR_MAX + 1] = {
        [DEVLINK_ATTR_BUS_NAME] = MNL_TYPE_NUL_STRING,
        [DEVLINK_ATTR_DEV_NAME] = MNL_TYPE_NUL_STRING,
@@ -1715,19 +1726,17 @@ static void __pr_out_handle_start(struct dl *dl, struct nlattr **tb,
        if (dl->json_output) {
                if (array) {
                        if (should_arr_last_handle_end(dl, bus_name, dev_name))
-                               jsonw_end_array(dl->jw);
+                               close_json_array(PRINT_JSON, NULL);
                        if (should_arr_last_handle_start(dl, bus_name,
                                                         dev_name)) {
-                               jsonw_name(dl->jw, buf);
-                               jsonw_start_array(dl->jw);
-                               jsonw_start_object(dl->jw);
+                               open_json_array(PRINT_JSON, buf);
+                               open_json_object(NULL);
                                arr_last_handle_set(dl, bus_name, dev_name);
                        } else {
-                               jsonw_start_object(dl->jw);
+                               open_json_object(NULL);
                        }
                } else {
-                       jsonw_name(dl->jw, buf);
-                       jsonw_start_object(dl->jw);
+                       open_json_object(buf);
                }
        } else {
                if (array) {
@@ -1754,7 +1763,7 @@ static void pr_out_handle_start_arr(struct dl *dl, struct nlattr **tb)
 static void pr_out_handle_end(struct dl *dl)
 {
        if (dl->json_output)
-               jsonw_end_object(dl->jw);
+               close_json_object();
        else
                __pr_out_newline();
 }
@@ -1816,21 +1825,19 @@ static void __pr_out_port_handle_start(struct dl *dl, const char *bus_name,
                        if (should_arr_last_port_handle_end(dl, bus_name,
                                                            dev_name,
                                                            port_index))
-                               jsonw_end_array(dl->jw);
+                               close_json_array(PRINT_JSON, NULL);
                        if (should_arr_last_port_handle_start(dl, bus_name,
                                                              dev_name,
                                                              port_index)) {
-                               jsonw_name(dl->jw, buf);
-                               jsonw_start_array(dl->jw);
-                               jsonw_start_object(dl->jw);
+                               open_json_array(PRINT_JSON, buf);
+                               open_json_object(NULL);
                                arr_last_port_handle_set(dl, bus_name, dev_name,
                                                         port_index);
                        } else {
-                               jsonw_start_object(dl->jw);
+                               open_json_object(NULL);
                        }
                } else {
-                       jsonw_name(dl->jw, buf);
-                       jsonw_start_object(dl->jw);
+                       open_json_object(buf);
                }
        } else {
                pr_out("%s:", buf);
@@ -1864,77 +1871,23 @@ static void pr_out_port_handle_start_arr(struct dl *dl, struct nlattr **tb, bool
 static void pr_out_port_handle_end(struct dl *dl)
 {
        if (dl->json_output)
-               jsonw_end_object(dl->jw);
+               close_json_object();
        else
                pr_out("\n");
 }
 
-
-static void pr_out_str(struct dl *dl, const char *name, const char *val)
-{
-       __pr_out_indent_newline(dl);
-       if (dl->json_output)
-               jsonw_string_field(dl->jw, name, val);
-       else
-               pr_out("%s %s", name, val);
-}
-
-static void pr_out_bool(struct dl *dl, const char *name, bool val)
-{
-       if (dl->json_output)
-               jsonw_bool_field(dl->jw, name, val);
-       else
-               pr_out_str(dl, name, val ? "true" : "false");
-}
-
-static void pr_out_uint(struct dl *dl, const char *name, unsigned int val)
-{
-       __pr_out_indent_newline(dl);
-       if (dl->json_output)
-               jsonw_uint_field(dl->jw, name, val);
-       else
-               pr_out("%s %u", name, val);
-}
-
 static void pr_out_u64(struct dl *dl, const char *name, uint64_t val)
 {
        __pr_out_indent_newline(dl);
        if (val == (uint64_t) -1)
-               return pr_out_str(dl, name, "unlimited");
+               return print_string_name_value(name, "unlimited");
 
        if (dl->json_output)
-               jsonw_u64_field(dl->jw, name, val);
+               print_u64(PRINT_JSON, name, NULL, val);
        else
                pr_out("%s %"PRIu64, name, val);
 }
 
-static void pr_out_bool_value(struct dl *dl, bool value)
-{
-       __pr_out_indent_newline(dl);
-       if (dl->json_output)
-               jsonw_bool(dl->jw, value);
-       else
-               pr_out("%s", value ? "true" : "false");
-}
-
-static void pr_out_uint_value(struct dl *dl, unsigned int value)
-{
-       __pr_out_indent_newline(dl);
-       if (dl->json_output)
-               jsonw_uint(dl->jw, value);
-       else
-               pr_out("%u", value);
-}
-
-static void pr_out_uint64_value(struct dl *dl, uint64_t value)
-{
-       __pr_out_indent_newline(dl);
-       if (dl->json_output)
-               jsonw_u64(dl->jw, value);
-       else
-               pr_out("%"PRIu64, value);
-}
-
 static bool is_binary_eol(int i)
 {
        return !(i%16);
@@ -1946,7 +1899,7 @@ static void pr_out_binary_value(struct dl *dl, uint8_t *data, uint32_t len)
 
        while (i < len) {
                if (dl->json_output)
-                       jsonw_printf(dl->jw, "%d", data[i]);
+                       print_int(PRINT_JSON, NULL, NULL, data[i]);
                else
                        pr_out("%02x ", data[i]);
                i++;
@@ -1957,20 +1910,11 @@ static void pr_out_binary_value(struct dl *dl, uint8_t *data, uint32_t len)
                __pr_out_newline();
 }
 
-static void pr_out_str_value(struct dl *dl, const char *value)
-{
-       __pr_out_indent_newline(dl);
-       if (dl->json_output)
-               jsonw_string(dl->jw, value);
-       else
-               pr_out("%s", value);
-}
-
 static void pr_out_name(struct dl *dl, const char *name)
 {
        __pr_out_indent_newline(dl);
        if (dl->json_output)
-               jsonw_name(dl->jw, name);
+               print_string(PRINT_JSON, name, NULL, NULL);
        else
                pr_out("%s:", name);
 }
@@ -1978,17 +1922,15 @@ static void pr_out_name(struct dl *dl, const char *name)
 static void pr_out_region_chunk_start(struct dl *dl, uint64_t addr)
 {
        if (dl->json_output) {
-               jsonw_name(dl->jw, "address");
-               jsonw_uint(dl->jw, addr);
-               jsonw_name(dl->jw, "data");
-               jsonw_start_array(dl->jw);
+               print_uint(PRINT_JSON, "address", NULL, addr);
+               open_json_array(PRINT_JSON, "data");
        }
 }
 
 static void pr_out_region_chunk_end(struct dl *dl)
 {
        if (dl->json_output)
-               jsonw_end_array(dl->jw);
+               close_json_array(PRINT_JSON, NULL);
 }
 
 static void pr_out_region_chunk(struct dl *dl, uint8_t *data, uint32_t len,
@@ -2008,7 +1950,7 @@ static void pr_out_region_chunk(struct dl *dl, uint8_t *data, uint32_t len,
                align_val++;
 
                if (dl->json_output)
-                       jsonw_printf(dl->jw, "%d", data[i]);
+                       print_int(PRINT_JSON, NULL, NULL, data[i]);
                else
                        pr_out("%02x ", data[i]);
 
@@ -2021,9 +1963,8 @@ static void pr_out_region_chunk(struct dl *dl, uint8_t *data, uint32_t len,
 static void pr_out_section_start(struct dl *dl, const char *name)
 {
        if (dl->json_output) {
-               jsonw_start_object(dl->jw);
-               jsonw_name(dl->jw, name);
-               jsonw_start_object(dl->jw);
+               open_json_object(NULL);
+               open_json_object(name);
        }
 }
 
@@ -2031,17 +1972,16 @@ static void pr_out_section_end(struct dl *dl)
 {
        if (dl->json_output) {
                if (dl->arr_last.present)
-                       jsonw_end_array(dl->jw);
-               jsonw_end_object(dl->jw);
-               jsonw_end_object(dl->jw);
+                       close_json_array(PRINT_JSON, NULL);
+               close_json_object();
+               close_json_object();
        }
 }
 
 static void pr_out_array_start(struct dl *dl, const char *name)
 {
        if (dl->json_output) {
-               jsonw_name(dl->jw, name);
-               jsonw_start_array(dl->jw);
+               open_json_array(PRINT_JSON, name);
        } else {
                __pr_out_indent_inc();
                __pr_out_newline();
@@ -2054,7 +1994,7 @@ static void pr_out_array_start(struct dl *dl, const char *name)
 static void pr_out_array_end(struct dl *dl)
 {
        if (dl->json_output) {
-               jsonw_end_array(dl->jw);
+               close_json_array(PRINT_JSON, NULL);
        } else {
                __pr_out_indent_dec();
                __pr_out_indent_dec();
@@ -2064,8 +2004,7 @@ static void pr_out_array_end(struct dl *dl)
 static void pr_out_object_start(struct dl *dl, const char *name)
 {
        if (dl->json_output) {
-               jsonw_name(dl->jw, name);
-               jsonw_start_object(dl->jw);
+               open_json_object(name);
        } else {
                __pr_out_indent_inc();
                __pr_out_newline();
@@ -2078,7 +2017,7 @@ static void pr_out_object_start(struct dl *dl, const char *name)
 static void pr_out_object_end(struct dl *dl)
 {
        if (dl->json_output) {
-               jsonw_end_object(dl->jw);
+               close_json_object();
        } else {
                __pr_out_indent_dec();
                __pr_out_indent_dec();
@@ -2088,13 +2027,13 @@ static void pr_out_object_end(struct dl *dl)
 static void pr_out_entry_start(struct dl *dl)
 {
        if (dl->json_output)
-               jsonw_start_object(dl->jw);
+               open_json_object(NULL);
 }
 
 static void pr_out_entry_end(struct dl *dl)
 {
        if (dl->json_output)
-               jsonw_end_object(dl->jw);
+               close_json_object();
        else
                __pr_out_newline();
 }
@@ -2165,19 +2104,24 @@ static void pr_out_eswitch(struct dl *dl, struct nlattr **tb)
 {
        __pr_out_handle_start(dl, tb, true, false);
 
-       if (tb[DEVLINK_ATTR_ESWITCH_MODE])
-               pr_out_str(dl, "mode",
-                          eswitch_mode_name(mnl_attr_get_u16(tb[DEVLINK_ATTR_ESWITCH_MODE])));
-
-       if (tb[DEVLINK_ATTR_ESWITCH_INLINE_MODE])
-               pr_out_str(dl, "inline-mode",
-                          eswitch_inline_mode_name(mnl_attr_get_u8(
-                                  tb[DEVLINK_ATTR_ESWITCH_INLINE_MODE])));
-
+       if (tb[DEVLINK_ATTR_ESWITCH_MODE]) {
+               check_indent_newline(dl);
+               print_string(PRINT_ANY, "mode", "mode %s",
+                            eswitch_mode_name(mnl_attr_get_u16(
+                                    tb[DEVLINK_ATTR_ESWITCH_MODE])));
+       }
+       if (tb[DEVLINK_ATTR_ESWITCH_INLINE_MODE]) {
+               check_indent_newline(dl);
+               print_string(PRINT_ANY, "inline-mode", "inline-mode %s",
+                            eswitch_inline_mode_name(mnl_attr_get_u8(
+                                    tb[DEVLINK_ATTR_ESWITCH_INLINE_MODE])));
+       }
        if (tb[DEVLINK_ATTR_ESWITCH_ENCAP_MODE]) {
                bool encap_mode = !!mnl_attr_get_u8(tb[DEVLINK_ATTR_ESWITCH_ENCAP_MODE]);
 
-               pr_out_str(dl, "encap", encap_mode ? "enable" : "disable");
+               check_indent_newline(dl);
+               print_string(PRINT_ANY, "encap", "encap %s",
+                            encap_mode ? "enable" : "disable");
        }
 
        pr_out_handle_end(dl);
@@ -2364,8 +2308,10 @@ static void pr_out_param_value(struct dl *dl, const char *nla_name,
             !nla_value[DEVLINK_ATTR_PARAM_VALUE_DATA]))
                return;
 
-       pr_out_str(dl, "cmode",
-                  param_cmode_name(mnl_attr_get_u8(nla_value[DEVLINK_ATTR_PARAM_VALUE_CMODE])));
+       check_indent_newline(dl);
+       print_string(PRINT_ANY, "cmode", "cmode %s",
+                    param_cmode_name(mnl_attr_get_u8(nla_value[DEVLINK_ATTR_PARAM_VALUE_CMODE])));
+
        val_attr = nla_value[DEVLINK_ATTR_PARAM_VALUE_DATA];
 
        conv_exists = param_val_conv_exists(param_val_conv, PARAM_VAL_CONV_LEN,
@@ -2381,9 +2327,10 @@ static void pr_out_param_value(struct dl *dl, const char *nla_name,
                                                     &vstr);
                        if (err)
                                return;
-                       pr_out_str(dl, "value", vstr);
+                       print_string(PRINT_ANY, "value", " value %s", vstr);
                } else {
-                       pr_out_uint(dl, "value", mnl_attr_get_u8(val_attr));
+                       print_uint(PRINT_ANY, "value", " value %u",
+                                  mnl_attr_get_u8(val_attr));
                }
                break;
        case MNL_TYPE_U16:
@@ -2395,9 +2342,10 @@ static void pr_out_param_value(struct dl *dl, const char *nla_name,
                                                     &vstr);
                        if (err)
                                return;
-                       pr_out_str(dl, "value", vstr);
+                       print_string(PRINT_ANY, "value", " value %s", vstr);
                } else {
-                       pr_out_uint(dl, "value", mnl_attr_get_u16(val_attr));
+                       print_uint(PRINT_ANY, "value", " value %u",
+                                  mnl_attr_get_u16(val_attr));
                }
                break;
        case MNL_TYPE_U32:
@@ -2409,16 +2357,18 @@ static void pr_out_param_value(struct dl *dl, const char *nla_name,
                                                     &vstr);
                        if (err)
                                return;
-                       pr_out_str(dl, "value", vstr);
+                       print_string(PRINT_ANY, "value", " value %s", vstr);
                } else {
-                       pr_out_uint(dl, "value", mnl_attr_get_u32(val_attr));
+                       print_uint(PRINT_ANY, "value", " value %u",
+                                  mnl_attr_get_u32(val_attr));
                }
                break;
        case MNL_TYPE_STRING:
-               pr_out_str(dl, "value", mnl_attr_get_str(val_attr));
+               print_string(PRINT_ANY, "value", " value %s",
+                            mnl_attr_get_str(val_attr));
                break;
        case MNL_TYPE_FLAG:
-               pr_out_bool(dl, "value", val_attr ? true : false);
+               print_bool(PRINT_ANY, "value", " value %s", val_attr);
                break;
        }
 }
@@ -2447,12 +2397,12 @@ static void pr_out_param(struct dl *dl, struct nlattr **tb, bool array)
        nla_type = mnl_attr_get_u8(nla_param[DEVLINK_ATTR_PARAM_TYPE]);
 
        nla_name = mnl_attr_get_str(nla_param[DEVLINK_ATTR_PARAM_NAME]);
-       pr_out_str(dl, "name", nla_name);
-
+       check_indent_newline(dl);
+       print_string(PRINT_ANY, "name", "name %s ", nla_name);
        if (!nla_param[DEVLINK_ATTR_PARAM_GENERIC])
-               pr_out_str(dl, "type", "driver-specific");
+               print_string(PRINT_ANY, "type", "type %s", "driver-specific");
        else
-               pr_out_str(dl, "type", "generic");
+               print_string(PRINT_ANY, "type", "type %s", "generic");
 
        pr_out_array_start(dl, "values");
        mnl_attr_for_each_nested(param_value_attr,
@@ -2729,7 +2679,8 @@ static int cmd_dev_show_cb(const struct nlmsghdr *nlh, void *data)
 
        if (reload_failed) {
                __pr_out_handle_start(dl, tb, true, false);
-               pr_out_bool(dl, "reload_failed", true);
+               check_indent_newline(dl);
+               print_bool(PRINT_ANY, "reload_failed", "reload_failed %s", true);
                pr_out_handle_end(dl);
        } else {
                pr_out_handle(dl, tb);
@@ -2816,7 +2767,8 @@ static void pr_out_versions_single(struct dl *dl, const struct nlmsghdr *nlh,
                ver_name = mnl_attr_get_str(tb[DEVLINK_ATTR_INFO_VERSION_NAME]);
                ver_value = mnl_attr_get_str(tb[DEVLINK_ATTR_INFO_VERSION_VALUE]);
 
-               pr_out_str(dl, ver_name, ver_value);
+               check_indent_newline(dl);
+               print_string_name_value(ver_name, ver_value);
                if (!dl->json_output)
                        __pr_out_newline();
        }
@@ -2836,7 +2788,9 @@ static void pr_out_info(struct dl *dl, const struct nlmsghdr *nlh,
 
                if (!dl->json_output)
                        __pr_out_newline();
-               pr_out_str(dl, "driver", mnl_attr_get_str(nla_drv));
+               check_indent_newline(dl);
+               print_string(PRINT_ANY, "driver", "driver %s",
+                            mnl_attr_get_str(nla_drv));
        }
 
        if (tb[DEVLINK_ATTR_INFO_SERIAL_NUMBER]) {
@@ -2844,7 +2798,9 @@ static void pr_out_info(struct dl *dl, const struct nlmsghdr *nlh,
 
                if (!dl->json_output)
                        __pr_out_newline();
-               pr_out_str(dl, "serial_number", mnl_attr_get_str(nla_sn));
+               check_indent_newline(dl);
+               print_string(PRINT_ANY, "serial_number", "serial_number %s",
+                            mnl_attr_get_str(nla_sn));
        }
        __pr_out_indent_dec();
 
@@ -3203,11 +3159,11 @@ static void pr_out_port_pfvf_num(struct dl *dl, struct nlattr **tb)
 
        if (tb[DEVLINK_ATTR_PORT_PCI_PF_NUMBER]) {
                fn_num = mnl_attr_get_u16(tb[DEVLINK_ATTR_PORT_PCI_PF_NUMBER]);
-               pr_out_uint(dl, "pfnum", fn_num);
+               print_uint(PRINT_ANY, "pfnum", " pfnum %u", fn_num);
        }
        if (tb[DEVLINK_ATTR_PORT_PCI_VF_NUMBER]) {
                fn_num = mnl_attr_get_u16(tb[DEVLINK_ATTR_PORT_PCI_VF_NUMBER]);
-               pr_out_uint(dl, "vfnum", fn_num);
+               print_uint(PRINT_ANY, "vfnum", " vfnum %u", fn_num);
        }
 }
 
@@ -3217,29 +3173,34 @@ static void pr_out_port(struct dl *dl, struct nlattr **tb)
        struct nlattr *dpt_attr = tb[DEVLINK_ATTR_PORT_DESIRED_TYPE];
 
        pr_out_port_handle_start(dl, tb, false);
+       check_indent_newline(dl);
        if (pt_attr) {
                uint16_t port_type = mnl_attr_get_u16(pt_attr);
 
-               pr_out_str(dl, "type", port_type_name(port_type));
+               print_string(PRINT_ANY, "type", "type %s",
+                            port_type_name(port_type));
                if (dpt_attr) {
                        uint16_t des_port_type = mnl_attr_get_u16(dpt_attr);
 
                        if (port_type != des_port_type)
-                               pr_out_str(dl, "des_type",
-                                          port_type_name(des_port_type));
+                               print_string(PRINT_ANY, "des_type", " des_type %s",
+                                            port_type_name(des_port_type));
                }
        }
-       if (tb[DEVLINK_ATTR_PORT_NETDEV_NAME])
-               pr_out_str(dl, "netdev",
-                          mnl_attr_get_str(tb[DEVLINK_ATTR_PORT_NETDEV_NAME]));
-       if (tb[DEVLINK_ATTR_PORT_IBDEV_NAME])
-               pr_out_str(dl, "ibdev",
-                          mnl_attr_get_str(tb[DEVLINK_ATTR_PORT_IBDEV_NAME]));
+       if (tb[DEVLINK_ATTR_PORT_NETDEV_NAME]) {
+               print_string(PRINT_ANY, "netdev", " netdev %s",
+                            mnl_attr_get_str(tb[DEVLINK_ATTR_PORT_NETDEV_NAME]));
+       }
+       if (tb[DEVLINK_ATTR_PORT_IBDEV_NAME]) {
+               print_string(PRINT_ANY, "ibdev", " ibdev %s",
+                            mnl_attr_get_str(tb[DEVLINK_ATTR_PORT_IBDEV_NAME]));
+               }
        if (tb[DEVLINK_ATTR_PORT_FLAVOUR]) {
                uint16_t port_flavour =
                                mnl_attr_get_u16(tb[DEVLINK_ATTR_PORT_FLAVOUR]);
 
-               pr_out_str(dl, "flavour", port_flavour_name(port_flavour));
+               print_string(PRINT_ANY, "flavour", " flavour %s",
+                            port_flavour_name(port_flavour));
 
                switch (port_flavour) {
                case DEVLINK_PORT_FLAVOUR_PCI_PF:
@@ -3254,11 +3215,11 @@ static void pr_out_port(struct dl *dl, struct nlattr **tb)
                uint32_t port_number;
 
                port_number = mnl_attr_get_u32(tb[DEVLINK_ATTR_PORT_NUMBER]);
-               pr_out_uint(dl, "port", port_number);
+               print_uint(PRINT_ANY, "port", " port %u", port_number);
        }
        if (tb[DEVLINK_ATTR_PORT_SPLIT_GROUP])
-               pr_out_uint(dl, "split_group",
-                           mnl_attr_get_u32(tb[DEVLINK_ATTR_PORT_SPLIT_GROUP]));
+               print_uint(PRINT_ANY, "split_group", " split_group %u",
+                          mnl_attr_get_u32(tb[DEVLINK_ATTR_PORT_SPLIT_GROUP]));
        pr_out_port_handle_end(dl);
 }
 
@@ -3390,18 +3351,19 @@ static void cmd_sb_help(void)
 static void pr_out_sb(struct dl *dl, struct nlattr **tb)
 {
        pr_out_handle_start_arr(dl, tb);
-       pr_out_uint(dl, "sb",
-                   mnl_attr_get_u32(tb[DEVLINK_ATTR_SB_INDEX]));
-       pr_out_uint(dl, "size",
-                   mnl_attr_get_u32(tb[DEVLINK_ATTR_SB_SIZE]));
-       pr_out_uint(dl, "ing_pools",
-                   mnl_attr_get_u16(tb[DEVLINK_ATTR_SB_INGRESS_POOL_COUNT]));
-       pr_out_uint(dl, "eg_pools",
-                   mnl_attr_get_u16(tb[DEVLINK_ATTR_SB_EGRESS_POOL_COUNT]));
-       pr_out_uint(dl, "ing_tcs",
-                   mnl_attr_get_u16(tb[DEVLINK_ATTR_SB_INGRESS_TC_COUNT]));
-       pr_out_uint(dl, "eg_tcs",
-                   mnl_attr_get_u16(tb[DEVLINK_ATTR_SB_EGRESS_TC_COUNT]));
+       check_indent_newline(dl);
+       print_uint(PRINT_ANY, "sb", "sb %u",
+                  mnl_attr_get_u32(tb[DEVLINK_ATTR_SB_INDEX]));
+       print_uint(PRINT_ANY, "size", " size %u",
+                  mnl_attr_get_u32(tb[DEVLINK_ATTR_SB_SIZE]));
+       print_uint(PRINT_ANY, "ing_pools", " ing_pools %u",
+                  mnl_attr_get_u16(tb[DEVLINK_ATTR_SB_INGRESS_POOL_COUNT]));
+       print_uint(PRINT_ANY, "eg_pools", " eg_pools %u",
+                  mnl_attr_get_u16(tb[DEVLINK_ATTR_SB_EGRESS_POOL_COUNT]));
+       print_uint(PRINT_ANY, "ing_tcs", " ing_tcs %u",
+                  mnl_attr_get_u16(tb[DEVLINK_ATTR_SB_INGRESS_TC_COUNT]));
+       print_uint(PRINT_ANY, "eg_tcs", " eg_tcs %u",
+                  mnl_attr_get_u16(tb[DEVLINK_ATTR_SB_EGRESS_TC_COUNT]));
        pr_out_handle_end(dl);
 }
 
@@ -3467,19 +3429,20 @@ static const char *threshold_type_name(uint8_t type)
 static void pr_out_sb_pool(struct dl *dl, struct nlattr **tb)
 {
        pr_out_handle_start_arr(dl, tb);
-       pr_out_uint(dl, "sb",
-                   mnl_attr_get_u32(tb[DEVLINK_ATTR_SB_INDEX]));
-       pr_out_uint(dl, "pool",
-                   mnl_attr_get_u16(tb[DEVLINK_ATTR_SB_POOL_INDEX]));
-       pr_out_str(dl, "type",
-                  pool_type_name(mnl_attr_get_u8(tb[DEVLINK_ATTR_SB_POOL_TYPE])));
-       pr_out_uint(dl, "size",
-                   mnl_attr_get_u32(tb[DEVLINK_ATTR_SB_POOL_SIZE]));
-       pr_out_str(dl, "thtype",
-                  threshold_type_name(mnl_attr_get_u8(tb[DEVLINK_ATTR_SB_POOL_THRESHOLD_TYPE])));
+       check_indent_newline(dl);
+       print_uint(PRINT_ANY, "sb", "sb %u",
+                  mnl_attr_get_u32(tb[DEVLINK_ATTR_SB_INDEX]));
+       print_uint(PRINT_ANY, "pool", " pool %u",
+                  mnl_attr_get_u16(tb[DEVLINK_ATTR_SB_POOL_INDEX]));
+       print_string(PRINT_ANY, "type", " type %s",
+                    pool_type_name(mnl_attr_get_u8(tb[DEVLINK_ATTR_SB_POOL_TYPE])));
+       print_uint(PRINT_ANY, "size", " size %u",
+                  mnl_attr_get_u32(tb[DEVLINK_ATTR_SB_POOL_SIZE]));
+       print_string(PRINT_ANY, "thtype", " thtype %s",
+                    threshold_type_name(mnl_attr_get_u8(tb[DEVLINK_ATTR_SB_POOL_THRESHOLD_TYPE])));
        if (tb[DEVLINK_ATTR_SB_POOL_CELL_SIZE])
-               pr_out_uint(dl, "cell_size",
-                           mnl_attr_get_u32(tb[DEVLINK_ATTR_SB_POOL_CELL_SIZE]));
+               print_uint(PRINT_ANY, "cell_size", " cell size %u",
+                          mnl_attr_get_u32(tb[DEVLINK_ATTR_SB_POOL_CELL_SIZE]));
        pr_out_handle_end(dl);
 }
 
@@ -3559,12 +3522,13 @@ static int cmd_sb_pool(struct dl *dl)
 static void pr_out_sb_port_pool(struct dl *dl, struct nlattr **tb)
 {
        pr_out_port_handle_start_arr(dl, tb, true);
-       pr_out_uint(dl, "sb",
-                   mnl_attr_get_u32(tb[DEVLINK_ATTR_SB_INDEX]));
-       pr_out_uint(dl, "pool",
-                   mnl_attr_get_u16(tb[DEVLINK_ATTR_SB_POOL_INDEX]));
-       pr_out_uint(dl, "threshold",
-                   mnl_attr_get_u32(tb[DEVLINK_ATTR_SB_THRESHOLD]));
+       check_indent_newline(dl);
+       print_uint(PRINT_ANY, "sb", "sb %u",
+                  mnl_attr_get_u32(tb[DEVLINK_ATTR_SB_INDEX]));
+       print_uint(PRINT_ANY, "pool", " pool %u",
+                  mnl_attr_get_u16(tb[DEVLINK_ATTR_SB_POOL_INDEX]));
+       print_uint(PRINT_ANY, "threshold", " threshold %u",
+                  mnl_attr_get_u32(tb[DEVLINK_ATTR_SB_THRESHOLD]));
        pr_out_port_handle_end(dl);
 }
 
@@ -3657,16 +3621,17 @@ static int cmd_sb_port(struct dl *dl)
 static void pr_out_sb_tc_bind(struct dl *dl, struct nlattr **tb)
 {
        pr_out_port_handle_start_arr(dl, tb, true);
-       pr_out_uint(dl, "sb",
-              mnl_attr_get_u32(tb[DEVLINK_ATTR_SB_INDEX]));
-       pr_out_uint(dl, "tc",
-              mnl_attr_get_u16(tb[DEVLINK_ATTR_SB_TC_INDEX]));
-       pr_out_str(dl, "type",
-              pool_type_name(mnl_attr_get_u8(tb[DEVLINK_ATTR_SB_POOL_TYPE])));
-       pr_out_uint(dl, "pool",
-              mnl_attr_get_u16(tb[DEVLINK_ATTR_SB_POOL_INDEX]));
-       pr_out_uint(dl, "threshold",
-              mnl_attr_get_u32(tb[DEVLINK_ATTR_SB_THRESHOLD]));
+       check_indent_newline(dl);
+       print_uint(PRINT_ANY, "sb", "sb %u",
+                  mnl_attr_get_u32(tb[DEVLINK_ATTR_SB_INDEX]));
+       print_uint(PRINT_ANY, "tc", " tc %u",
+                  mnl_attr_get_u16(tb[DEVLINK_ATTR_SB_TC_INDEX]));
+       print_string(PRINT_ANY, "type", " type %s",
+                    pool_type_name(mnl_attr_get_u8(tb[DEVLINK_ATTR_SB_POOL_TYPE])));
+       print_uint(PRINT_ANY, "pool", " pool %u",
+                  mnl_attr_get_u16(tb[DEVLINK_ATTR_SB_POOL_INDEX]));
+       print_uint(PRINT_ANY, "threshold", " threshold %u",
+                  mnl_attr_get_u32(tb[DEVLINK_ATTR_SB_THRESHOLD]));
        pr_out_port_handle_end(dl);
 }
 
@@ -3887,20 +3852,18 @@ static void pr_out_json_occ_show_item_list(struct dl *dl, const char *label,
        struct occ_item *occ_item;
        char buf[32];
 
-       jsonw_name(dl->jw, label);
-       jsonw_start_object(dl->jw);
+       open_json_object(label);
        list_for_each_entry(occ_item, list, list) {
                sprintf(buf, "%u", occ_item->index);
-               jsonw_name(dl->jw, buf);
-               jsonw_start_object(dl->jw);
+               open_json_object(buf);
                if (bound_pool)
-                       jsonw_uint_field(dl->jw, "bound_pool",
-                                        occ_item->bound_pool_index);
-               jsonw_uint_field(dl->jw, "current", occ_item->cur);
-               jsonw_uint_field(dl->jw, "max", occ_item->max);
-               jsonw_end_object(dl->jw);
+                       print_uint(PRINT_JSON, "bound_pool", NULL,
+                                  occ_item->bound_pool_index);
+               print_uint(PRINT_JSON, "current", NULL, occ_item->cur);
+               print_uint(PRINT_JSON, "max", NULL, occ_item->max);
+               close_json_object();
        }
-       jsonw_end_object(dl->jw);
+       close_json_object();
 }
 
 static void pr_out_occ_show_port(struct dl *dl, struct occ_port *occ_port)
@@ -4243,13 +4206,16 @@ static void pr_out_flash_update(struct dl *dl, struct nlattr **tb)
 {
        __pr_out_handle_start(dl, tb, true, false);
 
-       if (tb[DEVLINK_ATTR_FLASH_UPDATE_STATUS_MSG])
-               pr_out_str(dl, "msg",
-                          mnl_attr_get_str(tb[DEVLINK_ATTR_FLASH_UPDATE_STATUS_MSG]));
-
-       if (tb[DEVLINK_ATTR_FLASH_UPDATE_COMPONENT])
-               pr_out_str(dl, "component",
-                          mnl_attr_get_str(tb[DEVLINK_ATTR_FLASH_UPDATE_COMPONENT]));
+       if (tb[DEVLINK_ATTR_FLASH_UPDATE_STATUS_MSG]) {
+               check_indent_newline(dl);
+               print_string(PRINT_ANY, "msg", "msg %s",
+                            mnl_attr_get_str(tb[DEVLINK_ATTR_FLASH_UPDATE_STATUS_MSG]));
+       }
+       if (tb[DEVLINK_ATTR_FLASH_UPDATE_COMPONENT]) {
+               check_indent_newline(dl);
+               print_string(PRINT_ANY, "component", "component %s",
+                            mnl_attr_get_str(tb[DEVLINK_ATTR_FLASH_UPDATE_COMPONENT]));
+       }
 
        if (tb[DEVLINK_ATTR_FLASH_UPDATE_STATUS_DONE])
                pr_out_u64(dl, "done",
@@ -4716,13 +4682,15 @@ static void pr_out_dpipe_fields(struct dpipe_ctx *ctx,
        for (i = 0; i < field_count; i++) {
                field = &fields[i];
                pr_out_entry_start(ctx->dl);
-               pr_out_str(ctx->dl, "name", field->name);
+               check_indent_newline(ctx->dl);
+               print_string(PRINT_ANY, "name", "name %s", field->name);
                if (ctx->dl->verbose)
-                       pr_out_uint(ctx->dl, "id", field->id);
-               pr_out_uint(ctx->dl, "bitwidth", field->bitwidth);
-               if (field->mapping_type)
-                       pr_out_str(ctx->dl, "mapping_type",
-                                  dpipe_field_mapping_e2s(field->mapping_type));
+                       print_uint(PRINT_ANY, "id", " id %u", field->id);
+               print_uint(PRINT_ANY, "bitwidth", " bitwidth %u", field->bitwidth);
+               if (field->mapping_type) {
+                       print_string(PRINT_ANY, "mapping_type", " mapping_type %s",
+                                    dpipe_field_mapping_e2s(field->mapping_type));
+               }
                pr_out_entry_end(ctx->dl);
        }
 }
@@ -4732,11 +4700,11 @@ pr_out_dpipe_header(struct dpipe_ctx *ctx, struct nlattr **tb,
                    struct dpipe_header *header, bool global)
 {
        pr_out_handle_start_arr(ctx->dl, tb);
-       pr_out_str(ctx->dl, "name", header->name);
+       check_indent_newline(ctx->dl);
+       print_string(PRINT_ANY, "name", "name %s", header->name);
        if (ctx->dl->verbose) {
-               pr_out_uint(ctx->dl, "id", header->id);
-               pr_out_str(ctx->dl, "global",
-                          global ? "true" : "false");
+               print_uint(PRINT_ANY, "id", " id %u", header->id);
+               print_bool(PRINT_ANY, "global", " global %s", global);
        }
        pr_out_array_start(ctx->dl, "field");
        pr_out_dpipe_fields(ctx, header->fields,
@@ -4960,20 +4928,21 @@ static void pr_out_dpipe_action(struct dpipe_action *action,
        struct dpipe_op_info *op_info = &action->info;
        const char *mapping;
 
-       pr_out_str(ctx->dl, "type",
-                  dpipe_action_type_e2s(action->type));
-       pr_out_str(ctx->dl, "header",
-                  dpipe_header_id2s(ctx, op_info->header_id,
-                                    op_info->header_global));
-       pr_out_str(ctx->dl, "field",
-                  dpipe_field_id2s(ctx, op_info->header_id,
-                                   op_info->field_id,
-                                   op_info->header_global));
+       check_indent_newline(ctx->dl);
+       print_string(PRINT_ANY, "type", "type %s",
+                    dpipe_action_type_e2s(action->type));
+       print_string(PRINT_ANY, "header", " header %s",
+                    dpipe_header_id2s(ctx, op_info->header_id,
+                                      op_info->header_global));
+       print_string(PRINT_ANY, "field", " field %s",
+                    dpipe_field_id2s(ctx, op_info->header_id,
+                                     op_info->field_id,
+                                     op_info->header_global));
        mapping = dpipe_mapping_get(ctx, op_info->header_id,
                                    op_info->field_id,
                                    op_info->header_global);
        if (mapping)
-               pr_out_str(ctx->dl, "mapping", mapping);
+               print_string(PRINT_ANY, "mapping", " mapping %s", mapping);
 }
 
 static int dpipe_action_parse(struct dpipe_action *action, struct nlattr *nl)
@@ -5042,20 +5011,21 @@ static void pr_out_dpipe_match(struct dpipe_match *match,
        struct dpipe_op_info *op_info = &match->info;
        const char *mapping;
 
-       pr_out_str(ctx->dl, "type",
-                  dpipe_match_type_e2s(match->type));
-       pr_out_str(ctx->dl, "header",
-                  dpipe_header_id2s(ctx, op_info->header_id,
-                                    op_info->header_global));
-       pr_out_str(ctx->dl, "field",
-                  dpipe_field_id2s(ctx, op_info->header_id,
-                                   op_info->field_id,
-                                   op_info->header_global));
+       check_indent_newline(ctx->dl);
+       print_string(PRINT_ANY, "type", "type %s",
+                    dpipe_match_type_e2s(match->type));
+       print_string(PRINT_ANY, "header", " header %s",
+                    dpipe_header_id2s(ctx, op_info->header_id,
+                                      op_info->header_global));
+       print_string(PRINT_ANY, "field", " field %s",
+                    dpipe_field_id2s(ctx, op_info->header_id,
+                                     op_info->field_id,
+                                     op_info->header_global));
        mapping = dpipe_mapping_get(ctx, op_info->header_id,
                                    op_info->field_id,
                                    op_info->header_global);
        if (mapping)
-               pr_out_str(ctx->dl, "mapping", mapping);
+               print_string(PRINT_ANY, "mapping", " mapping %s", mapping);
 }
 
 static int dpipe_match_parse(struct dpipe_match *match,
@@ -5160,7 +5130,8 @@ resource_path_print(struct dl *dl, struct resources *resources,
                path -= strlen(del);
                memcpy(path, del, strlen(del));
        }
-       pr_out_str(dl, "resource_path", path);
+       check_indent_newline(dl);
+       print_string(PRINT_ANY, "resource_path", "resource_path %s", path);
        free(path);
 }
 
@@ -5205,16 +5176,17 @@ static int dpipe_table_show(struct dpipe_ctx *ctx, struct nlattr *nl)
        if (!ctx->print_tables)
                return 0;
 
-       pr_out_str(ctx->dl, "name", table->name);
-       pr_out_uint(ctx->dl, "size", size);
-       pr_out_str(ctx->dl, "counters_enabled",
-                  counters_enabled ? "true" : "false");
+       check_indent_newline(ctx->dl);
+       print_string(PRINT_ANY, "name", "name %s", table->name);
+       print_uint(PRINT_ANY, "size", " size %u", size);
+       print_bool(PRINT_ANY, "counters_enabled", " counters_enabled %s", counters_enabled);
 
        if (resource_valid) {
                resource_units = mnl_attr_get_u32(nla_table[DEVLINK_ATTR_DPIPE_TABLE_RESOURCE_UNITS]);
                resource_path_print(ctx->dl, ctx->resources,
                                    table->resource_id);
-               pr_out_uint(ctx->dl, "resource_units", resource_units);
+               print_uint(PRINT_ANY, "resource_units", " resource_units %u",
+                          resource_units);
        }
 
        pr_out_array_start(ctx->dl, "match");
@@ -5385,7 +5357,8 @@ static void dpipe_field_printer_ipv4_addr(struct dpipe_ctx *ctx,
        struct in_addr ip_addr;
 
        ip_addr.s_addr = htonl(*(uint32_t *)value);
-       pr_out_str(ctx->dl, dpipe_value_type_e2s(type), inet_ntoa(ip_addr));
+       check_indent_newline(ctx->dl);
+       print_string_name_value(dpipe_value_type_e2s(type), inet_ntoa(ip_addr));
 }
 
 static void
@@ -5393,8 +5366,9 @@ dpipe_field_printer_ethernet_addr(struct dpipe_ctx *ctx,
                                  enum dpipe_value_type type,
                                  void *value)
 {
-       pr_out_str(ctx->dl, dpipe_value_type_e2s(type),
-                  ether_ntoa((struct ether_addr *)value));
+       check_indent_newline(ctx->dl);
+       print_string_name_value(dpipe_value_type_e2s(type),
+                               ether_ntoa((struct ether_addr *)value));
 }
 
 static void dpipe_field_printer_ipv6_addr(struct dpipe_ctx *ctx,
@@ -5404,7 +5378,8 @@ static void dpipe_field_printer_ipv6_addr(struct dpipe_ctx *ctx,
        char str[INET6_ADDRSTRLEN];
 
        inet_ntop(AF_INET6, value, str, INET6_ADDRSTRLEN);
-       pr_out_str(ctx->dl, dpipe_value_type_e2s(type), str);
+       check_indent_newline(ctx->dl);
+       print_string_name_value(dpipe_value_type_e2s(type), str);
 }
 
 static struct dpipe_field_printer dpipe_field_printers_ipv4[] = {
@@ -5494,7 +5469,8 @@ static void __pr_out_entry_value(struct dpipe_ctx *ctx,
        if (value_len == sizeof(uint32_t)) {
                uint32_t *value_32 = value;
 
-               pr_out_uint(ctx->dl, dpipe_value_type_e2s(type), *value_32);
+               check_indent_newline(ctx->dl);
+               print_uint_name_value(dpipe_value_type_e2s(type), *value_32);
        }
 }
 
@@ -5515,7 +5491,8 @@ static void pr_out_dpipe_entry_value(struct dpipe_ctx *ctx,
 
        if (mapping) {
                value_mapping = mnl_attr_get_u32(nla_match_value[DEVLINK_ATTR_DPIPE_VALUE_MAPPING]);
-               pr_out_uint(ctx->dl, "mapping_value", value_mapping);
+               check_indent_newline(ctx->dl);
+               print_uint(PRINT_ANY, "mapping_value", "mapping_value %u", value_mapping);
        }
 
        if (mask) {
@@ -5632,12 +5609,13 @@ static int dpipe_entry_show(struct dpipe_ctx *ctx, struct nlattr *nl)
                return -EINVAL;
        }
 
+       check_indent_newline(ctx->dl);
        entry_index = mnl_attr_get_u32(nla_entry[DEVLINK_ATTR_DPIPE_ENTRY_INDEX]);
-       pr_out_uint(ctx->dl, "index", entry_index);
+       print_uint(PRINT_ANY, "index", "index %u", entry_index);
 
        if (nla_entry[DEVLINK_ATTR_DPIPE_ENTRY_COUNTER]) {
                counter = mnl_attr_get_u64(nla_entry[DEVLINK_ATTR_DPIPE_ENTRY_COUNTER]);
-               pr_out_uint(ctx->dl, "counter", counter);
+               print_uint(PRINT_ANY, "counter", " counter %u", counter);
        }
 
        pr_out_array_start(ctx->dl, "match_value");
@@ -5883,20 +5861,24 @@ static void resource_show(struct resource *resource,
        struct dl *dl = ctx->dl;
        bool array = false;
 
-       pr_out_str(dl, "name", resource->name);
+       check_indent_newline(dl);
+       print_string(PRINT_ANY, "name", "name %s", resource->name);
        if (dl->verbose)
                resource_path_print(dl, ctx->resources, resource->id);
        pr_out_u64(dl, "size", resource->size);
        if (resource->size != resource->size_new)
                pr_out_u64(dl, "size_new", resource->size_new);
        if (resource->occ_valid)
-               pr_out_uint(dl, "occ", resource->size_occ);
-       pr_out_str(dl, "unit", resource_unit_str_get(resource->unit));
+               print_uint(PRINT_ANY, "occ", " occ %u",  resource->size_occ);
+       print_string(PRINT_ANY, "unit", " unit %s",
+                    resource_unit_str_get(resource->unit));
 
        if (resource->size_min != resource->size_max) {
-               pr_out_uint(dl, "size_min", resource->size_min);
+               print_uint(PRINT_ANY, "size_min", " size_min %u",
+                          resource->size_min);
                pr_out_u64(dl, "size_max", resource->size_max);
-               pr_out_uint(dl, "size_gran", resource->size_gran);
+               print_uint(PRINT_ANY, "size_gran", " size_gran %u",
+                          resource->size_gran);
        }
 
        list_for_each_entry(table, &ctx->tables->table_list, list)
@@ -5907,14 +5889,17 @@ static void resource_show(struct resource *resource,
        if (array)
                pr_out_array_start(dl, "dpipe_tables");
        else
-               pr_out_str(dl, "dpipe_tables", "none");
+               print_string(PRINT_ANY, "dpipe_tables", " dpipe_tables none",
+                            "none");
 
        list_for_each_entry(table, &ctx->tables->table_list, list) {
                if (table->resource_id != resource->id ||
                    !table->resource_valid)
                        continue;
                pr_out_entry_start(dl);
-               pr_out_str(dl, "table_name", table->name);
+               check_indent_newline(dl);
+               print_string(PRINT_ANY, "table_name", "table_name %s",
+                            table->name);
                pr_out_entry_end(dl);
        }
        if (array)
@@ -5923,9 +5908,11 @@ static void resource_show(struct resource *resource,
        if (list_empty(&resource->resource_list))
                return;
 
-       if (ctx->pending_change)
-               pr_out_str(dl, "size_valid", resource->size_valid ?
-                          "true" : "false");
+       if (ctx->pending_change) {
+               check_indent_newline(dl);
+               print_string(PRINT_ANY, "size_valid", "size_valid %s",
+                            resource->size_valid ? "true" : "false");
+       }
        pr_out_array_start(dl, "resources");
        list_for_each_entry(child_resource, &resource->resource_list, list) {
                pr_out_entry_start(dl);
@@ -6140,18 +6127,16 @@ static void pr_out_region_handle_start(struct dl *dl, struct nlattr **tb)
        char buf[256];
 
        sprintf(buf, "%s/%s/%s", bus_name, dev_name, region_name);
-       if (dl->json_output) {
-               jsonw_name(dl->jw, buf);
-               jsonw_start_object(dl->jw);
-       } else {
+       if (dl->json_output)
+               open_json_object(buf);
+       else
                pr_out("%s:", buf);
-       }
 }
 
 static void pr_out_region_handle_end(struct dl *dl)
 {
        if (dl->json_output)
-               jsonw_end_object(dl->jw);
+               close_json_object();
        else
                pr_out("\n");
 }
@@ -6159,18 +6144,16 @@ static void pr_out_region_handle_end(struct dl *dl)
 static void pr_out_region_snapshots_start(struct dl *dl, bool array)
 {
        __pr_out_indent_newline(dl);
-       if (dl->json_output) {
-               jsonw_name(dl->jw, "snapshot");
-               jsonw_start_array(dl->jw);
-       } else {
+       if (dl->json_output)
+               open_json_array(PRINT_JSON, "snapshot");
+       else
                pr_out("snapshot %s", array ? "[" : "");
-       }
 }
 
 static void pr_out_region_snapshots_end(struct dl *dl, bool array)
 {
        if (dl->json_output)
-               jsonw_end_array(dl->jw);
+               close_json_array(PRINT_JSON, NULL);
        else if (array)
                pr_out("]");
 }
@@ -6185,7 +6168,7 @@ static void pr_out_region_snapshots_id(struct dl *dl, struct nlattr **tb, int in
        snapshot_id = mnl_attr_get_u32(tb[DEVLINK_ATTR_REGION_SNAPSHOT_ID]);
 
        if (dl->json_output)
-               jsonw_uint(dl->jw, snapshot_id);
+               print_uint(PRINT_JSON, NULL, NULL, snapshot_id);
        else
                pr_out("%s%u", index ? " " : "", snapshot_id);
 }
@@ -6433,24 +6416,25 @@ static int fmsg_value_show(struct dl *dl, int type, struct nlattr *nl_data)
        uint8_t *data;
        uint32_t len;
 
+       check_indent_newline(dl);
        switch (type) {
        case MNL_TYPE_FLAG:
-               pr_out_bool_value(dl, mnl_attr_get_u8(nl_data));
+               print_bool(PRINT_ANY, NULL, "%s", mnl_attr_get_u8(nl_data));
                break;
        case MNL_TYPE_U8:
-               pr_out_uint_value(dl, mnl_attr_get_u8(nl_data));
+               print_uint(PRINT_ANY, NULL, "%u", mnl_attr_get_u8(nl_data));
                break;
        case MNL_TYPE_U16:
-               pr_out_uint_value(dl, mnl_attr_get_u16(nl_data));
+               print_uint(PRINT_ANY, NULL, "%u", mnl_attr_get_u16(nl_data));
                break;
        case MNL_TYPE_U32:
-               pr_out_uint_value(dl, mnl_attr_get_u32(nl_data));
+               print_uint(PRINT_ANY, NULL, "%u", mnl_attr_get_u32(nl_data));
                break;
        case MNL_TYPE_U64:
-               pr_out_uint64_value(dl, mnl_attr_get_u64(nl_data));
+               print_u64(PRINT_ANY, NULL, "%"PRIu64, mnl_attr_get_u64(nl_data));
                break;
        case MNL_TYPE_NUL_STRING:
-               pr_out_str_value(dl, mnl_attr_get_str(nl_data));
+               print_string(PRINT_ANY, NULL, "%s", mnl_attr_get_str(nl_data));
                break;
        case MNL_TYPE_BINARY:
                len = mnl_attr_get_payload_len(nl_data);
@@ -6527,7 +6511,7 @@ static void pr_out_fmsg_start_object(struct dl *dl, char **name)
 {
        if (dl->json_output) {
                pr_out_fmsg_name(dl, name);
-               jsonw_start_object(dl->jw);
+               open_json_object(NULL);
        } else {
                pr_out_fmsg_group_start(dl, name);
        }
@@ -6536,7 +6520,7 @@ static void pr_out_fmsg_start_object(struct dl *dl, char **name)
 static void pr_out_fmsg_end_object(struct dl *dl)
 {
        if (dl->json_output)
-               jsonw_end_object(dl->jw);
+               close_json_object();
        else
                pr_out_fmsg_group_end(dl);
 }
@@ -6545,7 +6529,7 @@ static void pr_out_fmsg_start_array(struct dl *dl, char **name)
 {
        if (dl->json_output) {
                pr_out_fmsg_name(dl, name);
-               jsonw_start_array(dl->jw);
+               open_json_array(PRINT_JSON, NULL);
        } else {
                pr_out_fmsg_group_start(dl, name);
        }
@@ -6554,7 +6538,7 @@ static void pr_out_fmsg_start_array(struct dl *dl, char **name)
 static void pr_out_fmsg_end_array(struct dl *dl)
 {
        if (dl->json_output)
-               jsonw_end_array(dl->jw);
+               close_json_array(PRINT_JSON, NULL);
        else
                pr_out_fmsg_group_end(dl);
 }
@@ -6748,8 +6732,9 @@ static void pr_out_dump_reporter_format_logtime(struct dl *dl, const struct nlat
 out:
        strftime(dump_date, HEALTH_REPORTER_TIMESTAMP_FMT_LEN, "%Y-%m-%d", info);
        strftime(dump_time, HEALTH_REPORTER_TIMESTAMP_FMT_LEN, "%H:%M:%S", info);
-       pr_out_str(dl, "last_dump_date", dump_date);
-       pr_out_str(dl, "last_dump_time", dump_time);
+       check_indent_newline(dl);
+       print_string(PRINT_ANY, "last_dump_date", "last_dump_date %s", dump_date);
+       print_string(PRINT_ANY, "last_dump_time", " last_dump_time %s", dump_time);
 }
 
 static void pr_out_dump_report_timestamp(struct dl *dl, const struct nlattr *attr)
@@ -6767,8 +6752,9 @@ static void pr_out_dump_report_timestamp(struct dl *dl, const struct nlattr *att
        strftime(dump_date, HEALTH_REPORTER_TIMESTAMP_FMT_LEN, "%Y-%m-%d", tm);
        strftime(dump_time, HEALTH_REPORTER_TIMESTAMP_FMT_LEN, "%H:%M:%S", tm);
 
-       pr_out_str(dl, "last_dump_date", dump_date);
-       pr_out_str(dl, "last_dump_time", dump_time);
+       check_indent_newline(dl);
+       print_string(PRINT_ANY, "last_dump_date", "last_dump_date %s", dump_date);
+       print_string(PRINT_ANY, "last_dump_time", " last_dump_time %s", dump_time);
 }
 
 static void pr_out_health(struct dl *dl, struct nlattr **tb_health)
@@ -6790,14 +6776,16 @@ static void pr_out_health(struct dl *dl, struct nlattr **tb_health)
 
        pr_out_handle_start_arr(dl, tb_health);
 
-       pr_out_str(dl, "reporter",
-                  mnl_attr_get_str(tb[DEVLINK_ATTR_HEALTH_REPORTER_NAME]));
+       check_indent_newline(dl);
+       print_string(PRINT_ANY, "reporter", "reporter %s",
+                    mnl_attr_get_str(tb[DEVLINK_ATTR_HEALTH_REPORTER_NAME]));
        if (!dl->json_output) {
                __pr_out_newline();
                __pr_out_indent_inc();
        }
        state = mnl_attr_get_u8(tb[DEVLINK_ATTR_HEALTH_REPORTER_STATE]);
-       pr_out_str(dl, "state", health_state_name(state));
+       check_indent_newline(dl);
+       print_string(PRINT_ANY, "state", "state %s", health_state_name(state));
        pr_out_u64(dl, "error",
                   mnl_attr_get_u64(tb[DEVLINK_ATTR_HEALTH_REPORTER_ERR_COUNT]));
        pr_out_u64(dl, "recover",
@@ -6810,8 +6798,8 @@ static void pr_out_health(struct dl *dl, struct nlattr **tb_health)
                pr_out_u64(dl, "grace_period",
                           mnl_attr_get_u64(tb[DEVLINK_ATTR_HEALTH_REPORTER_GRACEFUL_PERIOD]));
        if (tb[DEVLINK_ATTR_HEALTH_REPORTER_AUTO_RECOVER])
-               pr_out_bool(dl, "auto_recover",
-                           mnl_attr_get_u8(tb[DEVLINK_ATTR_HEALTH_REPORTER_AUTO_RECOVER]));
+               print_bool(PRINT_ANY, "auto_recover", " auto_recover %s",
+                          mnl_attr_get_u8(tb[DEVLINK_ATTR_HEALTH_REPORTER_AUTO_RECOVER]));
 
        __pr_out_indent_dec();
        pr_out_handle_end(dl);
@@ -6938,8 +6926,11 @@ static void pr_out_trap_metadata(struct dl *dl, struct nlattr *attr)
        struct nlattr *attr_metadata;
 
        pr_out_array_start(dl, "metadata");
-       mnl_attr_for_each_nested(attr_metadata, attr)
-               pr_out_str_value(dl, trap_metadata_name(attr_metadata));
+       mnl_attr_for_each_nested(attr_metadata, attr) {
+               check_indent_newline(dl);
+               print_string(PRINT_ANY, NULL, "%s",
+                            trap_metadata_name(attr_metadata));
+       }
        pr_out_array_end(dl);
 }
 
@@ -6953,12 +6944,14 @@ static void pr_out_trap(struct dl *dl, struct nlattr **tb, bool array)
        else
                __pr_out_handle_start(dl, tb, true, false);
 
-       pr_out_str(dl, "name", mnl_attr_get_str(tb[DEVLINK_ATTR_TRAP_NAME]));
-       pr_out_str(dl, "type", trap_type_name(type));
-       pr_out_bool(dl, "generic", !!tb[DEVLINK_ATTR_TRAP_GENERIC]);
-       pr_out_str(dl, "action", trap_action_name(action));
-       pr_out_str(dl, "group",
-                  mnl_attr_get_str(tb[DEVLINK_ATTR_TRAP_GROUP_NAME]));
+       check_indent_newline(dl);
+       print_string(PRINT_ANY, "name", "name %s",
+                    mnl_attr_get_str(tb[DEVLINK_ATTR_TRAP_NAME]));
+       print_string(PRINT_ANY, "type", " type %s", trap_type_name(type));
+       print_bool(PRINT_ANY, "generic", " generic %s", !!tb[DEVLINK_ATTR_TRAP_GENERIC]);
+       print_string(PRINT_ANY, "action", " action %s", trap_action_name(action));
+       print_string(PRINT_ANY, "group", " group %s",
+                    mnl_attr_get_str(tb[DEVLINK_ATTR_TRAP_GROUP_NAME]));
        if (dl->verbose)
                pr_out_trap_metadata(dl, tb[DEVLINK_ATTR_TRAP_METADATA]);
        pr_out_stats(dl, tb[DEVLINK_ATTR_STATS]);
@@ -7040,9 +7033,10 @@ static void pr_out_trap_group(struct dl *dl, struct nlattr **tb, bool array)
        else
                __pr_out_handle_start(dl, tb, true, false);
 
-       pr_out_str(dl, "name",
-                  mnl_attr_get_str(tb[DEVLINK_ATTR_TRAP_GROUP_NAME]));
-       pr_out_bool(dl, "generic", !!tb[DEVLINK_ATTR_TRAP_GENERIC]);
+       check_indent_newline(dl);
+       print_string(PRINT_ANY, "name", "name %s",
+                    mnl_attr_get_str(tb[DEVLINK_ATTR_TRAP_GROUP_NAME]));
+       print_bool(PRINT_ANY, "generic", " generic %s", !!tb[DEVLINK_ATTR_TRAP_GENERIC]);
        pr_out_stats(dl, tb[DEVLINK_ATTR_STATS]);
        pr_out_handle_end(dl);
 }
@@ -7206,18 +7200,9 @@ static int dl_init(struct dl *dl)
                pr_err("Failed to create index map\n");
                goto err_ifname_map_create;
        }
-       if (dl->json_output) {
-               dl->jw = jsonw_new(stdout);
-               if (!dl->jw) {
-                       pr_err("Failed to create JSON writer\n");
-                       goto err_json_new;
-               }
-               jsonw_pretty(dl->jw, dl->pretty_output);
-       }
+       new_json_obj_plain(dl->json_output);
        return 0;
 
-err_json_new:
-       ifname_map_fini(dl);
 err_ifname_map_create:
        mnlg_socket_close(dl->nlg);
        return err;
@@ -7225,8 +7210,7 @@ err_ifname_map_create:
 
 static void dl_fini(struct dl *dl)
 {
-       if (dl->json_output)
-               jsonw_destroy(&dl->jw);
+       delete_json_obj_plain();
        ifname_map_fini(dl);
        mnlg_socket_close(dl->nlg);
 }
@@ -7333,7 +7317,7 @@ int main(int argc, char **argv)
                        dl->json_output = true;
                        break;
                case 'p':
-                       dl->pretty_output = true;
+                       pretty = true;
                        break;
                case 'v':
                        dl->verbose = true;

diff --git a/include/SNAPSHOT.h b/include/SNAPSHOT.h
index b98ad502606b642a80071a1f08702ea02b0023dc..c0fa1bb41f18fcce74cf870b797436f2c6a833fe 100644 (file)
--- a/include/SNAPSHOT.h
+++ b/include/SNAPSHOT.h
@@ -1 +1 @@
-static const char SNAPSHOT[] = "191125";
+static const char SNAPSHOT[] = "200127";

diff --git a/include/json_print.h b/include/json_print.h
index 6695654f719471c8ff7044d0cd775edb2758e9a9..34444793ada2f256b294a9b2196feb6aad2b94d8 100644 (file)
--- a/include/json_print.h
+++ b/include/json_print.h
@@ -31,6 +31,8 @@ enum output_type {
 
 void new_json_obj(int json);
 void delete_json_obj(void);
+void new_json_obj_plain(int json);
+void delete_json_obj_plain(void);
 
 bool is_json_context(void);
 
@@ -72,4 +74,11 @@ _PRINT_FUNC(lluint, unsigned long long)
 _PRINT_FUNC(float, double)
 #undef _PRINT_FUNC
 
+#define _PRINT_NAME_VALUE_FUNC(type_name, type, format_char)             \
+       void print_##type_name##_name_value(const char *name, type value) \
+
+_PRINT_NAME_VALUE_FUNC(uint, unsigned int, u);
+_PRINT_NAME_VALUE_FUNC(string, const char*, s);
+#undef _PRINT_NAME_VALUE_FUNC
+
 #endif /* _JSON_PRINT_H_ */

diff --git a/include/rt_names.h b/include/rt_names.h
index 62ebbd6a38d0314c01755bdac404dae80f76cb69..7afce1705f77590c779e2046e6ddf9fd5b98c8e6 100644 (file)
--- a/include/rt_names.h
+++ b/include/rt_names.h
@@ -33,4 +33,6 @@ int ll_proto_a2n(unsigned short *id, const char *buf);
 const char *nl_proto_n2a(int id, char *buf, int len);
 int nl_proto_a2n(__u32 *id, const char *arg);
 
+extern int numeric;
+
 #endif

diff --git a/ip/ip.c b/ip/ip.c
index fed26f8d48279e76f991c9c5ed31e91e467a4ced..90392c2acfa05540404e8d1db5d6df20c4435827 100644 (file)
--- a/ip/ip.c
+++ b/ip/ip.c
@@ -23,6 +23,7 @@
 #include "ip_common.h"
 #include "namespace.h"
 #include "color.h"
+#include "rt_names.h"
 
 int preferred_family = AF_UNSPEC;
 int human_readable;
@@ -36,7 +37,6 @@ int timestamp;
 int force;
 int max_flush_loops = 10;
 int batch_mode;
-int numeric;
 bool do_all;
 
 struct rtnl_handle rth = { .fd = -1 };

diff --git a/ip/ipaddress.c b/ip/ipaddress.c
index 9415d7682c1247481fff337af45fa6f3ec9f4842..80d27ce27d0c14c34ed796093dc45d47b5cb8d6b 100644 (file)
--- a/ip/ipaddress.c
+++ b/ip/ipaddress.c
@@ -1651,7 +1651,8 @@ static int show_handler(struct rtnl_ctrl_data *ctrl,
        struct ifaddrmsg *ifa = NLMSG_DATA(n);
 
        open_json_object(NULL);
-       print_int(PRINT_ANY, "index", "if%d:\n", ifa->ifa_index);
+       print_int(PRINT_ANY, "index", "if%d:", ifa->ifa_index);
+       print_nl();
        print_addrinfo(n, stdout);
        close_json_object();
        return 0;

diff --git a/ip/iplink_vlan.c b/ip/iplink_vlan.c
index 0dfb4a8d536caaf677fd77959bb969ed94797673..1e6817f5de3d235df6b600bb18798cd84079ade4 100644 (file)
--- a/ip/iplink_vlan.c
+++ b/ip/iplink_vlan.c
@@ -183,7 +183,8 @@ static void vlan_print_map(FILE *f,
        int rem;
 
        open_json_array(PRINT_JSON, name_json);
-       print_string(PRINT_FP, NULL, "\n      %s { ", name_fp);
+       print_nl();
+       print_string(PRINT_FP, NULL, "      %s { ", name_fp);
 
        rem = RTA_PAYLOAD(attr);
        for (i = RTA_DATA(attr); RTA_OK(i, rem); i = RTA_NEXT(i, rem)) {

diff --git a/lib/json_print.c b/lib/json_print.c
index 43ea69bbf73908b61b26248a214b13323aa0252b..8e7f32dca2ce18c6d1ffa91aabcd188e274ac296 100644 (file)
--- a/lib/json_print.c
+++ b/lib/json_print.c
@@ -20,7 +20,7 @@ static json_writer_t *_jw;
 #define _IS_JSON_CONTEXT(type) ((type & PRINT_JSON || type & PRINT_ANY) && _jw)
 #define _IS_FP_CONTEXT(type) (!_jw && (type & PRINT_FP || type & PRINT_ANY))
 
-void new_json_obj(int json)
+static void __new_json_obj(int json, bool have_array)
 {
        if (json) {
                _jw = jsonw_new(stdout);
@@ -30,18 +30,40 @@ void new_json_obj(int json)
                }
                if (pretty)
                        jsonw_pretty(_jw, true);
-               jsonw_start_array(_jw);
+               if (have_array)
+                       jsonw_start_array(_jw);
        }
 }
 
-void delete_json_obj(void)
+static void __delete_json_obj(bool have_array)
 {
        if (_jw) {
-               jsonw_end_array(_jw);
+               if (have_array)
+                       jsonw_end_array(_jw);
                jsonw_destroy(&_jw);
        }
 }
 
+void new_json_obj(int json)
+{
+       __new_json_obj(json, true);
+}
+
+void delete_json_obj(void)
+{
+       __delete_json_obj(true);
+}
+
+void new_json_obj_plain(int json)
+{
+       __new_json_obj(json, false);
+}
+
+void delete_json_obj_plain(void)
+{
+       __delete_json_obj(false);
+}
+
 bool is_json_context(void)
 {
        return _jw != NULL;
@@ -127,6 +149,19 @@ _PRINT_FUNC(lluint, unsigned long long);
 _PRINT_FUNC(float, double);
 #undef _PRINT_FUNC
 
+#define _PRINT_NAME_VALUE_FUNC(type_name, type, format_char)            \
+       void print_##type_name##_name_value(const char *name, type value)\
+       {                                                                \
+               SPRINT_BUF(format);                                      \
+                                                                        \
+               snprintf(format, SPRINT_BSIZE,                           \
+                        "%s %%"#format_char, name);                     \
+               print_##type_name(PRINT_ANY, name, format, value);       \
+       }
+_PRINT_NAME_VALUE_FUNC(uint, unsigned int, u);
+_PRINT_NAME_VALUE_FUNC(string, const char*, s);
+#undef _PRINT_NAME_VALUE_FUNC
+
 void print_color_string(enum output_type type,
                        enum color_attr color,
                        const char *key,

diff --git a/misc/.gitignore b/misc/.gitignore
index f73f7f211e6c88b95e780c4ec5473a160e74e264..d7df0b025c8db006cac96caadbdd247ca28a6595 100644 (file)
--- a/misc/.gitignore
+++ b/misc/.gitignore
@@ -1,7 +1,7 @@
 arpd
 ifstat
 ss
-ssfilter.c
+ssfilter.tab.c
 nstat
 lnstat
 rtacct

diff --git a/misc/Makefile b/misc/Makefile
index 6a849af4be221a3657994dd84c3916e028134e48..1debfb15986f5ec3b704297ffaeeeb24cb219bd2 100644 (file)
--- a/misc/Makefile
+++ b/misc/Makefile
@@ -1,5 +1,5 @@
 # SPDX-License-Identifier: GPL-2.0
-SSOBJ=ss.o ssfilter.o
+SSOBJ=ss.o ssfilter.tab.o
 LNSTATOBJ=lnstat.o lnstat_util.o
 
 TARGETS=ss nstat ifstat rtacct lnstat
@@ -27,8 +27,8 @@ rtacct: rtacct.c
 arpd: arpd.c
        $(QUIET_CC)$(CC) $(CFLAGS) -I$(DBM_INCLUDE) $(CPPFLAGS) $(LDFLAGS) -o arpd arpd.c $(LDLIBS) -ldb
 
-ssfilter.c: ssfilter.y
-       $(QUIET_YACC)bison ssfilter.y -o ssfilter.c
+ssfilter.tab.c: ssfilter.y
+       $(QUIET_YACC)$(YACC) -b ssfilter ssfilter.y
 
 lnstat: $(LNSTATOBJ)
        $(QUIET_LINK)$(CC) $^ $(LDFLAGS) $(LDLIBS) -o $@

diff --git a/misc/ss.c b/misc/ss.c
index 378b985c61ebb51bb8372958ddc3f6cd29c36274..3ef151fbf1f1b3856e95a1baa751a1cdd27d10b7 100644 (file)
--- a/misc/ss.c
+++ b/misc/ss.c
@@ -35,6 +35,7 @@
 #include "libnetlink.h"
 #include "namespace.h"
 #include "SNAPSHOT.h"
+#include "rt_names.h"
 
 #include <linux/tcp.h>
 #include <linux/sock_diag.h>
@@ -121,7 +122,6 @@ static int follow_events;
 static int sctp_ino;
 static int show_tipcinfo;
 static int show_tos;
-int numeric;
 int oneline;
 
 enum col_id {

diff --git a/tc/.gitignore b/tc/.gitignore
index e8e86c97a0fbcbf5f29eeb0240294b751e0bf03c..0dbe91956a38fa2c7bbc3dad16ff29b605c4b59a 100644 (file)
--- a/tc/.gitignore
+++ b/tc/.gitignore
@@ -1,5 +1,5 @@
-*.yacc.c
+*.tab.c
 *.lex.c
 *.output
-*.yacc.h
+*.tab.h
 tc

diff --git a/tc/Makefile b/tc/Makefile
index bea5550f5c31e7ca4034382e05f621823a71fd60..f06ba14b25543aa0ab7eec79684e56c80ee2d174 100644 (file)
--- a/tc/Makefile
+++ b/tc/Makefile
@@ -1,7 +1,7 @@
 # SPDX-License-Identifier: GPL-2.0
 TCOBJ= tc.o tc_qdisc.o tc_class.o tc_filter.o tc_util.o tc_monitor.o \
        tc_exec.o m_police.o m_estimator.o m_action.o m_ematch.o \
-       emp_ematch.yacc.o emp_ematch.lex.o
+       emp_ematch.tab.o emp_ematch.lex.o
 
 include ../config.mk
 
@@ -126,7 +126,6 @@ ifneq ($(IPT_LIB_DIR),)
        CFLAGS += -DIPT_LIB_DIR=\"$(IPT_LIB_DIR)\"
 endif
 
-YACC := bison
 LEX := flex
 CFLAGS += -DYY_NO_INPUT
 
@@ -159,8 +158,8 @@ install: all
        fi
 
 clean:
-       rm -f $(TCOBJ) $(TCLIB) libtc.a tc *.so emp_ematch.yacc.h; \
-       rm -f emp_ematch.yacc.*
+       rm -f $(TCOBJ) $(TCLIB) libtc.a tc *.so emp_ematch.tab.h; \
+       rm -f emp_ematch.tab.*
 
 q_atm.so: q_atm.c
        $(QUIET_CC)$(CC) $(CFLAGS) $(CPPFLAGS) $(LDFLAGS) -shared -fpic -o q_atm.so q_atm.c -latm
@@ -179,8 +178,8 @@ ifeq ($(TC_CONFIG_XT),y)
   LDLIBS += $$($(PKG_CONFIG) xtables --libs)
 endif
 
-%.yacc.c: %.y
-       $(QUIET_YACC)$(YACC) $(YACCFLAGS) -o $@ $<
+%.tab.c: %.y
+       $(QUIET_YACC)$(YACC) $(YACCFLAGS) -p ematch_ -b $(basename $(basename $@)) $<
 
 %.lex.c: %.l
        $(QUIET_LEX)$(LEX) $(LEXFLAGS) -o$@ $<
@@ -188,7 +187,7 @@ endif
 # our lexer includes the header from yacc, so make sure
 # we don't attempt to compile it before the header has
 # been generated as part of the yacc step.
-emp_ematch.lex.o: emp_ematch.yacc.c
+emp_ematch.lex.o: emp_ematch.tab.c
 
 ifneq ($(SHARED_LIBS),y)
 

diff --git a/tc/emp_ematch.l b/tc/emp_ematch.l
index d7a99304ba14c7a7ee59795f4344b960a39780ae..2f4926d43d5b2a9eb55253ac2eb26d2e4c86c1aa 100644 (file)
--- a/tc/emp_ematch.l
+++ b/tc/emp_ematch.l
@@ -1,6 +1,6 @@
 /* SPDX-License-Identifier: GPL-2.0 */
 %{
- #include "emp_ematch.yacc.h"
+ #include "emp_ematch.tab.h"
  #include "m_ematch.h"
 
  extern int ematch_argc;

diff --git a/tc/emp_ematch.y b/tc/emp_ematch.y
index a02e831aa7ea6f3e2af76cef685956b3498e744c..4da3daed095c54a7a98a9c2d540f601c265eba6e 100644 (file)
--- a/tc/emp_ematch.y
+++ b/tc/emp_ematch.y
@@ -6,11 +6,6 @@
  #include "m_ematch.h"
 %}
 
-%locations
-%token-table
-%define parse.error verbose
-%define api.prefix {ematch_}
-
 %union {
        unsigned int i;
        struct bstr *b;

diff --git a/tc/f_flower.c b/tc/f_flower.c
index ce057a72cc7cac08361c51478a57fce3b764ad51..9d59d71f9cd6292821a46fad32571825d1ae5633 100644 (file)
--- a/tc/f_flower.c
+++ b/tc/f_flower.c
@@ -1599,7 +1599,8 @@ static void flower_print_eth_addr(char *name, struct rtattr *addr_attr,
                        sprintf(out + done, "/%d", bits);
        }
 
-       sprintf(namefrm, "\n  %s %%s", name);
+       print_nl();
+       sprintf(namefrm, "  %s %%s", name);
        print_string(PRINT_ANY, name, namefrm, out);
 }
 
@@ -1744,7 +1745,8 @@ static void flower_print_ip_addr(char *name, __be16 eth_type,
        else if (bits < len * 8)
                sprintf(out + done, "/%d", bits);
 
-       sprintf(namefrm, "\n  %s %%s", name);
+       print_nl();
+       sprintf(namefrm, "  %s %%s", name);
        print_string(PRINT_ANY, name, namefrm, out);
 }
 static void flower_print_ip4_addr(char *name, struct rtattr *addr_attr,
@@ -1778,7 +1780,8 @@ static void flower_print_port_range(char *name, struct rtattr *min_attr,
 
                done = sprintf(out, "%u", rta_getattr_be16(min_attr));
                sprintf(out + done, "-%u", rta_getattr_be16(max_attr));
-               sprintf(namefrm, "\n  %s %%s", name);
+               print_nl();
+               sprintf(namefrm, "  %s %%s", name);
                print_string(PRINT_ANY, name, namefrm, out);
        }
 }
@@ -1797,8 +1800,8 @@ static void flower_print_tcp_flags(const char *name, struct rtattr *flags_attr,
        if (mask_attr)
                sprintf(out + done, "/%x", rta_getattr_be16(mask_attr));
 
-       print_string(PRINT_FP, NULL, "%s  ", _SL_);
-       sprintf(namefrm, "%s %%s", name);
+       print_nl();
+       sprintf(namefrm, "  %s %%s", name);
        print_string(PRINT_ANY, name, namefrm, out);
 }
 
@@ -2086,7 +2089,8 @@ static int flower_print_opt(struct filter_util *qu, FILE *f,
        if (tb[TCA_FLOWER_INDEV]) {
                struct rtattr *attr = tb[TCA_FLOWER_INDEV];
 
-               print_string(PRINT_ANY, "indev", "\n  indev %s",
+               print_nl();
+               print_string(PRINT_ANY, "indev", "  indev %s",
                             rta_getattr_str(attr));
        }
 
@@ -2277,7 +2281,6 @@ static int flower_print_opt(struct filter_util *qu, FILE *f,
                        print_nl();
                        print_bool(PRINT_ANY, "skip_sw", "  skip_sw", true);
                }
-
                if (flags & TCA_CLS_FLAGS_IN_HW) {
                        print_nl();
                        print_bool(PRINT_ANY, "in_hw", "  in_hw", true);

diff --git a/tc/q_prio.c b/tc/q_prio.c
index 8ef7cfa260d5bf5a3363a65035247e3ff1c7880a..a723a151bb7fbd720233ac2b128e68013d2cd7e7 100644 (file)
--- a/tc/q_prio.c
+++ b/tc/q_prio.c
@@ -108,7 +108,7 @@ int prio_print_opt(struct qdisc_util *qu, FILE *f, struct rtattr *opt)
                return -1;
 
        print_uint(PRINT_ANY, "bands", "bands %u ", qopt->bands);
-       open_json_array(PRINT_ANY, "priomap ");
+       open_json_array(PRINT_ANY, "priomap");
        for (i = 0; i <= TC_PRIO_MAX; i++)
                print_uint(PRINT_ANY, NULL, " %d", qopt->priomap[i]);
        close_json_array(PRINT_ANY, "");

diff --git a/tc/q_skbprio.c b/tc/q_skbprio.c
index 2e65a5899d8cc26698d4b14c06f3b862bd285d57..ca81a72cc8b1da60d66cfdfffc6e7a5f893cb549 100644 (file)
--- a/tc/q_skbprio.c
+++ b/tc/q_skbprio.c
@@ -73,7 +73,8 @@ static int skbprio_print_opt(struct qdisc_util *qu, FILE *f, struct rtattr *opt)
        if (RTA_PAYLOAD(opt)  < sizeof(*qopt))
                return -1;
        qopt = RTA_DATA(opt);
-       fprintf(f, "limit %u ", qopt->limit);
+
+       print_uint(PRINT_ANY, "limit", "limit %u ", qopt->limit);
        return 0;
 }
 

diff --git a/tc/tc.c b/tc/tc.c
index 37294b31c7dcb8d7c58fec4327b07aef4cc5fd21..b72657ec2e60c8430d850c187b0ef6dcc6d7a268 100644 (file)
--- a/tc/tc.c
+++ b/tc/tc.c
@@ -29,6 +29,7 @@
 #include "tc_util.h"
 #include "tc_common.h"
 #include "namespace.h"
+#include "rt_names.h"
 
 int show_stats;
 int show_details;
@@ -43,7 +44,6 @@ bool use_names;
 int json;
 int color;
 int oneline;
-int numeric;
 
 static char *conf_file;
 

diff --git a/tipc/node.c b/tipc/node.c
index 6c796bfbaac3b47228b711ec53c01b43933df32f..ffdaeaeabfbd059266aecdedba101613b632f85e 100644 (file)
--- a/tipc/node.c
+++ b/tipc/node.c
@@ -179,8 +179,10 @@ static int cmd_node_set_key(struct nlmsghdr *nlh, const struct cmd *cmd,
                            struct cmdl *cmdl, void *data)
 {
        struct {
-               struct tipc_aead_key key;
-               char mem[TIPC_AEAD_KEYLEN_MAX + 1];
+               union {
+                       struct tipc_aead_key key;
+                       char mem[TIPC_AEAD_KEY_SIZE_MAX];
+               };
        } input = {};
        struct opt opts[] = {
                { "algname",    OPT_KEYVAL,     NULL },

diff --git a/tipc/tipc.c b/tipc/tipc.c
index f85ddee0e278d8ff99dd3ab6fce7c274683fe814..60176a044f8d518309be4f625715e7b6d32b470f 100644 (file)
--- a/tipc/tipc.c
+++ b/tipc/tipc.c
@@ -22,10 +22,10 @@
 #include "node.h"
 #include "peer.h"
 #include "cmdl.h"
+#include "utils.h"
 
 int help_flag;
 int json;
-int pretty;
 
 static void about(struct cmdl *cmdl)
 {