data_len = len - offsetof(struct ofp_packet_in, data);
ds_put_format(string, " data_len=%zu", data_len);
- if (htonl(op->buffer_id) == UINT32_MAX) {
+ if (op->buffer_id == htonl(UINT32_MAX)) {
ds_put_format(string, " (unbuffered)");
if (ntohs(op->total_len) != data_len)
ds_put_format(string, " (***total_len != data_len***)");
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:
- return sizeof(struct nx_action_drop_spoofed_arp);
+ 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_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)
{
- uint16_t subtype = ntohs(nah->subtype);
+ int subtype = ntohs(nah->subtype);
int required_len = nx_action_len(subtype);
int len = ntohs(nah->len);
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:
ds_put_format(string, "set_tunnel:%#"PRIx32, ntohl(nast->tun_id));
return;
- case NXAST_DROP_SPOOFED_ARP:
- ds_put_cstr(string, "drop_spoofed_arp");
- return;
-
case NXAST_SET_QUEUE:
nasq = (struct nx_action_set_queue *)nah;
ds_put_format(string, "set_queue:%u", ntohl(nasq->queue_id));
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;
}
}
- ds_put_format(string, "***unknown Nicira action:%"PRIu16"***", subtype);
+ ds_put_format(string, "***unknown Nicira action:%d***", subtype);
}
static int
memcpy(name, port->name, sizeof name);
for (j = 0; j < sizeof name - 1; j++) {
- if (!isprint(name[j])) {
+ if (!isprint((unsigned char) name[j])) {
break;
}
}
}
static void
-print_ip_netmask(struct ds *string, const char *leader, uint32_t ip,
+print_ip_netmask(struct ds *string, const char *leader, ovs_be32 ip,
uint32_t wild_bits, int verbosity)
{
if (wild_bits >= 32 && verbosity < 2) {
skip_type = false;
}
}
- if (w & NXFW_TUN_ID) {
- ds_put_cstr(&f, "tun_id_wild,");
- }
print_wild(&f, "in_port=", w & OFPFW_IN_PORT, verbosity,
"%d", ntohs(om->in_port));
print_wild(&f, "dl_vlan=", w & OFPFW_DL_VLAN, verbosity,
bool need_priority;
int error;
- error = ofputil_decode_flow_mod(&fm, oh, NXFF_OPENFLOW10);
+ error = ofputil_decode_flow_mod(&fm, oh, true);
if (error) {
ofp_print_error(s, error);
return;
default:
ds_put_format(s, "cmd:%d", fm.command);
}
+ if (fm.table_id != 0) {
+ ds_put_format(s, " table:%d", fm.table_id);
+ }
ds_put_char(s, ' ');
if (verbosity >= 3 && code == OFPUTIL_OFPT_FLOW_MOD) {
struct ofputil_flow_removed fr;
int error;
- error = ofputil_decode_flow_removed(&fr, oh, NXFF_OPENFLOW10);
+ error = ofputil_decode_flow_removed(&fr, oh);
if (error) {
ofp_print_error(string, error);
return;
}
static void
-ofp_print_ofpst_desc_reply(struct ds *string, const struct ofp_header *oh)
+ofp_print_ofpst_desc_reply(struct ds *string, const struct ofp_desc_stats *ods)
{
- const struct ofp_desc_stats *ods = ofputil_stats_body(oh);
-
ds_put_char(string, '\n');
ds_put_format(string, "Manufacturer: %.*s\n",
(int) sizeof ods->mfr_desc, ods->mfr_desc);
}
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;
int error;
- error = ofputil_decode_flow_stats_request(&fsr, oh, NXFF_OPENFLOW10);
+ 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) {
struct ofputil_flow_stats fs;
int retval;
- retval = ofputil_decode_flow_stats_reply(&fs, &b, NXFF_OPENFLOW10);
+ retval = ofputil_decode_flow_stats_reply(&fs, &b);
if (retval) {
if (retval != EOF) {
ds_put_cstr(string, " ***parse error***");
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) {
}
static void
-ofp_print_ofp_aggregate_stats_reply (
- struct ds *string, const struct ofp_aggregate_stats_reply *asr)
+ofp_print_ofpst_aggregate_reply(struct ds *string,
+ const struct ofp_aggregate_stats_reply *asr)
{
ds_put_format(string, " packet_count=%"PRIu64,
ntohll(get_32aligned_be64(&asr->packet_count)));
ds_put_format(string, " flow_count=%"PRIu32, ntohl(asr->flow_count));
}
-static void
-ofp_print_ofpst_aggregate_reply(struct ds *string, const struct ofp_header *oh)
-{
- ofp_print_ofp_aggregate_stats_reply(string, ofputil_stats_body(oh));
-}
-
static void
ofp_print_nxst_aggregate_reply(struct ds *string,
const struct nx_aggregate_stats_reply *nasr)
{
- ofp_print_ofp_aggregate_stats_reply(string, &nasr->asr);
+ ds_put_format(string, " packet_count=%"PRIu64, ntohll(nasr->packet_count));
+ ds_put_format(string, " byte_count=%"PRIu64, ntohll(nasr->byte_count));
+ ds_put_format(string, " flow_count=%"PRIu32, ntohl(nasr->flow_count));
}
static void print_port_stat(struct ds *string, const char *leader,
}
static void
-ofp_print_ofpst_port_request(struct ds *string, const struct ofp_header *oh)
+ofp_print_ofpst_port_request(struct ds *string,
+ const struct ofp_port_stats_request *psr)
{
- const struct ofp_port_stats_request *psr = ofputil_stats_body(oh);
ds_put_format(string, " port_no=%"PRIu16, ntohs(psr->port_no));
}
}
static void
-ofp_print_ofpst_queue_request(struct ds *string, const struct ofp_header *oh)
+ofp_print_ofpst_queue_request(struct ds *string,
+ const struct ofp_queue_stats_request *qsr)
{
- const struct ofp_queue_stats_request *qsr = ofputil_stats_body(oh);
-
ds_put_cstr(string, "port=");
ofp_print_port_name(string, ntohs(qsr->port_no));
static void
ofp_print_stats_request(struct ds *string, const struct ofp_header *oh)
{
- const struct ofp_stats_request *srq
- = (const struct ofp_stats_request *) oh;
+ const struct ofp_stats_msg *srq = (const struct ofp_stats_msg *) oh;
if (srq->flags) {
ds_put_format(string, " ***unknown flags 0x%04"PRIx16"***",
static void
ofp_print_stats_reply(struct ds *string, const struct ofp_header *oh)
{
- const struct ofp_stats_reply *srp = (const struct ofp_stats_reply *) oh;
+ const struct ofp_stats_msg *srp = (const struct ofp_stats_msg *) oh;
if (srp->flags) {
uint16_t flags = ntohs(srp->flags);
}
}
-static void
-ofp_print_nxt_status_message(struct ds *string, const struct ofp_header *oh)
-{
- struct ofpbuf b;
-
- ofpbuf_use_const(&b, oh, ntohs(oh->length));
- ofpbuf_pull(&b, sizeof(struct nicira_header));
- ds_put_cstr(string, " \"");
- ds_put_printable(string, b.data, b.size);
- ds_put_char(string, '"');
-}
-
-static void
-ofp_print_nxt_tun_id_from_cookie(struct ds *string,
- const struct nxt_tun_id_cookie *ntic)
-{
- ds_put_format(string, " set=%"PRIu8, ntic->set);
-}
-
static void
ofp_print_nxt_role_message(struct ds *string,
const struct nx_role_request *nrr)
}
}
+static void
+ofp_print_nxt_flow_mod_table_id(struct ds *string,
+ const struct nxt_flow_mod_table_id *nfmti)
+{
+ ds_put_format(string, " %s", nfmti->set ? "enable" : "disable");
+}
+
static void
ofp_print_nxt_set_flow_format(struct ds *string,
const struct nxt_set_flow_format *nsff)
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:
case OFPUTIL_OFPST_PORT_REQUEST:
ofp_print_stats_request(string, oh);
- ofp_print_ofpst_port_request(string, oh);
+ ofp_print_ofpst_port_request(string, msg);
break;
case OFPUTIL_OFPST_QUEUE_REQUEST:
ofp_print_stats_request(string, oh);
- ofp_print_ofpst_queue_request(string, oh);
+ ofp_print_ofpst_queue_request(string, msg);
break;
case OFPUTIL_OFPST_DESC_REPLY:
ofp_print_stats_reply(string, oh);
- ofp_print_ofpst_desc_reply(string, oh);
+ ofp_print_ofpst_desc_reply(string, msg);
break;
case OFPUTIL_OFPST_FLOW_REPLY:
case OFPUTIL_OFPST_AGGREGATE_REPLY:
ofp_print_stats_reply(string, oh);
- ofp_print_ofpst_aggregate_reply(string, oh);
- break;
-
- case OFPUTIL_NXT_STATUS_REQUEST:
- case OFPUTIL_NXT_STATUS_REPLY:
- ofp_print_nxt_status_message(string, oh);
- break;
-
- case OFPUTIL_NXT_TUN_ID_FROM_COOKIE:
- ofp_print_nxt_tun_id_from_cookie(string, msg);
+ ofp_print_ofpst_aggregate_reply(string, msg);
break;
case OFPUTIL_NXT_ROLE_REQUEST:
ofp_print_nxt_role_message(string, msg);
break;
+ case OFPUTIL_NXT_FLOW_MOD_TABLE_ID:
+ ofp_print_nxt_flow_mod_table_id(string, msg);
+ break;
+
case OFPUTIL_NXT_SET_FLOW_FORMAT:
ofp_print_nxt_set_flow_format(string, msg);
break;