lib/ofp-util.c

   1 /*
   2  * Copyright (c) 2008, 2009, 2010, 2011, 2012, 2013, 2014, 2015, 2016 Nicira, Inc.
   3  *
   4  * Licensed under the Apache License, Version 2.0 (the "License");
   5  * you may not use this file except in compliance with the License.
   6  * You may obtain a copy of the License at:
   7  *
   8  *     http://www.apache.org/licenses/LICENSE-2.0
   9  *
  10  * Unless required by applicable law or agreed to in writing, software
  11  * distributed under the License is distributed on an "AS IS" BASIS,
  12  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  13  * See the License for the specific language governing permissions and
  14  * limitations under the License.
  15  */
  16
  17 #include <config.h>
  18 #include <ctype.h>
  19 #include <errno.h>
  20 #include <inttypes.h>
  21 #include <sys/types.h>
  22 #include <netinet/in.h>
  23 #include <netinet/icmp6.h>
  24 #include <stdlib.h>
  25 #include "bitmap.h"
  26 #include "bundle.h"
  27 #include "byte-order.h"
  28 #include "classifier.h"
  29 #include "learn.h"
  30 #include "multipath.h"
  31 #include "netdev.h"
  32 #include "nx-match.h"
  33 #include "id-pool.h"
  34 #include "openflow/netronome-ext.h"
  35 #include "openvswitch/dynamic-string.h"
  36 #include "openvswitch/meta-flow.h"
  37 #include "openvswitch/ofp-actions.h"
  38 #include "openvswitch/ofp-errors.h"
  39 #include "openvswitch/ofp-msgs.h"
  40 #include "openvswitch/ofp-print.h"
  41 #include "openvswitch/ofp-prop.h"
  42 #include "openvswitch/ofp-util.h"
  43 #include "openvswitch/ofpbuf.h"
  44 #include "openvswitch/type-props.h"
  45 #include "openvswitch/vlog.h"
  46 #include "openflow/intel-ext.h"
  47 #include "packets.h"
  48 #include "pktbuf.h"
  49 #include "random.h"
  50 #include "tun-metadata.h"
  51 #include "unaligned.h"
  52 #include "util.h"
  53 #include "uuid.h"
  54
  55 VLOG_DEFINE_THIS_MODULE(ofp_util);
  56
  57 /* Rate limit for OpenFlow message parse errors.  These always indicate a bug
  58  * in the peer and so there's not much point in showing a lot of them. */
  59 static struct vlog_rate_limit bad_ofmsg_rl = VLOG_RATE_LIMIT_INIT(1, 5);
  60
  61 static enum ofputil_table_vacancy ofputil_decode_table_vacancy(
  62     ovs_be32 config, enum ofp_version);
  63 static enum ofputil_table_eviction ofputil_decode_table_eviction(
  64     ovs_be32 config, enum ofp_version);
  65 static ovs_be32 ofputil_encode_table_config(enum ofputil_table_miss,
  66                                             enum ofputil_table_eviction,
  67                                             enum ofputil_table_vacancy,
  68                                             enum ofp_version);
  69
  70 /* Given the wildcard bit count in the least-significant 6 of 'wcbits', returns
  71  * an IP netmask with a 1 in each bit that must match and a 0 in each bit that
  72  * is wildcarded.
  73  *
  74  * The bits in 'wcbits' are in the format used in enum ofp_flow_wildcards: 0
  75  * is exact match, 1 ignores the LSB, 2 ignores the 2 least-significant bits,
  76  * ..., 32 and higher wildcard the entire field.  This is the *opposite* of the
  77  * usual convention where e.g. /24 indicates that 8 bits (not 24 bits) are
  78  * wildcarded. */
  79 ovs_be32
  80 ofputil_wcbits_to_netmask(int wcbits)
  81 {
  82     wcbits &= 0x3f;
  83     return wcbits < 32 ? htonl(~((1u << wcbits) - 1)) : 0;
  84 }
  85
  86 /* Given the IP netmask 'netmask', returns the number of bits of the IP address
  87  * that it wildcards, that is, the number of 0-bits in 'netmask', a number
  88  * between 0 and 32 inclusive.
  89  *
  90  * If 'netmask' is not a CIDR netmask (see ip_is_cidr()), the return value will
  91  * still be in the valid range but isn't otherwise meaningful. */
  92 int
  93 ofputil_netmask_to_wcbits(ovs_be32 netmask)
  94 {
  95     return 32 - ip_count_cidr_bits(netmask);
  96 }
  97
  98 /* Converts the OpenFlow 1.0 wildcards in 'ofpfw' (OFPFW10_*) into a
  99  * flow_wildcards in 'wc' for use in struct match.  It is the caller's
 100  * responsibility to handle the special case where the flow match's dl_vlan is
 101  * set to OFP_VLAN_NONE. */
 102 void
 103 ofputil_wildcard_from_ofpfw10(uint32_t ofpfw, struct flow_wildcards *wc)
 104 {
 105     BUILD_ASSERT_DECL(FLOW_WC_SEQ == 36);
 106
 107     /* Initialize most of wc. */
 108     flow_wildcards_init_catchall(wc);
 109
 110     if (!(ofpfw & OFPFW10_IN_PORT)) {
 111         wc->masks.in_port.ofp_port = u16_to_ofp(UINT16_MAX);
 112     }
 113
 114     if (!(ofpfw & OFPFW10_NW_TOS)) {
 115         wc->masks.nw_tos |= IP_DSCP_MASK;
 116     }
 117
 118     if (!(ofpfw & OFPFW10_NW_PROTO)) {
 119         wc->masks.nw_proto = UINT8_MAX;
 120     }
 121     wc->masks.nw_src = ofputil_wcbits_to_netmask(ofpfw
 122                                                  >> OFPFW10_NW_SRC_SHIFT);
 123     wc->masks.nw_dst = ofputil_wcbits_to_netmask(ofpfw
 124                                                  >> OFPFW10_NW_DST_SHIFT);
 125
 126     if (!(ofpfw & OFPFW10_TP_SRC)) {
 127         wc->masks.tp_src = OVS_BE16_MAX;
 128     }
 129     if (!(ofpfw & OFPFW10_TP_DST)) {
 130         wc->masks.tp_dst = OVS_BE16_MAX;
 131     }
 132
 133     if (!(ofpfw & OFPFW10_DL_SRC)) {
 134         WC_MASK_FIELD(wc, dl_src);
 135     }
 136     if (!(ofpfw & OFPFW10_DL_DST)) {
 137         WC_MASK_FIELD(wc, dl_dst);
 138     }
 139     if (!(ofpfw & OFPFW10_DL_TYPE)) {
 140         wc->masks.dl_type = OVS_BE16_MAX;
 141     }
 142
 143     /* VLAN TCI mask. */
 144     if (!(ofpfw & OFPFW10_DL_VLAN_PCP)) {
 145         wc->masks.vlan_tci |= htons(VLAN_PCP_MASK | VLAN_CFI);
 146     }
 147     if (!(ofpfw & OFPFW10_DL_VLAN)) {
 148         wc->masks.vlan_tci |= htons(VLAN_VID_MASK | VLAN_CFI);
 149     }
 150 }
 151
 152 /* Converts the ofp10_match in 'ofmatch' into a struct match in 'match'. */
 153 void
 154 ofputil_match_from_ofp10_match(const struct ofp10_match *ofmatch,
 155                                struct match *match)
 156 {
 157     uint32_t ofpfw = ntohl(ofmatch->wildcards) & OFPFW10_ALL;
 158
 159     /* Initialize match->wc. */
 160     memset(&match->flow, 0, sizeof match->flow);
 161     ofputil_wildcard_from_ofpfw10(ofpfw, &match->wc);
 162
 163     /* Initialize most of match->flow. */
 164     match->flow.nw_src = ofmatch->nw_src;
 165     match->flow.nw_dst = ofmatch->nw_dst;
 166     match->flow.in_port.ofp_port = u16_to_ofp(ntohs(ofmatch->in_port));
 167     match->flow.dl_type = ofputil_dl_type_from_openflow(ofmatch->dl_type);
 168     match->flow.tp_src = ofmatch->tp_src;
 169     match->flow.tp_dst = ofmatch->tp_dst;
 170     match->flow.dl_src = ofmatch->dl_src;
 171     match->flow.dl_dst = ofmatch->dl_dst;
 172     match->flow.nw_tos = ofmatch->nw_tos & IP_DSCP_MASK;
 173     match->flow.nw_proto = ofmatch->nw_proto;
 174
 175     /* Translate VLANs. */
 176     if (!(ofpfw & OFPFW10_DL_VLAN) &&
 177         ofmatch->dl_vlan == htons(OFP10_VLAN_NONE)) {
 178         /* Match only packets without 802.1Q header.
 179          *
 180          * When OFPFW10_DL_VLAN_PCP is wildcarded, this is obviously correct.
 181          *
 182          * If OFPFW10_DL_VLAN_PCP is matched, the flow match is contradictory,
 183          * because we can't have a specific PCP without an 802.1Q header.
 184          * However, older versions of OVS treated this as matching packets
 185          * withut an 802.1Q header, so we do here too. */
 186         match->flow.vlan_tci = htons(0);
 187         match->wc.masks.vlan_tci = htons(0xffff);
 188     } else {
 189         ovs_be16 vid, pcp, tci;
 190         uint16_t hpcp;
 191
 192         vid = ofmatch->dl_vlan & htons(VLAN_VID_MASK);
 193         hpcp = (ofmatch->dl_vlan_pcp << VLAN_PCP_SHIFT) & VLAN_PCP_MASK;
 194         pcp = htons(hpcp);
 195         tci = vid | pcp | htons(VLAN_CFI);
 196         match->flow.vlan_tci = tci & match->wc.masks.vlan_tci;
 197     }
 198
 199     /* Clean up. */
 200     match_zero_wildcarded_fields(match);
 201 }
 202
 203 /* Convert 'match' into the OpenFlow 1.0 match structure 'ofmatch'. */
 204 void
 205 ofputil_match_to_ofp10_match(const struct match *match,
 206                              struct ofp10_match *ofmatch)
 207 {
 208     const struct flow_wildcards *wc = &match->wc;
 209     uint32_t ofpfw;
 210
 211     /* Figure out most OpenFlow wildcards. */
 212     ofpfw = 0;
 213     if (!wc->masks.in_port.ofp_port) {
 214         ofpfw |= OFPFW10_IN_PORT;
 215     }
 216     if (!wc->masks.dl_type) {
 217         ofpfw |= OFPFW10_DL_TYPE;
 218     }
 219     if (!wc->masks.nw_proto) {
 220         ofpfw |= OFPFW10_NW_PROTO;
 221     }
 222     ofpfw |= (ofputil_netmask_to_wcbits(wc->masks.nw_src)
 223               << OFPFW10_NW_SRC_SHIFT);
 224     ofpfw |= (ofputil_netmask_to_wcbits(wc->masks.nw_dst)
 225               << OFPFW10_NW_DST_SHIFT);
 226     if (!(wc->masks.nw_tos & IP_DSCP_MASK)) {
 227         ofpfw |= OFPFW10_NW_TOS;
 228     }
 229     if (!wc->masks.tp_src) {
 230         ofpfw |= OFPFW10_TP_SRC;
 231     }
 232     if (!wc->masks.tp_dst) {
 233         ofpfw |= OFPFW10_TP_DST;
 234     }
 235     if (eth_addr_is_zero(wc->masks.dl_src)) {
 236         ofpfw |= OFPFW10_DL_SRC;
 237     }
 238     if (eth_addr_is_zero(wc->masks.dl_dst)) {
 239         ofpfw |= OFPFW10_DL_DST;
 240     }
 241
 242     /* Translate VLANs. */
 243     ofmatch->dl_vlan = htons(0);
 244     ofmatch->dl_vlan_pcp = 0;
 245     if (match->wc.masks.vlan_tci == htons(0)) {
 246         ofpfw |= OFPFW10_DL_VLAN | OFPFW10_DL_VLAN_PCP;
 247     } else if (match->wc.masks.vlan_tci & htons(VLAN_CFI)
 248                && !(match->flow.vlan_tci & htons(VLAN_CFI))) {
 249         ofmatch->dl_vlan = htons(OFP10_VLAN_NONE);
 250     } else {
 251         if (!(match->wc.masks.vlan_tci & htons(VLAN_VID_MASK))) {
 252             ofpfw |= OFPFW10_DL_VLAN;
 253         } else {
 254             ofmatch->dl_vlan = htons(vlan_tci_to_vid(match->flow.vlan_tci));
 255         }
 256
 257         if (!(match->wc.masks.vlan_tci & htons(VLAN_PCP_MASK))) {
 258             ofpfw |= OFPFW10_DL_VLAN_PCP;
 259         } else {
 260             ofmatch->dl_vlan_pcp = vlan_tci_to_pcp(match->flow.vlan_tci);
 261         }
 262     }
 263
 264     /* Compose most of the match structure. */
 265     ofmatch->wildcards = htonl(ofpfw);
 266     ofmatch->in_port = htons(ofp_to_u16(match->flow.in_port.ofp_port));
 267     ofmatch->dl_src = match->flow.dl_src;
 268     ofmatch->dl_dst = match->flow.dl_dst;
 269     ofmatch->dl_type = ofputil_dl_type_to_openflow(match->flow.dl_type);
 270     ofmatch->nw_src = match->flow.nw_src;
 271     ofmatch->nw_dst = match->flow.nw_dst;
 272     ofmatch->nw_tos = match->flow.nw_tos & IP_DSCP_MASK;
 273     ofmatch->nw_proto = match->flow.nw_proto;
 274     ofmatch->tp_src = match->flow.tp_src;
 275     ofmatch->tp_dst = match->flow.tp_dst;
 276     memset(ofmatch->pad1, '\0', sizeof ofmatch->pad1);
 277     memset(ofmatch->pad2, '\0', sizeof ofmatch->pad2);
 278 }
 279
 280 enum ofperr
 281 ofputil_pull_ofp11_match(struct ofpbuf *buf, struct match *match,
 282                          uint16_t *padded_match_len)
 283 {
 284     struct ofp11_match_header *omh = buf->data;
 285     uint16_t match_len;
 286
 287     if (buf->size < sizeof *omh) {
 288         return OFPERR_OFPBMC_BAD_LEN;
 289     }
 290
 291     match_len = ntohs(omh->length);
 292
 293     switch (ntohs(omh->type)) {
 294     case OFPMT_STANDARD: {
 295         struct ofp11_match *om;
 296
 297         if (match_len != sizeof *om || buf->size < sizeof *om) {
 298             return OFPERR_OFPBMC_BAD_LEN;
 299         }
 300         om = ofpbuf_pull(buf, sizeof *om);
 301         if (padded_match_len) {
 302             *padded_match_len = match_len;
 303         }
 304         return ofputil_match_from_ofp11_match(om, match);
 305     }
 306
 307     case OFPMT_OXM:
 308         if (padded_match_len) {
 309             *padded_match_len = ROUND_UP(match_len, 8);
 310         }
 311         return oxm_pull_match(buf, match);
 312
 313     default:
 314         return OFPERR_OFPBMC_BAD_TYPE;
 315     }
 316 }
 317
 318 /* Converts the ofp11_match in 'ofmatch' into a struct match in 'match'.
 319  * Returns 0 if successful, otherwise an OFPERR_* value. */
 320 enum ofperr
 321 ofputil_match_from_ofp11_match(const struct ofp11_match *ofmatch,
 322                                struct match *match)
 323 {
 324     uint16_t wc = ntohl(ofmatch->wildcards);
 325     bool ipv4, arp, rarp;
 326
 327     match_init_catchall(match);
 328
 329     if (!(wc & OFPFW11_IN_PORT)) {
 330         ofp_port_t ofp_port;
 331         enum ofperr error;
 332
 333         error = ofputil_port_from_ofp11(ofmatch->in_port, &ofp_port);
 334         if (error) {
 335             return OFPERR_OFPBMC_BAD_VALUE;
 336         }
 337         match_set_in_port(match, ofp_port);
 338     }
 339
 340     match_set_dl_src_masked(match, ofmatch->dl_src,
 341                             eth_addr_invert(ofmatch->dl_src_mask));
 342     match_set_dl_dst_masked(match, ofmatch->dl_dst,
 343                             eth_addr_invert(ofmatch->dl_dst_mask));
 344
 345     if (!(wc & OFPFW11_DL_VLAN)) {
 346         if (ofmatch->dl_vlan == htons(OFPVID11_NONE)) {
 347             /* Match only packets without a VLAN tag. */
 348             match->flow.vlan_tci = htons(0);
 349             match->wc.masks.vlan_tci = OVS_BE16_MAX;
 350         } else {
 351             if (ofmatch->dl_vlan == htons(OFPVID11_ANY)) {
 352                 /* Match any packet with a VLAN tag regardless of VID. */
 353                 match->flow.vlan_tci = htons(VLAN_CFI);
 354                 match->wc.masks.vlan_tci = htons(VLAN_CFI);
 355             } else if (ntohs(ofmatch->dl_vlan) < 4096) {
 356                 /* Match only packets with the specified VLAN VID. */
 357                 match->flow.vlan_tci = htons(VLAN_CFI) | ofmatch->dl_vlan;
 358                 match->wc.masks.vlan_tci = htons(VLAN_CFI | VLAN_VID_MASK);
 359             } else {
 360                 /* Invalid VID. */
 361                 return OFPERR_OFPBMC_BAD_VALUE;
 362             }
 363
 364             if (!(wc & OFPFW11_DL_VLAN_PCP)) {
 365                 if (ofmatch->dl_vlan_pcp <= 7) {
 366                     match->flow.vlan_tci |= htons(ofmatch->dl_vlan_pcp
 367                                                   << VLAN_PCP_SHIFT);
 368                     match->wc.masks.vlan_tci |= htons(VLAN_PCP_MASK);
 369                 } else {
 370                     /* Invalid PCP. */
 371                     return OFPERR_OFPBMC_BAD_VALUE;
 372                 }
 373             }
 374         }
 375     }
 376
 377     if (!(wc & OFPFW11_DL_TYPE)) {
 378         match_set_dl_type(match,
 379                           ofputil_dl_type_from_openflow(ofmatch->dl_type));
 380     }
 381
 382     ipv4 = match->flow.dl_type == htons(ETH_TYPE_IP);
 383     arp = match->flow.dl_type == htons(ETH_TYPE_ARP);
 384     rarp = match->flow.dl_type == htons(ETH_TYPE_RARP);
 385
 386     if (ipv4 && !(wc & OFPFW11_NW_TOS)) {
 387         if (ofmatch->nw_tos & ~IP_DSCP_MASK) {
 388             /* Invalid TOS. */
 389             return OFPERR_OFPBMC_BAD_VALUE;
 390         }
 391
 392         match_set_nw_dscp(match, ofmatch->nw_tos);
 393     }
 394
 395     if (ipv4 || arp || rarp) {
 396         if (!(wc & OFPFW11_NW_PROTO)) {
 397             match_set_nw_proto(match, ofmatch->nw_proto);
 398         }
 399         match_set_nw_src_masked(match, ofmatch->nw_src, ~ofmatch->nw_src_mask);
 400         match_set_nw_dst_masked(match, ofmatch->nw_dst, ~ofmatch->nw_dst_mask);
 401     }
 402
 403 #define OFPFW11_TP_ALL (OFPFW11_TP_SRC | OFPFW11_TP_DST)
 404     if (ipv4 && (wc & OFPFW11_TP_ALL) != OFPFW11_TP_ALL) {
 405         switch (match->flow.nw_proto) {
 406         case IPPROTO_ICMP:
 407             /* "A.2.3 Flow Match Structures" in OF1.1 says:
 408              *
 409              *    The tp_src and tp_dst fields will be ignored unless the
 410              *    network protocol specified is as TCP, UDP or SCTP.
 411              *
 412              * but I'm pretty sure we should support ICMP too, otherwise
 413              * that's a regression from OF1.0. */
 414             if (!(wc & OFPFW11_TP_SRC)) {
 415                 uint16_t icmp_type = ntohs(ofmatch->tp_src);
 416                 if (icmp_type < 0x100) {
 417                     match_set_icmp_type(match, icmp_type);
 418                 } else {
 419                     return OFPERR_OFPBMC_BAD_FIELD;
 420                 }
 421             }
 422             if (!(wc & OFPFW11_TP_DST)) {
 423                 uint16_t icmp_code = ntohs(ofmatch->tp_dst);
 424                 if (icmp_code < 0x100) {
 425                     match_set_icmp_code(match, icmp_code);
 426                 } else {
 427                     return OFPERR_OFPBMC_BAD_FIELD;
 428                 }
 429             }
 430             break;
 431
 432         case IPPROTO_TCP:
 433         case IPPROTO_UDP:
 434         case IPPROTO_SCTP:
 435             if (!(wc & (OFPFW11_TP_SRC))) {
 436                 match_set_tp_src(match, ofmatch->tp_src);
 437             }
 438             if (!(wc & (OFPFW11_TP_DST))) {
 439                 match_set_tp_dst(match, ofmatch->tp_dst);
 440             }
 441             break;
 442
 443         default:
 444             /* OF1.1 says explicitly to ignore this. */
 445             break;
 446         }
 447     }
 448
 449     if (eth_type_mpls(match->flow.dl_type)) {
 450         if (!(wc & OFPFW11_MPLS_LABEL)) {
 451             match_set_mpls_label(match, 0, ofmatch->mpls_label);
 452         }
 453         if (!(wc & OFPFW11_MPLS_TC)) {
 454             match_set_mpls_tc(match, 0, ofmatch->mpls_tc);
 455         }
 456     }
 457
 458     match_set_metadata_masked(match, ofmatch->metadata,
 459                               ~ofmatch->metadata_mask);
 460
 461     return 0;
 462 }
 463
 464 /* Convert 'match' into the OpenFlow 1.1 match structure 'ofmatch'. */
 465 void
 466 ofputil_match_to_ofp11_match(const struct match *match,
 467                              struct ofp11_match *ofmatch)
 468 {
 469     uint32_t wc = 0;
 470
 471     memset(ofmatch, 0, sizeof *ofmatch);
 472     ofmatch->omh.type = htons(OFPMT_STANDARD);
 473     ofmatch->omh.length = htons(OFPMT11_STANDARD_LENGTH);
 474
 475     if (!match->wc.masks.in_port.ofp_port) {
 476         wc |= OFPFW11_IN_PORT;
 477     } else {
 478         ofmatch->in_port = ofputil_port_to_ofp11(match->flow.in_port.ofp_port);
 479     }
 480
 481     ofmatch->dl_src = match->flow.dl_src;
 482     ofmatch->dl_src_mask = eth_addr_invert(match->wc.masks.dl_src);
 483     ofmatch->dl_dst = match->flow.dl_dst;
 484     ofmatch->dl_dst_mask = eth_addr_invert(match->wc.masks.dl_dst);
 485
 486     if (match->wc.masks.vlan_tci == htons(0)) {
 487         wc |= OFPFW11_DL_VLAN | OFPFW11_DL_VLAN_PCP;
 488     } else if (match->wc.masks.vlan_tci & htons(VLAN_CFI)
 489                && !(match->flow.vlan_tci & htons(VLAN_CFI))) {
 490         ofmatch->dl_vlan = htons(OFPVID11_NONE);
 491         wc |= OFPFW11_DL_VLAN_PCP;
 492     } else {
 493         if (!(match->wc.masks.vlan_tci & htons(VLAN_VID_MASK))) {
 494             ofmatch->dl_vlan = htons(OFPVID11_ANY);
 495         } else {
 496             ofmatch->dl_vlan = htons(vlan_tci_to_vid(match->flow.vlan_tci));
 497         }
 498
 499         if (!(match->wc.masks.vlan_tci & htons(VLAN_PCP_MASK))) {
 500             wc |= OFPFW11_DL_VLAN_PCP;
 501         } else {
 502             ofmatch->dl_vlan_pcp = vlan_tci_to_pcp(match->flow.vlan_tci);
 503         }
 504     }
 505
 506     if (!match->wc.masks.dl_type) {
 507         wc |= OFPFW11_DL_TYPE;
 508     } else {
 509         ofmatch->dl_type = ofputil_dl_type_to_openflow(match->flow.dl_type);
 510     }
 511
 512     if (!(match->wc.masks.nw_tos & IP_DSCP_MASK)) {
 513         wc |= OFPFW11_NW_TOS;
 514     } else {
 515         ofmatch->nw_tos = match->flow.nw_tos & IP_DSCP_MASK;
 516     }
 517
 518     if (!match->wc.masks.nw_proto) {
 519         wc |= OFPFW11_NW_PROTO;
 520     } else {
 521         ofmatch->nw_proto = match->flow.nw_proto;
 522     }
 523
 524     ofmatch->nw_src = match->flow.nw_src;
 525     ofmatch->nw_src_mask = ~match->wc.masks.nw_src;
 526     ofmatch->nw_dst = match->flow.nw_dst;
 527     ofmatch->nw_dst_mask = ~match->wc.masks.nw_dst;
 528
 529     if (!match->wc.masks.tp_src) {
 530         wc |= OFPFW11_TP_SRC;
 531     } else {
 532         ofmatch->tp_src = match->flow.tp_src;
 533     }
 534
 535     if (!match->wc.masks.tp_dst) {
 536         wc |= OFPFW11_TP_DST;
 537     } else {
 538         ofmatch->tp_dst = match->flow.tp_dst;
 539     }
 540
 541     if (!(match->wc.masks.mpls_lse[0] & htonl(MPLS_LABEL_MASK))) {
 542         wc |= OFPFW11_MPLS_LABEL;
 543     } else {
 544         ofmatch->mpls_label = htonl(mpls_lse_to_label(
 545                                         match->flow.mpls_lse[0]));
 546     }
 547
 548     if (!(match->wc.masks.mpls_lse[0] & htonl(MPLS_TC_MASK))) {
 549         wc |= OFPFW11_MPLS_TC;
 550     } else {
 551         ofmatch->mpls_tc = mpls_lse_to_tc(match->flow.mpls_lse[0]);
 552     }
 553
 554     ofmatch->metadata = match->flow.metadata;
 555     ofmatch->metadata_mask = ~match->wc.masks.metadata;
 556
 557     ofmatch->wildcards = htonl(wc);
 558 }
 559
 560 /* Returns the "typical" length of a match for 'protocol', for use in
 561  * estimating space to preallocate. */
 562 int
 563 ofputil_match_typical_len(enum ofputil_protocol protocol)
 564 {
 565     switch (protocol) {
 566     case OFPUTIL_P_OF10_STD:
 567     case OFPUTIL_P_OF10_STD_TID:
 568         return sizeof(struct ofp10_match);
 569
 570     case OFPUTIL_P_OF10_NXM:
 571     case OFPUTIL_P_OF10_NXM_TID:
 572         return NXM_TYPICAL_LEN;
 573
 574     case OFPUTIL_P_OF11_STD:
 575         return sizeof(struct ofp11_match);
 576
 577     case OFPUTIL_P_OF12_OXM:
 578     case OFPUTIL_P_OF13_OXM:
 579     case OFPUTIL_P_OF14_OXM:
 580     case OFPUTIL_P_OF15_OXM:
 581     case OFPUTIL_P_OF16_OXM:
 582         return NXM_TYPICAL_LEN;
 583
 584     default:
 585         OVS_NOT_REACHED();
 586     }
 587 }
 588
 589 /* Appends to 'b' an struct ofp11_match_header followed by a match that
 590  * expresses 'match' properly for 'protocol', plus enough zero bytes to pad the
 591  * data appended out to a multiple of 8.  'protocol' must be one that is usable
 592  * in OpenFlow 1.1 or later.
 593  *
 594  * This function can cause 'b''s data to be reallocated.
 595  *
 596  * Returns the number of bytes appended to 'b', excluding the padding.  Never
 597  * returns zero. */
 598 int
 599 ofputil_put_ofp11_match(struct ofpbuf *b, const struct match *match,
 600                         enum ofputil_protocol protocol)
 601 {
 602     switch (protocol) {
 603     case OFPUTIL_P_OF10_STD:
 604     case OFPUTIL_P_OF10_STD_TID:
 605     case OFPUTIL_P_OF10_NXM:
 606     case OFPUTIL_P_OF10_NXM_TID:
 607         OVS_NOT_REACHED();
 608
 609     case OFPUTIL_P_OF11_STD: {
 610         struct ofp11_match *om;
 611
 612         /* Make sure that no padding is needed. */
 613         BUILD_ASSERT_DECL(sizeof *om % 8 == 0);
 614
 615         om = ofpbuf_put_uninit(b, sizeof *om);
 616         ofputil_match_to_ofp11_match(match, om);
 617         return sizeof *om;
 618     }
 619
 620     case OFPUTIL_P_OF12_OXM:
 621     case OFPUTIL_P_OF13_OXM:
 622     case OFPUTIL_P_OF14_OXM:
 623     case OFPUTIL_P_OF15_OXM:
 624     case OFPUTIL_P_OF16_OXM:
 625         return oxm_put_match(b, match,
 626                              ofputil_protocol_to_ofp_version(protocol));
 627     }
 628
 629     OVS_NOT_REACHED();
 630 }
 631
 632 /* Given a 'dl_type' value in the format used in struct flow, returns the
 633  * corresponding 'dl_type' value for use in an ofp10_match or ofp11_match
 634  * structure. */
 635 ovs_be16
 636 ofputil_dl_type_to_openflow(ovs_be16 flow_dl_type)
 637 {
 638     return (flow_dl_type == htons(FLOW_DL_TYPE_NONE)
 639             ? htons(OFP_DL_TYPE_NOT_ETH_TYPE)
 640             : flow_dl_type);
 641 }
 642
 643 /* Given a 'dl_type' value in the format used in an ofp10_match or ofp11_match
 644  * structure, returns the corresponding 'dl_type' value for use in struct
 645  * flow. */
 646 ovs_be16
 647 ofputil_dl_type_from_openflow(ovs_be16 ofp_dl_type)
 648 {
 649     return (ofp_dl_type == htons(OFP_DL_TYPE_NOT_ETH_TYPE)
 650             ? htons(FLOW_DL_TYPE_NONE)
 651             : ofp_dl_type);
 652 }
 653 \f
 654 /* Protocols. */
 655
 656 struct proto_abbrev {
 657     enum ofputil_protocol protocol;
 658     const char *name;
 659 };
 660
 661 /* Most users really don't care about some of the differences between
 662  * protocols.  These abbreviations help with that. */
 663 static const struct proto_abbrev proto_abbrevs[] = {
 664     { OFPUTIL_P_ANY,          "any" },
 665     { OFPUTIL_P_OF10_STD_ANY, "OpenFlow10" },
 666     { OFPUTIL_P_OF10_NXM_ANY, "NXM" },
 667     { OFPUTIL_P_ANY_OXM,      "OXM" },
 668 };
 669 #define N_PROTO_ABBREVS ARRAY_SIZE(proto_abbrevs)
 670
 671 enum ofputil_protocol ofputil_flow_dump_protocols[] = {
 672     OFPUTIL_P_OF16_OXM,
 673     OFPUTIL_P_OF15_OXM,
 674     OFPUTIL_P_OF14_OXM,
 675     OFPUTIL_P_OF13_OXM,
 676     OFPUTIL_P_OF12_OXM,
 677     OFPUTIL_P_OF11_STD,
 678     OFPUTIL_P_OF10_NXM,
 679     OFPUTIL_P_OF10_STD,
 680 };
 681 size_t ofputil_n_flow_dump_protocols = ARRAY_SIZE(ofputil_flow_dump_protocols);
 682
 683 /* Returns the set of ofputil_protocols that are supported with the given
 684  * OpenFlow 'version'.  'version' should normally be an 8-bit OpenFlow version
 685  * identifier (e.g. 0x01 for OpenFlow 1.0, 0x02 for OpenFlow 1.1).  Returns 0
 686  * if 'version' is not supported or outside the valid range.  */
 687 enum ofputil_protocol
 688 ofputil_protocols_from_ofp_version(enum ofp_version version)
 689 {
 690     switch (version) {
 691     case OFP10_VERSION:
 692         return OFPUTIL_P_OF10_STD_ANY | OFPUTIL_P_OF10_NXM_ANY;
 693     case OFP11_VERSION:
 694         return OFPUTIL_P_OF11_STD;
 695     case OFP12_VERSION:
 696         return OFPUTIL_P_OF12_OXM;
 697     case OFP13_VERSION:
 698         return OFPUTIL_P_OF13_OXM;
 699     case OFP14_VERSION:
 700         return OFPUTIL_P_OF14_OXM;
 701     case OFP15_VERSION:
 702         return OFPUTIL_P_OF15_OXM;
 703     case OFP16_VERSION:
 704         return OFPUTIL_P_OF16_OXM;
 705     default:
 706         return 0;
 707     }
 708 }
 709
 710 /* Returns the ofputil_protocol that is initially in effect on an OpenFlow
 711  * connection that has negotiated the given 'version'.  'version' should
 712  * normally be an 8-bit OpenFlow version identifier (e.g. 0x01 for OpenFlow
 713  * 1.0, 0x02 for OpenFlow 1.1).  Returns 0 if 'version' is not supported or
 714  * outside the valid range.  */
 715 enum ofputil_protocol
 716 ofputil_protocol_from_ofp_version(enum ofp_version version)
 717 {
 718     return rightmost_1bit(ofputil_protocols_from_ofp_version(version));
 719 }
 720
 721 /* Returns the OpenFlow protocol version number (e.g. OFP10_VERSION,
 722  * etc.) that corresponds to 'protocol'. */
 723 enum ofp_version
 724 ofputil_protocol_to_ofp_version(enum ofputil_protocol protocol)
 725 {
 726     switch (protocol) {
 727     case OFPUTIL_P_OF10_STD:
 728     case OFPUTIL_P_OF10_STD_TID:
 729     case OFPUTIL_P_OF10_NXM:
 730     case OFPUTIL_P_OF10_NXM_TID:
 731         return OFP10_VERSION;
 732     case OFPUTIL_P_OF11_STD:
 733         return OFP11_VERSION;
 734     case OFPUTIL_P_OF12_OXM:
 735         return OFP12_VERSION;
 736     case OFPUTIL_P_OF13_OXM:
 737         return OFP13_VERSION;
 738     case OFPUTIL_P_OF14_OXM:
 739         return OFP14_VERSION;
 740     case OFPUTIL_P_OF15_OXM:
 741         return OFP15_VERSION;
 742     case OFPUTIL_P_OF16_OXM:
 743         return OFP16_VERSION;
 744     }
 745
 746     OVS_NOT_REACHED();
 747 }
 748
 749 /* Returns a bitmap of OpenFlow versions that are supported by at
 750  * least one of the 'protocols'. */
 751 uint32_t
 752 ofputil_protocols_to_version_bitmap(enum ofputil_protocol protocols)
 753 {
 754     uint32_t bitmap = 0;
 755
 756     for (; protocols; protocols = zero_rightmost_1bit(protocols)) {
 757         enum ofputil_protocol protocol = rightmost_1bit(protocols);
 758
 759         bitmap |= 1u << ofputil_protocol_to_ofp_version(protocol);
 760     }
 761
 762     return bitmap;
 763 }
 764
 765 /* Returns the set of protocols that are supported on top of the
 766  * OpenFlow versions included in 'bitmap'. */
 767 enum ofputil_protocol
 768 ofputil_protocols_from_version_bitmap(uint32_t bitmap)
 769 {
 770     enum ofputil_protocol protocols = 0;
 771
 772     for (; bitmap; bitmap = zero_rightmost_1bit(bitmap)) {
 773         enum ofp_version version = rightmost_1bit_idx(bitmap);
 774
 775         protocols |= ofputil_protocols_from_ofp_version(version);
 776     }
 777
 778     return protocols;
 779 }
 780
 781 /* Returns true if 'protocol' is a single OFPUTIL_P_* value, false
 782  * otherwise. */
 783 bool
 784 ofputil_protocol_is_valid(enum ofputil_protocol protocol)
 785 {
 786     return protocol & OFPUTIL_P_ANY && is_pow2(protocol);
 787 }
 788
 789 /* Returns the equivalent of 'protocol' with the Nicira flow_mod_table_id
 790  * extension turned on or off if 'enable' is true or false, respectively.
 791  *
 792  * This extension is only useful for protocols whose "standard" version does
 793  * not allow specific tables to be modified.  In particular, this is true of
 794  * OpenFlow 1.0.  In later versions of OpenFlow, a flow_mod request always
 795  * specifies a table ID and so there is no need for such an extension.  When
 796  * 'protocol' is such a protocol that doesn't need a flow_mod_table_id
 797  * extension, this function just returns its 'protocol' argument unchanged
 798  * regardless of the value of 'enable'.  */
 799 enum ofputil_protocol
 800 ofputil_protocol_set_tid(enum ofputil_protocol protocol, bool enable)
 801 {
 802     switch (protocol) {
 803     case OFPUTIL_P_OF10_STD:
 804     case OFPUTIL_P_OF10_STD_TID:
 805         return enable ? OFPUTIL_P_OF10_STD_TID : OFPUTIL_P_OF10_STD;
 806
 807     case OFPUTIL_P_OF10_NXM:
 808     case OFPUTIL_P_OF10_NXM_TID:
 809         return enable ? OFPUTIL_P_OF10_NXM_TID : OFPUTIL_P_OF10_NXM;
 810
 811     case OFPUTIL_P_OF11_STD:
 812         return OFPUTIL_P_OF11_STD;
 813
 814     case OFPUTIL_P_OF12_OXM:
 815         return OFPUTIL_P_OF12_OXM;
 816
 817     case OFPUTIL_P_OF13_OXM:
 818         return OFPUTIL_P_OF13_OXM;
 819
 820     case OFPUTIL_P_OF14_OXM:
 821         return OFPUTIL_P_OF14_OXM;
 822
 823     case OFPUTIL_P_OF15_OXM:
 824         return OFPUTIL_P_OF15_OXM;
 825
 826     case OFPUTIL_P_OF16_OXM:
 827         return OFPUTIL_P_OF16_OXM;
 828
 829     default:
 830         OVS_NOT_REACHED();
 831     }
 832 }
 833
 834 /* Returns the "base" version of 'protocol'.  That is, if 'protocol' includes
 835  * some extension to a standard protocol version, the return value is the
 836  * standard version of that protocol without any extension.  If 'protocol' is a
 837  * standard protocol version, returns 'protocol' unchanged. */
 838 enum ofputil_protocol
 839 ofputil_protocol_to_base(enum ofputil_protocol protocol)
 840 {
 841     return ofputil_protocol_set_tid(protocol, false);
 842 }
 843
 844 /* Returns 'new_base' with any extensions taken from 'cur'. */
 845 enum ofputil_protocol
 846 ofputil_protocol_set_base(enum ofputil_protocol cur,
 847                           enum ofputil_protocol new_base)
 848 {
 849     bool tid = (cur & OFPUTIL_P_TID) != 0;
 850
 851     switch (new_base) {
 852     case OFPUTIL_P_OF10_STD:
 853     case OFPUTIL_P_OF10_STD_TID:
 854         return ofputil_protocol_set_tid(OFPUTIL_P_OF10_STD, tid);
 855
 856     case OFPUTIL_P_OF10_NXM:
 857     case OFPUTIL_P_OF10_NXM_TID:
 858         return ofputil_protocol_set_tid(OFPUTIL_P_OF10_NXM, tid);
 859
 860     case OFPUTIL_P_OF11_STD:
 861         return ofputil_protocol_set_tid(OFPUTIL_P_OF11_STD, tid);
 862
 863     case OFPUTIL_P_OF12_OXM:
 864         return ofputil_protocol_set_tid(OFPUTIL_P_OF12_OXM, tid);
 865
 866     case OFPUTIL_P_OF13_OXM:
 867         return ofputil_protocol_set_tid(OFPUTIL_P_OF13_OXM, tid);
 868
 869     case OFPUTIL_P_OF14_OXM:
 870         return ofputil_protocol_set_tid(OFPUTIL_P_OF14_OXM, tid);
 871
 872     case OFPUTIL_P_OF15_OXM:
 873         return ofputil_protocol_set_tid(OFPUTIL_P_OF15_OXM, tid);
 874
 875     case OFPUTIL_P_OF16_OXM:
 876         return ofputil_protocol_set_tid(OFPUTIL_P_OF16_OXM, tid);
 877
 878     default:
 879         OVS_NOT_REACHED();
 880     }
 881 }
 882
 883 /* Returns a string form of 'protocol', if a simple form exists (that is, if
 884  * 'protocol' is either a single protocol or it is a combination of protocols
 885  * that have a single abbreviation).  Otherwise, returns NULL. */
 886 const char *
 887 ofputil_protocol_to_string(enum ofputil_protocol protocol)
 888 {
 889     const struct proto_abbrev *p;
 890
 891     /* Use a "switch" statement for single-bit names so that we get a compiler
 892      * warning if we forget any. */
 893     switch (protocol) {
 894     case OFPUTIL_P_OF10_NXM:
 895         return "NXM-table_id";
 896
 897     case OFPUTIL_P_OF10_NXM_TID:
 898         return "NXM+table_id";
 899
 900     case OFPUTIL_P_OF10_STD:
 901         return "OpenFlow10-table_id";
 902
 903     case OFPUTIL_P_OF10_STD_TID:
 904         return "OpenFlow10+table_id";
 905
 906     case OFPUTIL_P_OF11_STD:
 907         return "OpenFlow11";
 908
 909     case OFPUTIL_P_OF12_OXM:
 910         return "OXM-OpenFlow12";
 911
 912     case OFPUTIL_P_OF13_OXM:
 913         return "OXM-OpenFlow13";
 914
 915     case OFPUTIL_P_OF14_OXM:
 916         return "OXM-OpenFlow14";
 917
 918     case OFPUTIL_P_OF15_OXM:
 919         return "OXM-OpenFlow15";
 920
 921     case OFPUTIL_P_OF16_OXM:
 922         return "OXM-OpenFlow16";
 923     }
 924
 925     /* Check abbreviations. */
 926     for (p = proto_abbrevs; p < &proto_abbrevs[N_PROTO_ABBREVS]; p++) {
 927         if (protocol == p->protocol) {
 928             return p->name;
 929         }
 930     }
 931
 932     return NULL;
 933 }
 934
 935 /* Returns a string that represents 'protocols'.  The return value might be a
 936  * comma-separated list if 'protocols' doesn't have a simple name.  The return
 937  * value is "none" if 'protocols' is 0.
 938  *
 939  * The caller must free the returned string (with free()). */
 940 char *
 941 ofputil_protocols_to_string(enum ofputil_protocol protocols)
 942 {
 943     struct ds s;
 944
 945     ovs_assert(!(protocols & ~OFPUTIL_P_ANY));
 946     if (protocols == 0) {
 947         return xstrdup("none");
 948     }
 949
 950     ds_init(&s);
 951     while (protocols) {
 952         const struct proto_abbrev *p;
 953         int i;
 954
 955         if (s.length) {
 956             ds_put_char(&s, ',');
 957         }
 958
 959         for (p = proto_abbrevs; p < &proto_abbrevs[N_PROTO_ABBREVS]; p++) {
 960             if ((protocols & p->protocol) == p->protocol) {
 961                 ds_put_cstr(&s, p->name);
 962                 protocols &= ~p->protocol;
 963                 goto match;
 964             }
 965         }
 966
 967         for (i = 0; i < CHAR_BIT * sizeof(enum ofputil_protocol); i++) {
 968             enum ofputil_protocol bit = 1u << i;
 969
 970             if (protocols & bit) {
 971                 ds_put_cstr(&s, ofputil_protocol_to_string(bit));
 972                 protocols &= ~bit;
 973                 goto match;
 974             }
 975         }
 976         OVS_NOT_REACHED();
 977
 978     match: ;
 979     }
 980     return ds_steal_cstr(&s);
 981 }
 982
 983 static enum ofputil_protocol
 984 ofputil_protocol_from_string__(const char *s, size_t n)
 985 {
 986     const struct proto_abbrev *p;
 987     int i;
 988
 989     for (i = 0; i < CHAR_BIT * sizeof(enum ofputil_protocol); i++) {
 990         enum ofputil_protocol bit = 1u << i;
 991         const char *name = ofputil_protocol_to_string(bit);
 992
 993         if (name && n == strlen(name) && !strncasecmp(s, name, n)) {
 994             return bit;
 995         }
 996     }
 997
 998     for (p = proto_abbrevs; p < &proto_abbrevs[N_PROTO_ABBREVS]; p++) {
 999         if (n == strlen(p->name) && !strncasecmp(s, p->name, n)) {
1000             return p->protocol;
1001         }
1002     }
1003
1004     return 0;
1005 }
1006
1007 /* Returns the nonempty set of protocols represented by 's', which can be a
1008  * single protocol name or abbreviation or a comma-separated list of them.
1009  *
1010  * Aborts the program with an error message if 's' is invalid. */
1011 enum ofputil_protocol
1012 ofputil_protocols_from_string(const char *s)
1013 {
1014     const char *orig_s = s;
1015     enum ofputil_protocol protocols;
1016
1017     protocols = 0;
1018     while (*s) {
1019         enum ofputil_protocol p;
1020         size_t n;
1021
1022         n = strcspn(s, ",");
1023         if (n == 0) {
1024             s++;
1025             continue;
1026         }
1027
1028         p = ofputil_protocol_from_string__(s, n);
1029         if (!p) {
1030             ovs_fatal(0, "%.*s: unknown flow protocol", (int) n, s);
1031         }
1032         protocols |= p;
1033
1034         s += n;
1035     }
1036
1037     if (!protocols) {
1038         ovs_fatal(0, "%s: no flow protocol specified", orig_s);
1039     }
1040     return protocols;
1041 }
1042
1043 enum ofp_version
1044 ofputil_version_from_string(const char *s)
1045 {
1046     if (!strcasecmp(s, "OpenFlow10")) {
1047         return OFP10_VERSION;
1048     }
1049     if (!strcasecmp(s, "OpenFlow11")) {
1050         return OFP11_VERSION;
1051     }
1052     if (!strcasecmp(s, "OpenFlow12")) {
1053         return OFP12_VERSION;
1054     }
1055     if (!strcasecmp(s, "OpenFlow13")) {
1056         return OFP13_VERSION;
1057     }
1058     if (!strcasecmp(s, "OpenFlow14")) {
1059         return OFP14_VERSION;
1060     }
1061     if (!strcasecmp(s, "OpenFlow15")) {
1062         return OFP15_VERSION;
1063     }
1064     if (!strcasecmp(s, "OpenFlow16")) {
1065         return OFP16_VERSION;
1066     }
1067     return 0;
1068 }
1069
1070 static bool
1071 is_delimiter(unsigned char c)
1072 {
1073     return isspace(c) || c == ',';
1074 }
1075
1076 uint32_t
1077 ofputil_versions_from_string(const char *s)
1078 {
1079     size_t i = 0;
1080     uint32_t bitmap = 0;
1081
1082     while (s[i]) {
1083         size_t j;
1084         int version;
1085         char *key;
1086
1087         if (is_delimiter(s[i])) {
1088             i++;
1089             continue;
1090         }
1091         j = 0;
1092         while (s[i + j] && !is_delimiter(s[i + j])) {
1093             j++;
1094         }
1095         key = xmemdup0(s + i, j);
1096         version = ofputil_version_from_string(key);
1097         if (!version) {
1098             VLOG_FATAL("Unknown OpenFlow version: \"%s\"", key);
1099         }
1100         free(key);
1101         bitmap |= 1u << version;
1102         i += j;
1103     }
1104
1105     return bitmap;
1106 }
1107
1108 uint32_t
1109 ofputil_versions_from_strings(char ** const s, size_t count)
1110 {
1111     uint32_t bitmap = 0;
1112
1113     while (count--) {
1114         int version = ofputil_version_from_string(s[count]);
1115         if (!version) {
1116             VLOG_WARN("Unknown OpenFlow version: \"%s\"", s[count]);
1117         } else {
1118             bitmap |= 1u << version;
1119         }
1120     }
1121
1122     return bitmap;
1123 }
1124
1125 const char *
1126 ofputil_version_to_string(enum ofp_version ofp_version)
1127 {
1128     switch (ofp_version) {
1129     case OFP10_VERSION:
1130         return "OpenFlow10";
1131     case OFP11_VERSION:
1132         return "OpenFlow11";
1133     case OFP12_VERSION:
1134         return "OpenFlow12";
1135     case OFP13_VERSION:
1136         return "OpenFlow13";
1137     case OFP14_VERSION:
1138         return "OpenFlow14";
1139     case OFP15_VERSION:
1140         return "OpenFlow15";
1141     case OFP16_VERSION:
1142         return "OpenFlow16";
1143     default:
1144         OVS_NOT_REACHED();
1145     }
1146 }
1147
1148 bool
1149 ofputil_packet_in_format_is_valid(enum nx_packet_in_format packet_in_format)
1150 {
1151     switch (packet_in_format) {
1152     case NXPIF_STANDARD:
1153     case NXPIF_NXT_PACKET_IN:
1154     case NXPIF_NXT_PACKET_IN2:
1155         return true;
1156     }
1157
1158     return false;
1159 }
1160
1161 const char *
1162 ofputil_packet_in_format_to_string(enum nx_packet_in_format packet_in_format)
1163 {
1164     switch (packet_in_format) {
1165     case NXPIF_STANDARD:
1166         return "standard";
1167     case NXPIF_NXT_PACKET_IN:
1168         return "nxt_packet_in";
1169     case NXPIF_NXT_PACKET_IN2:
1170         return "nxt_packet_in2";
1171     default:
1172         OVS_NOT_REACHED();
1173     }
1174 }
1175
1176 int
1177 ofputil_packet_in_format_from_string(const char *s)
1178 {
1179     return (!strcmp(s, "standard") || !strcmp(s, "openflow10")
1180             ? NXPIF_STANDARD
1181             : !strcmp(s, "nxt_packet_in") || !strcmp(s, "nxm")
1182             ? NXPIF_NXT_PACKET_IN
1183             : !strcmp(s, "nxt_packet_in2")
1184             ? NXPIF_NXT_PACKET_IN2
1185             : -1);
1186 }
1187
1188 void
1189 ofputil_format_version(struct ds *msg, enum ofp_version version)
1190 {
1191     ds_put_format(msg, "0x%02x", version);
1192 }
1193
1194 void
1195 ofputil_format_version_name(struct ds *msg, enum ofp_version version)
1196 {
1197     ds_put_cstr(msg, ofputil_version_to_string(version));
1198 }
1199
1200 static void
1201 ofputil_format_version_bitmap__(struct ds *msg, uint32_t bitmap,
1202                                 void (*format_version)(struct ds *msg,
1203                                                        enum ofp_version))
1204 {
1205     while (bitmap) {
1206         format_version(msg, raw_ctz(bitmap));
1207         bitmap = zero_rightmost_1bit(bitmap);
1208         if (bitmap) {
1209             ds_put_cstr(msg, ", ");
1210         }
1211     }
1212 }
1213
1214 void
1215 ofputil_format_version_bitmap(struct ds *msg, uint32_t bitmap)
1216 {
1217     ofputil_format_version_bitmap__(msg, bitmap, ofputil_format_version);
1218 }
1219
1220 void
1221 ofputil_format_version_bitmap_names(struct ds *msg, uint32_t bitmap)
1222 {
1223     ofputil_format_version_bitmap__(msg, bitmap, ofputil_format_version_name);
1224 }
1225
1226 static bool
1227 ofputil_decode_hello_bitmap(const struct ofp_hello_elem_header *oheh,
1228                             uint32_t *allowed_versionsp)
1229 {
1230     uint16_t bitmap_len = ntohs(oheh->length) - sizeof *oheh;
1231     const ovs_be32 *bitmap = ALIGNED_CAST(const ovs_be32 *, oheh + 1);
1232     uint32_t allowed_versions;
1233
1234     if (!bitmap_len || bitmap_len % sizeof *bitmap) {
1235         return false;
1236     }
1237
1238     /* Only use the first 32-bit element of the bitmap as that is all the
1239      * current implementation supports.  Subsequent elements are ignored which
1240      * should have no effect on session negotiation until Open vSwitch supports
1241      * wire-protocol versions greater than 31.
1242      */
1243     allowed_versions = ntohl(bitmap[0]);
1244
1245     if (allowed_versions & 1) {
1246         /* There's no OpenFlow version 0. */
1247         VLOG_WARN_RL(&bad_ofmsg_rl, "peer claims to support invalid OpenFlow "
1248                      "version 0x00");
1249         allowed_versions &= ~1u;
1250     }
1251
1252     if (!allowed_versions) {
1253         VLOG_WARN_RL(&bad_ofmsg_rl, "peer does not support any OpenFlow "
1254                      "version (between 0x01 and 0x1f)");
1255         return false;
1256     }
1257
1258     *allowed_versionsp = allowed_versions;
1259     return true;
1260 }
1261
1262 static uint32_t
1263 version_bitmap_from_version(uint8_t ofp_version)
1264 {
1265     return ((ofp_version < 32 ? 1u << ofp_version : 0) - 1) << 1;
1266 }
1267
1268 /* Decodes OpenFlow OFPT_HELLO message 'oh', storing into '*allowed_versions'
1269  * the set of OpenFlow versions for which 'oh' announces support.
1270  *
1271  * Because of how OpenFlow defines OFPT_HELLO messages, this function is always
1272  * successful, and thus '*allowed_versions' is always initialized.  However, it
1273  * returns false if 'oh' contains some data that could not be fully understood,
1274  * true if 'oh' was completely parsed. */
1275 bool
1276 ofputil_decode_hello(const struct ofp_header *oh, uint32_t *allowed_versions)
1277 {
1278     struct ofpbuf msg = ofpbuf_const_initializer(oh, ntohs(oh->length));
1279     ofpbuf_pull(&msg, sizeof *oh);
1280
1281     *allowed_versions = version_bitmap_from_version(oh->version);
1282
1283     bool ok = true;
1284     while (msg.size) {
1285         const struct ofp_hello_elem_header *oheh;
1286         unsigned int len;
1287
1288         if (msg.size < sizeof *oheh) {
1289             return false;
1290         }
1291
1292         oheh = msg.data;
1293         len = ntohs(oheh->length);
1294         if (len < sizeof *oheh || !ofpbuf_try_pull(&msg, ROUND_UP(len, 8))) {
1295             return false;
1296         }
1297
1298         if (oheh->type != htons(OFPHET_VERSIONBITMAP)
1299             || !ofputil_decode_hello_bitmap(oheh, allowed_versions)) {
1300             ok = false;
1301         }
1302     }
1303
1304     return ok;
1305 }
1306
1307 /* Returns true if 'allowed_versions' needs to be accompanied by a version
1308  * bitmap to be correctly expressed in an OFPT_HELLO message. */
1309 static bool
1310 should_send_version_bitmap(uint32_t allowed_versions)
1311 {
1312     return !is_pow2((allowed_versions >> 1) + 1);
1313 }
1314
1315 /* Create an OFPT_HELLO message that expresses support for the OpenFlow
1316  * versions in the 'allowed_versions' bitmaps and returns the message. */
1317 struct ofpbuf *
1318 ofputil_encode_hello(uint32_t allowed_versions)
1319 {
1320     enum ofp_version ofp_version;
1321     struct ofpbuf *msg;
1322
1323     ofp_version = leftmost_1bit_idx(allowed_versions);
1324     msg = ofpraw_alloc(OFPRAW_OFPT_HELLO, ofp_version, 0);
1325
1326     if (should_send_version_bitmap(allowed_versions)) {
1327         struct ofp_hello_elem_header *oheh;
1328         uint16_t map_len;
1329
1330         map_len = sizeof allowed_versions;
1331         oheh = ofpbuf_put_zeros(msg, ROUND_UP(map_len + sizeof *oheh, 8));
1332         oheh->type = htons(OFPHET_VERSIONBITMAP);
1333         oheh->length = htons(map_len + sizeof *oheh);
1334         *ALIGNED_CAST(ovs_be32 *, oheh + 1) = htonl(allowed_versions);
1335
1336         ofpmsg_update_length(msg);
1337     }
1338
1339     return msg;
1340 }
1341
1342 /* Returns an OpenFlow message that, sent on an OpenFlow connection whose
1343  * protocol is 'current', at least partly transitions the protocol to 'want'.
1344  * Stores in '*next' the protocol that will be in effect on the OpenFlow
1345  * connection if the switch processes the returned message correctly.  (If
1346  * '*next != want' then the caller will have to iterate.)
1347  *
1348  * If 'current == want', or if it is not possible to transition from 'current'
1349  * to 'want' (because, for example, 'current' and 'want' use different OpenFlow
1350  * protocol versions), returns NULL and stores 'current' in '*next'. */
1351 struct ofpbuf *
1352 ofputil_encode_set_protocol(enum ofputil_protocol current,
1353                             enum ofputil_protocol want,
1354                             enum ofputil_protocol *next)
1355 {
1356     enum ofp_version cur_version, want_version;
1357     enum ofputil_protocol cur_base, want_base;
1358     bool cur_tid, want_tid;
1359
1360     cur_version = ofputil_protocol_to_ofp_version(current);
1361     want_version = ofputil_protocol_to_ofp_version(want);
1362     if (cur_version != want_version) {
1363         *next = current;
1364         return NULL;
1365     }
1366
1367     cur_base = ofputil_protocol_to_base(current);
1368     want_base = ofputil_protocol_to_base(want);
1369     if (cur_base != want_base) {
1370         *next = ofputil_protocol_set_base(current, want_base);
1371
1372         switch (want_base) {
1373         case OFPUTIL_P_OF10_NXM:
1374             return ofputil_encode_nx_set_flow_format(NXFF_NXM);
1375
1376         case OFPUTIL_P_OF10_STD:
1377             return ofputil_encode_nx_set_flow_format(NXFF_OPENFLOW10);
1378
1379         case OFPUTIL_P_OF11_STD:
1380         case OFPUTIL_P_OF12_OXM:
1381         case OFPUTIL_P_OF13_OXM:
1382         case OFPUTIL_P_OF14_OXM:
1383         case OFPUTIL_P_OF15_OXM:
1384         case OFPUTIL_P_OF16_OXM:
1385             /* There is only one variant of each OpenFlow 1.1+ protocol, and we
1386              * verified above that we're not trying to change versions. */
1387             OVS_NOT_REACHED();
1388
1389         case OFPUTIL_P_OF10_STD_TID:
1390         case OFPUTIL_P_OF10_NXM_TID:
1391             OVS_NOT_REACHED();
1392         }
1393     }
1394
1395     cur_tid = (current & OFPUTIL_P_TID) != 0;
1396     want_tid = (want & OFPUTIL_P_TID) != 0;
1397     if (cur_tid != want_tid) {
1398         *next = ofputil_protocol_set_tid(current, want_tid);
1399         return ofputil_make_flow_mod_table_id(want_tid);
1400     }
1401
1402     ovs_assert(current == want);
1403
1404     *next = current;
1405     return NULL;
1406 }
1407
1408 /* Returns an NXT_SET_FLOW_FORMAT message that can be used to set the flow
1409  * format to 'nxff'.  */
1410 struct ofpbuf *
1411 ofputil_encode_nx_set_flow_format(enum nx_flow_format nxff)
1412 {
1413     struct nx_set_flow_format *sff;
1414     struct ofpbuf *msg;
1415
1416     ovs_assert(ofputil_nx_flow_format_is_valid(nxff));
1417
1418     msg = ofpraw_alloc(OFPRAW_NXT_SET_FLOW_FORMAT, OFP10_VERSION, 0);
1419     sff = ofpbuf_put_zeros(msg, sizeof *sff);
1420     sff->format = htonl(nxff);
1421
1422     return msg;
1423 }
1424
1425 /* Returns the base protocol if 'flow_format' is a valid NXFF_* value, false
1426  * otherwise. */
1427 enum ofputil_protocol
1428 ofputil_nx_flow_format_to_protocol(enum nx_flow_format flow_format)
1429 {
1430     switch (flow_format) {
1431     case NXFF_OPENFLOW10:
1432         return OFPUTIL_P_OF10_STD;
1433
1434     case NXFF_NXM:
1435         return OFPUTIL_P_OF10_NXM;
1436
1437     default:
1438         return 0;
1439     }
1440 }
1441
1442 /* Returns true if 'flow_format' is a valid NXFF_* value, false otherwise. */
1443 bool
1444 ofputil_nx_flow_format_is_valid(enum nx_flow_format flow_format)
1445 {
1446     return ofputil_nx_flow_format_to_protocol(flow_format) != 0;
1447 }
1448
1449 /* Returns a string version of 'flow_format', which must be a valid NXFF_*
1450  * value. */
1451 const char *
1452 ofputil_nx_flow_format_to_string(enum nx_flow_format flow_format)
1453 {
1454     switch (flow_format) {
1455     case NXFF_OPENFLOW10:
1456         return "openflow10";
1457     case NXFF_NXM:
1458         return "nxm";
1459     default:
1460         OVS_NOT_REACHED();
1461     }
1462 }
1463
1464 struct ofpbuf *
1465 ofputil_make_set_packet_in_format(enum ofp_version ofp_version,
1466                                   enum nx_packet_in_format packet_in_format)
1467 {
1468     struct nx_set_packet_in_format *spif;
1469     struct ofpbuf *msg;
1470
1471     msg = ofpraw_alloc(OFPRAW_NXT_SET_PACKET_IN_FORMAT, ofp_version, 0);
1472     spif = ofpbuf_put_zeros(msg, sizeof *spif);
1473     spif->format = htonl(packet_in_format);
1474
1475     return msg;
1476 }
1477
1478 /* Returns an OpenFlow message that can be used to turn the flow_mod_table_id
1479  * extension on or off (according to 'flow_mod_table_id'). */
1480 struct ofpbuf *
1481 ofputil_make_flow_mod_table_id(bool flow_mod_table_id)
1482 {
1483     struct nx_flow_mod_table_id *nfmti;
1484     struct ofpbuf *msg;
1485
1486     msg = ofpraw_alloc(OFPRAW_NXT_FLOW_MOD_TABLE_ID, OFP10_VERSION, 0);
1487     nfmti = ofpbuf_put_zeros(msg, sizeof *nfmti);
1488     nfmti->set = flow_mod_table_id;
1489     return msg;
1490 }
1491
1492 struct ofputil_flow_mod_flag {
1493     uint16_t raw_flag;
1494     enum ofp_version min_version, max_version;
1495     enum ofputil_flow_mod_flags flag;
1496 };
1497
1498 static const struct ofputil_flow_mod_flag ofputil_flow_mod_flags[] = {
1499     { OFPFF_SEND_FLOW_REM,   OFP10_VERSION, 0, OFPUTIL_FF_SEND_FLOW_REM },
1500     { OFPFF_CHECK_OVERLAP,   OFP10_VERSION, 0, OFPUTIL_FF_CHECK_OVERLAP },
1501     { OFPFF10_EMERG,         OFP10_VERSION, OFP10_VERSION,
1502       OFPUTIL_FF_EMERG },
1503     { OFPFF12_RESET_COUNTS,  OFP12_VERSION, 0, OFPUTIL_FF_RESET_COUNTS },
1504     { OFPFF13_NO_PKT_COUNTS, OFP13_VERSION, 0, OFPUTIL_FF_NO_PKT_COUNTS },
1505     { OFPFF13_NO_BYT_COUNTS, OFP13_VERSION, 0, OFPUTIL_FF_NO_BYT_COUNTS },
1506     { 0, 0, 0, 0 },
1507 };
1508
1509 static enum ofperr
1510 ofputil_decode_flow_mod_flags(ovs_be16 raw_flags_,
1511                               enum ofp_flow_mod_command command,
1512                               enum ofp_version version,
1513                               enum ofputil_flow_mod_flags *flagsp)
1514 {
1515     uint16_t raw_flags = ntohs(raw_flags_);
1516     const struct ofputil_flow_mod_flag *f;
1517
1518     *flagsp = 0;
1519     for (f = ofputil_flow_mod_flags; f->raw_flag; f++) {
1520         if (raw_flags & f->raw_flag
1521             && version >= f->min_version
1522             && (!f->max_version || version <= f->max_version)) {
1523             raw_flags &= ~f->raw_flag;
1524             *flagsp |= f->flag;
1525         }
1526     }
1527
1528     /* In OF1.0 and OF1.1, "add" always resets counters, and other commands
1529      * never do.
1530      *
1531      * In OF1.2 and later, OFPFF12_RESET_COUNTS controls whether each command
1532      * resets counters. */
1533     if ((version == OFP10_VERSION || version == OFP11_VERSION)
1534         && command == OFPFC_ADD) {
1535         *flagsp |= OFPUTIL_FF_RESET_COUNTS;
1536     }
1537
1538     return raw_flags ? OFPERR_OFPFMFC_BAD_FLAGS : 0;
1539 }
1540
1541 static ovs_be16
1542 ofputil_encode_flow_mod_flags(enum ofputil_flow_mod_flags flags,
1543                               enum ofp_version version)
1544 {
1545     const struct ofputil_flow_mod_flag *f;
1546     uint16_t raw_flags;
1547
1548     raw_flags = 0;
1549     for (f = ofputil_flow_mod_flags; f->raw_flag; f++) {
1550         if (f->flag & flags
1551             && version >= f->min_version
1552             && (!f->max_version || version <= f->max_version)) {
1553             raw_flags |= f->raw_flag;
1554         }
1555     }
1556
1557     return htons(raw_flags);
1558 }
1559
1560 /* Converts an OFPT_FLOW_MOD or NXT_FLOW_MOD message 'oh' into an abstract
1561  * flow_mod in 'fm'.  Returns 0 if successful, otherwise an OpenFlow error
1562  * code.
1563  *
1564  * Uses 'ofpacts' to store the abstract OFPACT_* version of 'oh''s actions.
1565  * The caller must initialize 'ofpacts' and retains ownership of it.
1566  * 'fm->ofpacts' will point into the 'ofpacts' buffer.
1567  *
1568  * Does not validate the flow_mod actions.  The caller should do that, with
1569  * ofpacts_check(). */
1570 enum ofperr
1571 ofputil_decode_flow_mod(struct ofputil_flow_mod *fm,
1572                         const struct ofp_header *oh,
1573                         enum ofputil_protocol protocol,
1574                         struct ofpbuf *ofpacts,
1575                         ofp_port_t max_port, uint8_t max_table)
1576 {
1577     ovs_be16 raw_flags;
1578     enum ofperr error;
1579
1580     /* Ignored for non-delete actions */
1581     fm->delete_reason = OFPRR_DELETE;
1582
1583     struct ofpbuf b = ofpbuf_const_initializer(oh, ntohs(oh->length));
1584     enum ofpraw raw = ofpraw_pull_assert(&b);
1585     if (raw == OFPRAW_OFPT11_FLOW_MOD) {
1586         /* Standard OpenFlow 1.1+ flow_mod. */
1587         const struct ofp11_flow_mod *ofm;
1588
1589         ofm = ofpbuf_pull(&b, sizeof *ofm);
1590
1591         error = ofputil_pull_ofp11_match(&b, &fm->match, NULL);
1592         if (error) {
1593             return error;
1594         }
1595
1596         /* Translate the message. */
1597         fm->priority = ntohs(ofm->priority);
1598         if (ofm->command == OFPFC_ADD
1599             || (oh->version == OFP11_VERSION
1600                 && (ofm->command == OFPFC_MODIFY ||
1601                     ofm->command == OFPFC_MODIFY_STRICT)
1602                 && ofm->cookie_mask == htonll(0))) {
1603             /* In OpenFlow 1.1 only, a "modify" or "modify-strict" that does
1604              * not match on the cookie is treated as an "add" if there is no
1605              * match. */
1606             fm->cookie = htonll(0);
1607             fm->cookie_mask = htonll(0);
1608             fm->new_cookie = ofm->cookie;
1609         } else {
1610             fm->cookie = ofm->cookie;
1611             fm->cookie_mask = ofm->cookie_mask;
1612             fm->new_cookie = OVS_BE64_MAX;
1613         }
1614         fm->modify_cookie = false;
1615         fm->command = ofm->command;
1616
1617         /* Get table ID.
1618          *
1619          * OF1.1 entirely forbids table_id == OFPTT_ALL.
1620          * OF1.2+ allows table_id == OFPTT_ALL only for deletes. */
1621         fm->table_id = ofm->table_id;
1622         if (fm->table_id == OFPTT_ALL
1623             && (oh->version == OFP11_VERSION
1624                 || (ofm->command != OFPFC_DELETE &&
1625                     ofm->command != OFPFC_DELETE_STRICT))) {
1626             return OFPERR_OFPFMFC_BAD_TABLE_ID;
1627         }
1628
1629         fm->idle_timeout = ntohs(ofm->idle_timeout);
1630         fm->hard_timeout = ntohs(ofm->hard_timeout);
1631         if (oh->version >= OFP14_VERSION && ofm->command == OFPFC_ADD) {
1632             fm->importance = ntohs(ofm->importance);
1633         } else {
1634             fm->importance = 0;
1635         }
1636         fm->buffer_id = ntohl(ofm->buffer_id);
1637         error = ofputil_port_from_ofp11(ofm->out_port, &fm->out_port);
1638         if (error) {
1639             return error;
1640         }
1641
1642         fm->out_group = (ofm->command == OFPFC_DELETE ||
1643                          ofm->command == OFPFC_DELETE_STRICT
1644                          ? ntohl(ofm->out_group)
1645                          : OFPG_ANY);
1646         raw_flags = ofm->flags;
1647     } else {
1648         uint16_t command;
1649
1650         if (raw == OFPRAW_OFPT10_FLOW_MOD) {
1651             /* Standard OpenFlow 1.0 flow_mod. */
1652             const struct ofp10_flow_mod *ofm;
1653
1654             /* Get the ofp10_flow_mod. */
1655             ofm = ofpbuf_pull(&b, sizeof *ofm);
1656
1657             /* Translate the rule. */
1658             ofputil_match_from_ofp10_match(&ofm->match, &fm->match);
1659             ofputil_normalize_match(&fm->match);
1660
1661             /* OpenFlow 1.0 says that exact-match rules have to have the
1662              * highest possible priority. */
1663             fm->priority = (ofm->match.wildcards & htonl(OFPFW10_ALL)
1664                             ? ntohs(ofm->priority)
1665                             : UINT16_MAX);
1666
1667             /* Translate the message. */
1668             command = ntohs(ofm->command);
1669             fm->cookie = htonll(0);
1670             fm->cookie_mask = htonll(0);
1671             fm->new_cookie = ofm->cookie;
1672             fm->idle_timeout = ntohs(ofm->idle_timeout);
1673             fm->hard_timeout = ntohs(ofm->hard_timeout);
1674             fm->importance = 0;
1675             fm->buffer_id = ntohl(ofm->buffer_id);
1676             fm->out_port = u16_to_ofp(ntohs(ofm->out_port));
1677             fm->out_group = OFPG_ANY;
1678             raw_flags = ofm->flags;
1679         } else if (raw == OFPRAW_NXT_FLOW_MOD) {
1680             /* Nicira extended flow_mod. */
1681             const struct nx_flow_mod *nfm;
1682
1683             /* Dissect the message. */
1684             nfm = ofpbuf_pull(&b, sizeof *nfm);
1685             error = nx_pull_match(&b, ntohs(nfm->match_len),
1686                                   &fm->match, &fm->cookie, &fm->cookie_mask);
1687             if (error) {
1688                 return error;
1689             }
1690
1691             /* Translate the message. */
1692             command = ntohs(nfm->command);
1693             if ((command & 0xff) == OFPFC_ADD && fm->cookie_mask) {
1694                 /* Flow additions may only set a new cookie, not match an
1695                  * existing cookie. */
1696                 return OFPERR_NXBRC_NXM_INVALID;
1697             }
1698             fm->priority = ntohs(nfm->priority);
1699             fm->new_cookie = nfm->cookie;
1700             fm->idle_timeout = ntohs(nfm->idle_timeout);
1701             fm->hard_timeout = ntohs(nfm->hard_timeout);
1702             fm->importance = 0;
1703             fm->buffer_id = ntohl(nfm->buffer_id);
1704             fm->out_port = u16_to_ofp(ntohs(nfm->out_port));
1705             fm->out_group = OFPG_ANY;
1706             raw_flags = nfm->flags;
1707         } else {
1708             OVS_NOT_REACHED();
1709         }
1710
1711         fm->modify_cookie = fm->new_cookie != OVS_BE64_MAX;
1712         if (protocol & OFPUTIL_P_TID) {
1713             fm->command = command & 0xff;
1714             fm->table_id = command >> 8;
1715         } else {
1716             if (command > 0xff) {
1717                 VLOG_WARN_RL(&bad_ofmsg_rl, "flow_mod has explicit table_id "
1718                              "but flow_mod_table_id extension is not enabled");
1719             }
1720             fm->command = command;
1721             fm->table_id = 0xff;
1722         }
1723     }
1724
1725     if (fm->command > OFPFC_DELETE_STRICT) {
1726         return OFPERR_OFPFMFC_BAD_COMMAND;
1727     }
1728
1729     error = ofpacts_pull_openflow_instructions(&b, b.size,
1730                                                oh->version, ofpacts);
1731     if (error) {
1732         return error;
1733     }
1734     fm->ofpacts = ofpacts->data;
1735     fm->ofpacts_len = ofpacts->size;
1736
1737     error = ofputil_decode_flow_mod_flags(raw_flags, fm->command,
1738                                           oh->version, &fm->flags);
1739     if (error) {
1740         return error;
1741     }
1742
1743     if (fm->flags & OFPUTIL_FF_EMERG) {
1744         /* We do not support the OpenFlow 1.0 emergency flow cache, which
1745          * is not required in OpenFlow 1.0.1 and removed from OpenFlow 1.1.
1746          *
1747          * OpenFlow 1.0 specifies the error code to use when idle_timeout
1748          * or hard_timeout is nonzero.  Otherwise, there is no good error
1749          * code, so just state that the flow table is full. */
1750         return (fm->hard_timeout || fm->idle_timeout
1751                 ? OFPERR_OFPFMFC_BAD_EMERG_TIMEOUT
1752                 : OFPERR_OFPFMFC_TABLE_FULL);
1753     }
1754
1755     return ofpacts_check_consistency(fm->ofpacts, fm->ofpacts_len,
1756                                      &fm->match.flow, max_port,
1757                                      fm->table_id, max_table, protocol);
1758 }
1759
1760 static enum ofperr
1761 ofputil_pull_bands(struct ofpbuf *msg, size_t len, uint16_t *n_bands,
1762                    struct ofpbuf *bands)
1763 {
1764     const struct ofp13_meter_band_header *ombh;
1765     struct ofputil_meter_band *mb;
1766     uint16_t n = 0;
1767
1768     ombh = ofpbuf_try_pull(msg, len);
1769     if (!ombh) {
1770         return OFPERR_OFPBRC_BAD_LEN;
1771     }
1772
1773     while (len >= sizeof (struct ofp13_meter_band_drop)) {
1774         size_t ombh_len = ntohs(ombh->len);
1775         /* All supported band types have the same length. */
1776         if (ombh_len != sizeof (struct ofp13_meter_band_drop)) {
1777             return OFPERR_OFPBRC_BAD_LEN;
1778         }
1779         mb = ofpbuf_put_uninit(bands, sizeof *mb);
1780         mb->type = ntohs(ombh->type);
1781         if (mb->type != OFPMBT13_DROP && mb->type != OFPMBT13_DSCP_REMARK) {
1782             return OFPERR_OFPMMFC_BAD_BAND;
1783         }
1784         mb->rate = ntohl(ombh->rate);
1785         mb->burst_size = ntohl(ombh->burst_size);
1786         mb->prec_level = (mb->type == OFPMBT13_DSCP_REMARK) ?
1787             ((struct ofp13_meter_band_dscp_remark *)ombh)->prec_level : 0;
1788         n++;
1789         len -= ombh_len;
1790         ombh = ALIGNED_CAST(struct ofp13_meter_band_header *,
1791                             (char *) ombh + ombh_len);
1792     }
1793     if (len) {
1794         return OFPERR_OFPBRC_BAD_LEN;
1795     }
1796     *n_bands = n;
1797     return 0;
1798 }
1799
1800 enum ofperr
1801 ofputil_decode_meter_mod(const struct ofp_header *oh,
1802                          struct ofputil_meter_mod *mm,
1803                          struct ofpbuf *bands)
1804 {
1805     struct ofpbuf b = ofpbuf_const_initializer(oh, ntohs(oh->length));
1806     ofpraw_pull_assert(&b);
1807     const struct ofp13_meter_mod *omm = ofpbuf_pull(&b, sizeof *omm);
1808
1809     /* Translate the message. */
1810     mm->command = ntohs(omm->command);
1811     if (mm->command != OFPMC13_ADD &&
1812         mm->command != OFPMC13_MODIFY &&
1813         mm->command != OFPMC13_DELETE) {
1814         return OFPERR_OFPMMFC_BAD_COMMAND;
1815     }
1816     mm->meter.meter_id = ntohl(omm->meter_id);
1817
1818     if (mm->command == OFPMC13_DELETE) {
1819         mm->meter.flags = 0;
1820         mm->meter.n_bands = 0;
1821         mm->meter.bands = NULL;
1822     } else {
1823         enum ofperr error;
1824
1825         mm->meter.flags = ntohs(omm->flags);
1826         if (mm->meter.flags & OFPMF13_KBPS &&
1827             mm->meter.flags & OFPMF13_PKTPS) {
1828             return OFPERR_OFPMMFC_BAD_FLAGS;
1829         }
1830         mm->meter.bands = bands->data;
1831
1832         error = ofputil_pull_bands(&b, b.size, &mm->meter.n_bands, bands);
1833         if (error) {
1834             return error;
1835         }
1836     }
1837     return 0;
1838 }
1839
1840 void
1841 ofputil_decode_meter_request(const struct ofp_header *oh, uint32_t *meter_id)
1842 {
1843     const struct ofp13_meter_multipart_request *omr = ofpmsg_body(oh);
1844     *meter_id = ntohl(omr->meter_id);
1845 }
1846
1847 struct ofpbuf *
1848 ofputil_encode_meter_request(enum ofp_version ofp_version,
1849                              enum ofputil_meter_request_type type,
1850                              uint32_t meter_id)
1851 {
1852     struct ofpbuf *msg;
1853
1854     enum ofpraw raw;
1855
1856     switch (type) {
1857     case OFPUTIL_METER_CONFIG:
1858         raw = OFPRAW_OFPST13_METER_CONFIG_REQUEST;
1859         break;
1860     case OFPUTIL_METER_STATS:
1861         raw = OFPRAW_OFPST13_METER_REQUEST;
1862         break;
1863     default:
1864     case OFPUTIL_METER_FEATURES:
1865         raw = OFPRAW_OFPST13_METER_FEATURES_REQUEST;
1866         break;
1867     }
1868
1869     msg = ofpraw_alloc(raw, ofp_version, 0);
1870
1871     if (type != OFPUTIL_METER_FEATURES) {
1872         struct ofp13_meter_multipart_request *omr;
1873         omr = ofpbuf_put_zeros(msg, sizeof *omr);
1874         omr->meter_id = htonl(meter_id);
1875     }
1876     return msg;
1877 }
1878
1879 static void
1880 ofputil_put_bands(uint16_t n_bands, const struct ofputil_meter_band *mb,
1881                   struct ofpbuf *msg)
1882 {
1883     uint16_t n = 0;
1884
1885     for (n = 0; n < n_bands; ++n) {
1886         /* Currently all band types have same size. */
1887         struct ofp13_meter_band_dscp_remark *ombh;
1888         size_t ombh_len = sizeof *ombh;
1889
1890         ombh = ofpbuf_put_zeros(msg, ombh_len);
1891
1892         ombh->type = htons(mb->type);
1893         ombh->len = htons(ombh_len);
1894         ombh->rate = htonl(mb->rate);
1895         ombh->burst_size = htonl(mb->burst_size);
1896         ombh->prec_level = mb->prec_level;
1897
1898         mb++;
1899     }
1900 }
1901
1902 /* Encode a meter stat for 'mc' and append it to 'replies'. */
1903 void
1904 ofputil_append_meter_config(struct ovs_list *replies,
1905                             const struct ofputil_meter_config *mc)
1906 {
1907     struct ofpbuf *msg = ofpbuf_from_list(ovs_list_back(replies));
1908     size_t start_ofs = msg->size;
1909     struct ofp13_meter_config *reply;
1910
1911     ofpbuf_put_uninit(msg, sizeof *reply);
1912     ofputil_put_bands(mc->n_bands, mc->bands, msg);
1913
1914     reply = ofpbuf_at_assert(msg, start_ofs, sizeof *reply);
1915     reply->flags = htons(mc->flags);
1916     reply->meter_id = htonl(mc->meter_id);
1917     reply->length = htons(msg->size - start_ofs);
1918
1919     ofpmp_postappend(replies, start_ofs);
1920 }
1921
1922 /* Encode a meter stat for 'ms' and append it to 'replies'. */
1923 void
1924 ofputil_append_meter_stats(struct ovs_list *replies,
1925                            const struct ofputil_meter_stats *ms)
1926 {
1927     struct ofp13_meter_stats *reply;
1928     uint16_t n = 0;
1929     uint16_t len;
1930
1931     len = sizeof *reply + ms->n_bands * sizeof(struct ofp13_meter_band_stats);
1932     reply = ofpmp_append(replies, len);
1933
1934     reply->meter_id = htonl(ms->meter_id);
1935     reply->len = htons(len);
1936     memset(reply->pad, 0, sizeof reply->pad);
1937     reply->flow_count = htonl(ms->flow_count);
1938     reply->packet_in_count = htonll(ms->packet_in_count);
1939     reply->byte_in_count = htonll(ms->byte_in_count);
1940     reply->duration_sec = htonl(ms->duration_sec);
1941     reply->duration_nsec = htonl(ms->duration_nsec);
1942
1943     for (n = 0; n < ms->n_bands; ++n) {
1944         const struct ofputil_meter_band_stats *src = &ms->bands[n];
1945         struct ofp13_meter_band_stats *dst = &reply->band_stats[n];
1946
1947         dst->packet_band_count = htonll(src->packet_count);
1948         dst->byte_band_count = htonll(src->byte_count);
1949     }
1950 }
1951
1952 /* Converts an OFPMP_METER_CONFIG reply in 'msg' into an abstract
1953  * ofputil_meter_config in 'mc', with mc->bands pointing to bands decoded into
1954  * 'bands'.  The caller must have initialized 'bands' and retains ownership of
1955  * it across the call.
1956  *
1957  * Multiple OFPST13_METER_CONFIG replies can be packed into a single OpenFlow
1958  * message.  Calling this function multiple times for a single 'msg' iterates
1959  * through the replies.  'bands' is cleared for each reply.
1960  *
1961  * Returns 0 if successful, EOF if no replies were left in this 'msg',
1962  * otherwise a positive errno value. */
1963 int
1964 ofputil_decode_meter_config(struct ofpbuf *msg,
1965                             struct ofputil_meter_config *mc,
1966                             struct ofpbuf *bands)
1967 {
1968     const struct ofp13_meter_config *omc;
1969     enum ofperr err;
1970
1971     /* Pull OpenFlow headers for the first call. */
1972     if (!msg->header) {
1973         ofpraw_pull_assert(msg);
1974     }
1975
1976     if (!msg->size) {
1977         return EOF;
1978     }
1979
1980     omc = ofpbuf_try_pull(msg, sizeof *omc);
1981     if (!omc) {
1982         VLOG_WARN_RL(&bad_ofmsg_rl,
1983                      "OFPMP_METER_CONFIG reply has %"PRIu32" leftover bytes at end",
1984                      msg->size);
1985         return OFPERR_OFPBRC_BAD_LEN;
1986     }
1987
1988     ofpbuf_clear(bands);
1989     err = ofputil_pull_bands(msg, ntohs(omc->length) - sizeof *omc,
1990                              &mc->n_bands, bands);
1991     if (err) {
1992         return err;
1993     }
1994     mc->meter_id = ntohl(omc->meter_id);
1995     mc->flags = ntohs(omc->flags);
1996     mc->bands = bands->data;
1997
1998     return 0;
1999 }
2000
2001 static enum ofperr
2002 ofputil_pull_band_stats(struct ofpbuf *msg, size_t len, uint16_t *n_bands,
2003                         struct ofpbuf *bands)
2004 {
2005     const struct ofp13_meter_band_stats *ombs;
2006     struct ofputil_meter_band_stats *mbs;
2007     uint16_t n, i;
2008
2009     ombs = ofpbuf_try_pull(msg, len);
2010     if (!ombs) {
2011         return OFPERR_OFPBRC_BAD_LEN;
2012     }
2013
2014     n = len / sizeof *ombs;
2015     if (len != n * sizeof *ombs) {
2016         return OFPERR_OFPBRC_BAD_LEN;
2017     }
2018
2019     mbs = ofpbuf_put_uninit(bands, len);
2020
2021     for (i = 0; i < n; ++i) {
2022         mbs[i].packet_count = ntohll(ombs[i].packet_band_count);
2023         mbs[i].byte_count = ntohll(ombs[i].byte_band_count);
2024     }
2025     *n_bands = n;
2026     return 0;
2027 }
2028
2029 /* Converts an OFPMP_METER reply in 'msg' into an abstract
2030  * ofputil_meter_stats in 'ms', with ms->bands pointing to band stats
2031  * decoded into 'bands'.
2032  *
2033  * Multiple OFPMP_METER replies can be packed into a single OpenFlow
2034  * message.  Calling this function multiple times for a single 'msg' iterates
2035  * through the replies.  'bands' is cleared for each reply.
2036  *
2037  * Returns 0 if successful, EOF if no replies were left in this 'msg',
2038  * otherwise a positive errno value. */
2039 int
2040 ofputil_decode_meter_stats(struct ofpbuf *msg,
2041                            struct ofputil_meter_stats *ms,
2042                            struct ofpbuf *bands)
2043 {
2044     const struct ofp13_meter_stats *oms;
2045     enum ofperr err;
2046
2047     /* Pull OpenFlow headers for the first call. */
2048     if (!msg->header) {
2049         ofpraw_pull_assert(msg);
2050     }
2051
2052     if (!msg->size) {
2053         return EOF;
2054     }
2055
2056     oms = ofpbuf_try_pull(msg, sizeof *oms);
2057     if (!oms) {
2058         VLOG_WARN_RL(&bad_ofmsg_rl,
2059                      "OFPMP_METER reply has %"PRIu32" leftover bytes at end",
2060                      msg->size);
2061         return OFPERR_OFPBRC_BAD_LEN;
2062     }
2063
2064     ofpbuf_clear(bands);
2065     err = ofputil_pull_band_stats(msg, ntohs(oms->len) - sizeof *oms,
2066                                   &ms->n_bands, bands);
2067     if (err) {
2068         return err;
2069     }
2070     ms->meter_id = ntohl(oms->meter_id);
2071     ms->flow_count = ntohl(oms->flow_count);
2072     ms->packet_in_count = ntohll(oms->packet_in_count);
2073     ms->byte_in_count = ntohll(oms->byte_in_count);
2074     ms->duration_sec = ntohl(oms->duration_sec);
2075     ms->duration_nsec = ntohl(oms->duration_nsec);
2076     ms->bands = bands->data;
2077
2078     return 0;
2079 }
2080
2081 void
2082 ofputil_decode_meter_features(const struct ofp_header *oh,
2083                               struct ofputil_meter_features *mf)
2084 {
2085     const struct ofp13_meter_features *omf = ofpmsg_body(oh);
2086
2087     mf->max_meters = ntohl(omf->max_meter);
2088     mf->band_types = ntohl(omf->band_types);
2089     mf->capabilities = ntohl(omf->capabilities);
2090     mf->max_bands = omf->max_bands;
2091     mf->max_color = omf->max_color;
2092 }
2093
2094 struct ofpbuf *
2095 ofputil_encode_meter_features_reply(const struct ofputil_meter_features *mf,
2096                                     const struct ofp_header *request)
2097 {
2098     struct ofpbuf *reply;
2099     struct ofp13_meter_features *omf;
2100
2101     reply = ofpraw_alloc_stats_reply(request, 0);
2102     omf = ofpbuf_put_zeros(reply, sizeof *omf);
2103
2104     omf->max_meter = htonl(mf->max_meters);
2105     omf->band_types = htonl(mf->band_types);
2106     omf->capabilities = htonl(mf->capabilities);
2107     omf->max_bands = mf->max_bands;
2108     omf->max_color = mf->max_color;
2109
2110     return reply;
2111 }
2112
2113 struct ofpbuf *
2114 ofputil_encode_meter_mod(enum ofp_version ofp_version,
2115                          const struct ofputil_meter_mod *mm)
2116 {
2117     struct ofpbuf *msg;
2118
2119     struct ofp13_meter_mod *omm;
2120
2121     msg = ofpraw_alloc(OFPRAW_OFPT13_METER_MOD, ofp_version,
2122                        NXM_TYPICAL_LEN + mm->meter.n_bands * 16);
2123     omm = ofpbuf_put_zeros(msg, sizeof *omm);
2124     omm->command = htons(mm->command);
2125     if (mm->command != OFPMC13_DELETE) {
2126         omm->flags = htons(mm->meter.flags);
2127     }
2128     omm->meter_id = htonl(mm->meter.meter_id);
2129
2130     ofputil_put_bands(mm->meter.n_bands, mm->meter.bands, msg);
2131
2132     ofpmsg_update_length(msg);
2133     return msg;
2134 }
2135
2136 static ovs_be16
2137 ofputil_tid_command(const struct ofputil_flow_mod *fm,
2138                     enum ofputil_protocol protocol)
2139 {
2140     return htons(protocol & OFPUTIL_P_TID
2141                  ? (fm->command & 0xff) | (fm->table_id << 8)
2142                  : fm->command);
2143 }
2144
2145 /* Converts 'fm' into an OFPT_FLOW_MOD or NXT_FLOW_MOD message according to
2146  * 'protocol' and returns the message. */
2147 struct ofpbuf *
2148 ofputil_encode_flow_mod(const struct ofputil_flow_mod *fm,
2149                         enum ofputil_protocol protocol)
2150 {
2151     enum ofp_version version = ofputil_protocol_to_ofp_version(protocol);
2152     ovs_be16 raw_flags = ofputil_encode_flow_mod_flags(fm->flags, version);
2153     struct ofpbuf *msg;
2154
2155     switch (protocol) {
2156     case OFPUTIL_P_OF11_STD:
2157     case OFPUTIL_P_OF12_OXM:
2158     case OFPUTIL_P_OF13_OXM:
2159     case OFPUTIL_P_OF14_OXM:
2160     case OFPUTIL_P_OF15_OXM:
2161     case OFPUTIL_P_OF16_OXM: {
2162         struct ofp11_flow_mod *ofm;
2163         int tailroom;
2164
2165         tailroom = ofputil_match_typical_len(protocol) + fm->ofpacts_len;
2166         msg = ofpraw_alloc(OFPRAW_OFPT11_FLOW_MOD, version, tailroom);
2167         ofm = ofpbuf_put_zeros(msg, sizeof *ofm);
2168         if ((protocol == OFPUTIL_P_OF11_STD
2169              && (fm->command == OFPFC_MODIFY ||
2170                  fm->command == OFPFC_MODIFY_STRICT)
2171              && fm->cookie_mask == htonll(0))
2172             || fm->command == OFPFC_ADD) {
2173             ofm->cookie = fm->new_cookie;
2174         } else {
2175             ofm->cookie = fm->cookie & fm->cookie_mask;
2176         }
2177         ofm->cookie_mask = fm->cookie_mask;
2178         if (fm->table_id != OFPTT_ALL
2179             || (protocol != OFPUTIL_P_OF11_STD
2180                 && (fm->command == OFPFC_DELETE ||
2181                     fm->command == OFPFC_DELETE_STRICT))) {
2182             ofm->table_id = fm->table_id;
2183         } else {
2184             ofm->table_id = 0;
2185         }
2186         ofm->command = fm->command;
2187         ofm->idle_timeout = htons(fm->idle_timeout);
2188         ofm->hard_timeout = htons(fm->hard_timeout);
2189         ofm->priority = htons(fm->priority);
2190         ofm->buffer_id = htonl(fm->buffer_id);
2191         ofm->out_port = ofputil_port_to_ofp11(fm->out_port);
2192         ofm->out_group = htonl(fm->out_group);
2193         ofm->flags = raw_flags;
2194         if (version >= OFP14_VERSION && fm->command == OFPFC_ADD) {
2195             ofm->importance = htons(fm->importance);
2196         } else {
2197             ofm->importance = 0;
2198         }
2199         ofputil_put_ofp11_match(msg, &fm->match, protocol);
2200         ofpacts_put_openflow_instructions(fm->ofpacts, fm->ofpacts_len, msg,
2201                                           version);
2202         break;
2203     }
2204
2205     case OFPUTIL_P_OF10_STD:
2206     case OFPUTIL_P_OF10_STD_TID: {
2207         struct ofp10_flow_mod *ofm;
2208
2209         msg = ofpraw_alloc(OFPRAW_OFPT10_FLOW_MOD, OFP10_VERSION,
2210                            fm->ofpacts_len);
2211         ofm = ofpbuf_put_zeros(msg, sizeof *ofm);
2212         ofputil_match_to_ofp10_match(&fm->match, &ofm->match);
2213         ofm->cookie = fm->new_cookie;
2214         ofm->command = ofputil_tid_command(fm, protocol);
2215         ofm->idle_timeout = htons(fm->idle_timeout);
2216         ofm->hard_timeout = htons(fm->hard_timeout);
2217         ofm->priority = htons(fm->priority);
2218         ofm->buffer_id = htonl(fm->buffer_id);
2219         ofm->out_port = htons(ofp_to_u16(fm->out_port));
2220         ofm->flags = raw_flags;
2221         ofpacts_put_openflow_actions(fm->ofpacts, fm->ofpacts_len, msg,
2222                                      version);
2223         break;
2224     }
2225
2226     case OFPUTIL_P_OF10_NXM:
2227     case OFPUTIL_P_OF10_NXM_TID: {
2228         struct nx_flow_mod *nfm;
2229         int match_len;
2230
2231         msg = ofpraw_alloc(OFPRAW_NXT_FLOW_MOD, OFP10_VERSION,
2232                            NXM_TYPICAL_LEN + fm->ofpacts_len);
2233         nfm = ofpbuf_put_zeros(msg, sizeof *nfm);
2234         nfm->command = ofputil_tid_command(fm, protocol);
2235         nfm->cookie = fm->new_cookie;
2236         match_len = nx_put_match(msg, &fm->match, fm->cookie, fm->cookie_mask);
2237         nfm = msg->msg;
2238         nfm->idle_timeout = htons(fm->idle_timeout);
2239         nfm->hard_timeout = htons(fm->hard_timeout);
2240         nfm->priority = htons(fm->priority);
2241         nfm->buffer_id = htonl(fm->buffer_id);
2242         nfm->out_port = htons(ofp_to_u16(fm->out_port));
2243         nfm->flags = raw_flags;
2244         nfm->match_len = htons(match_len);
2245         ofpacts_put_openflow_actions(fm->ofpacts, fm->ofpacts_len, msg,
2246                                      version);
2247         break;
2248     }
2249
2250     default:
2251         OVS_NOT_REACHED();
2252     }
2253
2254     ofpmsg_update_length(msg);
2255     return msg;
2256 }
2257
2258 static enum ofperr
2259 ofputil_decode_ofpst10_flow_request(struct ofputil_flow_stats_request *fsr,
2260                                     const struct ofp10_flow_stats_request *ofsr,
2261                                     bool aggregate)
2262 {
2263     fsr->aggregate = aggregate;
2264     ofputil_match_from_ofp10_match(&ofsr->match, &fsr->match);
2265     fsr->out_port = u16_to_ofp(ntohs(ofsr->out_port));
2266     fsr->out_group = OFPG_ANY;
2267     fsr->table_id = ofsr->table_id;
2268     fsr->cookie = fsr->cookie_mask = htonll(0);
2269
2270     return 0;
2271 }
2272
2273 static enum ofperr
2274 ofputil_decode_ofpst11_flow_request(struct ofputil_flow_stats_request *fsr,
2275                                     struct ofpbuf *b, bool aggregate)
2276 {
2277     const struct ofp11_flow_stats_request *ofsr;
2278     enum ofperr error;
2279
2280     ofsr = ofpbuf_pull(b, sizeof *ofsr);
2281     fsr->aggregate = aggregate;
2282     fsr->table_id = ofsr->table_id;
2283     error = ofputil_port_from_ofp11(ofsr->out_port, &fsr->out_port);
2284     if (error) {
2285         return error;
2286     }
2287     fsr->out_group = ntohl(ofsr->out_group);
2288     fsr->cookie = ofsr->cookie;
2289     fsr->cookie_mask = ofsr->cookie_mask;
2290     error = ofputil_pull_ofp11_match(b, &fsr->match, NULL);
2291     if (error) {
2292         return error;
2293     }
2294
2295     return 0;
2296 }
2297
2298 static enum ofperr
2299 ofputil_decode_nxst_flow_request(struct ofputil_flow_stats_request *fsr,
2300                                  struct ofpbuf *b, bool aggregate)
2301 {
2302     const struct nx_flow_stats_request *nfsr;
2303     enum ofperr error;
2304
2305     nfsr = ofpbuf_pull(b, sizeof *nfsr);
2306     error = nx_pull_match(b, ntohs(nfsr->match_len), &fsr->match,
2307                           &fsr->cookie, &fsr->cookie_mask);
2308     if (error) {
2309         return error;
2310     }
2311     if (b->size) {
2312         return OFPERR_OFPBRC_BAD_LEN;
2313     }
2314
2315     fsr->aggregate = aggregate;
2316     fsr->out_port = u16_to_ofp(ntohs(nfsr->out_port));
2317     fsr->out_group = OFPG_ANY;
2318     fsr->table_id = nfsr->table_id;
2319
2320     return 0;
2321 }
2322
2323 /* Constructs and returns an OFPT_QUEUE_GET_CONFIG request for the specified
2324  * 'port' and 'queue', suitable for OpenFlow version 'version'.
2325  *
2326  * 'queue' is honored only for OpenFlow 1.4 and later; older versions always
2327  * request all queues. */
2328 struct ofpbuf *
2329 ofputil_encode_queue_get_config_request(enum ofp_version version,
2330                                         ofp_port_t port,
2331                                         uint32_t queue)
2332 {
2333     struct ofpbuf *request;
2334
2335     if (version == OFP10_VERSION) {
2336         struct ofp10_queue_get_config_request *qgcr10;
2337
2338         request = ofpraw_alloc(OFPRAW_OFPT10_QUEUE_GET_CONFIG_REQUEST,
2339                                version, 0);
2340         qgcr10 = ofpbuf_put_zeros(request, sizeof *qgcr10);
2341         qgcr10->port = htons(ofp_to_u16(port));
2342     } else if (version < OFP14_VERSION) {
2343         struct ofp11_queue_get_config_request *qgcr11;
2344
2345         request = ofpraw_alloc(OFPRAW_OFPT11_QUEUE_GET_CONFIG_REQUEST,
2346                                version, 0);
2347         qgcr11 = ofpbuf_put_zeros(request, sizeof *qgcr11);
2348         qgcr11->port = ofputil_port_to_ofp11(port);
2349     } else {
2350         struct ofp14_queue_desc_request *qdr14;
2351
2352         request = ofpraw_alloc(OFPRAW_OFPST14_QUEUE_DESC_REQUEST,
2353                                version, 0);
2354         qdr14 = ofpbuf_put_zeros(request, sizeof *qdr14);
2355         qdr14->port = ofputil_port_to_ofp11(port);
2356         qdr14->queue = htonl(queue);
2357     }
2358
2359     return request;
2360 }
2361
2362 /* Parses OFPT_QUEUE_GET_CONFIG request 'oh', storing the port specified by the
2363  * request into '*port'.  Returns 0 if successful, otherwise an OpenFlow error
2364  * code. */
2365 enum ofperr
2366 ofputil_decode_queue_get_config_request(const struct ofp_header *oh,
2367                                         ofp_port_t *port, uint32_t *queue)
2368 {
2369     const struct ofp10_queue_get_config_request *qgcr10;
2370     const struct ofp11_queue_get_config_request *qgcr11;
2371     const struct ofp14_queue_desc_request *qdr14;
2372     struct ofpbuf b = ofpbuf_const_initializer(oh, ntohs(oh->length));
2373     enum ofpraw raw = ofpraw_pull_assert(&b);
2374
2375     switch ((int) raw) {
2376     case OFPRAW_OFPT10_QUEUE_GET_CONFIG_REQUEST:
2377         qgcr10 = b.data;
2378         *port = u16_to_ofp(ntohs(qgcr10->port));
2379         *queue = OFPQ_ALL;
2380         break;
2381
2382     case OFPRAW_OFPT11_QUEUE_GET_CONFIG_REQUEST:
2383         qgcr11 = b.data;
2384         *queue = OFPQ_ALL;
2385         enum ofperr error = ofputil_port_from_ofp11(qgcr11->port, port);
2386         if (error || *port == OFPP_ANY) {
2387             return error;
2388         }
2389         break;
2390
2391     case OFPRAW_OFPST14_QUEUE_DESC_REQUEST:
2392         qdr14 = b.data;
2393         *queue = ntohl(qdr14->queue);
2394         return ofputil_port_from_ofp11(qdr14->port, port);
2395
2396     default:
2397         OVS_NOT_REACHED();
2398     }
2399
2400     return (ofp_to_u16(*port) < ofp_to_u16(OFPP_MAX)
2401             ? 0
2402             : OFPERR_OFPQOFC_BAD_PORT);
2403 }
2404
2405 /* Constructs and returns the beginning of a reply to
2406  * OFPT_QUEUE_GET_CONFIG_REQUEST or OFPMP_QUEUE_DESC request 'oh'.  The caller
2407  * may append information about individual queues with
2408  * ofputil_append_queue_get_config_reply(). */
2409 void
2410 ofputil_start_queue_get_config_reply(const struct ofp_header *request,
2411                                      struct ovs_list *replies)
2412 {
2413     struct ofpbuf *reply;
2414     enum ofperr error;
2415     ofp_port_t port;
2416     uint32_t queue;
2417
2418     error = ofputil_decode_queue_get_config_request(request, &port, &queue);
2419     ovs_assert(!error);
2420
2421     enum ofpraw raw = ofpraw_decode_assert(request);
2422     switch ((int) raw) {
2423     case OFPRAW_OFPT10_QUEUE_GET_CONFIG_REQUEST:
2424         reply = ofpraw_alloc_reply(OFPRAW_OFPT10_QUEUE_GET_CONFIG_REPLY,
2425                                    request, 0);
2426         struct ofp10_queue_get_config_reply *qgcr10
2427             = ofpbuf_put_zeros(reply, sizeof *qgcr10);
2428         qgcr10->port = htons(ofp_to_u16(port));
2429         break;
2430
2431     case OFPRAW_OFPT11_QUEUE_GET_CONFIG_REQUEST:
2432         reply = ofpraw_alloc_reply(OFPRAW_OFPT11_QUEUE_GET_CONFIG_REPLY,
2433                                    request, 0);
2434         struct ofp11_queue_get_config_reply *qgcr11
2435             = ofpbuf_put_zeros(reply, sizeof *qgcr11);
2436         qgcr11->port = ofputil_port_to_ofp11(port);
2437         break;
2438
2439     case OFPRAW_OFPST14_QUEUE_DESC_REQUEST:
2440         reply = ofpraw_alloc_stats_reply(request, 0);
2441         break;
2442
2443     default:
2444         OVS_NOT_REACHED();
2445     }
2446
2447     ovs_list_init(replies);
2448     ovs_list_push_back(replies, &reply->list_node);
2449 }
2450
2451 static void
2452 put_ofp10_queue_rate(struct ofpbuf *reply,
2453                      enum ofp10_queue_properties property, uint16_t rate)
2454 {
2455     if (rate != UINT16_MAX) {
2456         struct ofp10_queue_prop_rate *oqpr;
2457
2458         oqpr = ofpbuf_put_zeros(reply, sizeof *oqpr);
2459         oqpr->prop_header.property = htons(property);
2460         oqpr->prop_header.len = htons(sizeof *oqpr);
2461         oqpr->rate = htons(rate);
2462     }
2463 }
2464
2465 static void
2466 put_ofp14_queue_rate(struct ofpbuf *reply,
2467                      enum ofp14_queue_desc_prop_type type, uint16_t rate)
2468 {
2469     if (rate != UINT16_MAX) {
2470         ofpprop_put_u16(reply, type, rate);
2471     }
2472 }
2473
2474 void
2475 ofputil_append_queue_get_config_reply(const struct ofputil_queue_config *qc,
2476                                       struct ovs_list *replies)
2477 {
2478     enum ofp_version ofp_version = ofpmp_version(replies);
2479     struct ofpbuf *reply = ofpbuf_from_list(ovs_list_back(replies));
2480     size_t start_ofs = reply->size;
2481     size_t len_ofs;
2482     ovs_be16 *len;
2483
2484     if (ofp_version < OFP14_VERSION) {
2485         if (ofp_version < OFP12_VERSION) {
2486             struct ofp10_packet_queue *opq10;
2487
2488             opq10 = ofpbuf_put_zeros(reply, sizeof *opq10);
2489             opq10->queue_id = htonl(qc->queue);
2490             len_ofs = (char *) &opq10->len - (char *) reply->data;
2491         } else {
2492             struct ofp12_packet_queue *opq12;
2493
2494             opq12 = ofpbuf_put_zeros(reply, sizeof *opq12);
2495             opq12->port = ofputil_port_to_ofp11(qc->port);
2496             opq12->queue_id = htonl(qc->queue);
2497             len_ofs = (char *) &opq12->len - (char *) reply->data;
2498         }
2499
2500         put_ofp10_queue_rate(reply, OFPQT10_MIN_RATE, qc->min_rate);
2501         put_ofp10_queue_rate(reply, OFPQT11_MAX_RATE, qc->max_rate);
2502     } else {
2503         struct ofp14_queue_desc *oqd = ofpbuf_put_zeros(reply, sizeof *oqd);
2504         oqd->port_no = ofputil_port_to_ofp11(qc->port);
2505         oqd->queue_id = htonl(qc->queue);
2506         len_ofs = (char *) &oqd->len - (char *) reply->data;
2507         put_ofp14_queue_rate(reply, OFPQDPT14_MIN_RATE, qc->min_rate);
2508         put_ofp14_queue_rate(reply, OFPQDPT14_MAX_RATE, qc->max_rate);
2509     }
2510
2511     len = ofpbuf_at(reply, len_ofs, sizeof *len);
2512     *len = htons(reply->size - start_ofs);
2513
2514     if (ofp_version >= OFP14_VERSION) {
2515         ofpmp_postappend(replies, start_ofs);
2516     }
2517 }
2518
2519 static enum ofperr
2520 parse_ofp10_queue_rate(const struct ofp10_queue_prop_header *hdr,
2521                        uint16_t *rate)
2522 {
2523     const struct ofp10_queue_prop_rate *oqpr;
2524
2525     if (hdr->len == htons(sizeof *oqpr)) {
2526         oqpr = (const struct ofp10_queue_prop_rate *) hdr;
2527         *rate = ntohs(oqpr->rate);
2528         return 0;
2529     } else {
2530         return OFPERR_OFPBRC_BAD_LEN;
2531     }
2532 }
2533
2534 static int
2535 ofputil_pull_queue_get_config_reply10(struct ofpbuf *msg,
2536                                       struct ofputil_queue_config *queue)
2537 {
2538     const struct ofp_header *oh = msg->header;
2539     unsigned int opq_len;       /* Length of protocol-specific queue header. */
2540     unsigned int len;           /* Total length of queue + properties. */
2541
2542     /* Obtain the port number from the message header. */
2543     if (oh->version == OFP10_VERSION) {
2544         const struct ofp10_queue_get_config_reply *oqgcr10 = msg->msg;
2545         queue->port = u16_to_ofp(ntohs(oqgcr10->port));
2546     } else {
2547         const struct ofp11_queue_get_config_reply *oqgcr11 = msg->msg;
2548         enum ofperr error = ofputil_port_from_ofp11(oqgcr11->port,
2549                                                     &queue->port);
2550         if (error) {
2551             return error;
2552         }
2553     }
2554
2555     /* Pull off the queue header and get the queue number and length. */
2556     if (oh->version < OFP12_VERSION) {
2557         const struct ofp10_packet_queue *opq10;
2558         opq10 = ofpbuf_try_pull(msg, sizeof *opq10);
2559         if (!opq10) {
2560             return OFPERR_OFPBRC_BAD_LEN;
2561         }
2562         queue->queue = ntohl(opq10->queue_id);
2563         len = ntohs(opq10->len);
2564         opq_len = sizeof *opq10;
2565     } else {
2566         const struct ofp12_packet_queue *opq12;
2567         opq12 = ofpbuf_try_pull(msg, sizeof *opq12);
2568         if (!opq12) {
2569             return OFPERR_OFPBRC_BAD_LEN;
2570         }
2571         queue->queue = ntohl(opq12->queue_id);
2572         len = ntohs(opq12->len);
2573         opq_len = sizeof *opq12;
2574     }
2575
2576     /* Length check. */
2577     if (len < opq_len || len > msg->size + opq_len || len % 8) {
2578         return OFPERR_OFPBRC_BAD_LEN;
2579     }
2580     len -= opq_len;
2581
2582     /* Pull properties.  The format of these properties differs from used in
2583      * OF1.4+ so we can't use the common property functions. */
2584     while (len > 0) {
2585         const struct ofp10_queue_prop_header *hdr;
2586         unsigned int property;
2587         unsigned int prop_len;
2588         enum ofperr error = 0;
2589
2590         hdr = ofpbuf_at_assert(msg, 0, sizeof *hdr);
2591         prop_len = ntohs(hdr->len);
2592         if (prop_len < sizeof *hdr || prop_len > msg->size || prop_len % 8) {
2593             return OFPERR_OFPBRC_BAD_LEN;
2594         }
2595
2596         property = ntohs(hdr->property);
2597         switch (property) {
2598         case OFPQT10_MIN_RATE:
2599             error = parse_ofp10_queue_rate(hdr, &queue->min_rate);
2600             break;
2601
2602         case OFPQT11_MAX_RATE:
2603             error = parse_ofp10_queue_rate(hdr, &queue->max_rate);
2604             break;
2605
2606         default:
2607             VLOG_INFO_RL(&bad_ofmsg_rl, "unknown queue property %u", property);
2608             break;
2609         }
2610         if (error) {
2611             return error;
2612         }
2613
2614         ofpbuf_pull(msg, prop_len);
2615         len -= prop_len;
2616     }
2617     return 0;
2618 }
2619
2620 static int
2621 ofputil_pull_queue_get_config_reply14(struct ofpbuf *msg,
2622                                       struct ofputil_queue_config *queue)
2623 {
2624     struct ofp14_queue_desc *oqd14 = ofpbuf_try_pull(msg, sizeof *oqd14);
2625     if (!oqd14) {
2626         return OFPERR_OFPBRC_BAD_LEN;
2627     }
2628     enum ofperr error = ofputil_port_from_ofp11(oqd14->port_no, &queue->port);
2629     if (error) {
2630         return error;
2631     }
2632     queue->queue = ntohl(oqd14->queue_id);
2633
2634     /* Length check. */
2635     unsigned int len = ntohs(oqd14->len);
2636     if (len < sizeof *oqd14 || len > msg->size + sizeof *oqd14 || len % 8) {
2637         return OFPERR_OFPBRC_BAD_LEN;
2638     }
2639     len -= sizeof *oqd14;
2640
2641     struct ofpbuf properties = ofpbuf_const_initializer(ofpbuf_pull(msg, len),
2642                                                         len);
2643     while (properties.size > 0) {
2644         struct ofpbuf payload;
2645         uint64_t type;
2646
2647         error = ofpprop_pull(&properties, &payload, &type);
2648         if (error) {
2649             return error;
2650         }
2651
2652         switch (type) {
2653         case OFPQDPT14_MIN_RATE:
2654             error = ofpprop_parse_u16(&payload, &queue->min_rate);
2655             break;
2656
2657         case OFPQDPT14_MAX_RATE:
2658             error = ofpprop_parse_u16(&payload, &queue->max_rate);
2659             break;
2660
2661         default:
2662             error = OFPPROP_UNKNOWN(true, "queue desc", type);
2663             break;
2664         }
2665
2666         if (error) {
2667             return error;
2668         }
2669     }
2670
2671     return 0;
2672 }
2673
2674 /* Decodes information about a queue from the OFPT_QUEUE_GET_CONFIG_REPLY in
2675  * 'reply' and stores it in '*queue'.  ofputil_decode_queue_get_config_reply()
2676  * must already have pulled off the main header.
2677  *
2678  * This function returns EOF if the last queue has already been decoded, 0 if a
2679  * queue was successfully decoded into '*queue', or an ofperr if there was a
2680  * problem decoding 'reply'. */
2681 int
2682 ofputil_pull_queue_get_config_reply(struct ofpbuf *msg,
2683                                     struct ofputil_queue_config *queue)
2684 {
2685     enum ofpraw raw;
2686     if (!msg->header) {
2687         /* Pull OpenFlow header. */
2688         raw = ofpraw_pull_assert(msg);
2689
2690         /* Pull protocol-specific ofp_queue_get_config_reply header (OF1.4
2691          * doesn't have one at all). */
2692         if (raw == OFPRAW_OFPT10_QUEUE_GET_CONFIG_REPLY) {
2693             ofpbuf_pull(msg, sizeof(struct ofp10_queue_get_config_reply));
2694         } else if (raw == OFPRAW_OFPT11_QUEUE_GET_CONFIG_REPLY) {
2695             ofpbuf_pull(msg, sizeof(struct ofp11_queue_get_config_reply));
2696         } else {
2697             ovs_assert(raw == OFPRAW_OFPST14_QUEUE_DESC_REPLY);
2698         }
2699     } else {
2700         raw = ofpraw_decode_assert(msg->header);
2701     }
2702
2703     queue->min_rate = UINT16_MAX;
2704     queue->max_rate = UINT16_MAX;
2705
2706     if (!msg->size) {
2707         return EOF;
2708     } else if (raw == OFPRAW_OFPST14_QUEUE_DESC_REPLY) {
2709         return ofputil_pull_queue_get_config_reply14(msg, queue);
2710     } else {
2711         return ofputil_pull_queue_get_config_reply10(msg, queue);
2712     }
2713 }
2714
2715 /* Converts an OFPST_FLOW, OFPST_AGGREGATE, NXST_FLOW, or NXST_AGGREGATE
2716  * request 'oh', into an abstract flow_stats_request in 'fsr'.  Returns 0 if
2717  * successful, otherwise an OpenFlow error code. */
2718 enum ofperr
2719 ofputil_decode_flow_stats_request(struct ofputil_flow_stats_request *fsr,
2720                                   const struct ofp_header *oh)
2721 {
2722     struct ofpbuf b = ofpbuf_const_initializer(oh, ntohs(oh->length));
2723     enum ofpraw raw = ofpraw_pull_assert(&b);
2724     switch ((int) raw) {
2725     case OFPRAW_OFPST10_FLOW_REQUEST:
2726         return ofputil_decode_ofpst10_flow_request(fsr, b.data, false);
2727
2728     case OFPRAW_OFPST10_AGGREGATE_REQUEST:
2729         return ofputil_decode_ofpst10_flow_request(fsr, b.data, true);
2730
2731     case OFPRAW_OFPST11_FLOW_REQUEST:
2732         return ofputil_decode_ofpst11_flow_request(fsr, &b, false);
2733
2734     case OFPRAW_OFPST11_AGGREGATE_REQUEST:
2735         return ofputil_decode_ofpst11_flow_request(fsr, &b, true);
2736
2737     case OFPRAW_NXST_FLOW_REQUEST:
2738         return ofputil_decode_nxst_flow_request(fsr, &b, false);
2739
2740     case OFPRAW_NXST_AGGREGATE_REQUEST:
2741         return ofputil_decode_nxst_flow_request(fsr, &b, true);
2742
2743     default:
2744         /* Hey, the caller lied. */
2745         OVS_NOT_REACHED();
2746     }
2747 }
2748
2749 /* Converts abstract flow_stats_request 'fsr' into an OFPST_FLOW,
2750  * OFPST_AGGREGATE, NXST_FLOW, or NXST_AGGREGATE request 'oh' according to
2751  * 'protocol', and returns the message. */
2752 struct ofpbuf *
2753 ofputil_encode_flow_stats_request(const struct ofputil_flow_stats_request *fsr,
2754                                   enum ofputil_protocol protocol)
2755 {
2756     struct ofpbuf *msg;
2757     enum ofpraw raw;
2758
2759     switch (protocol) {
2760     case OFPUTIL_P_OF11_STD:
2761     case OFPUTIL_P_OF12_OXM:
2762     case OFPUTIL_P_OF13_OXM:
2763     case OFPUTIL_P_OF14_OXM:
2764     case OFPUTIL_P_OF15_OXM:
2765     case OFPUTIL_P_OF16_OXM: {
2766         struct ofp11_flow_stats_request *ofsr;
2767
2768         raw = (fsr->aggregate
2769                ? OFPRAW_OFPST11_AGGREGATE_REQUEST
2770                : OFPRAW_OFPST11_FLOW_REQUEST);
2771         msg = ofpraw_alloc(raw, ofputil_protocol_to_ofp_version(protocol),
2772                            ofputil_match_typical_len(protocol));
2773         ofsr = ofpbuf_put_zeros(msg, sizeof *ofsr);
2774         ofsr->table_id = fsr->table_id;
2775         ofsr->out_port = ofputil_port_to_ofp11(fsr->out_port);
2776         ofsr->out_group = htonl(fsr->out_group);
2777         ofsr->cookie = fsr->cookie;
2778         ofsr->cookie_mask = fsr->cookie_mask;
2779         ofputil_put_ofp11_match(msg, &fsr->match, protocol);
2780         break;
2781     }
2782
2783     case OFPUTIL_P_OF10_STD:
2784     case OFPUTIL_P_OF10_STD_TID: {
2785         struct ofp10_flow_stats_request *ofsr;
2786
2787         raw = (fsr->aggregate
2788                ? OFPRAW_OFPST10_AGGREGATE_REQUEST
2789                : OFPRAW_OFPST10_FLOW_REQUEST);
2790         msg = ofpraw_alloc(raw, OFP10_VERSION, 0);
2791         ofsr = ofpbuf_put_zeros(msg, sizeof *ofsr);
2792         ofputil_match_to_ofp10_match(&fsr->match, &ofsr->match);
2793         ofsr->table_id = fsr->table_id;
2794         ofsr->out_port = htons(ofp_to_u16(fsr->out_port));
2795         break;
2796     }
2797
2798     case OFPUTIL_P_OF10_NXM:
2799     case OFPUTIL_P_OF10_NXM_TID: {
2800         struct nx_flow_stats_request *nfsr;
2801         int match_len;
2802
2803         raw = (fsr->aggregate
2804                ? OFPRAW_NXST_AGGREGATE_REQUEST
2805                : OFPRAW_NXST_FLOW_REQUEST);
2806         msg = ofpraw_alloc(raw, OFP10_VERSION, NXM_TYPICAL_LEN);
2807         ofpbuf_put_zeros(msg, sizeof *nfsr);
2808         match_len = nx_put_match(msg, &fsr->match,
2809                                  fsr->cookie, fsr->cookie_mask);
2810
2811         nfsr = msg->msg;
2812         nfsr->out_port = htons(ofp_to_u16(fsr->out_port));
2813         nfsr->match_len = htons(match_len);
2814         nfsr->table_id = fsr->table_id;
2815         break;
2816     }
2817
2818     default:
2819         OVS_NOT_REACHED();
2820     }
2821
2822     return msg;
2823 }
2824
2825 /* Converts an OFPST_FLOW or NXST_FLOW reply in 'msg' into an abstract
2826  * ofputil_flow_stats in 'fs'.
2827  *
2828  * Multiple OFPST_FLOW or NXST_FLOW replies can be packed into a single
2829  * OpenFlow message.  Calling this function multiple times for a single 'msg'
2830  * iterates through the replies.  The caller must initially leave 'msg''s layer
2831  * pointers null and not modify them between calls.
2832  *
2833  * Most switches don't send the values needed to populate fs->idle_age and
2834  * fs->hard_age, so those members will usually be set to 0.  If the switch from
2835  * which 'msg' originated is known to implement NXT_FLOW_AGE, then pass
2836  * 'flow_age_extension' as true so that the contents of 'msg' determine the
2837  * 'idle_age' and 'hard_age' members in 'fs'.
2838  *
2839  * Uses 'ofpacts' to store the abstract OFPACT_* version of the flow stats
2840  * reply's actions.  The caller must initialize 'ofpacts' and retains ownership
2841  * of it.  'fs->ofpacts' will point into the 'ofpacts' buffer.
2842  *
2843  * Returns 0 if successful, EOF if no replies were left in this 'msg',
2844  * otherwise a positive errno value. */
2845 int
2846 ofputil_decode_flow_stats_reply(struct ofputil_flow_stats *fs,
2847                                 struct ofpbuf *msg,
2848                                 bool flow_age_extension,
2849                                 struct ofpbuf *ofpacts)
2850 {
2851     const struct ofp_header *oh;
2852     size_t instructions_len;
2853     enum ofperr error;
2854     enum ofpraw raw;
2855
2856     error = (msg->header ? ofpraw_decode(&raw, msg->header)
2857              : ofpraw_pull(&raw, msg));
2858     if (error) {
2859         return error;
2860     }
2861     oh = msg->header;
2862
2863     if (!msg->size) {
2864         return EOF;
2865     } else if (raw == OFPRAW_OFPST11_FLOW_REPLY
2866                || raw == OFPRAW_OFPST13_FLOW_REPLY) {
2867         const struct ofp11_flow_stats *ofs;
2868         size_t length;
2869         uint16_t padded_match_len;
2870
2871         ofs = ofpbuf_try_pull(msg, sizeof *ofs);
2872         if (!ofs) {
2873             VLOG_WARN_RL(&bad_ofmsg_rl, "OFPST_FLOW reply has %"PRIu32" leftover "
2874                          "bytes at end", msg->size);
2875             return EINVAL;
2876         }
2877
2878         length = ntohs(ofs->length);
2879         if (length < sizeof *ofs) {
2880             VLOG_WARN_RL(&bad_ofmsg_rl, "OFPST_FLOW reply claims invalid "
2881                          "length %"PRIuSIZE, length);
2882             return EINVAL;
2883         }
2884
2885         if (ofputil_pull_ofp11_match(msg, &fs->match, &padded_match_len)) {
2886             VLOG_WARN_RL(&bad_ofmsg_rl, "OFPST_FLOW reply bad match");
2887             return EINVAL;
2888         }
2889         instructions_len = length - sizeof *ofs - padded_match_len;
2890
2891         fs->priority = ntohs(ofs->priority);
2892         fs->table_id = ofs->table_id;
2893         fs->duration_sec = ntohl(ofs->duration_sec);
2894         fs->duration_nsec = ntohl(ofs->duration_nsec);
2895         fs->idle_timeout = ntohs(ofs->idle_timeout);
2896         fs->hard_timeout = ntohs(ofs->hard_timeout);
2897         if (oh->version >= OFP14_VERSION) {
2898             fs->importance = ntohs(ofs->importance);
2899         } else {
2900             fs->importance = 0;
2901         }
2902         if (raw == OFPRAW_OFPST13_FLOW_REPLY) {
2903             error = ofputil_decode_flow_mod_flags(ofs->flags, -1, oh->version,
2904                                                   &fs->flags);
2905             if (error) {
2906                 return error;
2907             }
2908         } else {
2909             fs->flags = 0;
2910         }
2911         fs->idle_age = -1;
2912         fs->hard_age = -1;
2913         fs->cookie = ofs->cookie;
2914         fs->packet_count = ntohll(ofs->packet_count);
2915         fs->byte_count = ntohll(ofs->byte_count);
2916     } else if (raw == OFPRAW_OFPST10_FLOW_REPLY) {
2917         const struct ofp10_flow_stats *ofs;
2918         size_t length;
2919
2920         ofs = ofpbuf_try_pull(msg, sizeof *ofs);
2921         if (!ofs) {
2922             VLOG_WARN_RL(&bad_ofmsg_rl, "OFPST_FLOW reply has %"PRIu32" leftover "
2923                          "bytes at end", msg->size);
2924             return EINVAL;
2925         }
2926
2927         length = ntohs(ofs->length);
2928         if (length < sizeof *ofs) {
2929             VLOG_WARN_RL(&bad_ofmsg_rl, "OFPST_FLOW reply claims invalid "
2930                          "length %"PRIuSIZE, length);
2931             return EINVAL;
2932         }
2933         instructions_len = length - sizeof *ofs;
2934
2935         fs->cookie = get_32aligned_be64(&ofs->cookie);
2936         ofputil_match_from_ofp10_match(&ofs->match, &fs->match);
2937         fs->priority = ntohs(ofs->priority);
2938         fs->table_id = ofs->table_id;
2939         fs->duration_sec = ntohl(ofs->duration_sec);
2940         fs->duration_nsec = ntohl(ofs->duration_nsec);
2941         fs->idle_timeout = ntohs(ofs->idle_timeout);
2942         fs->hard_timeout = ntohs(ofs->hard_timeout);
2943         fs->importance = 0;
2944         fs->idle_age = -1;
2945         fs->hard_age = -1;
2946         fs->packet_count = ntohll(get_32aligned_be64(&ofs->packet_count));
2947         fs->byte_count = ntohll(get_32aligned_be64(&ofs->byte_count));
2948         fs->flags = 0;
2949     } else if (raw == OFPRAW_NXST_FLOW_REPLY) {
2950         const struct nx_flow_stats *nfs;
2951         size_t match_len, length;
2952
2953         nfs = ofpbuf_try_pull(msg, sizeof *nfs);
2954         if (!nfs) {
2955             VLOG_WARN_RL(&bad_ofmsg_rl, "NXST_FLOW reply has %"PRIu32" leftover "
2956                          "bytes at end", msg->size);
2957             return EINVAL;
2958         }
2959
2960         length = ntohs(nfs->length);
2961         match_len = ntohs(nfs->match_len);
2962         if (length < sizeof *nfs + ROUND_UP(match_len, 8)) {
2963             VLOG_WARN_RL(&bad_ofmsg_rl, "NXST_FLOW reply with match_len=%"PRIuSIZE" "
2964                          "claims invalid length %"PRIuSIZE, match_len, length);
2965             return EINVAL;
2966         }
2967         if (nx_pull_match(msg, match_len, &fs->match, NULL, NULL)) {
2968             return EINVAL;
2969         }
2970         instructions_len = length - sizeof *nfs - ROUND_UP(match_len, 8);
2971
2972         fs->cookie = nfs->cookie;
2973         fs->table_id = nfs->table_id;
2974         fs->duration_sec = ntohl(nfs->duration_sec);
2975         fs->duration_nsec = ntohl(nfs->duration_nsec);
2976         fs->priority = ntohs(nfs->priority);
2977         fs->idle_timeout = ntohs(nfs->idle_timeout);
2978         fs->hard_timeout = ntohs(nfs->hard_timeout);
2979         fs->importance = 0;
2980         fs->idle_age = -1;
2981         fs->hard_age = -1;
2982         if (flow_age_extension) {
2983             if (nfs->idle_age) {
2984                 fs->idle_age = ntohs(nfs->idle_age) - 1;
2985             }
2986             if (nfs->hard_age) {
2987                 fs->hard_age = ntohs(nfs->hard_age) - 1;
2988             }
2989         }
2990         fs->packet_count = ntohll(nfs->packet_count);
2991         fs->byte_count = ntohll(nfs->byte_count);
2992         fs->flags = 0;
2993     } else {
2994         OVS_NOT_REACHED();
2995     }
2996
2997     if (ofpacts_pull_openflow_instructions(msg, instructions_len, oh->version,
2998                                            ofpacts)) {
2999         VLOG_WARN_RL(&bad_ofmsg_rl, "OFPST_FLOW reply bad instructions");
3000         return EINVAL;
3001     }
3002     fs->ofpacts = ofpacts->data;
3003     fs->ofpacts_len = ofpacts->size;
3004
3005     return 0;
3006 }
3007
3008 /* Returns 'count' unchanged except that UINT64_MAX becomes 0.
3009  *
3010  * We use this in situations where OVS internally uses UINT64_MAX to mean
3011  * "value unknown" but OpenFlow 1.0 does not define any unknown value. */
3012 static uint64_t
3013 unknown_to_zero(uint64_t count)
3014 {
3015     return count != UINT64_MAX ? count : 0;
3016 }
3017
3018 /* Appends an OFPST_FLOW or NXST_FLOW reply that contains the data in 'fs' to
3019  * those already present in the list of ofpbufs in 'replies'.  'replies' should
3020  * have been initialized with ofpmp_init(). */
3021 void
3022 ofputil_append_flow_stats_reply(const struct ofputil_flow_stats *fs,
3023                                 struct ovs_list *replies)
3024 {
3025     struct ofpbuf *reply = ofpbuf_from_list(ovs_list_back(replies));
3026     size_t start_ofs = reply->size;
3027     enum ofp_version version = ofpmp_version(replies);
3028     enum ofpraw raw = ofpmp_decode_raw(replies);
3029
3030     if (raw == OFPRAW_OFPST11_FLOW_REPLY || raw == OFPRAW_OFPST13_FLOW_REPLY) {
3031         struct ofp11_flow_stats *ofs;
3032
3033         ofpbuf_put_uninit(reply, sizeof *ofs);
3034         oxm_put_match(reply, &fs->match, version);
3035         ofpacts_put_openflow_instructions(fs->ofpacts, fs->ofpacts_len, reply,
3036                                           version);
3037
3038         ofs = ofpbuf_at_assert(reply, start_ofs, sizeof *ofs);
3039         ofs->length = htons(reply->size - start_ofs);
3040         ofs->table_id = fs->table_id;
3041         ofs->pad = 0;
3042         ofs->duration_sec = htonl(fs->duration_sec);
3043         ofs->duration_nsec = htonl(fs->duration_nsec);
3044         ofs->priority = htons(fs->priority);
3045         ofs->idle_timeout = htons(fs->idle_timeout);
3046         ofs->hard_timeout = htons(fs->hard_timeout);
3047         if (version >= OFP14_VERSION) {
3048             ofs->importance = htons(fs->importance);
3049         } else {
3050             ofs->importance = 0;
3051         }
3052         if (raw == OFPRAW_OFPST13_FLOW_REPLY) {
3053             ofs->flags = ofputil_encode_flow_mod_flags(fs->flags, version);
3054         } else {
3055             ofs->flags = 0;
3056         }
3057         memset(ofs->pad2, 0, sizeof ofs->pad2);
3058         ofs->cookie = fs->cookie;
3059         ofs->packet_count = htonll(unknown_to_zero(fs->packet_count));
3060         ofs->byte_count = htonll(unknown_to_zero(fs->byte_count));
3061     } else if (raw == OFPRAW_OFPST10_FLOW_REPLY) {
3062         struct ofp10_flow_stats *ofs;
3063
3064         ofpbuf_put_uninit(reply, sizeof *ofs);
3065         ofpacts_put_openflow_actions(fs->ofpacts, fs->ofpacts_len, reply,
3066                                      version);
3067         ofs = ofpbuf_at_assert(reply, start_ofs, sizeof *ofs);
3068         ofs->length = htons(reply->size - start_ofs);
3069         ofs->table_id = fs->table_id;
3070         ofs->pad = 0;
3071         ofputil_match_to_ofp10_match(&fs->match, &ofs->match);
3072         ofs->duration_sec = htonl(fs->duration_sec);
3073         ofs->duration_nsec = htonl(fs->duration_nsec);
3074         ofs->priority = htons(fs->priority);
3075         ofs->idle_timeout = htons(fs->idle_timeout);
3076         ofs->hard_timeout = htons(fs->hard_timeout);
3077         memset(ofs->pad2, 0, sizeof ofs->pad2);
3078         put_32aligned_be64(&ofs->cookie, fs->cookie);
3079         put_32aligned_be64(&ofs->packet_count,
3080                            htonll(unknown_to_zero(fs->packet_count)));
3081         put_32aligned_be64(&ofs->byte_count,
3082                            htonll(unknown_to_zero(fs->byte_count)));
3083     } else if (raw == OFPRAW_NXST_FLOW_REPLY) {
3084         struct nx_flow_stats *nfs;
3085         int match_len;
3086
3087         ofpbuf_put_uninit(reply, sizeof *nfs);
3088         match_len = nx_put_match(reply, &fs->match, 0, 0);
3089         ofpacts_put_openflow_actions(fs->ofpacts, fs->ofpacts_len, reply,
3090                                      version);
3091         nfs = ofpbuf_at_assert(reply, start_ofs, sizeof *nfs);
3092         nfs->length = htons(reply->size - start_ofs);
3093         nfs->table_id = fs->table_id;
3094         nfs->pad = 0;
3095         nfs->duration_sec = htonl(fs->duration_sec);
3096         nfs->duration_nsec = htonl(fs->duration_nsec);
3097         nfs->priority = htons(fs->priority);
3098         nfs->idle_timeout = htons(fs->idle_timeout);
3099         nfs->hard_timeout = htons(fs->hard_timeout);
3100         nfs->idle_age = htons(fs->idle_age < 0 ? 0
3101                               : fs->idle_age < UINT16_MAX ? fs->idle_age + 1
3102                               : UINT16_MAX);
3103         nfs->hard_age = htons(fs->hard_age < 0 ? 0
3104                               : fs->hard_age < UINT16_MAX ? fs->hard_age + 1
3105                               : UINT16_MAX);
3106         nfs->match_len = htons(match_len);
3107         nfs->cookie = fs->cookie;
3108         nfs->packet_count = htonll(fs->packet_count);
3109         nfs->byte_count = htonll(fs->byte_count);
3110     } else {
3111         OVS_NOT_REACHED();
3112     }
3113
3114     ofpmp_postappend(replies, start_ofs);
3115 }
3116
3117 /* Converts abstract ofputil_aggregate_stats 'stats' into an OFPST_AGGREGATE or
3118  * NXST_AGGREGATE reply matching 'request', and returns the message. */
3119 struct ofpbuf *
3120 ofputil_encode_aggregate_stats_reply(
3121     const struct ofputil_aggregate_stats *stats,
3122     const struct ofp_header *request)
3123 {
3124     struct ofp_aggregate_stats_reply *asr;
3125     uint64_t packet_count;
3126     uint64_t byte_count;
3127     struct ofpbuf *msg;
3128     enum ofpraw raw;
3129
3130     ofpraw_decode(&raw, request);
3131     if (raw == OFPRAW_OFPST10_AGGREGATE_REQUEST) {
3132         packet_count = unknown_to_zero(stats->packet_count);
3133         byte_count = unknown_to_zero(stats->byte_count);
3134     } else {
3135         packet_count = stats->packet_count;
3136         byte_count = stats->byte_count;
3137     }
3138
3139     msg = ofpraw_alloc_stats_reply(request, 0);
3140     asr = ofpbuf_put_zeros(msg, sizeof *asr);
3141     put_32aligned_be64(&asr->packet_count, htonll(packet_count));
3142     put_32aligned_be64(&asr->byte_count, htonll(byte_count));
3143     asr->flow_count = htonl(stats->flow_count);
3144
3145     return msg;
3146 }
3147
3148 enum ofperr
3149 ofputil_decode_aggregate_stats_reply(struct ofputil_aggregate_stats *stats,
3150                                      const struct ofp_header *reply)
3151 {
3152     struct ofpbuf msg = ofpbuf_const_initializer(reply, ntohs(reply->length));
3153     ofpraw_pull_assert(&msg);
3154
3155     struct ofp_aggregate_stats_reply *asr = msg.msg;
3156     stats->packet_count = ntohll(get_32aligned_be64(&asr->packet_count));
3157     stats->byte_count = ntohll(get_32aligned_be64(&asr->byte_count));
3158     stats->flow_count = ntohl(asr->flow_count);
3159
3160     return 0;
3161 }
3162
3163 /* Converts an OFPT_FLOW_REMOVED or NXT_FLOW_REMOVED message 'oh' into an
3164  * abstract ofputil_flow_removed in 'fr'.  Returns 0 if successful, otherwise
3165  * an OpenFlow error code. */
3166 enum ofperr
3167 ofputil_decode_flow_removed(struct ofputil_flow_removed *fr,
3168                             const struct ofp_header *oh)
3169 {
3170     struct ofpbuf b = ofpbuf_const_initializer(oh, ntohs(oh->length));
3171     enum ofpraw raw = ofpraw_pull_assert(&b);
3172     if (raw == OFPRAW_OFPT11_FLOW_REMOVED) {
3173         const struct ofp12_flow_removed *ofr;
3174         enum ofperr error;
3175
3176         ofr = ofpbuf_pull(&b, sizeof *ofr);
3177
3178         error = ofputil_pull_ofp11_match(&b, &fr->match, NULL);
3179         if (error) {
3180             return error;
3181         }
3182
3183         fr->priority = ntohs(ofr->priority);
3184         fr->cookie = ofr->cookie;
3185         fr->reason = ofr->reason;
3186         fr->table_id = ofr->table_id;
3187         fr->duration_sec = ntohl(ofr->duration_sec);
3188         fr->duration_nsec = ntohl(ofr->duration_nsec);
3189         fr->idle_timeout = ntohs(ofr->idle_timeout);
3190         fr->hard_timeout = ntohs(ofr->hard_timeout);
3191         fr->packet_count = ntohll(ofr->packet_count);
3192         fr->byte_count = ntohll(ofr->byte_count);
3193     } else if (raw == OFPRAW_OFPT10_FLOW_REMOVED) {
3194         const struct ofp10_flow_removed *ofr;
3195
3196         ofr = ofpbuf_pull(&b, sizeof *ofr);
3197
3198         ofputil_match_from_ofp10_match(&ofr->match, &fr->match);
3199         fr->priority = ntohs(ofr->priority);
3200         fr->cookie = ofr->cookie;
3201         fr->reason = ofr->reason;
3202         fr->table_id = 255;
3203         fr->duration_sec = ntohl(ofr->duration_sec);
3204         fr->duration_nsec = ntohl(ofr->duration_nsec);
3205         fr->idle_timeout = ntohs(ofr->idle_timeout);
3206         fr->hard_timeout = 0;
3207         fr->packet_count = ntohll(ofr->packet_count);
3208         fr->byte_count = ntohll(ofr->byte_count);
3209     } else if (raw == OFPRAW_NXT_FLOW_REMOVED) {
3210         struct nx_flow_removed *nfr;
3211         enum ofperr error;
3212
3213         nfr = ofpbuf_pull(&b, sizeof *nfr);
3214         error = nx_pull_match(&b, ntohs(nfr->match_len), &fr->match,
3215                               NULL, NULL);
3216         if (error) {
3217             return error;
3218         }
3219         if (b.size) {
3220             return OFPERR_OFPBRC_BAD_LEN;
3221         }
3222
3223         fr->priority = ntohs(nfr->priority);
3224         fr->cookie = nfr->cookie;
3225         fr->reason = nfr->reason;
3226         fr->table_id = nfr->table_id ? nfr->table_id - 1 : 255;
3227         fr->duration_sec = ntohl(nfr->duration_sec);
3228         fr->duration_nsec = ntohl(nfr->duration_nsec);
3229         fr->idle_timeout = ntohs(nfr->idle_timeout);
3230         fr->hard_timeout = 0;
3231         fr->packet_count = ntohll(nfr->packet_count);
3232         fr->byte_count = ntohll(nfr->byte_count);
3233     } else {
3234         OVS_NOT_REACHED();
3235     }
3236
3237     return 0;
3238 }
3239
3240 /* Converts abstract ofputil_flow_removed 'fr' into an OFPT_FLOW_REMOVED or
3241  * NXT_FLOW_REMOVED message 'oh' according to 'protocol', and returns the
3242  * message. */
3243 struct ofpbuf *
3244 ofputil_encode_flow_removed(const struct ofputil_flow_removed *fr,
3245                             enum ofputil_protocol protocol)
3246 {
3247     struct ofpbuf *msg;
3248     enum ofp_flow_removed_reason reason = fr->reason;
3249
3250     if (reason == OFPRR_METER_DELETE && !(protocol & OFPUTIL_P_OF14_UP)) {
3251         reason = OFPRR_DELETE;
3252     }
3253
3254     switch (protocol) {
3255     case OFPUTIL_P_OF11_STD:
3256     case OFPUTIL_P_OF12_OXM:
3257     case OFPUTIL_P_OF13_OXM:
3258     case OFPUTIL_P_OF14_OXM:
3259     case OFPUTIL_P_OF15_OXM:
3260     case OFPUTIL_P_OF16_OXM: {
3261         struct ofp12_flow_removed *ofr;
3262
3263         msg = ofpraw_alloc_xid(OFPRAW_OFPT11_FLOW_REMOVED,
3264                                ofputil_protocol_to_ofp_version(protocol),
3265                                htonl(0),
3266                                ofputil_match_typical_len(protocol));
3267         ofr = ofpbuf_put_zeros(msg, sizeof *ofr);
3268         ofr->cookie = fr->cookie;
3269         ofr->priority = htons(fr->priority);
3270         ofr->reason = reason;
3271         ofr->table_id = fr->table_id;
3272         ofr->duration_sec = htonl(fr->duration_sec);
3273         ofr->duration_nsec = htonl(fr->duration_nsec);
3274         ofr->idle_timeout = htons(fr->idle_timeout);
3275         ofr->hard_timeout = htons(fr->hard_timeout);
3276         ofr->packet_count = htonll(fr->packet_count);
3277         ofr->byte_count = htonll(fr->byte_count);
3278         ofputil_put_ofp11_match(msg, &fr->match, protocol);
3279         break;
3280     }
3281
3282     case OFPUTIL_P_OF10_STD:
3283     case OFPUTIL_P_OF10_STD_TID: {
3284         struct ofp10_flow_removed *ofr;
3285
3286         msg = ofpraw_alloc_xid(OFPRAW_OFPT10_FLOW_REMOVED, OFP10_VERSION,
3287                                htonl(0), 0);
3288         ofr = ofpbuf_put_zeros(msg, sizeof *ofr);
3289         ofputil_match_to_ofp10_match(&fr->match, &ofr->match);
3290         ofr->cookie = fr->cookie;
3291         ofr->priority = htons(fr->priority);
3292         ofr->reason = reason;
3293         ofr->duration_sec = htonl(fr->duration_sec);
3294         ofr->duration_nsec = htonl(fr->duration_nsec);
3295         ofr->idle_timeout = htons(fr->idle_timeout);
3296         ofr->packet_count = htonll(unknown_to_zero(fr->packet_count));
3297         ofr->byte_count = htonll(unknown_to_zero(fr->byte_count));
3298         break;
3299     }
3300
3301     case OFPUTIL_P_OF10_NXM:
3302     case OFPUTIL_P_OF10_NXM_TID: {
3303         struct nx_flow_removed *nfr;
3304         int match_len;
3305
3306         msg = ofpraw_alloc_xid(OFPRAW_NXT_FLOW_REMOVED, OFP10_VERSION,
3307                                htonl(0), NXM_TYPICAL_LEN);
3308         ofpbuf_put_zeros(msg, sizeof *nfr);
3309         match_len = nx_put_match(msg, &fr->match, 0, 0);
3310
3311         nfr = msg->msg;
3312         nfr->cookie = fr->cookie;
3313         nfr->priority = htons(fr->priority);
3314         nfr->reason = reason;
3315         nfr->table_id = fr->table_id + 1;
3316         nfr->duration_sec = htonl(fr->duration_sec);
3317         nfr->duration_nsec = htonl(fr->duration_nsec);
3318         nfr->idle_timeout = htons(fr->idle_timeout);
3319         nfr->match_len = htons(match_len);
3320         nfr->packet_count = htonll(fr->packet_count);
3321         nfr->byte_count = htonll(fr->byte_count);
3322         break;
3323     }
3324
3325     default:
3326         OVS_NOT_REACHED();
3327     }
3328
3329     return msg;
3330 }
3331
3332 /* The caller has done basic initialization of '*pin'; the other output
3333  * arguments needs to be initialized. */
3334 static enum ofperr
3335 decode_nx_packet_in2(const struct ofp_header *oh, bool loose,
3336                      struct ofputil_packet_in *pin,
3337                      size_t *total_len, uint32_t *buffer_id,
3338                      struct ofpbuf *continuation)
3339 {
3340     *total_len = 0;
3341     *buffer_id = UINT32_MAX;
3342
3343     struct ofpbuf properties;
3344     ofpbuf_use_const(&properties, oh, ntohs(oh->length));
3345     ofpraw_pull_assert(&properties);
3346
3347     while (properties.size > 0) {
3348         struct ofpbuf payload;
3349         uint64_t type;
3350
3351         enum ofperr error = ofpprop_pull(&properties, &payload, &type);
3352         if (error) {
3353             return error;
3354         }
3355
3356         switch (type) {
3357         case NXPINT_PACKET:
3358             pin->packet = payload.msg;
3359             pin->packet_len = ofpbuf_msgsize(&payload);
3360             break;
3361
3362         case NXPINT_FULL_LEN: {
3363             uint32_t u32;
3364             error = ofpprop_parse_u32(&payload, &u32);
3365             *total_len = u32;
3366             break;
3367         }
3368
3369         case NXPINT_BUFFER_ID:
3370             error = ofpprop_parse_u32(&payload, buffer_id);
3371             break;
3372
3373         case NXPINT_TABLE_ID:
3374             error = ofpprop_parse_u8(&payload, &pin->table_id);
3375             break;
3376
3377         case NXPINT_COOKIE:
3378             error = ofpprop_parse_be64(&payload, &pin->cookie);
3379             break;
3380
3381         case NXPINT_REASON: {
3382             uint8_t reason;
3383             error = ofpprop_parse_u8(&payload, &reason);
3384             pin->reason = reason;
3385             break;
3386         }
3387
3388         case NXPINT_METADATA:
3389             error = oxm_decode_match(payload.msg, ofpbuf_msgsize(&payload),
3390                                      &pin->flow_metadata);
3391             break;
3392
3393         case NXPINT_USERDATA:
3394             pin->userdata = payload.msg;
3395             pin->userdata_len = ofpbuf_msgsize(&payload);
3396             break;
3397
3398         case NXPINT_CONTINUATION:
3399             if (continuation) {
3400                 error = ofpprop_parse_nested(&payload, continuation);
3401             }
3402             break;
3403
3404         default:
3405             error = OFPPROP_UNKNOWN(loose, "NX_PACKET_IN2", type);
3406             break;
3407         }
3408         if (error) {
3409             return error;
3410         }
3411     }
3412
3413     if (!pin->packet_len) {
3414         VLOG_WARN_RL(&bad_ofmsg_rl, "NXT_PACKET_IN2 lacks packet");
3415         return OFPERR_OFPBRC_BAD_LEN;
3416     } else if (!*total_len) {
3417         *total_len = pin->packet_len;
3418     } else if (*total_len < pin->packet_len) {
3419         VLOG_WARN_RL(&bad_ofmsg_rl, "NXT_PACKET_IN2 claimed full_len < len");
3420         return OFPERR_OFPBRC_BAD_LEN;
3421     }
3422
3423     return 0;
3424 }
3425
3426 /* Decodes the packet-in message starting at 'oh' into '*pin'.  Populates
3427  * 'pin->packet' and 'pin->packet_len' with the part of the packet actually
3428  * included in the message.  If 'total_lenp' is nonnull, populates
3429  * '*total_lenp' with the original length of the packet (which is larger than
3430  * 'packet->len' if only part of the packet was included).  If 'buffer_idp' is
3431  * nonnull, stores the packet's buffer ID in '*buffer_idp' (UINT32_MAX if it
3432  * was not buffered).
3433  *
3434  * Populates 'continuation', if nonnull, with the continuation data from the
3435  * packet-in (an empty buffer, if 'oh' did not contain continuation data).  The
3436  * format of this data is supposed to be opaque to anything other than
3437  * ovs-vswitchd, so that in any other process the only reasonable use of this
3438  * data is to be copied into an NXT_RESUME message via ofputil_encode_resume().
3439  *
3440  * This function points 'pin->packet' into 'oh', so the caller should not free
3441  * it separately from the original OpenFlow message.  This is also true for
3442  * 'pin->userdata' (which could also end up NULL if there is no userdata).
3443  *
3444  * Returns 0 if successful, otherwise an OpenFlow error code. */
3445 enum ofperr
3446 ofputil_decode_packet_in(const struct ofp_header *oh, bool loose,
3447                          struct ofputil_packet_in *pin,
3448                          size_t *total_lenp, uint32_t *buffer_idp,
3449                          struct ofpbuf *continuation)
3450 {
3451     uint32_t buffer_id;
3452     size_t total_len;
3453
3454     memset(pin, 0, sizeof *pin);
3455     pin->cookie = OVS_BE64_MAX;
3456     if (continuation) {
3457         ofpbuf_use_const(continuation, NULL, 0);
3458     }
3459
3460     struct ofpbuf b = ofpbuf_const_initializer(oh, ntohs(oh->length));
3461     enum ofpraw raw = ofpraw_pull_assert(&b);
3462     if (raw == OFPRAW_OFPT13_PACKET_IN || raw == OFPRAW_OFPT12_PACKET_IN) {
3463         const struct ofp12_packet_in *opi = ofpbuf_pull(&b, sizeof *opi);
3464         const ovs_be64 *cookie = (raw == OFPRAW_OFPT13_PACKET_IN
3465                                   ? ofpbuf_pull(&b, sizeof *cookie)
3466                                   : NULL);
3467         enum ofperr error = oxm_pull_match_loose(&b, &pin->flow_metadata);
3468         if (error) {
3469             return error;
3470         }
3471
3472         if (!ofpbuf_try_pull(&b, 2)) {
3473             return OFPERR_OFPBRC_BAD_LEN;
3474         }
3475
3476         pin->reason = opi->reason;
3477         pin->table_id = opi->table_id;
3478         buffer_id = ntohl(opi->buffer_id);
3479         total_len = ntohs(opi->total_len);
3480         if (cookie) {
3481             pin->cookie = *cookie;
3482         }
3483
3484         pin->packet = b.data;
3485         pin->packet_len = b.size;
3486     } else if (raw == OFPRAW_OFPT10_PACKET_IN) {
3487         const struct ofp10_packet_in *opi;
3488
3489         opi = ofpbuf_pull(&b, offsetof(struct ofp10_packet_in, data));
3490
3491         pin->packet = CONST_CAST(uint8_t *, opi->data);
3492         pin->packet_len = b.size;
3493
3494         match_init_catchall(&pin->flow_metadata);
3495         match_set_in_port(&pin->flow_metadata,
3496                           u16_to_ofp(ntohs(opi->in_port)));
3497         pin->reason = opi->reason;
3498         buffer_id = ntohl(opi->buffer_id);
3499         total_len = ntohs(opi->total_len);
3500     } else if (raw == OFPRAW_OFPT11_PACKET_IN) {
3501         const struct ofp11_packet_in *opi;
3502         ofp_port_t in_port;
3503         enum ofperr error;
3504
3505         opi = ofpbuf_pull(&b, sizeof *opi);
3506
3507         pin->packet = b.data;
3508         pin->packet_len = b.size;
3509
3510         buffer_id = ntohl(opi->buffer_id);
3511         error = ofputil_port_from_ofp11(opi->in_port, &in_port);
3512         if (error) {
3513             return error;
3514         }
3515         match_init_catchall(&pin->flow_metadata);
3516         match_set_in_port(&pin->flow_metadata, in_port);
3517         total_len = ntohs(opi->total_len);
3518         pin->reason = opi->reason;
3519         pin->table_id = opi->table_id;
3520     } else if (raw == OFPRAW_NXT_PACKET_IN) {
3521         const struct nx_packet_in *npi;
3522         int error;
3523
3524         npi = ofpbuf_pull(&b, sizeof *npi);
3525         error = nx_pull_match_loose(&b, ntohs(npi->match_len),
3526                                     &pin->flow_metadata, NULL, NULL);
3527         if (error) {
3528             return error;
3529         }
3530
3531         if (!ofpbuf_try_pull(&b, 2)) {
3532             return OFPERR_OFPBRC_BAD_LEN;
3533         }
3534
3535         pin->reason = npi->reason;
3536         pin->table_id = npi->table_id;
3537         pin->cookie = npi->cookie;
3538
3539         buffer_id = ntohl(npi->buffer_id);
3540         total_len = ntohs(npi->total_len);
3541
3542         pin->packet = b.data;
3543         pin->packet_len = b.size;
3544     } else if (raw == OFPRAW_NXT_PACKET_IN2 || raw == OFPRAW_NXT_RESUME) {
3545         enum ofperr error = decode_nx_packet_in2(oh, loose, pin, &total_len,
3546                                                  &buffer_id, continuation);
3547         if (error) {
3548             return error;
3549         }
3550     } else {
3551         OVS_NOT_REACHED();
3552     }
3553
3554     if (total_lenp) {
3555         *total_lenp = total_len;
3556     }
3557     if (buffer_idp) {
3558         *buffer_idp = buffer_id;
3559     }
3560
3561     return 0;
3562 }
3563
3564 static int
3565 encode_packet_in_reason(enum ofp_packet_in_reason reason,
3566                         enum ofp_version version)
3567 {
3568     switch (reason) {
3569     case OFPR_NO_MATCH:
3570     case OFPR_ACTION:
3571     case OFPR_INVALID_TTL:
3572         return reason;
3573
3574     case OFPR_ACTION_SET:
3575     case OFPR_GROUP:
3576     case OFPR_PACKET_OUT:
3577         return version < OFP14_VERSION ? OFPR_ACTION : reason;
3578
3579     case OFPR_EXPLICIT_MISS:
3580         return version < OFP13_VERSION ? OFPR_ACTION : OFPR_NO_MATCH;
3581
3582     case OFPR_IMPLICIT_MISS:
3583         return OFPR_NO_MATCH;
3584
3585     case OFPR_N_REASONS:
3586     default:
3587         OVS_NOT_REACHED();
3588     }
3589 }
3590
3591 /* Only NXT_PACKET_IN2 (not NXT_RESUME) should include NXCPT_USERDATA, so this
3592  * function omits it.  The caller can add it itself if desired. */
3593 static void
3594 ofputil_put_packet_in(const struct ofputil_packet_in *pin,
3595                       enum ofp_version version, uint32_t buffer_id,
3596                       size_t include_bytes, struct ofpbuf *msg)
3597 {
3598     /* Add packet properties. */
3599     ofpprop_put(msg, NXPINT_PACKET, pin->packet, include_bytes);
3600     if (include_bytes != pin->packet_len) {
3601         ofpprop_put_u32(msg, NXPINT_FULL_LEN, pin->packet_len);
3602     }
3603     if (buffer_id != UINT32_MAX) {
3604         ofpprop_put_u32(msg, NXPINT_BUFFER_ID, buffer_id);
3605     }
3606
3607     /* Add flow properties. */
3608     ofpprop_put_u8(msg, NXPINT_TABLE_ID, pin->table_id);
3609     if (pin->cookie != OVS_BE64_MAX) {
3610         ofpprop_put_be64(msg, NXPINT_COOKIE, pin->cookie);
3611     }
3612
3613     /* Add other properties. */
3614     ofpprop_put_u8(msg, NXPINT_REASON,
3615                    encode_packet_in_reason(pin->reason, version));
3616
3617     size_t start = ofpprop_start(msg, NXPINT_METADATA);
3618     oxm_put_raw(msg, &pin->flow_metadata, version);
3619     ofpprop_end(msg, start);
3620 }
3621
3622 static void
3623 put_actions_property(struct ofpbuf *msg, uint64_t prop_type,
3624                      enum ofp_version version,
3625                      const struct ofpact *actions, size_t actions_len)
3626 {
3627     if (actions_len) {
3628         size_t start = ofpprop_start_nested(msg, prop_type);
3629         ofpacts_put_openflow_actions(actions, actions_len, msg, version);
3630         ofpprop_end(msg, start);
3631     }
3632 }
3633
3634 enum nx_continuation_prop_type {
3635     NXCPT_BRIDGE = 0x8000,
3636     NXCPT_STACK,
3637     NXCPT_MIRRORS,
3638     NXCPT_CONNTRACKED,
3639     NXCPT_TABLE_ID,
3640     NXCPT_COOKIE,
3641     NXCPT_ACTIONS,
3642     NXCPT_ACTION_SET,
3643 };
3644
3645 /* Only NXT_PACKET_IN2 (not NXT_RESUME) should include NXCPT_USERDATA, so this
3646  * function omits it.  The caller can add it itself if desired. */
3647 static void
3648 ofputil_put_packet_in_private(const struct ofputil_packet_in_private *pin,
3649                               enum ofp_version version, uint32_t buffer_id,
3650                               size_t include_bytes, struct ofpbuf *msg)
3651 {
3652     ofputil_put_packet_in(&pin->public, version, buffer_id,
3653                           include_bytes, msg);
3654
3655     size_t continuation_ofs = ofpprop_start_nested(msg, NXPINT_CONTINUATION);
3656     size_t inner_ofs = msg->size;
3657
3658     if (!uuid_is_zero(&pin->bridge)) {
3659         ofpprop_put_uuid(msg, NXCPT_BRIDGE, &pin->bridge);
3660     }
3661
3662     for (size_t i = 0; i < pin->n_stack; i++) {
3663         const union mf_subvalue *s = &pin->stack[i];
3664         size_t ofs;
3665         for (ofs = 0; ofs < sizeof *s; ofs++) {
3666             if (s->u8[ofs]) {
3667                 break;
3668             }
3669         }
3670
3671         ofpprop_put(msg, NXCPT_STACK, &s->u8[ofs], sizeof *s - ofs);
3672     }
3673
3674     if (pin->mirrors) {
3675         ofpprop_put_u32(msg, NXCPT_MIRRORS, pin->mirrors);
3676     }
3677
3678     if (pin->conntracked) {
3679         ofpprop_put_flag(msg, NXCPT_CONNTRACKED);
3680     }
3681
3682     if (pin->actions_len) {
3683         /* Divide 'pin->actions' into groups that begins with an
3684          * unroll_xlate action.  For each group, emit a NXCPT_TABLE_ID and
3685          * NXCPT_COOKIE property (if either has changed; each is initially
3686          * assumed 0), then a NXCPT_ACTIONS property with the grouped
3687          * actions.
3688          *
3689          * The alternative is to make OFPACT_UNROLL_XLATE public.  We can
3690          * always do that later, since this is a private property. */
3691         const struct ofpact *const end = ofpact_end(pin->actions,
3692                                                     pin->actions_len);
3693         const struct ofpact_unroll_xlate *unroll = NULL;
3694         uint8_t table_id = 0;
3695         ovs_be64 cookie = 0;
3696
3697         const struct ofpact *a;
3698         for (a = pin->actions; ; a = ofpact_next(a)) {
3699             if (a == end || a->type == OFPACT_UNROLL_XLATE) {
3700                 if (unroll) {
3701                     if (table_id != unroll->rule_table_id) {
3702                         ofpprop_put_u8(msg, NXCPT_TABLE_ID,
3703                                        unroll->rule_table_id);
3704                         table_id = unroll->rule_table_id;
3705                     }
3706                     if (cookie != unroll->rule_cookie) {
3707                         ofpprop_put_be64(msg, NXCPT_COOKIE,
3708                                          unroll->rule_cookie);
3709                         cookie = unroll->rule_cookie;
3710                     }
3711                 }
3712
3713                 const struct ofpact *start
3714                     = unroll ? ofpact_next(&unroll->ofpact) : pin->actions;
3715                 put_actions_property(msg, NXCPT_ACTIONS, version,
3716                                      start, (a - start) * sizeof *a);
3717
3718                 if (a == end) {
3719                     break;
3720                 }
3721                 unroll = ofpact_get_UNROLL_XLATE(a);
3722             }
3723         }
3724     }
3725
3726     if (pin->action_set_len) {
3727         size_t start = ofpprop_start_nested(msg, NXCPT_ACTION_SET);
3728         ofpacts_put_openflow_actions(pin->action_set,
3729                                      pin->action_set_len, msg, version);
3730         ofpprop_end(msg, start);
3731     }
3732
3733     if (msg->size > inner_ofs) {
3734         ofpprop_end(msg, continuation_ofs);
3735     } else {
3736         msg->size = continuation_ofs;
3737     }
3738 }
3739
3740 static struct ofpbuf *
3741 ofputil_encode_ofp10_packet_in(const struct ofputil_packet_in *pin,
3742                                uint32_t buffer_id)
3743 {
3744     struct ofp10_packet_in *opi;
3745     struct ofpbuf *msg;
3746
3747     msg = ofpraw_alloc_xid(OFPRAW_OFPT10_PACKET_IN, OFP10_VERSION,
3748                            htonl(0), pin->packet_len);
3749     opi = ofpbuf_put_zeros(msg, offsetof(struct ofp10_packet_in, data));
3750     opi->total_len = htons(pin->packet_len);
3751     opi->in_port = htons(ofp_to_u16(pin->flow_metadata.flow.in_port.ofp_port));
3752     opi->reason = encode_packet_in_reason(pin->reason, OFP10_VERSION);
3753     opi->buffer_id = htonl(buffer_id);
3754
3755     return msg;
3756 }
3757
3758 static struct ofpbuf *
3759 ofputil_encode_nx_packet_in(const struct ofputil_packet_in *pin,
3760                             enum ofp_version version, uint32_t buffer_id)
3761 {
3762     struct nx_packet_in *npi;
3763     struct ofpbuf *msg;
3764     size_t match_len;
3765
3766     /* The final argument is just an estimate of the space required. */
3767     msg = ofpraw_alloc_xid(OFPRAW_NXT_PACKET_IN, version,
3768                            htonl(0), NXM_TYPICAL_LEN + 2 + pin->packet_len);
3769     ofpbuf_put_zeros(msg, sizeof *npi);
3770     match_len = nx_put_match(msg, &pin->flow_metadata, 0, 0);
3771     ofpbuf_put_zeros(msg, 2);
3772
3773     npi = msg->msg;
3774     npi->buffer_id = htonl(buffer_id);
3775     npi->total_len = htons(pin->packet_len);
3776     npi->reason = encode_packet_in_reason(pin->reason, version);
3777     npi->table_id = pin->table_id;
3778     npi->cookie = pin->cookie;
3779     npi->match_len = htons(match_len);
3780
3781     return msg;
3782 }
3783
3784 static struct ofpbuf *
3785 ofputil_encode_nx_packet_in2(const struct ofputil_packet_in_private *pin,
3786                              enum ofp_version version, uint32_t buffer_id,
3787                              size_t include_bytes)
3788 {
3789     /* 'extra' is just an estimate of the space required. */
3790     size_t extra = (pin->public.packet_len
3791                     + NXM_TYPICAL_LEN   /* flow_metadata */
3792                     + pin->n_stack * 16
3793                     + pin->actions_len
3794                     + pin->action_set_len
3795                     + 256);     /* fudge factor */
3796     struct ofpbuf *msg = ofpraw_alloc_xid(OFPRAW_NXT_PACKET_IN2, version,
3797                                           htonl(0), extra);
3798
3799     ofputil_put_packet_in_private(pin, version, buffer_id, include_bytes, msg);
3800     if (pin->public.userdata_len) {
3801         ofpprop_put(msg, NXPINT_USERDATA, pin->public.userdata,
3802                     pin->public.userdata_len);
3803     }
3804
3805     ofpmsg_update_length(msg);
3806     return msg;
3807 }
3808
3809 static struct ofpbuf *
3810 ofputil_encode_ofp11_packet_in(const struct ofputil_packet_in *pin,
3811                                uint32_t buffer_id)
3812 {
3813     struct ofp11_packet_in *opi;
3814     struct ofpbuf *msg;
3815
3816     msg = ofpraw_alloc_xid(OFPRAW_OFPT11_PACKET_IN, OFP11_VERSION,
3817                            htonl(0), pin->packet_len);
3818     opi = ofpbuf_put_zeros(msg, sizeof *opi);
3819     opi->buffer_id = htonl(buffer_id);
3820     opi->in_port = ofputil_port_to_ofp11(
3821         pin->flow_metadata.flow.in_port.ofp_port);
3822     opi->in_phy_port = opi->in_port;
3823     opi->total_len = htons(pin->packet_len);
3824     opi->reason = encode_packet_in_reason(pin->reason, OFP11_VERSION);
3825     opi->table_id = pin->table_id;
3826
3827     return msg;
3828 }
3829
3830 static struct ofpbuf *
3831 ofputil_encode_ofp12_packet_in(const struct ofputil_packet_in *pin,
3832                                enum ofp_version version,
3833                                uint32_t buffer_id)
3834 {
3835     enum ofpraw raw = (version >= OFP13_VERSION
3836                        ? OFPRAW_OFPT13_PACKET_IN
3837                        : OFPRAW_OFPT12_PACKET_IN);
3838     struct ofpbuf *msg;
3839
3840     /* The final argument is just an estimate of the space required. */
3841     msg = ofpraw_alloc_xid(raw, version,
3842                            htonl(0), NXM_TYPICAL_LEN + 2 + pin->packet_len);
3843
3844     struct ofp12_packet_in *opi = ofpbuf_put_zeros(msg, sizeof *opi);
3845     opi->buffer_id = htonl(buffer_id);
3846     opi->total_len = htons(pin->packet_len);
3847     opi->reason = encode_packet_in_reason(pin->reason, version);
3848     opi->table_id = pin->table_id;
3849
3850     if (version >= OFP13_VERSION) {
3851         ovs_be64 cookie = pin->cookie;
3852         ofpbuf_put(msg, &cookie, sizeof cookie);
3853     }
3854
3855     oxm_put_match(msg, &pin->flow_metadata, version);
3856     ofpbuf_put_zeros(msg, 2);
3857
3858     return msg;
3859 }
3860
3861 /* Converts abstract ofputil_packet_in_private 'pin' into a PACKET_IN message
3862  * for 'protocol', using the packet-in format specified by 'packet_in_format'.
3863  *
3864  * If 'pkt_buf' is nonnull and 'max_len' allows the packet to be buffered, this
3865  * function will attempt to obtain a buffer ID from 'pktbuf' and truncate the
3866  * packet to 'max_len' bytes.  Otherwise, or if 'pktbuf' doesn't have a free
3867  * buffer, it will send the whole packet without buffering.
3868  *
3869  * This function is really meant only for use by ovs-vswitchd.  To any other
3870  * code, the "continuation" data, i.e. the data that is in struct
3871  * ofputil_packet_in_private but not in struct ofputil_packet_in, is supposed
3872  * to be opaque (and it might change from one OVS version to another).  Thus,
3873  * if any other code wants to encode a packet-in, it should use a non-"private"
3874  * version of this function.  (Such a version doesn't currently exist because
3875  * only ovs-vswitchd currently wants to encode packet-ins.  If you need one,
3876  * write it...) */
3877 struct ofpbuf *
3878 ofputil_encode_packet_in_private(const struct ofputil_packet_in_private *pin,
3879                                  enum ofputil_protocol protocol,
3880                                  enum nx_packet_in_format packet_in_format,
3881                                  uint16_t max_len, struct pktbuf *pktbuf)
3882 {
3883     enum ofp_version version = ofputil_protocol_to_ofp_version(protocol);
3884
3885     /* Get buffer ID. */
3886     ofp_port_t in_port = pin->public.flow_metadata.flow.in_port.ofp_port;
3887     uint32_t buffer_id = (max_len != OFPCML12_NO_BUFFER && pktbuf
3888                           ? pktbuf_save(pktbuf, pin->public.packet,
3889                                         pin->public.packet_len, in_port)
3890                           : UINT32_MAX);
3891
3892     /* Calculate the number of bytes of the packet to include in the
3893      * packet-in:
3894      *
3895      *    - If not buffered, the whole thing.
3896      *
3897      *    - Otherwise, no more than 'max_len' bytes. */
3898     size_t include_bytes = (buffer_id == UINT32_MAX
3899                             ? pin->public.packet_len
3900                             : MIN(max_len, pin->public.packet_len));
3901
3902     struct ofpbuf *msg;
3903     switch (packet_in_format) {
3904     case NXPIF_STANDARD:
3905         switch (protocol) {
3906         case OFPUTIL_P_OF10_STD:
3907         case OFPUTIL_P_OF10_STD_TID:
3908         case OFPUTIL_P_OF10_NXM:
3909         case OFPUTIL_P_OF10_NXM_TID:
3910             msg = ofputil_encode_ofp10_packet_in(&pin->public, buffer_id);
3911             break;
3912
3913         case OFPUTIL_P_OF11_STD:
3914             msg = ofputil_encode_ofp11_packet_in(&pin->public, buffer_id);
3915             break;
3916
3917         case OFPUTIL_P_OF12_OXM:
3918         case OFPUTIL_P_OF13_OXM:
3919         case OFPUTIL_P_OF14_OXM:
3920         case OFPUTIL_P_OF15_OXM:
3921         case OFPUTIL_P_OF16_OXM:
3922             msg = ofputil_encode_ofp12_packet_in(&pin->public, version, buffer_id);
3923             break;
3924
3925         default:
3926             OVS_NOT_REACHED();
3927         }
3928         break;
3929
3930     case NXPIF_NXT_PACKET_IN:
3931         msg = ofputil_encode_nx_packet_in(&pin->public, version, buffer_id);
3932         break;
3933
3934     case NXPIF_NXT_PACKET_IN2:
3935         return ofputil_encode_nx_packet_in2(pin, version, buffer_id,
3936                                             include_bytes);
3937
3938     default:
3939         OVS_NOT_REACHED();
3940     }
3941
3942     ofpbuf_put(msg, pin->public.packet, include_bytes);
3943     ofpmsg_update_length(msg);
3944     return msg;
3945 }
3946
3947 /* Returns a string form of 'reason'.  The return value is either a statically
3948  * allocated constant string or the 'bufsize'-byte buffer 'reasonbuf'.
3949  * 'bufsize' should be at least OFPUTIL_PACKET_IN_REASON_BUFSIZE. */
3950 const char *
3951 ofputil_packet_in_reason_to_string(enum ofp_packet_in_reason reason,
3952                                    char *reasonbuf, size_t bufsize)
3953 {
3954     switch (reason) {
3955     case OFPR_NO_MATCH:
3956         return "no_match";
3957     case OFPR_ACTION:
3958         return "action";
3959     case OFPR_INVALID_TTL:
3960         return "invalid_ttl";
3961     case OFPR_ACTION_SET:
3962         return "action_set";
3963     case OFPR_GROUP:
3964         return "group";
3965     case OFPR_PACKET_OUT:
3966         return "packet_out";
3967     case OFPR_EXPLICIT_MISS:
3968     case OFPR_IMPLICIT_MISS:
3969         return "";
3970
3971     case OFPR_N_REASONS:
3972     default:
3973         snprintf(reasonbuf, bufsize, "%d", (int) reason);
3974         return reasonbuf;
3975     }
3976 }
3977
3978 bool
3979 ofputil_packet_in_reason_from_string(const char *s,
3980                                      enum ofp_packet_in_reason *reason)
3981 {
3982     int i;
3983
3984     for (i = 0; i < OFPR_N_REASONS; i++) {
3985         char reasonbuf[OFPUTIL_PACKET_IN_REASON_BUFSIZE];
3986         const char *reason_s;
3987
3988         reason_s = ofputil_packet_in_reason_to_string(i, reasonbuf,
3989                                                       sizeof reasonbuf);
3990         if (!strcasecmp(s, reason_s)) {
3991             *reason = i;
3992             return true;
3993         }
3994     }
3995     return false;
3996 }
3997
3998 /* Returns a newly allocated NXT_RESUME message for 'pin', with the given
3999  * 'continuation', for 'protocol'.  This message is suitable for resuming the
4000  * pipeline traveral of the packet represented by 'pin', if sent to the switch
4001  * from which 'pin' was received. */
4002 struct ofpbuf *
4003 ofputil_encode_resume(const struct ofputil_packet_in *pin,
4004                       const struct ofpbuf *continuation,
4005                       enum ofputil_protocol protocol)
4006 {
4007     enum ofp_version version = ofputil_protocol_to_ofp_version(protocol);
4008     size_t extra = pin->packet_len + NXM_TYPICAL_LEN + continuation->size;
4009     struct ofpbuf *msg = ofpraw_alloc_xid(OFPRAW_NXT_RESUME, version,
4010                                           0, extra);
4011     ofputil_put_packet_in(pin, version, UINT32_MAX, pin->packet_len, msg);
4012     ofpprop_put_nested(msg, NXPINT_CONTINUATION, continuation);
4013     ofpmsg_update_length(msg);
4014     return msg;
4015 }
4016
4017 static enum ofperr
4018 parse_subvalue_prop(const struct ofpbuf *property, union mf_subvalue *sv)
4019 {
4020     unsigned int len = ofpbuf_msgsize(property);
4021     if (len > sizeof *sv) {
4022         VLOG_WARN_RL(&bad_ofmsg_rl, "NXCPT_STACK property has bad length %u",
4023                      len);
4024         return OFPERR_OFPBPC_BAD_LEN;
4025     }
4026     memset(sv, 0, sizeof *sv);
4027     memcpy(&sv->u8[sizeof *sv - len], property->msg, len);
4028     return 0;
4029 }
4030
4031 static enum ofperr
4032 parse_actions_property(struct ofpbuf *property, enum ofp_version version,
4033                        struct ofpbuf *ofpacts)
4034 {
4035     if (!ofpbuf_try_pull(property, ROUND_UP(ofpbuf_headersize(property), 8))) {
4036         VLOG_WARN_RL(&bad_ofmsg_rl, "actions property has bad length %"PRIu32,
4037                      property->size);
4038         return OFPERR_OFPBPC_BAD_LEN;
4039     }
4040
4041     return ofpacts_pull_openflow_actions(property, property->size,
4042                                          version, ofpacts);
4043 }
4044
4045 /* This is like ofputil_decode_packet_in(), except that it decodes the
4046  * continuation data into 'pin'.  The format of this data is supposed to be
4047  * opaque to any process other than ovs-vswitchd, so this function should not
4048  * be used outside ovs-vswitchd.
4049  *
4050  * When successful, 'pin' contains some dynamically allocated data.  Call
4051  * ofputil_packet_in_private_destroy() to free this data. */
4052 enum ofperr
4053 ofputil_decode_packet_in_private(const struct ofp_header *oh, bool loose,
4054                                  struct ofputil_packet_in_private *pin,
4055                                  size_t *total_len, uint32_t *buffer_id)
4056 {
4057     memset(pin, 0, sizeof *pin);
4058
4059     struct ofpbuf continuation;
4060     enum ofperr error;
4061     error = ofputil_decode_packet_in(oh, loose, &pin->public, total_len,
4062                                      buffer_id, &continuation);
4063     if (error) {
4064         return error;
4065     }
4066
4067     struct ofpbuf actions, action_set;
4068     ofpbuf_init(&actions, 0);
4069     ofpbuf_init(&action_set, 0);
4070
4071     uint8_t table_id = 0;
4072     ovs_be64 cookie = 0;
4073
4074     size_t allocated_stack = 0;
4075
4076     while (continuation.size > 0) {
4077         struct ofpbuf payload;
4078         uint64_t type;
4079
4080         error = ofpprop_pull(&continuation, &payload, &type);
4081         ovs_assert(!error);
4082
4083         switch (type) {
4084         case NXCPT_BRIDGE:
4085             error = ofpprop_parse_uuid(&payload, &pin->bridge);
4086             break;
4087
4088         case NXCPT_STACK:
4089             if (pin->n_stack >= allocated_stack) {
4090                 pin->stack = x2nrealloc(pin->stack, &allocated_stack,
4091                                            sizeof *pin->stack);
4092             }
4093             error = parse_subvalue_prop(&payload,
4094                                         &pin->stack[pin->n_stack++]);
4095             break;
4096
4097         case NXCPT_MIRRORS:
4098             error = ofpprop_parse_u32(&payload, &pin->mirrors);
4099             break;
4100
4101         case NXCPT_CONNTRACKED:
4102             pin->conntracked = true;
4103             break;
4104
4105         case NXCPT_TABLE_ID:
4106             error = ofpprop_parse_u8(&payload, &table_id);
4107             break;
4108
4109         case NXCPT_COOKIE:
4110             error = ofpprop_parse_be64(&payload, &cookie);
4111             break;
4112
4113         case NXCPT_ACTIONS: {
4114             struct ofpact_unroll_xlate *unroll
4115                 = ofpact_put_UNROLL_XLATE(&actions);
4116             unroll->rule_table_id = table_id;
4117             unroll->rule_cookie = cookie;
4118             error = parse_actions_property(&payload, oh->version, &actions);
4119             break;
4120         }
4121
4122         case NXCPT_ACTION_SET:
4123             error = parse_actions_property(&payload, oh->version, &action_set);
4124             break;
4125
4126         default:
4127             error = OFPPROP_UNKNOWN(loose, "continuation", type);
4128             break;
4129         }
4130         if (error) {
4131             break;
4132         }
4133     }
4134
4135     pin->actions_len = actions.size;
4136     pin->actions = ofpbuf_steal_data(&actions);
4137     pin->action_set_len = action_set.size;
4138     pin->action_set = ofpbuf_steal_data(&action_set);
4139
4140     if (error) {
4141         ofputil_packet_in_private_destroy(pin);
4142     }
4143
4144     return 0;
4145 }
4146
4147 /* Frees data in 'pin' that is dynamically allocated by
4148  * ofputil_decode_packet_in_private().
4149  *
4150  * 'pin->public' contains some pointer members that
4151  * ofputil_decode_packet_in_private() doesn't initialize to newly allocated
4152  * data, so this function doesn't free those. */
4153 void
4154 ofputil_packet_in_private_destroy(struct ofputil_packet_in_private *pin)
4155 {
4156     if (pin) {
4157         free(pin->stack);
4158         free(pin->actions);
4159         free(pin->action_set);
4160     }
4161 }
4162
4163 /* Converts an OFPT_PACKET_OUT in 'opo' into an abstract ofputil_packet_out in
4164  * 'po'.
4165  *
4166  * Uses 'ofpacts' to store the abstract OFPACT_* version of the packet out
4167  * message's actions.  The caller must initialize 'ofpacts' and retains
4168  * ownership of it.  'po->ofpacts' will point into the 'ofpacts' buffer.
4169  *
4170  * Returns 0 if successful, otherwise an OFPERR_* value. */
4171 enum ofperr
4172 ofputil_decode_packet_out(struct ofputil_packet_out *po,
4173                           const struct ofp_header *oh,
4174                           struct ofpbuf *ofpacts)
4175 {
4176     struct ofpbuf b = ofpbuf_const_initializer(oh, ntohs(oh->length));
4177     enum ofpraw raw = ofpraw_pull_assert(&b);
4178
4179     ofpbuf_clear(ofpacts);
4180     if (raw == OFPRAW_OFPT11_PACKET_OUT) {
4181         enum ofperr error;
4182         const struct ofp11_packet_out *opo = ofpbuf_pull(&b, sizeof *opo);
4183
4184         po->buffer_id = ntohl(opo->buffer_id);
4185         error = ofputil_port_from_ofp11(opo->in_port, &po->in_port);
4186         if (error) {
4187             return error;
4188         }
4189
4190         error = ofpacts_pull_openflow_actions(&b, ntohs(opo->actions_len),
4191                                               oh->version, ofpacts);
4192         if (error) {
4193             return error;
4194         }
4195     } else if (raw == OFPRAW_OFPT10_PACKET_OUT) {
4196         enum ofperr error;
4197         const struct ofp10_packet_out *opo = ofpbuf_pull(&b, sizeof *opo);
4198
4199         po->buffer_id = ntohl(opo->buffer_id);
4200         po->in_port = u16_to_ofp(ntohs(opo->in_port));
4201
4202         error = ofpacts_pull_openflow_actions(&b, ntohs(opo->actions_len),
4203                                               oh->version, ofpacts);
4204         if (error) {
4205             return error;
4206         }
4207     } else {
4208         OVS_NOT_REACHED();
4209     }
4210
4211     if (ofp_to_u16(po->in_port) >= ofp_to_u16(OFPP_MAX)
4212         && po->in_port != OFPP_LOCAL
4213         && po->in_port != OFPP_NONE && po->in_port != OFPP_CONTROLLER) {
4214         VLOG_WARN_RL(&bad_ofmsg_rl, "packet-out has bad input port %#"PRIx16,
4215                      po->in_port);
4216         return OFPERR_OFPBRC_BAD_PORT;
4217     }
4218
4219     po->ofpacts = ofpacts->data;
4220     po->ofpacts_len = ofpacts->size;
4221
4222     if (po->buffer_id == UINT32_MAX) {
4223         po->packet = b.data;
4224         po->packet_len = b.size;
4225     } else {
4226         po->packet = NULL;
4227         po->packet_len = 0;
4228     }
4229
4230     return 0;
4231 }
4232 \f
4233 /* ofputil_phy_port */
4234
4235 /* NETDEV_F_* to and from OFPPF_* and OFPPF10_*. */
4236 BUILD_ASSERT_DECL((int) NETDEV_F_10MB_HD    == OFPPF_10MB_HD);  /* bit 0 */
4237 BUILD_ASSERT_DECL((int) NETDEV_F_10MB_FD    == OFPPF_10MB_FD);  /* bit 1 */
4238 BUILD_ASSERT_DECL((int) NETDEV_F_100MB_HD   == OFPPF_100MB_HD); /* bit 2 */
4239 BUILD_ASSERT_DECL((int) NETDEV_F_100MB_FD   == OFPPF_100MB_FD); /* bit 3 */
4240 BUILD_ASSERT_DECL((int) NETDEV_F_1GB_HD     == OFPPF_1GB_HD);   /* bit 4 */
4241 BUILD_ASSERT_DECL((int) NETDEV_F_1GB_FD     == OFPPF_1GB_FD);   /* bit 5 */
4242 BUILD_ASSERT_DECL((int) NETDEV_F_10GB_FD    == OFPPF_10GB_FD);  /* bit 6 */
4243
4244 /* NETDEV_F_ bits 11...15 are OFPPF10_ bits 7...11: */
4245 BUILD_ASSERT_DECL((int) NETDEV_F_COPPER == (OFPPF10_COPPER << 4));
4246 BUILD_ASSERT_DECL((int) NETDEV_F_FIBER == (OFPPF10_FIBER << 4));
4247 BUILD_ASSERT_DECL((int) NETDEV_F_AUTONEG == (OFPPF10_AUTONEG << 4));
4248 BUILD_ASSERT_DECL((int) NETDEV_F_PAUSE == (OFPPF10_PAUSE << 4));
4249 BUILD_ASSERT_DECL((int) NETDEV_F_PAUSE_ASYM == (OFPPF10_PAUSE_ASYM << 4));
4250
4251 static enum netdev_features
4252 netdev_port_features_from_ofp10(ovs_be32 ofp10_)
4253 {
4254     uint32_t ofp10 = ntohl(ofp10_);
4255     return (ofp10 & 0x7f) | ((ofp10 & 0xf80) << 4);
4256 }
4257
4258 static ovs_be32
4259 netdev_port_features_to_ofp10(enum netdev_features features)
4260 {
4261     return htonl((features & 0x7f) | ((features & 0xf800) >> 4));
4262 }
4263
4264 BUILD_ASSERT_DECL((int) NETDEV_F_10MB_HD    == OFPPF_10MB_HD);     /* bit 0 */
4265 BUILD_ASSERT_DECL((int) NETDEV_F_10MB_FD    == OFPPF_10MB_FD);     /* bit 1 */
4266 BUILD_ASSERT_DECL((int) NETDEV_F_100MB_HD   == OFPPF_100MB_HD);    /* bit 2 */
4267 BUILD_ASSERT_DECL((int) NETDEV_F_100MB_FD   == OFPPF_100MB_FD);    /* bit 3 */
4268 BUILD_ASSERT_DECL((int) NETDEV_F_1GB_HD     == OFPPF_1GB_HD);      /* bit 4 */
4269 BUILD_ASSERT_DECL((int) NETDEV_F_1GB_FD     == OFPPF_1GB_FD);      /* bit 5 */
4270 BUILD_ASSERT_DECL((int) NETDEV_F_10GB_FD    == OFPPF_10GB_FD);     /* bit 6 */
4271 BUILD_ASSERT_DECL((int) NETDEV_F_40GB_FD    == OFPPF11_40GB_FD);   /* bit 7 */
4272 BUILD_ASSERT_DECL((int) NETDEV_F_100GB_FD   == OFPPF11_100GB_FD);  /* bit 8 */
4273 BUILD_ASSERT_DECL((int) NETDEV_F_1TB_FD     == OFPPF11_1TB_FD);    /* bit 9 */
4274 BUILD_ASSERT_DECL((int) NETDEV_F_OTHER      == OFPPF11_OTHER);     /* bit 10 */
4275 BUILD_ASSERT_DECL((int) NETDEV_F_COPPER     == OFPPF11_COPPER);    /* bit 11 */
4276 BUILD_ASSERT_DECL((int) NETDEV_F_FIBER      == OFPPF11_FIBER);     /* bit 12 */
4277 BUILD_ASSERT_DECL((int) NETDEV_F_AUTONEG    == OFPPF11_AUTONEG);   /* bit 13 */
4278 BUILD_ASSERT_DECL((int) NETDEV_F_PAUSE      == OFPPF11_PAUSE);     /* bit 14 */
4279 BUILD_ASSERT_DECL((int) NETDEV_F_PAUSE_ASYM == OFPPF11_PAUSE_ASYM);/* bit 15 */
4280
4281 static enum netdev_features
4282 netdev_port_features_from_ofp11(ovs_be32 ofp11)
4283 {
4284     return ntohl(ofp11) & 0xffff;
4285 }
4286
4287 static ovs_be32
4288 netdev_port_features_to_ofp11(enum netdev_features features)
4289 {
4290     return htonl(features & 0xffff);
4291 }
4292
4293 static enum ofperr
4294 ofputil_decode_ofp10_phy_port(struct ofputil_phy_port *pp,
4295                               const struct ofp10_phy_port *opp)
4296 {
4297     pp->port_no = u16_to_ofp(ntohs(opp->port_no));
4298     pp->hw_addr = opp->hw_addr;
4299     ovs_strlcpy(pp->name, opp->name, OFP_MAX_PORT_NAME_LEN);
4300
4301     pp->config = ntohl(opp->config) & OFPPC10_ALL;
4302     pp->state = ntohl(opp->state) & OFPPS10_ALL;
4303
4304     pp->curr = netdev_port_features_from_ofp10(opp->curr);
4305     pp->advertised = netdev_port_features_from_ofp10(opp->advertised);
4306     pp->supported = netdev_port_features_from_ofp10(opp->supported);
4307     pp->peer = netdev_port_features_from_ofp10(opp->peer);
4308
4309     pp->curr_speed = netdev_features_to_bps(pp->curr, 0) / 1000;
4310     pp->max_speed = netdev_features_to_bps(pp->supported, 0) / 1000;
4311
4312     return 0;
4313 }
4314
4315 static enum ofperr
4316 ofputil_decode_ofp11_port(struct ofputil_phy_port *pp,
4317                           const struct ofp11_port *op)
4318 {
4319     enum ofperr error;
4320
4321     error = ofputil_port_from_ofp11(op->port_no, &pp->port_no);
4322     if (error) {
4323         return error;
4324     }
4325     pp->hw_addr = op->hw_addr;
4326     ovs_strlcpy(pp->name, op->name, OFP_MAX_PORT_NAME_LEN);
4327
4328     pp->config = ntohl(op->config) & OFPPC11_ALL;
4329     pp->state = ntohl(op->state) & OFPPS11_ALL;
4330
4331     pp->curr = netdev_port_features_from_ofp11(op->curr);
4332     pp->advertised = netdev_port_features_from_ofp11(op->advertised);
4333     pp->supported = netdev_port_features_from_ofp11(op->supported);
4334     pp->peer = netdev_port_features_from_ofp11(op->peer);
4335
4336     pp->curr_speed = ntohl(op->curr_speed);
4337     pp->max_speed = ntohl(op->max_speed);
4338
4339     return 0;
4340 }
4341
4342 static enum ofperr
4343 parse_ofp14_port_ethernet_property(const struct ofpbuf *payload,
4344                                    struct ofputil_phy_port *pp)
4345 {
4346     struct ofp14_port_desc_prop_ethernet *eth = payload->data;
4347
4348     if (payload->size != sizeof *eth) {
4349         return OFPERR_OFPBPC_BAD_LEN;
4350     }
4351
4352     pp->curr = netdev_port_features_from_ofp11(eth->curr);
4353     pp->advertised = netdev_port_features_from_ofp11(eth->advertised);
4354     pp->supported = netdev_port_features_from_ofp11(eth->supported);
4355     pp->peer = netdev_port_features_from_ofp11(eth->peer);
4356
4357     pp->curr_speed = ntohl(eth->curr_speed);
4358     pp->max_speed = ntohl(eth->max_speed);
4359
4360     return 0;
4361 }
4362
4363 static enum ofperr
4364 ofputil_pull_ofp14_port(struct ofputil_phy_port *pp, struct ofpbuf *msg)
4365 {
4366     struct ofp14_port *op = ofpbuf_try_pull(msg, sizeof *op);
4367     if (!op) {
4368         return OFPERR_OFPBRC_BAD_LEN;
4369     }
4370
4371     size_t len = ntohs(op->length);
4372     if (len < sizeof *op || len - sizeof *op > msg->size) {
4373         return OFPERR_OFPBRC_BAD_LEN;
4374     }
4375     len -= sizeof *op;
4376
4377     enum ofperr error = ofputil_port_from_ofp11(op->port_no, &pp->port_no);
4378     if (error) {
4379         return error;
4380     }
4381     pp->hw_addr = op->hw_addr;
4382     ovs_strlcpy(pp->name, op->name, OFP_MAX_PORT_NAME_LEN);
4383
4384     pp->config = ntohl(op->config) & OFPPC11_ALL;
4385     pp->state = ntohl(op->state) & OFPPS11_ALL;
4386
4387     struct ofpbuf properties = ofpbuf_const_initializer(ofpbuf_pull(msg, len),
4388                                                         len);
4389     while (properties.size > 0) {
4390         struct ofpbuf payload;
4391         enum ofperr error;
4392         uint64_t type;
4393
4394         error = ofpprop_pull(&properties, &payload, &type);
4395         if (error) {
4396             return error;
4397         }
4398
4399         switch (type) {
4400         case OFPPDPT14_ETHERNET:
4401             error = parse_ofp14_port_ethernet_property(&payload, pp);
4402             break;
4403
4404         default:
4405             error = OFPPROP_UNKNOWN(true, "port", type);
4406             break;
4407         }
4408
4409         if (error) {
4410             return error;
4411         }
4412     }
4413
4414     return 0;
4415 }
4416
4417 static void
4418 ofputil_encode_ofp10_phy_port(const struct ofputil_phy_port *pp,
4419                               struct ofp10_phy_port *opp)
4420 {
4421     memset(opp, 0, sizeof *opp);
4422
4423     opp->port_no = htons(ofp_to_u16(pp->port_no));
4424     opp->hw_addr = pp->hw_addr;
4425     ovs_strlcpy(opp->name, pp->name, OFP_MAX_PORT_NAME_LEN);
4426
4427     opp->config = htonl(pp->config & OFPPC10_ALL);
4428     opp->state = htonl(pp->state & OFPPS10_ALL);
4429
4430     opp->curr = netdev_port_features_to_ofp10(pp->curr);
4431     opp->advertised = netdev_port_features_to_ofp10(pp->advertised);
4432     opp->supported = netdev_port_features_to_ofp10(pp->supported);
4433     opp->peer = netdev_port_features_to_ofp10(pp->peer);
4434 }
4435
4436 static void
4437 ofputil_encode_ofp11_port(const struct ofputil_phy_port *pp,
4438                           struct ofp11_port *op)
4439 {
4440     memset(op, 0, sizeof *op);
4441
4442     op->port_no = ofputil_port_to_ofp11(pp->port_no);
4443     op->hw_addr = pp->hw_addr;
4444     ovs_strlcpy(op->name, pp->name, OFP_MAX_PORT_NAME_LEN);
4445
4446     op->config = htonl(pp->config & OFPPC11_ALL);
4447     op->state = htonl(pp->state & OFPPS11_ALL);
4448
4449     op->curr = netdev_port_features_to_ofp11(pp->curr);
4450     op->advertised = netdev_port_features_to_ofp11(pp->advertised);
4451     op->supported = netdev_port_features_to_ofp11(pp->supported);
4452     op->peer = netdev_port_features_to_ofp11(pp->peer);
4453
4454     op->curr_speed = htonl(pp->curr_speed);
4455     op->max_speed = htonl(pp->max_speed);
4456 }
4457
4458 static void
4459 ofputil_put_ofp14_port(const struct ofputil_phy_port *pp,
4460                        struct ofpbuf *b)
4461 {
4462     struct ofp14_port *op;
4463     struct ofp14_port_desc_prop_ethernet *eth;
4464
4465     ofpbuf_prealloc_tailroom(b, sizeof *op + sizeof *eth);
4466
4467     op = ofpbuf_put_zeros(b, sizeof *op);
4468     op->port_no = ofputil_port_to_ofp11(pp->port_no);
4469     op->length = htons(sizeof *op + sizeof *eth);
4470     op->hw_addr = pp->hw_addr;
4471     ovs_strlcpy(op->name, pp->name, sizeof op->name);
4472     op->config = htonl(pp->config & OFPPC11_ALL);
4473     op->state = htonl(pp->state & OFPPS11_ALL);
4474
4475     eth = ofpprop_put_zeros(b, OFPPDPT14_ETHERNET, sizeof *eth);
4476     eth->curr = netdev_port_features_to_ofp11(pp->curr);
4477     eth->advertised = netdev_port_features_to_ofp11(pp->advertised);
4478     eth->supported = netdev_port_features_to_ofp11(pp->supported);
4479     eth->peer = netdev_port_features_to_ofp11(pp->peer);
4480     eth->curr_speed = htonl(pp->curr_speed);
4481     eth->max_speed = htonl(pp->max_speed);
4482 }
4483
4484 static void
4485 ofputil_put_phy_port(enum ofp_version ofp_version,
4486                      const struct ofputil_phy_port *pp, struct ofpbuf *b)
4487 {
4488     switch (ofp_version) {
4489     case OFP10_VERSION: {
4490         struct ofp10_phy_port *opp = ofpbuf_put_uninit(b, sizeof *opp);
4491         ofputil_encode_ofp10_phy_port(pp, opp);
4492         break;
4493     }
4494
4495     case OFP11_VERSION:
4496     case OFP12_VERSION:
4497     case OFP13_VERSION: {
4498         struct ofp11_port *op = ofpbuf_put_uninit(b, sizeof *op);
4499         ofputil_encode_ofp11_port(pp, op);
4500         break;
4501     }
4502
4503     case OFP14_VERSION:
4504     case OFP15_VERSION:
4505     case OFP16_VERSION:
4506         ofputil_put_ofp14_port(pp, b);
4507         break;
4508
4509     default:
4510         OVS_NOT_REACHED();
4511     }
4512 }
4513
4514 enum ofperr
4515 ofputil_decode_port_desc_stats_request(const struct ofp_header *request,
4516                                        ofp_port_t *port)
4517 {
4518     struct ofpbuf b = ofpbuf_const_initializer(request,
4519                                                ntohs(request->length));
4520     enum ofpraw raw = ofpraw_pull_assert(&b);
4521     if (raw == OFPRAW_OFPST10_PORT_DESC_REQUEST) {
4522         *port = OFPP_ANY;
4523         return 0;
4524     } else if (raw == OFPRAW_OFPST15_PORT_DESC_REQUEST) {
4525         ovs_be32 *ofp11_port;
4526
4527         ofp11_port = ofpbuf_pull(&b, sizeof *ofp11_port);
4528         return ofputil_port_from_ofp11(*ofp11_port, port);
4529     } else {
4530         OVS_NOT_REACHED();
4531     }
4532 }
4533
4534 struct ofpbuf *
4535 ofputil_encode_port_desc_stats_request(enum ofp_version ofp_version,
4536                                        ofp_port_t port)
4537 {
4538     struct ofpbuf *request;
4539
4540     switch (ofp_version) {
4541     case OFP10_VERSION:
4542     case OFP11_VERSION:
4543     case OFP12_VERSION:
4544     case OFP13_VERSION:
4545     case OFP14_VERSION:
4546         request = ofpraw_alloc(OFPRAW_OFPST10_PORT_DESC_REQUEST,
4547                                ofp_version, 0);
4548         break;
4549     case OFP15_VERSION:
4550     case OFP16_VERSION:{
4551         struct ofp15_port_desc_request *req;
4552         request = ofpraw_alloc(OFPRAW_OFPST15_PORT_DESC_REQUEST,
4553                                ofp_version, 0);
4554         req = ofpbuf_put_zeros(request, sizeof *req);
4555         req->port_no = ofputil_port_to_ofp11(port);
4556         break;
4557     }
4558     default:
4559         OVS_NOT_REACHED();
4560     }
4561
4562     return request;
4563 }
4564
4565 void
4566 ofputil_append_port_desc_stats_reply(const struct ofputil_phy_port *pp,
4567                                      struct ovs_list *replies)
4568 {
4569     struct ofpbuf *reply = ofpbuf_from_list(ovs_list_back(replies));
4570     size_t start_ofs = reply->size;
4571
4572     ofputil_put_phy_port(ofpmp_version(replies), pp, reply);
4573     ofpmp_postappend(replies, start_ofs);
4574 }
4575 \f
4576 /* ofputil_switch_config */
4577
4578 /* Decodes 'oh', which must be an OFPT_GET_CONFIG_REPLY or OFPT_SET_CONFIG
4579  * message, into 'config'.  Returns false if 'oh' contained any flags that
4580  * aren't specified in its version of OpenFlow, true otherwise. */
4581 static bool
4582 ofputil_decode_switch_config(const struct ofp_header *oh,
4583                              struct ofputil_switch_config *config)
4584 {
4585     struct ofpbuf b = ofpbuf_const_initializer(oh, ntohs(oh->length));
4586     ofpraw_pull_assert(&b);
4587
4588     const struct ofp_switch_config *osc = ofpbuf_pull(&b, sizeof *osc);
4589     config->frag = ntohs(osc->flags) & OFPC_FRAG_MASK;
4590     config->miss_send_len = ntohs(osc->miss_send_len);
4591
4592     ovs_be16 valid_mask = htons(OFPC_FRAG_MASK);
4593     if (oh->version < OFP13_VERSION) {
4594         const ovs_be16 ttl_bit = htons(OFPC_INVALID_TTL_TO_CONTROLLER);
4595         valid_mask |= ttl_bit;
4596         config->invalid_ttl_to_controller = (osc->flags & ttl_bit) != 0;
4597     } else {
4598         config->invalid_ttl_to_controller = -1;
4599     }
4600
4601     return !(osc->flags & ~valid_mask);
4602 }
4603
4604 void
4605 ofputil_decode_get_config_reply(const struct ofp_header *oh,
4606                                 struct ofputil_switch_config *config)
4607 {
4608     ofputil_decode_switch_config(oh, config);
4609 }
4610
4611 enum ofperr
4612 ofputil_decode_set_config(const struct ofp_header *oh,
4613                           struct ofputil_switch_config *config)
4614 {
4615     return (ofputil_decode_switch_config(oh, config)
4616             ? 0
4617             : OFPERR_OFPSCFC_BAD_FLAGS);
4618 }
4619
4620 static struct ofpbuf *
4621 ofputil_put_switch_config(const struct ofputil_switch_config *config,
4622                           struct ofpbuf *b)
4623 {
4624     const struct ofp_header *oh = b->data;
4625     struct ofp_switch_config *osc = ofpbuf_put_zeros(b, sizeof *osc);
4626     osc->flags = htons(config->frag);
4627     if (config->invalid_ttl_to_controller > 0 && oh->version < OFP13_VERSION) {
4628         osc->flags |= htons(OFPC_INVALID_TTL_TO_CONTROLLER);
4629     }
4630     osc->miss_send_len = htons(config->miss_send_len);
4631     return b;
4632 }
4633
4634 struct ofpbuf *
4635 ofputil_encode_get_config_reply(const struct ofp_header *request,
4636                                 const struct ofputil_switch_config *config)
4637 {
4638     struct ofpbuf *b = ofpraw_alloc_reply(OFPRAW_OFPT_GET_CONFIG_REPLY,
4639                                           request, 0);
4640     return ofputil_put_switch_config(config, b);
4641 }
4642
4643 struct ofpbuf *
4644 ofputil_encode_set_config(const struct ofputil_switch_config *config,
4645                           enum ofp_version version)
4646 {
4647     struct ofpbuf *b = ofpraw_alloc(OFPRAW_OFPT_SET_CONFIG, version, 0);
4648     return ofputil_put_switch_config(config, b);
4649 }
4650 \f
4651 /* ofputil_switch_features */
4652
4653 #define OFPC_COMMON (OFPC_FLOW_STATS | OFPC_TABLE_STATS | OFPC_PORT_STATS | \
4654                      OFPC_IP_REASM | OFPC_QUEUE_STATS)
4655 BUILD_ASSERT_DECL((int) OFPUTIL_C_FLOW_STATS == OFPC_FLOW_STATS);
4656 BUILD_ASSERT_DECL((int) OFPUTIL_C_TABLE_STATS == OFPC_TABLE_STATS);
4657 BUILD_ASSERT_DECL((int) OFPUTIL_C_PORT_STATS == OFPC_PORT_STATS);
4658 BUILD_ASSERT_DECL((int) OFPUTIL_C_IP_REASM == OFPC_IP_REASM);
4659 BUILD_ASSERT_DECL((int) OFPUTIL_C_QUEUE_STATS == OFPC_QUEUE_STATS);
4660 BUILD_ASSERT_DECL((int) OFPUTIL_C_ARP_MATCH_IP == OFPC_ARP_MATCH_IP);
4661
4662 static uint32_t
4663 ofputil_capabilities_mask(enum ofp_version ofp_version)
4664 {
4665     /* Handle capabilities whose bit is unique for all OpenFlow versions */
4666     switch (ofp_version) {
4667     case OFP10_VERSION:
4668     case OFP11_VERSION:
4669         return OFPC_COMMON | OFPC_ARP_MATCH_IP;
4670     case OFP12_VERSION:
4671     case OFP13_VERSION:
4672     case OFP14_VERSION:
4673     case OFP15_VERSION:
4674     case OFP16_VERSION:
4675         return OFPC_COMMON | OFPC12_PORT_BLOCKED;
4676     default:
4677         /* Caller needs to check osf->header.version itself */
4678         return 0;
4679     }
4680 }
4681
4682 /* Pulls an OpenFlow "switch_features" structure from 'b' and decodes it into
4683  * an abstract representation in '*features', readying 'b' to iterate over the
4684  * OpenFlow port structures following 'osf' with later calls to
4685  * ofputil_pull_phy_port().  Returns 0 if successful, otherwise an OFPERR_*
4686  * value.  */
4687 enum ofperr
4688 ofputil_pull_switch_features(struct ofpbuf *b,
4689                              struct ofputil_switch_features *features)
4690 {
4691     const struct ofp_header *oh = b->data;
4692     enum ofpraw raw = ofpraw_pull_assert(b);
4693     const struct ofp_switch_features *osf = ofpbuf_pull(b, sizeof *osf);
4694     features->datapath_id = ntohll(osf->datapath_id);
4695     features->n_buffers = ntohl(osf->n_buffers);
4696     features->n_tables = osf->n_tables;
4697     features->auxiliary_id = 0;
4698
4699     features->capabilities = ntohl(osf->capabilities) &
4700         ofputil_capabilities_mask(oh->version);
4701
4702     if (raw == OFPRAW_OFPT10_FEATURES_REPLY) {
4703         if (osf->capabilities & htonl(OFPC10_STP)) {
4704             features->capabilities |= OFPUTIL_C_STP;
4705         }
4706         features->ofpacts = ofpact_bitmap_from_openflow(osf->actions,
4707                                                         OFP10_VERSION);
4708     } else if (raw == OFPRAW_OFPT11_FEATURES_REPLY
4709                || raw == OFPRAW_OFPT13_FEATURES_REPLY) {
4710         if (osf->capabilities & htonl(OFPC11_GROUP_STATS)) {
4711             features->capabilities |= OFPUTIL_C_GROUP_STATS;
4712         }
4713         features->ofpacts = 0;
4714         if (raw == OFPRAW_OFPT13_FEATURES_REPLY) {
4715             features->auxiliary_id = osf->auxiliary_id;
4716         }
4717     } else {
4718         return OFPERR_OFPBRC_BAD_VERSION;
4719     }
4720
4721     return 0;
4722 }
4723
4724 /* In OpenFlow 1.0, 1.1, and 1.2, an OFPT_FEATURES_REPLY message lists all the
4725  * switch's ports, unless there are too many to fit.  In OpenFlow 1.3 and
4726  * later, an OFPT_FEATURES_REPLY does not list ports at all.
4727  *
4728  * Given a buffer 'b' that contains a Features Reply message, this message
4729  * checks if it contains a complete list of the switch's ports.  Returns true,
4730  * if so.  Returns false if the list is missing (OF1.3+) or incomplete
4731  * (OF1.0/1.1/1.2), and in the latter case removes all of the ports from the
4732  * message.
4733  *
4734  * When this function returns false, the caller should send an OFPST_PORT_DESC
4735  * stats request to get the ports. */
4736 bool
4737 ofputil_switch_features_has_ports(struct ofpbuf *b)
4738 {
4739     struct ofp_header *oh = b->data;
4740     size_t phy_port_size;
4741
4742     if (oh->version >= OFP13_VERSION) {
4743         /* OpenFlow 1.3+ never has ports in the feature reply. */
4744         return false;
4745     }
4746
4747     phy_port_size = (oh->version == OFP10_VERSION
4748                      ? sizeof(struct ofp10_phy_port)
4749                      : sizeof(struct ofp11_port));
4750     if (ntohs(oh->length) + phy_port_size <= UINT16_MAX) {
4751         /* There's room for additional ports in the feature reply.
4752          * Assume that the list is complete. */
4753         return true;
4754     }
4755
4756     /* The feature reply has no room for more ports.  Probably the list is
4757      * truncated.  Drop the ports and tell the caller to retrieve them with
4758      * OFPST_PORT_DESC. */
4759     b->size = sizeof *oh + sizeof(struct ofp_switch_features);
4760     ofpmsg_update_length(b);
4761     return false;
4762 }
4763
4764 /* Returns a buffer owned by the caller that encodes 'features' in the format
4765  * required by 'protocol' with the given 'xid'.  The caller should append port
4766  * information to the buffer with subsequent calls to
4767  * ofputil_put_switch_features_port(). */
4768 struct ofpbuf *
4769 ofputil_encode_switch_features(const struct ofputil_switch_features *features,
4770                                enum ofputil_protocol protocol, ovs_be32 xid)
4771 {
4772     struct ofp_switch_features *osf;
4773     struct ofpbuf *b;
4774     enum ofp_version version;
4775     enum ofpraw raw;
4776
4777     version = ofputil_protocol_to_ofp_version(protocol);
4778     switch (version) {
4779     case OFP10_VERSION:
4780         raw = OFPRAW_OFPT10_FEATURES_REPLY;
4781         break;
4782     case OFP11_VERSION:
4783     case OFP12_VERSION:
4784         raw = OFPRAW_OFPT11_FEATURES_REPLY;
4785         break;
4786     case OFP13_VERSION:
4787     case OFP14_VERSION:
4788     case OFP15_VERSION:
4789     case OFP16_VERSION:
4790         raw = OFPRAW_OFPT13_FEATURES_REPLY;
4791         break;
4792     default:
4793         OVS_NOT_REACHED();
4794     }
4795     b = ofpraw_alloc_xid(raw, version, xid, 0);
4796     osf = ofpbuf_put_zeros(b, sizeof *osf);
4797     osf->datapath_id = htonll(features->datapath_id);
4798     osf->n_buffers = htonl(features->n_buffers);
4799     osf->n_tables = features->n_tables;
4800
4801     osf->capabilities = htonl(features->capabilities & OFPC_COMMON);
4802     osf->capabilities = htonl(features->capabilities &
4803                               ofputil_capabilities_mask(version));
4804     switch (version) {
4805     case OFP10_VERSION:
4806         if (features->capabilities & OFPUTIL_C_STP) {
4807             osf->capabilities |= htonl(OFPC10_STP);
4808         }
4809         osf->actions = ofpact_bitmap_to_openflow(features->ofpacts,
4810                                                  OFP10_VERSION);
4811         break;
4812     case OFP13_VERSION:
4813     case OFP14_VERSION:
4814     case OFP15_VERSION:
4815     case OFP16_VERSION:
4816         osf->auxiliary_id = features->auxiliary_id;
4817         /* fall through */
4818     case OFP11_VERSION:
4819     case OFP12_VERSION:
4820         if (features->capabilities & OFPUTIL_C_GROUP_STATS) {
4821             osf->capabilities |= htonl(OFPC11_GROUP_STATS);
4822         }
4823         break;
4824     default:
4825         OVS_NOT_REACHED();
4826     }
4827
4828     return b;
4829 }
4830
4831 /* Encodes 'pp' into the format required by the switch_features message already
4832  * in 'b', which should have been returned by ofputil_encode_switch_features(),
4833  * and appends the encoded version to 'b'. */
4834 void
4835 ofputil_put_switch_features_port(const struct ofputil_phy_port *pp,
4836                                  struct ofpbuf *b)
4837 {
4838     const struct ofp_header *oh = b->data;
4839
4840     if (oh->version < OFP13_VERSION) {
4841         /* Try adding a port description to the message, but drop it again if
4842          * the buffer overflows.  (This possibility for overflow is why
4843          * OpenFlow 1.3+ moved port descriptions into a multipart message.)  */
4844         size_t start_ofs = b->size;
4845         ofputil_put_phy_port(oh->version, pp, b);
4846         if (b->size > UINT16_MAX) {
4847             b->size = start_ofs;
4848         }
4849     }
4850 }
4851 \f
4852 /* ofputil_port_status */
4853
4854 /* Decodes the OpenFlow "port status" message in '*ops' into an abstract form
4855  * in '*ps'.  Returns 0 if successful, otherwise an OFPERR_* value. */
4856 enum ofperr
4857 ofputil_decode_port_status(const struct ofp_header *oh,
4858                            struct ofputil_port_status *ps)
4859 {
4860     struct ofpbuf b = ofpbuf_const_initializer(oh, ntohs(oh->length));
4861     ofpraw_pull_assert(&b);
4862
4863     const struct ofp_port_status *ops = ofpbuf_pull(&b, sizeof *ops);
4864     if (ops->reason != OFPPR_ADD &&
4865         ops->reason != OFPPR_DELETE &&
4866         ops->reason != OFPPR_MODIFY) {
4867         return OFPERR_NXBRC_BAD_REASON;
4868     }
4869     ps->reason = ops->reason;
4870
4871     int retval = ofputil_pull_phy_port(oh->version, &b, &ps->desc);
4872     ovs_assert(retval != EOF);
4873     return retval;
4874 }
4875
4876 /* Converts the abstract form of a "port status" message in '*ps' into an
4877  * OpenFlow message suitable for 'protocol', and returns that encoded form in
4878  * a buffer owned by the caller. */
4879 struct ofpbuf *
4880 ofputil_encode_port_status(const struct ofputil_port_status *ps,
4881                            enum ofputil_protocol protocol)
4882 {
4883     struct ofp_port_status *ops;
4884     struct ofpbuf *b;
4885     enum ofp_version version;
4886     enum ofpraw raw;
4887
4888     version = ofputil_protocol_to_ofp_version(protocol);
4889     switch (version) {
4890     case OFP10_VERSION:
4891         raw = OFPRAW_OFPT10_PORT_STATUS;
4892         break;
4893
4894     case OFP11_VERSION:
4895     case OFP12_VERSION:
4896     case OFP13_VERSION:
4897         raw = OFPRAW_OFPT11_PORT_STATUS;
4898         break;
4899
4900     case OFP14_VERSION:
4901     case OFP15_VERSION:
4902     case OFP16_VERSION:
4903         raw = OFPRAW_OFPT14_PORT_STATUS;
4904         break;
4905
4906     default:
4907         OVS_NOT_REACHED();
4908     }
4909
4910     b = ofpraw_alloc_xid(raw, version, htonl(0), 0);
4911     ops = ofpbuf_put_zeros(b, sizeof *ops);
4912     ops->reason = ps->reason;
4913     ofputil_put_phy_port(version, &ps->desc, b);
4914     ofpmsg_update_length(b);
4915     return b;
4916 }
4917
4918 /* ofputil_port_mod */
4919
4920 static enum ofperr
4921 parse_port_mod_ethernet_property(struct ofpbuf *property,
4922                                  struct ofputil_port_mod *pm)
4923 {
4924     ovs_be32 advertise;
4925     enum ofperr error;
4926
4927     error = ofpprop_parse_be32(property, &advertise);
4928     if (!error) {
4929         pm->advertise = netdev_port_features_from_ofp11(advertise);
4930     }
4931     return error;
4932 }
4933
4934 /* Decodes the OpenFlow "port mod" message in '*oh' into an abstract form in
4935  * '*pm'.  Returns 0 if successful, otherwise an OFPERR_* value. */
4936 enum ofperr
4937 ofputil_decode_port_mod(const struct ofp_header *oh,
4938                         struct ofputil_port_mod *pm, bool loose)
4939 {
4940     struct ofpbuf b = ofpbuf_const_initializer(oh, ntohs(oh->length));
4941     enum ofpraw raw = ofpraw_pull_assert(&b);
4942     if (raw == OFPRAW_OFPT10_PORT_MOD) {
4943         const struct ofp10_port_mod *opm = b.data;
4944
4945         pm->port_no = u16_to_ofp(ntohs(opm->port_no));
4946         pm->hw_addr = opm->hw_addr;
4947         pm->config = ntohl(opm->config) & OFPPC10_ALL;
4948         pm->mask = ntohl(opm->mask) & OFPPC10_ALL;
4949         pm->advertise = netdev_port_features_from_ofp10(opm->advertise);
4950     } else if (raw == OFPRAW_OFPT11_PORT_MOD) {
4951         const struct ofp11_port_mod *opm = b.data;
4952         enum ofperr error;
4953
4954         error = ofputil_port_from_ofp11(opm->port_no, &pm->port_no);
4955         if (error) {
4956             return error;
4957         }
4958
4959         pm->hw_addr = opm->hw_addr;
4960         pm->config = ntohl(opm->config) & OFPPC11_ALL;
4961         pm->mask = ntohl(opm->mask) & OFPPC11_ALL;
4962         pm->advertise = netdev_port_features_from_ofp11(opm->advertise);
4963     } else if (raw == OFPRAW_OFPT14_PORT_MOD) {
4964         const struct ofp14_port_mod *opm = ofpbuf_pull(&b, sizeof *opm);
4965         enum ofperr error;
4966
4967         memset(pm, 0, sizeof *pm);
4968
4969         error = ofputil_port_from_ofp11(opm->port_no, &pm->port_no);
4970         if (error) {
4971             return error;
4972         }
4973
4974         pm->hw_addr = opm->hw_addr;
4975         pm->config = ntohl(opm->config) & OFPPC11_ALL;
4976         pm->mask = ntohl(opm->mask) & OFPPC11_ALL;
4977
4978         while (b.size > 0) {
4979             struct ofpbuf property;
4980             enum ofperr error;
4981             uint64_t type;
4982
4983             error = ofpprop_pull(&b, &property, &type);
4984             if (error) {
4985                 return error;
4986             }
4987
4988             switch (type) {
4989             case OFPPMPT14_ETHERNET:
4990                 error = parse_port_mod_ethernet_property(&property, pm);
4991                 break;
4992
4993             default:
4994                 error = OFPPROP_UNKNOWN(loose, "port_mod", type);
4995                 break;
4996             }
4997
4998             if (error) {
4999                 return error;
5000             }
5001         }
5002     } else {
5003         return OFPERR_OFPBRC_BAD_TYPE;
5004     }
5005
5006     pm->config &= pm->mask;
5007     return 0;
5008 }
5009
5010 /* Converts the abstract form of a "port mod" message in '*pm' into an OpenFlow
5011  * message suitable for 'protocol', and returns that encoded form in a buffer
5012  * owned by the caller. */
5013 struct ofpbuf *
5014 ofputil_encode_port_mod(const struct ofputil_port_mod *pm,
5015                         enum ofputil_protocol protocol)
5016 {
5017     enum ofp_version ofp_version = ofputil_protocol_to_ofp_version(protocol);
5018     struct ofpbuf *b;
5019
5020     switch (ofp_version) {
5021     case OFP10_VERSION: {
5022         struct ofp10_port_mod *opm;
5023
5024         b = ofpraw_alloc(OFPRAW_OFPT10_PORT_MOD, ofp_version, 0);
5025         opm = ofpbuf_put_zeros(b, sizeof *opm);
5026         opm->port_no = htons(ofp_to_u16(pm->port_no));
5027         opm->hw_addr = pm->hw_addr;
5028         opm->config = htonl(pm->config & OFPPC10_ALL);
5029         opm->mask = htonl(pm->mask & OFPPC10_ALL);
5030         opm->advertise = netdev_port_features_to_ofp10(pm->advertise);
5031         break;
5032     }
5033
5034     case OFP11_VERSION:
5035     case OFP12_VERSION:
5036     case OFP13_VERSION: {
5037         struct ofp11_port_mod *opm;
5038
5039         b = ofpraw_alloc(OFPRAW_OFPT11_PORT_MOD, ofp_version, 0);
5040         opm = ofpbuf_put_zeros(b, sizeof *opm);
5041         opm->port_no = ofputil_port_to_ofp11(pm->port_no);
5042         opm->hw_addr = pm->hw_addr;
5043         opm->config = htonl(pm->config & OFPPC11_ALL);
5044         opm->mask = htonl(pm->mask & OFPPC11_ALL);
5045         opm->advertise = netdev_port_features_to_ofp11(pm->advertise);
5046         break;
5047     }
5048     case OFP14_VERSION:
5049     case OFP15_VERSION:
5050     case OFP16_VERSION: {
5051         struct ofp14_port_mod *opm;
5052
5053         b = ofpraw_alloc(OFPRAW_OFPT14_PORT_MOD, ofp_version, 0);
5054         opm = ofpbuf_put_zeros(b, sizeof *opm);
5055         opm->port_no = ofputil_port_to_ofp11(pm->port_no);
5056         opm->hw_addr = pm->hw_addr;
5057         opm->config = htonl(pm->config & OFPPC11_ALL);
5058         opm->mask = htonl(pm->mask & OFPPC11_ALL);
5059
5060         if (pm->advertise) {
5061             ofpprop_put_be32(b, OFPPMPT14_ETHERNET,
5062                              netdev_port_features_to_ofp11(pm->advertise));
5063         }
5064         break;
5065     }
5066     default:
5067         OVS_NOT_REACHED();
5068     }
5069
5070     return b;
5071 }
5072 \f
5073 /* Table features. */
5074
5075 static enum ofperr
5076 pull_table_feature_property(struct ofpbuf *msg, struct ofpbuf *payload,
5077                             uint64_t *typep)
5078 {
5079     enum ofperr error;
5080
5081     error = ofpprop_pull(msg, payload, typep);
5082     if (payload && !error) {
5083         ofpbuf_pull(payload, (char *)payload->msg - (char *)payload->header);
5084     }
5085     return error;
5086 }
5087
5088 static enum ofperr
5089 parse_action_bitmap(struct ofpbuf *payload, enum ofp_version ofp_version,
5090                     uint64_t *ofpacts)
5091 {
5092     uint32_t types = 0;
5093
5094     while (payload->size > 0) {
5095         enum ofperr error;
5096         uint64_t type;
5097
5098         error = ofpprop_pull__(payload, NULL, 1, 0x10000, &type);
5099         if (error) {
5100             return error;
5101         }
5102         if (type < CHAR_BIT * sizeof types) {
5103             types |= 1u << type;
5104         }
5105     }
5106
5107     *ofpacts = ofpact_bitmap_from_openflow(htonl(types), ofp_version);
5108     return 0;
5109 }
5110
5111 static enum ofperr
5112 parse_instruction_ids(struct ofpbuf *payload, bool loose, uint32_t *insts)
5113 {
5114     *insts = 0;
5115     while (payload->size > 0) {
5116         enum ovs_instruction_type inst;
5117         enum ofperr error;
5118         uint64_t ofpit;
5119
5120         /* OF1.3 and OF1.4 aren't clear about padding in the instruction IDs.
5121          * It seems clear that they aren't padded to 8 bytes, though, because
5122          * both standards say that "non-experimenter instructions are 4 bytes"
5123          * and do not mention any padding before the first instruction ID.
5124          * (There wouldn't be any point in padding to 8 bytes if the IDs were
5125          * aligned on an odd 4-byte boundary.)
5126          *
5127          * Anyway, we just assume they're all glommed together on byte
5128          * boundaries. */
5129         error = ofpprop_pull__(payload, NULL, 1, 0x10000, &ofpit);
5130         if (error) {
5131             return error;
5132         }
5133
5134         error = ovs_instruction_type_from_inst_type(&inst, ofpit);
5135         if (!error) {
5136             *insts |= 1u << inst;
5137         } else if (!loose) {
5138             return error;
5139         }
5140     }
5141     return 0;
5142 }
5143
5144 static enum ofperr
5145 parse_table_features_next_table(struct ofpbuf *payload,
5146                                 unsigned long int *next_tables)
5147 {
5148     size_t i;
5149
5150     memset(next_tables, 0, bitmap_n_bytes(255));
5151     for (i = 0; i < payload->size; i++) {
5152         uint8_t id = ((const uint8_t *) payload->data)[i];
5153         if (id >= 255) {
5154             return OFPERR_OFPBPC_BAD_VALUE;
5155         }
5156         bitmap_set1(next_tables, id);
5157     }
5158     return 0;
5159 }
5160
5161 static enum ofperr
5162 parse_oxms(struct ofpbuf *payload, bool loose,
5163            struct mf_bitmap *exactp, struct mf_bitmap *maskedp)
5164 {
5165     struct mf_bitmap exact = MF_BITMAP_INITIALIZER;
5166     struct mf_bitmap masked = MF_BITMAP_INITIALIZER;
5167
5168     while (payload->size > 0) {
5169         const struct mf_field *field;
5170         enum ofperr error;
5171         bool hasmask;
5172
5173         error = nx_pull_header(payload, &field, &hasmask);
5174         if (!error) {
5175             bitmap_set1(hasmask ? masked.bm : exact.bm, field->id);
5176         } else if (error != OFPERR_OFPBMC_BAD_FIELD || !loose) {
5177             return error;
5178         }
5179     }
5180     if (exactp) {
5181         *exactp = exact;
5182     } else if (!bitmap_is_all_zeros(exact.bm, MFF_N_IDS)) {
5183         return OFPERR_OFPBMC_BAD_MASK;
5184     }
5185     if (maskedp) {
5186         *maskedp = masked;
5187     } else if (!bitmap_is_all_zeros(masked.bm, MFF_N_IDS)) {
5188         return OFPERR_OFPBMC_BAD_MASK;
5189     }
5190     return 0;
5191 }
5192
5193 /* Converts an OFPMP_TABLE_FEATURES request or reply in 'msg' into an abstract
5194  * ofputil_table_features in 'tf'.
5195  *
5196  * If 'loose' is true, this function ignores properties and values that it does
5197  * not understand, as a controller would want to do when interpreting
5198  * capabilities provided by a switch.  If 'loose' is false, this function
5199  * treats unknown properties and values as an error, as a switch would want to
5200  * do when interpreting a configuration request made by a controller.
5201  *
5202  * A single OpenFlow message can specify features for multiple tables.  Calling
5203  * this function multiple times for a single 'msg' iterates through the tables
5204  * in the message.  The caller must initially leave 'msg''s layer pointers null
5205  * and not modify them between calls.
5206  *
5207  * Returns 0 if successful, EOF if no tables were left in this 'msg', otherwise
5208  * a positive "enum ofperr" value. */
5209 int
5210 ofputil_decode_table_features(struct ofpbuf *msg,
5211                               struct ofputil_table_features *tf, bool loose)
5212 {
5213     memset(tf, 0, sizeof *tf);
5214
5215     if (!msg->header) {
5216         ofpraw_pull_assert(msg);
5217     }
5218
5219     if (!msg->size) {
5220         return EOF;
5221     }
5222
5223     const struct ofp_header *oh = msg->header;
5224     struct ofp13_table_features *otf = msg->data;
5225     if (msg->size < sizeof *otf) {
5226         return OFPERR_OFPBPC_BAD_LEN;
5227     }
5228
5229     unsigned int len = ntohs(otf->length);
5230     if (len < sizeof *otf || len % 8 || len > msg->size) {
5231         return OFPERR_OFPBPC_BAD_LEN;
5232     }
5233
5234     tf->table_id = otf->table_id;
5235     if (tf->table_id == OFPTT_ALL) {
5236         return OFPERR_OFPTFFC_BAD_TABLE;
5237     }
5238
5239     ovs_strlcpy(tf->name, otf->name, OFP_MAX_TABLE_NAME_LEN);
5240     tf->metadata_match = otf->metadata_match;
5241     tf->metadata_write = otf->metadata_write;
5242     tf->miss_config = OFPUTIL_TABLE_MISS_DEFAULT;
5243     if (oh->version >= OFP14_VERSION) {
5244         uint32_t caps = ntohl(otf->capabilities);
5245         tf->supports_eviction = (caps & OFPTC14_EVICTION) != 0;
5246         tf->supports_vacancy_events = (caps & OFPTC14_VACANCY_EVENTS) != 0;
5247     } else {
5248         tf->supports_eviction = -1;
5249         tf->supports_vacancy_events = -1;
5250     }
5251     tf->max_entries = ntohl(otf->max_entries);
5252
5253     struct ofpbuf properties = ofpbuf_const_initializer(ofpbuf_pull(msg, len),
5254                                                         len);
5255     ofpbuf_pull(&properties, sizeof *otf);
5256     while (properties.size > 0) {
5257         struct ofpbuf payload;
5258         enum ofperr error;
5259         uint64_t type;
5260
5261         error = pull_table_feature_property(&properties, &payload, &type);
5262         if (error) {
5263             return error;
5264         }
5265
5266         switch ((enum ofp13_table_feature_prop_type) type) {
5267         case OFPTFPT13_INSTRUCTIONS:
5268             error = parse_instruction_ids(&payload, loose,
5269                                           &tf->nonmiss.instructions);
5270             break;
5271         case OFPTFPT13_INSTRUCTIONS_MISS:
5272             error = parse_instruction_ids(&payload, loose,
5273                                           &tf->miss.instructions);
5274             break;
5275
5276         case OFPTFPT13_NEXT_TABLES:
5277             error = parse_table_features_next_table(&payload,
5278                                                     tf->nonmiss.next);
5279             break;
5280         case OFPTFPT13_NEXT_TABLES_MISS:
5281             error = parse_table_features_next_table(&payload, tf->miss.next);
5282             break;
5283
5284         case OFPTFPT13_WRITE_ACTIONS:
5285             error = parse_action_bitmap(&payload, oh->version,
5286                                         &tf->nonmiss.write.ofpacts);
5287             break;
5288         case OFPTFPT13_WRITE_ACTIONS_MISS:
5289             error = parse_action_bitmap(&payload, oh->version,
5290                                         &tf->miss.write.ofpacts);
5291             break;
5292
5293         case OFPTFPT13_APPLY_ACTIONS:
5294             error = parse_action_bitmap(&payload, oh->version,
5295                                         &tf->nonmiss.apply.ofpacts);
5296             break;
5297         case OFPTFPT13_APPLY_ACTIONS_MISS:
5298             error = parse_action_bitmap(&payload, oh->version,
5299                                         &tf->miss.apply.ofpacts);
5300             break;
5301
5302         case OFPTFPT13_MATCH:
5303             error = parse_oxms(&payload, loose, &tf->match, &tf->mask);
5304             break;
5305         case OFPTFPT13_WILDCARDS:
5306             error = parse_oxms(&payload, loose, &tf->wildcard, NULL);
5307             break;
5308
5309         case OFPTFPT13_WRITE_SETFIELD:
5310             error = parse_oxms(&payload, loose,
5311                                &tf->nonmiss.write.set_fields, NULL);
5312             break;
5313         case OFPTFPT13_WRITE_SETFIELD_MISS:
5314             error = parse_oxms(&payload, loose,
5315                                &tf->miss.write.set_fields, NULL);
5316             break;
5317         case OFPTFPT13_APPLY_SETFIELD:
5318             error = parse_oxms(&payload, loose,
5319                                &tf->nonmiss.apply.set_fields, NULL);
5320             break;
5321         case OFPTFPT13_APPLY_SETFIELD_MISS:
5322             error = parse_oxms(&payload, loose,
5323                                &tf->miss.apply.set_fields, NULL);
5324             break;
5325
5326         case OFPTFPT13_EXPERIMENTER:
5327         case OFPTFPT13_EXPERIMENTER_MISS:
5328         default:
5329             error = OFPPROP_UNKNOWN(loose, "table features", type);
5330             break;
5331         }
5332         if (error) {
5333             return error;
5334         }
5335     }
5336
5337     /* Fix inconsistencies:
5338      *
5339      *     - Turn on 'match' bits that are set in 'mask', because maskable
5340      *       fields are matchable.
5341      *
5342      *     - Turn on 'wildcard' bits that are set in 'mask', because a field
5343      *       that is arbitrarily maskable can be wildcarded entirely.
5344      *
5345      *     - Turn off 'wildcard' bits that are not in 'match', because a field
5346      *       must be matchable for it to be meaningfully wildcarded. */
5347     bitmap_or(tf->match.bm, tf->mask.bm, MFF_N_IDS);
5348     bitmap_or(tf->wildcard.bm, tf->mask.bm, MFF_N_IDS);
5349     bitmap_and(tf->wildcard.bm, tf->match.bm, MFF_N_IDS);
5350
5351     return 0;
5352 }
5353
5354 /* Encodes and returns a request to obtain the table features of a switch.
5355  * The message is encoded for OpenFlow version 'ofp_version'. */
5356 struct ofpbuf *
5357 ofputil_encode_table_features_request(enum ofp_version ofp_version)
5358 {
5359     struct ofpbuf *request = NULL;
5360
5361     switch (ofp_version) {
5362     case OFP10_VERSION:
5363     case OFP11_VERSION:
5364     case OFP12_VERSION:
5365         ovs_fatal(0, "dump-table-features needs OpenFlow 1.3 or later "
5366                      "(\'-O OpenFlow13\')");
5367     case OFP13_VERSION:
5368     case OFP14_VERSION:
5369     case OFP15_VERSION:
5370     case OFP16_VERSION:
5371         request = ofpraw_alloc(OFPRAW_OFPST13_TABLE_FEATURES_REQUEST,
5372                                ofp_version, 0);
5373         break;
5374     default:
5375         OVS_NOT_REACHED();
5376     }
5377
5378     return request;
5379 }
5380
5381 static void
5382 put_fields_property(struct ofpbuf *reply,
5383                     const struct mf_bitmap *fields,
5384                     const struct mf_bitmap *masks,
5385                     enum ofp13_table_feature_prop_type property,
5386                     enum ofp_version version)
5387 {
5388     size_t start_ofs;
5389     int field;
5390
5391     start_ofs = ofpprop_start(reply, property);
5392     BITMAP_FOR_EACH_1 (field, MFF_N_IDS, fields->bm) {
5393         nx_put_header(reply, field, version,
5394                       masks && bitmap_is_set(masks->bm, field));
5395     }
5396     ofpprop_end(reply, start_ofs);
5397 }
5398
5399 static void
5400 put_table_action_features(struct ofpbuf *reply,
5401                           const struct ofputil_table_action_features *taf,
5402                           enum ofp13_table_feature_prop_type actions_type,
5403                           enum ofp13_table_feature_prop_type set_fields_type,
5404                           int miss_offset, enum ofp_version version)
5405 {
5406     ofpprop_put_bitmap(reply, actions_type + miss_offset,
5407                        ntohl(ofpact_bitmap_to_openflow(taf->ofpacts,
5408                                                        version)));
5409     put_fields_property(reply, &taf->set_fields, NULL,
5410                         set_fields_type + miss_offset, version);
5411 }
5412
5413 static void
5414 put_table_instruction_features(
5415     struct ofpbuf *reply, const struct ofputil_table_instruction_features *tif,
5416     int miss_offset, enum ofp_version version)
5417 {
5418     size_t start_ofs;
5419     uint8_t table_id;
5420
5421     ofpprop_put_bitmap(reply, OFPTFPT13_INSTRUCTIONS + miss_offset,
5422                        ntohl(ovsinst_bitmap_to_openflow(tif->instructions,
5423                                                         version)));
5424
5425     start_ofs = ofpprop_start(reply, OFPTFPT13_NEXT_TABLES + miss_offset);
5426     BITMAP_FOR_EACH_1 (table_id, 255, tif->next) {
5427         ofpbuf_put(reply, &table_id, 1);
5428     }
5429     ofpprop_end(reply, start_ofs);
5430
5431     put_table_action_features(reply, &tif->write,
5432                               OFPTFPT13_WRITE_ACTIONS,
5433                               OFPTFPT13_WRITE_SETFIELD, miss_offset, version);
5434     put_table_action_features(reply, &tif->apply,
5435                               OFPTFPT13_APPLY_ACTIONS,
5436                               OFPTFPT13_APPLY_SETFIELD, miss_offset, version);
5437 }
5438
5439 void
5440 ofputil_append_table_features_reply(const struct ofputil_table_features *tf,
5441                                     struct ovs_list *replies)
5442 {
5443     struct ofpbuf *reply = ofpbuf_from_list(ovs_list_back(replies));
5444     enum ofp_version version = ofpmp_version(replies);
5445     size_t start_ofs = reply->size;
5446     struct ofp13_table_features *otf;
5447
5448     otf = ofpbuf_put_zeros(reply, sizeof *otf);
5449     otf->table_id = tf->table_id;
5450     ovs_strlcpy(otf->name, tf->name, sizeof otf->name);
5451     otf->metadata_match = tf->metadata_match;
5452     otf->metadata_write = tf->metadata_write;
5453     if (version >= OFP14_VERSION) {
5454         if (tf->supports_eviction) {
5455             otf->capabilities |= htonl(OFPTC14_EVICTION);
5456         }
5457         if (tf->supports_vacancy_events) {
5458             otf->capabilities |= htonl(OFPTC14_VACANCY_EVENTS);
5459         }
5460     }
5461     otf->max_entries = htonl(tf->max_entries);
5462
5463     put_table_instruction_features(reply, &tf->nonmiss, 0, version);
5464     put_table_instruction_features(reply, &tf->miss, 1, version);
5465
5466     put_fields_property(reply, &tf->match, &tf->mask,
5467                         OFPTFPT13_MATCH, version);
5468     put_fields_property(reply, &tf->wildcard, NULL,
5469                         OFPTFPT13_WILDCARDS, version);
5470
5471     otf = ofpbuf_at_assert(reply, start_ofs, sizeof *otf);
5472     otf->length = htons(reply->size - start_ofs);
5473     ofpmp_postappend(replies, start_ofs);
5474 }
5475
5476 static enum ofperr
5477 parse_table_desc_vacancy_property(struct ofpbuf *property,
5478                                   struct ofputil_table_desc *td)
5479 {
5480     struct ofp14_table_mod_prop_vacancy *otv = property->data;
5481
5482     if (property->size != sizeof *otv) {
5483         return OFPERR_OFPBPC_BAD_LEN;
5484     }
5485
5486     td->table_vacancy.vacancy_down = otv->vacancy_down;
5487     td->table_vacancy.vacancy_up = otv->vacancy_up;
5488     td->table_vacancy.vacancy = otv->vacancy;
5489     return 0;
5490 }
5491
5492 /* Decodes the next OpenFlow "table desc" message (of possibly several) from
5493  * 'msg' into an abstract form in '*td'.  Returns 0 if successful, EOF if the
5494  * last "table desc" in 'msg' was already decoded, otherwise an OFPERR_*
5495  * value. */
5496 int
5497 ofputil_decode_table_desc(struct ofpbuf *msg,
5498                           struct ofputil_table_desc *td,
5499                           enum ofp_version version)
5500 {
5501     memset(td, 0, sizeof *td);
5502
5503     if (!msg->header) {
5504         ofpraw_pull_assert(msg);
5505     }
5506
5507     if (!msg->size) {
5508         return EOF;
5509     }
5510
5511     struct ofp14_table_desc *otd = ofpbuf_try_pull(msg, sizeof *otd);
5512     if (!otd) {
5513         VLOG_WARN_RL(&bad_ofmsg_rl, "OFP14_TABLE_DESC reply has %"PRIu32" "
5514                      "leftover bytes at end", msg->size);
5515         return OFPERR_OFPBRC_BAD_LEN;
5516     }
5517
5518     td->table_id = otd->table_id;
5519     size_t length = ntohs(otd->length);
5520     if (length < sizeof *otd || length - sizeof *otd > msg->size) {
5521         VLOG_WARN_RL(&bad_ofmsg_rl, "OFP14_TABLE_DESC reply claims invalid "
5522                      "length %"PRIuSIZE, length);
5523         return OFPERR_OFPBRC_BAD_LEN;
5524     }
5525     length -= sizeof *otd;
5526
5527     td->eviction = ofputil_decode_table_eviction(otd->config, version);
5528     td->vacancy = ofputil_decode_table_vacancy(otd->config, version);
5529     td->eviction_flags = UINT32_MAX;
5530
5531     struct ofpbuf properties = ofpbuf_const_initializer(
5532         ofpbuf_pull(msg, length), length);
5533     while (properties.size > 0) {
5534         struct ofpbuf payload;
5535         enum ofperr error;
5536         uint64_t type;
5537
5538         error = ofpprop_pull(&properties, &payload, &type);
5539         if (error) {
5540             return error;
5541         }
5542
5543         switch (type) {
5544         case OFPTMPT14_EVICTION:
5545             error = ofpprop_parse_u32(&payload, &td->eviction_flags);
5546             break;
5547
5548         case OFPTMPT14_VACANCY:
5549             error = parse_table_desc_vacancy_property(&payload, td);
5550             break;
5551
5552         default:
5553             error = OFPPROP_UNKNOWN(true, "table_desc", type);
5554             break;
5555         }
5556
5557         if (error) {
5558             return error;
5559         }
5560     }
5561
5562     return 0;
5563 }
5564
5565 /* Encodes and returns a request to obtain description of tables of a switch.
5566  * The message is encoded for OpenFlow version 'ofp_version'. */
5567 struct ofpbuf *
5568 ofputil_encode_table_desc_request(enum ofp_version ofp_version)
5569 {
5570     struct ofpbuf *request = NULL;
5571
5572     if (ofp_version >= OFP14_VERSION) {
5573         request = ofpraw_alloc(OFPRAW_OFPST14_TABLE_DESC_REQUEST,
5574                                ofp_version, 0);
5575     } else {
5576         ovs_fatal(0, "dump-table-desc needs OpenFlow 1.4 or later "
5577                   "(\'-O OpenFlow14\')");
5578     }
5579
5580     return request;
5581 }
5582
5583 /* Function to append Table desc information in a reply list. */
5584 void
5585 ofputil_append_table_desc_reply(const struct ofputil_table_desc *td,
5586                                 struct ovs_list *replies,
5587                                 enum ofp_version version)
5588 {
5589     struct ofpbuf *reply = ofpbuf_from_list(ovs_list_back(replies));
5590     size_t start_otd;
5591     struct ofp14_table_desc *otd;
5592
5593     start_otd = reply->size;
5594     ofpbuf_put_zeros(reply, sizeof *otd);
5595     if (td->eviction_flags != UINT32_MAX) {
5596         ofpprop_put_u32(reply, OFPTMPT14_EVICTION, td->eviction_flags);
5597     }
5598     if (td->vacancy == OFPUTIL_TABLE_VACANCY_ON) {
5599         struct ofp14_table_mod_prop_vacancy *otv;
5600
5601         otv = ofpprop_put_zeros(reply, OFPTMPT14_VACANCY, sizeof *otv);
5602         otv->vacancy_down = td->table_vacancy.vacancy_down;
5603         otv->vacancy_up = td->table_vacancy.vacancy_up;
5604         otv->vacancy = td->table_vacancy.vacancy;
5605     }
5606
5607     otd = ofpbuf_at_assert(reply, start_otd, sizeof *otd);
5608     otd->length = htons(reply->size - start_otd);
5609     otd->table_id = td->table_id;
5610     otd->config = ofputil_encode_table_config(OFPUTIL_TABLE_MISS_DEFAULT,
5611                                               td->eviction, td->vacancy,
5612                                               version);
5613     ofpmp_postappend(replies, start_otd);
5614 }
5615
5616 /* This function parses Vacancy property, and decodes the
5617  * ofp14_table_mod_prop_vacancy in ofputil_table_mod.
5618  * Returns OFPERR_OFPBPC_BAD_VALUE error code when vacancy_down is
5619  * greater than vacancy_up and also when current vacancy has non-zero
5620  * value. Returns 0 on success. */
5621 static enum ofperr
5622 parse_table_mod_vacancy_property(struct ofpbuf *property,
5623                                  struct ofputil_table_mod *tm)
5624 {
5625     struct ofp14_table_mod_prop_vacancy *otv = property->data;
5626
5627     if (property->size != sizeof *otv) {
5628         return OFPERR_OFPBPC_BAD_LEN;
5629     }
5630     tm->table_vacancy.vacancy_down = otv->vacancy_down;
5631     tm->table_vacancy.vacancy_up = otv->vacancy_up;
5632     if (tm->table_vacancy.vacancy_down > tm->table_vacancy.vacancy_up) {
5633         OFPPROP_LOG(&bad_ofmsg_rl, false,
5634                     "Value of vacancy_down is greater than vacancy_up");
5635         return OFPERR_OFPBPC_BAD_VALUE;
5636     }
5637     if (tm->table_vacancy.vacancy_down > 100 ||
5638         tm->table_vacancy.vacancy_up > 100) {
5639         OFPPROP_LOG(&bad_ofmsg_rl, false, "Vacancy threshold percentage "
5640                     "should not be greater than 100");
5641         return OFPERR_OFPBPC_BAD_VALUE;
5642     }
5643     tm->table_vacancy.vacancy = otv->vacancy;
5644     if (tm->table_vacancy.vacancy) {
5645         OFPPROP_LOG(&bad_ofmsg_rl, false,
5646                     "Vacancy value should be zero for table-mod messages");
5647         return OFPERR_OFPBPC_BAD_VALUE;
5648     }
5649     return 0;
5650 }
5651
5652 /* Given 'config', taken from an OpenFlow 'version' message that specifies
5653  * table configuration (a table mod, table stats, or table features message),
5654  * returns the table vacancy configuration that it specifies.
5655  *
5656  * Only OpenFlow 1.4 and later specify table vacancy configuration this way,
5657  * so for other 'version' this function always returns
5658  * OFPUTIL_TABLE_VACANCY_DEFAULT. */
5659 static enum ofputil_table_vacancy
5660 ofputil_decode_table_vacancy(ovs_be32 config, enum ofp_version version)
5661 {
5662     return (version < OFP14_VERSION ? OFPUTIL_TABLE_VACANCY_DEFAULT
5663             : config & htonl(OFPTC14_VACANCY_EVENTS) ? OFPUTIL_TABLE_VACANCY_ON
5664             : OFPUTIL_TABLE_VACANCY_OFF);
5665 }
5666
5667 /* Given 'config', taken from an OpenFlow 'version' message that specifies
5668  * table configuration (a table mod, table stats, or table features message),
5669  * returns the table eviction configuration that it specifies.
5670  *
5671  * Only OpenFlow 1.4 and later specify table eviction configuration this way,
5672  * so for other 'version' values this function always returns
5673  * OFPUTIL_TABLE_EVICTION_DEFAULT. */
5674 static enum ofputil_table_eviction
5675 ofputil_decode_table_eviction(ovs_be32 config, enum ofp_version version)
5676 {
5677     return (version < OFP14_VERSION ? OFPUTIL_TABLE_EVICTION_DEFAULT
5678             : config & htonl(OFPTC14_EVICTION) ? OFPUTIL_TABLE_EVICTION_ON
5679             : OFPUTIL_TABLE_EVICTION_OFF);
5680 }
5681
5682 /* Returns a bitmap of OFPTC* values suitable for 'config' fields in various
5683  * OpenFlow messages of the given 'version', based on the provided 'miss' and
5684  * 'eviction' values. */
5685 static ovs_be32
5686 ofputil_encode_table_config(enum ofputil_table_miss miss,
5687                             enum ofputil_table_eviction eviction,
5688                             enum ofputil_table_vacancy vacancy,
5689                             enum ofp_version version)
5690 {
5691     uint32_t config = 0;
5692     /* See the section "OFPTC_* Table Configuration" in DESIGN.md for more
5693      * information on the crazy evolution of this field. */
5694     switch (version) {
5695     case OFP10_VERSION:
5696         /* OpenFlow 1.0 didn't have such a field, any value ought to do. */
5697         return htonl(0);
5698
5699     case OFP11_VERSION:
5700     case OFP12_VERSION:
5701         /* OpenFlow 1.1 and 1.2 define only OFPTC11_TABLE_MISS_*. */
5702         switch (miss) {
5703         case OFPUTIL_TABLE_MISS_DEFAULT:
5704             /* Really this shouldn't be used for encoding (the caller should
5705              * provide a specific value) but I can't imagine that defaulting to
5706              * the fall-through case here will hurt. */
5707         case OFPUTIL_TABLE_MISS_CONTROLLER:
5708         default:
5709             return htonl(OFPTC11_TABLE_MISS_CONTROLLER);
5710         case OFPUTIL_TABLE_MISS_CONTINUE:
5711             return htonl(OFPTC11_TABLE_MISS_CONTINUE);
5712         case OFPUTIL_TABLE_MISS_DROP:
5713             return htonl(OFPTC11_TABLE_MISS_DROP);
5714         }
5715         OVS_NOT_REACHED();
5716
5717     case OFP13_VERSION:
5718         /* OpenFlow 1.3 removed OFPTC11_TABLE_MISS_* and didn't define any new
5719          * flags, so this is correct. */
5720         return htonl(0);
5721
5722     case OFP14_VERSION:
5723     case OFP15_VERSION:
5724     case OFP16_VERSION:
5725         /* OpenFlow 1.4 introduced OFPTC14_EVICTION and
5726          * OFPTC14_VACANCY_EVENTS. */
5727         if (eviction == OFPUTIL_TABLE_EVICTION_ON) {
5728             config |= OFPTC14_EVICTION;
5729         }
5730         if (vacancy == OFPUTIL_TABLE_VACANCY_ON) {
5731             config |= OFPTC14_VACANCY_EVENTS;
5732         }
5733         return htonl(config);
5734     }
5735
5736     OVS_NOT_REACHED();
5737 }
5738
5739 /* Given 'config', taken from an OpenFlow 'version' message that specifies
5740  * table configuration (a table mod, table stats, or table features message),
5741  * returns the table miss configuration that it specifies.
5742  *
5743  * Only OpenFlow 1.1 and 1.2 specify table miss configurations this way, so for
5744  * other 'version' values this function always returns
5745  * OFPUTIL_TABLE_MISS_DEFAULT. */
5746 static enum ofputil_table_miss
5747 ofputil_decode_table_miss(ovs_be32 config_, enum ofp_version version)
5748 {
5749     uint32_t config = ntohl(config_);
5750
5751     if (version == OFP11_VERSION || version == OFP12_VERSION) {
5752         switch (config & OFPTC11_TABLE_MISS_MASK) {
5753         case OFPTC11_TABLE_MISS_CONTROLLER:
5754             return OFPUTIL_TABLE_MISS_CONTROLLER;
5755
5756         case OFPTC11_TABLE_MISS_CONTINUE:
5757             return OFPUTIL_TABLE_MISS_CONTINUE;
5758
5759         case OFPTC11_TABLE_MISS_DROP:
5760             return OFPUTIL_TABLE_MISS_DROP;
5761
5762         default:
5763             VLOG_WARN_RL(&bad_ofmsg_rl, "bad table miss config %d", config);
5764             return OFPUTIL_TABLE_MISS_CONTROLLER;
5765         }
5766     } else {
5767         return OFPUTIL_TABLE_MISS_DEFAULT;
5768     }
5769 }
5770
5771 /* Decodes the OpenFlow "table mod" message in '*oh' into an abstract form in
5772  * '*pm'.  Returns 0 if successful, otherwise an OFPERR_* value. */
5773 enum ofperr
5774 ofputil_decode_table_mod(const struct ofp_header *oh,
5775                          struct ofputil_table_mod *pm)
5776 {
5777     memset(pm, 0, sizeof *pm);
5778     pm->miss = OFPUTIL_TABLE_MISS_DEFAULT;
5779     pm->eviction = OFPUTIL_TABLE_EVICTION_DEFAULT;
5780     pm->eviction_flags = UINT32_MAX;
5781     pm->vacancy = OFPUTIL_TABLE_VACANCY_DEFAULT;
5782
5783     struct ofpbuf b = ofpbuf_const_initializer(oh, ntohs(oh->length));
5784     enum ofpraw raw = ofpraw_pull_assert(&b);
5785     if (raw == OFPRAW_OFPT11_TABLE_MOD) {
5786         const struct ofp11_table_mod *otm = b.data;
5787
5788         pm->table_id = otm->table_id;
5789         pm->miss = ofputil_decode_table_miss(otm->config, oh->version);
5790     } else if (raw == OFPRAW_OFPT14_TABLE_MOD) {
5791         const struct ofp14_table_mod *otm = ofpbuf_pull(&b, sizeof *otm);
5792
5793         pm->table_id = otm->table_id;
5794         pm->miss = ofputil_decode_table_miss(otm->config, oh->version);
5795         pm->eviction = ofputil_decode_table_eviction(otm->config, oh->version);
5796         pm->vacancy = ofputil_decode_table_vacancy(otm->config, oh->version);
5797         while (b.size > 0) {
5798             struct ofpbuf property;
5799             enum ofperr error;
5800             uint64_t type;
5801
5802             error = ofpprop_pull(&b, &property, &type);
5803             if (error) {
5804                 return error;
5805             }
5806
5807             switch (type) {
5808             case OFPTMPT14_EVICTION:
5809                 error = ofpprop_parse_u32(&property, &pm->eviction);
5810                 break;
5811
5812             case OFPTMPT14_VACANCY:
5813                 error = parse_table_mod_vacancy_property(&property, pm);
5814                 break;
5815
5816             default:
5817                 error = OFPERR_OFPBRC_BAD_TYPE;
5818                 break;
5819             }
5820
5821             if (error) {
5822                 return error;
5823             }
5824         }
5825     } else {
5826         return OFPERR_OFPBRC_BAD_TYPE;
5827     }
5828
5829     return 0;
5830 }
5831
5832 /* Converts the abstract form of a "table mod" message in '*tm' into an
5833  * OpenFlow message suitable for 'protocol', and returns that encoded form in a
5834  * buffer owned by the caller. */
5835 struct ofpbuf *
5836 ofputil_encode_table_mod(const struct ofputil_table_mod *tm,
5837                         enum ofputil_protocol protocol)
5838 {
5839     enum ofp_version ofp_version = ofputil_protocol_to_ofp_version(protocol);
5840     struct ofpbuf *b;
5841
5842     switch (ofp_version) {
5843     case OFP10_VERSION: {
5844         ovs_fatal(0, "table mod needs OpenFlow 1.1 or later "
5845                      "(\'-O OpenFlow11\')");
5846         break;
5847     }
5848     case OFP11_VERSION:
5849     case OFP12_VERSION:
5850     case OFP13_VERSION: {
5851         struct ofp11_table_mod *otm;
5852
5853         b = ofpraw_alloc(OFPRAW_OFPT11_TABLE_MOD, ofp_version, 0);
5854         otm = ofpbuf_put_zeros(b, sizeof *otm);
5855         otm->table_id = tm->table_id;
5856         otm->config = ofputil_encode_table_config(tm->miss, tm->eviction,
5857                                                   tm->vacancy, ofp_version);
5858         break;
5859     }
5860     case OFP14_VERSION:
5861     case OFP15_VERSION:
5862     case OFP16_VERSION: {
5863         struct ofp14_table_mod *otm;
5864
5865         b = ofpraw_alloc(OFPRAW_OFPT14_TABLE_MOD, ofp_version, 0);
5866         otm = ofpbuf_put_zeros(b, sizeof *otm);
5867         otm->table_id = tm->table_id;
5868         otm->config = ofputil_encode_table_config(tm->miss, tm->eviction,
5869                                                   tm->vacancy, ofp_version);
5870
5871         if (tm->eviction_flags != UINT32_MAX) {
5872             ofpprop_put_u32(b, OFPTMPT14_EVICTION, tm->eviction_flags);
5873         }
5874         if (tm->vacancy == OFPUTIL_TABLE_VACANCY_ON) {
5875             struct ofp14_table_mod_prop_vacancy *otv;
5876
5877             otv = ofpprop_put_zeros(b, OFPTMPT14_VACANCY, sizeof *otv);
5878             otv->vacancy_down = tm->table_vacancy.vacancy_down;
5879             otv->vacancy_up = tm->table_vacancy.vacancy_up;
5880         }
5881         break;
5882     }
5883     default:
5884         OVS_NOT_REACHED();
5885     }
5886
5887     return b;
5888 }
5889 \f
5890 /* ofputil_role_request */
5891
5892 /* Decodes the OpenFlow "role request" or "role reply" message in '*oh' into
5893  * an abstract form in '*rr'.  Returns 0 if successful, otherwise an
5894  * OFPERR_* value. */
5895 enum ofperr
5896 ofputil_decode_role_message(const struct ofp_header *oh,
5897                             struct ofputil_role_request *rr)
5898 {
5899     struct ofpbuf b = ofpbuf_const_initializer(oh, ntohs(oh->length));
5900     enum ofpraw raw = ofpraw_pull_assert(&b);
5901     if (raw == OFPRAW_OFPT12_ROLE_REQUEST ||
5902         raw == OFPRAW_OFPT12_ROLE_REPLY) {
5903         const struct ofp12_role_request *orr = b.msg;
5904
5905         if (orr->role != htonl(OFPCR12_ROLE_NOCHANGE) &&
5906             orr->role != htonl(OFPCR12_ROLE_EQUAL) &&
5907             orr->role != htonl(OFPCR12_ROLE_MASTER) &&
5908             orr->role != htonl(OFPCR12_ROLE_SLAVE)) {
5909             return OFPERR_OFPRRFC_BAD_ROLE;
5910         }
5911
5912         rr->role = ntohl(orr->role);
5913         if (raw == OFPRAW_OFPT12_ROLE_REQUEST
5914             ? orr->role == htonl(OFPCR12_ROLE_NOCHANGE)
5915             : orr->generation_id == OVS_BE64_MAX) {
5916             rr->have_generation_id = false;
5917             rr->generation_id = 0;
5918         } else {
5919             rr->have_generation_id = true;
5920             rr->generation_id = ntohll(orr->generation_id);
5921         }
5922     } else if (raw == OFPRAW_NXT_ROLE_REQUEST ||
5923                raw == OFPRAW_NXT_ROLE_REPLY) {
5924         const struct nx_role_request *nrr = b.msg;
5925
5926         BUILD_ASSERT(NX_ROLE_OTHER + 1 == OFPCR12_ROLE_EQUAL);
5927         BUILD_ASSERT(NX_ROLE_MASTER + 1 == OFPCR12_ROLE_MASTER);
5928         BUILD_ASSERT(NX_ROLE_SLAVE + 1 == OFPCR12_ROLE_SLAVE);
5929
5930         if (nrr->role != htonl(NX_ROLE_OTHER) &&
5931             nrr->role != htonl(NX_ROLE_MASTER) &&
5932             nrr->role != htonl(NX_ROLE_SLAVE)) {
5933             return OFPERR_OFPRRFC_BAD_ROLE;
5934         }
5935
5936         rr->role = ntohl(nrr->role) + 1;
5937         rr->have_generation_id = false;
5938         rr->generation_id = 0;
5939     } else {
5940         OVS_NOT_REACHED();
5941     }
5942
5943     return 0;
5944 }
5945
5946 /* Returns an encoded form of a role reply suitable for the "request" in a
5947  * buffer owned by the caller. */
5948 struct ofpbuf *
5949 ofputil_encode_role_reply(const struct ofp_header *request,
5950                           const struct ofputil_role_request *rr)
5951 {
5952     struct ofpbuf *buf;
5953     enum ofpraw raw;
5954
5955     raw = ofpraw_decode_assert(request);
5956     if (raw == OFPRAW_OFPT12_ROLE_REQUEST) {
5957         struct ofp12_role_request *orr;
5958
5959         buf = ofpraw_alloc_reply(OFPRAW_OFPT12_ROLE_REPLY, request, 0);
5960         orr = ofpbuf_put_zeros(buf, sizeof *orr);
5961
5962         orr->role = htonl(rr->role);
5963         orr->generation_id = htonll(rr->have_generation_id
5964                                     ? rr->generation_id
5965                                     : UINT64_MAX);
5966     } else if (raw == OFPRAW_NXT_ROLE_REQUEST) {
5967         struct nx_role_request *nrr;
5968
5969         BUILD_ASSERT(NX_ROLE_OTHER == OFPCR12_ROLE_EQUAL - 1);
5970         BUILD_ASSERT(NX_ROLE_MASTER == OFPCR12_ROLE_MASTER - 1);
5971         BUILD_ASSERT(NX_ROLE_SLAVE == OFPCR12_ROLE_SLAVE - 1);
5972
5973         buf = ofpraw_alloc_reply(OFPRAW_NXT_ROLE_REPLY, request, 0);
5974         nrr = ofpbuf_put_zeros(buf, sizeof *nrr);
5975         nrr->role = htonl(rr->role - 1);
5976     } else {
5977         OVS_NOT_REACHED();
5978     }
5979
5980     return buf;
5981 }
5982 \f
5983 /* Encodes "role status" message 'status' for sending in the given
5984  * 'protocol'.  Returns the role status message, if 'protocol' supports them,
5985  * otherwise a null pointer. */
5986 struct ofpbuf *
5987 ofputil_encode_role_status(const struct ofputil_role_status *status,
5988                            enum ofputil_protocol protocol)
5989 {
5990     enum ofp_version version;
5991
5992     version = ofputil_protocol_to_ofp_version(protocol);
5993     if (version >= OFP14_VERSION) {
5994         struct ofp14_role_status *rstatus;
5995         struct ofpbuf *buf;
5996
5997         buf = ofpraw_alloc_xid(OFPRAW_OFPT14_ROLE_STATUS, version, htonl(0),
5998                                0);
5999         rstatus = ofpbuf_put_zeros(buf, sizeof *rstatus);
6000         rstatus->role = htonl(status->role);
6001         rstatus->reason = status->reason;
6002         rstatus->generation_id = htonll(status->generation_id);
6003
6004         return buf;
6005     } else {
6006         return NULL;
6007     }
6008 }
6009
6010 enum ofperr
6011 ofputil_decode_role_status(const struct ofp_header *oh,
6012                            struct ofputil_role_status *rs)
6013 {
6014     struct ofpbuf b = ofpbuf_const_initializer(oh, ntohs(oh->length));
6015     enum ofpraw raw = ofpraw_pull_assert(&b);
6016     ovs_assert(raw == OFPRAW_OFPT14_ROLE_STATUS);
6017
6018     const struct ofp14_role_status *r = b.msg;
6019     if (r->role != htonl(OFPCR12_ROLE_NOCHANGE) &&
6020         r->role != htonl(OFPCR12_ROLE_EQUAL) &&
6021         r->role != htonl(OFPCR12_ROLE_MASTER) &&
6022         r->role != htonl(OFPCR12_ROLE_SLAVE)) {
6023         return OFPERR_OFPRRFC_BAD_ROLE;
6024     }
6025
6026     rs->role = ntohl(r->role);
6027     rs->generation_id = ntohll(r->generation_id);
6028     rs->reason = r->reason;
6029
6030     return 0;
6031 }
6032
6033 /* Encodes 'rf' according to 'protocol', and returns the encoded message.
6034  * 'protocol' must be for OpenFlow 1.4 or later. */
6035 struct ofpbuf *
6036 ofputil_encode_requestforward(const struct ofputil_requestforward *rf,
6037                               enum ofputil_protocol protocol)
6038 {
6039     enum ofp_version ofp_version = ofputil_protocol_to_ofp_version(protocol);
6040     struct ofpbuf *inner;
6041
6042     switch (rf->reason) {
6043     case OFPRFR_GROUP_MOD:
6044         inner = ofputil_encode_group_mod(ofp_version, rf->group_mod);
6045         break;
6046
6047     case OFPRFR_METER_MOD:
6048         inner = ofputil_encode_meter_mod(ofp_version, rf->meter_mod);
6049         break;
6050
6051     case OFPRFR_N_REASONS:
6052     default:
6053         OVS_NOT_REACHED();
6054     }
6055
6056     struct ofp_header *inner_oh = inner->data;
6057     inner_oh->xid = rf->xid;
6058     inner_oh->length = htons(inner->size);
6059
6060     struct ofpbuf *outer = ofpraw_alloc_xid(OFPRAW_OFPT14_REQUESTFORWARD,
6061                                             ofp_version, htonl(0),
6062                                             inner->size);
6063     ofpbuf_put(outer, inner->data, inner->size);
6064     ofpbuf_delete(inner);
6065
6066     return outer;
6067 }
6068
6069 /* Decodes OFPT_REQUESTFORWARD message 'outer'.  On success, puts the decoded
6070  * form into '*rf' and returns 0, and the caller is later responsible for
6071  * freeing the content of 'rf', with ofputil_destroy_requestforward(rf).  On
6072  * failure, returns an ofperr and '*rf' is indeterminate. */
6073 enum ofperr
6074 ofputil_decode_requestforward(const struct ofp_header *outer,
6075                               struct ofputil_requestforward *rf)
6076 {
6077     struct ofpbuf b = ofpbuf_const_initializer(outer, ntohs(outer->length));
6078
6079     /* Skip past outer message. */
6080     enum ofpraw outer_raw = ofpraw_pull_assert(&b);
6081     ovs_assert(outer_raw == OFPRAW_OFPT14_REQUESTFORWARD);
6082
6083     /* Validate inner message. */
6084     if (b.size < sizeof(struct ofp_header)) {
6085         return OFPERR_OFPBFC_MSG_BAD_LEN;
6086     }
6087     const struct ofp_header *inner = b.data;
6088     unsigned int inner_len = ntohs(inner->length);
6089     if (inner_len < sizeof(struct ofp_header) || inner_len > b.size) {
6090         return OFPERR_OFPBFC_MSG_BAD_LEN;
6091     }
6092     if (inner->version != outer->version) {
6093         return OFPERR_OFPBRC_BAD_VERSION;
6094     }
6095
6096     /* Parse inner message. */
6097     enum ofptype type;
6098     enum ofperr error = ofptype_decode(&type, inner);
6099     if (error) {
6100         return error;
6101     }
6102
6103     rf->xid = inner->xid;
6104     if (type == OFPTYPE_GROUP_MOD) {
6105         rf->reason = OFPRFR_GROUP_MOD;
6106         rf->group_mod = xmalloc(sizeof *rf->group_mod);
6107         error = ofputil_decode_group_mod(inner, rf->group_mod);
6108         if (error) {
6109             free(rf->group_mod);
6110             return error;
6111         }
6112     } else if (type == OFPTYPE_METER_MOD) {
6113         rf->reason = OFPRFR_METER_MOD;
6114         rf->meter_mod = xmalloc(sizeof *rf->meter_mod);
6115         ofpbuf_init(&rf->bands, 64);
6116         error = ofputil_decode_meter_mod(inner, rf->meter_mod, &rf->bands);
6117         if (error) {
6118             free(rf->meter_mod);
6119             ofpbuf_uninit(&rf->bands);
6120             return error;
6121         }
6122     } else {
6123         return OFPERR_OFPBFC_MSG_UNSUP;
6124     }
6125
6126     return 0;
6127 }
6128
6129 /* Frees the content of 'rf', which should have been initialized through a
6130  * successful call to ofputil_decode_requestforward(). */
6131 void
6132 ofputil_destroy_requestforward(struct ofputil_requestforward *rf)
6133 {
6134     if (!rf) {
6135         return;
6136     }
6137
6138     switch (rf->reason) {
6139     case OFPRFR_GROUP_MOD:
6140         ofputil_uninit_group_mod(rf->group_mod);
6141         free(rf->group_mod);
6142         break;
6143
6144     case OFPRFR_METER_MOD:
6145         ofpbuf_uninit(&rf->bands);
6146         free(rf->meter_mod);
6147         break;
6148
6149     case OFPRFR_N_REASONS:
6150         OVS_NOT_REACHED();
6151     }
6152 }
6153
6154 /* Table stats. */
6155
6156 /* OpenFlow 1.0 and 1.1 don't distinguish between a field that cannot be
6157  * matched and a field that must be wildcarded.  This function returns a bitmap
6158  * that contains both kinds of fields. */
6159 static struct mf_bitmap
6160 wild_or_nonmatchable_fields(const struct ofputil_table_features *features)
6161 {
6162     struct mf_bitmap wc = features->match;
6163     bitmap_not(wc.bm, MFF_N_IDS);
6164     bitmap_or(wc.bm, features->wildcard.bm, MFF_N_IDS);
6165     return wc;
6166 }
6167
6168 struct ofp10_wc_map {
6169     enum ofp10_flow_wildcards wc10;
6170     enum mf_field_id mf;
6171 };
6172
6173 static const struct ofp10_wc_map ofp10_wc_map[] = {
6174     { OFPFW10_IN_PORT,     MFF_IN_PORT },
6175     { OFPFW10_DL_VLAN,     MFF_VLAN_VID },
6176     { OFPFW10_DL_SRC,      MFF_ETH_SRC },
6177     { OFPFW10_DL_DST,      MFF_ETH_DST},
6178     { OFPFW10_DL_TYPE,     MFF_ETH_TYPE },
6179     { OFPFW10_NW_PROTO,    MFF_IP_PROTO },
6180     { OFPFW10_TP_SRC,      MFF_TCP_SRC },
6181     { OFPFW10_TP_DST,      MFF_TCP_DST },
6182     { OFPFW10_NW_SRC_MASK, MFF_IPV4_SRC },
6183     { OFPFW10_NW_DST_MASK, MFF_IPV4_DST },
6184     { OFPFW10_DL_VLAN_PCP, MFF_VLAN_PCP },
6185     { OFPFW10_NW_TOS,      MFF_IP_DSCP },
6186 };
6187
6188 static ovs_be32
6189 mf_bitmap_to_of10(const struct mf_bitmap *fields)
6190 {
6191     const struct ofp10_wc_map *p;
6192     uint32_t wc10 = 0;
6193
6194     for (p = ofp10_wc_map; p < &ofp10_wc_map[ARRAY_SIZE(ofp10_wc_map)]; p++) {
6195         if (bitmap_is_set(fields->bm, p->mf)) {
6196             wc10 |= p->wc10;
6197         }
6198     }
6199     return htonl(wc10);
6200 }
6201
6202 static struct mf_bitmap
6203 mf_bitmap_from_of10(ovs_be32 wc10_)
6204 {
6205     struct mf_bitmap fields = MF_BITMAP_INITIALIZER;
6206     const struct ofp10_wc_map *p;
6207     uint32_t wc10 = ntohl(wc10_);
6208
6209     for (p = ofp10_wc_map; p < &ofp10_wc_map[ARRAY_SIZE(ofp10_wc_map)]; p++) {
6210         if (wc10 & p->wc10) {
6211             bitmap_set1(fields.bm, p->mf);
6212         }
6213     }
6214     return fields;
6215 }
6216
6217 static void
6218 ofputil_put_ofp10_table_stats(const struct ofputil_table_stats *stats,
6219                               const struct ofputil_table_features *features,
6220                               struct ofpbuf *buf)
6221 {
6222     struct mf_bitmap wc = wild_or_nonmatchable_fields(features);
6223     struct ofp10_table_stats *out;
6224
6225     out = ofpbuf_put_zeros(buf, sizeof *out);
6226     out->table_id = features->table_id;
6227     ovs_strlcpy(out->name, features->name, sizeof out->name);
6228     out->wildcards = mf_bitmap_to_of10(&wc);
6229     out->max_entries = htonl(features->max_entries);
6230     out->active_count = htonl(stats->active_count);
6231     put_32aligned_be64(&out->lookup_count, htonll(stats->lookup_count));
6232     put_32aligned_be64(&out->matched_count, htonll(stats->matched_count));
6233 }
6234
6235 struct ofp11_wc_map {
6236     enum ofp11_flow_match_fields wc11;
6237     enum mf_field_id mf;
6238 };
6239
6240 static const struct ofp11_wc_map ofp11_wc_map[] = {
6241     { OFPFMF11_IN_PORT,     MFF_IN_PORT },
6242     { OFPFMF11_DL_VLAN,     MFF_VLAN_VID },
6243     { OFPFMF11_DL_VLAN_PCP, MFF_VLAN_PCP },
6244     { OFPFMF11_DL_TYPE,     MFF_ETH_TYPE },
6245     { OFPFMF11_NW_TOS,      MFF_IP_DSCP },
6246     { OFPFMF11_NW_PROTO,    MFF_IP_PROTO },
6247     { OFPFMF11_TP_SRC,      MFF_TCP_SRC },
6248     { OFPFMF11_TP_DST,      MFF_TCP_DST },
6249     { OFPFMF11_MPLS_LABEL,  MFF_MPLS_LABEL },
6250     { OFPFMF11_MPLS_TC,     MFF_MPLS_TC },
6251     /* I don't know what OFPFMF11_TYPE means. */
6252     { OFPFMF11_DL_SRC,      MFF_ETH_SRC },
6253     { OFPFMF11_DL_DST,      MFF_ETH_DST },
6254     { OFPFMF11_NW_SRC,      MFF_IPV4_SRC },
6255     { OFPFMF11_NW_DST,      MFF_IPV4_DST },
6256     { OFPFMF11_METADATA,    MFF_METADATA },
6257 };
6258
6259 static ovs_be32
6260 mf_bitmap_to_of11(const struct mf_bitmap *fields)
6261 {
6262     const struct ofp11_wc_map *p;
6263     uint32_t wc11 = 0;
6264
6265     for (p = ofp11_wc_map; p < &ofp11_wc_map[ARRAY_SIZE(ofp11_wc_map)]; p++) {
6266         if (bitmap_is_set(fields->bm, p->mf)) {
6267             wc11 |= p->wc11;
6268         }
6269     }
6270     return htonl(wc11);
6271 }
6272
6273 static struct mf_bitmap
6274 mf_bitmap_from_of11(ovs_be32 wc11_)
6275 {
6276     struct mf_bitmap fields = MF_BITMAP_INITIALIZER;
6277     const struct ofp11_wc_map *p;
6278     uint32_t wc11 = ntohl(wc11_);
6279
6280     for (p = ofp11_wc_map; p < &ofp11_wc_map[ARRAY_SIZE(ofp11_wc_map)]; p++) {
6281         if (wc11 & p->wc11) {
6282             bitmap_set1(fields.bm, p->mf);
6283         }
6284     }
6285     return fields;
6286 }
6287
6288 static void
6289 ofputil_put_ofp11_table_stats(const struct ofputil_table_stats *stats,
6290                               const struct ofputil_table_features *features,
6291                               struct ofpbuf *buf)
6292 {
6293     struct mf_bitmap wc = wild_or_nonmatchable_fields(features);
6294     struct ofp11_table_stats *out;
6295
6296     out = ofpbuf_put_zeros(buf, sizeof *out);
6297     out->table_id = features->table_id;
6298     ovs_strlcpy(out->name, features->name, sizeof out->name);
6299     out->wildcards = mf_bitmap_to_of11(&wc);
6300     out->match = mf_bitmap_to_of11(&features->match);
6301     out->instructions = ovsinst_bitmap_to_openflow(
6302         features->nonmiss.instructions, OFP11_VERSION);
6303     out->write_actions = ofpact_bitmap_to_openflow(
6304         features->nonmiss.write.ofpacts, OFP11_VERSION);
6305     out->apply_actions = ofpact_bitmap_to_openflow(
6306         features->nonmiss.apply.ofpacts, OFP11_VERSION);
6307     out->config = htonl(features->miss_config);
6308     out->max_entries = htonl(features->max_entries);
6309     out->active_count = htonl(stats->active_count);
6310     out->lookup_count = htonll(stats->lookup_count);
6311     out->matched_count = htonll(stats->matched_count);
6312 }
6313
6314 static void
6315 ofputil_put_ofp12_table_stats(const struct ofputil_table_stats *stats,
6316                               const struct ofputil_table_features *features,
6317                               struct ofpbuf *buf)
6318 {
6319     struct ofp12_table_stats *out;
6320
6321     out = ofpbuf_put_zeros(buf, sizeof *out);
6322     out->table_id = features->table_id;
6323     ovs_strlcpy(out->name, features->name, sizeof out->name);
6324     out->match = oxm_bitmap_from_mf_bitmap(&features->match, OFP12_VERSION);
6325     out->wildcards = oxm_bitmap_from_mf_bitmap(&features->wildcard,
6326                                              OFP12_VERSION);
6327     out->write_actions = ofpact_bitmap_to_openflow(
6328         features->nonmiss.write.ofpacts, OFP12_VERSION);
6329     out->apply_actions = ofpact_bitmap_to_openflow(
6330         features->nonmiss.apply.ofpacts, OFP12_VERSION);
6331     out->write_setfields = oxm_bitmap_from_mf_bitmap(
6332         &features->nonmiss.write.set_fields, OFP12_VERSION);
6333     out->apply_setfields = oxm_bitmap_from_mf_bitmap(
6334         &features->nonmiss.apply.set_fields, OFP12_VERSION);
6335     out->metadata_match = features->metadata_match;
6336     out->metadata_write = features->metadata_write;
6337     out->instructions = ovsinst_bitmap_to_openflow(
6338         features->nonmiss.instructions, OFP12_VERSION);
6339     out->config = ofputil_encode_table_config(features->miss_config,
6340                                               OFPUTIL_TABLE_EVICTION_DEFAULT,
6341                                               OFPUTIL_TABLE_VACANCY_DEFAULT,
6342                                               OFP12_VERSION);
6343     out->max_entries = htonl(features->max_entries);
6344     out->active_count = htonl(stats->active_count);
6345     out->lookup_count = htonll(stats->lookup_count);
6346     out->matched_count = htonll(stats->matched_count);
6347 }
6348
6349 static void
6350 ofputil_put_ofp13_table_stats(const struct ofputil_table_stats *stats,
6351                               struct ofpbuf *buf)
6352 {
6353     struct ofp13_table_stats *out;
6354
6355     out = ofpbuf_put_zeros(buf, sizeof *out);
6356     out->table_id = stats->table_id;
6357     out->active_count = htonl(stats->active_count);
6358     out->lookup_count = htonll(stats->lookup_count);
6359     out->matched_count = htonll(stats->matched_count);
6360 }
6361
6362 struct ofpbuf *
6363 ofputil_encode_table_stats_reply(const struct ofp_header *request)
6364 {
6365     return ofpraw_alloc_stats_reply(request, 0);
6366 }
6367
6368 void
6369 ofputil_append_table_stats_reply(struct ofpbuf *reply,
6370                                  const struct ofputil_table_stats *stats,
6371                                  const struct ofputil_table_features *features)
6372 {
6373     struct ofp_header *oh = reply->header;
6374
6375     ovs_assert(stats->table_id == features->table_id);
6376
6377     switch ((enum ofp_version) oh->version) {
6378     case OFP10_VERSION:
6379         ofputil_put_ofp10_table_stats(stats, features, reply);
6380         break;
6381
6382     case OFP11_VERSION:
6383         ofputil_put_ofp11_table_stats(stats, features, reply);
6384         break;
6385
6386     case OFP12_VERSION:
6387         ofputil_put_ofp12_table_stats(stats, features, reply);
6388         break;
6389
6390     case OFP13_VERSION:
6391     case OFP14_VERSION:
6392     case OFP15_VERSION:
6393     case OFP16_VERSION:
6394         ofputil_put_ofp13_table_stats(stats, reply);
6395         break;
6396
6397     default:
6398         OVS_NOT_REACHED();
6399     }
6400 }
6401
6402 static int
6403 ofputil_decode_ofp10_table_stats(struct ofpbuf *msg,
6404                                  struct ofputil_table_stats *stats,
6405                                  struct ofputil_table_features *features)
6406 {
6407     struct ofp10_table_stats *ots;
6408
6409     ots = ofpbuf_try_pull(msg, sizeof *ots);
6410     if (!ots) {
6411         return OFPERR_OFPBRC_BAD_LEN;
6412     }
6413
6414     features->table_id = ots->table_id;
6415     ovs_strlcpy(features->name, ots->name, sizeof features->name);
6416     features->max_entries = ntohl(ots->max_entries);
6417     features->match = features->wildcard = mf_bitmap_from_of10(ots->wildcards);
6418
6419     stats->table_id = ots->table_id;
6420     stats->active_count = ntohl(ots->active_count);
6421     stats->lookup_count = ntohll(get_32aligned_be64(&ots->lookup_count));
6422     stats->matched_count = ntohll(get_32aligned_be64(&ots->matched_count));
6423
6424     return 0;
6425 }
6426
6427 static int
6428 ofputil_decode_ofp11_table_stats(struct ofpbuf *msg,
6429                                  struct ofputil_table_stats *stats,
6430                                  struct ofputil_table_features *features)
6431 {
6432     struct ofp11_table_stats *ots;
6433
6434     ots = ofpbuf_try_pull(msg, sizeof *ots);
6435     if (!ots) {
6436         return OFPERR_OFPBRC_BAD_LEN;
6437     }
6438
6439     features->table_id = ots->table_id;
6440     ovs_strlcpy(features->name, ots->name, sizeof features->name);
6441     features->max_entries = ntohl(ots->max_entries);
6442     features->nonmiss.instructions = ovsinst_bitmap_from_openflow(
6443         ots->instructions, OFP11_VERSION);
6444     features->nonmiss.write.ofpacts = ofpact_bitmap_from_openflow(
6445         ots->write_actions, OFP11_VERSION);
6446     features->nonmiss.apply.ofpacts = ofpact_bitmap_from_openflow(
6447         ots->write_actions, OFP11_VERSION);
6448     features->miss = features->nonmiss;
6449     features->miss_config = ofputil_decode_table_miss(ots->config,
6450                                                       OFP11_VERSION);
6451     features->match = mf_bitmap_from_of11(ots->match);
6452     features->wildcard = mf_bitmap_from_of11(ots->wildcards);
6453     bitmap_or(features->match.bm, features->wildcard.bm, MFF_N_IDS);
6454
6455     stats->table_id = ots->table_id;
6456     stats->active_count = ntohl(ots->active_count);
6457     stats->lookup_count = ntohll(ots->lookup_count);
6458     stats->matched_count = ntohll(ots->matched_count);
6459
6460     return 0;
6461 }
6462
6463 static int
6464 ofputil_decode_ofp12_table_stats(struct ofpbuf *msg,
6465                                  struct ofputil_table_stats *stats,
6466                                  struct ofputil_table_features *features)
6467 {
6468     struct ofp12_table_stats *ots;
6469
6470     ots = ofpbuf_try_pull(msg, sizeof *ots);
6471     if (!ots) {
6472         return OFPERR_OFPBRC_BAD_LEN;
6473     }
6474
6475     features->table_id = ots->table_id;
6476     ovs_strlcpy(features->name, ots->name, sizeof features->name);
6477     features->metadata_match = ots->metadata_match;
6478     features->metadata_write = ots->metadata_write;
6479     features->miss_config = ofputil_decode_table_miss(ots->config,
6480                                                       OFP12_VERSION);
6481     features->max_entries = ntohl(ots->max_entries);
6482
6483     features->nonmiss.instructions = ovsinst_bitmap_from_openflow(
6484         ots->instructions, OFP12_VERSION);
6485     features->nonmiss.write.ofpacts = ofpact_bitmap_from_openflow(
6486         ots->write_actions, OFP12_VERSION);
6487     features->nonmiss.apply.ofpacts = ofpact_bitmap_from_openflow(
6488         ots->apply_actions, OFP12_VERSION);
6489     features->nonmiss.write.set_fields = oxm_bitmap_to_mf_bitmap(
6490         ots->write_setfields, OFP12_VERSION);
6491     features->nonmiss.apply.set_fields = oxm_bitmap_to_mf_bitmap(
6492         ots->apply_setfields, OFP12_VERSION);
6493     features->miss = features->nonmiss;
6494
6495     features->match = oxm_bitmap_to_mf_bitmap(ots->match, OFP12_VERSION);
6496     features->wildcard = oxm_bitmap_to_mf_bitmap(ots->wildcards,
6497                                                  OFP12_VERSION);
6498     bitmap_or(features->match.bm, features->wildcard.bm, MFF_N_IDS);
6499
6500     stats->table_id = ots->table_id;
6501     stats->active_count = ntohl(ots->active_count);
6502     stats->lookup_count = ntohll(ots->lookup_count);
6503     stats->matched_count = ntohll(ots->matched_count);
6504
6505     return 0;
6506 }
6507
6508 static int
6509 ofputil_decode_ofp13_table_stats(struct ofpbuf *msg,
6510                                  struct ofputil_table_stats *stats,
6511                                  struct ofputil_table_features *features)
6512 {
6513     struct ofp13_table_stats *ots;
6514
6515     ots = ofpbuf_try_pull(msg, sizeof *ots);
6516     if (!ots) {
6517         return OFPERR_OFPBRC_BAD_LEN;
6518     }
6519
6520     features->table_id = ots->table_id;
6521
6522     stats->table_id = ots->table_id;
6523     stats->active_count = ntohl(ots->active_count);
6524     stats->lookup_count = ntohll(ots->lookup_count);
6525     stats->matched_count = ntohll(ots->matched_count);
6526
6527     return 0;
6528 }
6529
6530 int
6531 ofputil_decode_table_stats_reply(struct ofpbuf *msg,
6532                                  struct ofputil_table_stats *stats,
6533                                  struct ofputil_table_features *features)
6534 {
6535     const struct ofp_header *oh;
6536
6537     if (!msg->header) {
6538         ofpraw_pull_assert(msg);
6539     }
6540     oh = msg->header;
6541
6542     if (!msg->size) {
6543         return EOF;
6544     }
6545
6546     memset(stats, 0, sizeof *stats);
6547     memset(features, 0, sizeof *features);
6548     features->supports_eviction = -1;
6549     features->supports_vacancy_events = -1;
6550
6551     switch ((enum ofp_version) oh->version) {
6552     case OFP10_VERSION:
6553         return ofputil_decode_ofp10_table_stats(msg, stats, features);
6554
6555     case OFP11_VERSION:
6556         return ofputil_decode_ofp11_table_stats(msg, stats, features);
6557
6558     case OFP12_VERSION:
6559         return ofputil_decode_ofp12_table_stats(msg, stats, features);
6560
6561     case OFP13_VERSION:
6562     case OFP14_VERSION:
6563     case OFP15_VERSION:
6564     case OFP16_VERSION:
6565         return ofputil_decode_ofp13_table_stats(msg, stats, features);
6566
6567     default:
6568         OVS_NOT_REACHED();
6569     }
6570 }
6571 \f
6572 /* ofputil_flow_monitor_request */
6573
6574 /* Converts an NXST_FLOW_MONITOR request in 'msg' into an abstract
6575  * ofputil_flow_monitor_request in 'rq'.
6576  *
6577  * Multiple NXST_FLOW_MONITOR requests can be packed into a single OpenFlow
6578  * message.  Calling this function multiple times for a single 'msg' iterates
6579  * through the requests.  The caller must initially leave 'msg''s layer
6580  * pointers null and not modify them between calls.
6581  *
6582  * Returns 0 if successful, EOF if no requests were left in this 'msg',
6583  * otherwise an OFPERR_* value. */
6584 int
6585 ofputil_decode_flow_monitor_request(struct ofputil_flow_monitor_request *rq,
6586                                     struct ofpbuf *msg)
6587 {
6588     struct nx_flow_monitor_request *nfmr;
6589     uint16_t flags;
6590
6591     if (!msg->header) {
6592         ofpraw_pull_assert(msg);
6593     }
6594
6595     if (!msg->size) {
6596         return EOF;
6597     }
6598
6599     nfmr = ofpbuf_try_pull(msg, sizeof *nfmr);
6600     if (!nfmr) {
6601         VLOG_WARN_RL(&bad_ofmsg_rl, "NXST_FLOW_MONITOR request has %"PRIu32" "
6602                      "leftover bytes at end", msg->size);
6603         return OFPERR_OFPBRC_BAD_LEN;
6604     }
6605
6606     flags = ntohs(nfmr->flags);
6607     if (!(flags & (NXFMF_ADD | NXFMF_DELETE | NXFMF_MODIFY))
6608         || flags & ~(NXFMF_INITIAL | NXFMF_ADD | NXFMF_DELETE
6609                      | NXFMF_MODIFY | NXFMF_ACTIONS | NXFMF_OWN)) {
6610         VLOG_WARN_RL(&bad_ofmsg_rl, "NXST_FLOW_MONITOR has bad flags %#"PRIx16,
6611                      flags);
6612         return OFPERR_OFPMOFC_BAD_FLAGS;
6613     }
6614
6615     if (!is_all_zeros(nfmr->zeros, sizeof nfmr->zeros)) {
6616         return OFPERR_NXBRC_MUST_BE_ZERO;
6617     }
6618
6619     rq->id = ntohl(nfmr->id);
6620     rq->flags = flags;
6621     rq->out_port = u16_to_ofp(ntohs(nfmr->out_port));
6622     rq->table_id = nfmr->table_id;
6623
6624     return nx_pull_match(msg, ntohs(nfmr->match_len), &rq->match, NULL, NULL);
6625 }
6626
6627 void
6628 ofputil_append_flow_monitor_request(
6629     const struct ofputil_flow_monitor_request *rq, struct ofpbuf *msg)
6630 {
6631     struct nx_flow_monitor_request *nfmr;
6632     size_t start_ofs;
6633     int match_len;
6634
6635     if (!msg->size) {
6636         ofpraw_put(OFPRAW_NXST_FLOW_MONITOR_REQUEST, OFP10_VERSION, msg);
6637     }
6638
6639     start_ofs = msg->size;
6640     ofpbuf_put_zeros(msg, sizeof *nfmr);
6641     match_len = nx_put_match(msg, &rq->match, htonll(0), htonll(0));
6642
6643     nfmr = ofpbuf_at_assert(msg, start_ofs, sizeof *nfmr);
6644     nfmr->id = htonl(rq->id);
6645     nfmr->flags = htons(rq->flags);
6646     nfmr->out_port = htons(ofp_to_u16(rq->out_port));
6647     nfmr->match_len = htons(match_len);
6648     nfmr->table_id = rq->table_id;
6649 }
6650
6651 /* Converts an NXST_FLOW_MONITOR reply (also known as a flow update) in 'msg'
6652  * into an abstract ofputil_flow_update in 'update'.  The caller must have
6653  * initialized update->match to point to space allocated for a match.
6654  *
6655  * Uses 'ofpacts' to store the abstract OFPACT_* version of the update's
6656  * actions (except for NXFME_ABBREV, which never includes actions).  The caller
6657  * must initialize 'ofpacts' and retains ownership of it.  'update->ofpacts'
6658  * will point into the 'ofpacts' buffer.
6659  *
6660  * Multiple flow updates can be packed into a single OpenFlow message.  Calling
6661  * this function multiple times for a single 'msg' iterates through the
6662  * updates.  The caller must initially leave 'msg''s layer pointers null and
6663  * not modify them between calls.
6664  *
6665  * Returns 0 if successful, EOF if no updates were left in this 'msg',
6666  * otherwise an OFPERR_* value. */
6667 int
6668 ofputil_decode_flow_update(struct ofputil_flow_update *update,
6669                            struct ofpbuf *msg, struct ofpbuf *ofpacts)
6670 {
6671     struct nx_flow_update_header *nfuh;
6672     unsigned int length;
6673     struct ofp_header *oh;
6674
6675     if (!msg->header) {
6676         ofpraw_pull_assert(msg);
6677     }
6678
6679     ofpbuf_clear(ofpacts);
6680     if (!msg->size) {
6681         return EOF;
6682     }
6683
6684     if (msg->size < sizeof(struct nx_flow_update_header)) {
6685         goto bad_len;
6686     }
6687
6688     oh = msg->header;
6689
6690     nfuh = msg->data;
6691     update->event = ntohs(nfuh->event);
6692     length = ntohs(nfuh->length);
6693     if (length > msg->size || length % 8) {
6694         goto bad_len;
6695     }
6696
6697     if (update->event == NXFME_ABBREV) {
6698         struct nx_flow_update_abbrev *nfua;
6699
6700         if (length != sizeof *nfua) {
6701             goto bad_len;
6702         }
6703
6704         nfua = ofpbuf_pull(msg, sizeof *nfua);
6705         update->xid = nfua->xid;
6706         return 0;
6707     } else if (update->event == NXFME_ADDED
6708                || update->event == NXFME_DELETED
6709                || update->event == NXFME_MODIFIED) {
6710         struct nx_flow_update_full *nfuf;
6711         unsigned int actions_len;
6712         unsigned int match_len;
6713         enum ofperr error;
6714
6715         if (length < sizeof *nfuf) {
6716             goto bad_len;
6717         }
6718
6719         nfuf = ofpbuf_pull(msg, sizeof *nfuf);
6720         match_len = ntohs(nfuf->match_len);
6721         if (sizeof *nfuf + match_len > length) {
6722             goto bad_len;
6723         }
6724
6725         update->reason = ntohs(nfuf->reason);
6726         update->idle_timeout = ntohs(nfuf->idle_timeout);
6727         update->hard_timeout = ntohs(nfuf->hard_timeout);
6728         update->table_id = nfuf->table_id;
6729         update->cookie = nfuf->cookie;
6730         update->priority = ntohs(nfuf->priority);
6731
6732         error = nx_pull_match(msg, match_len, update->match, NULL, NULL);
6733         if (error) {
6734             return error;
6735         }
6736
6737         actions_len = length - sizeof *nfuf - ROUND_UP(match_len, 8);
6738         error = ofpacts_pull_openflow_actions(msg, actions_len, oh->version,
6739                                               ofpacts);
6740         if (error) {
6741             return error;
6742         }
6743
6744         update->ofpacts = ofpacts->data;
6745         update->ofpacts_len = ofpacts->size;
6746         return 0;
6747     } else {
6748         VLOG_WARN_RL(&bad_ofmsg_rl,
6749                      "NXST_FLOW_MONITOR reply has bad event %"PRIu16,
6750                      ntohs(nfuh->event));
6751         return OFPERR_NXBRC_FM_BAD_EVENT;
6752     }
6753
6754 bad_len:
6755     VLOG_WARN_RL(&bad_ofmsg_rl, "NXST_FLOW_MONITOR reply has %"PRIu32" "
6756                  "leftover bytes at end", msg->size);
6757     return OFPERR_OFPBRC_BAD_LEN;
6758 }
6759
6760 uint32_t
6761 ofputil_decode_flow_monitor_cancel(const struct ofp_header *oh)
6762 {
6763     const struct nx_flow_monitor_cancel *cancel = ofpmsg_body(oh);
6764
6765     return ntohl(cancel->id);
6766 }
6767
6768 struct ofpbuf *
6769 ofputil_encode_flow_monitor_cancel(uint32_t id)
6770 {
6771     struct nx_flow_monitor_cancel *nfmc;
6772     struct ofpbuf *msg;
6773
6774     msg = ofpraw_alloc(OFPRAW_NXT_FLOW_MONITOR_CANCEL, OFP10_VERSION, 0);
6775     nfmc = ofpbuf_put_uninit(msg, sizeof *nfmc);
6776     nfmc->id = htonl(id);
6777     return msg;
6778 }
6779
6780 void
6781 ofputil_start_flow_update(struct ovs_list *replies)
6782 {
6783     struct ofpbuf *msg;
6784
6785     msg = ofpraw_alloc_xid(OFPRAW_NXST_FLOW_MONITOR_REPLY, OFP10_VERSION,
6786                            htonl(0), 1024);
6787
6788     ovs_list_init(replies);
6789     ovs_list_push_back(replies, &msg->list_node);
6790 }
6791
6792 void
6793 ofputil_append_flow_update(const struct ofputil_flow_update *update,
6794                            struct ovs_list *replies)
6795 {
6796     enum ofp_version version = ofpmp_version(replies);
6797     struct nx_flow_update_header *nfuh;
6798     struct ofpbuf *msg;
6799     size_t start_ofs;
6800
6801     msg = ofpbuf_from_list(ovs_list_back(replies));
6802     start_ofs = msg->size;
6803
6804     if (update->event == NXFME_ABBREV) {
6805         struct nx_flow_update_abbrev *nfua;
6806
6807         nfua = ofpbuf_put_zeros(msg, sizeof *nfua);
6808         nfua->xid = update->xid;
6809     } else {
6810         struct nx_flow_update_full *nfuf;
6811         int match_len;
6812
6813         ofpbuf_put_zeros(msg, sizeof *nfuf);
6814         match_len = nx_put_match(msg, update->match, htonll(0), htonll(0));
6815         ofpacts_put_openflow_actions(update->ofpacts, update->ofpacts_len, msg,
6816                                      version);
6817         nfuf = ofpbuf_at_assert(msg, start_ofs, sizeof *nfuf);
6818         nfuf->reason = htons(update->reason);
6819         nfuf->priority = htons(update->priority);
6820         nfuf->idle_timeout = htons(update->idle_timeout);
6821         nfuf->hard_timeout = htons(update->hard_timeout);
6822         nfuf->match_len = htons(match_len);
6823         nfuf->table_id = update->table_id;
6824         nfuf->cookie = update->cookie;
6825     }
6826
6827     nfuh = ofpbuf_at_assert(msg, start_ofs, sizeof *nfuh);
6828     nfuh->length = htons(msg->size - start_ofs);
6829     nfuh->event = htons(update->event);
6830
6831     ofpmp_postappend(replies, start_ofs);
6832 }
6833 \f
6834 struct ofpbuf *
6835 ofputil_encode_packet_out(const struct ofputil_packet_out *po,
6836                           enum ofputil_protocol protocol)
6837 {
6838     enum ofp_version ofp_version = ofputil_protocol_to_ofp_version(protocol);
6839     struct ofpbuf *msg;
6840     size_t size;
6841
6842     size = po->ofpacts_len;
6843     if (po->buffer_id == UINT32_MAX) {
6844         size += po->packet_len;
6845     }
6846
6847     switch (ofp_version) {
6848     case OFP10_VERSION: {
6849         struct ofp10_packet_out *opo;
6850         size_t actions_ofs;
6851
6852         msg = ofpraw_alloc(OFPRAW_OFPT10_PACKET_OUT, OFP10_VERSION, size);
6853         ofpbuf_put_zeros(msg, sizeof *opo);
6854         actions_ofs = msg->size;
6855         ofpacts_put_openflow_actions(po->ofpacts, po->ofpacts_len, msg,
6856                                      ofp_version);
6857
6858         opo = msg->msg;
6859         opo->buffer_id = htonl(po->buffer_id);
6860         opo->in_port = htons(ofp_to_u16(po->in_port));
6861         opo->actions_len = htons(msg->size - actions_ofs);
6862         break;
6863     }
6864
6865     case OFP11_VERSION:
6866     case OFP12_VERSION:
6867     case OFP13_VERSION:
6868     case OFP14_VERSION:
6869     case OFP15_VERSION:
6870     case OFP16_VERSION: {
6871         struct ofp11_packet_out *opo;
6872         size_t len;
6873
6874         msg = ofpraw_alloc(OFPRAW_OFPT11_PACKET_OUT, ofp_version, size);
6875         ofpbuf_put_zeros(msg, sizeof *opo);
6876         len = ofpacts_put_openflow_actions(po->ofpacts, po->ofpacts_len, msg,
6877                                            ofp_version);
6878         opo = msg->msg;
6879         opo->buffer_id = htonl(po->buffer_id);
6880         opo->in_port = ofputil_port_to_ofp11(po->in_port);
6881         opo->actions_len = htons(len);
6882         break;
6883     }
6884
6885     default:
6886         OVS_NOT_REACHED();
6887     }
6888
6889     if (po->buffer_id == UINT32_MAX) {
6890         ofpbuf_put(msg, po->packet, po->packet_len);
6891     }
6892
6893     ofpmsg_update_length(msg);
6894
6895     return msg;
6896 }
6897 \f
6898 /* Creates and returns an OFPT_ECHO_REQUEST message with an empty payload. */
6899 struct ofpbuf *
6900 make_echo_request(enum ofp_version ofp_version)
6901 {
6902     return ofpraw_alloc_xid(OFPRAW_OFPT_ECHO_REQUEST, ofp_version,
6903                             htonl(0), 0);
6904 }
6905
6906 /* Creates and returns an OFPT_ECHO_REPLY message matching the
6907  * OFPT_ECHO_REQUEST message in 'rq'. */
6908 struct ofpbuf *
6909 make_echo_reply(const struct ofp_header *rq)
6910 {
6911     struct ofpbuf rq_buf = ofpbuf_const_initializer(rq, ntohs(rq->length));
6912     ofpraw_pull_assert(&rq_buf);
6913
6914     struct ofpbuf *reply = ofpraw_alloc_reply(OFPRAW_OFPT_ECHO_REPLY,
6915                                               rq, rq_buf.size);
6916     ofpbuf_put(reply, rq_buf.data, rq_buf.size);
6917     return reply;
6918 }
6919
6920 struct ofpbuf *
6921 ofputil_encode_barrier_request(enum ofp_version ofp_version)
6922 {
6923     enum ofpraw type;
6924
6925     switch (ofp_version) {
6926     case OFP16_VERSION:
6927     case OFP15_VERSION:
6928     case OFP14_VERSION:
6929     case OFP13_VERSION:
6930     case OFP12_VERSION:
6931     case OFP11_VERSION:
6932         type = OFPRAW_OFPT11_BARRIER_REQUEST;
6933         break;
6934
6935     case OFP10_VERSION:
6936         type = OFPRAW_OFPT10_BARRIER_REQUEST;
6937         break;
6938
6939     default:
6940         OVS_NOT_REACHED();
6941     }
6942
6943     return ofpraw_alloc(type, ofp_version, 0);
6944 }
6945
6946 const char *
6947 ofputil_frag_handling_to_string(enum ofputil_frag_handling frag)
6948 {
6949     switch (frag) {
6950     case OFPUTIL_FRAG_NORMAL:   return "normal";
6951     case OFPUTIL_FRAG_DROP:     return "drop";
6952     case OFPUTIL_FRAG_REASM:    return "reassemble";
6953     case OFPUTIL_FRAG_NX_MATCH: return "nx-match";
6954     }
6955
6956     OVS_NOT_REACHED();
6957 }
6958
6959 bool
6960 ofputil_frag_handling_from_string(const char *s,
6961                                   enum ofputil_frag_handling *frag)
6962 {
6963     if (!strcasecmp(s, "normal")) {
6964         *frag = OFPUTIL_FRAG_NORMAL;
6965     } else if (!strcasecmp(s, "drop")) {
6966         *frag = OFPUTIL_FRAG_DROP;
6967     } else if (!strcasecmp(s, "reassemble")) {
6968         *frag = OFPUTIL_FRAG_REASM;
6969     } else if (!strcasecmp(s, "nx-match")) {
6970         *frag = OFPUTIL_FRAG_NX_MATCH;
6971     } else {
6972         return false;
6973     }
6974     return true;
6975 }
6976
6977 /* Converts the OpenFlow 1.1+ port number 'ofp11_port' into an OpenFlow 1.0
6978  * port number and stores the latter in '*ofp10_port', for the purpose of
6979  * decoding OpenFlow 1.1+ protocol messages.  Returns 0 if successful,
6980  * otherwise an OFPERR_* number.  On error, stores OFPP_NONE in '*ofp10_port'.
6981  *
6982  * See the definition of OFP11_MAX for an explanation of the mapping. */
6983 enum ofperr
6984 ofputil_port_from_ofp11(ovs_be32 ofp11_port, ofp_port_t *ofp10_port)
6985 {
6986     uint32_t ofp11_port_h = ntohl(ofp11_port);
6987
6988     if (ofp11_port_h < ofp_to_u16(OFPP_MAX)) {
6989         *ofp10_port = u16_to_ofp(ofp11_port_h);
6990         return 0;
6991     } else if (ofp11_port_h >= ofp11_to_u32(OFPP11_MAX)) {
6992         *ofp10_port = u16_to_ofp(ofp11_port_h - OFPP11_OFFSET);
6993         return 0;
6994     } else {
6995         *ofp10_port = OFPP_NONE;
6996         VLOG_WARN_RL(&bad_ofmsg_rl, "port %"PRIu32" is outside the supported "
6997                      "range 0 through %d or 0x%"PRIx32" through 0x%"PRIx32,
6998                      ofp11_port_h, ofp_to_u16(OFPP_MAX) - 1,
6999                      ofp11_to_u32(OFPP11_MAX), UINT32_MAX);
7000         return OFPERR_OFPBAC_BAD_OUT_PORT;
7001     }
7002 }
7003
7004 /* Returns the OpenFlow 1.1+ port number equivalent to the OpenFlow 1.0 port
7005  * number 'ofp10_port', for encoding OpenFlow 1.1+ protocol messages.
7006  *
7007  * See the definition of OFP11_MAX for an explanation of the mapping. */
7008 ovs_be32
7009 ofputil_port_to_ofp11(ofp_port_t ofp10_port)
7010 {
7011     return htonl(ofp_to_u16(ofp10_port) < ofp_to_u16(OFPP_MAX)
7012                  ? ofp_to_u16(ofp10_port)
7013                  : ofp_to_u16(ofp10_port) + OFPP11_OFFSET);
7014 }
7015
7016 #define OFPUTIL_NAMED_PORTS                     \
7017         OFPUTIL_NAMED_PORT(IN_PORT)             \
7018         OFPUTIL_NAMED_PORT(TABLE)               \
7019         OFPUTIL_NAMED_PORT(NORMAL)              \
7020         OFPUTIL_NAMED_PORT(FLOOD)               \
7021         OFPUTIL_NAMED_PORT(ALL)                 \
7022         OFPUTIL_NAMED_PORT(CONTROLLER)          \
7023         OFPUTIL_NAMED_PORT(LOCAL)               \
7024         OFPUTIL_NAMED_PORT(ANY)                 \
7025         OFPUTIL_NAMED_PORT(UNSET)
7026
7027 /* For backwards compatibility, so that "none" is recognized as OFPP_ANY */
7028 #define OFPUTIL_NAMED_PORTS_WITH_NONE           \
7029         OFPUTIL_NAMED_PORTS                     \
7030         OFPUTIL_NAMED_PORT(NONE)
7031
7032 /* Stores the port number represented by 's' into '*portp'.  's' may be an
7033  * integer or, for reserved ports, the standard OpenFlow name for the port
7034  * (e.g. "LOCAL").
7035  *
7036  * Returns true if successful, false if 's' is not a valid OpenFlow port number
7037  * or name.  The caller should issue an error message in this case, because
7038  * this function usually does not.  (This gives the caller an opportunity to
7039  * look up the port name another way, e.g. by contacting the switch and listing
7040  * the names of all its ports).
7041  *
7042  * This function accepts OpenFlow 1.0 port numbers.  It also accepts a subset
7043  * of OpenFlow 1.1+ port numbers, mapping those port numbers into the 16-bit
7044  * range as described in include/openflow/openflow-1.1.h. */
7045 bool
7046 ofputil_port_from_string(const char *s, ofp_port_t *portp)
7047 {
7048     unsigned int port32; /* int is at least 32 bits wide. */
7049
7050     if (*s == '-') {
7051         VLOG_WARN("Negative value %s is not a valid port number.", s);
7052         return false;
7053     }
7054     *portp = 0;
7055     if (str_to_uint(s, 10, &port32)) {
7056         if (port32 < ofp_to_u16(OFPP_MAX)) {
7057             /* Pass. */
7058         } else if (port32 < ofp_to_u16(OFPP_FIRST_RESV)) {
7059             VLOG_WARN("port %u is a reserved OF1.0 port number that will "
7060                       "be translated to %u when talking to an OF1.1 or "
7061                       "later controller", port32, port32 + OFPP11_OFFSET);
7062         } else if (port32 <= ofp_to_u16(OFPP_LAST_RESV)) {
7063             char name[OFP_MAX_PORT_NAME_LEN];
7064
7065             ofputil_port_to_string(u16_to_ofp(port32), name, sizeof name);
7066             VLOG_WARN_ONCE("referring to port %s as %"PRIu32" is deprecated "
7067                            "for compatibility with OpenFlow 1.1 and later",
7068                            name, port32);
7069         } else if (port32 < ofp11_to_u32(OFPP11_MAX)) {
7070             VLOG_WARN("port %u is outside the supported range 0 through "
7071                       "%"PRIx16" or 0x%x through 0x%"PRIx32, port32,
7072                       UINT16_MAX, ofp11_to_u32(OFPP11_MAX), UINT32_MAX);
7073             return false;
7074         } else {
7075             port32 -= OFPP11_OFFSET;
7076         }
7077
7078         *portp = u16_to_ofp(port32);
7079         return true;
7080     } else {
7081         struct pair {
7082             const char *name;
7083             ofp_port_t value;
7084         };
7085         static const struct pair pairs[] = {
7086 #define OFPUTIL_NAMED_PORT(NAME) {#NAME, OFPP_##NAME},
7087             OFPUTIL_NAMED_PORTS_WITH_NONE
7088 #undef OFPUTIL_NAMED_PORT
7089         };
7090         const struct pair *p;
7091
7092         for (p = pairs; p < &pairs[ARRAY_SIZE(pairs)]; p++) {
7093             if (!strcasecmp(s, p->name)) {
7094                 *portp = p->value;
7095                 return true;
7096             }
7097         }
7098         return false;
7099     }
7100 }
7101
7102 /* Appends to 's' a string representation of the OpenFlow port number 'port'.
7103  * Most ports' string representation is just the port number, but for special
7104  * ports, e.g. OFPP_LOCAL, it is the name, e.g. "LOCAL". */
7105 void
7106 ofputil_format_port(ofp_port_t port, struct ds *s)
7107 {
7108     char name[OFP_MAX_PORT_NAME_LEN];
7109
7110     ofputil_port_to_string(port, name, sizeof name);
7111     ds_put_cstr(s, name);
7112 }
7113
7114 /* Puts in the 'bufsize' byte in 'namebuf' a null-terminated string
7115  * representation of OpenFlow port number 'port'.  Most ports are represented
7116  * as just the port number, but special ports, e.g. OFPP_LOCAL, are represented
7117  * by name, e.g. "LOCAL". */
7118 void
7119 ofputil_port_to_string(ofp_port_t port,
7120                        char namebuf[OFP_MAX_PORT_NAME_LEN], size_t bufsize)
7121 {
7122     switch (port) {
7123 #define OFPUTIL_NAMED_PORT(NAME)                        \
7124         case OFPP_##NAME:                               \
7125             ovs_strlcpy(namebuf, #NAME, bufsize);       \
7126             break;
7127         OFPUTIL_NAMED_PORTS
7128 #undef OFPUTIL_NAMED_PORT
7129
7130     default:
7131         snprintf(namebuf, bufsize, "%"PRIu16, port);
7132         break;
7133     }
7134 }
7135
7136 /* Stores the group id represented by 's' into '*group_idp'.  's' may be an
7137  * integer or, for reserved group IDs, the standard OpenFlow name for the group
7138  * (either "ANY" or "ALL").
7139  *
7140  * Returns true if successful, false if 's' is not a valid OpenFlow group ID or
7141  * name. */
7142 bool
7143 ofputil_group_from_string(const char *s, uint32_t *group_idp)
7144 {
7145     if (!strcasecmp(s, "any")) {
7146         *group_idp = OFPG_ANY;
7147     } else if (!strcasecmp(s, "all")) {
7148         *group_idp = OFPG_ALL;
7149     } else if (!str_to_uint(s, 10, group_idp)) {
7150         VLOG_WARN("%s is not a valid group ID.  (Valid group IDs are "
7151                   "32-bit nonnegative integers or the keywords ANY or "
7152                   "ALL.)", s);
7153         return false;
7154     }
7155
7156     return true;
7157 }
7158
7159 /* Appends to 's' a string representation of the OpenFlow group ID 'group_id'.
7160  * Most groups' string representation is just the number, but for special
7161  * groups, e.g. OFPG_ALL, it is the name, e.g. "ALL". */
7162 void
7163 ofputil_format_group(uint32_t group_id, struct ds *s)
7164 {
7165     char name[MAX_GROUP_NAME_LEN];
7166
7167     ofputil_group_to_string(group_id, name, sizeof name);
7168     ds_put_cstr(s, name);
7169 }
7170
7171
7172 /* Puts in the 'bufsize' byte in 'namebuf' a null-terminated string
7173  * representation of OpenFlow group ID 'group_id'.  Most group are represented
7174  * as just their number, but special groups, e.g. OFPG_ALL, are represented
7175  * by name, e.g. "ALL". */
7176 void
7177 ofputil_group_to_string(uint32_t group_id,
7178                         char namebuf[MAX_GROUP_NAME_LEN + 1], size_t bufsize)
7179 {
7180     switch (group_id) {
7181     case OFPG_ALL:
7182         ovs_strlcpy(namebuf, "ALL", bufsize);
7183         break;
7184
7185     case OFPG_ANY:
7186         ovs_strlcpy(namebuf, "ANY", bufsize);
7187         break;
7188
7189     default:
7190         snprintf(namebuf, bufsize, "%"PRIu32, group_id);
7191         break;
7192     }
7193 }
7194
7195 /* Given a buffer 'b' that contains an array of OpenFlow ports of type
7196  * 'ofp_version', tries to pull the first element from the array.  If
7197  * successful, initializes '*pp' with an abstract representation of the
7198  * port and returns 0.  If no ports remain to be decoded, returns EOF.
7199  * On an error, returns a positive OFPERR_* value. */
7200 int
7201 ofputil_pull_phy_port(enum ofp_version ofp_version, struct ofpbuf *b,
7202                       struct ofputil_phy_port *pp)
7203 {
7204     memset(pp, 0, sizeof *pp);
7205
7206     switch (ofp_version) {
7207     case OFP10_VERSION: {
7208         const struct ofp10_phy_port *opp = ofpbuf_try_pull(b, sizeof *opp);
7209         return opp ? ofputil_decode_ofp10_phy_port(pp, opp) : EOF;
7210     }
7211     case OFP11_VERSION:
7212     case OFP12_VERSION:
7213     case OFP13_VERSION: {
7214         const struct ofp11_port *op = ofpbuf_try_pull(b, sizeof *op);
7215         return op ? ofputil_decode_ofp11_port(pp, op) : EOF;
7216     }
7217     case OFP14_VERSION:
7218     case OFP15_VERSION:
7219     case OFP16_VERSION:
7220         return b->size ? ofputil_pull_ofp14_port(pp, b) : EOF;
7221     default:
7222         OVS_NOT_REACHED();
7223     }
7224 }
7225
7226 static void
7227 ofputil_normalize_match__(struct match *match, bool may_log)
7228 {
7229     enum {
7230         MAY_NW_ADDR     = 1 << 0, /* nw_src, nw_dst */
7231         MAY_TP_ADDR     = 1 << 1, /* tp_src, tp_dst */
7232         MAY_NW_PROTO    = 1 << 2, /* nw_proto */
7233         MAY_IPVx        = 1 << 3, /* tos, frag, ttl */
7234         MAY_ARP_SHA     = 1 << 4, /* arp_sha */
7235         MAY_ARP_THA     = 1 << 5, /* arp_tha */
7236         MAY_IPV6        = 1 << 6, /* ipv6_src, ipv6_dst, ipv6_label */
7237         MAY_ND_TARGET   = 1 << 7, /* nd_target */
7238         MAY_MPLS        = 1 << 8, /* mpls label and tc */
7239     } may_match;
7240
7241     struct flow_wildcards wc;
7242
7243     /* Figure out what fields may be matched. */
7244     if (match->flow.dl_type == htons(ETH_TYPE_IP)) {
7245         may_match = MAY_NW_PROTO | MAY_IPVx | MAY_NW_ADDR;
7246         if (match->flow.nw_proto == IPPROTO_TCP ||
7247             match->flow.nw_proto == IPPROTO_UDP ||
7248             match->flow.nw_proto == IPPROTO_SCTP ||
7249             match->flow.nw_proto == IPPROTO_ICMP) {
7250             may_match |= MAY_TP_ADDR;
7251         }
7252     } else if (match->flow.dl_type == htons(ETH_TYPE_IPV6)) {
7253         may_match = MAY_NW_PROTO | MAY_IPVx | MAY_IPV6;
7254         if (match->flow.nw_proto == IPPROTO_TCP ||
7255             match->flow.nw_proto == IPPROTO_UDP ||
7256             match->flow.nw_proto == IPPROTO_SCTP) {
7257             may_match |= MAY_TP_ADDR;
7258         } else if (match->flow.nw_proto == IPPROTO_ICMPV6) {
7259             may_match |= MAY_TP_ADDR;
7260             if (match->flow.tp_src == htons(ND_NEIGHBOR_SOLICIT)) {
7261                 may_match |= MAY_ND_TARGET | MAY_ARP_SHA;
7262             } else if (match->flow.tp_src == htons(ND_NEIGHBOR_ADVERT)) {
7263                 may_match |= MAY_ND_TARGET | MAY_ARP_THA;
7264             }
7265         }
7266     } else if (match->flow.dl_type == htons(ETH_TYPE_ARP) ||
7267                match->flow.dl_type == htons(ETH_TYPE_RARP)) {
7268         may_match = MAY_NW_PROTO | MAY_NW_ADDR | MAY_ARP_SHA | MAY_ARP_THA;
7269     } else if (eth_type_mpls(match->flow.dl_type)) {
7270         may_match = MAY_MPLS;
7271     } else {
7272         may_match = 0;
7273     }
7274
7275     /* Clear the fields that may not be matched. */
7276     wc = match->wc;
7277     if (!(may_match & MAY_NW_ADDR)) {
7278         wc.masks.nw_src = wc.masks.nw_dst = htonl(0);
7279     }
7280     if (!(may_match & MAY_TP_ADDR)) {
7281         wc.masks.tp_src = wc.masks.tp_dst = htons(0);
7282     }
7283     if (!(may_match & MAY_NW_PROTO)) {
7284         wc.masks.nw_proto = 0;
7285     }
7286     if (!(may_match & MAY_IPVx)) {
7287         wc.masks.nw_tos = 0;
7288         wc.masks.nw_ttl = 0;
7289     }
7290     if (!(may_match & MAY_ARP_SHA)) {
7291         WC_UNMASK_FIELD(&wc, arp_sha);
7292     }
7293     if (!(may_match & MAY_ARP_THA)) {
7294         WC_UNMASK_FIELD(&wc, arp_tha);
7295     }
7296     if (!(may_match & MAY_IPV6)) {
7297         wc.masks.ipv6_src = wc.masks.ipv6_dst = in6addr_any;
7298         wc.masks.ipv6_label = htonl(0);
7299     }
7300     if (!(may_match & MAY_ND_TARGET)) {
7301         wc.masks.nd_target = in6addr_any;
7302     }
7303     if (!(may_match & MAY_MPLS)) {
7304         memset(wc.masks.mpls_lse, 0, sizeof wc.masks.mpls_lse);
7305     }
7306
7307     /* Log any changes. */
7308     if (!flow_wildcards_equal(&wc, &match->wc)) {
7309         bool log = may_log && !VLOG_DROP_INFO(&bad_ofmsg_rl);
7310         char *pre = log ? match_to_string(match, OFP_DEFAULT_PRIORITY) : NULL;
7311
7312         match->wc = wc;
7313         match_zero_wildcarded_fields(match);
7314
7315         if (log) {
7316             char *post = match_to_string(match, OFP_DEFAULT_PRIORITY);
7317             VLOG_INFO("normalization changed ofp_match, details:");
7318             VLOG_INFO(" pre: %s", pre);
7319             VLOG_INFO("post: %s", post);
7320             free(pre);
7321             free(post);
7322         }
7323     }
7324 }
7325
7326 /* "Normalizes" the wildcards in 'match'.  That means:
7327  *
7328  *    1. If the type of level N is known, then only the valid fields for that
7329  *       level may be specified.  For example, ARP does not have a TOS field,
7330  *       so nw_tos must be wildcarded if 'match' specifies an ARP flow.
7331  *       Similarly, IPv4 does not have any IPv6 addresses, so ipv6_src and
7332  *       ipv6_dst (and other fields) must be wildcarded if 'match' specifies an
7333  *       IPv4 flow.
7334  *
7335  *    2. If the type of level N is not known (or not understood by Open
7336  *       vSwitch), then no fields at all for that level may be specified.  For
7337  *       example, Open vSwitch does not understand SCTP, an L4 protocol, so the
7338  *       L4 fields tp_src and tp_dst must be wildcarded if 'match' specifies an
7339  *       SCTP flow.
7340  *
7341  * If this function changes 'match', it logs a rate-limited informational
7342  * message. */
7343 void
7344 ofputil_normalize_match(struct match *match)
7345 {
7346     ofputil_normalize_match__(match, true);
7347 }
7348
7349 /* Same as ofputil_normalize_match() without the logging.  Thus, this function
7350  * is suitable for a program's internal use, whereas ofputil_normalize_match()
7351  * sense for use on flows received from elsewhere (so that a bug in the program
7352  * that sent them can be reported and corrected). */
7353 void
7354 ofputil_normalize_match_quiet(struct match *match)
7355 {
7356     ofputil_normalize_match__(match, false);
7357 }
7358
7359 static size_t
7360 parse_value(const char *s, const char *delimiters)
7361 {
7362     size_t n = 0;
7363
7364     /* Iterate until we reach a delimiter.
7365      *
7366      * strchr(s, '\0') returns s+strlen(s), so this test handles the null
7367      * terminator at the end of 's'.  */
7368     while (!strchr(delimiters, s[n])) {
7369         if (s[n] == '(') {
7370             int level = 0;
7371             do {
7372                 switch (s[n]) {
7373                 case '\0':
7374                     return n;
7375                 case '(':
7376                     level++;
7377                     break;
7378                 case ')':
7379                     level--;
7380                     break;
7381                 }
7382                 n++;
7383             } while (level > 0);
7384         } else {
7385             n++;
7386         }
7387     }
7388     return n;
7389 }
7390
7391 /* Parses a key or a key-value pair from '*stringp'.
7392  *
7393  * On success: Stores the key into '*keyp'.  Stores the value, if present, into
7394  * '*valuep', otherwise an empty string.  Advances '*stringp' past the end of
7395  * the key-value pair, preparing it for another call.  '*keyp' and '*valuep'
7396  * are substrings of '*stringp' created by replacing some of its bytes by null
7397  * terminators.  Returns true.
7398  *
7399  * If '*stringp' is just white space or commas, sets '*keyp' and '*valuep' to
7400  * NULL and returns false. */
7401 bool
7402 ofputil_parse_key_value(char **stringp, char **keyp, char **valuep)
7403 {
7404     /* Skip white space and delimiters.  If that brings us to the end of the
7405      * input string, we are done and there are no more key-value pairs. */
7406     *stringp += strspn(*stringp, ", \t\r\n");
7407     if (**stringp == '\0') {
7408         *keyp = *valuep = NULL;
7409         return false;
7410     }
7411
7412     /* Extract the key and the delimiter that ends the key-value pair or begins
7413      * the value.  Advance the input position past the key and delimiter. */
7414     char *key = *stringp;
7415     size_t key_len = strcspn(key, ":=(, \t\r\n");
7416     char key_delim = key[key_len];
7417     key[key_len] = '\0';
7418     *stringp += key_len + (key_delim != '\0');
7419
7420     /* Figure out what delimiter ends the value:
7421      *
7422      *     - If key_delim is ":" or "=", the value extends until white space
7423      *       or a comma.
7424      *
7425      *     - If key_delim is "(", the value extends until ")".
7426      *
7427      * If there is no value, we are done. */
7428     const char *value_delims;
7429     if (key_delim == ':' || key_delim == '=') {
7430         value_delims = ", \t\r\n";
7431     } else if (key_delim == '(') {
7432         value_delims = ")";
7433     } else {
7434         *keyp = key;
7435         *valuep = key + key_len; /* Empty string. */
7436         return true;
7437     }
7438
7439     /* Extract the value.  Advance the input position past the value and
7440      * delimiter. */
7441     char *value = *stringp;
7442     size_t value_len = parse_value(value, value_delims);
7443     char value_delim = value[value_len];
7444     value[value_len] = '\0';
7445     *stringp += value_len + (value_delim != '\0');
7446
7447     *keyp = key;
7448     *valuep = value;
7449     return true;
7450 }
7451
7452 /* Encode a dump ports request for 'port', the encoded message
7453  * will be for OpenFlow version 'ofp_version'. Returns message
7454  * as a struct ofpbuf. Returns encoded message on success, NULL on error */
7455 struct ofpbuf *
7456 ofputil_encode_dump_ports_request(enum ofp_version ofp_version, ofp_port_t port)
7457 {
7458     struct ofpbuf *request;
7459
7460     switch (ofp_version) {
7461     case OFP10_VERSION: {
7462         struct ofp10_port_stats_request *req;
7463         request = ofpraw_alloc(OFPRAW_OFPST10_PORT_REQUEST, ofp_version, 0);
7464         req = ofpbuf_put_zeros(request, sizeof *req);
7465         req->port_no = htons(ofp_to_u16(port));
7466         break;
7467     }
7468     case OFP11_VERSION:
7469     case OFP12_VERSION:
7470     case OFP13_VERSION:
7471     case OFP14_VERSION:
7472     case OFP15_VERSION:
7473     case OFP16_VERSION: {
7474         struct ofp11_port_stats_request *req;
7475         request = ofpraw_alloc(OFPRAW_OFPST11_PORT_REQUEST, ofp_version, 0);
7476         req = ofpbuf_put_zeros(request, sizeof *req);
7477         req->port_no = ofputil_port_to_ofp11(port);
7478         break;
7479     }
7480     default:
7481         OVS_NOT_REACHED();
7482     }
7483
7484     return request;
7485 }
7486
7487 static void
7488 ofputil_port_stats_to_ofp10(const struct ofputil_port_stats *ops,
7489                             struct ofp10_port_stats *ps10)
7490 {
7491     ps10->port_no = htons(ofp_to_u16(ops->port_no));
7492     memset(ps10->pad, 0, sizeof ps10->pad);
7493     put_32aligned_be64(&ps10->rx_packets, htonll(ops->stats.rx_packets));
7494     put_32aligned_be64(&ps10->tx_packets, htonll(ops->stats.tx_packets));
7495     put_32aligned_be64(&ps10->rx_bytes, htonll(ops->stats.rx_bytes));
7496     put_32aligned_be64(&ps10->tx_bytes, htonll(ops->stats.tx_bytes));
7497     put_32aligned_be64(&ps10->rx_dropped, htonll(ops->stats.rx_dropped));
7498     put_32aligned_be64(&ps10->tx_dropped, htonll(ops->stats.tx_dropped));
7499     put_32aligned_be64(&ps10->rx_errors, htonll(ops->stats.rx_errors));
7500     put_32aligned_be64(&ps10->tx_errors, htonll(ops->stats.tx_errors));
7501     put_32aligned_be64(&ps10->rx_frame_err, htonll(ops->stats.rx_frame_errors));
7502     put_32aligned_be64(&ps10->rx_over_err, htonll(ops->stats.rx_over_errors));
7503     put_32aligned_be64(&ps10->rx_crc_err, htonll(ops->stats.rx_crc_errors));
7504     put_32aligned_be64(&ps10->collisions, htonll(ops->stats.collisions));
7505 }
7506
7507 static void
7508 ofputil_port_stats_to_ofp11(const struct ofputil_port_stats *ops,
7509                             struct ofp11_port_stats *ps11)
7510 {
7511     ps11->port_no = ofputil_port_to_ofp11(ops->port_no);
7512     memset(ps11->pad, 0, sizeof ps11->pad);
7513     ps11->rx_packets = htonll(ops->stats.rx_packets);
7514     ps11->tx_packets = htonll(ops->stats.tx_packets);
7515     ps11->rx_bytes = htonll(ops->stats.rx_bytes);
7516     ps11->tx_bytes = htonll(ops->stats.tx_bytes);
7517     ps11->rx_dropped = htonll(ops->stats.rx_dropped);
7518     ps11->tx_dropped = htonll(ops->stats.tx_dropped);
7519     ps11->rx_errors = htonll(ops->stats.rx_errors);
7520     ps11->tx_errors = htonll(ops->stats.tx_errors);
7521     ps11->rx_frame_err = htonll(ops->stats.rx_frame_errors);
7522     ps11->rx_over_err = htonll(ops->stats.rx_over_errors);
7523     ps11->rx_crc_err = htonll(ops->stats.rx_crc_errors);
7524     ps11->collisions = htonll(ops->stats.collisions);
7525 }
7526
7527 static void
7528 ofputil_port_stats_to_ofp13(const struct ofputil_port_stats *ops,
7529                             struct ofp13_port_stats *ps13)
7530 {
7531     ofputil_port_stats_to_ofp11(ops, &ps13->ps);
7532     ps13->duration_sec = htonl(ops->duration_sec);
7533     ps13->duration_nsec = htonl(ops->duration_nsec);
7534 }
7535
7536 static void
7537 ofputil_append_ofp14_port_stats(const struct ofputil_port_stats *ops,
7538                                 struct ovs_list *replies)
7539 {
7540     struct ofp14_port_stats_prop_ethernet *eth;
7541     struct intel_port_stats_rfc2819 *stats_rfc2819;
7542     struct ofp14_port_stats *ps14;
7543     struct ofpbuf *reply;
7544
7545     reply = ofpmp_reserve(replies, sizeof *ps14 + sizeof *eth +
7546                           sizeof *stats_rfc2819);
7547
7548     ps14 = ofpbuf_put_uninit(reply, sizeof *ps14);
7549     ps14->length = htons(sizeof *ps14 + sizeof *eth +
7550                          sizeof *stats_rfc2819);
7551     memset(ps14->pad, 0, sizeof ps14->pad);
7552     ps14->port_no = ofputil_port_to_ofp11(ops->port_no);
7553     ps14->duration_sec = htonl(ops->duration_sec);
7554     ps14->duration_nsec = htonl(ops->duration_nsec);
7555     ps14->rx_packets = htonll(ops->stats.rx_packets);
7556     ps14->tx_packets = htonll(ops->stats.tx_packets);
7557     ps14->rx_bytes = htonll(ops->stats.rx_bytes);
7558     ps14->tx_bytes = htonll(ops->stats.tx_bytes);
7559     ps14->rx_dropped = htonll(ops->stats.rx_dropped);
7560     ps14->tx_dropped = htonll(ops->stats.tx_dropped);
7561     ps14->rx_errors = htonll(ops->stats.rx_errors);
7562     ps14->tx_errors = htonll(ops->stats.tx_errors);
7563
7564     eth = ofpprop_put_zeros(reply, OFPPSPT14_ETHERNET, sizeof *eth);
7565     eth->rx_frame_err = htonll(ops->stats.rx_frame_errors);
7566     eth->rx_over_err = htonll(ops->stats.rx_over_errors);
7567     eth->rx_crc_err = htonll(ops->stats.rx_crc_errors);
7568     eth->collisions = htonll(ops->stats.collisions);
7569
7570     uint64_t prop_type = OFPPROP_EXP(INTEL_VENDOR_ID,
7571                                      INTEL_PORT_STATS_RFC2819);
7572
7573     stats_rfc2819 = ofpprop_put_zeros(reply, prop_type,
7574                                       sizeof *stats_rfc2819);
7575
7576     memset(stats_rfc2819->pad, 0, sizeof stats_rfc2819->pad);
7577     stats_rfc2819->rx_1_to_64_packets = htonll(ops->stats.rx_1_to_64_packets);
7578     stats_rfc2819->rx_65_to_127_packets =
7579         htonll(ops->stats.rx_65_to_127_packets);
7580     stats_rfc2819->rx_128_to_255_packets =
7581         htonll(ops->stats.rx_128_to_255_packets);
7582     stats_rfc2819->rx_256_to_511_packets =
7583         htonll(ops->stats.rx_256_to_511_packets);
7584     stats_rfc2819->rx_512_to_1023_packets =
7585         htonll(ops->stats.rx_512_to_1023_packets);
7586     stats_rfc2819->rx_1024_to_1522_packets =
7587         htonll(ops->stats.rx_1024_to_1522_packets);
7588     stats_rfc2819->rx_1523_to_max_packets =
7589         htonll(ops->stats.rx_1523_to_max_packets);
7590
7591     stats_rfc2819->tx_1_to_64_packets = htonll(ops->stats.tx_1_to_64_packets);
7592     stats_rfc2819->tx_65_to_127_packets =
7593         htonll(ops->stats.tx_65_to_127_packets);
7594     stats_rfc2819->tx_128_to_255_packets =
7595         htonll(ops->stats.tx_128_to_255_packets);
7596     stats_rfc2819->tx_256_to_511_packets =
7597         htonll(ops->stats.tx_256_to_511_packets);
7598     stats_rfc2819->tx_512_to_1023_packets =
7599         htonll(ops->stats.tx_512_to_1023_packets);
7600     stats_rfc2819->tx_1024_to_1522_packets =
7601         htonll(ops->stats.tx_1024_to_1522_packets);
7602     stats_rfc2819->tx_1523_to_max_packets =
7603         htonll(ops->stats.tx_1523_to_max_packets);
7604
7605     stats_rfc2819->tx_multicast_packets =
7606         htonll(ops->stats.tx_multicast_packets);
7607     stats_rfc2819->rx_broadcast_packets =
7608         htonll(ops->stats.rx_broadcast_packets);
7609     stats_rfc2819->tx_broadcast_packets =
7610         htonll(ops->stats.tx_broadcast_packets);
7611     stats_rfc2819->rx_undersized_errors =
7612         htonll(ops->stats.rx_undersized_errors);
7613     stats_rfc2819->rx_oversize_errors =
7614         htonll(ops->stats.rx_oversize_errors);
7615     stats_rfc2819->rx_fragmented_errors =
7616         htonll(ops->stats.rx_fragmented_errors);
7617     stats_rfc2819->rx_jabber_errors =
7618         htonll(ops->stats.rx_jabber_errors);
7619 }
7620
7621 /* Encode a ports stat for 'ops' and append it to 'replies'. */
7622 void
7623 ofputil_append_port_stat(struct ovs_list *replies,
7624                          const struct ofputil_port_stats *ops)
7625 {
7626     switch (ofpmp_version(replies)) {
7627     case OFP13_VERSION: {
7628         struct ofp13_port_stats *reply = ofpmp_append(replies, sizeof *reply);
7629         ofputil_port_stats_to_ofp13(ops, reply);
7630         break;
7631     }
7632     case OFP12_VERSION:
7633     case OFP11_VERSION: {
7634         struct ofp11_port_stats *reply = ofpmp_append(replies, sizeof *reply);
7635         ofputil_port_stats_to_ofp11(ops, reply);
7636         break;
7637     }
7638
7639     case OFP10_VERSION: {
7640         struct ofp10_port_stats *reply = ofpmp_append(replies, sizeof *reply);
7641         ofputil_port_stats_to_ofp10(ops, reply);
7642         break;
7643     }
7644
7645     case OFP14_VERSION:
7646     case OFP15_VERSION:
7647     case OFP16_VERSION:
7648         ofputil_append_ofp14_port_stats(ops, replies);
7649         break;
7650
7651     default:
7652         OVS_NOT_REACHED();
7653     }
7654 }
7655
7656 static enum ofperr
7657 ofputil_port_stats_from_ofp10(struct ofputil_port_stats *ops,
7658                               const struct ofp10_port_stats *ps10)
7659 {
7660
7661     ops->port_no = u16_to_ofp(ntohs(ps10->port_no));
7662     ops->stats.rx_packets = ntohll(get_32aligned_be64(&ps10->rx_packets));
7663     ops->stats.tx_packets = ntohll(get_32aligned_be64(&ps10->tx_packets));
7664     ops->stats.rx_bytes = ntohll(get_32aligned_be64(&ps10->rx_bytes));
7665     ops->stats.tx_bytes = ntohll(get_32aligned_be64(&ps10->tx_bytes));
7666     ops->stats.rx_dropped = ntohll(get_32aligned_be64(&ps10->rx_dropped));
7667     ops->stats.tx_dropped = ntohll(get_32aligned_be64(&ps10->tx_dropped));
7668     ops->stats.rx_errors = ntohll(get_32aligned_be64(&ps10->rx_errors));
7669     ops->stats.tx_errors = ntohll(get_32aligned_be64(&ps10->tx_errors));
7670     ops->stats.rx_frame_errors =
7671         ntohll(get_32aligned_be64(&ps10->rx_frame_err));
7672     ops->stats.rx_over_errors = ntohll(get_32aligned_be64(&ps10->rx_over_err));
7673     ops->stats.rx_crc_errors = ntohll(get_32aligned_be64(&ps10->rx_crc_err));
7674     ops->stats.collisions = ntohll(get_32aligned_be64(&ps10->collisions));
7675     ops->duration_sec = ops->duration_nsec = UINT32_MAX;
7676
7677     return 0;
7678 }
7679
7680 static enum ofperr
7681 ofputil_port_stats_from_ofp11(struct ofputil_port_stats *ops,
7682                               const struct ofp11_port_stats *ps11)
7683 {
7684     enum ofperr error;
7685
7686     error = ofputil_port_from_ofp11(ps11->port_no, &ops->port_no);
7687     if (error) {
7688         return error;
7689     }
7690
7691     ops->stats.rx_packets = ntohll(ps11->rx_packets);
7692     ops->stats.tx_packets = ntohll(ps11->tx_packets);
7693     ops->stats.rx_bytes = ntohll(ps11->rx_bytes);
7694     ops->stats.tx_bytes = ntohll(ps11->tx_bytes);
7695     ops->stats.rx_dropped = ntohll(ps11->rx_dropped);
7696     ops->stats.tx_dropped = ntohll(ps11->tx_dropped);
7697     ops->stats.rx_errors = ntohll(ps11->rx_errors);
7698     ops->stats.tx_errors = ntohll(ps11->tx_errors);
7699     ops->stats.rx_frame_errors = ntohll(ps11->rx_frame_err);
7700     ops->stats.rx_over_errors = ntohll(ps11->rx_over_err);
7701     ops->stats.rx_crc_errors = ntohll(ps11->rx_crc_err);
7702     ops->stats.collisions = ntohll(ps11->collisions);
7703     ops->duration_sec = ops->duration_nsec = UINT32_MAX;
7704
7705     return 0;
7706 }
7707
7708 static enum ofperr
7709 ofputil_port_stats_from_ofp13(struct ofputil_port_stats *ops,
7710                               const struct ofp13_port_stats *ps13)
7711 {
7712     enum ofperr error = ofputil_port_stats_from_ofp11(ops, &ps13->ps);
7713     if (!error) {
7714         ops->duration_sec = ntohl(ps13->duration_sec);
7715         ops->duration_nsec = ntohl(ps13->duration_nsec);
7716     }
7717     return error;
7718 }
7719
7720 static enum ofperr
7721 parse_ofp14_port_stats_ethernet_property(const struct ofpbuf *payload,
7722                                          struct ofputil_port_stats *ops)
7723 {
7724     const struct ofp14_port_stats_prop_ethernet *eth = payload->data;
7725
7726     if (payload->size != sizeof *eth) {
7727         return OFPERR_OFPBPC_BAD_LEN;
7728     }
7729
7730     ops->stats.rx_frame_errors = ntohll(eth->rx_frame_err);
7731     ops->stats.rx_over_errors = ntohll(eth->rx_over_err);
7732     ops->stats.rx_crc_errors = ntohll(eth->rx_crc_err);
7733     ops->stats.collisions = ntohll(eth->collisions);
7734
7735     return 0;
7736 }
7737
7738 static enum ofperr
7739 parse_intel_port_stats_rfc2819_property(const struct ofpbuf *payload,
7740                                         struct ofputil_port_stats *ops)
7741 {
7742     const struct intel_port_stats_rfc2819 *rfc2819 = payload->data;
7743
7744     if (payload->size != sizeof *rfc2819) {
7745         return OFPERR_OFPBPC_BAD_LEN;
7746     }
7747     ops->stats.rx_1_to_64_packets = ntohll(rfc2819->rx_1_to_64_packets);
7748     ops->stats.rx_65_to_127_packets = ntohll(rfc2819->rx_65_to_127_packets);
7749     ops->stats.rx_128_to_255_packets = ntohll(rfc2819->rx_128_to_255_packets);
7750     ops->stats.rx_256_to_511_packets = ntohll(rfc2819->rx_256_to_511_packets);
7751     ops->stats.rx_512_to_1023_packets =
7752         ntohll(rfc2819->rx_512_to_1023_packets);
7753     ops->stats.rx_1024_to_1522_packets =
7754         ntohll(rfc2819->rx_1024_to_1522_packets);
7755     ops->stats.rx_1523_to_max_packets =
7756         ntohll(rfc2819->rx_1523_to_max_packets);
7757
7758     ops->stats.tx_1_to_64_packets = ntohll(rfc2819->tx_1_to_64_packets);
7759     ops->stats.tx_65_to_127_packets = ntohll(rfc2819->tx_65_to_127_packets);
7760     ops->stats.tx_128_to_255_packets = ntohll(rfc2819->tx_128_to_255_packets);
7761     ops->stats.tx_256_to_511_packets = ntohll(rfc2819->tx_256_to_511_packets);
7762     ops->stats.tx_512_to_1023_packets =
7763         ntohll(rfc2819->tx_512_to_1023_packets);
7764     ops->stats.tx_1024_to_1522_packets =
7765         ntohll(rfc2819->tx_1024_to_1522_packets);
7766     ops->stats.tx_1523_to_max_packets =
7767         ntohll(rfc2819->tx_1523_to_max_packets);
7768
7769     ops->stats.tx_multicast_packets = ntohll(rfc2819->tx_multicast_packets);
7770     ops->stats.rx_broadcast_packets = ntohll(rfc2819->rx_broadcast_packets);
7771     ops->stats.tx_broadcast_packets = ntohll(rfc2819->tx_broadcast_packets);
7772     ops->stats.rx_undersized_errors = ntohll(rfc2819->rx_undersized_errors);
7773
7774     ops->stats.rx_oversize_errors = ntohll(rfc2819->rx_oversize_errors);
7775     ops->stats.rx_fragmented_errors = ntohll(rfc2819->rx_fragmented_errors);
7776     ops->stats.rx_jabber_errors = ntohll(rfc2819->rx_jabber_errors);
7777
7778     return 0;
7779 }
7780
7781 static enum ofperr
7782 parse_intel_port_stats_property(const struct ofpbuf *payload,
7783                                 uint32_t exp_type,
7784                                 struct ofputil_port_stats *ops)
7785 {
7786     enum ofperr error;
7787
7788     switch (exp_type) {
7789     case INTEL_PORT_STATS_RFC2819:
7790         error = parse_intel_port_stats_rfc2819_property(payload, ops);
7791         break;
7792     default:
7793         error = OFPERR_OFPBPC_BAD_EXP_TYPE;
7794         break;
7795     }
7796
7797     return error;
7798 }
7799
7800 static enum ofperr
7801 ofputil_pull_ofp14_port_stats(struct ofputil_port_stats *ops,
7802                               struct ofpbuf *msg)
7803 {
7804     const struct ofp14_port_stats *ps14 = ofpbuf_try_pull(msg, sizeof *ps14);
7805     if (!ps14) {
7806         return OFPERR_OFPBRC_BAD_LEN;
7807     }
7808
7809     size_t len = ntohs(ps14->length);
7810     if (len < sizeof *ps14 || len - sizeof *ps14 > msg->size) {
7811         return OFPERR_OFPBRC_BAD_LEN;
7812     }
7813     len -= sizeof *ps14;
7814
7815     enum ofperr error = ofputil_port_from_ofp11(ps14->port_no, &ops->port_no);
7816     if (error) {
7817         return error;
7818     }
7819
7820     ops->duration_sec = ntohl(ps14->duration_sec);
7821     ops->duration_nsec = ntohl(ps14->duration_nsec);
7822     ops->stats.rx_packets = ntohll(ps14->rx_packets);
7823     ops->stats.tx_packets = ntohll(ps14->tx_packets);
7824     ops->stats.rx_bytes = ntohll(ps14->rx_bytes);
7825     ops->stats.tx_bytes = ntohll(ps14->tx_bytes);
7826     ops->stats.rx_dropped = ntohll(ps14->rx_dropped);
7827     ops->stats.tx_dropped = ntohll(ps14->tx_dropped);
7828     ops->stats.rx_errors = ntohll(ps14->rx_errors);
7829     ops->stats.tx_errors = ntohll(ps14->tx_errors);
7830
7831
7832     struct ofpbuf properties = ofpbuf_const_initializer(ofpbuf_pull(msg, len),
7833                                                         len);
7834     while (properties.size > 0) {
7835         struct ofpbuf payload;
7836         enum ofperr error;
7837         uint64_t type = 0;
7838
7839         error = ofpprop_pull(&properties, &payload, &type);
7840         if (error) {
7841             return error;
7842         }
7843         switch (type) {
7844         case OFPPSPT14_ETHERNET:
7845             error = parse_ofp14_port_stats_ethernet_property(&payload, ops);
7846             break;
7847         case OFPPROP_EXP(INTEL_VENDOR_ID, INTEL_PORT_STATS_RFC2819):
7848             error = parse_intel_port_stats_property(&payload,
7849                                                     INTEL_PORT_STATS_RFC2819,
7850                                                     ops);
7851             break;
7852         default:
7853             error = OFPPROP_UNKNOWN(true, "port stats", type);
7854             break;
7855         }
7856
7857         if (error) {
7858             return error;
7859         }
7860     }
7861
7862     return 0;
7863 }
7864
7865 /* Returns the number of port stats elements in OFPTYPE_PORT_STATS_REPLY
7866  * message 'oh'. */
7867 size_t
7868 ofputil_count_port_stats(const struct ofp_header *oh)
7869 {
7870     struct ofpbuf b = ofpbuf_const_initializer(oh, ntohs(oh->length));
7871     ofpraw_pull_assert(&b);
7872
7873     for (size_t n = 0; ; n++) {
7874         struct ofputil_port_stats ps;
7875         if (ofputil_decode_port_stats(&ps, &b)) {
7876             return n;
7877         }
7878     }
7879 }
7880
7881 /* Converts an OFPST_PORT_STATS reply in 'msg' into an abstract
7882  * ofputil_port_stats in 'ps'.
7883  *
7884  * Multiple OFPST_PORT_STATS replies can be packed into a single OpenFlow
7885  * message.  Calling this function multiple times for a single 'msg' iterates
7886  * through the replies.  The caller must initially leave 'msg''s layer pointers
7887  * null and not modify them between calls.
7888  *
7889  * Returns 0 if successful, EOF if no replies were left in this 'msg',
7890  * otherwise a positive errno value. */
7891 int
7892 ofputil_decode_port_stats(struct ofputil_port_stats *ps, struct ofpbuf *msg)
7893 {
7894     enum ofperr error;
7895     enum ofpraw raw;
7896
7897     memset(&(ps->stats), 0xFF, sizeof (ps->stats));
7898
7899     error = (msg->header ? ofpraw_decode(&raw, msg->header)
7900              : ofpraw_pull(&raw, msg));
7901     if (error) {
7902         return error;
7903     }
7904
7905     if (!msg->size) {
7906         return EOF;
7907     } else if (raw == OFPRAW_OFPST14_PORT_REPLY) {
7908         return ofputil_pull_ofp14_port_stats(ps, msg);
7909     } else if (raw == OFPRAW_OFPST13_PORT_REPLY) {
7910         const struct ofp13_port_stats *ps13;
7911         ps13 = ofpbuf_try_pull(msg, sizeof *ps13);
7912         if (!ps13) {
7913             goto bad_len;
7914         }
7915         return ofputil_port_stats_from_ofp13(ps, ps13);
7916     } else if (raw == OFPRAW_OFPST11_PORT_REPLY) {
7917         const struct ofp11_port_stats *ps11;
7918
7919         ps11 = ofpbuf_try_pull(msg, sizeof *ps11);
7920         if (!ps11) {
7921             goto bad_len;
7922         }
7923         return ofputil_port_stats_from_ofp11(ps, ps11);
7924     } else if (raw == OFPRAW_OFPST10_PORT_REPLY) {
7925         const struct ofp10_port_stats *ps10;
7926
7927         ps10 = ofpbuf_try_pull(msg, sizeof *ps10);
7928         if (!ps10) {
7929             goto bad_len;
7930         }
7931         return ofputil_port_stats_from_ofp10(ps, ps10);
7932     } else {
7933         OVS_NOT_REACHED();
7934     }
7935
7936  bad_len:
7937     VLOG_WARN_RL(&bad_ofmsg_rl, "OFPST_PORT reply has %"PRIu32" leftover "
7938                  "bytes at end", msg->size);
7939     return OFPERR_OFPBRC_BAD_LEN;
7940 }
7941
7942 /* Parse a port status request message into a 16 bit OpenFlow 1.0
7943  * port number and stores the latter in '*ofp10_port'.
7944  * Returns 0 if successful, otherwise an OFPERR_* number. */
7945 enum ofperr
7946 ofputil_decode_port_stats_request(const struct ofp_header *request,
7947                                   ofp_port_t *ofp10_port)
7948 {
7949     switch ((enum ofp_version)request->version) {
7950     case OFP16_VERSION:
7951     case OFP15_VERSION:
7952     case OFP14_VERSION:
7953     case OFP13_VERSION:
7954     case OFP12_VERSION:
7955     case OFP11_VERSION: {
7956         const struct ofp11_port_stats_request *psr11 = ofpmsg_body(request);
7957         return ofputil_port_from_ofp11(psr11->port_no, ofp10_port);
7958     }
7959
7960     case OFP10_VERSION: {
7961         const struct ofp10_port_stats_request *psr10 = ofpmsg_body(request);
7962         *ofp10_port = u16_to_ofp(ntohs(psr10->port_no));
7963         return 0;
7964     }
7965
7966     default:
7967         OVS_NOT_REACHED();
7968     }
7969 }
7970
7971 static void
7972 ofputil_ipfix_stats_to_reply(const struct ofputil_ipfix_stats *ois,
7973                             struct nx_ipfix_stats_reply *reply)
7974 {
7975     reply->collector_set_id = htonl(ois->collector_set_id);
7976     reply->total_flows = htonll(ois->total_flows);
7977     reply->current_flows = htonll(ois->current_flows);
7978     reply->pkts = htonll(ois->pkts);
7979     reply->ipv4_pkts = htonll(ois->ipv4_pkts);
7980     reply->ipv6_pkts = htonll(ois->ipv6_pkts);
7981     reply->error_pkts = htonll(ois->error_pkts);
7982     reply->ipv4_error_pkts = htonll(ois->ipv4_error_pkts);
7983     reply->ipv6_error_pkts = htonll(ois->ipv6_error_pkts);
7984     reply->tx_pkts = htonll(ois->tx_pkts);
7985     reply->tx_errors = htonll(ois->tx_errors);
7986     memset(reply->pad, 0, sizeof reply->pad);
7987 }
7988
7989 /* Encode a ipfix stat for 'ois' and append it to 'replies'. */
7990 void
7991 ofputil_append_ipfix_stat(struct ovs_list *replies,
7992                          const struct ofputil_ipfix_stats *ois)
7993 {
7994     struct nx_ipfix_stats_reply *reply = ofpmp_append(replies, sizeof *reply);
7995     ofputil_ipfix_stats_to_reply(ois, reply);
7996 }
7997
7998 static enum ofperr
7999 ofputil_ipfix_stats_from_nx(struct ofputil_ipfix_stats *is,
8000                             const struct nx_ipfix_stats_reply *reply)
8001 {
8002     is->collector_set_id = ntohl(reply->collector_set_id);
8003     is->total_flows = ntohll(reply->total_flows);
8004     is->current_flows = ntohll(reply->current_flows);
8005     is->pkts = ntohll(reply->pkts);
8006     is->ipv4_pkts = ntohll(reply->ipv4_pkts);
8007     is->ipv6_pkts = ntohll(reply->ipv6_pkts);
8008     is->error_pkts = ntohll(reply->error_pkts);
8009     is->ipv4_error_pkts = ntohll(reply->ipv4_error_pkts);
8010     is->ipv6_error_pkts = ntohll(reply->ipv6_error_pkts);
8011     is->tx_pkts = ntohll(reply->tx_pkts);
8012     is->tx_errors = ntohll(reply->tx_errors);
8013
8014     return 0;
8015 }
8016
8017 int
8018 ofputil_pull_ipfix_stats(struct ofputil_ipfix_stats *is, struct ofpbuf *msg)
8019 {
8020     enum ofperr error;
8021     enum ofpraw raw;
8022
8023     memset(is, 0xFF, sizeof (*is));
8024
8025     error = (msg->header ? ofpraw_decode(&raw, msg->header)
8026              : ofpraw_pull(&raw, msg));
8027     if (error) {
8028         return error;
8029     }
8030
8031     if (!msg->size) {
8032         return EOF;
8033     } else if (raw == OFPRAW_NXST_IPFIX_BRIDGE_REPLY ||
8034                raw == OFPRAW_NXST_IPFIX_FLOW_REPLY) {
8035         struct nx_ipfix_stats_reply *reply;
8036
8037         reply = ofpbuf_try_pull(msg, sizeof *reply);
8038         return ofputil_ipfix_stats_from_nx(is, reply);
8039     } else {
8040         OVS_NOT_REACHED();
8041     }
8042 }
8043
8044
8045 /* Returns the number of ipfix stats elements in
8046  * OFPTYPE_IPFIX_BRIDGE_STATS_REPLY or OFPTYPE_IPFIX_FLOW_STATS_REPLY
8047  * message 'oh'. */
8048 size_t
8049 ofputil_count_ipfix_stats(const struct ofp_header *oh)
8050 {
8051     struct ofpbuf b = ofpbuf_const_initializer(oh, ntohs(oh->length));
8052     ofpraw_pull_assert(&b);
8053
8054     return b.size / sizeof(struct ofputil_ipfix_stats);
8055 }
8056
8057 /* Frees all of the "struct ofputil_bucket"s in the 'buckets' list. */
8058 void
8059 ofputil_bucket_list_destroy(struct ovs_list *buckets)
8060 {
8061     struct ofputil_bucket *bucket;
8062
8063     LIST_FOR_EACH_POP (bucket, list_node, buckets) {
8064         free(bucket->ofpacts);
8065         free(bucket);
8066     }
8067 }
8068
8069 /* Clones 'bucket' and its ofpacts data */
8070 static struct ofputil_bucket *
8071 ofputil_bucket_clone_data(const struct ofputil_bucket *bucket)
8072 {
8073     struct ofputil_bucket *new;
8074
8075     new = xmemdup(bucket, sizeof *bucket);
8076     new->ofpacts = xmemdup(bucket->ofpacts, bucket->ofpacts_len);
8077
8078     return new;
8079 }
8080
8081 /* Clones each of the buckets in the list 'src' appending them
8082  * in turn to 'dest' which should be an initialised list.
8083  * An exception is that if the pointer value of a bucket in 'src'
8084  * matches 'skip' then it is not cloned or appended to 'dest'.
8085  * This allows all of 'src' or 'all of 'src' except 'skip' to
8086  * be cloned and appended to 'dest'. */
8087 void
8088 ofputil_bucket_clone_list(struct ovs_list *dest, const struct ovs_list *src,
8089                           const struct ofputil_bucket *skip)
8090 {
8091     struct ofputil_bucket *bucket;
8092
8093     LIST_FOR_EACH (bucket, list_node, src) {
8094         struct ofputil_bucket *new_bucket;
8095
8096         if (bucket == skip) {
8097             continue;
8098         }
8099
8100         new_bucket = ofputil_bucket_clone_data(bucket);
8101         ovs_list_push_back(dest, &new_bucket->list_node);
8102     }
8103 }
8104
8105 /* Find a bucket in the list 'buckets' whose bucket id is 'bucket_id'
8106  * Returns the first bucket found or NULL if no buckets are found. */
8107 struct ofputil_bucket *
8108 ofputil_bucket_find(const struct ovs_list *buckets, uint32_t bucket_id)
8109 {
8110     struct ofputil_bucket *bucket;
8111
8112     if (bucket_id > OFPG15_BUCKET_MAX) {
8113         return NULL;
8114     }
8115
8116     LIST_FOR_EACH (bucket, list_node, buckets) {
8117         if (bucket->bucket_id == bucket_id) {
8118             return bucket;
8119         }
8120     }
8121
8122     return NULL;
8123 }
8124
8125 /* Returns true if more than one bucket in the list 'buckets'
8126  * have the same bucket id. Returns false otherwise. */
8127 bool
8128 ofputil_bucket_check_duplicate_id(const struct ovs_list *buckets)
8129 {
8130     struct ofputil_bucket *i, *j;
8131
8132     LIST_FOR_EACH (i, list_node, buckets) {
8133         LIST_FOR_EACH_REVERSE (j, list_node, buckets) {
8134             if (i == j) {
8135                 break;
8136             }
8137             if (i->bucket_id == j->bucket_id) {
8138                 return true;
8139             }
8140         }
8141     }
8142
8143     return false;
8144 }
8145
8146 /* Returns the bucket at the front of the list 'buckets'.
8147  * Undefined if 'buckets is empty. */
8148 struct ofputil_bucket *
8149 ofputil_bucket_list_front(const struct ovs_list *buckets)
8150 {
8151     static struct ofputil_bucket *bucket;
8152
8153     ASSIGN_CONTAINER(bucket, ovs_list_front(buckets), list_node);
8154
8155     return bucket;
8156 }
8157
8158 /* Returns the bucket at the back of the list 'buckets'.
8159  * Undefined if 'buckets is empty. */
8160 struct ofputil_bucket *
8161 ofputil_bucket_list_back(const struct ovs_list *buckets)
8162 {
8163     static struct ofputil_bucket *bucket;
8164
8165     ASSIGN_CONTAINER(bucket, ovs_list_back(buckets), list_node);
8166
8167     return bucket;
8168 }
8169
8170 /* Returns an OpenFlow group stats request for OpenFlow version 'ofp_version',
8171  * that requests stats for group 'group_id'.  (Use OFPG_ALL to request stats
8172  * for all groups.)
8173  *
8174  * Group statistics include packet and byte counts for each group. */
8175 struct ofpbuf *
8176 ofputil_encode_group_stats_request(enum ofp_version ofp_version,
8177                                    uint32_t group_id)
8178 {
8179     struct ofpbuf *request;
8180
8181     switch (ofp_version) {
8182     case OFP10_VERSION:
8183         ovs_fatal(0, "dump-group-stats needs OpenFlow 1.1 or later "
8184                      "(\'-O OpenFlow11\')");
8185     case OFP11_VERSION:
8186     case OFP12_VERSION:
8187     case OFP13_VERSION:
8188     case OFP14_VERSION:
8189     case OFP15_VERSION:
8190     case OFP16_VERSION: {
8191         struct ofp11_group_stats_request *req;
8192         request = ofpraw_alloc(OFPRAW_OFPST11_GROUP_REQUEST, ofp_version, 0);
8193         req = ofpbuf_put_zeros(request, sizeof *req);
8194         req->group_id = htonl(group_id);
8195         break;
8196     }
8197     default:
8198         OVS_NOT_REACHED();
8199     }
8200
8201     return request;
8202 }
8203
8204 void
8205 ofputil_uninit_group_desc(struct ofputil_group_desc *gd)
8206 {
8207     ofputil_bucket_list_destroy(&gd->buckets);
8208     free(&gd->props.fields);
8209 }
8210
8211 /* Decodes the OpenFlow group description request in 'oh', returning the group
8212  * whose description is requested, or OFPG_ALL if stats for all groups was
8213  * requested. */
8214 uint32_t
8215 ofputil_decode_group_desc_request(const struct ofp_header *oh)
8216 {
8217     struct ofpbuf request = ofpbuf_const_initializer(oh, ntohs(oh->length));
8218     enum ofpraw raw = ofpraw_pull_assert(&request);
8219     if (raw == OFPRAW_OFPST11_GROUP_DESC_REQUEST) {
8220         return OFPG_ALL;
8221     } else if (raw == OFPRAW_OFPST15_GROUP_DESC_REQUEST) {
8222         ovs_be32 *group_id = ofpbuf_pull(&request, sizeof *group_id);
8223         return ntohl(*group_id);
8224     } else {
8225         OVS_NOT_REACHED();
8226     }
8227 }
8228
8229 /* Returns an OpenFlow group description request for OpenFlow version
8230  * 'ofp_version', that requests stats for group 'group_id'.  Use OFPG_ALL to
8231  * request stats for all groups (OpenFlow 1.4 and earlier always request all
8232  * groups).
8233  *
8234  * Group descriptions include the bucket and action configuration for each
8235  * group. */
8236 struct ofpbuf *
8237 ofputil_encode_group_desc_request(enum ofp_version ofp_version,
8238                                   uint32_t group_id)
8239 {
8240     struct ofpbuf *request;
8241
8242     switch (ofp_version) {
8243     case OFP10_VERSION:
8244         ovs_fatal(0, "dump-groups needs OpenFlow 1.1 or later "
8245                      "(\'-O OpenFlow11\')");
8246     case OFP11_VERSION:
8247     case OFP12_VERSION:
8248     case OFP13_VERSION:
8249     case OFP14_VERSION:
8250         request = ofpraw_alloc(OFPRAW_OFPST11_GROUP_DESC_REQUEST,
8251                                ofp_version, 0);
8252         break;
8253     case OFP15_VERSION:
8254     case OFP16_VERSION: {
8255         struct ofp15_group_desc_request *req;
8256         request = ofpraw_alloc(OFPRAW_OFPST15_GROUP_DESC_REQUEST,
8257                                ofp_version, 0);
8258         req = ofpbuf_put_zeros(request, sizeof *req);
8259         req->group_id = htonl(group_id);
8260         break;
8261     }
8262     default:
8263         OVS_NOT_REACHED();
8264     }
8265
8266     return request;
8267 }
8268
8269 static void
8270 ofputil_group_bucket_counters_to_ofp11(const struct ofputil_group_stats *gs,
8271                                     struct ofp11_bucket_counter bucket_cnts[])
8272 {
8273     int i;
8274
8275     for (i = 0; i < gs->n_buckets; i++) {
8276        bucket_cnts[i].packet_count = htonll(gs->bucket_stats[i].packet_count);
8277        bucket_cnts[i].byte_count = htonll(gs->bucket_stats[i].byte_count);
8278     }
8279 }
8280
8281 static void
8282 ofputil_group_stats_to_ofp11(const struct ofputil_group_stats *gs,
8283                              struct ofp11_group_stats *gs11, size_t length,
8284                              struct ofp11_bucket_counter bucket_cnts[])
8285 {
8286     memset(gs11, 0, sizeof *gs11);
8287     gs11->length = htons(length);
8288     gs11->group_id = htonl(gs->group_id);
8289     gs11->ref_count = htonl(gs->ref_count);
8290     gs11->packet_count = htonll(gs->packet_count);
8291     gs11->byte_count = htonll(gs->byte_count);
8292     ofputil_group_bucket_counters_to_ofp11(gs, bucket_cnts);
8293 }
8294
8295 static void
8296 ofputil_group_stats_to_ofp13(const struct ofputil_group_stats *gs,
8297                              struct ofp13_group_stats *gs13, size_t length,
8298                              struct ofp11_bucket_counter bucket_cnts[])
8299 {
8300     ofputil_group_stats_to_ofp11(gs, &gs13->gs, length, bucket_cnts);
8301     gs13->duration_sec = htonl(gs->duration_sec);
8302     gs13->duration_nsec = htonl(gs->duration_nsec);
8303
8304 }
8305
8306 /* Encodes 'gs' properly for the format of the list of group statistics
8307  * replies already begun in 'replies' and appends it to the list.  'replies'
8308  * must have originally been initialized with ofpmp_init(). */
8309 void
8310 ofputil_append_group_stats(struct ovs_list *replies,
8311                            const struct ofputil_group_stats *gs)
8312 {
8313     size_t bucket_counter_size;
8314     struct ofp11_bucket_counter *bucket_counters;
8315     size_t length;
8316
8317     bucket_counter_size = gs->n_buckets * sizeof(struct ofp11_bucket_counter);
8318
8319     switch (ofpmp_version(replies)) {
8320     case OFP11_VERSION:
8321     case OFP12_VERSION:{
8322             struct ofp11_group_stats *gs11;
8323
8324             length = sizeof *gs11 + bucket_counter_size;
8325             gs11 = ofpmp_append(replies, length);
8326             bucket_counters = (struct ofp11_bucket_counter *)(gs11 + 1);
8327             ofputil_group_stats_to_ofp11(gs, gs11, length, bucket_counters);
8328             break;
8329         }
8330
8331     case OFP13_VERSION:
8332     case OFP14_VERSION:
8333     case OFP15_VERSION:
8334     case OFP16_VERSION: {
8335             struct ofp13_group_stats *gs13;
8336
8337             length = sizeof *gs13 + bucket_counter_size;
8338             gs13 = ofpmp_append(replies, length);
8339             bucket_counters = (struct ofp11_bucket_counter *)(gs13 + 1);
8340             ofputil_group_stats_to_ofp13(gs, gs13, length, bucket_counters);
8341             break;
8342         }
8343
8344     case OFP10_VERSION:
8345     default:
8346         OVS_NOT_REACHED();
8347     }
8348 }
8349 /* Returns an OpenFlow group features request for OpenFlow version
8350  * 'ofp_version'. */
8351 struct ofpbuf *
8352 ofputil_encode_group_features_request(enum ofp_version ofp_version)
8353 {
8354     struct ofpbuf *request = NULL;
8355
8356     switch (ofp_version) {
8357     case OFP10_VERSION:
8358     case OFP11_VERSION:
8359         ovs_fatal(0, "dump-group-features needs OpenFlow 1.2 or later "
8360                      "(\'-O OpenFlow12\')");
8361     case OFP12_VERSION:
8362     case OFP13_VERSION:
8363     case OFP14_VERSION:
8364     case OFP15_VERSION:
8365     case OFP16_VERSION:
8366         request = ofpraw_alloc(OFPRAW_OFPST12_GROUP_FEATURES_REQUEST,
8367                                ofp_version, 0);
8368         break;
8369     default:
8370         OVS_NOT_REACHED();
8371     }
8372
8373     return request;
8374 }
8375
8376 /* Returns a OpenFlow message that encodes 'features' properly as a reply to
8377  * group features request 'request'. */
8378 struct ofpbuf *
8379 ofputil_encode_group_features_reply(
8380     const struct ofputil_group_features *features,
8381     const struct ofp_header *request)
8382 {
8383     struct ofp12_group_features_stats *ogf;
8384     struct ofpbuf *reply;
8385     int i;
8386
8387     reply = ofpraw_alloc_xid(OFPRAW_OFPST12_GROUP_FEATURES_REPLY,
8388                              request->version, request->xid, 0);
8389     ogf = ofpbuf_put_zeros(reply, sizeof *ogf);
8390     ogf->types = htonl(features->types);
8391     ogf->capabilities = htonl(features->capabilities);
8392     for (i = 0; i < OFPGT12_N_TYPES; i++) {
8393         ogf->max_groups[i] = htonl(features->max_groups[i]);
8394         ogf->actions[i] = ofpact_bitmap_to_openflow(features->ofpacts[i],
8395                                                     request->version);
8396     }
8397
8398     return reply;
8399 }
8400
8401 /* Decodes group features reply 'oh' into 'features'. */
8402 void
8403 ofputil_decode_group_features_reply(const struct ofp_header *oh,
8404                                     struct ofputil_group_features *features)
8405 {
8406     const struct ofp12_group_features_stats *ogf = ofpmsg_body(oh);
8407     int i;
8408
8409     features->types = ntohl(ogf->types);
8410     features->capabilities = ntohl(ogf->capabilities);
8411     for (i = 0; i < OFPGT12_N_TYPES; i++) {
8412         features->max_groups[i] = ntohl(ogf->max_groups[i]);
8413         features->ofpacts[i] = ofpact_bitmap_from_openflow(
8414             ogf->actions[i], oh->version);
8415     }
8416 }
8417
8418 /* Parse a group status request message into a 32 bit OpenFlow 1.1
8419  * group ID and stores the latter in '*group_id'.
8420  * Returns 0 if successful, otherwise an OFPERR_* number. */
8421 enum ofperr
8422 ofputil_decode_group_stats_request(const struct ofp_header *request,
8423                                    uint32_t *group_id)
8424 {
8425     const struct ofp11_group_stats_request *gsr11 = ofpmsg_body(request);
8426     *group_id = ntohl(gsr11->group_id);
8427     return 0;
8428 }
8429
8430 /* Converts a group stats reply in 'msg' into an abstract ofputil_group_stats
8431  * in 'gs'.  Assigns freshly allocated memory to gs->bucket_stats for the
8432  * caller to eventually free.
8433  *
8434  * Multiple group stats replies can be packed into a single OpenFlow message.
8435  * Calling this function multiple times for a single 'msg' iterates through the
8436  * replies.  The caller must initially leave 'msg''s layer pointers null and
8437  * not modify them between calls.
8438  *
8439  * Returns 0 if successful, EOF if no replies were left in this 'msg',
8440  * otherwise a positive errno value. */
8441 int
8442 ofputil_decode_group_stats_reply(struct ofpbuf *msg,
8443                                  struct ofputil_group_stats *gs)
8444 {
8445     struct ofp11_bucket_counter *obc;
8446     struct ofp11_group_stats *ogs11;
8447     enum ofpraw raw;
8448     enum ofperr error;
8449     size_t base_len;
8450     size_t length;
8451     size_t i;
8452
8453     gs->bucket_stats = NULL;
8454     error = (msg->header ? ofpraw_decode(&raw, msg->header)
8455              : ofpraw_pull(&raw, msg));
8456     if (error) {
8457         return error;
8458     }
8459
8460     if (!msg->size) {
8461         return EOF;
8462     }
8463
8464     if (raw == OFPRAW_OFPST11_GROUP_REPLY) {
8465         base_len = sizeof *ogs11;
8466         ogs11 = ofpbuf_try_pull(msg, sizeof *ogs11);
8467         gs->duration_sec = gs->duration_nsec = UINT32_MAX;
8468     } else if (raw == OFPRAW_OFPST13_GROUP_REPLY) {
8469         struct ofp13_group_stats *ogs13;
8470
8471         base_len = sizeof *ogs13;
8472         ogs13 = ofpbuf_try_pull(msg, sizeof *ogs13);
8473         if (ogs13) {
8474             ogs11 = &ogs13->gs;
8475             gs->duration_sec = ntohl(ogs13->duration_sec);
8476             gs->duration_nsec = ntohl(ogs13->duration_nsec);
8477         } else {
8478             ogs11 = NULL;
8479         }
8480     } else {
8481         OVS_NOT_REACHED();
8482     }
8483
8484     if (!ogs11) {
8485         VLOG_WARN_RL(&bad_ofmsg_rl, "%s reply has %"PRIu32" leftover bytes at end",
8486                      ofpraw_get_name(raw), msg->size);
8487         return OFPERR_OFPBRC_BAD_LEN;
8488     }
8489     length = ntohs(ogs11->length);
8490     if (length < sizeof base_len) {
8491         VLOG_WARN_RL(&bad_ofmsg_rl, "%s reply claims invalid length %"PRIuSIZE,
8492                      ofpraw_get_name(raw), length);
8493         return OFPERR_OFPBRC_BAD_LEN;
8494     }
8495
8496     gs->group_id = ntohl(ogs11->group_id);
8497     gs->ref_count = ntohl(ogs11->ref_count);
8498     gs->packet_count = ntohll(ogs11->packet_count);
8499     gs->byte_count = ntohll(ogs11->byte_count);
8500
8501     gs->n_buckets = (length - base_len) / sizeof *obc;
8502     obc = ofpbuf_try_pull(msg, gs->n_buckets * sizeof *obc);
8503     if (!obc) {
8504         VLOG_WARN_RL(&bad_ofmsg_rl, "%s reply has %"PRIu32" leftover bytes at end",
8505                      ofpraw_get_name(raw), msg->size);
8506         return OFPERR_OFPBRC_BAD_LEN;
8507     }
8508
8509     gs->bucket_stats = xmalloc(gs->n_buckets * sizeof *gs->bucket_stats);
8510     for (i = 0; i < gs->n_buckets; i++) {
8511         gs->bucket_stats[i].packet_count = ntohll(obc[i].packet_count);
8512         gs->bucket_stats[i].byte_count = ntohll(obc[i].byte_count);
8513     }
8514
8515     return 0;
8516 }
8517
8518 static void
8519 ofputil_put_ofp11_bucket(const struct ofputil_bucket *bucket,
8520                          struct ofpbuf *openflow, enum ofp_version ofp_version)
8521 {
8522     struct ofp11_bucket *ob;
8523     size_t start;
8524
8525     start = openflow->size;
8526     ofpbuf_put_zeros(openflow, sizeof *ob);
8527     ofpacts_put_openflow_actions(bucket->ofpacts, bucket->ofpacts_len,
8528                                 openflow, ofp_version);
8529     ob = ofpbuf_at_assert(openflow, start, sizeof *ob);
8530     ob->len = htons(openflow->size - start);
8531     ob->weight = htons(bucket->weight);
8532     ob->watch_port = ofputil_port_to_ofp11(bucket->watch_port);
8533     ob->watch_group = htonl(bucket->watch_group);
8534 }
8535
8536 static void
8537 ofputil_put_ofp15_bucket(const struct ofputil_bucket *bucket,
8538                          uint32_t bucket_id, enum ofp11_group_type group_type,
8539                          struct ofpbuf *openflow, enum ofp_version ofp_version)
8540 {
8541     struct ofp15_bucket *ob;
8542     size_t start, actions_start, actions_len;
8543
8544     start = openflow->size;
8545     ofpbuf_put_zeros(openflow, sizeof *ob);
8546
8547     actions_start = openflow->size;
8548     ofpacts_put_openflow_actions(bucket->ofpacts, bucket->ofpacts_len,
8549                                  openflow, ofp_version);
8550     actions_len = openflow->size - actions_start;
8551
8552     if (group_type == OFPGT11_SELECT) {
8553         ofpprop_put_u16(openflow, OFPGBPT15_WEIGHT, bucket->weight);
8554     }
8555     if (bucket->watch_port != OFPP_ANY) {
8556         ofpprop_put_be32(openflow, OFPGBPT15_WATCH_PORT,
8557                          ofputil_port_to_ofp11(bucket->watch_port));
8558     }
8559     if (bucket->watch_group != OFPG_ANY) {
8560         ofpprop_put_u32(openflow, OFPGBPT15_WATCH_GROUP, bucket->watch_group);
8561     }
8562
8563     ob = ofpbuf_at_assert(openflow, start, sizeof *ob);
8564     ob->len = htons(openflow->size - start);
8565     ob->action_array_len = htons(actions_len);
8566     ob->bucket_id = htonl(bucket_id);
8567 }
8568
8569 static void
8570 ofputil_put_group_prop_ntr_selection_method(enum ofp_version ofp_version,
8571                                             const struct ofputil_group_props *gp,
8572                                             struct ofpbuf *openflow)
8573 {
8574     struct ntr_group_prop_selection_method *prop;
8575     size_t start;
8576
8577     start = openflow->size;
8578     ofpbuf_put_zeros(openflow, sizeof *prop);
8579     oxm_put_field_array(openflow, &gp->fields, ofp_version);
8580     prop = ofpbuf_at_assert(openflow, start, sizeof *prop);
8581     prop->type = htons(OFPGPT15_EXPERIMENTER);
8582     prop->experimenter = htonl(NTR_VENDOR_ID);
8583     prop->exp_type = htonl(NTRT_SELECTION_METHOD);
8584     strcpy(prop->selection_method, gp->selection_method);
8585     prop->selection_method_param = htonll(gp->selection_method_param);
8586     ofpprop_end(openflow, start);
8587 }
8588
8589 static void
8590 ofputil_append_ofp11_group_desc_reply(const struct ofputil_group_desc *gds,
8591                                       const struct ovs_list *buckets,
8592                                       struct ovs_list *replies,
8593                                       enum ofp_version version)
8594 {
8595     struct ofpbuf *reply = ofpbuf_from_list(ovs_list_back(replies));
8596     struct ofp11_group_desc_stats *ogds;
8597     struct ofputil_bucket *bucket;
8598     size_t start_ogds;
8599
8600     start_ogds = reply->size;
8601     ofpbuf_put_zeros(reply, sizeof *ogds);
8602     LIST_FOR_EACH (bucket, list_node, buckets) {
8603         ofputil_put_ofp11_bucket(bucket, reply, version);
8604     }
8605     ogds = ofpbuf_at_assert(reply, start_ogds, sizeof *ogds);
8606     ogds->length = htons(reply->size - start_ogds);
8607     ogds->type = gds->type;
8608     ogds->group_id = htonl(gds->group_id);
8609
8610     ofpmp_postappend(replies, start_ogds);
8611 }
8612
8613 static void
8614 ofputil_append_ofp15_group_desc_reply(const struct ofputil_group_desc *gds,
8615                                       const struct ovs_list *buckets,
8616                                       struct ovs_list *replies,
8617                                       enum ofp_version version)
8618 {
8619     struct ofpbuf *reply = ofpbuf_from_list(ovs_list_back(replies));
8620     struct ofp15_group_desc_stats *ogds;
8621     struct ofputil_bucket *bucket;
8622     size_t start_ogds, start_buckets;
8623
8624     start_ogds = reply->size;
8625     ofpbuf_put_zeros(reply, sizeof *ogds);
8626     start_buckets = reply->size;
8627     LIST_FOR_EACH (bucket, list_node, buckets) {
8628         ofputil_put_ofp15_bucket(bucket, bucket->bucket_id,
8629                                  gds->type, reply, version);
8630     }
8631     ogds = ofpbuf_at_assert(reply, start_ogds, sizeof *ogds);
8632     ogds->type = gds->type;
8633     ogds->group_id = htonl(gds->group_id);
8634     ogds->bucket_list_len =  htons(reply->size - start_buckets);
8635
8636     /* Add group properties */
8637     if (gds->props.selection_method[0]) {
8638         ofputil_put_group_prop_ntr_selection_method(version, &gds->props,
8639                                                     reply);
8640     }
8641     ogds = ofpbuf_at_assert(reply, start_ogds, sizeof *ogds);
8642     ogds->length = htons(reply->size - start_ogds);
8643
8644     ofpmp_postappend(replies, start_ogds);
8645 }
8646
8647 /* Appends a group stats reply that contains the data in 'gds' to those already
8648  * present in the list of ofpbufs in 'replies'.  'replies' should have been
8649  * initialized with ofpmp_init(). */
8650 void
8651 ofputil_append_group_desc_reply(const struct ofputil_group_desc *gds,
8652                                 const struct ovs_list *buckets,
8653                                 struct ovs_list *replies)
8654 {
8655     enum ofp_version version = ofpmp_version(replies);
8656
8657     switch (version)
8658     {
8659     case OFP11_VERSION:
8660     case OFP12_VERSION:
8661     case OFP13_VERSION:
8662     case OFP14_VERSION:
8663         ofputil_append_ofp11_group_desc_reply(gds, buckets, replies, version);
8664         break;
8665
8666     case OFP15_VERSION:
8667     case OFP16_VERSION:
8668         ofputil_append_ofp15_group_desc_reply(gds, buckets, replies, version);
8669         break;
8670
8671     case OFP10_VERSION:
8672     default:
8673         OVS_NOT_REACHED();
8674     }
8675 }
8676
8677 static enum ofperr
8678 ofputil_pull_ofp11_buckets(struct ofpbuf *msg, size_t buckets_length,
8679                            enum ofp_version version, struct ovs_list *buckets)
8680 {
8681     struct ofp11_bucket *ob;
8682     uint32_t bucket_id = 0;
8683
8684     ovs_list_init(buckets);
8685     while (buckets_length > 0) {
8686         struct ofputil_bucket *bucket;
8687         struct ofpbuf ofpacts;
8688         enum ofperr error;
8689         size_t ob_len;
8690
8691         ob = (buckets_length >= sizeof *ob
8692               ? ofpbuf_try_pull(msg, sizeof *ob)
8693               : NULL);
8694         if (!ob) {
8695             VLOG_WARN_RL(&bad_ofmsg_rl, "buckets end with %"PRIuSIZE" leftover bytes",
8696                          buckets_length);
8697             return OFPERR_OFPGMFC_BAD_BUCKET;
8698         }
8699
8700         ob_len = ntohs(ob->len);
8701         if (ob_len < sizeof *ob) {
8702             VLOG_WARN_RL(&bad_ofmsg_rl, "OpenFlow message bucket length "
8703                          "%"PRIuSIZE" is not valid", ob_len);
8704             return OFPERR_OFPGMFC_BAD_BUCKET;
8705         } else if (ob_len > buckets_length) {
8706             VLOG_WARN_RL(&bad_ofmsg_rl, "OpenFlow message bucket length "
8707                          "%"PRIuSIZE" exceeds remaining buckets data size %"PRIuSIZE,
8708                          ob_len, buckets_length);
8709             return OFPERR_OFPGMFC_BAD_BUCKET;
8710         }
8711         buckets_length -= ob_len;
8712
8713         ofpbuf_init(&ofpacts, 0);
8714         error = ofpacts_pull_openflow_actions(msg, ob_len - sizeof *ob,
8715                                               version, &ofpacts);
8716         if (error) {
8717             ofpbuf_uninit(&ofpacts);
8718             ofputil_bucket_list_destroy(buckets);
8719             return error;
8720         }
8721
8722         bucket = xzalloc(sizeof *bucket);
8723         bucket->weight = ntohs(ob->weight);
8724         error = ofputil_port_from_ofp11(ob->watch_port, &bucket->watch_port);
8725         if (error) {
8726             ofpbuf_uninit(&ofpacts);
8727             ofputil_bucket_list_destroy(buckets);
8728             return OFPERR_OFPGMFC_BAD_WATCH;
8729         }
8730         bucket->watch_group = ntohl(ob->watch_group);
8731         bucket->bucket_id = bucket_id++;
8732
8733         bucket->ofpacts = ofpbuf_steal_data(&ofpacts);
8734         bucket->ofpacts_len = ofpacts.size;
8735         ovs_list_push_back(buckets, &bucket->list_node);
8736     }
8737
8738     return 0;
8739 }
8740
8741 static enum ofperr
8742 ofputil_pull_ofp15_buckets(struct ofpbuf *msg, size_t buckets_length,
8743                            enum ofp_version version, uint8_t group_type,
8744                            struct ovs_list *buckets)
8745 {
8746     struct ofp15_bucket *ob;
8747
8748     ovs_list_init(buckets);
8749     while (buckets_length > 0) {
8750         struct ofputil_bucket *bucket = NULL;
8751         struct ofpbuf ofpacts;
8752         enum ofperr err = OFPERR_OFPGMFC_BAD_BUCKET;
8753         size_t ob_len, actions_len, properties_len;
8754         ovs_be32 watch_port = ofputil_port_to_ofp11(OFPP_ANY);
8755         ovs_be32 watch_group = htonl(OFPG_ANY);
8756         ovs_be16 weight = htons(group_type == OFPGT11_SELECT ? 1 : 0);
8757
8758         ofpbuf_init(&ofpacts, 0);
8759
8760         ob = ofpbuf_try_pull(msg, sizeof *ob);
8761         if (!ob) {
8762             VLOG_WARN_RL(&bad_ofmsg_rl, "buckets end with %"PRIuSIZE
8763                          " leftover bytes", buckets_length);
8764             goto err;
8765         }
8766
8767         ob_len = ntohs(ob->len);
8768         actions_len = ntohs(ob->action_array_len);
8769
8770         if (ob_len < sizeof *ob) {
8771             VLOG_WARN_RL(&bad_ofmsg_rl, "OpenFlow message bucket length "
8772                          "%"PRIuSIZE" is not valid", ob_len);
8773             goto err;
8774         } else if (ob_len > buckets_length) {
8775             VLOG_WARN_RL(&bad_ofmsg_rl, "OpenFlow message bucket length "
8776                          "%"PRIuSIZE" exceeds remaining buckets data size %"
8777                          PRIuSIZE, ob_len, buckets_length);
8778             goto err;
8779         } else if (actions_len > ob_len - sizeof *ob) {
8780             VLOG_WARN_RL(&bad_ofmsg_rl, "OpenFlow message bucket actions "
8781                          "length %"PRIuSIZE" exceeds remaining bucket "
8782                          "data size %"PRIuSIZE, actions_len,
8783                          ob_len - sizeof *ob);
8784             goto err;
8785         }
8786         buckets_length -= ob_len;
8787
8788         err = ofpacts_pull_openflow_actions(msg, actions_len, version,
8789                                             &ofpacts);
8790         if (err) {
8791             goto err;
8792         }
8793
8794         properties_len = ob_len - sizeof *ob - actions_len;
8795         struct ofpbuf properties = ofpbuf_const_initializer(
8796             ofpbuf_pull(msg, properties_len), properties_len);
8797         while (properties.size > 0) {
8798             struct ofpbuf payload;
8799             uint64_t type;
8800
8801             err = ofpprop_pull(&properties, &payload, &type);
8802             if (err) {
8803                 goto err;
8804             }
8805
8806             switch (type) {
8807             case OFPGBPT15_WEIGHT:
8808                 err = ofpprop_parse_be16(&payload, &weight);
8809                 break;
8810
8811             case OFPGBPT15_WATCH_PORT:
8812                 err = ofpprop_parse_be32(&payload, &watch_port);
8813                 break;
8814
8815             case OFPGBPT15_WATCH_GROUP:
8816                 err = ofpprop_parse_be32(&payload, &watch_group);
8817                 break;
8818
8819             default:
8820                 err = OFPPROP_UNKNOWN(false, "group bucket", type);
8821                 break;
8822             }
8823
8824             if (err) {
8825                 goto err;
8826             }
8827         }
8828
8829         bucket = xzalloc(sizeof *bucket);
8830
8831         bucket->weight = ntohs(weight);
8832         err = ofputil_port_from_ofp11(watch_port, &bucket->watch_port);
8833         if (err) {
8834             err = OFPERR_OFPGMFC_BAD_WATCH;
8835             goto err;
8836         }
8837         bucket->watch_group = ntohl(watch_group);
8838         bucket->bucket_id = ntohl(ob->bucket_id);
8839         if (bucket->bucket_id > OFPG15_BUCKET_MAX) {
8840             VLOG_WARN_RL(&bad_ofmsg_rl, "bucket id (%u) is out of range",
8841                          bucket->bucket_id);
8842             err = OFPERR_OFPGMFC_BAD_BUCKET;
8843             goto err;
8844         }
8845
8846         bucket->ofpacts = ofpbuf_steal_data(&ofpacts);
8847         bucket->ofpacts_len = ofpacts.size;
8848         ovs_list_push_back(buckets, &bucket->list_node);
8849
8850         continue;
8851
8852     err:
8853         free(bucket);
8854         ofpbuf_uninit(&ofpacts);
8855         ofputil_bucket_list_destroy(buckets);
8856         return err;
8857     }
8858
8859     if (ofputil_bucket_check_duplicate_id(buckets)) {
8860         VLOG_WARN_RL(&bad_ofmsg_rl, "Duplicate bucket id");
8861         ofputil_bucket_list_destroy(buckets);
8862         return OFPERR_OFPGMFC_BAD_BUCKET;
8863     }
8864
8865     return 0;
8866 }
8867
8868 static void
8869 ofputil_init_group_properties(struct ofputil_group_props *gp)
8870 {
8871     memset(gp, 0, sizeof *gp);
8872 }
8873
8874 static enum ofperr
8875 parse_group_prop_ntr_selection_method(struct ofpbuf *payload,
8876                                       enum ofp11_group_type group_type,
8877                                       enum ofp15_group_mod_command group_cmd,
8878                                       struct ofputil_group_props *gp)
8879 {
8880     struct ntr_group_prop_selection_method *prop = payload->data;
8881     size_t fields_len, method_len;
8882     enum ofperr error;
8883
8884     switch (group_type) {
8885     case OFPGT11_SELECT:
8886         break;
8887     case OFPGT11_ALL:
8888     case OFPGT11_INDIRECT:
8889     case OFPGT11_FF:
8890         OFPPROP_LOG(&bad_ofmsg_rl, false, "ntr selection method property is "
8891                     "only allowed for select groups");
8892         return OFPERR_OFPBPC_BAD_VALUE;
8893     default:
8894         OVS_NOT_REACHED();
8895     }
8896
8897     switch (group_cmd) {
8898     case OFPGC15_ADD:
8899     case OFPGC15_MODIFY:
8900     case OFPGC15_ADD_OR_MOD:
8901         break;
8902     case OFPGC15_DELETE:
8903     case OFPGC15_INSERT_BUCKET:
8904     case OFPGC15_REMOVE_BUCKET:
8905         OFPPROP_LOG(&bad_ofmsg_rl, false, "ntr selection method property is "
8906                     "only allowed for add and delete group modifications");
8907         return OFPERR_OFPBPC_BAD_VALUE;
8908     default:
8909         OVS_NOT_REACHED();
8910     }
8911
8912     if (payload->size < sizeof *prop) {
8913         OFPPROP_LOG(&bad_ofmsg_rl, false, "ntr selection method property "
8914                     "length %u is not valid", payload->size);
8915         return OFPERR_OFPBPC_BAD_LEN;
8916     }
8917
8918     method_len = strnlen(prop->selection_method, NTR_MAX_SELECTION_METHOD_LEN);
8919
8920     if (method_len == NTR_MAX_SELECTION_METHOD_LEN) {
8921         OFPPROP_LOG(&bad_ofmsg_rl, false,
8922                     "ntr selection method is not null terminated");
8923         return OFPERR_OFPBPC_BAD_VALUE;
8924     }
8925
8926     if (strcmp("hash", prop->selection_method)) {
8927         OFPPROP_LOG(&bad_ofmsg_rl, false,
8928                     "ntr selection method '%s' is not supported",
8929                     prop->selection_method);
8930         return OFPERR_OFPBPC_BAD_VALUE;
8931     }
8932
8933     strcpy(gp->selection_method, prop->selection_method);
8934     gp->selection_method_param = ntohll(prop->selection_method_param);
8935
8936     if (!method_len && gp->selection_method_param) {
8937         OFPPROP_LOG(&bad_ofmsg_rl, false, "ntr selection method parameter is "
8938                     "non-zero but selection method is empty");
8939         return OFPERR_OFPBPC_BAD_VALUE;
8940     }
8941
8942     ofpbuf_pull(payload, sizeof *prop);
8943
8944     fields_len = ntohs(prop->length) - sizeof *prop;
8945     if (!method_len && fields_len) {
8946         OFPPROP_LOG(&bad_ofmsg_rl, false, "ntr selection method parameter is "
8947                     "zero but fields are provided");
8948         return OFPERR_OFPBPC_BAD_VALUE;
8949     }
8950
8951     error = oxm_pull_field_array(payload->data, fields_len,
8952                                  &gp->fields);
8953     if (error) {
8954         OFPPROP_LOG(&bad_ofmsg_rl, false,
8955                     "ntr selection method fields are invalid");
8956         return error;
8957     }
8958
8959     return 0;
8960 }
8961
8962 static enum ofperr
8963 parse_ofp15_group_properties(struct ofpbuf *msg,
8964                              enum ofp11_group_type group_type,
8965                              enum ofp15_group_mod_command group_cmd,
8966                              struct ofputil_group_props *gp,
8967                              size_t properties_len)
8968 {
8969     struct ofpbuf properties = ofpbuf_const_initializer(
8970         ofpbuf_pull(msg, properties_len), properties_len);
8971     while (properties.size > 0) {
8972         struct ofpbuf payload;
8973         enum ofperr error;
8974         uint64_t type;
8975
8976         error = ofpprop_pull(&properties, &payload, &type);
8977         if (error) {
8978             return error;
8979         }
8980
8981         switch (type) {
8982         case OFPPROP_EXP(NTR_VENDOR_ID, NTRT_SELECTION_METHOD):
8983         case OFPPROP_EXP(NTR_COMPAT_VENDOR_ID, NTRT_SELECTION_METHOD):
8984             error = parse_group_prop_ntr_selection_method(&payload, group_type,
8985                                                           group_cmd, gp);
8986             break;
8987
8988         default:
8989             error = OFPPROP_UNKNOWN(false, "group", type);
8990             break;
8991         }
8992
8993         if (error) {
8994             return error;
8995         }
8996     }
8997
8998     return 0;
8999 }
9000
9001 static int
9002 ofputil_decode_ofp11_group_desc_reply(struct ofputil_group_desc *gd,
9003                                       struct ofpbuf *msg,
9004                                       enum ofp_version version)
9005 {
9006     struct ofp11_group_desc_stats *ogds;
9007     size_t length;
9008
9009     if (!msg->header) {
9010         ofpraw_pull_assert(msg);
9011     }
9012
9013     if (!msg->size) {
9014         return EOF;
9015     }
9016
9017     ogds = ofpbuf_try_pull(msg, sizeof *ogds);
9018     if (!ogds) {
9019         VLOG_WARN_RL(&bad_ofmsg_rl, "OFPST11_GROUP_DESC reply has %"PRIu32" "
9020                      "leftover bytes at end", msg->size);
9021         return OFPERR_OFPBRC_BAD_LEN;
9022     }
9023     gd->type = ogds->type;
9024     gd->group_id = ntohl(ogds->group_id);
9025
9026     length = ntohs(ogds->length);
9027     if (length < sizeof *ogds || length - sizeof *ogds > msg->size) {
9028         VLOG_WARN_RL(&bad_ofmsg_rl, "OFPST11_GROUP_DESC reply claims invalid "
9029                      "length %"PRIuSIZE, length);
9030         return OFPERR_OFPBRC_BAD_LEN;
9031     }
9032
9033     return ofputil_pull_ofp11_buckets(msg, length - sizeof *ogds, version,
9034                                       &gd->buckets);
9035 }
9036
9037 static int
9038 ofputil_decode_ofp15_group_desc_reply(struct ofputil_group_desc *gd,
9039                                       struct ofpbuf *msg,
9040                                       enum ofp_version version)
9041 {
9042     struct ofp15_group_desc_stats *ogds;
9043     uint16_t length, bucket_list_len;
9044     int error;
9045
9046     if (!msg->header) {
9047         ofpraw_pull_assert(msg);
9048     }
9049
9050     if (!msg->size) {
9051         return EOF;
9052     }
9053
9054     ogds = ofpbuf_try_pull(msg, sizeof *ogds);
9055     if (!ogds) {
9056         VLOG_WARN_RL(&bad_ofmsg_rl, "OFPST11_GROUP_DESC reply has %"PRIu32" "
9057                      "leftover bytes at end", msg->size);
9058         return OFPERR_OFPBRC_BAD_LEN;
9059     }
9060     gd->type = ogds->type;
9061     gd->group_id = ntohl(ogds->group_id);
9062
9063     length = ntohs(ogds->length);
9064     if (length < sizeof *ogds || length - sizeof *ogds > msg->size) {
9065         VLOG_WARN_RL(&bad_ofmsg_rl, "OFPST11_GROUP_DESC reply claims invalid "
9066                      "length %u", length);
9067         return OFPERR_OFPBRC_BAD_LEN;
9068     }
9069
9070     bucket_list_len = ntohs(ogds->bucket_list_len);
9071     if (length < bucket_list_len + sizeof *ogds) {
9072         VLOG_WARN_RL(&bad_ofmsg_rl, "OFPST11_GROUP_DESC reply claims invalid "
9073                      "bucket list length %u", bucket_list_len);
9074         return OFPERR_OFPBRC_BAD_LEN;
9075     }
9076     error = ofputil_pull_ofp15_buckets(msg, bucket_list_len, version, gd->type,
9077                                        &gd->buckets);
9078     if (error) {
9079         return error;
9080     }
9081
9082     /* By definition group desc messages don't have a group mod command.
9083      * However, parse_group_prop_ntr_selection_method() checks to make sure
9084      * that the command is OFPGC15_ADD or OFPGC15_DELETE to guard
9085      * against group mod messages with other commands supplying
9086      * a NTR selection method group experimenter property.
9087      * Such properties are valid for group desc replies so
9088      * claim that the group mod command is OFPGC15_ADD to
9089      * satisfy the check in parse_group_prop_ntr_selection_method() */
9090     return parse_ofp15_group_properties(msg, gd->type, OFPGC15_ADD, &gd->props,
9091                                         length - sizeof *ogds - bucket_list_len);
9092 }
9093
9094 /* Converts a group description reply in 'msg' into an abstract
9095  * ofputil_group_desc in 'gd'.
9096  *
9097  * Multiple group description replies can be packed into a single OpenFlow
9098  * message.  Calling this function multiple times for a single 'msg' iterates
9099  * through the replies.  The caller must initially leave 'msg''s layer pointers
9100  * null and not modify them between calls.
9101  *
9102  * Returns 0 if successful, EOF if no replies were left in this 'msg',
9103  * otherwise a positive errno value. */
9104 int
9105 ofputil_decode_group_desc_reply(struct ofputil_group_desc *gd,
9106                                 struct ofpbuf *msg, enum ofp_version version)
9107 {
9108     ofputil_init_group_properties(&gd->props);
9109
9110     switch (version)
9111     {
9112     case OFP11_VERSION:
9113     case OFP12_VERSION:
9114     case OFP13_VERSION:
9115     case OFP14_VERSION:
9116         return ofputil_decode_ofp11_group_desc_reply(gd, msg, version);
9117
9118     case OFP15_VERSION:
9119     case OFP16_VERSION:
9120         return ofputil_decode_ofp15_group_desc_reply(gd, msg, version);
9121
9122     case OFP10_VERSION:
9123     default:
9124         OVS_NOT_REACHED();
9125     }
9126 }
9127
9128 void
9129 ofputil_uninit_group_mod(struct ofputil_group_mod *gm)
9130 {
9131     ofputil_bucket_list_destroy(&gm->buckets);
9132 }
9133
9134 static struct ofpbuf *
9135 ofputil_encode_ofp11_group_mod(enum ofp_version ofp_version,
9136                                const struct ofputil_group_mod *gm)
9137 {
9138     struct ofpbuf *b;
9139     struct ofp11_group_mod *ogm;
9140     size_t start_ogm;
9141     struct ofputil_bucket *bucket;
9142
9143     b = ofpraw_alloc(OFPRAW_OFPT11_GROUP_MOD, ofp_version, 0);
9144     start_ogm = b->size;
9145     ofpbuf_put_zeros(b, sizeof *ogm);
9146
9147     LIST_FOR_EACH (bucket, list_node, &gm->buckets) {
9148         ofputil_put_ofp11_bucket(bucket, b, ofp_version);
9149     }
9150     ogm = ofpbuf_at_assert(b, start_ogm, sizeof *ogm);
9151     ogm->command = htons(gm->command);
9152     ogm->type = gm->type;
9153     ogm->group_id = htonl(gm->group_id);
9154
9155     return b;
9156 }
9157
9158 static struct ofpbuf *
9159 ofputil_encode_ofp15_group_mod(enum ofp_version ofp_version,
9160                                const struct ofputil_group_mod *gm)
9161 {
9162     struct ofpbuf *b;
9163     struct ofp15_group_mod *ogm;
9164     size_t start_ogm;
9165     struct ofputil_bucket *bucket;
9166     struct id_pool *bucket_ids = NULL;
9167
9168     b = ofpraw_alloc(OFPRAW_OFPT15_GROUP_MOD, ofp_version, 0);
9169     start_ogm = b->size;
9170     ofpbuf_put_zeros(b, sizeof *ogm);
9171
9172     LIST_FOR_EACH (bucket, list_node, &gm->buckets) {
9173         uint32_t bucket_id;
9174
9175         /* Generate a bucket id if none was supplied */
9176         if (bucket->bucket_id > OFPG15_BUCKET_MAX) {
9177             if (!bucket_ids) {
9178                 const struct ofputil_bucket *bkt;
9179
9180                 bucket_ids = id_pool_create(0, OFPG15_BUCKET_MAX + 1);
9181
9182                 /* Mark all bucket_ids that are present in gm
9183                  * as used in the pool. */
9184                 LIST_FOR_EACH_REVERSE (bkt, list_node, &gm->buckets) {
9185                     if (bkt == bucket) {
9186                         break;
9187                     }
9188                     if (bkt->bucket_id <= OFPG15_BUCKET_MAX) {
9189                         id_pool_add(bucket_ids, bkt->bucket_id);
9190                     }
9191                 }
9192             }
9193
9194             if (!id_pool_alloc_id(bucket_ids, &bucket_id)) {
9195                 OVS_NOT_REACHED();
9196             }
9197         } else {
9198             bucket_id = bucket->bucket_id;
9199         }
9200
9201         ofputil_put_ofp15_bucket(bucket, bucket_id, gm->type, b, ofp_version);
9202     }
9203     ogm = ofpbuf_at_assert(b, start_ogm, sizeof *ogm);
9204     ogm->command = htons(gm->command);
9205     ogm->type = gm->type;
9206     ogm->group_id = htonl(gm->group_id);
9207     ogm->command_bucket_id = htonl(gm->command_bucket_id);
9208     ogm->bucket_array_len = htons(b->size - start_ogm - sizeof *ogm);
9209
9210     /* Add group properties */
9211     if (gm->props.selection_method[0]) {
9212         ofputil_put_group_prop_ntr_selection_method(ofp_version, &gm->props, b);
9213     }
9214
9215     id_pool_destroy(bucket_ids);
9216     return b;
9217 }
9218
9219 static void
9220 bad_group_cmd(enum ofp15_group_mod_command cmd)
9221 {
9222     const char *opt_version;
9223     const char *version;
9224     const char *cmd_str;
9225
9226     switch (cmd) {
9227     case OFPGC15_ADD:
9228     case OFPGC15_MODIFY:
9229     case OFPGC15_ADD_OR_MOD:
9230     case OFPGC15_DELETE:
9231         version = "1.1";
9232         opt_version = "11";
9233         break;
9234
9235     case OFPGC15_INSERT_BUCKET:
9236     case OFPGC15_REMOVE_BUCKET:
9237         version = "1.5";
9238         opt_version = "15";
9239         break;
9240
9241     default:
9242         OVS_NOT_REACHED();
9243     }
9244
9245     switch (cmd) {
9246     case OFPGC15_ADD:
9247         cmd_str = "add-group";
9248         break;
9249
9250     case OFPGC15_MODIFY:
9251     case OFPGC15_ADD_OR_MOD:
9252         cmd_str = "mod-group";
9253         break;
9254
9255     case OFPGC15_DELETE:
9256         cmd_str = "del-group";
9257         break;
9258
9259     case OFPGC15_INSERT_BUCKET:
9260         cmd_str = "insert-bucket";
9261         break;
9262
9263     case OFPGC15_REMOVE_BUCKET:
9264         cmd_str = "remove-bucket";
9265         break;
9266
9267     default:
9268         OVS_NOT_REACHED();
9269     }
9270
9271     ovs_fatal(0, "%s needs OpenFlow %s or later (\'-O OpenFlow%s\')",
9272               cmd_str, version, opt_version);
9273
9274 }
9275
9276 /* Converts abstract group mod 'gm' into a message for OpenFlow version
9277  * 'ofp_version' and returns the message. */
9278 struct ofpbuf *
9279 ofputil_encode_group_mod(enum ofp_version ofp_version,
9280                          const struct ofputil_group_mod *gm)
9281 {
9282
9283     switch (ofp_version) {
9284     case OFP10_VERSION:
9285         bad_group_cmd(gm->command);
9286
9287     case OFP11_VERSION:
9288     case OFP12_VERSION:
9289     case OFP13_VERSION:
9290     case OFP14_VERSION:
9291         if (gm->command > OFPGC11_DELETE && gm->command != OFPGC11_ADD_OR_MOD) {
9292             bad_group_cmd(gm->command);
9293         }
9294         return ofputil_encode_ofp11_group_mod(ofp_version, gm);
9295
9296     case OFP15_VERSION:
9297     case OFP16_VERSION:
9298         return ofputil_encode_ofp15_group_mod(ofp_version, gm);
9299
9300     default:
9301         OVS_NOT_REACHED();
9302     }
9303 }
9304
9305 static enum ofperr
9306 ofputil_pull_ofp11_group_mod(struct ofpbuf *msg, enum ofp_version ofp_version,
9307                              struct ofputil_group_mod *gm)
9308 {
9309     const struct ofp11_group_mod *ogm;
9310     enum ofperr error;
9311
9312     ogm = ofpbuf_pull(msg, sizeof *ogm);
9313     gm->command = ntohs(ogm->command);
9314     gm->type = ogm->type;
9315     gm->group_id = ntohl(ogm->group_id);
9316     gm->command_bucket_id = OFPG15_BUCKET_ALL;
9317
9318     error = ofputil_pull_ofp11_buckets(msg, msg->size, ofp_version,
9319                                        &gm->buckets);
9320
9321     /* OF1.3.5+ prescribes an error when an OFPGC_DELETE includes buckets. */
9322     if (!error
9323         && ofp_version >= OFP13_VERSION
9324         && gm->command == OFPGC11_DELETE
9325         && !ovs_list_is_empty(&gm->buckets)) {
9326         error = OFPERR_OFPGMFC_INVALID_GROUP;
9327     }
9328
9329     return error;
9330 }
9331
9332 static enum ofperr
9333 ofputil_pull_ofp15_group_mod(struct ofpbuf *msg, enum ofp_version ofp_version,
9334                              struct ofputil_group_mod *gm)
9335 {
9336     const struct ofp15_group_mod *ogm;
9337     uint16_t bucket_list_len;
9338     enum ofperr error = OFPERR_OFPGMFC_BAD_BUCKET;
9339
9340     ogm = ofpbuf_pull(msg, sizeof *ogm);
9341     gm->command = ntohs(ogm->command);
9342     gm->type = ogm->type;
9343     gm->group_id = ntohl(ogm->group_id);
9344
9345     gm->command_bucket_id = ntohl(ogm->command_bucket_id);
9346     switch (gm->command) {
9347     case OFPGC15_REMOVE_BUCKET:
9348         if (gm->command_bucket_id == OFPG15_BUCKET_ALL) {
9349             error = 0;
9350         }
9351         /* Fall through */
9352     case OFPGC15_INSERT_BUCKET:
9353         if (gm->command_bucket_id <= OFPG15_BUCKET_MAX ||
9354             gm->command_bucket_id == OFPG15_BUCKET_FIRST
9355             || gm->command_bucket_id == OFPG15_BUCKET_LAST) {
9356             error = 0;
9357         }
9358         break;
9359
9360     case OFPGC11_ADD:
9361     case OFPGC11_MODIFY:
9362     case OFPGC11_ADD_OR_MOD:
9363     case OFPGC11_DELETE:
9364     default:
9365         if (gm->command_bucket_id == OFPG15_BUCKET_ALL) {
9366             error = 0;
9367         }
9368         break;
9369     }
9370     if (error) {
9371         VLOG_WARN_RL(&bad_ofmsg_rl,
9372                      "group command bucket id (%u) is out of range",
9373                      gm->command_bucket_id);
9374         return OFPERR_OFPGMFC_BAD_BUCKET;
9375     }
9376
9377     bucket_list_len = ntohs(ogm->bucket_array_len);
9378     error = ofputil_pull_ofp15_buckets(msg, bucket_list_len, ofp_version,
9379                                        gm->type, &gm->buckets);
9380     if (error) {
9381         return error;
9382     }
9383
9384     return parse_ofp15_group_properties(msg, gm->type, gm->command, &gm->props,
9385                                         msg->size);
9386 }
9387
9388 /* Converts OpenFlow group mod message 'oh' into an abstract group mod in
9389  * 'gm'.  Returns 0 if successful, otherwise an OpenFlow error code. */
9390 enum ofperr
9391 ofputil_decode_group_mod(const struct ofp_header *oh,
9392                          struct ofputil_group_mod *gm)
9393 {
9394     ofputil_init_group_properties(&gm->props);
9395
9396     enum ofp_version ofp_version = oh->version;
9397     struct ofpbuf msg = ofpbuf_const_initializer(oh, ntohs(oh->length));
9398     ofpraw_pull_assert(&msg);
9399
9400     enum ofperr err;
9401     switch (ofp_version)
9402     {
9403     case OFP11_VERSION:
9404     case OFP12_VERSION:
9405     case OFP13_VERSION:
9406     case OFP14_VERSION:
9407         err = ofputil_pull_ofp11_group_mod(&msg, ofp_version, gm);
9408         break;
9409
9410     case OFP15_VERSION:
9411     case OFP16_VERSION:
9412         err = ofputil_pull_ofp15_group_mod(&msg, ofp_version, gm);
9413         break;
9414
9415     case OFP10_VERSION:
9416     default:
9417         OVS_NOT_REACHED();
9418     }
9419     if (err) {
9420         return err;
9421     }
9422
9423     switch (gm->type) {
9424     case OFPGT11_INDIRECT:
9425         if (gm->command != OFPGC11_DELETE
9426             && !ovs_list_is_singleton(&gm->buckets) ) {
9427             return OFPERR_OFPGMFC_INVALID_GROUP;
9428         }
9429         break;
9430     case OFPGT11_ALL:
9431     case OFPGT11_SELECT:
9432     case OFPGT11_FF:
9433         break;
9434     default:
9435         return OFPERR_OFPGMFC_BAD_TYPE;
9436     }
9437
9438     switch (gm->command) {
9439     case OFPGC11_ADD:
9440     case OFPGC11_MODIFY:
9441     case OFPGC11_ADD_OR_MOD:
9442     case OFPGC11_DELETE:
9443     case OFPGC15_INSERT_BUCKET:
9444         break;
9445     case OFPGC15_REMOVE_BUCKET:
9446         if (!ovs_list_is_empty(&gm->buckets)) {
9447             return OFPERR_OFPGMFC_BAD_BUCKET;
9448         }
9449         break;
9450     default:
9451         return OFPERR_OFPGMFC_BAD_COMMAND;
9452     }
9453
9454     struct ofputil_bucket *bucket;
9455     LIST_FOR_EACH (bucket, list_node, &gm->buckets) {
9456         if (bucket->weight && gm->type != OFPGT11_SELECT) {
9457             return OFPERR_OFPGMFC_INVALID_GROUP;
9458         }
9459
9460         switch (gm->type) {
9461         case OFPGT11_ALL:
9462         case OFPGT11_INDIRECT:
9463             if (ofputil_bucket_has_liveness(bucket)) {
9464                 return OFPERR_OFPGMFC_WATCH_UNSUPPORTED;
9465             }
9466             break;
9467         case OFPGT11_SELECT:
9468             break;
9469         case OFPGT11_FF:
9470             if (!ofputil_bucket_has_liveness(bucket)) {
9471                 return OFPERR_OFPGMFC_INVALID_GROUP;
9472             }
9473             break;
9474         default:
9475             /* Returning BAD TYPE to be consistent
9476              * though gm->type has been checked already. */
9477             return OFPERR_OFPGMFC_BAD_TYPE;
9478         }
9479     }
9480
9481     return 0;
9482 }
9483
9484 /* Parse a queue status request message into 'oqsr'.
9485  * Returns 0 if successful, otherwise an OFPERR_* number. */
9486 enum ofperr
9487 ofputil_decode_queue_stats_request(const struct ofp_header *request,
9488                                    struct ofputil_queue_stats_request *oqsr)
9489 {
9490     switch ((enum ofp_version)request->version) {
9491     case OFP16_VERSION:
9492     case OFP15_VERSION:
9493     case OFP14_VERSION:
9494     case OFP13_VERSION:
9495     case OFP12_VERSION:
9496     case OFP11_VERSION: {
9497         const struct ofp11_queue_stats_request *qsr11 = ofpmsg_body(request);
9498         oqsr->queue_id = ntohl(qsr11->queue_id);
9499         return ofputil_port_from_ofp11(qsr11->port_no, &oqsr->port_no);
9500     }
9501
9502     case OFP10_VERSION: {
9503         const struct ofp10_queue_stats_request *qsr10 = ofpmsg_body(request);
9504         oqsr->queue_id = ntohl(qsr10->queue_id);
9505         oqsr->port_no = u16_to_ofp(ntohs(qsr10->port_no));
9506         /* OF 1.0 uses OFPP_ALL for OFPP_ANY */
9507         if (oqsr->port_no == OFPP_ALL) {
9508             oqsr->port_no = OFPP_ANY;
9509         }
9510         return 0;
9511     }
9512
9513     default:
9514         OVS_NOT_REACHED();
9515     }
9516 }
9517
9518 /* Encode a queue stats request for 'oqsr', the encoded message
9519  * will be for OpenFlow version 'ofp_version'. Returns message
9520  * as a struct ofpbuf. Returns encoded message on success, NULL on error. */
9521 struct ofpbuf *
9522 ofputil_encode_queue_stats_request(enum ofp_version ofp_version,
9523                                    const struct ofputil_queue_stats_request *oqsr)
9524 {
9525     struct ofpbuf *request;
9526
9527     switch (ofp_version) {
9528     case OFP11_VERSION:
9529     case OFP12_VERSION:
9530     case OFP13_VERSION:
9531     case OFP14_VERSION:
9532     case OFP15_VERSION:
9533     case OFP16_VERSION: {
9534         struct ofp11_queue_stats_request *req;
9535         request = ofpraw_alloc(OFPRAW_OFPST11_QUEUE_REQUEST, ofp_version, 0);
9536         req = ofpbuf_put_zeros(request, sizeof *req);
9537         req->port_no = ofputil_port_to_ofp11(oqsr->port_no);
9538         req->queue_id = htonl(oqsr->queue_id);
9539         break;
9540     }
9541     case OFP10_VERSION: {
9542         struct ofp10_queue_stats_request *req;
9543         request = ofpraw_alloc(OFPRAW_OFPST10_QUEUE_REQUEST, ofp_version, 0);
9544         req = ofpbuf_put_zeros(request, sizeof *req);
9545         /* OpenFlow 1.0 needs OFPP_ALL instead of OFPP_ANY */
9546         req->port_no = htons(ofp_to_u16(oqsr->port_no == OFPP_ANY
9547                                         ? OFPP_ALL : oqsr->port_no));
9548         req->queue_id = htonl(oqsr->queue_id);
9549         break;
9550     }
9551     default:
9552         OVS_NOT_REACHED();
9553     }
9554
9555     return request;
9556 }
9557
9558 /* Returns the number of queue stats elements in OFPTYPE_QUEUE_STATS_REPLY
9559  * message 'oh'. */
9560 size_t
9561 ofputil_count_queue_stats(const struct ofp_header *oh)
9562 {
9563     struct ofpbuf b = ofpbuf_const_initializer(oh, ntohs(oh->length));
9564     ofpraw_pull_assert(&b);
9565
9566     for (size_t n = 0; ; n++) {
9567         struct ofputil_queue_stats qs;
9568         if (ofputil_decode_queue_stats(&qs, &b)) {
9569             return n;
9570         }
9571     }
9572 }
9573
9574 static enum ofperr
9575 ofputil_queue_stats_from_ofp10(struct ofputil_queue_stats *oqs,
9576                                const struct ofp10_queue_stats *qs10)
9577 {
9578     oqs->port_no = u16_to_ofp(ntohs(qs10->port_no));
9579     oqs->queue_id = ntohl(qs10->queue_id);
9580     oqs->tx_bytes = ntohll(get_32aligned_be64(&qs10->tx_bytes));
9581     oqs->tx_packets = ntohll(get_32aligned_be64(&qs10->tx_packets));
9582     oqs->tx_errors = ntohll(get_32aligned_be64(&qs10->tx_errors));
9583     oqs->duration_sec = oqs->duration_nsec = UINT32_MAX;
9584
9585     return 0;
9586 }
9587
9588 static enum ofperr
9589 ofputil_queue_stats_from_ofp11(struct ofputil_queue_stats *oqs,
9590                                const struct ofp11_queue_stats *qs11)
9591 {
9592     enum ofperr error;
9593
9594     error = ofputil_port_from_ofp11(qs11->port_no, &oqs->port_no);
9595     if (error) {
9596         return error;
9597     }
9598
9599     oqs->queue_id = ntohl(qs11->queue_id);
9600     oqs->tx_bytes = ntohll(qs11->tx_bytes);
9601     oqs->tx_packets = ntohll(qs11->tx_packets);
9602     oqs->tx_errors = ntohll(qs11->tx_errors);
9603     oqs->duration_sec = oqs->duration_nsec = UINT32_MAX;
9604
9605     return 0;
9606 }
9607
9608 static enum ofperr
9609 ofputil_queue_stats_from_ofp13(struct ofputil_queue_stats *oqs,
9610                                const struct ofp13_queue_stats *qs13)
9611 {
9612     enum ofperr error = ofputil_queue_stats_from_ofp11(oqs, &qs13->qs);
9613     if (!error) {
9614         oqs->duration_sec = ntohl(qs13->duration_sec);
9615         oqs->duration_nsec = ntohl(qs13->duration_nsec);
9616     }
9617
9618     return error;
9619 }
9620
9621 static enum ofperr
9622 ofputil_pull_ofp14_queue_stats(struct ofputil_queue_stats *oqs,
9623                                struct ofpbuf *msg)
9624 {
9625     const struct ofp14_queue_stats *qs14;
9626     size_t len;
9627
9628     qs14 = ofpbuf_try_pull(msg, sizeof *qs14);
9629     if (!qs14) {
9630         return OFPERR_OFPBRC_BAD_LEN;
9631     }
9632
9633     len = ntohs(qs14->length);
9634     if (len < sizeof *qs14 || len - sizeof *qs14 > msg->size) {
9635         return OFPERR_OFPBRC_BAD_LEN;
9636     }
9637     ofpbuf_pull(msg, len - sizeof *qs14);
9638
9639     /* No properties yet defined, so ignore them for now. */
9640
9641     return ofputil_queue_stats_from_ofp13(oqs, &qs14->qs);
9642 }
9643
9644 /* Converts an OFPST_QUEUE_STATS reply in 'msg' into an abstract
9645  * ofputil_queue_stats in 'qs'.
9646  *
9647  * Multiple OFPST_QUEUE_STATS replies can be packed into a single OpenFlow
9648  * message.  Calling this function multiple times for a single 'msg' iterates
9649  * through the replies.  The caller must initially leave 'msg''s layer pointers
9650  * null and not modify them between calls.
9651  *
9652  * Returns 0 if successful, EOF if no replies were left in this 'msg',
9653  * otherwise a positive errno value. */
9654 int
9655 ofputil_decode_queue_stats(struct ofputil_queue_stats *qs, struct ofpbuf *msg)
9656 {
9657     enum ofperr error;
9658     enum ofpraw raw;
9659
9660     error = (msg->header ? ofpraw_decode(&raw, msg->header)
9661              : ofpraw_pull(&raw, msg));
9662     if (error) {
9663         return error;
9664     }
9665
9666     if (!msg->size) {
9667         return EOF;
9668     } else if (raw == OFPRAW_OFPST14_QUEUE_REPLY) {
9669         return ofputil_pull_ofp14_queue_stats(qs, msg);
9670     } else if (raw == OFPRAW_OFPST13_QUEUE_REPLY) {
9671         const struct ofp13_queue_stats *qs13;
9672
9673         qs13 = ofpbuf_try_pull(msg, sizeof *qs13);
9674         if (!qs13) {
9675             goto bad_len;
9676         }
9677         return ofputil_queue_stats_from_ofp13(qs, qs13);
9678     } else if (raw == OFPRAW_OFPST11_QUEUE_REPLY) {
9679         const struct ofp11_queue_stats *qs11;
9680
9681         qs11 = ofpbuf_try_pull(msg, sizeof *qs11);
9682         if (!qs11) {
9683             goto bad_len;
9684         }
9685         return ofputil_queue_stats_from_ofp11(qs, qs11);
9686     } else if (raw == OFPRAW_OFPST10_QUEUE_REPLY) {
9687         const struct ofp10_queue_stats *qs10;
9688
9689         qs10 = ofpbuf_try_pull(msg, sizeof *qs10);
9690         if (!qs10) {
9691             goto bad_len;
9692         }
9693         return ofputil_queue_stats_from_ofp10(qs, qs10);
9694     } else {
9695         OVS_NOT_REACHED();
9696     }
9697
9698  bad_len:
9699     VLOG_WARN_RL(&bad_ofmsg_rl, "OFPST_QUEUE reply has %"PRIu32" leftover "
9700                  "bytes at end", msg->size);
9701     return OFPERR_OFPBRC_BAD_LEN;
9702 }
9703
9704 static void
9705 ofputil_queue_stats_to_ofp10(const struct ofputil_queue_stats *oqs,
9706                              struct ofp10_queue_stats *qs10)
9707 {
9708     qs10->port_no = htons(ofp_to_u16(oqs->port_no));
9709     memset(qs10->pad, 0, sizeof qs10->pad);
9710     qs10->queue_id = htonl(oqs->queue_id);
9711     put_32aligned_be64(&qs10->tx_bytes, htonll(oqs->tx_bytes));
9712     put_32aligned_be64(&qs10->tx_packets, htonll(oqs->tx_packets));
9713     put_32aligned_be64(&qs10->tx_errors, htonll(oqs->tx_errors));
9714 }
9715
9716 static void
9717 ofputil_queue_stats_to_ofp11(const struct ofputil_queue_stats *oqs,
9718                              struct ofp11_queue_stats *qs11)
9719 {
9720     qs11->port_no = ofputil_port_to_ofp11(oqs->port_no);
9721     qs11->queue_id = htonl(oqs->queue_id);
9722     qs11->tx_bytes = htonll(oqs->tx_bytes);
9723     qs11->tx_packets = htonll(oqs->tx_packets);
9724     qs11->tx_errors = htonll(oqs->tx_errors);
9725 }
9726
9727 static void
9728 ofputil_queue_stats_to_ofp13(const struct ofputil_queue_stats *oqs,
9729                              struct ofp13_queue_stats *qs13)
9730 {
9731     ofputil_queue_stats_to_ofp11(oqs, &qs13->qs);
9732     if (oqs->duration_sec != UINT32_MAX) {
9733         qs13->duration_sec = htonl(oqs->duration_sec);
9734         qs13->duration_nsec = htonl(oqs->duration_nsec);
9735     } else {
9736         qs13->duration_sec = OVS_BE32_MAX;
9737         qs13->duration_nsec = OVS_BE32_MAX;
9738     }
9739 }
9740
9741 static void
9742 ofputil_queue_stats_to_ofp14(const struct ofputil_queue_stats *oqs,
9743                              struct ofp14_queue_stats *qs14)
9744 {
9745     qs14->length = htons(sizeof *qs14);
9746     memset(qs14->pad, 0, sizeof qs14->pad);
9747     ofputil_queue_stats_to_ofp13(oqs, &qs14->qs);
9748 }
9749
9750
9751 /* Encode a queue stat for 'oqs' and append it to 'replies'. */
9752 void
9753 ofputil_append_queue_stat(struct ovs_list *replies,
9754                           const struct ofputil_queue_stats *oqs)
9755 {
9756     switch (ofpmp_version(replies)) {
9757     case OFP13_VERSION: {
9758         struct ofp13_queue_stats *reply = ofpmp_append(replies, sizeof *reply);
9759         ofputil_queue_stats_to_ofp13(oqs, reply);
9760         break;
9761     }
9762
9763     case OFP12_VERSION:
9764     case OFP11_VERSION: {
9765         struct ofp11_queue_stats *reply = ofpmp_append(replies, sizeof *reply);
9766         ofputil_queue_stats_to_ofp11(oqs, reply);
9767         break;
9768     }
9769
9770     case OFP10_VERSION: {
9771         struct ofp10_queue_stats *reply = ofpmp_append(replies, sizeof *reply);
9772         ofputil_queue_stats_to_ofp10(oqs, reply);
9773         break;
9774     }
9775
9776     case OFP14_VERSION:
9777     case OFP15_VERSION:
9778     case OFP16_VERSION: {
9779         struct ofp14_queue_stats *reply = ofpmp_append(replies, sizeof *reply);
9780         ofputil_queue_stats_to_ofp14(oqs, reply);
9781         break;
9782     }
9783
9784     default:
9785         OVS_NOT_REACHED();
9786     }
9787 }
9788
9789 enum ofperr
9790 ofputil_decode_bundle_ctrl(const struct ofp_header *oh,
9791                            struct ofputil_bundle_ctrl_msg *msg)
9792 {
9793     struct ofpbuf b = ofpbuf_const_initializer(oh, ntohs(oh->length));
9794     enum ofpraw raw = ofpraw_pull_assert(&b);
9795     ovs_assert(raw == OFPRAW_OFPT14_BUNDLE_CONTROL
9796                || raw == OFPRAW_ONFT13_BUNDLE_CONTROL);
9797
9798     const struct ofp14_bundle_ctrl_msg *m = b.msg;
9799     msg->bundle_id = ntohl(m->bundle_id);
9800     msg->type = ntohs(m->type);
9801     msg->flags = ntohs(m->flags);
9802
9803     return 0;
9804 }
9805
9806 struct ofpbuf *
9807 ofputil_encode_bundle_ctrl_request(enum ofp_version ofp_version,
9808                                    struct ofputil_bundle_ctrl_msg *bc)
9809 {
9810     struct ofpbuf *request;
9811     struct ofp14_bundle_ctrl_msg *m;
9812
9813     switch (ofp_version) {
9814     case OFP10_VERSION:
9815     case OFP11_VERSION:
9816     case OFP12_VERSION:
9817         ovs_fatal(0, "bundles need OpenFlow 1.3 or later "
9818                      "(\'-O OpenFlow14\')");
9819     case OFP13_VERSION:
9820     case OFP14_VERSION:
9821     case OFP15_VERSION:
9822     case OFP16_VERSION:
9823         request = ofpraw_alloc(ofp_version == OFP13_VERSION
9824                                ? OFPRAW_ONFT13_BUNDLE_CONTROL
9825                                : OFPRAW_OFPT14_BUNDLE_CONTROL, ofp_version, 0);
9826         m = ofpbuf_put_zeros(request, sizeof *m);
9827
9828         m->bundle_id = htonl(bc->bundle_id);
9829         m->type = htons(bc->type);
9830         m->flags = htons(bc->flags);
9831         break;
9832     default:
9833         OVS_NOT_REACHED();
9834     }
9835
9836     return request;
9837 }
9838
9839 struct ofpbuf *
9840 ofputil_encode_bundle_ctrl_reply(const struct ofp_header *oh,
9841                                  struct ofputil_bundle_ctrl_msg *msg)
9842 {
9843     struct ofpbuf *buf;
9844     struct ofp14_bundle_ctrl_msg *m;
9845
9846     buf = ofpraw_alloc_reply(oh->version == OFP13_VERSION
9847                              ? OFPRAW_ONFT13_BUNDLE_CONTROL
9848                              : OFPRAW_OFPT14_BUNDLE_CONTROL, oh, 0);
9849     m = ofpbuf_put_zeros(buf, sizeof *m);
9850
9851     m->bundle_id = htonl(msg->bundle_id);
9852     m->type = htons(msg->type);
9853     m->flags = htons(msg->flags);
9854
9855     return buf;
9856 }
9857
9858 /* Return true for bundlable state change requests, false for other messages.
9859  */
9860 static bool
9861 ofputil_is_bundlable(enum ofptype type)
9862 {
9863     switch (type) {
9864         /* Minimum required by OpenFlow 1.4. */
9865     case OFPTYPE_PORT_MOD:
9866     case OFPTYPE_FLOW_MOD:
9867         return true;
9868
9869         /* Nice to have later. */
9870     case OFPTYPE_FLOW_MOD_TABLE_ID:
9871     case OFPTYPE_GROUP_MOD:
9872     case OFPTYPE_TABLE_MOD:
9873     case OFPTYPE_METER_MOD:
9874     case OFPTYPE_PACKET_OUT:
9875     case OFPTYPE_NXT_TLV_TABLE_MOD:
9876
9877         /* Not to be bundlable. */
9878     case OFPTYPE_ECHO_REQUEST:
9879     case OFPTYPE_FEATURES_REQUEST:
9880     case OFPTYPE_GET_CONFIG_REQUEST:
9881     case OFPTYPE_SET_CONFIG:
9882     case OFPTYPE_BARRIER_REQUEST:
9883     case OFPTYPE_ROLE_REQUEST:
9884     case OFPTYPE_ECHO_REPLY:
9885     case OFPTYPE_SET_FLOW_FORMAT:
9886     case OFPTYPE_SET_PACKET_IN_FORMAT:
9887     case OFPTYPE_SET_CONTROLLER_ID:
9888     case OFPTYPE_FLOW_AGE:
9889     case OFPTYPE_FLOW_MONITOR_CANCEL:
9890     case OFPTYPE_SET_ASYNC_CONFIG:
9891     case OFPTYPE_GET_ASYNC_REQUEST:
9892     case OFPTYPE_DESC_STATS_REQUEST:
9893     case OFPTYPE_FLOW_STATS_REQUEST:
9894     case OFPTYPE_AGGREGATE_STATS_REQUEST:
9895     case OFPTYPE_TABLE_STATS_REQUEST:
9896     case OFPTYPE_TABLE_FEATURES_STATS_REQUEST:
9897     case OFPTYPE_TABLE_DESC_REQUEST:
9898     case OFPTYPE_PORT_STATS_REQUEST:
9899     case OFPTYPE_QUEUE_STATS_REQUEST:
9900     case OFPTYPE_PORT_DESC_STATS_REQUEST:
9901     case OFPTYPE_FLOW_MONITOR_STATS_REQUEST:
9902     case OFPTYPE_METER_STATS_REQUEST:
9903     case OFPTYPE_METER_CONFIG_STATS_REQUEST:
9904     case OFPTYPE_METER_FEATURES_STATS_REQUEST:
9905     case OFPTYPE_GROUP_STATS_REQUEST:
9906     case OFPTYPE_GROUP_DESC_STATS_REQUEST:
9907     case OFPTYPE_GROUP_FEATURES_STATS_REQUEST:
9908     case OFPTYPE_QUEUE_GET_CONFIG_REQUEST:
9909     case OFPTYPE_BUNDLE_CONTROL:
9910     case OFPTYPE_BUNDLE_ADD_MESSAGE:
9911     case OFPTYPE_HELLO:
9912     case OFPTYPE_ERROR:
9913     case OFPTYPE_FEATURES_REPLY:
9914     case OFPTYPE_GET_CONFIG_REPLY:
9915     case OFPTYPE_PACKET_IN:
9916     case OFPTYPE_FLOW_REMOVED:
9917     case OFPTYPE_PORT_STATUS:
9918     case OFPTYPE_BARRIER_REPLY:
9919     case OFPTYPE_QUEUE_GET_CONFIG_REPLY:
9920     case OFPTYPE_DESC_STATS_REPLY:
9921     case OFPTYPE_FLOW_STATS_REPLY:
9922     case OFPTYPE_QUEUE_STATS_REPLY:
9923     case OFPTYPE_PORT_STATS_REPLY:
9924     case OFPTYPE_TABLE_STATS_REPLY:
9925     case OFPTYPE_AGGREGATE_STATS_REPLY:
9926     case OFPTYPE_PORT_DESC_STATS_REPLY:
9927     case OFPTYPE_ROLE_REPLY:
9928     case OFPTYPE_FLOW_MONITOR_PAUSED:
9929     case OFPTYPE_FLOW_MONITOR_RESUMED:
9930     case OFPTYPE_FLOW_MONITOR_STATS_REPLY:
9931     case OFPTYPE_GET_ASYNC_REPLY:
9932     case OFPTYPE_GROUP_STATS_REPLY:
9933     case OFPTYPE_GROUP_DESC_STATS_REPLY:
9934     case OFPTYPE_GROUP_FEATURES_STATS_REPLY:
9935     case OFPTYPE_METER_STATS_REPLY:
9936     case OFPTYPE_METER_CONFIG_STATS_REPLY:
9937     case OFPTYPE_METER_FEATURES_STATS_REPLY:
9938     case OFPTYPE_TABLE_FEATURES_STATS_REPLY:
9939     case OFPTYPE_TABLE_DESC_REPLY:
9940     case OFPTYPE_ROLE_STATUS:
9941     case OFPTYPE_REQUESTFORWARD:
9942     case OFPTYPE_TABLE_STATUS:
9943     case OFPTYPE_NXT_TLV_TABLE_REQUEST:
9944     case OFPTYPE_NXT_TLV_TABLE_REPLY:
9945     case OFPTYPE_NXT_RESUME:
9946     case OFPTYPE_IPFIX_BRIDGE_STATS_REQUEST:
9947     case OFPTYPE_IPFIX_BRIDGE_STATS_REPLY:
9948     case OFPTYPE_IPFIX_FLOW_STATS_REQUEST:
9949     case OFPTYPE_IPFIX_FLOW_STATS_REPLY:
9950         break;
9951     }
9952
9953     return false;
9954 }
9955
9956 enum ofperr
9957 ofputil_decode_bundle_add(const struct ofp_header *oh,
9958                           struct ofputil_bundle_add_msg *msg,
9959                           enum ofptype *typep)
9960 {
9961     struct ofpbuf b = ofpbuf_const_initializer(oh, ntohs(oh->length));
9962     enum ofpraw raw = ofpraw_pull_assert(&b);
9963     ovs_assert(raw == OFPRAW_OFPT14_BUNDLE_ADD_MESSAGE
9964                || raw == OFPRAW_ONFT13_BUNDLE_ADD_MESSAGE);
9965
9966     const struct ofp14_bundle_ctrl_msg *m = ofpbuf_pull(&b, sizeof *m);
9967     msg->bundle_id = ntohl(m->bundle_id);
9968     msg->flags = ntohs(m->flags);
9969
9970     msg->msg = b.data;
9971     if (msg->msg->version != oh->version) {
9972         return OFPERR_OFPBFC_BAD_VERSION;
9973     }
9974     size_t inner_len = ntohs(msg->msg->length);
9975     if (inner_len < sizeof(struct ofp_header) || inner_len > b.size) {
9976         return OFPERR_OFPBFC_MSG_BAD_LEN;
9977     }
9978     if (msg->msg->xid != oh->xid) {
9979         return OFPERR_OFPBFC_MSG_BAD_XID;
9980     }
9981
9982     /* Reject unbundlable messages. */
9983     enum ofptype type;
9984     enum ofperr error = ofptype_decode(&type, msg->msg);
9985     if (error) {
9986         VLOG_WARN_RL(&bad_ofmsg_rl, "OFPT14_BUNDLE_ADD_MESSAGE contained "
9987                      "message is unparsable (%s)", ofperr_get_name(error));
9988         return OFPERR_OFPBFC_MSG_UNSUP; /* 'error' would be confusing. */
9989     }
9990
9991     if (!ofputil_is_bundlable(type)) {
9992         VLOG_WARN_RL(&bad_ofmsg_rl, "%s message not allowed inside "
9993                      "OFPT14_BUNDLE_ADD_MESSAGE", ofptype_get_name(type));
9994         return OFPERR_OFPBFC_MSG_UNSUP;
9995     }
9996     if (typep) {
9997         *typep = type;
9998     }
9999
10000     return 0;
10001 }
10002
10003 struct ofpbuf *
10004 ofputil_encode_bundle_add(enum ofp_version ofp_version,
10005                           struct ofputil_bundle_add_msg *msg)
10006 {
10007     struct ofpbuf *request;
10008     struct ofp14_bundle_ctrl_msg *m;
10009
10010     /* Must use the same xid as the embedded message. */
10011     request = ofpraw_alloc_xid(ofp_version == OFP13_VERSION
10012                                ? OFPRAW_ONFT13_BUNDLE_ADD_MESSAGE
10013                                : OFPRAW_OFPT14_BUNDLE_ADD_MESSAGE, ofp_version,
10014                                msg->msg->xid, 0);
10015     m = ofpbuf_put_zeros(request, sizeof *m);
10016
10017     m->bundle_id = htonl(msg->bundle_id);
10018     m->flags = htons(msg->flags);
10019     ofpbuf_put(request, msg->msg, ntohs(msg->msg->length));
10020
10021     return request;
10022 }
10023
10024 static void
10025 encode_tlv_table_mappings(struct ofpbuf *b, struct ovs_list *mappings)
10026 {
10027     struct ofputil_tlv_map *map;
10028
10029     LIST_FOR_EACH (map, list_node, mappings) {
10030         struct nx_tlv_map *nx_map;
10031
10032         nx_map = ofpbuf_put_zeros(b, sizeof *nx_map);
10033         nx_map->option_class = htons(map->option_class);
10034         nx_map->option_type = map->option_type;
10035         nx_map->option_len = map->option_len;
10036         nx_map->index = htons(map->index);
10037     }
10038 }
10039
10040 struct ofpbuf *
10041 ofputil_encode_tlv_table_mod(enum ofp_version ofp_version,
10042                                 struct ofputil_tlv_table_mod *ttm)
10043 {
10044     struct ofpbuf *b;
10045     struct nx_tlv_table_mod *nx_ttm;
10046
10047     b = ofpraw_alloc(OFPRAW_NXT_TLV_TABLE_MOD, ofp_version, 0);
10048     nx_ttm = ofpbuf_put_zeros(b, sizeof *nx_ttm);
10049     nx_ttm->command = htons(ttm->command);
10050     encode_tlv_table_mappings(b, &ttm->mappings);
10051
10052     return b;
10053 }
10054
10055 static enum ofperr
10056 decode_tlv_table_mappings(struct ofpbuf *msg, unsigned int max_fields,
10057                              struct ovs_list *mappings)
10058 {
10059     ovs_list_init(mappings);
10060
10061     while (msg->size) {
10062         struct nx_tlv_map *nx_map;
10063         struct ofputil_tlv_map *map;
10064
10065         nx_map = ofpbuf_pull(msg, sizeof *nx_map);
10066         map = xmalloc(sizeof *map);
10067         ovs_list_push_back(mappings, &map->list_node);
10068
10069         map->option_class = ntohs(nx_map->option_class);
10070         map->option_type = nx_map->option_type;
10071
10072         map->option_len = nx_map->option_len;
10073         if (map->option_len % 4 || map->option_len > TLV_MAX_OPT_SIZE) {
10074             VLOG_WARN_RL(&bad_ofmsg_rl,
10075                          "tlv table option length (%u) is not a valid option size",
10076                          map->option_len);
10077             ofputil_uninit_tlv_table(mappings);
10078             return OFPERR_NXTTMFC_BAD_OPT_LEN;
10079         }
10080
10081         map->index = ntohs(nx_map->index);
10082         if (map->index >= max_fields) {
10083             VLOG_WARN_RL(&bad_ofmsg_rl,
10084                          "tlv table field index (%u) is too large (max %u)",
10085                          map->index, max_fields - 1);
10086             ofputil_uninit_tlv_table(mappings);
10087             return OFPERR_NXTTMFC_BAD_FIELD_IDX;
10088         }
10089     }
10090
10091     return 0;
10092 }
10093
10094 enum ofperr
10095 ofputil_decode_tlv_table_mod(const struct ofp_header *oh,
10096                                 struct ofputil_tlv_table_mod *ttm)
10097 {
10098     struct ofpbuf msg = ofpbuf_const_initializer(oh, ntohs(oh->length));
10099     ofpraw_pull_assert(&msg);
10100
10101     struct nx_tlv_table_mod *nx_ttm = ofpbuf_pull(&msg, sizeof *nx_ttm);
10102     ttm->command = ntohs(nx_ttm->command);
10103     if (ttm->command > NXTTMC_CLEAR) {
10104         VLOG_WARN_RL(&bad_ofmsg_rl,
10105                      "tlv table mod command (%u) is out of range",
10106                      ttm->command);
10107         return OFPERR_NXTTMFC_BAD_COMMAND;
10108     }
10109
10110     return decode_tlv_table_mappings(&msg, TUN_METADATA_NUM_OPTS,
10111                                         &ttm->mappings);
10112 }
10113
10114 struct ofpbuf *
10115 ofputil_encode_tlv_table_reply(const struct ofp_header *oh,
10116                                   struct ofputil_tlv_table_reply *ttr)
10117 {
10118     struct ofpbuf *b;
10119     struct nx_tlv_table_reply *nx_ttr;
10120
10121     b = ofpraw_alloc_reply(OFPRAW_NXT_TLV_TABLE_REPLY, oh, 0);
10122     nx_ttr = ofpbuf_put_zeros(b, sizeof *nx_ttr);
10123     nx_ttr->max_option_space = htonl(ttr->max_option_space);
10124     nx_ttr->max_fields = htons(ttr->max_fields);
10125
10126     encode_tlv_table_mappings(b, &ttr->mappings);
10127
10128     return b;
10129 }
10130
10131 /* Decodes the NXT_TLV_TABLE_REPLY message in 'oh' into '*ttr'.  Returns 0
10132  * if successful, otherwise an ofperr.
10133  *
10134  * The decoder verifies that the indexes in 'ttr->mappings' are less than
10135  * 'ttr->max_fields', but the caller must ensure, if necessary, that they are
10136  * less than TUN_METADATA_NUM_OPTS. */
10137 enum ofperr
10138 ofputil_decode_tlv_table_reply(const struct ofp_header *oh,
10139                                   struct ofputil_tlv_table_reply *ttr)
10140 {
10141     struct ofpbuf msg = ofpbuf_const_initializer(oh, ntohs(oh->length));
10142     ofpraw_pull_assert(&msg);
10143
10144     struct nx_tlv_table_reply *nx_ttr = ofpbuf_pull(&msg, sizeof *nx_ttr);
10145     ttr->max_option_space = ntohl(nx_ttr->max_option_space);
10146     ttr->max_fields = ntohs(nx_ttr->max_fields);
10147
10148     return decode_tlv_table_mappings(&msg, ttr->max_fields, &ttr->mappings);
10149 }
10150
10151 void
10152 ofputil_uninit_tlv_table(struct ovs_list *mappings)
10153 {
10154     struct ofputil_tlv_map *map;
10155
10156     LIST_FOR_EACH_POP (map, list_node, mappings) {
10157         free(map);
10158     }
10159 }
10160
10161 const char *
10162 ofputil_async_msg_type_to_string(enum ofputil_async_msg_type type)
10163 {
10164     switch (type) {
10165     case OAM_PACKET_IN:      return "PACKET_IN";
10166     case OAM_PORT_STATUS:    return "PORT_STATUS";
10167     case OAM_FLOW_REMOVED:   return "FLOW_REMOVED";
10168     case OAM_ROLE_STATUS:    return "ROLE_STATUS";
10169     case OAM_TABLE_STATUS:   return "TABLE_STATUS";
10170     case OAM_REQUESTFORWARD: return "REQUESTFORWARD";
10171
10172     case OAM_N_TYPES:
10173     default:
10174         OVS_NOT_REACHED();
10175     }
10176 }
10177
10178 struct ofp14_async_prop {
10179     uint64_t prop_type;
10180     enum ofputil_async_msg_type oam;
10181     bool master;
10182     uint32_t allowed10, allowed14;
10183 };
10184
10185 #define AP_PAIR(SLAVE_PROP_TYPE, OAM, A10, A14) \
10186     { SLAVE_PROP_TYPE,       OAM, false, A10, (A14) ? (A14) : (A10) },  \
10187     { (SLAVE_PROP_TYPE + 1), OAM, true,  A10, (A14) ? (A14) : (A10) }
10188
10189 static const struct ofp14_async_prop async_props[] = {
10190     AP_PAIR( 0, OAM_PACKET_IN,      OFPR10_BITS, OFPR14_BITS),
10191     AP_PAIR( 2, OAM_PORT_STATUS,    (1 << OFPPR_N_REASONS) - 1, 0),
10192     AP_PAIR( 4, OAM_FLOW_REMOVED,   (1 << OVS_OFPRR_NONE) - 1, 0),
10193     AP_PAIR( 6, OAM_ROLE_STATUS,    (1 << OFPCRR_N_REASONS) - 1, 0),
10194     AP_PAIR( 8, OAM_TABLE_STATUS,   OFPTR_BITS, 0),
10195     AP_PAIR(10, OAM_REQUESTFORWARD, (1 << OFPRFR_N_REASONS) - 1, 0),
10196 };
10197
10198 #define FOR_EACH_ASYNC_PROP(VAR)                                \
10199     for (const struct ofp14_async_prop *VAR = async_props;      \
10200          VAR < &async_props[ARRAY_SIZE(async_props)]; VAR++)
10201
10202 static const struct ofp14_async_prop *
10203 get_ofp14_async_config_prop_by_prop_type(uint64_t prop_type)
10204 {
10205     FOR_EACH_ASYNC_PROP (ap) {
10206         if (prop_type == ap->prop_type) {
10207             return ap;
10208         }
10209     }
10210     return NULL;
10211 }
10212
10213 static const struct ofp14_async_prop *
10214 get_ofp14_async_config_prop_by_oam(enum ofputil_async_msg_type oam,
10215                                    bool master)
10216 {
10217     FOR_EACH_ASYNC_PROP (ap) {
10218         if (ap->oam == oam && ap->master == master) {
10219             return ap;
10220         }
10221     }
10222     return NULL;
10223 }
10224
10225 static uint32_t
10226 ofp14_async_prop_allowed(const struct ofp14_async_prop *prop,
10227                          enum ofp_version version)
10228 {
10229     return version >= OFP14_VERSION ? prop->allowed14 : prop->allowed10;
10230 }
10231
10232 static ovs_be32
10233 encode_async_mask(const struct ofputil_async_cfg *src,
10234                   const struct ofp14_async_prop *ap,
10235                   enum ofp_version version)
10236 {
10237     uint32_t mask = ap->master ? src->master[ap->oam] : src->slave[ap->oam];
10238     return htonl(mask & ofp14_async_prop_allowed(ap, version));
10239 }
10240
10241 static enum ofperr
10242 decode_async_mask(ovs_be32 src,
10243                   const struct ofp14_async_prop *ap, enum ofp_version version,
10244                   bool loose, struct ofputil_async_cfg *dst)
10245 {
10246     uint32_t mask = ntohl(src);
10247     uint32_t allowed = ofp14_async_prop_allowed(ap, version);
10248     if (mask & ~allowed) {
10249         OFPPROP_LOG(&bad_ofmsg_rl, loose,
10250                     "bad value %#x for %s (allowed mask %#x)",
10251                     mask, ofputil_async_msg_type_to_string(ap->oam),
10252                     allowed);
10253         mask &= allowed;
10254         if (!loose) {
10255             return OFPERR_OFPACFC_INVALID;
10256         }
10257     }
10258
10259     if (ap->oam == OAM_PACKET_IN) {
10260         if (mask & (1u << OFPR_NO_MATCH)) {
10261             mask |= 1u << OFPR_EXPLICIT_MISS;
10262             if (version < OFP13_VERSION) {
10263                 mask |= 1u << OFPR_IMPLICIT_MISS;
10264             }
10265         }
10266     }
10267
10268     uint32_t *array = ap->master ? dst->master : dst->slave;
10269     array[ap->oam] = mask;
10270     return 0;
10271 }
10272
10273 static enum ofperr
10274 parse_async_tlv(const struct ofpbuf *property,
10275                 const struct ofp14_async_prop *ap,
10276                 struct ofputil_async_cfg *ac,
10277                 enum ofp_version version, bool loose)
10278 {
10279     enum ofperr error;
10280     ovs_be32 mask;
10281
10282     error  = ofpprop_parse_be32(property, &mask);
10283     if (error) {
10284         return error;
10285     }
10286
10287     if (ofpprop_is_experimenter(ap->prop_type)) {
10288         /* For experimenter properties, whether a property is for the master or
10289          * slave role is indicated by both 'type' and 'exp_type' in struct
10290          * ofp_prop_experimenter.  Check that these are consistent. */
10291         const struct ofp_prop_experimenter *ope = property->data;
10292         bool should_be_master = ope->type == htons(0xffff);
10293         if (should_be_master != ap->master) {
10294             VLOG_WARN_RL(&bad_ofmsg_rl, "async property type %#"PRIx16" "
10295                          "indicates %s role but exp_type %"PRIu32" indicates "
10296                          "%s role",
10297                          ntohs(ope->type),
10298                          should_be_master ? "master" : "slave",
10299                          ntohl(ope->exp_type),
10300                          ap->master ? "master" : "slave");
10301             return OFPERR_OFPBPC_BAD_EXP_TYPE;
10302         }
10303     }
10304
10305     return decode_async_mask(mask, ap, version, loose, ac);
10306 }
10307
10308 static void
10309 decode_legacy_async_masks(const ovs_be32 masks[2],
10310                           enum ofputil_async_msg_type oam,
10311                           enum ofp_version version,
10312                           struct ofputil_async_cfg *dst)
10313 {
10314     for (int i = 0; i < 2; i++) {
10315         bool master = i == 0;
10316         const struct ofp14_async_prop *ap
10317             = get_ofp14_async_config_prop_by_oam(oam, master);
10318         decode_async_mask(masks[i], ap, version, true, dst);
10319     }
10320 }
10321
10322 /* Decodes the OpenFlow "set async config" request and "get async config
10323  * reply" message in '*oh' into an abstract form in 'ac'.
10324  *
10325  * Some versions of the "set async config" request change only some of the
10326  * settings and leave the others alone.  This function uses 'basis' as the
10327  * initial state for decoding these.  Other versions of the request change all
10328  * the settings; this function ignores 'basis' when decoding these.
10329  *
10330  * If 'loose' is true, this function ignores properties and values that it does
10331  * not understand, as a controller would want to do when interpreting
10332  * capabilities provided by a switch.  If 'loose' is false, this function
10333  * treats unknown properties and values as an error, as a switch would want to
10334  * do when interpreting a configuration request made by a controller.
10335  *
10336  * Returns 0 if successful, otherwise an OFPERR_* value.
10337  *
10338  * Returns error code OFPERR_OFPACFC_INVALID if the value of mask is not in
10339  * the valid range of mask.
10340  *
10341  * Returns error code OFPERR_OFPACFC_UNSUPPORTED if the configuration is not
10342  * supported.*/
10343 enum ofperr
10344 ofputil_decode_set_async_config(const struct ofp_header *oh, bool loose,
10345                                 const struct ofputil_async_cfg *basis,
10346                                 struct ofputil_async_cfg *ac)
10347 {
10348     struct ofpbuf b = ofpbuf_const_initializer(oh, ntohs(oh->length));
10349     enum ofpraw raw = ofpraw_pull_assert(&b);
10350
10351     if (raw == OFPRAW_OFPT13_SET_ASYNC ||
10352         raw == OFPRAW_NXT_SET_ASYNC_CONFIG ||
10353         raw == OFPRAW_OFPT13_GET_ASYNC_REPLY) {
10354         const struct nx_async_config *msg = ofpmsg_body(oh);
10355
10356         *ac = OFPUTIL_ASYNC_CFG_INIT;
10357         decode_legacy_async_masks(msg->packet_in_mask, OAM_PACKET_IN,
10358                                   oh->version, ac);
10359         decode_legacy_async_masks(msg->port_status_mask, OAM_PORT_STATUS,
10360                                   oh->version, ac);
10361         decode_legacy_async_masks(msg->flow_removed_mask, OAM_FLOW_REMOVED,
10362                                   oh->version, ac);
10363     } else if (raw == OFPRAW_OFPT14_SET_ASYNC ||
10364                raw == OFPRAW_OFPT14_GET_ASYNC_REPLY ||
10365                raw == OFPRAW_NXT_SET_ASYNC_CONFIG2) {
10366         *ac = *basis;
10367         while (b.size > 0) {
10368             struct ofpbuf property;
10369             enum ofperr error;
10370             uint64_t type;
10371
10372             error = ofpprop_pull__(&b, &property, 8, 0xfffe, &type);
10373             if (error) {
10374                 return error;
10375             }
10376
10377             const struct ofp14_async_prop *ap
10378                 = get_ofp14_async_config_prop_by_prop_type(type);
10379             error = (ap
10380                      ? parse_async_tlv(&property, ap, ac, oh->version, loose)
10381                      : OFPPROP_UNKNOWN(loose, "async config", type));
10382             if (error) {
10383                 /* Most messages use OFPBPC_BAD_TYPE but async has its own (who
10384                  * knows why, it's OpenFlow. */
10385                 if (error == OFPERR_OFPBPC_BAD_TYPE) {
10386                     error = OFPERR_OFPACFC_UNSUPPORTED;
10387                 }
10388                 return error;
10389             }
10390         }
10391     } else {
10392         return OFPERR_OFPBRC_BAD_VERSION;
10393     }
10394     return 0;
10395 }
10396
10397 static void
10398 encode_legacy_async_masks(const struct ofputil_async_cfg *ac,
10399                           enum ofputil_async_msg_type oam,
10400                           enum ofp_version version,
10401                           ovs_be32 masks[2])
10402 {
10403     for (int i = 0; i < 2; i++) {
10404         bool master = i == 0;
10405         const struct ofp14_async_prop *ap
10406             = get_ofp14_async_config_prop_by_oam(oam, master);
10407         masks[i] = encode_async_mask(ac, ap, version);
10408     }
10409 }
10410
10411 static void
10412 ofputil_put_async_config__(const struct ofputil_async_cfg *ac,
10413                            struct ofpbuf *buf, bool tlv,
10414                            enum ofp_version version, uint32_t oams)
10415 {
10416     if (!tlv) {
10417         struct nx_async_config *msg = ofpbuf_put_zeros(buf, sizeof *msg);
10418         encode_legacy_async_masks(ac, OAM_PACKET_IN, version,
10419                                   msg->packet_in_mask);
10420         encode_legacy_async_masks(ac, OAM_PORT_STATUS, version,
10421                                   msg->port_status_mask);
10422         encode_legacy_async_masks(ac, OAM_FLOW_REMOVED, version,
10423                                   msg->flow_removed_mask);
10424     } else {
10425         FOR_EACH_ASYNC_PROP (ap) {
10426             if (oams & (1u << ap->oam)) {
10427                 size_t ofs = buf->size;
10428                 ofpprop_put_be32(buf, ap->prop_type,
10429                                  encode_async_mask(ac, ap, version));
10430
10431                 /* For experimenter properties, we need to use type 0xfffe for
10432                  * master and 0xffff for slaves. */
10433                 if (ofpprop_is_experimenter(ap->prop_type)) {
10434                     struct ofp_prop_experimenter *ope
10435                         = ofpbuf_at_assert(buf, ofs, sizeof *ope);
10436                     ope->type = ap->master ? htons(0xffff) : htons(0xfffe);
10437                 }
10438             }
10439         }
10440     }
10441 }
10442
10443 /* Encodes and returns a reply to the OFPT_GET_ASYNC_REQUEST in 'oh' that
10444  * states that the asynchronous message configuration is 'ac'. */
10445 struct ofpbuf *
10446 ofputil_encode_get_async_reply(const struct ofp_header *oh,
10447                                const struct ofputil_async_cfg *ac)
10448 {
10449     struct ofpbuf *buf;
10450
10451     enum ofpraw raw = (oh->version < OFP14_VERSION
10452                        ? OFPRAW_OFPT13_GET_ASYNC_REPLY
10453                        : OFPRAW_OFPT14_GET_ASYNC_REPLY);
10454     struct ofpbuf *reply = ofpraw_alloc_reply(raw, oh, 0);
10455     ofputil_put_async_config__(ac, reply,
10456                                raw == OFPRAW_OFPT14_GET_ASYNC_REPLY,
10457                                oh->version, UINT32_MAX);
10458     return reply;
10459
10460     return buf;
10461 }
10462
10463 /* Encodes and returns a message, in a format appropriate for OpenFlow version
10464  * 'ofp_version', that sets the asynchronous message configuration to 'ac'.
10465  *
10466  * Specify 'oams' as a bitmap of OAM_* that indicate the asynchronous messages
10467  * to configure.  OF1.0 through OF1.3 can't natively configure a subset of
10468  * messages, so more messages than requested may be configured.  OF1.0 through
10469  * OF1.3 also can't configure OVS extension OAM_* values, so if 'oam' includes
10470  * any extensions then this function encodes an Open vSwitch extension message
10471  * that does support configuring OVS extension OAM_*. */
10472 struct ofpbuf *
10473 ofputil_encode_set_async_config(const struct ofputil_async_cfg *ac,
10474                                 uint32_t oams, enum ofp_version ofp_version)
10475 {
10476     enum ofpraw raw = (ofp_version >= OFP14_VERSION ? OFPRAW_OFPT14_SET_ASYNC
10477                        : oams & OAM_EXTENSIONS ? OFPRAW_NXT_SET_ASYNC_CONFIG2
10478                        : ofp_version >= OFP13_VERSION ? OFPRAW_OFPT13_SET_ASYNC
10479                        : OFPRAW_NXT_SET_ASYNC_CONFIG);
10480     struct ofpbuf *request = ofpraw_alloc(raw, ofp_version, 0);
10481     ofputil_put_async_config__(ac, request,
10482                                (raw == OFPRAW_OFPT14_SET_ASYNC ||
10483                                 raw == OFPRAW_NXT_SET_ASYNC_CONFIG2),
10484                                ofp_version, oams);
10485     return request;
10486 }
10487
10488 struct ofputil_async_cfg
10489 ofputil_async_cfg_default(enum ofp_version version)
10490 {
10491     /* We enable all of the OF1.4 reasons regardless of 'version' because the
10492      * reasons added in OF1.4 just are just refinements of the OFPR_ACTION
10493      * introduced in OF1.0, breaking it into more specific categories.  When we
10494      * encode these for earlier OpenFlow versions, we translate them into
10495      * OFPR_ACTION.  */
10496     uint32_t pin = OFPR14_BITS & ~(1u << OFPR_INVALID_TTL);
10497     pin |= 1u << OFPR_EXPLICIT_MISS;
10498     if (version <= OFP12_VERSION) {
10499         pin |= 1u << OFPR_IMPLICIT_MISS;
10500     }
10501
10502     return (struct ofputil_async_cfg) {
10503         .master[OAM_PACKET_IN] = pin,
10504
10505         .master[OAM_FLOW_REMOVED]
10506             = (version >= OFP14_VERSION ? OFPRR14_BITS : OFPRR10_BITS),
10507
10508         .master[OAM_PORT_STATUS] = OFPPR_BITS,
10509         .slave[OAM_PORT_STATUS] = OFPPR_BITS,
10510     };
10511 }
10512
10513 static void
10514 ofputil_put_ofp14_table_desc(const struct ofputil_table_desc *td,
10515                              struct ofpbuf *b, enum ofp_version version)
10516 {
10517     struct ofp14_table_desc *otd;
10518     struct ofp14_table_mod_prop_vacancy *otv;
10519     size_t start_otd;
10520
10521     start_otd = b->size;
10522     ofpbuf_put_zeros(b, sizeof *otd);
10523
10524     ofpprop_put_u32(b, OFPTMPT14_EVICTION, td->eviction_flags);
10525
10526     otv = ofpbuf_put_zeros(b, sizeof *otv);
10527     otv->type = htons(OFPTMPT14_VACANCY);
10528     otv->length = htons(sizeof *otv);
10529     otv->vacancy_down = td->table_vacancy.vacancy_down;
10530     otv->vacancy_up = td->table_vacancy.vacancy_up;
10531     otv->vacancy = td->table_vacancy.vacancy;
10532
10533     otd = ofpbuf_at_assert(b, start_otd, sizeof *otd);
10534     otd->length = htons(b->size - start_otd);
10535     otd->table_id = td->table_id;
10536     otd->config = ofputil_encode_table_config(OFPUTIL_TABLE_MISS_DEFAULT,
10537                                               td->eviction, td->vacancy,
10538                                               version);
10539 }
10540
10541 /* Converts the abstract form of a "table status" message in '*ts' into an
10542  * OpenFlow message suitable for 'protocol', and returns that encoded form in
10543  * a buffer owned by the caller. */
10544 struct ofpbuf *
10545 ofputil_encode_table_status(const struct ofputil_table_status *ts,
10546                             enum ofputil_protocol protocol)
10547 {
10548     enum ofp_version version;
10549     struct ofpbuf *b;
10550
10551     version = ofputil_protocol_to_ofp_version(protocol);
10552     if (version >= OFP14_VERSION) {
10553         enum ofpraw raw;
10554         struct ofp14_table_status *ots;
10555
10556         raw = OFPRAW_OFPT14_TABLE_STATUS;
10557         b = ofpraw_alloc_xid(raw, version, htonl(0), 0);
10558         ots = ofpbuf_put_zeros(b, sizeof *ots);
10559         ots->reason = ts->reason;
10560         ofputil_put_ofp14_table_desc(&ts->desc, b, version);
10561         ofpmsg_update_length(b);
10562         return b;
10563     } else {
10564         return NULL;
10565     }
10566 }
10567
10568 /* Decodes the OpenFlow "table status" message in '*ots' into an abstract form
10569  * in '*ts'.  Returns 0 if successful, otherwise an OFPERR_* value. */
10570 enum ofperr
10571 ofputil_decode_table_status(const struct ofp_header *oh,
10572                             struct ofputil_table_status *ts)
10573 {
10574     const struct ofp14_table_status *ots;
10575     struct ofpbuf b;
10576     enum ofperr error;
10577     enum ofpraw raw;
10578
10579     ofpbuf_use_const(&b, oh, ntohs(oh->length));
10580     raw = ofpraw_pull_assert(&b);
10581     ots = ofpbuf_pull(&b, sizeof *ots);
10582
10583     if (raw == OFPRAW_OFPT14_TABLE_STATUS) {
10584         if (ots->reason != OFPTR_VACANCY_DOWN
10585             && ots->reason != OFPTR_VACANCY_UP) {
10586             return OFPERR_OFPBPC_BAD_VALUE;
10587         }
10588         ts->reason = ots->reason;
10589
10590         error = ofputil_decode_table_desc(&b, &ts->desc, oh->version);
10591         return error;
10592     } else {
10593         return OFPERR_OFPBRC_BAD_VERSION;
10594     }
10595
10596     return 0;
10597 }