lib/ofp-util.c

   1 /*
   2  * Copyright (c) 2008, 2009, 2010, 2011, 2012, 2013 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 "ofp-print.h"
  19 #include <ctype.h>
  20 #include <errno.h>
  21 #include <inttypes.h>
  22 #include <sys/types.h>
  23 #include <netinet/in.h>
  24 #include <netinet/icmp6.h>
  25 #include <stdlib.h>
  26 #include "bundle.h"
  27 #include "byte-order.h"
  28 #include "classifier.h"
  29 #include "dynamic-string.h"
  30 #include "learn.h"
  31 #include "meta-flow.h"
  32 #include "multipath.h"
  33 #include "netdev.h"
  34 #include "nx-match.h"
  35 #include "ofp-actions.h"
  36 #include "ofp-errors.h"
  37 #include "ofp-msgs.h"
  38 #include "ofp-util.h"
  39 #include "ofpbuf.h"
  40 #include "packets.h"
  41 #include "random.h"
  42 #include "unaligned.h"
  43 #include "type-props.h"
  44 #include "vlog.h"
  45
  46 VLOG_DEFINE_THIS_MODULE(ofp_util);
  47
  48 /* Rate limit for OpenFlow message parse errors.  These always indicate a bug
  49  * in the peer and so there's not much point in showing a lot of them. */
  50 static struct vlog_rate_limit bad_ofmsg_rl = VLOG_RATE_LIMIT_INIT(1, 5);
  51
  52 /* Given the wildcard bit count in the least-significant 6 of 'wcbits', returns
  53  * an IP netmask with a 1 in each bit that must match and a 0 in each bit that
  54  * is wildcarded.
  55  *
  56  * The bits in 'wcbits' are in the format used in enum ofp_flow_wildcards: 0
  57  * is exact match, 1 ignores the LSB, 2 ignores the 2 least-significant bits,
  58  * ..., 32 and higher wildcard the entire field.  This is the *opposite* of the
  59  * usual convention where e.g. /24 indicates that 8 bits (not 24 bits) are
  60  * wildcarded. */
  61 ovs_be32
  62 ofputil_wcbits_to_netmask(int wcbits)
  63 {
  64     wcbits &= 0x3f;
  65     return wcbits < 32 ? htonl(~((1u << wcbits) - 1)) : 0;
  66 }
  67
  68 /* Given the IP netmask 'netmask', returns the number of bits of the IP address
  69  * that it wildcards, that is, the number of 0-bits in 'netmask', a number
  70  * between 0 and 32 inclusive.
  71  *
  72  * If 'netmask' is not a CIDR netmask (see ip_is_cidr()), the return value will
  73  * still be in the valid range but isn't otherwise meaningful. */
  74 int
  75 ofputil_netmask_to_wcbits(ovs_be32 netmask)
  76 {
  77     return 32 - ip_count_cidr_bits(netmask);
  78 }
  79
  80 /* Converts the OpenFlow 1.0 wildcards in 'ofpfw' (OFPFW10_*) into a
  81  * flow_wildcards in 'wc' for use in struct match.  It is the caller's
  82  * responsibility to handle the special case where the flow match's dl_vlan is
  83  * set to OFP_VLAN_NONE. */
  84 void
  85 ofputil_wildcard_from_ofpfw10(uint32_t ofpfw, struct flow_wildcards *wc)
  86 {
  87     BUILD_ASSERT_DECL(FLOW_WC_SEQ == 24);
  88
  89     /* Initialize most of wc. */
  90     flow_wildcards_init_catchall(wc);
  91
  92     if (!(ofpfw & OFPFW10_IN_PORT)) {
  93         wc->masks.in_port.ofp_port = u16_to_ofp(UINT16_MAX);
  94     }
  95
  96     if (!(ofpfw & OFPFW10_NW_TOS)) {
  97         wc->masks.nw_tos |= IP_DSCP_MASK;
  98     }
  99
 100     if (!(ofpfw & OFPFW10_NW_PROTO)) {
 101         wc->masks.nw_proto = UINT8_MAX;
 102     }
 103     wc->masks.nw_src = ofputil_wcbits_to_netmask(ofpfw
 104                                                  >> OFPFW10_NW_SRC_SHIFT);
 105     wc->masks.nw_dst = ofputil_wcbits_to_netmask(ofpfw
 106                                                  >> OFPFW10_NW_DST_SHIFT);
 107
 108     if (!(ofpfw & OFPFW10_TP_SRC)) {
 109         wc->masks.tp_src = OVS_BE16_MAX;
 110     }
 111     if (!(ofpfw & OFPFW10_TP_DST)) {
 112         wc->masks.tp_dst = OVS_BE16_MAX;
 113     }
 114
 115     if (!(ofpfw & OFPFW10_DL_SRC)) {
 116         memset(wc->masks.dl_src, 0xff, ETH_ADDR_LEN);
 117     }
 118     if (!(ofpfw & OFPFW10_DL_DST)) {
 119         memset(wc->masks.dl_dst, 0xff, ETH_ADDR_LEN);
 120     }
 121     if (!(ofpfw & OFPFW10_DL_TYPE)) {
 122         wc->masks.dl_type = OVS_BE16_MAX;
 123     }
 124
 125     /* VLAN TCI mask. */
 126     if (!(ofpfw & OFPFW10_DL_VLAN_PCP)) {
 127         wc->masks.vlan_tci |= htons(VLAN_PCP_MASK | VLAN_CFI);
 128     }
 129     if (!(ofpfw & OFPFW10_DL_VLAN)) {
 130         wc->masks.vlan_tci |= htons(VLAN_VID_MASK | VLAN_CFI);
 131     }
 132 }
 133
 134 /* Converts the ofp10_match in 'ofmatch' into a struct match in 'match'. */
 135 void
 136 ofputil_match_from_ofp10_match(const struct ofp10_match *ofmatch,
 137                                struct match *match)
 138 {
 139     uint32_t ofpfw = ntohl(ofmatch->wildcards) & OFPFW10_ALL;
 140
 141     /* Initialize match->wc. */
 142     memset(&match->flow, 0, sizeof match->flow);
 143     ofputil_wildcard_from_ofpfw10(ofpfw, &match->wc);
 144
 145     /* Initialize most of match->flow. */
 146     match->flow.nw_src = ofmatch->nw_src;
 147     match->flow.nw_dst = ofmatch->nw_dst;
 148     match->flow.in_port.ofp_port = u16_to_ofp(ntohs(ofmatch->in_port));
 149     match->flow.dl_type = ofputil_dl_type_from_openflow(ofmatch->dl_type);
 150     match->flow.tp_src = ofmatch->tp_src;
 151     match->flow.tp_dst = ofmatch->tp_dst;
 152     memcpy(match->flow.dl_src, ofmatch->dl_src, ETH_ADDR_LEN);
 153     memcpy(match->flow.dl_dst, ofmatch->dl_dst, ETH_ADDR_LEN);
 154     match->flow.nw_tos = ofmatch->nw_tos & IP_DSCP_MASK;
 155     match->flow.nw_proto = ofmatch->nw_proto;
 156
 157     /* Translate VLANs. */
 158     if (!(ofpfw & OFPFW10_DL_VLAN) &&
 159         ofmatch->dl_vlan == htons(OFP10_VLAN_NONE)) {
 160         /* Match only packets without 802.1Q header.
 161          *
 162          * When OFPFW10_DL_VLAN_PCP is wildcarded, this is obviously correct.
 163          *
 164          * If OFPFW10_DL_VLAN_PCP is matched, the flow match is contradictory,
 165          * because we can't have a specific PCP without an 802.1Q header.
 166          * However, older versions of OVS treated this as matching packets
 167          * withut an 802.1Q header, so we do here too. */
 168         match->flow.vlan_tci = htons(0);
 169         match->wc.masks.vlan_tci = htons(0xffff);
 170     } else {
 171         ovs_be16 vid, pcp, tci;
 172
 173         vid = ofmatch->dl_vlan & htons(VLAN_VID_MASK);
 174         pcp = htons((ofmatch->dl_vlan_pcp << VLAN_PCP_SHIFT) & VLAN_PCP_MASK);
 175         tci = vid | pcp | htons(VLAN_CFI);
 176         match->flow.vlan_tci = tci & match->wc.masks.vlan_tci;
 177     }
 178
 179     /* Clean up. */
 180     match_zero_wildcarded_fields(match);
 181 }
 182
 183 /* Convert 'match' into the OpenFlow 1.0 match structure 'ofmatch'. */
 184 void
 185 ofputil_match_to_ofp10_match(const struct match *match,
 186                              struct ofp10_match *ofmatch)
 187 {
 188     const struct flow_wildcards *wc = &match->wc;
 189     uint32_t ofpfw;
 190
 191     /* Figure out most OpenFlow wildcards. */
 192     ofpfw = 0;
 193     if (!wc->masks.in_port.ofp_port) {
 194         ofpfw |= OFPFW10_IN_PORT;
 195     }
 196     if (!wc->masks.dl_type) {
 197         ofpfw |= OFPFW10_DL_TYPE;
 198     }
 199     if (!wc->masks.nw_proto) {
 200         ofpfw |= OFPFW10_NW_PROTO;
 201     }
 202     ofpfw |= (ofputil_netmask_to_wcbits(wc->masks.nw_src)
 203               << OFPFW10_NW_SRC_SHIFT);
 204     ofpfw |= (ofputil_netmask_to_wcbits(wc->masks.nw_dst)
 205               << OFPFW10_NW_DST_SHIFT);
 206     if (!(wc->masks.nw_tos & IP_DSCP_MASK)) {
 207         ofpfw |= OFPFW10_NW_TOS;
 208     }
 209     if (!wc->masks.tp_src) {
 210         ofpfw |= OFPFW10_TP_SRC;
 211     }
 212     if (!wc->masks.tp_dst) {
 213         ofpfw |= OFPFW10_TP_DST;
 214     }
 215     if (eth_addr_is_zero(wc->masks.dl_src)) {
 216         ofpfw |= OFPFW10_DL_SRC;
 217     }
 218     if (eth_addr_is_zero(wc->masks.dl_dst)) {
 219         ofpfw |= OFPFW10_DL_DST;
 220     }
 221
 222     /* Translate VLANs. */
 223     ofmatch->dl_vlan = htons(0);
 224     ofmatch->dl_vlan_pcp = 0;
 225     if (match->wc.masks.vlan_tci == htons(0)) {
 226         ofpfw |= OFPFW10_DL_VLAN | OFPFW10_DL_VLAN_PCP;
 227     } else if (match->wc.masks.vlan_tci & htons(VLAN_CFI)
 228                && !(match->flow.vlan_tci & htons(VLAN_CFI))) {
 229         ofmatch->dl_vlan = htons(OFP10_VLAN_NONE);
 230         ofpfw |= OFPFW10_DL_VLAN_PCP;
 231     } else {
 232         if (!(match->wc.masks.vlan_tci & htons(VLAN_VID_MASK))) {
 233             ofpfw |= OFPFW10_DL_VLAN;
 234         } else {
 235             ofmatch->dl_vlan = htons(vlan_tci_to_vid(match->flow.vlan_tci));
 236         }
 237
 238         if (!(match->wc.masks.vlan_tci & htons(VLAN_PCP_MASK))) {
 239             ofpfw |= OFPFW10_DL_VLAN_PCP;
 240         } else {
 241             ofmatch->dl_vlan_pcp = vlan_tci_to_pcp(match->flow.vlan_tci);
 242         }
 243     }
 244
 245     /* Compose most of the match structure. */
 246     ofmatch->wildcards = htonl(ofpfw);
 247     ofmatch->in_port = htons(ofp_to_u16(match->flow.in_port.ofp_port));
 248     memcpy(ofmatch->dl_src, match->flow.dl_src, ETH_ADDR_LEN);
 249     memcpy(ofmatch->dl_dst, match->flow.dl_dst, ETH_ADDR_LEN);
 250     ofmatch->dl_type = ofputil_dl_type_to_openflow(match->flow.dl_type);
 251     ofmatch->nw_src = match->flow.nw_src;
 252     ofmatch->nw_dst = match->flow.nw_dst;
 253     ofmatch->nw_tos = match->flow.nw_tos & IP_DSCP_MASK;
 254     ofmatch->nw_proto = match->flow.nw_proto;
 255     ofmatch->tp_src = match->flow.tp_src;
 256     ofmatch->tp_dst = match->flow.tp_dst;
 257     memset(ofmatch->pad1, '\0', sizeof ofmatch->pad1);
 258     memset(ofmatch->pad2, '\0', sizeof ofmatch->pad2);
 259 }
 260
 261 enum ofperr
 262 ofputil_pull_ofp11_match(struct ofpbuf *buf, struct match *match,
 263                          uint16_t *padded_match_len)
 264 {
 265     struct ofp11_match_header *omh = buf->data;
 266     uint16_t match_len;
 267
 268     if (buf->size < sizeof *omh) {
 269         return OFPERR_OFPBMC_BAD_LEN;
 270     }
 271
 272     match_len = ntohs(omh->length);
 273
 274     switch (ntohs(omh->type)) {
 275     case OFPMT_STANDARD: {
 276         struct ofp11_match *om;
 277
 278         if (match_len != sizeof *om || buf->size < sizeof *om) {
 279             return OFPERR_OFPBMC_BAD_LEN;
 280         }
 281         om = ofpbuf_pull(buf, sizeof *om);
 282         if (padded_match_len) {
 283             *padded_match_len = match_len;
 284         }
 285         return ofputil_match_from_ofp11_match(om, match);
 286     }
 287
 288     case OFPMT_OXM:
 289         if (padded_match_len) {
 290             *padded_match_len = ROUND_UP(match_len, 8);
 291         }
 292         return oxm_pull_match(buf, match);
 293
 294     default:
 295         return OFPERR_OFPBMC_BAD_TYPE;
 296     }
 297 }
 298
 299 /* Converts the ofp11_match in 'ofmatch' into a struct match in 'match'.
 300  * Returns 0 if successful, otherwise an OFPERR_* value. */
 301 enum ofperr
 302 ofputil_match_from_ofp11_match(const struct ofp11_match *ofmatch,
 303                                struct match *match)
 304 {
 305     uint16_t wc = ntohl(ofmatch->wildcards);
 306     uint8_t dl_src_mask[ETH_ADDR_LEN];
 307     uint8_t dl_dst_mask[ETH_ADDR_LEN];
 308     bool ipv4, arp, rarp;
 309     int i;
 310
 311     match_init_catchall(match);
 312
 313     if (!(wc & OFPFW11_IN_PORT)) {
 314         ofp_port_t ofp_port;
 315         enum ofperr error;
 316
 317         error = ofputil_port_from_ofp11(ofmatch->in_port, &ofp_port);
 318         if (error) {
 319             return OFPERR_OFPBMC_BAD_VALUE;
 320         }
 321         match_set_in_port(match, ofp_port);
 322     }
 323
 324     for (i = 0; i < ETH_ADDR_LEN; i++) {
 325         dl_src_mask[i] = ~ofmatch->dl_src_mask[i];
 326     }
 327     match_set_dl_src_masked(match, ofmatch->dl_src, dl_src_mask);
 328
 329     for (i = 0; i < ETH_ADDR_LEN; i++) {
 330         dl_dst_mask[i] = ~ofmatch->dl_dst_mask[i];
 331     }
 332     match_set_dl_dst_masked(match, ofmatch->dl_dst, dl_dst_mask);
 333
 334     if (!(wc & OFPFW11_DL_VLAN)) {
 335         if (ofmatch->dl_vlan == htons(OFPVID11_NONE)) {
 336             /* Match only packets without a VLAN tag. */
 337             match->flow.vlan_tci = htons(0);
 338             match->wc.masks.vlan_tci = OVS_BE16_MAX;
 339         } else {
 340             if (ofmatch->dl_vlan == htons(OFPVID11_ANY)) {
 341                 /* Match any packet with a VLAN tag regardless of VID. */
 342                 match->flow.vlan_tci = htons(VLAN_CFI);
 343                 match->wc.masks.vlan_tci = htons(VLAN_CFI);
 344             } else if (ntohs(ofmatch->dl_vlan) < 4096) {
 345                 /* Match only packets with the specified VLAN VID. */
 346                 match->flow.vlan_tci = htons(VLAN_CFI) | ofmatch->dl_vlan;
 347                 match->wc.masks.vlan_tci = htons(VLAN_CFI | VLAN_VID_MASK);
 348             } else {
 349                 /* Invalid VID. */
 350                 return OFPERR_OFPBMC_BAD_VALUE;
 351             }
 352
 353             if (!(wc & OFPFW11_DL_VLAN_PCP)) {
 354                 if (ofmatch->dl_vlan_pcp <= 7) {
 355                     match->flow.vlan_tci |= htons(ofmatch->dl_vlan_pcp
 356                                                   << VLAN_PCP_SHIFT);
 357                     match->wc.masks.vlan_tci |= htons(VLAN_PCP_MASK);
 358                 } else {
 359                     /* Invalid PCP. */
 360                     return OFPERR_OFPBMC_BAD_VALUE;
 361                 }
 362             }
 363         }
 364     }
 365
 366     if (!(wc & OFPFW11_DL_TYPE)) {
 367         match_set_dl_type(match,
 368                           ofputil_dl_type_from_openflow(ofmatch->dl_type));
 369     }
 370
 371     ipv4 = match->flow.dl_type == htons(ETH_TYPE_IP);
 372     arp = match->flow.dl_type == htons(ETH_TYPE_ARP);
 373     rarp = match->flow.dl_type == htons(ETH_TYPE_RARP);
 374
 375     if (ipv4 && !(wc & OFPFW11_NW_TOS)) {
 376         if (ofmatch->nw_tos & ~IP_DSCP_MASK) {
 377             /* Invalid TOS. */
 378             return OFPERR_OFPBMC_BAD_VALUE;
 379         }
 380
 381         match_set_nw_dscp(match, ofmatch->nw_tos);
 382     }
 383
 384     if (ipv4 || arp || rarp) {
 385         if (!(wc & OFPFW11_NW_PROTO)) {
 386             match_set_nw_proto(match, ofmatch->nw_proto);
 387         }
 388         match_set_nw_src_masked(match, ofmatch->nw_src, ~ofmatch->nw_src_mask);
 389         match_set_nw_dst_masked(match, ofmatch->nw_dst, ~ofmatch->nw_dst_mask);
 390     }
 391
 392 #define OFPFW11_TP_ALL (OFPFW11_TP_SRC | OFPFW11_TP_DST)
 393     if (ipv4 && (wc & OFPFW11_TP_ALL) != OFPFW11_TP_ALL) {
 394         switch (match->flow.nw_proto) {
 395         case IPPROTO_ICMP:
 396             /* "A.2.3 Flow Match Structures" in OF1.1 says:
 397              *
 398              *    The tp_src and tp_dst fields will be ignored unless the
 399              *    network protocol specified is as TCP, UDP or SCTP.
 400              *
 401              * but I'm pretty sure we should support ICMP too, otherwise
 402              * that's a regression from OF1.0. */
 403             if (!(wc & OFPFW11_TP_SRC)) {
 404                 uint16_t icmp_type = ntohs(ofmatch->tp_src);
 405                 if (icmp_type < 0x100) {
 406                     match_set_icmp_type(match, icmp_type);
 407                 } else {
 408                     return OFPERR_OFPBMC_BAD_FIELD;
 409                 }
 410             }
 411             if (!(wc & OFPFW11_TP_DST)) {
 412                 uint16_t icmp_code = ntohs(ofmatch->tp_dst);
 413                 if (icmp_code < 0x100) {
 414                     match_set_icmp_code(match, icmp_code);
 415                 } else {
 416                     return OFPERR_OFPBMC_BAD_FIELD;
 417                 }
 418             }
 419             break;
 420
 421         case IPPROTO_TCP:
 422         case IPPROTO_UDP:
 423         case IPPROTO_SCTP:
 424             if (!(wc & (OFPFW11_TP_SRC))) {
 425                 match_set_tp_src(match, ofmatch->tp_src);
 426             }
 427             if (!(wc & (OFPFW11_TP_DST))) {
 428                 match_set_tp_dst(match, ofmatch->tp_dst);
 429             }
 430             break;
 431
 432         default:
 433             /* OF1.1 says explicitly to ignore this. */
 434             break;
 435         }
 436     }
 437
 438     if (eth_type_mpls(match->flow.dl_type)) {
 439         if (!(wc & OFPFW11_MPLS_LABEL)) {
 440             match_set_mpls_label(match, 0, ofmatch->mpls_label);
 441         }
 442         if (!(wc & OFPFW11_MPLS_TC)) {
 443             match_set_mpls_tc(match, 0, ofmatch->mpls_tc);
 444         }
 445     }
 446
 447     match_set_metadata_masked(match, ofmatch->metadata,
 448                               ~ofmatch->metadata_mask);
 449
 450     return 0;
 451 }
 452
 453 /* Convert 'match' into the OpenFlow 1.1 match structure 'ofmatch'. */
 454 void
 455 ofputil_match_to_ofp11_match(const struct match *match,
 456                              struct ofp11_match *ofmatch)
 457 {
 458     uint32_t wc = 0;
 459     int i;
 460
 461     memset(ofmatch, 0, sizeof *ofmatch);
 462     ofmatch->omh.type = htons(OFPMT_STANDARD);
 463     ofmatch->omh.length = htons(OFPMT11_STANDARD_LENGTH);
 464
 465     if (!match->wc.masks.in_port.ofp_port) {
 466         wc |= OFPFW11_IN_PORT;
 467     } else {
 468         ofmatch->in_port = ofputil_port_to_ofp11(match->flow.in_port.ofp_port);
 469     }
 470
 471     memcpy(ofmatch->dl_src, match->flow.dl_src, ETH_ADDR_LEN);
 472     for (i = 0; i < ETH_ADDR_LEN; i++) {
 473         ofmatch->dl_src_mask[i] = ~match->wc.masks.dl_src[i];
 474     }
 475
 476     memcpy(ofmatch->dl_dst, match->flow.dl_dst, ETH_ADDR_LEN);
 477     for (i = 0; i < ETH_ADDR_LEN; i++) {
 478         ofmatch->dl_dst_mask[i] = ~match->wc.masks.dl_dst[i];
 479     }
 480
 481     if (match->wc.masks.vlan_tci == htons(0)) {
 482         wc |= OFPFW11_DL_VLAN | OFPFW11_DL_VLAN_PCP;
 483     } else if (match->wc.masks.vlan_tci & htons(VLAN_CFI)
 484                && !(match->flow.vlan_tci & htons(VLAN_CFI))) {
 485         ofmatch->dl_vlan = htons(OFPVID11_NONE);
 486         wc |= OFPFW11_DL_VLAN_PCP;
 487     } else {
 488         if (!(match->wc.masks.vlan_tci & htons(VLAN_VID_MASK))) {
 489             ofmatch->dl_vlan = htons(OFPVID11_ANY);
 490         } else {
 491             ofmatch->dl_vlan = htons(vlan_tci_to_vid(match->flow.vlan_tci));
 492         }
 493
 494         if (!(match->wc.masks.vlan_tci & htons(VLAN_PCP_MASK))) {
 495             wc |= OFPFW11_DL_VLAN_PCP;
 496         } else {
 497             ofmatch->dl_vlan_pcp = vlan_tci_to_pcp(match->flow.vlan_tci);
 498         }
 499     }
 500
 501     if (!match->wc.masks.dl_type) {
 502         wc |= OFPFW11_DL_TYPE;
 503     } else {
 504         ofmatch->dl_type = ofputil_dl_type_to_openflow(match->flow.dl_type);
 505     }
 506
 507     if (!(match->wc.masks.nw_tos & IP_DSCP_MASK)) {
 508         wc |= OFPFW11_NW_TOS;
 509     } else {
 510         ofmatch->nw_tos = match->flow.nw_tos & IP_DSCP_MASK;
 511     }
 512
 513     if (!match->wc.masks.nw_proto) {
 514         wc |= OFPFW11_NW_PROTO;
 515     } else {
 516         ofmatch->nw_proto = match->flow.nw_proto;
 517     }
 518
 519     ofmatch->nw_src = match->flow.nw_src;
 520     ofmatch->nw_src_mask = ~match->wc.masks.nw_src;
 521     ofmatch->nw_dst = match->flow.nw_dst;
 522     ofmatch->nw_dst_mask = ~match->wc.masks.nw_dst;
 523
 524     if (!match->wc.masks.tp_src) {
 525         wc |= OFPFW11_TP_SRC;
 526     } else {
 527         ofmatch->tp_src = match->flow.tp_src;
 528     }
 529
 530     if (!match->wc.masks.tp_dst) {
 531         wc |= OFPFW11_TP_DST;
 532     } else {
 533         ofmatch->tp_dst = match->flow.tp_dst;
 534     }
 535
 536     if (!(match->wc.masks.mpls_lse[0] & htonl(MPLS_LABEL_MASK))) {
 537         wc |= OFPFW11_MPLS_LABEL;
 538     } else {
 539         ofmatch->mpls_label = htonl(mpls_lse_to_label(
 540                                         match->flow.mpls_lse[0]));
 541     }
 542
 543     if (!(match->wc.masks.mpls_lse[0] & htonl(MPLS_TC_MASK))) {
 544         wc |= OFPFW11_MPLS_TC;
 545     } else {
 546         ofmatch->mpls_tc = mpls_lse_to_tc(match->flow.mpls_lse[0]);
 547     }
 548
 549     ofmatch->metadata = match->flow.metadata;
 550     ofmatch->metadata_mask = ~match->wc.masks.metadata;
 551
 552     ofmatch->wildcards = htonl(wc);
 553 }
 554
 555 /* Returns the "typical" length of a match for 'protocol', for use in
 556  * estimating space to preallocate. */
 557 int
 558 ofputil_match_typical_len(enum ofputil_protocol protocol)
 559 {
 560     switch (protocol) {
 561     case OFPUTIL_P_OF10_STD:
 562     case OFPUTIL_P_OF10_STD_TID:
 563         return sizeof(struct ofp10_match);
 564
 565     case OFPUTIL_P_OF10_NXM:
 566     case OFPUTIL_P_OF10_NXM_TID:
 567         return NXM_TYPICAL_LEN;
 568
 569     case OFPUTIL_P_OF11_STD:
 570         return sizeof(struct ofp11_match);
 571
 572     case OFPUTIL_P_OF12_OXM:
 573     case OFPUTIL_P_OF13_OXM:
 574         return NXM_TYPICAL_LEN;
 575
 576     default:
 577         OVS_NOT_REACHED();
 578     }
 579 }
 580
 581 /* Appends to 'b' an struct ofp11_match_header followed by a match that
 582  * expresses 'match' properly for 'protocol', plus enough zero bytes to pad the
 583  * data appended out to a multiple of 8.  'protocol' must be one that is usable
 584  * in OpenFlow 1.1 or later.
 585  *
 586  * This function can cause 'b''s data to be reallocated.
 587  *
 588  * Returns the number of bytes appended to 'b', excluding the padding.  Never
 589  * returns zero. */
 590 int
 591 ofputil_put_ofp11_match(struct ofpbuf *b, const struct match *match,
 592                         enum ofputil_protocol protocol)
 593 {
 594     switch (protocol) {
 595     case OFPUTIL_P_OF10_STD:
 596     case OFPUTIL_P_OF10_STD_TID:
 597     case OFPUTIL_P_OF10_NXM:
 598     case OFPUTIL_P_OF10_NXM_TID:
 599         OVS_NOT_REACHED();
 600
 601     case OFPUTIL_P_OF11_STD: {
 602         struct ofp11_match *om;
 603
 604         /* Make sure that no padding is needed. */
 605         BUILD_ASSERT_DECL(sizeof *om % 8 == 0);
 606
 607         om = ofpbuf_put_uninit(b, sizeof *om);
 608         ofputil_match_to_ofp11_match(match, om);
 609         return sizeof *om;
 610     }
 611
 612     case OFPUTIL_P_OF12_OXM:
 613     case OFPUTIL_P_OF13_OXM:
 614         return oxm_put_match(b, match);
 615     }
 616
 617     OVS_NOT_REACHED();
 618 }
 619
 620 /* Given a 'dl_type' value in the format used in struct flow, returns the
 621  * corresponding 'dl_type' value for use in an ofp10_match or ofp11_match
 622  * structure. */
 623 ovs_be16
 624 ofputil_dl_type_to_openflow(ovs_be16 flow_dl_type)
 625 {
 626     return (flow_dl_type == htons(FLOW_DL_TYPE_NONE)
 627             ? htons(OFP_DL_TYPE_NOT_ETH_TYPE)
 628             : flow_dl_type);
 629 }
 630
 631 /* Given a 'dl_type' value in the format used in an ofp10_match or ofp11_match
 632  * structure, returns the corresponding 'dl_type' value for use in struct
 633  * flow. */
 634 ovs_be16
 635 ofputil_dl_type_from_openflow(ovs_be16 ofp_dl_type)
 636 {
 637     return (ofp_dl_type == htons(OFP_DL_TYPE_NOT_ETH_TYPE)
 638             ? htons(FLOW_DL_TYPE_NONE)
 639             : ofp_dl_type);
 640 }
 641 \f
 642 /* Protocols. */
 643
 644 struct proto_abbrev {
 645     enum ofputil_protocol protocol;
 646     const char *name;
 647 };
 648
 649 /* Most users really don't care about some of the differences between
 650  * protocols.  These abbreviations help with that. */
 651 static const struct proto_abbrev proto_abbrevs[] = {
 652     { OFPUTIL_P_ANY,          "any" },
 653     { OFPUTIL_P_OF10_STD_ANY, "OpenFlow10" },
 654     { OFPUTIL_P_OF10_NXM_ANY, "NXM" },
 655     { OFPUTIL_P_ANY_OXM,      "OXM" },
 656 };
 657 #define N_PROTO_ABBREVS ARRAY_SIZE(proto_abbrevs)
 658
 659 enum ofputil_protocol ofputil_flow_dump_protocols[] = {
 660     OFPUTIL_P_OF13_OXM,
 661     OFPUTIL_P_OF12_OXM,
 662     OFPUTIL_P_OF11_STD,
 663     OFPUTIL_P_OF10_NXM,
 664     OFPUTIL_P_OF10_STD,
 665 };
 666 size_t ofputil_n_flow_dump_protocols = ARRAY_SIZE(ofputil_flow_dump_protocols);
 667
 668 /* Returns the set of ofputil_protocols that are supported with the given
 669  * OpenFlow 'version'.  'version' should normally be an 8-bit OpenFlow version
 670  * identifier (e.g. 0x01 for OpenFlow 1.0, 0x02 for OpenFlow 1.1).  Returns 0
 671  * if 'version' is not supported or outside the valid range.  */
 672 enum ofputil_protocol
 673 ofputil_protocols_from_ofp_version(enum ofp_version version)
 674 {
 675     switch (version) {
 676     case OFP10_VERSION:
 677         return OFPUTIL_P_OF10_STD_ANY | OFPUTIL_P_OF10_NXM_ANY;
 678     case OFP11_VERSION:
 679         return OFPUTIL_P_OF11_STD;
 680     case OFP12_VERSION:
 681         return OFPUTIL_P_OF12_OXM;
 682     case OFP13_VERSION:
 683         return OFPUTIL_P_OF13_OXM;
 684     default:
 685         return 0;
 686     }
 687 }
 688
 689 /* Returns the ofputil_protocol that is initially in effect on an OpenFlow
 690  * connection that has negotiated the given 'version'.  'version' should
 691  * normally be an 8-bit OpenFlow version identifier (e.g. 0x01 for OpenFlow
 692  * 1.0, 0x02 for OpenFlow 1.1).  Returns 0 if 'version' is not supported or
 693  * outside the valid range.  */
 694 enum ofputil_protocol
 695 ofputil_protocol_from_ofp_version(enum ofp_version version)
 696 {
 697     return rightmost_1bit(ofputil_protocols_from_ofp_version(version));
 698 }
 699
 700 /* Returns the OpenFlow protocol version number (e.g. OFP10_VERSION,
 701  * etc.) that corresponds to 'protocol'. */
 702 enum ofp_version
 703 ofputil_protocol_to_ofp_version(enum ofputil_protocol protocol)
 704 {
 705     switch (protocol) {
 706     case OFPUTIL_P_OF10_STD:
 707     case OFPUTIL_P_OF10_STD_TID:
 708     case OFPUTIL_P_OF10_NXM:
 709     case OFPUTIL_P_OF10_NXM_TID:
 710         return OFP10_VERSION;
 711     case OFPUTIL_P_OF11_STD:
 712         return OFP11_VERSION;
 713     case OFPUTIL_P_OF12_OXM:
 714         return OFP12_VERSION;
 715     case OFPUTIL_P_OF13_OXM:
 716         return OFP13_VERSION;
 717     }
 718
 719     OVS_NOT_REACHED();
 720 }
 721
 722 /* Returns a bitmap of OpenFlow versions that are supported by at
 723  * least one of the 'protocols'. */
 724 uint32_t
 725 ofputil_protocols_to_version_bitmap(enum ofputil_protocol protocols)
 726 {
 727     uint32_t bitmap = 0;
 728
 729     for (; protocols; protocols = zero_rightmost_1bit(protocols)) {
 730         enum ofputil_protocol protocol = rightmost_1bit(protocols);
 731
 732         bitmap |= 1u << ofputil_protocol_to_ofp_version(protocol);
 733     }
 734
 735     return bitmap;
 736 }
 737
 738 /* Returns the set of protocols that are supported on top of the
 739  * OpenFlow versions included in 'bitmap'. */
 740 enum ofputil_protocol
 741 ofputil_protocols_from_version_bitmap(uint32_t bitmap)
 742 {
 743     enum ofputil_protocol protocols = 0;
 744
 745     for (; bitmap; bitmap = zero_rightmost_1bit(bitmap)) {
 746         enum ofp_version version = rightmost_1bit_idx(bitmap);
 747
 748         protocols |= ofputil_protocols_from_ofp_version(version);
 749     }
 750
 751     return protocols;
 752 }
 753
 754 /* Returns true if 'protocol' is a single OFPUTIL_P_* value, false
 755  * otherwise. */
 756 bool
 757 ofputil_protocol_is_valid(enum ofputil_protocol protocol)
 758 {
 759     return protocol & OFPUTIL_P_ANY && is_pow2(protocol);
 760 }
 761
 762 /* Returns the equivalent of 'protocol' with the Nicira flow_mod_table_id
 763  * extension turned on or off if 'enable' is true or false, respectively.
 764  *
 765  * This extension is only useful for protocols whose "standard" version does
 766  * not allow specific tables to be modified.  In particular, this is true of
 767  * OpenFlow 1.0.  In later versions of OpenFlow, a flow_mod request always
 768  * specifies a table ID and so there is no need for such an extension.  When
 769  * 'protocol' is such a protocol that doesn't need a flow_mod_table_id
 770  * extension, this function just returns its 'protocol' argument unchanged
 771  * regardless of the value of 'enable'.  */
 772 enum ofputil_protocol
 773 ofputil_protocol_set_tid(enum ofputil_protocol protocol, bool enable)
 774 {
 775     switch (protocol) {
 776     case OFPUTIL_P_OF10_STD:
 777     case OFPUTIL_P_OF10_STD_TID:
 778         return enable ? OFPUTIL_P_OF10_STD_TID : OFPUTIL_P_OF10_STD;
 779
 780     case OFPUTIL_P_OF10_NXM:
 781     case OFPUTIL_P_OF10_NXM_TID:
 782         return enable ? OFPUTIL_P_OF10_NXM_TID : OFPUTIL_P_OF10_NXM;
 783
 784     case OFPUTIL_P_OF11_STD:
 785         return OFPUTIL_P_OF11_STD;
 786
 787     case OFPUTIL_P_OF12_OXM:
 788         return OFPUTIL_P_OF12_OXM;
 789
 790     case OFPUTIL_P_OF13_OXM:
 791         return OFPUTIL_P_OF13_OXM;
 792
 793     default:
 794         OVS_NOT_REACHED();
 795     }
 796 }
 797
 798 /* Returns the "base" version of 'protocol'.  That is, if 'protocol' includes
 799  * some extension to a standard protocol version, the return value is the
 800  * standard version of that protocol without any extension.  If 'protocol' is a
 801  * standard protocol version, returns 'protocol' unchanged. */
 802 enum ofputil_protocol
 803 ofputil_protocol_to_base(enum ofputil_protocol protocol)
 804 {
 805     return ofputil_protocol_set_tid(protocol, false);
 806 }
 807
 808 /* Returns 'new_base' with any extensions taken from 'cur'. */
 809 enum ofputil_protocol
 810 ofputil_protocol_set_base(enum ofputil_protocol cur,
 811                           enum ofputil_protocol new_base)
 812 {
 813     bool tid = (cur & OFPUTIL_P_TID) != 0;
 814
 815     switch (new_base) {
 816     case OFPUTIL_P_OF10_STD:
 817     case OFPUTIL_P_OF10_STD_TID:
 818         return ofputil_protocol_set_tid(OFPUTIL_P_OF10_STD, tid);
 819
 820     case OFPUTIL_P_OF10_NXM:
 821     case OFPUTIL_P_OF10_NXM_TID:
 822         return ofputil_protocol_set_tid(OFPUTIL_P_OF10_NXM, tid);
 823
 824     case OFPUTIL_P_OF11_STD:
 825         return ofputil_protocol_set_tid(OFPUTIL_P_OF11_STD, tid);
 826
 827     case OFPUTIL_P_OF12_OXM:
 828         return ofputil_protocol_set_tid(OFPUTIL_P_OF12_OXM, tid);
 829
 830     case OFPUTIL_P_OF13_OXM:
 831         return ofputil_protocol_set_tid(OFPUTIL_P_OF13_OXM, tid);
 832
 833     default:
 834         OVS_NOT_REACHED();
 835     }
 836 }
 837
 838 /* Returns a string form of 'protocol', if a simple form exists (that is, if
 839  * 'protocol' is either a single protocol or it is a combination of protocols
 840  * that have a single abbreviation).  Otherwise, returns NULL. */
 841 const char *
 842 ofputil_protocol_to_string(enum ofputil_protocol protocol)
 843 {
 844     const struct proto_abbrev *p;
 845
 846     /* Use a "switch" statement for single-bit names so that we get a compiler
 847      * warning if we forget any. */
 848     switch (protocol) {
 849     case OFPUTIL_P_OF10_NXM:
 850         return "NXM-table_id";
 851
 852     case OFPUTIL_P_OF10_NXM_TID:
 853         return "NXM+table_id";
 854
 855     case OFPUTIL_P_OF10_STD:
 856         return "OpenFlow10-table_id";
 857
 858     case OFPUTIL_P_OF10_STD_TID:
 859         return "OpenFlow10+table_id";
 860
 861     case OFPUTIL_P_OF11_STD:
 862         return "OpenFlow11";
 863
 864     case OFPUTIL_P_OF12_OXM:
 865         return "OXM-OpenFlow12";
 866
 867     case OFPUTIL_P_OF13_OXM:
 868         return "OXM-OpenFlow13";
 869     }
 870
 871     /* Check abbreviations. */
 872     for (p = proto_abbrevs; p < &proto_abbrevs[N_PROTO_ABBREVS]; p++) {
 873         if (protocol == p->protocol) {
 874             return p->name;
 875         }
 876     }
 877
 878     return NULL;
 879 }
 880
 881 /* Returns a string that represents 'protocols'.  The return value might be a
 882  * comma-separated list if 'protocols' doesn't have a simple name.  The return
 883  * value is "none" if 'protocols' is 0.
 884  *
 885  * The caller must free the returned string (with free()). */
 886 char *
 887 ofputil_protocols_to_string(enum ofputil_protocol protocols)
 888 {
 889     struct ds s;
 890
 891     ovs_assert(!(protocols & ~OFPUTIL_P_ANY));
 892     if (protocols == 0) {
 893         return xstrdup("none");
 894     }
 895
 896     ds_init(&s);
 897     while (protocols) {
 898         const struct proto_abbrev *p;
 899         int i;
 900
 901         if (s.length) {
 902             ds_put_char(&s, ',');
 903         }
 904
 905         for (p = proto_abbrevs; p < &proto_abbrevs[N_PROTO_ABBREVS]; p++) {
 906             if ((protocols & p->protocol) == p->protocol) {
 907                 ds_put_cstr(&s, p->name);
 908                 protocols &= ~p->protocol;
 909                 goto match;
 910             }
 911         }
 912
 913         for (i = 0; i < CHAR_BIT * sizeof(enum ofputil_protocol); i++) {
 914             enum ofputil_protocol bit = 1u << i;
 915
 916             if (protocols & bit) {
 917                 ds_put_cstr(&s, ofputil_protocol_to_string(bit));
 918                 protocols &= ~bit;
 919                 goto match;
 920             }
 921         }
 922         OVS_NOT_REACHED();
 923
 924     match: ;
 925     }
 926     return ds_steal_cstr(&s);
 927 }
 928
 929 static enum ofputil_protocol
 930 ofputil_protocol_from_string__(const char *s, size_t n)
 931 {
 932     const struct proto_abbrev *p;
 933     int i;
 934
 935     for (i = 0; i < CHAR_BIT * sizeof(enum ofputil_protocol); i++) {
 936         enum ofputil_protocol bit = 1u << i;
 937         const char *name = ofputil_protocol_to_string(bit);
 938
 939         if (name && n == strlen(name) && !strncasecmp(s, name, n)) {
 940             return bit;
 941         }
 942     }
 943
 944     for (p = proto_abbrevs; p < &proto_abbrevs[N_PROTO_ABBREVS]; p++) {
 945         if (n == strlen(p->name) && !strncasecmp(s, p->name, n)) {
 946             return p->protocol;
 947         }
 948     }
 949
 950     return 0;
 951 }
 952
 953 /* Returns the nonempty set of protocols represented by 's', which can be a
 954  * single protocol name or abbreviation or a comma-separated list of them.
 955  *
 956  * Aborts the program with an error message if 's' is invalid. */
 957 enum ofputil_protocol
 958 ofputil_protocols_from_string(const char *s)
 959 {
 960     const char *orig_s = s;
 961     enum ofputil_protocol protocols;
 962
 963     protocols = 0;
 964     while (*s) {
 965         enum ofputil_protocol p;
 966         size_t n;
 967
 968         n = strcspn(s, ",");
 969         if (n == 0) {
 970             s++;
 971             continue;
 972         }
 973
 974         p = ofputil_protocol_from_string__(s, n);
 975         if (!p) {
 976             ovs_fatal(0, "%.*s: unknown flow protocol", (int) n, s);
 977         }
 978         protocols |= p;
 979
 980         s += n;
 981     }
 982
 983     if (!protocols) {
 984         ovs_fatal(0, "%s: no flow protocol specified", orig_s);
 985     }
 986     return protocols;
 987 }
 988
 989 static int
 990 ofputil_version_from_string(const char *s)
 991 {
 992     if (!strcasecmp(s, "OpenFlow10")) {
 993         return OFP10_VERSION;
 994     }
 995     if (!strcasecmp(s, "OpenFlow11")) {
 996         return OFP11_VERSION;
 997     }
 998     if (!strcasecmp(s, "OpenFlow12")) {
 999         return OFP12_VERSION;
1000     }
1001     if (!strcasecmp(s, "OpenFlow13")) {
1002         return OFP13_VERSION;
1003     }
1004     return 0;
1005 }
1006
1007 static bool
1008 is_delimiter(unsigned char c)
1009 {
1010     return isspace(c) || c == ',';
1011 }
1012
1013 uint32_t
1014 ofputil_versions_from_string(const char *s)
1015 {
1016     size_t i = 0;
1017     uint32_t bitmap = 0;
1018
1019     while (s[i]) {
1020         size_t j;
1021         int version;
1022         char *key;
1023
1024         if (is_delimiter(s[i])) {
1025             i++;
1026             continue;
1027         }
1028         j = 0;
1029         while (s[i + j] && !is_delimiter(s[i + j])) {
1030             j++;
1031         }
1032         key = xmemdup0(s + i, j);
1033         version = ofputil_version_from_string(key);
1034         if (!version) {
1035             VLOG_FATAL("Unknown OpenFlow version: \"%s\"", key);
1036         }
1037         free(key);
1038         bitmap |= 1u << version;
1039         i += j;
1040     }
1041
1042     return bitmap;
1043 }
1044
1045 uint32_t
1046 ofputil_versions_from_strings(char ** const s, size_t count)
1047 {
1048     uint32_t bitmap = 0;
1049
1050     while (count--) {
1051         int version = ofputil_version_from_string(s[count]);
1052         if (!version) {
1053             VLOG_WARN("Unknown OpenFlow version: \"%s\"", s[count]);
1054         } else {
1055             bitmap |= 1u << version;
1056         }
1057     }
1058
1059     return bitmap;
1060 }
1061
1062 const char *
1063 ofputil_version_to_string(enum ofp_version ofp_version)
1064 {
1065     switch (ofp_version) {
1066     case OFP10_VERSION:
1067         return "OpenFlow10";
1068     case OFP11_VERSION:
1069         return "OpenFlow11";
1070     case OFP12_VERSION:
1071         return "OpenFlow12";
1072     case OFP13_VERSION:
1073         return "OpenFlow13";
1074     default:
1075         OVS_NOT_REACHED();
1076     }
1077 }
1078
1079 bool
1080 ofputil_packet_in_format_is_valid(enum nx_packet_in_format packet_in_format)
1081 {
1082     switch (packet_in_format) {
1083     case NXPIF_OPENFLOW10:
1084     case NXPIF_NXM:
1085         return true;
1086     }
1087
1088     return false;
1089 }
1090
1091 const char *
1092 ofputil_packet_in_format_to_string(enum nx_packet_in_format packet_in_format)
1093 {
1094     switch (packet_in_format) {
1095     case NXPIF_OPENFLOW10:
1096         return "openflow10";
1097     case NXPIF_NXM:
1098         return "nxm";
1099     default:
1100         OVS_NOT_REACHED();
1101     }
1102 }
1103
1104 int
1105 ofputil_packet_in_format_from_string(const char *s)
1106 {
1107     return (!strcmp(s, "openflow10") ? NXPIF_OPENFLOW10
1108             : !strcmp(s, "nxm") ? NXPIF_NXM
1109             : -1);
1110 }
1111
1112 void
1113 ofputil_format_version(struct ds *msg, enum ofp_version version)
1114 {
1115     ds_put_format(msg, "0x%02x", version);
1116 }
1117
1118 void
1119 ofputil_format_version_name(struct ds *msg, enum ofp_version version)
1120 {
1121     ds_put_cstr(msg, ofputil_version_to_string(version));
1122 }
1123
1124 static void
1125 ofputil_format_version_bitmap__(struct ds *msg, uint32_t bitmap,
1126                                 void (*format_version)(struct ds *msg,
1127                                                        enum ofp_version))
1128 {
1129     while (bitmap) {
1130         format_version(msg, raw_ctz(bitmap));
1131         bitmap = zero_rightmost_1bit(bitmap);
1132         if (bitmap) {
1133             ds_put_cstr(msg, ", ");
1134         }
1135     }
1136 }
1137
1138 void
1139 ofputil_format_version_bitmap(struct ds *msg, uint32_t bitmap)
1140 {
1141     ofputil_format_version_bitmap__(msg, bitmap, ofputil_format_version);
1142 }
1143
1144 void
1145 ofputil_format_version_bitmap_names(struct ds *msg, uint32_t bitmap)
1146 {
1147     ofputil_format_version_bitmap__(msg, bitmap, ofputil_format_version_name);
1148 }
1149
1150 static bool
1151 ofputil_decode_hello_bitmap(const struct ofp_hello_elem_header *oheh,
1152                             uint32_t *allowed_versionsp)
1153 {
1154     uint16_t bitmap_len = ntohs(oheh->length) - sizeof *oheh;
1155     const ovs_be32 *bitmap = ALIGNED_CAST(const ovs_be32 *, oheh + 1);
1156     uint32_t allowed_versions;
1157
1158     if (!bitmap_len || bitmap_len % sizeof *bitmap) {
1159         return false;
1160     }
1161
1162     /* Only use the first 32-bit element of the bitmap as that is all the
1163      * current implementation supports.  Subsequent elements are ignored which
1164      * should have no effect on session negotiation until Open vSwtich supports
1165      * wire-protocol versions greater than 31.
1166      */
1167     allowed_versions = ntohl(bitmap[0]);
1168
1169     if (allowed_versions & 1) {
1170         /* There's no OpenFlow version 0. */
1171         VLOG_WARN_RL(&bad_ofmsg_rl, "peer claims to support invalid OpenFlow "
1172                      "version 0x00");
1173         allowed_versions &= ~1u;
1174     }
1175
1176     if (!allowed_versions) {
1177         VLOG_WARN_RL(&bad_ofmsg_rl, "peer does not support any OpenFlow "
1178                      "version (between 0x01 and 0x1f)");
1179         return false;
1180     }
1181
1182     *allowed_versionsp = allowed_versions;
1183     return true;
1184 }
1185
1186 static uint32_t
1187 version_bitmap_from_version(uint8_t ofp_version)
1188 {
1189     return ((ofp_version < 32 ? 1u << ofp_version : 0) - 1) << 1;
1190 }
1191
1192 /* Decodes OpenFlow OFPT_HELLO message 'oh', storing into '*allowed_versions'
1193  * the set of OpenFlow versions for which 'oh' announces support.
1194  *
1195  * Because of how OpenFlow defines OFPT_HELLO messages, this function is always
1196  * successful, and thus '*allowed_versions' is always initialized.  However, it
1197  * returns false if 'oh' contains some data that could not be fully understood,
1198  * true if 'oh' was completely parsed. */
1199 bool
1200 ofputil_decode_hello(const struct ofp_header *oh, uint32_t *allowed_versions)
1201 {
1202     struct ofpbuf msg;
1203     bool ok = true;
1204
1205     ofpbuf_use_const(&msg, oh, ntohs(oh->length));
1206     ofpbuf_pull(&msg, sizeof *oh);
1207
1208     *allowed_versions = version_bitmap_from_version(oh->version);
1209     while (msg.size) {
1210         const struct ofp_hello_elem_header *oheh;
1211         unsigned int len;
1212
1213         if (msg.size < sizeof *oheh) {
1214             return false;
1215         }
1216
1217         oheh = msg.data;
1218         len = ntohs(oheh->length);
1219         if (len < sizeof *oheh || !ofpbuf_try_pull(&msg, ROUND_UP(len, 8))) {
1220             return false;
1221         }
1222
1223         if (oheh->type != htons(OFPHET_VERSIONBITMAP)
1224             || !ofputil_decode_hello_bitmap(oheh, allowed_versions)) {
1225             ok = false;
1226         }
1227     }
1228
1229     return ok;
1230 }
1231
1232 /* Returns true if 'allowed_versions' needs to be accompanied by a version
1233  * bitmap to be correctly expressed in an OFPT_HELLO message. */
1234 static bool
1235 should_send_version_bitmap(uint32_t allowed_versions)
1236 {
1237     return !is_pow2((allowed_versions >> 1) + 1);
1238 }
1239
1240 /* Create an OFPT_HELLO message that expresses support for the OpenFlow
1241  * versions in the 'allowed_versions' bitmaps and returns the message. */
1242 struct ofpbuf *
1243 ofputil_encode_hello(uint32_t allowed_versions)
1244 {
1245     enum ofp_version ofp_version;
1246     struct ofpbuf *msg;
1247
1248     ofp_version = leftmost_1bit_idx(allowed_versions);
1249     msg = ofpraw_alloc(OFPRAW_OFPT_HELLO, ofp_version, 0);
1250
1251     if (should_send_version_bitmap(allowed_versions)) {
1252         struct ofp_hello_elem_header *oheh;
1253         uint16_t map_len;
1254
1255         map_len = sizeof allowed_versions;
1256         oheh = ofpbuf_put_zeros(msg, ROUND_UP(map_len + sizeof *oheh, 8));
1257         oheh->type = htons(OFPHET_VERSIONBITMAP);
1258         oheh->length = htons(map_len + sizeof *oheh);
1259         *ALIGNED_CAST(ovs_be32 *, oheh + 1) = htonl(allowed_versions);
1260
1261         ofpmsg_update_length(msg);
1262     }
1263
1264     return msg;
1265 }
1266
1267 /* Returns an OpenFlow message that, sent on an OpenFlow connection whose
1268  * protocol is 'current', at least partly transitions the protocol to 'want'.
1269  * Stores in '*next' the protocol that will be in effect on the OpenFlow
1270  * connection if the switch processes the returned message correctly.  (If
1271  * '*next != want' then the caller will have to iterate.)
1272  *
1273  * If 'current == want', or if it is not possible to transition from 'current'
1274  * to 'want' (because, for example, 'current' and 'want' use different OpenFlow
1275  * protocol versions), returns NULL and stores 'current' in '*next'. */
1276 struct ofpbuf *
1277 ofputil_encode_set_protocol(enum ofputil_protocol current,
1278                             enum ofputil_protocol want,
1279                             enum ofputil_protocol *next)
1280 {
1281     enum ofp_version cur_version, want_version;
1282     enum ofputil_protocol cur_base, want_base;
1283     bool cur_tid, want_tid;
1284
1285     cur_version = ofputil_protocol_to_ofp_version(current);
1286     want_version = ofputil_protocol_to_ofp_version(want);
1287     if (cur_version != want_version) {
1288         *next = current;
1289         return NULL;
1290     }
1291
1292     cur_base = ofputil_protocol_to_base(current);
1293     want_base = ofputil_protocol_to_base(want);
1294     if (cur_base != want_base) {
1295         *next = ofputil_protocol_set_base(current, want_base);
1296
1297         switch (want_base) {
1298         case OFPUTIL_P_OF10_NXM:
1299             return ofputil_encode_nx_set_flow_format(NXFF_NXM);
1300
1301         case OFPUTIL_P_OF10_STD:
1302             return ofputil_encode_nx_set_flow_format(NXFF_OPENFLOW10);
1303
1304         case OFPUTIL_P_OF11_STD:
1305         case OFPUTIL_P_OF12_OXM:
1306         case OFPUTIL_P_OF13_OXM:
1307             /* There is only one variant of each OpenFlow 1.1+ protocol, and we
1308              * verified above that we're not trying to change versions. */
1309             OVS_NOT_REACHED();
1310
1311         case OFPUTIL_P_OF10_STD_TID:
1312         case OFPUTIL_P_OF10_NXM_TID:
1313             OVS_NOT_REACHED();
1314         }
1315     }
1316
1317     cur_tid = (current & OFPUTIL_P_TID) != 0;
1318     want_tid = (want & OFPUTIL_P_TID) != 0;
1319     if (cur_tid != want_tid) {
1320         *next = ofputil_protocol_set_tid(current, want_tid);
1321         return ofputil_make_flow_mod_table_id(want_tid);
1322     }
1323
1324     ovs_assert(current == want);
1325
1326     *next = current;
1327     return NULL;
1328 }
1329
1330 /* Returns an NXT_SET_FLOW_FORMAT message that can be used to set the flow
1331  * format to 'nxff'.  */
1332 struct ofpbuf *
1333 ofputil_encode_nx_set_flow_format(enum nx_flow_format nxff)
1334 {
1335     struct nx_set_flow_format *sff;
1336     struct ofpbuf *msg;
1337
1338     ovs_assert(ofputil_nx_flow_format_is_valid(nxff));
1339
1340     msg = ofpraw_alloc(OFPRAW_NXT_SET_FLOW_FORMAT, OFP10_VERSION, 0);
1341     sff = ofpbuf_put_zeros(msg, sizeof *sff);
1342     sff->format = htonl(nxff);
1343
1344     return msg;
1345 }
1346
1347 /* Returns the base protocol if 'flow_format' is a valid NXFF_* value, false
1348  * otherwise. */
1349 enum ofputil_protocol
1350 ofputil_nx_flow_format_to_protocol(enum nx_flow_format flow_format)
1351 {
1352     switch (flow_format) {
1353     case NXFF_OPENFLOW10:
1354         return OFPUTIL_P_OF10_STD;
1355
1356     case NXFF_NXM:
1357         return OFPUTIL_P_OF10_NXM;
1358
1359     default:
1360         return 0;
1361     }
1362 }
1363
1364 /* Returns true if 'flow_format' is a valid NXFF_* value, false otherwise. */
1365 bool
1366 ofputil_nx_flow_format_is_valid(enum nx_flow_format flow_format)
1367 {
1368     return ofputil_nx_flow_format_to_protocol(flow_format) != 0;
1369 }
1370
1371 /* Returns a string version of 'flow_format', which must be a valid NXFF_*
1372  * value. */
1373 const char *
1374 ofputil_nx_flow_format_to_string(enum nx_flow_format flow_format)
1375 {
1376     switch (flow_format) {
1377     case NXFF_OPENFLOW10:
1378         return "openflow10";
1379     case NXFF_NXM:
1380         return "nxm";
1381     default:
1382         OVS_NOT_REACHED();
1383     }
1384 }
1385
1386 struct ofpbuf *
1387 ofputil_make_set_packet_in_format(enum ofp_version ofp_version,
1388                                   enum nx_packet_in_format packet_in_format)
1389 {
1390     struct nx_set_packet_in_format *spif;
1391     struct ofpbuf *msg;
1392
1393     msg = ofpraw_alloc(OFPRAW_NXT_SET_PACKET_IN_FORMAT, ofp_version, 0);
1394     spif = ofpbuf_put_zeros(msg, sizeof *spif);
1395     spif->format = htonl(packet_in_format);
1396
1397     return msg;
1398 }
1399
1400 /* Returns an OpenFlow message that can be used to turn the flow_mod_table_id
1401  * extension on or off (according to 'flow_mod_table_id'). */
1402 struct ofpbuf *
1403 ofputil_make_flow_mod_table_id(bool flow_mod_table_id)
1404 {
1405     struct nx_flow_mod_table_id *nfmti;
1406     struct ofpbuf *msg;
1407
1408     msg = ofpraw_alloc(OFPRAW_NXT_FLOW_MOD_TABLE_ID, OFP10_VERSION, 0);
1409     nfmti = ofpbuf_put_zeros(msg, sizeof *nfmti);
1410     nfmti->set = flow_mod_table_id;
1411     return msg;
1412 }
1413
1414 struct ofputil_flow_mod_flag {
1415     uint16_t raw_flag;
1416     enum ofp_version min_version, max_version;
1417     enum ofputil_flow_mod_flags flag;
1418 };
1419
1420 static const struct ofputil_flow_mod_flag ofputil_flow_mod_flags[] = {
1421     { OFPFF_SEND_FLOW_REM,   OFP10_VERSION, 0, OFPUTIL_FF_SEND_FLOW_REM },
1422     { OFPFF_CHECK_OVERLAP,   OFP10_VERSION, 0, OFPUTIL_FF_CHECK_OVERLAP },
1423     { OFPFF10_EMERG,         OFP10_VERSION, OFP10_VERSION,
1424       OFPUTIL_FF_EMERG },
1425     { OFPFF12_RESET_COUNTS,  OFP12_VERSION, 0, OFPUTIL_FF_RESET_COUNTS },
1426     { OFPFF13_NO_PKT_COUNTS, OFP13_VERSION, 0, OFPUTIL_FF_NO_PKT_COUNTS },
1427     { OFPFF13_NO_BYT_COUNTS, OFP13_VERSION, 0, OFPUTIL_FF_NO_BYT_COUNTS },
1428     { 0, 0, 0, 0 },
1429 };
1430
1431 static enum ofperr
1432 ofputil_decode_flow_mod_flags(ovs_be16 raw_flags_,
1433                               enum ofp_flow_mod_command command,
1434                               enum ofp_version version,
1435                               enum ofputil_flow_mod_flags *flagsp)
1436 {
1437     uint16_t raw_flags = ntohs(raw_flags_);
1438     const struct ofputil_flow_mod_flag *f;
1439
1440     *flagsp = 0;
1441     for (f = ofputil_flow_mod_flags; f->raw_flag; f++) {
1442         if (raw_flags & f->raw_flag
1443             && version >= f->min_version
1444             && (!f->max_version || version <= f->max_version)) {
1445             raw_flags &= ~f->raw_flag;
1446             *flagsp |= f->flag;
1447         }
1448     }
1449
1450     /* In OF1.0 and OF1.1, "add" always resets counters, and other commands
1451      * never do.
1452      *
1453      * In OF1.2 and later, OFPFF12_RESET_COUNTS controls whether each command
1454      * resets counters. */
1455     if ((version == OFP10_VERSION || version == OFP11_VERSION)
1456         && command == OFPFC_ADD) {
1457         *flagsp |= OFPUTIL_FF_RESET_COUNTS;
1458     }
1459
1460     return raw_flags ? OFPERR_OFPFMFC_BAD_FLAGS : 0;
1461 }
1462
1463 static ovs_be16
1464 ofputil_encode_flow_mod_flags(enum ofputil_flow_mod_flags flags,
1465                               enum ofp_version version)
1466 {
1467     const struct ofputil_flow_mod_flag *f;
1468     uint16_t raw_flags;
1469
1470     raw_flags = 0;
1471     for (f = ofputil_flow_mod_flags; f->raw_flag; f++) {
1472         if (f->flag & flags
1473             && version >= f->min_version
1474             && (!f->max_version || version <= f->max_version)) {
1475             raw_flags |= f->raw_flag;
1476         }
1477     }
1478
1479     return htons(raw_flags);
1480 }
1481
1482 /* Converts an OFPT_FLOW_MOD or NXT_FLOW_MOD message 'oh' into an abstract
1483  * flow_mod in 'fm'.  Returns 0 if successful, otherwise an OpenFlow error
1484  * code.
1485  *
1486  * Uses 'ofpacts' to store the abstract OFPACT_* version of 'oh''s actions.
1487  * The caller must initialize 'ofpacts' and retains ownership of it.
1488  * 'fm->ofpacts' will point into the 'ofpacts' buffer.
1489  *
1490  * Does not validate the flow_mod actions.  The caller should do that, with
1491  * ofpacts_check(). */
1492 enum ofperr
1493 ofputil_decode_flow_mod(struct ofputil_flow_mod *fm,
1494                         const struct ofp_header *oh,
1495                         enum ofputil_protocol protocol,
1496                         struct ofpbuf *ofpacts,
1497                         ofp_port_t max_port, uint8_t max_table)
1498 {
1499     ovs_be16 raw_flags;
1500     enum ofperr error;
1501     struct ofpbuf b;
1502     enum ofpraw raw;
1503
1504     ofpbuf_use_const(&b, oh, ntohs(oh->length));
1505     raw = ofpraw_pull_assert(&b);
1506     if (raw == OFPRAW_OFPT11_FLOW_MOD) {
1507         /* Standard OpenFlow 1.1+ flow_mod. */
1508         const struct ofp11_flow_mod *ofm;
1509
1510         ofm = ofpbuf_pull(&b, sizeof *ofm);
1511
1512         error = ofputil_pull_ofp11_match(&b, &fm->match, NULL);
1513         if (error) {
1514             return error;
1515         }
1516
1517         error = ofpacts_pull_openflow_instructions(&b, b.size, oh->version,
1518                                                    ofpacts);
1519         if (error) {
1520             return error;
1521         }
1522
1523         /* Translate the message. */
1524         fm->priority = ntohs(ofm->priority);
1525         if (ofm->command == OFPFC_ADD
1526             || (oh->version == OFP11_VERSION
1527                 && (ofm->command == OFPFC_MODIFY ||
1528                     ofm->command == OFPFC_MODIFY_STRICT)
1529                 && ofm->cookie_mask == htonll(0))) {
1530             /* In OpenFlow 1.1 only, a "modify" or "modify-strict" that does
1531              * not match on the cookie is treated as an "add" if there is no
1532              * match. */
1533             fm->cookie = htonll(0);
1534             fm->cookie_mask = htonll(0);
1535             fm->new_cookie = ofm->cookie;
1536         } else {
1537             fm->cookie = ofm->cookie;
1538             fm->cookie_mask = ofm->cookie_mask;
1539             fm->new_cookie = OVS_BE64_MAX;
1540         }
1541         fm->modify_cookie = false;
1542         fm->command = ofm->command;
1543
1544         /* Get table ID.
1545          *
1546          * OF1.1 entirely forbids table_id == OFPTT_ALL.
1547          * OF1.2+ allows table_id == OFPTT_ALL only for deletes. */
1548         fm->table_id = ofm->table_id;
1549         if (fm->table_id == OFPTT_ALL
1550             && (oh->version == OFP11_VERSION
1551                 || (ofm->command != OFPFC_DELETE &&
1552                     ofm->command != OFPFC_DELETE_STRICT))) {
1553             return OFPERR_OFPFMFC_BAD_TABLE_ID;
1554         }
1555
1556         fm->idle_timeout = ntohs(ofm->idle_timeout);
1557         fm->hard_timeout = ntohs(ofm->hard_timeout);
1558         fm->buffer_id = ntohl(ofm->buffer_id);
1559         error = ofputil_port_from_ofp11(ofm->out_port, &fm->out_port);
1560         if (error) {
1561             return error;
1562         }
1563
1564         fm->out_group = (ofm->command == OFPFC_DELETE ||
1565                          ofm->command == OFPFC_DELETE_STRICT
1566                          ? ntohl(ofm->out_group)
1567                          : OFPG11_ANY);
1568         raw_flags = ofm->flags;
1569     } else {
1570         uint16_t command;
1571
1572         if (raw == OFPRAW_OFPT10_FLOW_MOD) {
1573             /* Standard OpenFlow 1.0 flow_mod. */
1574             const struct ofp10_flow_mod *ofm;
1575
1576             /* Get the ofp10_flow_mod. */
1577             ofm = ofpbuf_pull(&b, sizeof *ofm);
1578
1579             /* Translate the rule. */
1580             ofputil_match_from_ofp10_match(&ofm->match, &fm->match);
1581             ofputil_normalize_match(&fm->match);
1582
1583             /* Now get the actions. */
1584             error = ofpacts_pull_openflow_actions(&b, b.size, oh->version,
1585                                                   ofpacts);
1586             if (error) {
1587                 return error;
1588             }
1589
1590             /* OpenFlow 1.0 says that exact-match rules have to have the
1591              * highest possible priority. */
1592             fm->priority = (ofm->match.wildcards & htonl(OFPFW10_ALL)
1593                             ? ntohs(ofm->priority)
1594                             : UINT16_MAX);
1595
1596             /* Translate the message. */
1597             command = ntohs(ofm->command);
1598             fm->cookie = htonll(0);
1599             fm->cookie_mask = htonll(0);
1600             fm->new_cookie = ofm->cookie;
1601             fm->idle_timeout = ntohs(ofm->idle_timeout);
1602             fm->hard_timeout = ntohs(ofm->hard_timeout);
1603             fm->buffer_id = ntohl(ofm->buffer_id);
1604             fm->out_port = u16_to_ofp(ntohs(ofm->out_port));
1605             fm->out_group = OFPG11_ANY;
1606             raw_flags = ofm->flags;
1607         } else if (raw == OFPRAW_NXT_FLOW_MOD) {
1608             /* Nicira extended flow_mod. */
1609             const struct nx_flow_mod *nfm;
1610
1611             /* Dissect the message. */
1612             nfm = ofpbuf_pull(&b, sizeof *nfm);
1613             error = nx_pull_match(&b, ntohs(nfm->match_len),
1614                                   &fm->match, &fm->cookie, &fm->cookie_mask);
1615             if (error) {
1616                 return error;
1617             }
1618             error = ofpacts_pull_openflow_actions(&b, b.size, oh->version,
1619                                                   ofpacts);
1620             if (error) {
1621                 return error;
1622             }
1623
1624             /* Translate the message. */
1625             command = ntohs(nfm->command);
1626             if ((command & 0xff) == OFPFC_ADD && fm->cookie_mask) {
1627                 /* Flow additions may only set a new cookie, not match an
1628                  * existing cookie. */
1629                 return OFPERR_NXBRC_NXM_INVALID;
1630             }
1631             fm->priority = ntohs(nfm->priority);
1632             fm->new_cookie = nfm->cookie;
1633             fm->idle_timeout = ntohs(nfm->idle_timeout);
1634             fm->hard_timeout = ntohs(nfm->hard_timeout);
1635             fm->buffer_id = ntohl(nfm->buffer_id);
1636             fm->out_port = u16_to_ofp(ntohs(nfm->out_port));
1637             fm->out_group = OFPG11_ANY;
1638             raw_flags = nfm->flags;
1639         } else {
1640             OVS_NOT_REACHED();
1641         }
1642
1643         fm->modify_cookie = fm->new_cookie != OVS_BE64_MAX;
1644         if (protocol & OFPUTIL_P_TID) {
1645             fm->command = command & 0xff;
1646             fm->table_id = command >> 8;
1647         } else {
1648             fm->command = command;
1649             fm->table_id = 0xff;
1650         }
1651     }
1652
1653     fm->ofpacts = ofpacts->data;
1654     fm->ofpacts_len = ofpacts->size;
1655
1656     error = ofputil_decode_flow_mod_flags(raw_flags, fm->command,
1657                                           oh->version, &fm->flags);
1658     if (error) {
1659         return error;
1660     }
1661
1662     if (fm->flags & OFPUTIL_FF_EMERG) {
1663         /* We do not support the OpenFlow 1.0 emergency flow cache, which
1664          * is not required in OpenFlow 1.0.1 and removed from OpenFlow 1.1.
1665          *
1666          * OpenFlow 1.0 specifies the error code to use when idle_timeout
1667          * or hard_timeout is nonzero.  Otherwise, there is no good error
1668          * code, so just state that the flow table is full. */
1669         return (fm->hard_timeout || fm->idle_timeout
1670                 ? OFPERR_OFPFMFC_BAD_EMERG_TIMEOUT
1671                 : OFPERR_OFPFMFC_TABLE_FULL);
1672     }
1673
1674     return ofpacts_check_consistency(fm->ofpacts, fm->ofpacts_len,
1675                                      &fm->match.flow, max_port,
1676                                      fm->table_id, max_table, protocol);
1677 }
1678
1679 static enum ofperr
1680 ofputil_pull_bands(struct ofpbuf *msg, size_t len, uint16_t *n_bands,
1681                    struct ofpbuf *bands)
1682 {
1683     const struct ofp13_meter_band_header *ombh;
1684     struct ofputil_meter_band *mb;
1685     uint16_t n = 0;
1686
1687     ombh = ofpbuf_try_pull(msg, len);
1688     if (!ombh) {
1689         return OFPERR_OFPBRC_BAD_LEN;
1690     }
1691
1692     while (len >= sizeof (struct ofp13_meter_band_drop)) {
1693         size_t ombh_len = ntohs(ombh->len);
1694         /* All supported band types have the same length. */
1695         if (ombh_len != sizeof (struct ofp13_meter_band_drop)) {
1696             return OFPERR_OFPBRC_BAD_LEN;
1697         }
1698         mb = ofpbuf_put_uninit(bands, sizeof *mb);
1699         mb->type = ntohs(ombh->type);
1700         if (mb->type != OFPMBT13_DROP && mb->type != OFPMBT13_DSCP_REMARK) {
1701             return OFPERR_OFPMMFC_BAD_BAND;
1702         }
1703         mb->rate = ntohl(ombh->rate);
1704         mb->burst_size = ntohl(ombh->burst_size);
1705         mb->prec_level = (mb->type == OFPMBT13_DSCP_REMARK) ?
1706             ((struct ofp13_meter_band_dscp_remark *)ombh)->prec_level : 0;
1707         n++;
1708         len -= ombh_len;
1709         ombh = ALIGNED_CAST(struct ofp13_meter_band_header *,
1710                             (char *) ombh + ombh_len);
1711     }
1712     if (len) {
1713         return OFPERR_OFPBRC_BAD_LEN;
1714     }
1715     *n_bands = n;
1716     return 0;
1717 }
1718
1719 enum ofperr
1720 ofputil_decode_meter_mod(const struct ofp_header *oh,
1721                          struct ofputil_meter_mod *mm,
1722                          struct ofpbuf *bands)
1723 {
1724     const struct ofp13_meter_mod *omm;
1725     struct ofpbuf b;
1726
1727     ofpbuf_use_const(&b, oh, ntohs(oh->length));
1728     ofpraw_pull_assert(&b);
1729     omm = ofpbuf_pull(&b, sizeof *omm);
1730
1731     /* Translate the message. */
1732     mm->command = ntohs(omm->command);
1733     if (mm->command != OFPMC13_ADD &&
1734         mm->command != OFPMC13_MODIFY &&
1735         mm->command != OFPMC13_DELETE) {
1736         return OFPERR_OFPMMFC_BAD_COMMAND;
1737     }
1738     mm->meter.meter_id = ntohl(omm->meter_id);
1739
1740     if (mm->command == OFPMC13_DELETE) {
1741         mm->meter.flags = 0;
1742         mm->meter.n_bands = 0;
1743         mm->meter.bands = NULL;
1744     } else {
1745         enum ofperr error;
1746
1747         mm->meter.flags = ntohs(omm->flags);
1748         if (mm->meter.flags & OFPMF13_KBPS &&
1749             mm->meter.flags & OFPMF13_PKTPS) {
1750             return OFPERR_OFPMMFC_BAD_FLAGS;
1751         }
1752         mm->meter.bands = bands->data;
1753
1754         error = ofputil_pull_bands(&b, b.size, &mm->meter.n_bands, bands);
1755         if (error) {
1756             return error;
1757         }
1758     }
1759     return 0;
1760 }
1761
1762 void
1763 ofputil_decode_meter_request(const struct ofp_header *oh, uint32_t *meter_id)
1764 {
1765     const struct ofp13_meter_multipart_request *omr = ofpmsg_body(oh);
1766     *meter_id = ntohl(omr->meter_id);
1767 }
1768
1769 struct ofpbuf *
1770 ofputil_encode_meter_request(enum ofp_version ofp_version,
1771                              enum ofputil_meter_request_type type,
1772                              uint32_t meter_id)
1773 {
1774     struct ofpbuf *msg;
1775
1776     enum ofpraw raw;
1777
1778     switch (type) {
1779     case OFPUTIL_METER_CONFIG:
1780         raw = OFPRAW_OFPST13_METER_CONFIG_REQUEST;
1781         break;
1782     case OFPUTIL_METER_STATS:
1783         raw = OFPRAW_OFPST13_METER_REQUEST;
1784         break;
1785     default:
1786     case OFPUTIL_METER_FEATURES:
1787         raw = OFPRAW_OFPST13_METER_FEATURES_REQUEST;
1788         break;
1789     }
1790
1791     msg = ofpraw_alloc(raw, ofp_version, 0);
1792
1793     if (type != OFPUTIL_METER_FEATURES) {
1794         struct ofp13_meter_multipart_request *omr;
1795         omr = ofpbuf_put_zeros(msg, sizeof *omr);
1796         omr->meter_id = htonl(meter_id);
1797     }
1798     return msg;
1799 }
1800
1801 static void
1802 ofputil_put_bands(uint16_t n_bands, const struct ofputil_meter_band *mb,
1803                   struct ofpbuf *msg)
1804 {
1805     uint16_t n = 0;
1806
1807     for (n = 0; n < n_bands; ++n) {
1808         /* Currently all band types have same size. */
1809         struct ofp13_meter_band_dscp_remark *ombh;
1810         size_t ombh_len = sizeof *ombh;
1811
1812         ombh = ofpbuf_put_zeros(msg, ombh_len);
1813
1814         ombh->type = htons(mb->type);
1815         ombh->len = htons(ombh_len);
1816         ombh->rate = htonl(mb->rate);
1817         ombh->burst_size = htonl(mb->burst_size);
1818         ombh->prec_level = mb->prec_level;
1819
1820         mb++;
1821     }
1822 }
1823
1824 /* Encode a meter stat for 'mc' and append it to 'replies'. */
1825 void
1826 ofputil_append_meter_config(struct list *replies,
1827                             const struct ofputil_meter_config *mc)
1828 {
1829     struct ofpbuf *msg = ofpbuf_from_list(list_back(replies));
1830     size_t start_ofs = msg->size;
1831     struct ofp13_meter_config *reply = ofpbuf_put_uninit(msg, sizeof *reply);
1832     reply->flags = htons(mc->flags);
1833     reply->meter_id = htonl(mc->meter_id);
1834
1835     ofputil_put_bands(mc->n_bands, mc->bands, msg);
1836
1837     reply->length = htons(msg->size - start_ofs);
1838
1839     ofpmp_postappend(replies, start_ofs);
1840 }
1841
1842 /* Encode a meter stat for 'ms' and append it to 'replies'. */
1843 void
1844 ofputil_append_meter_stats(struct list *replies,
1845                            const struct ofputil_meter_stats *ms)
1846 {
1847     struct ofp13_meter_stats *reply;
1848     uint16_t n = 0;
1849     uint16_t len;
1850
1851     len = sizeof *reply + ms->n_bands * sizeof(struct ofp13_meter_band_stats);
1852     reply = ofpmp_append(replies, len);
1853
1854     reply->meter_id = htonl(ms->meter_id);
1855     reply->len = htons(len);
1856     memset(reply->pad, 0, sizeof reply->pad);
1857     reply->flow_count = htonl(ms->flow_count);
1858     reply->packet_in_count = htonll(ms->packet_in_count);
1859     reply->byte_in_count = htonll(ms->byte_in_count);
1860     reply->duration_sec = htonl(ms->duration_sec);
1861     reply->duration_nsec = htonl(ms->duration_nsec);
1862
1863     for (n = 0; n < ms->n_bands; ++n) {
1864         const struct ofputil_meter_band_stats *src = &ms->bands[n];
1865         struct ofp13_meter_band_stats *dst = &reply->band_stats[n];
1866
1867         dst->packet_band_count = htonll(src->packet_count);
1868         dst->byte_band_count = htonll(src->byte_count);
1869     }
1870 }
1871
1872 /* Converts an OFPMP_METER_CONFIG reply in 'msg' into an abstract
1873  * ofputil_meter_config in 'mc', with mc->bands pointing to bands decoded into
1874  * 'bands'.  The caller must have initialized 'bands' and retains ownership of
1875  * it across the call.
1876  *
1877  * Multiple OFPST13_METER_CONFIG replies can be packed into a single OpenFlow
1878  * message.  Calling this function multiple times for a single 'msg' iterates
1879  * through the replies.  'bands' is cleared for each reply.
1880  *
1881  * Returns 0 if successful, EOF if no replies were left in this 'msg',
1882  * otherwise a positive errno value. */
1883 int
1884 ofputil_decode_meter_config(struct ofpbuf *msg,
1885                             struct ofputil_meter_config *mc,
1886                             struct ofpbuf *bands)
1887 {
1888     const struct ofp13_meter_config *omc;
1889     enum ofperr err;
1890
1891     /* Pull OpenFlow headers for the first call. */
1892     if (!msg->l2) {
1893         ofpraw_pull_assert(msg);
1894     }
1895
1896     if (!msg->size) {
1897         return EOF;
1898     }
1899
1900     omc = ofpbuf_try_pull(msg, sizeof *omc);
1901     if (!omc) {
1902         VLOG_WARN_RL(&bad_ofmsg_rl,
1903                      "OFPMP_METER_CONFIG reply has %"PRIuSIZE" leftover bytes at end",
1904                      msg->size);
1905         return OFPERR_OFPBRC_BAD_LEN;
1906     }
1907
1908     ofpbuf_clear(bands);
1909     err = ofputil_pull_bands(msg, ntohs(omc->length) - sizeof *omc,
1910                              &mc->n_bands, bands);
1911     if (err) {
1912         return err;
1913     }
1914     mc->meter_id = ntohl(omc->meter_id);
1915     mc->flags = ntohs(omc->flags);
1916     mc->bands = bands->data;
1917
1918     return 0;
1919 }
1920
1921 static enum ofperr
1922 ofputil_pull_band_stats(struct ofpbuf *msg, size_t len, uint16_t *n_bands,
1923                         struct ofpbuf *bands)
1924 {
1925     const struct ofp13_meter_band_stats *ombs;
1926     struct ofputil_meter_band_stats *mbs;
1927     uint16_t n, i;
1928
1929     ombs = ofpbuf_try_pull(msg, len);
1930     if (!ombs) {
1931         return OFPERR_OFPBRC_BAD_LEN;
1932     }
1933
1934     n = len / sizeof *ombs;
1935     if (len != n * sizeof *ombs) {
1936         return OFPERR_OFPBRC_BAD_LEN;
1937     }
1938
1939     mbs = ofpbuf_put_uninit(bands, len);
1940
1941     for (i = 0; i < n; ++i) {
1942         mbs[i].packet_count = ntohll(ombs[i].packet_band_count);
1943         mbs[i].byte_count = ntohll(ombs[i].byte_band_count);
1944     }
1945     *n_bands = n;
1946     return 0;
1947 }
1948
1949 /* Converts an OFPMP_METER reply in 'msg' into an abstract
1950  * ofputil_meter_stats in 'ms', with ms->bands pointing to band stats
1951  * decoded into 'bands'.
1952  *
1953  * Multiple OFPMP_METER replies can be packed into a single OpenFlow
1954  * message.  Calling this function multiple times for a single 'msg' iterates
1955  * through the replies.  'bands' is cleared for each reply.
1956  *
1957  * Returns 0 if successful, EOF if no replies were left in this 'msg',
1958  * otherwise a positive errno value. */
1959 int
1960 ofputil_decode_meter_stats(struct ofpbuf *msg,
1961                            struct ofputil_meter_stats *ms,
1962                            struct ofpbuf *bands)
1963 {
1964     const struct ofp13_meter_stats *oms;
1965     enum ofperr err;
1966
1967     /* Pull OpenFlow headers for the first call. */
1968     if (!msg->l2) {
1969         ofpraw_pull_assert(msg);
1970     }
1971
1972     if (!msg->size) {
1973         return EOF;
1974     }
1975
1976     oms = ofpbuf_try_pull(msg, sizeof *oms);
1977     if (!oms) {
1978         VLOG_WARN_RL(&bad_ofmsg_rl,
1979                      "OFPMP_METER reply has %"PRIuSIZE" leftover bytes at end",
1980                      msg->size);
1981         return OFPERR_OFPBRC_BAD_LEN;
1982     }
1983
1984     ofpbuf_clear(bands);
1985     err = ofputil_pull_band_stats(msg, ntohs(oms->len) - sizeof *oms,
1986                                   &ms->n_bands, bands);
1987     if (err) {
1988         return err;
1989     }
1990     ms->meter_id = ntohl(oms->meter_id);
1991     ms->flow_count = ntohl(oms->flow_count);
1992     ms->packet_in_count = ntohll(oms->packet_in_count);
1993     ms->byte_in_count = ntohll(oms->byte_in_count);
1994     ms->duration_sec = ntohl(oms->duration_sec);
1995     ms->duration_nsec = ntohl(oms->duration_nsec);
1996     ms->bands = bands->data;
1997
1998     return 0;
1999 }
2000
2001 void
2002 ofputil_decode_meter_features(const struct ofp_header *oh,
2003                               struct ofputil_meter_features *mf)
2004 {
2005     const struct ofp13_meter_features *omf = ofpmsg_body(oh);
2006
2007     mf->max_meters = ntohl(omf->max_meter);
2008     mf->band_types = ntohl(omf->band_types);
2009     mf->capabilities = ntohl(omf->capabilities);
2010     mf->max_bands = omf->max_bands;
2011     mf->max_color = omf->max_color;
2012 }
2013
2014 struct ofpbuf *
2015 ofputil_encode_meter_features_reply(const struct ofputil_meter_features *mf,
2016                                     const struct ofp_header *request)
2017 {
2018     struct ofpbuf *reply;
2019     struct ofp13_meter_features *omf;
2020
2021     reply = ofpraw_alloc_stats_reply(request, 0);
2022     omf = ofpbuf_put_zeros(reply, sizeof *omf);
2023
2024     omf->max_meter = htonl(mf->max_meters);
2025     omf->band_types = htonl(mf->band_types);
2026     omf->capabilities = htonl(mf->capabilities);
2027     omf->max_bands = mf->max_bands;
2028     omf->max_color = mf->max_color;
2029
2030     return reply;
2031 }
2032
2033 struct ofpbuf *
2034 ofputil_encode_meter_mod(enum ofp_version ofp_version,
2035                          const struct ofputil_meter_mod *mm)
2036 {
2037     struct ofpbuf *msg;
2038
2039     struct ofp13_meter_mod *omm;
2040
2041     msg = ofpraw_alloc(OFPRAW_OFPT13_METER_MOD, ofp_version,
2042                        NXM_TYPICAL_LEN + mm->meter.n_bands * 16);
2043     omm = ofpbuf_put_zeros(msg, sizeof *omm);
2044     omm->command = htons(mm->command);
2045     if (mm->command != OFPMC13_DELETE) {
2046         omm->flags = htons(mm->meter.flags);
2047     }
2048     omm->meter_id = htonl(mm->meter.meter_id);
2049
2050     ofputil_put_bands(mm->meter.n_bands, mm->meter.bands, msg);
2051
2052     ofpmsg_update_length(msg);
2053     return msg;
2054 }
2055
2056 static ovs_be16
2057 ofputil_tid_command(const struct ofputil_flow_mod *fm,
2058                     enum ofputil_protocol protocol)
2059 {
2060     return htons(protocol & OFPUTIL_P_TID
2061                  ? (fm->command & 0xff) | (fm->table_id << 8)
2062                  : fm->command);
2063 }
2064
2065 /* Converts 'fm' into an OFPT_FLOW_MOD or NXT_FLOW_MOD message according to
2066  * 'protocol' and returns the message. */
2067 struct ofpbuf *
2068 ofputil_encode_flow_mod(const struct ofputil_flow_mod *fm,
2069                         enum ofputil_protocol protocol)
2070 {
2071     enum ofp_version version = ofputil_protocol_to_ofp_version(protocol);
2072     ovs_be16 raw_flags = ofputil_encode_flow_mod_flags(fm->flags, version);
2073     struct ofpbuf *msg;
2074
2075     switch (protocol) {
2076     case OFPUTIL_P_OF11_STD:
2077     case OFPUTIL_P_OF12_OXM:
2078     case OFPUTIL_P_OF13_OXM: {
2079         struct ofp11_flow_mod *ofm;
2080         int tailroom;
2081
2082         tailroom = ofputil_match_typical_len(protocol) + fm->ofpacts_len;
2083         msg = ofpraw_alloc(OFPRAW_OFPT11_FLOW_MOD, version, tailroom);
2084         ofm = ofpbuf_put_zeros(msg, sizeof *ofm);
2085         if ((protocol == OFPUTIL_P_OF11_STD
2086              && (fm->command == OFPFC_MODIFY ||
2087                  fm->command == OFPFC_MODIFY_STRICT)
2088              && fm->cookie_mask == htonll(0))
2089             || fm->command == OFPFC_ADD) {
2090             ofm->cookie = fm->new_cookie;
2091         } else {
2092             ofm->cookie = fm->cookie;
2093         }
2094         ofm->cookie_mask = fm->cookie_mask;
2095         if (fm->table_id != OFPTT_ALL
2096             || (protocol != OFPUTIL_P_OF11_STD
2097                 && (fm->command == OFPFC_DELETE ||
2098                     fm->command == OFPFC_DELETE_STRICT))) {
2099             ofm->table_id = fm->table_id;
2100         } else {
2101             ofm->table_id = 0;
2102         }
2103         ofm->command = fm->command;
2104         ofm->idle_timeout = htons(fm->idle_timeout);
2105         ofm->hard_timeout = htons(fm->hard_timeout);
2106         ofm->priority = htons(fm->priority);
2107         ofm->buffer_id = htonl(fm->buffer_id);
2108         ofm->out_port = ofputil_port_to_ofp11(fm->out_port);
2109         ofm->out_group = htonl(fm->out_group);
2110         ofm->flags = raw_flags;
2111         ofputil_put_ofp11_match(msg, &fm->match, protocol);
2112         ofpacts_put_openflow_instructions(fm->ofpacts, fm->ofpacts_len, msg,
2113                                           version);
2114         break;
2115     }
2116
2117     case OFPUTIL_P_OF10_STD:
2118     case OFPUTIL_P_OF10_STD_TID: {
2119         struct ofp10_flow_mod *ofm;
2120
2121         msg = ofpraw_alloc(OFPRAW_OFPT10_FLOW_MOD, OFP10_VERSION,
2122                            fm->ofpacts_len);
2123         ofm = ofpbuf_put_zeros(msg, sizeof *ofm);
2124         ofputil_match_to_ofp10_match(&fm->match, &ofm->match);
2125         ofm->cookie = fm->new_cookie;
2126         ofm->command = ofputil_tid_command(fm, protocol);
2127         ofm->idle_timeout = htons(fm->idle_timeout);
2128         ofm->hard_timeout = htons(fm->hard_timeout);
2129         ofm->priority = htons(fm->priority);
2130         ofm->buffer_id = htonl(fm->buffer_id);
2131         ofm->out_port = htons(ofp_to_u16(fm->out_port));
2132         ofm->flags = raw_flags;
2133         ofpacts_put_openflow_actions(fm->ofpacts, fm->ofpacts_len, msg,
2134                                      version);
2135         break;
2136     }
2137
2138     case OFPUTIL_P_OF10_NXM:
2139     case OFPUTIL_P_OF10_NXM_TID: {
2140         struct nx_flow_mod *nfm;
2141         int match_len;
2142
2143         msg = ofpraw_alloc(OFPRAW_NXT_FLOW_MOD, OFP10_VERSION,
2144                            NXM_TYPICAL_LEN + fm->ofpacts_len);
2145         nfm = ofpbuf_put_zeros(msg, sizeof *nfm);
2146         nfm->command = ofputil_tid_command(fm, protocol);
2147         nfm->cookie = fm->new_cookie;
2148         match_len = nx_put_match(msg, &fm->match, fm->cookie, fm->cookie_mask);
2149         nfm = msg->l3;
2150         nfm->idle_timeout = htons(fm->idle_timeout);
2151         nfm->hard_timeout = htons(fm->hard_timeout);
2152         nfm->priority = htons(fm->priority);
2153         nfm->buffer_id = htonl(fm->buffer_id);
2154         nfm->out_port = htons(ofp_to_u16(fm->out_port));
2155         nfm->flags = raw_flags;
2156         nfm->match_len = htons(match_len);
2157         ofpacts_put_openflow_actions(fm->ofpacts, fm->ofpacts_len, msg,
2158                                      version);
2159         break;
2160     }
2161
2162     default:
2163         OVS_NOT_REACHED();
2164     }
2165
2166     ofpmsg_update_length(msg);
2167     return msg;
2168 }
2169
2170 static enum ofperr
2171 ofputil_decode_ofpst10_flow_request(struct ofputil_flow_stats_request *fsr,
2172                                     const struct ofp10_flow_stats_request *ofsr,
2173                                     bool aggregate)
2174 {
2175     fsr->aggregate = aggregate;
2176     ofputil_match_from_ofp10_match(&ofsr->match, &fsr->match);
2177     fsr->out_port = u16_to_ofp(ntohs(ofsr->out_port));
2178     fsr->out_group = OFPG11_ANY;
2179     fsr->table_id = ofsr->table_id;
2180     fsr->cookie = fsr->cookie_mask = htonll(0);
2181
2182     return 0;
2183 }
2184
2185 static enum ofperr
2186 ofputil_decode_ofpst11_flow_request(struct ofputil_flow_stats_request *fsr,
2187                                     struct ofpbuf *b, bool aggregate)
2188 {
2189     const struct ofp11_flow_stats_request *ofsr;
2190     enum ofperr error;
2191
2192     ofsr = ofpbuf_pull(b, sizeof *ofsr);
2193     fsr->aggregate = aggregate;
2194     fsr->table_id = ofsr->table_id;
2195     error = ofputil_port_from_ofp11(ofsr->out_port, &fsr->out_port);
2196     if (error) {
2197         return error;
2198     }
2199     fsr->out_group = ntohl(ofsr->out_group);
2200     fsr->cookie = ofsr->cookie;
2201     fsr->cookie_mask = ofsr->cookie_mask;
2202     error = ofputil_pull_ofp11_match(b, &fsr->match, NULL);
2203     if (error) {
2204         return error;
2205     }
2206
2207     return 0;
2208 }
2209
2210 static enum ofperr
2211 ofputil_decode_nxst_flow_request(struct ofputil_flow_stats_request *fsr,
2212                                  struct ofpbuf *b, bool aggregate)
2213 {
2214     const struct nx_flow_stats_request *nfsr;
2215     enum ofperr error;
2216
2217     nfsr = ofpbuf_pull(b, sizeof *nfsr);
2218     error = nx_pull_match(b, ntohs(nfsr->match_len), &fsr->match,
2219                           &fsr->cookie, &fsr->cookie_mask);
2220     if (error) {
2221         return error;
2222     }
2223     if (b->size) {
2224         return OFPERR_OFPBRC_BAD_LEN;
2225     }
2226
2227     fsr->aggregate = aggregate;
2228     fsr->out_port = u16_to_ofp(ntohs(nfsr->out_port));
2229     fsr->out_group = OFPG11_ANY;
2230     fsr->table_id = nfsr->table_id;
2231
2232     return 0;
2233 }
2234
2235 /* Constructs and returns an OFPT_QUEUE_GET_CONFIG request for the specified
2236  * 'port', suitable for OpenFlow version 'version'. */
2237 struct ofpbuf *
2238 ofputil_encode_queue_get_config_request(enum ofp_version version,
2239                                         ofp_port_t port)
2240 {
2241     struct ofpbuf *request;
2242
2243     if (version == OFP10_VERSION) {
2244         struct ofp10_queue_get_config_request *qgcr10;
2245
2246         request = ofpraw_alloc(OFPRAW_OFPT10_QUEUE_GET_CONFIG_REQUEST,
2247                                version, 0);
2248         qgcr10 = ofpbuf_put_zeros(request, sizeof *qgcr10);
2249         qgcr10->port = htons(ofp_to_u16(port));
2250     } else {
2251         struct ofp11_queue_get_config_request *qgcr11;
2252
2253         request = ofpraw_alloc(OFPRAW_OFPT11_QUEUE_GET_CONFIG_REQUEST,
2254                                version, 0);
2255         qgcr11 = ofpbuf_put_zeros(request, sizeof *qgcr11);
2256         qgcr11->port = ofputil_port_to_ofp11(port);
2257     }
2258
2259     return request;
2260 }
2261
2262 /* Parses OFPT_QUEUE_GET_CONFIG request 'oh', storing the port specified by the
2263  * request into '*port'.  Returns 0 if successful, otherwise an OpenFlow error
2264  * code. */
2265 enum ofperr
2266 ofputil_decode_queue_get_config_request(const struct ofp_header *oh,
2267                                         ofp_port_t *port)
2268 {
2269     const struct ofp10_queue_get_config_request *qgcr10;
2270     const struct ofp11_queue_get_config_request *qgcr11;
2271     enum ofpraw raw;
2272     struct ofpbuf b;
2273
2274     ofpbuf_use_const(&b, oh, ntohs(oh->length));
2275     raw = ofpraw_pull_assert(&b);
2276
2277     switch ((int) raw) {
2278     case OFPRAW_OFPT10_QUEUE_GET_CONFIG_REQUEST:
2279         qgcr10 = b.data;
2280         *port = u16_to_ofp(ntohs(qgcr10->port));
2281         return 0;
2282
2283     case OFPRAW_OFPT11_QUEUE_GET_CONFIG_REQUEST:
2284         qgcr11 = b.data;
2285         return ofputil_port_from_ofp11(qgcr11->port, port);
2286     }
2287
2288     OVS_NOT_REACHED();
2289 }
2290
2291 /* Constructs and returns the beginning of a reply to
2292  * OFPT_QUEUE_GET_CONFIG_REQUEST 'oh'.  The caller may append information about
2293  * individual queues with ofputil_append_queue_get_config_reply(). */
2294 struct ofpbuf *
2295 ofputil_encode_queue_get_config_reply(const struct ofp_header *oh)
2296 {
2297     struct ofp10_queue_get_config_reply *qgcr10;
2298     struct ofp11_queue_get_config_reply *qgcr11;
2299     struct ofpbuf *reply;
2300     enum ofperr error;
2301     struct ofpbuf b;
2302     enum ofpraw raw;
2303     ofp_port_t port;
2304
2305     error = ofputil_decode_queue_get_config_request(oh, &port);
2306     ovs_assert(!error);
2307
2308     ofpbuf_use_const(&b, oh, ntohs(oh->length));
2309     raw = ofpraw_pull_assert(&b);
2310
2311     switch ((int) raw) {
2312     case OFPRAW_OFPT10_QUEUE_GET_CONFIG_REQUEST:
2313         reply = ofpraw_alloc_reply(OFPRAW_OFPT10_QUEUE_GET_CONFIG_REPLY,
2314                                    oh, 0);
2315         qgcr10 = ofpbuf_put_zeros(reply, sizeof *qgcr10);
2316         qgcr10->port = htons(ofp_to_u16(port));
2317         break;
2318
2319     case OFPRAW_OFPT11_QUEUE_GET_CONFIG_REQUEST:
2320         reply = ofpraw_alloc_reply(OFPRAW_OFPT11_QUEUE_GET_CONFIG_REPLY,
2321                                    oh, 0);
2322         qgcr11 = ofpbuf_put_zeros(reply, sizeof *qgcr11);
2323         qgcr11->port = ofputil_port_to_ofp11(port);
2324         break;
2325
2326     default:
2327         OVS_NOT_REACHED();
2328     }
2329
2330     return reply;
2331 }
2332
2333 static void
2334 put_queue_rate(struct ofpbuf *reply, enum ofp_queue_properties property,
2335                uint16_t rate)
2336 {
2337     if (rate != UINT16_MAX) {
2338         struct ofp_queue_prop_rate *oqpr;
2339
2340         oqpr = ofpbuf_put_zeros(reply, sizeof *oqpr);
2341         oqpr->prop_header.property = htons(property);
2342         oqpr->prop_header.len = htons(sizeof *oqpr);
2343         oqpr->rate = htons(rate);
2344     }
2345 }
2346
2347 /* Appends a queue description for 'queue_id' to the
2348  * OFPT_QUEUE_GET_CONFIG_REPLY already in 'oh'. */
2349 void
2350 ofputil_append_queue_get_config_reply(struct ofpbuf *reply,
2351                                       const struct ofputil_queue_config *oqc)
2352 {
2353     const struct ofp_header *oh = reply->data;
2354     size_t start_ofs, len_ofs;
2355     ovs_be16 *len;
2356
2357     start_ofs = reply->size;
2358     if (oh->version < OFP12_VERSION) {
2359         struct ofp10_packet_queue *opq10;
2360
2361         opq10 = ofpbuf_put_zeros(reply, sizeof *opq10);
2362         opq10->queue_id = htonl(oqc->queue_id);
2363         len_ofs = (char *) &opq10->len - (char *) reply->data;
2364     } else {
2365         struct ofp11_queue_get_config_reply *qgcr11;
2366         struct ofp12_packet_queue *opq12;
2367         ovs_be32 port;
2368
2369         qgcr11 = reply->l3;
2370         port = qgcr11->port;
2371
2372         opq12 = ofpbuf_put_zeros(reply, sizeof *opq12);
2373         opq12->port = port;
2374         opq12->queue_id = htonl(oqc->queue_id);
2375         len_ofs = (char *) &opq12->len - (char *) reply->data;
2376     }
2377
2378     put_queue_rate(reply, OFPQT_MIN_RATE, oqc->min_rate);
2379     put_queue_rate(reply, OFPQT_MAX_RATE, oqc->max_rate);
2380
2381     len = ofpbuf_at(reply, len_ofs, sizeof *len);
2382     *len = htons(reply->size - start_ofs);
2383 }
2384
2385 /* Decodes the initial part of an OFPT_QUEUE_GET_CONFIG_REPLY from 'reply' and
2386  * stores in '*port' the port that the reply is about.  The caller may call
2387  * ofputil_pull_queue_get_config_reply() to obtain information about individual
2388  * queues included in the reply.  Returns 0 if successful, otherwise an
2389  * ofperr.*/
2390 enum ofperr
2391 ofputil_decode_queue_get_config_reply(struct ofpbuf *reply, ofp_port_t *port)
2392 {
2393     const struct ofp10_queue_get_config_reply *qgcr10;
2394     const struct ofp11_queue_get_config_reply *qgcr11;
2395     enum ofpraw raw;
2396
2397     raw = ofpraw_pull_assert(reply);
2398     switch ((int) raw) {
2399     case OFPRAW_OFPT10_QUEUE_GET_CONFIG_REPLY:
2400         qgcr10 = ofpbuf_pull(reply, sizeof *qgcr10);
2401         *port = u16_to_ofp(ntohs(qgcr10->port));
2402         return 0;
2403
2404     case OFPRAW_OFPT11_QUEUE_GET_CONFIG_REPLY:
2405         qgcr11 = ofpbuf_pull(reply, sizeof *qgcr11);
2406         return ofputil_port_from_ofp11(qgcr11->port, port);
2407     }
2408
2409     OVS_NOT_REACHED();
2410 }
2411
2412 static enum ofperr
2413 parse_queue_rate(const struct ofp_queue_prop_header *hdr, uint16_t *rate)
2414 {
2415     const struct ofp_queue_prop_rate *oqpr;
2416
2417     if (hdr->len == htons(sizeof *oqpr)) {
2418         oqpr = (const struct ofp_queue_prop_rate *) hdr;
2419         *rate = ntohs(oqpr->rate);
2420         return 0;
2421     } else {
2422         return OFPERR_OFPBRC_BAD_LEN;
2423     }
2424 }
2425
2426 /* Decodes information about a queue from the OFPT_QUEUE_GET_CONFIG_REPLY in
2427  * 'reply' and stores it in '*queue'.  ofputil_decode_queue_get_config_reply()
2428  * must already have pulled off the main header.
2429  *
2430  * This function returns EOF if the last queue has already been decoded, 0 if a
2431  * queue was successfully decoded into '*queue', or an ofperr if there was a
2432  * problem decoding 'reply'. */
2433 int
2434 ofputil_pull_queue_get_config_reply(struct ofpbuf *reply,
2435                                     struct ofputil_queue_config *queue)
2436 {
2437     const struct ofp_header *oh;
2438     unsigned int opq_len;
2439     unsigned int len;
2440
2441     if (!reply->size) {
2442         return EOF;
2443     }
2444
2445     queue->min_rate = UINT16_MAX;
2446     queue->max_rate = UINT16_MAX;
2447
2448     oh = reply->l2;
2449     if (oh->version < OFP12_VERSION) {
2450         const struct ofp10_packet_queue *opq10;
2451
2452         opq10 = ofpbuf_try_pull(reply, sizeof *opq10);
2453         if (!opq10) {
2454             return OFPERR_OFPBRC_BAD_LEN;
2455         }
2456         queue->queue_id = ntohl(opq10->queue_id);
2457         len = ntohs(opq10->len);
2458         opq_len = sizeof *opq10;
2459     } else {
2460         const struct ofp12_packet_queue *opq12;
2461
2462         opq12 = ofpbuf_try_pull(reply, sizeof *opq12);
2463         if (!opq12) {
2464             return OFPERR_OFPBRC_BAD_LEN;
2465         }
2466         queue->queue_id = ntohl(opq12->queue_id);
2467         len = ntohs(opq12->len);
2468         opq_len = sizeof *opq12;
2469     }
2470
2471     if (len < opq_len || len > reply->size + opq_len || len % 8) {
2472         return OFPERR_OFPBRC_BAD_LEN;
2473     }
2474     len -= opq_len;
2475
2476     while (len > 0) {
2477         const struct ofp_queue_prop_header *hdr;
2478         unsigned int property;
2479         unsigned int prop_len;
2480         enum ofperr error = 0;
2481
2482         hdr = ofpbuf_at_assert(reply, 0, sizeof *hdr);
2483         prop_len = ntohs(hdr->len);
2484         if (prop_len < sizeof *hdr || prop_len > reply->size || prop_len % 8) {
2485             return OFPERR_OFPBRC_BAD_LEN;
2486         }
2487
2488         property = ntohs(hdr->property);
2489         switch (property) {
2490         case OFPQT_MIN_RATE:
2491             error = parse_queue_rate(hdr, &queue->min_rate);
2492             break;
2493
2494         case OFPQT_MAX_RATE:
2495             error = parse_queue_rate(hdr, &queue->max_rate);
2496             break;
2497
2498         default:
2499             VLOG_INFO_RL(&bad_ofmsg_rl, "unknown queue property %u", property);
2500             break;
2501         }
2502         if (error) {
2503             return error;
2504         }
2505
2506         ofpbuf_pull(reply, prop_len);
2507         len -= prop_len;
2508     }
2509     return 0;
2510 }
2511
2512 /* Converts an OFPST_FLOW, OFPST_AGGREGATE, NXST_FLOW, or NXST_AGGREGATE
2513  * request 'oh', into an abstract flow_stats_request in 'fsr'.  Returns 0 if
2514  * successful, otherwise an OpenFlow error code. */
2515 enum ofperr
2516 ofputil_decode_flow_stats_request(struct ofputil_flow_stats_request *fsr,
2517                                   const struct ofp_header *oh)
2518 {
2519     enum ofpraw raw;
2520     struct ofpbuf b;
2521
2522     ofpbuf_use_const(&b, oh, ntohs(oh->length));
2523     raw = ofpraw_pull_assert(&b);
2524     switch ((int) raw) {
2525     case OFPRAW_OFPST10_FLOW_REQUEST:
2526         return ofputil_decode_ofpst10_flow_request(fsr, b.data, false);
2527
2528     case OFPRAW_OFPST10_AGGREGATE_REQUEST:
2529         return ofputil_decode_ofpst10_flow_request(fsr, b.data, true);
2530
2531     case OFPRAW_OFPST11_FLOW_REQUEST:
2532         return ofputil_decode_ofpst11_flow_request(fsr, &b, false);
2533
2534     case OFPRAW_OFPST11_AGGREGATE_REQUEST:
2535         return ofputil_decode_ofpst11_flow_request(fsr, &b, true);
2536
2537     case OFPRAW_NXST_FLOW_REQUEST:
2538         return ofputil_decode_nxst_flow_request(fsr, &b, false);
2539
2540     case OFPRAW_NXST_AGGREGATE_REQUEST:
2541         return ofputil_decode_nxst_flow_request(fsr, &b, true);
2542
2543     default:
2544         /* Hey, the caller lied. */
2545         OVS_NOT_REACHED();
2546     }
2547 }
2548
2549 /* Converts abstract flow_stats_request 'fsr' into an OFPST_FLOW,
2550  * OFPST_AGGREGATE, NXST_FLOW, or NXST_AGGREGATE request 'oh' according to
2551  * 'protocol', and returns the message. */
2552 struct ofpbuf *
2553 ofputil_encode_flow_stats_request(const struct ofputil_flow_stats_request *fsr,
2554                                   enum ofputil_protocol protocol)
2555 {
2556     struct ofpbuf *msg;
2557     enum ofpraw raw;
2558
2559     switch (protocol) {
2560     case OFPUTIL_P_OF11_STD:
2561     case OFPUTIL_P_OF12_OXM:
2562     case OFPUTIL_P_OF13_OXM: {
2563         struct ofp11_flow_stats_request *ofsr;
2564
2565         raw = (fsr->aggregate
2566                ? OFPRAW_OFPST11_AGGREGATE_REQUEST
2567                : OFPRAW_OFPST11_FLOW_REQUEST);
2568         msg = ofpraw_alloc(raw, ofputil_protocol_to_ofp_version(protocol),
2569                            ofputil_match_typical_len(protocol));
2570         ofsr = ofpbuf_put_zeros(msg, sizeof *ofsr);
2571         ofsr->table_id = fsr->table_id;
2572         ofsr->out_port = ofputil_port_to_ofp11(fsr->out_port);
2573         ofsr->out_group = htonl(fsr->out_group);
2574         ofsr->cookie = fsr->cookie;
2575         ofsr->cookie_mask = fsr->cookie_mask;
2576         ofputil_put_ofp11_match(msg, &fsr->match, protocol);
2577         break;
2578     }
2579
2580     case OFPUTIL_P_OF10_STD:
2581     case OFPUTIL_P_OF10_STD_TID: {
2582         struct ofp10_flow_stats_request *ofsr;
2583
2584         raw = (fsr->aggregate
2585                ? OFPRAW_OFPST10_AGGREGATE_REQUEST
2586                : OFPRAW_OFPST10_FLOW_REQUEST);
2587         msg = ofpraw_alloc(raw, OFP10_VERSION, 0);
2588         ofsr = ofpbuf_put_zeros(msg, sizeof *ofsr);
2589         ofputil_match_to_ofp10_match(&fsr->match, &ofsr->match);
2590         ofsr->table_id = fsr->table_id;
2591         ofsr->out_port = htons(ofp_to_u16(fsr->out_port));
2592         break;
2593     }
2594
2595     case OFPUTIL_P_OF10_NXM:
2596     case OFPUTIL_P_OF10_NXM_TID: {
2597         struct nx_flow_stats_request *nfsr;
2598         int match_len;
2599
2600         raw = (fsr->aggregate
2601                ? OFPRAW_NXST_AGGREGATE_REQUEST
2602                : OFPRAW_NXST_FLOW_REQUEST);
2603         msg = ofpraw_alloc(raw, OFP10_VERSION, NXM_TYPICAL_LEN);
2604         ofpbuf_put_zeros(msg, sizeof *nfsr);
2605         match_len = nx_put_match(msg, &fsr->match,
2606                                  fsr->cookie, fsr->cookie_mask);
2607
2608         nfsr = msg->l3;
2609         nfsr->out_port = htons(ofp_to_u16(fsr->out_port));
2610         nfsr->match_len = htons(match_len);
2611         nfsr->table_id = fsr->table_id;
2612         break;
2613     }
2614
2615     default:
2616         OVS_NOT_REACHED();
2617     }
2618
2619     return msg;
2620 }
2621
2622 /* Converts an OFPST_FLOW or NXST_FLOW reply in 'msg' into an abstract
2623  * ofputil_flow_stats in 'fs'.
2624  *
2625  * Multiple OFPST_FLOW or NXST_FLOW replies can be packed into a single
2626  * OpenFlow message.  Calling this function multiple times for a single 'msg'
2627  * iterates through the replies.  The caller must initially leave 'msg''s layer
2628  * pointers null and not modify them between calls.
2629  *
2630  * Most switches don't send the values needed to populate fs->idle_age and
2631  * fs->hard_age, so those members will usually be set to 0.  If the switch from
2632  * which 'msg' originated is known to implement NXT_FLOW_AGE, then pass
2633  * 'flow_age_extension' as true so that the contents of 'msg' determine the
2634  * 'idle_age' and 'hard_age' members in 'fs'.
2635  *
2636  * Uses 'ofpacts' to store the abstract OFPACT_* version of the flow stats
2637  * reply's actions.  The caller must initialize 'ofpacts' and retains ownership
2638  * of it.  'fs->ofpacts' will point into the 'ofpacts' buffer.
2639  *
2640  * Returns 0 if successful, EOF if no replies were left in this 'msg',
2641  * otherwise a positive errno value. */
2642 int
2643 ofputil_decode_flow_stats_reply(struct ofputil_flow_stats *fs,
2644                                 struct ofpbuf *msg,
2645                                 bool flow_age_extension,
2646                                 struct ofpbuf *ofpacts)
2647 {
2648     const struct ofp_header *oh;
2649     enum ofperr error;
2650     enum ofpraw raw;
2651
2652     error = (msg->l2
2653              ? ofpraw_decode(&raw, msg->l2)
2654              : ofpraw_pull(&raw, msg));
2655     if (error) {
2656         return error;
2657     }
2658     oh = msg->l2;
2659
2660     if (!msg->size) {
2661         return EOF;
2662     } else if (raw == OFPRAW_OFPST11_FLOW_REPLY
2663                || raw == OFPRAW_OFPST13_FLOW_REPLY) {
2664         const struct ofp11_flow_stats *ofs;
2665         size_t length;
2666         uint16_t padded_match_len;
2667
2668         ofs = ofpbuf_try_pull(msg, sizeof *ofs);
2669         if (!ofs) {
2670             VLOG_WARN_RL(&bad_ofmsg_rl, "OFPST_FLOW reply has %"PRIuSIZE" leftover "
2671                          "bytes at end", msg->size);
2672             return EINVAL;
2673         }
2674
2675         length = ntohs(ofs->length);
2676         if (length < sizeof *ofs) {
2677             VLOG_WARN_RL(&bad_ofmsg_rl, "OFPST_FLOW reply claims invalid "
2678                          "length %"PRIuSIZE, length);
2679             return EINVAL;
2680         }
2681
2682         if (ofputil_pull_ofp11_match(msg, &fs->match, &padded_match_len)) {
2683             VLOG_WARN_RL(&bad_ofmsg_rl, "OFPST_FLOW reply bad match");
2684             return EINVAL;
2685         }
2686
2687         if (ofpacts_pull_openflow_instructions(msg, length - sizeof *ofs -
2688                                                padded_match_len, oh->version,
2689                                                ofpacts)) {
2690             VLOG_WARN_RL(&bad_ofmsg_rl, "OFPST_FLOW reply bad instructions");
2691             return EINVAL;
2692         }
2693
2694         fs->priority = ntohs(ofs->priority);
2695         fs->table_id = ofs->table_id;
2696         fs->duration_sec = ntohl(ofs->duration_sec);
2697         fs->duration_nsec = ntohl(ofs->duration_nsec);
2698         fs->idle_timeout = ntohs(ofs->idle_timeout);
2699         fs->hard_timeout = ntohs(ofs->hard_timeout);
2700         if (raw == OFPRAW_OFPST13_FLOW_REPLY) {
2701             error = ofputil_decode_flow_mod_flags(ofs->flags, -1, oh->version,
2702                                                   &fs->flags);
2703             if (error) {
2704                 return error;
2705             }
2706         } else {
2707             fs->flags = 0;
2708         }
2709         fs->idle_age = -1;
2710         fs->hard_age = -1;
2711         fs->cookie = ofs->cookie;
2712         fs->packet_count = ntohll(ofs->packet_count);
2713         fs->byte_count = ntohll(ofs->byte_count);
2714     } else if (raw == OFPRAW_OFPST10_FLOW_REPLY) {
2715         const struct ofp10_flow_stats *ofs;
2716         size_t length;
2717
2718         ofs = ofpbuf_try_pull(msg, sizeof *ofs);
2719         if (!ofs) {
2720             VLOG_WARN_RL(&bad_ofmsg_rl, "OFPST_FLOW reply has %"PRIuSIZE" leftover "
2721                          "bytes at end", msg->size);
2722             return EINVAL;
2723         }
2724
2725         length = ntohs(ofs->length);
2726         if (length < sizeof *ofs) {
2727             VLOG_WARN_RL(&bad_ofmsg_rl, "OFPST_FLOW reply claims invalid "
2728                          "length %"PRIuSIZE, length);
2729             return EINVAL;
2730         }
2731
2732         if (ofpacts_pull_openflow_actions(msg, length - sizeof *ofs,
2733                                           oh->version, ofpacts)) {
2734             return EINVAL;
2735         }
2736
2737         fs->cookie = get_32aligned_be64(&ofs->cookie);
2738         ofputil_match_from_ofp10_match(&ofs->match, &fs->match);
2739         fs->priority = ntohs(ofs->priority);
2740         fs->table_id = ofs->table_id;
2741         fs->duration_sec = ntohl(ofs->duration_sec);
2742         fs->duration_nsec = ntohl(ofs->duration_nsec);
2743         fs->idle_timeout = ntohs(ofs->idle_timeout);
2744         fs->hard_timeout = ntohs(ofs->hard_timeout);
2745         fs->idle_age = -1;
2746         fs->hard_age = -1;
2747         fs->packet_count = ntohll(get_32aligned_be64(&ofs->packet_count));
2748         fs->byte_count = ntohll(get_32aligned_be64(&ofs->byte_count));
2749         fs->flags = 0;
2750     } else if (raw == OFPRAW_NXST_FLOW_REPLY) {
2751         const struct nx_flow_stats *nfs;
2752         size_t match_len, actions_len, length;
2753
2754         nfs = ofpbuf_try_pull(msg, sizeof *nfs);
2755         if (!nfs) {
2756             VLOG_WARN_RL(&bad_ofmsg_rl, "NXST_FLOW reply has %"PRIuSIZE" leftover "
2757                          "bytes at end", msg->size);
2758             return EINVAL;
2759         }
2760
2761         length = ntohs(nfs->length);
2762         match_len = ntohs(nfs->match_len);
2763         if (length < sizeof *nfs + ROUND_UP(match_len, 8)) {
2764             VLOG_WARN_RL(&bad_ofmsg_rl, "NXST_FLOW reply with match_len=%"PRIuSIZE" "
2765                          "claims invalid length %"PRIuSIZE, match_len, length);
2766             return EINVAL;
2767         }
2768         if (nx_pull_match(msg, match_len, &fs->match, NULL, NULL)) {
2769             return EINVAL;
2770         }
2771
2772         actions_len = length - sizeof *nfs - ROUND_UP(match_len, 8);
2773         if (ofpacts_pull_openflow_actions(msg, actions_len, oh->version,
2774                                           ofpacts)) {
2775             return EINVAL;
2776         }
2777
2778         fs->cookie = nfs->cookie;
2779         fs->table_id = nfs->table_id;
2780         fs->duration_sec = ntohl(nfs->duration_sec);
2781         fs->duration_nsec = ntohl(nfs->duration_nsec);
2782         fs->priority = ntohs(nfs->priority);
2783         fs->idle_timeout = ntohs(nfs->idle_timeout);
2784         fs->hard_timeout = ntohs(nfs->hard_timeout);
2785         fs->idle_age = -1;
2786         fs->hard_age = -1;
2787         if (flow_age_extension) {
2788             if (nfs->idle_age) {
2789                 fs->idle_age = ntohs(nfs->idle_age) - 1;
2790             }
2791             if (nfs->hard_age) {
2792                 fs->hard_age = ntohs(nfs->hard_age) - 1;
2793             }
2794         }
2795         fs->packet_count = ntohll(nfs->packet_count);
2796         fs->byte_count = ntohll(nfs->byte_count);
2797         fs->flags = 0;
2798     } else {
2799         OVS_NOT_REACHED();
2800     }
2801
2802     fs->ofpacts = ofpacts->data;
2803     fs->ofpacts_len = ofpacts->size;
2804
2805     return 0;
2806 }
2807
2808 /* Returns 'count' unchanged except that UINT64_MAX becomes 0.
2809  *
2810  * We use this in situations where OVS internally uses UINT64_MAX to mean
2811  * "value unknown" but OpenFlow 1.0 does not define any unknown value. */
2812 static uint64_t
2813 unknown_to_zero(uint64_t count)
2814 {
2815     return count != UINT64_MAX ? count : 0;
2816 }
2817
2818 /* Appends an OFPST_FLOW or NXST_FLOW reply that contains the data in 'fs' to
2819  * those already present in the list of ofpbufs in 'replies'.  'replies' should
2820  * have been initialized with ofpmp_init(). */
2821 void
2822 ofputil_append_flow_stats_reply(const struct ofputil_flow_stats *fs,
2823                                 struct list *replies)
2824 {
2825     struct ofpbuf *reply = ofpbuf_from_list(list_back(replies));
2826     size_t start_ofs = reply->size;
2827     enum ofpraw raw;
2828     enum ofp_version version = ((struct ofp_header *)reply->data)->version;
2829
2830     ofpraw_decode_partial(&raw, reply->data, reply->size);
2831     if (raw == OFPRAW_OFPST11_FLOW_REPLY || raw == OFPRAW_OFPST13_FLOW_REPLY) {
2832         struct ofp11_flow_stats *ofs;
2833
2834         ofpbuf_put_uninit(reply, sizeof *ofs);
2835         oxm_put_match(reply, &fs->match);
2836         ofpacts_put_openflow_instructions(fs->ofpacts, fs->ofpacts_len, reply,
2837                                           version);
2838
2839         ofs = ofpbuf_at_assert(reply, start_ofs, sizeof *ofs);
2840         ofs->length = htons(reply->size - start_ofs);
2841         ofs->table_id = fs->table_id;
2842         ofs->pad = 0;
2843         ofs->duration_sec = htonl(fs->duration_sec);
2844         ofs->duration_nsec = htonl(fs->duration_nsec);
2845         ofs->priority = htons(fs->priority);
2846         ofs->idle_timeout = htons(fs->idle_timeout);
2847         ofs->hard_timeout = htons(fs->hard_timeout);
2848         if (raw == OFPRAW_OFPST13_FLOW_REPLY) {
2849             ofs->flags = ofputil_encode_flow_mod_flags(fs->flags, version);
2850         } else {
2851             ofs->flags = 0;
2852         }
2853         memset(ofs->pad2, 0, sizeof ofs->pad2);
2854         ofs->cookie = fs->cookie;
2855         ofs->packet_count = htonll(unknown_to_zero(fs->packet_count));
2856         ofs->byte_count = htonll(unknown_to_zero(fs->byte_count));
2857     } else if (raw == OFPRAW_OFPST10_FLOW_REPLY) {
2858         struct ofp10_flow_stats *ofs;
2859
2860         ofpbuf_put_uninit(reply, sizeof *ofs);
2861         ofpacts_put_openflow_actions(fs->ofpacts, fs->ofpacts_len, reply,
2862                                      version);
2863         ofs = ofpbuf_at_assert(reply, start_ofs, sizeof *ofs);
2864         ofs->length = htons(reply->size - start_ofs);
2865         ofs->table_id = fs->table_id;
2866         ofs->pad = 0;
2867         ofputil_match_to_ofp10_match(&fs->match, &ofs->match);
2868         ofs->duration_sec = htonl(fs->duration_sec);
2869         ofs->duration_nsec = htonl(fs->duration_nsec);
2870         ofs->priority = htons(fs->priority);
2871         ofs->idle_timeout = htons(fs->idle_timeout);
2872         ofs->hard_timeout = htons(fs->hard_timeout);
2873         memset(ofs->pad2, 0, sizeof ofs->pad2);
2874         put_32aligned_be64(&ofs->cookie, fs->cookie);
2875         put_32aligned_be64(&ofs->packet_count,
2876                            htonll(unknown_to_zero(fs->packet_count)));
2877         put_32aligned_be64(&ofs->byte_count,
2878                            htonll(unknown_to_zero(fs->byte_count)));
2879     } else if (raw == OFPRAW_NXST_FLOW_REPLY) {
2880         struct nx_flow_stats *nfs;
2881         int match_len;
2882
2883         ofpbuf_put_uninit(reply, sizeof *nfs);
2884         match_len = nx_put_match(reply, &fs->match, 0, 0);
2885         ofpacts_put_openflow_actions(fs->ofpacts, fs->ofpacts_len, reply,
2886                                      version);
2887         nfs = ofpbuf_at_assert(reply, start_ofs, sizeof *nfs);
2888         nfs->length = htons(reply->size - start_ofs);
2889         nfs->table_id = fs->table_id;
2890         nfs->pad = 0;
2891         nfs->duration_sec = htonl(fs->duration_sec);
2892         nfs->duration_nsec = htonl(fs->duration_nsec);
2893         nfs->priority = htons(fs->priority);
2894         nfs->idle_timeout = htons(fs->idle_timeout);
2895         nfs->hard_timeout = htons(fs->hard_timeout);
2896         nfs->idle_age = htons(fs->idle_age < 0 ? 0
2897                               : fs->idle_age < UINT16_MAX ? fs->idle_age + 1
2898                               : UINT16_MAX);
2899         nfs->hard_age = htons(fs->hard_age < 0 ? 0
2900                               : fs->hard_age < UINT16_MAX ? fs->hard_age + 1
2901                               : UINT16_MAX);
2902         nfs->match_len = htons(match_len);
2903         nfs->cookie = fs->cookie;
2904         nfs->packet_count = htonll(fs->packet_count);
2905         nfs->byte_count = htonll(fs->byte_count);
2906     } else {
2907         OVS_NOT_REACHED();
2908     }
2909
2910     ofpmp_postappend(replies, start_ofs);
2911 }
2912
2913 /* Converts abstract ofputil_aggregate_stats 'stats' into an OFPST_AGGREGATE or
2914  * NXST_AGGREGATE reply matching 'request', and returns the message. */
2915 struct ofpbuf *
2916 ofputil_encode_aggregate_stats_reply(
2917     const struct ofputil_aggregate_stats *stats,
2918     const struct ofp_header *request)
2919 {
2920     struct ofp_aggregate_stats_reply *asr;
2921     uint64_t packet_count;
2922     uint64_t byte_count;
2923     struct ofpbuf *msg;
2924     enum ofpraw raw;
2925
2926     ofpraw_decode(&raw, request);
2927     if (raw == OFPRAW_OFPST10_AGGREGATE_REQUEST) {
2928         packet_count = unknown_to_zero(stats->packet_count);
2929         byte_count = unknown_to_zero(stats->byte_count);
2930     } else {
2931         packet_count = stats->packet_count;
2932         byte_count = stats->byte_count;
2933     }
2934
2935     msg = ofpraw_alloc_stats_reply(request, 0);
2936     asr = ofpbuf_put_zeros(msg, sizeof *asr);
2937     put_32aligned_be64(&asr->packet_count, htonll(packet_count));
2938     put_32aligned_be64(&asr->byte_count, htonll(byte_count));
2939     asr->flow_count = htonl(stats->flow_count);
2940
2941     return msg;
2942 }
2943
2944 enum ofperr
2945 ofputil_decode_aggregate_stats_reply(struct ofputil_aggregate_stats *stats,
2946                                      const struct ofp_header *reply)
2947 {
2948     struct ofp_aggregate_stats_reply *asr;
2949     struct ofpbuf msg;
2950
2951     ofpbuf_use_const(&msg, reply, ntohs(reply->length));
2952     ofpraw_pull_assert(&msg);
2953
2954     asr = msg.l3;
2955     stats->packet_count = ntohll(get_32aligned_be64(&asr->packet_count));
2956     stats->byte_count = ntohll(get_32aligned_be64(&asr->byte_count));
2957     stats->flow_count = ntohl(asr->flow_count);
2958
2959     return 0;
2960 }
2961
2962 /* Converts an OFPT_FLOW_REMOVED or NXT_FLOW_REMOVED message 'oh' into an
2963  * abstract ofputil_flow_removed in 'fr'.  Returns 0 if successful, otherwise
2964  * an OpenFlow error code. */
2965 enum ofperr
2966 ofputil_decode_flow_removed(struct ofputil_flow_removed *fr,
2967                             const struct ofp_header *oh)
2968 {
2969     enum ofpraw raw;
2970     struct ofpbuf b;
2971
2972     ofpbuf_use_const(&b, oh, ntohs(oh->length));
2973     raw = ofpraw_pull_assert(&b);
2974     if (raw == OFPRAW_OFPT11_FLOW_REMOVED) {
2975         const struct ofp12_flow_removed *ofr;
2976         enum ofperr error;
2977
2978         ofr = ofpbuf_pull(&b, sizeof *ofr);
2979
2980         error = ofputil_pull_ofp11_match(&b, &fr->match, NULL);
2981         if (error) {
2982             return error;
2983         }
2984
2985         fr->priority = ntohs(ofr->priority);
2986         fr->cookie = ofr->cookie;
2987         fr->reason = ofr->reason;
2988         fr->table_id = ofr->table_id;
2989         fr->duration_sec = ntohl(ofr->duration_sec);
2990         fr->duration_nsec = ntohl(ofr->duration_nsec);
2991         fr->idle_timeout = ntohs(ofr->idle_timeout);
2992         fr->hard_timeout = ntohs(ofr->hard_timeout);
2993         fr->packet_count = ntohll(ofr->packet_count);
2994         fr->byte_count = ntohll(ofr->byte_count);
2995     } else if (raw == OFPRAW_OFPT10_FLOW_REMOVED) {
2996         const struct ofp10_flow_removed *ofr;
2997
2998         ofr = ofpbuf_pull(&b, sizeof *ofr);
2999
3000         ofputil_match_from_ofp10_match(&ofr->match, &fr->match);
3001         fr->priority = ntohs(ofr->priority);
3002         fr->cookie = ofr->cookie;
3003         fr->reason = ofr->reason;
3004         fr->table_id = 255;
3005         fr->duration_sec = ntohl(ofr->duration_sec);
3006         fr->duration_nsec = ntohl(ofr->duration_nsec);
3007         fr->idle_timeout = ntohs(ofr->idle_timeout);
3008         fr->hard_timeout = 0;
3009         fr->packet_count = ntohll(ofr->packet_count);
3010         fr->byte_count = ntohll(ofr->byte_count);
3011     } else if (raw == OFPRAW_NXT_FLOW_REMOVED) {
3012         struct nx_flow_removed *nfr;
3013         enum ofperr error;
3014
3015         nfr = ofpbuf_pull(&b, sizeof *nfr);
3016         error = nx_pull_match(&b, ntohs(nfr->match_len), &fr->match,
3017                               NULL, NULL);
3018         if (error) {
3019             return error;
3020         }
3021         if (b.size) {
3022             return OFPERR_OFPBRC_BAD_LEN;
3023         }
3024
3025         fr->priority = ntohs(nfr->priority);
3026         fr->cookie = nfr->cookie;
3027         fr->reason = nfr->reason;
3028         fr->table_id = nfr->table_id ? nfr->table_id - 1 : 255;
3029         fr->duration_sec = ntohl(nfr->duration_sec);
3030         fr->duration_nsec = ntohl(nfr->duration_nsec);
3031         fr->idle_timeout = ntohs(nfr->idle_timeout);
3032         fr->hard_timeout = 0;
3033         fr->packet_count = ntohll(nfr->packet_count);
3034         fr->byte_count = ntohll(nfr->byte_count);
3035     } else {
3036         OVS_NOT_REACHED();
3037     }
3038
3039     return 0;
3040 }
3041
3042 /* Converts abstract ofputil_flow_removed 'fr' into an OFPT_FLOW_REMOVED or
3043  * NXT_FLOW_REMOVED message 'oh' according to 'protocol', and returns the
3044  * message. */
3045 struct ofpbuf *
3046 ofputil_encode_flow_removed(const struct ofputil_flow_removed *fr,
3047                             enum ofputil_protocol protocol)
3048 {
3049     struct ofpbuf *msg;
3050
3051     switch (protocol) {
3052     case OFPUTIL_P_OF11_STD:
3053     case OFPUTIL_P_OF12_OXM:
3054     case OFPUTIL_P_OF13_OXM: {
3055         struct ofp12_flow_removed *ofr;
3056
3057         msg = ofpraw_alloc_xid(OFPRAW_OFPT11_FLOW_REMOVED,
3058                                ofputil_protocol_to_ofp_version(protocol),
3059                                htonl(0),
3060                                ofputil_match_typical_len(protocol));
3061         ofr = ofpbuf_put_zeros(msg, sizeof *ofr);
3062         ofr->cookie = fr->cookie;
3063         ofr->priority = htons(fr->priority);
3064         ofr->reason = fr->reason;
3065         ofr->table_id = fr->table_id;
3066         ofr->duration_sec = htonl(fr->duration_sec);
3067         ofr->duration_nsec = htonl(fr->duration_nsec);
3068         ofr->idle_timeout = htons(fr->idle_timeout);
3069         ofr->hard_timeout = htons(fr->hard_timeout);
3070         ofr->packet_count = htonll(fr->packet_count);
3071         ofr->byte_count = htonll(fr->byte_count);
3072         ofputil_put_ofp11_match(msg, &fr->match, protocol);
3073         break;
3074     }
3075
3076     case OFPUTIL_P_OF10_STD:
3077     case OFPUTIL_P_OF10_STD_TID: {
3078         struct ofp10_flow_removed *ofr;
3079
3080         msg = ofpraw_alloc_xid(OFPRAW_OFPT10_FLOW_REMOVED, OFP10_VERSION,
3081                                htonl(0), 0);
3082         ofr = ofpbuf_put_zeros(msg, sizeof *ofr);
3083         ofputil_match_to_ofp10_match(&fr->match, &ofr->match);
3084         ofr->cookie = fr->cookie;
3085         ofr->priority = htons(fr->priority);
3086         ofr->reason = fr->reason;
3087         ofr->duration_sec = htonl(fr->duration_sec);
3088         ofr->duration_nsec = htonl(fr->duration_nsec);
3089         ofr->idle_timeout = htons(fr->idle_timeout);
3090         ofr->packet_count = htonll(unknown_to_zero(fr->packet_count));
3091         ofr->byte_count = htonll(unknown_to_zero(fr->byte_count));
3092         break;
3093     }
3094
3095     case OFPUTIL_P_OF10_NXM:
3096     case OFPUTIL_P_OF10_NXM_TID: {
3097         struct nx_flow_removed *nfr;
3098         int match_len;
3099
3100         msg = ofpraw_alloc_xid(OFPRAW_NXT_FLOW_REMOVED, OFP10_VERSION,
3101                                htonl(0), NXM_TYPICAL_LEN);
3102         nfr = ofpbuf_put_zeros(msg, sizeof *nfr);
3103         match_len = nx_put_match(msg, &fr->match, 0, 0);
3104
3105         nfr = msg->l3;
3106         nfr->cookie = fr->cookie;
3107         nfr->priority = htons(fr->priority);
3108         nfr->reason = fr->reason;
3109         nfr->table_id = fr->table_id + 1;
3110         nfr->duration_sec = htonl(fr->duration_sec);
3111         nfr->duration_nsec = htonl(fr->duration_nsec);
3112         nfr->idle_timeout = htons(fr->idle_timeout);
3113         nfr->match_len = htons(match_len);
3114         nfr->packet_count = htonll(fr->packet_count);
3115         nfr->byte_count = htonll(fr->byte_count);
3116         break;
3117     }
3118
3119     default:
3120         OVS_NOT_REACHED();
3121     }
3122
3123     return msg;
3124 }
3125
3126 static void
3127 ofputil_decode_packet_in_finish(struct ofputil_packet_in *pin,
3128                                 struct match *match, struct ofpbuf *b)
3129 {
3130     pin->packet = b->data;
3131     pin->packet_len = b->size;
3132
3133     pin->fmd.in_port = match->flow.in_port.ofp_port;
3134     pin->fmd.tun_id = match->flow.tunnel.tun_id;
3135     pin->fmd.tun_src = match->flow.tunnel.ip_src;
3136     pin->fmd.tun_dst = match->flow.tunnel.ip_dst;
3137     pin->fmd.metadata = match->flow.metadata;
3138     memcpy(pin->fmd.regs, match->flow.regs, sizeof pin->fmd.regs);
3139     pin->fmd.pkt_mark = match->flow.pkt_mark;
3140 }
3141
3142 enum ofperr
3143 ofputil_decode_packet_in(struct ofputil_packet_in *pin,
3144                          const struct ofp_header *oh)
3145 {
3146     enum ofpraw raw;
3147     struct ofpbuf b;
3148
3149     memset(pin, 0, sizeof *pin);
3150     pin->cookie = OVS_BE64_MAX;
3151
3152     ofpbuf_use_const(&b, oh, ntohs(oh->length));
3153     raw = ofpraw_pull_assert(&b);
3154     if (raw == OFPRAW_OFPT13_PACKET_IN || raw == OFPRAW_OFPT12_PACKET_IN) {
3155         const struct ofp13_packet_in *opi;
3156         struct match match;
3157         int error;
3158         size_t packet_in_size;
3159
3160         if (raw == OFPRAW_OFPT12_PACKET_IN) {
3161             packet_in_size = sizeof (struct ofp12_packet_in);
3162         } else {
3163             packet_in_size = sizeof (struct ofp13_packet_in);
3164         }
3165
3166         opi = ofpbuf_pull(&b, packet_in_size);
3167         error = oxm_pull_match_loose(&b, &match);
3168         if (error) {
3169             return error;
3170         }
3171
3172         if (!ofpbuf_try_pull(&b, 2)) {
3173             return OFPERR_OFPBRC_BAD_LEN;
3174         }
3175
3176         pin->reason = opi->pi.reason;
3177         pin->table_id = opi->pi.table_id;
3178         pin->buffer_id = ntohl(opi->pi.buffer_id);
3179         pin->total_len = ntohs(opi->pi.total_len);
3180
3181         if (raw == OFPRAW_OFPT13_PACKET_IN) {
3182             pin->cookie = opi->cookie;
3183         }
3184
3185         ofputil_decode_packet_in_finish(pin, &match, &b);
3186     } else if (raw == OFPRAW_OFPT10_PACKET_IN) {
3187         const struct ofp10_packet_in *opi;
3188
3189         opi = ofpbuf_pull(&b, offsetof(struct ofp10_packet_in, data));
3190
3191         pin->packet = opi->data;
3192         pin->packet_len = b.size;
3193
3194         pin->fmd.in_port = u16_to_ofp(ntohs(opi->in_port));
3195         pin->reason = opi->reason;
3196         pin->buffer_id = ntohl(opi->buffer_id);
3197         pin->total_len = ntohs(opi->total_len);
3198     } else if (raw == OFPRAW_OFPT11_PACKET_IN) {
3199         const struct ofp11_packet_in *opi;
3200         enum ofperr error;
3201
3202         opi = ofpbuf_pull(&b, sizeof *opi);
3203
3204         pin->packet = b.data;
3205         pin->packet_len = b.size;
3206
3207         pin->buffer_id = ntohl(opi->buffer_id);
3208         error = ofputil_port_from_ofp11(opi->in_port, &pin->fmd.in_port);
3209         if (error) {
3210             return error;
3211         }
3212         pin->total_len = ntohs(opi->total_len);
3213         pin->reason = opi->reason;
3214         pin->table_id = opi->table_id;
3215     } else if (raw == OFPRAW_NXT_PACKET_IN) {
3216         const struct nx_packet_in *npi;
3217         struct match match;
3218         int error;
3219
3220         npi = ofpbuf_pull(&b, sizeof *npi);
3221         error = nx_pull_match_loose(&b, ntohs(npi->match_len), &match, NULL,
3222                                     NULL);
3223         if (error) {
3224             return error;
3225         }
3226
3227         if (!ofpbuf_try_pull(&b, 2)) {
3228             return OFPERR_OFPBRC_BAD_LEN;
3229         }
3230
3231         pin->reason = npi->reason;
3232         pin->table_id = npi->table_id;
3233         pin->cookie = npi->cookie;
3234
3235         pin->buffer_id = ntohl(npi->buffer_id);
3236         pin->total_len = ntohs(npi->total_len);
3237
3238         ofputil_decode_packet_in_finish(pin, &match, &b);
3239     } else {
3240         OVS_NOT_REACHED();
3241     }
3242
3243     return 0;
3244 }
3245
3246 static void
3247 ofputil_packet_in_to_match(const struct ofputil_packet_in *pin,
3248                            struct match *match)
3249 {
3250     int i;
3251
3252     match_init_catchall(match);
3253     if (pin->fmd.tun_id != htonll(0)) {
3254         match_set_tun_id(match, pin->fmd.tun_id);
3255     }
3256     if (pin->fmd.tun_src != htonl(0)) {
3257         match_set_tun_src(match, pin->fmd.tun_src);
3258     }
3259     if (pin->fmd.tun_dst != htonl(0)) {
3260         match_set_tun_dst(match, pin->fmd.tun_dst);
3261     }
3262     if (pin->fmd.metadata != htonll(0)) {
3263         match_set_metadata(match, pin->fmd.metadata);
3264     }
3265
3266     for (i = 0; i < FLOW_N_REGS; i++) {
3267         if (pin->fmd.regs[i]) {
3268             match_set_reg(match, i, pin->fmd.regs[i]);
3269         }
3270     }
3271
3272     if (pin->fmd.pkt_mark != 0) {
3273         match_set_pkt_mark(match, pin->fmd.pkt_mark);
3274     }
3275
3276     match_set_in_port(match, pin->fmd.in_port);
3277 }
3278
3279 static struct ofpbuf *
3280 ofputil_encode_ofp10_packet_in(const struct ofputil_packet_in *pin)
3281 {
3282     struct ofp10_packet_in *opi;
3283     struct ofpbuf *packet;
3284
3285     packet = ofpraw_alloc_xid(OFPRAW_OFPT10_PACKET_IN, OFP10_VERSION,
3286                               htonl(0), pin->packet_len);
3287     opi = ofpbuf_put_zeros(packet, offsetof(struct ofp10_packet_in, data));
3288     opi->total_len = htons(pin->total_len);
3289     opi->in_port = htons(ofp_to_u16(pin->fmd.in_port));
3290     opi->reason = pin->reason;
3291     opi->buffer_id = htonl(pin->buffer_id);
3292
3293     ofpbuf_put(packet, pin->packet, pin->packet_len);
3294
3295     return packet;
3296 }
3297
3298 static struct ofpbuf *
3299 ofputil_encode_nx_packet_in(const struct ofputil_packet_in *pin)
3300 {
3301     struct nx_packet_in *npi;
3302     struct ofpbuf *packet;
3303     struct match match;
3304     size_t match_len;
3305
3306     ofputil_packet_in_to_match(pin, &match);
3307
3308     /* The final argument is just an estimate of the space required. */
3309     packet = ofpraw_alloc_xid(OFPRAW_NXT_PACKET_IN, OFP10_VERSION,
3310                               htonl(0), (sizeof(struct flow_metadata) * 2
3311                                          + 2 + pin->packet_len));
3312     ofpbuf_put_zeros(packet, sizeof *npi);
3313     match_len = nx_put_match(packet, &match, 0, 0);
3314     ofpbuf_put_zeros(packet, 2);
3315     ofpbuf_put(packet, pin->packet, pin->packet_len);
3316
3317     npi = packet->l3;
3318     npi->buffer_id = htonl(pin->buffer_id);
3319     npi->total_len = htons(pin->total_len);
3320     npi->reason = pin->reason;
3321     npi->table_id = pin->table_id;
3322     npi->cookie = pin->cookie;
3323     npi->match_len = htons(match_len);
3324
3325     return packet;
3326 }
3327
3328 static struct ofpbuf *
3329 ofputil_encode_ofp11_packet_in(const struct ofputil_packet_in *pin)
3330 {
3331     struct ofp11_packet_in *opi;
3332     struct ofpbuf *packet;
3333
3334     packet = ofpraw_alloc_xid(OFPRAW_OFPT11_PACKET_IN, OFP11_VERSION,
3335                               htonl(0), pin->packet_len);
3336     opi = ofpbuf_put_zeros(packet, sizeof *opi);
3337     opi->buffer_id = htonl(pin->buffer_id);
3338     opi->in_port = ofputil_port_to_ofp11(pin->fmd.in_port);
3339     opi->in_phy_port = opi->in_port;
3340     opi->total_len = htons(pin->total_len);
3341     opi->reason = pin->reason;
3342     opi->table_id = pin->table_id;
3343
3344     ofpbuf_put(packet, pin->packet, pin->packet_len);
3345
3346     return packet;
3347 }
3348
3349 static struct ofpbuf *
3350 ofputil_encode_ofp12_packet_in(const struct ofputil_packet_in *pin,
3351                                enum ofputil_protocol protocol)
3352 {
3353     struct ofp13_packet_in *opi;
3354     struct match match;
3355     enum ofpraw packet_in_raw;
3356     enum ofp_version packet_in_version;
3357     size_t packet_in_size;
3358     struct ofpbuf *packet;
3359
3360     if (protocol == OFPUTIL_P_OF12_OXM) {
3361         packet_in_raw = OFPRAW_OFPT12_PACKET_IN;
3362         packet_in_version = OFP12_VERSION;
3363         packet_in_size = sizeof (struct ofp12_packet_in);
3364     } else {
3365         packet_in_raw = OFPRAW_OFPT13_PACKET_IN;
3366         packet_in_version = OFP13_VERSION;
3367         packet_in_size = sizeof (struct ofp13_packet_in);
3368     }
3369
3370     ofputil_packet_in_to_match(pin, &match);
3371
3372     /* The final argument is just an estimate of the space required. */
3373     packet = ofpraw_alloc_xid(packet_in_raw, packet_in_version,
3374                               htonl(0), (sizeof(struct flow_metadata) * 2
3375                                          + 2 + pin->packet_len));
3376     ofpbuf_put_zeros(packet, packet_in_size);
3377     oxm_put_match(packet, &match);
3378     ofpbuf_put_zeros(packet, 2);
3379     ofpbuf_put(packet, pin->packet, pin->packet_len);
3380
3381     opi = packet->l3;
3382     opi->pi.buffer_id = htonl(pin->buffer_id);
3383     opi->pi.total_len = htons(pin->total_len);
3384     opi->pi.reason = pin->reason;
3385     opi->pi.table_id = pin->table_id;
3386     if (protocol == OFPUTIL_P_OF13_OXM) {
3387         opi->cookie = pin->cookie;
3388     }
3389
3390     return packet;
3391 }
3392
3393 /* Converts abstract ofputil_packet_in 'pin' into a PACKET_IN message
3394  * in the format specified by 'packet_in_format'.  */
3395 struct ofpbuf *
3396 ofputil_encode_packet_in(const struct ofputil_packet_in *pin,
3397                          enum ofputil_protocol protocol,
3398                          enum nx_packet_in_format packet_in_format)
3399 {
3400     struct ofpbuf *packet;
3401
3402     switch (protocol) {
3403     case OFPUTIL_P_OF10_STD:
3404     case OFPUTIL_P_OF10_STD_TID:
3405     case OFPUTIL_P_OF10_NXM:
3406     case OFPUTIL_P_OF10_NXM_TID:
3407         packet = (packet_in_format == NXPIF_NXM
3408                   ? ofputil_encode_nx_packet_in(pin)
3409                   : ofputil_encode_ofp10_packet_in(pin));
3410         break;
3411
3412     case OFPUTIL_P_OF11_STD:
3413         packet = ofputil_encode_ofp11_packet_in(pin);
3414         break;
3415
3416     case OFPUTIL_P_OF12_OXM:
3417     case OFPUTIL_P_OF13_OXM:
3418         packet = ofputil_encode_ofp12_packet_in(pin, protocol);
3419         break;
3420
3421     default:
3422         OVS_NOT_REACHED();
3423     }
3424
3425     ofpmsg_update_length(packet);
3426     return packet;
3427 }
3428
3429 /* Returns a string form of 'reason'.  The return value is either a statically
3430  * allocated constant string or the 'bufsize'-byte buffer 'reasonbuf'.
3431  * 'bufsize' should be at least OFPUTIL_PACKET_IN_REASON_BUFSIZE. */
3432 const char *
3433 ofputil_packet_in_reason_to_string(enum ofp_packet_in_reason reason,
3434                                    char *reasonbuf, size_t bufsize)
3435 {
3436     switch (reason) {
3437     case OFPR_NO_MATCH:
3438         return "no_match";
3439     case OFPR_ACTION:
3440         return "action";
3441     case OFPR_INVALID_TTL:
3442         return "invalid_ttl";
3443
3444     case OFPR_N_REASONS:
3445     default:
3446         snprintf(reasonbuf, bufsize, "%d", (int) reason);
3447         return reasonbuf;
3448     }
3449 }
3450
3451 bool
3452 ofputil_packet_in_reason_from_string(const char *s,
3453                                      enum ofp_packet_in_reason *reason)
3454 {
3455     int i;
3456
3457     for (i = 0; i < OFPR_N_REASONS; i++) {
3458         char reasonbuf[OFPUTIL_PACKET_IN_REASON_BUFSIZE];
3459         const char *reason_s;
3460
3461         reason_s = ofputil_packet_in_reason_to_string(i, reasonbuf,
3462                                                       sizeof reasonbuf);
3463         if (!strcasecmp(s, reason_s)) {
3464             *reason = i;
3465             return true;
3466         }
3467     }
3468     return false;
3469 }
3470
3471 /* Converts an OFPT_PACKET_OUT in 'opo' into an abstract ofputil_packet_out in
3472  * 'po'.
3473  *
3474  * Uses 'ofpacts' to store the abstract OFPACT_* version of the packet out
3475  * message's actions.  The caller must initialize 'ofpacts' and retains
3476  * ownership of it.  'po->ofpacts' will point into the 'ofpacts' buffer.
3477  *
3478  * Returns 0 if successful, otherwise an OFPERR_* value. */
3479 enum ofperr
3480 ofputil_decode_packet_out(struct ofputil_packet_out *po,
3481                           const struct ofp_header *oh,
3482                           struct ofpbuf *ofpacts)
3483 {
3484     enum ofpraw raw;
3485     struct ofpbuf b;
3486
3487     ofpbuf_use_const(&b, oh, ntohs(oh->length));
3488     raw = ofpraw_pull_assert(&b);
3489
3490     if (raw == OFPRAW_OFPT11_PACKET_OUT) {
3491         enum ofperr error;
3492         const struct ofp11_packet_out *opo = ofpbuf_pull(&b, sizeof *opo);
3493
3494         po->buffer_id = ntohl(opo->buffer_id);
3495         error = ofputil_port_from_ofp11(opo->in_port, &po->in_port);
3496         if (error) {
3497             return error;
3498         }
3499
3500         error = ofpacts_pull_openflow_actions(&b, ntohs(opo->actions_len),
3501                                               oh->version, ofpacts);
3502         if (error) {
3503             return error;
3504         }
3505     } else if (raw == OFPRAW_OFPT10_PACKET_OUT) {
3506         enum ofperr error;
3507         const struct ofp10_packet_out *opo = ofpbuf_pull(&b, sizeof *opo);
3508
3509         po->buffer_id = ntohl(opo->buffer_id);
3510         po->in_port = u16_to_ofp(ntohs(opo->in_port));
3511
3512         error = ofpacts_pull_openflow_actions(&b, ntohs(opo->actions_len),
3513                                               oh->version, ofpacts);
3514         if (error) {
3515             return error;
3516         }
3517     } else {
3518         OVS_NOT_REACHED();
3519     }
3520
3521     if (ofp_to_u16(po->in_port) >= ofp_to_u16(OFPP_MAX)
3522         && po->in_port != OFPP_LOCAL
3523         && po->in_port != OFPP_NONE && po->in_port != OFPP_CONTROLLER) {
3524         VLOG_WARN_RL(&bad_ofmsg_rl, "packet-out has bad input port %#"PRIx16,
3525                      po->in_port);
3526         return OFPERR_OFPBRC_BAD_PORT;
3527     }
3528
3529     po->ofpacts = ofpacts->data;
3530     po->ofpacts_len = ofpacts->size;
3531
3532     if (po->buffer_id == UINT32_MAX) {
3533         po->packet = b.data;
3534         po->packet_len = b.size;
3535     } else {
3536         po->packet = NULL;
3537         po->packet_len = 0;
3538     }
3539
3540     return 0;
3541 }
3542 \f
3543 /* ofputil_phy_port */
3544
3545 /* NETDEV_F_* to and from OFPPF_* and OFPPF10_*. */
3546 BUILD_ASSERT_DECL((int) NETDEV_F_10MB_HD    == OFPPF_10MB_HD);  /* bit 0 */
3547 BUILD_ASSERT_DECL((int) NETDEV_F_10MB_FD    == OFPPF_10MB_FD);  /* bit 1 */
3548 BUILD_ASSERT_DECL((int) NETDEV_F_100MB_HD   == OFPPF_100MB_HD); /* bit 2 */
3549 BUILD_ASSERT_DECL((int) NETDEV_F_100MB_FD   == OFPPF_100MB_FD); /* bit 3 */
3550 BUILD_ASSERT_DECL((int) NETDEV_F_1GB_HD     == OFPPF_1GB_HD);   /* bit 4 */
3551 BUILD_ASSERT_DECL((int) NETDEV_F_1GB_FD     == OFPPF_1GB_FD);   /* bit 5 */
3552 BUILD_ASSERT_DECL((int) NETDEV_F_10GB_FD    == OFPPF_10GB_FD);  /* bit 6 */
3553
3554 /* NETDEV_F_ bits 11...15 are OFPPF10_ bits 7...11: */
3555 BUILD_ASSERT_DECL((int) NETDEV_F_COPPER == (OFPPF10_COPPER << 4));
3556 BUILD_ASSERT_DECL((int) NETDEV_F_FIBER == (OFPPF10_FIBER << 4));
3557 BUILD_ASSERT_DECL((int) NETDEV_F_AUTONEG == (OFPPF10_AUTONEG << 4));
3558 BUILD_ASSERT_DECL((int) NETDEV_F_PAUSE == (OFPPF10_PAUSE << 4));
3559 BUILD_ASSERT_DECL((int) NETDEV_F_PAUSE_ASYM == (OFPPF10_PAUSE_ASYM << 4));
3560
3561 static enum netdev_features
3562 netdev_port_features_from_ofp10(ovs_be32 ofp10_)
3563 {
3564     uint32_t ofp10 = ntohl(ofp10_);
3565     return (ofp10 & 0x7f) | ((ofp10 & 0xf80) << 4);
3566 }
3567
3568 static ovs_be32
3569 netdev_port_features_to_ofp10(enum netdev_features features)
3570 {
3571     return htonl((features & 0x7f) | ((features & 0xf800) >> 4));
3572 }
3573
3574 BUILD_ASSERT_DECL((int) NETDEV_F_10MB_HD    == OFPPF_10MB_HD);     /* bit 0 */
3575 BUILD_ASSERT_DECL((int) NETDEV_F_10MB_FD    == OFPPF_10MB_FD);     /* bit 1 */
3576 BUILD_ASSERT_DECL((int) NETDEV_F_100MB_HD   == OFPPF_100MB_HD);    /* bit 2 */
3577 BUILD_ASSERT_DECL((int) NETDEV_F_100MB_FD   == OFPPF_100MB_FD);    /* bit 3 */
3578 BUILD_ASSERT_DECL((int) NETDEV_F_1GB_HD     == OFPPF_1GB_HD);      /* bit 4 */
3579 BUILD_ASSERT_DECL((int) NETDEV_F_1GB_FD     == OFPPF_1GB_FD);      /* bit 5 */
3580 BUILD_ASSERT_DECL((int) NETDEV_F_10GB_FD    == OFPPF_10GB_FD);     /* bit 6 */
3581 BUILD_ASSERT_DECL((int) NETDEV_F_40GB_FD    == OFPPF11_40GB_FD);   /* bit 7 */
3582 BUILD_ASSERT_DECL((int) NETDEV_F_100GB_FD   == OFPPF11_100GB_FD);  /* bit 8 */
3583 BUILD_ASSERT_DECL((int) NETDEV_F_1TB_FD     == OFPPF11_1TB_FD);    /* bit 9 */
3584 BUILD_ASSERT_DECL((int) NETDEV_F_OTHER      == OFPPF11_OTHER);     /* bit 10 */
3585 BUILD_ASSERT_DECL((int) NETDEV_F_COPPER     == OFPPF11_COPPER);    /* bit 11 */
3586 BUILD_ASSERT_DECL((int) NETDEV_F_FIBER      == OFPPF11_FIBER);     /* bit 12 */
3587 BUILD_ASSERT_DECL((int) NETDEV_F_AUTONEG    == OFPPF11_AUTONEG);   /* bit 13 */
3588 BUILD_ASSERT_DECL((int) NETDEV_F_PAUSE      == OFPPF11_PAUSE);     /* bit 14 */
3589 BUILD_ASSERT_DECL((int) NETDEV_F_PAUSE_ASYM == OFPPF11_PAUSE_ASYM);/* bit 15 */
3590
3591 static enum netdev_features
3592 netdev_port_features_from_ofp11(ovs_be32 ofp11)
3593 {
3594     return ntohl(ofp11) & 0xffff;
3595 }
3596
3597 static ovs_be32
3598 netdev_port_features_to_ofp11(enum netdev_features features)
3599 {
3600     return htonl(features & 0xffff);
3601 }
3602
3603 static enum ofperr
3604 ofputil_decode_ofp10_phy_port(struct ofputil_phy_port *pp,
3605                               const struct ofp10_phy_port *opp)
3606 {
3607     memset(pp, 0, sizeof *pp);
3608
3609     pp->port_no = u16_to_ofp(ntohs(opp->port_no));
3610     memcpy(pp->hw_addr, opp->hw_addr, OFP_ETH_ALEN);
3611     ovs_strlcpy(pp->name, opp->name, OFP_MAX_PORT_NAME_LEN);
3612
3613     pp->config = ntohl(opp->config) & OFPPC10_ALL;
3614     pp->state = ntohl(opp->state) & OFPPS10_ALL;
3615
3616     pp->curr = netdev_port_features_from_ofp10(opp->curr);
3617     pp->advertised = netdev_port_features_from_ofp10(opp->advertised);
3618     pp->supported = netdev_port_features_from_ofp10(opp->supported);
3619     pp->peer = netdev_port_features_from_ofp10(opp->peer);
3620
3621     pp->curr_speed = netdev_features_to_bps(pp->curr, 0) / 1000;
3622     pp->max_speed = netdev_features_to_bps(pp->supported, 0) / 1000;
3623
3624     return 0;
3625 }
3626
3627 static enum ofperr
3628 ofputil_decode_ofp11_port(struct ofputil_phy_port *pp,
3629                           const struct ofp11_port *op)
3630 {
3631     enum ofperr error;
3632
3633     memset(pp, 0, sizeof *pp);
3634
3635     error = ofputil_port_from_ofp11(op->port_no, &pp->port_no);
3636     if (error) {
3637         return error;
3638     }
3639     memcpy(pp->hw_addr, op->hw_addr, OFP_ETH_ALEN);
3640     ovs_strlcpy(pp->name, op->name, OFP_MAX_PORT_NAME_LEN);
3641
3642     pp->config = ntohl(op->config) & OFPPC11_ALL;
3643     pp->state = ntohl(op->state) & OFPPS11_ALL;
3644
3645     pp->curr = netdev_port_features_from_ofp11(op->curr);
3646     pp->advertised = netdev_port_features_from_ofp11(op->advertised);
3647     pp->supported = netdev_port_features_from_ofp11(op->supported);
3648     pp->peer = netdev_port_features_from_ofp11(op->peer);
3649
3650     pp->curr_speed = ntohl(op->curr_speed);
3651     pp->max_speed = ntohl(op->max_speed);
3652
3653     return 0;
3654 }
3655
3656 static size_t
3657 ofputil_get_phy_port_size(enum ofp_version ofp_version)
3658 {
3659     switch (ofp_version) {
3660     case OFP10_VERSION:
3661         return sizeof(struct ofp10_phy_port);
3662     case OFP11_VERSION:
3663     case OFP12_VERSION:
3664     case OFP13_VERSION:
3665         return sizeof(struct ofp11_port);
3666     default:
3667         OVS_NOT_REACHED();
3668     }
3669 }
3670
3671 static void
3672 ofputil_encode_ofp10_phy_port(const struct ofputil_phy_port *pp,
3673                               struct ofp10_phy_port *opp)
3674 {
3675     memset(opp, 0, sizeof *opp);
3676
3677     opp->port_no = htons(ofp_to_u16(pp->port_no));
3678     memcpy(opp->hw_addr, pp->hw_addr, ETH_ADDR_LEN);
3679     ovs_strlcpy(opp->name, pp->name, OFP_MAX_PORT_NAME_LEN);
3680
3681     opp->config = htonl(pp->config & OFPPC10_ALL);
3682     opp->state = htonl(pp->state & OFPPS10_ALL);
3683
3684     opp->curr = netdev_port_features_to_ofp10(pp->curr);
3685     opp->advertised = netdev_port_features_to_ofp10(pp->advertised);
3686     opp->supported = netdev_port_features_to_ofp10(pp->supported);
3687     opp->peer = netdev_port_features_to_ofp10(pp->peer);
3688 }
3689
3690 static void
3691 ofputil_encode_ofp11_port(const struct ofputil_phy_port *pp,
3692                           struct ofp11_port *op)
3693 {
3694     memset(op, 0, sizeof *op);
3695
3696     op->port_no = ofputil_port_to_ofp11(pp->port_no);
3697     memcpy(op->hw_addr, pp->hw_addr, ETH_ADDR_LEN);
3698     ovs_strlcpy(op->name, pp->name, OFP_MAX_PORT_NAME_LEN);
3699
3700     op->config = htonl(pp->config & OFPPC11_ALL);
3701     op->state = htonl(pp->state & OFPPS11_ALL);
3702
3703     op->curr = netdev_port_features_to_ofp11(pp->curr);
3704     op->advertised = netdev_port_features_to_ofp11(pp->advertised);
3705     op->supported = netdev_port_features_to_ofp11(pp->supported);
3706     op->peer = netdev_port_features_to_ofp11(pp->peer);
3707
3708     op->curr_speed = htonl(pp->curr_speed);
3709     op->max_speed = htonl(pp->max_speed);
3710 }
3711
3712 static void
3713 ofputil_put_phy_port(enum ofp_version ofp_version,
3714                      const struct ofputil_phy_port *pp, struct ofpbuf *b)
3715 {
3716     switch (ofp_version) {
3717     case OFP10_VERSION: {
3718         struct ofp10_phy_port *opp;
3719         if (b->size + sizeof *opp <= UINT16_MAX) {
3720             opp = ofpbuf_put_uninit(b, sizeof *opp);
3721             ofputil_encode_ofp10_phy_port(pp, opp);
3722         }
3723         break;
3724     }
3725
3726     case OFP11_VERSION:
3727     case OFP12_VERSION:
3728     case OFP13_VERSION: {
3729         struct ofp11_port *op;
3730         if (b->size + sizeof *op <= UINT16_MAX) {
3731             op = ofpbuf_put_uninit(b, sizeof *op);
3732             ofputil_encode_ofp11_port(pp, op);
3733         }
3734         break;
3735     }
3736
3737     default:
3738         OVS_NOT_REACHED();
3739     }
3740 }
3741
3742 void
3743 ofputil_append_port_desc_stats_reply(enum ofp_version ofp_version,
3744                                      const struct ofputil_phy_port *pp,
3745                                      struct list *replies)
3746 {
3747     switch (ofp_version) {
3748     case OFP10_VERSION: {
3749         struct ofp10_phy_port *opp;
3750
3751         opp = ofpmp_append(replies, sizeof *opp);
3752         ofputil_encode_ofp10_phy_port(pp, opp);
3753         break;
3754     }
3755
3756     case OFP11_VERSION:
3757     case OFP12_VERSION:
3758     case OFP13_VERSION: {
3759         struct ofp11_port *op;
3760
3761         op = ofpmp_append(replies, sizeof *op);
3762         ofputil_encode_ofp11_port(pp, op);
3763         break;
3764     }
3765
3766     default:
3767       OVS_NOT_REACHED();
3768     }
3769 }
3770 \f
3771 /* ofputil_switch_features */
3772
3773 #define OFPC_COMMON (OFPC_FLOW_STATS | OFPC_TABLE_STATS | OFPC_PORT_STATS | \
3774                      OFPC_IP_REASM | OFPC_QUEUE_STATS)
3775 BUILD_ASSERT_DECL((int) OFPUTIL_C_FLOW_STATS == OFPC_FLOW_STATS);
3776 BUILD_ASSERT_DECL((int) OFPUTIL_C_TABLE_STATS == OFPC_TABLE_STATS);
3777 BUILD_ASSERT_DECL((int) OFPUTIL_C_PORT_STATS == OFPC_PORT_STATS);
3778 BUILD_ASSERT_DECL((int) OFPUTIL_C_IP_REASM == OFPC_IP_REASM);
3779 BUILD_ASSERT_DECL((int) OFPUTIL_C_QUEUE_STATS == OFPC_QUEUE_STATS);
3780 BUILD_ASSERT_DECL((int) OFPUTIL_C_ARP_MATCH_IP == OFPC_ARP_MATCH_IP);
3781
3782 struct ofputil_action_bit_translation {
3783     enum ofputil_action_bitmap ofputil_bit;
3784     int of_bit;
3785 };
3786
3787 static const struct ofputil_action_bit_translation of10_action_bits[] = {
3788     { OFPUTIL_A_OUTPUT,       OFPAT10_OUTPUT },
3789     { OFPUTIL_A_SET_VLAN_VID, OFPAT10_SET_VLAN_VID },
3790     { OFPUTIL_A_SET_VLAN_PCP, OFPAT10_SET_VLAN_PCP },
3791     { OFPUTIL_A_STRIP_VLAN,   OFPAT10_STRIP_VLAN },
3792     { OFPUTIL_A_SET_DL_SRC,   OFPAT10_SET_DL_SRC },
3793     { OFPUTIL_A_SET_DL_DST,   OFPAT10_SET_DL_DST },
3794     { OFPUTIL_A_SET_NW_SRC,   OFPAT10_SET_NW_SRC },
3795     { OFPUTIL_A_SET_NW_DST,   OFPAT10_SET_NW_DST },
3796     { OFPUTIL_A_SET_NW_TOS,   OFPAT10_SET_NW_TOS },
3797     { OFPUTIL_A_SET_TP_SRC,   OFPAT10_SET_TP_SRC },
3798     { OFPUTIL_A_SET_TP_DST,   OFPAT10_SET_TP_DST },
3799     { OFPUTIL_A_ENQUEUE,      OFPAT10_ENQUEUE },
3800     { 0, 0 },
3801 };
3802
3803 static enum ofputil_action_bitmap
3804 decode_action_bits(ovs_be32 of_actions,
3805                    const struct ofputil_action_bit_translation *x)
3806 {
3807     enum ofputil_action_bitmap ofputil_actions;
3808
3809     ofputil_actions = 0;
3810     for (; x->ofputil_bit; x++) {
3811         if (of_actions & htonl(1u << x->of_bit)) {
3812             ofputil_actions |= x->ofputil_bit;
3813         }
3814     }
3815     return ofputil_actions;
3816 }
3817
3818 static uint32_t
3819 ofputil_capabilities_mask(enum ofp_version ofp_version)
3820 {
3821     /* Handle capabilities whose bit is unique for all Open Flow versions */
3822     switch (ofp_version) {
3823     case OFP10_VERSION:
3824     case OFP11_VERSION:
3825         return OFPC_COMMON | OFPC_ARP_MATCH_IP;
3826     case OFP12_VERSION:
3827     case OFP13_VERSION:
3828         return OFPC_COMMON | OFPC12_PORT_BLOCKED;
3829     default:
3830         /* Caller needs to check osf->header.version itself */
3831         return 0;
3832     }
3833 }
3834
3835 /* Decodes an OpenFlow 1.0 or 1.1 "switch_features" structure 'osf' into an
3836  * abstract representation in '*features'.  Initializes '*b' to iterate over
3837  * the OpenFlow port structures following 'osf' with later calls to
3838  * ofputil_pull_phy_port().  Returns 0 if successful, otherwise an
3839  * OFPERR_* value.  */
3840 enum ofperr
3841 ofputil_decode_switch_features(const struct ofp_header *oh,
3842                                struct ofputil_switch_features *features,
3843                                struct ofpbuf *b)
3844 {
3845     const struct ofp_switch_features *osf;
3846     enum ofpraw raw;
3847
3848     ofpbuf_use_const(b, oh, ntohs(oh->length));
3849     raw = ofpraw_pull_assert(b);
3850
3851     osf = ofpbuf_pull(b, sizeof *osf);
3852     features->datapath_id = ntohll(osf->datapath_id);
3853     features->n_buffers = ntohl(osf->n_buffers);
3854     features->n_tables = osf->n_tables;
3855     features->auxiliary_id = 0;
3856
3857     features->capabilities = ntohl(osf->capabilities) &
3858         ofputil_capabilities_mask(oh->version);
3859
3860     if (b->size % ofputil_get_phy_port_size(oh->version)) {
3861         return OFPERR_OFPBRC_BAD_LEN;
3862     }
3863
3864     if (raw == OFPRAW_OFPT10_FEATURES_REPLY) {
3865         if (osf->capabilities & htonl(OFPC10_STP)) {
3866             features->capabilities |= OFPUTIL_C_STP;
3867         }
3868         features->actions = decode_action_bits(osf->actions, of10_action_bits);
3869     } else if (raw == OFPRAW_OFPT11_FEATURES_REPLY
3870                || raw == OFPRAW_OFPT13_FEATURES_REPLY) {
3871         if (osf->capabilities & htonl(OFPC11_GROUP_STATS)) {
3872             features->capabilities |= OFPUTIL_C_GROUP_STATS;
3873         }
3874         features->actions = 0;
3875         if (raw == OFPRAW_OFPT13_FEATURES_REPLY) {
3876             features->auxiliary_id = osf->auxiliary_id;
3877         }
3878     } else {
3879         return OFPERR_OFPBRC_BAD_VERSION;
3880     }
3881
3882     return 0;
3883 }
3884
3885 /* Returns true if the maximum number of ports are in 'oh'. */
3886 static bool
3887 max_ports_in_features(const struct ofp_header *oh)
3888 {
3889     size_t pp_size = ofputil_get_phy_port_size(oh->version);
3890     return ntohs(oh->length) + pp_size > UINT16_MAX;
3891 }
3892
3893 /* Given a buffer 'b' that contains a Features Reply message, checks if
3894  * it contains the maximum number of ports that will fit.  If so, it
3895  * returns true and removes the ports from the message.  The caller
3896  * should then send an OFPST_PORT_DESC stats request to get the ports,
3897  * since the switch may have more ports than could be represented in the
3898  * Features Reply.  Otherwise, returns false.
3899  */
3900 bool
3901 ofputil_switch_features_ports_trunc(struct ofpbuf *b)
3902 {
3903     struct ofp_header *oh = b->data;
3904
3905     if (max_ports_in_features(oh)) {
3906         /* Remove all the ports. */
3907         b->size = (sizeof(struct ofp_header)
3908                    + sizeof(struct ofp_switch_features));
3909         ofpmsg_update_length(b);
3910
3911         return true;
3912     }
3913
3914     return false;
3915 }
3916
3917 static ovs_be32
3918 encode_action_bits(enum ofputil_action_bitmap ofputil_actions,
3919                    const struct ofputil_action_bit_translation *x)
3920 {
3921     uint32_t of_actions;
3922
3923     of_actions = 0;
3924     for (; x->ofputil_bit; x++) {
3925         if (ofputil_actions & x->ofputil_bit) {
3926             of_actions |= 1 << x->of_bit;
3927         }
3928     }
3929     return htonl(of_actions);
3930 }
3931
3932 /* Returns a buffer owned by the caller that encodes 'features' in the format
3933  * required by 'protocol' with the given 'xid'.  The caller should append port
3934  * information to the buffer with subsequent calls to
3935  * ofputil_put_switch_features_port(). */
3936 struct ofpbuf *
3937 ofputil_encode_switch_features(const struct ofputil_switch_features *features,
3938                                enum ofputil_protocol protocol, ovs_be32 xid)
3939 {
3940     struct ofp_switch_features *osf;
3941     struct ofpbuf *b;
3942     enum ofp_version version;
3943     enum ofpraw raw;
3944
3945     version = ofputil_protocol_to_ofp_version(protocol);
3946     switch (version) {
3947     case OFP10_VERSION:
3948         raw = OFPRAW_OFPT10_FEATURES_REPLY;
3949         break;
3950     case OFP11_VERSION:
3951     case OFP12_VERSION:
3952         raw = OFPRAW_OFPT11_FEATURES_REPLY;
3953         break;
3954     case OFP13_VERSION:
3955         raw = OFPRAW_OFPT13_FEATURES_REPLY;
3956         break;
3957     default:
3958         OVS_NOT_REACHED();
3959     }
3960     b = ofpraw_alloc_xid(raw, version, xid, 0);
3961     osf = ofpbuf_put_zeros(b, sizeof *osf);
3962     osf->datapath_id = htonll(features->datapath_id);
3963     osf->n_buffers = htonl(features->n_buffers);
3964     osf->n_tables = features->n_tables;
3965
3966     osf->capabilities = htonl(features->capabilities & OFPC_COMMON);
3967     osf->capabilities = htonl(features->capabilities &
3968                               ofputil_capabilities_mask(version));
3969     switch (version) {
3970     case OFP10_VERSION:
3971         if (features->capabilities & OFPUTIL_C_STP) {
3972             osf->capabilities |= htonl(OFPC10_STP);
3973         }
3974         osf->actions = encode_action_bits(features->actions, of10_action_bits);
3975         break;
3976     case OFP13_VERSION:
3977         osf->auxiliary_id = features->auxiliary_id;
3978         /* fall through */
3979     case OFP11_VERSION:
3980     case OFP12_VERSION:
3981         if (features->capabilities & OFPUTIL_C_GROUP_STATS) {
3982             osf->capabilities |= htonl(OFPC11_GROUP_STATS);
3983         }
3984         break;
3985     default:
3986         OVS_NOT_REACHED();
3987     }
3988
3989     return b;
3990 }
3991
3992 /* Encodes 'pp' into the format required by the switch_features message already
3993  * in 'b', which should have been returned by ofputil_encode_switch_features(),
3994  * and appends the encoded version to 'b'. */
3995 void
3996 ofputil_put_switch_features_port(const struct ofputil_phy_port *pp,
3997                                  struct ofpbuf *b)
3998 {
3999     const struct ofp_header *oh = b->data;
4000
4001     if (oh->version < OFP13_VERSION) {
4002         ofputil_put_phy_port(oh->version, pp, b);
4003     }
4004 }
4005 \f
4006 /* ofputil_port_status */
4007
4008 /* Decodes the OpenFlow "port status" message in '*ops' into an abstract form
4009  * in '*ps'.  Returns 0 if successful, otherwise an OFPERR_* value. */
4010 enum ofperr
4011 ofputil_decode_port_status(const struct ofp_header *oh,
4012                            struct ofputil_port_status *ps)
4013 {
4014     const struct ofp_port_status *ops;
4015     struct ofpbuf b;
4016     int retval;
4017
4018     ofpbuf_use_const(&b, oh, ntohs(oh->length));
4019     ofpraw_pull_assert(&b);
4020     ops = ofpbuf_pull(&b, sizeof *ops);
4021
4022     if (ops->reason != OFPPR_ADD &&
4023         ops->reason != OFPPR_DELETE &&
4024         ops->reason != OFPPR_MODIFY) {
4025         return OFPERR_NXBRC_BAD_REASON;
4026     }
4027     ps->reason = ops->reason;
4028
4029     retval = ofputil_pull_phy_port(oh->version, &b, &ps->desc);
4030     ovs_assert(retval != EOF);
4031     return retval;
4032 }
4033
4034 /* Converts the abstract form of a "port status" message in '*ps' into an
4035  * OpenFlow message suitable for 'protocol', and returns that encoded form in
4036  * a buffer owned by the caller. */
4037 struct ofpbuf *
4038 ofputil_encode_port_status(const struct ofputil_port_status *ps,
4039                            enum ofputil_protocol protocol)
4040 {
4041     struct ofp_port_status *ops;
4042     struct ofpbuf *b;
4043     enum ofp_version version;
4044     enum ofpraw raw;
4045
4046     version = ofputil_protocol_to_ofp_version(protocol);
4047     switch (version) {
4048     case OFP10_VERSION:
4049         raw = OFPRAW_OFPT10_PORT_STATUS;
4050         break;
4051
4052     case OFP11_VERSION:
4053     case OFP12_VERSION:
4054     case OFP13_VERSION:
4055         raw = OFPRAW_OFPT11_PORT_STATUS;
4056         break;
4057
4058     default:
4059         OVS_NOT_REACHED();
4060     }
4061
4062     b = ofpraw_alloc_xid(raw, version, htonl(0), 0);
4063     ops = ofpbuf_put_zeros(b, sizeof *ops);
4064     ops->reason = ps->reason;
4065     ofputil_put_phy_port(version, &ps->desc, b);
4066     ofpmsg_update_length(b);
4067     return b;
4068 }
4069
4070 /* ofputil_port_mod */
4071
4072 /* Decodes the OpenFlow "port mod" message in '*oh' into an abstract form in
4073  * '*pm'.  Returns 0 if successful, otherwise an OFPERR_* value. */
4074 enum ofperr
4075 ofputil_decode_port_mod(const struct ofp_header *oh,
4076                         struct ofputil_port_mod *pm)
4077 {
4078     enum ofpraw raw;
4079     struct ofpbuf b;
4080
4081     ofpbuf_use_const(&b, oh, ntohs(oh->length));
4082     raw = ofpraw_pull_assert(&b);
4083
4084     if (raw == OFPRAW_OFPT10_PORT_MOD) {
4085         const struct ofp10_port_mod *opm = b.data;
4086
4087         pm->port_no = u16_to_ofp(ntohs(opm->port_no));
4088         memcpy(pm->hw_addr, opm->hw_addr, ETH_ADDR_LEN);
4089         pm->config = ntohl(opm->config) & OFPPC10_ALL;
4090         pm->mask = ntohl(opm->mask) & OFPPC10_ALL;
4091         pm->advertise = netdev_port_features_from_ofp10(opm->advertise);
4092     } else if (raw == OFPRAW_OFPT11_PORT_MOD) {
4093         const struct ofp11_port_mod *opm = b.data;
4094         enum ofperr error;
4095
4096         error = ofputil_port_from_ofp11(opm->port_no, &pm->port_no);
4097         if (error) {
4098             return error;
4099         }
4100
4101         memcpy(pm->hw_addr, opm->hw_addr, ETH_ADDR_LEN);
4102         pm->config = ntohl(opm->config) & OFPPC11_ALL;
4103         pm->mask = ntohl(opm->mask) & OFPPC11_ALL;
4104         pm->advertise = netdev_port_features_from_ofp11(opm->advertise);
4105     } else {
4106         return OFPERR_OFPBRC_BAD_TYPE;
4107     }
4108
4109     pm->config &= pm->mask;
4110     return 0;
4111 }
4112
4113 /* Converts the abstract form of a "port mod" message in '*pm' into an OpenFlow
4114  * message suitable for 'protocol', and returns that encoded form in a buffer
4115  * owned by the caller. */
4116 struct ofpbuf *
4117 ofputil_encode_port_mod(const struct ofputil_port_mod *pm,
4118                         enum ofputil_protocol protocol)
4119 {
4120     enum ofp_version ofp_version = ofputil_protocol_to_ofp_version(protocol);
4121     struct ofpbuf *b;
4122
4123     switch (ofp_version) {
4124     case OFP10_VERSION: {
4125         struct ofp10_port_mod *opm;
4126
4127         b = ofpraw_alloc(OFPRAW_OFPT10_PORT_MOD, ofp_version, 0);
4128         opm = ofpbuf_put_zeros(b, sizeof *opm);
4129         opm->port_no = htons(ofp_to_u16(pm->port_no));
4130         memcpy(opm->hw_addr, pm->hw_addr, ETH_ADDR_LEN);
4131         opm->config = htonl(pm->config & OFPPC10_ALL);
4132         opm->mask = htonl(pm->mask & OFPPC10_ALL);
4133         opm->advertise = netdev_port_features_to_ofp10(pm->advertise);
4134         break;
4135     }
4136
4137     case OFP11_VERSION:
4138     case OFP12_VERSION:
4139     case OFP13_VERSION: {
4140         struct ofp11_port_mod *opm;
4141
4142         b = ofpraw_alloc(OFPRAW_OFPT11_PORT_MOD, ofp_version, 0);
4143         opm = ofpbuf_put_zeros(b, sizeof *opm);
4144         opm->port_no = ofputil_port_to_ofp11(pm->port_no);
4145         memcpy(opm->hw_addr, pm->hw_addr, ETH_ADDR_LEN);
4146         opm->config = htonl(pm->config & OFPPC11_ALL);
4147         opm->mask = htonl(pm->mask & OFPPC11_ALL);
4148         opm->advertise = netdev_port_features_to_ofp11(pm->advertise);
4149         break;
4150     }
4151     default:
4152         OVS_NOT_REACHED();
4153     }
4154
4155     return b;
4156 }
4157
4158 /* ofputil_table_mod */
4159
4160 /* Decodes the OpenFlow "table mod" message in '*oh' into an abstract form in
4161  * '*pm'.  Returns 0 if successful, otherwise an OFPERR_* value. */
4162 enum ofperr
4163 ofputil_decode_table_mod(const struct ofp_header *oh,
4164                          struct ofputil_table_mod *pm)
4165 {
4166     enum ofpraw raw;
4167     struct ofpbuf b;
4168
4169     ofpbuf_use_const(&b, oh, ntohs(oh->length));
4170     raw = ofpraw_pull_assert(&b);
4171
4172     if (raw == OFPRAW_OFPT11_TABLE_MOD) {
4173         const struct ofp11_table_mod *otm = b.data;
4174
4175         pm->table_id = otm->table_id;
4176         pm->config = ntohl(otm->config);
4177     } else {
4178         return OFPERR_OFPBRC_BAD_TYPE;
4179     }
4180
4181     return 0;
4182 }
4183
4184 /* Converts the abstract form of a "table mod" message in '*pm' into an OpenFlow
4185  * message suitable for 'protocol', and returns that encoded form in a buffer
4186  * owned by the caller. */
4187 struct ofpbuf *
4188 ofputil_encode_table_mod(const struct ofputil_table_mod *pm,
4189                         enum ofputil_protocol protocol)
4190 {
4191     enum ofp_version ofp_version = ofputil_protocol_to_ofp_version(protocol);
4192     struct ofpbuf *b;
4193
4194     switch (ofp_version) {
4195     case OFP10_VERSION: {
4196         ovs_fatal(0, "table mod needs OpenFlow 1.1 or later "
4197                      "(\'-O OpenFlow11\')");
4198         break;
4199     }
4200     case OFP11_VERSION:
4201     case OFP12_VERSION:
4202     case OFP13_VERSION: {
4203         struct ofp11_table_mod *otm;
4204
4205         b = ofpraw_alloc(OFPRAW_OFPT11_TABLE_MOD, ofp_version, 0);
4206         otm = ofpbuf_put_zeros(b, sizeof *otm);
4207         otm->table_id = pm->table_id;
4208         otm->config = htonl(pm->config);
4209         break;
4210     }
4211     default:
4212         OVS_NOT_REACHED();
4213     }
4214
4215     return b;
4216 }
4217 \f
4218 /* ofputil_role_request */
4219
4220 /* Decodes the OpenFlow "role request" or "role reply" message in '*oh' into
4221  * an abstract form in '*rr'.  Returns 0 if successful, otherwise an
4222  * OFPERR_* value. */
4223 enum ofperr
4224 ofputil_decode_role_message(const struct ofp_header *oh,
4225                             struct ofputil_role_request *rr)
4226 {
4227     struct ofpbuf b;
4228     enum ofpraw raw;
4229
4230     ofpbuf_use_const(&b, oh, ntohs(oh->length));
4231     raw = ofpraw_pull_assert(&b);
4232
4233     if (raw == OFPRAW_OFPT12_ROLE_REQUEST ||
4234         raw == OFPRAW_OFPT12_ROLE_REPLY) {
4235         const struct ofp12_role_request *orr = b.l3;
4236
4237         if (orr->role != htonl(OFPCR12_ROLE_NOCHANGE) &&
4238             orr->role != htonl(OFPCR12_ROLE_EQUAL) &&
4239             orr->role != htonl(OFPCR12_ROLE_MASTER) &&
4240             orr->role != htonl(OFPCR12_ROLE_SLAVE)) {
4241             return OFPERR_OFPRRFC_BAD_ROLE;
4242         }
4243
4244         rr->role = ntohl(orr->role);
4245         if (raw == OFPRAW_OFPT12_ROLE_REQUEST
4246             ? orr->role == htonl(OFPCR12_ROLE_NOCHANGE)
4247             : orr->generation_id == OVS_BE64_MAX) {
4248             rr->have_generation_id = false;
4249             rr->generation_id = 0;
4250         } else {
4251             rr->have_generation_id = true;
4252             rr->generation_id = ntohll(orr->generation_id);
4253         }
4254     } else if (raw == OFPRAW_NXT_ROLE_REQUEST ||
4255                raw == OFPRAW_NXT_ROLE_REPLY) {
4256         const struct nx_role_request *nrr = b.l3;
4257
4258         BUILD_ASSERT(NX_ROLE_OTHER + 1 == OFPCR12_ROLE_EQUAL);
4259         BUILD_ASSERT(NX_ROLE_MASTER + 1 == OFPCR12_ROLE_MASTER);
4260         BUILD_ASSERT(NX_ROLE_SLAVE + 1 == OFPCR12_ROLE_SLAVE);
4261
4262         if (nrr->role != htonl(NX_ROLE_OTHER) &&
4263             nrr->role != htonl(NX_ROLE_MASTER) &&
4264             nrr->role != htonl(NX_ROLE_SLAVE)) {
4265             return OFPERR_OFPRRFC_BAD_ROLE;
4266         }
4267
4268         rr->role = ntohl(nrr->role) + 1;
4269         rr->have_generation_id = false;
4270         rr->generation_id = 0;
4271     } else {
4272         OVS_NOT_REACHED();
4273     }
4274
4275     return 0;
4276 }
4277
4278 /* Returns an encoded form of a role reply suitable for the "request" in a
4279  * buffer owned by the caller. */
4280 struct ofpbuf *
4281 ofputil_encode_role_reply(const struct ofp_header *request,
4282                           const struct ofputil_role_request *rr)
4283 {
4284     struct ofpbuf *buf;
4285     enum ofpraw raw;
4286
4287     raw = ofpraw_decode_assert(request);
4288     if (raw == OFPRAW_OFPT12_ROLE_REQUEST) {
4289         struct ofp12_role_request *orr;
4290
4291         buf = ofpraw_alloc_reply(OFPRAW_OFPT12_ROLE_REPLY, request, 0);
4292         orr = ofpbuf_put_zeros(buf, sizeof *orr);
4293
4294         orr->role = htonl(rr->role);
4295         orr->generation_id = htonll(rr->have_generation_id
4296                                     ? rr->generation_id
4297                                     : UINT64_MAX);
4298     } else if (raw == OFPRAW_NXT_ROLE_REQUEST) {
4299         struct nx_role_request *nrr;
4300
4301         BUILD_ASSERT(NX_ROLE_OTHER == OFPCR12_ROLE_EQUAL - 1);
4302         BUILD_ASSERT(NX_ROLE_MASTER == OFPCR12_ROLE_MASTER - 1);
4303         BUILD_ASSERT(NX_ROLE_SLAVE == OFPCR12_ROLE_SLAVE - 1);
4304
4305         buf = ofpraw_alloc_reply(OFPRAW_NXT_ROLE_REPLY, request, 0);
4306         nrr = ofpbuf_put_zeros(buf, sizeof *nrr);
4307         nrr->role = htonl(rr->role - 1);
4308     } else {
4309         OVS_NOT_REACHED();
4310     }
4311
4312     return buf;
4313 }
4314 \f
4315 struct ofpbuf *
4316 ofputil_encode_role_status(const struct ofputil_role_status *status,
4317                            enum ofputil_protocol protocol)
4318 {
4319     struct ofpbuf *buf;
4320     enum ofp_version version;
4321     struct ofp14_role_status *rstatus;
4322
4323     version = ofputil_protocol_to_ofp_version(protocol);
4324     buf = ofpraw_alloc_xid(OFPRAW_OFPT14_ROLE_STATUS, version, htonl(0), 0);
4325     rstatus = ofpbuf_put_zeros(buf, sizeof *rstatus);
4326     rstatus->role = htonl(status->role);
4327     rstatus->reason = status->reason;
4328     rstatus->generation_id = htonll(status->generation_id);
4329
4330     return buf;
4331 }
4332
4333 enum ofperr
4334 ofputil_decode_role_status(const struct ofp_header *oh,
4335                            struct ofputil_role_status *rs)
4336 {
4337     struct ofpbuf b;
4338     enum ofpraw raw;
4339     const struct ofp14_role_status *r;
4340
4341     ofpbuf_use_const(&b, oh, ntohs(oh->length));
4342     raw = ofpraw_pull_assert(&b);
4343     ovs_assert(raw == OFPRAW_OFPT14_ROLE_STATUS);
4344
4345     r = b.l3;
4346     if (r->role != htonl(OFPCR12_ROLE_NOCHANGE) &&
4347         r->role != htonl(OFPCR12_ROLE_EQUAL) &&
4348         r->role != htonl(OFPCR12_ROLE_MASTER) &&
4349         r->role != htonl(OFPCR12_ROLE_SLAVE)) {
4350         return OFPERR_OFPRRFC_BAD_ROLE;
4351     }
4352
4353     rs->role = ntohl(r->role);
4354     rs->generation_id = ntohll(r->generation_id);
4355     rs->reason = r->reason;
4356
4357     return 0;
4358 }
4359
4360 /* Table stats. */
4361
4362 static void
4363 ofputil_put_ofp10_table_stats(const struct ofp12_table_stats *in,
4364                               struct ofpbuf *buf)
4365 {
4366     struct wc_map {
4367         enum ofp10_flow_wildcards wc10;
4368         enum oxm12_ofb_match_fields mf12;
4369     };
4370
4371     static const struct wc_map wc_map[] = {
4372         { OFPFW10_IN_PORT,     OFPXMT12_OFB_IN_PORT },
4373         { OFPFW10_DL_VLAN,     OFPXMT12_OFB_VLAN_VID },
4374         { OFPFW10_DL_SRC,      OFPXMT12_OFB_ETH_SRC },
4375         { OFPFW10_DL_DST,      OFPXMT12_OFB_ETH_DST},
4376         { OFPFW10_DL_TYPE,     OFPXMT12_OFB_ETH_TYPE },
4377         { OFPFW10_NW_PROTO,    OFPXMT12_OFB_IP_PROTO },
4378         { OFPFW10_TP_SRC,      OFPXMT12_OFB_TCP_SRC },
4379         { OFPFW10_TP_DST,      OFPXMT12_OFB_TCP_DST },
4380         { OFPFW10_NW_SRC_MASK, OFPXMT12_OFB_IPV4_SRC },
4381         { OFPFW10_NW_DST_MASK, OFPXMT12_OFB_IPV4_DST },
4382         { OFPFW10_DL_VLAN_PCP, OFPXMT12_OFB_VLAN_PCP },
4383         { OFPFW10_NW_TOS,      OFPXMT12_OFB_IP_DSCP },
4384     };
4385
4386     struct ofp10_table_stats *out;
4387     const struct wc_map *p;
4388
4389     out = ofpbuf_put_zeros(buf, sizeof *out);
4390     out->table_id = in->table_id;
4391     ovs_strlcpy(out->name, in->name, sizeof out->name);
4392     out->wildcards = 0;
4393     for (p = wc_map; p < &wc_map[ARRAY_SIZE(wc_map)]; p++) {
4394         if (in->wildcards & htonll(1ULL << p->mf12)) {
4395             out->wildcards |= htonl(p->wc10);
4396         }
4397     }
4398     out->max_entries = in->max_entries;
4399     out->active_count = in->active_count;
4400     put_32aligned_be64(&out->lookup_count, in->lookup_count);
4401     put_32aligned_be64(&out->matched_count, in->matched_count);
4402 }
4403
4404 static ovs_be32
4405 oxm12_to_ofp11_flow_match_fields(ovs_be64 oxm12)
4406 {
4407     struct map {
4408         enum ofp11_flow_match_fields fmf11;
4409         enum oxm12_ofb_match_fields mf12;
4410     };
4411
4412     static const struct map map[] = {
4413         { OFPFMF11_IN_PORT,     OFPXMT12_OFB_IN_PORT },
4414         { OFPFMF11_DL_VLAN,     OFPXMT12_OFB_VLAN_VID },
4415         { OFPFMF11_DL_VLAN_PCP, OFPXMT12_OFB_VLAN_PCP },
4416         { OFPFMF11_DL_TYPE,     OFPXMT12_OFB_ETH_TYPE },
4417         { OFPFMF11_NW_TOS,      OFPXMT12_OFB_IP_DSCP },
4418         { OFPFMF11_NW_PROTO,    OFPXMT12_OFB_IP_PROTO },
4419         { OFPFMF11_TP_SRC,      OFPXMT12_OFB_TCP_SRC },
4420         { OFPFMF11_TP_DST,      OFPXMT12_OFB_TCP_DST },
4421         { OFPFMF11_MPLS_LABEL,  OFPXMT12_OFB_MPLS_LABEL },
4422         { OFPFMF11_MPLS_TC,     OFPXMT12_OFB_MPLS_TC },
4423         /* I don't know what OFPFMF11_TYPE means. */
4424         { OFPFMF11_DL_SRC,      OFPXMT12_OFB_ETH_SRC },
4425         { OFPFMF11_DL_DST,      OFPXMT12_OFB_ETH_DST },
4426         { OFPFMF11_NW_SRC,      OFPXMT12_OFB_IPV4_SRC },
4427         { OFPFMF11_NW_DST,      OFPXMT12_OFB_IPV4_DST },
4428         { OFPFMF11_METADATA,    OFPXMT12_OFB_METADATA },
4429     };
4430
4431     const struct map *p;
4432     uint32_t fmf11;
4433
4434     fmf11 = 0;
4435     for (p = map; p < &map[ARRAY_SIZE(map)]; p++) {
4436         if (oxm12 & htonll(1ULL << p->mf12)) {
4437             fmf11 |= p->fmf11;
4438         }
4439     }
4440     return htonl(fmf11);
4441 }
4442
4443 static void
4444 ofputil_put_ofp11_table_stats(const struct ofp12_table_stats *in,
4445                               struct ofpbuf *buf)
4446 {
4447     struct ofp11_table_stats *out;
4448
4449     out = ofpbuf_put_zeros(buf, sizeof *out);
4450     out->table_id = in->table_id;
4451     ovs_strlcpy(out->name, in->name, sizeof out->name);
4452     out->wildcards = oxm12_to_ofp11_flow_match_fields(in->wildcards);
4453     out->match = oxm12_to_ofp11_flow_match_fields(in->match);
4454     out->instructions = in->instructions;
4455     out->write_actions = in->write_actions;
4456     out->apply_actions = in->apply_actions;
4457     out->config = in->config;
4458     out->max_entries = in->max_entries;
4459     out->active_count = in->active_count;
4460     out->lookup_count = in->lookup_count;
4461     out->matched_count = in->matched_count;
4462 }
4463
4464 static void
4465 ofputil_put_ofp12_table_stats(const struct ofp12_table_stats *in,
4466                               struct ofpbuf *buf)
4467 {
4468     struct ofp12_table_stats *out = ofpbuf_put(buf, in, sizeof *in);
4469
4470     /* Trim off OF1.3-only capabilities. */
4471     out->match &= htonll(OFPXMT12_MASK);
4472     out->wildcards &= htonll(OFPXMT12_MASK);
4473     out->write_setfields &= htonll(OFPXMT12_MASK);
4474     out->apply_setfields &= htonll(OFPXMT12_MASK);
4475 }
4476
4477 static void
4478 ofputil_put_ofp13_table_stats(const struct ofp12_table_stats *in,
4479                               struct ofpbuf *buf)
4480 {
4481     struct ofp13_table_stats *out;
4482
4483     /* OF 1.3 splits table features off the ofp_table_stats,
4484      * so there is not much here. */
4485
4486     out = ofpbuf_put_uninit(buf, sizeof *out);
4487     out->table_id = in->table_id;
4488     out->active_count = in->active_count;
4489     out->lookup_count = in->lookup_count;
4490     out->matched_count = in->matched_count;
4491 }
4492
4493 struct ofpbuf *
4494 ofputil_encode_table_stats_reply(const struct ofp12_table_stats stats[], int n,
4495                                  const struct ofp_header *request)
4496 {
4497     struct ofpbuf *reply;
4498     int i;
4499
4500     reply = ofpraw_alloc_stats_reply(request, n * sizeof *stats);
4501
4502     for (i = 0; i < n; i++) {
4503         switch ((enum ofp_version) request->version) {
4504         case OFP10_VERSION:
4505             ofputil_put_ofp10_table_stats(&stats[i], reply);
4506             break;
4507
4508         case OFP11_VERSION:
4509             ofputil_put_ofp11_table_stats(&stats[i], reply);
4510             break;
4511
4512         case OFP12_VERSION:
4513             ofputil_put_ofp12_table_stats(&stats[i], reply);
4514             break;
4515
4516         case OFP13_VERSION:
4517             ofputil_put_ofp13_table_stats(&stats[i], reply);
4518             break;
4519
4520         default:
4521             OVS_NOT_REACHED();
4522         }
4523     }
4524
4525     return reply;
4526 }
4527 \f
4528 /* ofputil_flow_monitor_request */
4529
4530 /* Converts an NXST_FLOW_MONITOR request in 'msg' into an abstract
4531  * ofputil_flow_monitor_request in 'rq'.
4532  *
4533  * Multiple NXST_FLOW_MONITOR requests can be packed into a single OpenFlow
4534  * message.  Calling this function multiple times for a single 'msg' iterates
4535  * through the requests.  The caller must initially leave 'msg''s layer
4536  * pointers null and not modify them between calls.
4537  *
4538  * Returns 0 if successful, EOF if no requests were left in this 'msg',
4539  * otherwise an OFPERR_* value. */
4540 int
4541 ofputil_decode_flow_monitor_request(struct ofputil_flow_monitor_request *rq,
4542                                     struct ofpbuf *msg)
4543 {
4544     struct nx_flow_monitor_request *nfmr;
4545     uint16_t flags;
4546
4547     if (!msg->l2) {
4548         msg->l2 = msg->data;
4549         ofpraw_pull_assert(msg);
4550     }
4551
4552     if (!msg->size) {
4553         return EOF;
4554     }
4555
4556     nfmr = ofpbuf_try_pull(msg, sizeof *nfmr);
4557     if (!nfmr) {
4558         VLOG_WARN_RL(&bad_ofmsg_rl, "NXST_FLOW_MONITOR request has %"PRIuSIZE" "
4559                      "leftover bytes at end", msg->size);
4560         return OFPERR_OFPBRC_BAD_LEN;
4561     }
4562
4563     flags = ntohs(nfmr->flags);
4564     if (!(flags & (NXFMF_ADD | NXFMF_DELETE | NXFMF_MODIFY))
4565         || flags & ~(NXFMF_INITIAL | NXFMF_ADD | NXFMF_DELETE
4566                      | NXFMF_MODIFY | NXFMF_ACTIONS | NXFMF_OWN)) {
4567         VLOG_WARN_RL(&bad_ofmsg_rl, "NXST_FLOW_MONITOR has bad flags %#"PRIx16,
4568                      flags);
4569         return OFPERR_NXBRC_FM_BAD_FLAGS;
4570     }
4571
4572     if (!is_all_zeros(nfmr->zeros, sizeof nfmr->zeros)) {
4573         return OFPERR_NXBRC_MUST_BE_ZERO;
4574     }
4575
4576     rq->id = ntohl(nfmr->id);
4577     rq->flags = flags;
4578     rq->out_port = u16_to_ofp(ntohs(nfmr->out_port));
4579     rq->table_id = nfmr->table_id;
4580
4581     return nx_pull_match(msg, ntohs(nfmr->match_len), &rq->match, NULL, NULL);
4582 }
4583
4584 void
4585 ofputil_append_flow_monitor_request(
4586     const struct ofputil_flow_monitor_request *rq, struct ofpbuf *msg)
4587 {
4588     struct nx_flow_monitor_request *nfmr;
4589     size_t start_ofs;
4590     int match_len;
4591
4592     if (!msg->size) {
4593         ofpraw_put(OFPRAW_NXST_FLOW_MONITOR_REQUEST, OFP10_VERSION, msg);
4594     }
4595
4596     start_ofs = msg->size;
4597     ofpbuf_put_zeros(msg, sizeof *nfmr);
4598     match_len = nx_put_match(msg, &rq->match, htonll(0), htonll(0));
4599
4600     nfmr = ofpbuf_at_assert(msg, start_ofs, sizeof *nfmr);
4601     nfmr->id = htonl(rq->id);
4602     nfmr->flags = htons(rq->flags);
4603     nfmr->out_port = htons(ofp_to_u16(rq->out_port));
4604     nfmr->match_len = htons(match_len);
4605     nfmr->table_id = rq->table_id;
4606 }
4607
4608 /* Converts an NXST_FLOW_MONITOR reply (also known as a flow update) in 'msg'
4609  * into an abstract ofputil_flow_update in 'update'.  The caller must have
4610  * initialized update->match to point to space allocated for a match.
4611  *
4612  * Uses 'ofpacts' to store the abstract OFPACT_* version of the update's
4613  * actions (except for NXFME_ABBREV, which never includes actions).  The caller
4614  * must initialize 'ofpacts' and retains ownership of it.  'update->ofpacts'
4615  * will point into the 'ofpacts' buffer.
4616  *
4617  * Multiple flow updates can be packed into a single OpenFlow message.  Calling
4618  * this function multiple times for a single 'msg' iterates through the
4619  * updates.  The caller must initially leave 'msg''s layer pointers null and
4620  * not modify them between calls.
4621  *
4622  * Returns 0 if successful, EOF if no updates were left in this 'msg',
4623  * otherwise an OFPERR_* value. */
4624 int
4625 ofputil_decode_flow_update(struct ofputil_flow_update *update,
4626                            struct ofpbuf *msg, struct ofpbuf *ofpacts)
4627 {
4628     struct nx_flow_update_header *nfuh;
4629     unsigned int length;
4630     struct ofp_header *oh;
4631
4632     if (!msg->l2) {
4633         msg->l2 = msg->data;
4634         ofpraw_pull_assert(msg);
4635     }
4636
4637     if (!msg->size) {
4638         return EOF;
4639     }
4640
4641     if (msg->size < sizeof(struct nx_flow_update_header)) {
4642         goto bad_len;
4643     }
4644
4645     oh = msg->l2;
4646
4647     nfuh = msg->data;
4648     update->event = ntohs(nfuh->event);
4649     length = ntohs(nfuh->length);
4650     if (length > msg->size || length % 8) {
4651         goto bad_len;
4652     }
4653
4654     if (update->event == NXFME_ABBREV) {
4655         struct nx_flow_update_abbrev *nfua;
4656
4657         if (length != sizeof *nfua) {
4658             goto bad_len;
4659         }
4660
4661         nfua = ofpbuf_pull(msg, sizeof *nfua);
4662         update->xid = nfua->xid;
4663         return 0;
4664     } else if (update->event == NXFME_ADDED
4665                || update->event == NXFME_DELETED
4666                || update->event == NXFME_MODIFIED) {
4667         struct nx_flow_update_full *nfuf;
4668         unsigned int actions_len;
4669         unsigned int match_len;
4670         enum ofperr error;
4671
4672         if (length < sizeof *nfuf) {
4673             goto bad_len;
4674         }
4675
4676         nfuf = ofpbuf_pull(msg, sizeof *nfuf);
4677         match_len = ntohs(nfuf->match_len);
4678         if (sizeof *nfuf + match_len > length) {
4679             goto bad_len;
4680         }
4681
4682         update->reason = ntohs(nfuf->reason);
4683         update->idle_timeout = ntohs(nfuf->idle_timeout);
4684         update->hard_timeout = ntohs(nfuf->hard_timeout);
4685         update->table_id = nfuf->table_id;
4686         update->cookie = nfuf->cookie;
4687         update->priority = ntohs(nfuf->priority);
4688
4689         error = nx_pull_match(msg, match_len, update->match, NULL, NULL);
4690         if (error) {
4691             return error;
4692         }
4693
4694         actions_len = length - sizeof *nfuf - ROUND_UP(match_len, 8);
4695         error = ofpacts_pull_openflow_actions(msg, actions_len, oh->version,
4696                                               ofpacts);
4697         if (error) {
4698             return error;
4699         }
4700
4701         update->ofpacts = ofpacts->data;
4702         update->ofpacts_len = ofpacts->size;
4703         return 0;
4704     } else {
4705         VLOG_WARN_RL(&bad_ofmsg_rl,
4706                      "NXST_FLOW_MONITOR reply has bad event %"PRIu16,
4707                      ntohs(nfuh->event));
4708         return OFPERR_NXBRC_FM_BAD_EVENT;
4709     }
4710
4711 bad_len:
4712     VLOG_WARN_RL(&bad_ofmsg_rl, "NXST_FLOW_MONITOR reply has %"PRIuSIZE" "
4713                  "leftover bytes at end", msg->size);
4714     return OFPERR_OFPBRC_BAD_LEN;
4715 }
4716
4717 uint32_t
4718 ofputil_decode_flow_monitor_cancel(const struct ofp_header *oh)
4719 {
4720     const struct nx_flow_monitor_cancel *cancel = ofpmsg_body(oh);
4721
4722     return ntohl(cancel->id);
4723 }
4724
4725 struct ofpbuf *
4726 ofputil_encode_flow_monitor_cancel(uint32_t id)
4727 {
4728     struct nx_flow_monitor_cancel *nfmc;
4729     struct ofpbuf *msg;
4730
4731     msg = ofpraw_alloc(OFPRAW_NXT_FLOW_MONITOR_CANCEL, OFP10_VERSION, 0);
4732     nfmc = ofpbuf_put_uninit(msg, sizeof *nfmc);
4733     nfmc->id = htonl(id);
4734     return msg;
4735 }
4736
4737 void
4738 ofputil_start_flow_update(struct list *replies)
4739 {
4740     struct ofpbuf *msg;
4741
4742     msg = ofpraw_alloc_xid(OFPRAW_NXST_FLOW_MONITOR_REPLY, OFP10_VERSION,
4743                            htonl(0), 1024);
4744
4745     list_init(replies);
4746     list_push_back(replies, &msg->list_node);
4747 }
4748
4749 void
4750 ofputil_append_flow_update(const struct ofputil_flow_update *update,
4751                            struct list *replies)
4752 {
4753     struct nx_flow_update_header *nfuh;
4754     struct ofpbuf *msg;
4755     size_t start_ofs;
4756     enum ofp_version version;
4757
4758     msg = ofpbuf_from_list(list_back(replies));
4759     start_ofs = msg->size;
4760     version = ((struct ofp_header *)msg->l2)->version;
4761
4762     if (update->event == NXFME_ABBREV) {
4763         struct nx_flow_update_abbrev *nfua;
4764
4765         nfua = ofpbuf_put_zeros(msg, sizeof *nfua);
4766         nfua->xid = update->xid;
4767     } else {
4768         struct nx_flow_update_full *nfuf;
4769         int match_len;
4770
4771         ofpbuf_put_zeros(msg, sizeof *nfuf);
4772         match_len = nx_put_match(msg, update->match, htonll(0), htonll(0));
4773         ofpacts_put_openflow_actions(update->ofpacts, update->ofpacts_len, msg,
4774                                      version);
4775         nfuf = ofpbuf_at_assert(msg, start_ofs, sizeof *nfuf);
4776         nfuf->reason = htons(update->reason);
4777         nfuf->priority = htons(update->priority);
4778         nfuf->idle_timeout = htons(update->idle_timeout);
4779         nfuf->hard_timeout = htons(update->hard_timeout);
4780         nfuf->match_len = htons(match_len);
4781         nfuf->table_id = update->table_id;
4782         nfuf->cookie = update->cookie;
4783     }
4784
4785     nfuh = ofpbuf_at_assert(msg, start_ofs, sizeof *nfuh);
4786     nfuh->length = htons(msg->size - start_ofs);
4787     nfuh->event = htons(update->event);
4788
4789     ofpmp_postappend(replies, start_ofs);
4790 }
4791 \f
4792 struct ofpbuf *
4793 ofputil_encode_packet_out(const struct ofputil_packet_out *po,
4794                           enum ofputil_protocol protocol)
4795 {
4796     enum ofp_version ofp_version = ofputil_protocol_to_ofp_version(protocol);
4797     struct ofpbuf *msg;
4798     size_t size;
4799
4800     size = po->ofpacts_len;
4801     if (po->buffer_id == UINT32_MAX) {
4802         size += po->packet_len;
4803     }
4804
4805     switch (ofp_version) {
4806     case OFP10_VERSION: {
4807         struct ofp10_packet_out *opo;
4808         size_t actions_ofs;
4809
4810         msg = ofpraw_alloc(OFPRAW_OFPT10_PACKET_OUT, OFP10_VERSION, size);
4811         ofpbuf_put_zeros(msg, sizeof *opo);
4812         actions_ofs = msg->size;
4813         ofpacts_put_openflow_actions(po->ofpacts, po->ofpacts_len, msg,
4814                                      ofp_version);
4815
4816         opo = msg->l3;
4817         opo->buffer_id = htonl(po->buffer_id);
4818         opo->in_port = htons(ofp_to_u16(po->in_port));
4819         opo->actions_len = htons(msg->size - actions_ofs);
4820         break;
4821     }
4822
4823     case OFP11_VERSION:
4824     case OFP12_VERSION:
4825     case OFP13_VERSION: {
4826         struct ofp11_packet_out *opo;
4827         size_t len;
4828
4829         msg = ofpraw_alloc(OFPRAW_OFPT11_PACKET_OUT, ofp_version, size);
4830         ofpbuf_put_zeros(msg, sizeof *opo);
4831         len = ofpacts_put_openflow_actions(po->ofpacts, po->ofpacts_len, msg,
4832                                            ofp_version);
4833         opo = msg->l3;
4834         opo->buffer_id = htonl(po->buffer_id);
4835         opo->in_port = ofputil_port_to_ofp11(po->in_port);
4836         opo->actions_len = htons(len);
4837         break;
4838     }
4839
4840     default:
4841         OVS_NOT_REACHED();
4842     }
4843
4844     if (po->buffer_id == UINT32_MAX) {
4845         ofpbuf_put(msg, po->packet, po->packet_len);
4846     }
4847
4848     ofpmsg_update_length(msg);
4849
4850     return msg;
4851 }
4852 \f
4853 /* Creates and returns an OFPT_ECHO_REQUEST message with an empty payload. */
4854 struct ofpbuf *
4855 make_echo_request(enum ofp_version ofp_version)
4856 {
4857     return ofpraw_alloc_xid(OFPRAW_OFPT_ECHO_REQUEST, ofp_version,
4858                             htonl(0), 0);
4859 }
4860
4861 /* Creates and returns an OFPT_ECHO_REPLY message matching the
4862  * OFPT_ECHO_REQUEST message in 'rq'. */
4863 struct ofpbuf *
4864 make_echo_reply(const struct ofp_header *rq)
4865 {
4866     struct ofpbuf rq_buf;
4867     struct ofpbuf *reply;
4868
4869     ofpbuf_use_const(&rq_buf, rq, ntohs(rq->length));
4870     ofpraw_pull_assert(&rq_buf);
4871
4872     reply = ofpraw_alloc_reply(OFPRAW_OFPT_ECHO_REPLY, rq, rq_buf.size);
4873     ofpbuf_put(reply, rq_buf.data, rq_buf.size);
4874     return reply;
4875 }
4876
4877 struct ofpbuf *
4878 ofputil_encode_barrier_request(enum ofp_version ofp_version)
4879 {
4880     enum ofpraw type;
4881
4882     switch (ofp_version) {
4883     case OFP13_VERSION:
4884     case OFP12_VERSION:
4885     case OFP11_VERSION:
4886         type = OFPRAW_OFPT11_BARRIER_REQUEST;
4887         break;
4888
4889     case OFP10_VERSION:
4890         type = OFPRAW_OFPT10_BARRIER_REQUEST;
4891         break;
4892
4893     default:
4894         OVS_NOT_REACHED();
4895     }
4896
4897     return ofpraw_alloc(type, ofp_version, 0);
4898 }
4899
4900 const char *
4901 ofputil_frag_handling_to_string(enum ofp_config_flags flags)
4902 {
4903     switch (flags & OFPC_FRAG_MASK) {
4904     case OFPC_FRAG_NORMAL:   return "normal";
4905     case OFPC_FRAG_DROP:     return "drop";
4906     case OFPC_FRAG_REASM:    return "reassemble";
4907     case OFPC_FRAG_NX_MATCH: return "nx-match";
4908     }
4909
4910     OVS_NOT_REACHED();
4911 }
4912
4913 bool
4914 ofputil_frag_handling_from_string(const char *s, enum ofp_config_flags *flags)
4915 {
4916     if (!strcasecmp(s, "normal")) {
4917         *flags = OFPC_FRAG_NORMAL;
4918     } else if (!strcasecmp(s, "drop")) {
4919         *flags = OFPC_FRAG_DROP;
4920     } else if (!strcasecmp(s, "reassemble")) {
4921         *flags = OFPC_FRAG_REASM;
4922     } else if (!strcasecmp(s, "nx-match")) {
4923         *flags = OFPC_FRAG_NX_MATCH;
4924     } else {
4925         return false;
4926     }
4927     return true;
4928 }
4929
4930 /* Converts the OpenFlow 1.1+ port number 'ofp11_port' into an OpenFlow 1.0
4931  * port number and stores the latter in '*ofp10_port', for the purpose of
4932  * decoding OpenFlow 1.1+ protocol messages.  Returns 0 if successful,
4933  * otherwise an OFPERR_* number.  On error, stores OFPP_NONE in '*ofp10_port'.
4934  *
4935  * See the definition of OFP11_MAX for an explanation of the mapping. */
4936 enum ofperr
4937 ofputil_port_from_ofp11(ovs_be32 ofp11_port, ofp_port_t *ofp10_port)
4938 {
4939     uint32_t ofp11_port_h = ntohl(ofp11_port);
4940
4941     if (ofp11_port_h < ofp_to_u16(OFPP_MAX)) {
4942         *ofp10_port = u16_to_ofp(ofp11_port_h);
4943         return 0;
4944     } else if (ofp11_port_h >= ofp11_to_u32(OFPP11_MAX)) {
4945         *ofp10_port = u16_to_ofp(ofp11_port_h - OFPP11_OFFSET);
4946         return 0;
4947     } else {
4948         *ofp10_port = OFPP_NONE;
4949         VLOG_WARN_RL(&bad_ofmsg_rl, "port %"PRIu32" is outside the supported "
4950                      "range 0 through %d or 0x%"PRIx32" through 0x%"PRIx32,
4951                      ofp11_port_h, ofp_to_u16(OFPP_MAX) - 1,
4952                      ofp11_to_u32(OFPP11_MAX), UINT32_MAX);
4953         return OFPERR_OFPBAC_BAD_OUT_PORT;
4954     }
4955 }
4956
4957 /* Returns the OpenFlow 1.1+ port number equivalent to the OpenFlow 1.0 port
4958  * number 'ofp10_port', for encoding OpenFlow 1.1+ protocol messages.
4959  *
4960  * See the definition of OFP11_MAX for an explanation of the mapping. */
4961 ovs_be32
4962 ofputil_port_to_ofp11(ofp_port_t ofp10_port)
4963 {
4964     return htonl(ofp_to_u16(ofp10_port) < ofp_to_u16(OFPP_MAX)
4965                  ? ofp_to_u16(ofp10_port)
4966                  : ofp_to_u16(ofp10_port) + OFPP11_OFFSET);
4967 }
4968
4969 #define OFPUTIL_NAMED_PORTS                     \
4970         OFPUTIL_NAMED_PORT(IN_PORT)             \
4971         OFPUTIL_NAMED_PORT(TABLE)               \
4972         OFPUTIL_NAMED_PORT(NORMAL)              \
4973         OFPUTIL_NAMED_PORT(FLOOD)               \
4974         OFPUTIL_NAMED_PORT(ALL)                 \
4975         OFPUTIL_NAMED_PORT(CONTROLLER)          \
4976         OFPUTIL_NAMED_PORT(LOCAL)               \
4977         OFPUTIL_NAMED_PORT(ANY)
4978
4979 /* For backwards compatibility, so that "none" is recognized as OFPP_ANY */
4980 #define OFPUTIL_NAMED_PORTS_WITH_NONE           \
4981         OFPUTIL_NAMED_PORTS                     \
4982         OFPUTIL_NAMED_PORT(NONE)
4983
4984 /* Stores the port number represented by 's' into '*portp'.  's' may be an
4985  * integer or, for reserved ports, the standard OpenFlow name for the port
4986  * (e.g. "LOCAL").
4987  *
4988  * Returns true if successful, false if 's' is not a valid OpenFlow port number
4989  * or name.  The caller should issue an error message in this case, because
4990  * this function usually does not.  (This gives the caller an opportunity to
4991  * look up the port name another way, e.g. by contacting the switch and listing
4992  * the names of all its ports).
4993  *
4994  * This function accepts OpenFlow 1.0 port numbers.  It also accepts a subset
4995  * of OpenFlow 1.1+ port numbers, mapping those port numbers into the 16-bit
4996  * range as described in include/openflow/openflow-1.1.h. */
4997 bool
4998 ofputil_port_from_string(const char *s, ofp_port_t *portp)
4999 {
5000     uint32_t port32;
5001
5002     *portp = 0;
5003     if (str_to_uint(s, 10, &port32)) {
5004         if (port32 < ofp_to_u16(OFPP_MAX)) {
5005             /* Pass. */
5006         } else if (port32 < ofp_to_u16(OFPP_FIRST_RESV)) {
5007             VLOG_WARN("port %u is a reserved OF1.0 port number that will "
5008                       "be translated to %u when talking to an OF1.1 or "
5009                       "later controller", port32, port32 + OFPP11_OFFSET);
5010         } else if (port32 <= ofp_to_u16(OFPP_LAST_RESV)) {
5011             char name[OFP_MAX_PORT_NAME_LEN];
5012
5013             ofputil_port_to_string(u16_to_ofp(port32), name, sizeof name);
5014             VLOG_WARN_ONCE("referring to port %s as %"PRIu32" is deprecated "
5015                            "for compatibility with OpenFlow 1.1 and later",
5016                            name, port32);
5017         } else if (port32 < ofp11_to_u32(OFPP11_MAX)) {
5018             VLOG_WARN("port %u is outside the supported range 0 through "
5019                       "%"PRIx16" or 0x%x through 0x%"PRIx32, port32,
5020                       UINT16_MAX, ofp11_to_u32(OFPP11_MAX), UINT32_MAX);
5021             return false;
5022         } else {
5023             port32 -= OFPP11_OFFSET;
5024         }
5025
5026         *portp = u16_to_ofp(port32);
5027         return true;
5028     } else {
5029         struct pair {
5030             const char *name;
5031             ofp_port_t value;
5032         };
5033         static const struct pair pairs[] = {
5034 #define OFPUTIL_NAMED_PORT(NAME) {#NAME, OFPP_##NAME},
5035             OFPUTIL_NAMED_PORTS_WITH_NONE
5036 #undef OFPUTIL_NAMED_PORT
5037         };
5038         const struct pair *p;
5039
5040         for (p = pairs; p < &pairs[ARRAY_SIZE(pairs)]; p++) {
5041             if (!strcasecmp(s, p->name)) {
5042                 *portp = p->value;
5043                 return true;
5044             }
5045         }
5046         return false;
5047     }
5048 }
5049
5050 /* Appends to 's' a string representation of the OpenFlow port number 'port'.
5051  * Most ports' string representation is just the port number, but for special
5052  * ports, e.g. OFPP_LOCAL, it is the name, e.g. "LOCAL". */
5053 void
5054 ofputil_format_port(ofp_port_t port, struct ds *s)
5055 {
5056     char name[OFP_MAX_PORT_NAME_LEN];
5057
5058     ofputil_port_to_string(port, name, sizeof name);
5059     ds_put_cstr(s, name);
5060 }
5061
5062 /* Puts in the 'bufsize' byte in 'namebuf' a null-terminated string
5063  * representation of OpenFlow port number 'port'.  Most ports are represented
5064  * as just the port number, but special ports, e.g. OFPP_LOCAL, are represented
5065  * by name, e.g. "LOCAL". */
5066 void
5067 ofputil_port_to_string(ofp_port_t port,
5068                        char namebuf[OFP_MAX_PORT_NAME_LEN], size_t bufsize)
5069 {
5070     switch (port) {
5071 #define OFPUTIL_NAMED_PORT(NAME)                        \
5072         case OFPP_##NAME:                               \
5073             ovs_strlcpy(namebuf, #NAME, bufsize);       \
5074             break;
5075         OFPUTIL_NAMED_PORTS
5076 #undef OFPUTIL_NAMED_PORT
5077
5078     default:
5079         snprintf(namebuf, bufsize, "%"PRIu16, port);
5080         break;
5081     }
5082 }
5083
5084 /* Stores the group id represented by 's' into '*group_idp'.  's' may be an
5085  * integer or, for reserved group IDs, the standard OpenFlow name for the group
5086  * (either "ANY" or "ALL").
5087  *
5088  * Returns true if successful, false if 's' is not a valid OpenFlow group ID or
5089  * name. */
5090 bool
5091 ofputil_group_from_string(const char *s, uint32_t *group_idp)
5092 {
5093     if (!strcasecmp(s, "any")) {
5094         *group_idp = OFPG11_ANY;
5095     } else if (!strcasecmp(s, "all")) {
5096         *group_idp = OFPG11_ALL;
5097     } else if (!str_to_uint(s, 10, group_idp)) {
5098         VLOG_WARN("%s is not a valid group ID.  (Valid group IDs are "
5099                   "32-bit nonnegative integers or the keywords ANY or "
5100                   "ALL.)", s);
5101         return false;
5102     }
5103
5104     return true;
5105 }
5106
5107 /* Appends to 's' a string representation of the OpenFlow group ID 'group_id'.
5108  * Most groups' string representation is just the number, but for special
5109  * groups, e.g. OFPG11_ALL, it is the name, e.g. "ALL". */
5110 void
5111 ofputil_format_group(uint32_t group_id, struct ds *s)
5112 {
5113     char name[MAX_GROUP_NAME_LEN];
5114
5115     ofputil_group_to_string(group_id, name, sizeof name);
5116     ds_put_cstr(s, name);
5117 }
5118
5119
5120 /* Puts in the 'bufsize' byte in 'namebuf' a null-terminated string
5121  * representation of OpenFlow group ID 'group_id'.  Most group are represented
5122  * as just their number, but special groups, e.g. OFPG11_ALL, are represented
5123  * by name, e.g. "ALL". */
5124 void
5125 ofputil_group_to_string(uint32_t group_id,
5126                         char namebuf[MAX_GROUP_NAME_LEN + 1], size_t bufsize)
5127 {
5128     switch (group_id) {
5129     case OFPG11_ALL:
5130         ovs_strlcpy(namebuf, "ALL", bufsize);
5131         break;
5132
5133     case OFPG11_ANY:
5134         ovs_strlcpy(namebuf, "ANY", bufsize);
5135         break;
5136
5137     default:
5138         snprintf(namebuf, bufsize, "%"PRIu32, group_id);
5139         break;
5140     }
5141 }
5142
5143 /* Given a buffer 'b' that contains an array of OpenFlow ports of type
5144  * 'ofp_version', tries to pull the first element from the array.  If
5145  * successful, initializes '*pp' with an abstract representation of the
5146  * port and returns 0.  If no ports remain to be decoded, returns EOF.
5147  * On an error, returns a positive OFPERR_* value. */
5148 int
5149 ofputil_pull_phy_port(enum ofp_version ofp_version, struct ofpbuf *b,
5150                       struct ofputil_phy_port *pp)
5151 {
5152     switch (ofp_version) {
5153     case OFP10_VERSION: {
5154         const struct ofp10_phy_port *opp = ofpbuf_try_pull(b, sizeof *opp);
5155         return opp ? ofputil_decode_ofp10_phy_port(pp, opp) : EOF;
5156     }
5157     case OFP11_VERSION:
5158     case OFP12_VERSION:
5159     case OFP13_VERSION: {
5160         const struct ofp11_port *op = ofpbuf_try_pull(b, sizeof *op);
5161         return op ? ofputil_decode_ofp11_port(pp, op) : EOF;
5162     }
5163     default:
5164         OVS_NOT_REACHED();
5165     }
5166 }
5167
5168 /* Given a buffer 'b' that contains an array of OpenFlow ports of type
5169  * 'ofp_version', returns the number of elements. */
5170 size_t ofputil_count_phy_ports(uint8_t ofp_version, struct ofpbuf *b)
5171 {
5172     return b->size / ofputil_get_phy_port_size(ofp_version);
5173 }
5174
5175 /* ofp-util.def lists the mapping from names to action. */
5176 static const char *const names[OFPUTIL_N_ACTIONS] = {
5177     NULL,
5178 #define OFPAT10_ACTION(ENUM, STRUCT, NAME)             NAME,
5179 #define OFPAT11_ACTION(ENUM, STRUCT, EXTENSIBLE, NAME) NAME,
5180 #define NXAST_ACTION(ENUM, STRUCT, EXTENSIBLE, NAME)   NAME,
5181 #include "ofp-util.def"
5182 };
5183
5184 /* Returns the 'enum ofputil_action_code' corresponding to 'name' (e.g. if
5185  * 'name' is "output" then the return value is OFPUTIL_OFPAT10_OUTPUT), or -1
5186  * if 'name' is not the name of any action. */
5187 int
5188 ofputil_action_code_from_name(const char *name)
5189 {
5190     const char *const *p;
5191
5192     for (p = names; p < &names[ARRAY_SIZE(names)]; p++) {
5193         if (*p && !strcasecmp(name, *p)) {
5194             return p - names;
5195         }
5196     }
5197     return -1;
5198 }
5199
5200 /* Returns name corresponding to the 'enum ofputil_action_code',
5201  * or "Unkonwn action", if the name is not available. */
5202 const char *
5203 ofputil_action_name_from_code(enum ofputil_action_code code)
5204 {
5205     return code < (int)OFPUTIL_N_ACTIONS && names[code] ? names[code]
5206         : "Unknown action";
5207 }
5208
5209 /* Appends an action of the type specified by 'code' to 'buf' and returns the
5210  * action.  Initializes the parts of 'action' that identify it as having type
5211  * <ENUM> and length 'sizeof *action' and zeros the rest.  For actions that
5212  * have variable length, the length used and cleared is that of struct
5213  * <STRUCT>.  */
5214 void *
5215 ofputil_put_action(enum ofputil_action_code code, struct ofpbuf *buf)
5216 {
5217     switch (code) {
5218     case OFPUTIL_ACTION_INVALID:
5219         OVS_NOT_REACHED();
5220
5221 #define OFPAT10_ACTION(ENUM, STRUCT, NAME)                  \
5222     case OFPUTIL_##ENUM: return ofputil_put_##ENUM(buf);
5223 #define OFPAT11_ACTION(ENUM, STRUCT, EXTENSIBLE, NAME)      \
5224     case OFPUTIL_##ENUM: return ofputil_put_##ENUM(buf);
5225 #define NXAST_ACTION(ENUM, STRUCT, EXTENSIBLE, NAME)        \
5226     case OFPUTIL_##ENUM: return ofputil_put_##ENUM(buf);
5227 #include "ofp-util.def"
5228     }
5229     OVS_NOT_REACHED();
5230 }
5231
5232 #define OFPAT10_ACTION(ENUM, STRUCT, NAME)                        \
5233     void                                                        \
5234     ofputil_init_##ENUM(struct STRUCT *s)                       \
5235     {                                                           \
5236         memset(s, 0, sizeof *s);                                \
5237         s->type = htons(ENUM);                                  \
5238         s->len = htons(sizeof *s);                              \
5239     }                                                           \
5240                                                                 \
5241     struct STRUCT *                                             \
5242     ofputil_put_##ENUM(struct ofpbuf *buf)                      \
5243     {                                                           \
5244         struct STRUCT *s = ofpbuf_put_uninit(buf, sizeof *s);   \
5245         ofputil_init_##ENUM(s);                                 \
5246         return s;                                               \
5247     }
5248 #define OFPAT11_ACTION(ENUM, STRUCT, EXTENSIBLE, NAME) \
5249     OFPAT10_ACTION(ENUM, STRUCT, NAME)
5250 #define NXAST_ACTION(ENUM, STRUCT, EXTENSIBLE, NAME)            \
5251     void                                                        \
5252     ofputil_init_##ENUM(struct STRUCT *s)                       \
5253     {                                                           \
5254         memset(s, 0, sizeof *s);                                \
5255         s->type = htons(OFPAT10_VENDOR);                        \
5256         s->len = htons(sizeof *s);                              \
5257         s->vendor = htonl(NX_VENDOR_ID);                        \
5258         s->subtype = htons(ENUM);                               \
5259     }                                                           \
5260                                                                 \
5261     struct STRUCT *                                             \
5262     ofputil_put_##ENUM(struct ofpbuf *buf)                      \
5263     {                                                           \
5264         struct STRUCT *s = ofpbuf_put_uninit(buf, sizeof *s);   \
5265         ofputil_init_##ENUM(s);                                 \
5266         return s;                                               \
5267     }
5268 #include "ofp-util.def"
5269
5270 static void
5271 ofputil_normalize_match__(struct match *match, bool may_log)
5272 {
5273     enum {
5274         MAY_NW_ADDR     = 1 << 0, /* nw_src, nw_dst */
5275         MAY_TP_ADDR     = 1 << 1, /* tp_src, tp_dst */
5276         MAY_NW_PROTO    = 1 << 2, /* nw_proto */
5277         MAY_IPVx        = 1 << 3, /* tos, frag, ttl */
5278         MAY_ARP_SHA     = 1 << 4, /* arp_sha */
5279         MAY_ARP_THA     = 1 << 5, /* arp_tha */
5280         MAY_IPV6        = 1 << 6, /* ipv6_src, ipv6_dst, ipv6_label */
5281         MAY_ND_TARGET   = 1 << 7, /* nd_target */
5282         MAY_MPLS        = 1 << 8, /* mpls label and tc */
5283     } may_match;
5284
5285     struct flow_wildcards wc;
5286
5287     /* Figure out what fields may be matched. */
5288     if (match->flow.dl_type == htons(ETH_TYPE_IP)) {
5289         may_match = MAY_NW_PROTO | MAY_IPVx | MAY_NW_ADDR;
5290         if (match->flow.nw_proto == IPPROTO_TCP ||
5291             match->flow.nw_proto == IPPROTO_UDP ||
5292             match->flow.nw_proto == IPPROTO_SCTP ||
5293             match->flow.nw_proto == IPPROTO_ICMP) {
5294             may_match |= MAY_TP_ADDR;
5295         }
5296     } else if (match->flow.dl_type == htons(ETH_TYPE_IPV6)) {
5297         may_match = MAY_NW_PROTO | MAY_IPVx | MAY_IPV6;
5298         if (match->flow.nw_proto == IPPROTO_TCP ||
5299             match->flow.nw_proto == IPPROTO_UDP ||
5300             match->flow.nw_proto == IPPROTO_SCTP) {
5301             may_match |= MAY_TP_ADDR;
5302         } else if (match->flow.nw_proto == IPPROTO_ICMPV6) {
5303             may_match |= MAY_TP_ADDR;
5304             if (match->flow.tp_src == htons(ND_NEIGHBOR_SOLICIT)) {
5305                 may_match |= MAY_ND_TARGET | MAY_ARP_SHA;
5306             } else if (match->flow.tp_src == htons(ND_NEIGHBOR_ADVERT)) {
5307                 may_match |= MAY_ND_TARGET | MAY_ARP_THA;
5308             }
5309         }
5310     } else if (match->flow.dl_type == htons(ETH_TYPE_ARP) ||
5311                match->flow.dl_type == htons(ETH_TYPE_RARP)) {
5312         may_match = MAY_NW_PROTO | MAY_NW_ADDR | MAY_ARP_SHA | MAY_ARP_THA;
5313     } else if (eth_type_mpls(match->flow.dl_type)) {
5314         may_match = MAY_MPLS;
5315     } else {
5316         may_match = 0;
5317     }
5318
5319     /* Clear the fields that may not be matched. */
5320     wc = match->wc;
5321     if (!(may_match & MAY_NW_ADDR)) {
5322         wc.masks.nw_src = wc.masks.nw_dst = htonl(0);
5323     }
5324     if (!(may_match & MAY_TP_ADDR)) {
5325         wc.masks.tp_src = wc.masks.tp_dst = htons(0);
5326     }
5327     if (!(may_match & MAY_NW_PROTO)) {
5328         wc.masks.nw_proto = 0;
5329     }
5330     if (!(may_match & MAY_IPVx)) {
5331         wc.masks.nw_tos = 0;
5332         wc.masks.nw_ttl = 0;
5333     }
5334     if (!(may_match & MAY_ARP_SHA)) {
5335         memset(wc.masks.arp_sha, 0, ETH_ADDR_LEN);
5336     }
5337     if (!(may_match & MAY_ARP_THA)) {
5338         memset(wc.masks.arp_tha, 0, ETH_ADDR_LEN);
5339     }
5340     if (!(may_match & MAY_IPV6)) {
5341         wc.masks.ipv6_src = wc.masks.ipv6_dst = in6addr_any;
5342         wc.masks.ipv6_label = htonl(0);
5343     }
5344     if (!(may_match & MAY_ND_TARGET)) {
5345         wc.masks.nd_target = in6addr_any;
5346     }
5347     if (!(may_match & MAY_MPLS)) {
5348         memset(wc.masks.mpls_lse, 0, sizeof wc.masks.mpls_lse);
5349     }
5350
5351     /* Log any changes. */
5352     if (!flow_wildcards_equal(&wc, &match->wc)) {
5353         bool log = may_log && !VLOG_DROP_INFO(&bad_ofmsg_rl);
5354         char *pre = log ? match_to_string(match, OFP_DEFAULT_PRIORITY) : NULL;
5355
5356         match->wc = wc;
5357         match_zero_wildcarded_fields(match);
5358
5359         if (log) {
5360             char *post = match_to_string(match, OFP_DEFAULT_PRIORITY);
5361             VLOG_INFO("normalization changed ofp_match, details:");
5362             VLOG_INFO(" pre: %s", pre);
5363             VLOG_INFO("post: %s", post);
5364             free(pre);
5365             free(post);
5366         }
5367     }
5368 }
5369
5370 /* "Normalizes" the wildcards in 'match'.  That means:
5371  *
5372  *    1. If the type of level N is known, then only the valid fields for that
5373  *       level may be specified.  For example, ARP does not have a TOS field,
5374  *       so nw_tos must be wildcarded if 'match' specifies an ARP flow.
5375  *       Similarly, IPv4 does not have any IPv6 addresses, so ipv6_src and
5376  *       ipv6_dst (and other fields) must be wildcarded if 'match' specifies an
5377  *       IPv4 flow.
5378  *
5379  *    2. If the type of level N is not known (or not understood by Open
5380  *       vSwitch), then no fields at all for that level may be specified.  For
5381  *       example, Open vSwitch does not understand SCTP, an L4 protocol, so the
5382  *       L4 fields tp_src and tp_dst must be wildcarded if 'match' specifies an
5383  *       SCTP flow.
5384  *
5385  * If this function changes 'match', it logs a rate-limited informational
5386  * message. */
5387 void
5388 ofputil_normalize_match(struct match *match)
5389 {
5390     ofputil_normalize_match__(match, true);
5391 }
5392
5393 /* Same as ofputil_normalize_match() without the logging.  Thus, this function
5394  * is suitable for a program's internal use, whereas ofputil_normalize_match()
5395  * sense for use on flows received from elsewhere (so that a bug in the program
5396  * that sent them can be reported and corrected). */
5397 void
5398 ofputil_normalize_match_quiet(struct match *match)
5399 {
5400     ofputil_normalize_match__(match, false);
5401 }
5402
5403 /* Parses a key or a key-value pair from '*stringp'.
5404  *
5405  * On success: Stores the key into '*keyp'.  Stores the value, if present, into
5406  * '*valuep', otherwise an empty string.  Advances '*stringp' past the end of
5407  * the key-value pair, preparing it for another call.  '*keyp' and '*valuep'
5408  * are substrings of '*stringp' created by replacing some of its bytes by null
5409  * terminators.  Returns true.
5410  *
5411  * If '*stringp' is just white space or commas, sets '*keyp' and '*valuep' to
5412  * NULL and returns false. */
5413 bool
5414 ofputil_parse_key_value(char **stringp, char **keyp, char **valuep)
5415 {
5416     char *pos, *key, *value;
5417     size_t key_len;
5418
5419     pos = *stringp;
5420     pos += strspn(pos, ", \t\r\n");
5421     if (*pos == '\0') {
5422         *keyp = *valuep = NULL;
5423         return false;
5424     }
5425
5426     key = pos;
5427     key_len = strcspn(pos, ":=(, \t\r\n");
5428     if (key[key_len] == ':' || key[key_len] == '=') {
5429         /* The value can be separated by a colon. */
5430         size_t value_len;
5431
5432         value = key + key_len + 1;
5433         value_len = strcspn(value, ", \t\r\n");
5434         pos = value + value_len + (value[value_len] != '\0');
5435         value[value_len] = '\0';
5436     } else if (key[key_len] == '(') {
5437         /* The value can be surrounded by balanced parentheses.  The outermost
5438          * set of parentheses is removed. */
5439         int level = 1;
5440         size_t value_len;
5441
5442         value = key + key_len + 1;
5443         for (value_len = 0; level > 0; value_len++) {
5444             switch (value[value_len]) {
5445             case '\0':
5446                 level = 0;
5447                 break;
5448
5449             case '(':
5450                 level++;
5451                 break;
5452
5453             case ')':
5454                 level--;
5455                 break;
5456             }
5457         }
5458         value[value_len - 1] = '\0';
5459         pos = value + value_len;
5460     } else {
5461         /* There might be no value at all. */
5462         value = key + key_len;  /* Will become the empty string below. */
5463         pos = key + key_len + (key[key_len] != '\0');
5464     }
5465     key[key_len] = '\0';
5466
5467     *stringp = pos;
5468     *keyp = key;
5469     *valuep = value;
5470     return true;
5471 }
5472
5473 /* Encode a dump ports request for 'port', the encoded message
5474  * will be for Open Flow version 'ofp_version'. Returns message
5475  * as a struct ofpbuf. Returns encoded message on success, NULL on error */
5476 struct ofpbuf *
5477 ofputil_encode_dump_ports_request(enum ofp_version ofp_version, ofp_port_t port)
5478 {
5479     struct ofpbuf *request;
5480
5481     switch (ofp_version) {
5482     case OFP10_VERSION: {
5483         struct ofp10_port_stats_request *req;
5484         request = ofpraw_alloc(OFPRAW_OFPST10_PORT_REQUEST, ofp_version, 0);
5485         req = ofpbuf_put_zeros(request, sizeof *req);
5486         req->port_no = htons(ofp_to_u16(port));
5487         break;
5488     }
5489     case OFP11_VERSION:
5490     case OFP12_VERSION:
5491     case OFP13_VERSION: {
5492         struct ofp11_port_stats_request *req;
5493         request = ofpraw_alloc(OFPRAW_OFPST11_PORT_REQUEST, ofp_version, 0);
5494         req = ofpbuf_put_zeros(request, sizeof *req);
5495         req->port_no = ofputil_port_to_ofp11(port);
5496         break;
5497     }
5498     default:
5499         OVS_NOT_REACHED();
5500     }
5501
5502     return request;
5503 }
5504
5505 static void
5506 ofputil_port_stats_to_ofp10(const struct ofputil_port_stats *ops,
5507                             struct ofp10_port_stats *ps10)
5508 {
5509     ps10->port_no = htons(ofp_to_u16(ops->port_no));
5510     memset(ps10->pad, 0, sizeof ps10->pad);
5511     put_32aligned_be64(&ps10->rx_packets, htonll(ops->stats.rx_packets));
5512     put_32aligned_be64(&ps10->tx_packets, htonll(ops->stats.tx_packets));
5513     put_32aligned_be64(&ps10->rx_bytes, htonll(ops->stats.rx_bytes));
5514     put_32aligned_be64(&ps10->tx_bytes, htonll(ops->stats.tx_bytes));
5515     put_32aligned_be64(&ps10->rx_dropped, htonll(ops->stats.rx_dropped));
5516     put_32aligned_be64(&ps10->tx_dropped, htonll(ops->stats.tx_dropped));
5517     put_32aligned_be64(&ps10->rx_errors, htonll(ops->stats.rx_errors));
5518     put_32aligned_be64(&ps10->tx_errors, htonll(ops->stats.tx_errors));
5519     put_32aligned_be64(&ps10->rx_frame_err, htonll(ops->stats.rx_frame_errors));
5520     put_32aligned_be64(&ps10->rx_over_err, htonll(ops->stats.rx_over_errors));
5521     put_32aligned_be64(&ps10->rx_crc_err, htonll(ops->stats.rx_crc_errors));
5522     put_32aligned_be64(&ps10->collisions, htonll(ops->stats.collisions));
5523 }
5524
5525 static void
5526 ofputil_port_stats_to_ofp11(const struct ofputil_port_stats *ops,
5527                             struct ofp11_port_stats *ps11)
5528 {
5529     ps11->port_no = ofputil_port_to_ofp11(ops->port_no);
5530     memset(ps11->pad, 0, sizeof ps11->pad);
5531     ps11->rx_packets = htonll(ops->stats.rx_packets);
5532     ps11->tx_packets = htonll(ops->stats.tx_packets);
5533     ps11->rx_bytes = htonll(ops->stats.rx_bytes);
5534     ps11->tx_bytes = htonll(ops->stats.tx_bytes);
5535     ps11->rx_dropped = htonll(ops->stats.rx_dropped);
5536     ps11->tx_dropped = htonll(ops->stats.tx_dropped);
5537     ps11->rx_errors = htonll(ops->stats.rx_errors);
5538     ps11->tx_errors = htonll(ops->stats.tx_errors);
5539     ps11->rx_frame_err = htonll(ops->stats.rx_frame_errors);
5540     ps11->rx_over_err = htonll(ops->stats.rx_over_errors);
5541     ps11->rx_crc_err = htonll(ops->stats.rx_crc_errors);
5542     ps11->collisions = htonll(ops->stats.collisions);
5543 }
5544
5545 static void
5546 ofputil_port_stats_to_ofp13(const struct ofputil_port_stats *ops,
5547                             struct ofp13_port_stats *ps13)
5548 {
5549     ofputil_port_stats_to_ofp11(ops, &ps13->ps);
5550     ps13->duration_sec = htonl(ops->duration_sec);
5551     ps13->duration_nsec = htonl(ops->duration_nsec);
5552 }
5553
5554
5555 /* Encode a ports stat for 'ops' and append it to 'replies'. */
5556 void
5557 ofputil_append_port_stat(struct list *replies,
5558                          const struct ofputil_port_stats *ops)
5559 {
5560     struct ofpbuf *msg = ofpbuf_from_list(list_back(replies));
5561     struct ofp_header *oh = msg->data;
5562
5563     switch ((enum ofp_version)oh->version) {
5564     case OFP13_VERSION: {
5565         struct ofp13_port_stats *reply = ofpmp_append(replies, sizeof *reply);
5566         ofputil_port_stats_to_ofp13(ops, reply);
5567         break;
5568     }
5569     case OFP12_VERSION:
5570     case OFP11_VERSION: {
5571         struct ofp11_port_stats *reply = ofpmp_append(replies, sizeof *reply);
5572         ofputil_port_stats_to_ofp11(ops, reply);
5573         break;
5574     }
5575
5576     case OFP10_VERSION: {
5577         struct ofp10_port_stats *reply = ofpmp_append(replies, sizeof *reply);
5578         ofputil_port_stats_to_ofp10(ops, reply);
5579         break;
5580     }
5581
5582     default:
5583         OVS_NOT_REACHED();
5584     }
5585 }
5586
5587 static enum ofperr
5588 ofputil_port_stats_from_ofp10(struct ofputil_port_stats *ops,
5589                               const struct ofp10_port_stats *ps10)
5590 {
5591     memset(ops, 0, sizeof *ops);
5592
5593     ops->port_no = u16_to_ofp(ntohs(ps10->port_no));
5594     ops->stats.rx_packets = ntohll(get_32aligned_be64(&ps10->rx_packets));
5595     ops->stats.tx_packets = ntohll(get_32aligned_be64(&ps10->tx_packets));
5596     ops->stats.rx_bytes = ntohll(get_32aligned_be64(&ps10->rx_bytes));
5597     ops->stats.tx_bytes = ntohll(get_32aligned_be64(&ps10->tx_bytes));
5598     ops->stats.rx_dropped = ntohll(get_32aligned_be64(&ps10->rx_dropped));
5599     ops->stats.tx_dropped = ntohll(get_32aligned_be64(&ps10->tx_dropped));
5600     ops->stats.rx_errors = ntohll(get_32aligned_be64(&ps10->rx_errors));
5601     ops->stats.tx_errors = ntohll(get_32aligned_be64(&ps10->tx_errors));
5602     ops->stats.rx_frame_errors =
5603         ntohll(get_32aligned_be64(&ps10->rx_frame_err));
5604     ops->stats.rx_over_errors = ntohll(get_32aligned_be64(&ps10->rx_over_err));
5605     ops->stats.rx_crc_errors = ntohll(get_32aligned_be64(&ps10->rx_crc_err));
5606     ops->stats.collisions = ntohll(get_32aligned_be64(&ps10->collisions));
5607     ops->duration_sec = ops->duration_nsec = UINT32_MAX;
5608
5609     return 0;
5610 }
5611
5612 static enum ofperr
5613 ofputil_port_stats_from_ofp11(struct ofputil_port_stats *ops,
5614                               const struct ofp11_port_stats *ps11)
5615 {
5616     enum ofperr error;
5617
5618     memset(ops, 0, sizeof *ops);
5619     error = ofputil_port_from_ofp11(ps11->port_no, &ops->port_no);
5620     if (error) {
5621         return error;
5622     }
5623
5624     ops->stats.rx_packets = ntohll(ps11->rx_packets);
5625     ops->stats.tx_packets = ntohll(ps11->tx_packets);
5626     ops->stats.rx_bytes = ntohll(ps11->rx_bytes);
5627     ops->stats.tx_bytes = ntohll(ps11->tx_bytes);
5628     ops->stats.rx_dropped = ntohll(ps11->rx_dropped);
5629     ops->stats.tx_dropped = ntohll(ps11->tx_dropped);
5630     ops->stats.rx_errors = ntohll(ps11->rx_errors);
5631     ops->stats.tx_errors = ntohll(ps11->tx_errors);
5632     ops->stats.rx_frame_errors = ntohll(ps11->rx_frame_err);
5633     ops->stats.rx_over_errors = ntohll(ps11->rx_over_err);
5634     ops->stats.rx_crc_errors = ntohll(ps11->rx_crc_err);
5635     ops->stats.collisions = ntohll(ps11->collisions);
5636     ops->duration_sec = ops->duration_nsec = UINT32_MAX;
5637
5638     return 0;
5639 }
5640
5641 static enum ofperr
5642 ofputil_port_stats_from_ofp13(struct ofputil_port_stats *ops,
5643                               const struct ofp13_port_stats *ps13)
5644 {
5645     enum ofperr error = ofputil_port_stats_from_ofp11(ops, &ps13->ps);
5646     if (!error) {
5647         ops->duration_sec = ntohl(ps13->duration_sec);
5648         ops->duration_nsec = ntohl(ps13->duration_nsec);
5649     }
5650     return error;
5651 }
5652
5653 static size_t
5654 ofputil_get_port_stats_size(enum ofp_version ofp_version)
5655 {
5656     switch (ofp_version) {
5657     case OFP10_VERSION:
5658         return sizeof(struct ofp10_port_stats);
5659     case OFP11_VERSION:
5660     case OFP12_VERSION:
5661         return sizeof(struct ofp11_port_stats);
5662     case OFP13_VERSION:
5663         return sizeof(struct ofp13_port_stats);
5664     default:
5665         OVS_NOT_REACHED();
5666     }
5667 }
5668
5669 /* Returns the number of port stats elements in OFPTYPE_PORT_STATS_REPLY
5670  * message 'oh'. */
5671 size_t
5672 ofputil_count_port_stats(const struct ofp_header *oh)
5673 {
5674     struct ofpbuf b;
5675
5676     ofpbuf_use_const(&b, oh, ntohs(oh->length));
5677     ofpraw_pull_assert(&b);
5678
5679     return b.size / ofputil_get_port_stats_size(oh->version);
5680 }
5681
5682 /* Converts an OFPST_PORT_STATS reply in 'msg' into an abstract
5683  * ofputil_port_stats in 'ps'.
5684  *
5685  * Multiple OFPST_PORT_STATS replies can be packed into a single OpenFlow
5686  * message.  Calling this function multiple times for a single 'msg' iterates
5687  * through the replies.  The caller must initially leave 'msg''s layer pointers
5688  * null and not modify them between calls.
5689  *
5690  * Returns 0 if successful, EOF if no replies were left in this 'msg',
5691  * otherwise a positive errno value. */
5692 int
5693 ofputil_decode_port_stats(struct ofputil_port_stats *ps, struct ofpbuf *msg)
5694 {
5695     enum ofperr error;
5696     enum ofpraw raw;
5697
5698     error = (msg->l2
5699              ? ofpraw_decode(&raw, msg->l2)
5700              : ofpraw_pull(&raw, msg));
5701     if (error) {
5702         return error;
5703     }
5704
5705     if (!msg->size) {
5706         return EOF;
5707     } else if (raw == OFPRAW_OFPST13_PORT_REPLY) {
5708         const struct ofp13_port_stats *ps13;
5709
5710         ps13 = ofpbuf_try_pull(msg, sizeof *ps13);
5711         if (!ps13) {
5712             goto bad_len;
5713         }
5714         return ofputil_port_stats_from_ofp13(ps, ps13);
5715     } else if (raw == OFPRAW_OFPST11_PORT_REPLY) {
5716         const struct ofp11_port_stats *ps11;
5717
5718         ps11 = ofpbuf_try_pull(msg, sizeof *ps11);
5719         if (!ps11) {
5720             goto bad_len;
5721         }
5722         return ofputil_port_stats_from_ofp11(ps, ps11);
5723     } else if (raw == OFPRAW_OFPST10_PORT_REPLY) {
5724         const struct ofp10_port_stats *ps10;
5725
5726         ps10 = ofpbuf_try_pull(msg, sizeof *ps10);
5727         if (!ps10) {
5728             goto bad_len;
5729         }
5730         return ofputil_port_stats_from_ofp10(ps, ps10);
5731     } else {
5732         OVS_NOT_REACHED();
5733     }
5734
5735  bad_len:
5736     VLOG_WARN_RL(&bad_ofmsg_rl, "OFPST_PORT reply has %"PRIuSIZE" leftover "
5737                  "bytes at end", msg->size);
5738     return OFPERR_OFPBRC_BAD_LEN;
5739 }
5740
5741 /* Parse a port status request message into a 16 bit OpenFlow 1.0
5742  * port number and stores the latter in '*ofp10_port'.
5743  * Returns 0 if successful, otherwise an OFPERR_* number. */
5744 enum ofperr
5745 ofputil_decode_port_stats_request(const struct ofp_header *request,
5746                                   ofp_port_t *ofp10_port)
5747 {
5748     switch ((enum ofp_version)request->version) {
5749     case OFP13_VERSION:
5750     case OFP12_VERSION:
5751     case OFP11_VERSION: {
5752         const struct ofp11_port_stats_request *psr11 = ofpmsg_body(request);
5753         return ofputil_port_from_ofp11(psr11->port_no, ofp10_port);
5754     }
5755
5756     case OFP10_VERSION: {
5757         const struct ofp10_port_stats_request *psr10 = ofpmsg_body(request);
5758         *ofp10_port = u16_to_ofp(ntohs(psr10->port_no));
5759         return 0;
5760     }
5761
5762     default:
5763         OVS_NOT_REACHED();
5764     }
5765 }
5766
5767 /* Frees all of the "struct ofputil_bucket"s in the 'buckets' list. */
5768 void
5769 ofputil_bucket_list_destroy(struct list *buckets)
5770 {
5771     struct ofputil_bucket *bucket, *next_bucket;
5772
5773     LIST_FOR_EACH_SAFE (bucket, next_bucket, list_node, buckets) {
5774         list_remove(&bucket->list_node);
5775         free(bucket->ofpacts);
5776         free(bucket);
5777     }
5778 }
5779
5780 /* Returns an OpenFlow group stats request for OpenFlow version 'ofp_version',
5781  * that requests stats for group 'group_id'.  (Use OFPG_ALL to request stats
5782  * for all groups.)
5783  *
5784  * Group statistics include packet and byte counts for each group. */
5785 struct ofpbuf *
5786 ofputil_encode_group_stats_request(enum ofp_version ofp_version,
5787                                    uint32_t group_id)
5788 {
5789     struct ofpbuf *request;
5790
5791     switch (ofp_version) {
5792     case OFP10_VERSION:
5793         ovs_fatal(0, "dump-group-stats needs OpenFlow 1.1 or later "
5794                      "(\'-O OpenFlow11\')");
5795     case OFP11_VERSION:
5796     case OFP12_VERSION:
5797     case OFP13_VERSION: {
5798         struct ofp11_group_stats_request *req;
5799         request = ofpraw_alloc(OFPRAW_OFPST11_GROUP_REQUEST, ofp_version, 0);
5800         req = ofpbuf_put_zeros(request, sizeof *req);
5801         req->group_id = htonl(group_id);
5802         break;
5803     }
5804     default:
5805         OVS_NOT_REACHED();
5806     }
5807
5808     return request;
5809 }
5810
5811 /* Returns an OpenFlow group description request for OpenFlow version
5812  * 'ofp_version', that requests stats for group 'group_id'.  (Use OFPG_ALL to
5813  * request stats for all groups.)
5814  *
5815  * Group descriptions include the bucket and action configuration for each
5816  * group. */
5817 struct ofpbuf *
5818 ofputil_encode_group_desc_request(enum ofp_version ofp_version)
5819 {
5820     struct ofpbuf *request;
5821
5822     switch (ofp_version) {
5823     case OFP10_VERSION:
5824         ovs_fatal(0, "dump-groups needs OpenFlow 1.1 or later "
5825                      "(\'-O OpenFlow11\')");
5826     case OFP11_VERSION:
5827     case OFP12_VERSION:
5828     case OFP13_VERSION: {
5829         request = ofpraw_alloc(OFPRAW_OFPST11_GROUP_DESC_REQUEST, ofp_version, 0);
5830         break;
5831     }
5832     default:
5833         OVS_NOT_REACHED();
5834     }
5835
5836     return request;
5837 }
5838
5839 static void *
5840 ofputil_group_stats_to_ofp11(const struct ofputil_group_stats *ogs,
5841                              size_t base_len, struct list *replies)
5842 {
5843     struct ofp11_bucket_counter *bc11;
5844     struct ofp11_group_stats *gs11;
5845     size_t length;
5846     int i;
5847
5848     length = base_len + sizeof(struct ofp11_bucket_counter) * ogs->n_buckets;
5849
5850     gs11 = ofpmp_append(replies, length);
5851     memset(gs11, 0, base_len);
5852     gs11->length = htons(length);
5853     gs11->group_id = htonl(ogs->group_id);
5854     gs11->ref_count = htonl(ogs->ref_count);
5855     gs11->packet_count = htonll(ogs->packet_count);
5856     gs11->byte_count = htonll(ogs->byte_count);
5857
5858     bc11 = (void *) (((uint8_t *) gs11) + base_len);
5859     for (i = 0; i < ogs->n_buckets; i++) {
5860         const struct bucket_counter *obc = &ogs->bucket_stats[i];
5861
5862         bc11[i].packet_count = htonll(obc->packet_count);
5863         bc11[i].byte_count = htonll(obc->byte_count);
5864     }
5865
5866     return gs11;
5867 }
5868
5869 static void
5870 ofputil_append_of13_group_stats(const struct ofputil_group_stats *ogs,
5871                                 struct list *replies)
5872 {
5873     struct ofp13_group_stats *gs13;
5874
5875     gs13 = ofputil_group_stats_to_ofp11(ogs, sizeof *gs13, replies);
5876     gs13->duration_sec = htonl(ogs->duration_sec);
5877     gs13->duration_nsec = htonl(ogs->duration_nsec);
5878 }
5879
5880 /* Encodes 'ogs' properly for the format of the list of group statistics
5881  * replies already begun in 'replies' and appends it to the list.  'replies'
5882  * must have originally been initialized with ofpmp_init(). */
5883 void
5884 ofputil_append_group_stats(struct list *replies,
5885                            const struct ofputil_group_stats *ogs)
5886 {
5887     struct ofpbuf *msg = ofpbuf_from_list(list_back(replies));
5888     struct ofp_header *oh = msg->data;
5889
5890     switch ((enum ofp_version)oh->version) {
5891     case OFP11_VERSION:
5892     case OFP12_VERSION:
5893         ofputil_group_stats_to_ofp11(ogs, sizeof(struct ofp11_group_stats),
5894                                      replies);
5895         break;
5896
5897     case OFP13_VERSION:
5898         ofputil_append_of13_group_stats(ogs, replies);
5899         break;
5900
5901     case OFP10_VERSION:
5902     default:
5903         OVS_NOT_REACHED();
5904     }
5905 }
5906
5907 /* Returns an OpenFlow group features request for OpenFlow version
5908  * 'ofp_version'. */
5909 struct ofpbuf *
5910 ofputil_encode_group_features_request(enum ofp_version ofp_version)
5911 {
5912     struct ofpbuf *request = NULL;
5913
5914     switch (ofp_version) {
5915     case OFP10_VERSION:
5916     case OFP11_VERSION:
5917         ovs_fatal(0, "dump-group-features needs OpenFlow 1.2 or later "
5918                      "(\'-O OpenFlow12\')");
5919     case OFP12_VERSION:
5920     case OFP13_VERSION: {
5921         request = ofpraw_alloc(OFPRAW_OFPST12_GROUP_FEATURES_REQUEST,
5922                                         ofp_version, 0);
5923         break;
5924     }
5925     default:
5926         OVS_NOT_REACHED();
5927     }
5928
5929     return request;
5930 }
5931
5932 /* Returns a OpenFlow message that encodes 'features' properly as a reply to
5933  * group features request 'request'. */
5934 struct ofpbuf *
5935 ofputil_encode_group_features_reply(
5936     const struct ofputil_group_features *features,
5937     const struct ofp_header *request)
5938 {
5939     struct ofp12_group_features_stats *ogf;
5940     struct ofpbuf *reply;
5941
5942     reply = ofpraw_alloc_xid(OFPRAW_OFPST12_GROUP_FEATURES_REPLY,
5943                              request->version, request->xid, 0);
5944     ogf = ofpbuf_put_zeros(reply, sizeof *ogf);
5945     ogf->types = htonl(features->types);
5946     ogf->capabilities = htonl(features->capabilities);
5947     ogf->max_groups[0] = htonl(features->max_groups[0]);
5948     ogf->max_groups[1] = htonl(features->max_groups[1]);
5949     ogf->max_groups[2] = htonl(features->max_groups[2]);
5950     ogf->max_groups[3] = htonl(features->max_groups[3]);
5951     ogf->actions[0] = htonl(features->actions[0]);
5952     ogf->actions[1] = htonl(features->actions[1]);
5953     ogf->actions[2] = htonl(features->actions[2]);
5954     ogf->actions[3] = htonl(features->actions[3]);
5955
5956     return reply;
5957 }
5958
5959 /* Decodes group features reply 'oh' into 'features'. */
5960 void
5961 ofputil_decode_group_features_reply(const struct ofp_header *oh,
5962                                     struct ofputil_group_features *features)
5963 {
5964     const struct ofp12_group_features_stats *ogf = ofpmsg_body(oh);
5965
5966     features->types = ntohl(ogf->types);
5967     features->capabilities = ntohl(ogf->capabilities);
5968     features->max_groups[0] = ntohl(ogf->max_groups[0]);
5969     features->max_groups[1] = ntohl(ogf->max_groups[1]);
5970     features->max_groups[2] = ntohl(ogf->max_groups[2]);
5971     features->max_groups[3] = ntohl(ogf->max_groups[3]);
5972     features->actions[0] = ntohl(ogf->actions[0]);
5973     features->actions[1] = ntohl(ogf->actions[1]);
5974     features->actions[2] = ntohl(ogf->actions[2]);
5975     features->actions[3] = ntohl(ogf->actions[3]);
5976 }
5977
5978 /* Parse a group status request message into a 32 bit OpenFlow 1.1
5979  * group ID and stores the latter in '*group_id'.
5980  * Returns 0 if successful, otherwise an OFPERR_* number. */
5981 enum ofperr
5982 ofputil_decode_group_stats_request(const struct ofp_header *request,
5983                                    uint32_t *group_id)
5984 {
5985     const struct ofp11_group_stats_request *gsr11 = ofpmsg_body(request);
5986     *group_id = ntohl(gsr11->group_id);
5987     return 0;
5988 }
5989
5990 /* Converts a group stats reply in 'msg' into an abstract ofputil_group_stats
5991  * in 'gs'.  Assigns freshly allocated memory to gs->bucket_stats for the
5992  * caller to eventually free.
5993  *
5994  * Multiple group stats replies can be packed into a single OpenFlow message.
5995  * Calling this function multiple times for a single 'msg' iterates through the
5996  * replies.  The caller must initially leave 'msg''s layer pointers null and
5997  * not modify them between calls.
5998  *
5999  * Returns 0 if successful, EOF if no replies were left in this 'msg',
6000  * otherwise a positive errno value. */
6001 int
6002 ofputil_decode_group_stats_reply(struct ofpbuf *msg,
6003                                  struct ofputil_group_stats *gs)
6004 {
6005     struct ofp11_bucket_counter *obc;
6006     struct ofp11_group_stats *ogs11;
6007     enum ofpraw raw;
6008     enum ofperr error;
6009     size_t base_len;
6010     size_t length;
6011     size_t i;
6012
6013     gs->bucket_stats = NULL;
6014     error = (msg->l2
6015              ? ofpraw_decode(&raw, msg->l2)
6016              : ofpraw_pull(&raw, msg));
6017     if (error) {
6018         return error;
6019     }
6020
6021     if (!msg->size) {
6022         return EOF;
6023     }
6024
6025     if (raw == OFPRAW_OFPST11_GROUP_REPLY) {
6026         base_len = sizeof *ogs11;
6027         ogs11 = ofpbuf_try_pull(msg, sizeof *ogs11);
6028         gs->duration_sec = gs->duration_nsec = UINT32_MAX;
6029     } else if (raw == OFPRAW_OFPST13_GROUP_REPLY) {
6030         struct ofp13_group_stats *ogs13;
6031
6032         base_len = sizeof *ogs13;
6033         ogs13 = ofpbuf_try_pull(msg, sizeof *ogs13);
6034         if (ogs13) {
6035             ogs11 = &ogs13->gs;
6036             gs->duration_sec = ntohl(ogs13->duration_sec);
6037             gs->duration_nsec = ntohl(ogs13->duration_nsec);
6038         } else {
6039             ogs11 = NULL;
6040         }
6041     } else {
6042         OVS_NOT_REACHED();
6043     }
6044
6045     if (!ogs11) {
6046         VLOG_WARN_RL(&bad_ofmsg_rl, "%s reply has %"PRIuSIZE" leftover bytes at end",
6047                      ofpraw_get_name(raw), msg->size);
6048         return OFPERR_OFPBRC_BAD_LEN;
6049     }
6050     length = ntohs(ogs11->length);
6051     if (length < sizeof base_len) {
6052         VLOG_WARN_RL(&bad_ofmsg_rl, "%s reply claims invalid length %"PRIuSIZE,
6053                      ofpraw_get_name(raw), length);
6054         return OFPERR_OFPBRC_BAD_LEN;
6055     }
6056
6057     gs->group_id = ntohl(ogs11->group_id);
6058     gs->ref_count = ntohl(ogs11->ref_count);
6059     gs->packet_count = ntohll(ogs11->packet_count);
6060     gs->byte_count = ntohll(ogs11->byte_count);
6061
6062     gs->n_buckets = (length - base_len) / sizeof *obc;
6063     obc = ofpbuf_try_pull(msg, gs->n_buckets * sizeof *obc);
6064     if (!obc) {
6065         VLOG_WARN_RL(&bad_ofmsg_rl, "%s reply has %"PRIuSIZE" leftover bytes at end",
6066                      ofpraw_get_name(raw), msg->size);
6067         return OFPERR_OFPBRC_BAD_LEN;
6068     }
6069
6070     gs->bucket_stats = xmalloc(gs->n_buckets * sizeof *gs->bucket_stats);
6071     for (i = 0; i < gs->n_buckets; i++) {
6072         gs->bucket_stats[i].packet_count = ntohll(obc[i].packet_count);
6073         gs->bucket_stats[i].byte_count = ntohll(obc[i].byte_count);
6074     }
6075
6076     return 0;
6077 }
6078
6079 /* Appends a group stats reply that contains the data in 'gds' to those already
6080  * present in the list of ofpbufs in 'replies'.  'replies' should have been
6081  * initialized with ofpmp_init(). */
6082 void
6083 ofputil_append_group_desc_reply(const struct ofputil_group_desc *gds,
6084                                 struct list *buckets,
6085                                 struct list *replies)
6086 {
6087     struct ofpbuf *reply = ofpbuf_from_list(list_back(replies));
6088     struct ofp11_group_desc_stats *ogds;
6089     struct ofputil_bucket *bucket;
6090     size_t start_ogds;
6091     enum ofp_version version = ((struct ofp_header *)reply->data)->version;
6092
6093     start_ogds = reply->size;
6094     ofpbuf_put_zeros(reply, sizeof *ogds);
6095     LIST_FOR_EACH (bucket, list_node, buckets) {
6096         struct ofp11_bucket *ob;
6097         size_t start_ob;
6098
6099         start_ob = reply->size;
6100         ofpbuf_put_zeros(reply, sizeof *ob);
6101         ofpacts_put_openflow_actions(bucket->ofpacts, bucket->ofpacts_len,
6102                                      reply, version);
6103         ob = ofpbuf_at_assert(reply, start_ob, sizeof *ob);
6104         ob->len = htons(reply->size - start_ob);
6105         ob->weight = htons(bucket->weight);
6106         ob->watch_port = ofputil_port_to_ofp11(bucket->watch_port);
6107         ob->watch_group = htonl(bucket->watch_group);
6108     }
6109     ogds = ofpbuf_at_assert(reply, start_ogds, sizeof *ogds);
6110     ogds->length = htons(reply->size - start_ogds);
6111     ogds->type = gds->type;
6112     ogds->group_id = htonl(gds->group_id);
6113
6114     ofpmp_postappend(replies, start_ogds);
6115 }
6116
6117 static enum ofperr
6118 ofputil_pull_buckets(struct ofpbuf *msg, size_t buckets_length,
6119                      enum ofp_version version, struct list *buckets)
6120 {
6121     struct ofp11_bucket *ob;
6122
6123     list_init(buckets);
6124     while (buckets_length > 0) {
6125         struct ofputil_bucket *bucket;
6126         struct ofpbuf ofpacts;
6127         enum ofperr error;
6128         size_t ob_len;
6129
6130         ob = (buckets_length >= sizeof *ob
6131               ? ofpbuf_try_pull(msg, sizeof *ob)
6132               : NULL);
6133         if (!ob) {
6134             VLOG_WARN_RL(&bad_ofmsg_rl, "buckets end with %"PRIuSIZE" leftover bytes",
6135                          buckets_length);
6136         }
6137
6138         ob_len = ntohs(ob->len);
6139         if (ob_len < sizeof *ob) {
6140             VLOG_WARN_RL(&bad_ofmsg_rl, "OpenFlow message bucket length "
6141                          "%"PRIuSIZE" is not valid", ob_len);
6142             return OFPERR_OFPGMFC_BAD_BUCKET;
6143         } else if (ob_len > buckets_length) {
6144             VLOG_WARN_RL(&bad_ofmsg_rl, "OpenFlow message bucket length "
6145                          "%"PRIuSIZE" exceeds remaining buckets data size %"PRIuSIZE,
6146                          ob_len, buckets_length);
6147             return OFPERR_OFPGMFC_BAD_BUCKET;
6148         }
6149         buckets_length -= ob_len;
6150
6151         ofpbuf_init(&ofpacts, 0);
6152         error = ofpacts_pull_openflow_actions(msg, ob_len - sizeof *ob,
6153                                               version, &ofpacts);
6154         if (error) {
6155             ofpbuf_uninit(&ofpacts);
6156             ofputil_bucket_list_destroy(buckets);
6157             return error;
6158         }
6159
6160         bucket = xzalloc(sizeof *bucket);
6161         bucket->weight = ntohs(ob->weight);
6162         error = ofputil_port_from_ofp11(ob->watch_port, &bucket->watch_port);
6163         if (error) {
6164             ofpbuf_uninit(&ofpacts);
6165             ofputil_bucket_list_destroy(buckets);
6166             return OFPERR_OFPGMFC_BAD_WATCH;
6167         }
6168         bucket->watch_group = ntohl(ob->watch_group);
6169         bucket->ofpacts = ofpbuf_steal_data(&ofpacts);
6170         bucket->ofpacts_len = ofpacts.size;
6171         list_push_back(buckets, &bucket->list_node);
6172     }
6173
6174     return 0;
6175 }
6176
6177 /* Converts a group description reply in 'msg' into an abstract
6178  * ofputil_group_desc in 'gd'.
6179  *
6180  * Multiple group description replies can be packed into a single OpenFlow
6181  * message.  Calling this function multiple times for a single 'msg' iterates
6182  * through the replies.  The caller must initially leave 'msg''s layer pointers
6183  * null and not modify them between calls.
6184  *
6185  * Returns 0 if successful, EOF if no replies were left in this 'msg',
6186  * otherwise a positive errno value. */
6187 int
6188 ofputil_decode_group_desc_reply(struct ofputil_group_desc *gd,
6189                                 struct ofpbuf *msg, enum ofp_version version)
6190 {
6191     struct ofp11_group_desc_stats *ogds;
6192     size_t length;
6193
6194     if (!msg->l2) {
6195         ofpraw_pull_assert(msg);
6196     }
6197
6198     if (!msg->size) {
6199         return EOF;
6200     }
6201
6202     ogds = ofpbuf_try_pull(msg, sizeof *ogds);
6203     if (!ogds) {
6204         VLOG_WARN_RL(&bad_ofmsg_rl, "OFPST11_GROUP_DESC reply has %"PRIuSIZE" "
6205                      "leftover bytes at end", msg->size);
6206         return OFPERR_OFPBRC_BAD_LEN;
6207     }
6208     gd->type = ogds->type;
6209     gd->group_id = ntohl(ogds->group_id);
6210
6211     length = ntohs(ogds->length);
6212     if (length < sizeof *ogds || length - sizeof *ogds > msg->size) {
6213         VLOG_WARN_RL(&bad_ofmsg_rl, "OFPST11_GROUP_DESC reply claims invalid "
6214                      "length %"PRIuSIZE, length);
6215         return OFPERR_OFPBRC_BAD_LEN;
6216     }
6217
6218     return ofputil_pull_buckets(msg, length - sizeof *ogds, version,
6219                                 &gd->buckets);
6220 }
6221
6222 /* Converts abstract group mod 'gm' into a message for OpenFlow version
6223  * 'ofp_version' and returns the message. */
6224 struct ofpbuf *
6225 ofputil_encode_group_mod(enum ofp_version ofp_version,
6226                          const struct ofputil_group_mod *gm)
6227 {
6228     struct ofpbuf *b;
6229     struct ofp11_group_mod *ogm;
6230     size_t start_ogm;
6231     size_t start_bucket;
6232     struct ofputil_bucket *bucket;
6233     struct ofp11_bucket *ob;
6234
6235     switch (ofp_version) {
6236     case OFP10_VERSION: {
6237         if (gm->command == OFPGC11_ADD) {
6238             ovs_fatal(0, "add-group needs OpenFlow 1.1 or later "
6239                          "(\'-O OpenFlow11\')");
6240         } else if (gm->command == OFPGC11_MODIFY) {
6241             ovs_fatal(0, "mod-group needs OpenFlow 1.1 or later "
6242                          "(\'-O OpenFlow11\')");
6243         } else {
6244             ovs_fatal(0, "del-groups needs OpenFlow 1.1 or later "
6245                          "(\'-O OpenFlow11\')");
6246         }
6247     }
6248
6249     case OFP11_VERSION:
6250     case OFP12_VERSION:
6251     case OFP13_VERSION: {
6252         b = ofpraw_alloc(OFPRAW_OFPT11_GROUP_MOD, ofp_version, 0);
6253         start_ogm = b->size;
6254         ofpbuf_put_zeros(b, sizeof *ogm);
6255
6256         LIST_FOR_EACH (bucket, list_node, &gm->buckets) {
6257             start_bucket = b->size;
6258             ofpbuf_put_zeros(b, sizeof *ob);
6259             if (bucket->ofpacts && bucket->ofpacts_len) {
6260                 ofpacts_put_openflow_actions(bucket->ofpacts,
6261                                              bucket->ofpacts_len, b,
6262                                              ofp_version);
6263             }
6264             ob = ofpbuf_at_assert(b, start_bucket, sizeof *ob);
6265             ob->len = htons(b->size - start_bucket);;
6266             ob->weight = htons(bucket->weight);
6267             ob->watch_port = ofputil_port_to_ofp11(bucket->watch_port);
6268             ob->watch_group = htonl(bucket->watch_group);
6269         }
6270         ogm = ofpbuf_at_assert(b, start_ogm, sizeof *ogm);
6271         ogm->command = htons(gm->command);
6272         ogm->type = gm->type;
6273         ogm->group_id = htonl(gm->group_id);
6274
6275         break;
6276     }
6277
6278     default:
6279         OVS_NOT_REACHED();
6280     }
6281
6282     return b;
6283 }
6284
6285 /* Converts OpenFlow group mod message 'oh' into an abstract group mod in
6286  * 'gm'.  Returns 0 if successful, otherwise an OpenFlow error code. */
6287 enum ofperr
6288 ofputil_decode_group_mod(const struct ofp_header *oh,
6289                          struct ofputil_group_mod *gm)
6290 {
6291     const struct ofp11_group_mod *ogm;
6292     struct ofpbuf msg;
6293     struct ofputil_bucket *bucket;
6294     enum ofperr err;
6295
6296     ofpbuf_use_const(&msg, oh, ntohs(oh->length));
6297     ofpraw_pull_assert(&msg);
6298
6299     ogm = ofpbuf_pull(&msg, sizeof *ogm);
6300     gm->command = ntohs(ogm->command);
6301     gm->type = ogm->type;
6302     gm->group_id = ntohl(ogm->group_id);
6303
6304     err = ofputil_pull_buckets(&msg, msg.size, oh->version, &gm->buckets);
6305     if (err) {
6306         return err;
6307     }
6308
6309     LIST_FOR_EACH (bucket, list_node, &gm->buckets) {
6310         switch (gm->type) {
6311         case OFPGT11_ALL:
6312         case OFPGT11_INDIRECT:
6313             if (ofputil_bucket_has_liveness(bucket)) {
6314                 return OFPERR_OFPGMFC_WATCH_UNSUPPORTED;
6315             }
6316             break;
6317         case OFPGT11_SELECT:
6318             break;
6319         case OFPGT11_FF:
6320             if (!ofputil_bucket_has_liveness(bucket)) {
6321                 return OFPERR_OFPGMFC_INVALID_GROUP;
6322             }
6323             break;
6324         default:
6325             OVS_NOT_REACHED();
6326         }
6327     }
6328
6329     return 0;
6330 }
6331
6332 /* Parse a queue status request message into 'oqsr'.
6333  * Returns 0 if successful, otherwise an OFPERR_* number. */
6334 enum ofperr
6335 ofputil_decode_queue_stats_request(const struct ofp_header *request,
6336                                    struct ofputil_queue_stats_request *oqsr)
6337 {
6338     switch ((enum ofp_version)request->version) {
6339     case OFP13_VERSION:
6340     case OFP12_VERSION:
6341     case OFP11_VERSION: {
6342         const struct ofp11_queue_stats_request *qsr11 = ofpmsg_body(request);
6343         oqsr->queue_id = ntohl(qsr11->queue_id);
6344         return ofputil_port_from_ofp11(qsr11->port_no, &oqsr->port_no);
6345     }
6346
6347     case OFP10_VERSION: {
6348         const struct ofp10_queue_stats_request *qsr10 = ofpmsg_body(request);
6349         oqsr->queue_id = ntohl(qsr10->queue_id);
6350         oqsr->port_no = u16_to_ofp(ntohs(qsr10->port_no));
6351         /* OF 1.0 uses OFPP_ALL for OFPP_ANY */
6352         if (oqsr->port_no == OFPP_ALL) {
6353             oqsr->port_no = OFPP_ANY;
6354         }
6355         return 0;
6356     }
6357
6358     default:
6359         OVS_NOT_REACHED();
6360     }
6361 }
6362
6363 /* Encode a queue statsrequest for 'oqsr', the encoded message
6364  * will be fore Open Flow version 'ofp_version'. Returns message
6365  * as a struct ofpbuf. Returns encoded message on success, NULL on error */
6366 struct ofpbuf *
6367 ofputil_encode_queue_stats_request(enum ofp_version ofp_version,
6368                                    const struct ofputil_queue_stats_request *oqsr)
6369 {
6370     struct ofpbuf *request;
6371
6372     switch (ofp_version) {
6373     case OFP11_VERSION:
6374     case OFP12_VERSION:
6375     case OFP13_VERSION: {
6376         struct ofp11_queue_stats_request *req;
6377         request = ofpraw_alloc(OFPRAW_OFPST11_QUEUE_REQUEST, ofp_version, 0);
6378         req = ofpbuf_put_zeros(request, sizeof *req);
6379         req->port_no = ofputil_port_to_ofp11(oqsr->port_no);
6380         req->queue_id = htonl(oqsr->queue_id);
6381         break;
6382     }
6383     case OFP10_VERSION: {
6384         struct ofp10_queue_stats_request *req;
6385         request = ofpraw_alloc(OFPRAW_OFPST10_QUEUE_REQUEST, ofp_version, 0);
6386         req = ofpbuf_put_zeros(request, sizeof *req);
6387         /* OpenFlow 1.0 needs OFPP_ALL instead of OFPP_ANY */
6388         req->port_no = htons(ofp_to_u16(oqsr->port_no == OFPP_ANY
6389                                         ? OFPP_ALL : oqsr->port_no));
6390         req->queue_id = htonl(oqsr->queue_id);
6391         break;
6392     }
6393     default:
6394         OVS_NOT_REACHED();
6395     }
6396
6397     return request;
6398 }
6399
6400 static size_t
6401 ofputil_get_queue_stats_size(enum ofp_version ofp_version)
6402 {
6403     switch (ofp_version) {
6404     case OFP10_VERSION:
6405         return sizeof(struct ofp10_queue_stats);
6406     case OFP11_VERSION:
6407     case OFP12_VERSION:
6408         return sizeof(struct ofp11_queue_stats);
6409     case OFP13_VERSION:
6410         return sizeof(struct ofp13_queue_stats);
6411     default:
6412         OVS_NOT_REACHED();
6413     }
6414 }
6415
6416 /* Returns the number of queue stats elements in OFPTYPE_QUEUE_STATS_REPLY
6417  * message 'oh'. */
6418 size_t
6419 ofputil_count_queue_stats(const struct ofp_header *oh)
6420 {
6421     struct ofpbuf b;
6422
6423     ofpbuf_use_const(&b, oh, ntohs(oh->length));
6424     ofpraw_pull_assert(&b);
6425
6426     return b.size / ofputil_get_queue_stats_size(oh->version);
6427 }
6428
6429 static enum ofperr
6430 ofputil_queue_stats_from_ofp10(struct ofputil_queue_stats *oqs,
6431                                const struct ofp10_queue_stats *qs10)
6432 {
6433     oqs->port_no = u16_to_ofp(ntohs(qs10->port_no));
6434     oqs->queue_id = ntohl(qs10->queue_id);
6435     oqs->tx_bytes = ntohll(get_32aligned_be64(&qs10->tx_bytes));
6436     oqs->tx_packets = ntohll(get_32aligned_be64(&qs10->tx_packets));
6437     oqs->tx_errors = ntohll(get_32aligned_be64(&qs10->tx_errors));
6438     oqs->duration_sec = oqs->duration_nsec = UINT32_MAX;
6439
6440     return 0;
6441 }
6442
6443 static enum ofperr
6444 ofputil_queue_stats_from_ofp11(struct ofputil_queue_stats *oqs,
6445                                const struct ofp11_queue_stats *qs11)
6446 {
6447     enum ofperr error;
6448
6449     error = ofputil_port_from_ofp11(qs11->port_no, &oqs->port_no);
6450     if (error) {
6451         return error;
6452     }
6453
6454     oqs->queue_id = ntohl(qs11->queue_id);
6455     oqs->tx_bytes = ntohll(qs11->tx_bytes);
6456     oqs->tx_packets = ntohll(qs11->tx_packets);
6457     oqs->tx_errors = ntohll(qs11->tx_errors);
6458     oqs->duration_sec = oqs->duration_nsec = UINT32_MAX;
6459
6460     return 0;
6461 }
6462
6463 static enum ofperr
6464 ofputil_queue_stats_from_ofp13(struct ofputil_queue_stats *oqs,
6465                                const struct ofp13_queue_stats *qs13)
6466 {
6467     enum ofperr error = ofputil_queue_stats_from_ofp11(oqs, &qs13->qs);
6468     if (!error) {
6469         oqs->duration_sec = ntohl(qs13->duration_sec);
6470         oqs->duration_nsec = ntohl(qs13->duration_nsec);
6471     }
6472
6473     return error;
6474 }
6475
6476 /* Converts an OFPST_QUEUE_STATS reply in 'msg' into an abstract
6477  * ofputil_queue_stats in 'qs'.
6478  *
6479  * Multiple OFPST_QUEUE_STATS replies can be packed into a single OpenFlow
6480  * message.  Calling this function multiple times for a single 'msg' iterates
6481  * through the replies.  The caller must initially leave 'msg''s layer pointers
6482  * null and not modify them between calls.
6483  *
6484  * Returns 0 if successful, EOF if no replies were left in this 'msg',
6485  * otherwise a positive errno value. */
6486 int
6487 ofputil_decode_queue_stats(struct ofputil_queue_stats *qs, struct ofpbuf *msg)
6488 {
6489     enum ofperr error;
6490     enum ofpraw raw;
6491
6492     error = (msg->l2
6493              ? ofpraw_decode(&raw, msg->l2)
6494              : ofpraw_pull(&raw, msg));
6495     if (error) {
6496         return error;
6497     }
6498
6499     if (!msg->size) {
6500         return EOF;
6501     } else if (raw == OFPRAW_OFPST13_QUEUE_REPLY) {
6502         const struct ofp13_queue_stats *qs13;
6503
6504         qs13 = ofpbuf_try_pull(msg, sizeof *qs13);
6505         if (!qs13) {
6506             goto bad_len;
6507         }
6508         return ofputil_queue_stats_from_ofp13(qs, qs13);
6509     } else if (raw == OFPRAW_OFPST11_QUEUE_REPLY) {
6510         const struct ofp11_queue_stats *qs11;
6511
6512         qs11 = ofpbuf_try_pull(msg, sizeof *qs11);
6513         if (!qs11) {
6514             goto bad_len;
6515         }
6516         return ofputil_queue_stats_from_ofp11(qs, qs11);
6517     } else if (raw == OFPRAW_OFPST10_QUEUE_REPLY) {
6518         const struct ofp10_queue_stats *qs10;
6519
6520         qs10 = ofpbuf_try_pull(msg, sizeof *qs10);
6521         if (!qs10) {
6522             goto bad_len;
6523         }
6524         return ofputil_queue_stats_from_ofp10(qs, qs10);
6525     } else {
6526         OVS_NOT_REACHED();
6527     }
6528
6529  bad_len:
6530     VLOG_WARN_RL(&bad_ofmsg_rl, "OFPST_QUEUE reply has %"PRIuSIZE" leftover "
6531                  "bytes at end", msg->size);
6532     return OFPERR_OFPBRC_BAD_LEN;
6533 }
6534
6535 static void
6536 ofputil_queue_stats_to_ofp10(const struct ofputil_queue_stats *oqs,
6537                              struct ofp10_queue_stats *qs10)
6538 {
6539     qs10->port_no = htons(ofp_to_u16(oqs->port_no));
6540     memset(qs10->pad, 0, sizeof qs10->pad);
6541     qs10->queue_id = htonl(oqs->queue_id);
6542     put_32aligned_be64(&qs10->tx_bytes, htonll(oqs->tx_bytes));
6543     put_32aligned_be64(&qs10->tx_packets, htonll(oqs->tx_packets));
6544     put_32aligned_be64(&qs10->tx_errors, htonll(oqs->tx_errors));
6545 }
6546
6547 static void
6548 ofputil_queue_stats_to_ofp11(const struct ofputil_queue_stats *oqs,
6549                              struct ofp11_queue_stats *qs11)
6550 {
6551     qs11->port_no = ofputil_port_to_ofp11(oqs->port_no);
6552     qs11->queue_id = htonl(oqs->queue_id);
6553     qs11->tx_bytes = htonll(oqs->tx_bytes);
6554     qs11->tx_packets = htonll(oqs->tx_packets);
6555     qs11->tx_errors = htonll(oqs->tx_errors);
6556 }
6557
6558 static void
6559 ofputil_queue_stats_to_ofp13(const struct ofputil_queue_stats *oqs,
6560                              struct ofp13_queue_stats *qs13)
6561 {
6562     ofputil_queue_stats_to_ofp11(oqs, &qs13->qs);
6563     if (oqs->duration_sec != UINT32_MAX) {
6564         qs13->duration_sec = htonl(oqs->duration_sec);
6565         qs13->duration_nsec = htonl(oqs->duration_nsec);
6566     } else {
6567         qs13->duration_sec = OVS_BE32_MAX;
6568         qs13->duration_nsec = OVS_BE32_MAX;
6569     }
6570 }
6571
6572 /* Encode a queue stat for 'oqs' and append it to 'replies'. */
6573 void
6574 ofputil_append_queue_stat(struct list *replies,
6575                           const struct ofputil_queue_stats *oqs)
6576 {
6577     struct ofpbuf *msg = ofpbuf_from_list(list_back(replies));
6578     struct ofp_header *oh = msg->data;
6579
6580     switch ((enum ofp_version)oh->version) {
6581     case OFP13_VERSION: {
6582         struct ofp13_queue_stats *reply = ofpmp_append(replies, sizeof *reply);
6583         ofputil_queue_stats_to_ofp13(oqs, reply);
6584         break;
6585     }
6586
6587     case OFP12_VERSION:
6588     case OFP11_VERSION: {
6589         struct ofp11_queue_stats *reply = ofpmp_append(replies, sizeof *reply);
6590         ofputil_queue_stats_to_ofp11(oqs, reply);
6591         break;
6592     }
6593
6594     case OFP10_VERSION: {
6595         struct ofp10_queue_stats *reply = ofpmp_append(replies, sizeof *reply);
6596         ofputil_queue_stats_to_ofp10(oqs, reply);
6597         break;
6598     }
6599
6600     default:
6601         OVS_NOT_REACHED();
6602     }
6603 }