X-Git-Url: http://git.onelab.eu/?a=blobdiff_plain;f=lib%2Fofp-util.c;h=aa4009d84db1d2b5959467be2311c2fa4396b0ed;hb=2b13d312fc4d6e5eb1d0e3004fa523bb0c0ba544;hp=e335ff8608e70b7534c65001816bd64b5b541188;hpb=8d7785bd5a9e8ce9f21714cc7a7c7dca1086bed0;p=sliver-openvswitch.git diff --git a/lib/ofp-util.c b/lib/ofp-util.c index e335ff860..aa4009d84 100644 --- a/lib/ofp-util.c +++ b/lib/ofp-util.c @@ -1,5 +1,5 @@ /* - * 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. @@ -23,7 +23,6 @@ #include #include #include -#include "autopath.h" #include "bundle.h" #include "byte-order.h" #include "classifier.h" @@ -85,13 +84,13 @@ ofputil_netmask_to_wcbits(ovs_be32 netmask) void ofputil_wildcard_from_ofpfw10(uint32_t ofpfw, struct flow_wildcards *wc) { - BUILD_ASSERT_DECL(FLOW_WC_SEQ == 17); + BUILD_ASSERT_DECL(FLOW_WC_SEQ == 20); /* Initialize most of 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)) { @@ -146,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; @@ -191,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) { @@ -245,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); @@ -312,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); @@ -440,8 +439,7 @@ ofputil_match_from_ofp11_match(const struct ofp11_match *ofmatch, } } - if (match->flow.dl_type == htons(ETH_TYPE_MPLS) || - match->flow.dl_type == htons(ETH_TYPE_MPLS_MCAST)) { + if (eth_type_mpls(match->flow.dl_type)) { enum { OFPFW11_MPLS_ALL = OFPFW11_MPLS_LABEL | OFPFW11_MPLS_TC }; if ((wc & OFPFW11_MPLS_ALL) != OFPFW11_MPLS_ALL) { @@ -468,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); @@ -583,38 +581,52 @@ struct proto_abbrev { static const struct proto_abbrev proto_abbrevs[] = { { OFPUTIL_P_ANY, "any" }, { OFPUTIL_P_OF10_STD_ANY, "OpenFlow10" }, - { OFPUTIL_P_OF10_NXM_ANY, "NXM" }, + { OFPUTIL_P_OF10_NXM_ANY, "NXM" }, + { OFPUTIL_P_ANY_OXM, "OXM" }, }; #define N_PROTO_ABBREVS ARRAY_SIZE(proto_abbrevs) enum ofputil_protocol ofputil_flow_dump_protocols[] = { + OFPUTIL_P_OF13_OXM, OFPUTIL_P_OF12_OXM, OFPUTIL_P_OF10_NXM, OFPUTIL_P_OF10_STD, }; size_t ofputil_n_flow_dump_protocols = ARRAY_SIZE(ofputil_flow_dump_protocols); -/* Returns the ofputil_protocol that is initially in effect on an OpenFlow - * connection that has negotiated the given 'version'. 'version' should - * normally be an 8-bit OpenFlow version identifier (e.g. 0x01 for OpenFlow - * 1.0, 0x02 for OpenFlow 1.1). Returns 0 if 'version' is not supported or - * outside the valid range. */ +/* Returns the set of ofputil_protocols that are supported with the given + * OpenFlow 'version'. 'version' should normally be an 8-bit OpenFlow version + * identifier (e.g. 0x01 for OpenFlow 1.0, 0x02 for OpenFlow 1.1). Returns 0 + * if 'version' is not supported or outside the valid range. */ enum ofputil_protocol -ofputil_protocol_from_ofp_version(enum ofp_version version) +ofputil_protocols_from_ofp_version(enum ofp_version version) { switch (version) { case OFP10_VERSION: - return OFPUTIL_P_OF10_STD; + return OFPUTIL_P_OF10_STD_ANY | OFPUTIL_P_OF10_NXM_ANY; case OFP12_VERSION: return OFPUTIL_P_OF12_OXM; + case OFP13_VERSION: + return OFPUTIL_P_OF13_OXM; case OFP11_VERSION: default: return 0; } } +/* Returns the ofputil_protocol that is initially in effect on an OpenFlow + * connection that has negotiated the given 'version'. 'version' should + * normally be an 8-bit OpenFlow version identifier (e.g. 0x01 for OpenFlow + * 1.0, 0x02 for OpenFlow 1.1). Returns 0 if 'version' is not supported or + * outside the valid range. */ +enum ofputil_protocol +ofputil_protocol_from_ofp_version(enum ofp_version version) +{ + return rightmost_1bit(ofputil_protocols_from_ofp_version(version)); +} + /* Returns the OpenFlow protocol version number (e.g. OFP10_VERSION, - * OFP11_VERSION or OFP12_VERSION) that corresponds to 'protocol'. */ + * etc.) that corresponds to 'protocol'. */ enum ofp_version ofputil_protocol_to_ofp_version(enum ofputil_protocol protocol) { @@ -626,11 +638,45 @@ ofputil_protocol_to_ofp_version(enum ofputil_protocol protocol) return OFP10_VERSION; case OFPUTIL_P_OF12_OXM: return OFP12_VERSION; + case OFPUTIL_P_OF13_OXM: + return OFP13_VERSION; } NOT_REACHED(); } +/* Returns a bitmap of OpenFlow versions that are supported by at + * least one of the 'protocols'. */ +uint32_t +ofputil_protocols_to_version_bitmap(enum ofputil_protocol protocols) +{ + uint32_t bitmap = 0; + + for (; protocols; protocols = zero_rightmost_1bit(protocols)) { + enum ofputil_protocol protocol = rightmost_1bit(protocols); + + bitmap |= 1u << ofputil_protocol_to_ofp_version(protocol); + } + + return bitmap; +} + +/* Returns the set of protocols that are supported on top of the + * OpenFlow versions included in 'bitmap'. */ +enum ofputil_protocol +ofputil_protocols_from_version_bitmap(uint32_t bitmap) +{ + enum ofputil_protocol protocols = 0; + + for (; bitmap; bitmap = zero_rightmost_1bit(bitmap)) { + enum ofp_version version = rightmost_1bit_idx(bitmap); + + protocols |= ofputil_protocols_from_ofp_version(version); + } + + return protocols; +} + /* Returns true if 'protocol' is a single OFPUTIL_P_* value, false * otherwise. */ bool @@ -664,6 +710,9 @@ ofputil_protocol_set_tid(enum ofputil_protocol protocol, bool enable) case OFPUTIL_P_OF12_OXM: return OFPUTIL_P_OF12_OXM; + case OFPUTIL_P_OF13_OXM: + return OFPUTIL_P_OF13_OXM; + default: NOT_REACHED(); } @@ -698,6 +747,9 @@ ofputil_protocol_set_base(enum ofputil_protocol cur, case OFPUTIL_P_OF12_OXM: return ofputil_protocol_set_tid(OFPUTIL_P_OF12_OXM, tid); + case OFPUTIL_P_OF13_OXM: + return ofputil_protocol_set_tid(OFPUTIL_P_OF13_OXM, tid); + default: NOT_REACHED(); } @@ -727,7 +779,10 @@ ofputil_protocol_to_string(enum ofputil_protocol protocol) return "OpenFlow10+table_id"; case OFPUTIL_P_OF12_OXM: - return "OXM"; + return "OXM-OpenFlow12"; + + case OFPUTIL_P_OF13_OXM: + return "OXM-OpenFlow13"; } /* Check abbreviations. */ @@ -750,7 +805,7 @@ ofputil_protocols_to_string(enum ofputil_protocol protocols) { struct ds s; - assert(!(protocols & ~OFPUTIL_P_ANY)); + ovs_assert(!(protocols & ~OFPUTIL_P_ANY)); if (protocols == 0) { return xstrdup("none"); } @@ -860,11 +915,14 @@ ofputil_version_from_string(const char *s) if (!strcasecmp(s, "OpenFlow12")) { return OFP12_VERSION; } + if (!strcasecmp(s, "OpenFlow13")) { + return OFP13_VERSION; + } return 0; } static bool -is_delimiter(char c) +is_delimiter(unsigned char c) { return isspace(c) || c == ','; } @@ -928,6 +986,8 @@ ofputil_version_to_string(enum ofp_version ofp_version) return "OpenFlow11"; case OFP12_VERSION: return "OpenFlow12"; + case OFP13_VERSION: + return "OpenFlow13"; default: NOT_REACHED(); } @@ -988,73 +1048,124 @@ ofputil_usable_protocols(const struct match *match) { const struct flow_wildcards *wc = &match->wc; - BUILD_ASSERT_DECL(FLOW_WC_SEQ == 17); + BUILD_ASSERT_DECL(FLOW_WC_SEQ == 20); + + /* 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) { + return OFPUTIL_P_NONE; + } /* 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)) { - return OFPUTIL_P_OF10_NXM_ANY | OFPUTIL_P_OF12_OXM; + return OFPUTIL_P_OF10_NXM_ANY | OFPUTIL_P_OF12_OXM + | OFPUTIL_P_OF13_OXM; } if (!eth_mask_is_exact(wc->masks.dl_dst) && !eth_addr_is_zero(wc->masks.dl_dst)) { - return OFPUTIL_P_OF10_NXM_ANY | OFPUTIL_P_OF12_OXM; + return OFPUTIL_P_OF10_NXM_ANY | OFPUTIL_P_OF12_OXM + | OFPUTIL_P_OF13_OXM; } /* NXM, OXM, and OF1.1+ support matching metadata. */ if (wc->masks.metadata != htonll(0)) { - return OFPUTIL_P_OF10_NXM_ANY | OFPUTIL_P_OF12_OXM; + return OFPUTIL_P_OF10_NXM_ANY | OFPUTIL_P_OF12_OXM + | OFPUTIL_P_OF13_OXM; } /* NXM and OXM support matching ARP hardware addresses. */ if (!eth_addr_is_zero(wc->masks.arp_sha) || !eth_addr_is_zero(wc->masks.arp_tha)) { - return OFPUTIL_P_OF10_NXM_ANY | OFPUTIL_P_OF12_OXM; - } - - /* NXM and OXM support matching IPv6 traffic. */ - if (match->flow.dl_type == htons(ETH_TYPE_IPV6)) { - return OFPUTIL_P_OF10_NXM_ANY | OFPUTIL_P_OF12_OXM; + return OFPUTIL_P_OF10_NXM_ANY | OFPUTIL_P_OF12_OXM + | OFPUTIL_P_OF13_OXM; + } + + /* 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; } /* NXM and OXM support matching registers. */ if (!regs_fully_wildcarded(wc)) { - return OFPUTIL_P_OF10_NXM_ANY | OFPUTIL_P_OF12_OXM; + return OFPUTIL_P_OF10_NXM_ANY | OFPUTIL_P_OF12_OXM + | OFPUTIL_P_OF13_OXM; } - /* NXM and OXM support matching tun_id. */ - if (wc->masks.tunnel.tun_id != htonll(0)) { - return OFPUTIL_P_OF10_NXM_ANY | OFPUTIL_P_OF12_OXM; + /* 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; } /* NXM and OXM support matching fragments. */ if (wc->masks.nw_frag) { - return OFPUTIL_P_OF10_NXM_ANY | OFPUTIL_P_OF12_OXM; - } - - /* NXM and OXM support matching IPv6 flow label. */ - if (wc->masks.ipv6_label) { - return OFPUTIL_P_OF10_NXM_ANY | OFPUTIL_P_OF12_OXM; + 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; + return OFPUTIL_P_OF10_NXM_ANY | OFPUTIL_P_OF12_OXM + | OFPUTIL_P_OF13_OXM; } /* NXM and OXM support matching IP TTL/hop limit. */ if (wc->masks.nw_ttl) { - return OFPUTIL_P_OF10_NXM_ANY | OFPUTIL_P_OF12_OXM; + return OFPUTIL_P_OF10_NXM_ANY | OFPUTIL_P_OF12_OXM + | OFPUTIL_P_OF13_OXM; } /* NXM and OXM support non-CIDR IPv4 address masks. */ if (!ip_is_cidr(wc->masks.nw_src) || !ip_is_cidr(wc->masks.nw_dst)) { - return OFPUTIL_P_OF10_NXM_ANY | OFPUTIL_P_OF12_OXM; + return OFPUTIL_P_OF10_NXM_ANY | OFPUTIL_P_OF12_OXM + | OFPUTIL_P_OF13_OXM; } /* NXM and OXM support bitwise matching on transport port. */ if ((wc->masks.tp_src && wc->masks.tp_src != htons(UINT16_MAX)) || (wc->masks.tp_dst && wc->masks.tp_dst != htons(UINT16_MAX))) { - return OFPUTIL_P_OF10_NXM_ANY | OFPUTIL_P_OF12_OXM; + return OFPUTIL_P_OF10_NXM_ANY | OFPUTIL_P_OF12_OXM + | OFPUTIL_P_OF13_OXM; + } + + /* NXM and OF1.1+ support matching MPLS label */ + if (wc->masks.mpls_lse & htonl(MPLS_LABEL_MASK)) { + return OFPUTIL_P_OF10_NXM_ANY | OFPUTIL_P_OF12_OXM + | OFPUTIL_P_OF13_OXM; + } + + /* NXM and OF1.1+ support matching MPLS TC */ + if (wc->masks.mpls_lse & htonl(MPLS_TC_MASK)) { + return OFPUTIL_P_OF10_NXM_ANY | OFPUTIL_P_OF12_OXM + | OFPUTIL_P_OF13_OXM; + } + + /* NXM and OF1.3+ support matching MPLS stack flag */ + /* Allow for OF1.2 as there doesn't seem to be a + * particularly good reason not to */ + if (wc->masks.mpls_lse & htonl(MPLS_BOS_MASK)) { + return OFPUTIL_P_OF10_NXM_ANY | OFPUTIL_P_OF12_OXM + | OFPUTIL_P_OF13_OXM; } /* Other formats can express this rule. */ @@ -1254,8 +1365,9 @@ ofputil_encode_set_protocol(enum ofputil_protocol current, return ofputil_encode_nx_set_flow_format(NXFF_OPENFLOW10); case OFPUTIL_P_OF12_OXM: - /* There's only one OpenFlow 1.2 protocol and we already verified - * above that we're not trying to change versions. */ + case OFPUTIL_P_OF13_OXM: + /* There are only one of each OpenFlow 1.2+ protocols and we already + * verified above that we're not trying to change versions. */ NOT_REACHED(); case OFPUTIL_P_OF10_STD_TID: @@ -1271,7 +1383,7 @@ ofputil_encode_set_protocol(enum ofputil_protocol current, return ofputil_make_flow_mod_table_id(want_tid); } - assert(current == want); + ovs_assert(current == want); *next = current; return NULL; @@ -1285,7 +1397,7 @@ ofputil_encode_nx_set_flow_format(enum nx_flow_format nxff) struct nx_set_flow_format *sff; struct ofpbuf *msg; - assert(ofputil_nx_flow_format_is_valid(nxff)); + ovs_assert(ofputil_nx_flow_format_is_valid(nxff)); msg = ofpraw_alloc(OFPRAW_NXT_SET_FLOW_FORMAT, OFP10_VERSION, 0); sff = ofpbuf_put_zeros(msg, sizeof *sff); @@ -1420,7 +1532,9 @@ ofputil_decode_flow_mod(struct ofputil_flow_mod *fm, if (error) { return error; } - if (ofm->out_group != htonl(OFPG_ANY)) { + if ((ofm->command == OFPFC_DELETE + || ofm->command == OFPFC_DELETE_STRICT) + && ofm->out_group != htonl(OFPG_ANY)) { return OFPERR_OFPFMFC_UNKNOWN; } fm->flags = ntohs(ofm->flags); @@ -1457,7 +1571,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. */ @@ -1488,12 +1602,24 @@ 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(); } + if (fm->flags & OFPFF10_EMERG) { + /* We do not support the OpenFlow 1.0 emergency flow cache, which + * is not required in OpenFlow 1.0.1 and removed from OpenFlow 1.1. + * + * OpenFlow 1.0 specifies the error code to use when idle_timeout + * or hard_timeout is nonzero. Otherwise, there is no good error + * code, so just state that the flow table is full. */ + return (fm->hard_timeout || fm->idle_timeout + ? OFPERR_OFPFMFC_BAD_EMERG_TIMEOUT + : OFPERR_OFPFMFC_TABLE_FULL); + } + if (protocol & OFPUTIL_P_TID) { fm->command = command & 0xff; fm->table_id = command >> 8; @@ -1509,6 +1635,370 @@ 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 = (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) @@ -1527,10 +2017,12 @@ ofputil_encode_flow_mod(const struct ofputil_flow_mod *fm, struct ofpbuf *msg; switch (protocol) { - case OFPUTIL_P_OF12_OXM: { + case OFPUTIL_P_OF12_OXM: + case OFPUTIL_P_OF13_OXM: { struct ofp11_flow_mod *ofm; - msg = ofpraw_alloc(OFPRAW_OFPT11_FLOW_MOD, OFP12_VERSION, + msg = ofpraw_alloc(OFPRAW_OFPT11_FLOW_MOD, + ofputil_protocol_to_ofp_version(protocol), NXM_TYPICAL_LEN + fm->ofpacts_len); ofm = ofpbuf_put_zeros(msg, sizeof *ofm); if (fm->command == OFPFC_ADD) { @@ -1567,7 +2059,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; @@ -1589,7 +2081,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); @@ -1627,10 +2119,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; + usable_protocols &= OFPUTIL_P_OF10_NXM_ANY | OFPUTIL_P_OF12_OXM + | OFPUTIL_P_OF13_OXM; } } - assert(usable_protocols); return usable_protocols; } @@ -1642,7 +2134,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); @@ -1694,7 +2186,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; @@ -1748,13 +2240,15 @@ ofputil_encode_flow_stats_request(const struct ofputil_flow_stats_request *fsr, enum ofpraw raw; switch (protocol) { - case OFPUTIL_P_OF12_OXM: { + case OFPUTIL_P_OF12_OXM: + case OFPUTIL_P_OF13_OXM: { struct ofp11_flow_stats_request *ofsr; raw = (fsr->aggregate ? OFPRAW_OFPST11_AGGREGATE_REQUEST : OFPRAW_OFPST11_FLOW_REQUEST); - msg = ofpraw_alloc(raw, OFP12_VERSION, NXM_TYPICAL_LEN); + msg = ofpraw_alloc(raw, ofputil_protocol_to_ofp_version(protocol), + NXM_TYPICAL_LEN); ofsr = ofpbuf_put_zeros(msg, sizeof *ofsr); ofsr->table_id = fsr->table_id; ofsr->out_port = ofputil_port_to_ofp11(fsr->out_port); @@ -1776,7 +2270,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; } @@ -1794,7 +2288,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; @@ -1819,7 +2313,8 @@ ofputil_flow_stats_request_usable_protocols( usable_protocols = ofputil_usable_protocols(&fsr->match); if (fsr->cookie_mask != htonll(0)) { - usable_protocols &= OFPUTIL_P_OF10_NXM_ANY | OFPUTIL_P_OF12_OXM; + usable_protocols &= OFPUTIL_P_OF10_NXM_ANY | OFPUTIL_P_OF12_OXM + | OFPUTIL_P_OF13_OXM; } return usable_protocols; } @@ -1862,7 +2357,8 @@ ofputil_decode_flow_stats_reply(struct ofputil_flow_stats *fs, if (!msg->size) { return EOF; - } else if (raw == OFPRAW_OFPST11_FLOW_REPLY) { + } else if (raw == OFPRAW_OFPST11_FLOW_REPLY + || raw == OFPRAW_OFPST13_FLOW_REPLY) { const struct ofp11_flow_stats *ofs; size_t length; uint16_t padded_match_len; @@ -1898,6 +2394,7 @@ ofputil_decode_flow_stats_reply(struct ofputil_flow_stats *fs, fs->duration_nsec = ntohl(ofs->duration_nsec); fs->idle_timeout = ntohs(ofs->idle_timeout); fs->hard_timeout = ntohs(ofs->hard_timeout); + fs->flags = (raw == OFPRAW_OFPST13_FLOW_REPLY) ? ntohs(ofs->flags) : 0; fs->idle_age = -1; fs->hard_age = -1; fs->cookie = ofs->cookie; @@ -1937,6 +2434,7 @@ ofputil_decode_flow_stats_reply(struct ofputil_flow_stats *fs, fs->hard_age = -1; fs->packet_count = ntohll(get_32aligned_be64(&ofs->packet_count)); fs->byte_count = ntohll(get_32aligned_be64(&ofs->byte_count)); + fs->flags = 0; } else if (raw == OFPRAW_NXST_FLOW_REPLY) { const struct nx_flow_stats *nfs; size_t match_len, actions_len, length; @@ -1983,6 +2481,7 @@ ofputil_decode_flow_stats_reply(struct ofputil_flow_stats *fs, } fs->packet_count = ntohll(nfs->packet_count); fs->byte_count = ntohll(nfs->byte_count); + fs->flags = 0; } else { NOT_REACHED(); } @@ -2015,7 +2514,7 @@ ofputil_append_flow_stats_reply(const struct ofputil_flow_stats *fs, enum ofpraw raw; ofpraw_decode_partial(&raw, reply->data, reply->size); - if (raw == OFPRAW_OFPST11_FLOW_REPLY) { + if (raw == OFPRAW_OFPST11_FLOW_REPLY || raw == OFPRAW_OFPST13_FLOW_REPLY) { struct ofp11_flow_stats *ofs; ofpbuf_put_uninit(reply, sizeof *ofs); @@ -2032,6 +2531,7 @@ ofputil_append_flow_stats_reply(const struct ofputil_flow_stats *fs, ofs->priority = htons(fs->priority); ofs->idle_timeout = htons(fs->idle_timeout); ofs->hard_timeout = htons(fs->hard_timeout); + ofs->flags = (raw == OFPRAW_OFPST13_FLOW_REPLY) ? htons(fs->flags) : 0; memset(ofs->pad2, 0, sizeof ofs->pad2); ofs->cookie = fs->cookie; ofs->packet_count = htonll(unknown_to_zero(fs->packet_count)); @@ -2175,7 +2675,7 @@ ofputil_decode_flow_removed(struct ofputil_flow_removed *fr, fr->packet_count = ntohll(ofr->packet_count); fr->byte_count = ntohll(ofr->byte_count); } else if (raw == OFPRAW_OFPT10_FLOW_REMOVED) { - const struct ofp_flow_removed *ofr; + const struct ofp10_flow_removed *ofr; ofr = ofpbuf_pull(&b, sizeof *ofr); @@ -2207,7 +2707,7 @@ ofputil_decode_flow_removed(struct ofputil_flow_removed *fr, fr->priority = ntohs(nfr->priority); fr->cookie = nfr->cookie; fr->reason = nfr->reason; - fr->table_id = 255; + fr->table_id = nfr->table_id ? nfr->table_id - 1 : 255; fr->duration_sec = ntohl(nfr->duration_sec); fr->duration_nsec = ntohl(nfr->duration_nsec); fr->idle_timeout = ntohs(nfr->idle_timeout); @@ -2231,7 +2731,8 @@ ofputil_encode_flow_removed(const struct ofputil_flow_removed *fr, struct ofpbuf *msg; switch (protocol) { - case OFPUTIL_P_OF12_OXM: { + case OFPUTIL_P_OF12_OXM: + case OFPUTIL_P_OF13_OXM: { struct ofp12_flow_removed *ofr; msg = ofpraw_alloc_xid(OFPRAW_OFPT11_FLOW_REMOVED, @@ -2254,7 +2755,7 @@ ofputil_encode_flow_removed(const struct ofputil_flow_removed *fr, case OFPUTIL_P_OF10_STD: case OFPUTIL_P_OF10_STD_TID: { - struct ofp_flow_removed *ofr; + struct ofp10_flow_removed *ofr; msg = ofpraw_alloc_xid(OFPRAW_OFPT10_FLOW_REMOVED, OFP10_VERSION, htonl(0), 0); @@ -2285,6 +2786,7 @@ ofputil_encode_flow_removed(const struct ofputil_flow_removed *fr, nfr->cookie = fr->cookie; nfr->priority = htons(fr->priority); nfr->reason = fr->reason; + nfr->table_id = fr->table_id + 1; nfr->duration_sec = htonl(fr->duration_sec); nfr->duration_nsec = htonl(fr->duration_nsec); nfr->idle_timeout = htons(fr->idle_timeout); @@ -2308,8 +2810,10 @@ 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); } @@ -2325,12 +2829,19 @@ ofputil_decode_packet_in(struct ofputil_packet_in *pin, ofpbuf_use_const(&b, oh, ntohs(oh->length)); raw = ofpraw_pull_assert(&b); - if (raw == OFPRAW_OFPT12_PACKET_IN) { - const struct ofp12_packet_in *opi; + if (raw == OFPRAW_OFPT13_PACKET_IN || raw == OFPRAW_OFPT12_PACKET_IN) { + const struct ofp13_packet_in *opi; struct match match; int error; + size_t packet_in_size; + + if (raw == OFPRAW_OFPT12_PACKET_IN) { + packet_in_size = sizeof (struct ofp12_packet_in); + } else { + packet_in_size = sizeof (struct ofp13_packet_in); + } - opi = ofpbuf_pull(&b, sizeof *opi); + opi = ofpbuf_pull(&b, packet_in_size); error = oxm_pull_match_loose(&b, &match); if (error) { return error; @@ -2340,22 +2851,25 @@ ofputil_decode_packet_in(struct ofputil_packet_in *pin, return OFPERR_OFPBRC_BAD_LEN; } - pin->reason = opi->reason; - pin->table_id = opi->table_id; + pin->reason = opi->pi.reason; + pin->table_id = opi->pi.table_id; + pin->buffer_id = ntohl(opi->pi.buffer_id); + pin->total_len = ntohs(opi->pi.total_len); - pin->buffer_id = ntohl(opi->buffer_id); - pin->total_len = ntohs(opi->total_len); + if (raw == OFPRAW_OFPT13_PACKET_IN) { + pin->cookie = opi->cookie; + } ofputil_decode_packet_in_finish(pin, &match, &b); } else if (raw == OFPRAW_OFPT10_PACKET_IN) { - const struct ofp_packet_in *opi; + const struct ofp10_packet_in *opi; - opi = ofpbuf_pull(&b, offsetof(struct ofp_packet_in, data)); + opi = ofpbuf_pull(&b, offsetof(struct ofp10_packet_in, data)); 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); @@ -2400,6 +2914,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); } @@ -2424,34 +2944,50 @@ ofputil_encode_packet_in(const struct ofputil_packet_in *pin, struct ofpbuf *packet; /* Add OFPT_PACKET_IN. */ - if (protocol == OFPUTIL_P_OF12_OXM) { - struct ofp12_packet_in *opi; + if (protocol == OFPUTIL_P_OF13_OXM || protocol == OFPUTIL_P_OF12_OXM) { + struct ofp13_packet_in *opi; struct match match; + enum ofpraw packet_in_raw; + enum ofp_version packet_in_version; + size_t packet_in_size; + + if (protocol == OFPUTIL_P_OF12_OXM) { + packet_in_raw = OFPRAW_OFPT12_PACKET_IN; + packet_in_version = OFP12_VERSION; + packet_in_size = sizeof (struct ofp12_packet_in); + } else { + packet_in_raw = OFPRAW_OFPT13_PACKET_IN; + packet_in_version = OFP13_VERSION; + packet_in_size = sizeof (struct ofp13_packet_in); + } ofputil_packet_in_to_match(pin, &match); /* The final argument is just an estimate of the space required. */ - packet = ofpraw_alloc_xid(OFPRAW_OFPT12_PACKET_IN, OFP12_VERSION, + packet = ofpraw_alloc_xid(packet_in_raw, packet_in_version, htonl(0), (sizeof(struct flow_metadata) * 2 + 2 + send_len)); - ofpbuf_put_zeros(packet, sizeof *opi); + ofpbuf_put_zeros(packet, packet_in_size); oxm_put_match(packet, &match); ofpbuf_put_zeros(packet, 2); ofpbuf_put(packet, pin->packet, send_len); opi = packet->l3; - opi->buffer_id = htonl(pin->buffer_id); - opi->total_len = htons(pin->total_len); - opi->reason = pin->reason; - opi->table_id = pin->table_id; - } else if (packet_in_format == NXPIF_OPENFLOW10) { - struct ofp_packet_in *opi; + opi->pi.buffer_id = htonl(pin->buffer_id); + opi->pi.total_len = htons(pin->total_len); + opi->pi.reason = pin->reason; + opi->pi.table_id = pin->table_id; + if (protocol == OFPUTIL_P_OF13_OXM) { + opi->cookie = pin->cookie; + } + } else if (packet_in_format == NXPIF_OPENFLOW10) { + struct ofp10_packet_in *opi; packet = ofpraw_alloc_xid(OFPRAW_OFPT10_PACKET_IN, OFP10_VERSION, htonl(0), send_len); - opi = ofpbuf_put_zeros(packet, offsetof(struct ofp_packet_in, data)); + 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); @@ -2487,11 +3023,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"; @@ -2502,8 +3040,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; } } @@ -2514,7 +3052,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; } @@ -2558,10 +3101,10 @@ ofputil_decode_packet_out(struct ofputil_packet_out *po, } } else if (raw == OFPRAW_OFPT10_PACKET_OUT) { enum ofperr error; - const struct ofp_packet_out *opo = ofpbuf_pull(&b, sizeof *opo); + 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) { @@ -2571,7 +3114,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); @@ -2658,7 +3202,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); @@ -2713,6 +3257,7 @@ ofputil_get_phy_port_size(enum ofp_version ofp_version) return sizeof(struct ofp10_phy_port); case OFP11_VERSION: case OFP12_VERSION: + case OFP13_VERSION: return sizeof(struct ofp11_port); default: NOT_REACHED(); @@ -2725,7 +3270,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); @@ -2775,7 +3320,8 @@ ofputil_put_phy_port(enum ofp_version ofp_version, } case OFP11_VERSION: - case OFP12_VERSION: { + case OFP12_VERSION: + case OFP13_VERSION: { struct ofp11_port *op; if (b->size + sizeof *op <= UINT16_MAX) { op = ofpbuf_put_uninit(b, sizeof *op); @@ -2804,7 +3350,8 @@ ofputil_append_port_desc_stats_reply(enum ofp_version ofp_version, } case OFP11_VERSION: - case OFP12_VERSION: { + case OFP12_VERSION: + case OFP13_VERSION: { struct ofp11_port *op; op = ofpmp_append(replies, sizeof *op); @@ -2873,6 +3420,7 @@ ofputil_capabilities_mask(enum ofp_version ofp_version) case OFP11_VERSION: return OFPC_COMMON | OFPC_ARP_MATCH_IP; case OFP12_VERSION: + case OFP13_VERSION: return OFPC_COMMON | OFPC12_PORT_BLOCKED; default: /* Caller needs to check osf->header.version itself */ @@ -2900,6 +3448,7 @@ ofputil_decode_switch_features(const struct ofp_header *oh, features->datapath_id = ntohll(osf->datapath_id); features->n_buffers = ntohl(osf->n_buffers); features->n_tables = osf->n_tables; + features->auxiliary_id = 0; features->capabilities = ntohl(osf->capabilities) & ofputil_capabilities_mask(oh->version); @@ -2913,11 +3462,15 @@ ofputil_decode_switch_features(const struct ofp_header *oh, features->capabilities |= OFPUTIL_C_STP; } features->actions = decode_action_bits(osf->actions, of10_action_bits); - } else if (raw == OFPRAW_OFPT11_FEATURES_REPLY) { + } else if (raw == OFPRAW_OFPT11_FEATURES_REPLY + || raw == OFPRAW_OFPT13_FEATURES_REPLY) { if (osf->capabilities & htonl(OFPC11_GROUP_STATS)) { features->capabilities |= OFPUTIL_C_GROUP_STATS; } features->actions = 0; + if (raw == OFPRAW_OFPT13_FEATURES_REPLY) { + features->auxiliary_id = osf->auxiliary_id; + } } else { return OFPERR_OFPBRC_BAD_VERSION; } @@ -2994,6 +3547,9 @@ ofputil_encode_switch_features(const struct ofputil_switch_features *features, case OFP12_VERSION: raw = OFPRAW_OFPT11_FEATURES_REPLY; break; + case OFP13_VERSION: + raw = OFPRAW_OFPT13_FEATURES_REPLY; + break; default: NOT_REACHED(); } @@ -3013,6 +3569,9 @@ ofputil_encode_switch_features(const struct ofputil_switch_features *features, } osf->actions = encode_action_bits(features->actions, of10_action_bits); break; + case OFP13_VERSION: + osf->auxiliary_id = features->auxiliary_id; + /* fall through */ case OFP11_VERSION: case OFP12_VERSION: if (features->capabilities & OFPUTIL_C_GROUP_STATS) { @@ -3035,7 +3594,9 @@ ofputil_put_switch_features_port(const struct ofputil_phy_port *pp, { const struct ofp_header *oh = b->data; - ofputil_put_phy_port(oh->version, pp, b); + if (oh->version < OFP13_VERSION) { + ofputil_put_phy_port(oh->version, pp, b); + } } /* ofputil_port_status */ @@ -3062,7 +3623,7 @@ ofputil_decode_port_status(const struct ofp_header *oh, ps->reason = ops->reason; retval = ofputil_pull_phy_port(oh->version, &b, &ps->desc); - assert(retval != EOF); + ovs_assert(retval != EOF); return retval; } @@ -3086,6 +3647,7 @@ ofputil_encode_port_status(const struct ofputil_port_status *ps, case OFP11_VERSION: case OFP12_VERSION: + case OFP13_VERSION: raw = OFPRAW_OFPT11_PORT_STATUS; break; @@ -3118,7 +3680,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; @@ -3160,7 +3722,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); @@ -3169,7 +3731,8 @@ ofputil_encode_port_mod(const struct ofputil_port_mod *pm, } case OFP11_VERSION: - case OFP12_VERSION: { + case OFP12_VERSION: + case OFP13_VERSION: { struct ofp11_port_mod *opm; b = ofpraw_alloc(OFPRAW_OFPT11_PORT_MOD, ofp_version, 0); @@ -3189,6 +3752,103 @@ ofputil_encode_port_mod(const struct ofputil_port_mod *pm, return b; } +/* ofputil_role_request */ + +/* Decodes the OpenFlow "role request" or "role reply" message in '*oh' into + * an abstract form in '*rr'. Returns 0 if successful, otherwise an + * OFPERR_* value. */ +enum ofperr +ofputil_decode_role_message(const struct ofp_header *oh, + struct ofputil_role_request *rr) +{ + struct ofpbuf b; + enum ofpraw raw; + + ofpbuf_use_const(&b, oh, ntohs(oh->length)); + raw = ofpraw_pull_assert(&b); + + if (raw == OFPRAW_OFPT12_ROLE_REQUEST || + raw == OFPRAW_OFPT12_ROLE_REPLY) { + const struct ofp12_role_request *orr = b.l3; + + if (orr->role != htonl(OFPCR12_ROLE_NOCHANGE) && + orr->role != htonl(OFPCR12_ROLE_EQUAL) && + orr->role != htonl(OFPCR12_ROLE_MASTER) && + orr->role != htonl(OFPCR12_ROLE_SLAVE)) { + return OFPERR_OFPRRFC_BAD_ROLE; + } + + rr->role = ntohl(orr->role); + if (raw == OFPRAW_OFPT12_ROLE_REQUEST + ? orr->role == htonl(OFPCR12_ROLE_NOCHANGE) + : orr->generation_id == htonll(UINT64_MAX)) { + rr->have_generation_id = false; + rr->generation_id = 0; + } else { + rr->have_generation_id = true; + rr->generation_id = ntohll(orr->generation_id); + } + } else if (raw == OFPRAW_NXT_ROLE_REQUEST || + raw == OFPRAW_NXT_ROLE_REPLY) { + const struct nx_role_request *nrr = b.l3; + + BUILD_ASSERT(NX_ROLE_OTHER + 1 == OFPCR12_ROLE_EQUAL); + BUILD_ASSERT(NX_ROLE_MASTER + 1 == OFPCR12_ROLE_MASTER); + BUILD_ASSERT(NX_ROLE_SLAVE + 1 == OFPCR12_ROLE_SLAVE); + + if (nrr->role != htonl(NX_ROLE_OTHER) && + nrr->role != htonl(NX_ROLE_MASTER) && + nrr->role != htonl(NX_ROLE_SLAVE)) { + return OFPERR_OFPRRFC_BAD_ROLE; + } + + rr->role = ntohl(nrr->role) + 1; + rr->have_generation_id = false; + rr->generation_id = 0; + } else { + NOT_REACHED(); + } + + return 0; +} + +/* Returns an encoded form of a role reply suitable for the "request" in a + * buffer owned by the caller. */ +struct ofpbuf * +ofputil_encode_role_reply(const struct ofp_header *request, + const struct ofputil_role_request *rr) +{ + struct ofpbuf *buf; + enum ofpraw raw; + + raw = ofpraw_decode_assert(request); + if (raw == OFPRAW_OFPT12_ROLE_REQUEST) { + struct ofp12_role_request *orr; + + buf = ofpraw_alloc_reply(OFPRAW_OFPT12_ROLE_REPLY, request, 0); + orr = ofpbuf_put_zeros(buf, sizeof *orr); + + orr->role = htonl(rr->role); + orr->generation_id = htonll(rr->have_generation_id + ? rr->generation_id + : UINT64_MAX); + } else if (raw == OFPRAW_NXT_ROLE_REQUEST) { + struct nx_role_request *nrr; + + BUILD_ASSERT(NX_ROLE_OTHER == OFPCR12_ROLE_EQUAL - 1); + BUILD_ASSERT(NX_ROLE_MASTER == OFPCR12_ROLE_MASTER - 1); + BUILD_ASSERT(NX_ROLE_SLAVE == OFPCR12_ROLE_SLAVE - 1); + + buf = ofpraw_alloc_reply(OFPRAW_NXT_ROLE_REPLY, request, 0); + nrr = ofpbuf_put_zeros(buf, sizeof *nrr); + nrr->role = htonl(rr->role - 1); + } else { + NOT_REACHED(); + } + + return buf; +} + /* Table stats. */ static void @@ -3196,7 +3856,7 @@ ofputil_put_ofp10_table_stats(const struct ofp12_table_stats *in, struct ofpbuf *buf) { struct wc_map { - enum ofp_flow_wildcards wc10; + enum ofp10_flow_wildcards wc10; enum oxm12_ofb_match_fields mf12; }; @@ -3218,9 +3878,9 @@ ofputil_put_ofp10_table_stats(const struct ofp12_table_stats *in, struct ofp10_table_stats *out; const struct wc_map *p; - out = ofpbuf_put_uninit(buf, sizeof *out); + out = ofpbuf_put_zeros(buf, sizeof *out); out->table_id = in->table_id; - strcpy(out->name, in->name); + ovs_strlcpy(out->name, in->name, sizeof out->name); out->wildcards = 0; for (p = wc_map; p < &wc_map[ARRAY_SIZE(wc_map)]; p++) { if (in->wildcards & htonll(1ULL << p->mf12)) { @@ -3278,9 +3938,9 @@ ofputil_put_ofp11_table_stats(const struct ofp12_table_stats *in, { struct ofp11_table_stats *out; - out = ofpbuf_put_uninit(buf, sizeof *out); + out = ofpbuf_put_zeros(buf, sizeof *out); out->table_id = in->table_id; - strcpy(out->name, in->name); + ovs_strlcpy(out->name, in->name, sizeof out->name); out->wildcards = oxm12_to_ofp11_flow_match_fields(in->wildcards); out->match = oxm12_to_ofp11_flow_match_fields(in->match); out->instructions = in->instructions; @@ -3293,6 +3953,22 @@ ofputil_put_ofp11_table_stats(const struct ofp12_table_stats *in, out->matched_count = in->matched_count; } +static void +ofputil_put_ofp13_table_stats(const struct ofp12_table_stats *in, + struct ofpbuf *buf) +{ + struct ofp13_table_stats *out; + + /* OF 1.3 splits table features off the ofp_table_stats, + * so there is not much here. */ + + out = ofpbuf_put_uninit(buf, sizeof *out); + out->table_id = in->table_id; + out->active_count = in->active_count; + out->lookup_count = in->lookup_count; + out->matched_count = in->matched_count; +} + struct ofpbuf * ofputil_encode_table_stats_reply(const struct ofp12_table_stats stats[], int n, const struct ofp_header *request) @@ -3319,6 +3995,12 @@ ofputil_encode_table_stats_reply(const struct ofp12_table_stats stats[], int n, ofpbuf_put(reply, stats, n * sizeof *stats); break; + case OFP13_VERSION: + for (i = 0; i < n; i++) { + ofputil_put_ofp13_table_stats(&stats[i], reply); + } + break; + default: NOT_REACHED(); } @@ -3376,7 +4058,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); @@ -3401,7 +4083,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; } @@ -3502,7 +4184,7 @@ ofputil_decode_flow_update(struct ofputil_flow_update *update, VLOG_WARN_RL(&bad_ofmsg_rl, "NXST_FLOW_MONITOR reply has bad event %"PRIu16, ntohs(nfuh->event)); - return OFPERR_OFPET_BAD_REQUEST; + return OFPERR_NXBRC_FM_BAD_EVENT; } bad_len: @@ -3599,7 +4281,7 @@ ofputil_encode_packet_out(const struct ofputil_packet_out *po, switch (ofp_version) { case OFP10_VERSION: { - struct ofp_packet_out *opo; + struct ofp10_packet_out *opo; size_t actions_ofs; msg = ofpraw_alloc(OFPRAW_OFPT10_PACKET_OUT, OFP10_VERSION, size); @@ -3609,13 +4291,14 @@ 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; } case OFP11_VERSION: - case OFP12_VERSION: { + case OFP12_VERSION: + case OFP13_VERSION: { struct ofp11_packet_out *opo; size_t len; @@ -3673,6 +4356,7 @@ ofputil_encode_barrier_request(enum ofp_version ofp_version) enum ofpraw type; switch (ofp_version) { + case OFP13_VERSION: case OFP12_VERSION: case OFP11_VERSION: type = OFPRAW_OFPT11_BARRIER_REQUEST; @@ -3722,25 +4406,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; } } @@ -3750,18 +4435,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: @@ -3775,7 +4460,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; @@ -3790,6 +4475,11 @@ ofputil_check_output_port(uint16_t port, int max_ports) OFPUTIL_NAMED_PORT(ALL) \ OFPUTIL_NAMED_PORT(CONTROLLER) \ OFPUTIL_NAMED_PORT(LOCAL) \ + OFPUTIL_NAMED_PORT(ANY) + +/* For backwards compatibility, so that "none" is recognized as OFPP_ANY */ +#define OFPUTIL_NAMED_PORTS_WITH_NONE \ + OFPUTIL_NAMED_PORTS \ OFPUTIL_NAMED_PORT(NONE) /* Stores the port number represented by 's' into '*portp'. 's' may be an @@ -3806,50 +4496,44 @@ 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 s; - - ds_init(&s); - ofputil_format_port(port32, &s); - VLOG_WARN_ONCE("referring to port %s as %u is deprecated for " - "compatibility with future versions of OpenFlow", - ds_cstr(&s), port32); - ds_destroy(&s); - - *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); + "%"PRIx16" or 0x%x through 0x%"PRIx32, port32, + 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}, - OFPUTIL_NAMED_PORTS + OFPUTIL_NAMED_PORTS_WITH_NONE #undef OFPUTIL_NAMED_PORT }; const struct pair *p; @@ -3868,20 +4552,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 @@ -3899,7 +4597,8 @@ ofputil_pull_phy_port(enum ofp_version ofp_version, struct ofpbuf *b, return opp ? ofputil_decode_ofp10_phy_port(pp, opp) : EOF; } case OFP11_VERSION: - case OFP12_VERSION: { + case OFP12_VERSION: + case OFP13_VERSION: { const struct ofp11_port *op = ofpbuf_try_pull(b, sizeof *op); return op ? ofputil_decode_ofp11_port(pp, op) : EOF; } @@ -3923,7 +4622,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, @@ -3931,7 +4630,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)) { @@ -4013,7 +4712,8 @@ ofputil_normalize_match__(struct match *match, bool may_log) MAY_ARP_SHA = 1 << 4, /* arp_sha */ MAY_ARP_THA = 1 << 5, /* arp_tha */ MAY_IPV6 = 1 << 6, /* ipv6_src, ipv6_dst, ipv6_label */ - MAY_ND_TARGET = 1 << 7 /* nd_target */ + MAY_ND_TARGET = 1 << 7, /* nd_target */ + MAY_MPLS = 1 << 8, /* mpls label and tc */ } may_match; struct flow_wildcards wc; @@ -4042,6 +4742,8 @@ ofputil_normalize_match__(struct match *match, bool may_log) } else if (match->flow.dl_type == htons(ETH_TYPE_ARP) || match->flow.dl_type == htons(ETH_TYPE_RARP)) { may_match = MAY_NW_PROTO | MAY_NW_ADDR | MAY_ARP_SHA | MAY_ARP_THA; + } else if (eth_type_mpls(match->flow.dl_type)) { + may_match = MAY_MPLS; } else { may_match = 0; } @@ -4074,6 +4776,10 @@ ofputil_normalize_match__(struct match *match, bool may_log) if (!(may_match & MAY_ND_TARGET)) { wc.masks.nd_target = in6addr_any; } + if (!(may_match & MAY_MPLS)) { + wc.masks.mpls_lse = htonl(0); + wc.masks.mpls_depth = 0; + } /* Log any changes. */ if (!flow_wildcards_equal(&wc, &match->wc)) { @@ -4198,10 +4904,10 @@ ofputil_parse_key_value(char **stringp, char **keyp, char **valuep) } /* Encode a dump ports request for 'port', the encoded message - * will be fore Open Flow version 'ofp_version'. Returns message + * 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; @@ -4210,11 +4916,12 @@ 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: - case OFP12_VERSION: { + case OFP12_VERSION: + case OFP13_VERSION: { struct ofp11_port_stats_request *req; request = ofpraw_alloc(OFPRAW_OFPST11_PORT_REQUEST, ofp_version, 0); req = ofpbuf_put_zeros(request, sizeof *req); @@ -4232,7 +4939,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)); @@ -4268,6 +4975,16 @@ ofputil_port_stats_to_ofp11(const struct ofputil_port_stats *ops, ps11->collisions = htonll(ops->stats.collisions); } +static void +ofputil_port_stats_to_ofp13(const struct ofputil_port_stats *ops, + struct ofp13_port_stats *ps13) +{ + ofputil_port_stats_to_ofp11(ops, &ps13->ps); + ps13->duration_sec = htonl(ops->duration_sec); + ps13->duration_nsec = htonl(ops->duration_nsec); +} + + /* Encode a ports stat for 'ops' and append it to 'replies'. */ void ofputil_append_port_stat(struct list *replies, @@ -4277,6 +4994,11 @@ ofputil_append_port_stat(struct list *replies, struct ofp_header *oh = msg->data; switch ((enum ofp_version)oh->version) { + case OFP13_VERSION: { + struct ofp13_port_stats *reply = ofpmp_append(replies, sizeof *reply); + ofputil_port_stats_to_ofp13(ops, reply); + break; + } case OFP12_VERSION: case OFP11_VERSION: { struct ofp11_port_stats *reply = ofpmp_append(replies, sizeof *reply); @@ -4301,7 +5023,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)); @@ -4315,6 +5037,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; } @@ -4343,10 +5066,24 @@ 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; } +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); + if (!error) { + ops->duration_sec = ntohl(ps13->duration_sec); + ops->duration_nsec = ntohl(ps13->duration_nsec); + } + return error; +} + + /* Returns the number of port stats elements in OFPTYPE_PORT_STATS_REPLY * message 'oh'. */ size_t @@ -4387,14 +5124,20 @@ ofputil_decode_port_stats(struct ofputil_port_stats *ps, struct ofpbuf *msg) if (!msg->size) { return EOF; + } else if (raw == OFPRAW_OFPST13_PORT_REPLY) { + const struct ofp13_port_stats *ps13; + + ps13 = ofpbuf_try_pull(msg, sizeof *ps13); + if (!ps13) { + goto bad_len; + } + return ofputil_port_stats_from_ofp13(ps, ps13); } else if (raw == OFPRAW_OFPST11_PORT_REPLY) { const struct ofp11_port_stats *ps11; ps11 = ofpbuf_try_pull(msg, sizeof *ps11); if (!ps11) { - VLOG_WARN_RL(&bad_ofmsg_rl, "OFPST_PORT reply has %zu leftover " - "bytes at end", msg->size); - return OFPERR_OFPBRC_BAD_LEN; + goto bad_len; } return ofputil_port_stats_from_ofp11(ps, ps11); } else if (raw == OFPRAW_OFPST10_PORT_REPLY) { @@ -4402,15 +5145,17 @@ ofputil_decode_port_stats(struct ofputil_port_stats *ps, struct ofpbuf *msg) ps10 = ofpbuf_try_pull(msg, sizeof *ps10); if (!ps10) { - VLOG_WARN_RL(&bad_ofmsg_rl, "OFPST_PORT reply has %zu leftover " - "bytes at end", msg->size); - return OFPERR_OFPBRC_BAD_LEN; + goto bad_len; } return ofputil_port_stats_from_ofp10(ps, ps10); } else { NOT_REACHED(); } + bad_len: + VLOG_WARN_RL(&bad_ofmsg_rl, "OFPST_PORT reply has %zu leftover " + "bytes at end", msg->size); + return OFPERR_OFPBRC_BAD_LEN; } /* Parse a port status request message into a 16 bit OpenFlow 1.0 @@ -4418,9 +5163,10 @@ 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: case OFP12_VERSION: case OFP11_VERSION: { const struct ofp11_port_stats_request *psr11 = ofpmsg_body(request); @@ -4429,7 +5175,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; } @@ -4445,6 +5191,7 @@ ofputil_decode_queue_stats_request(const struct ofp_header *request, struct ofputil_queue_stats_request *oqsr) { switch ((enum ofp_version)request->version) { + case OFP13_VERSION: case OFP12_VERSION: case OFP11_VERSION: { const struct ofp11_queue_stats_request *qsr11 = ofpmsg_body(request); @@ -4453,9 +5200,13 @@ ofputil_decode_queue_stats_request(const struct ofp_header *request, } case OFP10_VERSION: { - const struct ofp10_queue_stats_request *qsr11 = ofpmsg_body(request); - oqsr->queue_id = ntohl(qsr11->queue_id); - oqsr->port_no = ntohs(qsr11->port_no); + const struct ofp10_queue_stats_request *qsr10 = ofpmsg_body(request); + oqsr->queue_id = ntohl(qsr10->queue_id); + 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; + } return 0; } @@ -4475,7 +5226,8 @@ ofputil_encode_queue_stats_request(enum ofp_version ofp_version, switch (ofp_version) { case OFP11_VERSION: - case OFP12_VERSION: { + case OFP12_VERSION: + case OFP13_VERSION: { struct ofp11_queue_stats_request *req; request = ofpraw_alloc(OFPRAW_OFPST11_QUEUE_REQUEST, ofp_version, 0); req = ofpbuf_put_zeros(request, sizeof *req); @@ -4487,7 +5239,9 @@ ofputil_encode_queue_stats_request(enum ofp_version ofp_version, struct ofp10_queue_stats_request *req; request = ofpraw_alloc(OFPRAW_OFPST10_QUEUE_REQUEST, ofp_version, 0); req = ofpbuf_put_zeros(request, sizeof *req); - req->port_no = htons(oqsr->port_no); + /* OpenFlow 1.0 needs OFPP_ALL instead of OFPP_ANY */ + 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; } @@ -4517,7 +5271,7 @@ 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)); @@ -4545,6 +5299,20 @@ ofputil_queue_stats_from_ofp11(struct ofputil_queue_stats *oqs, return 0; } +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); + if (!error) { + /* FIXME: Get qs13->duration_sec and qs13->duration_nsec, + * Add to netdev_queue_stats? */ + } + + return error; +} + /* Converts an OFPST_QUEUE_STATS reply in 'msg' into an abstract * ofputil_queue_stats in 'qs'. * @@ -4570,14 +5338,20 @@ ofputil_decode_queue_stats(struct ofputil_queue_stats *qs, struct ofpbuf *msg) if (!msg->size) { return EOF; + } else if (raw == OFPRAW_OFPST13_QUEUE_REPLY) { + const struct ofp13_queue_stats *qs13; + + qs13 = ofpbuf_try_pull(msg, sizeof *qs13); + if (!qs13) { + goto bad_len; + } + return ofputil_queue_stats_from_ofp13(qs, qs13); } else if (raw == OFPRAW_OFPST11_QUEUE_REPLY) { const struct ofp11_queue_stats *qs11; qs11 = ofpbuf_try_pull(msg, sizeof *qs11); if (!qs11) { - VLOG_WARN_RL(&bad_ofmsg_rl, "OFPST_QUEUE reply has %zu leftover " - "bytes at end", msg->size); - return OFPERR_OFPBRC_BAD_LEN; + goto bad_len; } return ofputil_queue_stats_from_ofp11(qs, qs11); } else if (raw == OFPRAW_OFPST10_QUEUE_REPLY) { @@ -4585,21 +5359,24 @@ ofputil_decode_queue_stats(struct ofputil_queue_stats *qs, struct ofpbuf *msg) qs10 = ofpbuf_try_pull(msg, sizeof *qs10); if (!qs10) { - VLOG_WARN_RL(&bad_ofmsg_rl, "OFPST_QUEUE reply has %zu leftover " - "bytes at end", msg->size); - return OFPERR_OFPBRC_BAD_LEN; + goto bad_len; } return ofputil_queue_stats_from_ofp10(qs, qs10); } else { NOT_REACHED(); } + + bad_len: + VLOG_WARN_RL(&bad_ofmsg_rl, "OFPST_QUEUE reply has %zu leftover " + "bytes at end", msg->size); + return OFPERR_OFPBRC_BAD_LEN; } 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)); @@ -4618,6 +5395,17 @@ ofputil_queue_stats_to_ofp11(const struct ofputil_queue_stats *oqs, qs11->tx_errors = htonll(oqs->stats.tx_errors); } +static void +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); +} + /* Encode a queue stat for 'oqs' and append it to 'replies'. */ void ofputil_append_queue_stat(struct list *replies, @@ -4627,15 +5415,21 @@ ofputil_append_queue_stat(struct list *replies, struct ofp_header *oh = msg->data; switch ((enum ofp_version)oh->version) { + case OFP13_VERSION: { + struct ofp13_queue_stats *reply = ofpmp_append(replies, sizeof *reply); + ofputil_queue_stats_to_ofp13(oqs, reply); + break; + } + case OFP12_VERSION: case OFP11_VERSION: { - struct ofp11_queue_stats *reply = ofpmp_append(replies, sizeof *reply);; + struct ofp11_queue_stats *reply = ofpmp_append(replies, sizeof *reply); ofputil_queue_stats_to_ofp11(oqs, reply); break; } case OFP10_VERSION: { - struct ofp10_queue_stats *reply = ofpmp_append(replies, sizeof *reply);; + struct ofp10_queue_stats *reply = ofpmp_append(replies, sizeof *reply); ofputil_queue_stats_to_ofp10(oqs, reply); break; }