X-Git-Url: http://git.onelab.eu/?a=blobdiff_plain;f=lib%2Fofp-util.c;h=45ff0a149e76c6e25025a8fd4198c8c5e961ab69;hb=591cb419cf3694e0ae66a95973e73c61bad9e03d;hp=6b78f84c2894310e7b9d396b48289b595eb5b6ba;hpb=cff78c8844bcce7c6b20fe30d56b5509232039d2;p=sliver-openvswitch.git diff --git a/lib/ofp-util.c b/lib/ofp-util.c index 6b78f84c2..45ff0a149 100644 --- a/lib/ofp-util.c +++ b/lib/ofp-util.c @@ -90,7 +90,7 @@ ofputil_wildcard_from_ofpfw10(uint32_t ofpfw, struct flow_wildcards *wc) flow_wildcards_init_catchall(wc); if (!(ofpfw & OFPFW10_IN_PORT)) { - wc->masks.in_port = UINT16_MAX; + wc->masks.in_port.ofp_port = u16_to_ofp(UINT16_MAX); } if (!(ofpfw & OFPFW10_NW_TOS)) { @@ -145,7 +145,7 @@ ofputil_match_from_ofp10_match(const struct ofp10_match *ofmatch, /* Initialize most of match->flow. */ match->flow.nw_src = ofmatch->nw_src; match->flow.nw_dst = ofmatch->nw_dst; - match->flow.in_port = ntohs(ofmatch->in_port); + match->flow.in_port.ofp_port = u16_to_ofp(ntohs(ofmatch->in_port)); match->flow.dl_type = ofputil_dl_type_from_openflow(ofmatch->dl_type); match->flow.tp_src = ofmatch->tp_src; match->flow.tp_dst = ofmatch->tp_dst; @@ -190,7 +190,7 @@ ofputil_match_to_ofp10_match(const struct match *match, /* Figure out most OpenFlow wildcards. */ ofpfw = 0; - if (!wc->masks.in_port) { + if (!wc->masks.in_port.ofp_port) { ofpfw |= OFPFW10_IN_PORT; } if (!wc->masks.dl_type) { @@ -244,7 +244,7 @@ ofputil_match_to_ofp10_match(const struct match *match, /* Compose most of the match structure. */ ofmatch->wildcards = htonl(ofpfw); - ofmatch->in_port = htons(match->flow.in_port); + ofmatch->in_port = htons(ofp_to_u16(match->flow.in_port.ofp_port)); memcpy(ofmatch->dl_src, match->flow.dl_src, ETH_ADDR_LEN); memcpy(ofmatch->dl_dst, match->flow.dl_dst, ETH_ADDR_LEN); ofmatch->dl_type = ofputil_dl_type_to_openflow(match->flow.dl_type); @@ -311,7 +311,7 @@ ofputil_match_from_ofp11_match(const struct ofp11_match *ofmatch, match_init_catchall(match); if (!(wc & OFPFW11_IN_PORT)) { - uint16_t ofp_port; + ofp_port_t ofp_port; enum ofperr error; error = ofputil_port_from_ofp11(ofmatch->in_port, &ofp_port); @@ -466,10 +466,10 @@ ofputil_match_to_ofp11_match(const struct match *match, ofmatch->omh.type = htons(OFPMT_STANDARD); ofmatch->omh.length = htons(OFPMT11_STANDARD_LENGTH); - if (!match->wc.masks.in_port) { + if (!match->wc.masks.in_port.ofp_port) { wc |= OFPFW11_IN_PORT; } else { - ofmatch->in_port = ofputil_port_to_ofp11(match->flow.in_port); + ofmatch->in_port = ofputil_port_to_ofp11(match->flow.in_port.ofp_port); } memcpy(ofmatch->dl_src, match->flow.dl_src, ETH_ADDR_LEN); @@ -547,6 +547,71 @@ ofputil_match_to_ofp11_match(const struct match *match, ofmatch->wildcards = htonl(wc); } +/* Returns the "typical" length of a match for 'protocol', for use in + * estimating space to preallocate. */ +int +ofputil_match_typical_len(enum ofputil_protocol protocol) +{ + switch (protocol) { + case OFPUTIL_P_OF10_STD: + case OFPUTIL_P_OF10_STD_TID: + return sizeof(struct ofp10_match); + + case OFPUTIL_P_OF10_NXM: + case OFPUTIL_P_OF10_NXM_TID: + return NXM_TYPICAL_LEN; + + case OFPUTIL_P_OF11_STD: + return sizeof(struct ofp11_match); + + case OFPUTIL_P_OF12_OXM: + case OFPUTIL_P_OF13_OXM: + return NXM_TYPICAL_LEN; + + default: + NOT_REACHED(); + } +} + +/* Appends to 'b' an struct ofp11_match_header followed by a match that + * expresses 'match' properly for 'protocol', plus enough zero bytes to pad the + * data appended out to a multiple of 8. 'protocol' must be one that is usable + * in OpenFlow 1.1 or later. + * + * This function can cause 'b''s data to be reallocated. + * + * Returns the number of bytes appended to 'b', excluding the padding. Never + * returns zero. */ +int +ofputil_put_ofp11_match(struct ofpbuf *b, const struct match *match, + enum ofputil_protocol protocol) +{ + switch (protocol) { + case OFPUTIL_P_OF10_STD: + case OFPUTIL_P_OF10_STD_TID: + case OFPUTIL_P_OF10_NXM: + case OFPUTIL_P_OF10_NXM_TID: + NOT_REACHED(); + + case OFPUTIL_P_OF11_STD: { + struct ofp11_match *om; + + /* Make sure that no padding is needed. */ + BUILD_ASSERT_DECL(sizeof *om % 8 == 0); + + om = ofpbuf_put_uninit(b, sizeof *om); + ofputil_match_to_ofp11_match(match, om); + return sizeof *om; + } + + case OFPUTIL_P_OF12_OXM: + case OFPUTIL_P_OF13_OXM: + return oxm_put_match(b, match); + } + + NOT_REACHED(); +} + /* Given a 'dl_type' value in the format used in struct flow, returns the * corresponding 'dl_type' value for use in an ofp10_match or ofp11_match * structure. */ @@ -589,6 +654,7 @@ static const struct proto_abbrev proto_abbrevs[] = { enum ofputil_protocol ofputil_flow_dump_protocols[] = { OFPUTIL_P_OF13_OXM, OFPUTIL_P_OF12_OXM, + OFPUTIL_P_OF11_STD, OFPUTIL_P_OF10_NXM, OFPUTIL_P_OF10_STD, }; @@ -604,11 +670,12 @@ ofputil_protocols_from_ofp_version(enum ofp_version version) switch (version) { case OFP10_VERSION: return OFPUTIL_P_OF10_STD_ANY | OFPUTIL_P_OF10_NXM_ANY; + case OFP11_VERSION: + return OFPUTIL_P_OF11_STD; case OFP12_VERSION: return OFPUTIL_P_OF12_OXM; case OFP13_VERSION: return OFPUTIL_P_OF13_OXM; - case OFP11_VERSION: default: return 0; } @@ -636,6 +703,8 @@ ofputil_protocol_to_ofp_version(enum ofputil_protocol protocol) case OFPUTIL_P_OF10_NXM: case OFPUTIL_P_OF10_NXM_TID: return OFP10_VERSION; + case OFPUTIL_P_OF11_STD: + return OFP11_VERSION; case OFPUTIL_P_OF12_OXM: return OFP12_VERSION; case OFPUTIL_P_OF13_OXM: @@ -707,6 +776,9 @@ ofputil_protocol_set_tid(enum ofputil_protocol protocol, bool enable) case OFPUTIL_P_OF10_NXM_TID: return enable ? OFPUTIL_P_OF10_NXM_TID : OFPUTIL_P_OF10_NXM; + case OFPUTIL_P_OF11_STD: + return OFPUTIL_P_OF11_STD; + case OFPUTIL_P_OF12_OXM: return OFPUTIL_P_OF12_OXM; @@ -744,6 +816,9 @@ ofputil_protocol_set_base(enum ofputil_protocol cur, case OFPUTIL_P_OF10_NXM_TID: return ofputil_protocol_set_tid(OFPUTIL_P_OF10_NXM, tid); + case OFPUTIL_P_OF11_STD: + return ofputil_protocol_set_tid(OFPUTIL_P_OF11_STD, tid); + case OFPUTIL_P_OF12_OXM: return ofputil_protocol_set_tid(OFPUTIL_P_OF12_OXM, tid); @@ -778,6 +853,9 @@ ofputil_protocol_to_string(enum ofputil_protocol protocol) case OFPUTIL_P_OF10_STD_TID: return "OpenFlow10+table_id"; + case OFPUTIL_P_OF11_STD: + return "OpenFlow11"; + case OFPUTIL_P_OF12_OXM: return "OXM-OpenFlow12"; @@ -922,7 +1000,7 @@ ofputil_version_from_string(const char *s) } static bool -is_delimiter(char c) +is_delimiter(unsigned char c) { return isspace(c) || c == ','; } @@ -1039,16 +1117,6 @@ regs_fully_wildcarded(const struct flow_wildcards *wc) return true; } -static bool -tun_parms_fully_wildcarded(const struct flow_wildcards *wc) -{ - return (!wc->masks.tunnel.ip_src && - !wc->masks.tunnel.ip_dst && - !wc->masks.tunnel.ip_ttl && - !wc->masks.tunnel.ip_tos && - !wc->masks.tunnel.flags); -} - /* Returns a bit-mask of ofputil_protocols that can be used for sending 'match' * to a switch (e.g. to add or remove a flow). Only NXM can handle tunnel IDs, * registers, or fixing the Ethernet multicast bit. Otherwise, it's better to @@ -1060,16 +1128,23 @@ ofputil_usable_protocols(const struct match *match) BUILD_ASSERT_DECL(FLOW_WC_SEQ == 20); - /* tunnel params other than tun_id can't be sent in a flow_mod */ - if (!tun_parms_fully_wildcarded(wc)) { + /* These tunnel params can't be sent in a flow_mod */ + if (wc->masks.tunnel.ip_ttl + || wc->masks.tunnel.ip_tos || wc->masks.tunnel.flags) { return OFPUTIL_P_NONE; } - /* skb_mark and skb_priority can't be sent in a flow_mod */ - if (wc->masks.skb_mark || wc->masks.skb_priority) { + /* skb_priority can't be sent in a flow_mod */ + if (wc->masks.skb_priority) { return OFPUTIL_P_NONE; } + /* NXM and OXM support pkt_mark */ + if (wc->masks.pkt_mark) { + return OFPUTIL_P_OF10_NXM_ANY | OFPUTIL_P_OF12_OXM + | OFPUTIL_P_OF13_OXM; + } + /* NXM, OXM, and OF1.1 support bitwise matching on ethernet addresses. */ if (!eth_mask_is_exact(wc->masks.dl_src) && !eth_addr_is_zero(wc->masks.dl_src)) { @@ -1095,8 +1170,19 @@ ofputil_usable_protocols(const struct match *match) | OFPUTIL_P_OF13_OXM; } - /* NXM and OXM support matching IPv6 traffic. */ - if (match->flow.dl_type == htons(ETH_TYPE_IPV6)) { + /* NXM and OXM support matching L3 and L4 fields within IPv6. + * + * (arp_sha, arp_tha, nw_frag, and nw_ttl are covered elsewhere so they + * don't need to be included in this test too.) */ + if (match->flow.dl_type == htons(ETH_TYPE_IPV6) + && (!ipv6_mask_is_any(&wc->masks.ipv6_src) + || !ipv6_mask_is_any(&wc->masks.ipv6_dst) + || !ipv6_mask_is_any(&wc->masks.nd_target) + || wc->masks.ipv6_label + || wc->masks.tp_src + || wc->masks.tp_dst + || wc->masks.nw_proto + || wc->masks.nw_tos)) { return OFPUTIL_P_OF10_NXM_ANY | OFPUTIL_P_OF12_OXM | OFPUTIL_P_OF13_OXM; } @@ -1107,8 +1193,10 @@ ofputil_usable_protocols(const struct match *match) | OFPUTIL_P_OF13_OXM; } - /* NXM and OXM support matching tun_id. */ - if (wc->masks.tunnel.tun_id != htonll(0)) { + /* NXM and OXM support matching tun_id, tun_src, and tun_dst. */ + if (wc->masks.tunnel.tun_id != htonll(0) + || wc->masks.tunnel.ip_src != htonl(0) + || wc->masks.tunnel.ip_dst != htonl(0)) { return OFPUTIL_P_OF10_NXM_ANY | OFPUTIL_P_OF12_OXM | OFPUTIL_P_OF13_OXM; } @@ -1119,12 +1207,6 @@ ofputil_usable_protocols(const struct match *match) | OFPUTIL_P_OF13_OXM; } - /* NXM and OXM support matching IPv6 flow label. */ - if (wc->masks.ipv6_label) { - return OFPUTIL_P_OF10_NXM_ANY | OFPUTIL_P_OF12_OXM - | OFPUTIL_P_OF13_OXM; - } - /* NXM and OXM support matching IP ECN bits. */ if (wc->masks.nw_tos & IP_ECN_MASK) { return OFPUTIL_P_OF10_NXM_ANY | OFPUTIL_P_OF12_OXM @@ -1217,7 +1299,7 @@ ofputil_decode_hello_bitmap(const struct ofp_hello_elem_header *oheh, uint32_t *allowed_versionsp) { uint16_t bitmap_len = ntohs(oheh->length) - sizeof *oheh; - const ovs_be32 *bitmap = (const ovs_be32 *) (oheh + 1); + const ovs_be32 *bitmap = ALIGNED_CAST(const ovs_be32 *, oheh + 1); uint32_t allowed_versions; if (!bitmap_len || bitmap_len % sizeof *bitmap) { @@ -1296,7 +1378,7 @@ ofputil_decode_hello(const struct ofp_header *oh, uint32_t *allowed_versions) /* Returns true if 'allowed_versions' needs to be accompanied by a version * bitmap to be correctly expressed in an OFPT_HELLO message. */ -static inline bool +static bool should_send_version_bitmap(uint32_t allowed_versions) { return !is_pow2((allowed_versions >> 1) + 1); @@ -1321,7 +1403,7 @@ ofputil_encode_hello(uint32_t allowed_versions) oheh = ofpbuf_put_zeros(msg, ROUND_UP(map_len + sizeof *oheh, 8)); oheh->type = htons(OFPHET_VERSIONBITMAP); oheh->length = htons(map_len + sizeof *oheh); - *(ovs_be32 *)(oheh + 1) = htonl(allowed_versions); + *ALIGNED_CAST(ovs_be32 *, oheh + 1) = htonl(allowed_versions); ofpmsg_update_length(msg); } @@ -1366,9 +1448,10 @@ ofputil_encode_set_protocol(enum ofputil_protocol current, case OFPUTIL_P_OF10_STD: return ofputil_encode_nx_set_flow_format(NXFF_OPENFLOW10); + case OFPUTIL_P_OF11_STD: case OFPUTIL_P_OF12_OXM: case OFPUTIL_P_OF13_OXM: - /* There are only one of each OpenFlow 1.2+ protocols and we already + /* There is only one variant of each OpenFlow 1.1+ protocol, and we * verified above that we're not trying to change versions. */ NOT_REACHED(); @@ -1516,7 +1599,14 @@ ofputil_decode_flow_mod(struct ofputil_flow_mod *fm, /* Translate the message. */ fm->priority = ntohs(ofm->priority); - if (ofm->command == OFPFC_ADD) { + if (ofm->command == OFPFC_ADD + || (oh->version == OFP11_VERSION + && (ofm->command == OFPFC_MODIFY || + ofm->command == OFPFC_MODIFY_STRICT) + && ofm->cookie_mask == htonll(0))) { + /* In OpenFlow 1.1 only, a "modify" or "modify-strict" that does + * not match on the cookie is treated as an "add" if there is no + * match. */ fm->cookie = htonll(0); fm->cookie_mask = htonll(0); fm->new_cookie = ofm->cookie; @@ -1525,6 +1615,7 @@ ofputil_decode_flow_mod(struct ofputil_flow_mod *fm, fm->cookie_mask = ofm->cookie_mask; fm->new_cookie = htonll(UINT64_MAX); } + fm->modify_cookie = false; fm->command = ofm->command; fm->table_id = ofm->table_id; fm->idle_timeout = ntohs(ofm->idle_timeout); @@ -1573,7 +1664,7 @@ ofputil_decode_flow_mod(struct ofputil_flow_mod *fm, fm->idle_timeout = ntohs(ofm->idle_timeout); fm->hard_timeout = ntohs(ofm->hard_timeout); fm->buffer_id = ntohl(ofm->buffer_id); - fm->out_port = ntohs(ofm->out_port); + fm->out_port = u16_to_ofp(ntohs(ofm->out_port)); fm->flags = ntohs(ofm->flags); } else if (raw == OFPRAW_NXT_FLOW_MOD) { /* Nicira extended flow_mod. */ @@ -1604,7 +1695,7 @@ ofputil_decode_flow_mod(struct ofputil_flow_mod *fm, fm->idle_timeout = ntohs(nfm->idle_timeout); fm->hard_timeout = ntohs(nfm->hard_timeout); fm->buffer_id = ntohl(nfm->buffer_id); - fm->out_port = ntohs(nfm->out_port); + fm->out_port = u16_to_ofp(ntohs(nfm->out_port)); fm->flags = ntohs(nfm->flags); } else { NOT_REACHED(); @@ -1622,6 +1713,7 @@ ofputil_decode_flow_mod(struct ofputil_flow_mod *fm, : OFPERR_OFPFMFC_TABLE_FULL); } + fm->modify_cookie = fm->new_cookie != htonll(UINT64_MAX); if (protocol & OFPUTIL_P_TID) { fm->command = command & 0xff; fm->table_id = command >> 8; @@ -1637,6 +1729,371 @@ ofputil_decode_flow_mod(struct ofputil_flow_mod *fm, return 0; } +static enum ofperr +ofputil_pull_bands(struct ofpbuf *msg, size_t len, uint16_t *n_bands, + struct ofpbuf *bands) +{ + const struct ofp13_meter_band_header *ombh; + struct ofputil_meter_band *mb; + uint16_t n = 0; + + ombh = ofpbuf_try_pull(msg, len); + if (!ombh) { + return OFPERR_OFPBRC_BAD_LEN; + } + + while (len >= sizeof (struct ofp13_meter_band_drop)) { + size_t ombh_len = ntohs(ombh->len); + /* All supported band types have the same length. */ + if (ombh_len != sizeof (struct ofp13_meter_band_drop)) { + return OFPERR_OFPBRC_BAD_LEN; + } + mb = ofpbuf_put_uninit(bands, sizeof *mb); + mb->type = ntohs(ombh->type); + mb->rate = ntohl(ombh->rate); + mb->burst_size = ntohl(ombh->burst_size); + mb->prec_level = (mb->type == OFPMBT13_DSCP_REMARK) ? + ((struct ofp13_meter_band_dscp_remark *)ombh)->prec_level : 0; + n++; + len -= ombh_len; + ombh = ALIGNED_CAST(struct ofp13_meter_band_header *, + (char *) ombh + ombh_len); + } + if (len) { + return OFPERR_OFPBRC_BAD_LEN; + } + *n_bands = n; + return 0; +} + +enum ofperr +ofputil_decode_meter_mod(const struct ofp_header *oh, + struct ofputil_meter_mod *mm, + struct ofpbuf *bands) +{ + const struct ofp13_meter_mod *omm; + struct ofpbuf b; + + ofpbuf_use_const(&b, oh, ntohs(oh->length)); + ofpraw_pull_assert(&b); + omm = ofpbuf_pull(&b, sizeof *omm); + + /* Translate the message. */ + mm->command = ntohs(omm->command); + mm->meter.meter_id = ntohl(omm->meter_id); + + if (mm->command == OFPMC13_DELETE) { + mm->meter.flags = 0; + mm->meter.n_bands = 0; + mm->meter.bands = NULL; + } else { + enum ofperr error; + + mm->meter.flags = ntohs(omm->flags); + mm->meter.bands = bands->data; + + error = ofputil_pull_bands(&b, b.size, &mm->meter.n_bands, bands); + if (error) { + return error; + } + } + return 0; +} + +void +ofputil_decode_meter_request(const struct ofp_header *oh, uint32_t *meter_id) +{ + const struct ofp13_meter_multipart_request *omr = ofpmsg_body(oh); + *meter_id = ntohl(omr->meter_id); +} + +struct ofpbuf * +ofputil_encode_meter_request(enum ofp_version ofp_version, + enum ofputil_meter_request_type type, + uint32_t meter_id) +{ + struct ofpbuf *msg; + + enum ofpraw raw; + + switch (type) { + case OFPUTIL_METER_CONFIG: + raw = OFPRAW_OFPST13_METER_CONFIG_REQUEST; + break; + case OFPUTIL_METER_STATS: + raw = OFPRAW_OFPST13_METER_REQUEST; + break; + default: + case OFPUTIL_METER_FEATURES: + raw = OFPRAW_OFPST13_METER_FEATURES_REQUEST; + break; + } + + msg = ofpraw_alloc(raw, ofp_version, 0); + + if (type != OFPUTIL_METER_FEATURES) { + struct ofp13_meter_multipart_request *omr; + omr = ofpbuf_put_zeros(msg, sizeof *omr); + omr->meter_id = htonl(meter_id); + } + return msg; +} + +static void +ofputil_put_bands(uint16_t n_bands, const struct ofputil_meter_band *mb, + struct ofpbuf *msg) +{ + uint16_t n = 0; + + for (n = 0; n < n_bands; ++n) { + /* Currently all band types have same size. */ + struct ofp13_meter_band_dscp_remark *ombh; + size_t ombh_len = sizeof *ombh; + + ombh = ofpbuf_put_zeros(msg, ombh_len); + + ombh->type = htons(mb->type); + ombh->len = htons(ombh_len); + ombh->rate = htonl(mb->rate); + ombh->burst_size = htonl(mb->burst_size); + ombh->prec_level = mb->prec_level; + + mb++; + } +} + +/* Encode a meter stat for 'mc' and append it to 'replies'. */ +void +ofputil_append_meter_config(struct list *replies, + const struct ofputil_meter_config *mc) +{ + struct ofpbuf *msg = ofpbuf_from_list(list_back(replies)); + size_t start_ofs = msg->size; + struct ofp13_meter_config *reply = ofpbuf_put_uninit(msg, sizeof *reply); + reply->flags = htons(mc->flags); + reply->meter_id = htonl(mc->meter_id); + + ofputil_put_bands(mc->n_bands, mc->bands, msg); + + reply->length = htons(msg->size - start_ofs); + + ofpmp_postappend(replies, start_ofs); +} + +/* Encode a meter stat for 'ms' and append it to 'replies'. */ +void +ofputil_append_meter_stats(struct list *replies, + const struct ofputil_meter_stats *ms) +{ + struct ofp13_meter_stats *reply; + uint16_t n = 0; + uint16_t len; + + len = sizeof *reply + ms->n_bands * sizeof(struct ofp13_meter_band_stats); + reply = ofpmp_append(replies, len); + + reply->meter_id = htonl(ms->meter_id); + reply->len = htons(len); + memset(reply->pad, 0, sizeof reply->pad); + reply->flow_count = htonl(ms->flow_count); + reply->packet_in_count = htonll(ms->packet_in_count); + reply->byte_in_count = htonll(ms->byte_in_count); + reply->duration_sec = htonl(ms->duration_sec); + reply->duration_nsec = htonl(ms->duration_nsec); + + for (n = 0; n < ms->n_bands; ++n) { + const struct ofputil_meter_band_stats *src = &ms->bands[n]; + struct ofp13_meter_band_stats *dst = &reply->band_stats[n]; + + dst->packet_band_count = htonll(src->packet_count); + dst->byte_band_count = htonll(src->byte_count); + } +} + +/* Converts an OFPMP_METER_CONFIG reply in 'msg' into an abstract + * ofputil_meter_config in 'mc', with mc->bands pointing to bands decoded into + * 'bands'. The caller must have initialized 'bands' and retains ownership of + * it across the call. + * + * Multiple OFPST13_METER_CONFIG replies can be packed into a single OpenFlow + * message. Calling this function multiple times for a single 'msg' iterates + * through the replies. 'bands' is cleared for each reply. + * + * Returns 0 if successful, EOF if no replies were left in this 'msg', + * otherwise a positive errno value. */ +int +ofputil_decode_meter_config(struct ofpbuf *msg, + struct ofputil_meter_config *mc, + struct ofpbuf *bands) +{ + const struct ofp13_meter_config *omc; + enum ofperr err; + + /* Pull OpenFlow headers for the first call. */ + if (!msg->l2) { + ofpraw_pull_assert(msg); + } + + if (!msg->size) { + return EOF; + } + + omc = ofpbuf_try_pull(msg, sizeof *omc); + if (!omc) { + VLOG_WARN_RL(&bad_ofmsg_rl, + "OFPMP_METER_CONFIG reply has %zu leftover bytes at end", + msg->size); + return OFPERR_OFPBRC_BAD_LEN; + } + + ofpbuf_clear(bands); + err = ofputil_pull_bands(msg, ntohs(omc->length) - sizeof *omc, + &mc->n_bands, bands); + if (err) { + return err; + } + mc->meter_id = ntohl(omc->meter_id); + mc->flags = ntohs(omc->flags); + mc->bands = bands->data; + + return 0; +} + +static enum ofperr +ofputil_pull_band_stats(struct ofpbuf *msg, size_t len, uint16_t *n_bands, + struct ofpbuf *bands) +{ + const struct ofp13_meter_band_stats *ombs; + struct ofputil_meter_band_stats *mbs; + uint16_t n, i; + + ombs = ofpbuf_try_pull(msg, len); + if (!ombs) { + return OFPERR_OFPBRC_BAD_LEN; + } + + n = len / sizeof *ombs; + if (len != n * sizeof *ombs) { + return OFPERR_OFPBRC_BAD_LEN; + } + + mbs = ofpbuf_put_uninit(bands, len); + + for (i = 0; i < n; ++i) { + mbs[i].packet_count = ntohll(ombs[i].packet_band_count); + mbs[i].byte_count = ntohll(ombs[i].byte_band_count); + } + *n_bands = n; + return 0; +} + +/* Converts an OFPMP_METER reply in 'msg' into an abstract + * ofputil_meter_stats in 'ms', with ms->bands pointing to band stats + * decoded into 'bands'. + * + * Multiple OFPMP_METER replies can be packed into a single OpenFlow + * message. Calling this function multiple times for a single 'msg' iterates + * through the replies. 'bands' is cleared for each reply. + * + * Returns 0 if successful, EOF if no replies were left in this 'msg', + * otherwise a positive errno value. */ +int +ofputil_decode_meter_stats(struct ofpbuf *msg, + struct ofputil_meter_stats *ms, + struct ofpbuf *bands) +{ + const struct ofp13_meter_stats *oms; + enum ofperr err; + + /* Pull OpenFlow headers for the first call. */ + if (!msg->l2) { + ofpraw_pull_assert(msg); + } + + if (!msg->size) { + return EOF; + } + + oms = ofpbuf_try_pull(msg, sizeof *oms); + if (!oms) { + VLOG_WARN_RL(&bad_ofmsg_rl, + "OFPMP_METER reply has %zu leftover bytes at end", + msg->size); + return OFPERR_OFPBRC_BAD_LEN; + } + + ofpbuf_clear(bands); + err = ofputil_pull_band_stats(msg, ntohs(oms->len) - sizeof *oms, + &ms->n_bands, bands); + if (err) { + return err; + } + ms->meter_id = ntohl(oms->meter_id); + ms->flow_count = ntohl(oms->flow_count); + ms->packet_in_count = ntohll(oms->packet_in_count); + ms->byte_in_count = ntohll(oms->byte_in_count); + ms->duration_sec = ntohl(oms->duration_sec); + ms->duration_nsec = ntohl(oms->duration_nsec); + ms->bands = bands->data; + + return 0; +} + +void +ofputil_decode_meter_features(const struct ofp_header *oh, + struct ofputil_meter_features *mf) +{ + const struct ofp13_meter_features *omf = ofpmsg_body(oh); + + mf->max_meters = ntohl(omf->max_meter); + mf->band_types = ntohl(omf->band_types); + mf->capabilities = ntohl(omf->capabilities); + mf->max_bands = omf->max_bands; + mf->max_color = omf->max_color; +} + +struct ofpbuf * +ofputil_encode_meter_features_reply(const struct ofputil_meter_features *mf, + const struct ofp_header *request) +{ + struct ofpbuf *reply; + struct ofp13_meter_features *omf; + + reply = ofpraw_alloc_stats_reply(request, 0); + omf = ofpbuf_put_zeros(reply, sizeof *omf); + + omf->max_meter = htonl(mf->max_meters); + omf->band_types = htonl(mf->band_types); + omf->capabilities = htonl(mf->capabilities); + omf->max_bands = mf->max_bands; + omf->max_color = mf->max_color; + + return reply; +} + +struct ofpbuf * +ofputil_encode_meter_mod(enum ofp_version ofp_version, + const struct ofputil_meter_mod *mm) +{ + struct ofpbuf *msg; + + struct ofp13_meter_mod *omm; + + msg = ofpraw_alloc(OFPRAW_OFPT13_METER_MOD, ofp_version, + NXM_TYPICAL_LEN + mm->meter.n_bands * 16); + omm = ofpbuf_put_zeros(msg, sizeof *omm); + omm->command = htons(mm->command); + if (mm->command != OFPMC13_DELETE) { + omm->flags = htons(mm->meter.flags); + } + omm->meter_id = htonl(mm->meter.meter_id); + + ofputil_put_bands(mm->meter.n_bands, mm->meter.bands, msg); + + ofpmsg_update_length(msg); + return msg; +} + static ovs_be16 ofputil_tid_command(const struct ofputil_flow_mod *fm, enum ofputil_protocol protocol) @@ -1655,15 +2112,22 @@ ofputil_encode_flow_mod(const struct ofputil_flow_mod *fm, struct ofpbuf *msg; switch (protocol) { + case OFPUTIL_P_OF11_STD: case OFPUTIL_P_OF12_OXM: case OFPUTIL_P_OF13_OXM: { struct ofp11_flow_mod *ofm; + int tailroom; - msg = ofpraw_alloc(OFPRAW_OFPT11_FLOW_MOD, + tailroom = ofputil_match_typical_len(protocol) + fm->ofpacts_len; + msg = ofpraw_alloc(OFPRAW_OFPT11_FLOW_MOD, ofputil_protocol_to_ofp_version(protocol), - NXM_TYPICAL_LEN + fm->ofpacts_len); + tailroom); ofm = ofpbuf_put_zeros(msg, sizeof *ofm); - if (fm->command == OFPFC_ADD) { + if ((protocol == OFPUTIL_P_OF11_STD + && (fm->command == OFPFC_MODIFY || + fm->command == OFPFC_MODIFY_STRICT) + && fm->cookie_mask == htonll(0)) + || fm->command == OFPFC_ADD) { ofm->cookie = fm->new_cookie; } else { ofm->cookie = fm->cookie; @@ -1678,7 +2142,7 @@ ofputil_encode_flow_mod(const struct ofputil_flow_mod *fm, ofm->out_port = ofputil_port_to_ofp11(fm->out_port); ofm->out_group = htonl(OFPG11_ANY); ofm->flags = htons(fm->flags); - oxm_put_match(msg, &fm->match); + ofputil_put_ofp11_match(msg, &fm->match, protocol); ofpacts_put_openflow11_instructions(fm->ofpacts, fm->ofpacts_len, msg); break; } @@ -1697,7 +2161,7 @@ ofputil_encode_flow_mod(const struct ofputil_flow_mod *fm, ofm->hard_timeout = htons(fm->hard_timeout); ofm->priority = htons(fm->priority); ofm->buffer_id = htonl(fm->buffer_id); - ofm->out_port = htons(fm->out_port); + ofm->out_port = htons(ofp_to_u16(fm->out_port)); ofm->flags = htons(fm->flags); ofpacts_put_openflow10(fm->ofpacts, fm->ofpacts_len, msg); break; @@ -1719,7 +2183,7 @@ ofputil_encode_flow_mod(const struct ofputil_flow_mod *fm, nfm->hard_timeout = htons(fm->hard_timeout); nfm->priority = htons(fm->priority); nfm->buffer_id = htonl(fm->buffer_id); - nfm->out_port = htons(fm->out_port); + nfm->out_port = htons(ofp_to_u16(fm->out_port)); nfm->flags = htons(fm->flags); nfm->match_len = htons(match_len); ofpacts_put_openflow10(fm->ofpacts, fm->ofpacts_len, msg); @@ -1757,8 +2221,10 @@ ofputil_flow_mod_usable_protocols(const struct ofputil_flow_mod *fms, /* Matching of the cookie is only supported through NXM or OF1.1+. */ if (fm->cookie_mask != htonll(0)) { - usable_protocols &= OFPUTIL_P_OF10_NXM_ANY | OFPUTIL_P_OF12_OXM - | OFPUTIL_P_OF13_OXM; + usable_protocols &= (OFPUTIL_P_OF10_NXM_ANY + | OFPUTIL_P_OF11_STD + | OFPUTIL_P_OF12_OXM + | OFPUTIL_P_OF13_OXM); } } @@ -1772,7 +2238,7 @@ ofputil_decode_ofpst10_flow_request(struct ofputil_flow_stats_request *fsr, { fsr->aggregate = aggregate; ofputil_match_from_ofp10_match(&ofsr->match, &fsr->match); - fsr->out_port = ntohs(ofsr->out_port); + fsr->out_port = u16_to_ofp(ntohs(ofsr->out_port)); fsr->table_id = ofsr->table_id; fsr->cookie = fsr->cookie_mask = htonll(0); @@ -1824,7 +2290,7 @@ ofputil_decode_nxst_flow_request(struct ofputil_flow_stats_request *fsr, } fsr->aggregate = aggregate; - fsr->out_port = ntohs(nfsr->out_port); + fsr->out_port = u16_to_ofp(ntohs(nfsr->out_port)); fsr->table_id = nfsr->table_id; return 0; @@ -1878,6 +2344,7 @@ ofputil_encode_flow_stats_request(const struct ofputil_flow_stats_request *fsr, enum ofpraw raw; switch (protocol) { + case OFPUTIL_P_OF11_STD: case OFPUTIL_P_OF12_OXM: case OFPUTIL_P_OF13_OXM: { struct ofp11_flow_stats_request *ofsr; @@ -1886,14 +2353,14 @@ ofputil_encode_flow_stats_request(const struct ofputil_flow_stats_request *fsr, ? OFPRAW_OFPST11_AGGREGATE_REQUEST : OFPRAW_OFPST11_FLOW_REQUEST); msg = ofpraw_alloc(raw, ofputil_protocol_to_ofp_version(protocol), - NXM_TYPICAL_LEN); + ofputil_match_typical_len(protocol)); ofsr = ofpbuf_put_zeros(msg, sizeof *ofsr); ofsr->table_id = fsr->table_id; ofsr->out_port = ofputil_port_to_ofp11(fsr->out_port); ofsr->out_group = htonl(OFPG11_ANY); ofsr->cookie = fsr->cookie; ofsr->cookie_mask = fsr->cookie_mask; - oxm_put_match(msg, &fsr->match); + ofputil_put_ofp11_match(msg, &fsr->match, protocol); break; } @@ -1908,7 +2375,7 @@ ofputil_encode_flow_stats_request(const struct ofputil_flow_stats_request *fsr, ofsr = ofpbuf_put_zeros(msg, sizeof *ofsr); ofputil_match_to_ofp10_match(&fsr->match, &ofsr->match); ofsr->table_id = fsr->table_id; - ofsr->out_port = htons(fsr->out_port); + ofsr->out_port = htons(ofp_to_u16(fsr->out_port)); break; } @@ -1926,7 +2393,7 @@ ofputil_encode_flow_stats_request(const struct ofputil_flow_stats_request *fsr, fsr->cookie, fsr->cookie_mask); nfsr = msg->l3; - nfsr->out_port = htons(fsr->out_port); + nfsr->out_port = htons(ofp_to_u16(fsr->out_port)); nfsr->match_len = htons(match_len); nfsr->table_id = fsr->table_id; break; @@ -2369,13 +2836,15 @@ ofputil_encode_flow_removed(const struct ofputil_flow_removed *fr, struct ofpbuf *msg; switch (protocol) { + case OFPUTIL_P_OF11_STD: case OFPUTIL_P_OF12_OXM: case OFPUTIL_P_OF13_OXM: { struct ofp12_flow_removed *ofr; msg = ofpraw_alloc_xid(OFPRAW_OFPT11_FLOW_REMOVED, ofputil_protocol_to_ofp_version(protocol), - htonl(0), NXM_TYPICAL_LEN); + htonl(0), + ofputil_match_typical_len(protocol)); ofr = ofpbuf_put_zeros(msg, sizeof *ofr); ofr->cookie = fr->cookie; ofr->priority = htons(fr->priority); @@ -2387,7 +2856,7 @@ ofputil_encode_flow_removed(const struct ofputil_flow_removed *fr, ofr->hard_timeout = htons(fr->hard_timeout); ofr->packet_count = htonll(fr->packet_count); ofr->byte_count = htonll(fr->byte_count); - oxm_put_match(msg, &fr->match); + ofputil_put_ofp11_match(msg, &fr->match, protocol); break; } @@ -2448,10 +2917,13 @@ ofputil_decode_packet_in_finish(struct ofputil_packet_in *pin, pin->packet = b->data; pin->packet_len = b->size; - pin->fmd.in_port = match->flow.in_port; + pin->fmd.in_port = match->flow.in_port.ofp_port; pin->fmd.tun_id = match->flow.tunnel.tun_id; + pin->fmd.tun_src = match->flow.tunnel.ip_src; + pin->fmd.tun_dst = match->flow.tunnel.ip_dst; pin->fmd.metadata = match->flow.metadata; memcpy(pin->fmd.regs, match->flow.regs, sizeof pin->fmd.regs); + pin->fmd.pkt_mark = match->flow.pkt_mark; } enum ofperr @@ -2505,7 +2977,7 @@ ofputil_decode_packet_in(struct ofputil_packet_in *pin, pin->packet = opi->data; pin->packet_len = b.size; - pin->fmd.in_port = ntohs(opi->in_port); + pin->fmd.in_port = u16_to_ofp(ntohs(opi->in_port)); pin->reason = opi->reason; pin->buffer_id = ntohl(opi->buffer_id); pin->total_len = ntohs(opi->total_len); @@ -2550,6 +3022,12 @@ ofputil_packet_in_to_match(const struct ofputil_packet_in *pin, if (pin->fmd.tun_id != htonll(0)) { match_set_tun_id(match, pin->fmd.tun_id); } + if (pin->fmd.tun_src != htonl(0)) { + match_set_tun_src(match, pin->fmd.tun_src); + } + if (pin->fmd.tun_dst != htonl(0)) { + match_set_tun_dst(match, pin->fmd.tun_dst); + } if (pin->fmd.metadata != htonll(0)) { match_set_metadata(match, pin->fmd.metadata); } @@ -2560,6 +3038,10 @@ ofputil_packet_in_to_match(const struct ofputil_packet_in *pin, } } + if (pin->fmd.pkt_mark != 0) { + match_set_pkt_mark(match, pin->fmd.pkt_mark); + } + match_set_in_port(match, pin->fmd.in_port); } @@ -2617,7 +3099,7 @@ ofputil_encode_packet_in(const struct ofputil_packet_in *pin, htonl(0), send_len); opi = ofpbuf_put_zeros(packet, offsetof(struct ofp10_packet_in, data)); opi->total_len = htons(pin->total_len); - opi->in_port = htons(pin->fmd.in_port); + opi->in_port = htons(ofp_to_u16(pin->fmd.in_port)); opi->reason = pin->reason; opi->buffer_id = htonl(pin->buffer_id); @@ -2653,11 +3135,13 @@ ofputil_encode_packet_in(const struct ofputil_packet_in *pin, return packet; } +/* 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 OFPUTIL_PACKET_IN_REASON_BUFSIZE. */ const char * -ofputil_packet_in_reason_to_string(enum ofp_packet_in_reason reason) +ofputil_packet_in_reason_to_string(enum ofp_packet_in_reason reason, + char *reasonbuf, size_t bufsize) { - static char s[INT_STRLEN(int) + 1]; - switch (reason) { case OFPR_NO_MATCH: return "no_match"; @@ -2668,8 +3152,8 @@ ofputil_packet_in_reason_to_string(enum ofp_packet_in_reason reason) case OFPR_N_REASONS: default: - sprintf(s, "%d", (int) reason); - return s; + snprintf(reasonbuf, bufsize, "%d", (int) reason); + return reasonbuf; } } @@ -2680,7 +3164,12 @@ ofputil_packet_in_reason_from_string(const char *s, int i; for (i = 0; i < OFPR_N_REASONS; i++) { - if (!strcasecmp(s, ofputil_packet_in_reason_to_string(i))) { + char reasonbuf[OFPUTIL_PACKET_IN_REASON_BUFSIZE]; + const char *reason_s; + + reason_s = ofputil_packet_in_reason_to_string(i, reasonbuf, + sizeof reasonbuf); + if (!strcasecmp(s, reason_s)) { *reason = i; return true; } @@ -2727,7 +3216,7 @@ ofputil_decode_packet_out(struct ofputil_packet_out *po, const struct ofp10_packet_out *opo = ofpbuf_pull(&b, sizeof *opo); po->buffer_id = ntohl(opo->buffer_id); - po->in_port = ntohs(opo->in_port); + po->in_port = u16_to_ofp(ntohs(opo->in_port)); error = ofpacts_pull_openflow10(&b, ntohs(opo->actions_len), ofpacts); if (error) { @@ -2737,7 +3226,8 @@ ofputil_decode_packet_out(struct ofputil_packet_out *po, NOT_REACHED(); } - if (po->in_port >= OFPP_MAX && po->in_port != OFPP_LOCAL + if (ofp_to_u16(po->in_port) >= ofp_to_u16(OFPP_MAX) + && po->in_port != OFPP_LOCAL && po->in_port != OFPP_NONE && po->in_port != OFPP_CONTROLLER) { VLOG_WARN_RL(&bad_ofmsg_rl, "packet-out has bad input port %#"PRIx16, po->in_port); @@ -2824,7 +3314,7 @@ ofputil_decode_ofp10_phy_port(struct ofputil_phy_port *pp, { memset(pp, 0, sizeof *pp); - pp->port_no = ntohs(opp->port_no); + pp->port_no = u16_to_ofp(ntohs(opp->port_no)); memcpy(pp->hw_addr, opp->hw_addr, OFP_ETH_ALEN); ovs_strlcpy(pp->name, opp->name, OFP_MAX_PORT_NAME_LEN); @@ -2892,7 +3382,7 @@ ofputil_encode_ofp10_phy_port(const struct ofputil_phy_port *pp, { memset(opp, 0, sizeof *opp); - opp->port_no = htons(pp->port_no); + opp->port_no = htons(ofp_to_u16(pp->port_no)); memcpy(opp->hw_addr, pp->hw_addr, ETH_ADDR_LEN); ovs_strlcpy(opp->name, pp->name, OFP_MAX_PORT_NAME_LEN); @@ -3302,7 +3792,7 @@ ofputil_decode_port_mod(const struct ofp_header *oh, if (raw == OFPRAW_OFPT10_PORT_MOD) { const struct ofp10_port_mod *opm = b.data; - pm->port_no = ntohs(opm->port_no); + pm->port_no = u16_to_ofp(ntohs(opm->port_no)); memcpy(pm->hw_addr, opm->hw_addr, ETH_ADDR_LEN); pm->config = ntohl(opm->config) & OFPPC10_ALL; pm->mask = ntohl(opm->mask) & OFPPC10_ALL; @@ -3344,7 +3834,7 @@ ofputil_encode_port_mod(const struct ofputil_port_mod *pm, b = ofpraw_alloc(OFPRAW_OFPT10_PORT_MOD, ofp_version, 0); opm = ofpbuf_put_zeros(b, sizeof *opm); - opm->port_no = htons(pm->port_no); + opm->port_no = htons(ofp_to_u16(pm->port_no)); memcpy(opm->hw_addr, pm->hw_addr, ETH_ADDR_LEN); opm->config = htonl(pm->config & OFPPC10_ALL); opm->mask = htonl(pm->mask & OFPPC10_ALL); @@ -3680,7 +4170,7 @@ ofputil_decode_flow_monitor_request(struct ofputil_flow_monitor_request *rq, rq->id = ntohl(nfmr->id); rq->flags = flags; - rq->out_port = ntohs(nfmr->out_port); + rq->out_port = u16_to_ofp(ntohs(nfmr->out_port)); rq->table_id = nfmr->table_id; return nx_pull_match(msg, ntohs(nfmr->match_len), &rq->match, NULL, NULL); @@ -3705,7 +4195,7 @@ ofputil_append_flow_monitor_request( nfmr = ofpbuf_at_assert(msg, start_ofs, sizeof *nfmr); nfmr->id = htonl(rq->id); nfmr->flags = htons(rq->flags); - nfmr->out_port = htons(rq->out_port); + nfmr->out_port = htons(ofp_to_u16(rq->out_port)); nfmr->match_len = htons(match_len); nfmr->table_id = rq->table_id; } @@ -3913,7 +4403,7 @@ ofputil_encode_packet_out(const struct ofputil_packet_out *po, opo = msg->l3; opo->buffer_id = htonl(po->buffer_id); - opo->in_port = htons(po->in_port); + opo->in_port = htons(ofp_to_u16(po->in_port)); opo->actions_len = htons(msg->size - actions_ofs); break; } @@ -4028,25 +4518,26 @@ ofputil_frag_handling_from_string(const char *s, enum ofp_config_flags *flags) /* Converts the OpenFlow 1.1+ port number 'ofp11_port' into an OpenFlow 1.0 * port number and stores the latter in '*ofp10_port', for the purpose of * decoding OpenFlow 1.1+ protocol messages. Returns 0 if successful, - * otherwise an OFPERR_* number. + * otherwise an OFPERR_* number. On error, stores OFPP_NONE in '*ofp10_port'. * * See the definition of OFP11_MAX for an explanation of the mapping. */ enum ofperr -ofputil_port_from_ofp11(ovs_be32 ofp11_port, uint16_t *ofp10_port) +ofputil_port_from_ofp11(ovs_be32 ofp11_port, ofp_port_t *ofp10_port) { uint32_t ofp11_port_h = ntohl(ofp11_port); - if (ofp11_port_h < OFPP_MAX) { - *ofp10_port = ofp11_port_h; + if (ofp11_port_h < ofp_to_u16(OFPP_MAX)) { + *ofp10_port = u16_to_ofp(ofp11_port_h); return 0; - } else if (ofp11_port_h >= OFPP11_MAX) { - *ofp10_port = ofp11_port_h - OFPP11_OFFSET; + } else if (ofp11_port_h >= ofp11_to_u32(OFPP11_MAX)) { + *ofp10_port = u16_to_ofp(ofp11_port_h - OFPP11_OFFSET); return 0; } else { + *ofp10_port = OFPP_NONE; VLOG_WARN_RL(&bad_ofmsg_rl, "port %"PRIu32" is outside the supported " "range 0 through %d or 0x%"PRIx32" through 0x%"PRIx32, - ofp11_port_h, OFPP_MAX - 1, - (uint32_t) OFPP11_MAX, UINT32_MAX); + ofp11_port_h, ofp_to_u16(OFPP_MAX) - 1, + ofp11_to_u32(OFPP11_MAX), UINT32_MAX); return OFPERR_OFPBAC_BAD_OUT_PORT; } } @@ -4056,18 +4547,18 @@ ofputil_port_from_ofp11(ovs_be32 ofp11_port, uint16_t *ofp10_port) * * See the definition of OFP11_MAX for an explanation of the mapping. */ ovs_be32 -ofputil_port_to_ofp11(uint16_t ofp10_port) +ofputil_port_to_ofp11(ofp_port_t ofp10_port) { - return htonl(ofp10_port < OFPP_MAX - ? ofp10_port - : ofp10_port + OFPP11_OFFSET); + return htonl(ofp_to_u16(ofp10_port) < ofp_to_u16(OFPP_MAX) + ? ofp_to_u16(ofp10_port) + : ofp_to_u16(ofp10_port) + OFPP11_OFFSET); } /* Checks that 'port' is a valid output port for the OFPAT10_OUTPUT action, given * that the switch will never have more than 'max_ports' ports. Returns 0 if * 'port' is valid, otherwise an OpenFlow return code. */ enum ofperr -ofputil_check_output_port(uint16_t port, int max_ports) +ofputil_check_output_port(ofp_port_t port, ofp_port_t max_ports) { switch (port) { case OFPP_IN_PORT: @@ -4081,7 +4572,7 @@ ofputil_check_output_port(uint16_t port, int max_ports) return 0; default: - if (port < max_ports) { + if (ofp_to_u16(port) < ofp_to_u16(max_ports)) { return 0; } return OFPERR_OFPBAC_BAD_OUT_PORT; @@ -4117,46 +4608,40 @@ ofputil_check_output_port(uint16_t port, int max_ports) * of OpenFlow 1.1+ port numbers, mapping those port numbers into the 16-bit * range as described in include/openflow/openflow-1.1.h. */ bool -ofputil_port_from_string(const char *s, uint16_t *portp) +ofputil_port_from_string(const char *s, ofp_port_t *portp) { - unsigned int port32; + uint32_t port32; *portp = 0; if (str_to_uint(s, 10, &port32)) { - if (port32 < OFPP_MAX) { - *portp = port32; - return true; - } else if (port32 < OFPP_FIRST_RESV) { + if (port32 < ofp_to_u16(OFPP_MAX)) { + /* Pass. */ + } else if (port32 < ofp_to_u16(OFPP_FIRST_RESV)) { VLOG_WARN("port %u is a reserved OF1.0 port number that will " "be translated to %u when talking to an OF1.1 or " "later controller", port32, port32 + OFPP11_OFFSET); - *portp = port32; - return true; - } else if (port32 <= OFPP_LAST_RESV) { - struct ds msg; - - ds_init(&msg); - ofputil_format_port(port32, &msg); - VLOG_WARN_ONCE("referring to port %s as %u is deprecated for " - "compatibility with future versions of OpenFlow", - ds_cstr(&msg), port32); - ds_destroy(&msg); - - *portp = port32; - return true; - } else if (port32 < OFPP11_MAX) { + } else if (port32 <= ofp_to_u16(OFPP_LAST_RESV)) { + char name[OFP_MAX_PORT_NAME_LEN]; + + ofputil_port_to_string(u16_to_ofp(port32), name, sizeof name); + VLOG_WARN_ONCE("referring to port %s as %"PRIu32" is deprecated " + "for compatibility with OpenFlow 1.1 and later", + name, port32); + } else if (port32 < ofp11_to_u32(OFPP11_MAX)) { VLOG_WARN("port %u is outside the supported range 0 through " "%"PRIx16" or 0x%x through 0x%"PRIx32, port32, - UINT16_MAX, (unsigned int) OFPP11_MAX, UINT32_MAX); + UINT16_MAX, ofp11_to_u32(OFPP11_MAX), UINT32_MAX); return false; } else { - *portp = port32 - OFPP11_OFFSET; - return true; + port32 -= OFPP11_OFFSET; } + + *portp = u16_to_ofp(port32); + return true; } else { struct pair { const char *name; - uint16_t value; + ofp_port_t value; }; static const struct pair pairs[] = { #define OFPUTIL_NAMED_PORT(NAME) {#NAME, OFPP_##NAME}, @@ -4179,20 +4664,34 @@ ofputil_port_from_string(const char *s, uint16_t *portp) * Most ports' string representation is just the port number, but for special * ports, e.g. OFPP_LOCAL, it is the name, e.g. "LOCAL". */ void -ofputil_format_port(uint16_t port, struct ds *s) +ofputil_format_port(ofp_port_t port, struct ds *s) { - const char *name; + char name[OFP_MAX_PORT_NAME_LEN]; + ofputil_port_to_string(port, name, sizeof name); + ds_put_cstr(s, name); +} + +/* Puts in the 'bufsize' byte in 'namebuf' a null-terminated string + * representation of OpenFlow port number 'port'. Most ports are represented + * as just the port number, but special ports, e.g. OFPP_LOCAL, are represented + * by name, e.g. "LOCAL". */ +void +ofputil_port_to_string(ofp_port_t port, + char namebuf[OFP_MAX_PORT_NAME_LEN], size_t bufsize) +{ switch (port) { -#define OFPUTIL_NAMED_PORT(NAME) case OFPP_##NAME: name = #NAME; break; +#define OFPUTIL_NAMED_PORT(NAME) \ + case OFPP_##NAME: \ + ovs_strlcpy(namebuf, #NAME, bufsize); \ + break; OFPUTIL_NAMED_PORTS #undef OFPUTIL_NAMED_PORT default: - ds_put_format(s, "%"PRIu16, port); - return; + snprintf(namebuf, bufsize, "%"PRIu16, port); + break; } - ds_put_cstr(s, name); } /* Given a buffer 'b' that contains an array of OpenFlow ports of type @@ -4235,7 +4734,7 @@ size_t ofputil_count_phy_ports(uint8_t ofp_version, struct ofpbuf *b) int ofputil_action_code_from_name(const char *name) { - static const char *names[OFPUTIL_N_ACTIONS] = { + static const char *const names[OFPUTIL_N_ACTIONS] = { NULL, #define OFPAT10_ACTION(ENUM, STRUCT, NAME) NAME, #define OFPAT11_ACTION(ENUM, STRUCT, EXTENSIBLE, NAME) NAME, @@ -4243,7 +4742,7 @@ ofputil_action_code_from_name(const char *name) #include "ofp-util.def" }; - const char **p; + const char *const *p; for (p = names; p < &names[ARRAY_SIZE(names)]; p++) { if (*p && !strcasecmp(name, *p)) { @@ -4520,7 +5019,7 @@ ofputil_parse_key_value(char **stringp, char **keyp, char **valuep) * will be for Open Flow version 'ofp_version'. Returns message * as a struct ofpbuf. Returns encoded message on success, NULL on error */ struct ofpbuf * -ofputil_encode_dump_ports_request(enum ofp_version ofp_version, int16_t port) +ofputil_encode_dump_ports_request(enum ofp_version ofp_version, ofp_port_t port) { struct ofpbuf *request; @@ -4529,7 +5028,7 @@ ofputil_encode_dump_ports_request(enum ofp_version ofp_version, int16_t port) struct ofp10_port_stats_request *req; request = ofpraw_alloc(OFPRAW_OFPST10_PORT_REQUEST, ofp_version, 0); req = ofpbuf_put_zeros(request, sizeof *req); - req->port_no = htons(port); + req->port_no = htons(ofp_to_u16(port)); break; } case OFP11_VERSION: @@ -4552,7 +5051,7 @@ static void ofputil_port_stats_to_ofp10(const struct ofputil_port_stats *ops, struct ofp10_port_stats *ps10) { - ps10->port_no = htons(ops->port_no); + ps10->port_no = htons(ofp_to_u16(ops->port_no)); memset(ps10->pad, 0, sizeof ps10->pad); put_32aligned_be64(&ps10->rx_packets, htonll(ops->stats.rx_packets)); put_32aligned_be64(&ps10->tx_packets, htonll(ops->stats.tx_packets)); @@ -4593,11 +5092,8 @@ ofputil_port_stats_to_ofp13(const struct ofputil_port_stats *ops, struct ofp13_port_stats *ps13) { ofputil_port_stats_to_ofp11(ops, &ps13->ps); - - /* OF 1.3 adds duration fields */ - /* FIXME: Need to implement port alive duration (sec + nsec) */ - ps13->duration_sec = htonl(~0); - ps13->duration_nsec = htonl(~0); + ps13->duration_sec = htonl(ops->duration_sec); + ps13->duration_nsec = htonl(ops->duration_nsec); } @@ -4639,7 +5135,7 @@ ofputil_port_stats_from_ofp10(struct ofputil_port_stats *ops, { memset(ops, 0, sizeof *ops); - ops->port_no = ntohs(ps10->port_no); + ops->port_no = u16_to_ofp(ntohs(ps10->port_no)); ops->stats.rx_packets = ntohll(get_32aligned_be64(&ps10->rx_packets)); ops->stats.tx_packets = ntohll(get_32aligned_be64(&ps10->tx_packets)); ops->stats.rx_bytes = ntohll(get_32aligned_be64(&ps10->rx_bytes)); @@ -4653,6 +5149,7 @@ ofputil_port_stats_from_ofp10(struct ofputil_port_stats *ops, ops->stats.rx_over_errors = ntohll(get_32aligned_be64(&ps10->rx_over_err)); ops->stats.rx_crc_errors = ntohll(get_32aligned_be64(&ps10->rx_crc_err)); ops->stats.collisions = ntohll(get_32aligned_be64(&ps10->collisions)); + ops->duration_sec = ops->duration_nsec = UINT32_MAX; return 0; } @@ -4681,6 +5178,7 @@ ofputil_port_stats_from_ofp11(struct ofputil_port_stats *ops, ops->stats.rx_over_errors = ntohll(ps11->rx_over_err); ops->stats.rx_crc_errors = ntohll(ps11->rx_crc_err); ops->stats.collisions = ntohll(ps11->collisions); + ops->duration_sec = ops->duration_nsec = UINT32_MAX; return 0; } @@ -4689,16 +5187,29 @@ static enum ofperr ofputil_port_stats_from_ofp13(struct ofputil_port_stats *ops, const struct ofp13_port_stats *ps13) { - enum ofperr error = - ofputil_port_stats_from_ofp11(ops, &ps13->ps); + enum ofperr error = ofputil_port_stats_from_ofp11(ops, &ps13->ps); if (!error) { - /* FIXME: Get ps13->duration_sec and ps13->duration_nsec, - * Add to netdev_stats? */ + ops->duration_sec = ntohl(ps13->duration_sec); + ops->duration_nsec = ntohl(ps13->duration_nsec); } - return error; } +static size_t +ofputil_get_port_stats_size(enum ofp_version ofp_version) +{ + switch (ofp_version) { + case OFP10_VERSION: + return sizeof(struct ofp10_port_stats); + case OFP11_VERSION: + case OFP12_VERSION: + return sizeof(struct ofp11_port_stats); + case OFP13_VERSION: + return sizeof(struct ofp13_port_stats); + default: + NOT_REACHED(); + } +} /* Returns the number of port stats elements in OFPTYPE_PORT_STATS_REPLY * message 'oh'. */ @@ -4710,9 +5221,7 @@ ofputil_count_port_stats(const struct ofp_header *oh) ofpbuf_use_const(&b, oh, ntohs(oh->length)); ofpraw_pull_assert(&b); - BUILD_ASSERT(sizeof(struct ofp10_port_stats) == - sizeof(struct ofp11_port_stats)); - return b.size / sizeof(struct ofp10_port_stats); + return b.size / ofputil_get_port_stats_size(oh->version); } /* Converts an OFPST_PORT_STATS reply in 'msg' into an abstract @@ -4779,7 +5288,7 @@ ofputil_decode_port_stats(struct ofputil_port_stats *ps, struct ofpbuf *msg) * Returns 0 if successful, otherwise an OFPERR_* number. */ enum ofperr ofputil_decode_port_stats_request(const struct ofp_header *request, - uint16_t *ofp10_port) + ofp_port_t *ofp10_port) { switch ((enum ofp_version)request->version) { case OFP13_VERSION: @@ -4791,7 +5300,7 @@ ofputil_decode_port_stats_request(const struct ofp_header *request, case OFP10_VERSION: { const struct ofp10_port_stats_request *psr10 = ofpmsg_body(request); - *ofp10_port = ntohs(psr10->port_no); + *ofp10_port = u16_to_ofp(ntohs(psr10->port_no)); return 0; } @@ -4818,7 +5327,7 @@ ofputil_decode_queue_stats_request(const struct ofp_header *request, case OFP10_VERSION: { const struct ofp10_queue_stats_request *qsr10 = ofpmsg_body(request); oqsr->queue_id = ntohl(qsr10->queue_id); - oqsr->port_no = ntohs(qsr10->port_no); + oqsr->port_no = u16_to_ofp(ntohs(qsr10->port_no)); /* OF 1.0 uses OFPP_ALL for OFPP_ANY */ if (oqsr->port_no == OFPP_ALL) { oqsr->port_no = OFPP_ANY; @@ -4856,8 +5365,8 @@ ofputil_encode_queue_stats_request(enum ofp_version ofp_version, request = ofpraw_alloc(OFPRAW_OFPST10_QUEUE_REQUEST, ofp_version, 0); req = ofpbuf_put_zeros(request, sizeof *req); /* OpenFlow 1.0 needs OFPP_ALL instead of OFPP_ANY */ - req->port_no = htons(oqsr->port_no == OFPP_ANY - ? OFPP_ALL : oqsr->port_no); + req->port_no = htons(ofp_to_u16(oqsr->port_no == OFPP_ANY + ? OFPP_ALL : oqsr->port_no)); req->queue_id = htonl(oqsr->queue_id); break; } @@ -4868,6 +5377,22 @@ ofputil_encode_queue_stats_request(enum ofp_version ofp_version, return request; } +static size_t +ofputil_get_queue_stats_size(enum ofp_version ofp_version) +{ + switch (ofp_version) { + case OFP10_VERSION: + return sizeof(struct ofp10_queue_stats); + case OFP11_VERSION: + case OFP12_VERSION: + return sizeof(struct ofp11_queue_stats); + case OFP13_VERSION: + return sizeof(struct ofp13_queue_stats); + default: + NOT_REACHED(); + } +} + /* Returns the number of queue stats elements in OFPTYPE_QUEUE_STATS_REPLY * message 'oh'. */ size_t @@ -4878,20 +5403,19 @@ ofputil_count_queue_stats(const struct ofp_header *oh) ofpbuf_use_const(&b, oh, ntohs(oh->length)); ofpraw_pull_assert(&b); - BUILD_ASSERT(sizeof(struct ofp10_queue_stats) == - sizeof(struct ofp11_queue_stats)); - return b.size / sizeof(struct ofp10_queue_stats); + return b.size / ofputil_get_queue_stats_size(oh->version); } static enum ofperr ofputil_queue_stats_from_ofp10(struct ofputil_queue_stats *oqs, const struct ofp10_queue_stats *qs10) { - oqs->port_no = ntohs(qs10->port_no); + oqs->port_no = u16_to_ofp(ntohs(qs10->port_no)); oqs->queue_id = ntohl(qs10->queue_id); - oqs->stats.tx_bytes = ntohll(get_32aligned_be64(&qs10->tx_bytes)); - oqs->stats.tx_packets = ntohll(get_32aligned_be64(&qs10->tx_packets)); - oqs->stats.tx_errors = ntohll(get_32aligned_be64(&qs10->tx_errors)); + oqs->tx_bytes = ntohll(get_32aligned_be64(&qs10->tx_bytes)); + oqs->tx_packets = ntohll(get_32aligned_be64(&qs10->tx_packets)); + oqs->tx_errors = ntohll(get_32aligned_be64(&qs10->tx_errors)); + oqs->duration_sec = oqs->duration_nsec = UINT32_MAX; return 0; } @@ -4908,9 +5432,10 @@ ofputil_queue_stats_from_ofp11(struct ofputil_queue_stats *oqs, } oqs->queue_id = ntohl(qs11->queue_id); - oqs->stats.tx_bytes = ntohll(qs11->tx_bytes); - oqs->stats.tx_packets = ntohll(qs11->tx_packets); - oqs->stats.tx_errors = ntohll(qs11->tx_errors); + oqs->tx_bytes = ntohll(qs11->tx_bytes); + oqs->tx_packets = ntohll(qs11->tx_packets); + oqs->tx_errors = ntohll(qs11->tx_errors); + oqs->duration_sec = oqs->duration_nsec = UINT32_MAX; return 0; } @@ -4919,11 +5444,10 @@ static enum ofperr ofputil_queue_stats_from_ofp13(struct ofputil_queue_stats *oqs, const struct ofp13_queue_stats *qs13) { - enum ofperr error - = ofputil_queue_stats_from_ofp11(oqs, &qs13->qs); + enum ofperr error = ofputil_queue_stats_from_ofp11(oqs, &qs13->qs); if (!error) { - /* FIXME: Get qs13->duration_sec and qs13->duration_nsec, - * Add to netdev_queue_stats? */ + oqs->duration_sec = ntohl(qs13->duration_sec); + oqs->duration_nsec = ntohl(qs13->duration_nsec); } return error; @@ -4992,12 +5516,12 @@ static void ofputil_queue_stats_to_ofp10(const struct ofputil_queue_stats *oqs, struct ofp10_queue_stats *qs10) { - qs10->port_no = htons(oqs->port_no); + qs10->port_no = htons(ofp_to_u16(oqs->port_no)); memset(qs10->pad, 0, sizeof qs10->pad); qs10->queue_id = htonl(oqs->queue_id); - put_32aligned_be64(&qs10->tx_bytes, htonll(oqs->stats.tx_bytes)); - put_32aligned_be64(&qs10->tx_packets, htonll(oqs->stats.tx_packets)); - put_32aligned_be64(&qs10->tx_errors, htonll(oqs->stats.tx_errors)); + put_32aligned_be64(&qs10->tx_bytes, htonll(oqs->tx_bytes)); + put_32aligned_be64(&qs10->tx_packets, htonll(oqs->tx_packets)); + put_32aligned_be64(&qs10->tx_errors, htonll(oqs->tx_errors)); } static void @@ -5006,9 +5530,9 @@ ofputil_queue_stats_to_ofp11(const struct ofputil_queue_stats *oqs, { qs11->port_no = ofputil_port_to_ofp11(oqs->port_no); qs11->queue_id = htonl(oqs->queue_id); - qs11->tx_bytes = htonll(oqs->stats.tx_bytes); - qs11->tx_packets = htonll(oqs->stats.tx_packets); - qs11->tx_errors = htonll(oqs->stats.tx_errors); + qs11->tx_bytes = htonll(oqs->tx_bytes); + qs11->tx_packets = htonll(oqs->tx_packets); + qs11->tx_errors = htonll(oqs->tx_errors); } static void @@ -5016,10 +5540,13 @@ ofputil_queue_stats_to_ofp13(const struct ofputil_queue_stats *oqs, struct ofp13_queue_stats *qs13) { ofputil_queue_stats_to_ofp11(oqs, &qs13->qs); - /* OF 1.3 adds duration fields */ - /* FIXME: Need to implement queue alive duration (sec + nsec) */ - qs13->duration_sec = htonl(~0); - qs13->duration_nsec = htonl(~0); + if (oqs->duration_sec != UINT32_MAX) { + qs13->duration_sec = htonl(oqs->duration_sec); + qs13->duration_nsec = htonl(oqs->duration_nsec); + } else { + qs13->duration_sec = htonl(UINT32_MAX); + qs13->duration_nsec = htonl(UINT32_MAX); + } } /* Encode a queue stat for 'oqs' and append it to 'replies'. */