/*
- * Copyright (c) 2008, 2009, 2010, 2011, 2012 Nicira, Inc.
+ * Copyright (c) 2008, 2009, 2010, 2011, 2012, 2013 Nicira, Inc.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
#include "openflow/openflow.h"
#include "openflow/nicira-ext.h"
#include "packets.h"
-#include "pcap.h"
#include "type-props.h"
#include "unaligned.h"
#include "util.h"
struct flow flow;
ofpbuf_use_const(&buf, data, len);
- flow_extract(&buf, 0, 0, NULL, 0, &flow);
+ flow_extract(&buf, 0, 0, NULL, NULL, &flow);
flow_format(&ds, &flow);
if (buf.l7) {
struct udp_header *uh = buf.l4;
ds_put_format(&ds, " udp_csum:%"PRIx16,
ntohs(uh->udp_csum));
+ } else if (flow.nw_proto == IPPROTO_SCTP) {
+ struct sctp_header *sh = buf.l4;
+ ds_put_format(&ds, " sctp_csum:%"PRIx32,
+ ntohl(sh->sctp_csum));
}
}
ofp_print_packet_in(struct ds *string, const struct ofp_header *oh,
int verbosity)
{
+ char reasonbuf[OFPUTIL_PACKET_IN_REASON_BUFSIZE];
struct ofputil_packet_in pin;
int error;
int i;
ds_put_format(string, " tun_id=0x%"PRIx64, ntohll(pin.fmd.tun_id));
}
+ if (pin.fmd.tun_src != htonl(0)) {
+ ds_put_format(string, " tun_src="IP_FMT, IP_ARGS(pin.fmd.tun_src));
+ }
+
+ if (pin.fmd.tun_dst != htonl(0)) {
+ ds_put_format(string, " tun_dst="IP_FMT, IP_ARGS(pin.fmd.tun_dst));
+ }
+
if (pin.fmd.metadata != htonll(0)) {
ds_put_format(string, " metadata=0x%"PRIx64, ntohll(pin.fmd.metadata));
}
}
}
+ if (pin.fmd.pkt_mark != 0) {
+ ds_put_format(string, " pkt_mark=0x%"PRIx32, pin.fmd.pkt_mark);
+ }
+
ds_put_format(string, " (via %s)",
- ofputil_packet_in_reason_to_string(pin.reason));
+ ofputil_packet_in_reason_to_string(pin.reason, reasonbuf,
+ sizeof reasonbuf));
ds_put_format(string, " data_len=%zu", pin.packet_len);
if (pin.buffer_id == UINT32_MAX) {
ds_put_cstr(string, packet);
free(packet);
}
+ if (verbosity > 2) {
+ ds_put_hex_dump(string, pin.packet, pin.packet_len, 0, false);
+ }
}
static void
ds_put_cstr(string, packet);
free(packet);
}
+ if (verbosity > 2) {
+ ds_put_hex_dump(string, po.packet, po.packet_len, 0, false);
+ }
} else {
ds_put_format(string, " buffer=0x%08"PRIx32, po.buffer_id);
}
- ds_put_char(string, '\n');
ofpbuf_uninit(&ofpacts);
}
{
const struct ofputil_phy_port *a = a_;
const struct ofputil_phy_port *b = b_;
- uint16_t ap = a->port_no;
- uint16_t bp = b->port_no;
+ uint16_t ap = ofp_to_u16(a->port_no);
+ uint16_t bp = ofp_to_u16(b->port_no);
return ap < bp ? -1 : ap > bp;
}
}
ds_put_format(string, " dpid:%016"PRIx64"\n", features.datapath_id);
- ds_put_format(string, "n_tables:%"PRIu8", n_buffers:%"PRIu32"\n",
+
+ ds_put_format(string, "n_tables:%"PRIu8", n_buffers:%"PRIu32,
features.n_tables, features.n_buffers);
+ if (features.auxiliary_id) {
+ ds_put_format(string, ", auxiliary_id:%"PRIu8, features.auxiliary_id);
+ }
+ ds_put_char(string, '\n');
ds_put_cstr(string, "capabilities: ");
ofp_print_bit_names(string, features.capabilities,
case OFP11_VERSION:
case OFP12_VERSION:
break;
+ case OFP13_VERSION:
+ return; /* no ports in ofp13_switch_features */
default:
NOT_REACHED();
}
ds_put_char(string, ',');
}
+static void
+print_wild_port(struct ds *string, const char *leader, int is_wild,
+ int verbosity, ofp_port_t port)
+{
+ if (is_wild && verbosity < 2) {
+ return;
+ }
+ ds_put_cstr(string, leader);
+ if (!is_wild) {
+ ofputil_format_port(port, string);
+ } else {
+ ds_put_char(string, '*');
+ }
+ ds_put_char(string, ',');
+}
+
static void
print_ip_netmask(struct ds *string, const char *leader, ovs_be32 ip,
uint32_t wild_bits, int verbosity)
}
ds_put_cstr(string, leader);
if (wild_bits < 32) {
- ds_put_format(string, IP_FMT, IP_ARGS(&ip));
+ ds_put_format(string, IP_FMT, IP_ARGS(ip));
if (wild_bits) {
ds_put_format(string, "/%d", 32 - wild_bits);
}
ds_put_cstr(&f, "tcp,");
} else if (om->nw_proto == IPPROTO_UDP) {
ds_put_cstr(&f, "udp,");
+ } else if (om->nw_proto == IPPROTO_SCTP) {
+ ds_put_cstr(&f, "sctp,");
} else {
ds_put_cstr(&f, "ip,");
skip_proto = false;
ds_put_cstr(&f, "arp,");
} else if (om->dl_type == htons(ETH_TYPE_RARP)){
ds_put_cstr(&f, "rarp,");
+ } else if (om->dl_type == htons(ETH_TYPE_MPLS)) {
+ ds_put_cstr(&f, "mpls,");
+ } else if (om->dl_type == htons(ETH_TYPE_MPLS_MCAST)) {
+ ds_put_cstr(&f, "mplsm,");
} else {
skip_type = false;
}
}
- print_wild(&f, "in_port=", w & OFPFW10_IN_PORT, verbosity,
- "%d", ntohs(om->in_port));
+ print_wild_port(&f, "in_port=", w & OFPFW10_IN_PORT, verbosity,
+ u16_to_ofp(ntohs(om->in_port)));
print_wild(&f, "dl_vlan=", w & OFPFW10_DL_VLAN, verbosity,
"%d", ntohs(om->dl_vlan));
print_wild(&f, "dl_vlan_pcp=", w & OFPFW10_DL_VLAN_PCP, verbosity,
return ds_cstr(&f);
}
+static void
+ofp_print_flow_flags(struct ds *s, enum ofputil_flow_mod_flags flags)
+{
+ if (flags & OFPUTIL_FF_SEND_FLOW_REM) {
+ ds_put_cstr(s, "send_flow_rem ");
+ }
+ if (flags & OFPUTIL_FF_CHECK_OVERLAP) {
+ ds_put_cstr(s, "check_overlap ");
+ }
+ if (flags & OFPUTIL_FF_RESET_COUNTS) {
+ ds_put_cstr(s, "reset_counts ");
+ }
+ if (flags & OFPUTIL_FF_NO_PKT_COUNTS) {
+ ds_put_cstr(s, "no_packet_counts ");
+ }
+ if (flags & OFPUTIL_FF_NO_BYT_COUNTS) {
+ ds_put_cstr(s, "no_byte_counts ");
+ }
+}
+
static void
ofp_print_flow_mod(struct ds *s, const struct ofp_header *oh, int verbosity)
{
if (fm.buffer_id != UINT32_MAX) {
ds_put_format(s, "buf:0x%"PRIx32" ", fm.buffer_id);
}
- if (fm.out_port != OFPP_NONE) {
+ if (fm.out_port != OFPP_ANY) {
ds_put_format(s, "out_port:");
ofputil_format_port(fm.out_port, s);
ds_put_char(s, ' ');
}
- if (fm.flags != 0) {
- uint16_t flags = fm.flags;
-
- if (flags & OFPFF_SEND_FLOW_REM) {
- ds_put_cstr(s, "send_flow_rem ");
- }
- if (flags & OFPFF_CHECK_OVERLAP) {
- ds_put_cstr(s, "check_overlap ");
- }
- if (flags & OFPFF10_EMERG) {
- ds_put_cstr(s, "emerg ");
- }
- flags &= ~(OFPFF_SEND_FLOW_REM | OFPFF_CHECK_OVERLAP | OFPFF10_EMERG);
- if (flags) {
- ds_put_format(s, "flags:0x%"PRIx16" ", flags);
- }
+ if (oh->version == OFP10_VERSION || oh->version == OFP11_VERSION) {
+ /* Don't print the reset_counts flag for OF1.0 and OF1.1 because those
+ * versions don't really have such a flag and printing one is likely to
+ * confuse people. */
+ fm.flags &= ~OFPUTIL_FF_RESET_COUNTS;
}
+ ofp_print_flow_flags(s, fm.flags);
ofpacts_format(fm.ofpacts, fm.ofpacts_len, s);
ofpbuf_uninit(&ofpacts);
ds_put_char(string, 's');
}
+/* Returns a string form of 'reason'. The return value is either a statically
+ * allocated constant string or the 'bufsize'-byte buffer 'reasonbuf'.
+ * 'bufsize' should be at least OFP_FLOW_REMOVED_REASON_BUFSIZE. */
+#define OFP_FLOW_REMOVED_REASON_BUFSIZE (INT_STRLEN(int) + 1)
static const char *
-ofp_flow_removed_reason_to_string(enum ofp_flow_removed_reason reason)
+ofp_flow_removed_reason_to_string(enum ofp_flow_removed_reason reason,
+ char *reasonbuf, size_t bufsize)
{
- static char s[32];
-
switch (reason) {
case OFPRR_IDLE_TIMEOUT:
return "idle";
return "group_delete";
case OFPRR_EVICTION:
return "eviction";
+ case OFPRR_METER_DELETE:
+ return "meter_delete";
default:
- sprintf(s, "%d", (int) reason);
- return s;
+ snprintf(reasonbuf, bufsize, "%d", (int) reason);
+ return reasonbuf;
}
}
static void
ofp_print_flow_removed(struct ds *string, const struct ofp_header *oh)
{
+ char reasonbuf[OFP_FLOW_REMOVED_REASON_BUFSIZE];
struct ofputil_flow_removed fr;
enum ofperr error;
match_format(&fr.match, string, fr.priority);
ds_put_format(string, " reason=%s",
- ofp_flow_removed_reason_to_string(fr.reason));
+ ofp_flow_removed_reason_to_string(fr.reason, reasonbuf,
+ sizeof reasonbuf));
if (fr.table_id != 255) {
ds_put_format(string, " table_id=%"PRIu8, fr.table_id);
return;
}
- ds_put_format(string, "port: %"PRIu16": addr:"ETH_ADDR_FMT"\n",
- pm.port_no, ETH_ADDR_ARGS(pm.hw_addr));
+ ds_put_cstr(string, "port: ");
+ ofputil_format_port(pm.port_no, string);
+ ds_put_format(string, ": addr:"ETH_ADDR_FMT"\n",
+ ETH_ADDR_ARGS(pm.hw_addr));
- ds_put_format(string, " config: ");
+ ds_put_cstr(string, " config: ");
ofp_print_port_config(string, pm.config);
- ds_put_format(string, " mask: ");
+ ds_put_cstr(string, " mask: ");
ofp_print_port_config(string, pm.mask);
- ds_put_format(string, " advertise: ");
+ ds_put_cstr(string, " advertise: ");
if (pm.advertise) {
ofp_print_port_features(string, pm.advertise);
} else {
- ds_put_format(string, "UNCHANGED\n");
+ ds_put_cstr(string, "UNCHANGED\n");
+ }
+}
+
+static void
+ofp_print_meter_flags(struct ds *s, uint16_t flags)
+{
+ if (flags & OFPMF13_KBPS) {
+ ds_put_cstr(s, "kbps ");
+ }
+ if (flags & OFPMF13_PKTPS) {
+ ds_put_cstr(s, "pktps ");
+ }
+ if (flags & OFPMF13_BURST) {
+ ds_put_cstr(s, "burst ");
+ }
+ if (flags & OFPMF13_STATS) {
+ ds_put_cstr(s, "stats ");
+ }
+
+ flags &= ~(OFPMF13_KBPS | OFPMF13_PKTPS | OFPMF13_BURST | OFPMF13_STATS);
+ if (flags) {
+ ds_put_format(s, "flags:0x%"PRIx16" ", flags);
+ }
+}
+
+static void
+ofp_print_meter_band(struct ds *s, uint16_t flags,
+ const struct ofputil_meter_band *mb)
+{
+ ds_put_cstr(s, "\ntype=");
+ switch (mb->type) {
+ case OFPMBT13_DROP:
+ ds_put_cstr(s, "drop");
+ break;
+ case OFPMBT13_DSCP_REMARK:
+ ds_put_cstr(s, "dscp_remark");
+ break;
+ default:
+ ds_put_format(s, "%u", mb->type);
+ }
+
+ ds_put_format(s, " rate=%"PRIu32, mb->rate);
+
+ if (flags & OFPMF13_BURST) {
+ ds_put_format(s, " burst_size=%"PRIu32, mb->burst_size);
+ }
+ if (mb->type == OFPMBT13_DSCP_REMARK) {
+ ds_put_format(s, " prec_level=%"PRIu8, mb->prec_level);
+ }
+}
+
+static void
+ofp_print_meter_stats(struct ds *s, const struct ofputil_meter_stats *ms)
+{
+ uint16_t i;
+
+ ds_put_format(s, "meter:%"PRIu32" ", ms->meter_id);
+ ds_put_format(s, "flow_count:%"PRIu32" ", ms->flow_count);
+ ds_put_format(s, "packet_in_count:%"PRIu64" ", ms->packet_in_count);
+ ds_put_format(s, "byte_in_count:%"PRIu64" ", ms->byte_in_count);
+ ds_put_cstr(s, "duration:");
+ ofp_print_duration(s, ms->duration_sec, ms->duration_nsec);
+ ds_put_char(s, ' ');
+
+ ds_put_cstr(s, "bands:\n");
+ for (i = 0; i < ms->n_bands; ++i) {
+ ds_put_format(s, "%d: ", i);
+ ds_put_format(s, "packet_count:%"PRIu64" ", ms->bands[i].packet_count);
+ ds_put_format(s, "byte_count:%"PRIu64"\n", ms->bands[i].byte_count);
+ }
+}
+
+static void
+ofp_print_meter_config(struct ds *s, const struct ofputil_meter_config *mc)
+{
+ uint16_t i;
+
+ ds_put_format(s, "meter=%"PRIu32" ", mc->meter_id);
+
+ ofp_print_meter_flags(s, mc->flags);
+
+ ds_put_cstr(s, "bands=");
+ for (i = 0; i < mc->n_bands; ++i) {
+ ofp_print_meter_band(s, mc->flags, &mc->bands[i]);
+ }
+ ds_put_char(s, '\n');
+}
+
+static void
+ofp_print_meter_mod(struct ds *s, const struct ofp_header *oh)
+{
+ struct ofputil_meter_mod mm;
+ struct ofpbuf bands;
+ enum ofperr error;
+
+ ofpbuf_init(&bands, 64);
+ error = ofputil_decode_meter_mod(oh, &mm, &bands);
+ if (error) {
+ ofpbuf_uninit(&bands);
+ ofp_print_error(s, error);
+ return;
+ }
+
+ switch (mm.command) {
+ case OFPMC13_ADD:
+ ds_put_cstr(s, " ADD ");
+ break;
+ case OFPMC13_MODIFY:
+ ds_put_cstr(s, " MOD ");
+ break;
+ case OFPMC13_DELETE:
+ ds_put_cstr(s, " DEL ");
+ break;
+ default:
+ ds_put_format(s, " cmd:%d ", mm.command);
+ }
+
+ ofp_print_meter_config(s, &mm.meter);
+ ofpbuf_uninit(&bands);
+}
+
+static void
+ofp_print_meter_stats_request(struct ds *s, const struct ofp_header *oh)
+{
+ uint32_t meter_id;
+
+ ofputil_decode_meter_request(oh, &meter_id);
+
+ ds_put_format(s, " meter=%"PRIu32, meter_id);
+}
+
+static const char *
+ofputil_meter_capabilities_to_name(uint32_t bit)
+{
+ enum ofp13_meter_flags flag = bit;
+
+ switch (flag) {
+ case OFPMF13_KBPS: return "kbps";
+ case OFPMF13_PKTPS: return "pktps";
+ case OFPMF13_BURST: return "burst";
+ case OFPMF13_STATS: return "stats";
+ }
+
+ return NULL;
+}
+
+static const char *
+ofputil_meter_band_types_to_name(uint32_t bit)
+{
+ switch (bit) {
+ case 1 << OFPMBT13_DROP: return "drop";
+ case 1 << OFPMBT13_DSCP_REMARK: return "dscp_remark";
+ }
+
+ return NULL;
+}
+
+static void
+ofp_print_meter_features_reply(struct ds *s, const struct ofp_header *oh)
+{
+ struct ofputil_meter_features mf;
+
+ ofputil_decode_meter_features(oh, &mf);
+
+ ds_put_format(s, "\nmax_meter:%"PRIu32, mf.max_meters);
+ ds_put_format(s, " max_bands:%"PRIu8, mf.max_bands);
+ ds_put_format(s, " max_color:%"PRIu8"\n", mf.max_color);
+
+ ds_put_cstr(s, "band_types: ");
+ ofp_print_bit_names(s, mf.band_types,
+ ofputil_meter_band_types_to_name, ' ');
+ ds_put_char(s, '\n');
+
+ ds_put_cstr(s, "capabilities: ");
+ ofp_print_bit_names(s, mf.capabilities,
+ ofputil_meter_capabilities_to_name, ' ');
+ ds_put_char(s, '\n');
+}
+
+static void
+ofp_print_meter_config_reply(struct ds *s, const struct ofp_header *oh)
+{
+ struct ofpbuf bands;
+ struct ofpbuf b;
+
+ ofpbuf_use_const(&b, oh, ntohs(oh->length));
+ ofpbuf_init(&bands, 64);
+ for (;;) {
+ struct ofputil_meter_config mc;
+ int retval;
+
+ retval = ofputil_decode_meter_config(&b, &mc, &bands);
+ if (retval) {
+ if (retval != EOF) {
+ ofp_print_error(s, retval);
+ }
+ break;
+ }
+ ds_put_char(s, '\n');
+ ofp_print_meter_config(s, &mc);
+ }
+ ofpbuf_uninit(&bands);
+}
+
+static void
+ofp_print_meter_stats_reply(struct ds *s, const struct ofp_header *oh)
+{
+ struct ofpbuf bands;
+ struct ofpbuf b;
+
+ ofpbuf_use_const(&b, oh, ntohs(oh->length));
+ ofpbuf_init(&bands, 64);
+ for (;;) {
+ struct ofputil_meter_stats ms;
+ int retval;
+
+ retval = ofputil_decode_meter_stats(&b, &ms, &bands);
+ if (retval) {
+ if (retval != EOF) {
+ ofp_print_error(s, retval);
+ }
+ break;
+ }
+ ds_put_char(s, '\n');
+ ofp_print_meter_stats(s, &ms);
}
+ ofpbuf_uninit(&bands);
}
static void
ds_put_format(string, " table=%"PRIu8, fsr.table_id);
}
- if (fsr.out_port != OFPP_NONE) {
+ if (fsr.out_port != OFPP_ANY) {
ds_put_cstr(string, " out_port=");
ofputil_format_port(fsr.out_port, string);
}
if (fs->hard_timeout != OFP_FLOW_PERMANENT) {
ds_put_format(string, "hard_timeout=%"PRIu16", ", fs->hard_timeout);
}
+ if (fs->flags) {
+ ofp_print_flow_flags(string, fs->flags);
+ }
if (fs->idle_age >= 0) {
ds_put_format(string, "idle_age=%d, ", fs->idle_age);
}
static void
ofp_print_ofpst_port_request(struct ds *string, const struct ofp_header *oh)
{
- uint16_t ofp10_port;
+ ofp_port_t ofp10_port;
enum ofperr error;
error = ofputil_decode_port_stats_request(oh, &ofp10_port);
return;
}
- ds_put_format(string, " port_no=%2"PRIu16, ofp10_port);
+ ds_put_cstr(string, " port_no=");
+ ofputil_format_port(ofp10_port, string);
}
static void
return;
}
- ds_put_format(string, " port %2"PRIu16, ps.port_no);
+ ds_put_cstr(string, " port ");
+ if (ofp_to_u16(ps.port_no) < 10) {
+ ds_put_char(string, ' ');
+ }
+ ofputil_format_port(ps.port_no, string);
ds_put_cstr(string, ": rx ");
print_port_stat(string, "pkts=", ps.stats.rx_packets, 1);
print_port_stat(string, "drop=", ps.stats.tx_dropped, 1);
print_port_stat(string, "errs=", ps.stats.tx_errors, 1);
print_port_stat(string, "coll=", ps.stats.collisions, 0);
+
+ if (ps.duration_sec != UINT32_MAX) {
+ ds_put_cstr(string, " duration=");
+ ofp_print_duration(string, ps.duration_sec, ps.duration_nsec);
+ ds_put_char(string, '\n');
+ }
}
}
{
char name_[OFP_MAX_TABLE_NAME_LEN + 1];
+ /* ofp13_table_stats is different */
+ if (ofp_version > OFP12_VERSION) {
+ return;
+ }
+
ovs_strlcpy(name_, name, sizeof name_);
ds_put_format(string, " %d: %-8s: ", ts->table_id, name_);
ntohll(ts->metadata_write));
}
+static void
+ofp_print_ofpst_table_reply13(struct ds *string, const struct ofp_header *oh,
+ int verbosity)
+{
+ struct ofp13_table_stats *ts;
+ struct ofpbuf b;
+ size_t n;
+
+ ofpbuf_use_const(&b, oh, ntohs(oh->length));
+ ofpraw_pull_assert(&b);
+
+ n = b.size / sizeof *ts;
+ ds_put_format(string, " %zu tables\n", n);
+ if (verbosity < 1) {
+ return;
+ }
+
+ for (;;) {
+ ts = ofpbuf_try_pull(&b, sizeof *ts);
+ if (!ts) {
+ return;
+ }
+ ds_put_format(string,
+ " %d: active=%"PRIu32", lookup=%"PRIu64 \
+ ", matched=%"PRIu64"\n",
+ ts->table_id, ntohl(ts->active_count),
+ ntohll(ts->lookup_count), ntohll(ts->matched_count));
+ }
+}
+
static void
ofp_print_ofpst_table_reply12(struct ds *string, const struct ofp_header *oh,
int verbosity)
int verbosity)
{
switch ((enum ofp_version)oh->version) {
+ case OFP13_VERSION:
+ ofp_print_ofpst_table_reply13(string, oh, verbosity);
+ break;
+
case OFP12_VERSION:
ofp_print_ofpst_table_reply12(string, oh, verbosity);
break;
ofp_print_queue_name(string, qs.queue_id);
ds_put_cstr(string, ": ");
- print_port_stat(string, "bytes=", qs.stats.tx_bytes, 1);
- print_port_stat(string, "pkts=", qs.stats.tx_packets, 1);
- print_port_stat(string, "errors=", qs.stats.tx_errors, 0);
+ print_port_stat(string, "bytes=", qs.tx_bytes, 1);
+ print_port_stat(string, "pkts=", qs.tx_packets, 1);
+ print_port_stat(string, "errors=", qs.tx_errors, 1);
+
+ ds_put_cstr(string, "duration=");
+ if (qs.duration_sec != UINT32_MAX) {
+ ofp_print_duration(string, qs.duration_sec, qs.duration_nsec);
+ } else {
+ ds_put_char(string, '?');
+ }
+ ds_put_char(string, '\n');
}
}
}
static void
-ofp_print_nxt_role_message(struct ds *string,
- const struct nx_role_request *nrr)
+ofp_print_role_message(struct ds *string, const struct ofp_header *oh)
{
- unsigned int role = ntohl(nrr->role);
+ struct ofputil_role_request rr;
+ enum ofperr error;
+
+ error = ofputil_decode_role_message(oh, &rr);
+ if (error) {
+ ofp_print_error(string, error);
+ return;
+ }
ds_put_cstr(string, " role=");
- if (role == NX_ROLE_OTHER) {
- ds_put_cstr(string, "other");
- } else if (role == NX_ROLE_MASTER) {
+
+ switch (rr.role) {
+ case OFPCR12_ROLE_NOCHANGE:
+ ds_put_cstr(string, "nochange");
+ break;
+ case OFPCR12_ROLE_EQUAL:
+ ds_put_cstr(string, "equal"); /* OF 1.2 wording */
+ break;
+ case OFPCR12_ROLE_MASTER:
ds_put_cstr(string, "master");
- } else if (role == NX_ROLE_SLAVE) {
+ break;
+ case OFPCR12_ROLE_SLAVE:
ds_put_cstr(string, "slave");
- } else {
- ds_put_format(string, "%u", role);
+ break;
+ default:
+ NOT_REACHED();
+ }
+
+ if (rr.have_generation_id) {
+ ds_put_format(string, " generation_id=%"PRIu64, rr.generation_id);
}
}
}
}
+/* Returns a string form of 'reason'. The return value is either a statically
+ * allocated constant string or the 'bufsize'-byte buffer 'reasonbuf'.
+ * 'bufsize' should be at least OFP_PORT_REASON_BUFSIZE. */
+#define OFP_PORT_REASON_BUFSIZE (INT_STRLEN(int) + 1)
static const char *
-ofp_port_reason_to_string(enum ofp_port_reason reason)
+ofp_port_reason_to_string(enum ofp_port_reason reason,
+ char *reasonbuf, size_t bufsize)
{
- static char s[32];
-
switch (reason) {
case OFPPR_ADD:
return "add";
return "modify";
default:
- sprintf(s, "%d", (int) reason);
- return s;
+ snprintf(reasonbuf, bufsize, "%d", (int) reason);
+ return reasonbuf;
}
}
ds_put_cstr(string, " PACKET_IN:");
for (j = 0; j < 32; j++) {
if (nac->packet_in_mask[i] & htonl(1u << j)) {
- ds_put_format(string, " %s",
- ofputil_packet_in_reason_to_string(j));
+ char reasonbuf[OFPUTIL_PACKET_IN_REASON_BUFSIZE];
+ const char *reason;
+
+ reason = ofputil_packet_in_reason_to_string(j, reasonbuf,
+ sizeof reasonbuf);
+ ds_put_format(string, " %s", reason);
}
}
if (!nac->packet_in_mask[i]) {
ds_put_cstr(string, " PORT_STATUS:");
for (j = 0; j < 32; j++) {
if (nac->port_status_mask[i] & htonl(1u << j)) {
- ds_put_format(string, " %s", ofp_port_reason_to_string(j));
+ char reasonbuf[OFP_PORT_REASON_BUFSIZE];
+ const char *reason;
+
+ reason = ofp_port_reason_to_string(j, reasonbuf,
+ sizeof reasonbuf);
+ ds_put_format(string, " %s", reason);
}
}
if (!nac->port_status_mask[i]) {
ds_put_cstr(string, " FLOW_REMOVED:");
for (j = 0; j < 32; j++) {
if (nac->flow_removed_mask[i] & htonl(1u << j)) {
- ds_put_format(string, " %s",
- ofp_flow_removed_reason_to_string(j));
+ char reasonbuf[OFP_FLOW_REMOVED_REASON_BUFSIZE];
+ const char *reason;
+
+ reason = ofp_flow_removed_reason_to_string(j, reasonbuf,
+ sizeof reasonbuf);
+ ds_put_format(string, " %s", reason);
}
}
if (!nac->flow_removed_mask[i]) {
ofpbuf_use_const(&b, oh, ntohs(oh->length));
ofpbuf_use_stub(&ofpacts, ofpacts_stub, sizeof ofpacts_stub);
for (;;) {
+ char reasonbuf[OFP_FLOW_REMOVED_REASON_BUFSIZE];
struct ofputil_flow_update update;
struct match match;
int retval;
case NXFME_DELETED:
ds_put_format(string, "DELETED reason=%s",
- ofp_flow_removed_reason_to_string(update.reason));
+ ofp_flow_removed_reason_to_string(update.reason,
+ reasonbuf,
+ sizeof reasonbuf));
break;
case NXFME_MODIFIED:
case OFP12_VERSION:
ds_put_cstr(string, " (OF1.2)");
break;
+ case OFP13_VERSION:
+ ds_put_cstr(string, " (OF1.3)");
+ break;
default:
ds_put_format(string, " (OF 0x%02"PRIx8")", oh->version);
break;
ofp_print_version(oh, string);
}
+static void
+ofp_print_not_implemented(struct ds *string)
+{
+ ds_put_cstr(string, "NOT IMPLEMENTED YET!\n");
+}
+
static void
ofp_to_string__(const struct ofp_header *oh, enum ofpraw raw,
struct ds *string, int verbosity)
ofp_header_to_string__(oh, raw, string);
switch (ofptype_from_ofpraw(raw)) {
+
+ /* FIXME: Change the following once they are implemented: */
+ case OFPTYPE_QUEUE_GET_CONFIG_REQUEST:
+ case OFPTYPE_QUEUE_GET_CONFIG_REPLY:
+ case OFPTYPE_GET_ASYNC_REQUEST:
+ case OFPTYPE_GET_ASYNC_REPLY:
+ case OFPTYPE_GROUP_STATS_REQUEST:
+ case OFPTYPE_GROUP_STATS_REPLY:
+ case OFPTYPE_GROUP_DESC_STATS_REQUEST:
+ case OFPTYPE_GROUP_DESC_STATS_REPLY:
+ case OFPTYPE_GROUP_FEATURES_STATS_REQUEST:
+ case OFPTYPE_GROUP_FEATURES_STATS_REPLY:
+ case OFPTYPE_TABLE_FEATURES_STATS_REQUEST:
+ case OFPTYPE_TABLE_FEATURES_STATS_REPLY:
+ ofp_print_not_implemented(string);
+ break;
+
case OFPTYPE_HELLO:
ofp_print_hello(string, oh);
break;
ofp_print_port_mod(string, oh);
break;
+ case OFPTYPE_METER_MOD:
+ ofp_print_meter_mod(string, oh);
+ break;
+
case OFPTYPE_BARRIER_REQUEST:
case OFPTYPE_BARRIER_REPLY:
break;
+ case OFPTYPE_ROLE_REQUEST:
+ case OFPTYPE_ROLE_REPLY:
+ ofp_print_role_message(string, oh);
+ break;
+
+ case OFPTYPE_METER_STATS_REQUEST:
+ case OFPTYPE_METER_CONFIG_STATS_REQUEST:
+ ofp_print_stats_request(string, oh);
+ ofp_print_meter_stats_request(string, oh);
+ break;
+
+ case OFPTYPE_METER_STATS_REPLY:
+ ofp_print_stats_reply(string, oh);
+ ofp_print_meter_stats_reply(string, oh);
+ break;
+
+ case OFPTYPE_METER_CONFIG_STATS_REPLY:
+ ofp_print_stats_reply(string, oh);
+ ofp_print_meter_config_reply(string, oh);
+ break;
+
+ case OFPTYPE_METER_FEATURES_STATS_REPLY:
+ ofp_print_stats_reply(string, oh);
+ ofp_print_meter_features_reply(string, oh);
+ break;
+
case OFPTYPE_DESC_STATS_REQUEST:
case OFPTYPE_PORT_DESC_STATS_REQUEST:
+ case OFPTYPE_METER_FEATURES_STATS_REQUEST:
ofp_print_stats_request(string, oh);
break;
ofp_print_ofpst_port_desc_reply(string, oh);
break;
- case OFPTYPE_ROLE_REQUEST:
- case OFPTYPE_ROLE_REPLY:
- ofp_print_nxt_role_message(string, ofpmsg_body(oh));
- break;
-
case OFPTYPE_FLOW_MOD_TABLE_ID:
ofp_print_nxt_flow_mod_table_id(string, ofpmsg_body(oh));
break;