X-Git-Url: http://git.cascardo.eti.br/?a=blobdiff_plain;f=lib%2Fofp-util.c;h=a0da289d0b601a2e6e3d73b4ba685171b5f7e721;hb=0c4b9393b6a5792b888d4b580e04cc3fa64ebc12;hp=6d551ada4949e38ae5e0511cfaf70d3578a83a88;hpb=0e6126754d1023d22e8111e615bf501d22f18aff;p=cascardo%2Fovs.git diff --git a/lib/ofp-util.c b/lib/ofp-util.c index 6d551ada4..a0da289d0 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 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,18 @@ #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-util.h" #include "ofpbuf.h" +#include "openflow/netronome-ext.h" #include "packets.h" #include "random.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,41 +52,72 @@ 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; }; +struct ofp_prop_experimenter { + ovs_be16 type; /* OFP*_EXPERIMENTER. */ + ovs_be16 length; /* Length in bytes of this property. */ + ovs_be32 experimenter; /* Experimenter ID which takes the same form as + * in struct ofp_experimenter_header. */ + ovs_be32 exp_type; /* Experimenter defined. */ +}; + /* 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. */ + * 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, - uint16_t *typep) +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) { + if (msg->size < sizeof *oph) { return OFPERR_OFPBPC_BAD_LEN; } - oph = ofpbuf_data(msg); + oph = msg->data; len = ntohs(oph->len); - if (len < sizeof *oph || ROUND_UP(len, 8) > ofpbuf_size(msg)) { + padded_len = ROUND_UP(len, alignment); + if (len < sizeof *oph || padded_len > msg->size) { return OFPERR_OFPBPC_BAD_LEN; } *typep = ntohs(oph->type); if (property) { - ofpbuf_use_const(property, ofpbuf_data(msg), len); + ofpbuf_use_const(property, msg->data, len); } - ofpbuf_pull(msg, ROUND_UP(len, 8)); + ofpbuf_pull(msg, padded_len); return 0; } -static void PRINTF_FORMAT(2, 3) +/* 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 OVS_PRINTF_FORMAT(2, 3) log_property(bool loose, const char *message, ...) { enum vlog_level level = loose ? VLL_DBG : VLL_WARN; @@ -97,6 +130,36 @@ log_property(bool loose, const char *message, ...) } } +static size_t +start_property(struct ofpbuf *msg, uint16_t type) +{ + size_t start_ofs = msg->size; + 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(msg->size - start_ofs); + ofpbuf_padto(msg, ROUND_UP(msg->size, 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)); + } +} + /* 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 * is wildcarded. @@ -132,7 +195,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 == 27); + BUILD_ASSERT_DECL(FLOW_WC_SEQ == 31); /* Initialize most of wc. */ flow_wildcards_init_catchall(wc); @@ -312,10 +375,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; } @@ -325,7 +388,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); @@ -1299,15 +1362,15 @@ ofputil_decode_hello(const struct ofp_header *oh, uint32_t *allowed_versions) ofpbuf_pull(&msg, sizeof *oh); *allowed_versions = version_bitmap_from_version(oh->version); - while (ofpbuf_size(&msg)) { + 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; @@ -1612,12 +1675,6 @@ ofputil_decode_flow_mod(struct ofputil_flow_mod *fm, return error; } - error = ofpacts_pull_openflow_instructions(&b, ofpbuf_size(&b), oh->version, - ofpacts); - if (error) { - return error; - } - /* Translate the message. */ fm->priority = ntohs(ofm->priority); if (ofm->command == OFPFC_ADD @@ -1653,6 +1710,11 @@ ofputil_decode_flow_mod(struct ofputil_flow_mod *fm, fm->idle_timeout = ntohs(ofm->idle_timeout); fm->hard_timeout = ntohs(ofm->hard_timeout); + if (oh->version >= OFP14_VERSION && ofm->command == OFPFC_ADD) { + fm->importance = ntohs(ofm->importance); + } else { + fm->importance = 0; + } fm->buffer_id = ntohl(ofm->buffer_id); error = ofputil_port_from_ofp11(ofm->out_port, &fm->out_port); if (error) { @@ -1678,13 +1740,6 @@ ofputil_decode_flow_mod(struct ofputil_flow_mod *fm, ofputil_match_from_ofp10_match(&ofm->match, &fm->match); ofputil_normalize_match(&fm->match); - /* Now get the actions. */ - error = ofpacts_pull_openflow_actions(&b, ofpbuf_size(&b), oh->version, - ofpacts); - if (error) { - return error; - } - /* OpenFlow 1.0 says that exact-match rules have to have the * highest possible priority. */ fm->priority = (ofm->match.wildcards & htonl(OFPFW10_ALL) @@ -1698,6 +1753,7 @@ ofputil_decode_flow_mod(struct ofputil_flow_mod *fm, fm->new_cookie = ofm->cookie; fm->idle_timeout = ntohs(ofm->idle_timeout); fm->hard_timeout = ntohs(ofm->hard_timeout); + 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; @@ -1713,11 +1769,6 @@ ofputil_decode_flow_mod(struct ofputil_flow_mod *fm, if (error) { return error; } - error = ofpacts_pull_openflow_actions(&b, ofpbuf_size(&b), oh->version, - ofpacts); - if (error) { - return error; - } /* Translate the message. */ command = ntohs(nfm->command); @@ -1730,6 +1781,7 @@ ofputil_decode_flow_mod(struct ofputil_flow_mod *fm, fm->new_cookie = nfm->cookie; fm->idle_timeout = ntohs(nfm->idle_timeout); fm->hard_timeout = ntohs(nfm->hard_timeout); + 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; @@ -1748,8 +1800,13 @@ ofputil_decode_flow_mod(struct ofputil_flow_mod *fm, } } - fm->ofpacts = ofpbuf_data(ofpacts); - fm->ofpacts_len = ofpbuf_size(ofpacts); + error = ofpacts_pull_openflow_instructions(&b, b.size, + oh->version, ofpacts); + if (error) { + return error; + } + fm->ofpacts = ofpacts->data; + fm->ofpacts_len = ofpacts->size; error = ofputil_decode_flow_mod_flags(raw_flags, fm->command, oh->version, &fm->flags); @@ -1847,9 +1904,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; } @@ -1921,25 +1978,25 @@ 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); + size_t start_ofs = msg->size; struct ofp13_meter_config *reply = ofpbuf_put_uninit(msg, sizeof *reply); reply->flags = htons(mc->flags); reply->meter_id = htonl(mc->meter_id); ofputil_put_bands(mc->n_bands, mc->bands, msg); - reply->length = htons(ofpbuf_size(msg) - start_ofs); + 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; @@ -1987,11 +2044,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; } @@ -1999,7 +2056,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; } @@ -2011,7 +2068,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; } @@ -2063,11 +2120,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; } @@ -2075,7 +2132,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; } @@ -2091,7 +2148,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; } @@ -2189,7 +2246,7 @@ ofputil_encode_flow_mod(const struct ofputil_flow_mod *fm, || fm->command == OFPFC_ADD) { ofm->cookie = fm->new_cookie; } else { - ofm->cookie = fm->cookie; + ofm->cookie = fm->cookie & fm->cookie_mask; } ofm->cookie_mask = fm->cookie_mask; if (fm->table_id != OFPTT_ALL @@ -2208,6 +2265,11 @@ ofputil_encode_flow_mod(const struct ofputil_flow_mod *fm, ofm->out_port = ofputil_port_to_ofp11(fm->out_port); ofm->out_group = htonl(fm->out_group); ofm->flags = raw_flags; + if (version >= OFP14_VERSION && fm->command == OFPFC_ADD) { + ofm->importance = htons(fm->importance); + } else { + ofm->importance = 0; + } ofputil_put_ofp11_match(msg, &fm->match, protocol); ofpacts_put_openflow_instructions(fm->ofpacts, fm->ofpacts_len, msg, version); @@ -2246,7 +2308,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); @@ -2320,7 +2382,7 @@ 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; } @@ -2376,12 +2438,12 @@ ofputil_decode_queue_get_config_request(const struct ofp_header *oh, 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; case OFPRAW_OFPT11_QUEUE_GET_CONFIG_REQUEST: - qgcr11 = ofpbuf_data(&b); + qgcr11 = b.data; return ofputil_port_from_ofp11(qgcr11->port, port); } @@ -2450,36 +2512,36 @@ void ofputil_append_queue_get_config_reply(struct ofpbuf *reply, const struct ofputil_queue_config *oqc) { - const struct ofp_header *oh = ofpbuf_data(reply); + const struct ofp_header *oh = reply->data; size_t start_ofs, len_ofs; ovs_be16 *len; - start_ofs = ofpbuf_size(reply); + start_ofs = reply->size; if (oh->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); + len_ofs = (char *) &opq10->len - (char *) reply->data; } else { struct ofp11_queue_get_config_reply *qgcr11; struct ofp12_packet_queue *opq12; ovs_be32 port; - qgcr11 = ofpbuf_l3(reply); + qgcr11 = reply->msg; port = qgcr11->port; 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); + len_ofs = (char *) &opq12->len - (char *) reply->data; } 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); + *len = htons(reply->size - start_ofs); } /* Decodes the initial part of an OFPT_QUEUE_GET_CONFIG_REPLY from 'reply' and @@ -2538,14 +2600,14 @@ ofputil_pull_queue_get_config_reply(struct ofpbuf *reply, unsigned int opq_len; unsigned int len; - if (!ofpbuf_size(reply)) { + if (!reply->size) { return EOF; } queue->min_rate = UINT16_MAX; queue->max_rate = UINT16_MAX; - oh = reply->frame; + oh = reply->header; if (oh->version < OFP12_VERSION) { const struct ofp10_packet_queue *opq10; @@ -2568,7 +2630,7 @@ ofputil_pull_queue_get_config_reply(struct ofpbuf *reply, opq_len = sizeof *opq12; } - if (len < opq_len || len > ofpbuf_size(reply) + opq_len || len % 8) { + if (len < opq_len || len > reply->size + opq_len || len % 8) { return OFPERR_OFPBRC_BAD_LEN; } len -= opq_len; @@ -2581,7 +2643,7 @@ ofputil_pull_queue_get_config_reply(struct ofpbuf *reply, hdr = ofpbuf_at_assert(reply, 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 > reply->size || prop_len % 8) { return OFPERR_OFPBRC_BAD_LEN; } @@ -2623,10 +2685,10 @@ ofputil_decode_flow_stats_request(struct ofputil_flow_stats_request *fsr, 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); @@ -2707,7 +2769,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; @@ -2748,18 +2810,18 @@ ofputil_decode_flow_stats_reply(struct ofputil_flow_stats *fs, struct ofpbuf *ofpacts) { const struct ofp_header *oh; + size_t instructions_len; 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) { @@ -2770,7 +2832,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; } @@ -2785,13 +2847,7 @@ ofputil_decode_flow_stats_reply(struct ofputil_flow_stats *fs, VLOG_WARN_RL(&bad_ofmsg_rl, "OFPST_FLOW reply bad match"); return EINVAL; } - - if (ofpacts_pull_openflow_instructions(msg, length - sizeof *ofs - - padded_match_len, oh->version, - ofpacts)) { - VLOG_WARN_RL(&bad_ofmsg_rl, "OFPST_FLOW reply bad instructions"); - return EINVAL; - } + instructions_len = length - sizeof *ofs - padded_match_len; fs->priority = ntohs(ofs->priority); fs->table_id = ofs->table_id; @@ -2799,6 +2855,11 @@ ofputil_decode_flow_stats_reply(struct ofputil_flow_stats *fs, fs->duration_nsec = ntohl(ofs->duration_nsec); fs->idle_timeout = ntohs(ofs->idle_timeout); fs->hard_timeout = ntohs(ofs->hard_timeout); + if (oh->version >= OFP14_VERSION) { + fs->importance = ntohs(ofs->importance); + } else { + fs->importance = 0; + } if (raw == OFPRAW_OFPST13_FLOW_REPLY) { error = ofputil_decode_flow_mod_flags(ofs->flags, -1, oh->version, &fs->flags); @@ -2820,7 +2881,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; } @@ -2830,11 +2891,7 @@ ofputil_decode_flow_stats_reply(struct ofputil_flow_stats *fs, "length %"PRIuSIZE, length); return EINVAL; } - - if (ofpacts_pull_openflow_actions(msg, length - sizeof *ofs, - oh->version, ofpacts)) { - return EINVAL; - } + instructions_len = length - sizeof *ofs; fs->cookie = get_32aligned_be64(&ofs->cookie); ofputil_match_from_ofp10_match(&ofs->match, &fs->match); @@ -2844,6 +2901,7 @@ ofputil_decode_flow_stats_reply(struct ofputil_flow_stats *fs, fs->duration_nsec = ntohl(ofs->duration_nsec); fs->idle_timeout = ntohs(ofs->idle_timeout); fs->hard_timeout = ntohs(ofs->hard_timeout); + fs->importance = 0; fs->idle_age = -1; fs->hard_age = -1; fs->packet_count = ntohll(get_32aligned_be64(&ofs->packet_count)); @@ -2851,12 +2909,12 @@ ofputil_decode_flow_stats_reply(struct ofputil_flow_stats *fs, fs->flags = 0; } else if (raw == OFPRAW_NXST_FLOW_REPLY) { const struct nx_flow_stats *nfs; - size_t match_len, actions_len, length; + size_t match_len, length; 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; } @@ -2870,12 +2928,7 @@ ofputil_decode_flow_stats_reply(struct ofputil_flow_stats *fs, if (nx_pull_match(msg, match_len, &fs->match, NULL, NULL)) { return EINVAL; } - - actions_len = length - sizeof *nfs - ROUND_UP(match_len, 8); - if (ofpacts_pull_openflow_actions(msg, actions_len, oh->version, - ofpacts)) { - return EINVAL; - } + instructions_len = length - sizeof *nfs - ROUND_UP(match_len, 8); fs->cookie = nfs->cookie; fs->table_id = nfs->table_id; @@ -2884,6 +2937,7 @@ ofputil_decode_flow_stats_reply(struct ofputil_flow_stats *fs, fs->priority = ntohs(nfs->priority); fs->idle_timeout = ntohs(nfs->idle_timeout); fs->hard_timeout = ntohs(nfs->hard_timeout); + fs->importance = 0; fs->idle_age = -1; fs->hard_age = -1; if (flow_age_extension) { @@ -2901,8 +2955,13 @@ ofputil_decode_flow_stats_reply(struct ofputil_flow_stats *fs, OVS_NOT_REACHED(); } - fs->ofpacts = ofpbuf_data(ofpacts); - fs->ofpacts_len = ofpbuf_size(ofpacts); + if (ofpacts_pull_openflow_instructions(msg, instructions_len, oh->version, + ofpacts)) { + VLOG_WARN_RL(&bad_ofmsg_rl, "OFPST_FLOW reply bad instructions"); + return EINVAL; + } + fs->ofpacts = ofpacts->data; + fs->ofpacts_len = ofpacts->size; return 0; } @@ -2922,10 +2981,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); @@ -2938,7 +2997,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); @@ -2946,6 +3005,11 @@ ofputil_append_flow_stats_reply(const struct ofputil_flow_stats *fs, ofs->priority = htons(fs->priority); ofs->idle_timeout = htons(fs->idle_timeout); ofs->hard_timeout = htons(fs->hard_timeout); + if (version >= OFP14_VERSION) { + ofs->importance = htons(fs->importance); + } else { + ofs->importance = 0; + } if (raw == OFPRAW_OFPST13_FLOW_REPLY) { ofs->flags = ofputil_encode_flow_mod_flags(fs->flags, version); } else { @@ -2962,7 +3026,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); @@ -2986,7 +3050,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); @@ -3052,7 +3116,7 @@ ofputil_decode_aggregate_stats_reply(struct ofputil_aggregate_stats *stats, ofpbuf_use_const(&msg, reply, ntohs(reply->length)); ofpraw_pull_assert(&msg); - asr = ofpbuf_l3(&msg); + 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); @@ -3119,7 +3183,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; } @@ -3207,10 +3271,10 @@ ofputil_encode_flow_removed(const struct ofputil_flow_removed *fr, msg = ofpraw_alloc_xid(OFPRAW_NXT_FLOW_REMOVED, OFP10_VERSION, htonl(0), NXM_TYPICAL_LEN); - nfr = ofpbuf_put_zeros(msg, sizeof *nfr); + 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; @@ -3235,13 +3299,15 @@ 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->packet = b->data; + pin->packet_len = b->size; 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.gbp_id = match->flow.tunnel.gbp_id; + pin->fmd.gbp_flags = match->flow.tunnel.gbp_flags; 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; @@ -3297,7 +3363,7 @@ ofputil_decode_packet_in(struct ofputil_packet_in *pin, opi = ofpbuf_pull(&b, offsetof(struct ofp10_packet_in, data)); pin->packet = opi->data; - pin->packet_len = ofpbuf_size(&b); + pin->packet_len = b.size; pin->fmd.in_port = u16_to_ofp(ntohs(opi->in_port)); pin->reason = opi->reason; @@ -3309,8 +3375,8 @@ ofputil_decode_packet_in(struct ofputil_packet_in *pin, opi = ofpbuf_pull(&b, sizeof *opi); - pin->packet = ofpbuf_data(&b); - pin->packet_len = ofpbuf_size(&b); + pin->packet = b.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); @@ -3367,6 +3433,12 @@ ofputil_packet_in_to_match(const struct ofputil_packet_in *pin, if (pin->fmd.tun_dst != htonl(0)) { match_set_tun_dst(match, pin->fmd.tun_dst); } + if (pin->fmd.gbp_id != htons(0)) { + match_set_tun_gbp_id(match, pin->fmd.gbp_id); + } + if (pin->fmd.gbp_flags) { + match_set_tun_gbp_flags(match, pin->fmd.gbp_flags); + } if (pin->fmd.metadata != htonll(0)) { match_set_metadata(match, pin->fmd.metadata); } @@ -3422,7 +3494,7 @@ ofputil_encode_nx_packet_in(const struct ofputil_packet_in *pin) ofpbuf_put_zeros(packet, 2); ofpbuf_put(packet, pin->packet, pin->packet_len); - npi = ofpbuf_l3(packet); + npi = packet->msg; npi->buffer_id = htonl(pin->buffer_id); npi->total_len = htons(pin->total_len); npi->reason = pin->reason; @@ -3471,7 +3543,7 @@ ofputil_encode_ofp12_packet_in(const struct ofputil_packet_in *pin, packet_in_size = sizeof (struct ofp12_packet_in); } else { packet_in_raw = OFPRAW_OFPT13_PACKET_IN; - packet_in_version = OFP13_VERSION; + packet_in_version = ofputil_protocol_to_ofp_version(protocol); packet_in_size = sizeof (struct ofp13_packet_in); } @@ -3486,12 +3558,12 @@ ofputil_encode_ofp12_packet_in(const struct ofputil_packet_in *pin, ofpbuf_put_zeros(packet, 2); ofpbuf_put(packet, pin->packet, pin->packet_len); - opi = ofpbuf_l3(packet); + opi = packet->msg; 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) { + if (protocol != OFPUTIL_P_OF12_OXM) { opi->cookie = pin->cookie; } @@ -3550,6 +3622,12 @@ 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_N_REASONS: default: @@ -3636,12 +3714,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; @@ -3763,9 +3841,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; } @@ -3794,7 +3872,7 @@ ofputil_pull_ofp14_port(struct ofputil_phy_port *pp, struct ofpbuf *msg) } len = ntohs(op->length); - if (len < sizeof *op || len - sizeof *op > ofpbuf_size(msg)) { + if (len < sizeof *op || len - sizeof *op > msg->size) { return OFPERR_OFPBRC_BAD_LEN; } len -= sizeof *op; @@ -3810,7 +3888,7 @@ ofputil_pull_ofp14_port(struct ofputil_phy_port *pp, struct ofpbuf *msg) pp->config = ntohl(op->config) & OFPPC11_ALL; pp->state = ntohl(op->state) & OFPPS11_ALL; - while (ofpbuf_size(&properties) > 0) { + while (properties.size > 0) { struct ofpbuf payload; enum ofperr error; uint16_t type; @@ -3992,10 +4070,10 @@ 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); @@ -4012,46 +4090,10 @@ BUILD_ASSERT_DECL((int) OFPUTIL_C_IP_REASM == OFPC_IP_REASM); BUILD_ASSERT_DECL((int) OFPUTIL_C_QUEUE_STATS == OFPC_QUEUE_STATS); BUILD_ASSERT_DECL((int) OFPUTIL_C_ARP_MATCH_IP == OFPC_ARP_MATCH_IP); -struct ofputil_action_bit_translation { - enum ofputil_action_bitmap ofputil_bit; - int of_bit; -}; - -static const struct ofputil_action_bit_translation of10_action_bits[] = { - { OFPUTIL_A_OUTPUT, OFPAT10_OUTPUT }, - { OFPUTIL_A_SET_VLAN_VID, OFPAT10_SET_VLAN_VID }, - { OFPUTIL_A_SET_VLAN_PCP, OFPAT10_SET_VLAN_PCP }, - { OFPUTIL_A_STRIP_VLAN, OFPAT10_STRIP_VLAN }, - { OFPUTIL_A_SET_DL_SRC, OFPAT10_SET_DL_SRC }, - { OFPUTIL_A_SET_DL_DST, OFPAT10_SET_DL_DST }, - { OFPUTIL_A_SET_NW_SRC, OFPAT10_SET_NW_SRC }, - { OFPUTIL_A_SET_NW_DST, OFPAT10_SET_NW_DST }, - { OFPUTIL_A_SET_NW_TOS, OFPAT10_SET_NW_TOS }, - { OFPUTIL_A_SET_TP_SRC, OFPAT10_SET_TP_SRC }, - { OFPUTIL_A_SET_TP_DST, OFPAT10_SET_TP_DST }, - { OFPUTIL_A_ENQUEUE, OFPAT10_ENQUEUE }, - { 0, 0 }, -}; - -static enum ofputil_action_bitmap -decode_action_bits(ovs_be32 of_actions, - const struct ofputil_action_bit_translation *x) -{ - enum ofputil_action_bitmap ofputil_actions; - - ofputil_actions = 0; - for (; x->ofputil_bit; x++) { - if (of_actions & htonl(1u << x->of_bit)) { - ofputil_actions |= x->ofputil_bit; - } - } - return ofputil_actions; -} - 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: @@ -4096,13 +4138,14 @@ ofputil_decode_switch_features(const struct ofp_header *oh, if (osf->capabilities & htonl(OFPC10_STP)) { features->capabilities |= OFPUTIL_C_STP; } - features->actions = decode_action_bits(osf->actions, of10_action_bits); + features->ofpacts = ofpact_bitmap_from_openflow(osf->actions, + OFP10_VERSION); } else if (raw == OFPRAW_OFPT11_FEATURES_REPLY || raw == OFPRAW_OFPT13_FEATURES_REPLY) { if (osf->capabilities & htonl(OFPC11_GROUP_STATS)) { features->capabilities |= OFPUTIL_C_GROUP_STATS; } - features->actions = 0; + features->ofpacts = 0; if (raw == OFPRAW_OFPT13_FEATURES_REPLY) { features->auxiliary_id = osf->auxiliary_id; } @@ -4128,7 +4171,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) { @@ -4148,26 +4191,11 @@ 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; } -static ovs_be32 -encode_action_bits(enum ofputil_action_bitmap ofputil_actions, - const struct ofputil_action_bit_translation *x) -{ - uint32_t of_actions; - - of_actions = 0; - for (; x->ofputil_bit; x++) { - if (ofputil_actions & x->ofputil_bit) { - of_actions |= 1 << x->of_bit; - } - } - return htonl(of_actions); -} - /* Returns a buffer owned by the caller that encodes 'features' in the format * required by 'protocol' with the given 'xid'. The caller should append port * information to the buffer with subsequent calls to @@ -4212,7 +4240,8 @@ ofputil_encode_switch_features(const struct ofputil_switch_features *features, if (features->capabilities & OFPUTIL_C_STP) { osf->capabilities |= htonl(OFPC10_STP); } - osf->actions = encode_action_bits(features->actions, of10_action_bits); + osf->actions = ofpact_bitmap_to_openflow(features->ofpacts, + OFP10_VERSION); break; case OFP13_VERSION: case OFP14_VERSION: @@ -4239,16 +4268,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; } } } @@ -4328,9 +4357,9 @@ 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); + struct ofp14_port_mod_prop_ethernet *eth = property->data; - if (ofpbuf_size(property) != sizeof *eth) { + if (property->size != sizeof *eth) { return OFPERR_OFPBRC_BAD_LEN; } @@ -4351,7 +4380,7 @@ ofputil_decode_port_mod(const struct ofp_header *oh, 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); @@ -4359,7 +4388,7 @@ ofputil_decode_port_mod(const struct ofp_header *oh, 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); @@ -4386,7 +4415,7 @@ ofputil_decode_port_mod(const struct ofp_header *oh, 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; @@ -4489,10 +4518,12 @@ ofputil_encode_port_mod(const struct ofputil_port_mod *pm, return b; } + +/* Table features. */ static enum ofperr pull_table_feature_property(struct ofpbuf *msg, struct ofpbuf *payload, - uint16_t *typep) + uint16_t *typep) { enum ofperr error; @@ -4504,20 +4535,25 @@ pull_table_feature_property(struct ofpbuf *msg, struct ofpbuf *payload, } static enum ofperr -parse_table_ids(struct ofpbuf *payload, uint32_t *ids) +parse_action_bitmap(struct ofpbuf *payload, enum ofp_version ofp_version, + uint64_t *ofpacts) { - uint16_t type; + uint32_t types = 0; + + while (payload->size > 0) { + uint16_t type; + enum ofperr error; - *ids = 0; - while (ofpbuf_size(payload) > 0) { - enum ofperr error = pull_table_feature_property(payload, NULL, &type); + error = ofputil_pull_property__(payload, NULL, 1, &type); if (error) { return error; } - if (type < CHAR_BIT * sizeof *ids) { - *ids |= 1u << type; + if (type < CHAR_BIT * sizeof types) { + types |= 1u << type; } } + + *ofpacts = ofpact_bitmap_from_openflow(htonl(types), ofp_version); return 0; } @@ -4525,12 +4561,21 @@ 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; - error = pull_table_feature_property(payload, NULL, &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 + * both standards say that "non-experimenter instructions are 4 bytes" + * and do not mention any padding before the first instruction ID. + * (There wouldn't be any point in padding to 8 bytes if the IDs were + * aligned on an odd 4-byte boundary.) + * + * Anyway, we just assume they're all glommed together on byte + * boundaries. */ + error = ofputil_pull_property__(payload, NULL, 1, &ofpit); if (error) { return error; } @@ -4552,8 +4597,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; } @@ -4562,69 +4607,33 @@ parse_table_features_next_table(struct ofpbuf *payload, return 0; } -static enum ofperr -parse_oxm(struct ofpbuf *b, bool loose, - const struct mf_field **fieldp, bool *hasmask) -{ - ovs_be32 *oxmp; - uint32_t oxm; - - oxmp = ofpbuf_try_pull(b, sizeof *oxmp); - if (!oxmp) { - return OFPERR_OFPBPC_BAD_LEN; - } - oxm = ntohl(*oxmp); - - /* Determine '*hasmask'. If 'oxm' is masked, convert it to the equivalent - * unmasked version, because the table of OXM fields we support only has - * masked versions of fields that we support with masks, but we should be - * able to parse the masked versions of those here. */ - *hasmask = NXM_HASMASK(oxm); - if (*hasmask) { - if (NXM_LENGTH(oxm) & 1) { - return OFPERR_OFPBPC_BAD_VALUE; - } - oxm = NXM_HEADER(NXM_VENDOR(oxm), NXM_FIELD(oxm), NXM_LENGTH(oxm) / 2); - } - - *fieldp = mf_from_nxm_header(oxm); - if (!*fieldp) { - log_property(loose, "unknown OXM field %#"PRIx32, ntohl(*oxmp)); - } - return *fieldp ? 0 : OFPERR_OFPBMC_BAD_FIELD; -} - static enum ofperr parse_oxms(struct ofpbuf *payload, bool loose, - uint64_t *exactp, uint64_t *maskedp) + struct mf_bitmap *exactp, struct mf_bitmap *maskedp) { - uint64_t exact, masked; + struct mf_bitmap exact = MF_BITMAP_INITIALIZER; + struct mf_bitmap masked = MF_BITMAP_INITIALIZER; - exact = masked = 0; - while (ofpbuf_size(payload) > 0) { + while (payload->size > 0) { const struct mf_field *field; enum ofperr error; bool hasmask; - error = parse_oxm(payload, loose, &field, &hasmask); + error = nx_pull_header(payload, &field, &hasmask); if (!error) { - if (hasmask) { - masked |= UINT64_C(1) << field->id; - } else { - exact |= UINT64_C(1) << field->id; - } + bitmap_set1(hasmask ? masked.bm : exact.bm, field->id); } else if (error != OFPERR_OFPBMC_BAD_FIELD || !loose) { return error; } } if (exactp) { *exactp = exact; - } else if (exact) { + } else if (!bitmap_is_all_zeros(exact.bm, MFF_N_IDS)) { return OFPERR_OFPBMC_BAD_MASK; } if (maskedp) { *maskedp = masked; - } else if (masked) { + } else if (!bitmap_is_all_zeros(masked.bm, MFF_N_IDS)) { return OFPERR_OFPBMC_BAD_MASK; } return 0; @@ -4650,27 +4659,33 @@ 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; - if (!msg->frame) { + memset(tf, 0, sizeof *tf); + + if (!msg->header) { ofpraw_pull_assert(msg); } + oh = msg->header; - if (!ofpbuf_size(msg)) { + if (!msg->size) { return EOF; } - if (ofpbuf_size(msg) < sizeof *otf) { + if (msg->size < sizeof *otf) { return OFPERR_OFPBPC_BAD_LEN; } - otf = ofpbuf_data(msg); + otf = msg->data; len = ntohs(otf->length); - if (len < sizeof *otf || len % 8 || len > ofpbuf_size(msg)) { + if (len < sizeof *otf || len % 8 || len > msg->size) { return OFPERR_OFPBPC_BAD_LEN; } - ofpbuf_pull(msg, sizeof *otf); + 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) { @@ -4680,15 +4695,15 @@ 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->config = ntohl(otf->config); + tf->miss_config = ofputil_table_miss_from_config(otf->config, oh->version); tf->max_entries = ntohl(otf->max_entries); - while (ofpbuf_size(msg) > 0) { + while (properties.size > 0) { struct ofpbuf payload; enum ofperr error; uint16_t type; - error = pull_table_feature_property(msg, &payload, &type); + error = pull_table_feature_property(&properties, &payload, &type); if (error) { return error; } @@ -4712,17 +4727,21 @@ ofputil_decode_table_features(struct ofpbuf *msg, break; case OFPTFPT13_WRITE_ACTIONS: - error = parse_table_ids(&payload, &tf->nonmiss.write.actions); + error = parse_action_bitmap(&payload, oh->version, + &tf->nonmiss.write.ofpacts); break; case OFPTFPT13_WRITE_ACTIONS_MISS: - error = parse_table_ids(&payload, &tf->miss.write.actions); + error = parse_action_bitmap(&payload, oh->version, + &tf->miss.write.ofpacts); break; case OFPTFPT13_APPLY_ACTIONS: - error = parse_table_ids(&payload, &tf->nonmiss.apply.actions); + error = parse_action_bitmap(&payload, oh->version, + &tf->nonmiss.apply.ofpacts); break; case OFPTFPT13_APPLY_ACTIONS_MISS: - error = parse_table_ids(&payload, &tf->miss.apply.actions); + error = parse_action_bitmap(&payload, oh->version, + &tf->miss.apply.ofpacts); break; case OFPTFPT13_MATCH: @@ -4764,15 +4783,17 @@ ofputil_decode_table_features(struct ofpbuf *msg, /* Fix inconsistencies: * - * - Turn off 'mask' and 'wildcard' bits that are not in 'match', - * because a field must be matchable to be masked or wildcarded. + * - Turn on 'match' bits that are set in 'mask', because maskable + * fields are matchable. * * - Turn on 'wildcard' bits that are set in 'mask', because a field - * that is arbitrarily maskable can be wildcarded entirely. */ - tf->mask &= tf->match; - tf->wildcard &= tf->match; - - tf->wildcard |= tf->mask; + * that is arbitrarily maskable can be wildcarded entirely. + * + * - Turn off 'wildcard' bits that are not in 'match', because a field + * must be matchable for it to be meaningfully wildcarded. */ + bitmap_or(tf->match.bm, tf->mask.bm, MFF_N_IDS); + bitmap_or(tf->wildcard.bm, tf->mask.bm, MFF_N_IDS); + bitmap_and(tf->wildcard.bm, tf->match.bm, MFF_N_IDS); return 0; } @@ -4803,8 +4824,157 @@ ofputil_encode_table_features_request(enum ofp_version ofp_version) return request; } +static void +put_fields_property(struct ofpbuf *reply, + const struct mf_bitmap *fields, + const struct mf_bitmap *masks, + enum ofp13_table_feature_prop_type property, + enum ofp_version version) +{ + size_t start_ofs; + int field; + + start_ofs = start_property(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); +} + +static void +put_table_action_features(struct ofpbuf *reply, + const struct ofputil_table_action_features *taf, + enum ofp13_table_feature_prop_type actions_type, + 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); + + put_fields_property(reply, &taf->set_fields, NULL, + set_fields_type + miss_offset, version); +} + +static void +put_table_instruction_features( + struct ofpbuf *reply, const struct ofputil_table_instruction_features *tif, + int miss_offset, enum ofp_version version) +{ + 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); + + start_ofs = start_property(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); + + put_table_action_features(reply, &tif->write, + OFPTFPT13_WRITE_ACTIONS, + OFPTFPT13_WRITE_SETFIELD, miss_offset, version); + put_table_action_features(reply, &tif->apply, + OFPTFPT13_APPLY_ACTIONS, + OFPTFPT13_APPLY_SETFIELD, miss_offset, version); +} + +void +ofputil_append_table_features_reply(const struct ofputil_table_features *tf, + struct ovs_list *replies) +{ + struct ofpbuf *reply = ofpbuf_from_list(list_back(replies)); + enum ofp_version version = ofpmp_version(replies); + size_t start_ofs = reply->size; + struct ofp13_table_features *otf; + + otf = ofpbuf_put_zeros(reply, sizeof *otf); + otf->table_id = tf->table_id; + 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); + otf->max_entries = htonl(tf->max_entries); + + put_table_instruction_features(reply, &tf->nonmiss, 0, version); + put_table_instruction_features(reply, &tf->miss, 1, version); + + put_fields_property(reply, &tf->match, &tf->mask, + OFPTFPT13_MATCH, version); + put_fields_property(reply, &tf->wildcard, NULL, + OFPTFPT13_WILDCARDS, version); + + otf = ofpbuf_at_assert(reply, start_ofs, sizeof *otf); + otf->length = htons(reply->size - start_ofs); + ofpmp_postappend(replies, start_ofs); +} + /* ofputil_table_mod */ +/* 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) +{ + uint32_t config = ntohl(config_); + + if (version < OFP13_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: + VLOG_WARN_RL(&bad_ofmsg_rl, "bad table miss config %d", config); + return OFPUTIL_TABLE_MISS_CONTROLLER; + } + } else { + return OFPUTIL_TABLE_MISS_DEFAULT; + } +} + +/* 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) +{ + if (version < OFP13_VERSION) { + switch (miss) { + case OFPUTIL_TABLE_MISS_CONTROLLER: + case OFPUTIL_TABLE_MISS_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); + + default: + OVS_NOT_REACHED(); + } + } else { + return htonl(0); + } +} + /* Decodes the OpenFlow "table mod" message in '*oh' into an abstract form in * '*pm'. Returns 0 if successful, otherwise an OFPERR_* value. */ enum ofperr @@ -4818,15 +4988,17 @@ ofputil_decode_table_mod(const struct ofp_header *oh, 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->config = ntohl(otm->config); + pm->miss_config = ofputil_table_miss_from_config(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->config = ntohl(otm->config); + 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. */ } else { @@ -4860,7 +5032,8 @@ 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 = htonl(pm->config); + otm->config = ofputil_table_miss_to_config(pm->miss_config, + ofp_version); break; } case OFP14_VERSION: @@ -4870,7 +5043,8 @@ 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 = htonl(pm->config); + otm->config = ofputil_table_miss_to_config(pm->miss_config, + ofp_version); break; } default: @@ -4897,7 +5071,7 @@ ofputil_decode_role_message(const struct ofp_header *oh, 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) && @@ -4918,7 +5092,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); @@ -4977,22 +5151,31 @@ ofputil_encode_role_reply(const struct ofp_header *request, return buf; } +/* Encodes "role status" message 'status' for sending in the given + * 'protocol'. Returns the role status message, if 'protocol' supports them, + * otherwise a null pointer. */ struct ofpbuf * ofputil_encode_role_status(const struct ofputil_role_status *status, enum ofputil_protocol protocol) { - struct ofpbuf *buf; enum ofp_version version; - struct ofp14_role_status *rstatus; version = ofputil_protocol_to_ofp_version(protocol); - buf = ofpraw_alloc_xid(OFPRAW_OFPT14_ROLE_STATUS, version, htonl(0), 0); - rstatus = ofpbuf_put_zeros(buf, sizeof *rstatus); - rstatus->role = htonl(status->role); - rstatus->reason = status->reason; - rstatus->generation_id = htonll(status->generation_id); - - return buf; + if (version >= OFP14_VERSION) { + struct ofp14_role_status *rstatus; + struct ofpbuf *buf; + + buf = ofpraw_alloc_xid(OFPRAW_OFPT14_ROLE_STATUS, version, htonl(0), + 0); + rstatus = ofpbuf_put_zeros(buf, sizeof *rstatus); + rstatus->role = htonl(status->role); + rstatus->reason = status->reason; + rstatus->generation_id = htonll(status->generation_id); + + return buf; + } else { + return NULL; + } } enum ofperr @@ -5007,7 +5190,7 @@ ofputil_decode_role_status(const struct ofp_header *oh, raw = ofpraw_pull_assert(&b); ovs_assert(raw == OFPRAW_OFPT14_ROLE_STATUS); - r = ofpbuf_l3(&b); + r = b.msg; if (r->role != htonl(OFPCR12_ROLE_NOCHANGE) && r->role != htonl(OFPCR12_ROLE_EQUAL) && r->role != htonl(OFPCR12_ROLE_MASTER) && @@ -5024,205 +5207,447 @@ ofputil_decode_role_status(const struct ofp_header *oh, /* Table stats. */ +/* OpenFlow 1.0 and 1.1 don't distinguish between a field that cannot be + * matched and a field that must be wildcarded. This function returns a bitmap + * that contains both kinds of fields. */ +static struct mf_bitmap +wild_or_nonmatchable_fields(const struct ofputil_table_features *features) +{ + struct mf_bitmap wc = features->match; + bitmap_not(wc.bm, MFF_N_IDS); + bitmap_or(wc.bm, features->wildcard.bm, MFF_N_IDS); + return wc; +} + +struct ofp10_wc_map { + enum ofp10_flow_wildcards wc10; + enum mf_field_id mf; +}; + +static const struct ofp10_wc_map ofp10_wc_map[] = { + { OFPFW10_IN_PORT, MFF_IN_PORT }, + { OFPFW10_DL_VLAN, MFF_VLAN_VID }, + { OFPFW10_DL_SRC, MFF_ETH_SRC }, + { OFPFW10_DL_DST, MFF_ETH_DST}, + { OFPFW10_DL_TYPE, MFF_ETH_TYPE }, + { OFPFW10_NW_PROTO, MFF_IP_PROTO }, + { OFPFW10_TP_SRC, MFF_TCP_SRC }, + { OFPFW10_TP_DST, MFF_TCP_DST }, + { OFPFW10_NW_SRC_MASK, MFF_IPV4_SRC }, + { OFPFW10_NW_DST_MASK, MFF_IPV4_DST }, + { OFPFW10_DL_VLAN_PCP, MFF_VLAN_PCP }, + { OFPFW10_NW_TOS, MFF_IP_DSCP }, +}; + +static ovs_be32 +mf_bitmap_to_of10(const struct mf_bitmap *fields) +{ + const struct ofp10_wc_map *p; + uint32_t wc10 = 0; + + for (p = ofp10_wc_map; p < &ofp10_wc_map[ARRAY_SIZE(ofp10_wc_map)]; p++) { + if (bitmap_is_set(fields->bm, p->mf)) { + wc10 |= p->wc10; + } + } + return htonl(wc10); +} + +static struct mf_bitmap +mf_bitmap_from_of10(ovs_be32 wc10_) +{ + struct mf_bitmap fields = MF_BITMAP_INITIALIZER; + const struct ofp10_wc_map *p; + uint32_t wc10 = ntohl(wc10_); + + for (p = ofp10_wc_map; p < &ofp10_wc_map[ARRAY_SIZE(ofp10_wc_map)]; p++) { + if (wc10 & p->wc10) { + bitmap_set1(fields.bm, p->mf); + } + } + return fields; +} + static void -ofputil_put_ofp10_table_stats(const struct ofp12_table_stats *in, +ofputil_put_ofp10_table_stats(const struct ofputil_table_stats *stats, + const struct ofputil_table_features *features, struct ofpbuf *buf) { - struct wc_map { - enum ofp10_flow_wildcards wc10; - enum oxm12_ofb_match_fields mf12; - }; - - static const struct wc_map wc_map[] = { - { OFPFW10_IN_PORT, OFPXMT12_OFB_IN_PORT }, - { OFPFW10_DL_VLAN, OFPXMT12_OFB_VLAN_VID }, - { OFPFW10_DL_SRC, OFPXMT12_OFB_ETH_SRC }, - { OFPFW10_DL_DST, OFPXMT12_OFB_ETH_DST}, - { OFPFW10_DL_TYPE, OFPXMT12_OFB_ETH_TYPE }, - { OFPFW10_NW_PROTO, OFPXMT12_OFB_IP_PROTO }, - { OFPFW10_TP_SRC, OFPXMT12_OFB_TCP_SRC }, - { OFPFW10_TP_DST, OFPXMT12_OFB_TCP_DST }, - { OFPFW10_NW_SRC_MASK, OFPXMT12_OFB_IPV4_SRC }, - { OFPFW10_NW_DST_MASK, OFPXMT12_OFB_IPV4_DST }, - { OFPFW10_DL_VLAN_PCP, OFPXMT12_OFB_VLAN_PCP }, - { OFPFW10_NW_TOS, OFPXMT12_OFB_IP_DSCP }, - }; - + struct mf_bitmap wc = wild_or_nonmatchable_fields(features); struct ofp10_table_stats *out; - const struct wc_map *p; out = ofpbuf_put_zeros(buf, sizeof *out); - out->table_id = in->table_id; - ovs_strlcpy(out->name, in->name, sizeof out->name); - out->wildcards = 0; - for (p = wc_map; p < &wc_map[ARRAY_SIZE(wc_map)]; p++) { - if (in->wildcards & htonll(1ULL << p->mf12)) { - out->wildcards |= htonl(p->wc10); + out->table_id = features->table_id; + ovs_strlcpy(out->name, features->name, sizeof out->name); + out->wildcards = mf_bitmap_to_of10(&wc); + out->max_entries = htonl(features->max_entries); + out->active_count = htonl(stats->active_count); + put_32aligned_be64(&out->lookup_count, htonll(stats->lookup_count)); + put_32aligned_be64(&out->matched_count, htonll(stats->matched_count)); +} + +struct ofp11_wc_map { + enum ofp11_flow_match_fields wc11; + enum mf_field_id mf; +}; + +static const struct ofp11_wc_map ofp11_wc_map[] = { + { OFPFMF11_IN_PORT, MFF_IN_PORT }, + { OFPFMF11_DL_VLAN, MFF_VLAN_VID }, + { OFPFMF11_DL_VLAN_PCP, MFF_VLAN_PCP }, + { OFPFMF11_DL_TYPE, MFF_ETH_TYPE }, + { OFPFMF11_NW_TOS, MFF_IP_DSCP }, + { OFPFMF11_NW_PROTO, MFF_IP_PROTO }, + { OFPFMF11_TP_SRC, MFF_TCP_SRC }, + { OFPFMF11_TP_DST, MFF_TCP_DST }, + { OFPFMF11_MPLS_LABEL, MFF_MPLS_LABEL }, + { OFPFMF11_MPLS_TC, MFF_MPLS_TC }, + /* I don't know what OFPFMF11_TYPE means. */ + { OFPFMF11_DL_SRC, MFF_ETH_SRC }, + { OFPFMF11_DL_DST, MFF_ETH_DST }, + { OFPFMF11_NW_SRC, MFF_IPV4_SRC }, + { OFPFMF11_NW_DST, MFF_IPV4_DST }, + { OFPFMF11_METADATA, MFF_METADATA }, +}; + +static ovs_be32 +mf_bitmap_to_of11(const struct mf_bitmap *fields) +{ + const struct ofp11_wc_map *p; + uint32_t wc11 = 0; + + for (p = ofp11_wc_map; p < &ofp11_wc_map[ARRAY_SIZE(ofp11_wc_map)]; p++) { + if (bitmap_is_set(fields->bm, p->mf)) { + wc11 |= p->wc11; } } - out->max_entries = in->max_entries; - out->active_count = in->active_count; - put_32aligned_be64(&out->lookup_count, in->lookup_count); - put_32aligned_be64(&out->matched_count, in->matched_count); + return htonl(wc11); } -static ovs_be32 -oxm12_to_ofp11_flow_match_fields(ovs_be64 oxm12) -{ - struct map { - enum ofp11_flow_match_fields fmf11; - enum oxm12_ofb_match_fields mf12; - }; - - static const struct map map[] = { - { OFPFMF11_IN_PORT, OFPXMT12_OFB_IN_PORT }, - { OFPFMF11_DL_VLAN, OFPXMT12_OFB_VLAN_VID }, - { OFPFMF11_DL_VLAN_PCP, OFPXMT12_OFB_VLAN_PCP }, - { OFPFMF11_DL_TYPE, OFPXMT12_OFB_ETH_TYPE }, - { OFPFMF11_NW_TOS, OFPXMT12_OFB_IP_DSCP }, - { OFPFMF11_NW_PROTO, OFPXMT12_OFB_IP_PROTO }, - { OFPFMF11_TP_SRC, OFPXMT12_OFB_TCP_SRC }, - { OFPFMF11_TP_DST, OFPXMT12_OFB_TCP_DST }, - { OFPFMF11_MPLS_LABEL, OFPXMT12_OFB_MPLS_LABEL }, - { OFPFMF11_MPLS_TC, OFPXMT12_OFB_MPLS_TC }, - /* I don't know what OFPFMF11_TYPE means. */ - { OFPFMF11_DL_SRC, OFPXMT12_OFB_ETH_SRC }, - { OFPFMF11_DL_DST, OFPXMT12_OFB_ETH_DST }, - { OFPFMF11_NW_SRC, OFPXMT12_OFB_IPV4_SRC }, - { OFPFMF11_NW_DST, OFPXMT12_OFB_IPV4_DST }, - { OFPFMF11_METADATA, OFPXMT12_OFB_METADATA }, - }; - - const struct map *p; - uint32_t fmf11; - - fmf11 = 0; - for (p = map; p < &map[ARRAY_SIZE(map)]; p++) { - if (oxm12 & htonll(1ULL << p->mf12)) { - fmf11 |= p->fmf11; - } - } - return htonl(fmf11); +static struct mf_bitmap +mf_bitmap_from_of11(ovs_be32 wc11_) +{ + struct mf_bitmap fields = MF_BITMAP_INITIALIZER; + const struct ofp11_wc_map *p; + uint32_t wc11 = ntohl(wc11_); + + for (p = ofp11_wc_map; p < &ofp11_wc_map[ARRAY_SIZE(ofp11_wc_map)]; p++) { + if (wc11 & p->wc11) { + bitmap_set1(fields.bm, p->mf); + } + } + return fields; } static void -ofputil_put_ofp11_table_stats(const struct ofp12_table_stats *in, +ofputil_put_ofp11_table_stats(const struct ofputil_table_stats *stats, + const struct ofputil_table_features *features, struct ofpbuf *buf) { + struct mf_bitmap wc = wild_or_nonmatchable_fields(features); struct ofp11_table_stats *out; out = ofpbuf_put_zeros(buf, sizeof *out); - out->table_id = in->table_id; - ovs_strlcpy(out->name, in->name, sizeof out->name); - out->wildcards = oxm12_to_ofp11_flow_match_fields(in->wildcards); - out->match = oxm12_to_ofp11_flow_match_fields(in->match); - out->instructions = in->instructions; - out->write_actions = in->write_actions; - out->apply_actions = in->apply_actions; - out->config = in->config; - out->max_entries = in->max_entries; - out->active_count = in->active_count; - out->lookup_count = in->lookup_count; - out->matched_count = in->matched_count; + out->table_id = features->table_id; + ovs_strlcpy(out->name, features->name, sizeof out->name); + out->wildcards = mf_bitmap_to_of11(&wc); + out->match = mf_bitmap_to_of11(&features->match); + out->instructions = ovsinst_bitmap_to_openflow( + features->nonmiss.instructions, OFP11_VERSION); + out->write_actions = ofpact_bitmap_to_openflow( + features->nonmiss.write.ofpacts, OFP11_VERSION); + out->apply_actions = ofpact_bitmap_to_openflow( + features->nonmiss.apply.ofpacts, OFP11_VERSION); + out->config = htonl(features->miss_config); + out->max_entries = htonl(features->max_entries); + out->active_count = htonl(stats->active_count); + out->lookup_count = htonll(stats->lookup_count); + out->matched_count = htonll(stats->matched_count); } static void -ofputil_put_ofp12_table_stats(const struct ofp12_table_stats *in, +ofputil_put_ofp12_table_stats(const struct ofputil_table_stats *stats, + const struct ofputil_table_features *features, struct ofpbuf *buf) { - struct ofp12_table_stats *out = ofpbuf_put(buf, in, sizeof *in); + struct ofp12_table_stats *out; - /* Trim off OF1.3-only capabilities. */ - out->match &= htonll(OFPXMT12_MASK); - out->wildcards &= htonll(OFPXMT12_MASK); - out->write_setfields &= htonll(OFPXMT12_MASK); - out->apply_setfields &= htonll(OFPXMT12_MASK); + out = ofpbuf_put_zeros(buf, sizeof *out); + out->table_id = features->table_id; + ovs_strlcpy(out->name, features->name, sizeof out->name); + out->match = oxm_bitmap_from_mf_bitmap(&features->match, OFP12_VERSION); + out->wildcards = oxm_bitmap_from_mf_bitmap(&features->wildcard, + OFP12_VERSION); + out->write_actions = ofpact_bitmap_to_openflow( + features->nonmiss.write.ofpacts, OFP12_VERSION); + out->apply_actions = ofpact_bitmap_to_openflow( + features->nonmiss.apply.ofpacts, OFP12_VERSION); + out->write_setfields = oxm_bitmap_from_mf_bitmap( + &features->nonmiss.write.set_fields, OFP12_VERSION); + out->apply_setfields = oxm_bitmap_from_mf_bitmap( + &features->nonmiss.apply.set_fields, OFP12_VERSION); + out->metadata_match = features->metadata_match; + 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->max_entries = htonl(features->max_entries); + out->active_count = htonl(stats->active_count); + out->lookup_count = htonll(stats->lookup_count); + out->matched_count = htonll(stats->matched_count); } static void -ofputil_put_ofp13_table_stats(const struct ofp12_table_stats *in, +ofputil_put_ofp13_table_stats(const struct ofputil_table_stats *stats, struct ofpbuf *buf) { struct ofp13_table_stats *out; - /* OF 1.3 splits table features off the ofp_table_stats, - * so there is not much here. */ - - out = ofpbuf_put_uninit(buf, sizeof *out); - out->table_id = in->table_id; - out->active_count = in->active_count; - out->lookup_count = in->lookup_count; - out->matched_count = in->matched_count; + out = ofpbuf_put_zeros(buf, sizeof *out); + out->table_id = stats->table_id; + out->active_count = htonl(stats->active_count); + out->lookup_count = htonll(stats->lookup_count); + out->matched_count = htonll(stats->matched_count); } struct ofpbuf * -ofputil_encode_table_stats_reply(const struct ofp12_table_stats stats[], int n, - const struct ofp_header *request) +ofputil_encode_table_stats_reply(const struct ofp_header *request) { - struct ofpbuf *reply; - int i; + return ofpraw_alloc_stats_reply(request, 0); +} - reply = ofpraw_alloc_stats_reply(request, n * sizeof *stats); +void +ofputil_append_table_stats_reply(struct ofpbuf *reply, + const struct ofputil_table_stats *stats, + const struct ofputil_table_features *features) +{ + struct ofp_header *oh = reply->header; - for (i = 0; i < n; i++) { - switch ((enum ofp_version) request->version) { - case OFP10_VERSION: - ofputil_put_ofp10_table_stats(&stats[i], reply); - break; + ovs_assert(stats->table_id == features->table_id); - case OFP11_VERSION: - ofputil_put_ofp11_table_stats(&stats[i], reply); - break; + switch ((enum ofp_version) oh->version) { + case OFP10_VERSION: + ofputil_put_ofp10_table_stats(stats, features, reply); + break; - case OFP12_VERSION: - ofputil_put_ofp12_table_stats(&stats[i], reply); - break; + case OFP11_VERSION: + ofputil_put_ofp11_table_stats(stats, features, reply); + break; - case OFP13_VERSION: - case OFP14_VERSION: - case OFP15_VERSION: - ofputil_put_ofp13_table_stats(&stats[i], reply); - break; + case OFP12_VERSION: + ofputil_put_ofp12_table_stats(stats, features, reply); + break; - default: - OVS_NOT_REACHED(); - } - } + case OFP13_VERSION: + case OFP14_VERSION: + case OFP15_VERSION: + ofputil_put_ofp13_table_stats(stats, reply); + break; - return reply; + default: + OVS_NOT_REACHED(); + } } - -/* ofputil_flow_monitor_request */ -/* Converts an NXST_FLOW_MONITOR request in 'msg' into an abstract - * ofputil_flow_monitor_request in 'rq'. - * - * Multiple NXST_FLOW_MONITOR requests can be packed into a single OpenFlow - * message. Calling this function multiple times for a single 'msg' iterates - * through the requests. The caller must initially leave 'msg''s layer - * pointers null and not modify them between calls. - * - * Returns 0 if successful, EOF if no requests were left in this 'msg', - * otherwise an OFPERR_* value. */ -int -ofputil_decode_flow_monitor_request(struct ofputil_flow_monitor_request *rq, - struct ofpbuf *msg) +static int +ofputil_decode_ofp10_table_stats(struct ofpbuf *msg, + struct ofputil_table_stats *stats, + struct ofputil_table_features *features) { - struct nx_flow_monitor_request *nfmr; - uint16_t flags; + struct ofp10_table_stats *ots; - if (!msg->frame) { - ofpraw_pull_assert(msg); + ots = ofpbuf_try_pull(msg, sizeof *ots); + if (!ots) { + return OFPERR_OFPBRC_BAD_LEN; + } + + features->table_id = ots->table_id; + ovs_strlcpy(features->name, ots->name, sizeof features->name); + features->max_entries = ntohl(ots->max_entries); + features->match = features->wildcard = mf_bitmap_from_of10(ots->wildcards); + + stats->table_id = ots->table_id; + stats->active_count = ntohl(ots->active_count); + stats->lookup_count = ntohll(get_32aligned_be64(&ots->lookup_count)); + stats->matched_count = ntohll(get_32aligned_be64(&ots->matched_count)); + + return 0; +} + +static int +ofputil_decode_ofp11_table_stats(struct ofpbuf *msg, + struct ofputil_table_stats *stats, + struct ofputil_table_features *features) +{ + struct ofp11_table_stats *ots; + + ots = ofpbuf_try_pull(msg, sizeof *ots); + if (!ots) { + return OFPERR_OFPBRC_BAD_LEN; + } + + features->table_id = ots->table_id; + ovs_strlcpy(features->name, ots->name, sizeof features->name); + features->max_entries = ntohl(ots->max_entries); + features->nonmiss.instructions = ovsinst_bitmap_from_openflow( + ots->instructions, OFP11_VERSION); + features->nonmiss.write.ofpacts = ofpact_bitmap_from_openflow( + ots->write_actions, OFP11_VERSION); + 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->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); + + stats->table_id = ots->table_id; + stats->active_count = ntohl(ots->active_count); + stats->lookup_count = ntohll(ots->lookup_count); + stats->matched_count = ntohll(ots->matched_count); + + return 0; +} + +static int +ofputil_decode_ofp12_table_stats(struct ofpbuf *msg, + struct ofputil_table_stats *stats, + struct ofputil_table_features *features) +{ + struct ofp12_table_stats *ots; + + ots = ofpbuf_try_pull(msg, sizeof *ots); + if (!ots) { + return OFPERR_OFPBRC_BAD_LEN; + } + + features->table_id = ots->table_id; + 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->max_entries = ntohl(ots->max_entries); + + features->nonmiss.instructions = ovsinst_bitmap_from_openflow( + ots->instructions, OFP12_VERSION); + features->nonmiss.write.ofpacts = ofpact_bitmap_from_openflow( + ots->write_actions, OFP12_VERSION); + features->nonmiss.apply.ofpacts = ofpact_bitmap_from_openflow( + ots->apply_actions, OFP12_VERSION); + features->nonmiss.write.set_fields = oxm_bitmap_to_mf_bitmap( + ots->write_setfields, OFP12_VERSION); + features->nonmiss.apply.set_fields = oxm_bitmap_to_mf_bitmap( + ots->apply_setfields, OFP12_VERSION); + features->miss = features->nonmiss; + + features->match = oxm_bitmap_to_mf_bitmap(ots->match, OFP12_VERSION); + features->wildcard = oxm_bitmap_to_mf_bitmap(ots->wildcards, + OFP12_VERSION); + bitmap_or(features->match.bm, features->wildcard.bm, MFF_N_IDS); + + stats->table_id = ots->table_id; + stats->active_count = ntohl(ots->active_count); + stats->lookup_count = ntohll(ots->lookup_count); + stats->matched_count = ntohll(ots->matched_count); + + return 0; +} + +static int +ofputil_decode_ofp13_table_stats(struct ofpbuf *msg, + struct ofputil_table_stats *stats, + struct ofputil_table_features *features) +{ + struct ofp13_table_stats *ots; + + ots = ofpbuf_try_pull(msg, sizeof *ots); + if (!ots) { + return OFPERR_OFPBRC_BAD_LEN; + } + + features->table_id = ots->table_id; + + stats->table_id = ots->table_id; + stats->active_count = ntohl(ots->active_count); + stats->lookup_count = ntohll(ots->lookup_count); + stats->matched_count = ntohll(ots->matched_count); + + return 0; +} + +int +ofputil_decode_table_stats_reply(struct ofpbuf *msg, + struct ofputil_table_stats *stats, + struct ofputil_table_features *features) +{ + const struct ofp_header *oh; + + if (!msg->header) { + ofpraw_pull_assert(msg); + } + oh = msg->header; + + if (!msg->size) { + return EOF; + } + + memset(stats, 0, sizeof *stats); + memset(features, 0, sizeof *features); + + switch ((enum ofp_version) oh->version) { + case OFP10_VERSION: + return ofputil_decode_ofp10_table_stats(msg, stats, features); + + case OFP11_VERSION: + return ofputil_decode_ofp11_table_stats(msg, stats, features); + + case OFP12_VERSION: + return ofputil_decode_ofp12_table_stats(msg, stats, features); + + case OFP13_VERSION: + case OFP14_VERSION: + case OFP15_VERSION: + return ofputil_decode_ofp13_table_stats(msg, stats, features); + + default: + OVS_NOT_REACHED(); + } +} + +/* ofputil_flow_monitor_request */ + +/* Converts an NXST_FLOW_MONITOR request in 'msg' into an abstract + * ofputil_flow_monitor_request in 'rq'. + * + * Multiple NXST_FLOW_MONITOR requests can be packed into a single OpenFlow + * message. Calling this function multiple times for a single 'msg' iterates + * through the requests. The caller must initially leave 'msg''s layer + * pointers null and not modify them between calls. + * + * Returns 0 if successful, EOF if no requests were left in this 'msg', + * otherwise an OFPERR_* value. */ +int +ofputil_decode_flow_monitor_request(struct ofputil_flow_monitor_request *rq, + struct ofpbuf *msg) +{ + struct nx_flow_monitor_request *nfmr; + uint16_t flags; + + 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; } @@ -5255,11 +5680,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)); @@ -5295,24 +5720,24 @@ 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)) { + 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; } @@ -5363,8 +5788,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, @@ -5375,7 +5800,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; } @@ -5400,7 +5825,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; @@ -5413,7 +5838,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; @@ -5421,7 +5846,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; @@ -5447,7 +5872,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); @@ -5473,14 +5898,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; } @@ -5496,7 +5921,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); @@ -5535,8 +5960,8 @@ make_echo_reply(const struct ofp_header *rq) ofpbuf_use_const(&rq_buf, 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)); + reply = ofpraw_alloc_reply(OFPRAW_OFPT_ECHO_REPLY, rq, rq_buf.size); + ofpbuf_put(reply, rq_buf.data, rq_buf.size); return reply; } @@ -5642,7 +6067,8 @@ ofputil_port_to_ofp11(ofp_port_t ofp10_port) OFPUTIL_NAMED_PORT(ALL) \ OFPUTIL_NAMED_PORT(CONTROLLER) \ OFPUTIL_NAMED_PORT(LOCAL) \ - OFPUTIL_NAMED_PORT(ANY) + OFPUTIL_NAMED_PORT(ANY) \ + OFPUTIL_NAMED_PORT(UNSET) /* For backwards compatibility, so that "none" is recognized as OFPP_ANY */ #define OFPUTIL_NAMED_PORTS_WITH_NONE \ @@ -5836,127 +6262,12 @@ 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; - default: - OVS_NOT_REACHED(); - } -} - -/* ofp-util.def lists the mapping from names to action. */ -static const char *const names[OFPUTIL_N_ACTIONS] = { - NULL, -#define OFPAT10_ACTION(ENUM, STRUCT, NAME) NAME, -#define OFPAT11_ACTION(ENUM, STRUCT, EXTENSIBLE, NAME) NAME, -#define OFPAT13_ACTION(ENUM, STRUCT, EXTENSIBLE, NAME) NAME, -#define NXAST_ACTION(ENUM, STRUCT, EXTENSIBLE, NAME) NAME, -#include "ofp-util.def" -}; - -/* Returns the 'enum ofputil_action_code' corresponding to 'name' (e.g. if - * 'name' is "output" then the return value is OFPUTIL_OFPAT10_OUTPUT), or -1 - * if 'name' is not the name of any action. */ -int -ofputil_action_code_from_name(const char *name) -{ - const char *const *p; - - for (p = names; p < &names[ARRAY_SIZE(names)]; p++) { - if (*p && !strcasecmp(name, *p)) { - return p - names; - } - } - return -1; -} - -/* Returns name corresponding to the 'enum ofputil_action_code', - * or "Unkonwn action", if the name is not available. */ -const char * -ofputil_action_name_from_code(enum ofputil_action_code code) -{ - return code < (int)OFPUTIL_N_ACTIONS && names[code] ? names[code] - : "Unknown action"; -} - -enum ofputil_action_code -ofputil_action_code_from_ofp13_action(enum ofp13_action_type type) -{ - switch (type) { - -#define OFPAT13_ACTION(ENUM, STRUCT, EXTENSIBLE, NAME) \ - case ENUM: \ - return OFPUTIL_##ENUM; -#include "ofp-util.def" - + return b->size ? ofputil_pull_ofp14_port(pp, b) : EOF; default: - return OFPUTIL_ACTION_INVALID; - } -} - -/* Appends an action of the type specified by 'code' to 'buf' and returns the - * action. Initializes the parts of 'action' that identify it as having type - * and length 'sizeof *action' and zeros the rest. For actions that - * have variable length, the length used and cleared is that of struct - * . */ -void * -ofputil_put_action(enum ofputil_action_code code, struct ofpbuf *buf) -{ - switch (code) { - case OFPUTIL_ACTION_INVALID: -#define OFPAT13_ACTION(ENUM, STRUCT, EXTENSIBLE, NAME) case OFPUTIL_##ENUM: -#include "ofp-util.def" OVS_NOT_REACHED(); - -#define OFPAT10_ACTION(ENUM, STRUCT, NAME) \ - case OFPUTIL_##ENUM: return ofputil_put_##ENUM(buf); -#define OFPAT11_ACTION(ENUM, STRUCT, EXTENSIBLE, NAME) \ - case OFPUTIL_##ENUM: return ofputil_put_##ENUM(buf); -#define NXAST_ACTION(ENUM, STRUCT, EXTENSIBLE, NAME) \ - case OFPUTIL_##ENUM: return ofputil_put_##ENUM(buf); -#include "ofp-util.def" } - OVS_NOT_REACHED(); } -#define OFPAT10_ACTION(ENUM, STRUCT, NAME) \ - void \ - ofputil_init_##ENUM(struct STRUCT *s) \ - { \ - memset(s, 0, sizeof *s); \ - s->type = htons(ENUM); \ - s->len = htons(sizeof *s); \ - } \ - \ - struct STRUCT * \ - ofputil_put_##ENUM(struct ofpbuf *buf) \ - { \ - struct STRUCT *s = ofpbuf_put_uninit(buf, sizeof *s); \ - ofputil_init_##ENUM(s); \ - return s; \ - } -#define OFPAT11_ACTION(ENUM, STRUCT, EXTENSIBLE, NAME) \ - OFPAT10_ACTION(ENUM, STRUCT, NAME) -#define OFPAT13_ACTION(ENUM, STRUCT, EXTENSIBLE, NAME) \ - OFPAT10_ACTION(ENUM, STRUCT, NAME) -#define NXAST_ACTION(ENUM, STRUCT, EXTENSIBLE, NAME) \ - void \ - ofputil_init_##ENUM(struct STRUCT *s) \ - { \ - memset(s, 0, sizeof *s); \ - s->type = htons(OFPAT10_VENDOR); \ - s->len = htons(sizeof *s); \ - s->vendor = htonl(NX_VENDOR_ID); \ - s->subtype = htons(ENUM); \ - } \ - \ - struct STRUCT * \ - ofputil_put_##ENUM(struct ofpbuf *buf) \ - { \ - struct STRUCT *s = ofpbuf_put_uninit(buf, sizeof *s); \ - ofputil_init_##ENUM(s); \ - return s; \ - } -#include "ofp-util.def" - static void ofputil_normalize_match__(struct match *match, bool may_log) { @@ -6161,7 +6472,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) @@ -6245,7 +6556,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; @@ -6280,7 +6591,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)) { @@ -6382,9 +6693,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; } @@ -6411,7 +6722,7 @@ ofputil_pull_ofp14_port_stats(struct ofputil_port_stats *ops, } len = ntohs(ps14->length); - if (len < sizeof *ps14 || len - sizeof *ps14 > ofpbuf_size(msg)) { + if (len < sizeof *ps14 || len - sizeof *ps14 > msg->size) { return OFPERR_OFPBRC_BAD_LEN; } len -= sizeof *ps14; @@ -6437,7 +6748,7 @@ 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) { + while (properties.size > 0) { struct ofpbuf payload; enum ofperr error; uint16_t type; @@ -6499,14 +6810,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); @@ -6540,7 +6850,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; } @@ -6574,7 +6884,7 @@ 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; @@ -6585,6 +6895,107 @@ ofputil_bucket_list_destroy(struct list *buckets) } } +/* 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.) @@ -6618,6 +7029,13 @@ 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. */ @@ -6718,7 +7136,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; @@ -6791,20 +7209,18 @@ ofputil_encode_group_features_reply( { struct ofp12_group_features_stats *ogf; struct ofpbuf *reply; + int i; reply = ofpraw_alloc_xid(OFPRAW_OFPST12_GROUP_FEATURES_REPLY, request->version, request->xid, 0); ogf = ofpbuf_put_zeros(reply, sizeof *ogf); ogf->types = htonl(features->types); ogf->capabilities = htonl(features->capabilities); - ogf->max_groups[0] = htonl(features->max_groups[0]); - ogf->max_groups[1] = htonl(features->max_groups[1]); - ogf->max_groups[2] = htonl(features->max_groups[2]); - ogf->max_groups[3] = htonl(features->max_groups[3]); - ogf->actions[0] = htonl(features->actions[0]); - ogf->actions[1] = htonl(features->actions[1]); - ogf->actions[2] = htonl(features->actions[2]); - ogf->actions[3] = htonl(features->actions[3]); + for (i = 0; i < OFPGT12_N_TYPES; i++) { + ogf->max_groups[i] = htonl(features->max_groups[i]); + ogf->actions[i] = ofpact_bitmap_to_openflow(features->ofpacts[i], + request->version); + } return reply; } @@ -6815,17 +7231,15 @@ ofputil_decode_group_features_reply(const struct ofp_header *oh, struct ofputil_group_features *features) { const struct ofp12_group_features_stats *ogf = ofpmsg_body(oh); + int i; features->types = ntohl(ogf->types); features->capabilities = ntohl(ogf->capabilities); - features->max_groups[0] = ntohl(ogf->max_groups[0]); - features->max_groups[1] = ntohl(ogf->max_groups[1]); - features->max_groups[2] = ntohl(ogf->max_groups[2]); - features->max_groups[3] = ntohl(ogf->max_groups[3]); - features->actions[0] = ntohl(ogf->actions[0]); - features->actions[1] = ntohl(ogf->actions[1]); - features->actions[2] = ntohl(ogf->actions[2]); - features->actions[3] = ntohl(ogf->actions[3]); + for (i = 0; i < OFPGT12_N_TYPES; i++) { + features->max_groups[i] = ntohl(ogf->max_groups[i]); + features->ofpacts[i] = ofpact_bitmap_from_openflow( + ogf->actions[i], oh->version); + } } /* Parse a group status request message into a 32 bit OpenFlow 1.1 @@ -6864,14 +7278,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; } @@ -6897,7 +7310,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); @@ -6916,7 +7329,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; } @@ -6929,49 +7342,203 @@ ofputil_decode_group_stats_reply(struct ofpbuf *msg, return 0; } -/* Appends a group stats reply that contains the data in 'gds' to those already - * present in the list of ofpbufs in 'replies'. 'replies' should have been - * initialized with ofpmp_init(). */ -void -ofputil_append_group_desc_reply(const struct ofputil_group_desc *gds, - struct list *buckets, - struct list *replies) +static void +ofputil_put_ofp11_bucket(const struct ofputil_bucket *bucket, + struct ofpbuf *openflow, enum ofp_version ofp_version) +{ + struct ofp11_bucket *ob; + size_t start; + + 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(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_group_bucket_prop_weight(ovs_be16 weight, + struct ofpbuf *openflow) +{ + size_t start_ofs; + struct ofp15_group_bucket_prop_weight *prop; + + start_ofs = start_property(openflow, OFPGBPT15_WEIGHT); + ofpbuf_put_zeros(openflow, sizeof *prop - sizeof(struct ofp_prop_header)); + prop = ofpbuf_at_assert(openflow, start_ofs, sizeof *prop); + prop->weight = weight; + end_property(openflow, start_ofs); +} + +static void +ofputil_put_ofp15_group_bucket_prop_watch(ovs_be32 watch, uint16_t type, + struct ofpbuf *openflow) +{ + size_t start_ofs; + struct ofp15_group_bucket_prop_watch *prop; + + start_ofs = start_property(openflow, type); + ofpbuf_put_zeros(openflow, sizeof *prop - sizeof(struct ofp_prop_header)); + prop = ofpbuf_at_assert(openflow, start_ofs, sizeof *prop); + prop->watch = watch; + end_property(openflow, start_ofs); +} + +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) { + ofputil_put_ofp15_group_bucket_prop_weight(htons(bucket->weight), + openflow); + } + if (bucket->watch_port != OFPP_ANY) { + ovs_be32 port = ofputil_port_to_ofp11(bucket->watch_port); + ofputil_put_ofp15_group_bucket_prop_watch(port, + OFPGBPT15_WATCH_PORT, + openflow); + } + if (bucket->watch_group != OFPG_ANY) { + ovs_be32 group = htonl(bucket->watch_group); + ofputil_put_ofp15_group_bucket_prop_watch(group, + OFPGBPT15_WATCH_GROUP, + openflow); + } + + 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); + end_property(openflow, start); +} + +static void +ofputil_append_ofp11_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)); - enum ofp_version version = ofpmp_version(replies); struct ofp11_group_desc_stats *ogds; 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(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) { - struct ofp11_bucket *ob; - size_t start_ob; - - start_ob = ofpbuf_size(reply); - ofpbuf_put_zeros(reply, sizeof *ob); - ofpacts_put_openflow_actions(bucket->ofpacts, bucket->ofpacts_len, - reply, version); - ob = ofpbuf_at_assert(reply, start_ob, sizeof *ob); - ob->len = htons(ofpbuf_size(reply) - start_ob); - ob->weight = htons(bucket->weight); - ob->watch_port = ofputil_port_to_ofp11(bucket->watch_port); - ob->watch_group = htonl(bucket->watch_group); + ofputil_put_ofp15_bucket(bucket, bucket->bucket_id, + gds->type, 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); + 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); + } ofpmp_postappend(replies, start_ogds); } +/* Appends a group stats reply that contains the data in 'gds' to those already + * present in the list of ofpbufs in 'replies'. 'replies' should have been + * initialized with ofpmp_init(). */ +void +ofputil_append_group_desc_reply(const struct ofputil_group_desc *gds, + const struct ovs_list *buckets, + struct ovs_list *replies) +{ + enum ofp_version version = ofpmp_version(replies); + + switch (version) + { + case OFP11_VERSION: + case OFP12_VERSION: + case OFP13_VERSION: + case OFP14_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(); + } +} + static enum ofperr -ofputil_pull_buckets(struct ofpbuf *msg, size_t buckets_length, - enum ofp_version version, struct list *buckets) +ofputil_pull_ofp11_buckets(struct ofpbuf *msg, size_t buckets_length, + enum ofp_version version, struct ovs_list *buckets) { struct ofp11_bucket *ob; + uint32_t bucket_id = 0; list_init(buckets); while (buckets_length > 0) { @@ -6986,6 +7553,7 @@ ofputil_pull_buckets(struct ofpbuf *msg, size_t buckets_length, if (!ob) { VLOG_WARN_RL(&bad_ofmsg_rl, "buckets end with %"PRIuSIZE" leftover bytes", buckets_length); + return OFPERR_OFPGMFC_BAD_BUCKET; } ob_len = ntohs(ob->len); @@ -7019,121 +7587,750 @@ ofputil_pull_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 +parse_ofp15_group_bucket_prop_weight(const struct ofpbuf *payload, + ovs_be16 *weight) +{ + struct ofp15_group_bucket_prop_weight *prop = payload->data; + + if (payload->size != sizeof *prop) { + log_property(false, "OpenFlow bucket weight property length " + "%u is not valid", payload->size); + return OFPERR_OFPBPC_BAD_LEN; + } + + *weight = prop->weight; + + return 0; +} + +static enum ofperr +parse_ofp15_group_bucket_prop_watch(const struct ofpbuf *payload, + ovs_be32 *watch) +{ + struct ofp15_group_bucket_prop_watch *prop = payload->data; + + if (payload->size != sizeof *prop) { + log_property(false, "OpenFlow bucket watch port or group " + "property length %u is not valid", payload->size); + return OFPERR_OFPBPC_BAD_LEN; + } + + *watch = prop->watch; + + return 0; +} + +static enum ofperr +ofputil_pull_ofp15_buckets(struct ofpbuf *msg, size_t buckets_length, + enum ofp_version version, struct ovs_list *buckets) +{ + struct ofp15_bucket *ob; + + list_init(buckets); + while (buckets_length > 0) { + struct ofputil_bucket *bucket = NULL; + struct ofpbuf ofpacts; + enum ofperr err = OFPERR_OFPGMFC_BAD_BUCKET; + struct ofpbuf properties; + 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(1); + + ofpbuf_init(&ofpacts, 0); + + 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; + } + + ob_len = ntohs(ob->len); + actions_len = ntohs(ob->action_array_len); + + 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; + + err = ofpacts_pull_openflow_actions(msg, actions_len, version, + &ofpacts); + if (err) { + goto err; + } + + properties_len = ob_len - sizeof *ob - actions_len; + ofpbuf_use_const(&properties, ofpbuf_pull(msg, properties_len), + properties_len); + + while (properties.size > 0) { + struct ofpbuf payload; + uint16_t type; + + err = ofputil_pull_property(&properties, &payload, &type); + if (err) { + goto err; + } + + switch (type) { + case OFPGBPT15_WEIGHT: + err = parse_ofp15_group_bucket_prop_weight(&payload, &weight); + break; + + case OFPGBPT15_WATCH_PORT: + err = parse_ofp15_group_bucket_prop_watch(&payload, + &watch_port); + break; + + case OFPGBPT15_WATCH_GROUP: + err = parse_ofp15_group_bucket_prop_watch(&payload, + &watch_group); + break; + + default: + log_property(false, "unknown group bucket property %"PRIu16, + type); + err = OFPERR_OFPBPC_BAD_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: + log_property(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: + log_property(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) { + log_property(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) { + log_property(false, "ntr selection method is not null terminated"); + return OFPERR_OFPBPC_BAD_VALUE; + } + + if (strcmp("hash", prop->selection_method)) { + log_property(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) { + log_property(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) { + log_property(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) { + log_property(false, "ntr selection method fields are invalid"); + return error; + } + + return 0; +} + +static enum ofperr +parse_group_prop_ntr(struct ofpbuf *payload, uint32_t exp_type, + enum ofp11_group_type group_type, + enum ofp15_group_mod_command group_cmd, + struct ofputil_group_props *gp) +{ + enum ofperr error; + + switch (exp_type) { + case NTRT_SELECTION_METHOD: + error = parse_group_prop_ntr_selection_method(payload, group_type, + group_cmd, gp); + break; + + default: + log_property(false, "unknown group property ntr experimenter type " + "%"PRIu32, exp_type); + error = OFPERR_OFPBPC_BAD_TYPE; + break; + } + + return error; +} + +static enum ofperr +parse_ofp15_group_prop_exp(struct ofpbuf *payload, + enum ofp11_group_type group_type, + enum ofp15_group_mod_command group_cmd, + struct ofputil_group_props *gp) +{ + struct ofp_prop_experimenter *prop = payload->data; + uint16_t experimenter; + uint32_t exp_type; + enum ofperr error; + + if (payload->size < sizeof *prop) { + return OFPERR_OFPBPC_BAD_LEN; + } + + experimenter = ntohl(prop->experimenter); + exp_type = ntohl(prop->exp_type); + + switch (experimenter) { + case NTR_VENDOR_ID: + error = parse_group_prop_ntr(payload, exp_type, group_type, + group_cmd, gp); + break; + + default: + log_property(false, "unknown group property experimenter %"PRIu16, + experimenter); + error = OFPERR_OFPBPC_BAD_EXPERIMENTER; + break; + } + + return error; +} + +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_use_const(&properties, ofpbuf_pull(msg, properties_len), + properties_len); + + while (properties.size > 0) { + struct ofpbuf payload; + enum ofperr error; + uint16_t type; + + error = ofputil_pull_property(&properties, &payload, &type); + if (error) { + return error; + } + + switch (type) { + case OFPGPT15_EXPERIMENTER: + error = parse_ofp15_group_prop_exp(&payload, group_type, + group_cmd, gp); + break; + + default: + log_property(false, "unknown group property %"PRIu16, type); + error = OFPERR_OFPBPC_BAD_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->frame) { + if (!msg->header) { ofpraw_pull_assert(msg); } - if (!ofpbuf_size(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", ofpbuf_size(msg)); + "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 > ofpbuf_size(msg)) { + 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_buckets(msg, length - sizeof *ogds, version, - &gd->buckets); + return ofputil_pull_ofp11_buckets(msg, length - sizeof *ogds, version, + &gd->buckets); } -/* 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) +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->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, + msg->size); +} + +/* 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; - size_t start_bucket; struct ofputil_bucket *bucket; - struct ofp11_bucket *ob; - 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\')"); + 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 { - ovs_fatal(0, "del-groups needs OpenFlow 1.1 or later " - "(\'-O OpenFlow11\')"); + 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; +} + +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"; + + 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 = "insert-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: - case OFP15_VERSION: - b = ofpraw_alloc(OFPRAW_OFPT11_GROUP_MOD, ofp_version, 0); - start_ogm = ofpbuf_size(b); - ofpbuf_put_zeros(b, sizeof *ogm); - - LIST_FOR_EACH (bucket, list_node, &gm->buckets) { - start_bucket = ofpbuf_size(b); - ofpbuf_put_zeros(b, sizeof *ob); - if (bucket->ofpacts && bucket->ofpacts_len) { - ofpacts_put_openflow_actions(bucket->ofpacts, - bucket->ofpacts_len, b, - ofp_version); - } - ob = ofpbuf_at_assert(b, start_bucket, sizeof *ob); - ob->len = htons(ofpbuf_size(b) - start_bucket);; - ob->weight = htons(bucket->weight); - ob->watch_port = ofputil_port_to_ofp11(bucket->watch_port); - ob->watch_group = htonl(bucket->watch_group); + if (gm->command > OFPGC11_DELETE) { + bad_group_cmd(gm->command); } - 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 ofputil_encode_ofp11_group_mod(ofp_version, gm); - break; + case OFP15_VERSION: + return ofputil_encode_ofp15_group_mod(ofp_version, gm); default: OVS_NOT_REACHED(); } +} - return b; +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->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 @@ -7142,7 +8339,7 @@ enum ofperr ofputil_decode_group_mod(const struct ofp_header *oh, struct ofputil_group_mod *gm) { - const struct ofp11_group_mod *ogm; + enum ofp_version ofp_version = oh->version; struct ofpbuf msg; struct ofputil_bucket *bucket; enum ofperr err; @@ -7150,16 +8347,59 @@ ofputil_decode_group_mod(const struct ofp_header *oh, ofpbuf_use_const(&msg, oh, ntohs(oh->length)); ofpraw_pull_assert(&msg); - ogm = ofpbuf_pull(&msg, sizeof *ogm); - gm->command = ntohs(ogm->command); - gm->type = ogm->type; - gm->group_id = ntohl(ogm->group_id); + ofputil_init_group_properties(&gm->props); + + 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(); + } - err = ofputil_pull_buckets(&msg, ofpbuf_size(&msg), oh->version, &gm->buckets); 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: + OVS_NOT_REACHED(); + } + + 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: + OVS_NOT_REACHED(); + } + LIST_FOR_EACH (bucket, list_node, &gm->buckets) { switch (gm->type) { case OFPGT11_ALL: @@ -7216,9 +8456,9 @@ ofputil_decode_queue_stats_request(const struct ofp_header *request, } } -/* 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 */ +/* 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) @@ -7332,7 +8572,7 @@ ofputil_pull_ofp14_queue_stats(struct ofputil_queue_stats *oqs, } len = ntohs(qs14->length); - if (len < sizeof *qs14 || len - sizeof *qs14 > ofpbuf_size(msg)) { + if (len < sizeof *qs14 || len - sizeof *qs14 > msg->size) { return OFPERR_OFPBRC_BAD_LEN; } ofpbuf_pull(msg, len - sizeof *qs14); @@ -7358,14 +8598,13 @@ ofputil_decode_queue_stats(struct ofputil_queue_stats *qs, 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_QUEUE_REPLY) { return ofputil_pull_ofp14_queue_stats(qs, msg); @@ -7399,7 +8638,7 @@ ofputil_decode_queue_stats(struct ofputil_queue_stats *qs, struct ofpbuf *msg) bad_len: VLOG_WARN_RL(&bad_ofmsg_rl, "OFPST_QUEUE reply has %"PRIu32" leftover " - "bytes at end", ofpbuf_size(msg)); + "bytes at end", msg->size); return OFPERR_OFPBRC_BAD_LEN; } @@ -7452,7 +8691,7 @@ ofputil_queue_stats_to_ofp14(const struct ofputil_queue_stats *oqs, /* Encode a queue stat for 'oqs' and append it to 'replies'. */ void -ofputil_append_queue_stat(struct list *replies, +ofputil_append_queue_stat(struct ovs_list *replies, const struct ofputil_queue_stats *oqs) { switch (ofpmp_version(replies)) { @@ -7499,7 +8738,7 @@ ofputil_decode_bundle_ctrl(const struct ofp_header *oh, raw = ofpraw_pull_assert(&b); ovs_assert(raw == OFPRAW_OFPT14_BUNDLE_CONTROL); - m = ofpbuf_l3(&b); + m = b.msg; msg->bundle_id = ntohl(m->bundle_id); msg->type = ntohs(m->type); msg->flags = ntohs(m->flags); @@ -7524,6 +8763,92 @@ ofputil_encode_bundle_ctrl_reply(const struct ofp_header *oh, 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: + + /* 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_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_ROLE_STATUS: + break; + } + + return false; +} + enum ofperr ofputil_decode_bundle_add(const struct ofp_header *oh, struct ofputil_bundle_add_msg *msg) @@ -7532,6 +8857,8 @@ ofputil_decode_bundle_add(const struct ofp_header *oh, struct ofpbuf b; enum ofpraw raw; size_t inner_len; + enum ofperr error; + enum ofptype type; ofpbuf_use_const(&b, oh, ntohs(oh->length)); raw = ofpraw_pull_assert(&b); @@ -7541,11 +8868,26 @@ ofputil_decode_bundle_add(const struct ofp_header *oh, msg->bundle_id = ntohl(m->bundle_id); msg->flags = ntohs(m->flags); - msg->msg = ofpbuf_data(&b); + msg->msg = b.data; inner_len = ntohs(msg->msg->length); - if (inner_len < sizeof(struct ofp_header) || inner_len > ofpbuf_size(&b)) { + 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; + } + + /* Reject unbundlable messages. */ + 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 (!ofputil_is_bundlable(type)) { + return OFPERR_OFPBFC_MSG_UNSUP; + } return 0; }