X-Git-Url: http://git.cascardo.eti.br/?a=blobdiff_plain;f=lib%2Fofp-util.c;h=de7cf3cea308801d38b8987863c64293865574ce;hb=6c6eedc5d6730835a0d9724e2e8cfe9cdf03b07d;hp=e45b06b9cb0710adcc9e8cced177f5ec7e2e3a87;hpb=5be5025202db59a00f71863bd78d85c26e53c409;p=cascardo%2Fovs.git diff --git a/lib/ofp-util.c b/lib/ofp-util.c index e45b06b9c..de7cf3cea 100644 --- a/lib/ofp-util.c +++ b/lib/ofp-util.c @@ -1,5 +1,5 @@ /* - * Copyright (c) 2008, 2009, 2010, 2011, 2012, 2013, 2014 Nicira, Inc. + * Copyright (c) 2008, 2009, 2010, 2011, 2012, 2013, 2014, 2015, 2016 Nicira, Inc. * * Licensed under the Apache License, Version 2.0 (the "License"); * you may not use this file except in compliance with the License. @@ -32,16 +32,21 @@ #include "multipath.h" #include "netdev.h" #include "nx-match.h" +#include "id-pool.h" #include "ofp-actions.h" #include "ofp-errors.h" #include "ofp-msgs.h" +#include "ofp-prop.h" #include "ofp-util.h" #include "ofpbuf.h" +#include "openflow/netronome-ext.h" #include "packets.h" +#include "pktbuf.h" #include "random.h" +#include "tun-metadata.h" #include "unaligned.h" #include "type-props.h" -#include "vlog.h" +#include "openvswitch/vlog.h" #include "bitmap.h" VLOG_DEFINE_THIS_MODULE(ofp_util); @@ -50,105 +55,14 @@ VLOG_DEFINE_THIS_MODULE(ofp_util); * in the peer and so there's not much point in showing a lot of them. */ static struct vlog_rate_limit bad_ofmsg_rl = VLOG_RATE_LIMIT_INIT(1, 5); -static enum ofputil_table_miss ofputil_table_miss_from_config( - ovs_be32 config_, enum ofp_version); - -struct ofp_prop_header { - ovs_be16 type; - ovs_be16 len; -}; - -/* Pulls a property, beginning with struct ofp_prop_header, from the beginning - * of 'msg'. Stores the type of the property in '*typep' and, if 'property' is - * nonnull, the entire property, including the header, in '*property'. Returns - * 0 if successful, otherwise an error code. - * - * This function pulls the property's stated size padded out to a multiple of - * 'alignment' bytes. The common case in OpenFlow is an 'alignment' of 8, so - * you can use ofputil_pull_property() for that case. */ -static enum ofperr -ofputil_pull_property__(struct ofpbuf *msg, struct ofpbuf *property, - unsigned int alignment, uint16_t *typep) -{ - struct ofp_prop_header *oph; - unsigned int padded_len; - unsigned int len; - - if (ofpbuf_size(msg) < sizeof *oph) { - return OFPERR_OFPBPC_BAD_LEN; - } - - oph = ofpbuf_data(msg); - len = ntohs(oph->len); - padded_len = ROUND_UP(len, alignment); - if (len < sizeof *oph || padded_len > ofpbuf_size(msg)) { - return OFPERR_OFPBPC_BAD_LEN; - } - - *typep = ntohs(oph->type); - if (property) { - ofpbuf_use_const(property, ofpbuf_data(msg), len); - } - ofpbuf_pull(msg, padded_len); - return 0; -} - -/* Pulls a property, beginning with struct ofp_prop_header, from the beginning - * of 'msg'. Stores the type of the property in '*typep' and, if 'property' is - * nonnull, the entire property, including the header, in '*property'. Returns - * 0 if successful, otherwise an error code. - * - * This function pulls the property's stated size padded out to a multiple of - * 8 bytes, which is the common case for OpenFlow properties. */ -static enum ofperr -ofputil_pull_property(struct ofpbuf *msg, struct ofpbuf *property, - uint16_t *typep) -{ - return ofputil_pull_property__(msg, property, 8, typep); -} - -static void PRINTF_FORMAT(2, 3) -log_property(bool loose, const char *message, ...) -{ - enum vlog_level level = loose ? VLL_DBG : VLL_WARN; - if (!vlog_should_drop(THIS_MODULE, level, &bad_ofmsg_rl)) { - va_list args; - - va_start(args, message); - vlog_valist(THIS_MODULE, level, message, args); - va_end(args); - } -} - -static size_t -start_property(struct ofpbuf *msg, uint16_t type) -{ - size_t start_ofs = ofpbuf_size(msg); - struct ofp_prop_header *oph; - - oph = ofpbuf_put_uninit(msg, sizeof *oph); - oph->type = htons(type); - oph->len = htons(4); /* May be updated later by end_property(). */ - return start_ofs; -} - -static void -end_property(struct ofpbuf *msg, size_t start_ofs) -{ - struct ofp_prop_header *oph; - - oph = ofpbuf_at_assert(msg, start_ofs, sizeof *oph); - oph->len = htons(ofpbuf_size(msg) - start_ofs); - ofpbuf_padto(msg, ROUND_UP(ofpbuf_size(msg), 8)); -} - -static void -put_bitmap_properties(struct ofpbuf *msg, uint64_t bitmap) -{ - for (; bitmap; bitmap = zero_rightmost_1bit(bitmap)) { - start_property(msg, rightmost_1bit_idx(bitmap)); - } -} +static enum ofputil_table_vacancy ofputil_decode_table_vacancy( + ovs_be32 config, enum ofp_version); +static enum ofputil_table_eviction ofputil_decode_table_eviction( + ovs_be32 config, enum ofp_version); +static ovs_be32 ofputil_encode_table_config(enum ofputil_table_miss, + enum ofputil_table_eviction, + enum ofputil_table_vacancy, + enum ofp_version); /* Given the wildcard bit count in the least-significant 6 of 'wcbits', returns * an IP netmask with a 1 in each bit that must match and a 0 in each bit that @@ -185,7 +99,7 @@ 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 == 28); + BUILD_ASSERT_DECL(FLOW_WC_SEQ == 35); /* Initialize most of wc. */ flow_wildcards_init_catchall(wc); @@ -214,10 +128,10 @@ ofputil_wildcard_from_ofpfw10(uint32_t ofpfw, struct flow_wildcards *wc) } if (!(ofpfw & OFPFW10_DL_SRC)) { - memset(wc->masks.dl_src, 0xff, ETH_ADDR_LEN); + WC_MASK_FIELD(wc, dl_src); } if (!(ofpfw & OFPFW10_DL_DST)) { - memset(wc->masks.dl_dst, 0xff, ETH_ADDR_LEN); + WC_MASK_FIELD(wc, dl_dst); } if (!(ofpfw & OFPFW10_DL_TYPE)) { wc->masks.dl_type = OVS_BE16_MAX; @@ -250,8 +164,8 @@ ofputil_match_from_ofp10_match(const struct ofp10_match *ofmatch, 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; - memcpy(match->flow.dl_src, ofmatch->dl_src, ETH_ADDR_LEN); - memcpy(match->flow.dl_dst, ofmatch->dl_dst, ETH_ADDR_LEN); + match->flow.dl_src = ofmatch->dl_src; + match->flow.dl_dst = ofmatch->dl_dst; match->flow.nw_tos = ofmatch->nw_tos & IP_DSCP_MASK; match->flow.nw_proto = ofmatch->nw_proto; @@ -330,7 +244,6 @@ ofputil_match_to_ofp10_match(const struct match *match, } else if (match->wc.masks.vlan_tci & htons(VLAN_CFI) && !(match->flow.vlan_tci & htons(VLAN_CFI))) { ofmatch->dl_vlan = htons(OFP10_VLAN_NONE); - ofpfw |= OFPFW10_DL_VLAN_PCP; } else { if (!(match->wc.masks.vlan_tci & htons(VLAN_VID_MASK))) { ofpfw |= OFPFW10_DL_VLAN; @@ -348,8 +261,8 @@ ofputil_match_to_ofp10_match(const struct match *match, /* Compose most of the match structure. */ ofmatch->wildcards = htonl(ofpfw); 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_src = match->flow.dl_src; + ofmatch->dl_dst = match->flow.dl_dst; ofmatch->dl_type = ofputil_dl_type_to_openflow(match->flow.dl_type); ofmatch->nw_src = match->flow.nw_src; ofmatch->nw_dst = match->flow.nw_dst; @@ -365,10 +278,10 @@ enum ofperr ofputil_pull_ofp11_match(struct ofpbuf *buf, struct match *match, uint16_t *padded_match_len) { - struct ofp11_match_header *omh = ofpbuf_data(buf); + struct ofp11_match_header *omh = buf->data; uint16_t match_len; - if (ofpbuf_size(buf) < sizeof *omh) { + if (buf->size < sizeof *omh) { return OFPERR_OFPBMC_BAD_LEN; } @@ -378,7 +291,7 @@ ofputil_pull_ofp11_match(struct ofpbuf *buf, struct match *match, case OFPMT_STANDARD: { struct ofp11_match *om; - if (match_len != sizeof *om || ofpbuf_size(buf) < sizeof *om) { + if (match_len != sizeof *om || buf->size < sizeof *om) { return OFPERR_OFPBMC_BAD_LEN; } om = ofpbuf_pull(buf, sizeof *om); @@ -406,10 +319,7 @@ ofputil_match_from_ofp11_match(const struct ofp11_match *ofmatch, struct match *match) { uint16_t wc = ntohl(ofmatch->wildcards); - uint8_t dl_src_mask[ETH_ADDR_LEN]; - uint8_t dl_dst_mask[ETH_ADDR_LEN]; bool ipv4, arp, rarp; - int i; match_init_catchall(match); @@ -424,15 +334,10 @@ ofputil_match_from_ofp11_match(const struct ofp11_match *ofmatch, match_set_in_port(match, ofp_port); } - for (i = 0; i < ETH_ADDR_LEN; i++) { - dl_src_mask[i] = ~ofmatch->dl_src_mask[i]; - } - match_set_dl_src_masked(match, ofmatch->dl_src, dl_src_mask); - - for (i = 0; i < ETH_ADDR_LEN; i++) { - dl_dst_mask[i] = ~ofmatch->dl_dst_mask[i]; - } - match_set_dl_dst_masked(match, ofmatch->dl_dst, dl_dst_mask); + match_set_dl_src_masked(match, ofmatch->dl_src, + eth_addr_invert(ofmatch->dl_src_mask)); + match_set_dl_dst_masked(match, ofmatch->dl_dst, + eth_addr_invert(ofmatch->dl_dst_mask)); if (!(wc & OFPFW11_DL_VLAN)) { if (ofmatch->dl_vlan == htons(OFPVID11_NONE)) { @@ -559,7 +464,6 @@ ofputil_match_to_ofp11_match(const struct match *match, struct ofp11_match *ofmatch) { uint32_t wc = 0; - int i; memset(ofmatch, 0, sizeof *ofmatch); ofmatch->omh.type = htons(OFPMT_STANDARD); @@ -571,15 +475,10 @@ ofputil_match_to_ofp11_match(const struct match *match, ofmatch->in_port = ofputil_port_to_ofp11(match->flow.in_port.ofp_port); } - memcpy(ofmatch->dl_src, match->flow.dl_src, ETH_ADDR_LEN); - for (i = 0; i < ETH_ADDR_LEN; i++) { - ofmatch->dl_src_mask[i] = ~match->wc.masks.dl_src[i]; - } - - memcpy(ofmatch->dl_dst, match->flow.dl_dst, ETH_ADDR_LEN); - for (i = 0; i < ETH_ADDR_LEN; i++) { - ofmatch->dl_dst_mask[i] = ~match->wc.masks.dl_dst[i]; - } + ofmatch->dl_src = match->flow.dl_src; + ofmatch->dl_src_mask = eth_addr_invert(match->wc.masks.dl_src); + ofmatch->dl_dst = match->flow.dl_dst; + ofmatch->dl_dst_mask = eth_addr_invert(match->wc.masks.dl_dst); if (match->wc.masks.vlan_tci == htons(0)) { wc |= OFPFW11_DL_VLAN | OFPFW11_DL_VLAN_PCP; @@ -1226,8 +1125,9 @@ bool ofputil_packet_in_format_is_valid(enum nx_packet_in_format packet_in_format) { switch (packet_in_format) { - case NXPIF_OPENFLOW10: - case NXPIF_NXM: + case NXPIF_STANDARD: + case NXPIF_NXT_PACKET_IN: + case NXPIF_NXT_PACKET_IN2: return true; } @@ -1238,10 +1138,12 @@ const char * ofputil_packet_in_format_to_string(enum nx_packet_in_format packet_in_format) { switch (packet_in_format) { - case NXPIF_OPENFLOW10: - return "openflow10"; - case NXPIF_NXM: - return "nxm"; + case NXPIF_STANDARD: + return "standard"; + case NXPIF_NXT_PACKET_IN: + return "nxt_packet_in"; + case NXPIF_NXT_PACKET_IN2: + return "nxt_packet_in2"; default: OVS_NOT_REACHED(); } @@ -1250,8 +1152,12 @@ ofputil_packet_in_format_to_string(enum nx_packet_in_format packet_in_format) int ofputil_packet_in_format_from_string(const char *s) { - return (!strcmp(s, "openflow10") ? NXPIF_OPENFLOW10 - : !strcmp(s, "nxm") ? NXPIF_NXM + return (!strcmp(s, "standard") || !strcmp(s, "openflow10") + ? NXPIF_STANDARD + : !strcmp(s, "nxt_packet_in") || !strcmp(s, "nxm") + ? NXPIF_NXT_PACKET_IN + : !strcmp(s, "nxt_packet_in2") + ? NXPIF_NXT_PACKET_IN2 : -1); } @@ -1307,7 +1213,7 @@ ofputil_decode_hello_bitmap(const struct ofp_hello_elem_header *oheh, /* Only use the first 32-bit element of the bitmap as that is all the * current implementation supports. Subsequent elements are ignored which - * should have no effect on session negotiation until Open vSwtich supports + * should have no effect on session negotiation until Open vSwitch supports * wire-protocol versions greater than 31. */ allowed_versions = ntohl(bitmap[0]); @@ -1345,22 +1251,21 @@ version_bitmap_from_version(uint8_t ofp_version) bool ofputil_decode_hello(const struct ofp_header *oh, uint32_t *allowed_versions) { - struct ofpbuf msg; - bool ok = true; - - ofpbuf_use_const(&msg, oh, ntohs(oh->length)); + struct ofpbuf msg = ofpbuf_const_initializer(oh, ntohs(oh->length)); ofpbuf_pull(&msg, sizeof *oh); *allowed_versions = version_bitmap_from_version(oh->version); - while (ofpbuf_size(&msg)) { + + bool ok = true; + while (msg.size) { const struct ofp_hello_elem_header *oheh; unsigned int len; - if (ofpbuf_size(&msg) < sizeof *oheh) { + if (msg.size < sizeof *oheh) { return false; } - oheh = ofpbuf_data(&msg); + oheh = msg.data; len = ntohs(oheh->length); if (len < sizeof *oheh || !ofpbuf_try_pull(&msg, ROUND_UP(len, 8))) { return false; @@ -1646,14 +1551,12 @@ ofputil_decode_flow_mod(struct ofputil_flow_mod *fm, { ovs_be16 raw_flags; enum ofperr error; - struct ofpbuf b; - enum ofpraw raw; /* Ignored for non-delete actions */ fm->delete_reason = OFPRR_DELETE; - ofpbuf_use_const(&b, oh, ntohs(oh->length)); - raw = ofpraw_pull_assert(&b); + struct ofpbuf b = ofpbuf_const_initializer(oh, ntohs(oh->length)); + enum ofpraw raw = ofpraw_pull_assert(&b); if (raw == OFPRAW_OFPT11_FLOW_MOD) { /* Standard OpenFlow 1.1+ flow_mod. */ const struct ofp11_flow_mod *ofm; @@ -1714,7 +1617,7 @@ ofputil_decode_flow_mod(struct ofputil_flow_mod *fm, fm->out_group = (ofm->command == OFPFC_DELETE || ofm->command == OFPFC_DELETE_STRICT ? ntohl(ofm->out_group) - : OFPG11_ANY); + : OFPG_ANY); raw_flags = ofm->flags; } else { uint16_t command; @@ -1746,7 +1649,7 @@ ofputil_decode_flow_mod(struct ofputil_flow_mod *fm, fm->importance = 0; fm->buffer_id = ntohl(ofm->buffer_id); fm->out_port = u16_to_ofp(ntohs(ofm->out_port)); - fm->out_group = OFPG11_ANY; + fm->out_group = OFPG_ANY; raw_flags = ofm->flags; } else if (raw == OFPRAW_NXT_FLOW_MOD) { /* Nicira extended flow_mod. */ @@ -1774,7 +1677,7 @@ ofputil_decode_flow_mod(struct ofputil_flow_mod *fm, fm->importance = 0; fm->buffer_id = ntohl(nfm->buffer_id); fm->out_port = u16_to_ofp(ntohs(nfm->out_port)); - fm->out_group = OFPG11_ANY; + fm->out_group = OFPG_ANY; raw_flags = nfm->flags; } else { OVS_NOT_REACHED(); @@ -1785,18 +1688,26 @@ ofputil_decode_flow_mod(struct ofputil_flow_mod *fm, fm->command = command & 0xff; fm->table_id = command >> 8; } else { + if (command > 0xff) { + VLOG_WARN_RL(&bad_ofmsg_rl, "flow_mod has explicit table_id " + "but flow_mod_table_id extension is not enabled"); + } fm->command = command; fm->table_id = 0xff; } } - error = ofpacts_pull_openflow_instructions(&b, ofpbuf_size(&b), + if (fm->command > OFPFC_DELETE_STRICT) { + return OFPERR_OFPFMFC_BAD_COMMAND; + } + + error = ofpacts_pull_openflow_instructions(&b, b.size, oh->version, ofpacts); if (error) { return error; } - fm->ofpacts = ofpbuf_data(ofpacts); - fm->ofpacts_len = ofpbuf_size(ofpacts); + fm->ofpacts = ofpacts->data; + fm->ofpacts_len = ofpacts->size; error = ofputil_decode_flow_mod_flags(raw_flags, fm->command, oh->version, &fm->flags); @@ -1866,12 +1777,9 @@ 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)); + struct ofpbuf b = ofpbuf_const_initializer(oh, ntohs(oh->length)); ofpraw_pull_assert(&b); - omm = ofpbuf_pull(&b, sizeof *omm); + const struct ofp13_meter_mod *omm = ofpbuf_pull(&b, sizeof *omm); /* Translate the message. */ mm->command = ntohs(omm->command); @@ -1894,9 +1802,9 @@ ofputil_decode_meter_mod(const struct ofp_header *oh, mm->meter.flags & OFPMF13_PKTPS) { return OFPERR_OFPMMFC_BAD_FLAGS; } - mm->meter.bands = ofpbuf_data(bands); + mm->meter.bands = bands->data; - error = ofputil_pull_bands(&b, ofpbuf_size(&b), &mm->meter.n_bands, bands); + error = ofputil_pull_bands(&b, b.size, &mm->meter.n_bands, bands); if (error) { return error; } @@ -1968,25 +1876,27 @@ ofputil_put_bands(uint16_t n_bands, const struct ofputil_meter_band *mb, /* Encode a meter stat for 'mc' and append it to 'replies'. */ void -ofputil_append_meter_config(struct list *replies, +ofputil_append_meter_config(struct ovs_list *replies, const struct ofputil_meter_config *mc) { struct ofpbuf *msg = ofpbuf_from_list(list_back(replies)); - size_t start_ofs = ofpbuf_size(msg); - struct ofp13_meter_config *reply = ofpbuf_put_uninit(msg, sizeof *reply); - reply->flags = htons(mc->flags); - reply->meter_id = htonl(mc->meter_id); + size_t start_ofs = msg->size; + struct ofp13_meter_config *reply; + ofpbuf_put_uninit(msg, sizeof *reply); ofputil_put_bands(mc->n_bands, mc->bands, msg); - reply->length = htons(ofpbuf_size(msg) - start_ofs); + reply = ofpbuf_at_assert(msg, start_ofs, sizeof *reply); + reply->flags = htons(mc->flags); + reply->meter_id = htonl(mc->meter_id); + 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, +ofputil_append_meter_stats(struct ovs_list *replies, const struct ofputil_meter_stats *ms) { struct ofp13_meter_stats *reply; @@ -2034,11 +1944,11 @@ ofputil_decode_meter_config(struct ofpbuf *msg, enum ofperr err; /* Pull OpenFlow headers for the first call. */ - if (!msg->frame) { + if (!msg->header) { ofpraw_pull_assert(msg); } - if (!ofpbuf_size(msg)) { + if (!msg->size) { return EOF; } @@ -2046,7 +1956,7 @@ ofputil_decode_meter_config(struct ofpbuf *msg, if (!omc) { VLOG_WARN_RL(&bad_ofmsg_rl, "OFPMP_METER_CONFIG reply has %"PRIu32" leftover bytes at end", - ofpbuf_size(msg)); + msg->size); return OFPERR_OFPBRC_BAD_LEN; } @@ -2058,7 +1968,7 @@ ofputil_decode_meter_config(struct ofpbuf *msg, } mc->meter_id = ntohl(omc->meter_id); mc->flags = ntohs(omc->flags); - mc->bands = ofpbuf_data(bands); + mc->bands = bands->data; return 0; } @@ -2110,11 +2020,11 @@ ofputil_decode_meter_stats(struct ofpbuf *msg, enum ofperr err; /* Pull OpenFlow headers for the first call. */ - if (!msg->frame) { + if (!msg->header) { ofpraw_pull_assert(msg); } - if (!ofpbuf_size(msg)) { + if (!msg->size) { return EOF; } @@ -2122,7 +2032,7 @@ ofputil_decode_meter_stats(struct ofpbuf *msg, if (!oms) { VLOG_WARN_RL(&bad_ofmsg_rl, "OFPMP_METER reply has %"PRIu32" leftover bytes at end", - ofpbuf_size(msg)); + msg->size); return OFPERR_OFPBRC_BAD_LEN; } @@ -2138,7 +2048,7 @@ ofputil_decode_meter_stats(struct ofpbuf *msg, 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 = ofpbuf_data(bands); + ms->bands = bands->data; return 0; } @@ -2298,7 +2208,7 @@ ofputil_encode_flow_mod(const struct ofputil_flow_mod *fm, nfm->command = ofputil_tid_command(fm, protocol); nfm->cookie = fm->new_cookie; match_len = nx_put_match(msg, &fm->match, fm->cookie, fm->cookie_mask); - nfm = ofpbuf_l3(msg); + nfm = msg->msg; nfm->idle_timeout = htons(fm->idle_timeout); nfm->hard_timeout = htons(fm->hard_timeout); nfm->priority = htons(fm->priority); @@ -2327,7 +2237,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 = u16_to_ofp(ntohs(ofsr->out_port)); - fsr->out_group = OFPG11_ANY; + fsr->out_group = OFPG_ANY; fsr->table_id = ofsr->table_id; fsr->cookie = fsr->cookie_mask = htonll(0); @@ -2372,23 +2282,27 @@ ofputil_decode_nxst_flow_request(struct ofputil_flow_stats_request *fsr, if (error) { return error; } - if (ofpbuf_size(b)) { + if (b->size) { return OFPERR_OFPBRC_BAD_LEN; } fsr->aggregate = aggregate; fsr->out_port = u16_to_ofp(ntohs(nfsr->out_port)); - fsr->out_group = OFPG11_ANY; + fsr->out_group = OFPG_ANY; fsr->table_id = nfsr->table_id; return 0; } /* Constructs and returns an OFPT_QUEUE_GET_CONFIG request for the specified - * 'port', suitable for OpenFlow version 'version'. */ + * 'port' and 'queue', suitable for OpenFlow version 'version'. + * + * 'queue' is honored only for OpenFlow 1.4 and later; older versions always + * request all queues. */ struct ofpbuf * ofputil_encode_queue_get_config_request(enum ofp_version version, - ofp_port_t port) + ofp_port_t port, + uint32_t queue) { struct ofpbuf *request; @@ -2399,13 +2313,21 @@ ofputil_encode_queue_get_config_request(enum ofp_version version, version, 0); qgcr10 = ofpbuf_put_zeros(request, sizeof *qgcr10); qgcr10->port = htons(ofp_to_u16(port)); - } else { + } else if (version < OFP14_VERSION) { struct ofp11_queue_get_config_request *qgcr11; request = ofpraw_alloc(OFPRAW_OFPT11_QUEUE_GET_CONFIG_REQUEST, version, 0); qgcr11 = ofpbuf_put_zeros(request, sizeof *qgcr11); qgcr11->port = ofputil_port_to_ofp11(port); + } else { + struct ofp14_queue_desc_request *qdr14; + + request = ofpraw_alloc(OFPRAW_OFPST14_QUEUE_DESC_REQUEST, + version, 0); + qdr14 = ofpbuf_put_zeros(request, sizeof *qdr14); + qdr14->port = ofputil_port_to_ofp11(port); + qdr14->queue = htonl(queue); } return request; @@ -2416,78 +2338,96 @@ ofputil_encode_queue_get_config_request(enum ofp_version version, * code. */ enum ofperr ofputil_decode_queue_get_config_request(const struct ofp_header *oh, - ofp_port_t *port) + ofp_port_t *port, uint32_t *queue) { const struct ofp10_queue_get_config_request *qgcr10; const struct ofp11_queue_get_config_request *qgcr11; - enum ofpraw raw; - struct ofpbuf b; - - ofpbuf_use_const(&b, oh, ntohs(oh->length)); - raw = ofpraw_pull_assert(&b); + const struct ofp14_queue_desc_request *qdr14; + struct ofpbuf b = ofpbuf_const_initializer(oh, ntohs(oh->length)); + enum ofpraw raw = ofpraw_pull_assert(&b); switch ((int) raw) { case OFPRAW_OFPT10_QUEUE_GET_CONFIG_REQUEST: - qgcr10 = ofpbuf_data(&b); + qgcr10 = b.data; *port = u16_to_ofp(ntohs(qgcr10->port)); - return 0; + *queue = OFPQ_ALL; + break; case OFPRAW_OFPT11_QUEUE_GET_CONFIG_REQUEST: - qgcr11 = ofpbuf_data(&b); - return ofputil_port_from_ofp11(qgcr11->port, port); + qgcr11 = b.data; + *queue = OFPQ_ALL; + enum ofperr error = ofputil_port_from_ofp11(qgcr11->port, port); + if (error || *port == OFPP_ANY) { + return error; + } + break; + + case OFPRAW_OFPST14_QUEUE_DESC_REQUEST: + qdr14 = b.data; + *queue = ntohl(qdr14->queue); + return ofputil_port_from_ofp11(qdr14->port, port); + + default: + OVS_NOT_REACHED(); } - OVS_NOT_REACHED(); + return (ofp_to_u16(*port) < ofp_to_u16(OFPP_MAX) + ? 0 + : OFPERR_OFPQOFC_BAD_PORT); } /* Constructs and returns the beginning of a reply to - * OFPT_QUEUE_GET_CONFIG_REQUEST 'oh'. The caller may append information about - * individual queues with ofputil_append_queue_get_config_reply(). */ -struct ofpbuf * -ofputil_encode_queue_get_config_reply(const struct ofp_header *oh) + * OFPT_QUEUE_GET_CONFIG_REQUEST or OFPMP_QUEUE_DESC request 'oh'. The caller + * may append information about individual queues with + * ofputil_append_queue_get_config_reply(). */ +void +ofputil_start_queue_get_config_reply(const struct ofp_header *request, + struct ovs_list *replies) { - struct ofp10_queue_get_config_reply *qgcr10; - struct ofp11_queue_get_config_reply *qgcr11; struct ofpbuf *reply; enum ofperr error; - struct ofpbuf b; - enum ofpraw raw; ofp_port_t port; + uint32_t queue; - error = ofputil_decode_queue_get_config_request(oh, &port); + error = ofputil_decode_queue_get_config_request(request, &port, &queue); ovs_assert(!error); - ofpbuf_use_const(&b, oh, ntohs(oh->length)); - raw = ofpraw_pull_assert(&b); - + enum ofpraw raw = ofpraw_decode_assert(request); switch ((int) raw) { case OFPRAW_OFPT10_QUEUE_GET_CONFIG_REQUEST: reply = ofpraw_alloc_reply(OFPRAW_OFPT10_QUEUE_GET_CONFIG_REPLY, - oh, 0); - qgcr10 = ofpbuf_put_zeros(reply, sizeof *qgcr10); + request, 0); + struct ofp10_queue_get_config_reply *qgcr10 + = ofpbuf_put_zeros(reply, sizeof *qgcr10); qgcr10->port = htons(ofp_to_u16(port)); break; case OFPRAW_OFPT11_QUEUE_GET_CONFIG_REQUEST: reply = ofpraw_alloc_reply(OFPRAW_OFPT11_QUEUE_GET_CONFIG_REPLY, - oh, 0); - qgcr11 = ofpbuf_put_zeros(reply, sizeof *qgcr11); + request, 0); + struct ofp11_queue_get_config_reply *qgcr11 + = ofpbuf_put_zeros(reply, sizeof *qgcr11); qgcr11->port = ofputil_port_to_ofp11(port); break; + case OFPRAW_OFPST14_QUEUE_DESC_REQUEST: + reply = ofpraw_alloc_stats_reply(request, 0); + break; + default: OVS_NOT_REACHED(); } - return reply; + list_init(replies); + list_push_back(replies, &reply->list_node); } static void -put_queue_rate(struct ofpbuf *reply, enum ofp_queue_properties property, - uint16_t rate) +put_ofp10_queue_rate(struct ofpbuf *reply, + enum ofp10_queue_properties property, uint16_t rate) { if (rate != UINT16_MAX) { - struct ofp_queue_prop_rate *oqpr; + struct ofp10_queue_prop_rate *oqpr; oqpr = ofpbuf_put_zeros(reply, sizeof *oqpr); oqpr->prop_header.property = htons(property); @@ -2496,78 +2436,68 @@ put_queue_rate(struct ofpbuf *reply, enum ofp_queue_properties property, } } -/* Appends a queue description for 'queue_id' to the - * OFPT_QUEUE_GET_CONFIG_REPLY already in 'oh'. */ +static void +put_ofp14_queue_rate(struct ofpbuf *reply, + enum ofp14_queue_desc_prop_type type, uint16_t rate) +{ + if (rate != UINT16_MAX) { + ofpprop_put_u16(reply, type, rate); + } +} + void -ofputil_append_queue_get_config_reply(struct ofpbuf *reply, - const struct ofputil_queue_config *oqc) +ofputil_append_queue_get_config_reply(const struct ofputil_queue_config *qc, + struct ovs_list *replies) { - const struct ofp_header *oh = ofpbuf_data(reply); - size_t start_ofs, len_ofs; + enum ofp_version ofp_version = ofpmp_version(replies); + struct ofpbuf *reply = ofpbuf_from_list(list_back(replies)); + size_t start_ofs = reply->size; + size_t len_ofs; ovs_be16 *len; - start_ofs = ofpbuf_size(reply); - if (oh->version < OFP12_VERSION) { - struct ofp10_packet_queue *opq10; + if (ofp_version < OFP14_VERSION) { + if (ofp_version < OFP12_VERSION) { + struct ofp10_packet_queue *opq10; - opq10 = ofpbuf_put_zeros(reply, sizeof *opq10); - opq10->queue_id = htonl(oqc->queue_id); - len_ofs = (char *) &opq10->len - (char *) ofpbuf_data(reply); - } else { - struct ofp11_queue_get_config_reply *qgcr11; - struct ofp12_packet_queue *opq12; - ovs_be32 port; + opq10 = ofpbuf_put_zeros(reply, sizeof *opq10); + opq10->queue_id = htonl(qc->queue); + len_ofs = (char *) &opq10->len - (char *) reply->data; + } else { + struct ofp12_packet_queue *opq12; - qgcr11 = ofpbuf_l3(reply); - port = qgcr11->port; + opq12 = ofpbuf_put_zeros(reply, sizeof *opq12); + opq12->port = ofputil_port_to_ofp11(qc->port); + opq12->queue_id = htonl(qc->queue); + len_ofs = (char *) &opq12->len - (char *) reply->data; + } - opq12 = ofpbuf_put_zeros(reply, sizeof *opq12); - opq12->port = port; - opq12->queue_id = htonl(oqc->queue_id); - len_ofs = (char *) &opq12->len - (char *) ofpbuf_data(reply); + put_ofp10_queue_rate(reply, OFPQT10_MIN_RATE, qc->min_rate); + put_ofp10_queue_rate(reply, OFPQT11_MAX_RATE, qc->max_rate); + } else { + struct ofp14_queue_desc *oqd = ofpbuf_put_zeros(reply, sizeof *oqd); + oqd->port_no = ofputil_port_to_ofp11(qc->port); + oqd->queue_id = htonl(qc->queue); + len_ofs = (char *) &oqd->len - (char *) reply->data; + put_ofp14_queue_rate(reply, OFPQDPT14_MIN_RATE, qc->min_rate); + put_ofp14_queue_rate(reply, OFPQDPT14_MAX_RATE, qc->max_rate); } - put_queue_rate(reply, OFPQT_MIN_RATE, oqc->min_rate); - put_queue_rate(reply, OFPQT_MAX_RATE, oqc->max_rate); - len = ofpbuf_at(reply, len_ofs, sizeof *len); - *len = htons(ofpbuf_size(reply) - start_ofs); -} - -/* Decodes the initial part of an OFPT_QUEUE_GET_CONFIG_REPLY from 'reply' and - * stores in '*port' the port that the reply is about. The caller may call - * ofputil_pull_queue_get_config_reply() to obtain information about individual - * queues included in the reply. Returns 0 if successful, otherwise an - * ofperr.*/ -enum ofperr -ofputil_decode_queue_get_config_reply(struct ofpbuf *reply, ofp_port_t *port) -{ - const struct ofp10_queue_get_config_reply *qgcr10; - const struct ofp11_queue_get_config_reply *qgcr11; - enum ofpraw raw; - - raw = ofpraw_pull_assert(reply); - switch ((int) raw) { - case OFPRAW_OFPT10_QUEUE_GET_CONFIG_REPLY: - qgcr10 = ofpbuf_pull(reply, sizeof *qgcr10); - *port = u16_to_ofp(ntohs(qgcr10->port)); - return 0; + *len = htons(reply->size - start_ofs); - case OFPRAW_OFPT11_QUEUE_GET_CONFIG_REPLY: - qgcr11 = ofpbuf_pull(reply, sizeof *qgcr11); - return ofputil_port_from_ofp11(qgcr11->port, port); + if (ofp_version >= OFP14_VERSION) { + ofpmp_postappend(replies, start_ofs); } - - OVS_NOT_REACHED(); } static enum ofperr -parse_queue_rate(const struct ofp_queue_prop_header *hdr, uint16_t *rate) +parse_ofp10_queue_rate(const struct ofp10_queue_prop_header *hdr, + uint16_t *rate) { - const struct ofp_queue_prop_rate *oqpr; + const struct ofp10_queue_prop_rate *oqpr; if (hdr->len == htons(sizeof *oqpr)) { - oqpr = (const struct ofp_queue_prop_rate *) hdr; + oqpr = (const struct ofp10_queue_prop_rate *) hdr; *rate = ntohs(oqpr->rate); return 0; } else { @@ -2575,76 +2505,76 @@ parse_queue_rate(const struct ofp_queue_prop_header *hdr, uint16_t *rate) } } -/* Decodes information about a queue from the OFPT_QUEUE_GET_CONFIG_REPLY in - * 'reply' and stores it in '*queue'. ofputil_decode_queue_get_config_reply() - * must already have pulled off the main header. - * - * This function returns EOF if the last queue has already been decoded, 0 if a - * queue was successfully decoded into '*queue', or an ofperr if there was a - * problem decoding 'reply'. */ -int -ofputil_pull_queue_get_config_reply(struct ofpbuf *reply, - struct ofputil_queue_config *queue) +static int +ofputil_pull_queue_get_config_reply10(struct ofpbuf *msg, + struct ofputil_queue_config *queue) { - const struct ofp_header *oh; - unsigned int opq_len; - unsigned int len; + const struct ofp_header *oh = msg->header; + unsigned int opq_len; /* Length of protocol-specific queue header. */ + unsigned int len; /* Total length of queue + properties. */ - if (!ofpbuf_size(reply)) { - return EOF; + /* Obtain the port number from the message header. */ + if (oh->version == OFP10_VERSION) { + const struct ofp10_queue_get_config_reply *oqgcr10 = msg->msg; + queue->port = u16_to_ofp(ntohs(oqgcr10->port)); + } else { + const struct ofp11_queue_get_config_reply *oqgcr11 = msg->msg; + enum ofperr error = ofputil_port_from_ofp11(oqgcr11->port, + &queue->port); + if (error) { + return error; + } } - queue->min_rate = UINT16_MAX; - queue->max_rate = UINT16_MAX; - - oh = reply->frame; + /* Pull off the queue header and get the queue number and length. */ if (oh->version < OFP12_VERSION) { const struct ofp10_packet_queue *opq10; - - opq10 = ofpbuf_try_pull(reply, sizeof *opq10); + opq10 = ofpbuf_try_pull(msg, sizeof *opq10); if (!opq10) { return OFPERR_OFPBRC_BAD_LEN; } - queue->queue_id = ntohl(opq10->queue_id); + queue->queue = ntohl(opq10->queue_id); len = ntohs(opq10->len); opq_len = sizeof *opq10; } else { const struct ofp12_packet_queue *opq12; - - opq12 = ofpbuf_try_pull(reply, sizeof *opq12); + opq12 = ofpbuf_try_pull(msg, sizeof *opq12); if (!opq12) { return OFPERR_OFPBRC_BAD_LEN; } - queue->queue_id = ntohl(opq12->queue_id); + queue->queue = ntohl(opq12->queue_id); len = ntohs(opq12->len); opq_len = sizeof *opq12; } - if (len < opq_len || len > ofpbuf_size(reply) + opq_len || len % 8) { + /* Length check. */ + if (len < opq_len || len > msg->size + opq_len || len % 8) { return OFPERR_OFPBRC_BAD_LEN; } len -= opq_len; + /* Pull properties. The format of these properties differs from used in + * OF1.4+ so we can't use the common property functions. */ while (len > 0) { - const struct ofp_queue_prop_header *hdr; + const struct ofp10_queue_prop_header *hdr; unsigned int property; unsigned int prop_len; enum ofperr error = 0; - hdr = ofpbuf_at_assert(reply, 0, sizeof *hdr); + hdr = ofpbuf_at_assert(msg, 0, sizeof *hdr); prop_len = ntohs(hdr->len); - if (prop_len < sizeof *hdr || prop_len > ofpbuf_size(reply) || prop_len % 8) { + if (prop_len < sizeof *hdr || prop_len > msg->size || prop_len % 8) { return OFPERR_OFPBRC_BAD_LEN; } property = ntohs(hdr->property); switch (property) { - case OFPQT_MIN_RATE: - error = parse_queue_rate(hdr, &queue->min_rate); + case OFPQT10_MIN_RATE: + error = parse_ofp10_queue_rate(hdr, &queue->min_rate); break; - case OFPQT_MAX_RATE: - error = parse_queue_rate(hdr, &queue->max_rate); + case OFPQT11_MAX_RATE: + error = parse_ofp10_queue_rate(hdr, &queue->max_rate); break; default: @@ -2655,12 +2585,107 @@ ofputil_pull_queue_get_config_reply(struct ofpbuf *reply, return error; } - ofpbuf_pull(reply, prop_len); + ofpbuf_pull(msg, prop_len); len -= prop_len; } return 0; } +static int +ofputil_pull_queue_get_config_reply14(struct ofpbuf *msg, + struct ofputil_queue_config *queue) +{ + struct ofp14_queue_desc *oqd14 = ofpbuf_try_pull(msg, sizeof *oqd14); + if (!oqd14) { + return OFPERR_OFPBRC_BAD_LEN; + } + enum ofperr error = ofputil_port_from_ofp11(oqd14->port_no, &queue->port); + if (error) { + return error; + } + queue->queue = ntohl(oqd14->queue_id); + + /* Length check. */ + unsigned int len = ntohs(oqd14->len); + if (len < sizeof *oqd14 || len > msg->size + sizeof *oqd14 || len % 8) { + return OFPERR_OFPBRC_BAD_LEN; + } + len -= sizeof *oqd14; + + struct ofpbuf properties = ofpbuf_const_initializer(ofpbuf_pull(msg, len), + len); + while (properties.size > 0) { + struct ofpbuf payload; + uint64_t type; + + error = ofpprop_pull(&properties, &payload, &type); + if (error) { + return error; + } + + switch (type) { + case OFPQDPT14_MIN_RATE: + error = ofpprop_parse_u16(&payload, &queue->min_rate); + break; + + case OFPQDPT14_MAX_RATE: + error = ofpprop_parse_u16(&payload, &queue->max_rate); + break; + + default: + error = OFPPROP_UNKNOWN(true, "queue desc", type); + break; + } + + if (error) { + return error; + } + } + + return 0; +} + +/* Decodes information about a queue from the OFPT_QUEUE_GET_CONFIG_REPLY in + * 'reply' and stores it in '*queue'. ofputil_decode_queue_get_config_reply() + * must already have pulled off the main header. + * + * This function returns EOF if the last queue has already been decoded, 0 if a + * queue was successfully decoded into '*queue', or an ofperr if there was a + * problem decoding 'reply'. */ +int +ofputil_pull_queue_get_config_reply(struct ofpbuf *msg, + struct ofputil_queue_config *queue) +{ + enum ofpraw raw; + if (!msg->header) { + /* Pull OpenFlow header. */ + raw = ofpraw_pull_assert(msg); + + /* Pull protocol-specific ofp_queue_get_config_reply header (OF1.4 + * doesn't have one at all). */ + if (raw == OFPRAW_OFPT10_QUEUE_GET_CONFIG_REPLY) { + ofpbuf_pull(msg, sizeof(struct ofp10_queue_get_config_reply)); + } else if (raw == OFPRAW_OFPT11_QUEUE_GET_CONFIG_REPLY) { + ofpbuf_pull(msg, sizeof(struct ofp11_queue_get_config_reply)); + } else { + ovs_assert(raw == OFPRAW_OFPST14_QUEUE_DESC_REPLY); + } + } else { + raw = ofpraw_decode_assert(msg->header); + } + + queue->min_rate = UINT16_MAX; + queue->max_rate = UINT16_MAX; + + if (!msg->size) { + return EOF; + } else if (raw == OFPRAW_OFPST14_QUEUE_DESC_REPLY) { + return ofputil_pull_queue_get_config_reply14(msg, queue); + } else { + return ofputil_pull_queue_get_config_reply10(msg, queue); + } +} + /* Converts an OFPST_FLOW, OFPST_AGGREGATE, NXST_FLOW, or NXST_AGGREGATE * request 'oh', into an abstract flow_stats_request in 'fsr'. Returns 0 if * successful, otherwise an OpenFlow error code. */ @@ -2668,17 +2693,14 @@ enum ofperr ofputil_decode_flow_stats_request(struct ofputil_flow_stats_request *fsr, const struct ofp_header *oh) { - enum ofpraw raw; - struct ofpbuf b; - - ofpbuf_use_const(&b, oh, ntohs(oh->length)); - raw = ofpraw_pull_assert(&b); + struct ofpbuf b = ofpbuf_const_initializer(oh, ntohs(oh->length)); + enum ofpraw raw = ofpraw_pull_assert(&b); switch ((int) raw) { case OFPRAW_OFPST10_FLOW_REQUEST: - return ofputil_decode_ofpst10_flow_request(fsr, ofpbuf_data(&b), false); + return ofputil_decode_ofpst10_flow_request(fsr, b.data, false); case OFPRAW_OFPST10_AGGREGATE_REQUEST: - return ofputil_decode_ofpst10_flow_request(fsr, ofpbuf_data(&b), true); + return ofputil_decode_ofpst10_flow_request(fsr, b.data, true); case OFPRAW_OFPST11_FLOW_REQUEST: return ofputil_decode_ofpst11_flow_request(fsr, &b, false); @@ -2759,7 +2781,7 @@ ofputil_encode_flow_stats_request(const struct ofputil_flow_stats_request *fsr, match_len = nx_put_match(msg, &fsr->match, fsr->cookie, fsr->cookie_mask); - nfsr = ofpbuf_l3(msg); + nfsr = msg->msg; nfsr->out_port = htons(ofp_to_u16(fsr->out_port)); nfsr->match_len = htons(match_len); nfsr->table_id = fsr->table_id; @@ -2804,15 +2826,14 @@ ofputil_decode_flow_stats_reply(struct ofputil_flow_stats *fs, enum ofperr error; enum ofpraw raw; - error = (msg->frame - ? ofpraw_decode(&raw, msg->frame) + error = (msg->header ? ofpraw_decode(&raw, msg->header) : ofpraw_pull(&raw, msg)); if (error) { return error; } - oh = msg->frame; + oh = msg->header; - if (!ofpbuf_size(msg)) { + if (!msg->size) { return EOF; } else if (raw == OFPRAW_OFPST11_FLOW_REPLY || raw == OFPRAW_OFPST13_FLOW_REPLY) { @@ -2823,7 +2844,7 @@ ofputil_decode_flow_stats_reply(struct ofputil_flow_stats *fs, ofs = ofpbuf_try_pull(msg, sizeof *ofs); if (!ofs) { VLOG_WARN_RL(&bad_ofmsg_rl, "OFPST_FLOW reply has %"PRIu32" leftover " - "bytes at end", ofpbuf_size(msg)); + "bytes at end", msg->size); return EINVAL; } @@ -2872,7 +2893,7 @@ ofputil_decode_flow_stats_reply(struct ofputil_flow_stats *fs, ofs = ofpbuf_try_pull(msg, sizeof *ofs); if (!ofs) { VLOG_WARN_RL(&bad_ofmsg_rl, "OFPST_FLOW reply has %"PRIu32" leftover " - "bytes at end", ofpbuf_size(msg)); + "bytes at end", msg->size); return EINVAL; } @@ -2905,7 +2926,7 @@ ofputil_decode_flow_stats_reply(struct ofputil_flow_stats *fs, nfs = ofpbuf_try_pull(msg, sizeof *nfs); if (!nfs) { VLOG_WARN_RL(&bad_ofmsg_rl, "NXST_FLOW reply has %"PRIu32" leftover " - "bytes at end", ofpbuf_size(msg)); + "bytes at end", msg->size); return EINVAL; } @@ -2951,8 +2972,8 @@ ofputil_decode_flow_stats_reply(struct ofputil_flow_stats *fs, VLOG_WARN_RL(&bad_ofmsg_rl, "OFPST_FLOW reply bad instructions"); return EINVAL; } - fs->ofpacts = ofpbuf_data(ofpacts); - fs->ofpacts_len = ofpbuf_size(ofpacts); + fs->ofpacts = ofpacts->data; + fs->ofpacts_len = ofpacts->size; return 0; } @@ -2972,10 +2993,10 @@ unknown_to_zero(uint64_t count) * have been initialized with ofpmp_init(). */ void ofputil_append_flow_stats_reply(const struct ofputil_flow_stats *fs, - struct list *replies) + struct ovs_list *replies) { struct ofpbuf *reply = ofpbuf_from_list(list_back(replies)); - size_t start_ofs = ofpbuf_size(reply); + size_t start_ofs = reply->size; enum ofp_version version = ofpmp_version(replies); enum ofpraw raw = ofpmp_decode_raw(replies); @@ -2988,7 +3009,7 @@ ofputil_append_flow_stats_reply(const struct ofputil_flow_stats *fs, version); ofs = ofpbuf_at_assert(reply, start_ofs, sizeof *ofs); - ofs->length = htons(ofpbuf_size(reply) - start_ofs); + ofs->length = htons(reply->size - start_ofs); ofs->table_id = fs->table_id; ofs->pad = 0; ofs->duration_sec = htonl(fs->duration_sec); @@ -3017,7 +3038,7 @@ ofputil_append_flow_stats_reply(const struct ofputil_flow_stats *fs, ofpacts_put_openflow_actions(fs->ofpacts, fs->ofpacts_len, reply, version); ofs = ofpbuf_at_assert(reply, start_ofs, sizeof *ofs); - ofs->length = htons(ofpbuf_size(reply) - start_ofs); + ofs->length = htons(reply->size - start_ofs); ofs->table_id = fs->table_id; ofs->pad = 0; ofputil_match_to_ofp10_match(&fs->match, &ofs->match); @@ -3041,7 +3062,7 @@ ofputil_append_flow_stats_reply(const struct ofputil_flow_stats *fs, ofpacts_put_openflow_actions(fs->ofpacts, fs->ofpacts_len, reply, version); nfs = ofpbuf_at_assert(reply, start_ofs, sizeof *nfs); - nfs->length = htons(ofpbuf_size(reply) - start_ofs); + nfs->length = htons(reply->size - start_ofs); nfs->table_id = fs->table_id; nfs->pad = 0; nfs->duration_sec = htonl(fs->duration_sec); @@ -3101,13 +3122,10 @@ enum ofperr ofputil_decode_aggregate_stats_reply(struct ofputil_aggregate_stats *stats, const struct ofp_header *reply) { - struct ofp_aggregate_stats_reply *asr; - struct ofpbuf msg; - - ofpbuf_use_const(&msg, reply, ntohs(reply->length)); + struct ofpbuf msg = ofpbuf_const_initializer(reply, ntohs(reply->length)); ofpraw_pull_assert(&msg); - asr = ofpbuf_l3(&msg); + struct ofp_aggregate_stats_reply *asr = msg.msg; stats->packet_count = ntohll(get_32aligned_be64(&asr->packet_count)); stats->byte_count = ntohll(get_32aligned_be64(&asr->byte_count)); stats->flow_count = ntohl(asr->flow_count); @@ -3122,11 +3140,8 @@ enum ofperr ofputil_decode_flow_removed(struct ofputil_flow_removed *fr, const struct ofp_header *oh) { - enum ofpraw raw; - struct ofpbuf b; - - ofpbuf_use_const(&b, oh, ntohs(oh->length)); - raw = ofpraw_pull_assert(&b); + struct ofpbuf b = ofpbuf_const_initializer(oh, ntohs(oh->length)); + enum ofpraw raw = ofpraw_pull_assert(&b); if (raw == OFPRAW_OFPT11_FLOW_REMOVED) { const struct ofp12_flow_removed *ofr; enum ofperr error; @@ -3174,7 +3189,7 @@ ofputil_decode_flow_removed(struct ofputil_flow_removed *fr, if (error) { return error; } - if (ofpbuf_size(&b)) { + if (b.size) { return OFPERR_OFPBRC_BAD_LEN; } @@ -3265,7 +3280,7 @@ ofputil_encode_flow_removed(const struct ofputil_flow_removed *fr, ofpbuf_put_zeros(msg, sizeof *nfr); match_len = nx_put_match(msg, &fr->match, 0, 0); - nfr = ofpbuf_l3(msg); + nfr = msg->msg; nfr->cookie = fr->cookie; nfr->priority = htons(fr->priority); nfr->reason = reason; @@ -3286,103 +3301,201 @@ ofputil_encode_flow_removed(const struct ofputil_flow_removed *fr, return msg; } -static void -ofputil_decode_packet_in_finish(struct ofputil_packet_in *pin, - struct match *match, struct ofpbuf *b) -{ - pin->packet = ofpbuf_data(b); - pin->packet_len = ofpbuf_size(b); - - 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 -ofputil_decode_packet_in(struct ofputil_packet_in *pin, - const struct ofp_header *oh) +/* The caller has done basic initialization of '*pin'; the other output + * arguments needs to be initialized. */ +static enum ofperr +decode_nx_packet_in2(const struct ofp_header *oh, bool loose, + struct ofputil_packet_in *pin, + size_t *total_len, uint32_t *buffer_id, + struct ofpbuf *continuation) { - enum ofpraw raw; - struct ofpbuf b; + *total_len = 0; + *buffer_id = UINT32_MAX; - memset(pin, 0, sizeof *pin); - pin->cookie = OVS_BE64_MAX; - - ofpbuf_use_const(&b, oh, ntohs(oh->length)); - raw = ofpraw_pull_assert(&b); - 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; + struct ofpbuf properties; + ofpbuf_use_const(&properties, oh, ntohs(oh->length)); + ofpraw_pull_assert(&properties); - if (raw == OFPRAW_OFPT12_PACKET_IN) { - packet_in_size = sizeof (struct ofp12_packet_in); - } else { - packet_in_size = sizeof (struct ofp13_packet_in); - } + while (properties.size > 0) { + struct ofpbuf payload; + uint64_t type; - opi = ofpbuf_pull(&b, packet_in_size); - error = oxm_pull_match_loose(&b, &match); + enum ofperr error = ofpprop_pull(&properties, &payload, &type); if (error) { return error; } - if (!ofpbuf_try_pull(&b, 2)) { - return OFPERR_OFPBRC_BAD_LEN; - } - - 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); + switch (type) { + case NXPINT_PACKET: + pin->packet = payload.msg; + pin->packet_len = ofpbuf_msgsize(&payload); + break; - if (raw == OFPRAW_OFPT13_PACKET_IN) { - pin->cookie = opi->cookie; + case NXPINT_FULL_LEN: { + uint32_t u32; + error = ofpprop_parse_u32(&payload, &u32); + *total_len = u32; + break; } - ofputil_decode_packet_in_finish(pin, &match, &b); - } else if (raw == OFPRAW_OFPT10_PACKET_IN) { - const struct ofp10_packet_in *opi; + case NXPINT_BUFFER_ID: + error = ofpprop_parse_u32(&payload, buffer_id); + break; - opi = ofpbuf_pull(&b, offsetof(struct ofp10_packet_in, data)); + case NXPINT_TABLE_ID: + error = ofpprop_parse_u8(&payload, &pin->table_id); + break; - pin->packet = opi->data; - pin->packet_len = ofpbuf_size(&b); + case NXPINT_COOKIE: + error = ofpprop_parse_be64(&payload, &pin->cookie); + break; - 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); - } else if (raw == OFPRAW_OFPT11_PACKET_IN) { - const struct ofp11_packet_in *opi; - enum ofperr error; + case NXPINT_REASON: { + uint8_t reason; + error = ofpprop_parse_u8(&payload, &reason); + pin->reason = reason; + break; + } - opi = ofpbuf_pull(&b, sizeof *opi); + case NXPINT_METADATA: + error = oxm_decode_match(payload.msg, ofpbuf_msgsize(&payload), + &pin->flow_metadata); + break; - pin->packet = ofpbuf_data(&b); - pin->packet_len = ofpbuf_size(&b); + case NXPINT_USERDATA: + pin->userdata = payload.msg; + pin->userdata_len = ofpbuf_msgsize(&payload); + break; + + case NXPINT_CONTINUATION: + if (continuation) { + error = ofpprop_parse_nested(&payload, continuation); + } + break; + + default: + error = OFPPROP_UNKNOWN(loose, "NX_PACKET_IN2", type); + break; + } + if (error) { + return error; + } + } + + if (!pin->packet_len) { + VLOG_WARN_RL(&bad_ofmsg_rl, "NXT_PACKET_IN2 lacks packet"); + return OFPERR_OFPBRC_BAD_LEN; + } else if (!*total_len) { + *total_len = pin->packet_len; + } else if (*total_len < pin->packet_len) { + VLOG_WARN_RL(&bad_ofmsg_rl, "NXT_PACKET_IN2 claimed full_len < len"); + return OFPERR_OFPBRC_BAD_LEN; + } + + return 0; +} + +/* Decodes the packet-in message starting at 'oh' into '*pin'. Populates + * 'pin->packet' and 'pin->packet_len' with the part of the packet actually + * included in the message. If 'total_lenp' is nonnull, populates + * '*total_lenp' with the original length of the packet (which is larger than + * 'packet->len' if only part of the packet was included). If 'buffer_idp' is + * nonnull, stores the packet's buffer ID in '*buffer_idp' (UINT32_MAX if it + * was not buffered). + * + * Populates 'continuation', if nonnull, with the continuation data from the + * packet-in (an empty buffer, if 'oh' did not contain continuation data). The + * format of this data is supposed to be opaque to anything other than + * ovs-vswitchd, so that in any other process the only reasonable use of this + * data is to be copied into an NXT_RESUME message via ofputil_encode_resume(). + * + * This function points 'pin->packet' into 'oh', so the caller should not free + * it separately from the original OpenFlow message. This is also true for + * 'pin->userdata' (which could also end up NULL if there is no userdata). + * + * Returns 0 if successful, otherwise an OpenFlow error code. */ +enum ofperr +ofputil_decode_packet_in(const struct ofp_header *oh, bool loose, + struct ofputil_packet_in *pin, + size_t *total_lenp, uint32_t *buffer_idp, + struct ofpbuf *continuation) +{ + uint32_t buffer_id; + size_t total_len; + + memset(pin, 0, sizeof *pin); + pin->cookie = OVS_BE64_MAX; + if (continuation) { + ofpbuf_use_const(continuation, NULL, 0); + } + + struct ofpbuf b = ofpbuf_const_initializer(oh, ntohs(oh->length)); + enum ofpraw raw = ofpraw_pull_assert(&b); + if (raw == OFPRAW_OFPT13_PACKET_IN || raw == OFPRAW_OFPT12_PACKET_IN) { + const struct ofp12_packet_in *opi = ofpbuf_pull(&b, sizeof *opi); + const ovs_be64 *cookie = (raw == OFPRAW_OFPT13_PACKET_IN + ? ofpbuf_pull(&b, sizeof *cookie) + : NULL); + enum ofperr error = oxm_pull_match_loose(&b, &pin->flow_metadata); + if (error) { + return error; + } + + if (!ofpbuf_try_pull(&b, 2)) { + return OFPERR_OFPBRC_BAD_LEN; + } + + pin->reason = opi->reason; + pin->table_id = opi->table_id; + buffer_id = ntohl(opi->buffer_id); + total_len = ntohs(opi->total_len); + if (cookie) { + pin->cookie = *cookie; + } + + pin->packet = b.data; + pin->packet_len = b.size; + } else if (raw == OFPRAW_OFPT10_PACKET_IN) { + const struct ofp10_packet_in *opi; + + opi = ofpbuf_pull(&b, offsetof(struct ofp10_packet_in, data)); + + pin->packet = CONST_CAST(uint8_t *, opi->data); + pin->packet_len = b.size; - pin->buffer_id = ntohl(opi->buffer_id); - error = ofputil_port_from_ofp11(opi->in_port, &pin->fmd.in_port); + match_init_catchall(&pin->flow_metadata); + match_set_in_port(&pin->flow_metadata, + u16_to_ofp(ntohs(opi->in_port))); + pin->reason = opi->reason; + buffer_id = ntohl(opi->buffer_id); + total_len = ntohs(opi->total_len); + } else if (raw == OFPRAW_OFPT11_PACKET_IN) { + const struct ofp11_packet_in *opi; + ofp_port_t in_port; + enum ofperr error; + + opi = ofpbuf_pull(&b, sizeof *opi); + + pin->packet = b.data; + pin->packet_len = b.size; + + buffer_id = ntohl(opi->buffer_id); + error = ofputil_port_from_ofp11(opi->in_port, &in_port); if (error) { return error; } - pin->total_len = ntohs(opi->total_len); + match_init_catchall(&pin->flow_metadata); + match_set_in_port(&pin->flow_metadata, in_port); + total_len = ntohs(opi->total_len); pin->reason = opi->reason; pin->table_id = opi->table_id; } else if (raw == OFPRAW_NXT_PACKET_IN) { const struct nx_packet_in *npi; - struct match match; int error; npi = ofpbuf_pull(&b, sizeof *npi); - error = nx_pull_match_loose(&b, ntohs(npi->match_len), &match, NULL, - NULL); + error = nx_pull_match_loose(&b, ntohs(npi->match_len), + &pin->flow_metadata, NULL, NULL); if (error) { return error; } @@ -3395,200 +3508,411 @@ ofputil_decode_packet_in(struct ofputil_packet_in *pin, pin->table_id = npi->table_id; pin->cookie = npi->cookie; - pin->buffer_id = ntohl(npi->buffer_id); - pin->total_len = ntohs(npi->total_len); + buffer_id = ntohl(npi->buffer_id); + total_len = ntohs(npi->total_len); - ofputil_decode_packet_in_finish(pin, &match, &b); + pin->packet = b.data; + pin->packet_len = b.size; + } else if (raw == OFPRAW_NXT_PACKET_IN2 || raw == OFPRAW_NXT_RESUME) { + enum ofperr error = decode_nx_packet_in2(oh, loose, pin, &total_len, + &buffer_id, continuation); + if (error) { + return error; + } } else { OVS_NOT_REACHED(); } + if (total_lenp) { + *total_lenp = total_len; + } + if (buffer_idp) { + *buffer_idp = buffer_id; + } + return 0; } +static int +encode_packet_in_reason(enum ofp_packet_in_reason reason, + enum ofp_version version) +{ + switch (reason) { + case OFPR_NO_MATCH: + case OFPR_ACTION: + case OFPR_INVALID_TTL: + return reason; + + case OFPR_ACTION_SET: + case OFPR_GROUP: + case OFPR_PACKET_OUT: + return version < OFP14_VERSION ? OFPR_ACTION : reason; + + case OFPR_EXPLICIT_MISS: + return version < OFP13_VERSION ? OFPR_ACTION : OFPR_NO_MATCH; + + case OFPR_IMPLICIT_MISS: + return OFPR_NO_MATCH; + + case OFPR_N_REASONS: + default: + OVS_NOT_REACHED(); + } +} + +/* Only NXT_PACKET_IN2 (not NXT_RESUME) should include NXCPT_USERDATA, so this + * function omits it. The caller can add it itself if desired. */ static void -ofputil_packet_in_to_match(const struct ofputil_packet_in *pin, - struct match *match) +ofputil_put_packet_in(const struct ofputil_packet_in *pin, + enum ofp_version version, uint32_t buffer_id, + size_t include_bytes, struct ofpbuf *msg) { - int i; + /* Add packet properties. */ + ofpprop_put(msg, NXPINT_PACKET, pin->packet, include_bytes); + if (include_bytes != pin->packet_len) { + ofpprop_put_u32(msg, NXPINT_FULL_LEN, pin->packet_len); + } + if (buffer_id != UINT32_MAX) { + ofpprop_put_u32(msg, NXPINT_BUFFER_ID, buffer_id); + } - match_init_catchall(match); - if (pin->fmd.tun_id != htonll(0)) { - match_set_tun_id(match, pin->fmd.tun_id); + /* Add flow properties. */ + ofpprop_put_u8(msg, NXPINT_TABLE_ID, pin->table_id); + if (pin->cookie != OVS_BE64_MAX) { + ofpprop_put_be64(msg, NXPINT_COOKIE, pin->cookie); + } + + /* Add other properties. */ + ofpprop_put_u8(msg, NXPINT_REASON, + encode_packet_in_reason(pin->reason, version)); + + size_t start = ofpprop_start(msg, NXPINT_METADATA); + oxm_put_raw(msg, &pin->flow_metadata, version); + ofpprop_end(msg, start); +} + +static void +put_actions_property(struct ofpbuf *msg, uint64_t prop_type, + enum ofp_version version, + const struct ofpact *actions, size_t actions_len) +{ + if (actions_len) { + size_t start = ofpprop_start_nested(msg, prop_type); + ofpacts_put_openflow_actions(actions, actions_len, msg, version); + ofpprop_end(msg, start); + } +} + +enum nx_continuation_prop_type { + NXCPT_BRIDGE = 0x8000, + NXCPT_STACK, + NXCPT_MIRRORS, + NXCPT_CONNTRACKED, + NXCPT_TABLE_ID, + NXCPT_COOKIE, + NXCPT_ACTIONS, + NXCPT_ACTION_SET, +}; + +/* Only NXT_PACKET_IN2 (not NXT_RESUME) should include NXCPT_USERDATA, so this + * function omits it. The caller can add it itself if desired. */ +static void +ofputil_put_packet_in_private(const struct ofputil_packet_in_private *pin, + enum ofp_version version, uint32_t buffer_id, + size_t include_bytes, struct ofpbuf *msg) +{ + ofputil_put_packet_in(&pin->public, version, buffer_id, + include_bytes, msg); + + size_t continuation_ofs = ofpprop_start_nested(msg, NXPINT_CONTINUATION); + size_t inner_ofs = msg->size; + + if (!uuid_is_zero(&pin->bridge)) { + ofpprop_put_uuid(msg, NXCPT_BRIDGE, &pin->bridge); } - if (pin->fmd.tun_src != htonl(0)) { - match_set_tun_src(match, pin->fmd.tun_src); + + for (size_t i = 0; i < pin->n_stack; i++) { + const union mf_subvalue *s = &pin->stack[i]; + size_t ofs; + for (ofs = 0; ofs < sizeof *s; ofs++) { + if (s->u8[ofs]) { + break; + } + } + + ofpprop_put(msg, NXCPT_STACK, &s->u8[ofs], sizeof *s - ofs); } - if (pin->fmd.tun_dst != htonl(0)) { - match_set_tun_dst(match, pin->fmd.tun_dst); + + if (pin->mirrors) { + ofpprop_put_u32(msg, NXCPT_MIRRORS, pin->mirrors); } - if (pin->fmd.metadata != htonll(0)) { - match_set_metadata(match, pin->fmd.metadata); + + if (pin->conntracked) { + ofpprop_put_flag(msg, NXCPT_CONNTRACKED); } - for (i = 0; i < FLOW_N_REGS; i++) { - if (pin->fmd.regs[i]) { - match_set_reg(match, i, pin->fmd.regs[i]); + if (pin->actions_len) { + /* Divide 'pin->actions' into groups that begins with an + * unroll_xlate action. For each group, emit a NXCPT_TABLE_ID and + * NXCPT_COOKIE property (if either has changed; each is initially + * assumed 0), then a NXCPT_ACTIONS property with the grouped + * actions. + * + * The alternative is to make OFPACT_UNROLL_XLATE public. We can + * always do that later, since this is a private property. */ + const struct ofpact *const end = ofpact_end(pin->actions, + pin->actions_len); + const struct ofpact_unroll_xlate *unroll = NULL; + uint8_t table_id = 0; + ovs_be64 cookie = 0; + + const struct ofpact *a; + for (a = pin->actions; ; a = ofpact_next(a)) { + if (a == end || a->type == OFPACT_UNROLL_XLATE) { + if (unroll) { + if (table_id != unroll->rule_table_id) { + ofpprop_put_u8(msg, NXCPT_TABLE_ID, + unroll->rule_table_id); + table_id = unroll->rule_table_id; + } + if (cookie != unroll->rule_cookie) { + ofpprop_put_be64(msg, NXCPT_COOKIE, + unroll->rule_cookie); + cookie = unroll->rule_cookie; + } + } + + const struct ofpact *start + = unroll ? ofpact_next(&unroll->ofpact) : pin->actions; + put_actions_property(msg, NXCPT_ACTIONS, version, + start, (a - start) * sizeof *a); + + if (a == end) { + break; + } + unroll = ofpact_get_UNROLL_XLATE(a); + } } } - if (pin->fmd.pkt_mark != 0) { - match_set_pkt_mark(match, pin->fmd.pkt_mark); + if (pin->action_set_len) { + size_t start = ofpprop_start_nested(msg, NXCPT_ACTION_SET); + ofpacts_put_openflow_actions(pin->action_set, + pin->action_set_len, msg, version); + ofpprop_end(msg, start); } - match_set_in_port(match, pin->fmd.in_port); + if (msg->size > inner_ofs) { + ofpprop_end(msg, continuation_ofs); + } else { + msg->size = continuation_ofs; + } } static struct ofpbuf * -ofputil_encode_ofp10_packet_in(const struct ofputil_packet_in *pin) +ofputil_encode_ofp10_packet_in(const struct ofputil_packet_in *pin, + uint32_t buffer_id) { struct ofp10_packet_in *opi; - struct ofpbuf *packet; - - packet = ofpraw_alloc_xid(OFPRAW_OFPT10_PACKET_IN, OFP10_VERSION, - htonl(0), pin->packet_len); - opi = ofpbuf_put_zeros(packet, offsetof(struct ofp10_packet_in, data)); - opi->total_len = htons(pin->total_len); - opi->in_port = htons(ofp_to_u16(pin->fmd.in_port)); - opi->reason = pin->reason; - opi->buffer_id = htonl(pin->buffer_id); + struct ofpbuf *msg; - ofpbuf_put(packet, pin->packet, pin->packet_len); + msg = ofpraw_alloc_xid(OFPRAW_OFPT10_PACKET_IN, OFP10_VERSION, + htonl(0), pin->packet_len); + opi = ofpbuf_put_zeros(msg, offsetof(struct ofp10_packet_in, data)); + opi->total_len = htons(pin->packet_len); + opi->in_port = htons(ofp_to_u16(pin->flow_metadata.flow.in_port.ofp_port)); + opi->reason = encode_packet_in_reason(pin->reason, OFP10_VERSION); + opi->buffer_id = htonl(buffer_id); - return packet; + return msg; } static struct ofpbuf * -ofputil_encode_nx_packet_in(const struct ofputil_packet_in *pin) +ofputil_encode_nx_packet_in(const struct ofputil_packet_in *pin, + enum ofp_version version, uint32_t buffer_id) { struct nx_packet_in *npi; - struct ofpbuf *packet; - struct match match; + struct ofpbuf *msg; size_t match_len; - ofputil_packet_in_to_match(pin, &match); - /* The final argument is just an estimate of the space required. */ - packet = ofpraw_alloc_xid(OFPRAW_NXT_PACKET_IN, OFP10_VERSION, - htonl(0), (sizeof(struct flow_metadata) * 2 - + 2 + pin->packet_len)); - ofpbuf_put_zeros(packet, sizeof *npi); - match_len = nx_put_match(packet, &match, 0, 0); - ofpbuf_put_zeros(packet, 2); - ofpbuf_put(packet, pin->packet, pin->packet_len); - - npi = ofpbuf_l3(packet); - npi->buffer_id = htonl(pin->buffer_id); - npi->total_len = htons(pin->total_len); - npi->reason = pin->reason; + msg = ofpraw_alloc_xid(OFPRAW_NXT_PACKET_IN, version, + htonl(0), NXM_TYPICAL_LEN + 2 + pin->packet_len); + ofpbuf_put_zeros(msg, sizeof *npi); + match_len = nx_put_match(msg, &pin->flow_metadata, 0, 0); + ofpbuf_put_zeros(msg, 2); + + npi = msg->msg; + npi->buffer_id = htonl(buffer_id); + npi->total_len = htons(pin->packet_len); + npi->reason = encode_packet_in_reason(pin->reason, version); npi->table_id = pin->table_id; npi->cookie = pin->cookie; npi->match_len = htons(match_len); - return packet; + return msg; +} + +static struct ofpbuf * +ofputil_encode_nx_packet_in2(const struct ofputil_packet_in_private *pin, + enum ofp_version version, uint32_t buffer_id, + size_t include_bytes) +{ + /* 'extra' is just an estimate of the space required. */ + size_t extra = (pin->public.packet_len + + NXM_TYPICAL_LEN /* flow_metadata */ + + pin->n_stack * 16 + + pin->actions_len + + pin->action_set_len + + 256); /* fudge factor */ + struct ofpbuf *msg = ofpraw_alloc_xid(OFPRAW_NXT_PACKET_IN2, version, + htonl(0), extra); + + ofputil_put_packet_in_private(pin, version, buffer_id, include_bytes, msg); + if (pin->public.userdata_len) { + ofpprop_put(msg, NXPINT_USERDATA, pin->public.userdata, + pin->public.userdata_len); + } + + ofpmsg_update_length(msg); + return msg; } static struct ofpbuf * -ofputil_encode_ofp11_packet_in(const struct ofputil_packet_in *pin) +ofputil_encode_ofp11_packet_in(const struct ofputil_packet_in *pin, + uint32_t buffer_id) { struct ofp11_packet_in *opi; - struct ofpbuf *packet; + struct ofpbuf *msg; - packet = ofpraw_alloc_xid(OFPRAW_OFPT11_PACKET_IN, OFP11_VERSION, - htonl(0), pin->packet_len); - opi = ofpbuf_put_zeros(packet, sizeof *opi); - opi->buffer_id = htonl(pin->buffer_id); - opi->in_port = ofputil_port_to_ofp11(pin->fmd.in_port); + msg = ofpraw_alloc_xid(OFPRAW_OFPT11_PACKET_IN, OFP11_VERSION, + htonl(0), pin->packet_len); + opi = ofpbuf_put_zeros(msg, sizeof *opi); + opi->buffer_id = htonl(buffer_id); + opi->in_port = ofputil_port_to_ofp11( + pin->flow_metadata.flow.in_port.ofp_port); opi->in_phy_port = opi->in_port; - opi->total_len = htons(pin->total_len); - opi->reason = pin->reason; + opi->total_len = htons(pin->packet_len); + opi->reason = encode_packet_in_reason(pin->reason, OFP11_VERSION); opi->table_id = pin->table_id; - ofpbuf_put(packet, pin->packet, pin->packet_len); - - return packet; + return msg; } static struct ofpbuf * ofputil_encode_ofp12_packet_in(const struct ofputil_packet_in *pin, - enum ofputil_protocol protocol) -{ - struct ofp13_packet_in *opi; - struct match match; - enum ofpraw packet_in_raw; - enum ofp_version packet_in_version; - size_t packet_in_size; - struct ofpbuf *packet; - - 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); + enum ofp_version version, + uint32_t buffer_id) +{ + enum ofpraw raw = (version >= OFP13_VERSION + ? OFPRAW_OFPT13_PACKET_IN + : OFPRAW_OFPT12_PACKET_IN); + struct ofpbuf *msg; /* The final argument is just an estimate of the space required. */ - packet = ofpraw_alloc_xid(packet_in_raw, packet_in_version, - htonl(0), (sizeof(struct flow_metadata) * 2 - + 2 + pin->packet_len)); - ofpbuf_put_zeros(packet, packet_in_size); - oxm_put_match(packet, &match, ofputil_protocol_to_ofp_version(protocol)); - ofpbuf_put_zeros(packet, 2); - ofpbuf_put(packet, pin->packet, pin->packet_len); + msg = ofpraw_alloc_xid(raw, version, + htonl(0), NXM_TYPICAL_LEN + 2 + pin->packet_len); + + struct ofp12_packet_in *opi = ofpbuf_put_zeros(msg, sizeof *opi); + opi->buffer_id = htonl(buffer_id); + opi->total_len = htons(pin->packet_len); + opi->reason = encode_packet_in_reason(pin->reason, version); + opi->table_id = pin->table_id; - opi = ofpbuf_l3(packet); - 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; + if (version >= OFP13_VERSION) { + ovs_be64 cookie = pin->cookie; + ofpbuf_put(msg, &cookie, sizeof cookie); } - return packet; + oxm_put_match(msg, &pin->flow_metadata, version); + ofpbuf_put_zeros(msg, 2); + + return msg; } -/* Converts abstract ofputil_packet_in 'pin' into a PACKET_IN message - * in the format specified by 'packet_in_format'. */ +/* Converts abstract ofputil_packet_in_private 'pin' into a PACKET_IN message + * for 'protocol', using the packet-in format specified by 'packet_in_format'. + * + * If 'pkt_buf' is nonnull and 'max_len' allows the packet to be buffered, this + * function will attempt to obtain a buffer ID from 'pktbuf' and truncate the + * packet to 'max_len' bytes. Otherwise, or if 'pktbuf' doesn't have a free + * buffer, it will send the whole packet without buffering. + * + * This function is really meant only for use by ovs-vswitchd. To any other + * code, the "continuation" data, i.e. the data that is in struct + * ofputil_packet_in_private but not in struct ofputil_packet_in, is supposed + * to be opaque (and it might change from one OVS version to another). Thus, + * if any other code wants to encode a packet-in, it should use a non-"private" + * version of this function. (Such a version doesn't currently exist because + * only ovs-vswitchd currently wants to encode packet-ins. If you need one, + * write it...) */ struct ofpbuf * -ofputil_encode_packet_in(const struct ofputil_packet_in *pin, - enum ofputil_protocol protocol, - enum nx_packet_in_format packet_in_format) +ofputil_encode_packet_in_private(const struct ofputil_packet_in_private *pin, + enum ofputil_protocol protocol, + enum nx_packet_in_format packet_in_format, + uint16_t max_len, struct pktbuf *pktbuf) { - struct ofpbuf *packet; + enum ofp_version version = ofputil_protocol_to_ofp_version(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: - packet = (packet_in_format == NXPIF_NXM - ? ofputil_encode_nx_packet_in(pin) - : ofputil_encode_ofp10_packet_in(pin)); - break; + /* Get buffer ID. */ + ofp_port_t in_port = pin->public.flow_metadata.flow.in_port.ofp_port; + uint32_t buffer_id = (max_len != OFPCML12_NO_BUFFER && pktbuf + ? pktbuf_save(pktbuf, pin->public.packet, + pin->public.packet_len, in_port) + : UINT32_MAX); - case OFPUTIL_P_OF11_STD: - packet = ofputil_encode_ofp11_packet_in(pin); + /* Calculate the number of bytes of the packet to include in the + * packet-in: + * + * - If not buffered, the whole thing. + * + * - Otherwise, no more than 'max_len' bytes. */ + size_t include_bytes = (buffer_id == UINT32_MAX + ? pin->public.packet_len + : MIN(max_len, pin->public.packet_len)); + + struct ofpbuf *msg; + switch (packet_in_format) { + case NXPIF_STANDARD: + switch (protocol) { + case OFPUTIL_P_OF10_STD: + case OFPUTIL_P_OF10_STD_TID: + case OFPUTIL_P_OF10_NXM: + case OFPUTIL_P_OF10_NXM_TID: + msg = ofputil_encode_ofp10_packet_in(&pin->public, buffer_id); + break; + + case OFPUTIL_P_OF11_STD: + msg = ofputil_encode_ofp11_packet_in(&pin->public, buffer_id); + break; + + case OFPUTIL_P_OF12_OXM: + case OFPUTIL_P_OF13_OXM: + case OFPUTIL_P_OF14_OXM: + case OFPUTIL_P_OF15_OXM: + msg = ofputil_encode_ofp12_packet_in(&pin->public, version, buffer_id); + break; + + default: + OVS_NOT_REACHED(); + } break; - case OFPUTIL_P_OF12_OXM: - case OFPUTIL_P_OF13_OXM: - case OFPUTIL_P_OF14_OXM: - case OFPUTIL_P_OF15_OXM: - packet = ofputil_encode_ofp12_packet_in(pin, protocol); + case NXPIF_NXT_PACKET_IN: + msg = ofputil_encode_nx_packet_in(&pin->public, version, buffer_id); break; + case NXPIF_NXT_PACKET_IN2: + return ofputil_encode_nx_packet_in2(pin, version, buffer_id, + include_bytes); + default: OVS_NOT_REACHED(); } - ofpmsg_update_length(packet); - return packet; + ofpbuf_put(msg, pin->public.packet, include_bytes); + ofpmsg_update_length(msg); + return msg; } /* Returns a string form of 'reason'. The return value is either a statically @@ -3605,6 +3929,15 @@ ofputil_packet_in_reason_to_string(enum ofp_packet_in_reason reason, return "action"; case OFPR_INVALID_TTL: return "invalid_ttl"; + case OFPR_ACTION_SET: + return "action_set"; + case OFPR_GROUP: + return "group"; + case OFPR_PACKET_OUT: + return "packet_out"; + case OFPR_EXPLICIT_MISS: + case OFPR_IMPLICIT_MISS: + return ""; case OFPR_N_REASONS: default: @@ -3633,6 +3966,171 @@ ofputil_packet_in_reason_from_string(const char *s, return false; } +/* Returns a newly allocated NXT_RESUME message for 'pin', with the given + * 'continuation', for 'protocol'. This message is suitable for resuming the + * pipeline traveral of the packet represented by 'pin', if sent to the switch + * from which 'pin' was received. */ +struct ofpbuf * +ofputil_encode_resume(const struct ofputil_packet_in *pin, + const struct ofpbuf *continuation, + enum ofputil_protocol protocol) +{ + enum ofp_version version = ofputil_protocol_to_ofp_version(protocol); + size_t extra = pin->packet_len + NXM_TYPICAL_LEN + continuation->size; + struct ofpbuf *msg = ofpraw_alloc_xid(OFPRAW_NXT_RESUME, version, + 0, extra); + ofputil_put_packet_in(pin, version, UINT32_MAX, pin->packet_len, msg); + ofpprop_put_nested(msg, NXPINT_CONTINUATION, continuation); + ofpmsg_update_length(msg); + return msg; +} + +static enum ofperr +parse_subvalue_prop(const struct ofpbuf *property, union mf_subvalue *sv) +{ + unsigned int len = ofpbuf_msgsize(property); + if (len > sizeof *sv) { + VLOG_WARN_RL(&bad_ofmsg_rl, "NXCPT_STACK property has bad length %u", + len); + return OFPERR_OFPBPC_BAD_LEN; + } + memset(sv, 0, sizeof *sv); + memcpy(&sv->u8[sizeof *sv - len], property->msg, len); + return 0; +} + +static enum ofperr +parse_actions_property(struct ofpbuf *property, enum ofp_version version, + struct ofpbuf *ofpacts) +{ + if (!ofpbuf_try_pull(property, ROUND_UP(ofpbuf_headersize(property), 8))) { + VLOG_WARN_RL(&bad_ofmsg_rl, "actions property has bad length %"PRIu32, + property->size); + return OFPERR_OFPBPC_BAD_LEN; + } + + return ofpacts_pull_openflow_actions(property, property->size, + version, ofpacts); +} + +/* This is like ofputil_decode_packet_in(), except that it decodes the + * continuation data into 'pin'. The format of this data is supposed to be + * opaque to any process other than ovs-vswitchd, so this function should not + * be used outside ovs-vswitchd. + * + * When successful, 'pin' contains some dynamically allocated data. Call + * ofputil_packet_in_private_destroy() to free this data. */ +enum ofperr +ofputil_decode_packet_in_private(const struct ofp_header *oh, bool loose, + struct ofputil_packet_in_private *pin, + size_t *total_len, uint32_t *buffer_id) +{ + memset(pin, 0, sizeof *pin); + + struct ofpbuf continuation; + enum ofperr error; + error = ofputil_decode_packet_in(oh, loose, &pin->public, total_len, + buffer_id, &continuation); + if (error) { + return error; + } + + struct ofpbuf actions, action_set; + ofpbuf_init(&actions, 0); + ofpbuf_init(&action_set, 0); + + uint8_t table_id = 0; + ovs_be64 cookie = 0; + + size_t allocated_stack = 0; + + while (continuation.size > 0) { + struct ofpbuf payload; + uint64_t type; + + error = ofpprop_pull(&continuation, &payload, &type); + ovs_assert(!error); + + switch (type) { + case NXCPT_BRIDGE: + error = ofpprop_parse_uuid(&payload, &pin->bridge); + break; + + case NXCPT_STACK: + if (pin->n_stack >= allocated_stack) { + pin->stack = x2nrealloc(pin->stack, &allocated_stack, + sizeof *pin->stack); + } + error = parse_subvalue_prop(&payload, + &pin->stack[pin->n_stack++]); + break; + + case NXCPT_MIRRORS: + error = ofpprop_parse_u32(&payload, &pin->mirrors); + break; + + case NXCPT_CONNTRACKED: + pin->conntracked = true; + break; + + case NXCPT_TABLE_ID: + error = ofpprop_parse_u8(&payload, &table_id); + break; + + case NXCPT_COOKIE: + error = ofpprop_parse_be64(&payload, &cookie); + break; + + case NXCPT_ACTIONS: { + struct ofpact_unroll_xlate *unroll + = ofpact_put_UNROLL_XLATE(&actions); + unroll->rule_table_id = table_id; + unroll->rule_cookie = cookie; + error = parse_actions_property(&payload, oh->version, &actions); + break; + } + + case NXCPT_ACTION_SET: + error = parse_actions_property(&payload, oh->version, &action_set); + break; + + default: + error = OFPPROP_UNKNOWN(loose, "continuation", type); + break; + } + if (error) { + break; + } + } + + pin->actions_len = actions.size; + pin->actions = ofpbuf_steal_data(&actions); + pin->action_set_len = action_set.size; + pin->action_set = ofpbuf_steal_data(&action_set); + + if (error) { + ofputil_packet_in_private_destroy(pin); + } + + return 0; +} + +/* Frees data in 'pin' that is dynamically allocated by + * ofputil_decode_packet_in_private(). + * + * 'pin->public' contains some pointer members that + * ofputil_decode_packet_in_private() doesn't initialize to newly allocated + * data, so this function doesn't free those. */ +void +ofputil_packet_in_private_destroy(struct ofputil_packet_in_private *pin) +{ + if (pin) { + free(pin->stack); + free(pin->actions); + free(pin->action_set); + } +} + /* Converts an OFPT_PACKET_OUT in 'opo' into an abstract ofputil_packet_out in * 'po'. * @@ -3646,12 +4144,10 @@ ofputil_decode_packet_out(struct ofputil_packet_out *po, const struct ofp_header *oh, struct ofpbuf *ofpacts) { - enum ofpraw raw; - struct ofpbuf b; - - ofpbuf_use_const(&b, oh, ntohs(oh->length)); - raw = ofpraw_pull_assert(&b); + struct ofpbuf b = ofpbuf_const_initializer(oh, ntohs(oh->length)); + enum ofpraw raw = ofpraw_pull_assert(&b); + ofpbuf_clear(ofpacts); if (raw == OFPRAW_OFPT11_PACKET_OUT) { enum ofperr error; const struct ofp11_packet_out *opo = ofpbuf_pull(&b, sizeof *opo); @@ -3691,12 +4187,12 @@ ofputil_decode_packet_out(struct ofputil_packet_out *po, return OFPERR_OFPBRC_BAD_PORT; } - po->ofpacts = ofpbuf_data(ofpacts); - po->ofpacts_len = ofpbuf_size(ofpacts); + po->ofpacts = ofpacts->data; + po->ofpacts_len = ofpacts->size; if (po->buffer_id == UINT32_MAX) { - po->packet = ofpbuf_data(&b); - po->packet_len = ofpbuf_size(&b); + po->packet = b.data; + po->packet_len = b.size; } else { po->packet = NULL; po->packet_len = 0; @@ -3770,7 +4266,7 @@ ofputil_decode_ofp10_phy_port(struct ofputil_phy_port *pp, const struct ofp10_phy_port *opp) { pp->port_no = u16_to_ofp(ntohs(opp->port_no)); - memcpy(pp->hw_addr, opp->hw_addr, OFP_ETH_ALEN); + pp->hw_addr = opp->hw_addr; ovs_strlcpy(pp->name, opp->name, OFP_MAX_PORT_NAME_LEN); pp->config = ntohl(opp->config) & OFPPC10_ALL; @@ -3797,7 +4293,7 @@ ofputil_decode_ofp11_port(struct ofputil_phy_port *pp, if (error) { return error; } - memcpy(pp->hw_addr, op->hw_addr, OFP_ETH_ALEN); + pp->hw_addr = op->hw_addr; ovs_strlcpy(pp->name, op->name, OFP_MAX_PORT_NAME_LEN); pp->config = ntohl(op->config) & OFPPC11_ALL; @@ -3818,9 +4314,9 @@ static enum ofperr parse_ofp14_port_ethernet_property(const struct ofpbuf *payload, struct ofputil_phy_port *pp) { - struct ofp14_port_desc_prop_ethernet *eth = ofpbuf_data(payload); + struct ofp14_port_desc_prop_ethernet *eth = payload->data; - if (ofpbuf_size(payload) != sizeof *eth) { + if (payload->size != sizeof *eth) { return OFPERR_OFPBPC_BAD_LEN; } @@ -3838,39 +4334,35 @@ parse_ofp14_port_ethernet_property(const struct ofpbuf *payload, static enum ofperr ofputil_pull_ofp14_port(struct ofputil_phy_port *pp, struct ofpbuf *msg) { - struct ofpbuf properties; - struct ofp14_port *op; - enum ofperr error; - size_t len; - - op = ofpbuf_try_pull(msg, sizeof *op); + struct ofp14_port *op = ofpbuf_try_pull(msg, sizeof *op); if (!op) { return OFPERR_OFPBRC_BAD_LEN; } - len = ntohs(op->length); - if (len < sizeof *op || len - sizeof *op > ofpbuf_size(msg)) { + size_t len = ntohs(op->length); + if (len < sizeof *op || len - sizeof *op > msg->size) { return OFPERR_OFPBRC_BAD_LEN; } len -= sizeof *op; - ofpbuf_use_const(&properties, ofpbuf_pull(msg, len), len); - error = ofputil_port_from_ofp11(op->port_no, &pp->port_no); + enum ofperr error = ofputil_port_from_ofp11(op->port_no, &pp->port_no); if (error) { return error; } - memcpy(pp->hw_addr, op->hw_addr, OFP_ETH_ALEN); + pp->hw_addr = op->hw_addr; ovs_strlcpy(pp->name, op->name, OFP_MAX_PORT_NAME_LEN); pp->config = ntohl(op->config) & OFPPC11_ALL; pp->state = ntohl(op->state) & OFPPS11_ALL; - while (ofpbuf_size(&properties) > 0) { + struct ofpbuf properties = ofpbuf_const_initializer(ofpbuf_pull(msg, len), + len); + while (properties.size > 0) { struct ofpbuf payload; enum ofperr error; - uint16_t type; + uint64_t type; - error = ofputil_pull_property(&properties, &payload, &type); + error = ofpprop_pull(&properties, &payload, &type); if (error) { return error; } @@ -3881,8 +4373,7 @@ ofputil_pull_ofp14_port(struct ofputil_phy_port *pp, struct ofpbuf *msg) break; default: - log_property(true, "unknown port property %"PRIu16, type); - error = 0; + error = OFPPROP_UNKNOWN(true, "port", type); break; } @@ -3901,7 +4392,7 @@ ofputil_encode_ofp10_phy_port(const struct ofputil_phy_port *pp, memset(opp, 0, sizeof *opp); opp->port_no = htons(ofp_to_u16(pp->port_no)); - memcpy(opp->hw_addr, pp->hw_addr, ETH_ADDR_LEN); + opp->hw_addr = pp->hw_addr; ovs_strlcpy(opp->name, pp->name, OFP_MAX_PORT_NAME_LEN); opp->config = htonl(pp->config & OFPPC10_ALL); @@ -3920,7 +4411,7 @@ ofputil_encode_ofp11_port(const struct ofputil_phy_port *pp, memset(op, 0, sizeof *op); op->port_no = ofputil_port_to_ofp11(pp->port_no); - memcpy(op->hw_addr, pp->hw_addr, ETH_ADDR_LEN); + op->hw_addr = pp->hw_addr; ovs_strlcpy(op->name, pp->name, OFP_MAX_PORT_NAME_LEN); op->config = htonl(pp->config & OFPPC11_ALL); @@ -3947,14 +4438,12 @@ ofputil_put_ofp14_port(const struct ofputil_phy_port *pp, op = ofpbuf_put_zeros(b, sizeof *op); op->port_no = ofputil_port_to_ofp11(pp->port_no); op->length = htons(sizeof *op + sizeof *eth); - memcpy(op->hw_addr, pp->hw_addr, ETH_ADDR_LEN); + op->hw_addr = pp->hw_addr; ovs_strlcpy(op->name, pp->name, sizeof op->name); op->config = htonl(pp->config & OFPPC11_ALL); op->state = htonl(pp->state & OFPPS11_ALL); - eth = ofpbuf_put_zeros(b, sizeof *eth); - eth->type = htons(OFPPDPT14_ETHERNET); - eth->length = htons(sizeof *eth); + eth = ofpprop_put_zeros(b, OFPPDPT14_ETHERNET, sizeof *eth); eth->curr = netdev_port_features_to_ofp11(pp->curr); eth->advertised = netdev_port_features_to_ofp11(pp->advertised); eth->supported = netdev_port_features_to_ofp11(pp->supported); @@ -3996,11 +4485,9 @@ enum ofperr ofputil_decode_port_desc_stats_request(const struct ofp_header *request, ofp_port_t *port) { - struct ofpbuf b; - enum ofpraw raw; - - ofpbuf_use_const(&b, request, ntohs(request->length)); - raw = ofpraw_pull_assert(&b); + struct ofpbuf b = ofpbuf_const_initializer(request, + ntohs(request->length)); + enum ofpraw raw = ofpraw_pull_assert(&b); if (raw == OFPRAW_OFPST10_PORT_DESC_REQUEST) { *port = OFPP_ANY; return 0; @@ -4019,7 +4506,6 @@ ofputil_encode_port_desc_stats_request(enum ofp_version ofp_version, ofp_port_t port) { struct ofpbuf *request; - ovs_be32 ofp11_port; switch (ofp_version) { case OFP10_VERSION: @@ -4030,14 +4516,14 @@ ofputil_encode_port_desc_stats_request(enum ofp_version ofp_version, request = ofpraw_alloc(OFPRAW_OFPST10_PORT_DESC_REQUEST, ofp_version, 0); break; - - case OFP15_VERSION: + case OFP15_VERSION:{ + struct ofp15_port_desc_request *req; request = ofpraw_alloc(OFPRAW_OFPST15_PORT_DESC_REQUEST, ofp_version, 0); - ofp11_port = ofputil_port_to_ofp11(port); - ofpbuf_put(request, &ofp11_port, sizeof ofp11_port); + req = ofpbuf_put_zeros(request, sizeof *req); + req->port_no = ofputil_port_to_ofp11(port); break; - + } default: OVS_NOT_REACHED(); } @@ -4047,15 +4533,90 @@ ofputil_encode_port_desc_stats_request(enum ofp_version ofp_version, void ofputil_append_port_desc_stats_reply(const struct ofputil_phy_port *pp, - struct list *replies) + struct ovs_list *replies) { struct ofpbuf *reply = ofpbuf_from_list(list_back(replies)); - size_t start_ofs = ofpbuf_size(reply); + size_t start_ofs = reply->size; ofputil_put_phy_port(ofpmp_version(replies), pp, reply); ofpmp_postappend(replies, start_ofs); } +/* ofputil_switch_config */ + +/* Decodes 'oh', which must be an OFPT_GET_CONFIG_REPLY or OFPT_SET_CONFIG + * message, into 'config'. Returns false if 'oh' contained any flags that + * aren't specified in its version of OpenFlow, true otherwise. */ +static bool +ofputil_decode_switch_config(const struct ofp_header *oh, + struct ofputil_switch_config *config) +{ + struct ofpbuf b = ofpbuf_const_initializer(oh, ntohs(oh->length)); + ofpraw_pull_assert(&b); + + const struct ofp_switch_config *osc = ofpbuf_pull(&b, sizeof *osc); + config->frag = ntohs(osc->flags) & OFPC_FRAG_MASK; + config->miss_send_len = ntohs(osc->miss_send_len); + + ovs_be16 valid_mask = htons(OFPC_FRAG_MASK); + if (oh->version < OFP13_VERSION) { + const ovs_be16 ttl_bit = htons(OFPC_INVALID_TTL_TO_CONTROLLER); + valid_mask |= ttl_bit; + config->invalid_ttl_to_controller = (osc->flags & ttl_bit) != 0; + } else { + config->invalid_ttl_to_controller = -1; + } + + return !(osc->flags & ~valid_mask); +} + +void +ofputil_decode_get_config_reply(const struct ofp_header *oh, + struct ofputil_switch_config *config) +{ + ofputil_decode_switch_config(oh, config); +} + +enum ofperr +ofputil_decode_set_config(const struct ofp_header *oh, + struct ofputil_switch_config *config) +{ + return (ofputil_decode_switch_config(oh, config) + ? 0 + : OFPERR_OFPSCFC_BAD_FLAGS); +} + +static struct ofpbuf * +ofputil_put_switch_config(const struct ofputil_switch_config *config, + struct ofpbuf *b) +{ + const struct ofp_header *oh = b->data; + struct ofp_switch_config *osc = ofpbuf_put_zeros(b, sizeof *osc); + osc->flags = htons(config->frag); + if (config->invalid_ttl_to_controller > 0 && oh->version < OFP13_VERSION) { + osc->flags |= htons(OFPC_INVALID_TTL_TO_CONTROLLER); + } + osc->miss_send_len = htons(config->miss_send_len); + return b; +} + +struct ofpbuf * +ofputil_encode_get_config_reply(const struct ofp_header *request, + const struct ofputil_switch_config *config) +{ + struct ofpbuf *b = ofpraw_alloc_reply(OFPRAW_OFPT_GET_CONFIG_REPLY, + request, 0); + return ofputil_put_switch_config(config, b); +} + +struct ofpbuf * +ofputil_encode_set_config(const struct ofputil_switch_config *config, + enum ofp_version version) +{ + struct ofpbuf *b = ofpraw_alloc(OFPRAW_OFPT_SET_CONFIG, version, 0); + return ofputil_put_switch_config(config, b); +} + /* ofputil_switch_features */ #define OFPC_COMMON (OFPC_FLOW_STATS | OFPC_TABLE_STATS | OFPC_PORT_STATS | \ @@ -4070,7 +4631,7 @@ BUILD_ASSERT_DECL((int) OFPUTIL_C_ARP_MATCH_IP == OFPC_ARP_MATCH_IP); static uint32_t ofputil_capabilities_mask(enum ofp_version ofp_version) { - /* Handle capabilities whose bit is unique for all Open Flow versions */ + /* Handle capabilities whose bit is unique for all OpenFlow versions */ switch (ofp_version) { case OFP10_VERSION: case OFP11_VERSION: @@ -4086,23 +4647,18 @@ ofputil_capabilities_mask(enum ofp_version ofp_version) } } -/* Decodes an OpenFlow 1.0 or 1.1 "switch_features" structure 'osf' into an - * abstract representation in '*features'. Initializes '*b' to iterate over - * the OpenFlow port structures following 'osf' with later calls to - * ofputil_pull_phy_port(). Returns 0 if successful, otherwise an - * OFPERR_* value. */ +/* Pulls an OpenFlow "switch_features" structure from 'b' and decodes it into + * an abstract representation in '*features', readying 'b' to iterate over the + * OpenFlow port structures following 'osf' with later calls to + * ofputil_pull_phy_port(). Returns 0 if successful, otherwise an OFPERR_* + * value. */ enum ofperr -ofputil_decode_switch_features(const struct ofp_header *oh, - struct ofputil_switch_features *features, - struct ofpbuf *b) +ofputil_pull_switch_features(struct ofpbuf *b, + struct ofputil_switch_features *features) { - const struct ofp_switch_features *osf; - enum ofpraw raw; - - ofpbuf_use_const(b, oh, ntohs(oh->length)); - raw = ofpraw_pull_assert(b); - - osf = ofpbuf_pull(b, sizeof *osf); + const struct ofp_header *oh = b->data; + enum ofpraw raw = ofpraw_pull_assert(b); + const struct ofp_switch_features *osf = ofpbuf_pull(b, sizeof *osf); features->datapath_id = ntohll(osf->datapath_id); features->n_buffers = ntohl(osf->n_buffers); features->n_tables = osf->n_tables; @@ -4148,7 +4704,7 @@ ofputil_decode_switch_features(const struct ofp_header *oh, bool ofputil_switch_features_has_ports(struct ofpbuf *b) { - struct ofp_header *oh = ofpbuf_data(b); + struct ofp_header *oh = b->data; size_t phy_port_size; if (oh->version >= OFP13_VERSION) { @@ -4168,7 +4724,7 @@ ofputil_switch_features_has_ports(struct ofpbuf *b) /* The feature reply has no room for more ports. Probably the list is * truncated. Drop the ports and tell the caller to retrieve them with * OFPST_PORT_DESC. */ - ofpbuf_set_size(b, sizeof *oh + sizeof(struct ofp_switch_features)); + b->size = sizeof *oh + sizeof(struct ofp_switch_features); ofpmsg_update_length(b); return false; } @@ -4245,16 +4801,16 @@ void ofputil_put_switch_features_port(const struct ofputil_phy_port *pp, struct ofpbuf *b) { - const struct ofp_header *oh = ofpbuf_data(b); + const struct ofp_header *oh = b->data; if (oh->version < OFP13_VERSION) { /* Try adding a port description to the message, but drop it again if * the buffer overflows. (This possibility for overflow is why * OpenFlow 1.3+ moved port descriptions into a multipart message.) */ - size_t start_ofs = ofpbuf_size(b); + size_t start_ofs = b->size; ofputil_put_phy_port(oh->version, pp, b); - if (ofpbuf_size(b) > UINT16_MAX) { - ofpbuf_set_size(b, start_ofs); + if (b->size > UINT16_MAX) { + b->size = start_ofs; } } } @@ -4267,14 +4823,10 @@ enum ofperr ofputil_decode_port_status(const struct ofp_header *oh, struct ofputil_port_status *ps) { - const struct ofp_port_status *ops; - struct ofpbuf b; - int retval; - - ofpbuf_use_const(&b, oh, ntohs(oh->length)); + struct ofpbuf b = ofpbuf_const_initializer(oh, ntohs(oh->length)); ofpraw_pull_assert(&b); - ops = ofpbuf_pull(&b, sizeof *ops); + const struct ofp_port_status *ops = ofpbuf_pull(&b, sizeof *ops); if (ops->reason != OFPPR_ADD && ops->reason != OFPPR_DELETE && ops->reason != OFPPR_MODIFY) { @@ -4282,7 +4834,7 @@ ofputil_decode_port_status(const struct ofp_header *oh, } ps->reason = ops->reason; - retval = ofputil_pull_phy_port(oh->version, &b, &ps->desc); + int retval = ofputil_pull_phy_port(oh->version, &b, &ps->desc); ovs_assert(retval != EOF); return retval; } @@ -4334,14 +4886,14 @@ static enum ofperr parse_port_mod_ethernet_property(struct ofpbuf *property, struct ofputil_port_mod *pm) { - struct ofp14_port_mod_prop_ethernet *eth = ofpbuf_data(property); + ovs_be32 advertise; + enum ofperr error; - if (ofpbuf_size(property) != sizeof *eth) { - return OFPERR_OFPBRC_BAD_LEN; + error = ofpprop_parse_be32(property, &advertise); + if (!error) { + pm->advertise = netdev_port_features_from_ofp11(advertise); } - - pm->advertise = netdev_port_features_from_ofp11(eth->advertise); - return 0; + return error; } /* Decodes the OpenFlow "port mod" message in '*oh' into an abstract form in @@ -4350,22 +4902,18 @@ enum ofperr ofputil_decode_port_mod(const struct ofp_header *oh, struct ofputil_port_mod *pm, bool loose) { - enum ofpraw raw; - struct ofpbuf b; - - ofpbuf_use_const(&b, oh, ntohs(oh->length)); - raw = ofpraw_pull_assert(&b); - + struct ofpbuf b = ofpbuf_const_initializer(oh, ntohs(oh->length)); + enum ofpraw raw = ofpraw_pull_assert(&b); if (raw == OFPRAW_OFPT10_PORT_MOD) { - const struct ofp10_port_mod *opm = ofpbuf_data(&b); + const struct ofp10_port_mod *opm = b.data; pm->port_no = u16_to_ofp(ntohs(opm->port_no)); - memcpy(pm->hw_addr, opm->hw_addr, ETH_ADDR_LEN); + pm->hw_addr = opm->hw_addr; pm->config = ntohl(opm->config) & OFPPC10_ALL; pm->mask = ntohl(opm->mask) & OFPPC10_ALL; pm->advertise = netdev_port_features_from_ofp10(opm->advertise); } else if (raw == OFPRAW_OFPT11_PORT_MOD) { - const struct ofp11_port_mod *opm = ofpbuf_data(&b); + const struct ofp11_port_mod *opm = b.data; enum ofperr error; error = ofputil_port_from_ofp11(opm->port_no, &pm->port_no); @@ -4373,7 +4921,7 @@ ofputil_decode_port_mod(const struct ofp_header *oh, return error; } - memcpy(pm->hw_addr, opm->hw_addr, ETH_ADDR_LEN); + pm->hw_addr = opm->hw_addr; pm->config = ntohl(opm->config) & OFPPC11_ALL; pm->mask = ntohl(opm->mask) & OFPPC11_ALL; pm->advertise = netdev_port_features_from_ofp11(opm->advertise); @@ -4388,16 +4936,16 @@ ofputil_decode_port_mod(const struct ofp_header *oh, return error; } - memcpy(pm->hw_addr, opm->hw_addr, ETH_ADDR_LEN); + pm->hw_addr = opm->hw_addr; pm->config = ntohl(opm->config) & OFPPC11_ALL; pm->mask = ntohl(opm->mask) & OFPPC11_ALL; - while (ofpbuf_size(&b) > 0) { + while (b.size > 0) { struct ofpbuf property; enum ofperr error; - uint16_t type; + uint64_t type; - error = ofputil_pull_property(&b, &property, &type); + error = ofpprop_pull(&b, &property, &type); if (error) { return error; } @@ -4408,14 +4956,7 @@ ofputil_decode_port_mod(const struct ofp_header *oh, break; default: - log_property(loose, "unknown port_mod property %"PRIu16, type); - if (loose) { - error = 0; - } else if (type == OFPPMPT14_EXPERIMENTER) { - error = OFPERR_OFPBPC_BAD_EXPERIMENTER; - } else { - error = OFPERR_OFPBRC_BAD_TYPE; - } + error = OFPPROP_UNKNOWN(loose, "port_mod", type); break; } @@ -4448,7 +4989,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(ofp_to_u16(pm->port_no)); - memcpy(opm->hw_addr, pm->hw_addr, ETH_ADDR_LEN); + opm->hw_addr = pm->hw_addr; opm->config = htonl(pm->config & OFPPC10_ALL); opm->mask = htonl(pm->mask & OFPPC10_ALL); opm->advertise = netdev_port_features_to_ofp10(pm->advertise); @@ -4463,7 +5004,7 @@ ofputil_encode_port_mod(const struct ofputil_port_mod *pm, b = ofpraw_alloc(OFPRAW_OFPT11_PORT_MOD, ofp_version, 0); opm = ofpbuf_put_zeros(b, sizeof *opm); opm->port_no = ofputil_port_to_ofp11(pm->port_no); - memcpy(opm->hw_addr, pm->hw_addr, ETH_ADDR_LEN); + opm->hw_addr = pm->hw_addr; opm->config = htonl(pm->config & OFPPC11_ALL); opm->mask = htonl(pm->mask & OFPPC11_ALL); opm->advertise = netdev_port_features_to_ofp11(pm->advertise); @@ -4471,21 +5012,18 @@ ofputil_encode_port_mod(const struct ofputil_port_mod *pm, } case OFP14_VERSION: case OFP15_VERSION: { - struct ofp14_port_mod_prop_ethernet *eth; struct ofp14_port_mod *opm; - b = ofpraw_alloc(OFPRAW_OFPT14_PORT_MOD, ofp_version, sizeof *eth); + b = ofpraw_alloc(OFPRAW_OFPT14_PORT_MOD, ofp_version, 0); opm = ofpbuf_put_zeros(b, sizeof *opm); opm->port_no = ofputil_port_to_ofp11(pm->port_no); - memcpy(opm->hw_addr, pm->hw_addr, ETH_ADDR_LEN); + opm->hw_addr = pm->hw_addr; opm->config = htonl(pm->config & OFPPC11_ALL); opm->mask = htonl(pm->mask & OFPPC11_ALL); if (pm->advertise) { - eth = ofpbuf_put_zeros(b, sizeof *eth); - eth->type = htons(OFPPMPT14_ETHERNET); - eth->length = htons(sizeof *eth); - eth->advertise = netdev_port_features_to_ofp11(pm->advertise); + ofpprop_put_be32(b, OFPPMPT14_ETHERNET, + netdev_port_features_to_ofp11(pm->advertise)); } break; } @@ -4500,13 +5038,13 @@ ofputil_encode_port_mod(const struct ofputil_port_mod *pm, static enum ofperr pull_table_feature_property(struct ofpbuf *msg, struct ofpbuf *payload, - uint16_t *typep) + uint64_t *typep) { enum ofperr error; - error = ofputil_pull_property(msg, payload, typep); + error = ofpprop_pull(msg, payload, typep); if (payload && !error) { - ofpbuf_pull(payload, sizeof(struct ofp_prop_header)); + ofpbuf_pull(payload, (char *)payload->msg - (char *)payload->header); } return error; } @@ -4517,11 +5055,11 @@ parse_action_bitmap(struct ofpbuf *payload, enum ofp_version ofp_version, { uint32_t types = 0; - while (ofpbuf_size(payload) > 0) { - uint16_t type; + while (payload->size > 0) { enum ofperr error; + uint64_t type; - error = ofputil_pull_property__(payload, NULL, 1, &type); + error = ofpprop_pull__(payload, NULL, 1, 0x10000, &type); if (error) { return error; } @@ -4538,10 +5076,10 @@ static enum ofperr parse_instruction_ids(struct ofpbuf *payload, bool loose, uint32_t *insts) { *insts = 0; - while (ofpbuf_size(payload) > 0) { + while (payload->size > 0) { enum ovs_instruction_type inst; enum ofperr error; - uint16_t ofpit; + uint64_t ofpit; /* OF1.3 and OF1.4 aren't clear about padding in the instruction IDs. * It seems clear that they aren't padded to 8 bytes, though, because @@ -4552,7 +5090,7 @@ parse_instruction_ids(struct ofpbuf *payload, bool loose, uint32_t *insts) * * Anyway, we just assume they're all glommed together on byte * boundaries. */ - error = ofputil_pull_property__(payload, NULL, 1, &ofpit); + error = ofpprop_pull__(payload, NULL, 1, 0x10000, &ofpit); if (error) { return error; } @@ -4574,8 +5112,8 @@ parse_table_features_next_table(struct ofpbuf *payload, size_t i; memset(next_tables, 0, bitmap_n_bytes(255)); - for (i = 0; i < ofpbuf_size(payload); i++) { - uint8_t id = ((const uint8_t *) ofpbuf_data(payload))[i]; + for (i = 0; i < payload->size; i++) { + uint8_t id = ((const uint8_t *) payload->data)[i]; if (id >= 255) { return OFPERR_OFPBPC_BAD_VALUE; } @@ -4591,7 +5129,7 @@ parse_oxms(struct ofpbuf *payload, bool loose, struct mf_bitmap exact = MF_BITMAP_INITIALIZER; struct mf_bitmap masked = MF_BITMAP_INITIALIZER; - while (ofpbuf_size(payload) > 0) { + while (payload->size > 0) { const struct mf_field *field; enum ofperr error; bool hasmask; @@ -4636,33 +5174,26 @@ int ofputil_decode_table_features(struct ofpbuf *msg, struct ofputil_table_features *tf, bool loose) { - const struct ofp_header *oh; - struct ofp13_table_features *otf; - struct ofpbuf properties; - unsigned int len; - memset(tf, 0, sizeof *tf); - if (!msg->frame) { + if (!msg->header) { ofpraw_pull_assert(msg); } - oh = ofpbuf_l2(msg); - if (!ofpbuf_size(msg)) { + if (!msg->size) { return EOF; } - if (ofpbuf_size(msg) < sizeof *otf) { + const struct ofp_header *oh = msg->header; + struct ofp13_table_features *otf = msg->data; + if (msg->size < sizeof *otf) { return OFPERR_OFPBPC_BAD_LEN; } - otf = ofpbuf_data(msg); - len = ntohs(otf->length); - if (len < sizeof *otf || len % 8 || len > ofpbuf_size(msg)) { + unsigned int len = ntohs(otf->length); + if (len < sizeof *otf || len % 8 || len > msg->size) { return OFPERR_OFPBPC_BAD_LEN; } - ofpbuf_use_const(&properties, ofpbuf_pull(msg, len), len); - ofpbuf_pull(&properties, sizeof *otf); tf->table_id = otf->table_id; if (tf->table_id == OFPTT_ALL) { @@ -4672,13 +5203,24 @@ ofputil_decode_table_features(struct ofpbuf *msg, ovs_strlcpy(tf->name, otf->name, OFP_MAX_TABLE_NAME_LEN); tf->metadata_match = otf->metadata_match; tf->metadata_write = otf->metadata_write; - tf->miss_config = ofputil_table_miss_from_config(otf->config, oh->version); + tf->miss_config = OFPUTIL_TABLE_MISS_DEFAULT; + if (oh->version >= OFP14_VERSION) { + uint32_t caps = ntohl(otf->capabilities); + tf->supports_eviction = (caps & OFPTC14_EVICTION) != 0; + tf->supports_vacancy_events = (caps & OFPTC14_VACANCY_EVENTS) != 0; + } else { + tf->supports_eviction = -1; + tf->supports_vacancy_events = -1; + } tf->max_entries = ntohl(otf->max_entries); - while (ofpbuf_size(&properties) > 0) { + struct ofpbuf properties = ofpbuf_const_initializer(ofpbuf_pull(msg, len), + len); + ofpbuf_pull(&properties, sizeof *otf); + while (properties.size > 0) { struct ofpbuf payload; enum ofperr error; - uint16_t type; + uint64_t type; error = pull_table_feature_property(&properties, &payload, &type); if (error) { @@ -4748,9 +5290,7 @@ ofputil_decode_table_features(struct ofpbuf *msg, case OFPTFPT13_EXPERIMENTER: case OFPTFPT13_EXPERIMENTER_MISS: default: - log_property(loose, "unknown table features property %"PRIu16, - type); - error = loose ? 0 : OFPERR_OFPBPC_BAD_TYPE; + error = OFPPROP_UNKNOWN(loose, "table features", type); break; } if (error) { @@ -4811,12 +5351,12 @@ put_fields_property(struct ofpbuf *reply, size_t start_ofs; int field; - start_ofs = start_property(reply, property); + start_ofs = ofpprop_start(reply, property); BITMAP_FOR_EACH_1 (field, MFF_N_IDS, fields->bm) { nx_put_header(reply, field, version, masks && bitmap_is_set(masks->bm, field)); } - end_property(reply, start_ofs); + ofpprop_end(reply, start_ofs); } static void @@ -4826,14 +5366,9 @@ put_table_action_features(struct ofpbuf *reply, enum ofp13_table_feature_prop_type set_fields_type, int miss_offset, enum ofp_version version) { - size_t start_ofs; - - start_ofs = start_property(reply, actions_type + miss_offset); - put_bitmap_properties(reply, - ntohl(ofpact_bitmap_to_openflow(taf->ofpacts, - version))); - end_property(reply, start_ofs); - + ofpprop_put_bitmap(reply, actions_type + miss_offset, + ntohl(ofpact_bitmap_to_openflow(taf->ofpacts, + version))); put_fields_property(reply, &taf->set_fields, NULL, set_fields_type + miss_offset, version); } @@ -4846,17 +5381,15 @@ put_table_instruction_features( size_t start_ofs; uint8_t table_id; - start_ofs = start_property(reply, OFPTFPT13_INSTRUCTIONS + miss_offset); - put_bitmap_properties(reply, - ntohl(ovsinst_bitmap_to_openflow(tif->instructions, - version))); - end_property(reply, start_ofs); + ofpprop_put_bitmap(reply, OFPTFPT13_INSTRUCTIONS + miss_offset, + ntohl(ovsinst_bitmap_to_openflow(tif->instructions, + version))); - start_ofs = start_property(reply, OFPTFPT13_NEXT_TABLES + miss_offset); + start_ofs = ofpprop_start(reply, OFPTFPT13_NEXT_TABLES + miss_offset); BITMAP_FOR_EACH_1 (table_id, 255, tif->next) { ofpbuf_put(reply, &table_id, 1); } - end_property(reply, start_ofs); + ofpprop_end(reply, start_ofs); put_table_action_features(reply, &tif->write, OFPTFPT13_WRITE_ACTIONS, @@ -4868,11 +5401,11 @@ put_table_instruction_features( void ofputil_append_table_features_reply(const struct ofputil_table_features *tf, - struct list *replies) + struct ovs_list *replies) { struct ofpbuf *reply = ofpbuf_from_list(list_back(replies)); enum ofp_version version = ofpmp_version(replies); - size_t start_ofs = ofpbuf_size(reply); + size_t start_ofs = reply->size; struct ofp13_table_features *otf; otf = ofpbuf_put_zeros(reply, sizeof *otf); @@ -4880,7 +5413,14 @@ ofputil_append_table_features_reply(const struct ofputil_table_features *tf, ovs_strlcpy(otf->name, tf->name, sizeof otf->name); otf->metadata_match = tf->metadata_match; otf->metadata_write = tf->metadata_write; - otf->config = ofputil_table_miss_to_config(tf->miss_config, version); + if (version >= OFP14_VERSION) { + if (tf->supports_eviction) { + otf->capabilities |= htonl(OFPTC14_EVICTION); + } + if (tf->supports_vacancy_events) { + otf->capabilities |= htonl(OFPTC14_VACANCY_EVENTS); + } + } otf->max_entries = htonl(tf->max_entries); put_table_instruction_features(reply, &tf->nonmiss, 0, version); @@ -4892,63 +5432,301 @@ ofputil_append_table_features_reply(const struct ofputil_table_features *tf, OFPTFPT13_WILDCARDS, version); otf = ofpbuf_at_assert(reply, start_ofs, sizeof *otf); - otf->length = htons(ofpbuf_size(reply) - start_ofs); + otf->length = htons(reply->size - start_ofs); ofpmp_postappend(replies, start_ofs); } -/* ofputil_table_mod */ +static enum ofperr +parse_table_desc_vacancy_property(struct ofpbuf *property, + struct ofputil_table_desc *td) +{ + struct ofp14_table_mod_prop_vacancy *otv = property->data; + + if (property->size != sizeof *otv) { + return OFPERR_OFPBPC_BAD_LEN; + } -/* Given 'config', taken from an OpenFlow 'version' message that specifies - * table configuration (a table mod, table stats, or table features message), - * returns the table miss configuration that it specifies. */ -static enum ofputil_table_miss -ofputil_table_miss_from_config(ovs_be32 config_, enum ofp_version version) + td->table_vacancy.vacancy_down = otv->vacancy_down; + td->table_vacancy.vacancy_up = otv->vacancy_up; + td->table_vacancy.vacancy = otv->vacancy; + return 0; +} + +/* Decodes the next OpenFlow "table desc" message (of possibly several) from + * 'msg' into an abstract form in '*td'. Returns 0 if successful, EOF if the + * last "table desc" in 'msg' was already decoded, otherwise an OFPERR_* + * value. */ +int +ofputil_decode_table_desc(struct ofpbuf *msg, + struct ofputil_table_desc *td, + enum ofp_version version) { - uint32_t config = ntohl(config_); + memset(td, 0, sizeof *td); - if (version < OFP13_VERSION) { - switch (config & OFPTC11_TABLE_MISS_MASK) { - case OFPTC11_TABLE_MISS_CONTROLLER: - return OFPUTIL_TABLE_MISS_CONTROLLER; + if (!msg->header) { + ofpraw_pull_assert(msg); + } - case OFPTC11_TABLE_MISS_CONTINUE: - return OFPUTIL_TABLE_MISS_CONTINUE; + if (!msg->size) { + return EOF; + } - case OFPTC11_TABLE_MISS_DROP: - return OFPUTIL_TABLE_MISS_DROP; + struct ofp14_table_desc *otd = ofpbuf_try_pull(msg, sizeof *otd); + if (!otd) { + VLOG_WARN_RL(&bad_ofmsg_rl, "OFP14_TABLE_DESC reply has %"PRIu32" " + "leftover bytes at end", msg->size); + return OFPERR_OFPBRC_BAD_LEN; + } + + td->table_id = otd->table_id; + size_t length = ntohs(otd->length); + if (length < sizeof *otd || length - sizeof *otd > msg->size) { + VLOG_WARN_RL(&bad_ofmsg_rl, "OFP14_TABLE_DESC reply claims invalid " + "length %"PRIuSIZE, length); + return OFPERR_OFPBRC_BAD_LEN; + } + length -= sizeof *otd; + + td->eviction = ofputil_decode_table_eviction(otd->config, version); + td->vacancy = ofputil_decode_table_vacancy(otd->config, version); + td->eviction_flags = UINT32_MAX; + + struct ofpbuf properties = ofpbuf_const_initializer( + ofpbuf_pull(msg, length), length); + while (properties.size > 0) { + struct ofpbuf payload; + enum ofperr error; + uint64_t type; + + error = ofpprop_pull(&properties, &payload, &type); + if (error) { + return error; + } + + switch (type) { + case OFPTMPT14_EVICTION: + error = ofpprop_parse_u32(&payload, &td->eviction_flags); + break; + + case OFPTMPT14_VACANCY: + error = parse_table_desc_vacancy_property(&payload, td); + break; default: - VLOG_WARN_RL(&bad_ofmsg_rl, "bad table miss config %d", config); - return OFPUTIL_TABLE_MISS_CONTROLLER; + error = OFPPROP_UNKNOWN(true, "table_desc", type); + break; + } + + if (error) { + return error; } + } + + return 0; +} + +/* Encodes and returns a request to obtain description of tables of a switch. + * The message is encoded for OpenFlow version 'ofp_version'. */ +struct ofpbuf * +ofputil_encode_table_desc_request(enum ofp_version ofp_version) +{ + struct ofpbuf *request = NULL; + + if (ofp_version >= OFP14_VERSION) { + request = ofpraw_alloc(OFPRAW_OFPST14_TABLE_DESC_REQUEST, + ofp_version, 0); } else { - return OFPUTIL_TABLE_MISS_DEFAULT; + ovs_fatal(0, "dump-table-desc needs OpenFlow 1.4 or later " + "(\'-O OpenFlow14\')"); } + + return request; } -/* Given a table miss configuration, returns the corresponding OpenFlow table - * configuration for use in an OpenFlow message of the given 'version'. */ -ovs_be32 -ofputil_table_miss_to_config(enum ofputil_table_miss miss, - enum ofp_version version) +/* Function to append Table desc information in a reply list. */ +void +ofputil_append_table_desc_reply(const struct ofputil_table_desc *td, + struct ovs_list *replies, + enum ofp_version version) +{ + struct ofpbuf *reply = ofpbuf_from_list(list_back(replies)); + size_t start_otd; + struct ofp14_table_desc *otd; + + start_otd = reply->size; + ofpbuf_put_zeros(reply, sizeof *otd); + if (td->eviction_flags != UINT32_MAX) { + ofpprop_put_u32(reply, OFPTMPT14_EVICTION, td->eviction_flags); + } + if (td->vacancy == OFPUTIL_TABLE_VACANCY_ON) { + struct ofp14_table_mod_prop_vacancy *otv; + + otv = ofpprop_put_zeros(reply, OFPTMPT14_VACANCY, sizeof *otv); + otv->vacancy_down = td->table_vacancy.vacancy_down; + otv->vacancy_up = td->table_vacancy.vacancy_up; + otv->vacancy = td->table_vacancy.vacancy; + } + + otd = ofpbuf_at_assert(reply, start_otd, sizeof *otd); + otd->length = htons(reply->size - start_otd); + otd->table_id = td->table_id; + otd->config = ofputil_encode_table_config(OFPUTIL_TABLE_MISS_DEFAULT, + td->eviction, td->vacancy, + version); + ofpmp_postappend(replies, start_otd); +} + +/* This function parses Vacancy property, and decodes the + * ofp14_table_mod_prop_vacancy in ofputil_table_mod. + * Returns OFPERR_OFPBPC_BAD_VALUE error code when vacancy_down is + * greater than vacancy_up and also when current vacancy has non-zero + * value. Returns 0 on success. */ +static enum ofperr +parse_table_mod_vacancy_property(struct ofpbuf *property, + struct ofputil_table_mod *tm) +{ + struct ofp14_table_mod_prop_vacancy *otv = property->data; + + if (property->size != sizeof *otv) { + return OFPERR_OFPBPC_BAD_LEN; + } + tm->table_vacancy.vacancy_down = otv->vacancy_down; + tm->table_vacancy.vacancy_up = otv->vacancy_up; + if (tm->table_vacancy.vacancy_down > tm->table_vacancy.vacancy_up) { + OFPPROP_LOG(&bad_ofmsg_rl, false, + "Value of vacancy_down is greater than vacancy_up"); + return OFPERR_OFPBPC_BAD_VALUE; + } + if (tm->table_vacancy.vacancy_down > 100 || + tm->table_vacancy.vacancy_up > 100) { + OFPPROP_LOG(&bad_ofmsg_rl, false, "Vacancy threshold percentage " + "should not be greater than 100"); + return OFPERR_OFPBPC_BAD_VALUE; + } + tm->table_vacancy.vacancy = otv->vacancy; + if (tm->table_vacancy.vacancy) { + OFPPROP_LOG(&bad_ofmsg_rl, false, + "Vacancy value should be zero for table-mod messages"); + return OFPERR_OFPBPC_BAD_VALUE; + } + return 0; +} + +/* Given 'config', taken from an OpenFlow 'version' message that specifies + * table configuration (a table mod, table stats, or table features message), + * returns the table vacancy configuration that it specifies. + * + * Only OpenFlow 1.4 and later specify table vacancy configuration this way, + * so for other 'version' this function always returns + * OFPUTIL_TABLE_VACANCY_DEFAULT. */ +static enum ofputil_table_vacancy +ofputil_decode_table_vacancy(ovs_be32 config, enum ofp_version version) +{ + return (version < OFP14_VERSION ? OFPUTIL_TABLE_VACANCY_DEFAULT + : config & htonl(OFPTC14_VACANCY_EVENTS) ? OFPUTIL_TABLE_VACANCY_ON + : OFPUTIL_TABLE_VACANCY_OFF); +} + +/* Given 'config', taken from an OpenFlow 'version' message that specifies + * table configuration (a table mod, table stats, or table features message), + * returns the table eviction configuration that it specifies. + * + * Only OpenFlow 1.4 and later specify table eviction configuration this way, + * so for other 'version' values this function always returns + * OFPUTIL_TABLE_EVICTION_DEFAULT. */ +static enum ofputil_table_eviction +ofputil_decode_table_eviction(ovs_be32 config, enum ofp_version version) { - if (version < OFP13_VERSION) { + return (version < OFP14_VERSION ? OFPUTIL_TABLE_EVICTION_DEFAULT + : config & htonl(OFPTC14_EVICTION) ? OFPUTIL_TABLE_EVICTION_ON + : OFPUTIL_TABLE_EVICTION_OFF); +} + +/* Returns a bitmap of OFPTC* values suitable for 'config' fields in various + * OpenFlow messages of the given 'version', based on the provided 'miss' and + * 'eviction' values. */ +static ovs_be32 +ofputil_encode_table_config(enum ofputil_table_miss miss, + enum ofputil_table_eviction eviction, + enum ofputil_table_vacancy vacancy, + enum ofp_version version) +{ + uint32_t config = 0; + /* See the section "OFPTC_* Table Configuration" in DESIGN.md for more + * information on the crazy evolution of this field. */ + switch (version) { + case OFP10_VERSION: + /* OpenFlow 1.0 didn't have such a field, any value ought to do. */ + return htonl(0); + + case OFP11_VERSION: + case OFP12_VERSION: + /* OpenFlow 1.1 and 1.2 define only OFPTC11_TABLE_MISS_*. */ switch (miss) { - case OFPUTIL_TABLE_MISS_CONTROLLER: case OFPUTIL_TABLE_MISS_DEFAULT: + /* Really this shouldn't be used for encoding (the caller should + * provide a specific value) but I can't imagine that defaulting to + * the fall-through case here will hurt. */ + case OFPUTIL_TABLE_MISS_CONTROLLER: + default: return htonl(OFPTC11_TABLE_MISS_CONTROLLER); - case OFPUTIL_TABLE_MISS_CONTINUE: return htonl(OFPTC11_TABLE_MISS_CONTINUE); - case OFPUTIL_TABLE_MISS_DROP: return htonl(OFPTC11_TABLE_MISS_DROP); + } + OVS_NOT_REACHED(); + + case OFP13_VERSION: + /* OpenFlow 1.3 removed OFPTC11_TABLE_MISS_* and didn't define any new + * flags, so this is correct. */ + return htonl(0); + + case OFP14_VERSION: + case OFP15_VERSION: + /* OpenFlow 1.4 introduced OFPTC14_EVICTION and + * OFPTC14_VACANCY_EVENTS. */ + if (eviction == OFPUTIL_TABLE_EVICTION_ON) { + config |= OFPTC14_EVICTION; + } + if (vacancy == OFPUTIL_TABLE_VACANCY_ON) { + config |= OFPTC14_VACANCY_EVENTS; + } + return htonl(config); + } + + OVS_NOT_REACHED(); +} + +/* Given 'config', taken from an OpenFlow 'version' message that specifies + * table configuration (a table mod, table stats, or table features message), + * returns the table miss configuration that it specifies. + * + * Only OpenFlow 1.1 and 1.2 specify table miss configurations this way, so for + * other 'version' values this function always returns + * OFPUTIL_TABLE_MISS_DEFAULT. */ +static enum ofputil_table_miss +ofputil_decode_table_miss(ovs_be32 config_, enum ofp_version version) +{ + uint32_t config = ntohl(config_); + + if (version == OFP11_VERSION || version == OFP12_VERSION) { + switch (config & OFPTC11_TABLE_MISS_MASK) { + case OFPTC11_TABLE_MISS_CONTROLLER: + return OFPUTIL_TABLE_MISS_CONTROLLER; + + case OFPTC11_TABLE_MISS_CONTINUE: + return OFPUTIL_TABLE_MISS_CONTINUE; + + case OFPTC11_TABLE_MISS_DROP: + return OFPUTIL_TABLE_MISS_DROP; default: - OVS_NOT_REACHED(); + VLOG_WARN_RL(&bad_ofmsg_rl, "bad table miss config %d", config); + return OFPUTIL_TABLE_MISS_CONTROLLER; } } else { - return htonl(0); + return OFPUTIL_TABLE_MISS_DEFAULT; } } @@ -4958,26 +5736,54 @@ enum ofperr ofputil_decode_table_mod(const struct ofp_header *oh, struct ofputil_table_mod *pm) { - enum ofpraw raw; - struct ofpbuf b; - - ofpbuf_use_const(&b, oh, ntohs(oh->length)); - raw = ofpraw_pull_assert(&b); + memset(pm, 0, sizeof *pm); + pm->miss = OFPUTIL_TABLE_MISS_DEFAULT; + pm->eviction = OFPUTIL_TABLE_EVICTION_DEFAULT; + pm->eviction_flags = UINT32_MAX; + pm->vacancy = OFPUTIL_TABLE_VACANCY_DEFAULT; + struct ofpbuf b = ofpbuf_const_initializer(oh, ntohs(oh->length)); + enum ofpraw raw = ofpraw_pull_assert(&b); if (raw == OFPRAW_OFPT11_TABLE_MOD) { - const struct ofp11_table_mod *otm = ofpbuf_data(&b); + const struct ofp11_table_mod *otm = b.data; pm->table_id = otm->table_id; - pm->miss_config = ofputil_table_miss_from_config(otm->config, - oh->version); + pm->miss = ofputil_decode_table_miss(otm->config, oh->version); } else if (raw == OFPRAW_OFPT14_TABLE_MOD) { const struct ofp14_table_mod *otm = ofpbuf_pull(&b, sizeof *otm); pm->table_id = otm->table_id; - pm->miss_config = ofputil_table_miss_from_config(otm->config, - oh->version); - /* We do not understand any properties yet, so we do not bother - * parsing them. */ + pm->miss = ofputil_decode_table_miss(otm->config, oh->version); + pm->eviction = ofputil_decode_table_eviction(otm->config, oh->version); + pm->vacancy = ofputil_decode_table_vacancy(otm->config, oh->version); + while (b.size > 0) { + struct ofpbuf property; + enum ofperr error; + uint64_t type; + + error = ofpprop_pull(&b, &property, &type); + if (error) { + return error; + } + + switch (type) { + case OFPTMPT14_EVICTION: + error = ofpprop_parse_u32(&property, &pm->eviction); + break; + + case OFPTMPT14_VACANCY: + error = parse_table_mod_vacancy_property(&property, pm); + break; + + default: + error = OFPERR_OFPBRC_BAD_TYPE; + break; + } + + if (error) { + return error; + } + } } else { return OFPERR_OFPBRC_BAD_TYPE; } @@ -4985,11 +5791,11 @@ ofputil_decode_table_mod(const struct ofp_header *oh, return 0; } -/* Converts the abstract form of a "table mod" message in '*pm' into an OpenFlow - * message suitable for 'protocol', and returns that encoded form in a buffer - * owned by the caller. */ +/* Converts the abstract form of a "table mod" message in '*tm' into an + * OpenFlow message suitable for 'protocol', and returns that encoded form in a + * buffer owned by the caller. */ struct ofpbuf * -ofputil_encode_table_mod(const struct ofputil_table_mod *pm, +ofputil_encode_table_mod(const struct ofputil_table_mod *tm, enum ofputil_protocol protocol) { enum ofp_version ofp_version = ofputil_protocol_to_ofp_version(protocol); @@ -5008,9 +5814,9 @@ ofputil_encode_table_mod(const struct ofputil_table_mod *pm, b = ofpraw_alloc(OFPRAW_OFPT11_TABLE_MOD, ofp_version, 0); otm = ofpbuf_put_zeros(b, sizeof *otm); - otm->table_id = pm->table_id; - otm->config = ofputil_table_miss_to_config(pm->miss_config, - ofp_version); + otm->table_id = tm->table_id; + otm->config = ofputil_encode_table_config(tm->miss, tm->eviction, + tm->vacancy, ofp_version); break; } case OFP14_VERSION: @@ -5019,9 +5825,20 @@ ofputil_encode_table_mod(const struct ofputil_table_mod *pm, b = ofpraw_alloc(OFPRAW_OFPT14_TABLE_MOD, ofp_version, 0); otm = ofpbuf_put_zeros(b, sizeof *otm); - otm->table_id = pm->table_id; - otm->config = ofputil_table_miss_to_config(pm->miss_config, - ofp_version); + otm->table_id = tm->table_id; + otm->config = ofputil_encode_table_config(tm->miss, tm->eviction, + tm->vacancy, ofp_version); + + if (tm->eviction_flags != UINT32_MAX) { + ofpprop_put_u32(b, OFPTMPT14_EVICTION, tm->eviction_flags); + } + if (tm->vacancy == OFPUTIL_TABLE_VACANCY_ON) { + struct ofp14_table_mod_prop_vacancy *otv; + + otv = ofpprop_put_zeros(b, OFPTMPT14_VACANCY, sizeof *otv); + otv->vacancy_down = tm->table_vacancy.vacancy_down; + otv->vacancy_up = tm->table_vacancy.vacancy_up; + } break; } default: @@ -5040,15 +5857,11 @@ 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); - + struct ofpbuf b = ofpbuf_const_initializer(oh, ntohs(oh->length)); + enum ofpraw raw = ofpraw_pull_assert(&b); if (raw == OFPRAW_OFPT12_ROLE_REQUEST || raw == OFPRAW_OFPT12_ROLE_REPLY) { - const struct ofp12_role_request *orr = ofpbuf_l3(&b); + const struct ofp12_role_request *orr = b.msg; if (orr->role != htonl(OFPCR12_ROLE_NOCHANGE) && orr->role != htonl(OFPCR12_ROLE_EQUAL) && @@ -5069,7 +5882,7 @@ ofputil_decode_role_message(const struct ofp_header *oh, } } else if (raw == OFPRAW_NXT_ROLE_REQUEST || raw == OFPRAW_NXT_ROLE_REPLY) { - const struct nx_role_request *nrr = ofpbuf_l3(&b); + const struct nx_role_request *nrr = b.msg; BUILD_ASSERT(NX_ROLE_OTHER + 1 == OFPCR12_ROLE_EQUAL); BUILD_ASSERT(NX_ROLE_MASTER + 1 == OFPCR12_ROLE_MASTER); @@ -5159,15 +5972,11 @@ enum ofperr ofputil_decode_role_status(const struct ofp_header *oh, struct ofputil_role_status *rs) { - struct ofpbuf b; - enum ofpraw raw; - const struct ofp14_role_status *r; - - ofpbuf_use_const(&b, oh, ntohs(oh->length)); - raw = ofpraw_pull_assert(&b); + struct ofpbuf b = ofpbuf_const_initializer(oh, ntohs(oh->length)); + enum ofpraw raw = ofpraw_pull_assert(&b); ovs_assert(raw == OFPRAW_OFPT14_ROLE_STATUS); - r = ofpbuf_l3(&b); + const struct ofp14_role_status *r = b.msg; if (r->role != htonl(OFPCR12_ROLE_NOCHANGE) && r->role != htonl(OFPCR12_ROLE_EQUAL) && r->role != htonl(OFPCR12_ROLE_MASTER) && @@ -5182,6 +5991,127 @@ ofputil_decode_role_status(const struct ofp_header *oh, return 0; } +/* Encodes 'rf' according to 'protocol', and returns the encoded message. + * 'protocol' must be for OpenFlow 1.4 or later. */ +struct ofpbuf * +ofputil_encode_requestforward(const struct ofputil_requestforward *rf, + enum ofputil_protocol protocol) +{ + enum ofp_version ofp_version = ofputil_protocol_to_ofp_version(protocol); + struct ofpbuf *inner; + + switch (rf->reason) { + case OFPRFR_GROUP_MOD: + inner = ofputil_encode_group_mod(ofp_version, rf->group_mod); + break; + + case OFPRFR_METER_MOD: + inner = ofputil_encode_meter_mod(ofp_version, rf->meter_mod); + break; + + case OFPRFR_N_REASONS: + default: + OVS_NOT_REACHED(); + } + + struct ofp_header *inner_oh = inner->data; + inner_oh->xid = rf->xid; + inner_oh->length = htons(inner->size); + + struct ofpbuf *outer = ofpraw_alloc_xid(OFPRAW_OFPT14_REQUESTFORWARD, + ofp_version, htonl(0), + inner->size); + ofpbuf_put(outer, inner->data, inner->size); + ofpbuf_delete(inner); + + return outer; +} + +/* Decodes OFPT_REQUESTFORWARD message 'outer'. On success, puts the decoded + * form into '*rf' and returns 0, and the caller is later responsible for + * freeing the content of 'rf', with ofputil_destroy_requestforward(rf). On + * failure, returns an ofperr and '*rf' is indeterminate. */ +enum ofperr +ofputil_decode_requestforward(const struct ofp_header *outer, + struct ofputil_requestforward *rf) +{ + struct ofpbuf b = ofpbuf_const_initializer(outer, ntohs(outer->length)); + + /* Skip past outer message. */ + enum ofpraw outer_raw = ofpraw_pull_assert(&b); + ovs_assert(outer_raw == OFPRAW_OFPT14_REQUESTFORWARD); + + /* Validate inner message. */ + if (b.size < sizeof(struct ofp_header)) { + return OFPERR_OFPBFC_MSG_BAD_LEN; + } + const struct ofp_header *inner = b.data; + unsigned int inner_len = ntohs(inner->length); + if (inner_len < sizeof(struct ofp_header) || inner_len > b.size) { + return OFPERR_OFPBFC_MSG_BAD_LEN; + } + if (inner->version != outer->version) { + return OFPERR_OFPBRC_BAD_VERSION; + } + + /* Parse inner message. */ + enum ofptype type; + enum ofperr error = ofptype_decode(&type, inner); + if (error) { + return error; + } + + rf->xid = inner->xid; + if (type == OFPTYPE_GROUP_MOD) { + rf->reason = OFPRFR_GROUP_MOD; + rf->group_mod = xmalloc(sizeof *rf->group_mod); + error = ofputil_decode_group_mod(inner, rf->group_mod); + if (error) { + free(rf->group_mod); + return error; + } + } else if (type == OFPTYPE_METER_MOD) { + rf->reason = OFPRFR_METER_MOD; + rf->meter_mod = xmalloc(sizeof *rf->meter_mod); + ofpbuf_init(&rf->bands, 64); + error = ofputil_decode_meter_mod(inner, rf->meter_mod, &rf->bands); + if (error) { + free(rf->meter_mod); + ofpbuf_uninit(&rf->bands); + return error; + } + } else { + return OFPERR_OFPBFC_MSG_UNSUP; + } + + return 0; +} + +/* Frees the content of 'rf', which should have been initialized through a + * successful call to ofputil_decode_requestforward(). */ +void +ofputil_destroy_requestforward(struct ofputil_requestforward *rf) +{ + if (!rf) { + return; + } + + switch (rf->reason) { + case OFPRFR_GROUP_MOD: + ofputil_uninit_group_mod(rf->group_mod); + free(rf->group_mod); + break; + + case OFPRFR_METER_MOD: + ofpbuf_uninit(&rf->bands); + free(rf->meter_mod); + break; + + case OFPRFR_N_REASONS: + OVS_NOT_REACHED(); + } +} + /* Table stats. */ /* OpenFlow 1.0 and 1.1 don't distinguish between a field that cannot be @@ -5367,8 +6297,10 @@ ofputil_put_ofp12_table_stats(const struct ofputil_table_stats *stats, out->metadata_write = features->metadata_write; out->instructions = ovsinst_bitmap_to_openflow( features->nonmiss.instructions, OFP12_VERSION); - out->config = ofputil_table_miss_to_config(features->miss_config, - OFP12_VERSION); + out->config = ofputil_encode_table_config(features->miss_config, + OFPUTIL_TABLE_EVICTION_DEFAULT, + OFPUTIL_TABLE_VACANCY_DEFAULT, + OFP12_VERSION); out->max_entries = htonl(features->max_entries); out->active_count = htonl(stats->active_count); out->lookup_count = htonll(stats->lookup_count); @@ -5399,7 +6331,7 @@ ofputil_append_table_stats_reply(struct ofpbuf *reply, const struct ofputil_table_stats *stats, const struct ofputil_table_features *features) { - struct ofp_header *oh = ofpbuf_l2(reply); + struct ofp_header *oh = reply->header; ovs_assert(stats->table_id == features->table_id); @@ -5474,8 +6406,8 @@ ofputil_decode_ofp11_table_stats(struct ofpbuf *msg, features->nonmiss.apply.ofpacts = ofpact_bitmap_from_openflow( ots->write_actions, OFP11_VERSION); features->miss = features->nonmiss; - features->miss_config = ofputil_table_miss_from_config(ots->config, - OFP11_VERSION); + features->miss_config = ofputil_decode_table_miss(ots->config, + OFP11_VERSION); features->match = mf_bitmap_from_of11(ots->match); features->wildcard = mf_bitmap_from_of11(ots->wildcards); bitmap_or(features->match.bm, features->wildcard.bm, MFF_N_IDS); @@ -5504,8 +6436,8 @@ ofputil_decode_ofp12_table_stats(struct ofpbuf *msg, ovs_strlcpy(features->name, ots->name, sizeof features->name); features->metadata_match = ots->metadata_match; features->metadata_write = ots->metadata_write; - features->miss_config = ofputil_table_miss_from_config(ots->config, - OFP12_VERSION); + features->miss_config = ofputil_decode_table_miss(ots->config, + OFP12_VERSION); features->max_entries = ntohl(ots->max_entries); features->nonmiss.instructions = ovsinst_bitmap_from_openflow( @@ -5562,17 +6494,19 @@ ofputil_decode_table_stats_reply(struct ofpbuf *msg, { const struct ofp_header *oh; - if (!msg->frame) { + if (!msg->header) { ofpraw_pull_assert(msg); } - oh = msg->frame; + oh = msg->header; - if (!ofpbuf_size(msg)) { + if (!msg->size) { return EOF; } memset(stats, 0, sizeof *stats); memset(features, 0, sizeof *features); + features->supports_eviction = -1; + features->supports_vacancy_events = -1; switch ((enum ofp_version) oh->version) { case OFP10_VERSION: @@ -5613,18 +6547,18 @@ ofputil_decode_flow_monitor_request(struct ofputil_flow_monitor_request *rq, struct nx_flow_monitor_request *nfmr; uint16_t flags; - if (!msg->frame) { + if (!msg->header) { ofpraw_pull_assert(msg); } - if (!ofpbuf_size(msg)) { + if (!msg->size) { return EOF; } nfmr = ofpbuf_try_pull(msg, sizeof *nfmr); if (!nfmr) { VLOG_WARN_RL(&bad_ofmsg_rl, "NXST_FLOW_MONITOR request has %"PRIu32" " - "leftover bytes at end", ofpbuf_size(msg)); + "leftover bytes at end", msg->size); return OFPERR_OFPBRC_BAD_LEN; } @@ -5657,11 +6591,11 @@ ofputil_append_flow_monitor_request( size_t start_ofs; int match_len; - if (!ofpbuf_size(msg)) { + if (!msg->size) { ofpraw_put(OFPRAW_NXST_FLOW_MONITOR_REQUEST, OFP10_VERSION, msg); } - start_ofs = ofpbuf_size(msg); + start_ofs = msg->size; ofpbuf_put_zeros(msg, sizeof *nfmr); match_len = nx_put_match(msg, &rq->match, htonll(0), htonll(0)); @@ -5697,24 +6631,25 @@ ofputil_decode_flow_update(struct ofputil_flow_update *update, unsigned int length; struct ofp_header *oh; - if (!msg->frame) { + if (!msg->header) { ofpraw_pull_assert(msg); } - if (!ofpbuf_size(msg)) { + ofpbuf_clear(ofpacts); + if (!msg->size) { return EOF; } - if (ofpbuf_size(msg) < sizeof(struct nx_flow_update_header)) { + if (msg->size < sizeof(struct nx_flow_update_header)) { goto bad_len; } - oh = msg->frame; + oh = msg->header; - nfuh = ofpbuf_data(msg); + nfuh = msg->data; update->event = ntohs(nfuh->event); length = ntohs(nfuh->length); - if (length > ofpbuf_size(msg) || length % 8) { + if (length > msg->size || length % 8) { goto bad_len; } @@ -5765,8 +6700,8 @@ ofputil_decode_flow_update(struct ofputil_flow_update *update, return error; } - update->ofpacts = ofpbuf_data(ofpacts); - update->ofpacts_len = ofpbuf_size(ofpacts); + update->ofpacts = ofpacts->data; + update->ofpacts_len = ofpacts->size; return 0; } else { VLOG_WARN_RL(&bad_ofmsg_rl, @@ -5777,7 +6712,7 @@ ofputil_decode_flow_update(struct ofputil_flow_update *update, bad_len: VLOG_WARN_RL(&bad_ofmsg_rl, "NXST_FLOW_MONITOR reply has %"PRIu32" " - "leftover bytes at end", ofpbuf_size(msg)); + "leftover bytes at end", msg->size); return OFPERR_OFPBRC_BAD_LEN; } @@ -5802,7 +6737,7 @@ ofputil_encode_flow_monitor_cancel(uint32_t id) } void -ofputil_start_flow_update(struct list *replies) +ofputil_start_flow_update(struct ovs_list *replies) { struct ofpbuf *msg; @@ -5815,7 +6750,7 @@ ofputil_start_flow_update(struct list *replies) void ofputil_append_flow_update(const struct ofputil_flow_update *update, - struct list *replies) + struct ovs_list *replies) { enum ofp_version version = ofpmp_version(replies); struct nx_flow_update_header *nfuh; @@ -5823,7 +6758,7 @@ ofputil_append_flow_update(const struct ofputil_flow_update *update, size_t start_ofs; msg = ofpbuf_from_list(list_back(replies)); - start_ofs = ofpbuf_size(msg); + start_ofs = msg->size; if (update->event == NXFME_ABBREV) { struct nx_flow_update_abbrev *nfua; @@ -5849,7 +6784,7 @@ ofputil_append_flow_update(const struct ofputil_flow_update *update, } nfuh = ofpbuf_at_assert(msg, start_ofs, sizeof *nfuh); - nfuh->length = htons(ofpbuf_size(msg) - start_ofs); + nfuh->length = htons(msg->size - start_ofs); nfuh->event = htons(update->event); ofpmp_postappend(replies, start_ofs); @@ -5875,14 +6810,14 @@ ofputil_encode_packet_out(const struct ofputil_packet_out *po, msg = ofpraw_alloc(OFPRAW_OFPT10_PACKET_OUT, OFP10_VERSION, size); ofpbuf_put_zeros(msg, sizeof *opo); - actions_ofs = ofpbuf_size(msg); + actions_ofs = msg->size; ofpacts_put_openflow_actions(po->ofpacts, po->ofpacts_len, msg, ofp_version); - opo = ofpbuf_l3(msg); + opo = msg->msg; opo->buffer_id = htonl(po->buffer_id); opo->in_port = htons(ofp_to_u16(po->in_port)); - opo->actions_len = htons(ofpbuf_size(msg) - actions_ofs); + opo->actions_len = htons(msg->size - actions_ofs); break; } @@ -5898,7 +6833,7 @@ ofputil_encode_packet_out(const struct ofputil_packet_out *po, ofpbuf_put_zeros(msg, sizeof *opo); len = ofpacts_put_openflow_actions(po->ofpacts, po->ofpacts_len, msg, ofp_version); - opo = ofpbuf_l3(msg); + opo = msg->msg; opo->buffer_id = htonl(po->buffer_id); opo->in_port = ofputil_port_to_ofp11(po->in_port); opo->actions_len = htons(len); @@ -5931,14 +6866,12 @@ make_echo_request(enum ofp_version ofp_version) struct ofpbuf * make_echo_reply(const struct ofp_header *rq) { - struct ofpbuf rq_buf; - struct ofpbuf *reply; - - ofpbuf_use_const(&rq_buf, rq, ntohs(rq->length)); + struct ofpbuf rq_buf = ofpbuf_const_initializer(rq, ntohs(rq->length)); ofpraw_pull_assert(&rq_buf); - reply = ofpraw_alloc_reply(OFPRAW_OFPT_ECHO_REPLY, rq, ofpbuf_size(&rq_buf)); - ofpbuf_put(reply, ofpbuf_data(&rq_buf), ofpbuf_size(&rq_buf)); + struct ofpbuf *reply = ofpraw_alloc_reply(OFPRAW_OFPT_ECHO_REPLY, + rq, rq_buf.size); + ofpbuf_put(reply, rq_buf.data, rq_buf.size); return reply; } @@ -5968,29 +6901,30 @@ ofputil_encode_barrier_request(enum ofp_version ofp_version) } const char * -ofputil_frag_handling_to_string(enum ofp_config_flags flags) +ofputil_frag_handling_to_string(enum ofputil_frag_handling frag) { - switch (flags & OFPC_FRAG_MASK) { - case OFPC_FRAG_NORMAL: return "normal"; - case OFPC_FRAG_DROP: return "drop"; - case OFPC_FRAG_REASM: return "reassemble"; - case OFPC_FRAG_NX_MATCH: return "nx-match"; + switch (frag) { + case OFPUTIL_FRAG_NORMAL: return "normal"; + case OFPUTIL_FRAG_DROP: return "drop"; + case OFPUTIL_FRAG_REASM: return "reassemble"; + case OFPUTIL_FRAG_NX_MATCH: return "nx-match"; } OVS_NOT_REACHED(); } bool -ofputil_frag_handling_from_string(const char *s, enum ofp_config_flags *flags) +ofputil_frag_handling_from_string(const char *s, + enum ofputil_frag_handling *frag) { if (!strcasecmp(s, "normal")) { - *flags = OFPC_FRAG_NORMAL; + *frag = OFPUTIL_FRAG_NORMAL; } else if (!strcasecmp(s, "drop")) { - *flags = OFPC_FRAG_DROP; + *frag = OFPUTIL_FRAG_DROP; } else if (!strcasecmp(s, "reassemble")) { - *flags = OFPC_FRAG_REASM; + *frag = OFPUTIL_FRAG_REASM; } else if (!strcasecmp(s, "nx-match")) { - *flags = OFPC_FRAG_NX_MATCH; + *frag = OFPUTIL_FRAG_NX_MATCH; } else { return false; } @@ -6166,9 +7100,9 @@ bool ofputil_group_from_string(const char *s, uint32_t *group_idp) { if (!strcasecmp(s, "any")) { - *group_idp = OFPG11_ANY; + *group_idp = OFPG_ANY; } else if (!strcasecmp(s, "all")) { - *group_idp = OFPG11_ALL; + *group_idp = OFPG_ALL; } else if (!str_to_uint(s, 10, group_idp)) { VLOG_WARN("%s is not a valid group ID. (Valid group IDs are " "32-bit nonnegative integers or the keywords ANY or " @@ -6181,7 +7115,7 @@ ofputil_group_from_string(const char *s, uint32_t *group_idp) /* Appends to 's' a string representation of the OpenFlow group ID 'group_id'. * Most groups' string representation is just the number, but for special - * groups, e.g. OFPG11_ALL, it is the name, e.g. "ALL". */ + * groups, e.g. OFPG_ALL, it is the name, e.g. "ALL". */ void ofputil_format_group(uint32_t group_id, struct ds *s) { @@ -6194,18 +7128,18 @@ ofputil_format_group(uint32_t group_id, struct ds *s) /* Puts in the 'bufsize' byte in 'namebuf' a null-terminated string * representation of OpenFlow group ID 'group_id'. Most group are represented - * as just their number, but special groups, e.g. OFPG11_ALL, are represented + * as just their number, but special groups, e.g. OFPG_ALL, are represented * by name, e.g. "ALL". */ void ofputil_group_to_string(uint32_t group_id, char namebuf[MAX_GROUP_NAME_LEN + 1], size_t bufsize) { switch (group_id) { - case OFPG11_ALL: + case OFPG_ALL: ovs_strlcpy(namebuf, "ALL", bufsize); break; - case OFPG11_ANY: + case OFPG_ANY: ovs_strlcpy(namebuf, "ANY", bufsize); break; @@ -6239,7 +7173,7 @@ ofputil_pull_phy_port(enum ofp_version ofp_version, struct ofpbuf *b, } case OFP14_VERSION: case OFP15_VERSION: - return ofpbuf_size(b) ? ofputil_pull_ofp14_port(pp, b) : EOF; + return b->size ? ofputil_pull_ofp14_port(pp, b) : EOF; default: OVS_NOT_REACHED(); } @@ -6310,10 +7244,10 @@ ofputil_normalize_match__(struct match *match, bool may_log) wc.masks.nw_ttl = 0; } if (!(may_match & MAY_ARP_SHA)) { - memset(wc.masks.arp_sha, 0, ETH_ADDR_LEN); + WC_UNMASK_FIELD(&wc, arp_sha); } if (!(may_match & MAY_ARP_THA)) { - memset(wc.masks.arp_tha, 0, ETH_ADDR_LEN); + WC_UNMASK_FIELD(&wc, arp_tha); } if (!(may_match & MAY_IPV6)) { wc.masks.ipv6_src = wc.masks.ipv6_dst = in6addr_any; @@ -6449,7 +7383,7 @@ ofputil_parse_key_value(char **stringp, char **keyp, char **valuep) } /* Encode a dump ports request for 'port', the encoded message - * will be for Open Flow version 'ofp_version'. Returns message + * will be for OpenFlow 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, ofp_port_t port) @@ -6533,7 +7467,7 @@ ofputil_port_stats_to_ofp13(const struct ofputil_port_stats *ops, static void ofputil_append_ofp14_port_stats(const struct ofputil_port_stats *ops, - struct list *replies) + struct ovs_list *replies) { struct ofp14_port_stats_prop_ethernet *eth; struct ofp14_port_stats *ps14; @@ -6556,10 +7490,7 @@ ofputil_append_ofp14_port_stats(const struct ofputil_port_stats *ops, ps14->rx_errors = htonll(ops->stats.rx_errors); ps14->tx_errors = htonll(ops->stats.tx_errors); - eth = ofpbuf_put_uninit(reply, sizeof *eth); - eth->type = htons(OFPPSPT14_ETHERNET); - eth->length = htons(sizeof *eth); - memset(eth->pad, 0, sizeof eth->pad); + eth = ofpprop_put_zeros(reply, OFPPSPT14_ETHERNET, sizeof *eth); eth->rx_frame_err = htonll(ops->stats.rx_frame_errors); eth->rx_over_err = htonll(ops->stats.rx_over_errors); eth->rx_crc_err = htonll(ops->stats.rx_crc_errors); @@ -6568,7 +7499,7 @@ ofputil_append_ofp14_port_stats(const struct ofputil_port_stats *ops, /* Encode a ports stat for 'ops' and append it to 'replies'. */ void -ofputil_append_port_stat(struct list *replies, +ofputil_append_port_stat(struct ovs_list *replies, const struct ofputil_port_stats *ops) { switch (ofpmp_version(replies)) { @@ -6670,9 +7601,9 @@ static enum ofperr parse_ofp14_port_stats_ethernet_property(const struct ofpbuf *payload, struct ofputil_port_stats *ops) { - const struct ofp14_port_stats_prop_ethernet *eth = ofpbuf_data(payload); + const struct ofp14_port_stats_prop_ethernet *eth = payload->data; - if (ofpbuf_size(payload) != sizeof *eth) { + if (payload->size != sizeof *eth) { return OFPERR_OFPBPC_BAD_LEN; } @@ -6688,24 +7619,18 @@ static enum ofperr ofputil_pull_ofp14_port_stats(struct ofputil_port_stats *ops, struct ofpbuf *msg) { - const struct ofp14_port_stats *ps14; - struct ofpbuf properties; - enum ofperr error; - size_t len; - - ps14 = ofpbuf_try_pull(msg, sizeof *ps14); + const struct ofp14_port_stats *ps14 = ofpbuf_try_pull(msg, sizeof *ps14); if (!ps14) { return OFPERR_OFPBRC_BAD_LEN; } - len = ntohs(ps14->length); - if (len < sizeof *ps14 || len - sizeof *ps14 > ofpbuf_size(msg)) { + size_t len = ntohs(ps14->length); + if (len < sizeof *ps14 || len - sizeof *ps14 > msg->size) { return OFPERR_OFPBRC_BAD_LEN; } len -= sizeof *ps14; - ofpbuf_use_const(&properties, ofpbuf_pull(msg, len), len); - error = ofputil_port_from_ofp11(ps14->port_no, &ops->port_no); + enum ofperr error = ofputil_port_from_ofp11(ps14->port_no, &ops->port_no); if (error) { return error; } @@ -6725,12 +7650,14 @@ ofputil_pull_ofp14_port_stats(struct ofputil_port_stats *ops, ops->stats.rx_crc_errors = UINT64_MAX; ops->stats.collisions = UINT64_MAX; - while (ofpbuf_size(&properties) > 0) { + struct ofpbuf properties = ofpbuf_const_initializer(ofpbuf_pull(msg, len), + len); + while (properties.size > 0) { struct ofpbuf payload; enum ofperr error; - uint16_t type; + uint64_t type; - error = ofputil_pull_property(&properties, &payload, &type); + error = ofpprop_pull(&properties, &payload, &type); if (error) { return error; } @@ -6741,8 +7668,7 @@ ofputil_pull_ofp14_port_stats(struct ofputil_port_stats *ops, break; default: - log_property(true, "unknown port stats property %"PRIu16, type); - error = 0; + error = OFPPROP_UNKNOWN(true, "port stats", type); break; } @@ -6759,16 +7685,15 @@ ofputil_pull_ofp14_port_stats(struct ofputil_port_stats *ops, size_t ofputil_count_port_stats(const struct ofp_header *oh) { - struct ofputil_port_stats ps; - struct ofpbuf b; - size_t n = 0; - - ofpbuf_use_const(&b, oh, ntohs(oh->length)); + struct ofpbuf b = ofpbuf_const_initializer(oh, ntohs(oh->length)); ofpraw_pull_assert(&b); - while (!ofputil_decode_port_stats(&ps, &b)) { - n++; + + for (size_t n = 0; ; n++) { + struct ofputil_port_stats ps; + if (ofputil_decode_port_stats(&ps, &b)) { + return n; + } } - return n; } /* Converts an OFPST_PORT_STATS reply in 'msg' into an abstract @@ -6787,14 +7712,13 @@ ofputil_decode_port_stats(struct ofputil_port_stats *ps, struct ofpbuf *msg) enum ofperr error; enum ofpraw raw; - error = (msg->frame - ? ofpraw_decode(&raw, msg->frame) + error = (msg->header ? ofpraw_decode(&raw, msg->header) : ofpraw_pull(&raw, msg)); if (error) { return error; } - if (!ofpbuf_size(msg)) { + if (!msg->size) { return EOF; } else if (raw == OFPRAW_OFPST14_PORT_REPLY) { return ofputil_pull_ofp14_port_stats(ps, msg); @@ -6828,7 +7752,7 @@ ofputil_decode_port_stats(struct ofputil_port_stats *ps, struct ofpbuf *msg) bad_len: VLOG_WARN_RL(&bad_ofmsg_rl, "OFPST_PORT reply has %"PRIu32" leftover " - "bytes at end", ofpbuf_size(msg)); + "bytes at end", msg->size); return OFPERR_OFPBRC_BAD_LEN; } @@ -6862,17 +7786,117 @@ ofputil_decode_port_stats_request(const struct ofp_header *request, /* Frees all of the "struct ofputil_bucket"s in the 'buckets' list. */ void -ofputil_bucket_list_destroy(struct list *buckets) +ofputil_bucket_list_destroy(struct ovs_list *buckets) { - struct ofputil_bucket *bucket, *next_bucket; + struct ofputil_bucket *bucket; - LIST_FOR_EACH_SAFE (bucket, next_bucket, list_node, buckets) { - list_remove(&bucket->list_node); + LIST_FOR_EACH_POP (bucket, list_node, buckets) { free(bucket->ofpacts); free(bucket); } } +/* Clones 'bucket' and its ofpacts data */ +static struct ofputil_bucket * +ofputil_bucket_clone_data(const struct ofputil_bucket *bucket) +{ + struct ofputil_bucket *new; + + new = xmemdup(bucket, sizeof *bucket); + new->ofpacts = xmemdup(bucket->ofpacts, bucket->ofpacts_len); + + return new; +} + +/* Clones each of the buckets in the list 'src' appending them + * in turn to 'dest' which should be an initialised list. + * An exception is that if the pointer value of a bucket in 'src' + * matches 'skip' then it is not cloned or appended to 'dest'. + * This allows all of 'src' or 'all of 'src' except 'skip' to + * be cloned and appended to 'dest'. */ +void +ofputil_bucket_clone_list(struct ovs_list *dest, const struct ovs_list *src, + const struct ofputil_bucket *skip) +{ + struct ofputil_bucket *bucket; + + LIST_FOR_EACH (bucket, list_node, src) { + struct ofputil_bucket *new_bucket; + + if (bucket == skip) { + continue; + } + + new_bucket = ofputil_bucket_clone_data(bucket); + list_push_back(dest, &new_bucket->list_node); + } +} + +/* Find a bucket in the list 'buckets' whose bucket id is 'bucket_id' + * Returns the first bucket found or NULL if no buckets are found. */ +struct ofputil_bucket * +ofputil_bucket_find(const struct ovs_list *buckets, uint32_t bucket_id) +{ + struct ofputil_bucket *bucket; + + if (bucket_id > OFPG15_BUCKET_MAX) { + return NULL; + } + + LIST_FOR_EACH (bucket, list_node, buckets) { + if (bucket->bucket_id == bucket_id) { + return bucket; + } + } + + return NULL; +} + +/* Returns true if more than one bucket in the list 'buckets' + * have the same bucket id. Returns false otherwise. */ +bool +ofputil_bucket_check_duplicate_id(const struct ovs_list *buckets) +{ + struct ofputil_bucket *i, *j; + + LIST_FOR_EACH (i, list_node, buckets) { + LIST_FOR_EACH_REVERSE (j, list_node, buckets) { + if (i == j) { + break; + } + if (i->bucket_id == j->bucket_id) { + return true; + } + } + } + + return false; +} + +/* Returns the bucket at the front of the list 'buckets'. + * Undefined if 'buckets is empty. */ +struct ofputil_bucket * +ofputil_bucket_list_front(const struct ovs_list *buckets) +{ + static struct ofputil_bucket *bucket; + + ASSIGN_CONTAINER(bucket, list_front(buckets), list_node); + + return bucket; +} + +/* Returns the bucket at the back of the list 'buckets'. + * Undefined if 'buckets is empty. */ +struct ofputil_bucket * +ofputil_bucket_list_back(const struct ovs_list *buckets) +{ + static struct ofputil_bucket *bucket; + + ASSIGN_CONTAINER(bucket, list_back(buckets), list_node); + + return bucket; +} + /* Returns an OpenFlow group stats request for OpenFlow version 'ofp_version', * that requests stats for group 'group_id'. (Use OFPG_ALL to request stats * for all groups.) @@ -6906,17 +7930,21 @@ ofputil_encode_group_stats_request(enum ofp_version ofp_version, return request; } +void +ofputil_uninit_group_desc(struct ofputil_group_desc *gd) +{ + ofputil_bucket_list_destroy(&gd->buckets); + free(&gd->props.fields); +} + /* Decodes the OpenFlow group description request in 'oh', returning the group * whose description is requested, or OFPG_ALL if stats for all groups was * requested. */ uint32_t ofputil_decode_group_desc_request(const struct ofp_header *oh) { - struct ofpbuf request; - enum ofpraw raw; - - ofpbuf_use_const(&request, oh, ntohs(oh->length)); - raw = ofpraw_pull_assert(&request); + struct ofpbuf request = ofpbuf_const_initializer(oh, ntohs(oh->length)); + enum ofpraw raw = ofpraw_pull_assert(&request); if (raw == OFPRAW_OFPST11_GROUP_DESC_REQUEST) { return OFPG_ALL; } else if (raw == OFPRAW_OFPST15_GROUP_DESC_REQUEST) { @@ -6939,7 +7967,6 @@ ofputil_encode_group_desc_request(enum ofp_version ofp_version, uint32_t group_id) { struct ofpbuf *request; - ovs_be32 gid; switch (ofp_version) { case OFP10_VERSION: @@ -6952,12 +7979,14 @@ ofputil_encode_group_desc_request(enum ofp_version ofp_version, request = ofpraw_alloc(OFPRAW_OFPST11_GROUP_DESC_REQUEST, ofp_version, 0); break; - case OFP15_VERSION: + case OFP15_VERSION:{ + struct ofp15_group_desc_request *req; request = ofpraw_alloc(OFPRAW_OFPST15_GROUP_DESC_REQUEST, ofp_version, 0); - gid = htonl(group_id); - ofpbuf_put(request, &gid, sizeof gid); + req = ofpbuf_put_zeros(request, sizeof *req); + req->group_id = htonl(group_id); break; + } default: OVS_NOT_REACHED(); } @@ -7006,7 +8035,7 @@ ofputil_group_stats_to_ofp13(const struct ofputil_group_stats *gs, * replies already begun in 'replies' and appends it to the list. 'replies' * must have originally been initialized with ofpmp_init(). */ void -ofputil_append_group_stats(struct list *replies, +ofputil_append_group_stats(struct ovs_list *replies, const struct ofputil_group_stats *gs) { size_t bucket_counter_size; @@ -7148,14 +8177,13 @@ ofputil_decode_group_stats_reply(struct ofpbuf *msg, size_t i; gs->bucket_stats = NULL; - error = (msg->frame - ? ofpraw_decode(&raw, msg->frame) + error = (msg->header ? ofpraw_decode(&raw, msg->header) : ofpraw_pull(&raw, msg)); if (error) { return error; } - if (!ofpbuf_size(msg)) { + if (!msg->size) { return EOF; } @@ -7181,7 +8209,7 @@ ofputil_decode_group_stats_reply(struct ofpbuf *msg, if (!ogs11) { VLOG_WARN_RL(&bad_ofmsg_rl, "%s reply has %"PRIu32" leftover bytes at end", - ofpraw_get_name(raw), ofpbuf_size(msg)); + ofpraw_get_name(raw), msg->size); return OFPERR_OFPBRC_BAD_LEN; } length = ntohs(ogs11->length); @@ -7200,7 +8228,7 @@ ofputil_decode_group_stats_reply(struct ofpbuf *msg, obc = ofpbuf_try_pull(msg, gs->n_buckets * sizeof *obc); if (!obc) { VLOG_WARN_RL(&bad_ofmsg_rl, "%s reply has %"PRIu32" leftover bytes at end", - ofpraw_get_name(raw), ofpbuf_size(msg)); + ofpraw_get_name(raw), msg->size); return OFPERR_OFPBRC_BAD_LEN; } @@ -7220,21 +8248,74 @@ ofputil_put_ofp11_bucket(const struct ofputil_bucket *bucket, struct ofp11_bucket *ob; size_t start; - start = ofpbuf_size(openflow); + start = openflow->size; ofpbuf_put_zeros(openflow, sizeof *ob); ofpacts_put_openflow_actions(bucket->ofpacts, bucket->ofpacts_len, openflow, ofp_version); ob = ofpbuf_at_assert(openflow, start, sizeof *ob); - ob->len = htons(ofpbuf_size(openflow) - start); + ob->len = htons(openflow->size - start); ob->weight = htons(bucket->weight); ob->watch_port = ofputil_port_to_ofp11(bucket->watch_port); ob->watch_group = htonl(bucket->watch_group); } +static void +ofputil_put_ofp15_bucket(const struct ofputil_bucket *bucket, + uint32_t bucket_id, enum ofp11_group_type group_type, + struct ofpbuf *openflow, enum ofp_version ofp_version) +{ + struct ofp15_bucket *ob; + size_t start, actions_start, actions_len; + + start = openflow->size; + ofpbuf_put_zeros(openflow, sizeof *ob); + + actions_start = openflow->size; + ofpacts_put_openflow_actions(bucket->ofpacts, bucket->ofpacts_len, + openflow, ofp_version); + actions_len = openflow->size - actions_start; + + if (group_type == OFPGT11_SELECT) { + ofpprop_put_u16(openflow, OFPGBPT15_WEIGHT, bucket->weight); + } + if (bucket->watch_port != OFPP_ANY) { + ofpprop_put_be32(openflow, OFPGBPT15_WATCH_PORT, + ofputil_port_to_ofp11(bucket->watch_port)); + } + if (bucket->watch_group != OFPG_ANY) { + ofpprop_put_u32(openflow, OFPGBPT15_WATCH_GROUP, bucket->watch_group); + } + + ob = ofpbuf_at_assert(openflow, start, sizeof *ob); + ob->len = htons(openflow->size - start); + ob->action_array_len = htons(actions_len); + ob->bucket_id = htonl(bucket_id); +} + +static void +ofputil_put_group_prop_ntr_selection_method(enum ofp_version ofp_version, + const struct ofputil_group_props *gp, + struct ofpbuf *openflow) +{ + struct ntr_group_prop_selection_method *prop; + size_t start; + + start = openflow->size; + ofpbuf_put_zeros(openflow, sizeof *prop); + oxm_put_field_array(openflow, &gp->fields, ofp_version); + prop = ofpbuf_at_assert(openflow, start, sizeof *prop); + prop->type = htons(OFPGPT15_EXPERIMENTER); + prop->experimenter = htonl(NTR_VENDOR_ID); + prop->exp_type = htonl(NTRT_SELECTION_METHOD); + strcpy(prop->selection_method, gp->selection_method); + prop->selection_method_param = htonll(gp->selection_method_param); + ofpprop_end(openflow, start); +} + static void ofputil_append_ofp11_group_desc_reply(const struct ofputil_group_desc *gds, - struct list *buckets, - struct list *replies, + const struct ovs_list *buckets, + struct ovs_list *replies, enum ofp_version version) { struct ofpbuf *reply = ofpbuf_from_list(list_back(replies)); @@ -7242,15 +8323,48 @@ ofputil_append_ofp11_group_desc_reply(const struct ofputil_group_desc *gds, struct ofputil_bucket *bucket; size_t start_ogds; - start_ogds = ofpbuf_size(reply); + start_ogds = reply->size; ofpbuf_put_zeros(reply, sizeof *ogds); LIST_FOR_EACH (bucket, list_node, buckets) { ofputil_put_ofp11_bucket(bucket, reply, version); } ogds = ofpbuf_at_assert(reply, start_ogds, sizeof *ogds); - ogds->length = htons(ofpbuf_size(reply) - start_ogds); + ogds->length = htons(reply->size - start_ogds); + ogds->type = gds->type; + ogds->group_id = htonl(gds->group_id); + + ofpmp_postappend(replies, start_ogds); +} + +static void +ofputil_append_ofp15_group_desc_reply(const struct ofputil_group_desc *gds, + const struct ovs_list *buckets, + struct ovs_list *replies, + enum ofp_version version) +{ + struct ofpbuf *reply = ofpbuf_from_list(list_back(replies)); + struct ofp15_group_desc_stats *ogds; + struct ofputil_bucket *bucket; + size_t start_ogds, start_buckets; + + start_ogds = reply->size; + ofpbuf_put_zeros(reply, sizeof *ogds); + start_buckets = reply->size; + LIST_FOR_EACH (bucket, list_node, buckets) { + ofputil_put_ofp15_bucket(bucket, bucket->bucket_id, + gds->type, reply, version); + } + ogds = ofpbuf_at_assert(reply, start_ogds, sizeof *ogds); ogds->type = gds->type; ogds->group_id = htonl(gds->group_id); + ogds->bucket_list_len = htons(reply->size - start_buckets); + + /* Add group properties */ + if (gds->props.selection_method[0]) { + ofputil_put_group_prop_ntr_selection_method(version, &gds->props, + reply); + } + ogds->length = htons(reply->size - start_ogds); ofpmp_postappend(replies, start_ogds); } @@ -7260,8 +8374,8 @@ ofputil_append_ofp11_group_desc_reply(const struct ofputil_group_desc *gds, * initialized with ofpmp_init(). */ void ofputil_append_group_desc_reply(const struct ofputil_group_desc *gds, - struct list *buckets, - struct list *replies) + const struct ovs_list *buckets, + struct ovs_list *replies) { enum ofp_version version = ofpmp_version(replies); @@ -7271,10 +8385,13 @@ ofputil_append_group_desc_reply(const struct ofputil_group_desc *gds, case OFP12_VERSION: case OFP13_VERSION: case OFP14_VERSION: - case OFP15_VERSION: ofputil_append_ofp11_group_desc_reply(gds, buckets, replies, version); break; + case OFP15_VERSION: + ofputil_append_ofp15_group_desc_reply(gds, buckets, replies, version); + break; + case OFP10_VERSION: default: OVS_NOT_REACHED(); @@ -7283,9 +8400,10 @@ ofputil_append_group_desc_reply(const struct ofputil_group_desc *gds, static enum ofperr ofputil_pull_ofp11_buckets(struct ofpbuf *msg, size_t buckets_length, - enum ofp_version version, struct list *buckets) + enum ofp_version version, struct ovs_list *buckets) { struct ofp11_bucket *ob; + uint32_t bucket_id = 0; list_init(buckets); while (buckets_length > 0) { @@ -7334,580 +8452,1845 @@ ofputil_pull_ofp11_buckets(struct ofpbuf *msg, size_t buckets_length, return OFPERR_OFPGMFC_BAD_WATCH; } bucket->watch_group = ntohl(ob->watch_group); + bucket->bucket_id = bucket_id++; + bucket->ofpacts = ofpbuf_steal_data(&ofpacts); - bucket->ofpacts_len = ofpbuf_size(&ofpacts); + bucket->ofpacts_len = ofpacts.size; list_push_back(buckets, &bucket->list_node); } return 0; } -/* Converts a group description reply in 'msg' into an abstract - * ofputil_group_desc in 'gd'. - * - * Multiple group description replies can be packed into a single OpenFlow - * message. Calling this function multiple times for a single 'msg' iterates - * through the replies. The caller must initially leave 'msg''s layer pointers - * null and not modify them between calls. - * - * Returns 0 if successful, EOF if no replies were left in this 'msg', - * otherwise a positive errno value. */ -int -ofputil_decode_group_desc_reply(struct ofputil_group_desc *gd, - struct ofpbuf *msg, enum ofp_version version) +static enum ofperr +ofputil_pull_ofp15_buckets(struct ofpbuf *msg, size_t buckets_length, + enum ofp_version version, uint8_t group_type, + struct ovs_list *buckets) { - struct ofp11_group_desc_stats *ogds; - size_t length; + struct ofp15_bucket *ob; - if (!msg->frame) { - ofpraw_pull_assert(msg); - } + list_init(buckets); + while (buckets_length > 0) { + struct ofputil_bucket *bucket = NULL; + struct ofpbuf ofpacts; + enum ofperr err = OFPERR_OFPGMFC_BAD_BUCKET; + size_t ob_len, actions_len, properties_len; + ovs_be32 watch_port = ofputil_port_to_ofp11(OFPP_ANY); + ovs_be32 watch_group = htonl(OFPG_ANY); + ovs_be16 weight = htons(group_type == OFPGT11_SELECT ? 1 : 0); - if (!ofpbuf_size(msg)) { - return EOF; - } + ofpbuf_init(&ofpacts, 0); - ogds = ofpbuf_try_pull(msg, sizeof *ogds); - if (!ogds) { - VLOG_WARN_RL(&bad_ofmsg_rl, "OFPST11_GROUP_DESC reply has %"PRIu32" " - "leftover bytes at end", ofpbuf_size(msg)); - return OFPERR_OFPBRC_BAD_LEN; - } - gd->type = ogds->type; - gd->group_id = ntohl(ogds->group_id); + ob = ofpbuf_try_pull(msg, sizeof *ob); + if (!ob) { + VLOG_WARN_RL(&bad_ofmsg_rl, "buckets end with %"PRIuSIZE + " leftover bytes", buckets_length); + goto err; + } - length = ntohs(ogds->length); - if (length < sizeof *ogds || length - sizeof *ogds > ofpbuf_size(msg)) { - VLOG_WARN_RL(&bad_ofmsg_rl, "OFPST11_GROUP_DESC reply claims invalid " - "length %"PRIuSIZE, length); - return OFPERR_OFPBRC_BAD_LEN; - } + ob_len = ntohs(ob->len); + actions_len = ntohs(ob->action_array_len); - return ofputil_pull_ofp11_buckets(msg, length - sizeof *ogds, version, - &gd->buckets); -} + if (ob_len < sizeof *ob) { + VLOG_WARN_RL(&bad_ofmsg_rl, "OpenFlow message bucket length " + "%"PRIuSIZE" is not valid", ob_len); + goto err; + } else if (ob_len > buckets_length) { + VLOG_WARN_RL(&bad_ofmsg_rl, "OpenFlow message bucket length " + "%"PRIuSIZE" exceeds remaining buckets data size %" + PRIuSIZE, ob_len, buckets_length); + goto err; + } else if (actions_len > ob_len - sizeof *ob) { + VLOG_WARN_RL(&bad_ofmsg_rl, "OpenFlow message bucket actions " + "length %"PRIuSIZE" exceeds remaining bucket " + "data size %"PRIuSIZE, actions_len, + ob_len - sizeof *ob); + goto err; + } + buckets_length -= ob_len; -static struct ofpbuf * -ofputil_encode_ofp11_group_mod(enum ofp_version ofp_version, - const struct ofputil_group_mod *gm) -{ - struct ofpbuf *b; - struct ofp11_group_mod *ogm; - size_t start_ogm; - struct ofputil_bucket *bucket; + err = ofpacts_pull_openflow_actions(msg, actions_len, version, + &ofpacts); + if (err) { + goto err; + } - b = ofpraw_alloc(OFPRAW_OFPT11_GROUP_MOD, ofp_version, 0); - start_ogm = ofpbuf_size(b); - ofpbuf_put_zeros(b, sizeof *ogm); + properties_len = ob_len - sizeof *ob - actions_len; + struct ofpbuf properties = ofpbuf_const_initializer( + ofpbuf_pull(msg, properties_len), properties_len); + while (properties.size > 0) { + struct ofpbuf payload; + uint64_t type; - LIST_FOR_EACH (bucket, list_node, &gm->buckets) { - ofputil_put_ofp11_bucket(bucket, b, ofp_version); - } - ogm = ofpbuf_at_assert(b, start_ogm, sizeof *ogm); + err = ofpprop_pull(&properties, &payload, &type); + if (err) { + goto err; + } + + switch (type) { + case OFPGBPT15_WEIGHT: + err = ofpprop_parse_be16(&payload, &weight); + break; + + case OFPGBPT15_WATCH_PORT: + err = ofpprop_parse_be32(&payload, &watch_port); + break; + + case OFPGBPT15_WATCH_GROUP: + err = ofpprop_parse_be32(&payload, &watch_group); + break; + + default: + err = OFPPROP_UNKNOWN(false, "group bucket", type); + break; + } + + if (err) { + goto err; + } + } + + bucket = xzalloc(sizeof *bucket); + + bucket->weight = ntohs(weight); + err = ofputil_port_from_ofp11(watch_port, &bucket->watch_port); + if (err) { + err = OFPERR_OFPGMFC_BAD_WATCH; + goto err; + } + bucket->watch_group = ntohl(watch_group); + bucket->bucket_id = ntohl(ob->bucket_id); + if (bucket->bucket_id > OFPG15_BUCKET_MAX) { + VLOG_WARN_RL(&bad_ofmsg_rl, "bucket id (%u) is out of range", + bucket->bucket_id); + err = OFPERR_OFPGMFC_BAD_BUCKET; + goto err; + } + + bucket->ofpacts = ofpbuf_steal_data(&ofpacts); + bucket->ofpacts_len = ofpacts.size; + list_push_back(buckets, &bucket->list_node); + + continue; + + err: + free(bucket); + ofpbuf_uninit(&ofpacts); + ofputil_bucket_list_destroy(buckets); + return err; + } + + if (ofputil_bucket_check_duplicate_id(buckets)) { + VLOG_WARN_RL(&bad_ofmsg_rl, "Duplicate bucket id"); + ofputil_bucket_list_destroy(buckets); + return OFPERR_OFPGMFC_BAD_BUCKET; + } + + return 0; +} + +static void +ofputil_init_group_properties(struct ofputil_group_props *gp) +{ + memset(gp, 0, sizeof *gp); +} + +static enum ofperr +parse_group_prop_ntr_selection_method(struct ofpbuf *payload, + enum ofp11_group_type group_type, + enum ofp15_group_mod_command group_cmd, + struct ofputil_group_props *gp) +{ + struct ntr_group_prop_selection_method *prop = payload->data; + size_t fields_len, method_len; + enum ofperr error; + + switch (group_type) { + case OFPGT11_SELECT: + break; + case OFPGT11_ALL: + case OFPGT11_INDIRECT: + case OFPGT11_FF: + OFPPROP_LOG(&bad_ofmsg_rl, false, "ntr selection method property is " + "only allowed for select groups"); + return OFPERR_OFPBPC_BAD_VALUE; + default: + OVS_NOT_REACHED(); + } + + switch (group_cmd) { + case OFPGC15_ADD: + case OFPGC15_MODIFY: + break; + case OFPGC15_DELETE: + case OFPGC15_INSERT_BUCKET: + case OFPGC15_REMOVE_BUCKET: + OFPPROP_LOG(&bad_ofmsg_rl, false, "ntr selection method property is " + "only allowed for add and delete group modifications"); + return OFPERR_OFPBPC_BAD_VALUE; + default: + OVS_NOT_REACHED(); + } + + if (payload->size < sizeof *prop) { + OFPPROP_LOG(&bad_ofmsg_rl, false, "ntr selection method property " + "length %u is not valid", payload->size); + return OFPERR_OFPBPC_BAD_LEN; + } + + method_len = strnlen(prop->selection_method, NTR_MAX_SELECTION_METHOD_LEN); + + if (method_len == NTR_MAX_SELECTION_METHOD_LEN) { + OFPPROP_LOG(&bad_ofmsg_rl, false, + "ntr selection method is not null terminated"); + return OFPERR_OFPBPC_BAD_VALUE; + } + + if (strcmp("hash", prop->selection_method)) { + OFPPROP_LOG(&bad_ofmsg_rl, false, + "ntr selection method '%s' is not supported", + prop->selection_method); + return OFPERR_OFPBPC_BAD_VALUE; + } + + strcpy(gp->selection_method, prop->selection_method); + gp->selection_method_param = ntohll(prop->selection_method_param); + + if (!method_len && gp->selection_method_param) { + OFPPROP_LOG(&bad_ofmsg_rl, false, "ntr selection method parameter is " + "non-zero but selection method is empty"); + return OFPERR_OFPBPC_BAD_VALUE; + } + + ofpbuf_pull(payload, sizeof *prop); + + fields_len = ntohs(prop->length) - sizeof *prop; + if (!method_len && fields_len) { + OFPPROP_LOG(&bad_ofmsg_rl, false, "ntr selection method parameter is " + "zero but fields are provided"); + return OFPERR_OFPBPC_BAD_VALUE; + } + + error = oxm_pull_field_array(payload->data, fields_len, + &gp->fields); + if (error) { + OFPPROP_LOG(&bad_ofmsg_rl, false, + "ntr selection method fields are invalid"); + return error; + } + + return 0; +} + +static enum ofperr +parse_ofp15_group_properties(struct ofpbuf *msg, + enum ofp11_group_type group_type, + enum ofp15_group_mod_command group_cmd, + struct ofputil_group_props *gp, + size_t properties_len) +{ + struct ofpbuf properties = ofpbuf_const_initializer( + ofpbuf_pull(msg, properties_len), properties_len); + while (properties.size > 0) { + struct ofpbuf payload; + enum ofperr error; + uint64_t type; + + error = ofpprop_pull(&properties, &payload, &type); + if (error) { + return error; + } + + switch (type) { + case OFPPROP_EXP(NTR_VENDOR_ID, NTRT_SELECTION_METHOD): + case OFPPROP_EXP(NTR_COMPAT_VENDOR_ID, NTRT_SELECTION_METHOD): + error = parse_group_prop_ntr_selection_method(&payload, group_type, + group_cmd, gp); + break; + + default: + error = OFPPROP_UNKNOWN(false, "group", type); + break; + } + + if (error) { + return error; + } + } + + return 0; +} + +static int +ofputil_decode_ofp11_group_desc_reply(struct ofputil_group_desc *gd, + struct ofpbuf *msg, + enum ofp_version version) +{ + struct ofp11_group_desc_stats *ogds; + size_t length; + + if (!msg->header) { + ofpraw_pull_assert(msg); + } + + if (!msg->size) { + return EOF; + } + + ogds = ofpbuf_try_pull(msg, sizeof *ogds); + if (!ogds) { + VLOG_WARN_RL(&bad_ofmsg_rl, "OFPST11_GROUP_DESC reply has %"PRIu32" " + "leftover bytes at end", msg->size); + return OFPERR_OFPBRC_BAD_LEN; + } + gd->type = ogds->type; + gd->group_id = ntohl(ogds->group_id); + + length = ntohs(ogds->length); + if (length < sizeof *ogds || length - sizeof *ogds > msg->size) { + VLOG_WARN_RL(&bad_ofmsg_rl, "OFPST11_GROUP_DESC reply claims invalid " + "length %"PRIuSIZE, length); + return OFPERR_OFPBRC_BAD_LEN; + } + + return ofputil_pull_ofp11_buckets(msg, length - sizeof *ogds, version, + &gd->buckets); +} + +static int +ofputil_decode_ofp15_group_desc_reply(struct ofputil_group_desc *gd, + struct ofpbuf *msg, + enum ofp_version version) +{ + struct ofp15_group_desc_stats *ogds; + uint16_t length, bucket_list_len; + int error; + + if (!msg->header) { + ofpraw_pull_assert(msg); + } + + if (!msg->size) { + return EOF; + } + + ogds = ofpbuf_try_pull(msg, sizeof *ogds); + if (!ogds) { + VLOG_WARN_RL(&bad_ofmsg_rl, "OFPST11_GROUP_DESC reply has %"PRIu32" " + "leftover bytes at end", msg->size); + return OFPERR_OFPBRC_BAD_LEN; + } + gd->type = ogds->type; + gd->group_id = ntohl(ogds->group_id); + + length = ntohs(ogds->length); + if (length < sizeof *ogds || length - sizeof *ogds > msg->size) { + VLOG_WARN_RL(&bad_ofmsg_rl, "OFPST11_GROUP_DESC reply claims invalid " + "length %u", length); + return OFPERR_OFPBRC_BAD_LEN; + } + + bucket_list_len = ntohs(ogds->bucket_list_len); + if (length < bucket_list_len + sizeof *ogds) { + VLOG_WARN_RL(&bad_ofmsg_rl, "OFPST11_GROUP_DESC reply claims invalid " + "bucket list length %u", bucket_list_len); + return OFPERR_OFPBRC_BAD_LEN; + } + error = ofputil_pull_ofp15_buckets(msg, bucket_list_len, version, gd->type, + &gd->buckets); + if (error) { + return error; + } + + /* By definition group desc messages don't have a group mod command. + * However, parse_group_prop_ntr_selection_method() checks to make sure + * that the command is OFPGC15_ADD or OFPGC15_DELETE to guard + * against group mod messages with other commands supplying + * a NTR selection method group experimenter property. + * Such properties are valid for group desc replies so + * claim that the group mod command is OFPGC15_ADD to + * satisfy the check in parse_group_prop_ntr_selection_method() */ + return parse_ofp15_group_properties(msg, gd->type, OFPGC15_ADD, &gd->props, + length - sizeof *ogds - bucket_list_len); +} + +/* Converts a group description reply in 'msg' into an abstract + * ofputil_group_desc in 'gd'. + * + * Multiple group description replies can be packed into a single OpenFlow + * message. Calling this function multiple times for a single 'msg' iterates + * through the replies. The caller must initially leave 'msg''s layer pointers + * null and not modify them between calls. + * + * Returns 0 if successful, EOF if no replies were left in this 'msg', + * otherwise a positive errno value. */ +int +ofputil_decode_group_desc_reply(struct ofputil_group_desc *gd, + struct ofpbuf *msg, enum ofp_version version) +{ + ofputil_init_group_properties(&gd->props); + + switch (version) + { + case OFP11_VERSION: + case OFP12_VERSION: + case OFP13_VERSION: + case OFP14_VERSION: + return ofputil_decode_ofp11_group_desc_reply(gd, msg, version); + + case OFP15_VERSION: + return ofputil_decode_ofp15_group_desc_reply(gd, msg, version); + + case OFP10_VERSION: + default: + OVS_NOT_REACHED(); + } +} + +void +ofputil_uninit_group_mod(struct ofputil_group_mod *gm) +{ + ofputil_bucket_list_destroy(&gm->buckets); +} + +static struct ofpbuf * +ofputil_encode_ofp11_group_mod(enum ofp_version ofp_version, + const struct ofputil_group_mod *gm) +{ + struct ofpbuf *b; + struct ofp11_group_mod *ogm; + size_t start_ogm; + struct ofputil_bucket *bucket; + + b = ofpraw_alloc(OFPRAW_OFPT11_GROUP_MOD, ofp_version, 0); + start_ogm = b->size; + ofpbuf_put_zeros(b, sizeof *ogm); + + LIST_FOR_EACH (bucket, list_node, &gm->buckets) { + ofputil_put_ofp11_bucket(bucket, b, ofp_version); + } + ogm = ofpbuf_at_assert(b, start_ogm, sizeof *ogm); + ogm->command = htons(gm->command); + ogm->type = gm->type; + ogm->group_id = htonl(gm->group_id); + + return b; +} + +static struct ofpbuf * +ofputil_encode_ofp15_group_mod(enum ofp_version ofp_version, + const struct ofputil_group_mod *gm) +{ + struct ofpbuf *b; + struct ofp15_group_mod *ogm; + size_t start_ogm; + struct ofputil_bucket *bucket; + struct id_pool *bucket_ids = NULL; + + b = ofpraw_alloc(OFPRAW_OFPT15_GROUP_MOD, ofp_version, 0); + start_ogm = b->size; + ofpbuf_put_zeros(b, sizeof *ogm); + + LIST_FOR_EACH (bucket, list_node, &gm->buckets) { + uint32_t bucket_id; + + /* Generate a bucket id if none was supplied */ + if (bucket->bucket_id > OFPG15_BUCKET_MAX) { + if (!bucket_ids) { + const struct ofputil_bucket *bkt; + + bucket_ids = id_pool_create(0, OFPG15_BUCKET_MAX + 1); + + /* Mark all bucket_ids that are present in gm + * as used in the pool. */ + LIST_FOR_EACH_REVERSE (bkt, list_node, &gm->buckets) { + if (bkt == bucket) { + break; + } + if (bkt->bucket_id <= OFPG15_BUCKET_MAX) { + id_pool_add(bucket_ids, bkt->bucket_id); + } + } + } + + if (!id_pool_alloc_id(bucket_ids, &bucket_id)) { + OVS_NOT_REACHED(); + } + } else { + bucket_id = bucket->bucket_id; + } + + ofputil_put_ofp15_bucket(bucket, bucket_id, gm->type, b, ofp_version); + } + ogm = ofpbuf_at_assert(b, start_ogm, sizeof *ogm); ogm->command = htons(gm->command); ogm->type = gm->type; ogm->group_id = htonl(gm->group_id); + ogm->command_bucket_id = htonl(gm->command_bucket_id); + ogm->bucket_array_len = htons(b->size - start_ogm - sizeof *ogm); + + /* Add group properties */ + if (gm->props.selection_method[0]) { + ofputil_put_group_prop_ntr_selection_method(ofp_version, &gm->props, b); + } + id_pool_destroy(bucket_ids); return b; } -/* Converts abstract group mod 'gm' into a message for OpenFlow version - * 'ofp_version' and returns the message. */ +static void +bad_group_cmd(enum ofp15_group_mod_command cmd) +{ + const char *opt_version; + const char *version; + const char *cmd_str; + + switch (cmd) { + case OFPGC15_ADD: + case OFPGC15_MODIFY: + case OFPGC15_DELETE: + version = "1.1"; + opt_version = "11"; + break; + + case OFPGC15_INSERT_BUCKET: + case OFPGC15_REMOVE_BUCKET: + version = "1.5"; + opt_version = "15"; + break; + + default: + OVS_NOT_REACHED(); + } + + switch (cmd) { + case OFPGC15_ADD: + cmd_str = "add-group"; + break; + + case OFPGC15_MODIFY: + cmd_str = "mod-group"; + break; + + case OFPGC15_DELETE: + cmd_str = "del-group"; + break; + + case OFPGC15_INSERT_BUCKET: + cmd_str = "insert-bucket"; + break; + + case OFPGC15_REMOVE_BUCKET: + cmd_str = "remove-bucket"; + break; + + default: + OVS_NOT_REACHED(); + } + + ovs_fatal(0, "%s needs OpenFlow %s or later (\'-O OpenFlow%s\')", + cmd_str, version, opt_version); + +} + +/* Converts abstract group mod 'gm' into a message for OpenFlow version + * 'ofp_version' and returns the message. */ +struct ofpbuf * +ofputil_encode_group_mod(enum ofp_version ofp_version, + const struct ofputil_group_mod *gm) +{ + + switch (ofp_version) { + case OFP10_VERSION: + bad_group_cmd(gm->command); + + case OFP11_VERSION: + case OFP12_VERSION: + case OFP13_VERSION: + case OFP14_VERSION: + if (gm->command > OFPGC11_DELETE) { + bad_group_cmd(gm->command); + } + return ofputil_encode_ofp11_group_mod(ofp_version, gm); + + case OFP15_VERSION: + return ofputil_encode_ofp15_group_mod(ofp_version, gm); + + default: + OVS_NOT_REACHED(); + } +} + +static enum ofperr +ofputil_pull_ofp11_group_mod(struct ofpbuf *msg, enum ofp_version ofp_version, + struct ofputil_group_mod *gm) +{ + const struct ofp11_group_mod *ogm; + enum ofperr error; + + ogm = ofpbuf_pull(msg, sizeof *ogm); + gm->command = ntohs(ogm->command); + gm->type = ogm->type; + gm->group_id = ntohl(ogm->group_id); + gm->command_bucket_id = OFPG15_BUCKET_ALL; + + error = ofputil_pull_ofp11_buckets(msg, msg->size, ofp_version, + &gm->buckets); + + /* OF1.3.5+ prescribes an error when an OFPGC_DELETE includes buckets. */ + if (!error + && ofp_version >= OFP13_VERSION + && gm->command == OFPGC11_DELETE + && !list_is_empty(&gm->buckets)) { + error = OFPERR_OFPGMFC_INVALID_GROUP; + } + + return error; +} + +static enum ofperr +ofputil_pull_ofp15_group_mod(struct ofpbuf *msg, enum ofp_version ofp_version, + struct ofputil_group_mod *gm) +{ + const struct ofp15_group_mod *ogm; + uint16_t bucket_list_len; + enum ofperr error = OFPERR_OFPGMFC_BAD_BUCKET; + + ogm = ofpbuf_pull(msg, sizeof *ogm); + gm->command = ntohs(ogm->command); + gm->type = ogm->type; + gm->group_id = ntohl(ogm->group_id); + + gm->command_bucket_id = ntohl(ogm->command_bucket_id); + switch (gm->command) { + case OFPGC15_REMOVE_BUCKET: + if (gm->command_bucket_id == OFPG15_BUCKET_ALL) { + error = 0; + } + /* Fall through */ + case OFPGC15_INSERT_BUCKET: + if (gm->command_bucket_id <= OFPG15_BUCKET_MAX || + gm->command_bucket_id == OFPG15_BUCKET_FIRST + || gm->command_bucket_id == OFPG15_BUCKET_LAST) { + error = 0; + } + break; + + case OFPGC11_ADD: + case OFPGC11_MODIFY: + case OFPGC11_DELETE: + default: + if (gm->command_bucket_id == OFPG15_BUCKET_ALL) { + error = 0; + } + break; + } + if (error) { + VLOG_WARN_RL(&bad_ofmsg_rl, + "group command bucket id (%u) is out of range", + gm->command_bucket_id); + return OFPERR_OFPGMFC_BAD_BUCKET; + } + + bucket_list_len = ntohs(ogm->bucket_array_len); + error = ofputil_pull_ofp15_buckets(msg, bucket_list_len, ofp_version, + gm->type, &gm->buckets); + if (error) { + return error; + } + + return parse_ofp15_group_properties(msg, gm->type, gm->command, &gm->props, + msg->size); +} + +/* Converts OpenFlow group mod message 'oh' into an abstract group mod in + * 'gm'. Returns 0 if successful, otherwise an OpenFlow error code. */ +enum ofperr +ofputil_decode_group_mod(const struct ofp_header *oh, + struct ofputil_group_mod *gm) +{ + ofputil_init_group_properties(&gm->props); + + enum ofp_version ofp_version = oh->version; + struct ofpbuf msg = ofpbuf_const_initializer(oh, ntohs(oh->length)); + ofpraw_pull_assert(&msg); + + enum ofperr err; + switch (ofp_version) + { + case OFP11_VERSION: + case OFP12_VERSION: + case OFP13_VERSION: + case OFP14_VERSION: + err = ofputil_pull_ofp11_group_mod(&msg, ofp_version, gm); + break; + + case OFP15_VERSION: + err = ofputil_pull_ofp15_group_mod(&msg, ofp_version, gm); + break; + + case OFP10_VERSION: + default: + OVS_NOT_REACHED(); + } + if (err) { + return err; + } + + switch (gm->type) { + case OFPGT11_INDIRECT: + if (!list_is_singleton(&gm->buckets)) { + return OFPERR_OFPGMFC_INVALID_GROUP; + } + break; + case OFPGT11_ALL: + case OFPGT11_SELECT: + case OFPGT11_FF: + break; + default: + return OFPERR_OFPGMFC_BAD_TYPE; + } + + switch (gm->command) { + case OFPGC11_ADD: + case OFPGC11_MODIFY: + case OFPGC11_DELETE: + case OFPGC15_INSERT_BUCKET: + break; + case OFPGC15_REMOVE_BUCKET: + if (!list_is_empty(&gm->buckets)) { + return OFPERR_OFPGMFC_BAD_BUCKET; + } + break; + default: + return OFPERR_OFPGMFC_BAD_COMMAND; + } + + struct ofputil_bucket *bucket; + LIST_FOR_EACH (bucket, list_node, &gm->buckets) { + if (bucket->weight && gm->type != OFPGT11_SELECT) { + return OFPERR_OFPGMFC_INVALID_GROUP; + } + + switch (gm->type) { + case OFPGT11_ALL: + case OFPGT11_INDIRECT: + if (ofputil_bucket_has_liveness(bucket)) { + return OFPERR_OFPGMFC_WATCH_UNSUPPORTED; + } + break; + case OFPGT11_SELECT: + break; + case OFPGT11_FF: + if (!ofputil_bucket_has_liveness(bucket)) { + return OFPERR_OFPGMFC_INVALID_GROUP; + } + break; + default: + /* Returning BAD TYPE to be consistent + * though gm->type has been checked already. */ + return OFPERR_OFPGMFC_BAD_TYPE; + } + } + + return 0; +} + +/* Parse a queue status request message into 'oqsr'. + * Returns 0 if successful, otherwise an OFPERR_* number. */ +enum ofperr +ofputil_decode_queue_stats_request(const struct ofp_header *request, + struct ofputil_queue_stats_request *oqsr) +{ + switch ((enum ofp_version)request->version) { + case OFP15_VERSION: + case OFP14_VERSION: + case OFP13_VERSION: + case OFP12_VERSION: + case OFP11_VERSION: { + const struct ofp11_queue_stats_request *qsr11 = ofpmsg_body(request); + oqsr->queue_id = ntohl(qsr11->queue_id); + return ofputil_port_from_ofp11(qsr11->port_no, &oqsr->port_no); + } + + case OFP10_VERSION: { + 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; + } + + default: + OVS_NOT_REACHED(); + } +} + +/* Encode a queue stats request for 'oqsr', the encoded message + * will be for OpenFlow version 'ofp_version'. Returns message + * as a struct ofpbuf. Returns encoded message on success, NULL on error. */ +struct ofpbuf * +ofputil_encode_queue_stats_request(enum ofp_version ofp_version, + const struct ofputil_queue_stats_request *oqsr) +{ + struct ofpbuf *request; + + switch (ofp_version) { + case OFP11_VERSION: + case OFP12_VERSION: + case OFP13_VERSION: + case OFP14_VERSION: + case OFP15_VERSION: { + struct ofp11_queue_stats_request *req; + request = ofpraw_alloc(OFPRAW_OFPST11_QUEUE_REQUEST, ofp_version, 0); + req = ofpbuf_put_zeros(request, sizeof *req); + req->port_no = ofputil_port_to_ofp11(oqsr->port_no); + req->queue_id = htonl(oqsr->queue_id); + break; + } + case OFP10_VERSION: { + struct ofp10_queue_stats_request *req; + 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(ofp_to_u16(oqsr->port_no == OFPP_ANY + ? OFPP_ALL : oqsr->port_no)); + req->queue_id = htonl(oqsr->queue_id); + break; + } + default: + OVS_NOT_REACHED(); + } + + return request; +} + +/* Returns the number of queue stats elements in OFPTYPE_QUEUE_STATS_REPLY + * message 'oh'. */ +size_t +ofputil_count_queue_stats(const struct ofp_header *oh) +{ + struct ofpbuf b = ofpbuf_const_initializer(oh, ntohs(oh->length)); + ofpraw_pull_assert(&b); + + for (size_t n = 0; ; n++) { + struct ofputil_queue_stats qs; + if (ofputil_decode_queue_stats(&qs, &b)) { + return n; + } + } +} + +static enum ofperr +ofputil_queue_stats_from_ofp10(struct ofputil_queue_stats *oqs, + const struct ofp10_queue_stats *qs10) +{ + oqs->port_no = u16_to_ofp(ntohs(qs10->port_no)); + oqs->queue_id = ntohl(qs10->queue_id); + 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; +} + +static enum ofperr +ofputil_queue_stats_from_ofp11(struct ofputil_queue_stats *oqs, + const struct ofp11_queue_stats *qs11) +{ + enum ofperr error; + + error = ofputil_port_from_ofp11(qs11->port_no, &oqs->port_no); + if (error) { + return error; + } + + oqs->queue_id = ntohl(qs11->queue_id); + 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; +} + +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) { + oqs->duration_sec = ntohl(qs13->duration_sec); + oqs->duration_nsec = ntohl(qs13->duration_nsec); + } + + return error; +} + +static enum ofperr +ofputil_pull_ofp14_queue_stats(struct ofputil_queue_stats *oqs, + struct ofpbuf *msg) +{ + const struct ofp14_queue_stats *qs14; + size_t len; + + qs14 = ofpbuf_try_pull(msg, sizeof *qs14); + if (!qs14) { + return OFPERR_OFPBRC_BAD_LEN; + } + + len = ntohs(qs14->length); + if (len < sizeof *qs14 || len - sizeof *qs14 > msg->size) { + return OFPERR_OFPBRC_BAD_LEN; + } + ofpbuf_pull(msg, len - sizeof *qs14); + + /* No properties yet defined, so ignore them for now. */ + + return ofputil_queue_stats_from_ofp13(oqs, &qs14->qs); +} + +/* Converts an OFPST_QUEUE_STATS reply in 'msg' into an abstract + * ofputil_queue_stats in 'qs'. + * + * Multiple OFPST_QUEUE_STATS replies can be packed into a single OpenFlow + * message. Calling this function multiple times for a single 'msg' iterates + * through the replies. The caller must initially leave 'msg''s layer pointers + * null and not modify them between calls. + * + * Returns 0 if successful, EOF if no replies were left in this 'msg', + * otherwise a positive errno value. */ +int +ofputil_decode_queue_stats(struct ofputil_queue_stats *qs, struct ofpbuf *msg) +{ + enum ofperr error; + enum ofpraw raw; + + error = (msg->header ? ofpraw_decode(&raw, msg->header) + : ofpraw_pull(&raw, msg)); + if (error) { + return error; + } + + if (!msg->size) { + return EOF; + } else if (raw == OFPRAW_OFPST14_QUEUE_REPLY) { + return ofputil_pull_ofp14_queue_stats(qs, msg); + } 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) { + goto bad_len; + } + return ofputil_queue_stats_from_ofp11(qs, qs11); + } else if (raw == OFPRAW_OFPST10_QUEUE_REPLY) { + const struct ofp10_queue_stats *qs10; + + qs10 = ofpbuf_try_pull(msg, sizeof *qs10); + if (!qs10) { + goto bad_len; + } + return ofputil_queue_stats_from_ofp10(qs, qs10); + } else { + OVS_NOT_REACHED(); + } + + bad_len: + VLOG_WARN_RL(&bad_ofmsg_rl, "OFPST_QUEUE reply has %"PRIu32" 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(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->tx_bytes)); + put_32aligned_be64(&qs10->tx_packets, htonll(oqs->tx_packets)); + put_32aligned_be64(&qs10->tx_errors, htonll(oqs->tx_errors)); +} + +static void +ofputil_queue_stats_to_ofp11(const struct ofputil_queue_stats *oqs, + struct ofp11_queue_stats *qs11) +{ + qs11->port_no = ofputil_port_to_ofp11(oqs->port_no); + qs11->queue_id = htonl(oqs->queue_id); + qs11->tx_bytes = htonll(oqs->tx_bytes); + qs11->tx_packets = htonll(oqs->tx_packets); + qs11->tx_errors = htonll(oqs->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); + if (oqs->duration_sec != UINT32_MAX) { + qs13->duration_sec = htonl(oqs->duration_sec); + qs13->duration_nsec = htonl(oqs->duration_nsec); + } else { + qs13->duration_sec = OVS_BE32_MAX; + qs13->duration_nsec = OVS_BE32_MAX; + } +} + +static void +ofputil_queue_stats_to_ofp14(const struct ofputil_queue_stats *oqs, + struct ofp14_queue_stats *qs14) +{ + qs14->length = htons(sizeof *qs14); + memset(qs14->pad, 0, sizeof qs14->pad); + ofputil_queue_stats_to_ofp13(oqs, &qs14->qs); +} + + +/* Encode a queue stat for 'oqs' and append it to 'replies'. */ +void +ofputil_append_queue_stat(struct ovs_list *replies, + const struct ofputil_queue_stats *oqs) +{ + switch (ofpmp_version(replies)) { + 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); + ofputil_queue_stats_to_ofp11(oqs, reply); + break; + } + + case OFP10_VERSION: { + struct ofp10_queue_stats *reply = ofpmp_append(replies, sizeof *reply); + ofputil_queue_stats_to_ofp10(oqs, reply); + break; + } + + case OFP14_VERSION: + case OFP15_VERSION: { + struct ofp14_queue_stats *reply = ofpmp_append(replies, sizeof *reply); + ofputil_queue_stats_to_ofp14(oqs, reply); + break; + } + + default: + OVS_NOT_REACHED(); + } +} + +enum ofperr +ofputil_decode_bundle_ctrl(const struct ofp_header *oh, + struct ofputil_bundle_ctrl_msg *msg) +{ + struct ofpbuf b = ofpbuf_const_initializer(oh, ntohs(oh->length)); + enum ofpraw raw = ofpraw_pull_assert(&b); + ovs_assert(raw == OFPRAW_OFPT14_BUNDLE_CONTROL); + + const struct ofp14_bundle_ctrl_msg *m = b.msg; + msg->bundle_id = ntohl(m->bundle_id); + msg->type = ntohs(m->type); + msg->flags = ntohs(m->flags); + + return 0; +} + struct ofpbuf * -ofputil_encode_group_mod(enum ofp_version ofp_version, - const struct ofputil_group_mod *gm) +ofputil_encode_bundle_ctrl_request(enum ofp_version ofp_version, + struct ofputil_bundle_ctrl_msg *bc) { - switch (ofp_version) { - case OFP10_VERSION: { - if (gm->command == OFPGC11_ADD) { - ovs_fatal(0, "add-group needs OpenFlow 1.1 or later " - "(\'-O OpenFlow11\')"); - } else if (gm->command == OFPGC11_MODIFY) { - ovs_fatal(0, "mod-group needs OpenFlow 1.1 or later " - "(\'-O OpenFlow11\')"); - } else { - ovs_fatal(0, "del-groups needs OpenFlow 1.1 or later " - "(\'-O OpenFlow11\')"); - } - } + struct ofpbuf *request; + struct ofp14_bundle_ctrl_msg *m; + switch (ofp_version) { + case OFP10_VERSION: case OFP11_VERSION: case OFP12_VERSION: case OFP13_VERSION: + ovs_fatal(0, "bundles need OpenFlow 1.4 or later " + "(\'-O OpenFlow14\')"); case OFP14_VERSION: case OFP15_VERSION: - return ofputil_encode_ofp11_group_mod(ofp_version, gm); + request = ofpraw_alloc(OFPRAW_OFPT14_BUNDLE_CONTROL, ofp_version, 0); + m = ofpbuf_put_zeros(request, sizeof *m); + m->bundle_id = htonl(bc->bundle_id); + m->type = htons(bc->type); + m->flags = htons(bc->flags); + break; default: OVS_NOT_REACHED(); } + + return request; } -static enum ofperr -ofputil_pull_ofp11_group_mod(struct ofpbuf *msg, enum ofp_version ofp_version, - struct ofputil_group_mod *gm) +struct ofpbuf * +ofputil_encode_bundle_ctrl_reply(const struct ofp_header *oh, + struct ofputil_bundle_ctrl_msg *msg) { - const struct ofp11_group_mod *ogm; + struct ofpbuf *buf; + struct ofp14_bundle_ctrl_msg *m; - ogm = ofpbuf_pull(msg, sizeof *ogm); - gm->command = ntohs(ogm->command); - gm->type = ogm->type; - gm->group_id = ntohl(ogm->group_id); + buf = ofpraw_alloc_reply(OFPRAW_OFPT14_BUNDLE_CONTROL, oh, 0); + m = ofpbuf_put_zeros(buf, sizeof *m); - return ofputil_pull_ofp11_buckets(msg, ofpbuf_size(msg), ofp_version, - &gm->buckets); + m->bundle_id = htonl(msg->bundle_id); + m->type = htons(msg->type); + m->flags = htons(msg->flags); + + return buf; +} + +/* Return true for bundlable state change requests, false for other messages. + */ +static bool +ofputil_is_bundlable(enum ofptype type) +{ + switch (type) { + /* Minimum required by OpenFlow 1.4. */ + case OFPTYPE_PORT_MOD: + case OFPTYPE_FLOW_MOD: + return true; + + /* Nice to have later. */ + case OFPTYPE_FLOW_MOD_TABLE_ID: + case OFPTYPE_GROUP_MOD: + case OFPTYPE_TABLE_MOD: + case OFPTYPE_METER_MOD: + case OFPTYPE_PACKET_OUT: + case OFPTYPE_NXT_TLV_TABLE_MOD: + + /* Not to be bundlable. */ + case OFPTYPE_ECHO_REQUEST: + case OFPTYPE_FEATURES_REQUEST: + case OFPTYPE_GET_CONFIG_REQUEST: + case OFPTYPE_SET_CONFIG: + case OFPTYPE_BARRIER_REQUEST: + case OFPTYPE_ROLE_REQUEST: + case OFPTYPE_ECHO_REPLY: + case OFPTYPE_SET_FLOW_FORMAT: + case OFPTYPE_SET_PACKET_IN_FORMAT: + case OFPTYPE_SET_CONTROLLER_ID: + case OFPTYPE_FLOW_AGE: + case OFPTYPE_FLOW_MONITOR_CANCEL: + case OFPTYPE_SET_ASYNC_CONFIG: + case OFPTYPE_GET_ASYNC_REQUEST: + case OFPTYPE_DESC_STATS_REQUEST: + case OFPTYPE_FLOW_STATS_REQUEST: + case OFPTYPE_AGGREGATE_STATS_REQUEST: + case OFPTYPE_TABLE_STATS_REQUEST: + case OFPTYPE_TABLE_FEATURES_STATS_REQUEST: + case OFPTYPE_TABLE_DESC_REQUEST: + case OFPTYPE_PORT_STATS_REQUEST: + case OFPTYPE_QUEUE_STATS_REQUEST: + case OFPTYPE_PORT_DESC_STATS_REQUEST: + case OFPTYPE_FLOW_MONITOR_STATS_REQUEST: + case OFPTYPE_METER_STATS_REQUEST: + case OFPTYPE_METER_CONFIG_STATS_REQUEST: + case OFPTYPE_METER_FEATURES_STATS_REQUEST: + case OFPTYPE_GROUP_STATS_REQUEST: + case OFPTYPE_GROUP_DESC_STATS_REQUEST: + case OFPTYPE_GROUP_FEATURES_STATS_REQUEST: + case OFPTYPE_QUEUE_GET_CONFIG_REQUEST: + case OFPTYPE_BUNDLE_CONTROL: + case OFPTYPE_BUNDLE_ADD_MESSAGE: + case OFPTYPE_HELLO: + case OFPTYPE_ERROR: + case OFPTYPE_FEATURES_REPLY: + case OFPTYPE_GET_CONFIG_REPLY: + case OFPTYPE_PACKET_IN: + case OFPTYPE_FLOW_REMOVED: + case OFPTYPE_PORT_STATUS: + case OFPTYPE_BARRIER_REPLY: + case OFPTYPE_QUEUE_GET_CONFIG_REPLY: + case OFPTYPE_DESC_STATS_REPLY: + case OFPTYPE_FLOW_STATS_REPLY: + case OFPTYPE_QUEUE_STATS_REPLY: + case OFPTYPE_PORT_STATS_REPLY: + case OFPTYPE_TABLE_STATS_REPLY: + case OFPTYPE_AGGREGATE_STATS_REPLY: + case OFPTYPE_PORT_DESC_STATS_REPLY: + case OFPTYPE_ROLE_REPLY: + case OFPTYPE_FLOW_MONITOR_PAUSED: + case OFPTYPE_FLOW_MONITOR_RESUMED: + case OFPTYPE_FLOW_MONITOR_STATS_REPLY: + case OFPTYPE_GET_ASYNC_REPLY: + case OFPTYPE_GROUP_STATS_REPLY: + case OFPTYPE_GROUP_DESC_STATS_REPLY: + case OFPTYPE_GROUP_FEATURES_STATS_REPLY: + case OFPTYPE_METER_STATS_REPLY: + case OFPTYPE_METER_CONFIG_STATS_REPLY: + case OFPTYPE_METER_FEATURES_STATS_REPLY: + case OFPTYPE_TABLE_FEATURES_STATS_REPLY: + case OFPTYPE_TABLE_DESC_REPLY: + case OFPTYPE_ROLE_STATUS: + case OFPTYPE_REQUESTFORWARD: + case OFPTYPE_TABLE_STATUS: + case OFPTYPE_NXT_TLV_TABLE_REQUEST: + case OFPTYPE_NXT_TLV_TABLE_REPLY: + case OFPTYPE_NXT_RESUME: + break; + } + + return false; } -/* Converts OpenFlow group mod message 'oh' into an abstract group mod in - * 'gm'. Returns 0 if successful, otherwise an OpenFlow error code. */ enum ofperr -ofputil_decode_group_mod(const struct ofp_header *oh, - struct ofputil_group_mod *gm) +ofputil_decode_bundle_add(const struct ofp_header *oh, + struct ofputil_bundle_add_msg *msg, + enum ofptype *typep) { - enum ofp_version ofp_version = oh->version; - struct ofpbuf msg; - struct ofputil_bucket *bucket; - enum ofperr err; + struct ofpbuf b = ofpbuf_const_initializer(oh, ntohs(oh->length)); + enum ofpraw raw = ofpraw_pull_assert(&b); + ovs_assert(raw == OFPRAW_OFPT14_BUNDLE_ADD_MESSAGE); - ofpbuf_use_const(&msg, oh, ntohs(oh->length)); - ofpraw_pull_assert(&msg); + const struct ofp14_bundle_ctrl_msg *m = ofpbuf_pull(&b, sizeof *m); + msg->bundle_id = ntohl(m->bundle_id); + msg->flags = ntohs(m->flags); - switch (ofp_version) - { - case OFP11_VERSION: - case OFP12_VERSION: - case OFP13_VERSION: - case OFP14_VERSION: - case OFP15_VERSION: - err = ofputil_pull_ofp11_group_mod(&msg, ofp_version, gm); - break; + msg->msg = b.data; + if (msg->msg->version != oh->version) { + return OFPERR_NXBFC_BAD_VERSION; + } + size_t inner_len = ntohs(msg->msg->length); + if (inner_len < sizeof(struct ofp_header) || inner_len > b.size) { + return OFPERR_OFPBFC_MSG_BAD_LEN; + } + if (msg->msg->xid != oh->xid) { + return OFPERR_OFPBFC_MSG_BAD_XID; + } - case OFP10_VERSION: - default: - OVS_NOT_REACHED(); + /* Reject unbundlable messages. */ + enum ofptype type; + enum ofperr error = ofptype_decode(&type, msg->msg); + if (error) { + VLOG_WARN_RL(&bad_ofmsg_rl, "OFPT14_BUNDLE_ADD_MESSAGE contained " + "message is unparsable (%s)", ofperr_get_name(error)); + return OFPERR_OFPBFC_MSG_UNSUP; /* 'error' would be confusing. */ } - if (err) { - return err; + if (!ofputil_is_bundlable(type)) { + VLOG_WARN_RL(&bad_ofmsg_rl, "%s message not allowed inside " + "OFPT14_BUNDLE_ADD_MESSAGE", ofptype_get_name(type)); + return OFPERR_OFPBFC_MSG_UNSUP; + } + if (typep) { + *typep = type; } - switch (gm->type) { - case OFPGT11_INDIRECT: - if (!list_is_singleton(&gm->buckets)) { - return OFPERR_OFPGMFC_INVALID_GROUP; - } - break; - case OFPGT11_ALL: - case OFPGT11_SELECT: - case OFPGT11_FF: - break; - default: - OVS_NOT_REACHED(); + return 0; +} + +struct ofpbuf * +ofputil_encode_bundle_add(enum ofp_version ofp_version, + struct ofputil_bundle_add_msg *msg) +{ + struct ofpbuf *request; + struct ofp14_bundle_ctrl_msg *m; + + /* Must use the same xid as the embedded message. */ + request = ofpraw_alloc_xid(OFPRAW_OFPT14_BUNDLE_ADD_MESSAGE, ofp_version, + msg->msg->xid, 0); + m = ofpbuf_put_zeros(request, sizeof *m); + + m->bundle_id = htonl(msg->bundle_id); + m->flags = htons(msg->flags); + ofpbuf_put(request, msg->msg, ntohs(msg->msg->length)); + + return request; +} + +static void +encode_tlv_table_mappings(struct ofpbuf *b, struct ovs_list *mappings) +{ + struct ofputil_tlv_map *map; + + LIST_FOR_EACH (map, list_node, mappings) { + struct nx_tlv_map *nx_map; + + nx_map = ofpbuf_put_zeros(b, sizeof *nx_map); + nx_map->option_class = htons(map->option_class); + nx_map->option_type = map->option_type; + nx_map->option_len = map->option_len; + nx_map->index = htons(map->index); } +} - LIST_FOR_EACH (bucket, list_node, &gm->buckets) { - switch (gm->type) { - case OFPGT11_ALL: - case OFPGT11_INDIRECT: - if (ofputil_bucket_has_liveness(bucket)) { - return OFPERR_OFPGMFC_WATCH_UNSUPPORTED; - } - break; - case OFPGT11_SELECT: - break; - case OFPGT11_FF: - if (!ofputil_bucket_has_liveness(bucket)) { - return OFPERR_OFPGMFC_INVALID_GROUP; - } - break; - default: - OVS_NOT_REACHED(); +struct ofpbuf * +ofputil_encode_tlv_table_mod(enum ofp_version ofp_version, + struct ofputil_tlv_table_mod *ttm) +{ + struct ofpbuf *b; + struct nx_tlv_table_mod *nx_ttm; + + b = ofpraw_alloc(OFPRAW_NXT_TLV_TABLE_MOD, ofp_version, 0); + nx_ttm = ofpbuf_put_zeros(b, sizeof *nx_ttm); + nx_ttm->command = htons(ttm->command); + encode_tlv_table_mappings(b, &ttm->mappings); + + return b; +} + +static enum ofperr +decode_tlv_table_mappings(struct ofpbuf *msg, unsigned int max_fields, + struct ovs_list *mappings) +{ + list_init(mappings); + + while (msg->size) { + struct nx_tlv_map *nx_map; + struct ofputil_tlv_map *map; + + nx_map = ofpbuf_pull(msg, sizeof *nx_map); + map = xmalloc(sizeof *map); + list_push_back(mappings, &map->list_node); + + map->option_class = ntohs(nx_map->option_class); + map->option_type = nx_map->option_type; + + map->option_len = nx_map->option_len; + if (map->option_len % 4 || map->option_len > TLV_MAX_OPT_SIZE) { + VLOG_WARN_RL(&bad_ofmsg_rl, + "tlv table option length (%u) is not a valid option size", + map->option_len); + ofputil_uninit_tlv_table(mappings); + return OFPERR_NXTTMFC_BAD_OPT_LEN; + } + + map->index = ntohs(nx_map->index); + if (map->index >= max_fields) { + VLOG_WARN_RL(&bad_ofmsg_rl, + "tlv table field index (%u) is too large (max %u)", + map->index, max_fields - 1); + ofputil_uninit_tlv_table(mappings); + return OFPERR_NXTTMFC_BAD_FIELD_IDX; } } return 0; } -/* Parse a queue status request message into 'oqsr'. - * Returns 0 if successful, otherwise an OFPERR_* number. */ enum ofperr -ofputil_decode_queue_stats_request(const struct ofp_header *request, - struct ofputil_queue_stats_request *oqsr) +ofputil_decode_tlv_table_mod(const struct ofp_header *oh, + struct ofputil_tlv_table_mod *ttm) { - switch ((enum ofp_version)request->version) { - case OFP15_VERSION: - case OFP14_VERSION: - case OFP13_VERSION: - case OFP12_VERSION: - case OFP11_VERSION: { - const struct ofp11_queue_stats_request *qsr11 = ofpmsg_body(request); - oqsr->queue_id = ntohl(qsr11->queue_id); - return ofputil_port_from_ofp11(qsr11->port_no, &oqsr->port_no); - } + struct ofpbuf msg = ofpbuf_const_initializer(oh, ntohs(oh->length)); + ofpraw_pull_assert(&msg); - case OFP10_VERSION: { - 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; + struct nx_tlv_table_mod *nx_ttm = ofpbuf_pull(&msg, sizeof *nx_ttm); + ttm->command = ntohs(nx_ttm->command); + if (ttm->command > NXTTMC_CLEAR) { + VLOG_WARN_RL(&bad_ofmsg_rl, + "tlv table mod command (%u) is out of range", + ttm->command); + return OFPERR_NXTTMFC_BAD_COMMAND; } - default: - OVS_NOT_REACHED(); - } + return decode_tlv_table_mappings(&msg, TUN_METADATA_NUM_OPTS, + &ttm->mappings); } -/* Encode a queue statsrequest for 'oqsr', the encoded message - * will be fore Open Flow version 'ofp_version'. Returns message - * as a struct ofpbuf. Returns encoded message on success, NULL on error */ struct ofpbuf * -ofputil_encode_queue_stats_request(enum ofp_version ofp_version, - const struct ofputil_queue_stats_request *oqsr) +ofputil_encode_tlv_table_reply(const struct ofp_header *oh, + struct ofputil_tlv_table_reply *ttr) { - struct ofpbuf *request; + struct ofpbuf *b; + struct nx_tlv_table_reply *nx_ttr; - switch (ofp_version) { - case OFP11_VERSION: - case OFP12_VERSION: - case OFP13_VERSION: - case OFP14_VERSION: - case OFP15_VERSION: { - struct ofp11_queue_stats_request *req; - request = ofpraw_alloc(OFPRAW_OFPST11_QUEUE_REQUEST, ofp_version, 0); - req = ofpbuf_put_zeros(request, sizeof *req); - req->port_no = ofputil_port_to_ofp11(oqsr->port_no); - req->queue_id = htonl(oqsr->queue_id); - break; - } - case OFP10_VERSION: { - struct ofp10_queue_stats_request *req; - 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(ofp_to_u16(oqsr->port_no == OFPP_ANY - ? OFPP_ALL : oqsr->port_no)); - req->queue_id = htonl(oqsr->queue_id); - break; - } - default: - OVS_NOT_REACHED(); - } + b = ofpraw_alloc_reply(OFPRAW_NXT_TLV_TABLE_REPLY, oh, 0); + nx_ttr = ofpbuf_put_zeros(b, sizeof *nx_ttr); + nx_ttr->max_option_space = htonl(ttr->max_option_space); + nx_ttr->max_fields = htons(ttr->max_fields); - return request; + encode_tlv_table_mappings(b, &ttr->mappings); + + return b; } -/* Returns the number of queue stats elements in OFPTYPE_QUEUE_STATS_REPLY - * message 'oh'. */ -size_t -ofputil_count_queue_stats(const struct ofp_header *oh) +/* Decodes the NXT_TLV_TABLE_REPLY message in 'oh' into '*ttr'. Returns 0 + * if successful, otherwise an ofperr. + * + * The decoder verifies that the indexes in 'ttr->mappings' are less than + * 'ttr->max_fields', but the caller must ensure, if necessary, that they are + * less than TUN_METADATA_NUM_OPTS. */ +enum ofperr +ofputil_decode_tlv_table_reply(const struct ofp_header *oh, + struct ofputil_tlv_table_reply *ttr) { - struct ofputil_queue_stats qs; - struct ofpbuf b; - size_t n = 0; + struct ofpbuf msg = ofpbuf_const_initializer(oh, ntohs(oh->length)); + ofpraw_pull_assert(&msg); - ofpbuf_use_const(&b, oh, ntohs(oh->length)); - ofpraw_pull_assert(&b); - while (!ofputil_decode_queue_stats(&qs, &b)) { - n++; - } - return n; + struct nx_tlv_table_reply *nx_ttr = ofpbuf_pull(&msg, sizeof *nx_ttr); + ttr->max_option_space = ntohl(nx_ttr->max_option_space); + ttr->max_fields = ntohs(nx_ttr->max_fields); + + return decode_tlv_table_mappings(&msg, ttr->max_fields, &ttr->mappings); } -static enum ofperr -ofputil_queue_stats_from_ofp10(struct ofputil_queue_stats *oqs, - const struct ofp10_queue_stats *qs10) +void +ofputil_uninit_tlv_table(struct ovs_list *mappings) { - oqs->port_no = u16_to_ofp(ntohs(qs10->port_no)); - oqs->queue_id = ntohl(qs10->queue_id); - 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; + struct ofputil_tlv_map *map; - return 0; + LIST_FOR_EACH_POP (map, list_node, mappings) { + free(map); + } } -static enum ofperr -ofputil_queue_stats_from_ofp11(struct ofputil_queue_stats *oqs, - const struct ofp11_queue_stats *qs11) +const char * +ofputil_async_msg_type_to_string(enum ofputil_async_msg_type type) { - enum ofperr error; - - error = ofputil_port_from_ofp11(qs11->port_no, &oqs->port_no); - if (error) { - return error; + switch (type) { + case OAM_PACKET_IN: return "PACKET_IN"; + case OAM_PORT_STATUS: return "PORT_STATUS"; + case OAM_FLOW_REMOVED: return "FLOW_REMOVED"; + case OAM_ROLE_STATUS: return "ROLE_STATUS"; + case OAM_TABLE_STATUS: return "TABLE_STATUS"; + case OAM_REQUESTFORWARD: return "REQUESTFORWARD"; + + case OAM_N_TYPES: + default: + OVS_NOT_REACHED(); } +} - oqs->queue_id = ntohl(qs11->queue_id); - 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; +struct ofp14_async_prop { + uint64_t prop_type; + enum ofputil_async_msg_type oam; + bool master; + uint32_t allowed10, allowed14; +}; - return 0; -} +#define AP_PAIR(SLAVE_PROP_TYPE, OAM, A10, A14) \ + { SLAVE_PROP_TYPE, OAM, false, A10, (A14) ? (A14) : (A10) }, \ + { (SLAVE_PROP_TYPE + 1), OAM, true, A10, (A14) ? (A14) : (A10) } + +static const struct ofp14_async_prop async_props[] = { + AP_PAIR( 0, OAM_PACKET_IN, OFPR10_BITS, OFPR14_BITS), + AP_PAIR( 2, OAM_PORT_STATUS, (1 << OFPPR_N_REASONS) - 1, 0), + AP_PAIR( 4, OAM_FLOW_REMOVED, (1 << OVS_OFPRR_NONE) - 1, 0), + AP_PAIR( 6, OAM_ROLE_STATUS, (1 << OFPCRR_N_REASONS) - 1, 0), + AP_PAIR( 8, OAM_TABLE_STATUS, OFPTR_BITS, 0), + AP_PAIR(10, OAM_REQUESTFORWARD, (1 << OFPRFR_N_REASONS) - 1, 0), +}; -static enum ofperr -ofputil_queue_stats_from_ofp13(struct ofputil_queue_stats *oqs, - const struct ofp13_queue_stats *qs13) +#define FOR_EACH_ASYNC_PROP(VAR) \ + for (const struct ofp14_async_prop *VAR = async_props; \ + VAR < &async_props[ARRAY_SIZE(async_props)]; VAR++) + +static const struct ofp14_async_prop * +get_ofp14_async_config_prop_by_prop_type(uint64_t prop_type) { - enum ofperr error = ofputil_queue_stats_from_ofp11(oqs, &qs13->qs); - if (!error) { - oqs->duration_sec = ntohl(qs13->duration_sec); - oqs->duration_nsec = ntohl(qs13->duration_nsec); + FOR_EACH_ASYNC_PROP (ap) { + if (prop_type == ap->prop_type) { + return ap; + } } + return NULL; +} - return error; +static const struct ofp14_async_prop * +get_ofp14_async_config_prop_by_oam(enum ofputil_async_msg_type oam, + bool master) +{ + FOR_EACH_ASYNC_PROP (ap) { + if (ap->oam == oam && ap->master == master) { + return ap; + } + } + return NULL; } -static enum ofperr -ofputil_pull_ofp14_queue_stats(struct ofputil_queue_stats *oqs, - struct ofpbuf *msg) +static uint32_t +ofp14_async_prop_allowed(const struct ofp14_async_prop *prop, + enum ofp_version version) { - const struct ofp14_queue_stats *qs14; - size_t len; + return version >= OFP14_VERSION ? prop->allowed14 : prop->allowed10; +} - qs14 = ofpbuf_try_pull(msg, sizeof *qs14); - if (!qs14) { - return OFPERR_OFPBRC_BAD_LEN; - } +static ovs_be32 +encode_async_mask(const struct ofputil_async_cfg *src, + const struct ofp14_async_prop *ap, + enum ofp_version version) +{ + uint32_t mask = ap->master ? src->master[ap->oam] : src->slave[ap->oam]; + return htonl(mask & ofp14_async_prop_allowed(ap, version)); +} - len = ntohs(qs14->length); - if (len < sizeof *qs14 || len - sizeof *qs14 > ofpbuf_size(msg)) { - return OFPERR_OFPBRC_BAD_LEN; +static enum ofperr +decode_async_mask(ovs_be32 src, + const struct ofp14_async_prop *ap, enum ofp_version version, + bool loose, struct ofputil_async_cfg *dst) +{ + uint32_t mask = ntohl(src); + uint32_t allowed = ofp14_async_prop_allowed(ap, version); + if (mask & ~allowed) { + OFPPROP_LOG(&bad_ofmsg_rl, loose, + "bad value %#x for %s (allowed mask %#x)", + mask, ofputil_async_msg_type_to_string(ap->oam), + allowed); + mask &= allowed; + if (!loose) { + return OFPERR_OFPACFC_INVALID; + } + } + + if (ap->oam == OAM_PACKET_IN) { + if (mask & (1u << OFPR_NO_MATCH)) { + mask |= 1u << OFPR_EXPLICIT_MISS; + if (version < OFP13_VERSION) { + mask |= 1u << OFPR_IMPLICIT_MISS; + } + } } - ofpbuf_pull(msg, len - sizeof *qs14); - - /* No properties yet defined, so ignore them for now. */ - return ofputil_queue_stats_from_ofp13(oqs, &qs14->qs); + uint32_t *array = ap->master ? dst->master : dst->slave; + array[ap->oam] = mask; + return 0; } -/* Converts an OFPST_QUEUE_STATS reply in 'msg' into an abstract - * ofputil_queue_stats in 'qs'. - * - * Multiple OFPST_QUEUE_STATS replies can be packed into a single OpenFlow - * message. Calling this function multiple times for a single 'msg' iterates - * through the replies. The caller must initially leave 'msg''s layer pointers - * null and not modify them between calls. - * - * Returns 0 if successful, EOF if no replies were left in this 'msg', - * otherwise a positive errno value. */ -int -ofputil_decode_queue_stats(struct ofputil_queue_stats *qs, struct ofpbuf *msg) +static enum ofperr +parse_async_tlv(const struct ofpbuf *property, + const struct ofp14_async_prop *ap, + struct ofputil_async_cfg *ac, + enum ofp_version version, bool loose) { enum ofperr error; - enum ofpraw raw; + ovs_be32 mask; - error = (msg->frame - ? ofpraw_decode(&raw, msg->frame) - : ofpraw_pull(&raw, msg)); + error = ofpprop_parse_be32(property, &mask); if (error) { return error; } - if (!ofpbuf_size(msg)) { - return EOF; - } else if (raw == OFPRAW_OFPST14_QUEUE_REPLY) { - return ofputil_pull_ofp14_queue_stats(qs, msg); - } 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) { - goto bad_len; - } - return ofputil_queue_stats_from_ofp11(qs, qs11); - } else if (raw == OFPRAW_OFPST10_QUEUE_REPLY) { - const struct ofp10_queue_stats *qs10; - - qs10 = ofpbuf_try_pull(msg, sizeof *qs10); - if (!qs10) { - goto bad_len; + if (ofpprop_is_experimenter(ap->prop_type)) { + /* For experimenter properties, whether a property is for the master or + * slave role is indicated by both 'type' and 'exp_type' in struct + * ofp_prop_experimenter. Check that these are consistent. */ + const struct ofp_prop_experimenter *ope = property->data; + bool should_be_master = ope->type == htons(0xffff); + if (should_be_master != ap->master) { + VLOG_WARN_RL(&bad_ofmsg_rl, "async property type %#"PRIx16" " + "indicates %s role but exp_type %"PRIu32" indicates " + "%s role", + ntohs(ope->type), + should_be_master ? "master" : "slave", + ntohl(ope->exp_type), + ap->master ? "master" : "slave"); + return OFPERR_OFPBPC_BAD_EXP_TYPE; } - return ofputil_queue_stats_from_ofp10(qs, qs10); - } else { - OVS_NOT_REACHED(); } - bad_len: - VLOG_WARN_RL(&bad_ofmsg_rl, "OFPST_QUEUE reply has %"PRIu32" leftover " - "bytes at end", ofpbuf_size(msg)); - return OFPERR_OFPBRC_BAD_LEN; + return decode_async_mask(mask, ap, version, loose, ac); } static void -ofputil_queue_stats_to_ofp10(const struct ofputil_queue_stats *oqs, - struct ofp10_queue_stats *qs10) +decode_legacy_async_masks(const ovs_be32 masks[2], + enum ofputil_async_msg_type oam, + enum ofp_version version, + struct ofputil_async_cfg *dst) { - 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->tx_bytes)); - put_32aligned_be64(&qs10->tx_packets, htonll(oqs->tx_packets)); - put_32aligned_be64(&qs10->tx_errors, htonll(oqs->tx_errors)); + for (int i = 0; i < 2; i++) { + bool master = i == 0; + const struct ofp14_async_prop *ap + = get_ofp14_async_config_prop_by_oam(oam, master); + decode_async_mask(masks[i], ap, version, true, dst); + } +} + +/* Decodes the OpenFlow "set async config" request and "get async config + * reply" message in '*oh' into an abstract form in 'ac'. + * + * Some versions of the "set async config" request change only some of the + * settings and leave the others alone. This function uses 'basis' as the + * initial state for decoding these. Other versions of the request change all + * the settings; this function ignores 'basis' when decoding these. + * + * If 'loose' is true, this function ignores properties and values that it does + * not understand, as a controller would want to do when interpreting + * capabilities provided by a switch. If 'loose' is false, this function + * treats unknown properties and values as an error, as a switch would want to + * do when interpreting a configuration request made by a controller. + * + * Returns 0 if successful, otherwise an OFPERR_* value. + * + * Returns error code OFPERR_OFPACFC_INVALID if the value of mask is not in + * the valid range of mask. + * + * Returns error code OFPERR_OFPACFC_UNSUPPORTED if the configuration is not + * supported.*/ +enum ofperr +ofputil_decode_set_async_config(const struct ofp_header *oh, bool loose, + const struct ofputil_async_cfg *basis, + struct ofputil_async_cfg *ac) +{ + struct ofpbuf b = ofpbuf_const_initializer(oh, ntohs(oh->length)); + enum ofpraw raw = ofpraw_pull_assert(&b); + + if (raw == OFPRAW_OFPT13_SET_ASYNC || + raw == OFPRAW_NXT_SET_ASYNC_CONFIG || + raw == OFPRAW_OFPT13_GET_ASYNC_REPLY) { + const struct nx_async_config *msg = ofpmsg_body(oh); + + *ac = OFPUTIL_ASYNC_CFG_INIT; + decode_legacy_async_masks(msg->packet_in_mask, OAM_PACKET_IN, + oh->version, ac); + decode_legacy_async_masks(msg->port_status_mask, OAM_PORT_STATUS, + oh->version, ac); + decode_legacy_async_masks(msg->flow_removed_mask, OAM_FLOW_REMOVED, + oh->version, ac); + } else if (raw == OFPRAW_OFPT14_SET_ASYNC || + raw == OFPRAW_OFPT14_GET_ASYNC_REPLY || + raw == OFPRAW_NXT_SET_ASYNC_CONFIG2) { + *ac = *basis; + while (b.size > 0) { + struct ofpbuf property; + enum ofperr error; + uint64_t type; + + error = ofpprop_pull__(&b, &property, 8, 0xfffe, &type); + if (error) { + return error; + } + + const struct ofp14_async_prop *ap + = get_ofp14_async_config_prop_by_prop_type(type); + error = (ap + ? parse_async_tlv(&property, ap, ac, oh->version, loose) + : OFPPROP_UNKNOWN(loose, "async config", type)); + if (error) { + /* Most messages use OFPBPC_BAD_TYPE but async has its own (who + * knows why, it's OpenFlow. */ + if (error == OFPERR_OFPBPC_BAD_TYPE) { + error = OFPERR_OFPACFC_UNSUPPORTED; + } + return error; + } + } + } else { + return OFPERR_OFPBRC_BAD_VERSION; + } + return 0; } static void -ofputil_queue_stats_to_ofp11(const struct ofputil_queue_stats *oqs, - struct ofp11_queue_stats *qs11) +encode_legacy_async_masks(const struct ofputil_async_cfg *ac, + enum ofputil_async_msg_type oam, + enum ofp_version version, + ovs_be32 masks[2]) { - qs11->port_no = ofputil_port_to_ofp11(oqs->port_no); - qs11->queue_id = htonl(oqs->queue_id); - qs11->tx_bytes = htonll(oqs->tx_bytes); - qs11->tx_packets = htonll(oqs->tx_packets); - qs11->tx_errors = htonll(oqs->tx_errors); + for (int i = 0; i < 2; i++) { + bool master = i == 0; + const struct ofp14_async_prop *ap + = get_ofp14_async_config_prop_by_oam(oam, master); + masks[i] = encode_async_mask(ac, ap, version); + } } 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); - if (oqs->duration_sec != UINT32_MAX) { - qs13->duration_sec = htonl(oqs->duration_sec); - qs13->duration_nsec = htonl(oqs->duration_nsec); +ofputil_put_async_config__(const struct ofputil_async_cfg *ac, + struct ofpbuf *buf, bool tlv, + enum ofp_version version, uint32_t oams) +{ + if (!tlv) { + struct nx_async_config *msg = ofpbuf_put_zeros(buf, sizeof *msg); + encode_legacy_async_masks(ac, OAM_PACKET_IN, version, + msg->packet_in_mask); + encode_legacy_async_masks(ac, OAM_PORT_STATUS, version, + msg->port_status_mask); + encode_legacy_async_masks(ac, OAM_FLOW_REMOVED, version, + msg->flow_removed_mask); } else { - qs13->duration_sec = OVS_BE32_MAX; - qs13->duration_nsec = OVS_BE32_MAX; + FOR_EACH_ASYNC_PROP (ap) { + if (oams & (1u << ap->oam)) { + size_t ofs = buf->size; + ofpprop_put_be32(buf, ap->prop_type, + encode_async_mask(ac, ap, version)); + + /* For experimenter properties, we need to use type 0xfffe for + * master and 0xffff for slaves. */ + if (ofpprop_is_experimenter(ap->prop_type)) { + struct ofp_prop_experimenter *ope + = ofpbuf_at_assert(buf, ofs, sizeof *ope); + ope->type = ap->master ? htons(0xffff) : htons(0xfffe); + } + } + } } } -static void -ofputil_queue_stats_to_ofp14(const struct ofputil_queue_stats *oqs, - struct ofp14_queue_stats *qs14) +/* Encodes and returns a reply to the OFPT_GET_ASYNC_REQUEST in 'oh' that + * states that the asynchronous message configuration is 'ac'. */ +struct ofpbuf * +ofputil_encode_get_async_reply(const struct ofp_header *oh, + const struct ofputil_async_cfg *ac) { - qs14->length = htons(sizeof *qs14); - memset(qs14->pad, 0, sizeof qs14->pad); - ofputil_queue_stats_to_ofp13(oqs, &qs14->qs); + struct ofpbuf *buf; + + enum ofpraw raw = (oh->version < OFP14_VERSION + ? OFPRAW_OFPT13_GET_ASYNC_REPLY + : OFPRAW_OFPT14_GET_ASYNC_REPLY); + struct ofpbuf *reply = ofpraw_alloc_reply(raw, oh, 0); + ofputil_put_async_config__(ac, reply, + raw == OFPRAW_OFPT14_GET_ASYNC_REPLY, + oh->version, UINT32_MAX); + return reply; + + return buf; } +/* Encodes and returns a message, in a format appropriate for OpenFlow version + * 'ofp_version', that sets the asynchronous message configuration to 'ac'. + * + * Specify 'oams' as a bitmap of OAM_* that indicate the asynchronous messages + * to configure. OF1.0 through OF1.3 can't natively configure a subset of + * messages, so more messages than requested may be configured. OF1.0 through + * OF1.3 also can't configure OVS extension OAM_* values, so if 'oam' includes + * any extensions then this function encodes an Open vSwitch extension message + * that does support configuring OVS extension OAM_*. */ +struct ofpbuf * +ofputil_encode_set_async_config(const struct ofputil_async_cfg *ac, + uint32_t oams, enum ofp_version ofp_version) +{ + enum ofpraw raw = (ofp_version >= OFP14_VERSION ? OFPRAW_OFPT14_SET_ASYNC + : oams & OAM_EXTENSIONS ? OFPRAW_NXT_SET_ASYNC_CONFIG2 + : ofp_version >= OFP13_VERSION ? OFPRAW_OFPT13_SET_ASYNC + : OFPRAW_NXT_SET_ASYNC_CONFIG); + struct ofpbuf *request = ofpraw_alloc(raw, ofp_version, 0); + ofputil_put_async_config__(ac, request, + (raw == OFPRAW_OFPT14_SET_ASYNC || + raw == OFPRAW_NXT_SET_ASYNC_CONFIG2), + ofp_version, oams); + return request; +} -/* Encode a queue stat for 'oqs' and append it to 'replies'. */ -void -ofputil_append_queue_stat(struct list *replies, - const struct ofputil_queue_stats *oqs) +struct ofputil_async_cfg +ofputil_async_cfg_default(enum ofp_version version) { - switch (ofpmp_version(replies)) { - 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); - ofputil_queue_stats_to_ofp11(oqs, reply); - break; + /* We enable all of the OF1.4 reasons regardless of 'version' because the + * reasons added in OF1.4 just are just refinements of the OFPR_ACTION + * introduced in OF1.0, breaking it into more specific categories. When we + * encode these for earlier OpenFlow versions, we translate them into + * OFPR_ACTION. */ + uint32_t pin = OFPR14_BITS & ~(1u << OFPR_INVALID_TTL); + pin |= 1u << OFPR_EXPLICIT_MISS; + if (version <= OFP12_VERSION) { + pin |= 1u << OFPR_IMPLICIT_MISS; } - case OFP10_VERSION: { - struct ofp10_queue_stats *reply = ofpmp_append(replies, sizeof *reply); - ofputil_queue_stats_to_ofp10(oqs, reply); - break; - } + return (struct ofputil_async_cfg) { + .master[OAM_PACKET_IN] = pin, - case OFP14_VERSION: - case OFP15_VERSION: { - struct ofp14_queue_stats *reply = ofpmp_append(replies, sizeof *reply); - ofputil_queue_stats_to_ofp14(oqs, reply); - break; - } + .master[OAM_FLOW_REMOVED] + = (version >= OFP14_VERSION ? OFPRR14_BITS : OFPRR10_BITS), - default: - OVS_NOT_REACHED(); - } + .master[OAM_PORT_STATUS] = OFPPR_BITS, + .slave[OAM_PORT_STATUS] = OFPPR_BITS, + }; } -enum ofperr -ofputil_decode_bundle_ctrl(const struct ofp_header *oh, - struct ofputil_bundle_ctrl_msg *msg) +static void +ofputil_put_ofp14_table_desc(const struct ofputil_table_desc *td, + struct ofpbuf *b, enum ofp_version version) { - struct ofpbuf b; - enum ofpraw raw; - const struct ofp14_bundle_ctrl_msg *m; + struct ofp14_table_desc *otd; + struct ofp14_table_mod_prop_vacancy *otv; + size_t start_otd; - ofpbuf_use_const(&b, oh, ntohs(oh->length)); - raw = ofpraw_pull_assert(&b); - ovs_assert(raw == OFPRAW_OFPT14_BUNDLE_CONTROL); + start_otd = b->size; + ofpbuf_put_zeros(b, sizeof *otd); - m = ofpbuf_l3(&b); - msg->bundle_id = ntohl(m->bundle_id); - msg->type = ntohs(m->type); - msg->flags = ntohs(m->flags); + ofpprop_put_u32(b, OFPTMPT14_EVICTION, td->eviction_flags); - return 0; + otv = ofpbuf_put_zeros(b, sizeof *otv); + otv->type = htons(OFPTMPT14_VACANCY); + otv->length = htons(sizeof *otv); + otv->vacancy_down = td->table_vacancy.vacancy_down; + otv->vacancy_up = td->table_vacancy.vacancy_up; + otv->vacancy = td->table_vacancy.vacancy; + + otd = ofpbuf_at_assert(b, start_otd, sizeof *otd); + otd->length = htons(b->size - start_otd); + otd->table_id = td->table_id; + otd->config = ofputil_encode_table_config(OFPUTIL_TABLE_MISS_DEFAULT, + td->eviction, td->vacancy, + version); } +/* Converts the abstract form of a "table status" message in '*ts' into an + * OpenFlow message suitable for 'protocol', and returns that encoded form in + * a buffer owned by the caller. */ struct ofpbuf * -ofputil_encode_bundle_ctrl_reply(const struct ofp_header *oh, - struct ofputil_bundle_ctrl_msg *msg) +ofputil_encode_table_status(const struct ofputil_table_status *ts, + enum ofputil_protocol protocol) { - struct ofpbuf *buf; - struct ofp14_bundle_ctrl_msg *m; - - buf = ofpraw_alloc_reply(OFPRAW_OFPT14_BUNDLE_CONTROL, oh, 0); - m = ofpbuf_put_zeros(buf, sizeof *m); - - m->bundle_id = htonl(msg->bundle_id); - m->type = htons(msg->type); - m->flags = htons(msg->flags); + enum ofp_version version; + struct ofpbuf *b; - return buf; + version = ofputil_protocol_to_ofp_version(protocol); + if (version >= OFP14_VERSION) { + enum ofpraw raw; + struct ofp14_table_status *ots; + + raw = OFPRAW_OFPT14_TABLE_STATUS; + b = ofpraw_alloc_xid(raw, version, htonl(0), 0); + ots = ofpbuf_put_zeros(b, sizeof *ots); + ots->reason = ts->reason; + ofputil_put_ofp14_table_desc(&ts->desc, b, version); + ofpmsg_update_length(b); + return b; + } else { + return NULL; + } } +/* Decodes the OpenFlow "table status" message in '*ots' into an abstract form + * in '*ts'. Returns 0 if successful, otherwise an OFPERR_* value. */ enum ofperr -ofputil_decode_bundle_add(const struct ofp_header *oh, - struct ofputil_bundle_add_msg *msg) +ofputil_decode_table_status(const struct ofp_header *oh, + struct ofputil_table_status *ts) { - const struct ofp14_bundle_ctrl_msg *m; + const struct ofp14_table_status *ots; struct ofpbuf b; + enum ofperr error; enum ofpraw raw; - size_t inner_len; ofpbuf_use_const(&b, oh, ntohs(oh->length)); raw = ofpraw_pull_assert(&b); - ovs_assert(raw == OFPRAW_OFPT14_BUNDLE_ADD_MESSAGE); + ots = ofpbuf_pull(&b, sizeof *ots); - m = ofpbuf_pull(&b, sizeof *m); - msg->bundle_id = ntohl(m->bundle_id); - msg->flags = ntohs(m->flags); + if (raw == OFPRAW_OFPT14_TABLE_STATUS) { + if (ots->reason != OFPTR_VACANCY_DOWN + && ots->reason != OFPTR_VACANCY_UP) { + return OFPERR_OFPBPC_BAD_VALUE; + } + ts->reason = ots->reason; - msg->msg = ofpbuf_data(&b); - inner_len = ntohs(msg->msg->length); - if (inner_len < sizeof(struct ofp_header) || inner_len > ofpbuf_size(&b)) { - return OFPERR_OFPBFC_MSG_BAD_LEN; + error = ofputil_decode_table_desc(&b, &ts->desc, oh->version); + return error; + } else { + return OFPERR_OFPBRC_BAD_VERSION; } return 0; } - -struct ofpbuf * -ofputil_encode_bundle_add(enum ofp_version ofp_version, - struct ofputil_bundle_add_msg *msg) -{ - struct ofpbuf *request; - struct ofp14_bundle_ctrl_msg *m; - - request = ofpraw_alloc(OFPRAW_OFPT14_BUNDLE_ADD_MESSAGE, ofp_version, 0); - m = ofpbuf_put_zeros(request, sizeof *m); - - m->bundle_id = htonl(msg->bundle_id); - m->flags = htons(msg->flags); - ofpbuf_put(request, msg->msg, ntohs(msg->msg->length)); - - return request; -}