X-Git-Url: http://git.onelab.eu/?a=blobdiff_plain;f=lib%2Fofp-util.c;h=8e81c0130ea8f2c411400a5d8dc569dad1067a4e;hb=a79f29f20e556514259d8593de779fc1b15c4055;hp=9645e04e1eb05d1a36efea790f4b269ca021b531;hpb=2134b5ec7df738baef77214a7044fa36d5121238;p=sliver-openvswitch.git diff --git a/lib/ofp-util.c b/lib/ofp-util.c index 9645e04e1..8e81c0130 100644 --- a/lib/ofp-util.c +++ b/lib/ofp-util.c @@ -1,5 +1,5 @@ /* - * Copyright (c) 2008, 2009, 2010, 2011, 2012, 2013 Nicira, Inc. + * Copyright (c) 2008, 2009, 2010, 2011, 2012, 2013, 2014 Nicira, Inc. * * Licensed under the Apache License, Version 2.0 (the "License"); * you may not use this file except in compliance with the License. @@ -42,6 +42,7 @@ #include "unaligned.h" #include "type-props.h" #include "vlog.h" +#include "bitmap.h" VLOG_DEFINE_THIS_MODULE(ofp_util); @@ -84,7 +85,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 == 22); + BUILD_ASSERT_DECL(FLOW_WC_SEQ == 25); /* Initialize most of wc. */ flow_wildcards_init_catchall(wc); @@ -169,9 +170,11 @@ ofputil_match_from_ofp10_match(const struct ofp10_match *ofmatch, match->wc.masks.vlan_tci = htons(0xffff); } else { ovs_be16 vid, pcp, tci; + uint16_t hpcp; vid = ofmatch->dl_vlan & htons(VLAN_VID_MASK); - pcp = htons((ofmatch->dl_vlan_pcp << VLAN_PCP_SHIFT) & VLAN_PCP_MASK); + hpcp = (ofmatch->dl_vlan_pcp << VLAN_PCP_SHIFT) & VLAN_PCP_MASK; + pcp = htons(hpcp); tci = vid | pcp | htons(VLAN_CFI); match->flow.vlan_tci = tci & match->wc.masks.vlan_tci; } @@ -437,10 +440,10 @@ ofputil_match_from_ofp11_match(const struct ofp11_match *ofmatch, if (eth_type_mpls(match->flow.dl_type)) { if (!(wc & OFPFW11_MPLS_LABEL)) { - match_set_mpls_label(match, ofmatch->mpls_label); + match_set_mpls_label(match, 0, ofmatch->mpls_label); } if (!(wc & OFPFW11_MPLS_TC)) { - match_set_mpls_tc(match, ofmatch->mpls_tc); + match_set_mpls_tc(match, 0, ofmatch->mpls_tc); } } @@ -533,16 +536,17 @@ ofputil_match_to_ofp11_match(const struct match *match, ofmatch->tp_dst = match->flow.tp_dst; } - if (!(match->wc.masks.mpls_lse & htonl(MPLS_LABEL_MASK))) { + if (!(match->wc.masks.mpls_lse[0] & htonl(MPLS_LABEL_MASK))) { wc |= OFPFW11_MPLS_LABEL; } else { - ofmatch->mpls_label = htonl(mpls_lse_to_label(match->flow.mpls_lse)); + ofmatch->mpls_label = htonl(mpls_lse_to_label( + match->flow.mpls_lse[0])); } - if (!(match->wc.masks.mpls_lse & htonl(MPLS_TC_MASK))) { + if (!(match->wc.masks.mpls_lse[0] & htonl(MPLS_TC_MASK))) { wc |= OFPFW11_MPLS_TC; } else { - ofmatch->mpls_tc = mpls_lse_to_tc(match->flow.mpls_lse); + ofmatch->mpls_tc = mpls_lse_to_tc(match->flow.mpls_lse[0]); } ofmatch->metadata = match->flow.metadata; @@ -570,10 +574,11 @@ ofputil_match_typical_len(enum ofputil_protocol protocol) case OFPUTIL_P_OF12_OXM: case OFPUTIL_P_OF13_OXM: + case OFPUTIL_P_OF14_OXM: return NXM_TYPICAL_LEN; default: - NOT_REACHED(); + OVS_NOT_REACHED(); } } @@ -595,7 +600,7 @@ ofputil_put_ofp11_match(struct ofpbuf *b, const struct match *match, case OFPUTIL_P_OF10_STD_TID: case OFPUTIL_P_OF10_NXM: case OFPUTIL_P_OF10_NXM_TID: - NOT_REACHED(); + OVS_NOT_REACHED(); case OFPUTIL_P_OF11_STD: { struct ofp11_match *om; @@ -610,10 +615,11 @@ ofputil_put_ofp11_match(struct ofpbuf *b, const struct match *match, case OFPUTIL_P_OF12_OXM: case OFPUTIL_P_OF13_OXM: + case OFPUTIL_P_OF14_OXM: return oxm_put_match(b, match); } - NOT_REACHED(); + OVS_NOT_REACHED(); } /* Given a 'dl_type' value in the format used in struct flow, returns the @@ -646,16 +652,21 @@ struct proto_abbrev { }; /* Most users really don't care about some of the differences between - * protocols. These abbreviations help with that. */ + * protocols. These abbreviations help with that. + * + * Until it is safe to use the OpenFlow 1.4 protocol (which currently can + * cause aborts due to unimplemented features), we omit OpenFlow 1.4 from all + * abbrevations. */ static const struct proto_abbrev proto_abbrevs[] = { - { OFPUTIL_P_ANY, "any" }, - { OFPUTIL_P_OF10_STD_ANY, "OpenFlow10" }, - { OFPUTIL_P_OF10_NXM_ANY, "NXM" }, - { OFPUTIL_P_ANY_OXM, "OXM" }, + { OFPUTIL_P_ANY & ~OFPUTIL_P_OF14_OXM, "any" }, + { OFPUTIL_P_OF10_STD_ANY & ~OFPUTIL_P_OF14_OXM, "OpenFlow10" }, + { OFPUTIL_P_OF10_NXM_ANY & ~OFPUTIL_P_OF14_OXM, "NXM" }, + { OFPUTIL_P_ANY_OXM & ~OFPUTIL_P_OF14_OXM, "OXM" }, }; #define N_PROTO_ABBREVS ARRAY_SIZE(proto_abbrevs) enum ofputil_protocol ofputil_flow_dump_protocols[] = { + OFPUTIL_P_OF14_OXM, OFPUTIL_P_OF13_OXM, OFPUTIL_P_OF12_OXM, OFPUTIL_P_OF11_STD, @@ -680,6 +691,8 @@ ofputil_protocols_from_ofp_version(enum ofp_version version) return OFPUTIL_P_OF12_OXM; case OFP13_VERSION: return OFPUTIL_P_OF13_OXM; + case OFP14_VERSION: + return OFPUTIL_P_OF14_OXM; default: return 0; } @@ -713,9 +726,11 @@ ofputil_protocol_to_ofp_version(enum ofputil_protocol protocol) return OFP12_VERSION; case OFPUTIL_P_OF13_OXM: return OFP13_VERSION; + case OFPUTIL_P_OF14_OXM: + return OFP14_VERSION; } - NOT_REACHED(); + OVS_NOT_REACHED(); } /* Returns a bitmap of OpenFlow versions that are supported by at @@ -789,8 +804,11 @@ ofputil_protocol_set_tid(enum ofputil_protocol protocol, bool enable) case OFPUTIL_P_OF13_OXM: return OFPUTIL_P_OF13_OXM; + case OFPUTIL_P_OF14_OXM: + return OFPUTIL_P_OF14_OXM; + default: - NOT_REACHED(); + OVS_NOT_REACHED(); } } @@ -829,8 +847,11 @@ ofputil_protocol_set_base(enum ofputil_protocol cur, case OFPUTIL_P_OF13_OXM: return ofputil_protocol_set_tid(OFPUTIL_P_OF13_OXM, tid); + case OFPUTIL_P_OF14_OXM: + return ofputil_protocol_set_tid(OFPUTIL_P_OF14_OXM, tid); + default: - NOT_REACHED(); + OVS_NOT_REACHED(); } } @@ -865,6 +886,9 @@ ofputil_protocol_to_string(enum ofputil_protocol protocol) case OFPUTIL_P_OF13_OXM: return "OXM-OpenFlow13"; + + case OFPUTIL_P_OF14_OXM: + return "OXM-OpenFlow14"; } /* Check abbreviations. */ @@ -918,7 +942,7 @@ ofputil_protocols_to_string(enum ofputil_protocol protocols) goto match; } } - NOT_REACHED(); + OVS_NOT_REACHED(); match: ; } @@ -1000,6 +1024,9 @@ ofputil_version_from_string(const char *s) if (!strcasecmp(s, "OpenFlow13")) { return OFP13_VERSION; } + if (!strcasecmp(s, "OpenFlow14")) { + return OFP14_VERSION; + } return 0; } @@ -1070,8 +1097,10 @@ ofputil_version_to_string(enum ofp_version ofp_version) return "OpenFlow12"; case OFP13_VERSION: return "OpenFlow13"; + case OFP14_VERSION: + return "OpenFlow14"; default: - NOT_REACHED(); + OVS_NOT_REACHED(); } } @@ -1096,7 +1125,7 @@ ofputil_packet_in_format_to_string(enum nx_packet_in_format packet_in_format) case NXPIF_NXM: return "nxm"; default: - NOT_REACHED(); + OVS_NOT_REACHED(); } } @@ -1303,13 +1332,14 @@ ofputil_encode_set_protocol(enum ofputil_protocol current, case OFPUTIL_P_OF11_STD: case OFPUTIL_P_OF12_OXM: case OFPUTIL_P_OF13_OXM: + case OFPUTIL_P_OF14_OXM: /* There is only one variant of each OpenFlow 1.1+ protocol, and we * verified above that we're not trying to change versions. */ - NOT_REACHED(); + OVS_NOT_REACHED(); case OFPUTIL_P_OF10_STD_TID: case OFPUTIL_P_OF10_NXM_TID: - NOT_REACHED(); + OVS_NOT_REACHED(); } } @@ -1378,7 +1408,7 @@ ofputil_nx_flow_format_to_string(enum nx_flow_format flow_format) case NXFF_NXM: return "nxm"; default: - NOT_REACHED(); + OVS_NOT_REACHED(); } } @@ -1542,10 +1572,10 @@ ofputil_decode_flow_mod(struct ofputil_flow_mod *fm, /* Get table ID. * - * OF1.1 entirely forbids table_id == 255. - * OF1.2+ allows table_id == 255 only for deletes. */ + * OF1.1 entirely forbids table_id == OFPTT_ALL. + * OF1.2+ allows table_id == OFPTT_ALL only for deletes. */ fm->table_id = ofm->table_id; - if (fm->table_id == 255 + if (fm->table_id == OFPTT_ALL && (oh->version == OFP11_VERSION || (ofm->command != OFPFC_DELETE && ofm->command != OFPFC_DELETE_STRICT))) { @@ -1559,13 +1589,11 @@ ofputil_decode_flow_mod(struct ofputil_flow_mod *fm, if (error) { return error; } - fm->out_group = ntohl(ofm->out_group); - if ((ofm->command == OFPFC_DELETE - || ofm->command == OFPFC_DELETE_STRICT) - && ofm->out_group != htonl(OFPG_ANY)) { - return OFPERR_OFPFMFC_UNKNOWN; - } + fm->out_group = (ofm->command == OFPFC_DELETE || + ofm->command == OFPFC_DELETE_STRICT + ? ntohl(ofm->out_group) + : OFPG11_ANY); raw_flags = ofm->flags; } else { uint16_t command; @@ -1638,7 +1666,7 @@ ofputil_decode_flow_mod(struct ofputil_flow_mod *fm, fm->out_group = OFPG11_ANY; raw_flags = nfm->flags; } else { - NOT_REACHED(); + OVS_NOT_REACHED(); } fm->modify_cookie = fm->new_cookie != OVS_BE64_MAX; @@ -1672,9 +1700,9 @@ ofputil_decode_flow_mod(struct ofputil_flow_mod *fm, : OFPERR_OFPFMFC_TABLE_FULL); } - return ofpacts_check(fm->ofpacts, fm->ofpacts_len, &fm->match.flow, - oh->version > OFP10_VERSION, max_port, - fm->table_id, max_table); + return ofpacts_check_consistency(fm->ofpacts, fm->ofpacts_len, + &fm->match.flow, max_port, + fm->table_id, max_table, protocol); } static enum ofperr @@ -1698,6 +1726,9 @@ ofputil_pull_bands(struct ofpbuf *msg, size_t len, uint16_t *n_bands, } mb = ofpbuf_put_uninit(bands, sizeof *mb); mb->type = ntohs(ombh->type); + if (mb->type != OFPMBT13_DROP && mb->type != OFPMBT13_DSCP_REMARK) { + return OFPERR_OFPMMFC_BAD_BAND; + } mb->rate = ntohl(ombh->rate); mb->burst_size = ntohl(ombh->burst_size); mb->prec_level = (mb->type == OFPMBT13_DSCP_REMARK) ? @@ -1728,6 +1759,11 @@ ofputil_decode_meter_mod(const struct ofp_header *oh, /* Translate the message. */ mm->command = ntohs(omm->command); + if (mm->command != OFPMC13_ADD && + mm->command != OFPMC13_MODIFY && + mm->command != OFPMC13_DELETE) { + return OFPERR_OFPMMFC_BAD_COMMAND; + } mm->meter.meter_id = ntohl(omm->meter_id); if (mm->command == OFPMC13_DELETE) { @@ -1738,6 +1774,10 @@ ofputil_decode_meter_mod(const struct ofp_header *oh, enum ofperr error; mm->meter.flags = ntohs(omm->flags); + if (mm->meter.flags & OFPMF13_KBPS && + mm->meter.flags & OFPMF13_PKTPS) { + return OFPERR_OFPMMFC_BAD_FLAGS; + } mm->meter.bands = bands->data; error = ofputil_pull_bands(&b, b.size, &mm->meter.n_bands, bands); @@ -1889,7 +1929,7 @@ ofputil_decode_meter_config(struct ofpbuf *msg, omc = ofpbuf_try_pull(msg, sizeof *omc); if (!omc) { VLOG_WARN_RL(&bad_ofmsg_rl, - "OFPMP_METER_CONFIG reply has %zu leftover bytes at end", + "OFPMP_METER_CONFIG reply has %"PRIuSIZE" leftover bytes at end", msg->size); return OFPERR_OFPBRC_BAD_LEN; } @@ -1965,7 +2005,7 @@ ofputil_decode_meter_stats(struct ofpbuf *msg, oms = ofpbuf_try_pull(msg, sizeof *oms); if (!oms) { VLOG_WARN_RL(&bad_ofmsg_rl, - "OFPMP_METER reply has %zu leftover bytes at end", + "OFPMP_METER reply has %"PRIuSIZE" leftover bytes at end", msg->size); return OFPERR_OFPBRC_BAD_LEN; } @@ -2064,7 +2104,8 @@ ofputil_encode_flow_mod(const struct ofputil_flow_mod *fm, switch (protocol) { case OFPUTIL_P_OF11_STD: case OFPUTIL_P_OF12_OXM: - case OFPUTIL_P_OF13_OXM: { + case OFPUTIL_P_OF13_OXM: + case OFPUTIL_P_OF14_OXM: { struct ofp11_flow_mod *ofm; int tailroom; @@ -2081,7 +2122,7 @@ ofputil_encode_flow_mod(const struct ofputil_flow_mod *fm, ofm->cookie = fm->cookie; } ofm->cookie_mask = fm->cookie_mask; - if (fm->table_id != 255 + if (fm->table_id != OFPTT_ALL || (protocol != OFPUTIL_P_OF11_STD && (fm->command == OFPFC_DELETE || fm->command == OFPFC_DELETE_STRICT))) { @@ -2149,7 +2190,7 @@ ofputil_encode_flow_mod(const struct ofputil_flow_mod *fm, } default: - NOT_REACHED(); + OVS_NOT_REACHED(); } ofpmsg_update_length(msg); @@ -2274,7 +2315,7 @@ ofputil_decode_queue_get_config_request(const struct ofp_header *oh, return ofputil_port_from_ofp11(qgcr11->port, port); } - NOT_REACHED(); + OVS_NOT_REACHED(); } /* Constructs and returns the beginning of a reply to @@ -2313,7 +2354,7 @@ ofputil_encode_queue_get_config_reply(const struct ofp_header *oh) break; default: - NOT_REACHED(); + OVS_NOT_REACHED(); } return reply; @@ -2395,7 +2436,7 @@ ofputil_decode_queue_get_config_reply(struct ofpbuf *reply, ofp_port_t *port) return ofputil_port_from_ofp11(qgcr11->port, port); } - NOT_REACHED(); + OVS_NOT_REACHED(); } static enum ofperr @@ -2531,7 +2572,7 @@ ofputil_decode_flow_stats_request(struct ofputil_flow_stats_request *fsr, default: /* Hey, the caller lied. */ - NOT_REACHED(); + OVS_NOT_REACHED(); } } @@ -2548,7 +2589,8 @@ ofputil_encode_flow_stats_request(const struct ofputil_flow_stats_request *fsr, switch (protocol) { case OFPUTIL_P_OF11_STD: case OFPUTIL_P_OF12_OXM: - case OFPUTIL_P_OF13_OXM: { + case OFPUTIL_P_OF13_OXM: + case OFPUTIL_P_OF14_OXM: { struct ofp11_flow_stats_request *ofsr; raw = (fsr->aggregate @@ -2602,7 +2644,7 @@ ofputil_encode_flow_stats_request(const struct ofputil_flow_stats_request *fsr, } default: - NOT_REACHED(); + OVS_NOT_REACHED(); } return msg; @@ -2656,7 +2698,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 %zu leftover " + VLOG_WARN_RL(&bad_ofmsg_rl, "OFPST_FLOW reply has %"PRIuSIZE" leftover " "bytes at end", msg->size); return EINVAL; } @@ -2664,7 +2706,7 @@ ofputil_decode_flow_stats_reply(struct ofputil_flow_stats *fs, length = ntohs(ofs->length); if (length < sizeof *ofs) { VLOG_WARN_RL(&bad_ofmsg_rl, "OFPST_FLOW reply claims invalid " - "length %zu", length); + "length %"PRIuSIZE, length); return EINVAL; } @@ -2706,7 +2748,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 %zu leftover " + VLOG_WARN_RL(&bad_ofmsg_rl, "OFPST_FLOW reply has %"PRIuSIZE" leftover " "bytes at end", msg->size); return EINVAL; } @@ -2714,7 +2756,7 @@ ofputil_decode_flow_stats_reply(struct ofputil_flow_stats *fs, length = ntohs(ofs->length); if (length < sizeof *ofs) { VLOG_WARN_RL(&bad_ofmsg_rl, "OFPST_FLOW reply claims invalid " - "length %zu", length); + "length %"PRIuSIZE, length); return EINVAL; } @@ -2742,7 +2784,7 @@ ofputil_decode_flow_stats_reply(struct ofputil_flow_stats *fs, nfs = ofpbuf_try_pull(msg, sizeof *nfs); if (!nfs) { - VLOG_WARN_RL(&bad_ofmsg_rl, "NXST_FLOW reply has %zu leftover " + VLOG_WARN_RL(&bad_ofmsg_rl, "NXST_FLOW reply has %"PRIuSIZE" leftover " "bytes at end", msg->size); return EINVAL; } @@ -2750,8 +2792,8 @@ ofputil_decode_flow_stats_reply(struct ofputil_flow_stats *fs, length = ntohs(nfs->length); match_len = ntohs(nfs->match_len); if (length < sizeof *nfs + ROUND_UP(match_len, 8)) { - VLOG_WARN_RL(&bad_ofmsg_rl, "NXST_FLOW reply with match_len=%zu " - "claims invalid length %zu", match_len, length); + VLOG_WARN_RL(&bad_ofmsg_rl, "NXST_FLOW reply with match_len=%"PRIuSIZE" " + "claims invalid length %"PRIuSIZE, match_len, length); return EINVAL; } if (nx_pull_match(msg, match_len, &fs->match, NULL, NULL)) { @@ -2785,7 +2827,7 @@ ofputil_decode_flow_stats_reply(struct ofputil_flow_stats *fs, fs->byte_count = ntohll(nfs->byte_count); fs->flags = 0; } else { - NOT_REACHED(); + OVS_NOT_REACHED(); } fs->ofpacts = ofpacts->data; @@ -2893,7 +2935,7 @@ ofputil_append_flow_stats_reply(const struct ofputil_flow_stats *fs, nfs->packet_count = htonll(fs->packet_count); nfs->byte_count = htonll(fs->byte_count); } else { - NOT_REACHED(); + OVS_NOT_REACHED(); } ofpmp_postappend(replies, start_ofs); @@ -3022,7 +3064,7 @@ ofputil_decode_flow_removed(struct ofputil_flow_removed *fr, fr->packet_count = ntohll(nfr->packet_count); fr->byte_count = ntohll(nfr->byte_count); } else { - NOT_REACHED(); + OVS_NOT_REACHED(); } return 0; @@ -3040,7 +3082,8 @@ ofputil_encode_flow_removed(const struct ofputil_flow_removed *fr, switch (protocol) { case OFPUTIL_P_OF11_STD: case OFPUTIL_P_OF12_OXM: - case OFPUTIL_P_OF13_OXM: { + case OFPUTIL_P_OF13_OXM: + case OFPUTIL_P_OF14_OXM: { struct ofp12_flow_removed *ofr; msg = ofpraw_alloc_xid(OFPRAW_OFPT11_FLOW_REMOVED, @@ -3106,7 +3149,7 @@ ofputil_encode_flow_removed(const struct ofputil_flow_removed *fr, } default: - NOT_REACHED(); + OVS_NOT_REACHED(); } return msg; @@ -3184,6 +3227,23 @@ ofputil_decode_packet_in(struct ofputil_packet_in *pin, pin->reason = opi->reason; pin->buffer_id = ntohl(opi->buffer_id); pin->total_len = ntohs(opi->total_len); + } else if (raw == OFPRAW_OFPT11_PACKET_IN) { + const struct ofp11_packet_in *opi; + enum ofperr error; + + opi = ofpbuf_pull(&b, sizeof *opi); + + 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); + if (error) { + return error; + } + pin->total_len = ntohs(opi->total_len); + pin->reason = opi->reason; + pin->table_id = opi->table_id; } else if (raw == OFPRAW_NXT_PACKET_IN) { const struct nx_packet_in *npi; struct match match; @@ -3209,7 +3269,7 @@ ofputil_decode_packet_in(struct ofputil_packet_in *pin, ofputil_decode_packet_in_finish(pin, &match, &b); } else { - NOT_REACHED(); + OVS_NOT_REACHED(); } return 0; @@ -3248,6 +3308,120 @@ ofputil_packet_in_to_match(const struct ofputil_packet_in *pin, match_set_in_port(match, pin->fmd.in_port); } +static struct ofpbuf * +ofputil_encode_ofp10_packet_in(const struct ofputil_packet_in *pin) +{ + struct ofp10_packet_in *opi; + struct ofpbuf *packet; + + packet = ofpraw_alloc_xid(OFPRAW_OFPT10_PACKET_IN, OFP10_VERSION, + htonl(0), pin->packet_len); + opi = ofpbuf_put_zeros(packet, offsetof(struct ofp10_packet_in, data)); + opi->total_len = htons(pin->total_len); + opi->in_port = htons(ofp_to_u16(pin->fmd.in_port)); + opi->reason = pin->reason; + opi->buffer_id = htonl(pin->buffer_id); + + ofpbuf_put(packet, pin->packet, pin->packet_len); + + return packet; +} + +static struct ofpbuf * +ofputil_encode_nx_packet_in(const struct ofputil_packet_in *pin) +{ + struct nx_packet_in *npi; + struct ofpbuf *packet; + struct match match; + size_t match_len; + + ofputil_packet_in_to_match(pin, &match); + + /* The final argument is just an estimate of the space required. */ + packet = ofpraw_alloc_xid(OFPRAW_NXT_PACKET_IN, OFP10_VERSION, + htonl(0), (sizeof(struct flow_metadata) * 2 + + 2 + pin->packet_len)); + ofpbuf_put_zeros(packet, sizeof *npi); + match_len = nx_put_match(packet, &match, 0, 0); + ofpbuf_put_zeros(packet, 2); + ofpbuf_put(packet, pin->packet, pin->packet_len); + + npi = packet->l3; + npi->buffer_id = htonl(pin->buffer_id); + npi->total_len = htons(pin->total_len); + npi->reason = pin->reason; + npi->table_id = pin->table_id; + npi->cookie = pin->cookie; + npi->match_len = htons(match_len); + + return packet; +} + +static struct ofpbuf * +ofputil_encode_ofp11_packet_in(const struct ofputil_packet_in *pin) +{ + struct ofp11_packet_in *opi; + struct ofpbuf *packet; + + packet = ofpraw_alloc_xid(OFPRAW_OFPT11_PACKET_IN, OFP11_VERSION, + htonl(0), pin->packet_len); + opi = ofpbuf_put_zeros(packet, sizeof *opi); + opi->buffer_id = htonl(pin->buffer_id); + opi->in_port = ofputil_port_to_ofp11(pin->fmd.in_port); + opi->in_phy_port = opi->in_port; + opi->total_len = htons(pin->total_len); + opi->reason = pin->reason; + opi->table_id = pin->table_id; + + ofpbuf_put(packet, pin->packet, pin->packet_len); + + return packet; +} + +static struct ofpbuf * +ofputil_encode_ofp12_packet_in(const struct ofputil_packet_in *pin, + enum ofputil_protocol protocol) +{ + struct ofp13_packet_in *opi; + struct match match; + enum ofpraw packet_in_raw; + enum ofp_version packet_in_version; + size_t packet_in_size; + struct ofpbuf *packet; + + if (protocol == OFPUTIL_P_OF12_OXM) { + packet_in_raw = OFPRAW_OFPT12_PACKET_IN; + packet_in_version = OFP12_VERSION; + packet_in_size = sizeof (struct ofp12_packet_in); + } else { + packet_in_raw = OFPRAW_OFPT13_PACKET_IN; + packet_in_version = OFP13_VERSION; + packet_in_size = sizeof (struct ofp13_packet_in); + } + + ofputil_packet_in_to_match(pin, &match); + + /* The final argument is just an estimate of the space required. */ + packet = ofpraw_alloc_xid(packet_in_raw, packet_in_version, + htonl(0), (sizeof(struct flow_metadata) * 2 + + 2 + pin->packet_len)); + ofpbuf_put_zeros(packet, packet_in_size); + oxm_put_match(packet, &match); + ofpbuf_put_zeros(packet, 2); + ofpbuf_put(packet, pin->packet, pin->packet_len); + + opi = packet->l3; + opi->pi.buffer_id = htonl(pin->buffer_id); + opi->pi.total_len = htons(pin->total_len); + opi->pi.reason = pin->reason; + opi->pi.table_id = pin->table_id; + if (protocol == OFPUTIL_P_OF13_OXM) { + opi->cookie = pin->cookie; + } + + return packet; +} + /* Converts abstract ofputil_packet_in 'pin' into a PACKET_IN message * in the format specified by 'packet_in_format'. */ struct ofpbuf * @@ -3257,83 +3431,31 @@ ofputil_encode_packet_in(const struct ofputil_packet_in *pin, { struct ofpbuf *packet; - /* Add OFPT_PACKET_IN. */ - if (protocol == OFPUTIL_P_OF13_OXM || protocol == OFPUTIL_P_OF12_OXM) { - struct ofp13_packet_in *opi; - struct match match; - enum ofpraw packet_in_raw; - enum ofp_version packet_in_version; - size_t packet_in_size; + switch (protocol) { + case OFPUTIL_P_OF10_STD: + case OFPUTIL_P_OF10_STD_TID: + case OFPUTIL_P_OF10_NXM: + case OFPUTIL_P_OF10_NXM_TID: + packet = (packet_in_format == NXPIF_NXM + ? ofputil_encode_nx_packet_in(pin) + : ofputil_encode_ofp10_packet_in(pin)); + break; - if (protocol == OFPUTIL_P_OF12_OXM) { - packet_in_raw = OFPRAW_OFPT12_PACKET_IN; - packet_in_version = OFP12_VERSION; - packet_in_size = sizeof (struct ofp12_packet_in); - } else { - packet_in_raw = OFPRAW_OFPT13_PACKET_IN; - packet_in_version = OFP13_VERSION; - packet_in_size = sizeof (struct ofp13_packet_in); - } + case OFPUTIL_P_OF11_STD: + packet = ofputil_encode_ofp11_packet_in(pin); + break; - ofputil_packet_in_to_match(pin, &match); - - /* The final argument is just an estimate of the space required. */ - packet = ofpraw_alloc_xid(packet_in_raw, packet_in_version, - htonl(0), (sizeof(struct flow_metadata) * 2 - + 2 + pin->packet_len)); - ofpbuf_put_zeros(packet, packet_in_size); - oxm_put_match(packet, &match); - ofpbuf_put_zeros(packet, 2); - ofpbuf_put(packet, pin->packet, pin->packet_len); - - opi = packet->l3; - opi->pi.buffer_id = htonl(pin->buffer_id); - opi->pi.total_len = htons(pin->total_len); - opi->pi.reason = pin->reason; - opi->pi.table_id = pin->table_id; - if (protocol == OFPUTIL_P_OF13_OXM) { - opi->cookie = pin->cookie; - } - } else if (packet_in_format == NXPIF_OPENFLOW10) { - struct ofp10_packet_in *opi; - - packet = ofpraw_alloc_xid(OFPRAW_OFPT10_PACKET_IN, OFP10_VERSION, - htonl(0), pin->packet_len); - opi = ofpbuf_put_zeros(packet, offsetof(struct ofp10_packet_in, data)); - opi->total_len = htons(pin->total_len); - opi->in_port = htons(ofp_to_u16(pin->fmd.in_port)); - opi->reason = pin->reason; - opi->buffer_id = htonl(pin->buffer_id); - - ofpbuf_put(packet, pin->packet, pin->packet_len); - } else if (packet_in_format == NXPIF_NXM) { - struct nx_packet_in *npi; - struct match match; - size_t match_len; - - ofputil_packet_in_to_match(pin, &match); - - /* The final argument is just an estimate of the space required. */ - packet = ofpraw_alloc_xid(OFPRAW_NXT_PACKET_IN, OFP10_VERSION, - htonl(0), (sizeof(struct flow_metadata) * 2 - + 2 + pin->packet_len)); - ofpbuf_put_zeros(packet, sizeof *npi); - match_len = nx_put_match(packet, &match, 0, 0); - ofpbuf_put_zeros(packet, 2); - ofpbuf_put(packet, pin->packet, pin->packet_len); - - npi = packet->l3; - npi->buffer_id = htonl(pin->buffer_id); - npi->total_len = htons(pin->total_len); - npi->reason = pin->reason; - npi->table_id = pin->table_id; - npi->cookie = pin->cookie; - npi->match_len = htons(match_len); - } else { - NOT_REACHED(); + case OFPUTIL_P_OF12_OXM: + case OFPUTIL_P_OF13_OXM: + case OFPUTIL_P_OF14_OXM: + packet = ofputil_encode_ofp12_packet_in(pin, protocol); + break; + + default: + OVS_NOT_REACHED(); } - ofpmsg_update_length(packet); + ofpmsg_update_length(packet); return packet; } @@ -3426,7 +3548,7 @@ ofputil_decode_packet_out(struct ofputil_packet_out *po, return error; } } else { - NOT_REACHED(); + OVS_NOT_REACHED(); } if (ofp_to_u16(po->in_port) >= ofp_to_u16(OFPP_MAX) @@ -3551,7 +3673,7 @@ ofputil_decode_ofp11_port(struct ofputil_phy_port *pp, ovs_strlcpy(pp->name, op->name, OFP_MAX_PORT_NAME_LEN); pp->config = ntohl(op->config) & OFPPC11_ALL; - pp->state = ntohl(op->state) & OFPPC11_ALL; + pp->state = ntohl(op->state) & OFPPS11_ALL; pp->curr = netdev_port_features_from_ofp11(op->curr); pp->advertised = netdev_port_features_from_ofp11(op->advertised); @@ -3573,9 +3695,10 @@ ofputil_get_phy_port_size(enum ofp_version ofp_version) case OFP11_VERSION: case OFP12_VERSION: case OFP13_VERSION: + case OFP14_VERSION: return sizeof(struct ofp11_port); default: - NOT_REACHED(); + OVS_NOT_REACHED(); } } @@ -3645,8 +3768,12 @@ ofputil_put_phy_port(enum ofp_version ofp_version, break; } + case OFP14_VERSION: + OVS_NOT_REACHED(); + break; + default: - NOT_REACHED(); + OVS_NOT_REACHED(); } } @@ -3674,8 +3801,12 @@ ofputil_append_port_desc_stats_reply(enum ofp_version ofp_version, break; } + case OFP14_VERSION: + OVS_NOT_REACHED(); + break; + default: - NOT_REACHED(); + OVS_NOT_REACHED(); } } @@ -3737,6 +3868,9 @@ ofputil_capabilities_mask(enum ofp_version ofp_version) case OFP12_VERSION: case OFP13_VERSION: return OFPC_COMMON | OFPC12_PORT_BLOCKED; + case OFP14_VERSION: + OVS_NOT_REACHED(); + break; default: /* Caller needs to check osf->header.version itself */ return 0; @@ -3863,10 +3997,11 @@ ofputil_encode_switch_features(const struct ofputil_switch_features *features, raw = OFPRAW_OFPT11_FEATURES_REPLY; break; case OFP13_VERSION: + case OFP14_VERSION: raw = OFPRAW_OFPT13_FEATURES_REPLY; break; default: - NOT_REACHED(); + OVS_NOT_REACHED(); } b = ofpraw_alloc_xid(raw, version, xid, 0); osf = ofpbuf_put_zeros(b, sizeof *osf); @@ -3885,6 +4020,7 @@ ofputil_encode_switch_features(const struct ofputil_switch_features *features, osf->actions = encode_action_bits(features->actions, of10_action_bits); break; case OFP13_VERSION: + case OFP14_VERSION: osf->auxiliary_id = features->auxiliary_id; /* fall through */ case OFP11_VERSION: @@ -3894,7 +4030,7 @@ ofputil_encode_switch_features(const struct ofputil_switch_features *features, } break; default: - NOT_REACHED(); + OVS_NOT_REACHED(); } return b; @@ -3963,11 +4099,12 @@ ofputil_encode_port_status(const struct ofputil_port_status *ps, case OFP11_VERSION: case OFP12_VERSION: case OFP13_VERSION: + case OFP14_VERSION: raw = OFPRAW_OFPT11_PORT_STATUS; break; default: - NOT_REACHED(); + OVS_NOT_REACHED(); } b = ofpraw_alloc_xid(raw, version, htonl(0), 0); @@ -4059,13 +4196,359 @@ ofputil_encode_port_mod(const struct ofputil_port_mod *pm, opm->advertise = netdev_port_features_to_ofp11(pm->advertise); break; } + case OFP14_VERSION: + OVS_NOT_REACHED(); + break; default: - NOT_REACHED(); + OVS_NOT_REACHED(); } return b; } +struct ofp_prop_header { + ovs_be16 type; + ovs_be16 len; +}; + +static enum ofperr +ofputil_pull_property(struct ofpbuf *msg, struct ofpbuf *payload, + uint16_t *typep) +{ + struct ofp_prop_header *oph; + unsigned int len; + + if (msg->size < sizeof *oph) { + return OFPERR_OFPTFFC_BAD_LEN; + } + + oph = msg->data; + len = ntohs(oph->len); + if (len < sizeof *oph || ROUND_UP(len, 8) > msg->size) { + return OFPERR_OFPTFFC_BAD_LEN; + } + + *typep = ntohs(oph->type); + if (payload) { + ofpbuf_use_const(payload, msg->data, len); + ofpbuf_pull(payload, sizeof *oph); + } + ofpbuf_pull(msg, ROUND_UP(len, 8)); + return 0; +} + +static void PRINTF_FORMAT(2, 3) +log_property(bool loose, const char *message, ...) +{ + enum vlog_level level = loose ? VLL_DBG : VLL_WARN; + if (!vlog_should_drop(THIS_MODULE, level, &bad_ofmsg_rl)) { + va_list args; + + va_start(args, message); + vlog_valist(THIS_MODULE, level, message, args); + va_end(args); + } +} + +static enum ofperr +parse_table_ids(struct ofpbuf *payload, uint32_t *ids) +{ + uint16_t type; + + *ids = 0; + while (payload->size > 0) { + enum ofperr error = ofputil_pull_property(payload, NULL, &type); + if (error) { + return error; + } + if (type < CHAR_BIT * sizeof *ids) { + *ids |= 1u << type; + } + } + return 0; +} + +static enum ofperr +parse_instruction_ids(struct ofpbuf *payload, bool loose, uint32_t *insts) +{ + *insts = 0; + while (payload->size > 0) { + enum ovs_instruction_type inst; + enum ofperr error; + uint16_t ofpit; + + error = ofputil_pull_property(payload, NULL, &ofpit); + if (error) { + return error; + } + + error = ovs_instruction_type_from_inst_type(&inst, ofpit); + if (!error) { + *insts |= 1u << inst; + } else if (!loose) { + return error; + } + } + return 0; +} + +static enum ofperr +parse_table_features_next_table(struct ofpbuf *payload, + unsigned long int *next_tables) +{ + size_t i; + + memset(next_tables, 0, bitmap_n_bytes(255)); + for (i = 0; i < payload->size; i++) { + uint8_t id = ((const uint8_t *) payload->data)[i]; + if (id >= 255) { + return OFPERR_OFPTFFC_BAD_ARGUMENT; + } + bitmap_set1(next_tables, id); + } + 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_OFPTFFC_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_OFPTFFC_BAD_ARGUMENT; + } + 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) +{ + uint64_t exact, masked; + + exact = masked = 0; + while (payload->size > 0) { + const struct mf_field *field; + enum ofperr error; + bool hasmask; + + error = parse_oxm(payload, loose, &field, &hasmask); + if (!error) { + if (hasmask) { + masked |= UINT64_C(1) << field->id; + } else { + exact |= UINT64_C(1) << field->id; + } + } else if (error != OFPERR_OFPBMC_BAD_FIELD || !loose) { + return error; + } + } + if (exactp) { + *exactp = exact; + } else if (exact) { + return OFPERR_OFPBMC_BAD_MASK; + } + if (maskedp) { + *maskedp = masked; + } else if (masked) { + return OFPERR_OFPBMC_BAD_MASK; + } + return 0; +} + +/* Converts an OFPMP_TABLE_FEATURES request or reply in 'msg' into an abstract + * ofputil_table_features in 'tf'. + * + * If 'loose' is true, this function ignores properties and values that it does + * not understand, as a controller would want to do when interpreting + * capabilities provided by a switch. If 'loose' is false, this function + * treats unknown properties and values as an error, as a switch would want to + * do when interpreting a configuration request made by a controller. + * + * A single OpenFlow message can specify features for multiple tables. Calling + * this function multiple times for a single 'msg' iterates through the tables + * in the message. The caller must initially leave 'msg''s layer pointers null + * and not modify them between calls. + * + * Returns 0 if successful, EOF if no tables were left in this 'msg', otherwise + * a positive "enum ofperr" value. */ +int +ofputil_decode_table_features(struct ofpbuf *msg, + struct ofputil_table_features *tf, bool loose) +{ + struct ofp13_table_features *otf; + unsigned int len; + + if (!msg->l2) { + msg->l2 = msg->data; + ofpraw_pull_assert(msg); + } + + if (!msg->size) { + return EOF; + } + + if (msg->size < sizeof *otf) { + return OFPERR_OFPTFFC_BAD_LEN; + } + + otf = msg->data; + len = ntohs(otf->length); + if (len < sizeof *otf || len % 8 || len > msg->size) { + return OFPERR_OFPTFFC_BAD_LEN; + } + ofpbuf_pull(msg, sizeof *otf); + + tf->table_id = otf->table_id; + if (tf->table_id == OFPTT_ALL) { + return OFPERR_OFPTFFC_BAD_TABLE; + } + + 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->max_entries = ntohl(otf->max_entries); + + while (msg->size > 0) { + struct ofpbuf payload; + enum ofperr error; + uint16_t type; + + error = ofputil_pull_property(msg, &payload, &type); + if (error) { + return error; + } + + switch ((enum ofp13_table_feature_prop_type) type) { + case OFPTFPT13_INSTRUCTIONS: + error = parse_instruction_ids(&payload, loose, + &tf->nonmiss.instructions); + break; + case OFPTFPT13_INSTRUCTIONS_MISS: + error = parse_instruction_ids(&payload, loose, + &tf->miss.instructions); + break; + + case OFPTFPT13_NEXT_TABLES: + error = parse_table_features_next_table(&payload, + tf->nonmiss.next); + break; + case OFPTFPT13_NEXT_TABLES_MISS: + error = parse_table_features_next_table(&payload, tf->miss.next); + break; + + case OFPTFPT13_WRITE_ACTIONS: + error = parse_table_ids(&payload, &tf->nonmiss.write.actions); + break; + case OFPTFPT13_WRITE_ACTIONS_MISS: + error = parse_table_ids(&payload, &tf->miss.write.actions); + break; + + case OFPTFPT13_APPLY_ACTIONS: + error = parse_table_ids(&payload, &tf->nonmiss.apply.actions); + break; + case OFPTFPT13_APPLY_ACTIONS_MISS: + error = parse_table_ids(&payload, &tf->miss.apply.actions); + break; + + case OFPTFPT13_MATCH: + error = parse_oxms(&payload, loose, &tf->match, &tf->mask); + break; + case OFPTFPT13_WILDCARDS: + error = parse_oxms(&payload, loose, &tf->wildcard, NULL); + break; + + case OFPTFPT13_WRITE_SETFIELD: + error = parse_oxms(&payload, loose, + &tf->nonmiss.write.set_fields, NULL); + break; + case OFPTFPT13_WRITE_SETFIELD_MISS: + error = parse_oxms(&payload, loose, + &tf->miss.write.set_fields, NULL); + break; + case OFPTFPT13_APPLY_SETFIELD: + error = parse_oxms(&payload, loose, + &tf->nonmiss.apply.set_fields, NULL); + break; + case OFPTFPT13_APPLY_SETFIELD_MISS: + error = parse_oxms(&payload, loose, + &tf->miss.apply.set_fields, NULL); + break; + + case OFPTFPT13_EXPERIMENTER: + case OFPTFPT13_EXPERIMENTER_MISS: + log_property(loose, + "unknown table features experimenter property"); + error = loose ? 0 : OFPERR_OFPTFFC_BAD_TYPE; + break; + } + if (error) { + return error; + } + } + + /* 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 '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; + + return 0; +} + +/* Encodes and returns a request to obtain the table features of a switch. + * The message is encoded for OpenFlow version 'ofp_version'. */ +struct ofpbuf * +ofputil_encode_table_features_request(enum ofp_version ofp_version) +{ + struct ofpbuf *request = NULL; + + switch (ofp_version) { + case OFP10_VERSION: + case OFP11_VERSION: + case OFP12_VERSION: + ovs_fatal(0, "dump-table-features needs OpenFlow 1.3 or later " + "(\'-O OpenFlow13\')"); + case OFP13_VERSION: + case OFP14_VERSION: + request = ofpraw_alloc(OFPRAW_OFPST13_TABLE_FEATURES_REQUEST, + ofp_version, 0); + break; + default: + OVS_NOT_REACHED(); + } + + return request; +} + /* ofputil_table_mod */ /* Decodes the OpenFlow "table mod" message in '*oh' into an abstract form in @@ -4119,8 +4602,11 @@ ofputil_encode_table_mod(const struct ofputil_table_mod *pm, otm->config = htonl(pm->config); break; } + case OFP14_VERSION: + OVS_NOT_REACHED(); + break; default: - NOT_REACHED(); + OVS_NOT_REACHED(); } return b; @@ -4180,7 +4666,7 @@ ofputil_decode_role_message(const struct ofp_header *oh, rr->have_generation_id = false; rr->generation_id = 0; } else { - NOT_REACHED(); + OVS_NOT_REACHED(); } return 0; @@ -4217,7 +4703,7 @@ ofputil_encode_role_reply(const struct ofp_header *request, nrr = ofpbuf_put_zeros(buf, sizeof *nrr); nrr->role = htonl(rr->role - 1); } else { - NOT_REACHED(); + OVS_NOT_REACHED(); } return buf; @@ -4425,11 +4911,12 @@ ofputil_encode_table_stats_reply(const struct ofp12_table_stats stats[], int n, break; case OFP13_VERSION: + case OFP14_VERSION: ofputil_put_ofp13_table_stats(&stats[i], reply); break; default: - NOT_REACHED(); + OVS_NOT_REACHED(); } } @@ -4466,7 +4953,7 @@ ofputil_decode_flow_monitor_request(struct ofputil_flow_monitor_request *rq, nfmr = ofpbuf_try_pull(msg, sizeof *nfmr); if (!nfmr) { - VLOG_WARN_RL(&bad_ofmsg_rl, "NXST_FLOW_MONITOR request has %zu " + VLOG_WARN_RL(&bad_ofmsg_rl, "NXST_FLOW_MONITOR request has %"PRIuSIZE" " "leftover bytes at end", msg->size); return OFPERR_OFPBRC_BAD_LEN; } @@ -4620,7 +5107,7 @@ ofputil_decode_flow_update(struct ofputil_flow_update *update, } bad_len: - VLOG_WARN_RL(&bad_ofmsg_rl, "NXST_FLOW_MONITOR reply has %zu " + VLOG_WARN_RL(&bad_ofmsg_rl, "NXST_FLOW_MONITOR reply has %"PRIuSIZE" " "leftover bytes at end", msg->size); return OFPERR_OFPBRC_BAD_LEN; } @@ -4733,7 +5220,8 @@ ofputil_encode_packet_out(const struct ofputil_packet_out *po, case OFP11_VERSION: case OFP12_VERSION: - case OFP13_VERSION: { + case OFP13_VERSION: + case OFP14_VERSION:{ struct ofp11_packet_out *opo; size_t len; @@ -4749,7 +5237,7 @@ ofputil_encode_packet_out(const struct ofputil_packet_out *po, } default: - NOT_REACHED(); + OVS_NOT_REACHED(); } if (po->buffer_id == UINT32_MAX) { @@ -4791,6 +5279,7 @@ ofputil_encode_barrier_request(enum ofp_version ofp_version) enum ofpraw type; switch (ofp_version) { + case OFP14_VERSION: case OFP13_VERSION: case OFP12_VERSION: case OFP11_VERSION: @@ -4802,7 +5291,7 @@ ofputil_encode_barrier_request(enum ofp_version ofp_version) break; default: - NOT_REACHED(); + OVS_NOT_REACHED(); } return ofpraw_alloc(type, ofp_version, 0); @@ -4818,7 +5307,7 @@ ofputil_frag_handling_to_string(enum ofp_config_flags flags) case OFPC_FRAG_NX_MATCH: return "nx-match"; } - NOT_REACHED(); + OVS_NOT_REACHED(); } bool @@ -5071,8 +5560,11 @@ ofputil_pull_phy_port(enum ofp_version ofp_version, struct ofpbuf *b, const struct ofp11_port *op = ofpbuf_try_pull(b, sizeof *op); return op ? ofputil_decode_ofp11_port(pp, op) : EOF; } + case OFP14_VERSION: + OVS_NOT_REACHED(); + break; default: - NOT_REACHED(); + OVS_NOT_REACHED(); } } @@ -5088,6 +5580,7 @@ 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" }; @@ -5117,6 +5610,21 @@ ofputil_action_name_from_code(enum ofputil_action_code 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" + + 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 @@ -5127,7 +5635,9 @@ ofputil_put_action(enum ofputil_action_code code, struct ofpbuf *buf) { switch (code) { case OFPUTIL_ACTION_INVALID: - NOT_REACHED(); +#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); @@ -5137,7 +5647,7 @@ ofputil_put_action(enum ofputil_action_code code, struct ofpbuf *buf) case OFPUTIL_##ENUM: return ofputil_put_##ENUM(buf); #include "ofp-util.def" } - NOT_REACHED(); + OVS_NOT_REACHED(); } #define OFPAT10_ACTION(ENUM, STRUCT, NAME) \ @@ -5158,6 +5668,8 @@ ofputil_put_action(enum ofputil_action_code code, struct ofpbuf *buf) } #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) \ @@ -5256,7 +5768,7 @@ ofputil_normalize_match__(struct match *match, bool may_log) wc.masks.nd_target = in6addr_any; } if (!(may_match & MAY_MPLS)) { - wc.masks.mpls_lse = htonl(0); + memset(wc.masks.mpls_lse, 0, sizeof wc.masks.mpls_lse); } /* Log any changes. */ @@ -5399,7 +5911,8 @@ ofputil_encode_dump_ports_request(enum ofp_version ofp_version, ofp_port_t port) } case OFP11_VERSION: case OFP12_VERSION: - case OFP13_VERSION: { + case OFP13_VERSION: + case OFP14_VERSION:{ struct ofp11_port_stats_request *req; request = ofpraw_alloc(OFPRAW_OFPST11_PORT_REQUEST, ofp_version, 0); req = ofpbuf_put_zeros(request, sizeof *req); @@ -5407,7 +5920,7 @@ ofputil_encode_dump_ports_request(enum ofp_version ofp_version, ofp_port_t port) break; } default: - NOT_REACHED(); + OVS_NOT_REACHED(); } return request; @@ -5490,8 +6003,12 @@ ofputil_append_port_stat(struct list *replies, break; } + case OFP14_VERSION: + OVS_NOT_REACHED(); + break; + default: - NOT_REACHED(); + OVS_NOT_REACHED(); } } @@ -5572,8 +6089,11 @@ ofputil_get_port_stats_size(enum ofp_version ofp_version) return sizeof(struct ofp11_port_stats); case OFP13_VERSION: return sizeof(struct ofp13_port_stats); + case OFP14_VERSION: + OVS_NOT_REACHED(); + return 0; default: - NOT_REACHED(); + OVS_NOT_REACHED(); } } @@ -5640,11 +6160,11 @@ ofputil_decode_port_stats(struct ofputil_port_stats *ps, struct ofpbuf *msg) } return ofputil_port_stats_from_ofp10(ps, ps10); } else { - NOT_REACHED(); + OVS_NOT_REACHED(); } bad_len: - VLOG_WARN_RL(&bad_ofmsg_rl, "OFPST_PORT reply has %zu leftover " + VLOG_WARN_RL(&bad_ofmsg_rl, "OFPST_PORT reply has %"PRIuSIZE" leftover " "bytes at end", msg->size); return OFPERR_OFPBRC_BAD_LEN; } @@ -5670,8 +6190,12 @@ ofputil_decode_port_stats_request(const struct ofp_header *request, return 0; } + case OFP14_VERSION: + OVS_NOT_REACHED(); + break; + default: - NOT_REACHED(); + OVS_NOT_REACHED(); } } @@ -5705,7 +6229,8 @@ ofputil_encode_group_stats_request(enum ofp_version ofp_version, "(\'-O OpenFlow11\')"); case OFP11_VERSION: case OFP12_VERSION: - case OFP13_VERSION: { + case OFP13_VERSION: + case OFP14_VERSION: { struct ofp11_group_stats_request *req; request = ofpraw_alloc(OFPRAW_OFPST11_GROUP_REQUEST, ofp_version, 0); req = ofpbuf_put_zeros(request, sizeof *req); @@ -5713,7 +6238,7 @@ ofputil_encode_group_stats_request(enum ofp_version ofp_version, break; } default: - NOT_REACHED(); + OVS_NOT_REACHED(); } return request; @@ -5736,12 +6261,12 @@ ofputil_encode_group_desc_request(enum ofp_version ofp_version) "(\'-O OpenFlow11\')"); case OFP11_VERSION: case OFP12_VERSION: - case OFP13_VERSION: { + case OFP13_VERSION: + case OFP14_VERSION: request = ofpraw_alloc(OFPRAW_OFPST11_GROUP_DESC_REQUEST, ofp_version, 0); break; - } default: - NOT_REACHED(); + OVS_NOT_REACHED(); } return request; @@ -5809,9 +6334,13 @@ ofputil_append_group_stats(struct list *replies, ofputil_append_of13_group_stats(ogs, replies); break; + case OFP14_VERSION: + OVS_NOT_REACHED(); + break; + case OFP10_VERSION: default: - NOT_REACHED(); + OVS_NOT_REACHED(); } } @@ -5828,13 +6357,13 @@ ofputil_encode_group_features_request(enum ofp_version ofp_version) ovs_fatal(0, "dump-group-features needs OpenFlow 1.2 or later " "(\'-O OpenFlow12\')"); case OFP12_VERSION: - case OFP13_VERSION: { + case OFP13_VERSION: + case OFP14_VERSION: request = ofpraw_alloc(OFPRAW_OFPST12_GROUP_FEATURES_REQUEST, - ofp_version, 0); + ofp_version, 0); break; - } default: - NOT_REACHED(); + OVS_NOT_REACHED(); } return request; @@ -5950,17 +6479,17 @@ ofputil_decode_group_stats_reply(struct ofpbuf *msg, ogs11 = NULL; } } else { - NOT_REACHED(); + OVS_NOT_REACHED(); } if (!ogs11) { - VLOG_WARN_RL(&bad_ofmsg_rl, "%s reply has %zu leftover bytes at end", + VLOG_WARN_RL(&bad_ofmsg_rl, "%s reply has %"PRIuSIZE" leftover bytes at end", ofpraw_get_name(raw), msg->size); return OFPERR_OFPBRC_BAD_LEN; } length = ntohs(ogs11->length); if (length < sizeof base_len) { - VLOG_WARN_RL(&bad_ofmsg_rl, "%s reply claims invalid length %zu", + VLOG_WARN_RL(&bad_ofmsg_rl, "%s reply claims invalid length %"PRIuSIZE, ofpraw_get_name(raw), length); return OFPERR_OFPBRC_BAD_LEN; } @@ -5973,7 +6502,7 @@ ofputil_decode_group_stats_reply(struct ofpbuf *msg, gs->n_buckets = (length - base_len) / sizeof *obc; obc = ofpbuf_try_pull(msg, gs->n_buckets * sizeof *obc); if (!obc) { - VLOG_WARN_RL(&bad_ofmsg_rl, "%s reply has %zu leftover bytes at end", + VLOG_WARN_RL(&bad_ofmsg_rl, "%s reply has %"PRIuSIZE" leftover bytes at end", ofpraw_get_name(raw), msg->size); return OFPERR_OFPBRC_BAD_LEN; } @@ -6042,18 +6571,18 @@ ofputil_pull_buckets(struct ofpbuf *msg, size_t buckets_length, ? ofpbuf_try_pull(msg, sizeof *ob) : NULL); if (!ob) { - VLOG_WARN_RL(&bad_ofmsg_rl, "buckets end with %zu leftover bytes", + VLOG_WARN_RL(&bad_ofmsg_rl, "buckets end with %"PRIuSIZE" leftover bytes", buckets_length); } ob_len = ntohs(ob->len); if (ob_len < sizeof *ob) { VLOG_WARN_RL(&bad_ofmsg_rl, "OpenFlow message bucket length " - "%zu is not valid", ob_len); + "%"PRIuSIZE" is not valid", ob_len); return OFPERR_OFPGMFC_BAD_BUCKET; } else if (ob_len > buckets_length) { VLOG_WARN_RL(&bad_ofmsg_rl, "OpenFlow message bucket length " - "%zu exceeds remaining buckets data size %zu", + "%"PRIuSIZE" exceeds remaining buckets data size %"PRIuSIZE, ob_len, buckets_length); return OFPERR_OFPGMFC_BAD_BUCKET; } @@ -6112,7 +6641,7 @@ ofputil_decode_group_desc_reply(struct ofputil_group_desc *gd, ogds = ofpbuf_try_pull(msg, sizeof *ogds); if (!ogds) { - VLOG_WARN_RL(&bad_ofmsg_rl, "OFPST11_GROUP_DESC reply has %zu " + VLOG_WARN_RL(&bad_ofmsg_rl, "OFPST11_GROUP_DESC reply has %"PRIuSIZE" " "leftover bytes at end", msg->size); return OFPERR_OFPBRC_BAD_LEN; } @@ -6122,7 +6651,7 @@ ofputil_decode_group_desc_reply(struct ofputil_group_desc *gd, 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 %zu", length); + "length %"PRIuSIZE, length); return OFPERR_OFPBRC_BAD_LEN; } @@ -6159,7 +6688,8 @@ ofputil_encode_group_mod(enum ofp_version ofp_version, case OFP11_VERSION: case OFP12_VERSION: - case OFP13_VERSION: { + case OFP13_VERSION: + case OFP14_VERSION: b = ofpraw_alloc(OFPRAW_OFPT11_GROUP_MOD, ofp_version, 0); start_ogm = b->size; ofpbuf_put_zeros(b, sizeof *ogm); @@ -6184,10 +6714,9 @@ ofputil_encode_group_mod(enum ofp_version ofp_version, ogm->group_id = htonl(gm->group_id); break; - } default: - NOT_REACHED(); + OVS_NOT_REACHED(); } return b; @@ -6233,7 +6762,7 @@ ofputil_decode_group_mod(const struct ofp_header *oh, } break; default: - NOT_REACHED(); + OVS_NOT_REACHED(); } } @@ -6247,6 +6776,7 @@ ofputil_decode_queue_stats_request(const struct ofp_header *request, struct ofputil_queue_stats_request *oqsr) { switch ((enum ofp_version)request->version) { + case OFP14_VERSION: case OFP13_VERSION: case OFP12_VERSION: case OFP11_VERSION: { @@ -6267,7 +6797,7 @@ ofputil_decode_queue_stats_request(const struct ofp_header *request, } default: - NOT_REACHED(); + OVS_NOT_REACHED(); } } @@ -6283,7 +6813,8 @@ ofputil_encode_queue_stats_request(enum ofp_version ofp_version, switch (ofp_version) { case OFP11_VERSION: case OFP12_VERSION: - case OFP13_VERSION: { + case OFP13_VERSION: + case OFP14_VERSION: { struct ofp11_queue_stats_request *req; request = ofpraw_alloc(OFPRAW_OFPST11_QUEUE_REQUEST, ofp_version, 0); req = ofpbuf_put_zeros(request, sizeof *req); @@ -6302,7 +6833,7 @@ ofputil_encode_queue_stats_request(enum ofp_version ofp_version, break; } default: - NOT_REACHED(); + OVS_NOT_REACHED(); } return request; @@ -6319,8 +6850,11 @@ ofputil_get_queue_stats_size(enum ofp_version ofp_version) return sizeof(struct ofp11_queue_stats); case OFP13_VERSION: return sizeof(struct ofp13_queue_stats); + case OFP14_VERSION: + OVS_NOT_REACHED(); + return 0; default: - NOT_REACHED(); + OVS_NOT_REACHED(); } } @@ -6434,11 +6968,11 @@ ofputil_decode_queue_stats(struct ofputil_queue_stats *qs, struct ofpbuf *msg) } return ofputil_queue_stats_from_ofp10(qs, qs10); } else { - NOT_REACHED(); + OVS_NOT_REACHED(); } bad_len: - VLOG_WARN_RL(&bad_ofmsg_rl, "OFPST_QUEUE reply has %zu leftover " + VLOG_WARN_RL(&bad_ofmsg_rl, "OFPST_QUEUE reply has %"PRIuSIZE" leftover " "bytes at end", msg->size); return OFPERR_OFPBRC_BAD_LEN; } @@ -6508,7 +7042,11 @@ ofputil_append_queue_stat(struct list *replies, break; } + case OFP14_VERSION: + OVS_NOT_REACHED(); + break; + default: - NOT_REACHED(); + OVS_NOT_REACHED(); } }