X-Git-Url: http://git.onelab.eu/?a=blobdiff_plain;f=lib%2Fofp-print.c;h=d1a661bf210fa941fdef337951bb4073fd4bffc5;hb=81d1ea941425aea5eff1d9582ad12c9b3b528fe8;hp=828740acbc28be7791b4e3069350308f1d1697eb;hpb=63f2140a553dbbda9f19019a03abb088c7e7fa29;p=sliver-openvswitch.git diff --git a/lib/ofp-print.c b/lib/ofp-print.c index 828740acb..d1a661bf2 100644 --- a/lib/ofp-print.c +++ b/lib/ofp-print.c @@ -26,6 +26,7 @@ #include #include +#include "bundle.h" #include "byte-order.h" #include "compiler.h" #include "dynamic-string.h" @@ -203,312 +204,194 @@ print_note(struct ds *string, const struct nx_action_note *nan) } } -static int -nx_action_len(enum nx_action_subtype subtype) -{ - switch (subtype) { - case NXAST_SNAT__OBSOLETE: return -1; - case NXAST_RESUBMIT: return sizeof(struct nx_action_resubmit); - case NXAST_SET_TUNNEL: return sizeof(struct nx_action_set_tunnel); - case NXAST_DROP_SPOOFED_ARP__OBSOLETE: return -1; - case NXAST_SET_QUEUE: return sizeof(struct nx_action_set_queue); - case NXAST_POP_QUEUE: return sizeof(struct nx_action_pop_queue); - case NXAST_REG_MOVE: return sizeof(struct nx_action_reg_move); - case NXAST_REG_LOAD: return sizeof(struct nx_action_reg_load); - case NXAST_NOTE: return -1; - case NXAST_SET_TUNNEL64: return sizeof(struct nx_action_set_tunnel64); - case NXAST_MULTIPATH: return sizeof(struct nx_action_multipath); - case NXAST_AUTOPATH: return sizeof (struct nx_action_autopath); - default: return -1; - } -} - static void -ofp_print_nx_action(struct ds *string, const struct nx_action_header *nah) +ofp_print_action(struct ds *s, const union ofp_action *a, + enum ofputil_action_code code) { - int subtype = ntohs(nah->subtype); - int required_len = nx_action_len(subtype); - int len = ntohs(nah->len); - - if (required_len != -1 && required_len != len) { - ds_put_format(string, "***Nicira action %"PRIu16" wrong length: %d***", - subtype, len); - return; - } + const struct ofp_action_enqueue *oae; + const struct ofp_action_dl_addr *oada; + const struct nx_action_set_tunnel64 *nast64; + const struct nx_action_set_tunnel *nast; + const struct nx_action_set_queue *nasq; + const struct nx_action_resubmit *nar; + const struct nx_action_reg_move *move; + const struct nx_action_reg_load *load; + const struct nx_action_multipath *nam; + const struct nx_action_autopath *naa; + uint16_t port; - if (subtype <= TYPE_MAXIMUM(enum nx_action_subtype)) { - const struct nx_action_set_tunnel64 *nast64; - const struct nx_action_set_tunnel *nast; - const struct nx_action_set_queue *nasq; - const struct nx_action_resubmit *nar; - const struct nx_action_reg_move *move; - const struct nx_action_reg_load *load; - const struct nx_action_multipath *nam; - const struct nx_action_autopath *naa; - - switch ((enum nx_action_subtype) subtype) { - case NXAST_RESUBMIT: - nar = (struct nx_action_resubmit *)nah; - ds_put_format(string, "resubmit:"); - ofp_print_port_name(string, ntohs(nar->in_port)); - return; - - case NXAST_SET_TUNNEL: - nast = (struct nx_action_set_tunnel *)nah; - ds_put_format(string, "set_tunnel:%#"PRIx32, ntohl(nast->tun_id)); - return; - - case NXAST_SET_QUEUE: - nasq = (struct nx_action_set_queue *)nah; - ds_put_format(string, "set_queue:%u", ntohl(nasq->queue_id)); - return; - - case NXAST_POP_QUEUE: - ds_put_cstr(string, "pop_queue"); - return; - - case NXAST_NOTE: - print_note(string, (const struct nx_action_note *) nah); - return; - - case NXAST_REG_MOVE: - move = (const struct nx_action_reg_move *) nah; - nxm_format_reg_move(move, string); - return; - - case NXAST_REG_LOAD: - load = (const struct nx_action_reg_load *) nah; - nxm_format_reg_load(load, string); - return; - - case NXAST_SET_TUNNEL64: - nast64 = (const struct nx_action_set_tunnel64 *) nah; - ds_put_format(string, "set_tunnel64:%#"PRIx64, - ntohll(nast64->tun_id)); - return; - - case NXAST_MULTIPATH: - nam = (const struct nx_action_multipath *) nah; - multipath_format(nam, string); - return; - - case NXAST_AUTOPATH: - naa = (const struct nx_action_autopath *)nah; - ds_put_format(string, "autopath(%u,", ntohl(naa->id)); - nxm_format_field_bits(string, ntohl(naa->dst), - nxm_decode_ofs(naa->ofs_nbits), - nxm_decode_n_bits(naa->ofs_nbits)); - ds_put_char(string, ')'); - return; - - case NXAST_SNAT__OBSOLETE: - case NXAST_DROP_SPOOFED_ARP__OBSOLETE: - default: - break; + switch (code) { + case OFPUTIL_OFPAT_OUTPUT: + port = ntohs(a->output.port); + if (port < OFPP_MAX) { + ds_put_format(s, "output:%"PRIu16, port); + } else { + ofp_print_port_name(s, port); + if (port == OFPP_CONTROLLER) { + if (a->output.max_len != htons(0)) { + ds_put_format(s, ":%"PRIu16, ntohs(a->output.max_len)); + } else { + ds_put_cstr(s, ":all"); + } + } } - } + break; - ds_put_format(string, "***unknown Nicira action:%d***", subtype); -} + case OFPUTIL_OFPAT_ENQUEUE: + oae = (const struct ofp_action_enqueue *) a; + ds_put_format(s, "enqueue:"); + ofp_print_port_name(s, ntohs(oae->port)); + ds_put_format(s, "q%"PRIu32, ntohl(oae->queue_id)); + break; -static int -ofp_action_len(enum ofp_action_type type) -{ - switch (type) { - case OFPAT_OUTPUT: return sizeof(struct ofp_action_output); - case OFPAT_SET_VLAN_VID: return sizeof(struct ofp_action_vlan_vid); - case OFPAT_SET_VLAN_PCP: return sizeof(struct ofp_action_vlan_pcp); - case OFPAT_STRIP_VLAN: return sizeof(struct ofp_action_header); - case OFPAT_SET_DL_SRC: return sizeof(struct ofp_action_dl_addr); - case OFPAT_SET_DL_DST: return sizeof(struct ofp_action_dl_addr); - case OFPAT_SET_NW_SRC: return sizeof(struct ofp_action_nw_addr); - case OFPAT_SET_NW_DST: return sizeof(struct ofp_action_nw_addr); - case OFPAT_SET_NW_TOS: return sizeof(struct ofp_action_nw_tos); - case OFPAT_SET_TP_SRC: return sizeof(struct ofp_action_tp_port); - case OFPAT_SET_TP_DST: return sizeof(struct ofp_action_tp_port); - case OFPAT_ENQUEUE: return sizeof(struct ofp_action_enqueue); - case OFPAT_VENDOR: return -1; - default: return -1; - } -} + case OFPUTIL_OFPAT_SET_VLAN_VID: + ds_put_format(s, "mod_vlan_vid:%"PRIu16, + ntohs(a->vlan_vid.vlan_vid)); + break; -static int -ofp_print_action(struct ds *string, const struct ofp_action_header *ah, - size_t actions_len) -{ - enum ofp_action_type type; - int required_len; - size_t len; + case OFPUTIL_OFPAT_SET_VLAN_PCP: + ds_put_format(s, "mod_vlan_pcp:%"PRIu8, a->vlan_pcp.vlan_pcp); + break; - if (actions_len < sizeof *ah) { - ds_put_format(string, "***action array too short for next action***\n"); - return -1; - } + case OFPUTIL_OFPAT_STRIP_VLAN: + ds_put_cstr(s, "strip_vlan"); + break; - type = ntohs(ah->type); - len = ntohs(ah->len); - if (actions_len < len) { - ds_put_format(string, "***truncated action %d***\n", (int) type); - return -1; - } + case OFPUTIL_OFPAT_SET_DL_SRC: + oada = (const struct ofp_action_dl_addr *) a; + ds_put_format(s, "mod_dl_src:"ETH_ADDR_FMT, + ETH_ADDR_ARGS(oada->dl_addr)); + break; - if (!len) { - ds_put_format(string, "***zero-length action***\n"); - return 8; - } + case OFPUTIL_OFPAT_SET_DL_DST: + oada = (const struct ofp_action_dl_addr *) a; + ds_put_format(s, "mod_dl_dst:"ETH_ADDR_FMT, + ETH_ADDR_ARGS(oada->dl_addr)); + break; - if ((len % OFP_ACTION_ALIGN) != 0) { - ds_put_format(string, - "***action %d length not a multiple of %d***\n", - (int) type, OFP_ACTION_ALIGN); - return -1; - } + case OFPUTIL_OFPAT_SET_NW_SRC: + ds_put_format(s, "mod_nw_src:"IP_FMT, IP_ARGS(&a->nw_addr.nw_addr)); + break; - required_len = ofp_action_len(type); - if (required_len >= 0 && len != required_len) { - ds_put_format(string, - "***action %d wrong length: %zu***\n", (int) type, len); - return -1; - } + case OFPUTIL_OFPAT_SET_NW_DST: + ds_put_format(s, "mod_nw_dst:"IP_FMT, IP_ARGS(&a->nw_addr.nw_addr)); + break; - switch (type) { - case OFPAT_OUTPUT: { - struct ofp_action_output *oa = (struct ofp_action_output *)ah; - uint16_t port = ntohs(oa->port); - if (port < OFPP_MAX) { - ds_put_format(string, "output:%"PRIu16, port); - } else { - ofp_print_port_name(string, port); - if (port == OFPP_CONTROLLER) { - if (oa->max_len) { - ds_put_format(string, ":%"PRIu16, ntohs(oa->max_len)); - } else { - ds_put_cstr(string, ":all"); - } - } - } + case OFPUTIL_OFPAT_SET_NW_TOS: + ds_put_format(s, "mod_nw_tos:%d", a->nw_tos.nw_tos); break; - } - case OFPAT_ENQUEUE: { - struct ofp_action_enqueue *ea = (struct ofp_action_enqueue *)ah; - unsigned int port = ntohs(ea->port); - unsigned int queue_id = ntohl(ea->queue_id); - ds_put_format(string, "enqueue:"); - if (port != OFPP_IN_PORT) { - ds_put_format(string, "%u", port); - } else { - ds_put_cstr(string, "IN_PORT"); - } - ds_put_format(string, "q%u", queue_id); + case OFPUTIL_OFPAT_SET_TP_SRC: + ds_put_format(s, "mod_tp_src:%d", ntohs(a->tp_port.tp_port)); break; - } - case OFPAT_SET_VLAN_VID: { - struct ofp_action_vlan_vid *va = (struct ofp_action_vlan_vid *)ah; - ds_put_format(string, "mod_vlan_vid:%"PRIu16, ntohs(va->vlan_vid)); + case OFPUTIL_OFPAT_SET_TP_DST: + ds_put_format(s, "mod_tp_dst:%d", ntohs(a->tp_port.tp_port)); break; - } - case OFPAT_SET_VLAN_PCP: { - struct ofp_action_vlan_pcp *va = (struct ofp_action_vlan_pcp *)ah; - ds_put_format(string, "mod_vlan_pcp:%"PRIu8, va->vlan_pcp); + case OFPUTIL_NXAST_RESUBMIT: + nar = (struct nx_action_resubmit *)a; + ds_put_format(s, "resubmit:"); + ofp_print_port_name(s, ntohs(nar->in_port)); break; - } - case OFPAT_STRIP_VLAN: - ds_put_cstr(string, "strip_vlan"); + case OFPUTIL_NXAST_RESUBMIT_TABLE: + nar = (struct nx_action_resubmit *)a; + ds_put_format(s, "resubmit("); + if (nar->in_port != htons(OFPP_IN_PORT)) { + ofp_print_port_name(s, ntohs(nar->in_port)); + } + ds_put_char(s, ','); + if (nar->table != 255) { + ds_put_format(s, "%"PRIu8, nar->table); + } + ds_put_char(s, ')'); break; - case OFPAT_SET_DL_SRC: { - struct ofp_action_dl_addr *da = (struct ofp_action_dl_addr *)ah; - ds_put_format(string, "mod_dl_src:"ETH_ADDR_FMT, - ETH_ADDR_ARGS(da->dl_addr)); + case OFPUTIL_NXAST_SET_TUNNEL: + nast = (struct nx_action_set_tunnel *)a; + ds_put_format(s, "set_tunnel:%#"PRIx32, ntohl(nast->tun_id)); break; - } - case OFPAT_SET_DL_DST: { - struct ofp_action_dl_addr *da = (struct ofp_action_dl_addr *)ah; - ds_put_format(string, "mod_dl_dst:"ETH_ADDR_FMT, - ETH_ADDR_ARGS(da->dl_addr)); + case OFPUTIL_NXAST_SET_QUEUE: + nasq = (struct nx_action_set_queue *)a; + ds_put_format(s, "set_queue:%u", ntohl(nasq->queue_id)); break; - } - case OFPAT_SET_NW_SRC: { - struct ofp_action_nw_addr *na = (struct ofp_action_nw_addr *)ah; - ds_put_format(string, "mod_nw_src:"IP_FMT, IP_ARGS(&na->nw_addr)); + case OFPUTIL_NXAST_POP_QUEUE: + ds_put_cstr(s, "pop_queue"); break; - } - case OFPAT_SET_NW_DST: { - struct ofp_action_nw_addr *na = (struct ofp_action_nw_addr *)ah; - ds_put_format(string, "mod_nw_dst:"IP_FMT, IP_ARGS(&na->nw_addr)); + case OFPUTIL_NXAST_NOTE: + print_note(s, (const struct nx_action_note *) a); break; - } - case OFPAT_SET_NW_TOS: { - struct ofp_action_nw_tos *nt = (struct ofp_action_nw_tos *)ah; - ds_put_format(string, "mod_nw_tos:%d", nt->nw_tos); + case OFPUTIL_NXAST_REG_MOVE: + move = (const struct nx_action_reg_move *) a; + nxm_format_reg_move(move, s); break; - } - case OFPAT_SET_TP_SRC: { - struct ofp_action_tp_port *ta = (struct ofp_action_tp_port *)ah; - ds_put_format(string, "mod_tp_src:%d", ntohs(ta->tp_port)); + case OFPUTIL_NXAST_REG_LOAD: + load = (const struct nx_action_reg_load *) a; + nxm_format_reg_load(load, s); break; - } - case OFPAT_SET_TP_DST: { - struct ofp_action_tp_port *ta = (struct ofp_action_tp_port *)ah; - ds_put_format(string, "mod_tp_dst:%d", ntohs(ta->tp_port)); + case OFPUTIL_NXAST_SET_TUNNEL64: + nast64 = (const struct nx_action_set_tunnel64 *) a; + ds_put_format(s, "set_tunnel64:%#"PRIx64, + ntohll(nast64->tun_id)); break; - } - case OFPAT_VENDOR: { - struct ofp_action_vendor_header *avh - = (struct ofp_action_vendor_header *)ah; - if (len < sizeof *avh) { - ds_put_format(string, "***ofpat_vendor truncated***\n"); - return -1; - } - if (avh->vendor == htonl(NX_VENDOR_ID)) { - ofp_print_nx_action(string, (struct nx_action_header *)avh); - } else { - ds_put_format(string, "vendor action:0x%x", ntohl(avh->vendor)); - } + case OFPUTIL_NXAST_MULTIPATH: + nam = (const struct nx_action_multipath *) a; + multipath_format(nam, s); + break; + + case OFPUTIL_NXAST_AUTOPATH: + naa = (const struct nx_action_autopath *)a; + ds_put_format(s, "autopath(%u,", ntohl(naa->id)); + nxm_format_field_bits(s, ntohl(naa->dst), + nxm_decode_ofs(naa->ofs_nbits), + nxm_decode_n_bits(naa->ofs_nbits)); + ds_put_char(s, ')'); + break; + + case OFPUTIL_NXAST_BUNDLE: + case OFPUTIL_NXAST_BUNDLE_LOAD: + bundle_format((const struct nx_action_bundle *) a, s); break; - } default: - ds_put_format(string, "(decoder %d not implemented)", (int) type); break; } - - return len; } void -ofp_print_actions(struct ds *string, const struct ofp_action_header *action, - size_t actions_len) +ofp_print_actions(struct ds *string, const union ofp_action *actions, + size_t n_actions) { - uint8_t *p = (uint8_t *)action; - int len = 0; + const union ofp_action *a; + size_t left; ds_put_cstr(string, "actions="); - if (!actions_len) { + if (!n_actions) { ds_put_cstr(string, "drop"); } - while (actions_len > 0) { - if (len) { - ds_put_cstr(string, ","); - } - len = ofp_print_action(string, (struct ofp_action_header *)p, - actions_len); - if (len < 0) { - return; + + OFPUTIL_ACTION_FOR_EACH (a, left, actions, n_actions) { + int code = ofputil_decode_action(a); + if (code >= 0) { + if (a != actions) { + ds_put_cstr(string, ","); + } + ofp_print_action(string, a, code); + } else { + ofp_print_error(string, -code); } - p += len; - actions_len -= len; + } + if (left > 0) { + ds_put_format(string, " ***%zu leftover bytes following actions", + left * sizeof *a); } } @@ -527,7 +410,12 @@ ofp_print_packet_out(struct ds *string, const struct ofp_packet_out *opo, ds_put_format(string, "***packet too short for action length***\n"); return; } - ofp_print_actions(string, opo->actions, actions_len); + if (actions_len % sizeof(union ofp_action)) { + ds_put_format(string, "***action length not a multiple of %zu***\n", + sizeof(union ofp_action)); + } + ofp_print_actions(string, (const union ofp_action *) opo->actions, + actions_len / sizeof(union ofp_action)); if (ntohl(opo->buffer_id) == UINT32_MAX) { int data_len = len - sizeof *opo - actions_len; @@ -557,47 +445,108 @@ compare_ports(const void *a_, const void *b_) return ap < bp ? -1 : ap > bp; } -static void ofp_print_port_features(struct ds *string, uint32_t features) +struct bit_name { + uint32_t bit; + const char *name; +}; + +static void +ofp_print_bit_names(struct ds *string, uint32_t bits, + const struct bit_name bit_names[]) { - if (features == 0) { - ds_put_cstr(string, "Unsupported\n"); + int n = 0; + + if (!bits) { + ds_put_cstr(string, "0"); return; } - if (features & OFPPF_10MB_HD) { - ds_put_cstr(string, "10MB-HD "); - } - if (features & OFPPF_10MB_FD) { - ds_put_cstr(string, "10MB-FD "); - } - if (features & OFPPF_100MB_HD) { - ds_put_cstr(string, "100MB-HD "); - } - if (features & OFPPF_100MB_FD) { - ds_put_cstr(string, "100MB-FD "); - } - if (features & OFPPF_1GB_HD) { - ds_put_cstr(string, "1GB-HD "); - } - if (features & OFPPF_1GB_FD) { - ds_put_cstr(string, "1GB-FD "); - } - if (features & OFPPF_10GB_FD) { - ds_put_cstr(string, "10GB-FD "); - } - if (features & OFPPF_COPPER) { - ds_put_cstr(string, "COPPER "); - } - if (features & OFPPF_FIBER) { - ds_put_cstr(string, "FIBER "); - } - if (features & OFPPF_AUTONEG) { - ds_put_cstr(string, "AUTO_NEG "); + + for (; bits && bit_names->name; bit_names++) { + if (bits & bit_names->bit) { + if (n++) { + ds_put_char(string, ' '); + } + ds_put_cstr(string, bit_names->name); + bits &= ~bit_names->bit; + } } - if (features & OFPPF_PAUSE) { - ds_put_cstr(string, "AUTO_PAUSE "); + + if (bits) { + if (n++) { + ds_put_char(string, ' '); + } + ds_put_format(string, "0x%"PRIx32, bits); } - if (features & OFPPF_PAUSE_ASYM) { - ds_put_cstr(string, "AUTO_PAUSE_ASYM "); +} + +static void +ofp_print_port_features(struct ds *string, uint32_t features) +{ + static const struct bit_name feature_bits[] = { + { OFPPF_10MB_HD, "10MB-HD" }, + { OFPPF_10MB_FD, "10MB-FD" }, + { OFPPF_100MB_HD, "100MB-HD" }, + { OFPPF_100MB_FD, "100MB-FD" }, + { OFPPF_1GB_HD, "1GB-HD" }, + { OFPPF_1GB_FD, "1GB-FD" }, + { OFPPF_10GB_FD, "10GB-FD" }, + { OFPPF_COPPER, "COPPER" }, + { OFPPF_FIBER, "FIBER" }, + { OFPPF_AUTONEG, "AUTO_NEG" }, + { OFPPF_PAUSE, "AUTO_PAUSE" }, + { OFPPF_PAUSE_ASYM, "AUTO_PAUSE_ASYM" }, + { 0, NULL }, + }; + + ofp_print_bit_names(string, features, feature_bits); + ds_put_char(string, '\n'); +} + +static void +ofp_print_port_config(struct ds *string, uint32_t config) +{ + static const struct bit_name config_bits[] = { + { OFPPC_PORT_DOWN, "PORT_DOWN" }, + { OFPPC_NO_STP, "NO_STP" }, + { OFPPC_NO_RECV, "NO_RECV" }, + { OFPPC_NO_RECV_STP, "NO_RECV_STP" }, + { OFPPC_NO_FLOOD, "NO_FLOOD" }, + { OFPPC_NO_FWD, "NO_FWD" }, + { OFPPC_NO_PACKET_IN, "NO_PACKET_IN" }, + { 0, NULL }, + }; + + ofp_print_bit_names(string, config, config_bits); + ds_put_char(string, '\n'); +} + +static void +ofp_print_port_state(struct ds *string, uint32_t state) +{ + static const struct bit_name state_bits[] = { + { OFPPS_LINK_DOWN, "LINK_DOWN" }, + { 0, NULL }, + }; + uint32_t stp_state; + + /* The STP state is a 2-bit field so it doesn't fit in with the bitmask + * pattern. We have to special case it. + * + * OVS doesn't support STP, so this field will always be 0 if we are + * talking to OVS, so we'd always print STP_LISTEN in that case. + * Therefore, we don't print anything at all if the value is STP_LISTEN, to + * avoid confusing users. */ + stp_state = state & OFPPS_STP_MASK; + if (stp_state) { + ds_put_cstr(string, (stp_state == OFPPS_STP_LEARN ? "STP_LEARN" + : stp_state == OFPPS_STP_FORWARD ? "STP_FORWARD" + : "STP_BLOCK")); + state &= ~OFPPS_STP_MASK; + if (state) { + ofp_print_bit_names(string, state, state_bits); + } + } else { + ofp_print_bit_names(string, state, state_bits); } ds_put_char(string, '\n'); } @@ -618,9 +567,15 @@ ofp_print_phy_port(struct ds *string, const struct ofp_phy_port *port) ds_put_char(string, ' '); ofp_print_port_name(string, ntohs(port->port_no)); - ds_put_format(string, "(%s): addr:"ETH_ADDR_FMT", config: %#x, state:%#x\n", - name, ETH_ADDR_ARGS(port->hw_addr), ntohl(port->config), - ntohl(port->state)); + ds_put_format(string, "(%s): addr:"ETH_ADDR_FMT"\n", + name, ETH_ADDR_ARGS(port->hw_addr)); + + ds_put_cstr(string, " config: "); + ofp_print_port_config(string, ntohl(port->config)); + + ds_put_cstr(string, " state: "); + ofp_print_port_state(string, ntohl(port->state)); + if (port->curr) { ds_put_format(string, " current: "); ofp_print_port_features(string, ntohl(port->curr)); @@ -796,7 +751,7 @@ ofp_match_to_string(const struct ofp_match *om, int verbosity) (w & OFPFW_NW_DST_MASK) >> OFPFW_NW_DST_SHIFT, verbosity); if (!skip_proto) { if (om->dl_type == htons(ETH_TYPE_ARP)) { - print_wild(&f, "opcode=", w & OFPFW_NW_PROTO, verbosity, + print_wild(&f, "arp_op=", w & OFPFW_NW_PROTO, verbosity, "%u", om->nw_proto); } else { print_wild(&f, "nw_proto=", w & OFPFW_NW_PROTO, verbosity, @@ -826,7 +781,7 @@ static void ofp_print_flow_mod(struct ds *s, const struct ofp_header *oh, enum ofputil_msg_code code, int verbosity) { - struct flow_mod fm; + struct ofputil_flow_mod fm; bool need_priority; int error; @@ -857,7 +812,7 @@ ofp_print_flow_mod(struct ds *s, const struct ofp_header *oh, ds_put_format(s, "cmd:%d", fm.command); } if (fm.table_id != 0) { - ds_put_format(s, " table_id:%d", fm.table_id); + ds_put_format(s, " table:%d", fm.table_id); } ds_put_char(s, ' '); @@ -907,8 +862,7 @@ ofp_print_flow_mod(struct ds *s, const struct ofp_header *oh, ds_put_format(s, "flags:0x%"PRIx16" ", fm.flags); } - ofp_print_actions(s, (const struct ofp_action_header *) fm.actions, - fm.n_actions * sizeof *fm.actions); + ofp_print_actions(s, fm.actions, fm.n_actions); } static void @@ -1059,19 +1013,20 @@ ofp_print_ofpst_desc_reply(struct ds *string, const struct ofp_desc_stats *ods) } static void -ofp_print_flow_stats_request(struct ds *string, const struct ofp_header *oh) +ofp_print_flow_stats_request(struct ds *string, + const struct ofp_stats_msg *osm) { - struct flow_stats_request fsr; + struct ofputil_flow_stats_request fsr; int error; - error = ofputil_decode_flow_stats_request(&fsr, oh); + error = ofputil_decode_flow_stats_request(&fsr, &osm->header); if (error) { ofp_print_error(string, error); return; } if (fsr.table_id != 0xff) { - ds_put_format(string, " table_id=%"PRIu8, fsr.table_id); + ds_put_format(string, " table=%"PRIu8, fsr.table_id); } if (fsr.out_port != OFPP_NONE) { @@ -1110,7 +1065,7 @@ ofp_print_flow_stats_reply(struct ds *string, const struct ofp_header *oh) ds_put_format(string, " cookie=0x%"PRIx64", duration=", ntohll(fs.cookie)); ofp_print_duration(string, fs.duration_sec, fs.duration_nsec); - ds_put_format(string, ", table_id=%"PRIu8", ", fs.table_id); + ds_put_format(string, ", table=%"PRIu8", ", fs.table_id); ds_put_format(string, "n_packets=%"PRIu64", ", fs.packet_count); ds_put_format(string, "n_bytes=%"PRIu64", ", fs.byte_count); if (fs.idle_timeout != OFP_FLOW_PERMANENT) { @@ -1122,9 +1077,7 @@ ofp_print_flow_stats_reply(struct ds *string, const struct ofp_header *oh) cls_rule_format(&fs.rule, string); ds_put_char(string, ' '); - ofp_print_actions(string, - (const struct ofp_action_header *) fs.actions, - fs.n_actions * sizeof *fs.actions); + ofp_print_actions(string, fs.actions, fs.n_actions); } } @@ -1371,7 +1324,7 @@ ofp_to_string__(const struct ofp_header *oh, code = ofputil_msg_type_code(type); switch (code) { - case OFPUTIL_INVALID: + case OFPUTIL_MSG_INVALID: break; case OFPUTIL_OFPT_HELLO: @@ -1447,7 +1400,7 @@ ofp_to_string__(const struct ofp_header *oh, case OFPUTIL_OFPST_AGGREGATE_REQUEST: case OFPUTIL_NXST_AGGREGATE_REQUEST: ofp_print_stats_request(string, oh); - ofp_print_flow_stats_request(string, oh); + ofp_print_flow_stats_request(string, msg); break; case OFPUTIL_OFPST_TABLE_REQUEST: