[ovs-dev,2/2] ofp-util, ofp-parse: Break up into many separate modules.

Message ID 20180209225722.32379-2-blp@ovn.org
State Accepted
Headers show
Series
  • [ovs-dev,1/2] ofp-util: Remove prototypes for unimplemented functions.
Related show

Commit Message

Ben Pfaff Feb. 9, 2018, 10:57 p.m.
ofp-util had been far too large and monolithic for a long time.  This
commit breaks it up into units that make some logical sense.  It also
moves the pieces of ofp-parse that were specific to each unit into the
relevant unit.

Most of this commit is just moving code around.

Signed-off-by: Ben Pfaff <blp@ovn.org>
---
 Documentation/topics/openflow.rst    |     2 +-
 include/openvswitch/automake.mk      |    15 +
 include/openvswitch/meta-flow.h      |    13 +-
 include/openvswitch/namemap.h        |    78 +
 include/openvswitch/ofp-actions.h    |     2 +-
 include/openvswitch/ofp-bundle.h     |    83 +
 include/openvswitch/ofp-connection.h |    89 +
 include/openvswitch/ofp-flow.h       |   230 +
 include/openvswitch/ofp-group.h      |   187 +
 include/openvswitch/ofp-ipfix.h      |    52 +
 include/openvswitch/ofp-match.h      |   100 +
 include/openvswitch/ofp-meter.h      |   123 +
 include/openvswitch/ofp-monitor.h    |   129 +
 include/openvswitch/ofp-packet.h     |   168 +
 include/openvswitch/ofp-parse.h      |   111 +-
 include/openvswitch/ofp-port.h       |   177 +
 include/openvswitch/ofp-protocol.h   |   174 +
 include/openvswitch/ofp-queue.h      |    90 +
 include/openvswitch/ofp-switch.h     |   115 +
 include/openvswitch/ofp-table.h      |   302 +
 include/openvswitch/ofp-util.h       |  1497 +----
 include/openvswitch/vconn.h          |     4 +-
 lib/automake.mk                      |    15 +
 lib/bundle.c                         |     2 +-
 lib/classifier.c                     |     1 -
 lib/dpctl.c                          |     3 +-
 lib/dpif-netdev.c                    |     2 +-
 lib/dpif-netlink.c                   |    19 +-
 lib/dpif.c                           |     1 -
 lib/dpif.h                           |     2 +-
 lib/learn.c                          |     4 +-
 lib/learning-switch.c                |     7 +-
 lib/learning-switch.h                |     2 +-
 lib/match.c                          |     3 +-
 lib/meta-flow.c                      |     3 +-
 lib/multipath.c                      |     1 -
 lib/namemap.c                        |   132 +
 lib/nx-match.c                       |     3 +-
 lib/ofp-actions.c                    |     4 +-
 lib/ofp-bundle.c                     |   431 ++
 lib/ofp-connection.c                 |   526 ++
 lib/ofp-ed-props.c                   |     1 -
 lib/ofp-errors.c                     |     2 +-
 lib/ofp-flow.c                       |  1622 +++++
 lib/ofp-group.c                      |  2075 ++++++
 lib/ofp-ipfix.c                      |   111 +
 lib/ofp-match.c                      |   954 +++
 lib/ofp-meter.c                      |   630 ++
 lib/ofp-monitor.c                    |   689 ++
 lib/ofp-packet.c                     |  1233 ++++
 lib/ofp-parse.c                      |  1934 +-----
 lib/ofp-port.c                       |  1626 +++++
 lib/ofp-print.c                      |    11 +
 lib/ofp-protocol.c                   |   623 ++
 lib/ofp-queue.c                      |   727 +++
 lib/ofp-switch.c                     |   336 +
 lib/ofp-table.c                      |  1613 +++++
 lib/ofp-util.c                       | 11408 +--------------------------------
 lib/ofp-version-opt.c                |     2 +-
 lib/ofp-version-opt.h                |     1 -
 lib/tun-metadata.c                   |     2 +-
 lib/vconn.c                          |     1 +
 ofproto/bond.c                       |     1 -
 ofproto/bundles.c                    |     1 -
 ofproto/bundles.h                    |     1 -
 ofproto/connmgr.c                    |     2 +-
 ofproto/connmgr.h                    |     5 +-
 ofproto/fail-open.c                  |     1 -
 ofproto/ofproto-dpif-ipfix.c         |     1 +
 ofproto/ofproto-dpif-trace.c         |     1 -
 ofproto/ofproto-dpif.c               |     2 -
 ofproto/ofproto-dpif.h               |     1 -
 ofproto/ofproto-provider.h           |     8 +-
 ofproto/ofproto.c                    |     4 +
 ovn/controller/ofctrl.c              |     6 +-
 ovn/controller/pinctrl.c             |     2 +
 ovn/utilities/ovn-sbctl.c            |     1 +
 ovn/utilities/ovn-trace.c            |     1 +
 tests/learn.at                       |     2 +-
 tests/ofp-print.at                   |    14 +-
 tests/ovs-ofctl.at                   |    38 +-
 tests/test-classifier.c              |     1 -
 tests/test-flows.c                   |     2 +-
 tests/test-odp.c                     |     2 +-
 tests/test-vconn.c                   |     1 -
 utilities/ovs-dpctl.c                |     1 -
 utilities/ovs-ofctl.c                |     9 +
 utilities/ovs-testcontroller.c       |     4 +-
 vswitchd/bridge.c                    |     1 -
 89 files changed, 15811 insertions(+), 14805 deletions(-)
 create mode 100644 include/openvswitch/namemap.h
 create mode 100644 include/openvswitch/ofp-bundle.h
 create mode 100644 include/openvswitch/ofp-connection.h
 create mode 100644 include/openvswitch/ofp-flow.h
 create mode 100644 include/openvswitch/ofp-group.h
 create mode 100644 include/openvswitch/ofp-ipfix.h
 create mode 100644 include/openvswitch/ofp-match.h
 create mode 100644 include/openvswitch/ofp-meter.h
 create mode 100644 include/openvswitch/ofp-monitor.h
 create mode 100644 include/openvswitch/ofp-packet.h
 create mode 100644 include/openvswitch/ofp-port.h
 create mode 100644 include/openvswitch/ofp-protocol.h
 create mode 100644 include/openvswitch/ofp-queue.h
 create mode 100644 include/openvswitch/ofp-switch.h
 create mode 100644 include/openvswitch/ofp-table.h
 create mode 100644 lib/namemap.c
 create mode 100644 lib/ofp-bundle.c
 create mode 100644 lib/ofp-connection.c
 create mode 100644 lib/ofp-flow.c
 create mode 100644 lib/ofp-group.c
 create mode 100644 lib/ofp-ipfix.c
 create mode 100644 lib/ofp-match.c
 create mode 100644 lib/ofp-meter.c
 create mode 100644 lib/ofp-monitor.c
 create mode 100644 lib/ofp-packet.c
 create mode 100644 lib/ofp-port.c
 create mode 100644 lib/ofp-protocol.c
 create mode 100644 lib/ofp-queue.c
 create mode 100644 lib/ofp-switch.c
 create mode 100644 lib/ofp-table.c

Comments

Yifeng Sun Feb. 13, 2018, 6:17 p.m. | #1
Looks good to me. Thanks.

Reviewed-by: Yifeng Sun <pkusunyifeng@gmail.com>

On Fri, Feb 9, 2018 at 2:57 PM, Ben Pfaff <blp@ovn.org> wrote:

> ofp-util had been far too large and monolithic for a long time.  This
> commit breaks it up into units that make some logical sense.  It also
> moves the pieces of ofp-parse that were specific to each unit into the
> relevant unit.
>
> Most of this commit is just moving code around.
>
> Signed-off-by: Ben Pfaff <blp@ovn.org>
> ---
>  Documentation/topics/openflow.rst    |     2 +-
>  include/openvswitch/automake.mk      |    15 +
>  include/openvswitch/meta-flow.h      |    13 +-
>  include/openvswitch/namemap.h        |    78 +
>  include/openvswitch/ofp-actions.h    |     2 +-
>  include/openvswitch/ofp-bundle.h     |    83 +
>  include/openvswitch/ofp-connection.h |    89 +
>  include/openvswitch/ofp-flow.h       |   230 +
>  include/openvswitch/ofp-group.h      |   187 +
>  include/openvswitch/ofp-ipfix.h      |    52 +
>  include/openvswitch/ofp-match.h      |   100 +
>  include/openvswitch/ofp-meter.h      |   123 +
>  include/openvswitch/ofp-monitor.h    |   129 +
>  include/openvswitch/ofp-packet.h     |   168 +
>  include/openvswitch/ofp-parse.h      |   111 +-
>  include/openvswitch/ofp-port.h       |   177 +
>  include/openvswitch/ofp-protocol.h   |   174 +
>  include/openvswitch/ofp-queue.h      |    90 +
>  include/openvswitch/ofp-switch.h     |   115 +
>  include/openvswitch/ofp-table.h      |   302 +
>  include/openvswitch/ofp-util.h       |  1497 +----
>  include/openvswitch/vconn.h          |     4 +-
>  lib/automake.mk                      |    15 +
>  lib/bundle.c                         |     2 +-
>  lib/classifier.c                     |     1 -
>  lib/dpctl.c                          |     3 +-
>  lib/dpif-netdev.c                    |     2 +-
>  lib/dpif-netlink.c                   |    19 +-
>  lib/dpif.c                           |     1 -
>  lib/dpif.h                           |     2 +-
>  lib/learn.c                          |     4 +-
>  lib/learning-switch.c                |     7 +-
>  lib/learning-switch.h                |     2 +-
>  lib/match.c                          |     3 +-
>  lib/meta-flow.c                      |     3 +-
>  lib/multipath.c                      |     1 -
>  lib/namemap.c                        |   132 +
>  lib/nx-match.c                       |     3 +-
>  lib/ofp-actions.c                    |     4 +-
>  lib/ofp-bundle.c                     |   431 ++
>  lib/ofp-connection.c                 |   526 ++
>  lib/ofp-ed-props.c                   |     1 -
>  lib/ofp-errors.c                     |     2 +-
>  lib/ofp-flow.c                       |  1622 +++++
>  lib/ofp-group.c                      |  2075 ++++++
>  lib/ofp-ipfix.c                      |   111 +
>  lib/ofp-match.c                      |   954 +++
>  lib/ofp-meter.c                      |   630 ++
>  lib/ofp-monitor.c                    |   689 ++
>  lib/ofp-packet.c                     |  1233 ++++
>  lib/ofp-parse.c                      |  1934 +-----
>  lib/ofp-port.c                       |  1626 +++++
>  lib/ofp-print.c                      |    11 +
>  lib/ofp-protocol.c                   |   623 ++
>  lib/ofp-queue.c                      |   727 +++
>  lib/ofp-switch.c                     |   336 +
>  lib/ofp-table.c                      |  1613 +++++
>  lib/ofp-util.c                       | 11408
> +--------------------------------
>  lib/ofp-version-opt.c                |     2 +-
>  lib/ofp-version-opt.h                |     1 -
>  lib/tun-metadata.c                   |     2 +-
>  lib/vconn.c                          |     1 +
>  ofproto/bond.c                       |     1 -
>  ofproto/bundles.c                    |     1 -
>  ofproto/bundles.h                    |     1 -
>  ofproto/connmgr.c                    |     2 +-
>  ofproto/connmgr.h                    |     5 +-
>  ofproto/fail-open.c                  |     1 -
>  ofproto/ofproto-dpif-ipfix.c         |     1 +
>  ofproto/ofproto-dpif-trace.c         |     1 -
>  ofproto/ofproto-dpif.c               |     2 -
>  ofproto/ofproto-dpif.h               |     1 -
>  ofproto/ofproto-provider.h           |     8 +-
>  ofproto/ofproto.c                    |     4 +
>  ovn/controller/ofctrl.c              |     6 +-
>  ovn/controller/pinctrl.c             |     2 +
>  ovn/utilities/ovn-sbctl.c            |     1 +
>  ovn/utilities/ovn-trace.c            |     1 +
>  tests/learn.at                       |     2 +-
>  tests/ofp-print.at                   |    14 +-
>  tests/ovs-ofctl.at                   |    38 +-
>  tests/test-classifier.c              |     1 -
>  tests/test-flows.c                   |     2 +-
>  tests/test-odp.c                     |     2 +-
>  tests/test-vconn.c                   |     1 -
>  utilities/ovs-dpctl.c                |     1 -
>  utilities/ovs-ofctl.c                |     9 +
>  utilities/ovs-testcontroller.c       |     4 +-
>  vswitchd/bridge.c                    |     1 -
>  89 files changed, 15811 insertions(+), 14805 deletions(-)
>  create mode 100644 include/openvswitch/namemap.h
>  create mode 100644 include/openvswitch/ofp-bundle.h
>  create mode 100644 include/openvswitch/ofp-connection.h
>  create mode 100644 include/openvswitch/ofp-flow.h
>  create mode 100644 include/openvswitch/ofp-group.h
>  create mode 100644 include/openvswitch/ofp-ipfix.h
>  create mode 100644 include/openvswitch/ofp-match.h
>  create mode 100644 include/openvswitch/ofp-meter.h
>  create mode 100644 include/openvswitch/ofp-monitor.h
>  create mode 100644 include/openvswitch/ofp-packet.h
>  create mode 100644 include/openvswitch/ofp-port.h
>  create mode 100644 include/openvswitch/ofp-protocol.h
>  create mode 100644 include/openvswitch/ofp-queue.h
>  create mode 100644 include/openvswitch/ofp-switch.h
>  create mode 100644 include/openvswitch/ofp-table.h
>  create mode 100644 lib/namemap.c
>  create mode 100644 lib/ofp-bundle.c
>  create mode 100644 lib/ofp-connection.c
>  create mode 100644 lib/ofp-flow.c
>  create mode 100644 lib/ofp-group.c
>  create mode 100644 lib/ofp-ipfix.c
>  create mode 100644 lib/ofp-match.c
>  create mode 100644 lib/ofp-meter.c
>  create mode 100644 lib/ofp-monitor.c
>  create mode 100644 lib/ofp-packet.c
>  create mode 100644 lib/ofp-port.c
>  create mode 100644 lib/ofp-protocol.c
>  create mode 100644 lib/ofp-queue.c
>  create mode 100644 lib/ofp-switch.c
>  create mode 100644 lib/ofp-table.c
>
> diff --git a/Documentation/topics/openflow.rst b/Documentation/topics/
> openflow.rst
> index d82d544d9246..b2cd6d509224 100644
> --- a/Documentation/topics/openflow.rst
> +++ b/Documentation/topics/openflow.rst
> @@ -44,7 +44,7 @@ The primary approach to compatibility is to abstract
> most of the details of the
>  differences from the core code, by adding a protocol layer that translates
>  between OF1.x and a slightly higher-level abstract representation.  The
> core of
>  this approach is the many ``struct ofputil_*`` structures in
> -``include/openvswitch/ofp-util.h``.
> +``include/openvswitch/ofp-*.h``.
>
>  As a consequence of this approach, OVS cannot use OpenFlow protocol
> definitions
>  that closely resemble those in the OpenFlow specification, because
> diff --git a/include/openvswitch/automake.mk b/include/openvswitch/
> automake.mk
> index 93d1062a410d..aede515663cd 100644
> --- a/include/openvswitch/automake.mk
> +++ b/include/openvswitch/automake.mk
> @@ -10,14 +10,29 @@ openvswitchinclude_HEADERS = \
>         include/openvswitch/netdev.h \
>         include/openvswitch/match.h \
>         include/openvswitch/meta-flow.h \
> +       include/openvswitch/namemap.h \
>         include/openvswitch/ofpbuf.h \
>         include/openvswitch/ofp-actions.h \
> +       include/openvswitch/ofp-bundle.h \
> +       include/openvswitch/ofp-connection.h \
>         include/openvswitch/ofp-ed-props.h \
>         include/openvswitch/ofp-errors.h \
> +       include/openvswitch/ofp-flow.h \
> +       include/openvswitch/ofp-group.h \
> +       include/openvswitch/ofp-ipfix.h \
> +       include/openvswitch/ofp-match.h \
> +       include/openvswitch/ofp-meter.h \
> +       include/openvswitch/ofp-monitor.h \
>         include/openvswitch/ofp-msgs.h \
> +       include/openvswitch/ofp-packet.h \
>         include/openvswitch/ofp-parse.h \
> +       include/openvswitch/ofp-port.h \
>         include/openvswitch/ofp-print.h \
>         include/openvswitch/ofp-prop.h \
> +       include/openvswitch/ofp-protocol.h \
> +       include/openvswitch/ofp-queue.h \
> +       include/openvswitch/ofp-switch.h \
> +       include/openvswitch/ofp-table.h \
>         include/openvswitch/ofp-util.h \
>         include/openvswitch/packets.h \
>         include/openvswitch/poll-loop.h \
> diff --git a/include/openvswitch/meta-flow.h b/include/openvswitch/meta-
> flow.h
> index d0844b33312f..98c9e1cb5a76 100644
> --- a/include/openvswitch/meta-flow.h
> +++ b/include/openvswitch/meta-flow.h
> @@ -25,6 +25,7 @@
>  #include <netinet/ip6.h>
>  #include "openvswitch/flow.h"
>  #include "openvswitch/ofp-errors.h"
> +#include "openvswitch/ofp-protocol.h"
>  #include "openvswitch/packets.h"
>  #include "openvswitch/util.h"
>
> @@ -2031,14 +2032,10 @@ struct mf_field {
>       * the OpenFlow protocol version the field was introduced in.
>       * Also, some field types are tranparently mapped to each other via
> the
>       * struct flow (like vlan and dscp/tos fields), so each variant
> supports
> -     * all protocols.
> -     *
> -     * These are combinations of OFPUTIL_P_*.  (They are not declared as
> type
> -     * enum ofputil_protocol because that would give meta-flow.h and
> ofp-util.h
> -     * a circular dependency.) */
> -    uint32_t usable_protocols_exact;   /* Matching or setting whole
> field. */
> -    uint32_t usable_protocols_cidr;    /* Matching a CIDR mask in field.
> */
> -    uint32_t usable_protocols_bitwise; /* Matching arbitrary bits in
> field. */
> +     * all protocols. */
> +    enum ofputil_protocol usable_protocols_exact; /* Match/set whole
> field. */
> +    enum ofputil_protocol usable_protocols_cidr;    /* Match CIDR mask. */
> +    enum ofputil_protocol usable_protocols_bitwise; /* Match arbitrary
> bits. */
>
>      int flow_be32ofs;  /* Field's be32 offset in "struct flow", if prefix
> tree
>                          * lookup is supported for the field, or -1. */
> diff --git a/include/openvswitch/namemap.h b/include/openvswitch/namemap.h
> new file mode 100644
> index 000000000000..6a41176da8e2
> --- /dev/null
> +++ b/include/openvswitch/namemap.h
> @@ -0,0 +1,78 @@
> +/*
> + * Copyright (c) 2008-2017 Nicira, Inc.
> + *
> + * Licensed under the Apache License, Version 2.0 (the "License");
> + * you may not use this file except in compliance with the License.
> + * You may obtain a copy of the License at:
> + *
> + *     http://www.apache.org/licenses/LICENSE-2.0
> + *
> + * Unless required by applicable law or agreed to in writing, software
> + * distributed under the License is distributed on an "AS IS" BASIS,
> + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
> implied.
> + * See the License for the specific language governing permissions and
> + * limitations under the License.
> + */
> +
> +#ifndef OPENVSWITCH_NAMEMAP_H
> +#define OPENVSWITCH_NAMEMAP_H 1
> +
> +#include "openvswitch/hmap.h"
> +
> +struct ds;
> +
> +#ifdef __cplusplus
> +extern "C" {
> +#endif
> +
> +/* Name-number mapping.
> + *
> + * This data structure tracks and manages a mapping between names and
> 32-bit
> + * unsigned integers, with provision for detecting names that are used
> more
> + * than once.
> + *
> + * This structure is suitable for tracking mappings between OpenFlow port
> names
> + * and numbers.  OpenFlow doesn't require either these kinds of names to
> be
> + * unique, and in OVS it's possible for two ports to appear to have the
> same
> + * name if their names are longer than the maximum length supported by a
> given
> + * version of OpenFlow.
> + *
> + * OpenFlow does require port numbers to be unique.  We check for
> duplicate
> + * ports numbers just in case a switch has a bug.
> + *
> + * This structure is also suitable for tracking mappings between OpenFlow
> table
> + * names and number.  OpenFlow doesn't require table names to be unique
> and
> + * Open vSwitch doesn't try to make them unique. */
> +struct namemap_node {
> +    struct hmap_node name_node;
> +    struct hmap_node number_node;
> +
> +    uint32_t number;
> +    char *name;
> +
> +    bool duplicate;
> +};
> +
> +struct namemap {
> +    struct hmap by_name;
> +    struct hmap by_number;
> +};
> +#define NAMEMAP_INITIALIZER(MAP) \
> +    { HMAP_INITIALIZER(&(MAP)->by_name), HMAP_INITIALIZER(&(MAP)->by_number)
> }
> +
> +void namemap_init(struct namemap *);
> +struct namemap_node *namemap_find_by_name(const struct namemap *,
> +                                              const char *);
> +struct namemap_node *namemap_find_by_number(const struct namemap *,
> uint32_t);
> +void namemap_put(struct namemap *, uint32_t, const char *);
> +void namemap_destroy(struct namemap *);
> +
> +void namemap_put_name(const char *, struct ds *);
> +
> +#ifdef __cplusplus
> +}
> +#endif
> +
> +#endif  /* namemap.h */
> +
> +
> diff --git a/include/openvswitch/ofp-actions.h b/include/openvswitch/ofp-
> actions.h
> index cba027b1d945..b3dd0959d53e 100644
> --- a/include/openvswitch/ofp-actions.h
> +++ b/include/openvswitch/ofp-actions.h
> @@ -22,8 +22,8 @@
>  #include "openflow/openflow.h"
>  #include "openflow/nicira-ext.h"
>  #include "openvswitch/meta-flow.h"
> -#include "openvswitch/ofp-util.h"
>  #include "openvswitch/ofp-errors.h"
> +#include "openvswitch/ofp-protocol.h"
>  #include "openvswitch/types.h"
>  #include "openvswitch/ofp-ed-props.h"
>
> diff --git a/include/openvswitch/ofp-bundle.h b/include/openvswitch/ofp-
> bundle.h
> new file mode 100644
> index 000000000000..f19996663a74
> --- /dev/null
> +++ b/include/openvswitch/ofp-bundle.h
> @@ -0,0 +1,83 @@
> +/*
> + * Copyright (c) 2008-2017 Nicira, Inc.
> + *
> + * Licensed under the Apache License, Version 2.0 (the "License");
> + * you may not use this file except in compliance with the License.
> + * You may obtain a copy of the License at:
> + *
> + *     http://www.apache.org/licenses/LICENSE-2.0
> + *
> + * Unless required by applicable law or agreed to in writing, software
> + * distributed under the License is distributed on an "AS IS" BASIS,
> + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
> implied.
> + * See the License for the specific language governing permissions and
> + * limitations under the License.
> + */
> +
> +#ifndef OPENVSWITCH_OFP_BUNDLE_H
> +#define OPENVSWITCH_OFP_BUNDLE_H 1
> +
> +#include "openflow/openflow.h"
> +#include "openvswitch/ofp-flow.h"
> +#include "openvswitch/ofp-group.h"
> +#include "openvswitch/ofp-packet.h"
> +#include "openvswitch/ofp-msgs.h"
> +
> +#ifdef __cplusplus
> +extern "C" {
> +#endif
> +
> +struct ofputil_bundle_ctrl_msg {
> +    uint32_t    bundle_id;
> +    uint16_t    type;
> +    uint16_t    flags;
> +};
> +
> +struct ofputil_bundle_add_msg {
> +    uint32_t            bundle_id;
> +    uint16_t            flags;
> +    const struct ofp_header   *msg;
> +};
> +
> +enum ofperr ofputil_decode_bundle_ctrl(const struct ofp_header *,
> +                                       struct ofputil_bundle_ctrl_msg *);
> +
> +struct ofpbuf *ofputil_encode_bundle_ctrl_request(
> +    enum ofp_version, struct ofputil_bundle_ctrl_msg *);
> +struct ofpbuf *ofputil_encode_bundle_ctrl_reply(
> +    const struct ofp_header *, struct ofputil_bundle_ctrl_msg *);
> +
> +struct ofpbuf *ofputil_encode_bundle_add(enum ofp_version,
> +                                         struct ofputil_bundle_add_msg *);
> +
> +enum ofperr ofputil_decode_bundle_add(const struct ofp_header *,
> +                                      struct ofputil_bundle_add_msg *,
> +                                      enum ofptype *);
> +
> +/* Bundle message as produced by ofp-parse. */
> +struct ofputil_bundle_msg {
> +    enum ofptype type;
> +    union {
> +        struct ofputil_flow_mod fm;
> +        struct ofputil_group_mod gm;
> +        struct ofputil_packet_out po;
> +    };
> +};
> +
> +void ofputil_encode_bundle_msgs(const struct ofputil_bundle_msg *,
> size_t n,
> +                                struct ovs_list *requests,
> +                                enum ofputil_protocol);
> +void ofputil_free_bundle_msgs(struct ofputil_bundle_msg *, size_t n);
> +
> +char *parse_ofp_bundle_file(const char *file_name,
> +                            const struct ofputil_port_map *,
> +                            const struct ofputil_table_map *,
> +                            struct ofputil_bundle_msg **, size_t *n_bms,
> +                            enum ofputil_protocol *)
> +    OVS_WARN_UNUSED_RESULT;
> +
> +#ifdef __cplusplus
> +}
> +#endif
> +
> +#endif  /* ofp-bundle.h */
> diff --git a/include/openvswitch/ofp-connection.h
> b/include/openvswitch/ofp-connection.h
> new file mode 100644
> index 000000000000..540ce9ed9b21
> --- /dev/null
> +++ b/include/openvswitch/ofp-connection.h
> @@ -0,0 +1,89 @@
> +/*
> + * Copyright (c) 2008-2017 Nicira, Inc.
> + *
> + * Licensed under the Apache License, Version 2.0 (the "License");
> + * you may not use this file except in compliance with the License.
> + * You may obtain a copy of the License at:
> + *
> + *     http://www.apache.org/licenses/LICENSE-2.0
> + *
> + * Unless required by applicable law or agreed to in writing, software
> + * distributed under the License is distributed on an "AS IS" BASIS,
> + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
> implied.
> + * See the License for the specific language governing permissions and
> + * limitations under the License.
> + */
> +
> +#ifndef OPENVSWITCH_OFP_CONNECTION_H
> +#define OPENVSWITCH_OFP_CONNECTION_H 1
> +
> +#include "openflow/openflow.h"
> +#include "openvswitch/ofp-protocol.h"
> +
> +#ifdef __cplusplus
> +extern "C" {
> +#endif
> +
> +/* Abstract ofp_role_request and reply. */
> +struct ofputil_role_request {
> +    enum ofp12_controller_role role;
> +    bool have_generation_id;
> +    uint64_t generation_id;
> +};
> +
> +struct ofputil_role_status {
> +    enum ofp12_controller_role role;
> +    enum ofp14_controller_role_reason reason;
> +    uint64_t generation_id;
> +};
> +
> +enum ofperr ofputil_decode_role_message(const struct ofp_header *,
> +                                        struct ofputil_role_request *);
> +struct ofpbuf *ofputil_encode_role_reply(const struct ofp_header *,
> +                                         const struct
> ofputil_role_request *);
> +
> +struct ofpbuf *ofputil_encode_role_status(const struct
> ofputil_role_status *,
> +                                          enum ofputil_protocol);
> +
> +enum ofperr ofputil_decode_role_status(const struct ofp_header *,
> +                                       struct ofputil_role_status *);
> +
> +enum ofputil_async_msg_type {
> +    /* Standard asynchronous messages. */
> +    OAM_PACKET_IN,              /* OFPT_PACKET_IN or NXT_PACKET_IN. */
> +    OAM_PORT_STATUS,            /* OFPT_PORT_STATUS. */
> +    OAM_FLOW_REMOVED,           /* OFPT_FLOW_REMOVED or NXT_FLOW_REMOVED.
> */
> +    OAM_ROLE_STATUS,            /* OFPT_ROLE_STATUS. */
> +    OAM_TABLE_STATUS,           /* OFPT_TABLE_STATUS. */
> +    OAM_REQUESTFORWARD,         /* OFPT_REQUESTFORWARD. */
> +
> +    /* Extension asynchronous messages (none yet--coming soon!). */
> +#define OAM_EXTENSIONS 0        /* Bitmap of all extensions. */
> +
> +    OAM_N_TYPES
> +};
> +const char *ofputil_async_msg_type_to_string(enum
> ofputil_async_msg_type);
> +
> +struct ofputil_async_cfg {
> +    uint32_t master[OAM_N_TYPES];
> +    uint32_t slave[OAM_N_TYPES];
> +};
> +#define OFPUTIL_ASYNC_CFG_INIT (struct ofputil_async_cfg) { .master[0] =
> 0 }
> +
> +enum ofperr ofputil_decode_set_async_config(const struct ofp_header *,
> +                                            bool loose,
> +                                            const struct
> ofputil_async_cfg *,
> +                                            struct ofputil_async_cfg *);
> +
> +struct ofpbuf *ofputil_encode_get_async_reply(
> +    const struct ofp_header *, const struct ofputil_async_cfg *);
> +struct ofpbuf *ofputil_encode_set_async_config(
> +    const struct ofputil_async_cfg *, uint32_t oams, enum ofp_version);
> +
> +struct ofputil_async_cfg ofputil_async_cfg_default(enum ofp_version);
> +
> +#ifdef __cplusplus
> +}
> +#endif
> +
> +#endif  /* ofp-connection.h */
> diff --git a/include/openvswitch/ofp-flow.h b/include/openvswitch/ofp-
> flow.h
> new file mode 100644
> index 000000000000..abaf4a87a400
> --- /dev/null
> +++ b/include/openvswitch/ofp-flow.h
> @@ -0,0 +1,230 @@
> +/*
> + * Copyright (c) 2008-2017 Nicira, Inc.
> + *
> + * Licensed under the Apache License, Version 2.0 (the "License");
> + * you may not use this file except in compliance with the License.
> + * You may obtain a copy of the License at:
> + *
> + *     http://www.apache.org/licenses/LICENSE-2.0
> + *
> + * Unless required by applicable law or agreed to in writing, software
> + * distributed under the License is distributed on an "AS IS" BASIS,
> + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
> implied.
> + * See the License for the specific language governing permissions and
> + * limitations under the License.
> + */
> +
> +#ifndef OPENVSWITCH_OFP_FLOW_H
> +#define OPENVSWITCH_OFP_FLOW_H 1
> +
> +#include "openflow/openflow.h"
> +#include "openflow/nicira-ext.h"
> +#include "openvswitch/list.h"
> +#include "openvswitch/match.h"
> +#include "openvswitch/ofp-protocol.h"
> +
> +struct vl_mff_map;
> +struct ofputil_port_map;
> +struct ofputil_table_map;
> +
> +#ifdef __cplusplus
> +extern "C" {
> +#endif
> +
> +/* nx_flow_format */
> +struct ofpbuf *ofputil_encode_nx_set_flow_format(enum nx_flow_format);
> +enum ofputil_protocol ofputil_nx_flow_format_to_protocol(enum
> nx_flow_format);
> +bool ofputil_nx_flow_format_is_valid(enum nx_flow_format);
> +const char *ofputil_nx_flow_format_to_string(enum nx_flow_format);
> +
> +/* NXT_FLOW_MOD_TABLE_ID extension. */
> +struct ofpbuf *ofputil_make_flow_mod_table_id(bool flow_mod_table_id);
> +
> +/* Protocol-independent flow_mod flags. */
> +enum ofputil_flow_mod_flags {
> +    /* Flags that are maintained with a flow as part of its state.
> +     *
> +     * (OFPUTIL_FF_EMERG would be here too, if OVS supported it.) */
> +    OFPUTIL_FF_SEND_FLOW_REM = 1 << 0, /* All versions. */
> +    OFPUTIL_FF_NO_PKT_COUNTS = 1 << 1, /* OpenFlow 1.3+. */
> +    OFPUTIL_FF_NO_BYT_COUNTS = 1 << 2, /* OpenFlow 1.3+. */
> +
> +    /* These flags primarily affects flow_mod behavior.  They are not
> +     * particularly useful as part of flow state.  We include them in flow
> +     * state only because OpenFlow implies that they should be. */
> +    OFPUTIL_FF_CHECK_OVERLAP = 1 << 3, /* All versions. */
> +    OFPUTIL_FF_RESET_COUNTS  = 1 << 4, /* OpenFlow 1.2+. */
> +
> +    /* Not supported by OVS. */
> +    OFPUTIL_FF_EMERG         = 1 << 5, /* OpenFlow 1.0 only. */
> +
> +    /* The set of flags maintained as part of a flow table entry. */
> +#define OFPUTIL_FF_STATE (OFPUTIL_FF_SEND_FLOW_REM      \
> +                          | OFPUTIL_FF_NO_PKT_COUNTS    \
> +                          | OFPUTIL_FF_NO_BYT_COUNTS    \
> +                          | OFPUTIL_FF_CHECK_OVERLAP    \
> +                          | OFPUTIL_FF_RESET_COUNTS)
> +
> +    /* Flags that are only set by OVS for its internal use.  Cannot be
> set via
> +     * OpenFlow. */
> +    OFPUTIL_FF_HIDDEN_FIELDS = 1 << 6, /* Allow hidden match fields to be
> +                                          set or modified. */
> +    OFPUTIL_FF_NO_READONLY   = 1 << 7, /* Allow rules within read only
> tables
> +                                          to be modified */
> +};
> +
> +/* Protocol-independent flow_mod.
> + *
> + * The handling of cookies across multiple versions of OpenFlow is a bit
> + * confusing.  See the topics/design doc for the details. */
> +struct ofputil_flow_mod {
> +    struct ovs_list list_node; /* For queuing flow_mods. */
> +
> +    struct match match;
> +    int priority;
> +
> +    /* Cookie matching.  The flow_mod affects only flows that have
> cookies that
> +     * bitwise match 'cookie' bits in positions where 'cookie_mask has
> 1-bits.
> +     *
> +     * 'cookie_mask' should be zero for OFPFC_ADD flow_mods. */
> +    ovs_be64 cookie;         /* Cookie bits to match. */
> +    ovs_be64 cookie_mask;    /* 1-bit in each 'cookie' bit to match. */
> +
> +    /* Cookie changes.
> +     *
> +     * OFPFC_ADD uses 'new_cookie' as the new flow's cookie.  'new_cookie'
> +     * should not be UINT64_MAX.
> +     *
> +     * OFPFC_MODIFY and OFPFC_MODIFY_STRICT have two cases:
> +     *
> +     *   - If one or more matching flows exist and 'modify_cookie' is
> true,
> +     *     then the flow_mod changes the existing flows' cookies to
> +     *     'new_cookie'.  'new_cookie' should not be UINT64_MAX.
> +     *
> +     *   - If no matching flow exists, 'new_cookie' is not UINT64_MAX, and
> +     *     'cookie_mask' is 0, then the flow_mod adds a new flow with
> +     *     'new_cookie' as its cookie.
> +     */
> +    ovs_be64 new_cookie;     /* New cookie to install or UINT64_MAX. */
> +    bool modify_cookie;      /* Set cookie of existing flow to
> 'new_cookie'? */
> +
> +    uint8_t table_id;
> +    uint16_t command;
> +    uint16_t idle_timeout;
> +    uint16_t hard_timeout;
> +    uint32_t buffer_id;
> +    ofp_port_t out_port;
> +    uint32_t out_group;
> +    enum ofputil_flow_mod_flags flags;
> +    uint16_t importance;     /* Eviction precedence. */
> +    struct ofpact *ofpacts;  /* Series of "struct ofpact"s. */
> +    size_t ofpacts_len;      /* Length of ofpacts, in bytes. */
> +    uint64_t ofpacts_tlv_bitmap; /* 1-bit for each present TLV in
> 'ofpacts'. */
> +};
> +
> +enum ofperr ofputil_decode_flow_mod(struct ofputil_flow_mod *,
> +                                    const struct ofp_header *,
> +                                    enum ofputil_protocol,
> +                                    const struct tun_table *,
> +                                    const struct vl_mff_map *,
> +                                    struct ofpbuf *ofpacts,
> +                                    ofp_port_t max_port,
> +                                    uint8_t max_table);
> +struct ofpbuf *ofputil_encode_flow_mod(const struct ofputil_flow_mod *,
> +                                       enum ofputil_protocol);
> +
> +char *parse_ofp_str(struct ofputil_flow_mod *, int command, const char
> *str_,
> +                    const struct ofputil_port_map *,
> +                    const struct ofputil_table_map *,
> +                    enum ofputil_protocol *usable_protocols)
> +    OVS_WARN_UNUSED_RESULT;
> +
> +char *parse_ofp_flow_mod_str(struct ofputil_flow_mod *, const char
> *string,
> +                             const struct ofputil_port_map *,
> +                             const struct ofputil_table_map *,
> +                             int command,
> +                             enum ofputil_protocol *usable_protocols)
> +    OVS_WARN_UNUSED_RESULT;
> +
> +char *parse_ofp_flow_mod_file(const char *file_name,
> +                              const struct ofputil_port_map *,
> +                              const struct ofputil_table_map *,
> +                              int command,
> +                              struct ofputil_flow_mod **fms, size_t
> *n_fms,
> +                              enum ofputil_protocol *usable_protocols)
> +    OVS_WARN_UNUSED_RESULT;
> +
> +char *parse_ofp_exact_flow(struct flow *flow, struct flow_wildcards *wc,
> +                           const struct tun_table *tun_table, const char
> *s,
> +                           const struct ofputil_port_map *port_map);
> +
> +/* Flow stats or aggregate stats request, independent of protocol. */
> +struct ofputil_flow_stats_request {
> +    bool aggregate;             /* Aggregate results? */
> +    struct match match;
> +    ovs_be64 cookie;
> +    ovs_be64 cookie_mask;
> +    ofp_port_t out_port;
> +    uint32_t out_group;
> +    uint8_t table_id;
> +};
> +
> +enum ofperr ofputil_decode_flow_stats_request(
> +    struct ofputil_flow_stats_request *, const struct ofp_header *,
> +    const struct tun_table *, const struct vl_mff_map *);
> +struct ofpbuf *ofputil_encode_flow_stats_request(
> +    const struct ofputil_flow_stats_request *, enum ofputil_protocol);
> +char *parse_ofp_flow_stats_request_str(struct ofputil_flow_stats_request
> *,
> +                                       bool aggregate, const char *string,
> +                                       const struct ofputil_port_map *,
> +                                       const struct ofputil_table_map *,
> +                                       enum ofputil_protocol
> *usable_protocols)
> +    OVS_WARN_UNUSED_RESULT;
> +
> +/* Flow stats reply, independent of protocol. */
> +struct ofputil_flow_stats {
> +    struct match match;
> +    ovs_be64 cookie;
> +    uint8_t table_id;
> +    uint16_t priority;
> +    uint16_t idle_timeout;
> +    uint16_t hard_timeout;
> +    uint32_t duration_sec;
> +    uint32_t duration_nsec;
> +    int idle_age;               /* Seconds since last packet, -1 if
> unknown. */
> +    int hard_age;               /* Seconds since last change, -1 if
> unknown. */
> +    uint64_t packet_count;      /* Packet count, UINT64_MAX if unknown. */
> +    uint64_t byte_count;        /* Byte count, UINT64_MAX if unknown. */
> +    const struct ofpact *ofpacts;
> +    size_t ofpacts_len;
> +    enum ofputil_flow_mod_flags flags;
> +    uint16_t importance;        /* Eviction precedence. */
> +};
> +
> +int ofputil_decode_flow_stats_reply(struct ofputil_flow_stats *,
> +                                    struct ofpbuf *msg,
> +                                    bool flow_age_extension,
> +                                    struct ofpbuf *ofpacts);
> +void ofputil_append_flow_stats_reply(const struct ofputil_flow_stats *,
> +                                     struct ovs_list *replies,
> +                                     const struct tun_table *);
> +
> +/* Aggregate stats reply, independent of protocol. */
> +struct ofputil_aggregate_stats {
> +    uint64_t packet_count;      /* Packet count, UINT64_MAX if unknown. */
> +    uint64_t byte_count;        /* Byte count, UINT64_MAX if unknown. */
> +    uint32_t flow_count;
> +};
> +
> +struct ofpbuf *ofputil_encode_aggregate_stats_reply(
> +    const struct ofputil_aggregate_stats *stats,
> +    const struct ofp_header *request);
> +enum ofperr ofputil_decode_aggregate_stats_reply(
> +    struct ofputil_aggregate_stats *,
> +    const struct ofp_header *reply);
> +
> +#ifdef __cplusplus
> +}
> +#endif
> +
> +#endif  /* ofp-flow.h */
> diff --git a/include/openvswitch/ofp-group.h b/include/openvswitch/ofp-
> group.h
> new file mode 100644
> index 000000000000..8d893a53fcb2
> --- /dev/null
> +++ b/include/openvswitch/ofp-group.h
> @@ -0,0 +1,187 @@
> +/*
> + * Copyright (c) 2008-2017 Nicira, Inc.
> + *
> + * Licensed under the Apache License, Version 2.0 (the "License");
> + * you may not use this file except in compliance with the License.
> + * You may obtain a copy of the License at:
> + *
> + *     http://www.apache.org/licenses/LICENSE-2.0
> + *
> + * Unless required by applicable law or agreed to in writing, software
> + * distributed under the License is distributed on an "AS IS" BASIS,
> + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
> implied.
> + * See the License for the specific language governing permissions and
> + * limitations under the License.
> + */
> +
> +#ifndef OPENVSWITCH_OFP_GROUP_H
> +#define OPENVSWITCH_OFP_GROUP_H 1
> +
> +#include "openflow/openflow.h"
> +#include "openflow/netronome-ext.h"
> +#include "openvswitch/list.h"
> +#include "openvswitch/meta-flow.h"
> +#include "openvswitch/type-props.h"
> +
> +struct ds;
> +
> +#ifdef __cplusplus
> +extern "C" {
> +#endif
> +
> +struct ofputil_table_map;
> +
> +/* Group numbers. */
> +enum { MAX_GROUP_NAME_LEN = INT_STRLEN(uint32_t) };
> +bool ofputil_group_from_string(const char *, uint32_t *group_id);
> +void ofputil_format_group(uint32_t group_id, struct ds *);
> +void ofputil_group_to_string(uint32_t group_id,
> +                             char namebuf[MAX_GROUP_NAME_LEN + 1],
> +                             size_t bufsize);
> +
> +struct bucket_counter {
> +    uint64_t packet_count;   /* Number of packets processed by bucket. */
> +    uint64_t byte_count;     /* Number of bytes processed by bucket. */
> +};
> +
> +/* Bucket for use in groups. */
> +struct ofputil_bucket {
> +    struct ovs_list list_node;
> +    uint16_t weight;            /* Relative weight, for "select" groups.
> */
> +    ofp_port_t watch_port;      /* Port whose state affects whether this
> bucket
> +                                 * is live. Only required for fast
> failover
> +                                 * groups. */
> +    uint32_t watch_group;       /* Group whose state affects whether this
> +                                 * bucket is live. Only required for fast
> +                                 * failover groups. */
> +    uint32_t bucket_id;         /* Bucket Id used to identify bucket*/
> +    struct ofpact *ofpacts;     /* Series of "struct ofpact"s. */
> +    size_t ofpacts_len;         /* Length of ofpacts, in bytes. */
> +
> +    struct bucket_counter stats;
> +};
> +
> +void ofputil_bucket_list_destroy(struct ovs_list *buckets);
> +void ofputil_bucket_clone_list(struct ovs_list *dest,
> +                               const struct ovs_list *src,
> +                               const struct ofputil_bucket *);
> +struct ofputil_bucket *ofputil_bucket_find(const struct ovs_list *,
> +                                           uint32_t bucket_id);
> +bool ofputil_bucket_check_duplicate_id(const struct ovs_list *);
> +struct ofputil_bucket *ofputil_bucket_list_front(const struct ovs_list
> *);
> +struct ofputil_bucket *ofputil_bucket_list_back(const struct ovs_list *);
> +
> +static inline bool
> +ofputil_bucket_has_liveness(const struct ofputil_bucket *bucket)
> +{
> +    return (bucket->watch_port != OFPP_ANY ||
> +            bucket->watch_group != OFPG_ANY);
> +}
> +
> +struct ofputil_group_props {
> +    /* NTR selection method */
> +    char selection_method[NTR_MAX_SELECTION_METHOD_LEN];
> +    uint64_t selection_method_param;
> +    struct field_array fields;
> +};
> +
> +void ofputil_group_properties_destroy(struct ofputil_group_props *);
> +void ofputil_group_properties_copy(struct ofputil_group_props *to,
> +                                   const struct ofputil_group_props
> *from);
> +/* Protocol-independent group_mod. */
> +struct ofputil_group_mod {
> +    uint16_t command;             /* One of OFPGC15_*. */
> +    uint8_t type;                 /* One of OFPGT11_*. */
> +    uint32_t group_id;            /* Group identifier. */
> +    uint32_t command_bucket_id;   /* Bucket Id used as part of
> +                                   * OFPGC15_INSERT_BUCKET and
> +                                   * OFPGC15_REMOVE_BUCKET commands
> +                                   * execution.*/
> +    struct ovs_list buckets;      /* Contains "struct ofputil_bucket"s. */
> +    struct ofputil_group_props props; /* Group properties. */
> +};
> +
> +void ofputil_uninit_group_mod(struct ofputil_group_mod *gm);
> +struct ofpbuf *ofputil_encode_group_mod(enum ofp_version ofp_version,
> +                                        const struct ofputil_group_mod
> *gm);
> +
> +enum ofperr ofputil_decode_group_mod(const struct ofp_header *,
> +                                     struct ofputil_group_mod *);
> +
> +char *parse_ofp_group_mod_file(const char *file_name,
> +                               const struct ofputil_port_map *,
> +                               const struct ofputil_table_map *, int
> command,
> +                               struct ofputil_group_mod **gms, size_t
> *n_gms,
> +                               enum ofputil_protocol *usable_protocols)
> +    OVS_WARN_UNUSED_RESULT;
> +
> +char *parse_ofp_group_mod_str(struct ofputil_group_mod *, int command,
> +                              const char *string,
> +                              const struct ofputil_port_map *,
> +                              const struct ofputil_table_map *,
> +                              enum ofputil_protocol *usable_protocols)
> +    OVS_WARN_UNUSED_RESULT;
> +
> +/* Group stats reply, independent of protocol. */
> +struct ofputil_group_stats {
> +    uint32_t group_id;    /* Group identifier. */
> +    uint32_t ref_count;
> +    uint64_t packet_count;      /* Packet count, UINT64_MAX if unknown. */
> +    uint64_t byte_count;        /* Byte count, UINT64_MAX if unknown. */
> +    uint32_t duration_sec;      /* UINT32_MAX if unknown. */
> +    uint32_t duration_nsec;
> +    uint32_t n_buckets;
> +    struct bucket_counter *bucket_stats;
> +};
> +
> +struct ofpbuf *ofputil_encode_group_stats_request(enum ofp_version,
> +                                                  uint32_t group_id);
> +enum ofperr ofputil_decode_group_stats_request(
> +    const struct ofp_header *request, uint32_t *group_id);
> +void ofputil_append_group_stats(struct ovs_list *replies,
> +                                const struct ofputil_group_stats *);
> +
> +int ofputil_decode_group_stats_reply(struct ofpbuf *,
> +                                     struct ofputil_group_stats *);
> +
> +/* Group features reply, independent of protocol.
> + *
> + * Only OF1.2 and later support group features replies. */
> +struct ofputil_group_features {
> +    uint32_t  types;           /* Bitmap of OFPGT_* values supported. */
> +    uint32_t  capabilities;    /* Bitmap of OFPGFC12_* capability
> supported. */
> +    uint32_t  max_groups[4];   /* Maximum number of groups for each type.
> */
> +    uint64_t  ofpacts[4];      /* Bitmaps of supported OFPACT_* */
> +};
> +
> +struct ofpbuf *ofputil_encode_group_features_request(enum ofp_version);
> +struct ofpbuf *ofputil_encode_group_features_reply(
> +    const struct ofputil_group_features *, const struct ofp_header
> *request);
> +void ofputil_decode_group_features_reply(const struct ofp_header *,
> +                                         struct ofputil_group_features *);
> +
> +/* Group desc reply, independent of protocol. */
> +struct ofputil_group_desc {
> +    uint8_t type;               /* One of OFPGT_*. */
> +    uint32_t group_id;          /* Group identifier. */
> +    struct ovs_list buckets;    /* Contains "struct ofputil_bucket"s. */
> +    struct ofputil_group_props props; /* Group properties. */
> +};
> +
> +void ofputil_uninit_group_desc(struct ofputil_group_desc *gd);
> +uint32_t ofputil_decode_group_desc_request(const struct ofp_header *);
> +struct ofpbuf *ofputil_encode_group_desc_request(enum ofp_version,
> +                                                 uint32_t group_id);
> +
> +int ofputil_decode_group_desc_reply(struct ofputil_group_desc *,
> +                                    struct ofpbuf *, enum ofp_version);
> +
> +void ofputil_append_group_desc_reply(const struct ofputil_group_desc *,
> +                                     const struct ovs_list *buckets,
> +                                     struct ovs_list *replies);
> +
> +#ifdef __cplusplus
> +}
> +#endif
> +
> +#endif  /* ofp-group.h */
> diff --git a/include/openvswitch/ofp-ipfix.h b/include/openvswitch/ofp-
> ipfix.h
> new file mode 100644
> index 000000000000..75eefc005877
> --- /dev/null
> +++ b/include/openvswitch/ofp-ipfix.h
> @@ -0,0 +1,52 @@
> +/*
> + * Copyright (c) 2008-2017 Nicira, Inc.
> + *
> + * Licensed under the Apache License, Version 2.0 (the "License");
> + * you may not use this file except in compliance with the License.
> + * You may obtain a copy of the License at:
> + *
> + *     http://www.apache.org/licenses/LICENSE-2.0
> + *
> + * Unless required by applicable law or agreed to in writing, software
> + * distributed under the License is distributed on an "AS IS" BASIS,
> + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
> implied.
> + * See the License for the specific language governing permissions and
> + * limitations under the License.
> + */
> +
> +#ifndef OPENVSWITCH_OFP_IPFIX_H
> +#define OPENVSWITCH_OFP_IPFIX_H 1
> +
> +#include "openflow/openflow.h"
> +
> +struct ofpbuf;
> +struct ovs_list;
> +
> +#ifdef __cplusplus
> +extern "C" {
> +#endif
> +
> +struct ofputil_ipfix_stats {
> +    uint32_t collector_set_id;  /* Used only for flow-based IPFIX
> statistics. */
> +    uint64_t total_flows;  /* Totabl flows of this IPFIX exporter. */
> +    uint64_t current_flows;  /* Current flows of this IPFIX exporter. */
> +    uint64_t pkts;  /* Successfully sampled packets. */
> +    uint64_t ipv4_pkts;  /* Successfully sampled IPV4 packets. */
> +    uint64_t ipv6_pkts;  /* Successfully sampled IPV6 packets. */
> +    uint64_t error_pkts;  /* Error packets when sampling. */
> +    uint64_t ipv4_error_pkts;  /* Error IPV4 packets when sampling. */
> +    uint64_t ipv6_error_pkts;  /* Error IPV6 packets when sampling. */
> +    uint64_t tx_pkts;  /* TX IPFIX packets. */
> +    uint64_t tx_errors;  /* IPFIX packets TX errors. */
> +};
> +
> +void ofputil_append_ipfix_stat(struct ovs_list *replies,
> +                              const struct ofputil_ipfix_stats *);
> +size_t ofputil_count_ipfix_stats(const struct ofp_header *);
> +int ofputil_pull_ipfix_stats(struct ofputil_ipfix_stats *, struct ofpbuf
> *msg);
> +
> +#ifdef __cplusplus
> +}
> +#endif
> +
> +#endif  /* ofp-ipfix.h */
> diff --git a/include/openvswitch/ofp-match.h b/include/openvswitch/ofp-
> match.h
> new file mode 100644
> index 000000000000..8524ec11a9fb
> --- /dev/null
> +++ b/include/openvswitch/ofp-match.h
> @@ -0,0 +1,100 @@
> +/*
> + * Copyright (c) 2008-2017 Nicira, Inc.
> + *
> + * Licensed under the Apache License, Version 2.0 (the "License");
> + * you may not use this file except in compliance with the License.
> + * You may obtain a copy of the License at:
> + *
> + *     http://www.apache.org/licenses/LICENSE-2.0
> + *
> + * Unless required by applicable law or agreed to in writing, software
> + * distributed under the License is distributed on an "AS IS" BASIS,
> + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
> implied.
> + * See the License for the specific language governing permissions and
> + * limitations under the License.
> + */
> +
> +#ifndef OPENVSWITCH_OFP_MATCH_H
> +#define OPENVSWITCH_OFP_MATCH_H 1
> +
> +#include "openflow/openflow.h"
> +#include "openvswitch/list.h"
> +#include "openvswitch/ofp-protocol.h"
> +
> +struct vl_mff_map;
> +struct flow_wildcards;
> +struct match;
> +struct tun_table;
> +
> +#ifdef __cplusplus
> +extern "C" {
> +#endif
> +
> +/* Converting OFPFW10_NW_SRC_MASK and OFPFW10_NW_DST_MASK wildcard bit
> counts
> + * to and from IP bitmasks. */
> +ovs_be32 ofputil_wcbits_to_netmask(int wcbits);
> +int ofputil_netmask_to_wcbits(ovs_be32 netmask);
> +
> +/* Work with ofp10_match. */
> +void ofputil_wildcard_from_ofpfw10(uint32_t ofpfw, struct flow_wildcards
> *);
> +void ofputil_match_from_ofp10_match(const struct ofp10_match *,
> +                                    struct match *);
> +void ofputil_normalize_match(struct match *);
> +void ofputil_normalize_match_quiet(struct match *);
> +void ofputil_match_to_ofp10_match(const struct match *, struct
> ofp10_match *);
> +
> +/* Work with ofp11_match. */
> +enum ofperr ofputil_pull_ofp11_match(struct ofpbuf *, const struct
> tun_table *,
> +                                     const struct vl_mff_map *, struct
> match *,
> +                                     uint16_t *padded_match_len);
> +enum ofperr ofputil_match_from_ofp11_match(const struct ofp11_match *,
> +                                           struct match *);
> +int ofputil_put_ofp11_match(struct ofpbuf *, const struct match *,
> +                            enum ofputil_protocol);
> +void ofputil_match_to_ofp11_match(const struct match *, struct
> ofp11_match *);
> +int ofputil_match_typical_len(enum ofputil_protocol);
> +
> +/* dl_type translation between OpenFlow and 'struct flow' format. */
> +ovs_be16 ofputil_dl_type_to_openflow(ovs_be16 flow_dl_type);
> +ovs_be16 ofputil_dl_type_from_openflow(ovs_be16 ofp_dl_type);
> +
> +struct ofputil_tlv_map {
> +    struct ovs_list list_node;
> +
> +    uint16_t option_class;
> +    uint8_t  option_type;
> +    uint8_t  option_len;
> +    uint16_t index;
> +};
> +
> +struct ofputil_tlv_table_mod {
> +    uint16_t command;
> +    struct ovs_list mappings;      /* Contains "struct ofputil_tlv_map"s.
> */
> +};
> +
> +struct ofputil_tlv_table_reply {
> +    uint32_t max_option_space;
> +    uint16_t max_fields;
> +    struct ovs_list mappings;      /* Contains "struct ofputil_tlv_map"s.
> */
> +};
> +
> +struct ofpbuf *ofputil_encode_tlv_table_mod(enum ofp_version ofp_version,
> +                                               struct
> ofputil_tlv_table_mod *);
> +enum ofperr ofputil_decode_tlv_table_mod(const struct ofp_header *,
> +                                            struct ofputil_tlv_table_mod
> *);
> +struct ofpbuf *ofputil_encode_tlv_table_reply(const struct ofp_header *,
> +                                               struct
> ofputil_tlv_table_reply *);
> +enum ofperr ofputil_decode_tlv_table_reply(const struct ofp_header *,
> +                                              struct
> ofputil_tlv_table_reply *);
> +char *parse_ofp_tlv_table_mod_str(struct ofputil_tlv_table_mod *,
> +                                     uint16_t command, const char *string,
> +                                     enum ofputil_protocol
> *usable_protocols)
> +    OVS_WARN_UNUSED_RESULT;
> +
> +void ofputil_uninit_tlv_table(struct ovs_list *mappings);
> +
> +#ifdef __cplusplus
> +}
> +#endif
> +
> +#endif  /* ofp-match.h */
> diff --git a/include/openvswitch/ofp-meter.h b/include/openvswitch/ofp-
> meter.h
> new file mode 100644
> index 000000000000..18267a6fa260
> --- /dev/null
> +++ b/include/openvswitch/ofp-meter.h
> @@ -0,0 +1,123 @@
> +/*
> + * Copyright (c) 2008-2017 Nicira, Inc.
> + *
> + * Licensed under the Apache License, Version 2.0 (the "License");
> + * you may not use this file except in compliance with the License.
> + * You may obtain a copy of the License at:
> + *
> + *     http://www.apache.org/licenses/LICENSE-2.0
> + *
> + * Unless required by applicable law or agreed to in writing, software
> + * distributed under the License is distributed on an "AS IS" BASIS,
> + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
> implied.
> + * See the License for the specific language governing permissions and
> + * limitations under the License.
> + */
> +
> +#ifndef OPENVSWITCH_OFP_METER_H
> +#define OPENVSWITCH_OFP_METER_H 1
> +
> +#include "openflow/openflow.h"
> +#include "openvswitch/ofp-protocol.h"
> +
> +struct ofpbuf;
> +struct ovs_list;
> +
> +#ifdef __cplusplus
> +extern "C" {
> +#endif
> +
> +/* Type for meter_id in ofproto provider interface, UINT32_MAX if
> invalid. */
> +typedef struct { uint32_t uint32; } ofproto_meter_id;
> +
> +/* Meter band configuration for all supported band types. */
> +struct ofputil_meter_band {
> +    uint16_t type;
> +    uint8_t prec_level;         /* Non-zero if type ==
> OFPMBT_DSCP_REMARK. */
> +    uint32_t rate;
> +    uint32_t burst_size;
> +};
> +
> +struct ofputil_meter_band_stats {
> +    uint64_t packet_count;
> +    uint64_t byte_count;
> +};
> +
> +struct ofputil_meter_config {
> +    uint32_t meter_id;
> +    uint16_t flags;
> +    uint16_t n_bands;
> +    struct ofputil_meter_band *bands;
> +};
> +
> +void ofputil_append_meter_config(struct ovs_list *replies,
> +                                 const struct ofputil_meter_config *);
> +int ofputil_decode_meter_config(struct ofpbuf *,
> +                                struct ofputil_meter_config *,
> +                                struct ofpbuf *bands);
> +
> +struct ofputil_meter_mod {
> +    uint16_t command;
> +    struct ofputil_meter_config meter;
> +};
> +
> +enum ofperr ofputil_decode_meter_mod(const struct ofp_header *,
> +                                     struct ofputil_meter_mod *,
> +                                     struct ofpbuf *bands);
> +struct ofpbuf *ofputil_encode_meter_mod(enum ofp_version,
> +                                        const struct ofputil_meter_mod *);
> +char *parse_ofp_meter_mod_str(struct ofputil_meter_mod *, const char
> *string,
> +                              int command,
> +                              enum ofputil_protocol *usable_protocols)
> +    OVS_WARN_UNUSED_RESULT;
> +
> +struct ofputil_meter_stats {
> +    uint32_t meter_id;
> +    uint32_t flow_count;
> +    uint64_t packet_in_count;
> +    uint64_t byte_in_count;
> +    uint32_t duration_sec;
> +    uint32_t duration_nsec;
> +    uint16_t n_bands;
> +    struct ofputil_meter_band_stats *bands;
> +};
> +
> +void ofputil_append_meter_stats(struct ovs_list *replies,
> +                                const struct ofputil_meter_stats *);
> +int ofputil_decode_meter_stats(struct ofpbuf *,
> +                               struct ofputil_meter_stats *,
> +                               struct ofpbuf *bands);
> +
> +struct ofputil_meter_features {
> +    uint32_t max_meters;        /* Maximum number of meters. */
> +    uint32_t band_types;        /* Can support max 32 band types. */
> +    uint32_t capabilities;      /* Supported flags. */
> +    uint8_t  max_bands;
> +    uint8_t  max_color;
> +};
> +
> +void ofputil_decode_meter_features(const struct ofp_header *,
> +                                   struct ofputil_meter_features *);
> +struct ofpbuf *ofputil_encode_meter_features_reply(const struct
> +                                                   ofputil_meter_features
> *,
> +                                                   const struct
> ofp_header *
> +                                                   request);
> +
> +enum ofputil_meter_request_type {
> +    OFPUTIL_METER_FEATURES,
> +    OFPUTIL_METER_CONFIG,
> +    OFPUTIL_METER_STATS
> +};
> +
> +struct ofpbuf *ofputil_encode_meter_request(enum ofp_version,
> +                                            enum
> ofputil_meter_request_type,
> +                                            uint32_t meter_id);
> +void ofputil_decode_meter_request(const struct ofp_header *,
> +                                  uint32_t *meter_id);
> +
> +
> +#ifdef __cplusplus
> +}
> +#endif
> +
> +#endif  /* ofp-meter.h */
> diff --git a/include/openvswitch/ofp-monitor.h b/include/openvswitch/ofp-
> monitor.h
> new file mode 100644
> index 000000000000..7680440d4372
> --- /dev/null
> +++ b/include/openvswitch/ofp-monitor.h
> @@ -0,0 +1,129 @@
> +/*
> + * Copyright (c) 2008-2017 Nicira, Inc.
> + *
> + * Licensed under the Apache License, Version 2.0 (the "License");
> + * you may not use this file except in compliance with the License.
> + * You may obtain a copy of the License at:
> + *
> + *     http://www.apache.org/licenses/LICENSE-2.0
> + *
> + * Unless required by applicable law or agreed to in writing, software
> + * distributed under the License is distributed on an "AS IS" BASIS,
> + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
> implied.
> + * See the License for the specific language governing permissions and
> + * limitations under the License.
> + */
> +
> +#ifndef OPENVSWITCH_OFP_MONITOR_H
> +#define OPENVSWITCH_OFP_MONITOR_H 1
> +
> +#include "openflow/openflow.h"
> +#include "openvswitch/list.h"
> +#include "openvswitch/match.h"
> +#include "openvswitch/ofp-protocol.h"
> +#include "openvswitch/ofpbuf.h"
> +
> +#ifdef __cplusplus
> +extern "C" {
> +#endif
> +
> +struct ofputil_table_map;
> +
> +/* Flow removed message, independent of protocol. */
> +struct ofputil_flow_removed {
> +    struct match match;
> +    ovs_be64 cookie;
> +    uint16_t priority;
> +    uint8_t reason;             /* One of OFPRR_*. */
> +    uint8_t table_id;           /* 255 if message didn't include table
> ID. */
> +    uint32_t duration_sec;
> +    uint32_t duration_nsec;
> +    uint16_t idle_timeout;
> +    uint16_t hard_timeout;
> +    uint64_t packet_count;      /* Packet count, UINT64_MAX if unknown. */
> +    uint64_t byte_count;        /* Byte count, UINT64_MAX if unknown. */
> +};
> +
> +enum ofperr ofputil_decode_flow_removed(struct ofputil_flow_removed *,
> +                                        const struct ofp_header *);
> +struct ofpbuf *ofputil_encode_flow_removed(const struct
> ofputil_flow_removed *,
> +                                           enum ofputil_protocol);
> +
> +/* Abstract nx_flow_monitor_request. */
> +struct ofputil_flow_monitor_request {
> +    uint32_t id;
> +    enum nx_flow_monitor_flags flags;
> +    ofp_port_t out_port;
> +    uint8_t table_id;
> +    struct match match;
> +};
> +
> +int ofputil_decode_flow_monitor_request(struct
> ofputil_flow_monitor_request *,
> +                                        struct ofpbuf *msg);
> +void ofputil_append_flow_monitor_request(
> +    const struct ofputil_flow_monitor_request *, struct ofpbuf *msg);
> +char *parse_flow_monitor_request(struct ofputil_flow_monitor_request *,
> +                                 const char *,
> +                                 const struct ofputil_port_map *,
> +                                 const struct ofputil_table_map *,
> +                                 enum ofputil_protocol *usable_protocols)
> +    OVS_WARN_UNUSED_RESULT;
> +
> +/* Abstract nx_flow_update. */
> +struct ofputil_flow_update {
> +    enum nx_flow_update_event event;
> +
> +    /* Used only for NXFME_ADDED, NXFME_DELETED, NXFME_MODIFIED. */
> +    enum ofp_flow_removed_reason reason;
> +    uint16_t idle_timeout;
> +    uint16_t hard_timeout;
> +    uint8_t table_id;
> +    uint16_t priority;
> +    ovs_be64 cookie;
> +    struct match match;
> +    const struct ofpact *ofpacts;
> +    size_t ofpacts_len;
> +
> +    /* Used only for NXFME_ABBREV. */
> +    ovs_be32 xid;
> +};
> +
> +int ofputil_decode_flow_update(struct ofputil_flow_update *,
> +                               struct ofpbuf *msg, struct ofpbuf
> *ofpacts);
> +void ofputil_start_flow_update(struct ovs_list *replies);
> +void ofputil_append_flow_update(const struct ofputil_flow_update *,
> +                                struct ovs_list *replies,
> +                                const struct tun_table *);
> +
> +/* Abstract nx_flow_monitor_cancel. */
> +uint32_t ofputil_decode_flow_monitor_cancel(const struct ofp_header *);
> +struct ofpbuf *ofputil_encode_flow_monitor_cancel(uint32_t id);
> +
> +struct ofputil_requestforward {
> +    ovs_be32 xid;
> +    enum ofp14_requestforward_reason reason;
> +    union {
> +        /* reason == OFPRFR_METER_MOD. */
> +        struct {
> +            struct ofputil_meter_mod *meter_mod;
> +            struct ofpbuf bands;
> +        };
> +
> +        /* reason == OFPRFR_GROUP_MOD. */
> +        struct ofputil_group_mod *group_mod;
> +    };
> +};
> +
> +struct ofpbuf *ofputil_encode_requestforward(
> +    const struct ofputil_requestforward *, enum ofputil_protocol);
> +enum ofperr ofputil_decode_requestforward(const struct ofp_header *,
> +                                          struct ofputil_requestforward
> *);
> +void ofputil_destroy_requestforward(struct ofputil_requestforward *);
> +
> +
> +
> +#ifdef __cplusplus
> +}
> +#endif
> +
> +#endif  /* ofp-monitor.h */
> diff --git a/include/openvswitch/ofp-packet.h b/include/openvswitch/ofp-
> packet.h
> new file mode 100644
> index 000000000000..d6e78fb9ef2c
> --- /dev/null
> +++ b/include/openvswitch/ofp-packet.h
> @@ -0,0 +1,168 @@
> +/*
> + * Copyright (c) 2008-2017 Nicira, Inc.
> + *
> + * Licensed under the Apache License, Version 2.0 (the "License");
> + * you may not use this file except in compliance with the License.
> + * You may obtain a copy of the License at:
> + *
> + *     http://www.apache.org/licenses/LICENSE-2.0
> + *
> + * Unless required by applicable law or agreed to in writing, software
> + * distributed under the License is distributed on an "AS IS" BASIS,
> + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
> implied.
> + * See the License for the specific language governing permissions and
> + * limitations under the License.
> + */
> +
> +#ifndef OPENVSWITCH_OFP_PACKET_H
> +#define OPENVSWITCH_OFP_PACKET_H 1
> +
> +#include "openflow/openflow.h"
> +#include "openflow/nicira-ext.h"
> +#include "openvswitch/match.h"
> +#include "openvswitch/ofp-protocol.h"
> +#include "openvswitch/type-props.h"
> +#include "openvswitch/uuid.h"
> +
> +#ifdef __cplusplus
> +extern "C" {
> +#endif
> +
> +struct vl_mff_map;
> +struct ofputil_table_map;
> +
> +bool ofputil_packet_in_format_is_valid(enum nx_packet_in_format);
> +int ofputil_packet_in_format_from_string(const char *);
> +const char *ofputil_packet_in_format_to_string(enum nx_packet_in_format);
> +struct ofpbuf *ofputil_make_set_packet_in_format(enum ofp_version,
> +                                                 enum
> nx_packet_in_format);
> +
> +/* Abstract packet-in message.
> + *
> + * This omits the 'total_len' and 'buffer_id' fields, which we handle
> + * differently for encoding and decoding.*/
> +struct ofputil_packet_in {
> +    /* Packet data and metadata.
> +     *
> +     * On encoding, the full packet should be supplied, but depending on
> its
> +     * other parameters ofputil_encode_packet_in() might send only the
> first
> +     * part of the packet.
> +     *
> +     * On decoding, the 'len' bytes in 'packet' might only be the first
> part of
> +     * the original packet.  ofputil_decode_packet_in() reports the full
> +     * original length of the packet using its 'total_len' output
> parameter. */
> +    void *packet;               /* The packet. */
> +    size_t packet_len;          /* Length of 'packet' in bytes. */
> +
> +    /* Input port and other metadata for packet. */
> +    struct match flow_metadata;
> +
> +    /* Reason that the packet-in is being sent. */
> +    enum ofp_packet_in_reason reason;    /* One of OFPR_*. */
> +
> +    /* Information about the OpenFlow flow that triggered the packet-in.
> +     *
> +     * A packet-in triggered by a flow table miss has no associated
> flow.  In
> +     * that case, 'cookie' is UINT64_MAX. */
> +    uint8_t table_id;                    /* OpenFlow table ID. */
> +    ovs_be64 cookie;                     /* Flow's cookie. */
> +
> +    /* Arbitrary user-provided data. */
> +    uint8_t *userdata;
> +    size_t userdata_len;
> +};
> +
> +void ofputil_packet_in_destroy(struct ofputil_packet_in *);
> +
> +enum ofperr ofputil_decode_packet_in(const struct ofp_header *, bool
> loose,
> +                                     const struct tun_table *,
> +                                     const struct vl_mff_map *,
> +                                     struct ofputil_packet_in *,
> +                                     size_t *total_len, uint32_t
> *buffer_id,
> +                                     struct ofpbuf *continuation);
> +
> +struct ofpbuf *ofputil_encode_resume(const struct ofputil_packet_in *pin,
> +                                     const struct ofpbuf *continuation,
> +                                     enum ofputil_protocol);
> +
> +enum { OFPUTIL_PACKET_IN_REASON_BUFSIZE = INT_STRLEN(int) + 1 };
> +const char *ofputil_packet_in_reason_to_string(enum ofp_packet_in_reason,
> +                                               char *reasonbuf,
> +                                               size_t bufsize);
> +bool ofputil_packet_in_reason_from_string(const char *,
> +                                          enum ofp_packet_in_reason *);
> +
> +/* A packet-in message, including continuation data.  The format of
> + * continuation data is subject to change and thus it is supposed to be
> opaque
> + * to any process other than ovs-vswitchd.  Therefore, only ovs-vswitchd
> should
> + * use ofputil_packet_in_private and the functions that operate on it. */
> +struct ofputil_packet_in_private {
> +    struct ofputil_packet_in base;
> +
> +    /* NXCPT_BRIDGE. */
> +    struct uuid bridge;
> +
> +    /* NXCPT_STACK. */
> +    uint8_t *stack;
> +    size_t stack_size;
> +
> +    /* NXCPT_MIRRORS. */
> +    uint32_t mirrors;
> +
> +    /* NXCPT_CONNTRACKED. */
> +    bool conntracked;
> +
> +    /* NXCPT_ACTIONS. */
> +    struct ofpact *actions;
> +    size_t actions_len;
> +
> +    /* NXCPT_ACTION_SET. */
> +    struct ofpact *action_set;
> +    size_t action_set_len;
> +};
> +
> +struct ofpbuf *ofputil_encode_packet_in_private(
> +    const struct ofputil_packet_in_private *,
> +    enum ofputil_protocol protocol,
> +    enum nx_packet_in_format);
> +
> +enum ofperr ofputil_decode_packet_in_private(
> +    const struct ofp_header *, bool loose,
> +    const struct tun_table *,
> +    const struct vl_mff_map *,
> +    struct ofputil_packet_in_private *,
> +    size_t *total_len, uint32_t *buffer_id);
> +
> +void ofputil_packet_in_private_destroy(struct ofputil_packet_in_private
> *);
> +
> +/* Abstract packet-out message.
> + *
> + * ofputil_decode_packet_out() will ensure that 'in_port' is a physical
> port
> + * (OFPP_MAX or less) or one of OFPP_LOCAL, OFPP_NONE, or
> OFPP_CONTROLLER. */
> +struct ofputil_packet_out {
> +    const void *packet;         /* Packet data, if buffer_id ==
> UINT32_MAX. */
> +    size_t packet_len;          /* Length of packet data in bytes. */
> +    uint32_t buffer_id;         /* Buffer id or UINT32_MAX if no buffer.
> */
> +    struct match flow_metadata; /* Packet's input port and other
> metadata. */
> +    struct ofpact *ofpacts;     /* Actions. */
> +    size_t ofpacts_len;         /* Size of ofpacts in bytes. */
> +};
> +
> +enum ofperr ofputil_decode_packet_out(struct ofputil_packet_out *,
> +                                      const struct ofp_header *,
> +                                      const struct tun_table *,
> +                                      struct ofpbuf *ofpacts);
> +struct ofpbuf *ofputil_encode_packet_out(const struct ofputil_packet_out
> *,
> +                                         enum ofputil_protocol protocol);
> +
> +char *parse_ofp_packet_out_str(struct ofputil_packet_out *, const char *,
> +                               const struct ofputil_port_map *,
> +                               const struct ofputil_table_map *,
> +                               enum ofputil_protocol *usable_protocols)
> +    OVS_WARN_UNUSED_RESULT;
> +
> +#ifdef __cplusplus
> +}
> +#endif
> +
> +#endif  /* ofp-packet.h */
> diff --git a/include/openvswitch/ofp-parse.h b/include/openvswitch/ofp-
> parse.h
> index c4228a50358f..3fdd468acdfe 100644
> --- a/include/openvswitch/ofp-parse.h
> +++ b/include/openvswitch/ofp-parse.h
> @@ -23,106 +23,29 @@
>  #include <stdint.h>
>  #include <stdio.h>
>  #include "openvswitch/compiler.h"
> +#include "openvswitch/ofp-protocol.h"
>  #include "openvswitch/types.h"
>
>  #ifdef __cplusplus
>  extern "C" {
>  #endif
>
> -struct flow;
> -struct ofpbuf;
> -struct ofputil_flow_mod;
> -struct ofputil_packet_out;
> -struct ofputil_flow_monitor_request;
> -struct ofputil_flow_stats_request;
> -struct ofputil_group_mod;
> -struct ofputil_meter_mod;
> -struct ofputil_table_mod;
> -struct ofputil_bundle_msg;
> -struct ofputil_tlv_table_mod;
> -struct simap;
> -enum ofputil_protocol;
> +struct match;
> +struct mf_field;
> +struct ofputil_port_map;
>
> -char *parse_ofp_str(struct ofputil_flow_mod *, int command, const char
> *str_,
> -                    const struct ofputil_port_map *,
> -                    const struct ofputil_table_map *,
> -                    enum ofputil_protocol *usable_protocols)
> -    OVS_WARN_UNUSED_RESULT;
> -
> -char *parse_ofp_flow_mod_str(struct ofputil_flow_mod *, const char
> *string,
> -                             const struct ofputil_port_map *,
> -                             const struct ofputil_table_map *,
> -                             int command,
> -                             enum ofputil_protocol *usable_protocols)
> -    OVS_WARN_UNUSED_RESULT;
> -
> -char *parse_ofp_packet_out_str(struct ofputil_packet_out *po, const char
> *str_,
> -                               const struct ofputil_port_map *,
> -                               const struct ofputil_table_map *,
> -                               enum ofputil_protocol *usable_protocols)
> -    OVS_WARN_UNUSED_RESULT;
> -
> -char *parse_ofp_table_mod(struct ofputil_table_mod *,
> -                          const char *table_id, const char
> *flow_miss_handling,
> -                          const struct ofputil_table_map *,
> -                          uint32_t *usable_versions)
> -    OVS_WARN_UNUSED_RESULT;
> -
> -char *parse_ofp_flow_mod_file(const char *file_name,
> -                              const struct ofputil_port_map *,
> -                              const struct ofputil_table_map *,
> -                              int command,
> -                              struct ofputil_flow_mod **fms, size_t
> *n_fms,
> -                              enum ofputil_protocol *usable_protocols)
> -    OVS_WARN_UNUSED_RESULT;
> +struct ofp_protocol {
> +    const char *name;
> +    uint16_t dl_type;
> +    uint8_t nw_proto;
> +};
>
> -char *parse_ofp_flow_stats_request_str(struct ofputil_flow_stats_request
> *,
> -                                       bool aggregate, const char *string,
> -                                       const struct ofputil_port_map *,
> -                                       const struct ofputil_table_map *,
> -                                       enum ofputil_protocol
> *usable_protocols)
> -    OVS_WARN_UNUSED_RESULT;
> -
> -char *parse_ofp_exact_flow(struct flow *flow, struct flow_wildcards *wc,
> -                           const struct tun_table *tun_table, const char
> *s,
> -                           const struct ofputil_port_map *port_map);
> +bool ofp_parse_protocol(const char *name, const struct ofp_protocol **);
>
> -char *parse_ofp_meter_mod_str(struct ofputil_meter_mod *, const char
> *string,
> -                              int command,
> -                              enum ofputil_protocol *usable_protocols)
> -    OVS_WARN_UNUSED_RESULT;
> -
> -char *parse_flow_monitor_request(struct ofputil_flow_monitor_request *,
> -                                 const char *,
> -                                 const struct ofputil_port_map *,
> -                                 const struct ofputil_table_map *,
> -                                 enum ofputil_protocol *usable_protocols)
> -    OVS_WARN_UNUSED_RESULT;
> -
> -char *parse_ofp_group_mod_file(const char *file_name,
> -                               const struct ofputil_port_map *,
> -                               const struct ofputil_table_map *, int
> command,
> -                               struct ofputil_group_mod **gms, size_t
> *n_gms,
> -                               enum ofputil_protocol *usable_protocols)
> -    OVS_WARN_UNUSED_RESULT;
> -
> -char *parse_ofp_group_mod_str(struct ofputil_group_mod *, int command,
> -                              const char *string,
> -                              const struct ofputil_port_map *,
> -                              const struct ofputil_table_map *,
> -                              enum ofputil_protocol *usable_protocols)
> -    OVS_WARN_UNUSED_RESULT;
> -
> -char *parse_ofp_bundle_file(const char *file_name,
> -                            const struct ofputil_port_map *,
> -                            const struct ofputil_table_map *,
> -                            struct ofputil_bundle_msg **, size_t *n_bms,
> -                            enum ofputil_protocol *)
> -    OVS_WARN_UNUSED_RESULT;
> -
> -char *parse_ofp_tlv_table_mod_str(struct ofputil_tlv_table_mod *,
> -                                     uint16_t command, const char *string,
> -                                     enum ofputil_protocol
> *usable_protocols)
> +char *ofp_extract_actions(char *);
> +char *ofp_parse_field(const struct mf_field *, const char *,
> +                      const struct ofputil_port_map *, struct match *,
> +                      enum ofputil_protocol *usable_protocols)
>      OVS_WARN_UNUSED_RESULT;
>
>  char *str_to_u8(const char *str, const char *name, uint8_t *valuep)
> @@ -135,9 +58,9 @@ char *str_to_be64(const char *str, ovs_be64 *valuep)
> OVS_WARN_UNUSED_RESULT;
>  char *str_to_mac(const char *str, struct eth_addr *mac)
> OVS_WARN_UNUSED_RESULT;
>  char *str_to_ip(const char *str, ovs_be32 *ip) OVS_WARN_UNUSED_RESULT;
>  char *str_to_connhelper(const char *str, uint16_t *alg)
> OVS_WARN_UNUSED_RESULT;
> -char *parse_ofp_table_vacancy(struct ofputil_table_mod *,
> -                              const char *flow_miss_handling)
> -    OVS_WARN_UNUSED_RESULT;
> +
> +/* Handy utility for parsing flows and actions. */
> +bool ofputil_parse_key_value(char **stringp, char **keyp, char **valuep);
>
>  #ifdef __cplusplus
>  }
> diff --git a/include/openvswitch/ofp-port.h b/include/openvswitch/ofp-
> port.h
> new file mode 100644
> index 000000000000..59ca0373b032
> --- /dev/null
> +++ b/include/openvswitch/ofp-port.h
> @@ -0,0 +1,177 @@
> +/*
> + * Copyright (c) 2008-2017 Nicira, Inc.
> + *
> + * Licensed under the Apache License, Version 2.0 (the "License");
> + * you may not use this file except in compliance with the License.
> + * You may obtain a copy of the License at:
> + *
> + *     http://www.apache.org/licenses/LICENSE-2.0
> + *
> + * Unless required by applicable law or agreed to in writing, software
> + * distributed under the License is distributed on an "AS IS" BASIS,
> + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
> implied.
> + * See the License for the specific language governing permissions and
> + * limitations under the License.
> + */
> +
> +#ifndef OPENVSWITCH_OFP_PORT_H
> +#define OPENVSWITCH_OFP_PORT_H 1
> +
> +#include "openvswitch/hmap.h"
> +#include "openvswitch/netdev.h"
> +#include "openvswitch/ofp-protocol.h"
> +#include "openvswitch/namemap.h"
> +
> +struct ds;
> +struct ofpbuf;
> +struct ovs_list;
> +
> +#ifdef __cplusplus
> +extern "C" {
> +#endif
> +
> +/* Mapping between port numbers and names. */
> +struct ofputil_port_map {
> +    struct namemap map;
> +};
> +#define OFPUTIL_PORT_MAP_INITIALIZER(MAP) { NAMEMAP_INITIALIZER(&(MAP)->map)
> }
> +
> +void ofputil_port_map_init(struct ofputil_port_map *);
> +const char *ofputil_port_map_get_name(const struct ofputil_port_map *,
> +                                      ofp_port_t);
> +ofp_port_t ofputil_port_map_get_number(const struct ofputil_port_map *,
> +                                      const char *name);
> +void ofputil_port_map_put(struct ofputil_port_map *,
> +                          ofp_port_t, const char *name);
> +void ofputil_port_map_destroy(struct ofputil_port_map *);
> +
> +/* Port numbers. */
> +enum ofperr ofputil_port_from_ofp11(ovs_be32 ofp11_port,
> +                                    ofp_port_t *ofp10_port);
> +ovs_be32 ofputil_port_to_ofp11(ofp_port_t ofp10_port);
> +
> +bool ofputil_port_from_string(const char *, const struct ofputil_port_map
> *,
> +                              ofp_port_t *portp);
> +const char *ofputil_port_get_reserved_name(ofp_port_t);
> +void ofputil_format_port(ofp_port_t port, const struct ofputil_port_map *,
> +                         struct ds *);
> +void ofputil_port_to_string(ofp_port_t, const struct ofputil_port_map *,
> +                            char *namebuf, size_t bufsize);
> +
> +enum ofputil_port_config {
> +    /* OpenFlow 1.0 and 1.1 share these values for these port config
> bits. */
> +    OFPUTIL_PC_PORT_DOWN    = 1 << 0, /* Port is administratively down. */
> +    OFPUTIL_PC_NO_RECV      = 1 << 2, /* Drop all packets received by
> port. */
> +    OFPUTIL_PC_NO_FWD       = 1 << 5, /* Drop packets forwarded to port.
> */
> +    OFPUTIL_PC_NO_PACKET_IN = 1 << 6, /* No send packet-in msgs for port.
> */
> +    /* OpenFlow 1.0 only. */
> +    OFPUTIL_PC_NO_STP       = 1 << 1, /* No 802.1D spanning tree for
> port. */
> +    OFPUTIL_PC_NO_RECV_STP  = 1 << 3, /* Drop received 802.1D STP
> packets. */
> +    OFPUTIL_PC_NO_FLOOD     = 1 << 4, /* Do not include port when
> flooding. */
> +    /* There are no OpenFlow 1.1-only bits. */
> +};
> +
> +enum ofputil_port_state {
> +    /* OpenFlow 1.0 and 1.1 share this values for these port state bits.
> */
> +    OFPUTIL_PS_LINK_DOWN   = 1 << 0, /* No physical link present. */
> +    /* OpenFlow 1.1 only. */
> +    OFPUTIL_PS_BLOCKED     = 1 << 1, /* Port is blocked */
> +    OFPUTIL_PS_LIVE        = 1 << 2, /* Live for Fast Failover Group. */
> +    /* OpenFlow 1.0 only. */
> +    OFPUTIL_PS_STP_LISTEN  = 0 << 8, /* Not learning or relaying frames.
> */
> +    OFPUTIL_PS_STP_LEARN   = 1 << 8, /* Learning but not relaying frames.
> */
> +    OFPUTIL_PS_STP_FORWARD = 2 << 8, /* Learning and relaying frames. */
> +    OFPUTIL_PS_STP_BLOCK   = 3 << 8, /* Not part of spanning tree. */
> +    OFPUTIL_PS_STP_MASK    = 3 << 8  /* Bit mask for OFPPS10_STP_*
> values. */
> +};
> +
> +/* Abstract ofp10_phy_port, ofp11_port, ofp14_port, or ofp16_port. */
> +struct ofputil_phy_port {
> +    ofp_port_t port_no;
> +
> +    /* Hardware addresses.
> +     *
> +     * Most hardware has a normal 48-bit Ethernet address, in hw_addr.
> +     * Some hardware might have a 64-bit address in hw_addr64.
> +     * All-bits-0 indicates that a given address is not present. */
> +    struct eth_addr hw_addr;
> +    struct eth_addr64 hw_addr64;
> +
> +    char name[OFP16_MAX_PORT_NAME_LEN]; /* 64 bytes in OF1.6+, 16
> otherwise. */
> +    enum ofputil_port_config config;
> +    enum ofputil_port_state state;
> +
> +    /* NETDEV_F_* feature bitmasks. */
> +    enum netdev_features curr;       /* Current features. */
> +    enum netdev_features advertised; /* Features advertised by the port.
> */
> +    enum netdev_features supported;  /* Features supported by the port. */
> +    enum netdev_features peer;       /* Features advertised by peer. */
> +
> +    /* Speed. */
> +    uint32_t curr_speed;        /* Current speed, in kbps. */
> +    uint32_t max_speed;         /* Maximum supported speed, in kbps. */
> +};
> +
> +/* phy_port helper functions. */
> +void ofputil_put_phy_port(enum ofp_version,
> +                          const struct ofputil_phy_port *, struct ofpbuf
> *);
> +int ofputil_pull_phy_port(enum ofp_version, struct ofpbuf *,
> +                          struct ofputil_phy_port *);
> +
> +/* Abstract ofp_port_status. */
> +struct ofputil_port_status {
> +    enum ofp_port_reason reason;
> +    struct ofputil_phy_port desc;
> +};
> +
> +enum ofperr ofputil_decode_port_status(const struct ofp_header *,
> +                                       struct ofputil_port_status *);
> +struct ofpbuf *ofputil_encode_port_status(const struct
> ofputil_port_status *,
> +                                          enum ofputil_protocol);
> +
> +/* Abstract ofp_port_mod. */
> +struct ofputil_port_mod {
> +    ofp_port_t port_no;
> +    struct eth_addr hw_addr;
> +    struct eth_addr64 hw_addr64;
> +    enum ofputil_port_config config;
> +    enum ofputil_port_config mask;
> +    enum netdev_features advertise;
> +};
> +
> +enum ofperr ofputil_decode_port_mod(const struct ofp_header *,
> +                                    struct ofputil_port_mod *, bool
> loose);
> +struct ofpbuf *ofputil_encode_port_mod(const struct ofputil_port_mod *,
> +                                       enum ofputil_protocol);
> +
> +struct ofputil_port_stats {
> +    ofp_port_t port_no;
> +    struct netdev_stats stats;
> +    struct netdev_custom_stats custom_stats;
> +    uint32_t duration_sec;      /* UINT32_MAX if unknown. */
> +    uint32_t duration_nsec;
> +};
> +
> +struct ofpbuf *ofputil_encode_dump_ports_request(enum ofp_version
> ofp_version,
> +                                                 ofp_port_t port);
> +void ofputil_append_port_stat(struct ovs_list *replies,
> +                              const struct ofputil_port_stats *ops);
> +size_t ofputil_count_port_stats(const struct ofp_header *);
> +int ofputil_decode_port_stats(struct ofputil_port_stats *, struct ofpbuf
> *msg);
> +enum ofperr ofputil_decode_port_stats_request(const struct ofp_header
> *request,
> +                                              ofp_port_t *ofp10_port);
> +
> +/* Port desc stats requests and replies. */
> +enum ofperr ofputil_decode_port_desc_stats_request(const struct
> ofp_header *,
> +                                                   ofp_port_t *portp);
> +struct ofpbuf *ofputil_encode_port_desc_stats_request(
> +    enum ofp_version ofp_version, ofp_port_t);
> +
> +void ofputil_append_port_desc_stats_reply(const struct ofputil_phy_port
> *pp,
> +                                          struct ovs_list *replies);
> +
> +#ifdef __cplusplus
> +}
> +#endif
> +
> +#endif  /* ofp-port.h */
> diff --git a/include/openvswitch/ofp-protocol.h b/include/openvswitch/ofp-
> protocol.h
> new file mode 100644
> index 000000000000..bd1bedf32e69
> --- /dev/null
> +++ b/include/openvswitch/ofp-protocol.h
> @@ -0,0 +1,174 @@
> +/*
> + * Copyright (c) 2008-2017 Nicira, Inc.
> + *
> + * Licensed under the Apache License, Version 2.0 (the "License");
> + * you may not use this file except in compliance with the License.
> + * You may obtain a copy of the License at:
> + *
> + *     http://www.apache.org/licenses/LICENSE-2.0
> + *
> + * Unless required by applicable law or agreed to in writing, software
> + * distributed under the License is distributed on an "AS IS" BASIS,
> + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
> implied.
> + * See the License for the specific language governing permissions and
> + * limitations under the License.
> + */
> +
> +#ifndef OPENVSWITCH_OFP_PROTOCOL_H
> +#define OPENVSWITCH_OFP_PROTOCOL_H 1
> +
> +#include "openflow/openflow.h"
> +
> +struct ds;
> +
> +#ifdef __cplusplus
> +extern "C" {
> +#endif
> +
> +/* Protocols.
> + *
> + * A "protocol" is an OpenFlow version plus, for some OpenFlow versions,
> + * a bit extra about the flow match format in use.
> + *
> + * These are arranged from most portable to least portable, or
> alternatively
> + * from least powerful to most powerful.  Protocols earlier on the list
> are
> + * more likely to be understood for the purpose of making requests, but
> + * protocol later on the list are more likely to accurately describe a
> flow
> + * within a switch.
> + *
> + * On any given OpenFlow connection, a single protocol is in effect at any
> + * given time.  These values use separate bits only because that makes it
> easy
> + * to test whether a particular protocol is within a given set of
> protocols and
> + * to implement set union and intersection.
> + */
> +enum ofputil_protocol {
> +    /* OpenFlow 1.0 protocols.
> +     *
> +     * The "STD" protocols use the standard OpenFlow 1.0 flow format.
> +     * The "NXM" protocols use the Nicira Extensible Match (NXM) flow
> format.
> +     *
> +     * The protocols with "TID" mean that the nx_flow_mod_table_id Nicira
> +     * extension has been enabled.  The other protocols have it disabled.
> +     */
> +#define OFPUTIL_P_NONE 0
> +    OFPUTIL_P_OF10_STD     = 1 << 0,
> +    OFPUTIL_P_OF10_STD_TID = 1 << 1,
> +    OFPUTIL_P_OF10_NXM     = 1 << 2,
> +    OFPUTIL_P_OF10_NXM_TID = 1 << 3,
> +#define OFPUTIL_P_OF10_STD_ANY (OFPUTIL_P_OF10_STD |
> OFPUTIL_P_OF10_STD_TID)
> +#define OFPUTIL_P_OF10_NXM_ANY (OFPUTIL_P_OF10_NXM |
> OFPUTIL_P_OF10_NXM_TID)
> +#define OFPUTIL_P_OF10_ANY (OFPUTIL_P_OF10_STD_ANY |
> OFPUTIL_P_OF10_NXM_ANY)
> +
> +    /* OpenFlow 1.1 protocol.
> +     *
> +     * We only support the standard OpenFlow 1.1 flow format.
> +     *
> +     * OpenFlow 1.1 always operates with an equivalent of the
> +     * nx_flow_mod_table_id Nicira extension enabled, so there is no "TID"
> +     * variant. */
> +    OFPUTIL_P_OF11_STD     = 1 << 4,
> +
> +    /* OpenFlow 1.2+ protocols (only one variant each).
> +     *
> +     * These use the standard OpenFlow Extensible Match (OXM) flow format.
> +     *
> +     * OpenFlow 1.2+ always operates with an equivalent of the
> +     * nx_flow_mod_table_id Nicira extension enabled, so there is no "TID"
> +     * variant. */
> +    OFPUTIL_P_OF12_OXM      = 1 << 5,
> +    OFPUTIL_P_OF13_OXM      = 1 << 6,
> +    OFPUTIL_P_OF14_OXM      = 1 << 7,
> +    OFPUTIL_P_OF15_OXM      = 1 << 8,
> +    OFPUTIL_P_OF16_OXM      = 1 << 9,
> +#define OFPUTIL_P_ANY_OXM (OFPUTIL_P_OF12_OXM | \
> +                           OFPUTIL_P_OF13_OXM | \
> +                           OFPUTIL_P_OF14_OXM | \
> +                           OFPUTIL_P_OF15_OXM | \
> +                           OFPUTIL_P_OF16_OXM)
> +
> +#define OFPUTIL_P_NXM_OF11_UP (OFPUTIL_P_OF10_NXM_ANY |
> OFPUTIL_P_OF11_STD | \
> +                               OFPUTIL_P_ANY_OXM)
> +
> +#define OFPUTIL_P_NXM_OXM_ANY (OFPUTIL_P_OF10_NXM_ANY | OFPUTIL_P_ANY_OXM)
> +
> +#define OFPUTIL_P_OF11_UP (OFPUTIL_P_OF11_STD | OFPUTIL_P_ANY_OXM)
> +
> +#define OFPUTIL_P_OF12_UP (OFPUTIL_P_OF12_OXM | OFPUTIL_P_OF13_UP)
> +#define OFPUTIL_P_OF13_UP (OFPUTIL_P_OF13_OXM | OFPUTIL_P_OF14_UP)
> +#define OFPUTIL_P_OF14_UP (OFPUTIL_P_OF14_OXM | OFPUTIL_P_OF15_UP)
> +#define OFPUTIL_P_OF15_UP (OFPUTIL_P_OF15_OXM | OFPUTIL_P_OF16_UP)
> +#define OFPUTIL_P_OF16_UP OFPUTIL_P_OF16_OXM
> +
> +    /* All protocols. */
> +#define OFPUTIL_P_ANY ((1 << 10) - 1)
> +
> +    /* Protocols in which a specific table may be specified in flow_mods.
> */
> +#define OFPUTIL_P_TID (OFPUTIL_P_OF10_STD_TID | \
> +                       OFPUTIL_P_OF10_NXM_TID | \
> +                       OFPUTIL_P_OF11_STD |     \
> +                       OFPUTIL_P_ANY_OXM)
> +};
> +
> +/* Protocols to use for flow dumps, from most to least preferred. */
> +extern enum ofputil_protocol ofputil_flow_dump_protocols[];
> +extern size_t ofputil_n_flow_dump_protocols;
> +
> +enum ofputil_protocol ofputil_protocol_from_ofp_version(enum
> ofp_version);
> +enum ofputil_protocol ofputil_protocols_from_ofp_version(enum
> ofp_version);
> +enum ofp_version ofputil_protocol_to_ofp_version(enum ofputil_protocol);
> +
> +bool ofputil_protocol_is_valid(enum ofputil_protocol);
> +enum ofputil_protocol ofputil_protocol_set_tid(enum ofputil_protocol,
> +                                               bool enable);
> +enum ofputil_protocol ofputil_protocol_to_base(enum ofputil_protocol);
> +enum ofputil_protocol ofputil_protocol_set_base(
> +    enum ofputil_protocol cur, enum ofputil_protocol new_base);
> +
> +const char *ofputil_protocol_to_string(enum ofputil_protocol);
> +char *ofputil_protocols_to_string(enum ofputil_protocol);
> +enum ofputil_protocol ofputil_protocols_from_string(const char *);
> +
> +void ofputil_format_version(struct ds *, enum ofp_version);
> +void ofputil_format_version_name(struct ds *, enum ofp_version);
> +
> +/* A bitmap of version numbers
> + *
> + * Bit offsets correspond to ofp_version numbers which in turn correspond
> to
> + * wire-protocol numbers for OpenFlow versions, e.g. (1u << OFP11_VERSION)
> + * is the mask for OpenFlow 1.1.  If the bit for a version is set then it
> is
> + * allowed, otherwise it is disallowed. */
> +
> +void ofputil_format_version_bitmap(struct ds *msg, uint32_t bitmap);
> +void ofputil_format_version_bitmap_names(struct ds *msg, uint32_t
> bitmap);
> +
> +enum ofp_version ofputil_version_from_string(const char *s);
> +
> +uint32_t ofputil_protocols_to_version_bitmap(enum ofputil_protocol);
> +enum ofputil_protocol ofputil_protocols_from_version_bitmap(uint32_t
> bitmap);
> +
> +/* Bitmaps of OpenFlow versions that Open vSwitch supports, and that it
> enables
> + * by default.  When Open vSwitch has experimental or incomplete support
> for
> + * newer versions of OpenFlow, those versions should not be supported by
> + * default and thus should be omitted from the latter bitmap. */
> +#define OFPUTIL_SUPPORTED_VERSIONS ((1u << OFP10_VERSION) | \
> +                                    (1u << OFP11_VERSION) | \
> +                                    (1u << OFP12_VERSION) | \
> +                                    (1u << OFP13_VERSION) | \
> +                                    (1u << OFP14_VERSION))
> +#define OFPUTIL_DEFAULT_VERSIONS OFPUTIL_SUPPORTED_VERSIONS
> +
> +enum ofputil_protocol ofputil_protocols_from_string(const char *s);
> +
> +const char *ofputil_version_to_string(enum ofp_version ofp_version);
> +uint32_t ofputil_versions_from_string(const char *s);
> +uint32_t ofputil_versions_from_strings(char ** const s, size_t count);
> +
> +struct ofpbuf *ofputil_encode_set_protocol(enum ofputil_protocol current,
> +                                           enum ofputil_protocol want,
> +                                           enum ofputil_protocol *next);
> +
> +#ifdef __cplusplus
> +}
> +#endif
> +
> +#endif  /* ofp-protocol.h */
> diff --git a/include/openvswitch/ofp-queue.h b/include/openvswitch/ofp-
> queue.h
> new file mode 100644
> index 000000000000..b0229685ba6d
> --- /dev/null
> +++ b/include/openvswitch/ofp-queue.h
> @@ -0,0 +1,90 @@
> +/*
> + * Copyright (c) 2008-2017 Nicira, Inc.
> + *
> + * Licensed under the Apache License, Version 2.0 (the "License");
> + * you may not use this file except in compliance with the License.
> + * You may obtain a copy of the License at:
> + *
> + *     http://www.apache.org/licenses/LICENSE-2.0
> + *
> + * Unless required by applicable law or agreed to in writing, software
> + * distributed under the License is distributed on an "AS IS" BASIS,
> + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
> implied.
> + * See the License for the specific language governing permissions and
> + * limitations under the License.
> + */
> +
> +#ifndef OPENVSWITCH_OFP_QUEUE_H
> +#define OPENVSWITCH_OFP_QUEUE_H 1
> +
> +#include "openflow/openflow.h"
> +
> +struct ofpbuf;
> +struct ovs_list;
> +
> +#ifdef __cplusplus
> +extern "C" {
> +#endif
> +
> +/* Queue configuration reply. */
> +struct ofputil_queue_config {
> +    ofp_port_t port;
> +    uint32_t queue;
> +
> +    /* Each of these optional values is expressed in tenths of a percent.
> +     * Values greater than 1000 indicate that the feature is disabled.
> +     * UINT16_MAX indicates that the value is omitted. */
> +    uint16_t min_rate;
> +    uint16_t max_rate;
> +};
> +
> +void ofputil_start_queue_get_config_reply(const struct ofp_header
> *request,
> +                                          struct ovs_list *replies);
> +void ofputil_append_queue_get_config_reply(
> +    const struct ofputil_queue_config *, struct ovs_list *replies);
> +
> +int ofputil_pull_queue_get_config_reply(struct ofpbuf *reply,
> +                                        struct ofputil_queue_config *);
> +
> +struct ofputil_queue_stats_request {
> +    ofp_port_t port_no;           /* OFPP_ANY means "all ports". */
> +    uint32_t queue_id;
> +};
> +
> +enum ofperr ofputil_decode_queue_stats_request(
> +    const struct ofp_header *, struct ofputil_queue_stats_request *);
> +struct ofpbuf *ofputil_encode_queue_stats_request(
> +    enum ofp_version, const struct ofputil_queue_stats_request *);
> +
> +struct ofputil_queue_stats {
> +    ofp_port_t port_no;
> +    uint32_t queue_id;
> +
> +    /* Values of unsupported statistics are set to all-1-bits
> (UINT64_MAX). */
> +    uint64_t tx_bytes;
> +    uint64_t tx_packets;
> +    uint64_t tx_errors;
> +
> +    /* UINT32_MAX if unknown. */
> +    uint32_t duration_sec;
> +    uint32_t duration_nsec;
> +};
> +
> +size_t ofputil_count_queue_stats(const struct ofp_header *);
> +int ofputil_decode_queue_stats(struct ofputil_queue_stats *, struct
> ofpbuf *);
> +void ofputil_append_queue_stat(struct ovs_list *replies,
> +                               const struct ofputil_queue_stats *);
> +
> +/* Queue configuration request. */
> +struct ofpbuf *ofputil_encode_queue_get_config_request(enum ofp_version,
> +                                                       ofp_port_t port,
> +                                                       uint32_t queue);
> +enum ofperr ofputil_decode_queue_get_config_request(const struct
> ofp_header *,
> +                                                    ofp_port_t *port,
> +                                                    uint32_t *queue);
> +
> +#ifdef __cplusplus
> +}
> +#endif
> +
> +#endif  /* ofp-queue.h */
> diff --git a/include/openvswitch/ofp-switch.h b/include/openvswitch/ofp-
> switch.h
> new file mode 100644
> index 000000000000..737cd61e707f
> --- /dev/null
> +++ b/include/openvswitch/ofp-switch.h
> @@ -0,0 +1,115 @@
> +/*
> + * Copyright (c) 2008-2017 Nicira, Inc.
> + *
> + * Licensed under the Apache License, Version 2.0 (the "License");
> + * you may not use this file except in compliance with the License.
> + * You may obtain a copy of the License at:
> + *
> + *     http://www.apache.org/licenses/LICENSE-2.0
> + *
> + * Unless required by applicable law or agreed to in writing, software
> + * distributed under the License is distributed on an "AS IS" BASIS,
> + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
> implied.
> + * See the License for the specific language governing permissions and
> + * limitations under the License.
> + */
> +
> +#ifndef OPENVSWITCH_OFP_SWITCH_H
> +#define OPENVSWITCH_OFP_SWITCH_H 1
> +
> +#include "openflow/openflow.h"
> +#include "openvswitch/ofp-protocol.h"
> +
> +struct ofpbuf;
> +struct ofputil_phy_port;
> +
> +#ifdef __cplusplus
> +extern "C" {
> +#endif
> +
> +enum ofputil_capabilities {
> +    /* All OpenFlow versions share these capability values. */
> +    OFPUTIL_C_FLOW_STATS     = 1 << 0,  /* Flow statistics. */
> +    OFPUTIL_C_TABLE_STATS    = 1 << 1,  /* Table statistics. */
> +    OFPUTIL_C_PORT_STATS     = 1 << 2,  /* Port statistics. */
> +    OFPUTIL_C_IP_REASM       = 1 << 5,  /* Can reassemble IP fragments. */
> +    OFPUTIL_C_QUEUE_STATS    = 1 << 6,  /* Queue statistics. */
> +
> +    /* OpenFlow 1.0 and 1.1 share this capability. */
> +    OFPUTIL_C_ARP_MATCH_IP   = 1 << 7,  /* Match IP addresses in ARP
> pkts. */
> +
> +    /* OpenFlow 1.0 only. */
> +    OFPUTIL_C_STP            = 1 << 3,  /* 802.1d spanning tree. */
> +
> +    /* OpenFlow 1.1+ only.  Note that this bit value does not match the
> one
> +     * in the OpenFlow message. */
> +    OFPUTIL_C_GROUP_STATS    = 1 << 4,  /* Group statistics. */
> +
> +    /* OpenFlow 1.2+ only. */
> +    OFPUTIL_C_PORT_BLOCKED   = 1 << 8,  /* Switch will block looping
> ports */
> +
> +    /* OpenFlow 1.4+ only. */
> +    OFPUTIL_C_BUNDLES         = 1 << 9,  /* Switch supports bundles. */
> +    OFPUTIL_C_FLOW_MONITORING = 1 << 10, /* Switch supports flow
> monitoring. */
> +};
> +
> +/* Abstract ofp_switch_features. */
> +struct ofputil_switch_features {
> +    uint64_t datapath_id;       /* Datapath unique ID. */
> +    uint32_t n_buffers;         /* Max packets buffered at once. */
> +    uint8_t n_tables;           /* Number of tables supported by
> datapath. */
> +    uint8_t auxiliary_id;       /* Identify auxiliary connections */
> +    enum ofputil_capabilities capabilities;
> +    uint64_t ofpacts;           /* Bitmap of OFPACT_* bits. */
> +};
> +
> +enum ofperr ofputil_pull_switch_features(struct ofpbuf *,
> +                                         struct ofputil_switch_features
> *);
> +
> +struct ofpbuf *ofputil_encode_switch_features(
> +    const struct ofputil_switch_features *, enum ofputil_protocol,
> +    ovs_be32 xid);
> +void ofputil_put_switch_features_port(const struct ofputil_phy_port *,
> +                                      struct ofpbuf *);
> +bool ofputil_switch_features_has_ports(struct ofpbuf *b);
> +
> +enum ofputil_frag_handling {
> +    OFPUTIL_FRAG_NORMAL = OFPC_FRAG_NORMAL,    /* No special handling. */
> +    OFPUTIL_FRAG_DROP = OFPC_FRAG_DROP,        /* Drop fragments. */
> +    OFPUTIL_FRAG_REASM = OFPC_FRAG_REASM,      /* Reassemble (if
> supported). */
> +    OFPUTIL_FRAG_NX_MATCH = OFPC_FRAG_NX_MATCH /* Match on frag bits. */
> +};
> +
> +const char *ofputil_frag_handling_to_string(enum ofputil_frag_handling);
> +bool ofputil_frag_handling_from_string(const char *,
> +                                       enum ofputil_frag_handling *);
> +
> +/* Abstract struct ofp_switch_config. */
> +struct ofputil_switch_config {
> +    /* Fragment handling. */
> +    enum ofputil_frag_handling frag;
> +
> +    /* 0: Do not send packet to controller when decrementing invalid IP
> TTL.
> +     * 1: Do send packet to controller when decrementing invalid IP TTL.
> +     * -1: Unspecified (only OpenFlow 1.1 and 1.2 support this setting. */
> +    int invalid_ttl_to_controller;
> +
> +    /* Maximum bytes of packet to send to controller on miss. */
> +    uint16_t miss_send_len;
> +};
> +
> +void ofputil_decode_get_config_reply(const struct ofp_header *,
> +                                     struct ofputil_switch_config *);
> +struct ofpbuf *ofputil_encode_get_config_reply(
> +    const struct ofp_header *request, const struct ofputil_switch_config
> *);
> +
> +enum ofperr ofputil_decode_set_config(const struct ofp_header *,
> +                                      struct ofputil_switch_config *);
> +struct ofpbuf *ofputil_encode_set_config(
> +    const struct ofputil_switch_config *, enum ofp_version);
> +
> +#ifdef __cplusplus
> +}
> +#endif
> +
> +#endif  /* ofp-switch.h */
> diff --git a/include/openvswitch/ofp-table.h b/include/openvswitch/ofp-
> table.h
> new file mode 100644
> index 000000000000..47b0fae80763
> --- /dev/null
> +++ b/include/openvswitch/ofp-table.h
> @@ -0,0 +1,302 @@
> +/*
> + * Copyright (c) 2008-2017 Nicira, Inc.
> + *
> + * Licensed under the Apache License, Version 2.0 (the "License");
> + * you may not use this file except in compliance with the License.
> + * You may obtain a copy of the License at:
> + *
> + *     http://www.apache.org/licenses/LICENSE-2.0
> + *
> + * Unless required by applicable law or agreed to in writing, software
> + * distributed under the License is distributed on an "AS IS" BASIS,
> + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
> implied.
> + * See the License for the specific language governing permissions and
> + * limitations under the License.
> + */
> +
> +#ifndef OPENVSWITCH_OFP_TABLE_H
> +#define OPENVSWITCH_OFP_TABLE_H 1
> +
> +#include <limits.h>
> +#include "openflow/openflow.h"
> +#include "openvswitch/meta-flow.h"
> +#include "openvswitch/ofp-port.h"
> +
> +#ifdef __cplusplus
> +extern "C" {
> +#endif
> +
> +/* Abstract version of OFPTC11_TABLE_MISS_*.
> + *
> + * OpenFlow 1.0 always sends packets that miss to the next flow table, or
> to
> + * the controller if they miss in the last flow table.
> + *
> + * OpenFlow 1.1 and 1.2 can configure table miss behavior via a
> "table-mod"
> + * that specifies "send to controller", "miss", or "drop".
> + *
> + * OpenFlow 1.3 and later never sends packets that miss to the controller.
> + */
> +enum ofputil_table_miss {
> +    /* Protocol-specific default behavior.  On OpenFlow 1.0 through 1.2
> +     * connections, the packet is sent to the controller, and on OpenFlow
> 1.3
> +     * and later connections, the packet is dropped.
> +     *
> +     * This is also used as a result of decoding OpenFlow 1.3+ "config"
> values
> +     * in table-mods, to indicate that no table-miss was specified. */
> +    OFPUTIL_TABLE_MISS_DEFAULT,    /* Protocol default behavior. */
> +
> +    /* These constants have the same meanings as those in OpenFlow with
> the
> +     * same names. */
> +    OFPUTIL_TABLE_MISS_CONTROLLER, /* Send to controller. */
> +    OFPUTIL_TABLE_MISS_CONTINUE,   /* Go to next table. */
> +    OFPUTIL_TABLE_MISS_DROP,       /* Drop the packet. */
> +};
> +
> +/* Abstract version of OFPTC14_EVICTION.
> + *
> + * OpenFlow 1.0 through 1.3 don't know anything about eviction, so
> decoding a
> + * message for one of these protocols always yields
> + * OFPUTIL_TABLE_EVICTION_DEFAULT. */
> +enum ofputil_table_eviction {
> +    OFPUTIL_TABLE_EVICTION_DEFAULT, /* No value. */
> +    OFPUTIL_TABLE_EVICTION_ON,      /* Enable eviction. */
> +    OFPUTIL_TABLE_EVICTION_OFF      /* Disable eviction. */
> +};
> +
> +/* Abstract version of OFPTC14_VACANCY_EVENTS.
> + *
> + * OpenFlow 1.0 through 1.3 don't know anything about vacancy events, so
> + * decoding a message for one of these protocols always yields
> + * OFPUTIL_TABLE_VACANCY_DEFAULT. */
> +enum ofputil_table_vacancy {
> +    OFPUTIL_TABLE_VACANCY_DEFAULT, /* No value. */
> +    OFPUTIL_TABLE_VACANCY_ON,      /* Enable vacancy events. */
> +    OFPUTIL_TABLE_VACANCY_OFF      /* Disable vacancy events. */
> +};
> +
> +/* Abstract version of OFPTMPT_VACANCY.
> + *
> + * Openflow 1.4+ defines vacancy events.
> + * The fields vacancy_down and vacancy_up are the threshold for generating
> + * vacancy events that should be configured on the flow table, expressed
> as
> + * a percent.
> + * The vacancy field is only used when this property in included in a
> + * OFPMP_TABLE_DESC multipart reply or a OFPT_TABLE_STATUS message and
> + * represent the current vacancy of the table, expressed as a percent. In
> + * OFP_TABLE_MOD requests, this field must be set to 0 */
> +struct ofputil_table_mod_prop_vacancy {
> +    uint8_t vacancy_down;    /* Vacancy threshold when space decreases
> (%). */
> +    uint8_t vacancy_up;      /* Vacancy threshold when space increases
> (%). */
> +    uint8_t vacancy;         /* Current vacancy (%). */
> +};
> +
> +/* Mapping between table numbers and names. */
> +struct ofputil_table_map {
> +    struct namemap map;
> +};
> +#define OFPUTIL_TABLE_MAP_INITIALIZER(MAP) {
> NAMEMAP_INITIALIZER((MAP).map) }
> +
> +void ofputil_table_map_init(struct ofputil_table_map *);
> +const char *ofputil_table_map_get_name(const struct ofputil_table_map *,
> +                                       uint8_t);
> +uint8_t ofputil_table_map_get_number(const struct ofputil_table_map *,
> +                                     const char *name);
> +void ofputil_table_map_put(struct ofputil_table_map *,
> +                           uint8_t, const char *name);
> +void ofputil_table_map_destroy(struct ofputil_table_map *);
> +
> +/* Table numbers. */
> +bool ofputil_table_from_string(const char *, const struct
> ofputil_table_map *,
> +                               uint8_t *tablep);
> +void ofputil_format_table(uint8_t table, const struct ofputil_table_map *,
> +                         struct ds *);
> +void ofputil_table_to_string(uint8_t, const struct ofputil_table_map *,
> +                            char *namebuf, size_t bufsize);
> +
> +/* Abstract ofp_table_mod. */
> +struct ofputil_table_mod {
> +    uint8_t table_id;         /* ID of the table, 0xff indicates all
> tables. */
> +
> +    /* OpenFlow 1.1 and 1.2 only.  For other versions, ignored on
> encoding,
> +     * decoded to OFPUTIL_TABLE_MISS_DEFAULT. */
> +    enum ofputil_table_miss miss;
> +
> +    /* OpenFlow 1.4+ only.  For other versions, ignored on encoding,
> decoded to
> +     * OFPUTIL_TABLE_EVICTION_DEFAULT. */
> +    enum ofputil_table_eviction eviction;
> +
> +    /* OpenFlow 1.4+ only and optional even there; UINT32_MAX indicates
> +     * absence.  For other versions, ignored on encoding, decoded to
> +     * UINT32_MAX.*/
> +    uint32_t eviction_flags;    /* OFPTMPEF14_*. */
> +
> +    /* OpenFlow 1.4+ only. For other versions, ignored on encoding,
> decoded to
> +     * OFPUTIL_TABLE_VACANCY_DEFAULT. */
> +    enum ofputil_table_vacancy vacancy;
> +
> +    /* Openflow 1.4+ only. Defines threshold values of vacancy expressed
> as
> +     * percent, value of current vacancy is set to zero for table-mod.
> +     * For other versions, ignored on encoding, all values decoded to
> +     * zero. */
> +    struct ofputil_table_mod_prop_vacancy table_vacancy;
> +};
> +
> +/* Abstract ofp14_table_desc. */
> +struct ofputil_table_desc {
> +    uint8_t table_id;         /* ID of the table. */
> +    enum ofputil_table_eviction eviction;
> +    uint32_t eviction_flags;    /* UINT32_MAX if not present. */
> +    enum ofputil_table_vacancy vacancy;
> +    struct ofputil_table_mod_prop_vacancy table_vacancy;
> +};
> +
> +enum ofperr ofputil_decode_table_mod(const struct ofp_header *,
> +                                    struct ofputil_table_mod *);
> +struct ofpbuf *ofputil_encode_table_mod(const struct ofputil_table_mod *,
> +                                       enum ofputil_protocol);
> +char *parse_ofp_table_mod(struct ofputil_table_mod *,
> +                          const char *table_id, const char
> *flow_miss_handling,
> +                          const struct ofputil_table_map *,
> +                          uint32_t *usable_versions)
> +    OVS_WARN_UNUSED_RESULT;
> +
> +/* Abstract ofp_table_features.
> + *
> + * This is used for all versions of OpenFlow, even though
> ofp_table_features
> + * was only introduced in OpenFlow 1.3, because earlier versions of
> OpenFlow
> + * include support for a subset of ofp_table_features through OFPST_TABLE
> (aka
> + * OFPMP_TABLE). */
> +struct ofputil_table_features {
> +    uint8_t table_id;         /* Identifier of table. Lower numbered
> tables
> +                                 are consulted first. */
> +    char name[OFP_MAX_TABLE_NAME_LEN];
> +    ovs_be64 metadata_match;  /* Bits of metadata table can match. */
> +    ovs_be64 metadata_write;  /* Bits of metadata table can write. */
> +    uint32_t max_entries;     /* Max number of entries supported. */
> +
> +    /* Flags.
> +     *
> +     * 'miss_config' is relevant for OpenFlow 1.1 and 1.2 only, because
> those
> +     * versions include OFPTC_MISS_* flags in OFPST_TABLE.  For other
> versions,
> +     * it is decoded to OFPUTIL_TABLE_MISS_DEFAULT and ignored for
> encoding.
> +     *
> +     * 'supports_eviction' and 'supports_vacancy_events' are relevant
> only for
> +     * OpenFlow 1.4 and later only.  For OF1.4, they are boolean: 1 if
> +     * supported, otherwise 0.  For other versions, they are decoded as
> -1 and
> +     * ignored for encoding.
> +     *
> +     * Search for "OFPTC_* Table Configuration" in the documentation for
> more
> +     * details of how OpenFlow has changed in this area.
> +     */
> +    enum ofputil_table_miss miss_config; /* OF1.1 and 1.2 only. */
> +    int supports_eviction;               /* OF1.4+ only. */
> +    int supports_vacancy_events;         /* OF1.4+ only. */
> +
> +    /* Table features related to instructions.  There are two instances:
> +     *
> +     *   - 'miss' reports features available in the table miss flow.
> +     *
> +     *   - 'nonmiss' reports features available in other flows. */
> +    struct ofputil_table_instruction_features {
> +        /* Tables that "goto-table" may jump to. */
> +        unsigned long int next[BITMAP_N_LONGS(255)];
> +
> +        /* Bitmap of OVSINST_* for supported instructions. */
> +        uint32_t instructions;
> +
> +        /* Table features related to actions.  There are two instances:
> +         *
> +         *    - 'write' reports features available in a "write_actions"
> +         *      instruction.
> +         *
> +         *    - 'apply' reports features available in an "apply_actions"
> +         *      instruction. */
> +        struct ofputil_table_action_features {
> +            uint64_t ofpacts;     /* Bitmap of supported OFPACT_*. */
> +            struct mf_bitmap set_fields; /* Fields for "set-field". */
> +        } write, apply;
> +    } nonmiss, miss;
> +
> +    /* MFF_* bitmaps.
> +     *
> +     * For any given field the following combinations are valid:
> +     *
> +     *    - match=0, wildcard=0, mask=0: Flows in this table cannot match
> on
> +     *      this field.
> +     *
> +     *    - match=1, wildcard=0, mask=0: Flows in this table must match
> on all
> +     *      the bits in this field.
> +     *
> +     *    - match=1, wildcard=1, mask=0: Flows in this table must either
> match
> +     *      on all the bits in the field or wildcard the field entirely.
> +     *
> +     *    - match=1, wildcard=1, mask=1: Flows in this table may
> arbitrarily
> +     *      mask this field (as special cases, they may match on all the
> bits
> +     *      or wildcard it entirely).
> +     *
> +     * Other combinations do not make sense.
> +     */
> +    struct mf_bitmap match;     /* Fields that may be matched. */
> +    struct mf_bitmap mask;      /* Subset of 'match' that may have masks.
> */
> +    struct mf_bitmap wildcard;  /* Subset of 'match' that may be
> wildcarded. */
> +};
> +
> +int ofputil_decode_table_features(struct ofpbuf *,
> +                                  struct ofputil_table_features *, bool
> loose);
> +
> +int ofputil_decode_table_desc(struct ofpbuf *,
> +                              struct ofputil_table_desc *,
> +                              enum ofp_version);
> +
> +struct ofpbuf *ofputil_encode_table_features_request(enum ofp_version);
> +
> +struct ofpbuf *ofputil_encode_table_desc_request(enum ofp_version);
> +
> +void ofputil_append_table_features_reply(
> +    const struct ofputil_table_features *tf, struct ovs_list *replies);
> +
> +void ofputil_append_table_desc_reply(const struct ofputil_table_desc *td,
> +                                     struct ovs_list *replies,
> +                                     enum ofp_version);
> +
> +/* Abstract table stats.
> + *
> + * This corresponds to the OpenFlow 1.3 table statistics structure, which
> only
> + * includes actual statistics.  In earlier versions of OpenFlow, several
> + * members describe table features, so this structure has to be paired
> with
> + * struct ofputil_table_features to get all information. */
> +struct ofputil_table_stats {
> +    uint8_t table_id;           /* Identifier of table. */
> +    uint32_t active_count;      /* Number of active entries. */
> +    uint64_t lookup_count;      /* Number of packets looked up in table.
> */
> +    uint64_t matched_count;     /* Number of packets that hit table. */
> +};
> +
> +struct ofpbuf *ofputil_encode_table_stats_reply(const struct ofp_header
> *rq);
> +
> +struct ofpbuf *ofputil_encode_table_desc_reply(const struct ofp_header
> *rq);
> +
> +void ofputil_append_table_stats_reply(struct ofpbuf *reply,
> +                                      const struct ofputil_table_stats *,
> +                                      const struct ofputil_table_features
> *);
> +
> +int ofputil_decode_table_stats_reply(struct ofpbuf *reply,
> +                                     struct ofputil_table_stats *,
> +                                     struct ofputil_table_features *);
> +
> +/* Abstract ofp14_table_status. */
> +struct ofputil_table_status {
> +    enum ofp14_table_reason reason;     /* One of OFPTR_*. */
> +    struct ofputil_table_desc desc;   /* New table config. */
> +};
> +
> +enum ofperr ofputil_decode_table_status(const struct ofp_header *,
> +                                        struct ofputil_table_status *);
> +struct ofpbuf *ofputil_encode_table_status(const struct
> ofputil_table_status *,
> +                                           enum ofputil_protocol);
> +
> +#ifdef __cplusplus
> +}
> +#endif
> +
> +#endif  /* ofp-table.h */
> diff --git a/include/openvswitch/ofp-util.h b/include/openvswitch/ofp-
> util.h
> index 876ca6ed280a..f45877ba2c7a 100644
> --- a/include/openvswitch/ofp-util.h
> +++ b/include/openvswitch/ofp-util.h
> @@ -18,1512 +18,23 @@
>  #define OPENVSWITCH_OFP_UTIL_H 1
>
>  #include <stdbool.h>
> -#include <stddef.h>
>  #include <stdint.h>
> -#include "openvswitch/flow.h"
> -#include "openvswitch/hmap.h"
> -#include "openvswitch/list.h"
> -#include "openvswitch/match.h"
> -#include "openvswitch/meta-flow.h"
> -#include "openvswitch/netdev.h"
> -#include "openflow/netronome-ext.h"
> -#include "openflow/nicira-ext.h"
> -#include "openvswitch/ofp-msgs.h"
> -#include "openvswitch/ofpbuf.h"
> -#include "openvswitch/types.h"
> -#include "openvswitch/type-props.h"
> -#include "openvswitch/uuid.h"
> +#include "openvswitch/ofp-protocol.h"
> +
> +struct ofp_header;
>
>  #ifdef __cplusplus
>  extern "C" {
>  #endif
>
> -struct ofpbuf;
> -struct ofpact_set_field;
> -struct vl_mff_map;
> -
> -/* Name-number mapping.
> - *
> - * This is not exported directly but only through specializations for port
> - * name-number and table name-number mappings. */
> -struct ofputil_name_map {
> -    struct hmap by_name;
> -    struct hmap by_number;
> -};
> -#define OFPUTIL_NAME_MAP_INITIALIZER(MAP)  \
> -    { HMAP_INITIALIZER(&(MAP)->by_name), HMAP_INITIALIZER(&(MAP)->by_number)
> }
> -
> -/* Mapping between port numbers and names. */
> -struct ofputil_port_map {
> -    struct ofputil_name_map map;
> -};
> -#define OFPUTIL_PORT_MAP_INITIALIZER(MAP) \
> -    { OFPUTIL_NAME_MAP_INITIALIZER(&(MAP)->map) }
> -
> -void ofputil_port_map_init(struct ofputil_port_map *);
> -const char *ofputil_port_map_get_name(const struct ofputil_port_map *,
> -                                      ofp_port_t);
> -ofp_port_t ofputil_port_map_get_number(const struct ofputil_port_map *,
> -                                      const char *name);
> -void ofputil_port_map_put(struct ofputil_port_map *,
> -                          ofp_port_t, const char *name);
> -void ofputil_port_map_destroy(struct ofputil_port_map *);
> -
> -/* Port numbers. */
> -enum ofperr ofputil_port_from_ofp11(ovs_be32 ofp11_port,
> -                                    ofp_port_t *ofp10_port);
> -ovs_be32 ofputil_port_to_ofp11(ofp_port_t ofp10_port);
> -
> -bool ofputil_port_from_string(const char *, const struct ofputil_port_map
> *,
> -                              ofp_port_t *portp);
> -const char *ofputil_port_get_reserved_name(ofp_port_t);
> -void ofputil_format_port(ofp_port_t port, const struct ofputil_port_map *,
> -                         struct ds *);
> -void ofputil_port_to_string(ofp_port_t, const struct ofputil_port_map *,
> -                            char *namebuf, size_t bufsize);
> -
> -/* Group numbers. */
> -enum { MAX_GROUP_NAME_LEN = INT_STRLEN(uint32_t) };
> -bool ofputil_group_from_string(const char *, uint32_t *group_id);
> -void ofputil_format_group(uint32_t group_id, struct ds *);
> -void ofputil_group_to_string(uint32_t group_id,
> -                             char namebuf[MAX_GROUP_NAME_LEN + 1],
> -                             size_t bufsize);
> -
> -/* Converting OFPFW10_NW_SRC_MASK and OFPFW10_NW_DST_MASK wildcard bit
> counts
> - * to and from IP bitmasks. */
> -ovs_be32 ofputil_wcbits_to_netmask(int wcbits);
> -int ofputil_netmask_to_wcbits(ovs_be32 netmask);
> -
> -/* Protocols.
> - *
> - * A "protocol" is an OpenFlow version plus, for some OpenFlow versions,
> - * a bit extra about the flow match format in use.
> - *
> - * These are arranged from most portable to least portable, or
> alternatively
> - * from least powerful to most powerful.  Protocols earlier on the list
> are
> - * more likely to be understood for the purpose of making requests, but
> - * protocol later on the list are more likely to accurately describe a
> flow
> - * within a switch.
> - *
> - * On any given OpenFlow connection, a single protocol is in effect at any
> - * given time.  These values use separate bits only because that makes it
> easy
> - * to test whether a particular protocol is within a given set of
> protocols and
> - * to implement set union and intersection.
> - */
> -enum ofputil_protocol {
> -    /* OpenFlow 1.0 protocols.
> -     *
> -     * The "STD" protocols use the standard OpenFlow 1.0 flow format.
> -     * The "NXM" protocols use the Nicira Extensible Match (NXM) flow
> format.
> -     *
> -     * The protocols with "TID" mean that the nx_flow_mod_table_id Nicira
> -     * extension has been enabled.  The other protocols have it disabled.
> -     */
> -#define OFPUTIL_P_NONE 0
> -    OFPUTIL_P_OF10_STD     = 1 << 0,
> -    OFPUTIL_P_OF10_STD_TID = 1 << 1,
> -    OFPUTIL_P_OF10_NXM     = 1 << 2,
> -    OFPUTIL_P_OF10_NXM_TID = 1 << 3,
> -#define OFPUTIL_P_OF10_STD_ANY (OFPUTIL_P_OF10_STD |
> OFPUTIL_P_OF10_STD_TID)
> -#define OFPUTIL_P_OF10_NXM_ANY (OFPUTIL_P_OF10_NXM |
> OFPUTIL_P_OF10_NXM_TID)
> -#define OFPUTIL_P_OF10_ANY (OFPUTIL_P_OF10_STD_ANY |
> OFPUTIL_P_OF10_NXM_ANY)
> -
> -    /* OpenFlow 1.1 protocol.
> -     *
> -     * We only support the standard OpenFlow 1.1 flow format.
> -     *
> -     * OpenFlow 1.1 always operates with an equivalent of the
> -     * nx_flow_mod_table_id Nicira extension enabled, so there is no "TID"
> -     * variant. */
> -    OFPUTIL_P_OF11_STD     = 1 << 4,
> -
> -    /* OpenFlow 1.2+ protocols (only one variant each).
> -     *
> -     * These use the standard OpenFlow Extensible Match (OXM) flow format.
> -     *
> -     * OpenFlow 1.2+ always operates with an equivalent of the
> -     * nx_flow_mod_table_id Nicira extension enabled, so there is no "TID"
> -     * variant. */
> -    OFPUTIL_P_OF12_OXM      = 1 << 5,
> -    OFPUTIL_P_OF13_OXM      = 1 << 6,
> -    OFPUTIL_P_OF14_OXM      = 1 << 7,
> -    OFPUTIL_P_OF15_OXM      = 1 << 8,
> -    OFPUTIL_P_OF16_OXM      = 1 << 9,
> -#define OFPUTIL_P_ANY_OXM (OFPUTIL_P_OF12_OXM | \
> -                           OFPUTIL_P_OF13_OXM | \
> -                           OFPUTIL_P_OF14_OXM | \
> -                           OFPUTIL_P_OF15_OXM | \
> -                           OFPUTIL_P_OF16_OXM)
> -
> -#define OFPUTIL_P_NXM_OF11_UP (OFPUTIL_P_OF10_NXM_ANY |
> OFPUTIL_P_OF11_STD | \
> -                               OFPUTIL_P_ANY_OXM)
> -
> -#define OFPUTIL_P_NXM_OXM_ANY (OFPUTIL_P_OF10_NXM_ANY | OFPUTIL_P_ANY_OXM)
> -
> -#define OFPUTIL_P_OF11_UP (OFPUTIL_P_OF11_STD | OFPUTIL_P_ANY_OXM)
> -
> -#define OFPUTIL_P_OF12_UP (OFPUTIL_P_OF12_OXM | OFPUTIL_P_OF13_UP)
> -#define OFPUTIL_P_OF13_UP (OFPUTIL_P_OF13_OXM | OFPUTIL_P_OF14_UP)
> -#define OFPUTIL_P_OF14_UP (OFPUTIL_P_OF14_OXM | OFPUTIL_P_OF15_UP)
> -#define OFPUTIL_P_OF15_UP (OFPUTIL_P_OF15_OXM | OFPUTIL_P_OF16_UP)
> -#define OFPUTIL_P_OF16_UP OFPUTIL_P_OF16_OXM
> -
> -    /* All protocols. */
> -#define OFPUTIL_P_ANY ((1 << 10) - 1)
> -
> -    /* Protocols in which a specific table may be specified in flow_mods.
> */
> -#define OFPUTIL_P_TID (OFPUTIL_P_OF10_STD_TID | \
> -                       OFPUTIL_P_OF10_NXM_TID | \
> -                       OFPUTIL_P_OF11_STD |     \
> -                       OFPUTIL_P_ANY_OXM)
> -};
> -
> -/* Protocols to use for flow dumps, from most to least preferred. */
> -extern enum ofputil_protocol ofputil_flow_dump_protocols[];
> -extern size_t ofputil_n_flow_dump_protocols;
> -
> -enum ofputil_protocol ofputil_protocol_from_ofp_version(enum
> ofp_version);
> -enum ofputil_protocol ofputil_protocols_from_ofp_version(enum
> ofp_version);
> -enum ofp_version ofputil_protocol_to_ofp_version(enum ofputil_protocol);
> -
> -bool ofputil_protocol_is_valid(enum ofputil_protocol);
> -enum ofputil_protocol ofputil_protocol_set_tid(enum ofputil_protocol,
> -                                               bool enable);
> -enum ofputil_protocol ofputil_protocol_to_base(enum ofputil_protocol);
> -enum ofputil_protocol ofputil_protocol_set_base(
> -    enum ofputil_protocol cur, enum ofputil_protocol new_base);
> -
> -const char *ofputil_protocol_to_string(enum ofputil_protocol);
> -char *ofputil_protocols_to_string(enum ofputil_protocol);
> -enum ofputil_protocol ofputil_protocols_from_string(const char *);
> -
> -void ofputil_format_version(struct ds *, enum ofp_version);
> -void ofputil_format_version_name(struct ds *, enum ofp_version);
> -
> -/* A bitmap of version numbers
> - *
> - * Bit offsets correspond to ofp_version numbers which in turn correspond
> to
> - * wire-protocol numbers for OpenFlow versions, e.g. (1u << OFP11_VERSION)
> - * is the mask for OpenFlow 1.1.  If the bit for a version is set then it
> is
> - * allowed, otherwise it is disallowed. */
> -
> -void ofputil_format_version_bitmap(struct ds *msg, uint32_t bitmap);
> -void ofputil_format_version_bitmap_names(struct ds *msg, uint32_t
> bitmap);
> -
> -enum ofp_version ofputil_version_from_string(const char *s);
> -
> -uint32_t ofputil_protocols_to_version_bitmap(enum ofputil_protocol);
> -enum ofputil_protocol ofputil_protocols_from_version_bitmap(uint32_t
> bitmap);
> -
> -/* Bitmaps of OpenFlow versions that Open vSwitch supports, and that it
> enables
> - * by default.  When Open vSwitch has experimental or incomplete support
> for
> - * newer versions of OpenFlow, those versions should not be supported by
> - * default and thus should be omitted from the latter bitmap. */
> -#define OFPUTIL_SUPPORTED_VERSIONS ((1u << OFP10_VERSION) | \
> -                                    (1u << OFP11_VERSION) | \
> -                                    (1u << OFP12_VERSION) | \
> -                                    (1u << OFP13_VERSION) | \
> -                                    (1u << OFP14_VERSION))
> -#define OFPUTIL_DEFAULT_VERSIONS OFPUTIL_SUPPORTED_VERSIONS
> -
> -enum ofputil_protocol ofputil_protocols_from_string(const char *s);
> -
> -const char *ofputil_version_to_string(enum ofp_version ofp_version);
> -uint32_t ofputil_versions_from_string(const char *s);
> -uint32_t ofputil_versions_from_strings(char ** const s, size_t count);
> -
>  bool ofputil_decode_hello(const struct ofp_header *,
>                            uint32_t *allowed_versions);
>  struct ofpbuf *ofputil_encode_hello(uint32_t version_bitmap);
>
> -struct ofpbuf *ofputil_encode_set_protocol(enum ofputil_protocol current,
> -                                           enum ofputil_protocol want,
> -                                           enum ofputil_protocol *next);
> -
> -/* nx_flow_format */
> -struct ofpbuf *ofputil_encode_nx_set_flow_format(enum nx_flow_format);
> -enum ofputil_protocol ofputil_nx_flow_format_to_protocol(enum
> nx_flow_format);
> -bool ofputil_nx_flow_format_is_valid(enum nx_flow_format);
> -const char *ofputil_nx_flow_format_to_string(enum nx_flow_format);
> -
> -/* Work with ofp10_match. */
> -void ofputil_wildcard_from_ofpfw10(uint32_t ofpfw, struct flow_wildcards
> *);
> -void ofputil_match_from_ofp10_match(const struct ofp10_match *,
> -                                    struct match *);
> -void ofputil_normalize_match(struct match *);
> -void ofputil_normalize_match_quiet(struct match *);
> -void ofputil_match_to_ofp10_match(const struct match *, struct
> ofp10_match *);
> -
> -/* Work with ofp11_match. */
> -enum ofperr ofputil_pull_ofp11_match(struct ofpbuf *, const struct
> tun_table *,
> -                                     const struct vl_mff_map *, struct
> match *,
> -                                     uint16_t *padded_match_len);
> -enum ofperr ofputil_match_from_ofp11_match(const struct ofp11_match *,
> -                                           struct match *);
> -int ofputil_put_ofp11_match(struct ofpbuf *, const struct match *,
> -                            enum ofputil_protocol);
> -void ofputil_match_to_ofp11_match(const struct match *, struct
> ofp11_match *);
> -int ofputil_match_typical_len(enum ofputil_protocol);
> -
> -/* dl_type translation between OpenFlow and 'struct flow' format. */
> -ovs_be16 ofputil_dl_type_to_openflow(ovs_be16 flow_dl_type);
> -ovs_be16 ofputil_dl_type_from_openflow(ovs_be16 ofp_dl_type);
> -
> -/* PACKET_IN. */
> -bool ofputil_packet_in_format_is_valid(enum nx_packet_in_format);
> -int ofputil_packet_in_format_from_string(const char *);
> -const char *ofputil_packet_in_format_to_string(enum nx_packet_in_format);
> -struct ofpbuf *ofputil_make_set_packet_in_format(enum ofp_version,
> -                                                 enum
> nx_packet_in_format);
> -
> -/* NXT_FLOW_MOD_TABLE_ID extension. */
> -struct ofpbuf *ofputil_make_flow_mod_table_id(bool flow_mod_table_id);
> -
> -/* Protocol-independent flow_mod flags. */
> -enum ofputil_flow_mod_flags {
> -    /* Flags that are maintained with a flow as part of its state.
> -     *
> -     * (OFPUTIL_FF_EMERG would be here too, if OVS supported it.) */
> -    OFPUTIL_FF_SEND_FLOW_REM = 1 << 0, /* All versions. */
> -    OFPUTIL_FF_NO_PKT_COUNTS = 1 << 1, /* OpenFlow 1.3+. */
> -    OFPUTIL_FF_NO_BYT_COUNTS = 1 << 2, /* OpenFlow 1.3+. */
> -
> -    /* These flags primarily affects flow_mod behavior.  They are not
> -     * particularly useful as part of flow state.  We include them in flow
> -     * state only because OpenFlow implies that they should be. */
> -    OFPUTIL_FF_CHECK_OVERLAP = 1 << 3, /* All versions. */
> -    OFPUTIL_FF_RESET_COUNTS  = 1 << 4, /* OpenFlow 1.2+. */
> -
> -    /* Not supported by OVS. */
> -    OFPUTIL_FF_EMERG         = 1 << 5, /* OpenFlow 1.0 only. */
> -
> -    /* The set of flags maintained as part of a flow table entry. */
> -#define OFPUTIL_FF_STATE (OFPUTIL_FF_SEND_FLOW_REM      \
> -                          | OFPUTIL_FF_NO_PKT_COUNTS    \
> -                          | OFPUTIL_FF_NO_BYT_COUNTS    \
> -                          | OFPUTIL_FF_CHECK_OVERLAP    \
> -                          | OFPUTIL_FF_RESET_COUNTS)
> -
> -    /* Flags that are only set by OVS for its internal use.  Cannot be
> set via
> -     * OpenFlow. */
> -    OFPUTIL_FF_HIDDEN_FIELDS = 1 << 6, /* Allow hidden match fields to be
> -                                          set or modified. */
> -    OFPUTIL_FF_NO_READONLY   = 1 << 7, /* Allow rules within read only
> tables
> -                                          to be modified */
> -};
> -
> -/* Protocol-independent flow_mod.
> - *
> - * The handling of cookies across multiple versions of OpenFlow is a bit
> - * confusing.  See the topics/design doc for the details. */
> -struct ofputil_flow_mod {
> -    struct ovs_list list_node; /* For queuing flow_mods. */
> -
> -    struct match match;
> -    int priority;
> -
> -    /* Cookie matching.  The flow_mod affects only flows that have
> cookies that
> -     * bitwise match 'cookie' bits in positions where 'cookie_mask has
> 1-bits.
> -     *
> -     * 'cookie_mask' should be zero for OFPFC_ADD flow_mods. */
> -    ovs_be64 cookie;         /* Cookie bits to match. */
> -    ovs_be64 cookie_mask;    /* 1-bit in each 'cookie' bit to match. */
> -
> -    /* Cookie changes.
> -     *
> -     * OFPFC_ADD uses 'new_cookie' as the new flow's cookie.  'new_cookie'
> -     * should not be UINT64_MAX.
> -     *
> -     * OFPFC_MODIFY and OFPFC_MODIFY_STRICT have two cases:
> -     *
> -     *   - If one or more matching flows exist and 'modify_cookie' is
> true,
> -     *     then the flow_mod changes the existing flows' cookies to
> -     *     'new_cookie'.  'new_cookie' should not be UINT64_MAX.
> -     *
> -     *   - If no matching flow exists, 'new_cookie' is not UINT64_MAX, and
> -     *     'cookie_mask' is 0, then the flow_mod adds a new flow with
> -     *     'new_cookie' as its cookie.
> -     */
> -    ovs_be64 new_cookie;     /* New cookie to install or UINT64_MAX. */
> -    bool modify_cookie;      /* Set cookie of existing flow to
> 'new_cookie'? */
> -
> -    uint8_t table_id;
> -    uint16_t command;
> -    uint16_t idle_timeout;
> -    uint16_t hard_timeout;
> -    uint32_t buffer_id;
> -    ofp_port_t out_port;
> -    uint32_t out_group;
> -    enum ofputil_flow_mod_flags flags;
> -    uint16_t importance;     /* Eviction precedence. */
> -    struct ofpact *ofpacts;  /* Series of "struct ofpact"s. */
> -    size_t ofpacts_len;      /* Length of ofpacts, in bytes. */
> -    uint64_t ofpacts_tlv_bitmap; /* 1-bit for each present TLV in
> 'ofpacts'. */
> -};
> -
> -enum ofperr ofputil_decode_flow_mod(struct ofputil_flow_mod *,
> -                                    const struct ofp_header *,
> -                                    enum ofputil_protocol,
> -                                    const struct tun_table *,
> -                                    const struct vl_mff_map *,
> -                                    struct ofpbuf *ofpacts,
> -                                    ofp_port_t max_port,
> -                                    uint8_t max_table);
> -struct ofpbuf *ofputil_encode_flow_mod(const struct ofputil_flow_mod *,
> -                                       enum ofputil_protocol);
> -
> -/* Flow stats or aggregate stats request, independent of protocol. */
> -struct ofputil_flow_stats_request {
> -    bool aggregate;             /* Aggregate results? */
> -    struct match match;
> -    ovs_be64 cookie;
> -    ovs_be64 cookie_mask;
> -    ofp_port_t out_port;
> -    uint32_t out_group;
> -    uint8_t table_id;
> -};
> -
> -enum ofperr ofputil_decode_flow_stats_request(
> -    struct ofputil_flow_stats_request *, const struct ofp_header *,
> -    const struct tun_table *, const struct vl_mff_map *);
> -struct ofpbuf *ofputil_encode_flow_stats_request(
> -    const struct ofputil_flow_stats_request *, enum ofputil_protocol);
> -
> -/* Flow stats reply, independent of protocol. */
> -struct ofputil_flow_stats {
> -    struct match match;
> -    ovs_be64 cookie;
> -    uint8_t table_id;
> -    uint16_t priority;
> -    uint16_t idle_timeout;
> -    uint16_t hard_timeout;
> -    uint32_t duration_sec;
> -    uint32_t duration_nsec;
> -    int idle_age;               /* Seconds since last packet, -1 if
> unknown. */
> -    int hard_age;               /* Seconds since last change, -1 if
> unknown. */
> -    uint64_t packet_count;      /* Packet count, UINT64_MAX if unknown. */
> -    uint64_t byte_count;        /* Byte count, UINT64_MAX if unknown. */
> -    const struct ofpact *ofpacts;
> -    size_t ofpacts_len;
> -    enum ofputil_flow_mod_flags flags;
> -    uint16_t importance;        /* Eviction precedence. */
> -};
> -
> -int ofputil_decode_flow_stats_reply(struct ofputil_flow_stats *,
> -                                    struct ofpbuf *msg,
> -                                    bool flow_age_extension,
> -                                    struct ofpbuf *ofpacts);
> -void ofputil_append_flow_stats_reply(const struct ofputil_flow_stats *,
> -                                     struct ovs_list *replies,
> -                                     const struct tun_table *);
> -
> -/* Aggregate stats reply, independent of protocol. */
> -struct ofputil_aggregate_stats {
> -    uint64_t packet_count;      /* Packet count, UINT64_MAX if unknown. */
> -    uint64_t byte_count;        /* Byte count, UINT64_MAX if unknown. */
> -    uint32_t flow_count;
> -};
> -
> -struct ofpbuf *ofputil_encode_aggregate_stats_reply(
> -    const struct ofputil_aggregate_stats *stats,
> -    const struct ofp_header *request);
> -enum ofperr ofputil_decode_aggregate_stats_reply(
> -    struct ofputil_aggregate_stats *,
> -    const struct ofp_header *reply);
> -
> -/* Flow removed message, independent of protocol. */
> -struct ofputil_flow_removed {
> -    struct match match;
> -    ovs_be64 cookie;
> -    uint16_t priority;
> -    uint8_t reason;             /* One of OFPRR_*. */
> -    uint8_t table_id;           /* 255 if message didn't include table
> ID. */
> -    uint32_t duration_sec;
> -    uint32_t duration_nsec;
> -    uint16_t idle_timeout;
> -    uint16_t hard_timeout;
> -    uint64_t packet_count;      /* Packet count, UINT64_MAX if unknown. */
> -    uint64_t byte_count;        /* Byte count, UINT64_MAX if unknown. */
> -};
> -
> -enum ofperr ofputil_decode_flow_removed(struct ofputil_flow_removed *,
> -                                        const struct ofp_header *);
> -struct ofpbuf *ofputil_encode_flow_removed(const struct
> ofputil_flow_removed *,
> -                                           enum ofputil_protocol);
> -
> -/* Abstract packet-in message.
> - *
> - * This omits the 'total_len' and 'buffer_id' fields, which we handle
> - * differently for encoding and decoding.*/
> -struct ofputil_packet_in {
> -    /* Packet data and metadata.
> -     *
> -     * On encoding, the full packet should be supplied, but depending on
> its
> -     * other parameters ofputil_encode_packet_in() might send only the
> first
> -     * part of the packet.
> -     *
> -     * On decoding, the 'len' bytes in 'packet' might only be the first
> part of
> -     * the original packet.  ofputil_decode_packet_in() reports the full
> -     * original length of the packet using its 'total_len' output
> parameter. */
> -    void *packet;               /* The packet. */
> -    size_t packet_len;          /* Length of 'packet' in bytes. */
> -
> -    /* Input port and other metadata for packet. */
> -    struct match flow_metadata;
> -
> -    /* Reason that the packet-in is being sent. */
> -    enum ofp_packet_in_reason reason;    /* One of OFPR_*. */
> -
> -    /* Information about the OpenFlow flow that triggered the packet-in.
> -     *
> -     * A packet-in triggered by a flow table miss has no associated
> flow.  In
> -     * that case, 'cookie' is UINT64_MAX. */
> -    uint8_t table_id;                    /* OpenFlow table ID. */
> -    ovs_be64 cookie;                     /* Flow's cookie. */
> -
> -    /* Arbitrary user-provided data. */
> -    uint8_t *userdata;
> -    size_t userdata_len;
> -};
> -
> -void ofputil_packet_in_destroy(struct ofputil_packet_in *);
> -
> -enum ofperr ofputil_decode_packet_in(const struct ofp_header *, bool
> loose,
> -                                     const struct tun_table *,
> -                                     const struct vl_mff_map *,
> -                                     struct ofputil_packet_in *,
> -                                     size_t *total_len, uint32_t
> *buffer_id,
> -                                     struct ofpbuf *continuation);
> -
> -struct ofpbuf *ofputil_encode_resume(const struct ofputil_packet_in *pin,
> -                                     const struct ofpbuf *continuation,
> -                                     enum ofputil_protocol);
> -
> -enum { OFPUTIL_PACKET_IN_REASON_BUFSIZE = INT_STRLEN(int) + 1 };
> -const char *ofputil_packet_in_reason_to_string(enum ofp_packet_in_reason,
> -                                               char *reasonbuf,
> -                                               size_t bufsize);
> -bool ofputil_packet_in_reason_from_string(const char *,
> -                                          enum ofp_packet_in_reason *);
> -
> -/* A packet-in message, including continuation data.  The format of
> - * continuation data is subject to change and thus it is supposed to be
> opaque
> - * to any process other than ovs-vswitchd.  Therefore, only ovs-vswitchd
> should
> - * use ofputil_packet_in_private and the functions that operate on it. */
> -struct ofputil_packet_in_private {
> -    struct ofputil_packet_in base;
> -
> -    /* NXCPT_BRIDGE. */
> -    struct uuid bridge;
> -
> -    /* NXCPT_STACK. */
> -    uint8_t *stack;
> -    size_t stack_size;
> -
> -    /* NXCPT_MIRRORS. */
> -    uint32_t mirrors;
> -
> -    /* NXCPT_CONNTRACKED. */
> -    bool conntracked;
> -
> -    /* NXCPT_ACTIONS. */
> -    struct ofpact *actions;
> -    size_t actions_len;
> -
> -    /* NXCPT_ACTION_SET. */
> -    struct ofpact *action_set;
> -    size_t action_set_len;
> -};
> -
> -struct ofpbuf *ofputil_encode_packet_in_private(
> -    const struct ofputil_packet_in_private *,
> -    enum ofputil_protocol protocol,
> -    enum nx_packet_in_format);
> -
> -enum ofperr ofputil_decode_packet_in_private(
> -    const struct ofp_header *, bool loose,
> -    const struct tun_table *,
> -    const struct vl_mff_map *,
> -    struct ofputil_packet_in_private *,
> -    size_t *total_len, uint32_t *buffer_id);
> -
> -void ofputil_packet_in_private_destroy(struct ofputil_packet_in_private
> *);
> -
> -/* Abstract packet-out message.
> - *
> - * ofputil_decode_packet_out() will ensure that 'in_port' is a physical
> port
> - * (OFPP_MAX or less) or one of OFPP_LOCAL, OFPP_NONE, or
> OFPP_CONTROLLER. */
> -struct ofputil_packet_out {
> -    const void *packet;         /* Packet data, if buffer_id ==
> UINT32_MAX. */
> -    size_t packet_len;          /* Length of packet data in bytes. */
> -    uint32_t buffer_id;         /* Buffer id or UINT32_MAX if no buffer.
> */
> -    struct match flow_metadata; /* Packet's input port and other
> metadata. */
> -    struct ofpact *ofpacts;     /* Actions. */
> -    size_t ofpacts_len;         /* Size of ofpacts in bytes. */
> -};
> -
> -enum ofperr ofputil_decode_packet_out(struct ofputil_packet_out *,
> -                                      const struct ofp_header *,
> -                                      const struct tun_table *,
> -                                      struct ofpbuf *ofpacts);
> -struct ofpbuf *ofputil_encode_packet_out(const struct ofputil_packet_out
> *,
> -                                         enum ofputil_protocol protocol);
> -
> -enum ofputil_frag_handling {
> -    OFPUTIL_FRAG_NORMAL = OFPC_FRAG_NORMAL,    /* No special handling. */
> -    OFPUTIL_FRAG_DROP = OFPC_FRAG_DROP,        /* Drop fragments. */
> -    OFPUTIL_FRAG_REASM = OFPC_FRAG_REASM,      /* Reassemble (if
> supported). */
> -    OFPUTIL_FRAG_NX_MATCH = OFPC_FRAG_NX_MATCH /* Match on frag bits. */
> -};
> -
> -const char *ofputil_frag_handling_to_string(enum ofputil_frag_handling);
> -bool ofputil_frag_handling_from_string(const char *,
> -                                       enum ofputil_frag_handling *);
> -
> -/* Abstract struct ofp_switch_config. */
> -struct ofputil_switch_config {
> -    /* Fragment handling. */
> -    enum ofputil_frag_handling frag;
> -
> -    /* 0: Do not send packet to controller when decrementing invalid IP
> TTL.
> -     * 1: Do send packet to controller when decrementing invalid IP TTL.
> -     * -1: Unspecified (only OpenFlow 1.1 and 1.2 support this setting. */
> -    int invalid_ttl_to_controller;
> -
> -    /* Maximum bytes of packet to send to controller on miss. */
> -    uint16_t miss_send_len;
> -};
> -
> -void ofputil_decode_get_config_reply(const struct ofp_header *,
> -                                     struct ofputil_switch_config *);
> -struct ofpbuf *ofputil_encode_get_config_reply(
> -    const struct ofp_header *request, const struct ofputil_switch_config
> *);
> -
> -enum ofperr ofputil_decode_set_config(const struct ofp_header *,
> -                                      struct ofputil_switch_config *);
> -struct ofpbuf *ofputil_encode_set_config(
> -    const struct ofputil_switch_config *, enum ofp_version);
> -
> -enum ofputil_port_config {
> -    /* OpenFlow 1.0 and 1.1 share these values for these port config
> bits. */
> -    OFPUTIL_PC_PORT_DOWN    = 1 << 0, /* Port is administratively down. */
> -    OFPUTIL_PC_NO_RECV      = 1 << 2, /* Drop all packets received by
> port. */
> -    OFPUTIL_PC_NO_FWD       = 1 << 5, /* Drop packets forwarded to port.
> */
> -    OFPUTIL_PC_NO_PACKET_IN = 1 << 6, /* No send packet-in msgs for port.
> */
> -    /* OpenFlow 1.0 only. */
> -    OFPUTIL_PC_NO_STP       = 1 << 1, /* No 802.1D spanning tree for
> port. */
> -    OFPUTIL_PC_NO_RECV_STP  = 1 << 3, /* Drop received 802.1D STP
> packets. */
> -    OFPUTIL_PC_NO_FLOOD     = 1 << 4, /* Do not include port when
> flooding. */
> -    /* There are no OpenFlow 1.1-only bits. */
> -};
> -
> -enum ofputil_port_state {
> -    /* OpenFlow 1.0 and 1.1 share this values for these port state bits.
> */
> -    OFPUTIL_PS_LINK_DOWN   = 1 << 0, /* No physical link present. */
> -    /* OpenFlow 1.1 only. */
> -    OFPUTIL_PS_BLOCKED     = 1 << 1, /* Port is blocked */
> -    OFPUTIL_PS_LIVE        = 1 << 2, /* Live for Fast Failover Group. */
> -    /* OpenFlow 1.0 only. */
> -    OFPUTIL_PS_STP_LISTEN  = 0 << 8, /* Not learning or relaying frames.
> */
> -    OFPUTIL_PS_STP_LEARN   = 1 << 8, /* Learning but not relaying frames.
> */
> -    OFPUTIL_PS_STP_FORWARD = 2 << 8, /* Learning and relaying frames. */
> -    OFPUTIL_PS_STP_BLOCK   = 3 << 8, /* Not part of spanning tree. */
> -    OFPUTIL_PS_STP_MASK    = 3 << 8  /* Bit mask for OFPPS10_STP_*
> values. */
> -};
> -
> -/* Abstract ofp10_phy_port, ofp11_port, ofp14_port, or ofp16_port. */
> -struct ofputil_phy_port {
> -    ofp_port_t port_no;
> -
> -    /* Hardware addresses.
> -     *
> -     * Most hardware has a normal 48-bit Ethernet address, in hw_addr.
> -     * Some hardware might have a 64-bit address in hw_addr64.
> -     * All-bits-0 indicates that a given address is not present. */
> -    struct eth_addr hw_addr;
> -    struct eth_addr64 hw_addr64;
> -
> -    char name[OFP16_MAX_PORT_NAME_LEN]; /* 64 bytes in OF1.6+, 16
> otherwise. */
> -    enum ofputil_port_config config;
> -    enum ofputil_port_state state;
> -
> -    /* NETDEV_F_* feature bitmasks. */
> -    enum netdev_features curr;       /* Current features. */
> -    enum netdev_features advertised; /* Features advertised by the port.
> */
> -    enum netdev_features supported;  /* Features supported by the port. */
> -    enum netdev_features peer;       /* Features advertised by peer. */
> -
> -    /* Speed. */
> -    uint32_t curr_speed;        /* Current speed, in kbps. */
> -    uint32_t max_speed;         /* Maximum supported speed, in kbps. */
> -};
> -
> -enum ofputil_capabilities {
> -    /* All OpenFlow versions share these capability values. */
> -    OFPUTIL_C_FLOW_STATS     = 1 << 0,  /* Flow statistics. */
> -    OFPUTIL_C_TABLE_STATS    = 1 << 1,  /* Table statistics. */
> -    OFPUTIL_C_PORT_STATS     = 1 << 2,  /* Port statistics. */
> -    OFPUTIL_C_IP_REASM       = 1 << 5,  /* Can reassemble IP fragments. */
> -    OFPUTIL_C_QUEUE_STATS    = 1 << 6,  /* Queue statistics. */
> -
> -    /* OpenFlow 1.0 and 1.1 share this capability. */
> -    OFPUTIL_C_ARP_MATCH_IP   = 1 << 7,  /* Match IP addresses in ARP
> pkts. */
> -
> -    /* OpenFlow 1.0 only. */
> -    OFPUTIL_C_STP            = 1 << 3,  /* 802.1d spanning tree. */
> -
> -    /* OpenFlow 1.1+ only.  Note that this bit value does not match the
> one
> -     * in the OpenFlow message. */
> -    OFPUTIL_C_GROUP_STATS    = 1 << 4,  /* Group statistics. */
> -
> -    /* OpenFlow 1.2+ only. */
> -    OFPUTIL_C_PORT_BLOCKED   = 1 << 8,  /* Switch will block looping
> ports */
> -
> -    /* OpenFlow 1.4+ only. */
> -    OFPUTIL_C_BUNDLES         = 1 << 9,  /* Switch supports bundles. */
> -    OFPUTIL_C_FLOW_MONITORING = 1 << 10, /* Switch supports flow
> monitoring. */
> -};
> -
> -/* Abstract ofp_switch_features. */
> -struct ofputil_switch_features {
> -    uint64_t datapath_id;       /* Datapath unique ID. */
> -    uint32_t n_buffers;         /* Max packets buffered at once. */
> -    uint8_t n_tables;           /* Number of tables supported by
> datapath. */
> -    uint8_t auxiliary_id;       /* Identify auxiliary connections */
> -    enum ofputil_capabilities capabilities;
> -    uint64_t ofpacts;           /* Bitmap of OFPACT_* bits. */
> -};
> -
> -enum ofperr ofputil_pull_switch_features(struct ofpbuf *,
> -                                         struct ofputil_switch_features
> *);
> -
> -struct ofpbuf *ofputil_encode_switch_features(
> -    const struct ofputil_switch_features *, enum ofputil_protocol,
> -    ovs_be32 xid);
> -void ofputil_put_switch_features_port(const struct ofputil_phy_port *,
> -                                      struct ofpbuf *);
> -bool ofputil_switch_features_has_ports(struct ofpbuf *b);
> -
> -/* phy_port helper functions. */
> -int ofputil_pull_phy_port(enum ofp_version ofp_version, struct ofpbuf *,
> -                          struct ofputil_phy_port *);
> -
> -/* Abstract ofp_port_status. */
> -struct ofputil_port_status {
> -    enum ofp_port_reason reason;
> -    struct ofputil_phy_port desc;
> -};
> -
> -enum ofperr ofputil_decode_port_status(const struct ofp_header *,
> -                                       struct ofputil_port_status *);
> -struct ofpbuf *ofputil_encode_port_status(const struct
> ofputil_port_status *,
> -                                          enum ofputil_protocol);
> -
> -/* Abstract ofp_port_mod. */
> -struct ofputil_port_mod {
> -    ofp_port_t port_no;
> -    struct eth_addr hw_addr;
> -    struct eth_addr64 hw_addr64;
> -    enum ofputil_port_config config;
> -    enum ofputil_port_config mask;
> -    enum netdev_features advertise;
> -};
> -
> -enum ofperr ofputil_decode_port_mod(const struct ofp_header *,
> -                                    struct ofputil_port_mod *, bool
> loose);
> -struct ofpbuf *ofputil_encode_port_mod(const struct ofputil_port_mod *,
> -                                       enum ofputil_protocol);
> -
> -/* Abstract version of OFPTC11_TABLE_MISS_*.
> - *
> - * OpenFlow 1.0 always sends packets that miss to the next flow table, or
> to
> - * the controller if they miss in the last flow table.
> - *
> - * OpenFlow 1.1 and 1.2 can configure table miss behavior via a
> "table-mod"
> - * that specifies "send to controller", "miss", or "drop".
> - *
> - * OpenFlow 1.3 and later never sends packets that miss to the controller.
> - */
> -enum ofputil_table_miss {
> -    /* Protocol-specific default behavior.  On OpenFlow 1.0 through 1.2
> -     * connections, the packet is sent to the controller, and on OpenFlow
> 1.3
> -     * and later connections, the packet is dropped.
> -     *
> -     * This is also used as a result of decoding OpenFlow 1.3+ "config"
> values
> -     * in table-mods, to indicate that no table-miss was specified. */
> -    OFPUTIL_TABLE_MISS_DEFAULT,    /* Protocol default behavior. */
> -
> -    /* These constants have the same meanings as those in OpenFlow with
> the
> -     * same names. */
> -    OFPUTIL_TABLE_MISS_CONTROLLER, /* Send to controller. */
> -    OFPUTIL_TABLE_MISS_CONTINUE,   /* Go to next table. */
> -    OFPUTIL_TABLE_MISS_DROP,       /* Drop the packet. */
> -};
> -
> -/* Abstract version of OFPTC14_EVICTION.
> - *
> - * OpenFlow 1.0 through 1.3 don't know anything about eviction, so
> decoding a
> - * message for one of these protocols always yields
> - * OFPUTIL_TABLE_EVICTION_DEFAULT. */
> -enum ofputil_table_eviction {
> -    OFPUTIL_TABLE_EVICTION_DEFAULT, /* No value. */
> -    OFPUTIL_TABLE_EVICTION_ON,      /* Enable eviction. */
> -    OFPUTIL_TABLE_EVICTION_OFF      /* Disable eviction. */
> -};
> -
> -/* Abstract version of OFPTC14_VACANCY_EVENTS.
> - *
> - * OpenFlow 1.0 through 1.3 don't know anything about vacancy events, so
> - * decoding a message for one of these protocols always yields
> - * OFPUTIL_TABLE_VACANCY_DEFAULT. */
> -enum ofputil_table_vacancy {
> -    OFPUTIL_TABLE_VACANCY_DEFAULT, /* No value. */
> -    OFPUTIL_TABLE_VACANCY_ON,      /* Enable vacancy events. */
> -    OFPUTIL_TABLE_VACANCY_OFF      /* Disable vacancy events. */
> -};
> -
> -/* Abstract version of OFPTMPT_VACANCY.
> - *
> - * Openflow 1.4+ defines vacancy events.
> - * The fields vacancy_down and vacancy_up are the threshold for generating
> - * vacancy events that should be configured on the flow table, expressed
> as
> - * a percent.
> - * The vacancy field is only used when this property in included in a
> - * OFPMP_TABLE_DESC multipart reply or a OFPT_TABLE_STATUS message and
> - * represent the current vacancy of the table, expressed as a percent. In
> - * OFP_TABLE_MOD requests, this field must be set to 0 */
> -struct ofputil_table_mod_prop_vacancy {
> -    uint8_t vacancy_down;    /* Vacancy threshold when space decreases
> (%). */
> -    uint8_t vacancy_up;      /* Vacancy threshold when space increases
> (%). */
> -    uint8_t vacancy;         /* Current vacancy (%). */
> -};
> -
> -/* Mapping between table numbers and names. */
> -struct ofputil_table_map {
> -    struct ofputil_name_map map;
> -};
> -#define OFPUTIL_TABLE_MAP_INITIALIZER(MAP) \
> -    { OFPUTIL_NAME_MAP_INITIALIZER((MAP).map) }
> -
> -void ofputil_table_map_init(struct ofputil_table_map *);
> -const char *ofputil_table_map_get_name(const struct ofputil_table_map *,
> -                                       uint8_t);
> -uint8_t ofputil_table_map_get_number(const struct ofputil_table_map *,
> -                                     const char *name);
> -void ofputil_table_map_put(struct ofputil_table_map *,
> -                           uint8_t, const char *name);
> -void ofputil_table_map_destroy(struct ofputil_table_map *);
> -
> -/* Table numbers. */
> -bool ofputil_table_from_string(const char *, const struct
> ofputil_table_map *,
> -                               uint8_t *tablep);
> -void ofputil_format_table(uint8_t table, const struct ofputil_table_map *,
> -                         struct ds *);
> -void ofputil_table_to_string(uint8_t, const struct ofputil_table_map *,
> -                            char *namebuf, size_t bufsize);
> -
> -/* Abstract ofp_table_mod. */
> -struct ofputil_table_mod {
> -    uint8_t table_id;         /* ID of the table, 0xff indicates all
> tables. */
> -
> -    /* OpenFlow 1.1 and 1.2 only.  For other versions, ignored on
> encoding,
> -     * decoded to OFPUTIL_TABLE_MISS_DEFAULT. */
> -    enum ofputil_table_miss miss;
> -
> -    /* OpenFlow 1.4+ only.  For other versions, ignored on encoding,
> decoded to
> -     * OFPUTIL_TABLE_EVICTION_DEFAULT. */
> -    enum ofputil_table_eviction eviction;
> -
> -    /* OpenFlow 1.4+ only and optional even there; UINT32_MAX indicates
> -     * absence.  For other versions, ignored on encoding, decoded to
> -     * UINT32_MAX.*/
> -    uint32_t eviction_flags;    /* OFPTMPEF14_*. */
> -
> -    /* OpenFlow 1.4+ only. For other versions, ignored on encoding,
> decoded to
> -     * OFPUTIL_TABLE_VACANCY_DEFAULT. */
> -    enum ofputil_table_vacancy vacancy;
> -
> -    /* Openflow 1.4+ only. Defines threshold values of vacancy expressed
> as
> -     * percent, value of current vacancy is set to zero for table-mod.
> -     * For other versions, ignored on encoding, all values decoded to
> -     * zero. */
> -    struct ofputil_table_mod_prop_vacancy table_vacancy;
> -};
> -
> -/* Abstract ofp14_table_desc. */
> -struct ofputil_table_desc {
> -    uint8_t table_id;         /* ID of the table. */
> -    enum ofputil_table_eviction eviction;
> -    uint32_t eviction_flags;    /* UINT32_MAX if not present. */
> -    enum ofputil_table_vacancy vacancy;
> -    struct ofputil_table_mod_prop_vacancy table_vacancy;
> -};
> -
> -enum ofperr ofputil_decode_table_mod(const struct ofp_header *,
> -                                    struct ofputil_table_mod *);
> -struct ofpbuf *ofputil_encode_table_mod(const struct ofputil_table_mod *,
> -                                       enum ofputil_protocol);
> -
> -/* Abstract ofp_table_features.
> - *
> - * This is used for all versions of OpenFlow, even though
> ofp_table_features
> - * was only introduced in OpenFlow 1.3, because earlier versions of
> OpenFlow
> - * include support for a subset of ofp_table_features through OFPST_TABLE
> (aka
> - * OFPMP_TABLE). */
> -struct ofputil_table_features {
> -    uint8_t table_id;         /* Identifier of table. Lower numbered
> tables
> -                                 are consulted first. */
> -    char name[OFP_MAX_TABLE_NAME_LEN];
> -    ovs_be64 metadata_match;  /* Bits of metadata table can match. */
> -    ovs_be64 metadata_write;  /* Bits of metadata table can write. */
> -    uint32_t max_entries;     /* Max number of entries supported. */
> -
> -    /* Flags.
> -     *
> -     * 'miss_config' is relevant for OpenFlow 1.1 and 1.2 only, because
> those
> -     * versions include OFPTC_MISS_* flags in OFPST_TABLE.  For other
> versions,
> -     * it is decoded to OFPUTIL_TABLE_MISS_DEFAULT and ignored for
> encoding.
> -     *
> -     * 'supports_eviction' and 'supports_vacancy_events' are relevant
> only for
> -     * OpenFlow 1.4 and later only.  For OF1.4, they are boolean: 1 if
> -     * supported, otherwise 0.  For other versions, they are decoded as
> -1 and
> -     * ignored for encoding.
> -     *
> -     * Search for "OFPTC_* Table Configuration" in the documentation for
> more
> -     * details of how OpenFlow has changed in this area.
> -     */
> -    enum ofputil_table_miss miss_config; /* OF1.1 and 1.2 only. */
> -    int supports_eviction;               /* OF1.4+ only. */
> -    int supports_vacancy_events;         /* OF1.4+ only. */
> -
> -    /* Table features related to instructions.  There are two instances:
> -     *
> -     *   - 'miss' reports features available in the table miss flow.
> -     *
> -     *   - 'nonmiss' reports features available in other flows. */
> -    struct ofputil_table_instruction_features {
> -        /* Tables that "goto-table" may jump to. */
> -        unsigned long int next[BITMAP_N_LONGS(255)];
> -
> -        /* Bitmap of OVSINST_* for supported instructions. */
> -        uint32_t instructions;
> -
> -        /* Table features related to actions.  There are two instances:
> -         *
> -         *    - 'write' reports features available in a "write_actions"
> -         *      instruction.
> -         *
> -         *    - 'apply' reports features available in an "apply_actions"
> -         *      instruction. */
> -        struct ofputil_table_action_features {
> -            uint64_t ofpacts;     /* Bitmap of supported OFPACT_*. */
> -            struct mf_bitmap set_fields; /* Fields for "set-field". */
> -        } write, apply;
> -    } nonmiss, miss;
> -
> -    /* MFF_* bitmaps.
> -     *
> -     * For any given field the following combinations are valid:
> -     *
> -     *    - match=0, wildcard=0, mask=0: Flows in this table cannot match
> on
> -     *      this field.
> -     *
> -     *    - match=1, wildcard=0, mask=0: Flows in this table must match
> on all
> -     *      the bits in this field.
> -     *
> -     *    - match=1, wildcard=1, mask=0: Flows in this table must either
> match
> -     *      on all the bits in the field or wildcard the field entirely.
> -     *
> -     *    - match=1, wildcard=1, mask=1: Flows in this table may
> arbitrarily
> -     *      mask this field (as special cases, they may match on all the
> bits
> -     *      or wildcard it entirely).
> -     *
> -     * Other combinations do not make sense.
> -     */
> -    struct mf_bitmap match;     /* Fields that may be matched. */
> -    struct mf_bitmap mask;      /* Subset of 'match' that may have masks.
> */
> -    struct mf_bitmap wildcard;  /* Subset of 'match' that may be
> wildcarded. */
> -};
> -
> -int ofputil_decode_table_features(struct ofpbuf *,
> -                                  struct ofputil_table_features *, bool
> loose);
> -
> -int ofputil_decode_table_desc(struct ofpbuf *,
> -                              struct ofputil_table_desc *,
> -                              enum ofp_version);
> -
> -struct ofpbuf *ofputil_encode_table_features_request(enum ofp_version);
> -
> -struct ofpbuf *ofputil_encode_table_desc_request(enum ofp_version);
> -
> -void ofputil_append_table_features_reply(
> -    const struct ofputil_table_features *tf, struct ovs_list *replies);
> -
> -void ofputil_append_table_desc_reply(const struct ofputil_table_desc *td,
> -                                     struct ovs_list *replies,
> -                                     enum ofp_version);
> -
> -/* Meter band configuration for all supported band types. */
> -struct ofputil_meter_band {
> -    uint16_t type;
> -    uint8_t prec_level;         /* Non-zero if type ==
> OFPMBT_DSCP_REMARK. */
> -    uint32_t rate;
> -    uint32_t burst_size;
> -};
> -
> -struct ofputil_meter_band_stats {
> -    uint64_t packet_count;
> -    uint64_t byte_count;
> -};
> -
> -struct ofputil_meter_config {
> -    uint32_t meter_id;
> -    uint16_t flags;
> -    uint16_t n_bands;
> -    struct ofputil_meter_band *bands;
> -};
> -
> -/* Abstract ofp_meter_mod. */
> -struct ofputil_meter_mod {
> -    uint16_t command;
> -    struct ofputil_meter_config meter;
> -};
> -
> -struct ofputil_meter_stats {
> -    uint32_t meter_id;
> -    uint32_t flow_count;
> -    uint64_t packet_in_count;
> -    uint64_t byte_in_count;
> -    uint32_t duration_sec;
> -    uint32_t duration_nsec;
> -    uint16_t n_bands;
> -    struct ofputil_meter_band_stats *bands;
> -};
> -
> -struct ofputil_meter_features {
> -    uint32_t max_meters;        /* Maximum number of meters. */
> -    uint32_t band_types;        /* Can support max 32 band types. */
> -    uint32_t capabilities;      /* Supported flags. */
> -    uint8_t  max_bands;
> -    uint8_t  max_color;
> -};
> -
> -enum ofperr ofputil_decode_meter_mod(const struct ofp_header *,
> -                                     struct ofputil_meter_mod *,
> -                                     struct ofpbuf *bands);
> -struct ofpbuf *ofputil_encode_meter_mod(enum ofp_version,
> -                                        const struct ofputil_meter_mod *);
> -
> -void ofputil_decode_meter_features(const struct ofp_header *,
> -                                   struct ofputil_meter_features *);
> -struct ofpbuf *ofputil_encode_meter_features_reply(const struct
> -                                                   ofputil_meter_features
> *,
> -                                                   const struct
> ofp_header *
> -                                                   request);
> -void ofputil_decode_meter_request(const struct ofp_header *,
> -                                  uint32_t *meter_id);
> -
> -void ofputil_append_meter_config(struct ovs_list *replies,
> -                                 const struct ofputil_meter_config *);
> -
> -void ofputil_append_meter_stats(struct ovs_list *replies,
> -                                const struct ofputil_meter_stats *);
> -
> -enum ofputil_meter_request_type {
> -    OFPUTIL_METER_FEATURES,
> -    OFPUTIL_METER_CONFIG,
> -    OFPUTIL_METER_STATS
> -};
> -
> -struct ofpbuf *ofputil_encode_meter_request(enum ofp_version,
> -                                            enum
> ofputil_meter_request_type,
> -                                            uint32_t meter_id);
> -
> -int ofputil_decode_meter_stats(struct ofpbuf *,
> -                               struct ofputil_meter_stats *,
> -                               struct ofpbuf *bands);
> -
> -int ofputil_decode_meter_config(struct ofpbuf *,
> -                                struct ofputil_meter_config *,
> -                                struct ofpbuf *bands);
> -
> -/* Type for meter_id in ofproto provider interface, UINT32_MAX if
> invalid. */
> -typedef struct { uint32_t uint32; } ofproto_meter_id;
> -
> -/* Abstract ofp_role_request and reply. */
> -struct ofputil_role_request {
> -    enum ofp12_controller_role role;
> -    bool have_generation_id;
> -    uint64_t generation_id;
> -};
> -
> -struct ofputil_role_status {
> -    enum ofp12_controller_role role;
> -    enum ofp14_controller_role_reason reason;
> -    uint64_t generation_id;
> -};
> -
> -enum ofperr ofputil_decode_role_message(const struct ofp_header *,
> -                                        struct ofputil_role_request *);
> -struct ofpbuf *ofputil_encode_role_reply(const struct ofp_header *,
> -                                         const struct
> ofputil_role_request *);
> -
> -struct ofpbuf *ofputil_encode_role_status(
> -                                const struct ofputil_role_status *status,
> -                                enum ofputil_protocol protocol);
> -
> -enum ofperr ofputil_decode_role_status(const struct ofp_header *oh,
> -                                       struct ofputil_role_status *rs);
> -
> -/* Abstract table stats.
> - *
> - * This corresponds to the OpenFlow 1.3 table statistics structure, which
> only
> - * includes actual statistics.  In earlier versions of OpenFlow, several
> - * members describe table features, so this structure has to be paired
> with
> - * struct ofputil_table_features to get all information. */
> -struct ofputil_table_stats {
> -    uint8_t table_id;           /* Identifier of table. */
> -    uint32_t active_count;      /* Number of active entries. */
> -    uint64_t lookup_count;      /* Number of packets looked up in table.
> */
> -    uint64_t matched_count;     /* Number of packets that hit table. */
> -};
> -
> -struct ofpbuf *ofputil_encode_table_stats_reply(const struct ofp_header
> *rq);
> -
> -struct ofpbuf *ofputil_encode_table_desc_reply(const struct ofp_header
> *rq);
> -
> -void ofputil_append_table_stats_reply(struct ofpbuf *reply,
> -                                      const struct ofputil_table_stats *,
> -                                      const struct ofputil_table_features
> *);
> -
> -int ofputil_decode_table_stats_reply(struct ofpbuf *reply,
> -                                     struct ofputil_table_stats *,
> -                                     struct ofputil_table_features *);
> -
> -/* Queue configuration request. */
> -struct ofpbuf *ofputil_encode_queue_get_config_request(enum ofp_version,
> -                                                       ofp_port_t port,
> -                                                       uint32_t queue);
> -enum ofperr ofputil_decode_queue_get_config_request(const struct
> ofp_header *,
> -                                                    ofp_port_t *port,
> -                                                    uint32_t *queue);
> -
> -/* Queue configuration reply. */
> -struct ofputil_queue_config {
> -    ofp_port_t port;
> -    uint32_t queue;
> -
> -    /* Each of these optional values is expressed in tenths of a percent.
> -     * Values greater than 1000 indicate that the feature is disabled.
> -     * UINT16_MAX indicates that the value is omitted. */
> -    uint16_t min_rate;
> -    uint16_t max_rate;
> -};
> -
> -void ofputil_start_queue_get_config_reply(const struct ofp_header
> *request,
> -                                          struct ovs_list *replies);
> -void ofputil_append_queue_get_config_reply(
> -    const struct ofputil_queue_config *, struct ovs_list *replies);
> -
> -int ofputil_pull_queue_get_config_reply(struct ofpbuf *reply,
> -                                        struct ofputil_queue_config *);
> -
> -
> -/* Abstract nx_flow_monitor_request. */
> -struct ofputil_flow_monitor_request {
> -    uint32_t id;
> -    enum nx_flow_monitor_flags flags;
> -    ofp_port_t out_port;
> -    uint8_t table_id;
> -    struct match match;
> -};
> -
> -int ofputil_decode_flow_monitor_request(struct
> ofputil_flow_monitor_request *,
> -                                        struct ofpbuf *msg);
> -void ofputil_append_flow_monitor_request(
> -    const struct ofputil_flow_monitor_request *, struct ofpbuf *msg);
> -
> -/* Abstract nx_flow_update. */
> -struct ofputil_flow_update {
> -    enum nx_flow_update_event event;
> -
> -    /* Used only for NXFME_ADDED, NXFME_DELETED, NXFME_MODIFIED. */
> -    enum ofp_flow_removed_reason reason;
> -    uint16_t idle_timeout;
> -    uint16_t hard_timeout;
> -    uint8_t table_id;
> -    uint16_t priority;
> -    ovs_be64 cookie;
> -    struct match match;
> -    const struct ofpact *ofpacts;
> -    size_t ofpacts_len;
> -
> -    /* Used only for NXFME_ABBREV. */
> -    ovs_be32 xid;
> -};
> -
> -int ofputil_decode_flow_update(struct ofputil_flow_update *,
> -                               struct ofpbuf *msg, struct ofpbuf
> *ofpacts);
> -void ofputil_start_flow_update(struct ovs_list *replies);
> -void ofputil_append_flow_update(const struct ofputil_flow_update *,
> -                                struct ovs_list *replies,
> -                                const struct tun_table *);
> -
> -/* Abstract nx_flow_monitor_cancel. */
> -uint32_t ofputil_decode_flow_monitor_cancel(const struct ofp_header *);
> -struct ofpbuf *ofputil_encode_flow_monitor_cancel(uint32_t id);
> -
> -/* Port desc stats requests and replies. */
> -enum ofperr ofputil_decode_port_desc_stats_request(const struct
> ofp_header *,
> -                                                   ofp_port_t *portp);
> -struct ofpbuf *ofputil_encode_port_desc_stats_request(
> -    enum ofp_version ofp_version, ofp_port_t);
> -
> -void ofputil_append_port_desc_stats_reply(const struct ofputil_phy_port
> *pp,
> -                                          struct ovs_list *replies);
> -
> -/* Encoding simple OpenFlow messages. */
>  struct ofpbuf *make_echo_request(enum ofp_version);
> -struct ofpbuf *make_echo_reply(const struct ofp_header *rq);
> +struct ofpbuf *make_echo_reply(const struct ofp_header *);
>
>  struct ofpbuf *ofputil_encode_barrier_request(enum ofp_version);
> -
> -/* Handy utility for parsing flows and actions. */
> -bool ofputil_parse_key_value(char **stringp, char **keyp, char **valuep);
> -
> -struct ofputil_port_stats {
> -    ofp_port_t port_no;
> -    struct netdev_stats stats;
> -    struct netdev_custom_stats custom_stats;
> -    uint32_t duration_sec;      /* UINT32_MAX if unknown. */
> -    uint32_t duration_nsec;
> -};
> -
> -struct ofpbuf *ofputil_encode_dump_ports_request(enum ofp_version
> ofp_version,
> -                                                 ofp_port_t port);
> -void ofputil_append_port_stat(struct ovs_list *replies,
> -                              const struct ofputil_port_stats *ops);
> -size_t ofputil_count_port_stats(const struct ofp_header *);
> -int ofputil_decode_port_stats(struct ofputil_port_stats *, struct ofpbuf
> *msg);
> -enum ofperr ofputil_decode_port_stats_request(const struct ofp_header
> *request,
> -                                              ofp_port_t *ofp10_port);
> -
> -struct ofputil_ipfix_stats {
> -    uint32_t collector_set_id;  /* Used only for flow-based IPFIX
> statistics. */
> -    uint64_t total_flows;  /* Totabl flows of this IPFIX exporter. */
> -    uint64_t current_flows;  /* Current flows of this IPFIX exporter. */
> -    uint64_t pkts;  /* Successfully sampled packets. */
> -    uint64_t ipv4_pkts;  /* Successfully sampled IPV4 packets. */
> -    uint64_t ipv6_pkts;  /* Successfully sampled IPV6 packets. */
> -    uint64_t error_pkts;  /* Error packets when sampling. */
> -    uint64_t ipv4_error_pkts;  /* Error IPV4 packets when sampling. */
> -    uint64_t ipv6_error_pkts;  /* Error IPV6 packets when sampling. */
> -    uint64_t tx_pkts;  /* TX IPFIX packets. */
> -    uint64_t tx_errors;  /* IPFIX packets TX errors. */
> -};
> -
> -void ofputil_append_ipfix_stat(struct ovs_list *replies,
> -                              const struct ofputil_ipfix_stats *ois);
> -size_t ofputil_count_ipfix_stats(const struct ofp_header *);
> -int ofputil_pull_ipfix_stats(struct ofputil_ipfix_stats *, struct ofpbuf
> *msg);
> -
> -struct ofputil_queue_stats_request {
> -    ofp_port_t port_no;           /* OFPP_ANY means "all ports". */
> -    uint32_t queue_id;
> -};
> -
> -enum ofperr
> -ofputil_decode_queue_stats_request(const struct ofp_header *request,
> -                                   struct ofputil_queue_stats_request
> *oqsr);
> -struct ofpbuf *
> -ofputil_encode_queue_stats_request(enum ofp_version ofp_version,
> -                                   const struct
> ofputil_queue_stats_request *oqsr);
> -
> -struct ofputil_queue_stats {
> -    ofp_port_t port_no;
> -    uint32_t queue_id;
> -
> -    /* Values of unsupported statistics are set to all-1-bits
> (UINT64_MAX). */
> -    uint64_t tx_bytes;
> -    uint64_t tx_packets;
> -    uint64_t tx_errors;
> -
> -    /* UINT32_MAX if unknown. */
> -    uint32_t duration_sec;
> -    uint32_t duration_nsec;
> -};
> -
> -size_t ofputil_count_queue_stats(const struct ofp_header *);
> -int ofputil_decode_queue_stats(struct ofputil_queue_stats *qs, struct
> ofpbuf *msg);
> -void ofputil_append_queue_stat(struct ovs_list *replies,
> -                               const struct ofputil_queue_stats *oqs);
> -
> -struct bucket_counter {
> -    uint64_t packet_count;   /* Number of packets processed by bucket. */
> -    uint64_t byte_count;     /* Number of bytes processed by bucket. */
> -};
> -
> -/* Bucket for use in groups. */
> -struct ofputil_bucket {
> -    struct ovs_list list_node;
> -    uint16_t weight;            /* Relative weight, for "select" groups.
> */
> -    ofp_port_t watch_port;      /* Port whose state affects whether this
> bucket
> -                                 * is live. Only required for fast
> failover
> -                                 * groups. */
> -    uint32_t watch_group;       /* Group whose state affects whether this
> -                                 * bucket is live. Only required for fast
> -                                 * failover groups. */
> -    uint32_t bucket_id;         /* Bucket Id used to identify bucket*/
> -    struct ofpact *ofpacts;     /* Series of "struct ofpact"s. */
> -    size_t ofpacts_len;         /* Length of ofpacts, in bytes. */
> -
> -    struct bucket_counter stats;
> -};
> -
> -/* Protocol-independent group_mod. */
> -struct ofputil_group_props {
> -    /* NTR selection method */
> -    char selection_method[NTR_MAX_SELECTION_METHOD_LEN];
> -    uint64_t selection_method_param;
> -    struct field_array fields;
> -};
> -
> -/* Protocol-independent group_mod. */
> -struct ofputil_group_mod {
> -    uint16_t command;             /* One of OFPGC15_*. */
> -    uint8_t type;                 /* One of OFPGT11_*. */
> -    uint32_t group_id;            /* Group identifier. */
> -    uint32_t command_bucket_id;   /* Bucket Id used as part of
> -                                   * OFPGC15_INSERT_BUCKET and
> -                                   * OFPGC15_REMOVE_BUCKET commands
> -                                   * execution.*/
> -    struct ovs_list buckets;      /* Contains "struct ofputil_bucket"s. */
> -    struct ofputil_group_props props; /* Group properties. */
> -};
> -
> -/* Group stats reply, independent of protocol. */
> -struct ofputil_group_stats {
> -    uint32_t group_id;    /* Group identifier. */
> -    uint32_t ref_count;
> -    uint64_t packet_count;      /* Packet count, UINT64_MAX if unknown. */
> -    uint64_t byte_count;        /* Byte count, UINT64_MAX if unknown. */
> -    uint32_t duration_sec;      /* UINT32_MAX if unknown. */
> -    uint32_t duration_nsec;
> -    uint32_t n_buckets;
> -    struct bucket_counter *bucket_stats;
> -};
> -
> -/* Group features reply, independent of protocol.
> - *
> - * Only OF1.2 and later support group features replies. */
> -struct ofputil_group_features {
> -    uint32_t  types;           /* Bitmap of OFPGT_* values supported. */
> -    uint32_t  capabilities;    /* Bitmap of OFPGFC12_* capability
> supported. */
> -    uint32_t  max_groups[4];   /* Maximum number of groups for each type.
> */
> -    uint64_t  ofpacts[4];      /* Bitmaps of supported OFPACT_* */
> -};
> -
> -/* Group desc reply, independent of protocol. */
> -struct ofputil_group_desc {
> -    uint8_t type;               /* One of OFPGT_*. */
> -    uint32_t group_id;          /* Group identifier. */
> -    struct ovs_list buckets;    /* Contains "struct ofputil_bucket"s. */
> -    struct ofputil_group_props props; /* Group properties. */
> -};
> -
> -void ofputil_group_properties_destroy(struct ofputil_group_props *);
> -void ofputil_group_properties_copy(struct ofputil_group_props *to,
> -                                   const struct ofputil_group_props
> *from);
> -void ofputil_bucket_list_destroy(struct ovs_list *buckets);
> -void ofputil_bucket_clone_list(struct ovs_list *dest,
> -                               const struct ovs_list *src,
> -                               const struct ofputil_bucket *);
> -struct ofputil_bucket *ofputil_bucket_find(const struct ovs_list *,
> -                                           uint32_t bucket_id);
> -bool ofputil_bucket_check_duplicate_id(const struct ovs_list *);
> -struct ofputil_bucket *ofputil_bucket_list_front(const struct ovs_list
> *);
> -struct ofputil_bucket *ofputil_bucket_list_back(const struct ovs_list *);
> -
> -static inline bool
> -ofputil_bucket_has_liveness(const struct ofputil_bucket *bucket)
> -{
> -    return (bucket->watch_port != OFPP_ANY ||
> -            bucket->watch_group != OFPG_ANY);
> -}
> -
> -struct ofpbuf *ofputil_encode_group_stats_request(enum ofp_version,
> -                                                  uint32_t group_id);
> -enum ofperr ofputil_decode_group_stats_request(
> -    const struct ofp_header *request, uint32_t *group_id);
> -void ofputil_append_group_stats(struct ovs_list *replies,
> -                                const struct ofputil_group_stats *);
> -struct ofpbuf *ofputil_encode_group_features_request(enum ofp_version);
> -struct ofpbuf *ofputil_encode_group_features_reply(
> -    const struct ofputil_group_features *, const struct ofp_header
> *request);
> -void ofputil_decode_group_features_reply(const struct ofp_header *,
> -                                         struct ofputil_group_features *);
> -void ofputil_uninit_group_mod(struct ofputil_group_mod *gm);
> -struct ofpbuf *ofputil_encode_group_mod(enum ofp_version ofp_version,
> -                                        const struct ofputil_group_mod
> *gm);
> -
> -enum ofperr ofputil_decode_group_mod(const struct ofp_header *,
> -                                     struct ofputil_group_mod *);
> -
> -int ofputil_decode_group_stats_reply(struct ofpbuf *,
> -                                     struct ofputil_group_stats *);
> -
> -void ofputil_uninit_group_desc(struct ofputil_group_desc *gd);
> -uint32_t ofputil_decode_group_desc_request(const struct ofp_header *);
> -struct ofpbuf *ofputil_encode_group_desc_request(enum ofp_version,
> -                                                 uint32_t group_id);
> -
> -int ofputil_decode_group_desc_reply(struct ofputil_group_desc *,
> -                                    struct ofpbuf *, enum ofp_version);
> -
> -void ofputil_append_group_desc_reply(const struct ofputil_group_desc *,
> -                                     const struct ovs_list *buckets,
> -                                     struct ovs_list *replies);
> -
> -struct ofputil_bundle_ctrl_msg {
> -    uint32_t    bundle_id;
> -    uint16_t    type;
> -    uint16_t    flags;
> -};
> -
> -struct ofputil_bundle_add_msg {
> -    uint32_t            bundle_id;
> -    uint16_t            flags;
> -    const struct ofp_header   *msg;
> -};
> -
> -enum ofperr ofputil_decode_bundle_ctrl(const struct ofp_header *,
> -                                       struct ofputil_bundle_ctrl_msg *);
> -
> -struct ofpbuf *ofputil_encode_bundle_ctrl_request(enum ofp_version,
> -                                                  struct
> ofputil_bundle_ctrl_msg *);
> -struct ofpbuf *ofputil_encode_bundle_ctrl_reply(const struct ofp_header
> *,
> -                                                struct
> ofputil_bundle_ctrl_msg *);
> -
> -struct ofpbuf *ofputil_encode_bundle_add(enum ofp_version ofp_version,
> -                                         struct ofputil_bundle_add_msg
> *msg);
> -
> -enum ofperr ofputil_decode_bundle_add(const struct ofp_header *,
> -                                      struct ofputil_bundle_add_msg *,
> -                                      enum ofptype *type);
> -
> -/* Bundle message as produced by ofp-parse. */
> -struct ofputil_bundle_msg {
> -    enum ofptype type;
> -    union {
> -        struct ofputil_flow_mod fm;
> -        struct ofputil_group_mod gm;
> -        struct ofputil_packet_out po;
> -    };
> -};
> -
> -void ofputil_encode_bundle_msgs(const struct ofputil_bundle_msg *bms,
> -                                size_t n_bms, struct ovs_list *requests,
> -                                enum ofputil_protocol);
> -void ofputil_free_bundle_msgs(struct ofputil_bundle_msg *bms, size_t
> n_bms);
> -
> -struct ofputil_tlv_map {
> -    struct ovs_list list_node;
> -
> -    uint16_t option_class;
> -    uint8_t  option_type;
> -    uint8_t  option_len;
> -    uint16_t index;
> -};
> -
> -struct ofputil_tlv_table_mod {
> -    uint16_t command;
> -    struct ovs_list mappings;      /* Contains "struct ofputil_tlv_map"s.
> */
> -};
> -
> -struct ofputil_tlv_table_reply {
> -    uint32_t max_option_space;
> -    uint16_t max_fields;
> -    struct ovs_list mappings;      /* Contains "struct ofputil_tlv_map"s.
> */
> -};
> -
> -struct ofpbuf *ofputil_encode_tlv_table_mod(enum ofp_version ofp_version,
> -                                               struct
> ofputil_tlv_table_mod *);
> -enum ofperr ofputil_decode_tlv_table_mod(const struct ofp_header *,
> -                                            struct ofputil_tlv_table_mod
> *);
> -struct ofpbuf *ofputil_encode_tlv_table_reply(const struct ofp_header *,
> -                                               struct
> ofputil_tlv_table_reply *);
> -enum ofperr ofputil_decode_tlv_table_reply(const struct ofp_header *,
> -                                              struct
> ofputil_tlv_table_reply *);
> -void ofputil_uninit_tlv_table(struct ovs_list *mappings);
> -
> -enum ofputil_async_msg_type {
> -    /* Standard asynchronous messages. */
> -    OAM_PACKET_IN,              /* OFPT_PACKET_IN or NXT_PACKET_IN. */
> -    OAM_PORT_STATUS,            /* OFPT_PORT_STATUS. */
> -    OAM_FLOW_REMOVED,           /* OFPT_FLOW_REMOVED or NXT_FLOW_REMOVED.
> */
> -    OAM_ROLE_STATUS,            /* OFPT_ROLE_STATUS. */
> -    OAM_TABLE_STATUS,           /* OFPT_TABLE_STATUS. */
> -    OAM_REQUESTFORWARD,         /* OFPT_REQUESTFORWARD. */
> -
> -    /* Extension asynchronous messages (none yet--coming soon!). */
> -#define OAM_EXTENSIONS 0        /* Bitmap of all extensions. */
> -
> -    OAM_N_TYPES
> -};
> -const char *ofputil_async_msg_type_to_string(enum
> ofputil_async_msg_type);
> -
> -struct ofputil_async_cfg {
> -    uint32_t master[OAM_N_TYPES];
> -    uint32_t slave[OAM_N_TYPES];
> -};
> -#define OFPUTIL_ASYNC_CFG_INIT (struct ofputil_async_cfg) { .master[0] =
> 0 }
> -
> -enum ofperr ofputil_decode_set_async_config(const struct ofp_header *,
> -                                            bool loose,
> -                                            const struct
> ofputil_async_cfg *,
> -                                            struct ofputil_async_cfg *);
> -
> -struct ofpbuf *ofputil_encode_get_async_reply(
> -    const struct ofp_header *, const struct ofputil_async_cfg *);
> -struct ofpbuf *ofputil_encode_set_async_config(
> -    const struct ofputil_async_cfg *, uint32_t oams, enum ofp_version);
> -
> -struct ofputil_async_cfg ofputil_async_cfg_default(enum ofp_version);
> -
> -struct ofputil_requestforward {
> -    ovs_be32 xid;
> -    enum ofp14_requestforward_reason reason;
> -    union {
> -        /* reason == OFPRFR_METER_MOD. */
> -        struct {
> -            struct ofputil_meter_mod *meter_mod;
> -            struct ofpbuf bands;
> -        };
> -
> -        /* reason == OFPRFR_GROUP_MOD. */
> -        struct ofputil_group_mod *group_mod;
> -    };
> -};
> -
> -struct ofpbuf *ofputil_encode_requestforward(
> -    const struct ofputil_requestforward *, enum ofputil_protocol);
> -enum ofperr ofputil_decode_requestforward(const struct ofp_header *,
> -                                          struct ofputil_requestforward
> *);
> -void ofputil_destroy_requestforward(struct ofputil_requestforward *);
> -
> -/* Abstract ofp14_table_status. */
> -struct ofputil_table_status {
> -    enum ofp14_table_reason reason;     /* One of OFPTR_*. */
> -    struct ofputil_table_desc desc;   /* New table config. */
> -};
> -
> -enum ofperr ofputil_decode_table_status(const struct ofp_header *oh,
> -                                        struct ofputil_table_status *ts);
> -
> -struct ofpbuf *
> -ofputil_encode_table_status(const struct ofputil_table_status *ts,
> -                            enum ofputil_protocol protocol);
>
>  #ifdef __cplusplus
>  }
> diff --git a/include/openvswitch/vconn.h b/include/openvswitch/vconn.h
> index 90f9bad2c1c9..b30d46af0eb8 100644
> --- a/include/openvswitch/vconn.h
> +++ b/include/openvswitch/vconn.h
> @@ -20,7 +20,7 @@
>  #include <stdbool.h>
>  #include "openvswitch/list.h"
>  #include "openvswitch/types.h"
> -#include "openvswitch/ofp-util.h"
> +#include "openvswitch/ofp-protocol.h"
>  #include "openflow/openflow.h"
>
>  #ifdef __cplusplus
> @@ -28,6 +28,8 @@ extern "C" {
>  #endif
>
>  struct ofpbuf;
> +struct ofputil_flow_stats;
> +struct ofputil_flow_stats_request;
>  struct pvconn;
>  struct pvconn_class;
>  struct vconn;
> diff --git a/lib/automake.mk b/lib/automake.mk
> index 38d2a999d119..5c26e0f334f3 100644
> --- a/lib/automake.mk
> +++ b/lib/automake.mk
> @@ -131,6 +131,7 @@ lib_libopenvswitch_la_SOURCES = \
>         lib/meta-flow.c \
>         lib/multipath.c \
>         lib/multipath.h \
> +       lib/namemap.c \
>         lib/netdev-dpdk.h \
>         lib/netdev-dummy.c \
>         lib/netdev-provider.h \
> @@ -151,12 +152,26 @@ lib_libopenvswitch_la_SOURCES = \
>         lib/odp-util.c \
>         lib/odp-util.h \
>         lib/ofp-actions.c \
> +       lib/ofp-bundle.c \
> +       lib/ofp-connection.c \
>         lib/ofp-ed-props.c \
>         lib/ofp-errors.c \
> +       lib/ofp-flow.c \
> +       lib/ofp-group.c \
> +       lib/ofp-ipfix.c \
> +       lib/ofp-match.c \
> +       lib/ofp-meter.c \
> +       lib/ofp-monitor.c \
>         lib/ofp-msgs.c \
> +       lib/ofp-packet.c \
>         lib/ofp-parse.c \
> +       lib/ofp-port.c \
>         lib/ofp-print.c \
>         lib/ofp-prop.c \
> +       lib/ofp-protocol.c \
> +       lib/ofp-queue.c \
> +       lib/ofp-switch.c \
> +       lib/ofp-table.c \
>         lib/ofp-util.c \
>         lib/ofp-version-opt.h \
>         lib/ofp-version-opt.c \
> diff --git a/lib/bundle.c b/lib/bundle.c
> index a58d8d247270..edf6676d635e 100644
> --- a/lib/bundle.c
> +++ b/lib/bundle.c
> @@ -30,7 +30,7 @@
>  #include "openvswitch/meta-flow.h"
>  #include "openvswitch/ofp-actions.h"
>  #include "openvswitch/ofp-errors.h"
> -#include "openvswitch/ofp-util.h"
> +#include "openvswitch/ofp-port.h"
>  #include "openvswitch/ofpbuf.h"
>  #include "openvswitch/vlog.h"
>  #include "util.h"
> diff --git a/lib/classifier.c b/lib/classifier.c
> index 532f1662dc1a..ef7e3de0728c 100644
> --- a/lib/classifier.c
> +++ b/lib/classifier.c
> @@ -23,7 +23,6 @@
>  #include "byte-order.h"
>  #include "openvswitch/dynamic-string.h"
>  #include "odp-util.h"
> -#include "openvswitch/ofp-util.h"
>  #include "packets.h"
>  #include "util.h"
>
> diff --git a/lib/dpctl.c b/lib/dpctl.c
> index 87f0412f6a96..47f4182c7be8 100644
> --- a/lib/dpctl.c
> +++ b/lib/dpctl.c
> @@ -49,7 +49,8 @@
>  #include "timeval.h"
>  #include "unixctl.h"
>  #include "util.h"
> -#include "openvswitch/ofp-parse.h"
> +#include "openvswitch/ofp-flow.h"
> +#include "openvswitch/ofp-port.h"
>  #include "openvswitch/vlog.h"
>  VLOG_DEFINE_THIS_MODULE(dpctl);
>
> diff --git a/lib/dpif-netdev.c b/lib/dpif-netdev.c
> index ba62128c758c..89c4b8d2c596 100644
> --- a/lib/dpif-netdev.c
> +++ b/lib/dpif-netdev.c
> @@ -56,8 +56,8 @@
>  #include "openvswitch/dynamic-string.h"
>  #include "openvswitch/list.h"
>  #include "openvswitch/match.h"
> +#include "openvswitch/ofp-parse.h"
>  #include "openvswitch/ofp-print.h"
> -#include "openvswitch/ofp-util.h"
>  #include "openvswitch/ofpbuf.h"
>  #include "openvswitch/shash.h"
>  #include "openvswitch/vlog.h"
> diff --git a/lib/dpif-netlink.c b/lib/dpif-netlink.c
> index f8d75eb4595d..8543a2bbe462 100644
> --- a/lib/dpif-netlink.c
> +++ b/lib/dpif-netlink.c
> @@ -33,31 +33,32 @@
>  #include <unistd.h>
>
>  #include "bitmap.h"
> -#include "dpif-provider.h"
>  #include "dpif-netlink-rtnl.h"
> -#include "openvswitch/dynamic-string.h"
> -#include "flow.h"
> +#include "dpif-provider.h"
>  #include "fat-rwlock.h"
> -#include "netdev.h"
> -#include "netdev-provider.h"
> +#include "flow.h"
>  #include "netdev-linux.h"
> +#include "netdev-provider.h"
>  #include "netdev-vport.h"
> +#include "netdev.h"
>  #include "netlink-conntrack.h"
>  #include "netlink-notifier.h"
>  #include "netlink-socket.h"
>  #include "netlink.h"
>  #include "odp-util.h"
> +#include "openvswitch/dynamic-string.h"
> +#include "openvswitch/flow.h"
> +#include "openvswitch/match.h"
>  #include "openvswitch/ofpbuf.h"
> -#include "packets.h"
>  #include "openvswitch/poll-loop.h"
> -#include "random.h"
>  #include "openvswitch/shash.h"
> +#include "openvswitch/vlog.h"
> +#include "packets.h"
> +#include "random.h"
>  #include "sset.h"
>  #include "timeval.h"
>  #include "unaligned.h"
>  #include "util.h"
> -#include "openvswitch/vlog.h"
> -#include "openvswitch/flow.h"
>
>  VLOG_DEFINE_THIS_MODULE(dpif_netlink);
>  #ifdef _WIN32
> diff --git a/lib/dpif.c b/lib/dpif.c
> index d3ea4613fd21..a1be4fdca944 100644
> --- a/lib/dpif.c
> +++ b/lib/dpif.c
> @@ -34,7 +34,6 @@
>  #include "odp-execute.h"
>  #include "odp-util.h"
>  #include "openvswitch/ofp-print.h"
> -#include "openvswitch/ofp-util.h"
>  #include "openvswitch/ofpbuf.h"
>  #include "packets.h"
>  #include "openvswitch/poll-loop.h"
> diff --git a/lib/dpif.h b/lib/dpif.h
> index 2e739dc784be..94f89eca96e2 100644
> --- a/lib/dpif.h
> +++ b/lib/dpif.h
> @@ -392,7 +392,7 @@
>  #include "dp-packet.h"
>  #include "netdev.h"
>  #include "openflow/openflow.h"
> -#include "openvswitch/ofp-util.h"
> +#include "openvswitch/ofp-meter.h"
>  #include "ovs-numa.h"
>  #include "packets.h"
>  #include "util.h"
> diff --git a/lib/learn.c b/lib/learn.c
> index 5164082f8e52..f5d15503fe79 100644
> --- a/lib/learn.c
> +++ b/lib/learn.c
> @@ -27,7 +27,9 @@
>  #include "openvswitch/meta-flow.h"
>  #include "openvswitch/ofp-actions.h"
>  #include "openvswitch/ofp-errors.h"
> -#include "openvswitch/ofp-util.h"
> +#include "openvswitch/ofp-flow.h"
> +#include "openvswitch/ofp-parse.h"
> +#include "openvswitch/ofp-table.h"
>  #include "openvswitch/ofpbuf.h"
>  #include "vl-mff-map.h"
>  #include "unaligned.h"
> diff --git a/lib/learning-switch.c b/lib/learning-switch.c
> index f840f034875f..db520325c681 100644
> --- a/lib/learning-switch.c
> +++ b/lib/learning-switch.c
> @@ -32,11 +32,16 @@
>  #include "mac-learning.h"
>  #include "openflow/openflow.h"
>  #include "openvswitch/ofp-actions.h"
> +#include "openvswitch/ofp-connection.h"
>  #include "openvswitch/ofp-errors.h"
> +#include "openvswitch/ofp-flow.h"
> +#include "openvswitch/ofp-match.h"
>  #include "openvswitch/ofp-msgs.h"
>  #include "openvswitch/ofp-print.h"
>  #include "openvswitch/ofp-util.h"
> -#include "openvswitch/ofp-parse.h"
> +#include "openvswitch/ofp-packet.h"
> +#include "openvswitch/ofp-port.h"
> +#include "openvswitch/ofp-switch.h"
>  #include "openvswitch/ofpbuf.h"
>  #include "openvswitch/vconn.h"
>  #include "openvswitch/vlog.h"
> diff --git a/lib/learning-switch.h b/lib/learning-switch.h
> index 847e4beae89b..02b5112c99bb 100644
> --- a/lib/learning-switch.h
> +++ b/lib/learning-switch.h
> @@ -20,7 +20,7 @@
>  #include <stdbool.h>
>  #include <stdint.h>
>  #include <stdio.h>
> -#include "openvswitch/ofp-util.h"
> +#include "openvswitch/ofp-protocol.h"
>
>  struct ofpbuf;
>  struct rconn;
> diff --git a/lib/match.c b/lib/match.c
> index b8804922159d..97a5282997b0 100644
> --- a/lib/match.c
> +++ b/lib/match.c
> @@ -21,7 +21,8 @@
>  #include "byte-order.h"
>  #include "colors.h"
>  #include "openvswitch/dynamic-string.h"
> -#include "openvswitch/ofp-util.h"
> +#include "openvswitch/meta-flow.h"
> +#include "openvswitch/ofp-port.h"
>  #include "packets.h"
>  #include "tun-metadata.h"
>  #include "openvswitch/nsh.h"
> diff --git a/lib/meta-flow.c b/lib/meta-flow.c
> index ed41f5021ca9..aa2ec012d671 100644
> --- a/lib/meta-flow.c
> +++ b/lib/meta-flow.c
> @@ -26,7 +26,6 @@
>  #include "classifier.h"
>  #include "openvswitch/dynamic-string.h"
>  #include "nx-match.h"
> -#include "openvswitch/ofp-util.h"
>  #include "ovs-atomic.h"
>  #include "ovs-rcu.h"
>  #include "ovs-thread.h"
> @@ -38,6 +37,8 @@
>  #include "unaligned.h"
>  #include "util.h"
>  #include "openvswitch/ofp-errors.h"
> +#include "openvswitch/ofp-match.h"
> +#include "openvswitch/ofp-port.h"
>  #include "openvswitch/vlog.h"
>  #include "vl-mff-map.h"
>  #include "openvswitch/nsh.h"
> diff --git a/lib/multipath.c b/lib/multipath.c
> index fdbf94ea6947..659c0bde0347 100644
> --- a/lib/multipath.c
> +++ b/lib/multipath.c
> @@ -27,7 +27,6 @@
>  #include "openvswitch/dynamic-string.h"
>  #include "openvswitch/ofp-actions.h"
>  #include "openvswitch/ofp-errors.h"
> -#include "openvswitch/ofp-util.h"
>  #include "packets.h"
>  #include "util.h"
>
> diff --git a/lib/namemap.c b/lib/namemap.c
> new file mode 100644
> index 000000000000..785cda4c2782
> --- /dev/null
> +++ b/lib/namemap.c
> @@ -0,0 +1,132 @@
> +/*
> + * Copyright (c) 2017-2018 Nicira, Inc.
> + *
> + * Licensed under the Apache License, Version 2.0 (the "License");
> + * you may not use this file except in compliance with the License.
> + * You may obtain a copy of the License at:
> + *
> + *     http://www.apache.org/licenses/LICENSE-2.0
> + *
> + * Unless required by applicable law or agreed to in writing, software
> + * distributed under the License is distributed on an "AS IS" BASIS,
> + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
> implied.
> + * See the License for the specific language governing permissions and
> + * limitations under the License.
> + */
> +
> +#include <config.h>
> +#include "openvswitch/namemap.h"
> +#include <ctype.h>
> +#include "hash.h"
> +#include "openvswitch/dynamic-string.h"
> +#include "openvswitch/json.h"
> +
> +void
> +namemap_init(struct namemap *map)
> +{
> +    hmap_init(&map->by_name);
> +    hmap_init(&map->by_number);
> +}
> +
> +struct namemap_node *
> +namemap_find_by_name(const struct namemap *map, const char *name)
> +{
> +    struct namemap_node *node;
> +
> +    HMAP_FOR_EACH_WITH_HASH (node, name_node, hash_string(name, 0),
> +                             &map->by_name) {
> +        if (!strcmp(name, node->name)) {
> +            return node;
> +        }
> +    }
> +    return NULL;
> +}
> +
> +struct namemap_node *
> +namemap_find_by_number(const struct namemap *map, uint32_t number)
> +{
> +    struct namemap_node *node;
> +
> +    HMAP_FOR_EACH_IN_BUCKET (node, number_node, hash_int(number, 0),
> +                             &map->by_number) {
> +        if (node->number == number) {
> +            return node;
> +        }
> +    }
> +    return NULL;
> +}
> +
> +void
> +namemap_put(struct namemap *map, uint32_t number, const char *name)
> +{
> +    struct namemap_node *node;
> +
> +    /* Look for duplicate name. */
> +    node = namemap_find_by_name(map, name);
> +    if (node) {
> +        if (node->number != number) {
> +            node->duplicate = true;
> +        }
> +        return;
> +    }
> +
> +    /* Look for duplicate number. */
> +    node = namemap_find_by_number(map, number);
> +    if (node) {
> +        node->duplicate = true;
> +        return;
> +    }
> +
> +    /* Add new node. */
> +    node = xmalloc(sizeof *node);
> +    hmap_insert(&map->by_number, &node->number_node, hash_int(number, 0));
> +    hmap_insert(&map->by_name, &node->name_node, hash_string(name, 0));
> +    node->number = number;
> +    node->name = xstrdup(name);
> +    node->duplicate = false;
> +}
> +
> +void
> +namemap_destroy(struct namemap *map)
> +{
> +    if (map) {
> +        struct namemap_node *node, *next;
> +
> +        HMAP_FOR_EACH_SAFE (node, next, name_node, &map->by_name) {
> +            hmap_remove(&map->by_name, &node->name_node);
> +            hmap_remove(&map->by_number, &node->number_node);
> +            free(node->name);
> +            free(node);
> +        }
> +        hmap_destroy(&map->by_name);
> +        hmap_destroy(&map->by_number);
> +    }
> +}
> +
> +/* A table or port name doesn't need to be quoted if it is alphanumeric
> and
> + * starts with a letter. */
> +static bool
> +name_needs_quotes(const char *name)
> +{
> +    if (!isalpha((unsigned char) name[0])) {
> +        return true;
> +    }
> +
> +    for (const char *p = name + 1; *p; p++) {
> +        if (!isalnum((unsigned char) *p)) {
> +            return true;
> +        }
> +    }
> +    return false;
> +}
> +
> +/* Appends port or table 'name' to 's', quoting it if necessary. */
> +void
> +namemap_put_name(const char *name, struct ds *s)
> +{
> +    if (name_needs_quotes(name)) {
> +        json_string_escape(name, s);
> +    } else {
> +        ds_put_cstr(s, name);
> +    }
> +}
> diff --git a/lib/nx-match.c b/lib/nx-match.c
> index aa7691ae9985..005c4a6ac09d 100644
> --- a/lib/nx-match.c
> +++ b/lib/nx-match.c
> @@ -28,7 +28,8 @@
>  #include "openvswitch/meta-flow.h"
>  #include "openvswitch/ofp-actions.h"
>  #include "openvswitch/ofp-errors.h"
> -#include "openvswitch/ofp-util.h"
> +#include "openvswitch/ofp-match.h"
> +#include "openvswitch/ofp-port.h"
>  #include "openvswitch/ofpbuf.h"
>  #include "openvswitch/vlog.h"
>  #include "packets.h"
> diff --git a/lib/ofp-actions.c b/lib/ofp-actions.c
> index 80dbd6dc57d6..7c076f65f985 100644
> --- a/lib/ofp-actions.c
> +++ b/lib/ofp-actions.c
> @@ -32,9 +32,11 @@
>  #include "openvswitch/dynamic-string.h"
>  #include "openvswitch/meta-flow.h"
>  #include "openvswitch/ofp-actions.h"
> -#include "openvswitch/ofp-util.h"
> +#include "openvswitch/ofp-packet.h"
>  #include "openvswitch/ofp-parse.h"
> +#include "openvswitch/ofp-port.h"
>  #include "openvswitch/ofp-prop.h"
> +#include "openvswitch/ofp-table.h"
>  #include "openvswitch/ofpbuf.h"
>  #include "openvswitch/vlog.h"
>  #include "unaligned.h"
> diff --git a/lib/ofp-bundle.c b/lib/ofp-bundle.c
> new file mode 100644
> index 000000000000..0921c81bfb15
> --- /dev/null
> +++ b/lib/ofp-bundle.c
> @@ -0,0 +1,431 @@
> +/*
> + * Copyright (c) 2008-2017 Nicira, Inc.
> + *
> + * Licensed under the Apache License, Version 2.0 (the "License");
> + * you may not use this file except in compliance with the License.
> + * You may obtain a copy of the License at:
> + *
> + *     http://www.apache.org/licenses/LICENSE-2.0
> + *
> + * Unless required by applicable law or agreed to in writing, software
> + * distributed under the License is distributed on an "AS IS" BASIS,
> + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
> implied.
> + * See the License for the specific language governing permissions and
> + * limitations under the License.
> + */
> +
> +#include <config.h>
> +#include "openvswitch/ofp-bundle.h"
> +#include <errno.h>
> +#include <stdlib.h>
> +#include "openvswitch/ofp-parse.h"
> +#include "openvswitch/ofpbuf.h"
> +#include "openvswitch/vlog.h"
> +#include "util.h"
> +
> +VLOG_DEFINE_THIS_MODULE(ofp_bundle);
> +
> +/* Destroys 'bms'. */
> +void
> +ofputil_free_bundle_msgs(struct ofputil_bundle_msg *bms, size_t n_bms)
> +{
> +    for (size_t i = 0; i < n_bms; i++) {
> +        switch ((int)bms[i].type) {
> +        case OFPTYPE_FLOW_MOD:
> +            free(CONST_CAST(struct ofpact *, bms[i].fm.ofpacts));
> +            break;
> +        case OFPTYPE_GROUP_MOD:
> +            ofputil_uninit_group_mod(&bms[i].gm);
> +            break;
> +        case OFPTYPE_PACKET_OUT:
> +            free(bms[i].po.ofpacts);
> +            free(CONST_CAST(void *, bms[i].po.packet));
> +            break;
> +        default:
> +            break;
> +        }
> +    }
> +    free(bms);
> +}
> +
> +void
> +ofputil_encode_bundle_msgs(const struct ofputil_bundle_msg *bms,
> +                           size_t n_bms, struct ovs_list *requests,
> +                           enum ofputil_protocol protocol)
> +{
> +    enum ofp_version version = ofputil_protocol_to_ofp_version(protocol);
> +
> +    for (size_t i = 0; i < n_bms; i++) {
> +        struct ofpbuf *request = NULL;
> +
> +        switch ((int)bms[i].type) {
> +        case OFPTYPE_FLOW_MOD:
> +            request = ofputil_encode_flow_mod(&bms[i].fm, protocol);
> +            break;
> +        case OFPTYPE_GROUP_MOD:
> +            request = ofputil_encode_group_mod(version, &bms[i].gm);
> +            break;
> +        case OFPTYPE_PACKET_OUT:
> +            request = ofputil_encode_packet_out(&bms[i].po, protocol);
> +            break;
> +        default:
> +            break;
> +        }
> +        if (request) {
> +            ovs_list_push_back(requests, &request->list_node);
> +        }
> +    }
> +}
> +
> +enum ofperr
> +ofputil_decode_bundle_ctrl(const struct ofp_header *oh,
> +                           struct ofputil_bundle_ctrl_msg *msg)
> +{
> +    struct ofpbuf b = ofpbuf_const_initializer(oh, ntohs(oh->length));
> +    enum ofpraw raw = ofpraw_pull_assert(&b);
> +    ovs_assert(raw == OFPRAW_OFPT14_BUNDLE_CONTROL
> +               || raw == OFPRAW_ONFT13_BUNDLE_CONTROL);
> +
> +    const struct ofp14_bundle_ctrl_msg *m = b.msg;
> +    msg->bundle_id = ntohl(m->bundle_id);
> +    msg->type = ntohs(m->type);
> +    msg->flags = ntohs(m->flags);
> +
> +    return 0;
> +}
> +
> +struct ofpbuf *
> +ofputil_encode_bundle_ctrl_request(enum ofp_version ofp_version,
> +                                   struct ofputil_bundle_ctrl_msg *bc)
> +{
> +    struct ofpbuf *request;
> +    struct ofp14_bundle_ctrl_msg *m;
> +
> +    switch (ofp_version) {
> +    case OFP10_VERSION:
> +    case OFP11_VERSION:
> +    case OFP12_VERSION:
> +        ovs_fatal(0, "bundles need OpenFlow 1.3 or later "
> +                     "(\'-O OpenFlow14\')");
> +    case OFP13_VERSION:
> +    case OFP14_VERSION:
> +    case OFP15_VERSION:
> +    case OFP16_VERSION:
> +        request = ofpraw_alloc(ofp_version == OFP13_VERSION
> +                               ? OFPRAW_ONFT13_BUNDLE_CONTROL
> +                               : OFPRAW_OFPT14_BUNDLE_CONTROL,
> ofp_version, 0);
> +        m = ofpbuf_put_zeros(request, sizeof *m);
> +
> +        m->bundle_id = htonl(bc->bundle_id);
> +        m->type = htons(bc->type);
> +        m->flags = htons(bc->flags);
> +        break;
> +    default:
> +        OVS_NOT_REACHED();
> +    }
> +
> +    return request;
> +}
> +
> +struct ofpbuf *
> +ofputil_encode_bundle_ctrl_reply(const struct ofp_header *oh,
> +                                 struct ofputil_bundle_ctrl_msg *msg)
> +{
> +    struct ofpbuf *buf;
> +    struct ofp14_bundle_ctrl_msg *m;
> +
> +    buf = ofpraw_alloc_reply(oh->version == OFP13_VERSION
> +                             ? OFPRAW_ONFT13_BUNDLE_CONTROL
> +                             : OFPRAW_OFPT14_BUNDLE_CONTROL, oh, 0);
> +    m = ofpbuf_put_zeros(buf, sizeof *m);
> +
> +    m->bundle_id = htonl(msg->bundle_id);
> +    m->type = htons(msg->type);
> +    m->flags = htons(msg->flags);
> +
> +    return buf;
> +}
> +
> +/* Return true for bundlable state change requests, false for other
> messages.
> + */
> +static bool
> +ofputil_is_bundlable(enum ofptype type)
> +{
> +    switch (type) {
> +        /* Minimum required by OpenFlow 1.4. */
> +    case OFPTYPE_PORT_MOD:
> +    case OFPTYPE_FLOW_MOD:
> +        /* Other supported types. */
> +    case OFPTYPE_GROUP_MOD:
> +    case OFPTYPE_PACKET_OUT:
> +        return true;
> +
> +        /* Nice to have later. */
> +    case OFPTYPE_FLOW_MOD_TABLE_ID:
> +    case OFPTYPE_TABLE_MOD:
> +    case OFPTYPE_METER_MOD:
> +    case OFPTYPE_NXT_TLV_TABLE_MOD:
> +
> +        /* Not to be bundlable. */
> +    case OFPTYPE_ECHO_REQUEST:
> +    case OFPTYPE_FEATURES_REQUEST:
> +    case OFPTYPE_GET_CONFIG_REQUEST:
> +    case OFPTYPE_SET_CONFIG:
> +    case OFPTYPE_BARRIER_REQUEST:
> +    case OFPTYPE_ROLE_REQUEST:
> +    case OFPTYPE_ECHO_REPLY:
> +    case OFPTYPE_SET_FLOW_FORMAT:
> +    case OFPTYPE_SET_PACKET_IN_FORMAT:
> +    case OFPTYPE_SET_CONTROLLER_ID:
> +    case OFPTYPE_FLOW_AGE:
> +    case OFPTYPE_FLOW_MONITOR_CANCEL:
> +    case OFPTYPE_SET_ASYNC_CONFIG:
> +    case OFPTYPE_GET_ASYNC_REQUEST:
> +    case OFPTYPE_DESC_STATS_REQUEST:
> +    case OFPTYPE_FLOW_STATS_REQUEST:
> +    case OFPTYPE_AGGREGATE_STATS_REQUEST:
> +    case OFPTYPE_TABLE_STATS_REQUEST:
> +    case OFPTYPE_TABLE_FEATURES_STATS_REQUEST:
> +    case OFPTYPE_TABLE_DESC_REQUEST:
> +    case OFPTYPE_PORT_STATS_REQUEST:
> +    case OFPTYPE_QUEUE_STATS_REQUEST:
> +    case OFPTYPE_PORT_DESC_STATS_REQUEST:
> +    case OFPTYPE_FLOW_MONITOR_STATS_REQUEST:
> +    case OFPTYPE_METER_STATS_REQUEST:
> +    case OFPTYPE_METER_CONFIG_STATS_REQUEST:
> +    case OFPTYPE_METER_FEATURES_STATS_REQUEST:
> +    case OFPTYPE_GROUP_STATS_REQUEST:
> +    case OFPTYPE_GROUP_DESC_STATS_REQUEST:
> +    case OFPTYPE_GROUP_FEATURES_STATS_REQUEST:
> +    case OFPTYPE_QUEUE_GET_CONFIG_REQUEST:
> +    case OFPTYPE_BUNDLE_CONTROL:
> +    case OFPTYPE_BUNDLE_ADD_MESSAGE:
> +    case OFPTYPE_HELLO:
> +    case OFPTYPE_ERROR:
> +    case OFPTYPE_FEATURES_REPLY:
> +    case OFPTYPE_GET_CONFIG_REPLY:
> +    case OFPTYPE_PACKET_IN:
> +    case OFPTYPE_FLOW_REMOVED:
> +    case OFPTYPE_PORT_STATUS:
> +    case OFPTYPE_BARRIER_REPLY:
> +    case OFPTYPE_QUEUE_GET_CONFIG_REPLY:
> +    case OFPTYPE_DESC_STATS_REPLY:
> +    case OFPTYPE_FLOW_STATS_REPLY:
> +    case OFPTYPE_QUEUE_STATS_REPLY:
> +    case OFPTYPE_PORT_STATS_REPLY:
> +    case OFPTYPE_TABLE_STATS_REPLY:
> +    case OFPTYPE_AGGREGATE_STATS_REPLY:
> +    case OFPTYPE_PORT_DESC_STATS_REPLY:
> +    case OFPTYPE_ROLE_REPLY:
> +    case OFPTYPE_FLOW_MONITOR_PAUSED:
> +    case OFPTYPE_FLOW_MONITOR_RESUMED:
> +    case OFPTYPE_FLOW_MONITOR_STATS_REPLY:
> +    case OFPTYPE_GET_ASYNC_REPLY:
> +    case OFPTYPE_GROUP_STATS_REPLY:
> +    case OFPTYPE_GROUP_DESC_STATS_REPLY:
> +    case OFPTYPE_GROUP_FEATURES_STATS_REPLY:
> +    case OFPTYPE_METER_STATS_REPLY:
> +    case OFPTYPE_METER_CONFIG_STATS_REPLY:
> +    case OFPTYPE_METER_FEATURES_STATS_REPLY:
> +    case OFPTYPE_TABLE_FEATURES_STATS_REPLY:
> +    case OFPTYPE_TABLE_DESC_REPLY:
> +    case OFPTYPE_ROLE_STATUS:
> +    case OFPTYPE_REQUESTFORWARD:
> +    case OFPTYPE_TABLE_STATUS:
> +    case OFPTYPE_NXT_TLV_TABLE_REQUEST:
> +    case OFPTYPE_NXT_TLV_TABLE_REPLY:
> +    case OFPTYPE_NXT_RESUME:
> +    case OFPTYPE_IPFIX_BRIDGE_STATS_REQUEST:
> +    case OFPTYPE_IPFIX_BRIDGE_STATS_REPLY:
> +    case OFPTYPE_IPFIX_FLOW_STATS_REQUEST:
> +    case OFPTYPE_IPFIX_FLOW_STATS_REPLY:
> +    case OFPTYPE_CT_FLUSH_ZONE:
> +        break;
> +    }
> +
> +    return false;
> +}
> +
> +enum ofperr
> +ofputil_decode_bundle_add(const struct ofp_header *oh,
> +                          struct ofputil_bundle_add_msg *msg,
> +                          enum ofptype *typep)
> +{
> +    struct ofpbuf b = ofpbuf_const_initializer(oh, ntohs(oh->length));
> +
> +    /* Pull the outer ofp_header. */
> +    enum ofpraw raw = ofpraw_pull_assert(&b);
> +    ovs_assert(raw == OFPRAW_OFPT14_BUNDLE_ADD_MESSAGE
> +               || raw == OFPRAW_ONFT13_BUNDLE_ADD_MESSAGE);
> +
> +    /* Pull the bundle_ctrl header. */
> +    const struct ofp14_bundle_ctrl_msg *m = ofpbuf_pull(&b, sizeof *m);
> +    msg->bundle_id = ntohl(m->bundle_id);
> +    msg->flags = ntohs(m->flags);
> +
> +    /* Pull the inner ofp_header. */
> +    if (b.size < sizeof(struct ofp_header)) {
> +        return OFPERR_OFPBFC_MSG_BAD_LEN;
> +    }
> +    msg->msg = b.data;
> +    if (msg->msg->version != oh->version) {
> +        return OFPERR_OFPBFC_BAD_VERSION;
> +    }
> +    size_t inner_len = ntohs(msg->msg->length);
> +    if (inner_len < sizeof(struct ofp_header) || inner_len > b.size) {
> +        return OFPERR_OFPBFC_MSG_BAD_LEN;
> +    }
> +    if (msg->msg->xid != oh->xid) {
> +        return OFPERR_OFPBFC_MSG_BAD_XID;
> +    }
> +
> +    /* Reject unbundlable messages. */
> +    enum ofptype type;
> +    enum ofperr error = ofptype_decode(&type, msg->msg);
> +    if (error) {
> +        static struct vlog_rate_limit rl = VLOG_RATE_LIMIT_INIT(1, 5);
> +        VLOG_WARN_RL(&rl, "OFPT14_BUNDLE_ADD_MESSAGE contained "
> +                     "message is unparsable (%s)",
> ofperr_get_name(error));
> +        return OFPERR_OFPBFC_MSG_UNSUP; /* 'error' would be confusing. */
> +    }
> +
> +    if (!ofputil_is_bundlable(type)) {
> +        static struct vlog_rate_limit rl = VLOG_RATE_LIMIT_INIT(1, 5);
> +        VLOG_WARN_RL(&rl, "%s message not allowed inside "
> +                     "OFPT14_BUNDLE_ADD_MESSAGE", ofptype_get_name(type));
> +        return OFPERR_OFPBFC_MSG_UNSUP;
> +    }
> +    if (typep) {
> +        *typep = type;
> +    }
> +
> +    return 0;
> +}
> +
> +struct ofpbuf *
> +ofputil_encode_bundle_add(enum ofp_version ofp_version,
> +                          struct ofputil_bundle_add_msg *msg)
> +{
> +    struct ofpbuf *request;
> +    struct ofp14_bundle_ctrl_msg *m;
> +
> +    /* Must use the same xid as the embedded message. */
> +    request = ofpraw_alloc_xid(ofp_version == OFP13_VERSION
> +                               ? OFPRAW_ONFT13_BUNDLE_ADD_MESSAGE
> +                               : OFPRAW_OFPT14_BUNDLE_ADD_MESSAGE,
> ofp_version,
> +                               msg->msg->xid, ntohs(msg->msg->length));
> +    m = ofpbuf_put_zeros(request, sizeof *m);
> +
> +    m->bundle_id = htonl(msg->bundle_id);
> +    m->flags = htons(msg->flags);
> +    ofpbuf_put(request, msg->msg, ntohs(msg->msg->length));
> +
> +    ofpmsg_update_length(request);
> +    return request;
> +}
> +
> +/* Opens file 'file_name' and reads each line as a flow_mod or a
> group_mod,
> + * depending on the first keyword on each line.  Stores each flow and
> group
> + * mods in '*bms', an array allocated on the caller's behalf, and the
> number of
> + * messages in '*n_bms'.
> + *
> + * Returns NULL if successful, otherwise a malloc()'d string describing
> the
> + * error.  The caller is responsible for freeing the returned string. */
> +char * OVS_WARN_UNUSED_RESULT
> +parse_ofp_bundle_file(const char *file_name,
> +                      const struct ofputil_port_map *port_map,
> +                      const struct ofputil_table_map *table_map,
> +                      struct ofputil_bundle_msg **bms, size_t *n_bms,
> +                      enum ofputil_protocol *usable_protocols)
> +{
> +    size_t allocated_bms;
> +    char *error = NULL;
> +    int line_number;
> +    FILE *stream;
> +    struct ds ds;
> +
> +    *usable_protocols = OFPUTIL_P_ANY;
> +
> +    *bms = NULL;
> +    *n_bms = 0;
> +
> +    stream = !strcmp(file_name, "-") ? stdin : fopen(file_name, "r");
> +    if (stream == NULL) {
> +        return xasprintf("%s: open failed (%s)",
> +                         file_name, ovs_strerror(errno));
> +    }
> +
> +    allocated_bms = *n_bms;
> +    ds_init(&ds);
> +    line_number = 0;
> +    while (!ds_get_preprocessed_line(&ds, stream, &line_number)) {
> +        enum ofputil_protocol usable;
> +        char *s = ds_cstr(&ds);
> +        size_t len;
> +
> +        if (*n_bms >= allocated_bms) {
> +            struct ofputil_bundle_msg *new_bms;
> +
> +            new_bms = x2nrealloc(*bms, &allocated_bms, sizeof **bms);
> +            for (size_t i = 0; i < *n_bms; i++) {
> +                if (new_bms[i].type == OFPTYPE_GROUP_MOD) {
> +                    ovs_list_moved(&new_bms[i].gm.buckets,
> +                                   &(*bms)[i].gm.buckets);
> +                }
> +            }
> +            *bms = new_bms;
> +        }
> +
> +        s += strspn(s, " \t\r\n");   /* Skip white space. */
> +        len = strcspn(s, ", \t\r\n"); /* Get length of the first token. */
> +
> +        if (!strncmp(s, "flow", len)) {
> +            s += len;
> +            error = parse_ofp_flow_mod_str(&(*bms)[*n_bms].fm, s,
> port_map,
> +                                           table_map, -2, &usable);
> +            if (error) {
> +                break;
> +            }
> +            (*bms)[*n_bms].type = OFPTYPE_FLOW_MOD;
> +        } else if (!strncmp(s, "group", len)) {
> +            s += len;
> +            error = parse_ofp_group_mod_str(&(*bms)[*n_bms].gm, -2, s,
> +                                            port_map, table_map, &usable);
> +            if (error) {
> +                break;
> +            }
> +            (*bms)[*n_bms].type = OFPTYPE_GROUP_MOD;
> +        } else if (!strncmp(s, "packet-out", len)) {
> +            s += len;
> +            error = parse_ofp_packet_out_str(&(*bms)[*n_bms].po, s,
> port_map,
> +                                             table_map, &usable);
> +            if (error) {
> +                break;
> +            }
> +            (*bms)[*n_bms].type = OFPTYPE_PACKET_OUT;
> +        } else {
> +            error = xasprintf("Unsupported bundle message type: %.*s",
> +                              (int)len, s);
> +            break;
> +        }
> +
> +        *usable_protocols &= usable; /* Each line can narrow the set. */
> +        *n_bms += 1;
> +    }
> +
> +    ds_destroy(&ds);
> +    if (stream != stdin) {
> +        fclose(stream);
> +    }
> +
> +    if (error) {
> +        char *err_msg = xasprintf("%s:%d: %s", file_name, line_number,
> error);
> +        free(error);
> +
> +        ofputil_free_bundle_msgs(*bms, *n_bms);
> +        *bms = NULL;
> +        *n_bms = 0;
> +        return err_msg;
> +    }
> +    return NULL;
> +}
> diff --git a/lib/ofp-connection.c b/lib/ofp-connection.c
> new file mode 100644
> index 000000000000..599fd0f68c35
> --- /dev/null
> +++ b/lib/ofp-connection.c
> @@ -0,0 +1,526 @@
> +/*
> + * Copyright (c) 2008-2017 Nicira, Inc.
> + *
> + * Licensed under the Apache License, Version 2.0 (the "License");
> + * you may not use this file except in compliance with the License.
> + * You may obtain a copy of the License at:
> + *
> + *     http://www.apache.org/licenses/LICENSE-2.0
> + *
> + * Unless required by applicable law or agreed to in writing, software
> + * distributed under the License is distributed on an "AS IS" BASIS,
> + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
> implied.
> + * See the License for the specific language governing permissions and
> + * limitations under the License.
> + */
> +
> +#include <config.h>
> +#include "openvswitch/ofp-connection.h"
> +#include "byte-order.h"
> +#include "openflow/nicira-ext.h"
> +#include "openvswitch/ofp-errors.h"
> +#include "openvswitch/ofp-msgs.h"
> +#include "openvswitch/ofp-prop.h"
> +#include "openvswitch/ofpbuf.h"
> +#include "openvswitch/vlog.h"
> +#include "util.h"
> +
> +VLOG_DEFINE_THIS_MODULE(ofp_connection);
> +
> +/* ofputil_role_request */
> +
> +/* Decodes the OpenFlow "role request" or "role reply" message in '*oh'
> into
> + * an abstract form in '*rr'.  Returns 0 if successful, otherwise an
> + * OFPERR_* value. */
> +enum ofperr
> +ofputil_decode_role_message(const struct ofp_header *oh,
> +                            struct ofputil_role_request *rr)
> +{
> +    struct ofpbuf b = ofpbuf_const_initializer(oh, ntohs(oh->length));
> +    enum ofpraw raw = ofpraw_pull_assert(&b);
> +    if (raw == OFPRAW_OFPT12_ROLE_REQUEST ||
> +        raw == OFPRAW_OFPT12_ROLE_REPLY) {
> +        const struct ofp12_role_request *orr = b.msg;
> +
> +        if (orr->role != htonl(OFPCR12_ROLE_NOCHANGE) &&
> +            orr->role != htonl(OFPCR12_ROLE_EQUAL) &&
> +            orr->role != htonl(OFPCR12_ROLE_MASTER) &&
> +            orr->role != htonl(OFPCR12_ROLE_SLAVE)) {
> +            return OFPERR_OFPRRFC_BAD_ROLE;
> +        }
> +
> +        rr->role = ntohl(orr->role);
> +        if (raw == OFPRAW_OFPT12_ROLE_REQUEST
> +            ? orr->role == htonl(OFPCR12_ROLE_NOCHANGE)
> +            : orr->generation_id == OVS_BE64_MAX) {
> +            rr->have_generation_id = false;
> +            rr->generation_id = 0;
> +        } else {
> +            rr->have_generation_id = true;
> +            rr->generation_id = ntohll(orr->generation_id);
> +        }
> +    } else if (raw == OFPRAW_NXT_ROLE_REQUEST ||
> +               raw == OFPRAW_NXT_ROLE_REPLY) {
> +        const struct nx_role_request *nrr = b.msg;
> +
> +        BUILD_ASSERT(NX_ROLE_OTHER + 1 == OFPCR12_ROLE_EQUAL);
> +        BUILD_ASSERT(NX_ROLE_MASTER + 1 == OFPCR12_ROLE_MASTER);
> +        BUILD_ASSERT(NX_ROLE_SLAVE + 1 == OFPCR12_ROLE_SLAVE);
> +
> +        if (nrr->role != htonl(NX_ROLE_OTHER) &&
> +            nrr->role != htonl(NX_ROLE_MASTER) &&
> +            nrr->role != htonl(NX_ROLE_SLAVE)) {
> +            return OFPERR_OFPRRFC_BAD_ROLE;
> +        }
> +
> +        rr->role = ntohl(nrr->role) + 1;
> +        rr->have_generation_id = false;
> +        rr->generation_id = 0;
> +    } else {
> +        OVS_NOT_REACHED();
> +    }
> +
> +    return 0;
> +}
> +
> +/* Returns an encoded form of a role reply suitable for the "request" in a
> + * buffer owned by the caller. */
> +struct ofpbuf *
> +ofputil_encode_role_reply(const struct ofp_header *request,
> +                          const struct ofputil_role_request *rr)
> +{
> +    struct ofpbuf *buf;
> +    enum ofpraw raw;
> +
> +    raw = ofpraw_decode_assert(request);
> +    if (raw == OFPRAW_OFPT12_ROLE_REQUEST) {
> +        struct ofp12_role_request *orr;
> +
> +        buf = ofpraw_alloc_reply(OFPRAW_OFPT12_ROLE_REPLY, request, 0);
> +        orr = ofpbuf_put_zeros(buf, sizeof *orr);
> +
> +        orr->role = htonl(rr->role);
> +        orr->generation_id = htonll(rr->have_generation_id
> +                                    ? rr->generation_id
> +                                    : UINT64_MAX);
> +    } else if (raw == OFPRAW_NXT_ROLE_REQUEST) {
> +        struct nx_role_request *nrr;
> +
> +        BUILD_ASSERT(NX_ROLE_OTHER == OFPCR12_ROLE_EQUAL - 1);
> +        BUILD_ASSERT(NX_ROLE_MASTER == OFPCR12_ROLE_MASTER - 1);
> +        BUILD_ASSERT(NX_ROLE_SLAVE == OFPCR12_ROLE_SLAVE - 1);
> +
> +        buf = ofpraw_alloc_reply(OFPRAW_NXT_ROLE_REPLY, request, 0);
> +        nrr = ofpbuf_put_zeros(buf, sizeof *nrr);
> +        nrr->role = htonl(rr->role - 1);
> +    } else {
> +        OVS_NOT_REACHED();
> +    }
> +
> +    return buf;
> +}
> +
> +/* Encodes "role status" message 'status' for sending in the given
> + * 'protocol'.  Returns the role status message, if 'protocol' supports
> them,
> + * otherwise a null pointer. */
> +struct ofpbuf *
> +ofputil_encode_role_status(const struct ofputil_role_status *status,
> +                           enum ofputil_protocol protocol)
> +{
> +    enum ofp_version version;
> +
> +    version = ofputil_protocol_to_ofp_version(protocol);
> +    if (version >= OFP14_VERSION) {
> +        struct ofp14_role_status *rstatus;
> +        struct ofpbuf *buf;
> +
> +        buf = ofpraw_alloc_xid(OFPRAW_OFPT14_ROLE_STATUS, version,
> htonl(0),
> +                               0);
> +        rstatus = ofpbuf_put_zeros(buf, sizeof *rstatus);
> +        rstatus->role = htonl(status->role);
> +        rstatus->reason = status->reason;
> +        rstatus->generation_id = htonll(status->generation_id);
> +
> +        return buf;
> +    } else {
> +        return NULL;
> +    }
> +}
> +
> +enum ofperr
> +ofputil_decode_role_status(const struct ofp_header *oh,
> +                           struct ofputil_role_status *rs)
> +{
> +    struct ofpbuf b = ofpbuf_const_initializer(oh, ntohs(oh->length));
> +    ovs_assert(ofpraw_pull_assert(&b) == OFPRAW_OFPT14_ROLE_STATUS);
> +
> +    const struct ofp14_role_status *r = b.msg;
> +    if (r->role != htonl(OFPCR12_ROLE_NOCHANGE) &&
> +        r->role != htonl(OFPCR12_ROLE_EQUAL) &&
> +        r->role != htonl(OFPCR12_ROLE_MASTER) &&
> +        r->role != htonl(OFPCR12_ROLE_SLAVE)) {
> +        return OFPERR_OFPRRFC_BAD_ROLE;
> +    }
> +
> +    rs->role = ntohl(r->role);
> +    rs->generation_id = ntohll(r->generation_id);
> +    rs->reason = r->reason;
> +
> +    return 0;
> +}
> +
> +const char *
> +ofputil_async_msg_type_to_string(enum ofputil_async_msg_type type)
> +{
> +    switch (type) {
> +    case OAM_PACKET_IN:      return "PACKET_IN";
> +    case OAM_PORT_STATUS:    return "PORT_STATUS";
> +    case OAM_FLOW_REMOVED:   return "FLOW_REMOVED";
> +    case OAM_ROLE_STATUS:    return "ROLE_STATUS";
> +    case OAM_TABLE_STATUS:   return "TABLE_STATUS";
> +    case OAM_REQUESTFORWARD: return "REQUESTFORWARD";
> +
> +    case OAM_N_TYPES:
> +    default:
> +        OVS_NOT_REACHED();
> +    }
> +}
> +
> +struct ofp14_async_prop {
> +    uint64_t prop_type;
> +    enum ofputil_async_msg_type oam;
> +    bool master;
> +    uint32_t allowed10, allowed14;
> +};
> +
> +#define AP_PAIR(SLAVE_PROP_TYPE, OAM, A10, A14) \
> +    { SLAVE_PROP_TYPE,       OAM, false, A10, (A14) ? (A14) : (A10) },  \
> +    { (SLAVE_PROP_TYPE + 1), OAM, true,  A10, (A14) ? (A14) : (A10) }
> +
> +static const struct ofp14_async_prop async_props[] = {
> +    AP_PAIR( 0, OAM_PACKET_IN,      OFPR10_BITS, OFPR14_BITS),
> +    AP_PAIR( 2, OAM_PORT_STATUS,    (1 << OFPPR_N_REASONS) - 1, 0),
> +    AP_PAIR( 4, OAM_FLOW_REMOVED,   (1 << OVS_OFPRR_NONE) - 1, 0),
> +    AP_PAIR( 6, OAM_ROLE_STATUS,    (1 << OFPCRR_N_REASONS) - 1, 0),
> +    AP_PAIR( 8, OAM_TABLE_STATUS,   OFPTR_BITS, 0),
> +    AP_PAIR(10, OAM_REQUESTFORWARD, (1 << OFPRFR_N_REASONS) - 1, 0),
> +};
> +
> +#define FOR_EACH_ASYNC_PROP(VAR)                                \
> +    for (const struct ofp14_async_prop *VAR = async_props;      \
> +         VAR < &async_props[ARRAY_SIZE(async_props)]; VAR++)
> +
> +static const struct ofp14_async_prop *
> +get_ofp14_async_config_prop_by_prop_type(uint64_t prop_type)
> +{
> +    FOR_EACH_ASYNC_PROP (ap) {
> +        if (prop_type == ap->prop_type) {
> +            return ap;
> +        }
> +    }
> +    return NULL;
> +}
> +
> +static const struct ofp14_async_prop *
> +get_ofp14_async_config_prop_by_oam(enum ofputil_async_msg_type oam,
> +                                   bool master)
> +{
> +    FOR_EACH_ASYNC_PROP (ap) {
> +        if (ap->oam == oam && ap->master == master) {
> +            return ap;
> +        }
> +    }
> +    return NULL;
> +}
> +
> +static uint32_t
> +ofp14_async_prop_allowed(const struct ofp14_async_prop *prop,
> +                         enum ofp_version version)
> +{
> +    return version >= OFP14_VERSION ? prop->allowed14 : prop->allowed10;
> +}
> +
> +static ovs_be32
> +encode_async_mask(const struct ofputil_async_cfg *src,
> +                  const struct ofp14_async_prop *ap,
> +                  enum ofp_version version)
> +{
> +    uint32_t mask = ap->master ? src->master[ap->oam] :
> src->slave[ap->oam];
> +    return htonl(mask & ofp14_async_prop_allowed(ap, version));
> +}
> +
> +static enum ofperr
> +decode_async_mask(ovs_be32 src,
> +                  const struct ofp14_async_prop *ap, enum ofp_version
> version,
> +                  bool loose, struct ofputil_async_cfg *dst)
> +{
> +    uint32_t mask = ntohl(src);
> +    uint32_t allowed = ofp14_async_prop_allowed(ap, version);
> +    if (mask & ~allowed) {
> +        static struct vlog_rate_limit rl = VLOG_RATE_LIMIT_INIT(1, 5);
> +        OFPPROP_LOG(&rl, loose,
> +                    "bad value %#x for %s (allowed mask %#x)",
> +                    mask, ofputil_async_msg_type_to_string(ap->oam),
> +                    allowed);
> +        mask &= allowed;
> +        if (!loose) {
> +            return OFPERR_OFPACFC_INVALID;
> +        }
> +    }
> +
> +    if (ap->oam == OAM_PACKET_IN) {
> +        if (mask & (1u << OFPR_NO_MATCH)) {
> +            mask |= 1u << OFPR_EXPLICIT_MISS;
> +            if (version < OFP13_VERSION) {
> +                mask |= 1u << OFPR_IMPLICIT_MISS;
> +            }
> +        }
> +    }
> +
> +    uint32_t *array = ap->master ? dst->master : dst->slave;
> +    array[ap->oam] = mask;
> +    return 0;
> +}
> +
> +static enum ofperr
> +parse_async_tlv(const struct ofpbuf *property,
> +                const struct ofp14_async_prop *ap,
> +                struct ofputil_async_cfg *ac,
> +                enum ofp_version version, bool loose)
> +{
> +    enum ofperr error;
> +    ovs_be32 mask;
> +
> +    error  = ofpprop_parse_be32(property, &mask);
> +    if (error) {
> +        return error;
> +    }
> +
> +    if (ofpprop_is_experimenter(ap->prop_type)) {
> +        /* For experimenter properties, whether a property is for the
> master or
> +         * slave role is indicated by both 'type' and 'exp_type' in struct
> +         * ofp_prop_experimenter.  Check that these are consistent. */
> +        const struct ofp_prop_experimenter *ope = property->data;
> +        bool should_be_master = ope->type == htons(0xffff);
> +        if (should_be_master != ap->master) {
> +            static struct vlog_rate_limit rl = VLOG_RATE_LIMIT_INIT(1, 5);
> +            VLOG_WARN_RL(&rl, "async property type %#"PRIx16" "
> +                         "indicates %s role but exp_type %"PRIu32"
> indicates "
> +                         "%s role",
> +                         ntohs(ope->type),
> +                         should_be_master ? "master" : "slave",
> +                         ntohl(ope->exp_type),
> +                         ap->master ? "master" : "slave");
> +            return OFPERR_OFPBPC_BAD_EXP_TYPE;
> +        }
> +    }
> +
> +    return decode_async_mask(mask, ap, version, loose, ac);
> +}
> +
> +static void
> +decode_legacy_async_masks(const ovs_be32 masks[2],
> +                          enum ofputil_async_msg_type oam,
> +                          enum ofp_version version,
> +                          struct ofputil_async_cfg *dst)
> +{
> +    for (int i = 0; i < 2; i++) {
> +        bool master = i == 0;
> +        const struct ofp14_async_prop *ap
> +            = get_ofp14_async_config_prop_by_oam(oam, master);
> +        decode_async_mask(masks[i], ap, version, true, dst);
> +    }
> +}
> +
> +/* Decodes the OpenFlow "set async config" request and "get async config
> + * reply" message in '*oh' into an abstract form in 'ac'.
> + *
> + * Some versions of the "set async config" request change only some of the
> + * settings and leave the others alone.  This function uses 'basis' as the
> + * initial state for decoding these.  Other versions of the request
> change all
> + * the settings; this function ignores 'basis' when decoding these.
> + *
> + * If 'loose' is true, this function ignores properties and values that
> it does
> + * not understand, as a controller would want to do when interpreting
> + * capabilities provided by a switch.  If 'loose' is false, this function
> + * treats unknown properties and values as an error, as a switch would
> want to
> + * do when interpreting a configuration request made by a controller.
> + *
> + * Returns 0 if successful, otherwise an OFPERR_* value.
> + *
> + * Returns error code OFPERR_OFPACFC_INVALID if the value of mask is not
> in
> + * the valid range of mask.
> + *
> + * Returns error code OFPERR_OFPACFC_UNSUPPORTED if the configuration is
> not
> + * supported.*/
> +enum ofperr
> +ofputil_decode_set_async_config(const struct ofp_header *oh, bool loose,
> +                                const struct ofputil_async_cfg *basis,
> +                                struct ofputil_async_cfg *ac)
> +{
> +    struct ofpbuf b = ofpbuf_const_initializer(oh, ntohs(oh->length));
> +    enum ofpraw raw = ofpraw_pull_assert(&b);
> +
> +    if (raw == OFPRAW_OFPT13_SET_ASYNC ||
> +        raw == OFPRAW_NXT_SET_ASYNC_CONFIG ||
> +        raw == OFPRAW_OFPT13_GET_ASYNC_REPLY) {
> +        const struct nx_async_config *msg = ofpmsg_body(oh);
> +
> +        *ac = OFPUTIL_ASYNC_CFG_INIT;
> +        decode_legacy_async_masks(msg->packet_in_mask, OAM_PACKET_IN,
> +                                  oh->version, ac);
> +        decode_legacy_async_masks(msg->port_status_mask, OAM_PORT_STATUS,
> +                                  oh->version, ac);
> +        decode_legacy_async_masks(msg->flow_removed_mask,
> OAM_FLOW_REMOVED,
> +                                  oh->version, ac);
> +    } else if (raw == OFPRAW_OFPT14_SET_ASYNC ||
> +               raw == OFPRAW_OFPT14_GET_ASYNC_REPLY ||
> +               raw == OFPRAW_NXT_SET_ASYNC_CONFIG2) {
> +        *ac = *basis;
> +        while (b.size > 0) {
> +            struct ofpbuf property;
> +            enum ofperr error;
> +            uint64_t type;
> +
> +            error = ofpprop_pull__(&b, &property, 8, 0xfffe, &type);
> +            if (error) {
> +                return error;
> +            }
> +
> +            const struct ofp14_async_prop *ap
> +                = get_ofp14_async_config_prop_by_prop_type(type);
> +            error = (ap
> +                     ? parse_async_tlv(&property, ap, ac, oh->version,
> loose)
> +                     : OFPPROP_UNKNOWN(loose, "async config", type));
> +            if (error) {
> +                /* Most messages use OFPBPC_BAD_TYPE but async has its
> own (who
> +                 * knows why, it's OpenFlow. */
> +                if (error == OFPERR_OFPBPC_BAD_TYPE) {
> +                    error = OFPERR_OFPACFC_UNSUPPORTED;
> +                }
> +                return error;
> +            }
> +        }
> +    } else {
> +        return OFPERR_OFPBRC_BAD_VERSION;
> +    }
> +    return 0;
> +}
> +
> +static void
> +encode_legacy_async_masks(const struct ofputil_async_cfg *ac,
> +                          enum ofputil_async_msg_type oam,
> +                          enum ofp_version version,
> +                          ovs_be32 masks[2])
> +{
> +    for (int i = 0; i < 2; i++) {
> +        bool master = i == 0;
> +        const struct ofp14_async_prop *ap
> +            = get_ofp14_async_config_prop_by_oam(oam, master);
> +        masks[i] = encode_async_mask(ac, ap, version);
> +    }
> +}
> +
> +static void
> +ofputil_put_async_config__(const struct ofputil_async_cfg *ac,
> +                           struct ofpbuf *buf, bool tlv,
> +                           enum ofp_version version, uint32_t oams)
> +{
> +    if (!tlv) {
> +        struct nx_async_config *msg = ofpbuf_put_zeros(buf, sizeof *msg);
> +        encode_legacy_async_masks(ac, OAM_PACKET_IN, version,
> +                                  msg->packet_in_mask);
> +        encode_legacy_async_masks(ac, OAM_PORT_STATUS, version,
> +                                  msg->port_status_mask);
> +        encode_legacy_async_masks(ac, OAM_FLOW_REMOVED, version,
> +                                  msg->flow_removed_mask);
> +    } else {
> +        FOR_EACH_ASYNC_PROP (ap) {
> +            if (oams & (1u << ap->oam)) {
> +                size_t ofs = buf->size;
> +                ofpprop_put_be32(buf, ap->prop_type,
> +                                 encode_async_mask(ac, ap, version));
> +
> +                /* For experimenter properties, we need to use type
> 0xfffe for
> +                 * master and 0xffff for slaves. */
> +                if (ofpprop_is_experimenter(ap->prop_type)) {
> +                    struct ofp_prop_experimenter *ope
> +                        = ofpbuf_at_assert(buf, ofs, sizeof *ope);
> +                    ope->type = ap->master ? htons(0xffff) :
> htons(0xfffe);
> +                }
> +            }
> +        }
> +    }
> +}
> +
> +/* Encodes and returns a reply to the OFPT_GET_ASYNC_REQUEST in 'oh' that
> + * states that the asynchronous message configuration is 'ac'. */
> +struct ofpbuf *
> +ofputil_encode_get_async_reply(const struct ofp_header *oh,
> +                               const struct ofputil_async_cfg *ac)
> +{
> +    enum ofpraw raw = (oh->version < OFP14_VERSION
> +                       ? OFPRAW_OFPT13_GET_ASYNC_REPLY
> +                       : OFPRAW_OFPT14_GET_ASYNC_REPLY);
> +    struct ofpbuf *reply = ofpraw_alloc_reply(raw, oh, 0);
> +    ofputil_put_async_config__(ac, reply,
> +                               raw == OFPRAW_OFPT14_GET_ASYNC_REPLY,
> +                               oh->version, UINT32_MAX);
> +    return reply;
> +}
> +
> +/* Encodes and returns a message, in a format appropriate for OpenFlow
> version
> + * 'ofp_version', that sets the asynchronous message configuration to
> 'ac'.
> + *
> + * Specify 'oams' as a bitmap of OAM_* that indicate the asynchronous
> messages
> + * to configure.  OF1.0 through OF1.3 can't natively configure a subset of
> + * messages, so more messages than requested may be configured.  OF1.0
> through
> + * OF1.3 also can't configure OVS extension OAM_* values, so if 'oam'
> includes
> + * any extensions then this function encodes an Open vSwitch extension
> message
> + * that does support configuring OVS extension OAM_*. */
> +struct ofpbuf *
> +ofputil_encode_set_async_config(const struct ofputil_async_cfg *ac,
> +                                uint32_t oams, enum ofp_version
> ofp_version)
> +{
> +    enum ofpraw raw = (ofp_version >= OFP14_VERSION ?
> OFPRAW_OFPT14_SET_ASYNC
> +                       : oams & OAM_EXTENSIONS ?
> OFPRAW_NXT_SET_ASYNC_CONFIG2
> +                       : ofp_version >= OFP13_VERSION ?
> OFPRAW_OFPT13_SET_ASYNC
> +                       : OFPRAW_NXT_SET_ASYNC_CONFIG);
> +    struct ofpbuf *request = ofpraw_alloc(raw, ofp_version, 0);
> +    ofputil_put_async_config__(ac, request,
> +                               (raw == OFPRAW_OFPT14_SET_ASYNC ||
> +                                raw == OFPRAW_NXT_SET_ASYNC_CONFIG2),
> +                               ofp_version, oams);
> +    return request;
> +}
> +
> +struct ofputil_async_cfg
> +ofputil_async_cfg_default(enum ofp_version version)
> +{
> +    /* We enable all of the OF1.4 reasons regardless of 'version' because
> the
> +     * reasons added in OF1.4 just are just refinements of the OFPR_ACTION
> +     * introduced in OF1.0, breaking it into more specific categories.
> When we
> +     * encode these for earlier OpenFlow versions, we translate them into
> +     * OFPR_ACTION.  */
> +    uint32_t pin = OFPR14_BITS & ~(1u << OFPR_INVALID_TTL);
> +    pin |= 1u << OFPR_EXPLICIT_MISS;
> +    if (version <= OFP12_VERSION) {
> +        pin |= 1u << OFPR_IMPLICIT_MISS;
> +    }
> +
> +    struct ofputil_async_cfg oac = {
> +        .master[OAM_PACKET_IN] = pin,
> +        .master[OAM_PORT_STATUS] = OFPPR_BITS,
> +        .slave[OAM_PORT_STATUS] = OFPPR_BITS
> +    };
> +
> +    if (version >= OFP14_VERSION) {
> +        oac.master[OAM_FLOW_REMOVED] = OFPRR14_BITS;
> +    } else if (version == OFP13_VERSION) {
> +        oac.master[OAM_FLOW_REMOVED] = OFPRR13_BITS;
> +    } else {
> +        oac.master[OAM_FLOW_REMOVED] = OFPRR10_BITS;
> +    }
> +
> +    return oac;
> +}
> diff --git a/lib/ofp-ed-props.c b/lib/ofp-ed-props.c
> index d7bb72f35dbd..901da2f0dd1b 100644
> --- a/lib/ofp-ed-props.c
> +++ b/lib/ofp-ed-props.c
> @@ -19,7 +19,6 @@
>  #include <netinet/in.h>
>  #include <arpa/inet.h>
>  #include "openvswitch/ofp-ed-props.h"
> -#include "openvswitch/ofp-util.h"
>  #include "openvswitch/ofpbuf.h"
>  #include "openvswitch/ofp-parse.h"
>  #include "util.h"
> diff --git a/lib/ofp-errors.c b/lib/ofp-errors.c
> index 73930cc56dd0..bdae00c74958 100644
> --- a/lib/ofp-errors.c
> +++ b/lib/ofp-errors.c
> @@ -18,10 +18,10 @@
>  #include <errno.h>
>  #include "byte-order.h"
>  #include "openflow/openflow.h"
> +#include "openflow/nicira-ext.h"
>  #include "openvswitch/dynamic-string.h"
>  #include "openvswitch/ofp-errors.h"
>  #include "openvswitch/ofp-msgs.h"
> -#include "openvswitch/ofp-util.h"
>  #include "openvswitch/ofpbuf.h"
>  #include "openvswitch/vlog.h"
>  #include "util.h"
> diff --git a/lib/ofp-flow.c b/lib/ofp-flow.c
> new file mode 100644
> index 000000000000..8876b7be5eb1
> --- /dev/null
> +++ b/lib/ofp-flow.c
> @@ -0,0 +1,1622 @@
> +/*
> + * Copyright (c) 2008-2017 Nicira, Inc.
> + *
> + * Licensed under the Apache License, Version 2.0 (the "License");
> + * you may not use this file except in compliance with the License.
> + * You may obtain a copy of the License at:
> + *
> + *     http://www.apache.org/licenses/LICENSE-2.0
> + *
> + * Unless required by applicable law or agreed to in writing, software
> + * distributed under the License is distributed on an "AS IS" BASIS,
> + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
> implied.
> + * See the License for the specific language governing permissions and
> + * limitations under the License.
> + */
> +
> +#include <config.h>
> +#include "openvswitch/ofp-flow.h"
> +#include <errno.h>
> +#include "byte-order.h"
> +#include "flow.h"
> +#include "nx-match.h"
> +#include "openvswitch/ofp-actions.h"
> +#include "openvswitch/ofp-group.h"
> +#include "openvswitch/ofp-match.h"
> +#include "openvswitch/ofp-msgs.h"
> +#include "openvswitch/ofp-parse.h"
> +#include "openvswitch/ofp-port.h"
> +#include "openvswitch/ofp-table.h"
> +#include "openvswitch/ofpbuf.h"
> +#include "openvswitch/vlog.h"
> +#include "util.h"
> +
> +VLOG_DEFINE_THIS_MODULE(ofp_flow);
> +
> +static struct vlog_rate_limit rl = VLOG_RATE_LIMIT_INIT(1, 5);
> +
> +/* Returns an NXT_SET_FLOW_FORMAT message that can be used to set the flow
> + * format to 'nxff'.  */
> +struct ofpbuf *
> +ofputil_encode_nx_set_flow_format(enum nx_flow_format nxff)
> +{
> +    struct nx_set_flow_format *sff;
> +    struct ofpbuf *msg;
> +
> +    ovs_assert(ofputil_nx_flow_format_is_valid(nxff));
> +
> +    msg = ofpraw_alloc(OFPRAW_NXT_SET_FLOW_FORMAT, OFP10_VERSION, 0);
> +    sff = ofpbuf_put_zeros(msg, sizeof *sff);
> +    sff->format = htonl(nxff);
> +
> +    return msg;
> +}
> +
> +/* Returns the base protocol if 'flow_format' is a valid NXFF_* value,
> false
> + * otherwise. */
> +enum ofputil_protocol
> +ofputil_nx_flow_format_to_protocol(enum nx_flow_format flow_format)
> +{
> +    switch (flow_format) {
> +    case NXFF_OPENFLOW10:
> +        return OFPUTIL_P_OF10_STD;
> +
> +    case NXFF_NXM:
> +        return OFPUTIL_P_OF10_NXM;
> +
> +    default:
> +        return 0;
> +    }
> +}
> +
> +/* Returns true if 'flow_format' is a valid NXFF_* value, false
> otherwise. */
> +bool
> +ofputil_nx_flow_format_is_valid(enum nx_flow_format flow_format)
> +{
> +    return ofputil_nx_flow_format_to_protocol(flow_format) != 0;
> +}
> +
> +/* Returns a string version of 'flow_format', which must be a valid NXFF_*
> + * value. */
> +const char *
> +ofputil_nx_flow_format_to_string(enum nx_flow_format flow_format)
> +{
> +    switch (flow_format) {
> +    case NXFF_OPENFLOW10:
> +        return "openflow10";
> +    case NXFF_NXM:
> +        return "nxm";
> +    default:
> +        OVS_NOT_REACHED();
> +    }
> +}
> +
> +/* Returns an OpenFlow message that can be used to turn the
> flow_mod_table_id
> + * extension on or off (according to 'flow_mod_table_id'). */
> +struct ofpbuf *
> +ofputil_make_flow_mod_table_id(bool flow_mod_table_id)
> +{
> +    struct nx_flow_mod_table_id *nfmti;
> +    struct ofpbuf *msg;
> +
> +    msg = ofpraw_alloc(OFPRAW_NXT_FLOW_MOD_TABLE_ID, OFP10_VERSION, 0);
> +    nfmti = ofpbuf_put_zeros(msg, sizeof *nfmti);
> +    nfmti->set = flow_mod_table_id;
> +    return msg;
> +}
> +
> +struct ofputil_flow_mod_flag {
> +    uint16_t raw_flag;
> +    enum ofp_version min_version, max_version;
> +    enum ofputil_flow_mod_flags flag;
> +};
> +
> +static const struct ofputil_flow_mod_flag ofputil_flow_mod_flags[] = {
> +    { OFPFF_SEND_FLOW_REM,   OFP10_VERSION, 0, OFPUTIL_FF_SEND_FLOW_REM },
> +    { OFPFF_CHECK_OVERLAP,   OFP10_VERSION, 0, OFPUTIL_FF_CHECK_OVERLAP },
> +    { OFPFF10_EMERG,         OFP10_VERSION, OFP10_VERSION,
> +      OFPUTIL_FF_EMERG },
> +    { OFPFF12_RESET_COUNTS,  OFP12_VERSION, 0, OFPUTIL_FF_RESET_COUNTS },
> +    { OFPFF13_NO_PKT_COUNTS, OFP13_VERSION, 0, OFPUTIL_FF_NO_PKT_COUNTS },
> +    { OFPFF13_NO_BYT_COUNTS, OFP13_VERSION, 0, OFPUTIL_FF_NO_BYT_COUNTS },
> +    { 0, 0, 0, 0 },
> +};
> +
> +static enum ofperr
> +ofputil_decode_flow_mod_flags(ovs_be16 raw_flags_,
> +                              enum ofp_flow_mod_command command,
> +                              enum ofp_version version,
> +                              enum ofputil_flow_mod_flags *flagsp)
> +{
> +    uint16_t raw_flags = ntohs(raw_flags_);
> +    const struct ofputil_flow_mod_flag *f;
> +
> +    *flagsp = 0;
> +    for (f = ofputil_flow_mod_flags; f->raw_flag; f++) {
> +        if (raw_flags & f->raw_flag
> +            && version >= f->min_version
> +            && (!f->max_version || version <= f->max_version)) {
> +            raw_flags &= ~f->raw_flag;
> +            *flagsp |= f->flag;
> +        }
> +    }
> +
> +    /* In OF1.0 and OF1.1, "add" always resets counters, and other
> commands
> +     * never do.
> +     *
> +     * In OF1.2 and later, OFPFF12_RESET_COUNTS controls whether each
> command
> +     * resets counters. */
> +    if ((version == OFP10_VERSION || version == OFP11_VERSION)
> +        && command == OFPFC_ADD) {
> +        *flagsp |= OFPUTIL_FF_RESET_COUNTS;
> +    }
> +
> +    return raw_flags ? OFPERR_OFPFMFC_BAD_FLAGS : 0;
> +}
> +
> +static ovs_be16
> +ofputil_encode_flow_mod_flags(enum ofputil_flow_mod_flags flags,
> +                              enum ofp_version version)
> +{
> +    const struct ofputil_flow_mod_flag *f;
> +    uint16_t raw_flags;
> +
> +    raw_flags = 0;
> +    for (f = ofputil_flow_mod_flags; f->raw_flag; f++) {
> +        if (f->flag & flags
> +            && version >= f->min_version
> +            && (!f->max_version || version <= f->max_version)) {
> +            raw_flags |= f->raw_flag;
> +        }
> +    }
> +
> +    return htons(raw_flags);
> +}
> +
> +/* Converts an OFPT_FLOW_MOD or NXT_FLOW_MOD message 'oh' into an abstract
> + * flow_mod in 'fm'.  Returns 0 if successful, otherwise an OpenFlow error
> + * code.
> + *
> + * Uses 'ofpacts' to store the abstract OFPACT_* version of 'oh''s
> actions.
> + * The caller must initialize 'ofpacts' and retains ownership of it.
> + * 'fm->ofpacts' will point into the 'ofpacts' buffer.
> + *
> + * Does not validate the flow_mod actions.  The caller should do that,
> with
> + * ofpacts_check(). */
> +enum ofperr
> +ofputil_decode_flow_mod(struct ofputil_flow_mod *fm,
> +                        const struct ofp_header *oh,
> +                        enum ofputil_protocol protocol,
> +                        const struct tun_table *tun_table,
> +                        const struct vl_mff_map *vl_mff_map,
> +                        struct ofpbuf *ofpacts,
> +                        ofp_port_t max_port, uint8_t max_table)
> +{
> +    ovs_be16 raw_flags;
> +    enum ofperr error;
> +    struct ofpbuf b = ofpbuf_const_initializer(oh, ntohs(oh->length));
> +    enum ofpraw raw = ofpraw_pull_assert(&b);
> +    if (raw == OFPRAW_OFPT11_FLOW_MOD) {
> +        /* Standard OpenFlow 1.1+ flow_mod. */
> +        const struct ofp11_flow_mod *ofm;
> +
> +        ofm = ofpbuf_pull(&b, sizeof *ofm);
> +
> +        error = ofputil_pull_ofp11_match(&b, tun_table, vl_mff_map,
> &fm->match,
> +                                         NULL);
> +        if (error) {
> +            return error;
> +        }
> +
> +        /* Translate the message. */
> +        fm->priority = ntohs(ofm->priority);
> +        if (ofm->command == OFPFC_ADD
> +            || (oh->version == OFP11_VERSION
> +                && (ofm->command == OFPFC_MODIFY ||
> +                    ofm->command == OFPFC_MODIFY_STRICT)
> +                && ofm->cookie_mask == htonll(0))) {
> +            /* In OpenFlow 1.1 only, a "modify" or "modify-strict" that
> does
> +             * not match on the cookie is treated as an "add" if there is
> no
> +             * match. */
> +            fm->cookie = htonll(0);
> +            fm->cookie_mask = htonll(0);
> +            fm->new_cookie = ofm->cookie;
> +        } else {
> +            fm->cookie = ofm->cookie;
> +            fm->cookie_mask = ofm->cookie_mask;
> +            fm->new_cookie = OVS_BE64_MAX;
> +        }
> +        fm->modify_cookie = false;
> +        fm->command = ofm->command;
> +
> +        /* Get table ID.
> +         *
> +         * OF1.1 entirely forbids table_id == OFPTT_ALL.
> +         * OF1.2+ allows table_id == OFPTT_ALL only for deletes. */
> +        fm->table_id = ofm->table_id;
> +        if (fm->table_id == OFPTT_ALL
> +            && (oh->version == OFP11_VERSION
> +                || (ofm->command != OFPFC_DELETE &&
> +                    ofm->command != OFPFC_DELETE_STRICT))) {
> +            return OFPERR_OFPFMFC_BAD_TABLE_ID;
> +        }
> +
> +        fm->idle_timeout = ntohs(ofm->idle_timeout);
> +        fm->hard_timeout = ntohs(ofm->hard_timeout);
> +        if (oh->version >= OFP14_VERSION && ofm->command == OFPFC_ADD) {
> +            fm->importance = ntohs(ofm->importance);
> +        } else {
> +            fm->importance = 0;
> +        }
> +        fm->buffer_id = ntohl(ofm->buffer_id);
> +        error = ofputil_port_from_ofp11(ofm->out_port, &fm->out_port);
> +        if (error) {
> +            return error;
> +        }
> +
> +        fm->out_group = (ofm->command == OFPFC_DELETE ||
> +                         ofm->command == OFPFC_DELETE_STRICT
> +                         ? ntohl(ofm->out_group)
> +                         : OFPG_ANY);
> +        raw_flags = ofm->flags;
> +    } else {
> +        uint16_t command;
> +
> +        if (raw == OFPRAW_OFPT10_FLOW_MOD) {
> +            /* Standard OpenFlow 1.0 flow_mod. */
> +            const struct ofp10_flow_mod *ofm;
> +
> +            /* Get the ofp10_flow_mod. */
> +            ofm = ofpbuf_pull(&b, sizeof *ofm);
> +
> +            /* Translate the rule. */
> +            ofputil_match_from_ofp10_match(&ofm->match, &fm->match);
> +            ofputil_normalize_match(&fm->match);
> +
> +            /* OpenFlow 1.0 says that exact-match rules have to have the
> +             * highest possible priority. */
> +            fm->priority = (ofm->match.wildcards & htonl(OFPFW10_ALL)
> +                            ? ntohs(ofm->priority)
> +                            : UINT16_MAX);
> +
> +            /* Translate the message. */
> +            command = ntohs(ofm->command);
> +            fm->cookie = htonll(0);
> +            fm->cookie_mask = htonll(0);
> +            fm->new_cookie = ofm->cookie;
> +            fm->idle_timeout = ntohs(ofm->idle_timeout);
> +            fm->hard_timeout = ntohs(ofm->hard_timeout);
> +            fm->importance = 0;
> +            fm->buffer_id = ntohl(ofm->buffer_id);
> +            fm->out_port = u16_to_ofp(ntohs(ofm->out_port));
> +            fm->out_group = OFPG_ANY;
> +            raw_flags = ofm->flags;
> +        } else if (raw == OFPRAW_NXT_FLOW_MOD) {
> +            /* Nicira extended flow_mod. */
> +            const struct nx_flow_mod *nfm;
> +
> +            /* Dissect the message. */
> +            nfm = ofpbuf_pull(&b, sizeof *nfm);
> +            error = nx_pull_match(&b, ntohs(nfm->match_len),
> +                                  &fm->match, &fm->cookie,
> &fm->cookie_mask,
> +                                  false, tun_table, vl_mff_map);
> +            if (error) {
> +                return error;
> +            }
> +
> +            /* Translate the message. */
> +            command = ntohs(nfm->command);
> +            if ((command & 0xff) == OFPFC_ADD && fm->cookie_mask) {
> +                /* Flow additions may only set a new cookie, not match an
> +                 * existing cookie. */
> +                return OFPERR_NXBRC_NXM_INVALID;
> +            }
> +            fm->priority = ntohs(nfm->priority);
> +            fm->new_cookie = nfm->cookie;
> +            fm->idle_timeout = ntohs(nfm->idle_timeout);
> +            fm->hard_timeout = ntohs(nfm->hard_timeout);
> +            fm->importance = 0;
> +            fm->buffer_id = ntohl(nfm->buffer_id);
> +            fm->out_port = u16_to_ofp(ntohs(nfm->out_port));
> +            fm->out_group = OFPG_ANY;
> +            raw_flags = nfm->flags;
> +        } else {
> +            OVS_NOT_REACHED();
> +        }
> +
> +        fm->modify_cookie = fm->new_cookie != OVS_BE64_MAX;
> +        if (protocol & OFPUTIL_P_TID) {
> +            fm->command = command & 0xff;
> +            fm->table_id = command >> 8;
> +        } else {
> +            if (command > 0xff) {
> +                VLOG_WARN_RL(&rl, "flow_mod has explicit table_id "
> +                             "but flow_mod_table_id extension is not
> enabled");
> +            }
> +            fm->command = command;
> +            fm->table_id = 0xff;
> +        }
> +    }
> +
> +    /* Check for mismatched conntrack original direction tuple address
> fields
> +     * w.r.t. the IP version of the match. */
> +    if (((fm->match.wc.masks.ct_nw_src || fm->match.wc.masks.ct_nw_dst)
> +         && fm->match.flow.dl_type != htons(ETH_TYPE_IP))
> +        || ((ipv6_addr_is_set(&fm->match.wc.masks.ct_ipv6_src)
> +             || ipv6_addr_is_set(&fm->match.wc.masks.ct_ipv6_dst))
> +            && fm->match.flow.dl_type != htons(ETH_TYPE_IPV6))) {
> +        return OFPERR_OFPBAC_MATCH_INCONSISTENT;
> +    }
> +
> +    if (fm->command > OFPFC_DELETE_STRICT) {
> +        return OFPERR_OFPFMFC_BAD_COMMAND;
> +    }
> +
> +    fm->ofpacts_tlv_bitmap = 0;
> +    error = ofpacts_pull_openflow_instructions(&b, b.size, oh->version,
> +                                               vl_mff_map,
> +                                               &fm->ofpacts_tlv_bitmap,
> +                                               ofpacts);
> +    if (error) {
> +        return error;
> +    }
> +    fm->ofpacts = ofpacts->data;
> +    fm->ofpacts_len = ofpacts->size;
> +
> +    error = ofputil_decode_flow_mod_flags(raw_flags, fm->command,
> +                                          oh->version, &fm->flags);
> +    if (error) {
> +        return error;
> +    }
> +
> +    if (fm->flags & OFPUTIL_FF_EMERG) {
> +        /* We do not support the OpenFlow 1.0 emergency flow cache, which
> +         * is not required in OpenFlow 1.0.1 and removed from OpenFlow
> 1.1.
> +         *
> +         * OpenFlow 1.0 specifies the error code to use when idle_timeout
> +         * or hard_timeout is nonzero.  Otherwise, there is no good error
> +         * code, so just state that the flow table is full. */
> +        return (fm->hard_timeout || fm->idle_timeout
> +                ? OFPERR_OFPFMFC_BAD_EMERG_TIMEOUT
> +                : OFPERR_OFPFMFC_TABLE_FULL);
> +    }
> +
> +    return ofpacts_check_consistency(fm->ofpacts, fm->ofpacts_len,
> +                                     &fm->match, max_port,
> +                                     fm->table_id, max_table, protocol);
> +}
> +
> +static ovs_be16
> +ofputil_tid_command(const struct ofputil_flow_mod *fm,
> +                    enum ofputil_protocol protocol)
> +{
> +    return htons(protocol & OFPUTIL_P_TID
> +                 ? (fm->command & 0xff) | (fm->table_id << 8)
> +                 : fm->command);
> +}
> +
> +/* Converts 'fm' into an OFPT_FLOW_MOD or NXT_FLOW_MOD message according
> to
> + * 'protocol' and returns the message. */
> +struct ofpbuf *
> +ofputil_encode_flow_mod(const struct ofputil_flow_mod *fm,
> +                        enum ofputil_protocol protocol)
> +{
> +    enum ofp_version version = ofputil_protocol_to_ofp_version(protocol);
> +    ovs_be16 raw_flags = ofputil_encode_flow_mod_flags(fm->flags,
> version);
> +    struct ofpbuf *msg;
> +
> +    switch (protocol) {
> +    case OFPUTIL_P_OF11_STD:
> +    case OFPUTIL_P_OF12_OXM:
> +    case OFPUTIL_P_OF13_OXM:
> +    case OFPUTIL_P_OF14_OXM:
> +    case OFPUTIL_P_OF15_OXM:
> +    case OFPUTIL_P_OF16_OXM: {
> +        struct ofp11_flow_mod *ofm;
> +        int tailroom;
> +
> +        tailroom = ofputil_match_typical_len(protocol) + fm->ofpacts_len;
> +        msg = ofpraw_alloc(OFPRAW_OFPT11_FLOW_MOD, version, tailroom);
> +        ofm = ofpbuf_put_zeros(msg, sizeof *ofm);
> +        if ((protocol == OFPUTIL_P_OF11_STD
> +             && (fm->command == OFPFC_MODIFY ||
> +                 fm->command == OFPFC_MODIFY_STRICT)
> +             && fm->cookie_mask == htonll(0))
> +            || fm->command == OFPFC_ADD) {
> +            ofm->cookie = fm->new_cookie;
> +        } else {
> +            ofm->cookie = fm->cookie & fm->cookie_mask;
> +        }
> +        ofm->cookie_mask = fm->cookie_mask;
> +        if (fm->table_id != OFPTT_ALL
> +            || (protocol != OFPUTIL_P_OF11_STD
> +                && (fm->command == OFPFC_DELETE ||
> +                    fm->command == OFPFC_DELETE_STRICT))) {
> +            ofm->table_id = fm->table_id;
> +        } else {
> +            ofm->table_id = 0;
> +        }
> +        ofm->command = fm->command;
> +        ofm->idle_timeout = htons(fm->idle_timeout);
> +        ofm->hard_timeout = htons(fm->hard_timeout);
> +        ofm->priority = htons(fm->priority);
> +        ofm->buffer_id = htonl(fm->buffer_id);
> +        ofm->out_port = ofputil_port_to_ofp11(fm->out_port);
> +        ofm->out_group = htonl(fm->out_group);
> +        ofm->flags = raw_flags;
> +        if (version >= OFP14_VERSION && fm->command == OFPFC_ADD) {
> +            ofm->importance = htons(fm->importance);
> +        } else {
> +            ofm->importance = 0;
> +        }
> +        ofputil_put_ofp11_match(msg, &fm->match, protocol);
> +        ofpacts_put_openflow_instructions(fm->ofpacts, fm->ofpacts_len,
> msg,
> +                                          version);
> +        break;
> +    }
> +
> +    case OFPUTIL_P_OF10_STD:
> +    case OFPUTIL_P_OF10_STD_TID: {
> +        struct ofp10_flow_mod *ofm;
> +
> +        msg = ofpraw_alloc(OFPRAW_OFPT10_FLOW_MOD, OFP10_VERSION,
> +                           fm->ofpacts_len);
> +        ofm = ofpbuf_put_zeros(msg, sizeof *ofm);
> +        ofputil_match_to_ofp10_match(&fm->match, &ofm->match);
> +        ofm->cookie = fm->new_cookie;
> +        ofm->command = ofputil_tid_command(fm, protocol);
> +        ofm->idle_timeout = htons(fm->idle_timeout);
> +        ofm->hard_timeout = htons(fm->hard_timeout);
> +        ofm->priority = htons(fm->priority);
> +        ofm->buffer_id = htonl(fm->buffer_id);
> +        ofm->out_port = htons(ofp_to_u16(fm->out_port));
> +        ofm->flags = raw_flags;
> +        ofpacts_put_openflow_actions(fm->ofpacts, fm->ofpacts_len, msg,
> +                                     version);
> +        break;
> +    }
> +
> +    case OFPUTIL_P_OF10_NXM:
> +    case OFPUTIL_P_OF10_NXM_TID: {
> +        struct nx_flow_mod *nfm;
> +        int match_len;
> +
> +        msg = ofpraw_alloc(OFPRAW_NXT_FLOW_MOD, OFP10_VERSION,
> +                           NXM_TYPICAL_LEN + fm->ofpacts_len);
> +        nfm = ofpbuf_put_zeros(msg, sizeof *nfm);
> +        nfm->command = ofputil_tid_command(fm, protocol);
> +        nfm->cookie = fm->new_cookie;
> +        match_len = nx_put_match(msg, &fm->match, fm->cookie,
> fm->cookie_mask);
> +        nfm = msg->msg;
> +        nfm->idle_timeout = htons(fm->idle_timeout);
> +        nfm->hard_timeout = htons(fm->hard_timeout);
> +        nfm->priority = htons(fm->priority);
> +        nfm->buffer_id = htonl(fm->buffer_id);
> +        nfm->out_port = htons(ofp_to_u16(fm->out_port));
> +        nfm->flags = raw_flags;
> +        nfm->match_len = htons(match_len);
> +        ofpacts_put_openflow_actions(fm->ofpacts, fm->ofpacts_len, msg,
> +                                     version);
> +        break;
> +    }
> +
> +    default:
> +        OVS_NOT_REACHED();
> +    }
> +
> +    ofpmsg_update_length(msg);
> +    return msg;
> +}
> +
> +static enum ofperr
> +ofputil_decode_ofpst10_flow_request(struct ofputil_flow_stats_request
> *fsr,
> +                                    const struct ofp10_flow_stats_request
> *ofsr,
> +                                    bool aggregate)
> +{
> +    fsr->aggregate = aggregate;
> +    ofputil_match_from_ofp10_match(&ofsr->match, &fsr->match);
> +    fsr->out_port = u16_to_ofp(ntohs(ofsr->out_port));
> +    fsr->out_group = OFPG_ANY;
> +    fsr->table_id = ofsr->table_id;
> +    fsr->cookie = fsr->cookie_mask = htonll(0);
> +
> +    return 0;
> +}
> +
> +static enum ofperr
> +ofputil_decode_ofpst11_flow_request(struct ofputil_flow_stats_request
> *fsr,
> +                                    struct ofpbuf *b, bool aggregate,
> +                                    const struct tun_table *tun_table,
> +                                    const struct vl_mff_map *vl_mff_map)
> +{
> +    const struct ofp11_flow_stats_request *ofsr;
> +    enum ofperr error;
> +
> +    ofsr = ofpbuf_pull(b, sizeof *ofsr);
> +    fsr->aggregate = aggregate;
> +    fsr->table_id = ofsr->table_id;
> +    error = ofputil_port_from_ofp11(ofsr->out_port, &fsr->out_port);
> +    if (error) {
> +        return error;
> +    }
> +    fsr->out_group = ntohl(ofsr->out_group);
> +    fsr->cookie = ofsr->cookie;
> +    fsr->cookie_mask = ofsr->cookie_mask;
> +    error = ofputil_pull_ofp11_match(b, tun_table, vl_mff_map,
> &fsr->match,
> +                                     NULL);
> +    if (error) {
> +        return error;
> +    }
> +
> +    return 0;
> +}
> +
> +static enum ofperr
> +ofputil_decode_nxst_flow_request(struct ofputil_flow_stats_request *fsr,
> +                                 struct ofpbuf *b, bool aggregate,
> +                                 const struct tun_table *tun_table,
> +                                 const struct vl_mff_map *vl_mff_map)
> +{
> +    const struct nx_flow_stats_request *nfsr;
> +    enum ofperr error;
> +
> +    nfsr = ofpbuf_pull(b, sizeof *nfsr);
> +    error = nx_pull_match(b, ntohs(nfsr->match_len), &fsr->match,
> +                          &fsr->cookie, &fsr->cookie_mask, false,
> tun_table,
> +                          vl_mff_map);
> +    if (error) {
> +        return error;
> +    }
> +    if (b->size) {
> +        return OFPERR_OFPBRC_BAD_LEN;
> +    }
> +
> +    fsr->aggregate = aggregate;
> +    fsr->out_port = u16_to_ofp(ntohs(nfsr->out_port));
> +    fsr->out_group = OFPG_ANY;
> +    fsr->table_id = nfsr->table_id;
> +
> +    return 0;
> +}
> +
> +/* Converts an OFPST_FLOW, OFPST_AGGREGATE, NXST_FLOW, or NXST_AGGREGATE
> + * request 'oh', into an abstract flow_stats_request in 'fsr'.  Returns 0
> if
> + * successful, otherwise an OpenFlow error code.
> + *
> + * 'vl_mff_map' is an optional parameter that is used to validate the
> length
> + * of variable length mf_fields in 'match'. If it is not provided, the
> + * default mf_fields with maximum length will be used. */
> +enum ofperr
> +ofputil_decode_flow_stats_request(struct ofputil_flow_stats_request *fsr,
> +                                  const struct ofp_header *oh,
> +                                  const struct tun_table *tun_table,
> +                                  const struct vl_mff_map *vl_mff_map)
> +{
> +    struct ofpbuf b = ofpbuf_const_initializer(oh, ntohs(oh->length));
> +    enum ofpraw raw = ofpraw_pull_assert(&b);
> +    switch ((int) raw) {
> +    case OFPRAW_OFPST10_FLOW_REQUEST:
> +        return ofputil_decode_ofpst10_flow_request(fsr, b.data, false);
> +
> +    case OFPRAW_OFPST10_AGGREGATE_REQUEST:
> +        return ofputil_decode_ofpst10_flow_request(fsr, b.data, true);
> +
> +    case OFPRAW_OFPST11_FLOW_REQUEST:
> +        return ofputil_decode_ofpst11_flow_request(fsr, &b, false,
> tun_table,
> +                                                   vl_mff_map);
> +
> +    case OFPRAW_OFPST11_AGGREGATE_REQUEST:
> +        return ofputil_decode_ofpst11_flow_request(fsr, &b, true,
> tun_table,
> +                                                   vl_mff_map);
> +
> +    case OFPRAW_NXST_FLOW_REQUEST:
> +        return ofputil_decode_nxst_flow_request(fsr, &b, false,
> tun_table,
> +                                                vl_mff_map);
> +
> +    case OFPRAW_NXST_AGGREGATE_REQUEST:
> +        return ofputil_decode_nxst_flow_request(fsr, &b, true, tun_table,
> +                                                vl_mff_map);
> +
> +    default:
> +        /* Hey, the caller lied. */
> +        OVS_NOT_REACHED();
> +    }
> +}
> +
> +/* Converts abstract flow_stats_request 'fsr' into an OFPST_FLOW,
> + * OFPST_AGGREGATE, NXST_FLOW, or NXST_AGGREGATE request 'oh' according to
> + * 'protocol', and returns the message. */
> +struct ofpbuf *
> +ofputil_encode_flow_stats_request(const struct
> ofputil_flow_stats_request *fsr,
> +                                  enum ofputil_protocol protocol)
> +{
> +    struct ofpbuf *msg;
> +    enum ofpraw raw;
> +
> +    switch (protocol) {
> +    case OFPUTIL_P_OF11_STD:
> +    case OFPUTIL_P_OF12_OXM:
> +    case OFPUTIL_P_OF13_OXM:
> +    case OFPUTIL_P_OF14_OXM:
> +    case OFPUTIL_P_OF15_OXM:
> +    case OFPUTIL_P_OF16_OXM: {
> +        struct ofp11_flow_stats_request *ofsr;
> +
> +        raw = (fsr->aggregate
> +               ? OFPRAW_OFPST11_AGGREGATE_REQUEST
> +               : OFPRAW_OFPST11_FLOW_REQUEST);
> +        msg = ofpraw_alloc(raw, ofputil_protocol_to_ofp_
> version(protocol),
> +                           ofputil_match_typical_len(protocol));
> +        ofsr = ofpbuf_put_zeros(msg, sizeof *ofsr);
> +        ofsr->table_id = fsr->table_id;
> +        ofsr->out_port = ofputil_port_to_ofp11(fsr->out_port);
> +        ofsr->out_group = htonl(fsr->out_group);
> +        ofsr->cookie = fsr->cookie;
> +        ofsr->cookie_mask = fsr->cookie_mask;
> +        ofputil_put_ofp11_match(msg, &fsr->match, protocol);
> +        break;
> +    }
> +
> +    case OFPUTIL_P_OF10_STD:
> +    case OFPUTIL_P_OF10_STD_TID: {
> +        struct ofp10_flow_stats_request *ofsr;
> +
> +        raw = (fsr->aggregate
> +               ? OFPRAW_OFPST10_AGGREGATE_REQUEST
> +               : OFPRAW_OFPST10_FLOW_REQUEST);
> +        msg = ofpraw_alloc(raw, OFP10_VERSION, 0);
> +        ofsr = ofpbuf_put_zeros(msg, sizeof *ofsr);
> +        ofputil_match_to_ofp10_match(&fsr->match, &ofsr->match);
> +        ofsr->table_id = fsr->table_id;
> +        ofsr->out_port = htons(ofp_to_u16(fsr->out_port));
> +        break;
> +    }
> +
> +    case OFPUTIL_P_OF10_NXM:
> +    case OFPUTIL_P_OF10_NXM_TID: {
> +        struct nx_flow_stats_request *nfsr;
> +        int match_len;
> +
> +        raw = (fsr->aggregate
> +               ? OFPRAW_NXST_AGGREGATE_REQUEST
> +               : OFPRAW_NXST_FLOW_REQUEST);
> +        msg = ofpraw_alloc(raw, OFP10_VERSION, NXM_TYPICAL_LEN);
> +        ofpbuf_put_zeros(msg, sizeof *nfsr);
> +        match_len = nx_put_match(msg, &fsr->match,
> +                                 fsr->cookie, fsr->cookie_mask);
> +
> +        nfsr = msg->msg;
> +        nfsr->out_port = htons(ofp_to_u16(fsr->out_port));
> +        nfsr->match_len = htons(match_len);
> +        nfsr->table_id = fsr->table_id;
> +        break;
> +    }
> +
> +    default:
> +        OVS_NOT_REACHED();
> +    }
> +
> +    return msg;
> +}
> +
> +char * OVS_WARN_UNUSED_RESULT
> +parse_ofp_flow_stats_request_str(struct ofputil_flow_stats_request *fsr,
> +                                 bool aggregate, const char *string,
> +                                 const struct ofputil_port_map *port_map,
> +                                 const struct ofputil_table_map
> *table_map,
> +                                 enum ofputil_protocol *usable_protocols)
> +{
> +    struct ofputil_flow_mod fm;
> +    char *error;
> +
> +    error = parse_ofp_str(&fm, -1, string, port_map, table_map,
> +                          usable_protocols);
> +    if (error) {
> +        return error;
> +    }
> +
> +    /* Special table ID support not required for stats requests. */
> +    if (*usable_protocols & OFPUTIL_P_OF10_STD_TID) {
> +        *usable_protocols |= OFPUTIL_P_OF10_STD;
> +    }
> +    if (*usable_protocols & OFPUTIL_P_OF10_NXM_TID) {
> +        *usable_protocols |= OFPUTIL_P_OF10_NXM;
> +    }
> +
> +    fsr->aggregate = aggregate;
> +    fsr->cookie = fm.cookie;
> +    fsr->cookie_mask = fm.cookie_mask;
> +    fsr->match = fm.match;
> +    fsr->out_port = fm.out_port;
> +    fsr->out_group = fm.out_group;
> +    fsr->table_id = fm.table_id;
> +    return NULL;
> +}
> +
> +/* Converts an OFPST_FLOW or NXST_FLOW reply in 'msg' into an abstract
> + * ofputil_flow_stats in 'fs'.
> + *
> + * Multiple OFPST_FLOW or NXST_FLOW replies can be packed into a single
> + * OpenFlow message.  Calling this function multiple times for a single
> 'msg'
> + * iterates through the replies.  The caller must initially leave 'msg''s
> layer
> + * pointers null and not modify them between calls.
> + *
> + * Most switches don't send the values needed to populate fs->idle_age and
> + * fs->hard_age, so those members will usually be set to 0.  If the
> switch from
> + * which 'msg' originated is known to implement NXT_FLOW_AGE, then pass
> + * 'flow_age_extension' as true so that the contents of 'msg' determine
> the
> + * 'idle_age' and 'hard_age' members in 'fs'.
> + *
> + * Uses 'ofpacts' to store the abstract OFPACT_* version of the flow stats
> + * reply's actions.  The caller must initialize 'ofpacts' and retains
> ownership
> + * of it.  'fs->ofpacts' will point into the 'ofpacts' buffer.
> + *
> + * Returns 0 if successful, EOF if no replies were left in this 'msg',
> + * otherwise a positive errno value. */
> +int
> +ofputil_decode_flow_stats_reply(struct ofputil_flow_stats *fs,
> +                                struct ofpbuf *msg,
> +                                bool flow_age_extension,
> +                                struct ofpbuf *ofpacts)
> +{
> +    const struct ofp_header *oh;
> +    size_t instructions_len;
> +    enum ofperr error;
> +    enum ofpraw raw;
> +
> +    error = (msg->header ? ofpraw_decode(&raw, msg->header)
> +             : ofpraw_pull(&raw, msg));
> +    if (error) {
> +        return error;
> +    }
> +    oh = msg->header;
> +
> +    if (!msg->size) {
> +        return EOF;
> +    } else if (raw == OFPRAW_OFPST11_FLOW_REPLY
> +               || raw == OFPRAW_OFPST13_FLOW_REPLY) {
> +        const struct ofp11_flow_stats *ofs;
> +        size_t length;
> +        uint16_t padded_match_len;
> +
> +        ofs = ofpbuf_try_pull(msg, sizeof *ofs);
> +        if (!ofs) {
> +            VLOG_WARN_RL(&rl, "OFPST_FLOW reply has %"PRIu32" leftover "
> +                         "bytes at end", msg->size);
> +            return EINVAL;
> +        }
> +
> +        length = ntohs(ofs->length);
> +        if (length < sizeof *ofs) {
> +            VLOG_WARN_RL(&rl, "OFPST_FLOW reply claims invalid "
> +                         "length %"PRIuSIZE, length);
> +            return EINVAL;
> +        }
> +
> +        if (ofputil_pull_ofp11_match(msg, NULL, NULL, &fs->match,
> +                                     &padded_match_len)) {
> +            VLOG_WARN_RL(&rl, "OFPST_FLOW reply bad match");
> +            return EINVAL;
> +        }
> +        instructions_len = length - sizeof *ofs - padded_match_len;
> +
> +        fs->priority = ntohs(ofs->priority);
> +        fs->table_id = ofs->table_id;
> +        fs->duration_sec = ntohl(ofs->duration_sec);
> +        fs->duration_nsec = ntohl(ofs->duration_nsec);
> +        fs->idle_timeout = ntohs(ofs->idle_timeout);
> +        fs->hard_timeout = ntohs(ofs->hard_timeout);
> +        if (oh->version >= OFP14_VERSION) {
> +            fs->importance = ntohs(ofs->importance);
> +        } else {
> +            fs->importance = 0;
> +        }
> +        if (raw == OFPRAW_OFPST13_FLOW_REPLY) {
> +            error = ofputil_decode_flow_mod_flags(ofs->flags, -1,
> oh->version,
> +                                                  &fs->flags);
> +            if (error) {
> +                return error;
> +            }
> +        } else {
> +            fs->flags = 0;
> +        }
> +        fs->idle_age = -1;
> +        fs->hard_age = -1;
> +        fs->cookie = ofs->cookie;
> +        fs->packet_count = ntohll(ofs->packet_count);
> +        fs->byte_count = ntohll(ofs->byte_count);
> +    } else if (raw == OFPRAW_OFPST10_FLOW_REPLY) {
> +        const struct ofp10_flow_stats *ofs;
> +        size_t length;
> +
> +        ofs = ofpbuf_try_pull(msg, sizeof *ofs);
> +        if (!ofs) {
> +            VLOG_WARN_RL(&rl, "OFPST_FLOW reply has %"PRIu32" leftover "
> +                         "bytes at end", msg->size);
> +            return EINVAL;
> +        }
> +
> +        length = ntohs(ofs->length);
> +        if (length < sizeof *ofs) {
> +            VLOG_WARN_RL(&rl, "OFPST_FLOW reply claims invalid "
> +                         "length %"PRIuSIZE, length);
> +            return EINVAL;
> +        }
> +        instructions_len = length - sizeof *ofs;
> +
> +        fs->cookie = get_32aligned_be64(&ofs->cookie);
> +        ofputil_match_from_ofp10_match(&ofs->match, &fs->match);
> +        fs->priority = ntohs(ofs->priority);
> +        fs->table_id = ofs->table_id;
> +        fs->duration_sec = ntohl(ofs->duration_sec);
> +        fs->duration_nsec = ntohl(ofs->duration_nsec);
> +        fs->idle_timeout = ntohs(ofs->idle_timeout);
> +        fs->hard_timeout = ntohs(ofs->hard_timeout);
> +        fs->importance = 0;
> +        fs->idle_age = -1;
> +        fs->hard_age = -1;
> +        fs->packet_count = ntohll(get_32aligned_be64(&
> ofs->packet_count));
> +        fs->byte_count = ntohll(get_32aligned_be64(&ofs->byte_count));
> +        fs->flags = 0;
> +    } else if (raw == OFPRAW_NXST_FLOW_REPLY) {
> +        const struct nx_flow_stats *nfs;
> +        size_t match_len, length;
> +
> +        nfs = ofpbuf_try_pull(msg, sizeof *nfs);
> +        if (!nfs) {
> +            VLOG_WARN_RL(&rl, "NXST_FLOW reply has %"PRIu32" leftover "
> +                         "bytes at end", msg->size);
> +            return EINVAL;
> +        }
> +
> +        length = ntohs(nfs->length);
> +        match_len = ntohs(nfs->match_len);
> +        if (length < sizeof *nfs + ROUND_UP(match_len, 8)) {
> +            VLOG_WARN_RL(&rl, "NXST_FLOW reply with match_len=%"PRIuSIZE"
> "
> +                         "claims invalid length %"PRIuSIZE, match_len,
> length);
> +            return EINVAL;
> +        }
> +        if (nx_pull_match(msg, match_len, &fs->match, NULL, NULL, false,
> NULL,
> +                          NULL)) {
> +            return EINVAL;
> +        }
> +        instructions_len = length - sizeof *nfs - ROUND_UP(match_len, 8);
> +
> +        fs->cookie = nfs->cookie;
> +        fs->table_id = nfs->table_id;
> +        fs->duration_sec = ntohl(nfs->duration_sec);
> +        fs->duration_nsec = ntohl(nfs->duration_nsec);
> +        fs->priority = ntohs(nfs->priority);
> +        fs->idle_timeout = ntohs(nfs->idle_timeout);
> +        fs->hard_timeout = ntohs(nfs->hard_timeout);
> +        fs->importance = 0;
> +        fs->idle_age = -1;
> +        fs->hard_age = -1;
> +        if (flow_age_extension) {
> +            if (nfs->idle_age) {
> +                fs->idle_age = ntohs(nfs->idle_age) - 1;
> +            }
> +            if (nfs->hard_age) {
> +                fs->hard_age = ntohs(nfs->hard_age) - 1;
> +            }
> +        }
> +        fs->packet_count = ntohll(nfs->packet_count);
> +        fs->byte_count = ntohll(nfs->byte_count);
> +        fs->flags = 0;
> +    } else {
> +        OVS_NOT_REACHED();
> +    }
> +
> +    if (ofpacts_pull_openflow_instructions(msg, instructions_len,
> oh->version,
> +                                           NULL, NULL, ofpacts)) {
> +        VLOG_WARN_RL(&rl, "OFPST_FLOW reply bad instructions");
> +        return EINVAL;
> +    }
> +    fs->ofpacts = ofpacts->data;
> +    fs->ofpacts_len = ofpacts->size;
> +
> +    return 0;
> +}
> +
> +/* Returns 'count' unchanged except that UINT64_MAX becomes 0.
> + *
> + * We use this in situations where OVS internally uses UINT64_MAX to mean
> + * "value unknown" but OpenFlow 1.0 does not define any unknown value. */
> +static uint64_t
> +unknown_to_zero(uint64_t count)
> +{
> +    return count != UINT64_MAX ? count : 0;
> +}
> +
> +/* Appends an OFPST_FLOW or NXST_FLOW reply that contains the data in
> 'fs' to
> + * those already present in the list of ofpbufs in 'replies'.  'replies'
> should
> + * have been initialized with ofpmp_init(). */
> +void
> +ofputil_append_flow_stats_reply(const struct ofputil_flow_stats *fs,
> +                                struct ovs_list *replies,
> +                                const struct tun_table *tun_table)
> +{
> +    struct ofputil_flow_stats *fs_ = CONST_CAST(struct ofputil_flow_stats
> *,
> +                                                fs);
> +    const struct tun_table *orig_tun_table;
> +    struct ofpbuf *reply = ofpbuf_from_list(ovs_list_back(replies));
> +    size_t start_ofs = reply->size;
> +    enum ofp_version version = ofpmp_version(replies);
> +    enum ofpraw raw = ofpmp_decode_raw(replies);
> +
> +    orig_tun_table = fs->match.flow.tunnel.metadata.tab;
> +    fs_->match.flow.tunnel.metadata.tab = tun_table;
> +
> +    if (raw == OFPRAW_OFPST11_FLOW_REPLY || raw ==
> OFPRAW_OFPST13_FLOW_REPLY) {
> +        struct ofp11_flow_stats *ofs;
> +
> +        ofpbuf_put_uninit(reply, sizeof *ofs);
> +        oxm_put_match(reply, &fs->match, version);
> +        ofpacts_put_openflow_instructions(fs->ofpacts, fs->ofpacts_len,
> reply,
> +                                          version);
> +
> +        ofs = ofpbuf_at_assert(reply, start_ofs, sizeof *ofs);
> +        ofs->length = htons(reply->size - start_ofs);
> +        ofs->table_id = fs->table_id;
> +        ofs->pad = 0;
> +        ofs->duration_sec = htonl(fs->duration_sec);
> +        ofs->duration_nsec = htonl(fs->duration_nsec);
> +        ofs->priority = htons(fs->priority);
> +        ofs->idle_timeout = htons(fs->idle_timeout);
> +        ofs->hard_timeout = htons(fs->hard_timeout);
> +        if (version >= OFP14_VERSION) {
> +            ofs->importance = htons(fs->importance);
> +        } else {
> +            ofs->importance = 0;
> +        }
> +        if (raw == OFPRAW_OFPST13_FLOW_REPLY) {
> +            ofs->flags = ofputil_encode_flow_mod_flags(fs->flags,
> version);
> +        } else {
> +            ofs->flags = 0;
> +        }
> +        memset(ofs->pad2, 0, sizeof ofs->pad2);
> +        ofs->cookie = fs->cookie;
> +        ofs->packet_count = htonll(unknown_to_zero(fs->packet_count));
> +        ofs->byte_count = htonll(unknown_to_zero(fs->byte_count));
> +    } else if (raw == OFPRAW_OFPST10_FLOW_REPLY) {
> +        struct ofp10_flow_stats *ofs;
> +
> +        ofpbuf_put_uninit(reply, sizeof *ofs);
> +        ofpacts_put_openflow_actions(fs->ofpacts, fs->ofpacts_len, reply,
> +                                     version);
> +        ofs = ofpbuf_at_assert(reply, start_ofs, sizeof *ofs);
> +        ofs->length = htons(reply->size - start_ofs);
> +        ofs->table_id = fs->table_id;
> +        ofs->pad = 0;
> +        ofputil_match_to_ofp10_match(&fs->match, &ofs->match);
> +        ofs->duration_sec = htonl(fs->duration_sec);
> +        ofs->duration_nsec = htonl(fs->duration_nsec);
> +        ofs->priority = htons(fs->priority);
> +        ofs->idle_timeout = htons(fs->idle_timeout);
> +        ofs->hard_timeout = htons(fs->hard_timeout);
> +        memset(ofs->pad2, 0, sizeof ofs->pad2);
> +        put_32aligned_be64(&ofs->cookie, fs->cookie);
> +        put_32aligned_be64(&ofs->packet_count,
> +                           htonll(unknown_to_zero(fs->packet_count)));
> +        put_32aligned_be64(&ofs->byte_count,
> +                           htonll(unknown_to_zero(fs->byte_count)));
> +    } else if (raw == OFPRAW_NXST_FLOW_REPLY) {
> +        struct nx_flow_stats *nfs;
> +        int match_len;
> +
> +        ofpbuf_put_uninit(reply, sizeof *nfs);
> +        match_len = nx_put_match(reply, &fs->match, 0, 0);
> +        ofpacts_put_openflow_actions(fs->ofpacts, fs->ofpacts_len, reply,
> +                                     version);
> +        nfs = ofpbuf_at_assert(reply, start_ofs, sizeof *nfs);
> +        nfs->length = htons(reply->size - start_ofs);
> +        nfs->table_id = fs->table_id;
> +        nfs->pad = 0;
> +        nfs->duration_sec = htonl(fs->duration_sec);
> +        nfs->duration_nsec = htonl(fs->duration_nsec);
> +        nfs->priority = htons(fs->priority);
> +        nfs->idle_timeout = htons(fs->idle_timeout);
> +        nfs->hard_timeout = htons(fs->hard_timeout);
> +        nfs->idle_age = htons(fs->idle_age < 0 ? 0
> +                              : fs->idle_age < UINT16_MAX ? fs->idle_age
> + 1
> +                              : UINT16_MAX);
> +        nfs->hard_age = htons(fs->hard_age < 0 ? 0
> +                              : fs->hard_age < UINT16_MAX ? fs->hard_age
> + 1
> +                              : UINT16_MAX);
> +        nfs->match_len = htons(match_len);
> +        nfs->cookie = fs->cookie;
> +        nfs->packet_count = htonll(fs->packet_count);
> +        nfs->byte_count = htonll(fs->byte_count);
> +    } else {
> +        OVS_NOT_REACHED();
> +    }
> +
> +    ofpmp_postappend(replies, start_ofs);
> +    fs_->match.flow.tunnel.metadata.tab = orig_tun_table;
> +}
> +
> +/* Converts abstract ofputil_aggregate_stats 'stats' into an
> OFPST_AGGREGATE or
> + * NXST_AGGREGATE reply matching 'request', and returns the message. */
> +struct ofpbuf *
> +ofputil_encode_aggregate_stats_reply(
> +    const struct ofputil_aggregate_stats *stats,
> +    const struct ofp_header *request)
> +{
> +    struct ofp_aggregate_stats_reply *asr;
> +    uint64_t packet_count;
> +    uint64_t byte_count;
> +    struct ofpbuf *msg;
> +    enum ofpraw raw;
> +
> +    ofpraw_decode(&raw, request);
> +    if (raw == OFPRAW_OFPST10_AGGREGATE_REQUEST) {
> +        packet_count = unknown_to_zero(stats->packet_count);
> +        byte_count = unknown_to_zero(stats->byte_count);
> +    } else {
> +        packet_count = stats->packet_count;
> +        byte_count = stats->byte_count;
> +    }
> +
> +    msg = ofpraw_alloc_stats_reply(request, 0);
> +    asr = ofpbuf_put_zeros(msg, sizeof *asr);
> +    put_32aligned_be64(&asr->packet_count, htonll(packet_count));
> +    put_32aligned_be64(&asr->byte_count, htonll(byte_count));
> +    asr->flow_count = htonl(stats->flow_count);
> +
> +    return msg;
> +}
> +
> +enum ofperr
> +ofputil_decode_aggregate_stats_reply(struct ofputil_aggregate_stats
> *stats,
> +                                     const struct ofp_header *reply)
> +{
> +    struct ofpbuf msg = ofpbuf_const_initializer(reply,
> ntohs(reply->length));
> +    ofpraw_pull_assert(&msg);
> +
> +    struct ofp_aggregate_stats_reply *asr = msg.msg;
> +    stats->packet_count = ntohll(get_32aligned_be64(&asr->packet_count));
> +    stats->byte_count = ntohll(get_32aligned_be64(&asr->byte_count));
> +    stats->flow_count = ntohl(asr->flow_count);
> +
> +    return 0;
> +}
> +
> +
> +/* Parses 'str_value' as the value of subfield 'name', and updates
> + * 'match' appropriately.  Restricts the set of usable protocols to ones
> + * supporting the parsed field.
> + *
> + * Returns NULL if successful, otherwise a malloc()'d string describing
> the
> + * error.  The caller is responsible for freeing the returned string. */
> +static char * OVS_WARN_UNUSED_RESULT
> +parse_subfield(const char *name, const char *str_value, struct match
> *match,
> +               enum ofputil_protocol *usable_protocols)
> +{
> +    struct mf_subfield sf;
> +    char *error;
> +
> +    error = mf_parse_subfield(&sf, name);
> +    if (!error) {
> +        union mf_value val;
> +        char *tail;
> +        if (parse_int_string(str_value, (uint8_t *)&val,
> sf.field->n_bytes,
> +                             &tail) || *tail != 0) {
> +            return xasprintf("%s: cannot parse integer value: %s", name,
> +                             str_value);
> +        }
> +        if (!bitwise_is_all_zeros(&val, sf.field->n_bytes, sf.n_bits,
> +                                  sf.field->n_bytes * 8 - sf.n_bits)) {
> +            struct ds ds;
> +
> +            ds_init(&ds);
> +            mf_format(sf.field, &val, NULL, NULL, &ds);
> +            error = xasprintf("%s: value %s does not fit into %d bits",
> +                              name, ds_cstr(&ds), sf.n_bits);
> +            ds_destroy(&ds);
> +            return error;
> +        }
> +
> +        const struct mf_field *field = sf.field;
> +        union mf_value value, mask;
> +        unsigned int size = field->n_bytes;
> +
> +        mf_get(field, match, &value, &mask);
> +        bitwise_copy(&val, size, 0, &value, size, sf.ofs, sf.n_bits);
> +        bitwise_one (               &mask,  size, sf.ofs, sf.n_bits);
> +        *usable_protocols &= mf_set(field, &value, &mask, match, &error);
> +
> +        match_add_ethernet_prereq(match, sf.field);
> +    }
> +    return error;
> +}
> +
> +static char * OVS_WARN_UNUSED_RESULT
> +parse_ofp_str__(struct ofputil_flow_mod *fm, int command, char *string,
> +                const struct ofputil_port_map *port_map,
> +                const struct ofputil_table_map *table_map,
> +                enum ofputil_protocol *usable_protocols)
> +{
> +    enum {
> +        F_OUT_PORT = 1 << 0,
> +        F_ACTIONS = 1 << 1,
> +        F_IMPORTANCE = 1 << 2,
> +        F_TIMEOUT = 1 << 3,
> +        F_PRIORITY = 1 << 4,
> +        F_FLAGS = 1 << 5,
> +    } fields;
> +    char *act_str = NULL;
> +    char *name, *value;
> +
> +    *usable_protocols = OFPUTIL_P_ANY;
> +
> +    if (command == -2) {
> +        size_t len;
> +
> +        string += strspn(string, " \t\r\n");   /* Skip white space. */
> +        len = strcspn(string, ", \t\r\n"); /* Get length of the first
> token. */
> +
> +        if (!strncmp(string, "add", len)) {
> +            command = OFPFC_ADD;
> +        } else if (!strncmp(string, "delete", len)) {
> +            command = OFPFC_DELETE;
> +        } else if (!strncmp(string, "delete_strict", len)) {
> +            command = OFPFC_DELETE_STRICT;
> +        } else if (!strncmp(string, "modify", len)) {
> +            command = OFPFC_MODIFY;
> +        } else if (!strncmp(string, "modify_strict", len)) {
> +            command = OFPFC_MODIFY_STRICT;
> +        } else {
> +            len = 0;
> +            command = OFPFC_ADD;
> +        }
> +        string += len;
> +    }
> +
> +    switch (command) {
> +    case -1:
> +        fields = F_OUT_PORT;
> +        break;
> +
> +    case OFPFC_ADD:
> +        fields = F_ACTIONS | F_TIMEOUT | F_PRIORITY | F_FLAGS |
> F_IMPORTANCE;
> +        break;
> +
> +    case OFPFC_DELETE:
> +        fields = F_OUT_PORT;
> +        break;
> +
> +    case OFPFC_DELETE_STRICT:
> +        fields = F_OUT_PORT | F_PRIORITY;
> +        break;
> +
> +    case OFPFC_MODIFY:
> +        fields = F_ACTIONS | F_TIMEOUT | F_PRIORITY | F_FLAGS;
> +        break;
> +
> +    case OFPFC_MODIFY_STRICT:
> +        fields = F_ACTIONS | F_TIMEOUT | F_PRIORITY | F_FLAGS;
> +        break;
> +
> +    default:
> +        OVS_NOT_REACHED();
> +    }
> +
> +    *fm = (struct ofputil_flow_mod) {
> +        .match = MATCH_CATCHALL_INITIALIZER,
> +        .priority = OFP_DEFAULT_PRIORITY,
> +        .table_id = 0xff,
> +        .command = command,
> +        .buffer_id = UINT32_MAX,
> +        .out_port = OFPP_ANY,
> +        .out_group = OFPG_ANY,
> +    };
> +    /* For modify, by default, don't update the cookie. */
> +    if (command == OFPFC_MODIFY || command == OFPFC_MODIFY_STRICT) {
> +        fm->new_cookie = OVS_BE64_MAX;
> +    }
> +
> +    if (fields & F_ACTIONS) {
> +        act_str = ofp_extract_actions(string);
> +        if (!act_str) {
> +            return xstrdup("must specify an action");
> +        }
> +    }
> +
> +    while (ofputil_parse_key_value(&string, &name, &value)) {
> +        const struct ofp_protocol *p;
> +        const struct mf_field *mf;
> +        char *error = NULL;
> +
> +        if (ofp_parse_protocol(name, &p)) {
> +            match_set_dl_type(&fm->match, htons(p->dl_type));
> +            if (p->nw_proto) {
> +                match_set_nw_proto(&fm->match, p->nw_proto);
> +            }
> +            match_set_default_packet_type(&fm->match);
> +        } else if (!strcmp(name, "eth")) {
> +            match_set_packet_type(&fm->match, htonl(PT_ETH));
> +        } else if (fields & F_FLAGS && !strcmp(name, "send_flow_rem")) {
> +            fm->flags |= OFPUTIL_FF_SEND_FLOW_REM;
> +        } else if (fields & F_FLAGS && !strcmp(name, "check_overlap")) {
> +            fm->flags |= OFPUTIL_FF_CHECK_OVERLAP;
> +        } else if (fields & F_FLAGS && !strcmp(name, "reset_counts")) {
> +            fm->flags |= OFPUTIL_FF_RESET_COUNTS;
> +            *usable_protocols &= OFPUTIL_P_OF12_UP;
> +        } else if (fields & F_FLAGS && !strcmp(name, "no_packet_counts"))
> {
> +            fm->flags |= OFPUTIL_FF_NO_PKT_COUNTS;
> +            *usable_protocols &= OFPUTIL_P_OF13_UP;
> +        } else if (fields & F_FLAGS && !strcmp(name, "no_byte_counts")) {
> +            fm->flags |= OFPUTIL_FF_NO_BYT_COUNTS;
> +            *usable_protocols &= OFPUTIL_P_OF13_UP;
> +        } else if (!strcmp(name, "no_readonly_table")
> +                   || !strcmp(name, "allow_hidden_fields")) {
> +             /* ignore these fields. */
> +        } else if ((mf = mf_from_name(name)) != NULL) {
> +            error = ofp_parse_field(mf, value, port_map,
> +                                    &fm->match, usable_protocols);
> +        } else if (strchr(name, '[')) {
> +            error = parse_subfield(name, value, &fm->match,
> usable_protocols);
> +        } else {
> +            if (!*value) {
> +                return xasprintf("field %s missing value", name);
> +            }
> +
> +            if (!strcmp(name, "table")) {
> +                if (!ofputil_table_from_string(value, table_map,
> +                                               &fm->table_id)) {
> +                    return xasprintf("unknown table \"%s\"", value);
> +                }
> +                if (fm->table_id != 0xff) {
> +                    *usable_protocols &= OFPUTIL_P_TID;
> +                }
> +            } else if (fields & F_OUT_PORT && !strcmp(name, "out_port")) {
> +                if (!ofputil_port_from_string(value, port_map,
> +                                              &fm->out_port)) {
> +                    error = xasprintf("%s is not a valid OpenFlow port",
> +                                      value);
> +                }
> +            } else if (fields & F_OUT_PORT && !strcmp(name, "out_group"))
> {
> +                *usable_protocols &= OFPUTIL_P_OF11_UP;
> +                if (!ofputil_group_from_string(value, &fm->out_group)) {
> +                    error = xasprintf("%s is not a valid OpenFlow group",
> +                                      value);
> +                }
> +            } else if (fields & F_PRIORITY && !strcmp(name, "priority")) {
> +                uint16_t priority = 0;
> +
> +                error = str_to_u16(value, name, &priority);
> +                fm->priority = priority;
> +            } else if (fields & F_TIMEOUT && !strcmp(name,
> "idle_timeout")) {
> +                error = str_to_u16(value, name, &fm->idle_timeout);
> +            } else if (fields & F_TIMEOUT && !strcmp(name,
> "hard_timeout")) {
> +                error = str_to_u16(value, name, &fm->hard_timeout);
> +            } else if (fields & F_IMPORTANCE && !strcmp(name,
> "importance")) {
> +                error = str_to_u16(value, name, &fm->importance);
> +            } else if (!strcmp(name, "cookie")) {
> +                char *mask = strchr(value, '/');
> +
> +                if (mask) {
> +                    /* A mask means we're searching for a cookie. */
> +                    if (command == OFPFC_ADD) {
> +                        return xstrdup("flow additions cannot use "
> +                                       "a cookie mask");
> +                    }
> +                    *mask = '\0';
> +                    error = str_to_be64(value, &fm->cookie);
> +                    if (error) {
> +                        return error;
> +                    }
> +                    error = str_to_be64(mask + 1, &fm->cookie_mask);
> +
> +                    /* Matching of the cookie is only supported through
> NXM or
> +                     * OF1.1+. */
> +                    if (fm->cookie_mask != htonll(0)) {
> +                        *usable_protocols &= OFPUTIL_P_NXM_OF11_UP;
> +                    }
> +                } else {
> +                    /* No mask means that the cookie is being set. */
> +                    if (command != OFPFC_ADD && command != OFPFC_MODIFY
> +                        && command != OFPFC_MODIFY_STRICT) {
> +                        return xstrdup("cannot set cookie");
> +                    }
> +                    error = str_to_be64(value, &fm->new_cookie);
> +                    fm->modify_cookie = true;
> +                }
> +            } else if (!strcmp(name, "duration")
> +                       || !strcmp(name, "n_packets")
> +                       || !strcmp(name, "n_bytes")
> +                       || !strcmp(name, "idle_age")
> +                       || !strcmp(name, "hard_age")) {
> +                /* Ignore these, so that users can feed the output of
> +                 * "ovs-ofctl dump-flows" back into commands that parse
> +                 * flows. */
> +            } else {
> +                error = xasprintf("unknown keyword %s", name);
> +            }
> +        }
> +
> +        if (error) {
> +            return error;
> +        }
> +    }
> +    /* Copy ethertype to flow->dl_type for matches on packet_type
> +     * (OFPHTN_ETHERTYPE, ethertype). */
> +    if (fm->match.wc.masks.packet_type == OVS_BE32_MAX &&
> +            pt_ns(fm->match.flow.packet_type) == OFPHTN_ETHERTYPE) {
> +        fm->match.flow.dl_type = pt_ns_type_be(fm->match.flow.
> packet_type);
> +    }
> +    /* Check for usable protocol interdependencies between match fields.
> */
> +    if (fm->match.flow.dl_type == htons(ETH_TYPE_IPV6)) {
> +        const struct flow_wildcards *wc = &fm->match.wc;
> +        /* Only NXM and OXM support matching L3 and L4 fields within IPv6.
> +         *
> +         * (IPv6 specific fields as well as arp_sha, arp_tha, nw_frag, and
> +         *  nw_ttl are covered elsewhere so they don't need to be
> included in
> +         *  this test too.)
> +         */
> +        if (wc->masks.nw_proto || wc->masks.nw_tos
> +            || wc->masks.tp_src || wc->masks.tp_dst) {
> +            *usable_protocols &= OFPUTIL_P_NXM_OXM_ANY;
> +        }
> +    }
> +    if (!fm->cookie_mask && fm->new_cookie == OVS_BE64_MAX
> +        && (command == OFPFC_MODIFY || command == OFPFC_MODIFY_STRICT)) {
> +        /* On modifies without a mask, we are supposed to add a flow if
> +         * one does not exist.  If a cookie wasn't been specified, use a
> +         * default of zero. */
> +        fm->new_cookie = htonll(0);
> +    }
> +    if (fields & F_ACTIONS) {
> +        enum ofputil_protocol action_usable_protocols;
> +        struct ofpbuf ofpacts;
> +        char *error;
> +
> +        ofpbuf_init(&ofpacts, 32);
> +        struct ofpact_parse_params pp = {
> +            .port_map = port_map,
> +            .table_map = table_map,
> +            .ofpacts = &ofpacts,
> +            .usable_protocols = &action_usable_protocols
> +        };
> +        error = ofpacts_parse_instructions(act_str, &pp);
> +        *usable_protocols &= action_usable_protocols;
> +        if (!error) {
> +            enum ofperr err;
> +
> +            err = ofpacts_check(ofpacts.data, ofpacts.size, &fm->match,
> +                                OFPP_MAX, fm->table_id, 255,
> usable_protocols);
> +            if (!err && !*usable_protocols) {
> +                err = OFPERR_OFPBAC_MATCH_INCONSISTENT;
> +            }
> +            if (err) {
> +                error = xasprintf("actions are invalid with specified
> match "
> +                                  "(%s)", ofperr_to_string(err));
> +            }
> +
> +        }
> +        if (error) {
> +            ofpbuf_uninit(&ofpacts);
> +            return error;
> +        }
> +
> +        fm->ofpacts_len = ofpacts.size;
> +        fm->ofpacts = ofpbuf_steal_data(&ofpacts);
> +    } else {
> +        fm->ofpacts_len = 0;
> +        fm->ofpacts = NULL;
> +    }
> +
> +    return NULL;
> +}
> +
> +/* Convert 'str_' (as described in the Flow Syntax section of the
> ovs-ofctl man
> + * page) into 'fm' for sending the specified flow_mod 'command' to a
> switch.
> + * Returns the set of usable protocols in '*usable_protocols'.
> + *
> + * To parse syntax for an OFPT_FLOW_MOD (or NXT_FLOW_MOD), use an OFPFC_*
> + * constant for 'command'.  To parse syntax for an OFPST_FLOW or
> + * OFPST_AGGREGATE (or NXST_FLOW or NXST_AGGREGATE), use -1 for 'command'.
> + *
> + * If 'command' is given as -2, 'str_' may begin with a command name
> ("add",
> + * "modify", "delete", "modify_strict", or "delete_strict").  A missing
> command
> + * name is treated as "add".
> + *
> + * Returns NULL if successful, otherwise a malloc()'d string describing
> the
> + * error.  The caller is responsible for freeing the returned string. */
> +char * OVS_WARN_UNUSED_RESULT
> +parse_ofp_str(struct ofputil_flow_mod *fm, int command, const char *str_,
> +              const struct ofputil_port_map *port_map,
> +              const struct ofputil_table_map *table_map,
> +              enum ofputil_protocol *usable_protocols)
> +{
> +    char *string = xstrdup(str_);
> +    char *error;
> +
> +    error = parse_ofp_str__(fm, command, string, port_map, table_map,
> +                            usable_protocols);
> +    if (error) {
> +        fm->ofpacts = NULL;
> +        fm->ofpacts_len = 0;
> +    }
> +
> +    free(string);
> +    return error;
> +}
> +
> +/* Opens file 'file_name' and reads each line as a flow_mod of the
> specified
> + * type (one of OFPFC_*).  Stores each flow_mod in '*fm', an array
> allocated
> + * on the caller's behalf, and the number of flow_mods in '*n_fms'.
> + *
> + * If 'command' is given as -2, each line may start with a command name
> + * ("add", "modify", "delete", "modify_strict", or "delete_strict").  A
> missing
> + * command name is treated as "add".
> + *
> + * Returns NULL if successful, otherwise a malloc()'d string describing
> the
> + * error.  The caller is responsible for freeing the returned string. */
> +char * OVS_WARN_UNUSED_RESULT
> +parse_ofp_flow_mod_file(const char *file_name,
> +                        const struct ofputil_port_map *port_map,
> +                        const struct ofputil_table_map *table_map,
> +                        int command,
> +                        struct ofputil_flow_mod **fms, size_t *n_fms,
> +                        enum ofputil_protocol *usable_protocols)
> +{
> +    size_t allocated_fms;
> +    int line_number;
> +    FILE *stream;
> +    struct ds s;
> +
> +    *usable_protocols = OFPUTIL_P_ANY;
> +
> +    *fms = NULL;
> +    *n_fms = 0;
> +
> +    stream = !strcmp(file_name, "-") ? stdin : fopen(file_name, "r");
> +    if (stream == NULL) {
> +        return xasprintf("%s: open failed (%s)",
> +                         file_name, ovs_strerror(errno));
> +    }
> +
> +    allocated_fms = *n_fms;
> +    ds_init(&s);
> +    line_number = 0;
> +    while (!ds_get_preprocessed_line(&s, stream, &line_number)) {
> +        char *error;
> +        enum ofputil_protocol usable;
> +
> +        if (*n_fms >= allocated_fms) {
> +            *fms = x2nrealloc(*fms, &allocated_fms, sizeof **fms);
> +        }
> +        error = parse_ofp_flow_mod_str(&(*fms)[*n_fms], ds_cstr(&s),
> port_map,
> +                                       table_map, command, &usable);
> +        if (error) {
> +            char *err_msg;
> +            size_t i;
> +
> +            for (i = 0; i < *n_fms; i++) {
> +                free(CONST_CAST(struct ofpact *, (*fms)[i].ofpacts));
> +            }
> +            free(*fms);
> +            *fms = NULL;
> +            *n_fms = 0;
> +
> +            ds_destroy(&s);
> +            if (stream != stdin) {
> +                fclose(stream);
> +            }
> +
> +            err_msg = xasprintf("%s:%d: %s", file_name, line_number,
> error);
> +            free(error);
> +            return err_msg;
> +        }
> +        *usable_protocols &= usable; /* Each line can narrow the set. */
> +        *n_fms += 1;
> +    }
> +
> +    ds_destroy(&s);
> +    if (stream != stdin) {
> +        fclose(stream);
> +    }
> +    return NULL;
> +}
> +
> +/* Parses a specification of a flow from 's' into 'flow'.  's' must take
> the
> + * form FIELD=VALUE[,FIELD=VALUE]... where each FIELD is the name of a
> + * mf_field.  Fields must be specified in a natural order for satisfying
> + * prerequisites. If 'wc' is specified, masks the field in 'wc' for each
> of the
> + * field specified in flow. If the map, 'names_portno' is specfied,
> converts
> + * the in_port name into port no while setting the 'flow'.
> + *
> + * Returns NULL on success, otherwise a malloc()'d string that explains
> the
> + * problem. */
> +char *
> +parse_ofp_exact_flow(struct flow *flow, struct flow_wildcards *wc,
> +                     const struct tun_table *tun_table, const char *s,
> +                     const struct ofputil_port_map *port_map)
> +{
> +    char *pos, *key, *value_s;
> +    char *error = NULL;
> +    char *copy;
> +
> +    memset(flow, 0, sizeof *flow);
> +    if (wc) {
> +        memset(wc, 0, sizeof *wc);
> +    }
> +    flow->tunnel.metadata.tab = tun_table;
> +
> +    pos = copy = xstrdup(s);
> +    while (ofputil_parse_key_value(&pos, &key, &value_s)) {
> +        const struct ofp_protocol *p;
> +        if (ofp_parse_protocol(key, &p)) {
> +            if (flow->dl_type) {
> +                error = xasprintf("%s: Ethernet type set multiple times",
> s);
> +                goto exit;
> +            }
> +            flow->dl_type = htons(p->dl_type);
> +            if (wc) {
> +                wc->masks.dl_type = OVS_BE16_MAX;
> +            }
> +
> +            if (p->nw_proto) {
> +                if (flow->nw_proto) {
> +                    error = xasprintf("%s: network protocol set "
> +                                      "multiple times", s);
> +                    goto exit;
> +                }
> +                flow->nw_proto = p->nw_proto;
> +                if (wc) {
> +                    wc->masks.nw_proto = UINT8_MAX;
> +                }
> +            }
> +        } else {
> +            const struct mf_field *mf;
> +            union mf_value value;
> +            char *field_error;
> +
> +            mf = mf_from_name(key);
> +            if (!mf) {
> +                error = xasprintf("%s: unknown field %s", s, key);
> +                goto exit;
> +            }
> +
> +            if (!mf_are_prereqs_ok(mf, flow, NULL)) {
> +                error = xasprintf("%s: prerequisites not met for setting
> %s",
> +                                  s, key);
> +                goto exit;
> +            }
> +
> +            if (mf_is_set(mf, flow)) {
> +                error = xasprintf("%s: field %s set multiple times", s,
> key);
> +                goto exit;
> +            }
> +
> +            field_error = mf_parse_value(mf, value_s, port_map, &value);
> +            if (field_error) {
> +                error = xasprintf("%s: bad value for %s (%s)",
> +                                  s, key, field_error);
> +                free(field_error);
> +                goto exit;
> +            }
> +
> +            mf_set_flow_value(mf, &value, flow);
> +            if (wc) {
> +                mf_mask_field(mf, wc);
> +            }
> +        }
> +    }
> +
> +    if (!flow->in_port.ofp_port) {
> +        flow->in_port.ofp_port = OFPP_NONE;
> +    }
> +
> +exit:
> +    free(copy);
> +
> +    if (error) {
> +        memset(flow, 0, sizeof *flow);
> +        if (wc) {
> +            memset(wc, 0, sizeof *wc);
> +        }
> +    }
> +    return error;
> +}
> diff --git a/lib/ofp-group.c b/lib/ofp-group.c
> new file mode 100644
> index 000000000000..780eb6e89630
> --- /dev/null
> +++ b/lib/ofp-group.c
> @@ -0,0 +1,2075 @@
> +/*
> + * Copyright (c) 2008-2017 Nicira, Inc.
> + *
> + * Licensed under the Apache License, Version 2.0 (the "License");
> + * you may not use this file except in compliance with the License.
> + * You may obtain a copy of the License at:
> + *
> + *     http://www.apache.org/licenses/LICENSE-2.0
> + *
> + * Unless required by applicable law or agreed to in writing, software
> + * distributed under the License is distributed on an "AS IS" BASIS,
> + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
> implied.
> + * See the License for the specific language governing permissions and
> + * limitations under the License.
> + */
> +
> +#include <config.h>
> +#include "openvswitch/ofp-group.h"
> +#include <errno.h>
> +#include "byte-order.h"
> +#include "id-pool.h"
> +#include "nx-match.h"
> +#include "openvswitch/ofp-actions.h"
> +#include "openvswitch/dynamic-string.h"
> +#include "openvswitch/ofp-msgs.h"
> +#include "openvswitch/ofp-parse.h"
> +#include "openvswitch/ofp-port.h"
> +#include "openvswitch/ofp-prop.h"
> +#include "openvswitch/ofpbuf.h"
> +#include "openvswitch/vlog.h"
> +#include "util.h"
> +
> +VLOG_DEFINE_THIS_MODULE(ofp_group);
> +
> +static struct vlog_rate_limit rl = VLOG_RATE_LIMIT_INIT(1, 5);
> +
> +/* Stores the group id represented by 's' into '*group_idp'.  's' may be
> an
> + * integer or, for reserved group IDs, the standard OpenFlow name for the
> group
> + * (either "ANY" or "ALL").
> + *
> + * Returns true if successful, false if 's' is not a valid OpenFlow group
> ID or
> + * name. */
> +bool
> +ofputil_group_from_string(const char *s, uint32_t *group_idp)
> +{
> +    if (!strcasecmp(s, "any")) {
> +        *group_idp = OFPG_ANY;
> +    } else if (!strcasecmp(s, "all")) {
> +        *group_idp = OFPG_ALL;
> +    } else if (!str_to_uint(s, 10, group_idp)) {
> +        VLOG_WARN("%s is not a valid group ID.  (Valid group IDs are "
> +                  "32-bit nonnegative integers or the keywords ANY or "
> +                  "ALL.)", s);
> +        return false;
> +    }
> +
> +    return true;
> +}
> +
> +/* Appends to 's' a string representation of the OpenFlow group ID
> 'group_id'.
> + * Most groups' string representation is just the number, but for special
> + * groups, e.g. OFPG_ALL, it is the name, e.g. "ALL". */
> +void
> +ofputil_format_group(uint32_t group_id, struct ds *s)
> +{
> +    char name[MAX_GROUP_NAME_LEN];
> +
> +    ofputil_group_to_string(group_id, name, sizeof name);
> +    ds_put_cstr(s, name);
> +}
> +
> +
> +/* Puts in the 'bufsize' byte in 'namebuf' a null-terminated string
> + * representation of OpenFlow group ID 'group_id'.  Most group are
> represented
> + * as just their number, but special groups, e.g. OFPG_ALL, are
> represented
> + * by name, e.g. "ALL". */
> +void
> +ofputil_group_to_string(uint32_t group_id,
> +                        char namebuf[MAX_GROUP_NAME_LEN + 1], size_t
> bufsize)
> +{
> +    switch (group_id) {
> +    case OFPG_ALL:
> +        ovs_strlcpy(namebuf, "ALL", bufsize);
> +        break;
> +
> +    case OFPG_ANY:
> +        ovs_strlcpy(namebuf, "ANY", bufsize);
> +        break;
> +
> +    default:
> +        snprintf(namebuf, bufsize, "%"PRIu32, group_id);
> +        break;
> +    }
> +}
> +
> +/* Frees all of the "struct ofputil_bucket"s in the 'buckets' list. */
> +void
> +ofputil_bucket_list_destroy(struct ovs_list *buckets)
> +{
> +    struct ofputil_bucket *bucket;
> +
> +    LIST_FOR_EACH_POP (bucket, list_node, buckets) {
> +        free(bucket->ofpacts);
> +        free(bucket);
> +    }
> +}
> +
> +/* Clones 'bucket' and its ofpacts data */
> +static struct ofputil_bucket *
> +ofputil_bucket_clone_data(const struct ofputil_bucket *bucket)
> +{
> +    struct ofputil_bucket *new;
> +
> +    new = xmemdup(bucket, sizeof *bucket);
> +    new->ofpacts = xmemdup(bucket->ofpacts, bucket->ofpacts_len);
> +
> +    return new;
> +}
> +
> +/* Clones each of the buckets in the list 'src' appending them
> + * in turn to 'dest' which should be an initialised list.
> + * An exception is that if the pointer value of a bucket in 'src'
> + * matches 'skip' then it is not cloned or appended to 'dest'.
> + * This allows all of 'src' or 'all of 'src' except 'skip' to
> + * be cloned and appended to 'dest'. */
> +void
> +ofputil_bucket_clone_list(struct ovs_list *dest, const struct ovs_list
> *src,
> +                          const struct ofputil_bucket *skip)
> +{
> +    struct ofputil_bucket *bucket;
> +
> +    LIST_FOR_EACH (bucket, list_node, src) {
> +        struct ofputil_bucket *new_bucket;
> +
> +        if (bucket == skip) {
> +            continue;
> +        }
> +
> +        new_bucket = ofputil_bucket_clone_data(bucket);
> +        ovs_list_push_back(dest, &new_bucket->list_node);
> +    }
> +}
> +
> +/* Find a bucket in the list 'buckets' whose bucket id is 'bucket_id'
> + * Returns the first bucket found or NULL if no buckets are found. */
> +struct ofputil_bucket *
> +ofputil_bucket_find(const struct ovs_list *buckets, uint32_t bucket_id)
> +{
> +    struct ofputil_bucket *bucket;
> +
> +    if (bucket_id > OFPG15_BUCKET_MAX) {
> +        return NULL;
> +    }
> +
> +    LIST_FOR_EACH (bucket, list_node, buckets) {
> +        if (bucket->bucket_id == bucket_id) {
> +            return bucket;
> +        }
> +    }
> +
> +    return NULL;
> +}
> +
> +/* Returns true if more than one bucket in the list 'buckets'
> + * have the same bucket id. Returns false otherwise. */
> +bool
> +ofputil_bucket_check_duplicate_id(const struct ovs_list *buckets)
> +{
> +    struct ofputil_bucket *i, *j;
> +
> +    LIST_FOR_EACH (i, list_node, buckets) {
> +        LIST_FOR_EACH_REVERSE (j, list_node, buckets) {
> +            if (i == j) {
> +                break;
> +            }
> +            if (i->bucket_id == j->bucket_id) {
> +                return true;
> +            }
> +        }
> +    }
> +
> +    return false;
> +}
> +
> +/* Returns the bucket at the front of the list 'buckets'.
> + * Undefined if 'buckets is empty. */
> +struct ofputil_bucket *
> +ofputil_bucket_list_front(const struct ovs_list *buckets)
> +{
> +    static struct ofputil_bucket *bucket;
> +
> +    ASSIGN_CONTAINER(bucket, ovs_list_front(buckets), list_node);
> +
> +    return bucket;
> +}
> +
> +/* Returns the bucket at the back of the list 'buckets'.
> + * Undefined if 'buckets is empty. */
> +struct ofputil_bucket *
> +ofputil_bucket_list_back(const struct ovs_list *buckets)
> +{
> +    static struct ofputil_bucket *bucket;
> +
> +    ASSIGN_CONTAINER(bucket, ovs_list_back(buckets), list_node);
> +
> +    return bucket;
> +}
> +
> +/* Returns an OpenFlow group stats request for OpenFlow version
> 'ofp_version',
> + * that requests stats for group 'group_id'.  (Use OFPG_ALL to request
> stats
> + * for all groups.)
> + *
> + * Group statistics include packet and byte counts for each group. */
> +struct ofpbuf *
> +ofputil_encode_group_stats_request(enum ofp_version ofp_version,
> +                                   uint32_t group_id)
> +{
> +    struct ofpbuf *request;
> +
> +    switch (ofp_version) {
> +    case OFP10_VERSION:
> +        ovs_fatal(0, "dump-group-stats needs OpenFlow 1.1 or later "
> +                     "(\'-O OpenFlow11\')");
> +    case OFP11_VERSION:
> +    case OFP12_VERSION:
> +    case OFP13_VERSION:
> +    case OFP14_VERSION:
> +    case OFP15_VERSION:
> +    case OFP16_VERSION: {
> +        struct ofp11_group_stats_request *req;
> +        request = ofpraw_alloc(OFPRAW_OFPST11_GROUP_REQUEST,
> ofp_version, 0);
> +        req = ofpbuf_put_zeros(request, sizeof *req);
> +        req->group_id = htonl(group_id);
> +        break;
> +    }
> +    default:
> +        OVS_NOT_REACHED();
> +    }
> +
> +    return request;
> +}
> +
> +void
> +ofputil_uninit_group_desc(struct ofputil_group_desc *gd)
> +{
> +    ofputil_bucket_list_destroy(&gd->buckets);
> +    ofputil_group_properties_destroy(&gd->props);
> +}
> +
> +/* Decodes the OpenFlow group description request in 'oh', returning the
> group
> + * whose description is requested, or OFPG_ALL if stats for all groups was
> + * requested. */
> +uint32_t
> +ofputil_decode_group_desc_request(const struct ofp_header *oh)
> +{
> +    struct ofpbuf request = ofpbuf_const_initializer(oh,
> ntohs(oh->length));
> +    enum ofpraw raw = ofpraw_pull_assert(&request);
> +    if (raw == OFPRAW_OFPST11_GROUP_DESC_REQUEST) {
> +        return OFPG_ALL;
> +    } else if (raw == OFPRAW_OFPST15_GROUP_DESC_REQUEST) {
> +        ovs_be32 *group_id = ofpbuf_pull(&request, sizeof *group_id);
> +        return ntohl(*group_id);
> +    } else {
> +        OVS_NOT_REACHED();
> +    }
> +}
> +
> +/* Returns an OpenFlow group description request for OpenFlow version
> + * 'ofp_version', that requests stats for group 'group_id'.  Use OFPG_ALL
> to
> + * request stats for all groups (OpenFlow 1.4 and earlier always request
> all
> + * groups).
> + *
> + * Group descriptions include the bucket and action configuration for each
> + * group. */
> +struct ofpbuf *
> +ofputil_encode_group_desc_request(enum ofp_version ofp_version,
> +                                  uint32_t group_id)
> +{
> +    struct ofpbuf *request;
> +
> +    switch (ofp_version) {
> +    case OFP10_VERSION:
> +        ovs_fatal(0, "dump-groups needs OpenFlow 1.1 or later "
> +                     "(\'-O OpenFlow11\')");
> +    case OFP11_VERSION:
> +    case OFP12_VERSION:
> +    case OFP13_VERSION:
> +    case OFP14_VERSION:
> +        request = ofpraw_alloc(OFPRAW_OFPST11_GROUP_DESC_REQUEST,
> +                               ofp_version, 0);
> +        break;
> +    case OFP15_VERSION:
> +    case OFP16_VERSION: {
> +        struct ofp15_group_desc_request *req;
> +        request = ofpraw_alloc(OFPRAW_OFPST15_GROUP_DESC_REQUEST,
> +                               ofp_version, 0);
> +        req = ofpbuf_put_zeros(request, sizeof *req);
> +        req->group_id = htonl(group_id);
> +        break;
> +    }
> +    default:
> +        OVS_NOT_REACHED();
> +    }
> +
> +    return request;
> +}
> +
> +static void
> +ofputil_group_bucket_counters_to_ofp11(const struct ofputil_group_stats
> *gs,
> +                                    struct ofp11_bucket_counter
> bucket_cnts[])
> +{
> +    int i;
> +
> +    for (i = 0; i < gs->n_buckets; i++) {
> +       bucket_cnts[i].packet_count = htonll(gs->bucket_stats[i].
> packet_count);
> +       bucket_cnts[i].byte_count = htonll(gs->bucket_stats[i].
> byte_count);
> +    }
> +}
> +
> +static void
> +ofputil_group_stats_to_ofp11(const struct ofputil_group_stats *gs,
> +                             struct ofp11_group_stats *gs11, size_t
> length,
> +                             struct ofp11_bucket_counter bucket_cnts[])
> +{
> +    memset(gs11, 0, sizeof *gs11);
> +    gs11->length = htons(length);
> +    gs11->group_id = htonl(gs->group_id);
> +    gs11->ref_count = htonl(gs->ref_count);
> +    gs11->packet_count = htonll(gs->packet_count);
> +    gs11->byte_count = htonll(gs->byte_count);
> +    ofputil_group_bucket_counters_to_ofp11(gs, bucket_cnts);
> +}
> +
> +static void
> +ofputil_group_stats_to_ofp13(const struct ofputil_group_stats *gs,
> +                             struct ofp13_group_stats *gs13, size_t
> length,
> +                             struct ofp11_bucket_counter bucket_cnts[])
> +{
> +    ofputil_group_stats_to_ofp11(gs, &gs13->gs, length, bucket_cnts);
> +    gs13->duration_sec = htonl(gs->duration_sec);
> +    gs13->duration_nsec = htonl(gs->duration_nsec);
> +
> +}
> +
> +/* Encodes 'gs' properly for the format of the list of group statistics
> + * replies already begun in 'replies' and appends it to the list.
> 'replies'
> + * must have originally been initialized with ofpmp_init(). */
> +void
> +ofputil_append_group_stats(struct ovs_list *replies,
> +                           const struct ofputil_group_stats *gs)
> +{
> +    size_t bucket_counter_size;
> +    struct ofp11_bucket_counter *bucket_counters;
> +    size_t length;
> +
> +    bucket_counter_size = gs->n_buckets * sizeof(struct
> ofp11_bucket_counter);
> +
> +    switch (ofpmp_version(replies)) {
> +    case OFP11_VERSION:
> +    case OFP12_VERSION:{
> +            struct ofp11_group_stats *gs11;
> +
> +            length = sizeof *gs11 + bucket_counter_size;
> +            gs11 = ofpmp_append(replies, length);
> +            bucket_counters = (struct ofp11_bucket_counter *)(gs11 + 1);
> +            ofputil_group_stats_to_ofp11(gs, gs11, length,
> bucket_counters);
> +            break;
> +        }
> +
> +    case OFP13_VERSION:
> +    case OFP14_VERSION:
> +    case OFP15_VERSION:
> +    case OFP16_VERSION: {
> +            struct ofp13_group_stats *gs13;
> +
> +            length = sizeof *gs13 + bucket_counter_size;
> +            gs13 = ofpmp_append(replies, length);
> +            bucket_counters = (struct ofp11_bucket_counter *)(gs13 + 1);
> +            ofputil_group_stats_to_ofp13(gs, gs13, length,
> bucket_counters);
> +            break;
> +        }
> +
> +    case OFP10_VERSION:
> +    default:
> +        OVS_NOT_REACHED();
> +    }
> +}
> +/* Returns an OpenFlow group features request for OpenFlow version
> + * 'ofp_version'. */
> +struct ofpbuf *
> +ofputil_encode_group_features_request(enum ofp_version ofp_version)
> +{
> +    struct ofpbuf *request = NULL;
> +
> +    switch (ofp_version) {
> +    case OFP10_VERSION:
> +    case OFP11_VERSION:
> +        ovs_fatal(0, "dump-group-features needs OpenFlow 1.2 or later "
> +                     "(\'-O OpenFlow12\')");
> +    case OFP12_VERSION:
> +    case OFP13_VERSION:
> +    case OFP14_VERSION:
> +    case OFP15_VERSION:
> +    case OFP16_VERSION:
> +        request = ofpraw_alloc(OFPRAW_OFPST12_GROUP_FEATURES_REQUEST,
> +                               ofp_version, 0);
> +        break;
> +    default:
> +        OVS_NOT_REACHED();
> +    }
> +
> +    return request;
> +}
> +
> +/* Returns a OpenFlow message that encodes 'features' properly as a reply
> to
> + * group features request 'request'. */
> +struct ofpbuf *
> +ofputil_encode_group_features_reply(
> +    const struct ofputil_group_features *features,
> +    const struct ofp_header *request)
> +{
> +    struct ofp12_group_features_stats *ogf;
> +    struct ofpbuf *reply;
> +    int i;
> +
> +    reply = ofpraw_alloc_xid(OFPRAW_OFPST12_GROUP_FEATURES_REPLY,
> +                             request->version, request->xid, 0);
> +    ogf = ofpbuf_put_zeros(reply, sizeof *ogf);
> +    ogf->types = htonl(features->types);
> +    ogf->capabilities = htonl(features->capabilities);
> +    for (i = 0; i < OFPGT12_N_TYPES; i++) {
> +        ogf->max_groups[i] = htonl(features->max_groups[i]);
> +        ogf->actions[i] = ofpact_bitmap_to_openflow(features->ofpacts[i],
> +                                                    request->version);
> +    }
> +
> +    return reply;
> +}
> +
> +/* Decodes group features reply 'oh' into 'features'. */
> +void
> +ofputil_decode_group_features_reply(const struct ofp_header *oh,
> +                                    struct ofputil_group_features
> *features)
> +{
> +    const struct ofp12_group_features_stats *ogf = ofpmsg_body(oh);
> +    int i;
> +
> +    features->types = ntohl(ogf->types);
> +    features->capabilities = ntohl(ogf->capabilities);
> +    for (i = 0; i < OFPGT12_N_TYPES; i++) {
> +        features->max_groups[i] = ntohl(ogf->max_groups[i]);
> +        features->ofpacts[i] = ofpact_bitmap_from_openflow(
> +            ogf->actions[i], oh->version);
> +    }
> +}
> +
> +/* Parse a group status request message into a 32 bit OpenFlow 1.1
> + * group ID and stores the latter in '*group_id'.
> + * Returns 0 if successful, otherwise an OFPERR_* number. */
> +enum ofperr
> +ofputil_decode_group_stats_request(const struct ofp_header *request,
> +                                   uint32_t *group_id)
> +{
> +    const struct ofp11_group_stats_request *gsr11 = ofpmsg_body(request);
> +    *group_id = ntohl(gsr11->group_id);
> +    return 0;
> +}
> +
> +/* Converts a group stats reply in 'msg' into an abstract
> ofputil_group_stats
> + * in 'gs'.  Assigns freshly allocated memory to gs->bucket_stats for the
> + * caller to eventually free.
> + *
> + * Multiple group stats replies can be packed into a single OpenFlow
> message.
> + * Calling this function multiple times for a single 'msg' iterates
> through the
> + * replies.  The caller must initially leave 'msg''s layer pointers null
> and
> + * not modify them between calls.
> + *
> + * Returns 0 if successful, EOF if no replies were left in this 'msg',
> + * otherwise a positive errno value. */
> +int
> +ofputil_decode_group_stats_reply(struct ofpbuf *msg,
> +                                 struct ofputil_group_stats *gs)
> +{
> +    struct ofp11_bucket_counter *obc;
> +    struct ofp11_group_stats *ogs11;
> +    enum ofpraw raw;
> +    enum ofperr error;
> +    size_t base_len;
> +    size_t length;
> +    size_t i;
> +
> +    gs->bucket_stats = NULL;
> +    error = (msg->header ? ofpraw_decode(&raw, msg->header)
> +             : ofpraw_pull(&raw, msg));
> +    if (error) {
> +        return error;
> +    }
> +
> +    if (!msg->size) {
> +        return EOF;
> +    }
> +
> +    if (raw == OFPRAW_OFPST11_GROUP_REPLY) {
> +        base_len = sizeof *ogs11;
> +        ogs11 = ofpbuf_try_pull(msg, sizeof *ogs11);
> +        gs->duration_sec = gs->duration_nsec = UINT32_MAX;
> +    } else if (raw == OFPRAW_OFPST13_GROUP_REPLY) {
> +        struct ofp13_group_stats *ogs13;
> +
> +        base_len = sizeof *ogs13;
> +        ogs13 = ofpbuf_try_pull(msg, sizeof *ogs13);
> +        if (ogs13) {
> +            ogs11 = &ogs13->gs;
> +            gs->duration_sec = ntohl(ogs13->duration_sec);
> +            gs->duration_nsec = ntohl(ogs13->duration_nsec);
> +        } else {
> +            ogs11 = NULL;
> +        }
> +    } else {
> +        OVS_NOT_REACHED();
> +    }
> +
> +    if (!ogs11) {
> +        VLOG_WARN_RL(&rl, "%s reply has %"PRIu32" leftover bytes at end",
> +                     ofpraw_get_name(raw), msg->size);
> +        return OFPERR_OFPBRC_BAD_LEN;
> +    }
> +    length = ntohs(ogs11->length);
> +    if (length < sizeof base_len) {
> +        VLOG_WARN_RL(&rl, "%s reply claims invalid length %"PRIuSIZE,
> +                     ofpraw_get_name(raw), length);
> +        return OFPERR_OFPBRC_BAD_LEN;
> +    }
> +
> +    gs->group_id = ntohl(ogs11->group_id);
> +    gs->ref_count = ntohl(ogs11->ref_count);
> +    gs->packet_count = ntohll(ogs11->packet_count);
> +    gs->byte_count = ntohll(ogs11->byte_count);
> +
> +    gs->n_buckets = (length - base_len) / sizeof *obc;
> +    obc = ofpbuf_try_pull(msg, gs->n_buckets * sizeof *obc);
> +    if (!obc) {
> +        VLOG_WARN_RL(&rl, "%s reply has %"PRIu32" leftover bytes at end",
> +                     ofpraw_get_name(raw), msg->size);
> +        return OFPERR_OFPBRC_BAD_LEN;
> +    }
> +
> +    gs->bucket_stats = xmalloc(gs->n_buckets * sizeof *gs->bucket_stats);
> +    for (i = 0; i < gs->n_buckets; i++) {
> +        gs->bucket_stats[i].packet_count = ntohll(obc[i].packet_count);
> +        gs->bucket_stats[i].byte_count = ntohll(obc[i].byte_count);
> +    }
> +
> +    return 0;
> +}
> +
> +static char * OVS_WARN_UNUSED_RESULT
> +parse_bucket_str(struct ofputil_bucket *bucket, char *str_,
> +                 const struct ofputil_port_map *port_map,
> +                 const struct ofputil_table_map *table_map,
> +                 uint8_t group_type, enum ofputil_protocol
> *usable_protocols)
> +{
> +    char *pos, *key, *value;
> +    struct ofpbuf ofpacts;
> +    struct ds actions;
> +    char *error;
> +
> +    bucket->weight = group_type == OFPGT11_SELECT ? 1 : 0;
> +    bucket->bucket_id = OFPG15_BUCKET_ALL;
> +    bucket->watch_port = OFPP_ANY;
> +    bucket->watch_group = OFPG_ANY;
> +
> +    ds_init(&actions);
> +
> +    pos = str_;
> +    error = NULL;
> +    while (ofputil_parse_key_value(&pos, &key, &value)) {
> +        if (!strcasecmp(key, "weight")) {
> +            error = str_to_u16(value, "weight", &bucket->weight);
> +        } else if (!strcasecmp(key, "watch_port")) {
> +            if (!ofputil_port_from_string(value, port_map,
> &bucket->watch_port)
> +                || (ofp_to_u16(bucket->watch_port) >=
> ofp_to_u16(OFPP_MAX)
> +                    && bucket->watch_port != OFPP_ANY)) {
> +                error = xasprintf("%s: invalid watch_port", value);
> +            }
> +        } else if (!strcasecmp(key, "watch_group")) {
> +            error = str_to_u32(value, &bucket->watch_group);
> +            if (!error && bucket->watch_group > OFPG_MAX) {
> +                error = xasprintf("invalid watch_group id %"PRIu32,
> +                                  bucket->watch_group);
> +            }
> +        } else if (!strcasecmp(key, "bucket_id")) {
> +            error = str_to_u32(value, &bucket->bucket_id);
> +            if (!error && bucket->bucket_id > OFPG15_BUCKET_MAX) {
> +                error = xasprintf("invalid bucket_id id %"PRIu32,
> +                                  bucket->bucket_id);
> +            }
> +            *usable_protocols &= OFPUTIL_P_OF15_UP;
> +        } else if (!strcasecmp(key, "action") || !strcasecmp(key,
> "actions")) {
> +            ds_put_format(&actions, "%s,", value);
> +        } else {
> +            ds_put_format(&actions, "%s(%s),", key, value);
> +        }
> +
> +        if (error) {
> +            ds_destroy(&actions);
> +            return error;
> +        }
> +    }
> +
> +    if (!actions.length) {
> +        return xstrdup("bucket must specify actions");
> +    }
> +    ds_chomp(&actions, ',');
> +
> +    ofpbuf_init(&ofpacts, 0);
> +    struct ofpact_parse_params pp = {
> +        .port_map = port_map,
> +        .table_map = table_map,
> +        .ofpacts = &ofpacts,
> +        .usable_protocols = usable_protocols,
> +    };
> +    error = ofpacts_parse_actions(ds_cstr(&actions), &pp);
> +    ds_destroy(&actions);
> +    if (error) {
> +        ofpbuf_uninit(&ofpacts);
> +        return error;
> +    }
> +    bucket->ofpacts = ofpacts.data;
> +    bucket->ofpacts_len = ofpacts.size;
> +
> +    return NULL;
> +}
> +
> +static char * OVS_WARN_UNUSED_RESULT
> +parse_select_group_field(char *s, const struct ofputil_port_map *port_map,
> +                         struct field_array *fa,
> +                         enum ofputil_protocol *usable_protocols)
> +{
> +    char *name, *value_str;
> +
> +    while (ofputil_parse_key_value(&s, &name, &value_str)) {
> +        const struct mf_field *mf = mf_from_name(name);
> +
> +        if (mf) {
> +            char *error;
> +            union mf_value value;
> +
> +            if (bitmap_is_set(fa->used.bm, mf->id)) {
> +                return xasprintf("%s: duplicate field", name);
> +            }
> +
> +            if (*value_str) {
> +                error = mf_parse_value(mf, value_str, port_map, &value);
> +                if (error) {
> +                    return error;
> +                }
> +
> +                /* The mask cannot be all-zeros */
> +                if (!mf_is_tun_metadata(mf) &&
> +                    is_all_zeros(&value, mf->n_bytes)) {
> +                    return xasprintf("%s: values are wildcards here "
> +                                     "and must not be all-zeros", s);
> +                }
> +
> +                /* The values parsed are masks for fields used
> +                 * by the selection method */
> +                if (!mf_is_mask_valid(mf, &value)) {
> +                    return xasprintf("%s: invalid mask for field %s",
> +                                     value_str, mf->name);
> +                }
> +            } else {
> +                memset(&value, 0xff, mf->n_bytes);
> +            }
> +
> +            field_array_set(mf->id, &value, fa);
> +
> +            if (is_all_ones(&value, mf->n_bytes)) {
> +                *usable_protocols &= mf->usable_protocols_exact;
> +            } else if (mf->usable_protocols_bitwise ==
> mf->usable_protocols_cidr
> +                       || ip_is_cidr(value.be32)) {
> +                *usable_protocols &= mf->usable_protocols_cidr;
> +            } else {
> +                *usable_protocols &= mf->usable_protocols_bitwise;
> +            }
> +        } else {
> +            return xasprintf("%s: unknown field %s", s, name);
> +        }
> +    }
> +
> +    return NULL;
> +}
> +
> +static char * OVS_WARN_UNUSED_RESULT
> +parse_ofp_group_mod_str__(struct ofputil_group_mod *gm, int command,
> +                          char *string,
> +                          const struct ofputil_port_map *port_map,
> +                          const struct ofputil_table_map *table_map,
> +                          enum ofputil_protocol *usable_protocols)
> +{
> +    enum {
> +        F_GROUP_TYPE            = 1 << 0,
> +        F_BUCKETS               = 1 << 1,
> +        F_COMMAND_BUCKET_ID     = 1 << 2,
> +        F_COMMAND_BUCKET_ID_ALL = 1 << 3,
> +    } fields;
> +    bool had_type = false;
> +    bool had_command_bucket_id = false;
> +    struct ofputil_bucket *bucket;
> +    char *error = NULL;
> +
> +    *usable_protocols = OFPUTIL_P_OF11_UP;
> +
> +    if (command == -2) {
> +        size_t len;
> +
> +        string += strspn(string, " \t\r\n");   /* Skip white space. */
> +        len = strcspn(string, ", \t\r\n"); /* Get length of the first
> token. */
> +
> +        if (!strncmp(string, "add", len)) {
> +            command = OFPGC11_ADD;
> +        } else if (!strncmp(string, "delete", len)) {
> +            command = OFPGC11_DELETE;
> +        } else if (!strncmp(string, "modify", len)) {
> +            command = OFPGC11_MODIFY;
> +        } else if (!strncmp(string, "add_or_mod", len)) {
> +            command = OFPGC11_ADD_OR_MOD;
> +        } else if (!strncmp(string, "insert_bucket", len)) {
> +            command = OFPGC15_INSERT_BUCKET;
> +        } else if (!strncmp(string, "remove_bucket", len)) {
> +            command = OFPGC15_REMOVE_BUCKET;
> +        } else {
> +            len = 0;
> +            command = OFPGC11_ADD;
> +        }
> +        string += len;
> +    }
> +
> +    switch (command) {
> +    case OFPGC11_ADD:
> +        fields = F_GROUP_TYPE | F_BUCKETS;
> +        break;
> +
> +    case OFPGC11_DELETE:
> +        fields = 0;
> +        break;
> +
> +    case OFPGC11_MODIFY:
> +        fields = F_GROUP_TYPE | F_BUCKETS;
> +        break;
> +
> +    case OFPGC11_ADD_OR_MOD:
> +        fields = F_GROUP_TYPE | F_BUCKETS;
> +        break;
> +
> +    case OFPGC15_INSERT_BUCKET:
> +        fields = F_BUCKETS | F_COMMAND_BUCKET_ID;
> +        *usable_protocols &= OFPUTIL_P_OF15_UP;
> +        break;
> +
> +    case OFPGC15_REMOVE_BUCKET:
> +        fields = F_COMMAND_BUCKET_ID | F_COMMAND_BUCKET_ID_ALL;
> +        *usable_protocols &= OFPUTIL_P_OF15_UP;
> +        break;
> +
> +    default:
> +        OVS_NOT_REACHED();
> +    }
> +
> +    memset(gm, 0, sizeof *gm);
> +    gm->command = command;
> +    gm->group_id = OFPG_ANY;
> +    gm->command_bucket_id = OFPG15_BUCKET_ALL;
> +    ovs_list_init(&gm->buckets);
> +    if (command == OFPGC11_DELETE && string[0] == '\0') {
> +        gm->group_id = OFPG_ALL;
> +        return NULL;
> +    }
> +
> +    *usable_protocols = OFPUTIL_P_OF11_UP;
> +
> +    /* Strip the buckets off the end of 'string', if there are any,
> saving a
> +     * pointer for later.  We want to parse the buckets last because the
> bucket
> +     * type influences bucket defaults. */
> +    char *bkt_str = strstr(string, "bucket=");
> +    if (bkt_str) {
> +        if (!(fields & F_BUCKETS)) {
> +            error = xstrdup("bucket is not needed");
> +            goto out;
> +        }
> +        *bkt_str = '\0';
> +    }
> +
> +    /* Parse everything before the buckets. */
> +    char *pos = string;
> +    char *name, *value;
> +    while (ofputil_parse_key_value(&pos, &name, &value)) {
> +        if (!strcmp(name, "command_bucket_id")) {
> +            if (!(fields & F_COMMAND_BUCKET_ID)) {
> +                error = xstrdup("command bucket id is not needed");
> +                goto out;
> +            }
> +            if (!strcmp(value, "all")) {
> +                gm->command_bucket_id = OFPG15_BUCKET_ALL;
> +            } else if (!strcmp(value, "first")) {
> +                gm->command_bucket_id = OFPG15_BUCKET_FIRST;
> +            } else if (!strcmp(value, "last")) {
> +                gm->command_bucket_id = OFPG15_BUCKET_LAST;
> +            } else {
> +                error = str_to_u32(value, &gm->command_bucket_id);
> +                if (error) {
> +                    goto out;
> +                }
> +                if (gm->command_bucket_id > OFPG15_BUCKET_MAX
> +                    && (gm->command_bucket_id != OFPG15_BUCKET_FIRST
> +                        && gm->command_bucket_id != OFPG15_BUCKET_LAST
> +                        && gm->command_bucket_id != OFPG15_BUCKET_ALL)) {
> +                    error = xasprintf("invalid command bucket id %"PRIu32,
> +                                      gm->command_bucket_id);
> +                    goto out;
> +                }
> +            }
> +            if (gm->command_bucket_id == OFPG15_BUCKET_ALL
> +                && !(fields & F_COMMAND_BUCKET_ID_ALL)) {
> +                error = xstrdup("command_bucket_id=all is not permitted");
> +                goto out;
> +            }
> +            had_command_bucket_id = true;
> +        } else if (!strcmp(name, "group_id")) {
> +            if(!strcmp(value, "all")) {
> +                gm->group_id = OFPG_ALL;
> +            } else {
> +                error = str_to_u32(value, &gm->group_id);
> +                if (error) {
> +                    goto out;
> +                }
> +                if (gm->group_id != OFPG_ALL && gm->group_id > OFPG_MAX) {
> +                    error = xasprintf("invalid group id %"PRIu32,
> +                                      gm->group_id);
> +                    goto out;
> +                }
> +            }
> +        } else if (!strcmp(name, "type")){
> +            if (!(fields & F_GROUP_TYPE)) {
> +                error = xstrdup("type is not needed");
> +                goto out;
> +            }
> +            if (!strcmp(value, "all")) {
> +                gm->type = OFPGT11_ALL;
> +            } else if (!strcmp(value, "select")) {
> +                gm->type = OFPGT11_SELECT;
> +            } else if (!strcmp(value, "indirect")) {
> +                gm->type = OFPGT11_INDIRECT;
> +            } else if (!strcmp(value, "ff") ||
> +                       !strcmp(value, "fast_failover")) {
> +                gm->type = OFPGT11_FF;
> +            } else {
> +                error = xasprintf("invalid group type %s", value);
> +                goto out;
> +            }
> +            had_type = true;
> +        } else if (!strcmp(name, "selection_method")) {
> +            if (!(fields & F_GROUP_TYPE)) {
> +                error = xstrdup("selection method is not needed");
> +                goto out;
> +            }
> +            if (strlen(value) >= NTR_MAX_SELECTION_METHOD_LEN) {
> +                error = xasprintf("selection method is longer than %u"
> +                                  " bytes long",
> +                                  NTR_MAX_SELECTION_METHOD_LEN - 1);
> +                goto out;
> +            }
> +            memset(gm->props.selection_method, '\0',
> +                   NTR_MAX_SELECTION_METHOD_LEN);
> +            strcpy(gm->props.selection_method, value);
> +            *usable_protocols &= OFPUTIL_P_OF15_UP;
> +        } else if (!strcmp(name, "selection_method_param")) {
> +            if (!(fields & F_GROUP_TYPE)) {
> +                error = xstrdup("selection method param is not needed");
> +                goto out;
> +            }
> +            error = str_to_u64(value, &gm->props.selection_method_param);
> +            if (error) {
> +                goto out;
> +            }
> +            *usable_protocols &= OFPUTIL_P_OF15_UP;
> +        } else if (!strcmp(name, "fields")) {
> +            if (!(fields & F_GROUP_TYPE)) {
> +                error = xstrdup("fields are not needed");
> +                goto out;
> +            }
> +            error = parse_select_group_field(value, port_map,
> +                                             &gm->props.fields,
> +                                             usable_protocols);
> +            if (error) {
> +                goto out;
> +            }
> +            *usable_protocols &= OFPUTIL_P_OF15_UP;
> +        } else {
> +            error = xasprintf("unknown keyword %s", name);
> +            goto out;
> +        }
> +    }
> +    if (gm->group_id == OFPG_ANY) {
> +        error = xstrdup("must specify a group_id");
> +        goto out;
> +    }
> +    if (fields & F_GROUP_TYPE && !had_type) {
> +        error = xstrdup("must specify a type");
> +        goto out;
> +    }
> +
> +    /* Exclude fields for non "hash" selection method. */
> +    if (strcmp(gm->props.selection_method, "hash") &&
> +        gm->props.fields.values_size) {
> +        error = xstrdup("fields may only be specified with
> \"selection_method=hash\"");
> +        goto out;
> +    }
> +    /* Exclude selection_method_param if no selection_method is given. */
> +    if (gm->props.selection_method[0] == 0
> +        && gm->props.selection_method_param != 0) {
> +        error = xstrdup("selection_method_param is only allowed with
> \"selection_method\"");
> +        goto out;
> +    }
> +    if (fields & F_COMMAND_BUCKET_ID) {
> +        if (!(fields & F_COMMAND_BUCKET_ID_ALL || had_command_bucket_id))
> {
> +            error = xstrdup("must specify a command bucket id");
> +            goto out;
> +        }
> +    } else if (had_command_bucket_id) {
> +        error = xstrdup("command bucket id is not needed");
> +        goto out;
> +    }
> +
> +    /* Now parse the buckets, if any. */
> +    while (bkt_str) {
> +        char *next_bkt_str;
> +
> +        bkt_str = strchr(bkt_str + 1, '=');
> +        if (!bkt_str) {
> +            error = xstrdup("must specify bucket content");
> +            goto out;
> +        }
> +        bkt_str++;
> +
> +        next_bkt_str = strstr(bkt_str, "bucket=");
> +        if (next_bkt_str) {
> +            *next_bkt_str = '\0';
> +        }
> +
> +        bucket = xzalloc(sizeof(struct ofputil_bucket));
> +        error = parse_bucket_str(bucket, bkt_str, port_map, table_map,
> +                                 gm->type, usable_protocols);
> +        if (error) {
> +            free(bucket);
> +            goto out;
> +        }
> +        ovs_list_push_back(&gm->buckets, &bucket->list_node);
> +
> +        if (gm->type != OFPGT11_SELECT && bucket->weight) {
> +            error = xstrdup("Only select groups can have bucket
> weights.");
> +            goto out;
> +        }
> +
> +        bkt_str = next_bkt_str;
> +    }
> +    if (gm->type == OFPGT11_INDIRECT && !ovs_list_is_short(&gm->buckets))
> {
> +        error = xstrdup("Indirect groups can have at most one bucket.");
> +        goto out;
> +    }
> +
> +    return NULL;
> + out:
> +    ofputil_uninit_group_mod(gm);
> +    return error;
> +}
> +
> +/* If 'command' is given as -2, each line may start with a command name
> ("add",
> + * "modify", "add_or_mod", "delete", "insert_bucket", or
> "remove_bucket").  A
> + * missing command name is treated as "add".
> + */
> +char * OVS_WARN_UNUSED_RESULT
> +parse_ofp_group_mod_str(struct ofputil_group_mod *gm, int command,
> +                        const char *str_,
> +                        const struct ofputil_port_map *port_map,
> +                        const struct ofputil_table_map *table_map,
> +                        enum ofputil_protocol *usable_protocols)
> +{
> +    char *string = xstrdup(str_);
> +    char *error = parse_ofp_group_mod_str__(gm, command, string, port_map,
> +                                            table_map, usable_protocols);
> +    free(string);
> +    return error;
> +}
> +
> +/* If 'command' is given as -2, each line may start with a command name
> ("add",
> + * "modify", "add_or_mod", "delete", "insert_bucket", or
> "remove_bucket").  A
> + * missing command name is treated as "add".
> + */
> +char * OVS_WARN_UNUSED_RESULT
> +parse_ofp_group_mod_file(const char *file_name,
> +                         const struct ofputil_port_map *port_map,
> +                         const struct ofputil_table_map *table_map,
> +                         int command,
> +                         struct ofputil_group_mod **gms, size_t *n_gms,
> +                         enum ofputil_protocol *usable_protocols)
> +{
> +    size_t allocated_gms;
> +    int line_number;
> +    FILE *stream;
> +    struct ds s;
> +
> +    *gms = NULL;
> +    *n_gms = 0;
> +
> +    stream = !strcmp(file_name, "-") ? stdin : fopen(file_name, "r");
> +    if (stream == NULL) {
> +        return xasprintf("%s: open failed (%s)",
> +                         file_name, ovs_strerror(errno));
> +    }
> +
> +    allocated_gms = *n_gms;
> +    ds_init(&s);
> +    line_number = 0;
> +    *usable_protocols = OFPUTIL_P_OF11_UP;
> +    while (!ds_get_preprocessed_line(&s, stream, &line_number)) {
> +        enum ofputil_protocol usable;
> +        char *error;
> +
> +        if (*n_gms >= allocated_gms) {
> +            struct ofputil_group_mod *new_gms;
> +            size_t i;
> +
> +            new_gms = x2nrealloc(*gms, &allocated_gms, sizeof **gms);
> +            for (i = 0; i < *n_gms; i++) {
> +                ovs_list_moved(&new_gms[i].buckets, &(*gms)[i].buckets);
> +            }
> +            *gms = new_gms;
> +        }
> +        error = parse_ofp_group_mod_str(&(*gms)[*n_gms], command,
> ds_cstr(&s),
> +                                        port_map, table_map, &usable);
> +        if (error) {
> +            size_t i;
> +
> +            for (i = 0; i < *n_gms; i++) {
> +                ofputil_uninit_group_mod(&(*gms)[i]);
> +            }
> +            free(*gms);
> +            *gms = NULL;
> +            *n_gms = 0;
> +
> +            ds_destroy(&s);
> +            if (stream != stdin) {
> +                fclose(stream);
> +            }
> +
> +            char *ret = xasprintf("%s:%d: %s", file_name, line_number,
> error);
> +            free(error);
> +            return ret;
> +        }
> +        *usable_protocols &= usable;
> +        *n_gms += 1;
> +    }
> +
> +    ds_destroy(&s);
> +    if (stream != stdin) {
> +        fclose(stream);
> +    }
> +    return NULL;
> +}
> +
> +static void
> +ofputil_put_ofp11_bucket(const struct ofputil_bucket *bucket,
> +                         struct ofpbuf *openflow, enum ofp_version
> ofp_version)
> +{
> +    struct ofp11_bucket *ob;
> +    size_t start;
> +
> +    start = openflow->size;
> +    ofpbuf_put_zeros(openflow, sizeof *ob);
> +    ofpacts_put_openflow_actions(bucket->ofpacts, bucket->ofpacts_len,
> +                                openflow, ofp_version);
> +    ob = ofpbuf_at_assert(openflow, start, sizeof *ob);
> +    ob->len = htons(openflow->size - start);
> +    ob->weight = htons(bucket->weight);
> +    ob->watch_port = ofputil_port_to_ofp11(bucket->watch_port);
> +    ob->watch_group = htonl(bucket->watch_group);
> +}
> +
> +static void
> +ofputil_put_ofp15_bucket(const struct ofputil_bucket *bucket,
> +                         uint32_t bucket_id, enum ofp11_group_type
> group_type,
> +                         struct ofpbuf *openflow, enum ofp_version
> ofp_version)
> +{
> +    struct ofp15_bucket *ob;
> +    size_t start, actions_start, actions_len;
> +
> +    start = openflow->size;
> +    ofpbuf_put_zeros(openflow, sizeof *ob);
> +
> +    actions_start = openflow->size;
> +    ofpacts_put_openflow_actions(bucket->ofpacts, bucket->ofpacts_len,
> +                                 openflow, ofp_version);
> +    actions_len = openflow->size - actions_start;
> +
> +    if (group_type == OFPGT11_SELECT) {
> +        ofpprop_put_u16(openflow, OFPGBPT15_WEIGHT, bucket->weight);
> +    }
> +    if (bucket->watch_port != OFPP_ANY) {
> +        ofpprop_put_be32(openflow, OFPGBPT15_WATCH_PORT,
> +                         ofputil_port_to_ofp11(bucket->watch_port));
> +    }
> +    if (bucket->watch_group != OFPG_ANY) {
> +        ofpprop_put_u32(openflow, OFPGBPT15_WATCH_GROUP,
> bucket->watch_group);
> +    }
> +
> +    ob = ofpbuf_at_assert(openflow, start, sizeof *ob);
> +    ob->len = htons(openflow->size - start);
> +    ob->action_array_len = htons(actions_len);
> +    ob->bucket_id = htonl(bucket_id);
> +}
> +
> +static void
> +ofputil_put_group_prop_ntr_selection_method(enum ofp_version ofp_version,
> +                                            const struct
> ofputil_group_props *gp,
> +                                            struct ofpbuf *openflow)
> +{
> +    struct ntr_group_prop_selection_method *prop;
> +    size_t start;
> +
> +    start = openflow->size;
> +    ofpbuf_put_zeros(openflow, sizeof *prop);
> +    oxm_put_field_array(openflow, &gp->fields, ofp_version);
> +    prop = ofpbuf_at_assert(openflow, start, sizeof *prop);
> +    prop->type = htons(OFPGPT15_EXPERIMENTER);
> +    prop->experimenter = htonl(NTR_VENDOR_ID);
> +    prop->exp_type = htonl(NTRT_SELECTION_METHOD);
> +    strcpy(prop->selection_method, gp->selection_method);
> +    prop->selection_method_param = htonll(gp->selection_method_param);
> +    ofpprop_end(openflow, start);
> +}
> +
> +static void
> +ofputil_append_ofp11_group_desc_reply(const struct ofputil_group_desc
> *gds,
> +                                      const struct ovs_list *buckets,
> +                                      struct ovs_list *replies,
> +                                      enum ofp_version version)
> +{
> +    struct ofpbuf *reply = ofpbuf_from_list(ovs_list_back(replies));
> +    struct ofp11_group_desc_stats *ogds;
> +    struct ofputil_bucket *bucket;
> +    size_t start_ogds;
> +
> +    start_ogds = reply->size;
> +    ofpbuf_put_zeros(reply, sizeof *ogds);
> +    LIST_FOR_EACH (bucket, list_node, buckets) {
> +        ofputil_put_ofp11_bucket(bucket, reply, version);
> +    }
> +    ogds = ofpbuf_at_assert(reply, start_ogds, sizeof *ogds);
> +    ogds->length = htons(reply->size - start_ogds);
> +    ogds->type = gds->type;
> +    ogds->group_id = htonl(gds->group_id);
> +
> +    ofpmp_postappend(replies, start_ogds);
> +}
> +
> +static void
> +ofputil_append_ofp15_group_desc_reply(const struct ofputil_group_desc
> *gds,
> +                                      const struct ovs_list *buckets,
> +                                      struct ovs_list *replies,
> +                                      enum ofp_version version)
> +{
> +    struct ofpbuf *reply = ofpbuf_from_list(ovs_list_back(replies));
> +    struct ofp15_group_desc_stats *ogds;
> +    struct ofputil_bucket *bucket;
> +    size_t start_ogds, start_buckets;
> +
> +    start_ogds = reply->size;
> +    ofpbuf_put_zeros(reply, sizeof *ogds);
> +    start_buckets = reply->size;
> +    LIST_FOR_EACH (bucket, list_node, buckets) {
> +        ofputil_put_ofp15_bucket(bucket, bucket->bucket_id,
> +                                 gds->type, reply, version);
> +    }
> +    ogds = ofpbuf_at_assert(reply, start_ogds, sizeof *ogds);
> +    ogds->type = gds->type;
> +    ogds->group_id = htonl(gds->group_id);
> +    ogds->bucket_list_len =  htons(reply->size - start_buckets);
> +
> +    /* Add group properties */
> +    if (gds->props.selection_method[0]) {
> +        ofputil_put_group_prop_ntr_selection_method(version, &gds->props,
> +                                                    reply);
> +    }
> +    ogds = ofpbuf_at_assert(reply, start_ogds, sizeof *ogds);
> +    ogds->length = htons(reply->size - start_ogds);
> +
> +    ofpmp_postappend(replies, start_ogds);
> +}
> +
> +/* Appends a group stats reply that contains the data in 'gds' to those
> already
> + * present in the list of ofpbufs in 'replies'.  'replies' should have
> been
> + * initialized with ofpmp_init(). */
> +void
> +ofputil_append_group_desc_reply(const struct ofputil_group_desc *gds,
> +                                const struct ovs_list *buckets,
> +                                struct ovs_list *replies)
> +{
> +    enum ofp_version version = ofpmp_version(replies);
> +
> +    switch (version)
> +    {
> +    case OFP11_VERSION:
> +    case OFP12_VERSION:
> +    case OFP13_VERSION:
> +    case OFP14_VERSION:
> +        ofputil_append_ofp11_group_desc_reply(gds, buckets, replies,
> version);
> +        break;
> +
> +    case OFP15_VERSION:
> +    case OFP16_VERSION:
> +        ofputil_append_ofp15_group_desc_reply(gds, buckets, replies,
> version);
> +        break;
> +
> +    case OFP10_VERSION:
> +    default:
> +        OVS_NOT_REACHED();
> +    }
> +}
> +
> +static enum ofperr
> +ofputil_pull_ofp11_buckets(struct ofpbuf *msg, size_t buckets_length,
> +                           enum ofp_version version, struct ovs_list
> *buckets)
> +{
> +    struct ofp11_bucket *ob;
> +    uint32_t bucket_id = 0;
> +
> +    ovs_list_init(buckets);
> +    while (buckets_length > 0) {
> +        struct ofputil_bucket *bucket;
> +        struct ofpbuf ofpacts;
> +        enum ofperr error;
> +        size_t ob_len;
> +
> +        ob = (buckets_length >= sizeof *ob
> +              ? ofpbuf_try_pull(msg, sizeof *ob)
> +              : NULL);
> +        if (!ob) {
> +            VLOG_WARN_RL(&rl, "buckets end with %"PRIuSIZE" leftover
> bytes",
> +                         buckets_length);
> +            ofputil_bucket_list_destroy(buckets);
> +            return OFPERR_OFPGMFC_BAD_BUCKET;
> +        }
> +
> +        ob_len = ntohs(ob->len);
> +        if (ob_len < sizeof *ob) {
> +            VLOG_WARN_RL(&rl, "OpenFlow message bucket length "
> +                         "%"PRIuSIZE" is not valid", ob_len);
> +            ofputil_bucket_list_destroy(buckets);
> +            return OFPERR_OFPGMFC_BAD_BUCKET;
> +        } else if (ob_len > buckets_length) {
> +            VLOG_WARN_RL(&rl, "OpenFlow message bucket length "
> +                         "%"PRIuSIZE" exceeds remaining buckets data size
> %"PRIuSIZE,
> +                         ob_len, buckets_length);
> +            ofputil_bucket_list_destroy(buckets);
> +            return OFPERR_OFPGMFC_BAD_BUCKET;
> +        }
> +        buckets_length -= ob_len;
> +
> +        ofpbuf_init(&ofpacts, 0);
> +        error = ofpacts_pull_openflow_actions(msg, ob_len - sizeof *ob,
> +                                              version, NULL, NULL,
> &ofpacts);
> +        if (error) {
> +            ofpbuf_uninit(&ofpacts);
> +            ofputil_bucket_list_destroy(buckets);
> +            return error;
> +        }
> +
> +        bucket = xzalloc(sizeof *bucket);
> +        bucket->weight = ntohs(ob->weight);
> +        error = ofputil_port_from_ofp11(ob->watch_port,
> &bucket->watch_port);
> +        if (error) {
> +            ofpbuf_uninit(&ofpacts);
> +            ofputil_bucket_list_destroy(buckets);
> +            free(bucket);
> +            return OFPERR_OFPGMFC_BAD_WATCH;
> +        }
> +        bucket->watch_group = ntohl(ob->watch_group);
> +        bucket->bucket_id = bucket_id++;
> +
> +        bucket->ofpacts = ofpbuf_steal_data(&ofpacts);
> +        bucket->ofpacts_len = ofpacts.size;
> +        ovs_list_push_back(buckets, &bucket->list_node);
> +    }
> +
> +    return 0;
> +}
> +
> +static enum ofperr
> +ofputil_pull_ofp15_buckets(struct ofpbuf *msg, size_t buckets_length,
> +                           enum ofp_version version, uint8_t group_type,
> +                           struct ovs_list *buckets)
> +{
> +    struct ofp15_bucket *ob;
> +
> +    ovs_list_init(buckets);
> +    while (buckets_length > 0) {
> +        struct ofputil_bucket *bucket = NULL;
> +        struct ofpbuf ofpacts;
> +        enum ofperr err = OFPERR_OFPGMFC_BAD_BUCKET;
> +        size_t ob_len, actions_len, properties_len;
> +        ovs_be32 watch_port = ofputil_port_to_ofp11(OFPP_ANY);
> +        ovs_be32 watch_group = htonl(OFPG_ANY);
> +        ovs_be16 weight = htons(group_type == OFPGT11_SELECT ? 1 : 0);
> +
> +        ofpbuf_init(&ofpacts, 0);
> +
> +        ob = ofpbuf_try_pull(msg, sizeof *ob);
> +        if (!ob) {
> +            VLOG_WARN_RL(&rl, "buckets end with %"PRIuSIZE
> +                         " leftover bytes", buckets_length);
> +            goto err;
> +        }
> +
> +        ob_len = ntohs(ob->len);
> +        actions_len = ntohs(ob->action_array_len);
> +
> +        if (ob_len < sizeof *ob) {
> +            VLOG_WARN_RL(&rl, "OpenFlow message bucket length "
> +                         "%"PRIuSIZE" is not valid", ob_len);
> +            goto err;
> +        } else if (ob_len > buckets_length) {
> +            VLOG_WARN_RL(&rl, "OpenFlow message bucket length "
> +                         "%"PRIuSIZE" exceeds remaining buckets data size
> %"
> +                         PRIuSIZE, ob_len, buckets_length);
> +            goto err;
> +        } else if (actions_len > ob_len - sizeof *ob) {
> +            VLOG_WARN_RL(&rl, "OpenFlow message bucket actions "
> +                         "length %"PRIuSIZE" exceeds remaining bucket "
> +                         "data size %"PRIuSIZE, actions_len,
> +                         ob_len - sizeof *ob);
> +            goto err;
> +        }
> +        buckets_length -= ob_len;
> +
> +        err = ofpacts_pull_openflow_actions(msg, actions_len, version,
> +                                            NULL, NULL, &ofpacts);
> +        if (err) {
> +            goto err;
> +        }
> +
> +        properties_len = ob_len - sizeof *ob - actions_len;
> +        struct ofpbuf properties = ofpbuf_const_initializer(
> +            ofpbuf_pull(msg, properties_len), properties_len);
> +        while (properties.size > 0) {
> +            struct ofpbuf payload;
> +            uint64_t type;
> +
> +            err = ofpprop_pull(&properties, &payload, &type);
> +            if (err) {
> +                goto err;
> +            }
> +
> +            switch (type) {
> +            case OFPGBPT15_WEIGHT:
> +                err = ofpprop_parse_be16(&payload, &weight);
> +                break;
> +
> +            case OFPGBPT15_WATCH_PORT:
> +                err = ofpprop_parse_be32(&payload, &watch_port);
> +                break;
> +
> +            case OFPGBPT15_WATCH_GROUP:
> +                err = ofpprop_parse_be32(&payload, &watch_group);
> +                break;
> +
> +            default:
> +                err = OFPPROP_UNKNOWN(false, "group bucket", type);
> +                break;
> +            }
> +
> +            if (err) {
> +                goto err;
> +            }
> +        }
> +
> +        bucket = xzalloc(sizeof *bucket);
> +
> +        bucket->weight = ntohs(weight);
> +        err = ofputil_port_from_ofp11(watch_port, &bucket->watch_port);
> +        if (err) {
> +            err = OFPERR_OFPGMFC_BAD_WATCH;
> +            goto err;
> +        }
> +        bucket->watch_group = ntohl(watch_group);
> +        bucket->bucket_id = ntohl(ob->bucket_id);
> +        if (bucket->bucket_id > OFPG15_BUCKET_MAX) {
> +            VLOG_WARN_RL(&rl, "bucket id (%u) is out of range",
> +                         bucket->bucket_id);
> +            err = OFPERR_OFPGMFC_BAD_BUCKET;
> +            goto err;
> +        }
> +
> +        bucket->ofpacts = ofpbuf_steal_data(&ofpacts);
> +        bucket->ofpacts_len = ofpacts.size;
> +        ovs_list_push_back(buckets, &bucket->list_node);
> +
> +        continue;
> +
> +    err:
> +        free(bucket);
> +        ofpbuf_uninit(&ofpacts);
> +        ofputil_bucket_list_destroy(buckets);
> +        return err;
> +    }
> +
> +    if (ofputil_bucket_check_duplicate_id(buckets)) {
> +        VLOG_WARN_RL(&rl, "Duplicate bucket id");
> +        ofputil_bucket_list_destroy(buckets);
> +        return OFPERR_OFPGMFC_BAD_BUCKET;
> +    }
> +
> +    return 0;
> +}
> +
> +static void
> +ofputil_init_group_properties(struct ofputil_group_props *gp)
> +{
> +    memset(gp, 0, sizeof *gp);
> +}
> +
> +void
> +ofputil_group_properties_copy(struct ofputil_group_props *to,
> +                              const struct ofputil_group_props *from)
> +{
> +    *to = *from;
> +    to->fields.values = xmemdup(from->fields.values,
> from->fields.values_size);
> +}
> +
> +void
> +ofputil_group_properties_destroy(struct ofputil_group_props *gp)
> +{
> +    free(gp->fields.values);
> +}
> +
> +static enum ofperr
> +parse_group_prop_ntr_selection_method(struct ofpbuf *payload,
> +                                      enum ofp11_group_type group_type,
> +                                      enum ofp15_group_mod_command
> group_cmd,
> +                                      struct ofputil_group_props *gp)
> +{
> +    struct ntr_group_prop_selection_method *prop = payload->data;
> +    size_t fields_len, method_len;
> +    enum ofperr error;
> +
> +    switch (group_type) {
> +    case OFPGT11_SELECT:
> +        break;
> +    case OFPGT11_ALL:
> +    case OFPGT11_INDIRECT:
> +    case OFPGT11_FF:
> +        OFPPROP_LOG(&rl, false, "ntr selection method property is "
> +                    "only allowed for select groups");
> +        return OFPERR_OFPBPC_BAD_VALUE;
> +    default:
> +        OVS_NOT_REACHED();
> +    }
> +
> +    switch (group_cmd) {
> +    case OFPGC15_ADD:
> +    case OFPGC15_MODIFY:
> +    case OFPGC15_ADD_OR_MOD:
> +        break;
> +    case OFPGC15_DELETE:
> +    case OFPGC15_INSERT_BUCKET:
> +    case OFPGC15_REMOVE_BUCKET:
> +        OFPPROP_LOG(&rl, false, "ntr selection method property is "
> +                    "only allowed for add and delete group
> modifications");
> +        return OFPERR_OFPBPC_BAD_VALUE;
> +    default:
> +        OVS_NOT_REACHED();
> +    }
> +
> +    if (payload->size < sizeof *prop) {
> +        OFPPROP_LOG(&rl, false, "ntr selection method property "
> +                    "length %u is not valid", payload->size);
> +        return OFPERR_OFPBPC_BAD_LEN;
> +    }
> +
> +    method_len = strnlen(prop->selection_method,
> NTR_MAX_SELECTION_METHOD_LEN);
> +
> +    if (method_len == NTR_MAX_SELECTION_METHOD_LEN) {
> +        OFPPROP_LOG(&rl, false,
> +                    "ntr selection method is not null terminated");
> +        return OFPERR_OFPBPC_BAD_VALUE;
> +    }
> +
> +    if (strcmp("hash", prop->selection_method)
> +        && strcmp("dp_hash", prop->selection_method)) {
> +        OFPPROP_LOG(&rl, false,
> +                    "ntr selection method '%s' is not supported",
> +                    prop->selection_method);
> +        return OFPERR_OFPBPC_BAD_VALUE;
> +    }
> +    /* 'method_len' is now non-zero. */
> +
> +    strcpy(gp->selection_method, prop->selection_method);
> +    gp->selection_method_param = ntohll(prop->selection_method_param);
> +
> +    ofpbuf_pull(payload, sizeof *prop);
> +
> +    fields_len = ntohs(prop->length) - sizeof *prop;
> +    if (fields_len && strcmp("hash", gp->selection_method)) {
> +        OFPPROP_LOG(&rl, false, "ntr selection method %s "
> +                    "does not support fields", gp->selection_method);
> +        return OFPERR_OFPBPC_BAD_VALUE;
> +    }
> +
> +    error = oxm_pull_field_array(payload->data, fields_len,
> +                                 &gp->fields);
> +    if (error) {
> +        OFPPROP_LOG(&rl, false,
> +                    "ntr selection method fields are invalid");
> +        return error;
> +    }
> +
> +    return 0;
> +}
> +
> +static enum ofperr
> +parse_ofp15_group_properties(struct ofpbuf *msg,
> +                             enum ofp11_group_type group_type,
> +                             enum ofp15_group_mod_command group_cmd,
> +                             struct ofputil_group_props *gp,
> +                             size_t properties_len)
> +{
> +    struct ofpbuf properties = ofpbuf_const_initializer(
> +        ofpbuf_pull(msg, properties_len), properties_len);
> +    while (properties.size > 0) {
> +        struct ofpbuf payload;
> +        enum ofperr error;
> +        uint64_t type;
> +
> +        error = ofpprop_pull(&properties, &payload, &type);
> +        if (error) {
> +            return error;
> +        }
> +
> +        switch (type) {
> +        case OFPPROP_EXP(NTR_VENDOR_ID, NTRT_SELECTION_METHOD):
> +        case OFPPROP_EXP(NTR_COMPAT_VENDOR_ID, NTRT_SELECTION_METHOD):
> +            error = parse_group_prop_ntr_selection_method(&payload,
> group_type,
> +                                                          group_cmd, gp);
> +            break;
> +
> +        default:
> +            error = OFPPROP_UNKNOWN(false, "group", type);
> +            break;
> +        }
> +
> +        if (error) {
> +            return error;
> +        }
> +    }
> +
> +    return 0;
> +}
> +
> +static int
> +ofputil_decode_ofp11_group_desc_reply(struct ofputil_group_desc *gd,
> +                                      struct ofpbuf *msg,
> +                                      enum ofp_version version)
> +{
> +    struct ofp11_group_desc_stats *ogds;
> +    size_t length;
> +
> +    if (!msg->header) {
> +        ofpraw_pull_assert(msg);
> +    }
> +
> +    if (!msg->size) {
> +        return EOF;
> +    }
> +
> +    ogds = ofpbuf_try_pull(msg, sizeof *ogds);
> +    if (!ogds) {
> +        VLOG_WARN_RL(&rl, "OFPST11_GROUP_DESC reply has %"PRIu32" "
> +                     "leftover bytes at end", msg->size);
> +        return OFPERR_OFPBRC_BAD_LEN;
> +    }
> +    gd->type = ogds->type;
> +    gd->group_id = ntohl(ogds->group_id);
> +
> +    length = ntohs(ogds->length);
> +    if (length < sizeof *ogds || length - sizeof *ogds > msg->size) {
> +        VLOG_WARN_RL(&rl, "OFPST11_GROUP_DESC reply claims invalid "
> +                     "length %"PRIuSIZE, length);
> +        return OFPERR_OFPBRC_BAD_LEN;
> +    }
> +
> +    return ofputil_pull_ofp11_buckets(msg, length - sizeof *ogds,
> version,
> +                                      &gd->buckets);
> +}
> +
> +static int
> +ofputil_decode_ofp15_group_desc_reply(struct ofputil_group_desc *gd,
> +                                      struct ofpbuf *msg,
> +                                      enum ofp_version version)
> +{
> +    struct ofp15_group_desc_stats *ogds;
> +    uint16_t length, bucket_list_len;
> +    int error;
> +
> +    if (!msg->header) {
> +        ofpraw_pull_assert(msg);
> +    }
> +
> +    if (!msg->size) {
> +        return EOF;
> +    }
> +
> +    ogds = ofpbuf_try_pull(msg, sizeof *ogds);
> +    if (!ogds) {
> +        VLOG_WARN_RL(&rl, "OFPST11_GROUP_DESC reply has %"PRIu32" "
> +                     "leftover bytes at end", msg->size);
> +        return OFPERR_OFPBRC_BAD_LEN;
> +    }
> +    gd->type = ogds->type;
> +    gd->group_id = ntohl(ogds->group_id);
> +
> +    length = ntohs(ogds->length);
> +    if (length < sizeof *ogds || length - sizeof *ogds > msg->size) {
> +        VLOG_WARN_RL(&rl, "OFPST11_GROUP_DESC reply claims invalid "
> +                     "length %u", length);
> +        return OFPERR_OFPBRC_BAD_LEN;
> +    }
> +
> +    bucket_list_len = ntohs(ogds->bucket_list_len);
> +    if (length < bucket_list_len + sizeof *ogds) {
> +        VLOG_WARN_RL(&rl, "OFPST11_GROUP_DESC reply claims invalid "
> +                     "bucket list length %u", bucket_list_len);
> +        return OFPERR_OFPBRC_BAD_LEN;
> +    }
> +    error = ofputil_pull_ofp15_buckets(msg, bucket_list_len, version,
> gd->type,
> +                                       &gd->buckets);
> +    if (error) {
> +        return error;
> +    }
> +
> +    /* By definition group desc messages don't have a group mod command.
> +     * However, parse_group_prop_ntr_selection_method() checks to make
> sure
> +     * that the command is OFPGC15_ADD or OFPGC15_DELETE to guard
> +     * against group mod messages with other commands supplying
> +     * a NTR selection method group experimenter property.
> +     * Such properties are valid for group desc replies so
> +     * claim that the group mod command is OFPGC15_ADD to
> +     * satisfy the check in parse_group_prop_ntr_selection_method() */
> +    error = parse_ofp15_group_properties(
> +        msg, gd->type, OFPGC15_ADD, &gd->props,
> +        length - sizeof *ogds - bucket_list_len);
> +    if (error) {
> +        ofputil_bucket_list_destroy(&gd->buckets);
> +    }
> +    return error;
> +}
> +
> +/* Converts a group description reply in 'msg' into an abstract
> + * ofputil_group_desc in 'gd'.
> + *
> + * Multiple group description replies can be packed into a single OpenFlow
> + * message.  Calling this function multiple times for a single 'msg'
> iterates
> + * through the replies.  The caller must initially leave 'msg''s layer
> pointers
> + * null and not modify them between calls.
> + *
> + * Returns 0 if successful, EOF if no replies were left in this 'msg',
> + * otherwise a positive errno value. */
> +int
> +ofputil_decode_group_desc_reply(struct ofputil_group_desc *gd,
> +                                struct ofpbuf *msg, enum ofp_version
> version)
> +{
> +    ofputil_init_group_properties(&gd->props);
> +
> +    switch (version)
> +    {
> +    case OFP11_VERSION:
> +    case OFP12_VERSION:
> +    case OFP13_VERSION:
> +    case OFP14_VERSION:
> +        return ofputil_decode_ofp11_group_desc_reply(gd, msg, version);
> +
> +    case OFP15_VERSION:
> +    case OFP16_VERSION:
> +        return ofputil_decode_ofp15_group_desc_reply(gd, msg, version);
> +
> +    case OFP10_VERSION:
> +    default:
> +        OVS_NOT_REACHED();
> +    }
> +}
> +
> +void
> +ofputil_uninit_group_mod(struct ofputil_group_mod *gm)
> +{
> +    ofputil_bucket_list_destroy(&gm->buckets);
> +    ofputil_group_properties_destroy(&gm->props);
> +}
> +
> +static struct ofpbuf *
> +ofputil_encode_ofp11_group_mod(enum ofp_version ofp_version,
> +                               const struct ofputil_group_mod *gm)
> +{
> +    struct ofpbuf *b;
> +    struct ofp11_group_mod *ogm;
> +    size_t start_ogm;
> +    struct ofputil_bucket *bucket;
> +
> +    b = ofpraw_alloc(OFPRAW_OFPT11_GROUP_MOD, ofp_version, 0);
> +    start_ogm = b->size;
> +    ofpbuf_put_zeros(b, sizeof *ogm);
> +
> +    LIST_FOR_EACH (bucket, list_node, &gm->buckets) {
> +        ofputil_put_ofp11_bucket(bucket, b, ofp_version);
> +    }
> +    ogm = ofpbuf_at_assert(b, start_ogm, sizeof *ogm);
> +    ogm->command = htons(gm->command);
> +    ogm->type = gm->type;
> +    ogm->group_id = htonl(gm->group_id);
> +
> +    return b;
> +}
> +
> +static struct ofpbuf *
> +ofputil_encode_ofp15_group_mod(enum ofp_version ofp_version,
> +                               const struct ofputil_group_mod *gm)
> +{
> +    struct ofpbuf *b;
> +    struct ofp15_group_mod *ogm;
> +    size_t start_ogm;
> +    struct ofputil_bucket *bucket;
> +    struct id_pool *bucket_ids = NULL;
> +
> +    b = ofpraw_alloc(OFPRAW_OFPT15_GROUP_MOD, ofp_version, 0);
> +    start_ogm = b->size;
> +    ofpbuf_put_zeros(b, sizeof *ogm);
> +
> +    LIST_FOR_EACH (bucket, list_node, &gm->buckets) {
> +        uint32_t bucket_id;
> +
> +        /* Generate a bucket id if none was supplied */
> +        if (bucket->bucket_id > OFPG15_BUCKET_MAX) {
> +            if (!bucket_ids) {
> +                const struct ofputil_bucket *bkt;
> +
> +                bucket_ids = id_pool_create(0, OFPG15_BUCKET_MAX + 1);
> +
> +                /* Mark all bucket_ids that are present in gm
> +                 * as used in the pool. */
> +                LIST_FOR_EACH_REVERSE (bkt, list_node, &gm->buckets) {
> +                    if (bkt == bucket) {
> +                        break;
> +                    }
> +                    if (bkt->bucket_id <= OFPG15_BUCKET_MAX) {
> +                        id_pool_add(bucket_ids, bkt->bucket_id);
> +                    }
> +                }
> +            }
> +
> +            if (!id_pool_alloc_id(bucket_ids, &bucket_id)) {
> +                OVS_NOT_REACHED();
> +            }
> +        } else {
> +            bucket_id = bucket->bucket_id;
> +        }
> +
> +        ofputil_put_ofp15_bucket(bucket, bucket_id, gm->type, b,
> ofp_version);
> +    }
> +    ogm = ofpbuf_at_assert(b, start_ogm, sizeof *ogm);
> +    ogm->command = htons(gm->command);
> +    ogm->type = gm->type;
> +    ogm->group_id = htonl(gm->group_id);
> +    ogm->command_bucket_id = htonl(gm->command_bucket_id);
> +    ogm->bucket_array_len = htons(b->size - start_ogm - sizeof *ogm);
> +
> +    /* Add group properties */
> +    if (gm->props.selection_method[0]) {
> +        ofputil_put_group_prop_ntr_selection_method(ofp_version,
> &gm->props, b);
> +    }
> +
> +    id_pool_destroy(bucket_ids);
> +    return b;
> +}
> +
> +static void
> +bad_group_cmd(enum ofp15_group_mod_command cmd)
> +{
> +    const char *opt_version;
> +    const char *version;
> +    const char *cmd_str;
> +
> +    switch (cmd) {
> +    case OFPGC15_ADD:
> +    case OFPGC15_MODIFY:
> +    case OFPGC15_ADD_OR_MOD:
> +    case OFPGC15_DELETE:
> +        version = "1.1";
> +        opt_version = "11";
> +        break;
> +
> +    case OFPGC15_INSERT_BUCKET:
> +    case OFPGC15_REMOVE_BUCKET:
> +        version = "1.5";
> +        opt_version = "15";
> +        break;
> +
> +    default:
> +        OVS_NOT_REACHED();
> +    }
> +
> +    switch (cmd) {
> +    case OFPGC15_ADD:
> +        cmd_str = "add-group";
> +        break;
> +
> +    case OFPGC15_MODIFY:
> +    case OFPGC15_ADD_OR_MOD:
> +        cmd_str = "mod-group";
> +        break;
> +
> +    case OFPGC15_DELETE:
> +        cmd_str = "del-group";
> +        break;
> +
> +    case OFPGC15_INSERT_BUCKET:
> +        cmd_str = "insert-bucket";
> +        break;
> +
> +    case OFPGC15_REMOVE_BUCKET:
> +        cmd_str = "remove-bucket";
> +        break;
> +
> +    default:
> +        OVS_NOT_REACHED();
> +    }
> +
> +    ovs_fatal(0, "%s needs OpenFlow %s or later (\'-O OpenFlow%s\')",
> +              cmd_str, version, opt_version);
> +
> +}
> +
> +/* Converts abstract group mod 'gm' into a message for OpenFlow version
> + * 'ofp_version' and returns the message. */
> +struct ofpbuf *
> +ofputil_encode_group_mod(enum ofp_version ofp_version,
> +                         const struct ofputil_group_mod *gm)
> +{
> +
> +    switch (ofp_version) {
> +    case OFP10_VERSION:
> +        bad_group_cmd(gm->command);
> +        /* fall through */
> +
> +    case OFP11_VERSION:
> +    case OFP12_VERSION:
> +    case OFP13_VERSION:
> +    case OFP14_VERSION:
> +        if (gm->command > OFPGC11_DELETE && gm->command !=
> OFPGC11_ADD_OR_MOD) {
> +            bad_group_cmd(gm->command);
> +        }
> +        return ofputil_encode_ofp11_group_mod(ofp_version, gm);
> +
> +    case OFP15_VERSION:
> +    case OFP16_VERSION:
> +        return ofputil_encode_ofp15_group_mod(ofp_version, gm);
> +
> +    default:
> +        OVS_NOT_REACHED();
> +    }
> +}
> +
> +static enum ofperr
> +ofputil_pull_ofp11_group_mod(struct ofpbuf *msg, enum ofp_version
> ofp_version,
> +                             struct ofputil_group_mod *gm)
> +{
> +    const struct ofp11_group_mod *ogm;
> +    enum ofperr error;
> +
> +    ogm = ofpbuf_pull(msg, sizeof *ogm);
> +    gm->command = ntohs(ogm->command);
> +    gm->type = ogm->type;
> +    gm->group_id = ntohl(ogm->group_id);
> +    gm->command_bucket_id = OFPG15_BUCKET_ALL;
> +
> +    error = ofputil_pull_ofp11_buckets(msg, msg->size, ofp_version,
> +                                       &gm->buckets);
> +
> +    /* OF1.3.5+ prescribes an error when an OFPGC_DELETE includes
> buckets. */
> +    if (!error
> +        && ofp_version >= OFP13_VERSION
> +        && gm->command == OFPGC11_DELETE
> +        && !ovs_list_is_empty(&gm->buckets)) {
> +        error = OFPERR_OFPGMFC_INVALID_GROUP;
> +        ofputil_bucket_list_destroy(&gm->buckets);
> +    }
> +
> +    return error;
> +}
> +
> +static enum ofperr
> +ofputil_pull_ofp15_group_mod(struct ofpbuf *msg, enum ofp_version
> ofp_version,
> +                             struct ofputil_group_mod *gm)
> +{
> +    const struct ofp15_group_mod *ogm;
> +    uint16_t bucket_list_len;
> +    enum ofperr error = OFPERR_OFPGMFC_BAD_BUCKET;
> +
> +    ogm = ofpbuf_pull(msg, sizeof *ogm);
> +    gm->command = ntohs(ogm->command);
> +    gm->type = ogm->type;
> +    gm->group_id = ntohl(ogm->group_id);
> +
> +    gm->command_bucket_id = ntohl(ogm->command_bucket_id);
> +    switch (gm->command) {
> +    case OFPGC15_REMOVE_BUCKET:
> +        if (gm->command_bucket_id == OFPG15_BUCKET_ALL) {
> +            error = 0;
> +        }
> +        /* Fall through */
> +    case OFPGC15_INSERT_BUCKET:
> +        if (gm->command_bucket_id <= OFPG15_BUCKET_MAX ||
> +            gm->command_bucket_id == OFPG15_BUCKET_FIRST
> +            || gm->command_bucket_id == OFPG15_BUCKET_LAST) {
> +            error = 0;
> +        }
> +        break;
> +
> +    case OFPGC11_ADD:
> +    case OFPGC11_MODIFY:
> +    case OFPGC11_ADD_OR_MOD:
> +    case OFPGC11_DELETE:
> +    default:
> +        if (gm->command_bucket_id == OFPG15_BUCKET_ALL) {
> +            error = 0;
> +        }
> +        break;
> +    }
> +    if (error) {
> +        VLOG_WARN_RL(&rl,
> +                     "group command bucket id (%u) is out of range",
> +                     gm->command_bucket_id);
> +        return OFPERR_OFPGMFC_BAD_BUCKET;
> +    }
> +
> +    bucket_list_len = ntohs(ogm->bucket_array_len);
> +    if (bucket_list_len > msg->size) {
> +        return OFPERR_OFPBRC_BAD_LEN;
> +    }
> +    error = ofputil_pull_ofp15_buckets(msg, bucket_list_len, ofp_version,
> +                                       gm->type, &gm->buckets);
> +    if (error) {
> +        return error;
> +    }
> +
> +    error = parse_ofp15_group_properties(msg, gm->type, gm->command,
> +                                         &gm->props, msg->size);
> +    if (error) {
> +        ofputil_bucket_list_destroy(&gm->buckets);
> +    }
> +    return error;
> +}
> +
> +static enum ofperr
> +ofputil_check_group_mod(const struct ofputil_group_mod *gm)
> +{
> +    switch (gm->type) {
> +    case OFPGT11_INDIRECT:
> +        if (gm->command != OFPGC11_DELETE
> +            && !ovs_list_is_singleton(&gm->buckets) ) {
> +            return OFPERR_OFPGMFC_INVALID_GROUP;
> +        }
> +        break;
> +    case OFPGT11_ALL:
> +    case OFPGT11_SELECT:
> +    case OFPGT11_FF:
> +        break;
> +    default:
> +        return OFPERR_OFPGMFC_BAD_TYPE;
> +    }
> +
> +    switch (gm->command) {
> +    case OFPGC11_ADD:
> +    case OFPGC11_MODIFY:
> +    case OFPGC11_ADD_OR_MOD:
> +    case OFPGC11_DELETE:
> +    case OFPGC15_INSERT_BUCKET:
> +        break;
> +    case OFPGC15_REMOVE_BUCKET:
> +        if (!ovs_list_is_empty(&gm->buckets)) {
> +            return OFPERR_OFPGMFC_BAD_BUCKET;
> +        }
> +        break;
> +    default:
> +        return OFPERR_OFPGMFC_BAD_COMMAND;
> +    }
> +
> +    struct ofputil_bucket *bucket;
> +    LIST_FOR_EACH (bucket, list_node, &gm->buckets) {
> +        if (bucket->weight && gm->type != OFPGT11_SELECT) {
> +            return OFPERR_OFPGMFC_INVALID_GROUP;
> +        }
> +
> +        switch (gm->type) {
> +        case OFPGT11_ALL:
> +        case OFPGT11_INDIRECT:
> +            if (ofputil_bucket_has_liveness(bucket)) {
> +                return OFPERR_OFPGMFC_WATCH_UNSUPPORTED;
> +            }
> +            break;
> +        case OFPGT11_SELECT:
> +            break;
> +        case OFPGT11_FF:
> +            if (!ofputil_bucket_has_liveness(bucket)) {
> +                return OFPERR_OFPGMFC_INVALID_GROUP;
> +            }
> +            break;
> +        default:
> +            /* Returning BAD TYPE to be consistent
> +             * though gm->type has been checked already. */
> +            return OFPERR_OFPGMFC_BAD_TYPE;
> +        }
> +    }
> +
> +    return 0;
> +}
> +
> +/* Converts OpenFlow group mod message 'oh' into an abstract group mod in
> + * 'gm'.  Returns 0 if successful, otherwise an OpenFlow error code. */
> +enum ofperr
> +ofputil_decode_group_mod(const struct ofp_header *oh,
> +                         struct ofputil_group_mod *gm)
> +{
> +    ofputil_init_group_properties(&gm->props);
> +
> +    enum ofp_version ofp_version = oh->version;
> +    struct ofpbuf msg = ofpbuf_const_initializer(oh, ntohs(oh->length));
> +    ofpraw_pull_assert(&msg);
> +
> +    enum ofperr err;
> +    switch (ofp_version)
> +    {
> +    case OFP11_VERSION:
> +    case OFP12_VERSION:
> +    case OFP13_VERSION:
> +    case OFP14_VERSION:
> +        err = ofputil_pull_ofp11_group_mod(&msg, ofp_version, gm);
> +        break;
> +
> +    case OFP15_VERSION:
> +    case OFP16_VERSION:
> +        err = ofputil_pull_ofp15_group_mod(&msg, ofp_version, gm);
> +        break;
> +
> +    case OFP10_VERSION:
> +    default:
> +        OVS_NOT_REACHED();
> +    }
> +    if (err) {
> +        return err;
> +    }
> +
> +    err = ofputil_check_group_mod(gm);
> +    if (err) {
> +        ofputil_uninit_group_mod(gm);
> +    }
> +    return err;
> +}
> diff --git a/lib/ofp-ipfix.c b/lib/ofp-ipfix.c
> new file mode 100644
> index 000000000000..d710b5a4b225
> --- /dev/null
> +++ b/lib/ofp-ipfix.c
> @@ -0,0 +1,111 @@
> +/*
> + * Copyright (c) 2008-2017 Nicira, Inc.
> + *
> + * Licensed under the Apache License, Version 2.0 (the "License");
> + * you may not use this file except in compliance with the License.
> + * You may obtain a copy of the License at:
> + *
> + *     http://www.apache.org/licenses/LICENSE-2.0
> + *
> + * Unless required by applicable law or agreed to in writing, software
> + * distributed under the License is distributed on an "AS IS" BASIS,
> + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
> implied.
> + * See the License for the specific language governing permissions and
> + * limitations under the License.
> + */
> +
> +#include <config.h>
> +#include "openvswitch/ofp-ipfix.h"
> +#include <stdlib.h>
> +#include "byte-order.h"
> +#include "openflow/nicira-ext.h"
> +#include "openvswitch/ofp-errors.h"
> +#include "openvswitch/ofp-msgs.h"
> +#include "openvswitch/ofpbuf.h"
> +#include "util.h"
> +
> +static void
> +ofputil_ipfix_stats_to_reply(const struct ofputil_ipfix_stats *ois,
> +                            struct nx_ipfix_stats_reply *reply)
> +{
> +    reply->collector_set_id = htonl(ois->collector_set_id);
> +    reply->total_flows = htonll(ois->total_flows);
> +    reply->current_flows = htonll(ois->current_flows);
> +    reply->pkts = htonll(ois->pkts);
> +    reply->ipv4_pkts = htonll(ois->ipv4_pkts);
> +    reply->ipv6_pkts = htonll(ois->ipv6_pkts);
> +    reply->error_pkts = htonll(ois->error_pkts);
> +    reply->ipv4_error_pkts = htonll(ois->ipv4_error_pkts);
> +    reply->ipv6_error_pkts = htonll(ois->ipv6_error_pkts);
> +    reply->tx_pkts = htonll(ois->tx_pkts);
> +    reply->tx_errors = htonll(ois->tx_errors);
> +    memset(reply->pad, 0, sizeof reply->pad);
> +}
> +
> +/* Encode a ipfix stat for 'ois' and append it to 'replies'. */
> +void
> +ofputil_append_ipfix_stat(struct ovs_list *replies,
> +                         const struct ofputil_ipfix_stats *ois)
> +{
> +    struct nx_ipfix_stats_reply *reply = ofpmp_append(replies, sizeof
> *reply);
> +    ofputil_ipfix_stats_to_reply(ois, reply);
> +}
> +
> +static enum ofperr
> +ofputil_ipfix_stats_from_nx(struct ofputil_ipfix_stats *is,
> +                            const struct nx_ipfix_stats_reply *reply)
> +{
> +    is->collector_set_id = ntohl(reply->collector_set_id);
> +    is->total_flows = ntohll(reply->total_flows);
> +    is->current_flows = ntohll(reply->current_flows);
> +    is->pkts = ntohll(reply->pkts);
> +    is->ipv4_pkts = ntohll(reply->ipv4_pkts);
> +    is->ipv6_pkts = ntohll(reply->ipv6_pkts);
> +    is->error_pkts = ntohll(reply->error_pkts);
> +    is->ipv4_error_pkts = ntohll(reply->ipv4_error_pkts);
> +    is->ipv6_error_pkts = ntohll(reply->ipv6_error_pkts);
> +    is->tx_pkts = ntohll(reply->tx_pkts);
> +    is->tx_errors = ntohll(reply->tx_errors);
> +
> +    return 0;
> +}
> +
> +int
> +ofputil_pull_ipfix_stats(struct ofputil_ipfix_stats *is, struct ofpbuf
> *msg)
> +{
> +    enum ofperr error;
> +    enum ofpraw raw;
> +
> +    memset(is, 0xFF, sizeof (*is));
> +
> +    error = (msg->header ? ofpraw_decode(&raw, msg->header)
> +             : ofpraw_pull(&raw, msg));
> +    if (error) {
> +        return error;
> +    }
> +
> +    if (!msg->size) {
> +        return EOF;
> +    } else if (raw == OFPRAW_NXST_IPFIX_BRIDGE_REPLY ||
> +               raw == OFPRAW_NXST_IPFIX_FLOW_REPLY) {
> +        struct nx_ipfix_stats_reply *reply;
> +
> +        reply = ofpbuf_try_pull(msg, sizeof *reply);
> +        return ofputil_ipfix_stats_from_nx(is, reply);
> +    } else {
> +        OVS_NOT_REACHED();
> +    }
> +}
> +
> +
> +/* Returns the number of ipfix stats elements in
> + * OFPTYPE_IPFIX_BRIDGE_STATS_REPLY or OFPTYPE_IPFIX_FLOW_STATS_REPLY
> + * message 'oh'. */
> +size_t
> +ofputil_count_ipfix_stats(const struct ofp_header *oh)
> +{
> +    struct ofpbuf b = ofpbuf_const_initializer(oh, ntohs(oh->length));
> +    ofpraw_pull_assert(&b);
> +
> +    return b.size / sizeof(struct ofputil_ipfix_stats);
> +}
> diff --git a/lib/ofp-match.c b/lib/ofp-match.c
> new file mode 100644
> index 000000000000..73d575fee85d
> --- /dev/null
> +++ b/lib/ofp-match.c
> @@ -0,0 +1,954 @@
> +/*
> + * Copyright (c) 2008-2017 Nicira, Inc.
> + *
> + * Licensed under the Apache License, Version 2.0 (the "License");
> + * you may not use this file except in compliance with the License.
> + * You may obtain a copy of the License at:
> + *
> + *     http://www.apache.org/licenses/LICENSE-2.0
> + *
> + * Unless required by applicable law or agreed to in writing, software
> + * distributed under the License is distributed on an "AS IS" BASIS,
> + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
> implied.
> + * See the License for the specific language governing permissions and
> + * limitations under the License.
> + */
> +
> +#include <config.h>
> +#include "openvswitch/ofp-match.h"
> +#include "byte-order.h"
> +#include "flow.h"
> +#include "nx-match.h"
> +#include "openvswitch/match.h"
> +#include "openvswitch/ofp-errors.h"
> +#include "openvswitch/ofp-msgs.h"
> +#include "openvswitch/ofp-port.h"
> +#include "openvswitch/packets.h"
> +#include "openvswitch/vlog.h"
> +
> +VLOG_DEFINE_THIS_MODULE(ofp_match);
> +
> +static struct vlog_rate_limit rl = VLOG_RATE_LIMIT_INIT(1, 5);
> +
> +/* Given the wildcard bit count in the least-significant 6 of 'wcbits',
> returns
> + * an IP netmask with a 1 in each bit that must match and a 0 in each bit
> that
> + * is wildcarded.
> + *
> + * The bits in 'wcbits' are in the format used in enum
> ofp_flow_wildcards: 0
> + * is exact match, 1 ignores the LSB, 2 ignores the 2 least-significant
> bits,
> + * ..., 32 and higher wildcard the entire field.  This is the *opposite*
> of the
> + * usual convention where e.g. /24 indicates that 8 bits (not 24 bits) are
> + * wildcarded. */
> +ovs_be32
> +ofputil_wcbits_to_netmask(int wcbits)
> +{
> +    wcbits &= 0x3f;
> +    return wcbits < 32 ? htonl(~((1u << wcbits) - 1)) : 0;
> +}
> +
> +/* Given the IP netmask 'netmask', returns the number of bits of the IP
> address
> + * that it wildcards, that is, the number of 0-bits in 'netmask', a number
> + * between 0 and 32 inclusive.
> + *
> + * If 'netmask' is not a CIDR netmask (see ip_is_cidr()), the return
> value will
> + * still be in the valid range but isn't otherwise meaningful. */
> +int
> +ofputil_netmask_to_wcbits(ovs_be32 netmask)
> +{
> +    return 32 - ip_count_cidr_bits(netmask);
> +}
> +
> +/* Converts the OpenFlow 1.0 wildcards in 'ofpfw' (OFPFW10_*) into a
> + * flow_wildcards in 'wc' for use in struct match.  It is the caller's
> + * responsibility to handle the special case where the flow match's
> dl_vlan is
> + * set to OFP_VLAN_NONE. */
> +void
> +ofputil_wildcard_from_ofpfw10(uint32_t ofpfw, struct flow_wildcards *wc)
> +{
> +    BUILD_ASSERT_DECL(FLOW_WC_SEQ == 40);
> +
> +    /* Initialize most of wc. */
> +    flow_wildcards_init_catchall(wc);
> +
> +    if (!(ofpfw & OFPFW10_IN_PORT)) {
> +        wc->masks.in_port.ofp_port = u16_to_ofp(UINT16_MAX);
> +    }
> +
> +    if (!(ofpfw & OFPFW10_NW_TOS)) {
> +        wc->masks.nw_tos |= IP_DSCP_MASK;
> +    }
> +
> +    if (!(ofpfw & OFPFW10_NW_PROTO)) {
> +        wc->masks.nw_proto = UINT8_MAX;
> +    }
> +    wc->masks.nw_src = ofputil_wcbits_to_netmask(ofpfw
> +                                                 >> OFPFW10_NW_SRC_SHIFT);
> +    wc->masks.nw_dst = ofputil_wcbits_to_netmask(ofpfw
> +                                                 >> OFPFW10_NW_DST_SHIFT);
> +
> +    if (!(ofpfw & OFPFW10_TP_SRC)) {
> +        wc->masks.tp_src = OVS_BE16_MAX;
> +    }
> +    if (!(ofpfw & OFPFW10_TP_DST)) {
> +        wc->masks.tp_dst = OVS_BE16_MAX;
> +    }
> +
> +    if (!(ofpfw & OFPFW10_DL_SRC)) {
> +        WC_MASK_FIELD(wc, dl_src);
> +    }
> +    if (!(ofpfw & OFPFW10_DL_DST)) {
> +        WC_MASK_FIELD(wc, dl_dst);
> +    }
> +    if (!(ofpfw & OFPFW10_DL_TYPE)) {
> +        wc->masks.dl_type = OVS_BE16_MAX;
> +    }
> +
> +    /* VLAN TCI mask. */
> +    if (!(ofpfw & OFPFW10_DL_VLAN_PCP)) {
> +        wc->masks.vlans[0].tci |= htons(VLAN_PCP_MASK | VLAN_CFI);
> +    }
> +    if (!(ofpfw & OFPFW10_DL_VLAN)) {
> +        wc->masks.vlans[0].tci |= htons(VLAN_VID_MASK | VLAN_CFI);
> +    }
> +}
> +
> +/* Converts the ofp10_match in 'ofmatch' into a struct match in 'match'.
> */
> +void
> +ofputil_match_from_ofp10_match(const struct ofp10_match *ofmatch,
> +                               struct match *match)
> +{
> +    uint32_t ofpfw = ntohl(ofmatch->wildcards) & OFPFW10_ALL;
> +
> +    /* Initialize match->wc. */
> +    memset(&match->flow, 0, sizeof match->flow);
> +    ofputil_wildcard_from_ofpfw10(ofpfw, &match->wc);
> +    memset(&match->tun_md, 0, sizeof match->tun_md);
> +
> +    /* If any fields, except in_port, are matched, then we also need to
> match
> +     * on the Ethernet packet_type. */
> +    const uint32_t ofpfw_data_bits = (OFPFW10_NW_TOS | OFPFW10_NW_PROTO
> +                                      | OFPFW10_TP_SRC | OFPFW10_TP_DST
> +                                      | OFPFW10_DL_SRC | OFPFW10_DL_DST
> +                                      | OFPFW10_DL_TYPE
> +                                      | OFPFW10_DL_VLAN |
> OFPFW10_DL_VLAN_PCP);
> +    if ((ofpfw & ofpfw_data_bits) != ofpfw_data_bits
> +        || ofputil_wcbits_to_netmask(ofpfw >> OFPFW10_NW_SRC_SHIFT)
> +        || ofputil_wcbits_to_netmask(ofpfw >> OFPFW10_NW_DST_SHIFT)) {
> +        match_set_default_packet_type(match);
> +    }
> +
> +    /* Initialize most of match->flow. */
> +    match->flow.nw_src = ofmatch->nw_src;
> +    match->flow.nw_dst = ofmatch->nw_dst;
> +    match->flow.in_port.ofp_port = u16_to_ofp(ntohs(ofmatch->in_port));
> +    match->flow.dl_type = ofputil_dl_type_from_openflow(
> ofmatch->dl_type);
> +    match->flow.tp_src = ofmatch->tp_src;
> +    match->flow.tp_dst = ofmatch->tp_dst;
> +    match->flow.dl_src = ofmatch->dl_src;
> +    match->flow.dl_dst = ofmatch->dl_dst;
> +    match->flow.nw_tos = ofmatch->nw_tos & IP_DSCP_MASK;
> +    match->flow.nw_proto = ofmatch->nw_proto;
> +
> +    /* Translate VLANs. */
> +    if (!(ofpfw & OFPFW10_DL_VLAN) &&
> +        ofmatch->dl_vlan == htons(OFP10_VLAN_NONE)) {
> +        /* Match only packets without 802.1Q header.
> +         *
> +         * When OFPFW10_DL_VLAN_PCP is wildcarded, this is obviously
> correct.
> +         *
> +         * If OFPFW10_DL_VLAN_PCP is matched, the flow match is
> contradictory,
> +         * because we can't have a specific PCP without an 802.1Q header.
> +         * However, older versions of OVS treated this as matching packets
> +         * withut an 802.1Q header, so we do here too. */
> +        match->flow.vlans[0].tci = htons(0);
> +        match->wc.masks.vlans[0].tci = htons(0xffff);
> +    } else {
> +        ovs_be16 vid, pcp, tci;
> +        uint16_t hpcp;
> +
> +        vid = ofmatch->dl_vlan & htons(VLAN_VID_MASK);
> +        hpcp = (ofmatch->dl_vlan_pcp << VLAN_PCP_SHIFT) & VLAN_PCP_MASK;
> +        pcp = htons(hpcp);
> +        tci = vid | pcp | htons(VLAN_CFI);
> +        match->flow.vlans[0].tci = tci & match->wc.masks.vlans[0].tci;
> +    }
> +
> +    /* Clean up. */
> +    match_zero_wildcarded_fields(match);
> +}
> +
> +/* Convert 'match' into the OpenFlow 1.0 match structure 'ofmatch'. */
> +void
> +ofputil_match_to_ofp10_match(const struct match *match,
> +                             struct ofp10_match *ofmatch)
> +{
> +    const struct flow_wildcards *wc = &match->wc;
> +    uint32_t ofpfw;
> +
> +    /* Figure out most OpenFlow wildcards. */
> +    ofpfw = 0;
> +    if (!wc->masks.in_port.ofp_port) {
> +        ofpfw |= OFPFW10_IN_PORT;
> +    }
> +    if (!wc->masks.dl_type) {
> +        ofpfw |= OFPFW10_DL_TYPE;
> +    }
> +    if (!wc->masks.nw_proto) {
> +        ofpfw |= OFPFW10_NW_PROTO;
> +    }
> +    ofpfw |= (ofputil_netmask_to_wcbits(wc->masks.nw_src)
> +              << OFPFW10_NW_SRC_SHIFT);
> +    ofpfw |= (ofputil_netmask_to_wcbits(wc->masks.nw_dst)
> +              << OFPFW10_NW_DST_SHIFT);
> +    if (!(wc->masks.nw_tos & IP_DSCP_MASK)) {
> +        ofpfw |= OFPFW10_NW_TOS;
> +    }
> +    if (!wc->masks.tp_src) {
> +        ofpfw |= OFPFW10_TP_SRC;
> +    }
> +    if (!wc->masks.tp_dst) {
> +        ofpfw |= OFPFW10_TP_DST;
> +    }
> +    if (eth_addr_is_zero(wc->masks.dl_src)) {
> +        ofpfw |= OFPFW10_DL_SRC;
> +    }
> +    if (eth_addr_is_zero(wc->masks.dl_dst)) {
> +        ofpfw |= OFPFW10_DL_DST;
> +    }
> +
> +    /* Translate VLANs. */
> +    ofmatch->dl_vlan = htons(0);
> +    ofmatch->dl_vlan_pcp = 0;
> +    if (match->wc.masks.vlans[0].tci == htons(0)) {
> +        ofpfw |= OFPFW10_DL_VLAN | OFPFW10_DL_VLAN_PCP;
> +    } else if (match->wc.masks.vlans[0].tci & htons(VLAN_CFI)
> +               && !(match->flow.vlans[0].tci & htons(VLAN_CFI))) {
> +        ofmatch->dl_vlan = htons(OFP10_VLAN_NONE);
> +    } else {
> +        if (!(match->wc.masks.vlans[0].tci & htons(VLAN_VID_MASK))) {
> +            ofpfw |= OFPFW10_DL_VLAN;
> +        } else {
> +            ofmatch->dl_vlan =
> +                htons(vlan_tci_to_vid(match->flow.vlans[0].tci));
> +        }
> +
> +        if (!(match->wc.masks.vlans[0].tci & htons(VLAN_PCP_MASK))) {
> +            ofpfw |= OFPFW10_DL_VLAN_PCP;
> +        } else {
> +            ofmatch->dl_vlan_pcp = vlan_tci_to_pcp(match->flow.
> vlans[0].tci);
> +        }
> +    }
> +
> +    /* Compose most of the match structure. */
> +    ofmatch->wildcards = htonl(ofpfw);
> +    ofmatch->in_port = htons(ofp_to_u16(match->flow.in_port.ofp_port));
> +    ofmatch->dl_src = match->flow.dl_src;
> +    ofmatch->dl_dst = match->flow.dl_dst;
> +    ofmatch->dl_type = ofputil_dl_type_to_openflow(match->flow.dl_type);
> +    ofmatch->nw_src = match->flow.nw_src;
> +    ofmatch->nw_dst = match->flow.nw_dst;
> +    ofmatch->nw_tos = match->flow.nw_tos & IP_DSCP_MASK;
> +    ofmatch->nw_proto = match->flow.nw_proto;
> +    ofmatch->tp_src = match->flow.tp_src;
> +    ofmatch->tp_dst = match->flow.tp_dst;
> +    memset(ofmatch->pad1, '\0', sizeof ofmatch->pad1);
> +    memset(ofmatch->pad2, '\0', sizeof ofmatch->pad2);
> +}
> +
> +enum ofperr
> +ofputil_pull_ofp11_match(struct ofpbuf *buf, const struct tun_table
> *tun_table,
> +                         const struct vl_mff_map *vl_mff_map,
> +                         struct match *match, uint16_t *padded_match_len)
> +{
> +    struct ofp11_match_header *omh = buf->data;
> +    uint16_t match_len;
> +
> +    if (buf->size < sizeof *omh) {
> +        return OFPERR_OFPBMC_BAD_LEN;
> +    }
> +
> +    match_len = ntohs(omh->length);
> +
> +    switch (ntohs(omh->type)) {
> +    case OFPMT_STANDARD: {
> +        struct ofp11_match *om;
> +
> +        if (match_len != sizeof *om || buf->size < sizeof *om) {
> +            return OFPERR_OFPBMC_BAD_LEN;
> +        }
> +        om = ofpbuf_pull(buf, sizeof *om);
> +        if (padded_match_len) {
> +            *padded_match_len = match_len;
> +        }
> +        return ofputil_match_from_ofp11_match(om, match);
> +    }
> +
> +    case OFPMT_OXM:
> +        if (padded_match_len) {
> +            *padded_match_len = ROUND_UP(match_len, 8);
> +        }
> +        return oxm_pull_match(buf, false, tun_table, vl_mff_map, match);
> +
> +    default:
> +        return OFPERR_OFPBMC_BAD_TYPE;
> +    }
> +}
> +
> +/* Converts the ofp11_match in 'ofmatch' into a struct match in 'match'.
> + * Returns 0 if successful, otherwise an OFPERR_* value. */
> +enum ofperr
> +ofputil_match_from_ofp11_match(const struct ofp11_match *ofmatch,
> +                               struct match *match)
> +{
> +    uint16_t wc = ntohl(ofmatch->wildcards);
> +    bool ipv4, arp, rarp;
> +
> +    match_init_catchall(match);
> +    match->flow.tunnel.metadata.tab = NULL;
> +
> +    if (!(wc & OFPFW11_IN_PORT)) {
> +        ofp_port_t ofp_port;
> +        enum ofperr error;
> +
> +        error = ofputil_port_from_ofp11(ofmatch->in_port, &ofp_port);
> +        if (error) {
> +            return OFPERR_OFPBMC_BAD_VALUE;
> +        }
> +        match_set_in_port(match, ofp_port);
> +    }
> +
> +    struct eth_addr dl_src_mask = eth_addr_invert(ofmatch->dl_src_mask);
> +    struct eth_addr dl_dst_mask = eth_addr_invert(ofmatch->dl_dst_mask);
> +    if (!eth_addr_is_zero(dl_src_mask) || !eth_addr_is_zero(dl_dst_mask))
> {
> +        match_set_dl_src_masked(match, ofmatch->dl_src, dl_src_mask);
> +        match_set_dl_dst_masked(match, ofmatch->dl_dst, dl_dst_mask);
> +        match_set_default_packet_type(match);
> +    }
> +
> +    if (!(wc & OFPFW11_DL_VLAN)) {
> +        if (ofmatch->dl_vlan == htons(OFPVID11_NONE)) {
> +            /* Match only packets without a VLAN tag. */
> +            match->flow.vlans[0].tci = htons(0);
> +            match->wc.masks.vlans[0].tci = OVS_BE16_MAX;
> +        } else {
> +            if (ofmatch->dl_vlan == htons(OFPVID11_ANY)) {
> +                /* Match any packet with a VLAN tag regardless of VID. */
> +                match->flow.vlans[0].tci = htons(VLAN_CFI);
> +                match->wc.masks.vlans[0].tci = htons(VLAN_CFI);
> +            } else if (ntohs(ofmatch->dl_vlan) < 4096) {
> +                /* Match only packets with the specified VLAN VID. */
> +                match->flow.vlans[0].tci = htons(VLAN_CFI) |
> ofmatch->dl_vlan;
> +                match->wc.masks.vlans[0].tci = htons(VLAN_CFI |
> VLAN_VID_MASK);
> +            } else {
> +                /* Invalid VID. */
> +                return OFPERR_OFPBMC_BAD_VALUE;
> +            }
> +
> +            if (!(wc & OFPFW11_DL_VLAN_PCP)) {
> +                if (ofmatch->dl_vlan_pcp <= 7) {
> +                    match->flow.vlans[0].tci |= htons(ofmatch->dl_vlan_pcp
> +                                                  << VLAN_PCP_SHIFT);
> +                    match->wc.masks.vlans[0].tci |= htons(VLAN_PCP_MASK);
> +                } else {
> +                    /* Invalid PCP. */
> +                    return OFPERR_OFPBMC_BAD_VALUE;
> +                }
> +            }
> +        }
> +        match_set_default_packet_type(match);
> +    }
> +
> +    if (!(wc & OFPFW11_DL_TYPE)) {
> +        match_set_dl_type(match,
> +                          ofputil_dl_type_from_openflow(
> ofmatch->dl_type));
> +        match_set_default_packet_type(match);
> +    }
> +
> +    ipv4 = match->flow.dl_type == htons(ETH_TYPE_IP);
> +    arp = match->flow.dl_type == htons(ETH_TYPE_ARP);
> +    rarp = match->flow.dl_type == htons(ETH_TYPE_RARP);
> +
> +    if (ipv4 && !(wc & OFPFW11_NW_TOS)) {
> +        if (ofmatch->nw_tos & ~IP_DSCP_MASK) {
> +            /* Invalid TOS. */
> +            return OFPERR_OFPBMC_BAD_VALUE;
> +        }
> +
> +        match_set_nw_dscp(match, ofmatch->nw_tos);
> +    }
> +
> +    if (ipv4 || arp || rarp) {
> +        if (!(wc & OFPFW11_NW_PROTO)) {
> +            match_set_nw_proto(match, ofmatch->nw_proto);
> +        }
> +        match_set_nw_src_masked(match, ofmatch->nw_src,
> ~ofmatch->nw_src_mask);
> +        match_set_nw_dst_masked(match, ofmatch->nw_dst,
> ~ofmatch->nw_dst_mask);
> +    }
> +
> +#define OFPFW11_TP_ALL (OFPFW11_TP_SRC | OFPFW11_TP_DST)
> +    if (ipv4 && (wc & OFPFW11_TP_ALL) != OFPFW11_TP_ALL) {
> +        switch (match->flow.nw_proto) {
> +        case IPPROTO_ICMP:
> +            /* "A.2.3 Flow Match Structures" in OF1.1 says:
> +             *
> +             *    The tp_src and tp_dst fields will be ignored unless the
> +             *    network protocol specified is as TCP, UDP or SCTP.
> +             *
> +             * but I'm pretty sure we should support ICMP too, otherwise
> +             * that's a regression from OF1.0. */
> +            if (!(wc & OFPFW11_TP_SRC)) {
> +                uint16_t icmp_type = ntohs(ofmatch->tp_src);
> +                if (icmp_type < 0x100) {
> +                    match_set_icmp_type(match, icmp_type);
> +                } else {
> +                    return OFPERR_OFPBMC_BAD_FIELD;
> +                }
> +            }
> +            if (!(wc & OFPFW11_TP_DST)) {
> +                uint16_t icmp_code = ntohs(ofmatch->tp_dst);
> +                if (icmp_code < 0x100) {
> +                    match_set_icmp_code(match, icmp_code);
> +                } else {
> +                    return OFPERR_OFPBMC_BAD_FIELD;
> +                }
> +            }
> +            break;
> +
> +        case IPPROTO_TCP:
> +        case IPPROTO_UDP:
> +        case IPPROTO_SCTP:
> +            if (!(wc & (OFPFW11_TP_SRC))) {
> +                match_set_tp_src(match, ofmatch->tp_src);
> +            }
> +            if (!(wc & (OFPFW11_TP_DST))) {
> +                match_set_tp_dst(match, ofmatch->tp_dst);
> +            }
> +            break;
> +
> +        default:
> +            /* OF1.1 says explicitly to ignore this. */
> +            break;
> +        }
> +    }
> +
> +    if (eth_type_mpls(match->flow.dl_type)) {
> +        if (!(wc & OFPFW11_MPLS_LABEL)) {
> +            match_set_mpls_label(match, 0, ofmatch->mpls_label);
> +        }
> +        if (!(wc & OFPFW11_MPLS_TC)) {
> +            match_set_mpls_tc(match, 0, ofmatch->mpls_tc);
> +        }
> +    }
> +
> +    match_set_metadata_masked(match, ofmatch->metadata,
> +                              ~ofmatch->metadata_mask);
> +
> +    return 0;
> +}
> +
> +/* Convert 'match' into the OpenFlow 1.1 match structure 'ofmatch'. */
> +void
> +ofputil_match_to_ofp11_match(const struct match *match,
> +                             struct ofp11_match *ofmatch)
> +{
> +    uint32_t wc = 0;
> +
> +    memset(ofmatch, 0, sizeof *ofmatch);
> +    ofmatch->omh.type = htons(OFPMT_STANDARD);
> +    ofmatch->omh.length = htons(OFPMT11_STANDARD_LENGTH);
> +
> +    if (!match->wc.masks.in_port.ofp_port) {
> +        wc |= OFPFW11_IN_PORT;
> +    } else {
> +        ofmatch->in_port = ofputil_port_to_ofp11(match->
> flow.in_port.ofp_port);
> +    }
> +
> +    ofmatch->dl_src = match->flow.dl_src;
> +    ofmatch->dl_src_mask = eth_addr_invert(match->wc.masks.dl_src);
> +    ofmatch->dl_dst = match->flow.dl_dst;
> +    ofmatch->dl_dst_mask = eth_addr_invert(match->wc.masks.dl_dst);
> +
> +    if (match->wc.masks.vlans[0].tci == htons(0)) {
> +        wc |= OFPFW11_DL_VLAN | OFPFW11_DL_VLAN_PCP;
> +    } else if (match->wc.masks.vlans[0].tci & htons(VLAN_CFI)
> +               && !(match->flow.vlans[0].tci & htons(VLAN_CFI))) {
> +        ofmatch->dl_vlan = htons(OFPVID11_NONE);
> +        wc |= OFPFW11_DL_VLAN_PCP;
> +    } else {
> +        if (!(match->wc.masks.vlans[0].tci & htons(VLAN_VID_MASK))) {
> +            ofmatch->dl_vlan = htons(OFPVID11_ANY);
> +        } else {
> +            ofmatch->dl_vlan =
> +                htons(vlan_tci_to_vid(match->flow.vlans[0].tci));
> +        }
> +
> +        if (!(match->wc.masks.vlans[0].tci & htons(VLAN_PCP_MASK))) {
> +            wc |= OFPFW11_DL_VLAN_PCP;
> +        } else {
> +            ofmatch->dl_vlan_pcp = vlan_tci_to_pcp(match->flow.
> vlans[0].tci);
> +        }
> +    }
> +
> +    if (!match->wc.masks.dl_type) {
> +        wc |= OFPFW11_DL_TYPE;
> +    } else {
> +        ofmatch->dl_type = ofputil_dl_type_to_openflow(
> match->flow.dl_type);
> +    }
> +
> +    if (!(match->wc.masks.nw_tos & IP_DSCP_MASK)) {
> +        wc |= OFPFW11_NW_TOS;
> +    } else {
> +        ofmatch->nw_tos = match->flow.nw_tos & IP_DSCP_MASK;
> +    }
> +
> +    if (!match->wc.masks.nw_proto) {
> +        wc |= OFPFW11_NW_PROTO;
> +    } else {
> +        ofmatch->nw_proto = match->flow.nw_proto;
> +    }
> +
> +    ofmatch->nw_src = match->flow.nw_src;
> +    ofmatch->nw_src_mask = ~match->wc.masks.nw_src;
> +    ofmatch->nw_dst = match->flow.nw_dst;
> +    ofmatch->nw_dst_mask = ~match->wc.masks.nw_dst;
> +
> +    if (!match->wc.masks.tp_src) {
> +        wc |= OFPFW11_TP_SRC;
> +    } else {
> +        ofmatch->tp_src = match->flow.tp_src;
> +    }
> +
> +    if (!match->wc.masks.tp_dst) {
> +        wc |= OFPFW11_TP_DST;
> +    } else {
> +        ofmatch->tp_dst = match->flow.tp_dst;
> +    }
> +
> +    if (!(match->wc.masks.mpls_lse[0] & htonl(MPLS_LABEL_MASK))) {
> +        wc |= OFPFW11_MPLS_LABEL;
> +    } else {
> +        ofmatch->mpls_label = htonl(mpls_lse_to_label(
> +                                        match->flow.mpls_lse[0]));
> +    }
> +
> +    if (!(match->wc.masks.mpls_lse[0] & htonl(MPLS_TC_MASK))) {
> +        wc |= OFPFW11_MPLS_TC;
> +    } else {
> +        ofmatch->mpls_tc = mpls_lse_to_tc(match->flow.mpls_lse[0]);
> +    }
> +
> +    ofmatch->metadata = match->flow.metadata;
> +    ofmatch->metadata_mask = ~match->wc.masks.metadata;
> +
> +    ofmatch->wildcards = htonl(wc);
> +}
> +
> +/* Returns the "typical" length of a match for 'protocol', for use in
> + * estimating space to preallocate. */
> +int
> +ofputil_match_typical_len(enum ofputil_protocol protocol)
> +{
> +    switch (protocol) {
> +    case OFPUTIL_P_OF10_STD:
> +    case OFPUTIL_P_OF10_STD_TID:
> +        return sizeof(struct ofp10_match);
> +
> +    case OFPUTIL_P_OF10_NXM:
> +    case OFPUTIL_P_OF10_NXM_TID:
> +        return NXM_TYPICAL_LEN;
> +
> +    case OFPUTIL_P_OF11_STD:
> +        return sizeof(struct ofp11_match);
> +
> +    case OFPUTIL_P_OF12_OXM:
> +    case OFPUTIL_P_OF13_OXM:
> +    case OFPUTIL_P_OF14_OXM:
> +    case OFPUTIL_P_OF15_OXM:
> +    case OFPUTIL_P_OF16_OXM:
> +        return NXM_TYPICAL_LEN;
> +
> +    default:
> +        OVS_NOT_REACHED();
> +    }
> +}
> +
> +/* Appends to 'b' an struct ofp11_match_header followed by a match that
> + * expresses 'match' properly for 'protocol', plus enough zero bytes to
> pad the
> + * data appended out to a multiple of 8.  'protocol' must be one that is
> usable
> + * in OpenFlow 1.1 or later.
> + *
> + * This function can cause 'b''s data to be reallocated.
> + *
> + * Returns the number of bytes appended to 'b', excluding the padding.
> Never
> + * returns zero. */
> +int
> +ofputil_put_ofp11_match(struct ofpbuf *b, const struct match *match,
> +                        enum ofputil_protocol protocol)
> +{
> +    switch (protocol) {
> +    case OFPUTIL_P_OF10_STD:
> +    case OFPUTIL_P_OF10_STD_TID:
> +    case OFPUTIL_P_OF10_NXM:
> +    case OFPUTIL_P_OF10_NXM_TID:
> +        OVS_NOT_REACHED();
> +
> +    case OFPUTIL_P_OF11_STD: {
> +        struct ofp11_match *om;
> +
> +        /* Make sure that no padding is needed. */
> +        BUILD_ASSERT_DECL(sizeof *om % 8 == 0);
> +
> +        om = ofpbuf_put_uninit(b, sizeof *om);
> +        ofputil_match_to_ofp11_match(match, om);
> +        return sizeof *om;
> +    }
> +
> +    case OFPUTIL_P_OF12_OXM:
> +    case OFPUTIL_P_OF13_OXM:
> +    case OFPUTIL_P_OF14_OXM:
> +    case OFPUTIL_P_OF15_OXM:
> +    case OFPUTIL_P_OF16_OXM:
> +        return oxm_put_match(b, match,
> +                             ofputil_protocol_to_ofp_version(protocol));
> +    }
> +
> +    OVS_NOT_REACHED();
> +}
> +
> +/* Given a 'dl_type' value in the format used in struct flow, returns the
> + * corresponding 'dl_type' value for use in an ofp10_match or ofp11_match
> + * structure. */
> +ovs_be16
> +ofputil_dl_type_to_openflow(ovs_be16 flow_dl_type)
> +{
> +    return (flow_dl_type == htons(FLOW_DL_TYPE_NONE)
> +            ? htons(OFP_DL_TYPE_NOT_ETH_TYPE)
> +            : flow_dl_type);
> +}
> +
> +/* Given a 'dl_type' value in the format used in an ofp10_match or
> ofp11_match
> + * structure, returns the corresponding 'dl_type' value for use in struct
> + * flow. */
> +ovs_be16
> +ofputil_dl_type_from_openflow(ovs_be16 ofp_dl_type)
> +{
> +    return (ofp_dl_type == htons(OFP_DL_TYPE_NOT_ETH_TYPE)
> +            ? htons(FLOW_DL_TYPE_NONE)
> +            : ofp_dl_type);
> +}
> +
> +static void
> +encode_tlv_table_mappings(struct ofpbuf *b, struct ovs_list *mappings)
> +{
> +    struct ofputil_tlv_map *map;
> +
> +    LIST_FOR_EACH (map, list_node, mappings) {
> +        struct nx_tlv_map *nx_map;
> +
> +        nx_map = ofpbuf_put_zeros(b, sizeof *nx_map);
> +        nx_map->option_class = htons(map->option_class);
> +        nx_map->option_type = map->option_type;
> +        nx_map->option_len = map->option_len;
> +        nx_map->index = htons(map->index);
> +    }
> +}
> +
> +struct ofpbuf *
> +ofputil_encode_tlv_table_mod(enum ofp_version ofp_version,
> +                                struct ofputil_tlv_table_mod *ttm)
> +{
> +    struct ofpbuf *b;
> +    struct nx_tlv_table_mod *nx_ttm;
> +
> +    b = ofpraw_alloc(OFPRAW_NXT_TLV_TABLE_MOD, ofp_version, 0);
> +    nx_ttm = ofpbuf_put_zeros(b, sizeof *nx_ttm);
> +    nx_ttm->command = htons(ttm->command);
> +    encode_tlv_table_mappings(b, &ttm->mappings);
> +
> +    return b;
> +}
> +
> +static enum ofperr
> +decode_tlv_table_mappings(struct ofpbuf *msg, unsigned int max_fields,
> +                             struct ovs_list *mappings)
> +{
> +    ovs_list_init(mappings);
> +
> +    while (msg->size) {
> +        struct nx_tlv_map *nx_map;
> +        struct ofputil_tlv_map *map;
> +
> +        nx_map = ofpbuf_pull(msg, sizeof *nx_map);
> +        map = xmalloc(sizeof *map);
> +        ovs_list_push_back(mappings, &map->list_node);
> +
> +        map->option_class = ntohs(nx_map->option_class);
> +        map->option_type = nx_map->option_type;
> +
> +        map->option_len = nx_map->option_len;
> +        if (map->option_len % 4 || map->option_len > TLV_MAX_OPT_SIZE) {
> +            VLOG_WARN_RL(&rl, "tlv table option length (%u) is not a "
> +                         "valid option size", map->option_len);
> +            ofputil_uninit_tlv_table(mappings);
> +            return OFPERR_NXTTMFC_BAD_OPT_LEN;
> +        }
> +
> +        map->index = ntohs(nx_map->index);
> +        if (map->index >= max_fields) {
> +            VLOG_WARN_RL(&rl, "tlv table field index (%u) is too large "
> +                         "(max %u)", map->index, max_fields - 1);
> +            ofputil_uninit_tlv_table(mappings);
> +            return OFPERR_NXTTMFC_BAD_FIELD_IDX;
> +        }
> +    }
> +
> +    return 0;
> +}
> +
> +enum ofperr
> +ofputil_decode_tlv_table_mod(const struct ofp_header *oh,
> +                                struct ofputil_tlv_table_mod *ttm)
> +{
> +    struct ofpbuf msg = ofpbuf_const_initializer(oh, ntohs(oh->length));
> +    ofpraw_pull_assert(&msg);
> +
> +    struct nx_tlv_table_mod *nx_ttm = ofpbuf_pull(&msg, sizeof *nx_ttm);
> +    ttm->command = ntohs(nx_ttm->command);
> +    if (ttm->command > NXTTMC_CLEAR) {
> +        VLOG_WARN_RL(&rl, "tlv table mod command (%u) is out of range",
> +                     ttm->command);
> +        return OFPERR_NXTTMFC_BAD_COMMAND;
> +    }
> +
> +    return decode_tlv_table_mappings(&msg, TUN_METADATA_NUM_OPTS,
> +                                        &ttm->mappings);
> +}
> +
> +struct ofpbuf *
> +ofputil_encode_tlv_table_reply(const struct ofp_header *oh,
> +                                  struct ofputil_tlv_table_reply *ttr)
> +{
> +    struct ofpbuf *b;
> +    struct nx_tlv_table_reply *nx_ttr;
> +
> +    b = ofpraw_alloc_reply(OFPRAW_NXT_TLV_TABLE_REPLY, oh, 0);
> +    nx_ttr = ofpbuf_put_zeros(b, sizeof *nx_ttr);
> +    nx_ttr->max_option_space = htonl(ttr->max_option_space);
> +    nx_ttr->max_fields = htons(ttr->max_fields);
> +
> +    encode_tlv_table_mappings(b, &ttr->mappings);
> +
> +    return b;
> +}
> +
> +/* Decodes the NXT_TLV_TABLE_REPLY message in 'oh' into '*ttr'.  Returns 0
> + * if successful, otherwise an ofperr.
> + *
> + * The decoder verifies that the indexes in 'ttr->mappings' are less than
> + * 'ttr->max_fields', but the caller must ensure, if necessary, that they
> are
> + * less than TUN_METADATA_NUM_OPTS. */
> +enum ofperr
> +ofputil_decode_tlv_table_reply(const struct ofp_header *oh,
> +                                  struct ofputil_tlv_table_reply *ttr)
> +{
> +    struct ofpbuf msg = ofpbuf_const_initializer(oh, ntohs(oh->length));
> +    ofpraw_pull_assert(&msg);
> +
> +    struct nx_tlv_table_reply *nx_ttr = ofpbuf_pull(&msg, sizeof *nx_ttr);
> +    ttr->max_option_space = ntohl(nx_ttr->max_option_space);
> +    ttr->max_fields = ntohs(nx_ttr->max_fields);
> +
> +    return decode_tlv_table_mappings(&msg, ttr->max_fields,
> &ttr->mappings);
> +}
> +
> +char * OVS_WARN_UNUSED_RESULT
> +parse_ofp_tlv_table_mod_str(struct ofputil_tlv_table_mod *ttm,
> +                               uint16_t command, const char *s,
> +                               enum ofputil_protocol *usable_protocols)
> +{
> +    *usable_protocols = OFPUTIL_P_NXM_OXM_ANY;
> +
> +    ttm->command = command;
> +    ovs_list_init(&ttm->mappings);
> +
> +    while (*s) {
> +        struct ofputil_tlv_map *map = xmalloc(sizeof *map);
> +        int n;
> +
> +        if (*s == ',') {
> +            s++;
> +        }
> +
> +        ovs_list_push_back(&ttm->mappings, &map->list_node);
> +
> +        if (!ovs_scan(s, "{class=%"SCNi16",type=%"
> SCNi8",len=%"SCNi8"}->tun_metadata%"SCNi16"%n",
> +                      &map->option_class, &map->option_type,
> &map->option_len,
> +                      &map->index, &n)) {
> +            ofputil_uninit_tlv_table(&ttm->mappings);
> +            return xstrdup("invalid tlv mapping");
> +        }
> +
> +        s += n;
> +    }
> +
> +    return NULL;
> +}
> +
> +void
> +ofputil_uninit_tlv_table(struct ovs_list *mappings)
> +{
> +    struct ofputil_tlv_map *map;
> +
> +    LIST_FOR_EACH_POP (map, list_node, mappings) {
> +        free(map);
> +    }
> +}
> +
> +static void
> +ofputil_normalize_match__(struct match *match, bool may_log)
> +{
> +    enum {
> +        MAY_NW_ADDR     = 1 << 0, /* nw_src, nw_dst */
> +        MAY_TP_ADDR     = 1 << 1, /* tp_src, tp_dst */
> +        MAY_NW_PROTO    = 1 << 2, /* nw_proto */
> +        MAY_IPVx        = 1 << 3, /* tos, frag, ttl */
> +        MAY_ARP_SHA     = 1 << 4, /* arp_sha */
> +        MAY_ARP_THA     = 1 << 5, /* arp_tha */
> +        MAY_IPV6        = 1 << 6, /* ipv6_src, ipv6_dst, ipv6_label */
> +        MAY_ND_TARGET   = 1 << 7, /* nd_target */
> +        MAY_MPLS        = 1 << 8, /* mpls label and tc */
> +        MAY_ETHER       = 1 << 9, /* dl_src, dl_dst */
> +    } may_match;
> +
> +    struct flow_wildcards wc = match->wc;
> +    ovs_be16 dl_type;
> +
> +    /* Figure out what fields may be matched. */
> +    /* Check the packet_type first and extract dl_type. */
> +    if (wc.masks.packet_type == 0 || match_has_default_packet_type(match))
> {
> +        may_match = MAY_ETHER;
> +        dl_type = match->flow.dl_type;
> +    } else if (wc.masks.packet_type == OVS_BE32_MAX &&
> +               pt_ns(match->flow.packet_type) == OFPHTN_ETHERTYPE) {
> +        may_match = 0;
> +        dl_type = pt_ns_type_be(match->flow.packet_type);
> +    } else {
> +        may_match = 0;
> +        dl_type = 0;
> +    }
> +    if (dl_type == htons(ETH_TYPE_IP)) {
> +        may_match |= MAY_NW_PROTO | MAY_IPVx | MAY_NW_ADDR;
> +        if (match->flow.nw_proto == IPPROTO_TCP ||
> +            match->flow.nw_proto == IPPROTO_UDP ||
> +            match->flow.nw_proto == IPPROTO_SCTP ||
> +            match->flow.nw_proto == IPPROTO_ICMP) {
> +            may_match |= MAY_TP_ADDR;
> +        }
> +    } else if (dl_type == htons(ETH_TYPE_IPV6)) {
> +        may_match |= MAY_NW_PROTO | MAY_IPVx | MAY_IPV6;
> +        if (match->flow.nw_proto == IPPROTO_TCP ||
> +            match->flow.nw_proto == IPPROTO_UDP ||
> +            match->flow.nw_proto == IPPROTO_SCTP) {
> +            may_match |= MAY_TP_ADDR;
> +        } else if (match->flow.nw_proto == IPPROTO_ICMPV6) {
> +            may_match |= MAY_TP_ADDR;
> +            if (match->flow.tp_src == htons(ND_NEIGHBOR_SOLICIT)) {
> +                may_match |= MAY_ND_TARGET | MAY_ARP_SHA;
> +            } else if (match->flow.tp_src == htons(ND_NEIGHBOR_ADVERT)) {
> +                may_match |= MAY_ND_TARGET | MAY_ARP_THA;
> +            }
> +        }
> +    } else if (dl_type == htons(ETH_TYPE_ARP) ||
> +               dl_type == htons(ETH_TYPE_RARP)) {
> +        may_match |= MAY_NW_PROTO | MAY_NW_ADDR | MAY_ARP_SHA |
> MAY_ARP_THA;
> +    } else if (eth_type_mpls(dl_type)) {
> +        may_match |= MAY_MPLS;
> +    }
> +
> +    /* Clear the fields that may not be matched. */
> +    if (!(may_match & MAY_ETHER)) {
> +        wc.masks.dl_src = wc.masks.dl_dst = eth_addr_zero;
> +    }
> +    if (!(may_match & MAY_NW_ADDR)) {
> +        wc.masks.nw_src = wc.masks.nw_dst = htonl(0);
> +    }
> +    if (!(may_match & MAY_TP_ADDR)) {
> +        wc.masks.tp_src = wc.masks.tp_dst = htons(0);
> +    }
> +    if (!(may_match & MAY_NW_PROTO)) {
> +        wc.masks.nw_proto = 0;
> +    }
> +    if (!(may_match & MAY_IPVx)) {
> +        wc.masks.nw_tos = 0;
> +        wc.masks.nw_ttl = 0;
> +    }
> +    if (!(may_match & MAY_ARP_SHA)) {
> +        WC_UNMASK_FIELD(&wc, arp_sha);
> +    }
> +    if (!(may_match & MAY_ARP_THA)) {
> +        WC_UNMASK_FIELD(&wc, arp_tha);
> +    }
> +    if (!(may_match & MAY_IPV6)) {
> +        wc.masks.ipv6_src = wc.masks.ipv6_dst = in6addr_any;
> +        wc.masks.ipv6_label = htonl(0);
> +    }
> +    if (!(may_match & MAY_ND_TARGET)) {
> +        wc.masks.nd_target = in6addr_any;
> +    }
> +    if (!(may_match & MAY_MPLS)) {
> +        memset(wc.masks.mpls_lse, 0, sizeof wc.masks.mpls_lse);
> +    }
> +
> +    /* Log any changes. */
> +    if (!flow_wildcards_equal(&wc, &match->wc)) {
> +        bool log = may_log && !VLOG_DROP_INFO(&rl);
> +        char *pre = (log
> +                     ? match_to_string(match, NULL, OFP_DEFAULT_PRIORITY)
> +                     : NULL);
> +
> +        match->wc = wc;
> +        match_zero_wildcarded_fields(match);
> +
> +        if (log) {
> +            char *post = match_to_string(match, NULL,
> OFP_DEFAULT_PRIORITY);
> +            VLOG_INFO("normalization changed ofp_match, details:");
> +            VLOG_INFO(" pre: %s", pre);
> +            VLOG_INFO("post: %s", post);
> +            free(pre);
> +            free(post);
> +        }
> +    }
> +}
> +
> +/* "Normalizes" the wildcards in 'match'.  That means:
> + *
> + *    1. If the type of level N is known, then only the valid fields for
> that
> + *       level may be specified.  For example, ARP does not have a TOS
> field,
> + *       so nw_tos must be wildcarded if 'match' specifies an ARP flow.
> + *       Similarly, IPv4 does not have any IPv6 addresses, so ipv6_src and
> + *       ipv6_dst (and other fields) must be wildcarded if 'match'
> specifies an
> + *       IPv4 flow.
> + *
> + *    2. If the type of level N is not known (or not understood by Open
> + *       vSwitch), then no fields at all for that level may be
> specified.  For
> + *       example, Open vSwitch does not understand SCTP, an L4 protocol,
> so the
> + *       L4 fields tp_src and tp_dst must be wildcarded if 'match'
> specifies an
> + *       SCTP flow.
> + *
> + * If this function changes 'match', it logs a rate-limited informational
> + * message. */
> +void
> +ofputil_normalize_match(struct match *match)
> +{
> +    ofputil_normalize_match__(match, true);
> +}
> +
> +/* Same as ofputil_normalize_match() without the logging.  Thus, this
> function
> + * is suitable for a program's internal use, whereas
> ofputil_normalize_match()
> + * sense for use on flows received from elsewhere (so that a bug in the
> program
> + * that sent them can be reported and corrected). */
> +void
> +ofputil_normalize_match_quiet(struct match *match)
> +{
> +    ofputil_normalize_match__(match, false);
> +}
> diff --git a/lib/ofp-meter.c b/lib/ofp-meter.c
> new file mode 100644
> index 000000000000..204f035ec290
> --- /dev/null
> +++ b/lib/ofp-meter.c
> @@ -0,0 +1,630 @@
> +/*
> + * Copyright (c) 2008-2017 Nicira, Inc.
> + *
> + * Licensed under the Apache License, Version 2.0 (the "License");
> + * you may not use this file except in compliance with the License.
> + * You may obtain a copy of the License at:
> + *
> + *     http://www.apache.org/licenses/LICENSE-2.0
> + *
> + * Unless required by applicable law or agreed to in writing, software
> + * distributed under the License is distributed on an "AS IS" BASIS,
> + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
> implied.
> + * See the License for the specific language governing permissions and
> + * limitations under the License.
> + */
> +
> +#include <config.h>
> +#include "openvswitch/ofp-meter.h"
> +#include "byte-order.h"
> +#include "nx-match.h"
> +#include "openvswitch/ofp-errors.h"
> +#include "openvswitch/ofp-msgs.h"
> +#include "openvswitch/ofp-parse.h"
> +#include "openvswitch/ofpbuf.h"
> +#include "openvswitch/vlog.h"
> +
> +VLOG_DEFINE_THIS_MODULE(ofp_meter);
> +
> +static struct vlog_rate_limit rl = VLOG_RATE_LIMIT_INIT(1, 5);
> +
> +static enum ofperr
> +ofputil_pull_bands(struct ofpbuf *msg, size_t len, uint16_t *n_bands,
> +                   struct ofpbuf *bands)
> +{
> +    const struct ofp13_meter_band_header *ombh;
> +    struct ofputil_meter_band *mb;
> +    uint16_t n = 0;
> +
> +    ombh = ofpbuf_try_pull(msg, len);
> +    if (!ombh) {
> +        return OFPERR_OFPBRC_BAD_LEN;
> +    }
> +
> +    while (len >= sizeof (struct ofp13_meter_band_drop)) {
> +        size_t ombh_len = ntohs(ombh->len);
> +        /* All supported band types have the same length. */
> +        if (ombh_len != sizeof (struct ofp13_meter_band_drop)) {
> +            return OFPERR_OFPBRC_BAD_LEN;
> +        }
> +        mb = ofpbuf_put_uninit(bands, sizeof *mb);
> +        mb->type = ntohs(ombh->type);
> +        if (mb->type != OFPMBT13_DROP && mb->type !=
> OFPMBT13_DSCP_REMARK) {
> +            return OFPERR_OFPMMFC_BAD_BAND;
> +        }
> +        mb->rate = ntohl(ombh->rate);
> +        mb->burst_size = ntohl(ombh->burst_size);
> +        mb->prec_level = (mb->type == OFPMBT13_DSCP_REMARK) ?
> +            ((struct ofp13_meter_band_dscp_remark *)ombh)->prec_level : 0;
> +        n++;
> +        len -= ombh_len;
> +        ombh = ALIGNED_CAST(struct ofp13_meter_band_header *,
> +                            (char *) ombh + ombh_len);
> +    }
> +    if (len) {
> +        return OFPERR_OFPBRC_BAD_LEN;
> +    }
> +    *n_bands = n;
> +    return 0;
> +}
> +
> +enum ofperr
> +ofputil_decode_meter_mod(const struct ofp_header *oh,
> +                         struct ofputil_meter_mod *mm,
> +                         struct ofpbuf *bands)
> +{
> +    struct ofpbuf b = ofpbuf_const_initializer(oh, ntohs(oh->length));
> +    ofpraw_pull_assert(&b);
> +    const struct ofp13_meter_mod *omm = ofpbuf_pull(&b, sizeof *omm);
> +
> +    /* Translate the message. */
> +    mm->command = ntohs(omm->command);
> +    if (mm->command != OFPMC13_ADD &&
> +        mm->command != OFPMC13_MODIFY &&
> +        mm->command != OFPMC13_DELETE) {
> +        return OFPERR_OFPMMFC_BAD_COMMAND;
> +    }
> +    mm->meter.meter_id = ntohl(omm->meter_id);
> +
> +    if (mm->command == OFPMC13_DELETE) {
> +        mm->meter.flags = 0;
> +        mm->meter.n_bands = 0;
> +        mm->meter.bands = NULL;
> +    } else {
> +        enum ofperr error;
> +
> +        mm->meter.flags = ntohs(omm->flags);
> +        if (mm->meter.flags & OFPMF13_KBPS &&
> +            mm->meter.flags & OFPMF13_PKTPS) {
> +            return OFPERR_OFPMMFC_BAD_FLAGS;
> +        }
> +        mm->meter.bands = bands->data;
> +
> +        error = ofputil_pull_bands(&b, b.size, &mm->meter.n_bands, bands);
> +        if (error) {
> +            return error;
> +        }
> +    }
> +    return 0;
> +}
> +
> +void
> +ofputil_decode_meter_request(const struct ofp_header *oh, uint32_t
> *meter_id)
> +{
> +    const struct ofp13_meter_multipart_request *omr = ofpmsg_body(oh);
> +    *meter_id = ntohl(omr->meter_id);
> +}
> +
> +struct ofpbuf *
> +ofputil_encode_meter_request(enum ofp_version ofp_version,
> +                             enum ofputil_meter_request_type type,
> +                             uint32_t meter_id)
> +{
> +    struct ofpbuf *msg;
> +
> +    enum ofpraw raw;
> +
> +    switch (type) {
> +    case OFPUTIL_METER_CONFIG:
> +        raw = OFPRAW_OFPST13_METER_CONFIG_REQUEST;
> +        break;
> +    case OFPUTIL_METER_STATS:
> +        raw = OFPRAW_OFPST13_METER_REQUEST;
> +        break;
> +    default:
> +    case OFPUTIL_METER_FEATURES:
> +        raw = OFPRAW_OFPST13_METER_FEATURES_REQUEST;
> +        break;
> +    }
> +
> +    msg = ofpraw_alloc(raw, ofp_version, 0);
> +
> +    if (type != OFPUTIL_METER_FEATURES) {
> +        struct ofp13_meter_multipart_request *omr;
> +        omr = ofpbuf_put_zeros(msg, sizeof *omr);
> +        omr->meter_id = htonl(meter_id);
> +    }
> +    return msg;
> +}
> +
> +static void
> +ofputil_put_bands(uint16_t n_bands, const struct ofputil_meter_band *mb,
> +                  struct ofpbuf *msg)
> +{
> +    uint16_t n = 0;
> +
> +    for (n = 0; n < n_bands; ++n) {
> +        /* Currently all band types have same size. */
> +        struct ofp13_meter_band_dscp_remark *ombh;
> +        size_t ombh_len = sizeof *ombh;
> +
> +        ombh = ofpbuf_put_zeros(msg, ombh_len);
> +
> +        ombh->type = htons(mb->type);
> +        ombh->len = htons(ombh_len);
> +        ombh->rate = htonl(mb->rate);
> +        ombh->burst_size = htonl(mb->burst_size);
> +        ombh->prec_level = mb->prec_level;
> +
> +        mb++;
> +    }
> +}
> +
> +/* Encode a meter stat for 'mc' and append it to 'replies'. */
> +void
> +ofputil_append_meter_config(struct ovs_list *replies,
> +                            const struct ofputil_meter_config *mc)
> +{
> +    struct ofpbuf *msg = ofpbuf_from_list(ovs_list_back(replies));
> +    size_t start_ofs = msg->size;
> +    struct ofp13_meter_config *reply;
> +
> +    ofpbuf_put_uninit(msg, sizeof *reply);
> +    ofputil_put_bands(mc->n_bands, mc->bands, msg);
> +
> +    reply = ofpbuf_at_assert(msg, start_ofs, sizeof *reply);
> +    reply->flags = htons(mc->flags);
> +    reply->meter_id = htonl(mc->meter_id);
> +    reply->length = htons(msg->size - start_ofs);
> +
> +    ofpmp_postappend(replies, start_ofs);
> +}
> +
> +/* Encode a meter stat for 'ms' and append it to 'replies'. */
> +void
> +ofputil_append_meter_stats(struct ovs_list *replies,
> +                           const struct ofputil_meter_stats *ms)
> +{
> +    struct ofp13_meter_stats *reply;
> +    uint16_t n = 0;
> +    uint16_t len;
> +
> +    len = sizeof *reply + ms->n_bands * sizeof(struct
> ofp13_meter_band_stats);
> +    reply = ofpmp_append(replies, len);
> +
> +    reply->meter_id = htonl(ms->meter_id);
> +    reply->len = htons(len);
> +    memset(reply->pad, 0, sizeof reply->pad);
> +    reply->flow_count = htonl(ms->flow_count);
> +    reply->packet_in_count = htonll(ms->packet_in_count);
> +    reply->byte_in_count = htonll(ms->byte_in_count);
> +    reply->duration_sec = htonl(ms->duration_sec);
> +    reply->duration_nsec = htonl(ms->duration_nsec);
> +
> +    for (n = 0; n < ms->n_bands; ++n) {
> +        const struct ofputil_meter_band_stats *src = &ms->bands[n];
> +        struct ofp13_meter_band_stats *dst = &reply->band_stats[n];
> +
> +        dst->packet_band_count = htonll(src->packet_count);
> +        dst->byte_band_count = htonll(src->byte_count);
> +    }
> +}
> +
> +/* Converts an OFPMP_METER_CONFIG reply in 'msg' into an abstract
> + * ofputil_meter_config in 'mc', with mc->bands pointing to bands decoded
> into
> + * 'bands'.  The caller must have initialized 'bands' and retains
> ownership of
> + * it across the call.
> + *
> + * Multiple OFPST13_METER_CONFIG replies can be packed into a single
> OpenFlow
> + * message.  Calling this function multiple times for a single 'msg'
> iterates
> + * through the replies.  'bands' is cleared for each reply.
> + *
> + * Returns 0 if successful, EOF if no replies were left in this 'msg',
> + * otherwise a positive errno value. */
> +int
> +ofputil_decode_meter_config(struct ofpbuf *msg,
> +                            struct ofputil_meter_config *mc,
> +                            struct ofpbuf *bands)
> +{
> +    const struct ofp13_meter_config *omc;
> +    enum ofperr err;
> +
> +    /* Pull OpenFlow headers for the first call. */
> +    if (!msg->header) {
> +        ofpraw_pull_assert(msg);
> +    }
> +
> +    if (!msg->size) {
> +        return EOF;
> +    }
> +
> +    omc = ofpbuf_try_pull(msg, sizeof *omc);
> +    if (!omc) {
> +        VLOG_WARN_RL(&rl, "OFPMP_METER_CONFIG reply has %"PRIu32"
> leftover "
> +                     "bytes at end", msg->size);
> +        return OFPERR_OFPBRC_BAD_LEN;
> +    }
> +
> +    ofpbuf_clear(bands);
> +    err = ofputil_pull_bands(msg, ntohs(omc->length) - sizeof *omc,
> +                             &mc->n_bands, bands);
> +    if (err) {
> +        return err;
> +    }
> +    mc->meter_id = ntohl(omc->meter_id);
> +    mc->flags = ntohs(omc->flags);
> +    mc->bands = bands->data;
> +
> +    return 0;
> +}
> +
> +static enum ofperr
> +ofputil_pull_band_stats(struct ofpbuf *msg, size_t len, uint16_t
> *n_bands,
> +                        struct ofpbuf *bands)
> +{
> +    const struct ofp13_meter_band_stats *ombs;
> +    struct ofputil_meter_band_stats *mbs;
> +    uint16_t n, i;
> +
> +    ombs = ofpbuf_try_pull(msg, len);
> +    if (!ombs) {
> +        return OFPERR_OFPBRC_BAD_LEN;
> +    }
> +
> +    n = len / sizeof *ombs;
> +    if (len != n * sizeof *ombs) {
> +        return OFPERR_OFPBRC_BAD_LEN;
> +    }
> +
> +    mbs = ofpbuf_put_uninit(bands, len);
> +
> +    for (i = 0; i < n; ++i) {
> +        mbs[i].packet_count = ntohll(ombs[i].packet_band_count);
> +        mbs[i].byte_count = ntohll(ombs[i].byte_band_count);
> +    }
> +    *n_bands = n;
> +    return 0;
> +}
> +
> +/* Converts an OFPMP_METER reply in 'msg' into an abstract
> + * ofputil_meter_stats in 'ms', with ms->bands pointing to band stats
> + * decoded into 'bands'.
> + *
> + * Multiple OFPMP_METER replies can be packed into a single OpenFlow
> + * message.  Calling this function multiple times for a single 'msg'
> iterates
> + * through the replies.  'bands' is cleared for each reply.
> + *
> + * Returns 0 if successful, EOF if no replies were left in this 'msg',
> + * otherwise a positive errno value. */
> +int
> +ofputil_decode_meter_stats(struct ofpbuf *msg,
> +                           struct ofputil_meter_stats *ms,
> +                           struct ofpbuf *bands)
> +{
> +    const struct ofp13_meter_stats *oms;
> +    enum ofperr err;
> +
> +    /* Pull OpenFlow headers for the first call. */
> +    if (!msg->header) {
> +        ofpraw_pull_assert(msg);
> +    }
> +
> +    if (!msg->size) {
> +        return EOF;
> +    }
> +
> +    oms = ofpbuf_try_pull(msg, sizeof *oms);
> +    if (!oms) {
> +        VLOG_WARN_RL(&rl, "OFPMP_METER reply has %"PRIu32" leftover bytes
> "
> +                     "at end", msg->size);
> +        return OFPERR_OFPBRC_BAD_LEN;
> +    }
> +
> +    ofpbuf_clear(bands);
> +    err = ofputil_pull_band_stats(msg, ntohs(oms->len) - sizeof *oms,
> +                                  &ms->n_bands, bands);
> +    if (err) {
> +        return err;
> +    }
> +    ms->meter_id = ntohl(oms->meter_id);
> +    ms->flow_count = ntohl(oms->flow_count);
> +    ms->packet_in_count = ntohll(oms->packet_in_count);
> +    ms->byte_in_count = ntohll(oms->byte_in_count);
> +    ms->duration_sec = ntohl(oms->duration_sec);
> +    ms->duration_nsec = ntohl(oms->duration_nsec);
> +    ms->bands = bands->data;
> +
> +    return 0;
> +}
> +
> +void
> +ofputil_decode_meter_features(const struct ofp_header *oh,
> +                              struct ofputil_meter_features *mf)
> +{
> +    const struct ofp13_meter_features *omf = ofpmsg_body(oh);
> +
> +    mf->max_meters = ntohl(omf->max_meter);
> +    mf->band_types = ntohl(omf->band_types);
> +    mf->capabilities = ntohl(omf->capabilities);
> +    mf->max_bands = omf->max_bands;
> +    mf->max_color = omf->max_color;
> +}
> +
> +struct ofpbuf *
> +ofputil_encode_meter_features_reply(const struct ofputil_meter_features
> *mf,
> +                                    const struct ofp_header *request)
> +{
> +    struct ofpbuf *reply;
> +    struct ofp13_meter_features *omf;
> +
> +    reply = ofpraw_alloc_stats_reply(request, 0);
> +    omf = ofpbuf_put_zeros(reply, sizeof *omf);
> +
> +    omf->max_meter = htonl(mf->max_meters);
> +    omf->band_types = htonl(mf->band_types);
> +    omf->capabilities = htonl(mf->capabilities);
> +    omf->max_bands = mf->max_bands;
> +    omf->max_color = mf->max_color;
> +
> +    return reply;
> +}
> +
> +struct ofpbuf *
> +ofputil_encode_meter_mod(enum ofp_version ofp_version,
> +                         const struct ofputil_meter_mod *mm)
> +{
> +    struct ofpbuf *msg;
> +
> +    struct ofp13_meter_mod *omm;
> +
> +    msg = ofpraw_alloc(OFPRAW_OFPT13_METER_MOD, ofp_version,
> +                       NXM_TYPICAL_LEN + mm->meter.n_bands * 16);
> +    omm = ofpbuf_put_zeros(msg, sizeof *omm);
> +    omm->command = htons(mm->command);
> +    if (mm->command != OFPMC13_DELETE) {
> +        omm->flags = htons(mm->meter.flags);
> +    }
> +    omm->meter_id = htonl(mm->meter.meter_id);
> +
> +    ofputil_put_bands(mm->meter.n_bands, mm->meter.bands, msg);
> +
> +    ofpmsg_update_length(msg);
> +    return msg;
> +}
> +
> +/* Parse a string representation of a meter modification message to '*mm'.
> + * If successful, 'mm->meter.bands' must be free()d by the caller. */
> +static char * OVS_WARN_UNUSED_RESULT
> +parse_ofp_meter_mod_str__(struct ofputil_meter_mod *mm, char *string,
> +                          struct ofpbuf *bands, int command,
> +                          enum ofputil_protocol *usable_protocols)
> +{
> +    enum {
> +        F_METER = 1 << 0,
> +        F_FLAGS = 1 << 1,
> +        F_BANDS = 1 << 2,
> +    } fields;
> +    char *save_ptr = NULL;
> +    char *band_str = NULL;
> +    char *name;
> +
> +    /* Meters require at least OF 1.3. */
> +    *usable_protocols = OFPUTIL_P_OF13_UP;
> +
> +    switch (command) {
> +    case -1:
> +        fields = F_METER;
> +        break;
> +
> +    case OFPMC13_ADD:
> +        fields = F_METER | F_FLAGS | F_BANDS;
> +        break;
> +
> +    case OFPMC13_DELETE:
> +        fields = F_METER;
> +        break;
> +
> +    case OFPMC13_MODIFY:
> +        fields = F_METER | F_FLAGS | F_BANDS;
> +        break;
> +
> +    default:
> +        OVS_NOT_REACHED();
> +    }
> +
> +    mm->command = command;
> +    mm->meter.meter_id = 0;
> +    mm->meter.flags = 0;
> +    mm->meter.n_bands = 0;
> +    mm->meter.bands = NULL;
> +
> +    if (fields & F_BANDS) {
> +        band_str = strstr(string, "band");
> +        if (!band_str) {
> +            return xstrdup("must specify bands");
> +        }
> +        *band_str = '\0';
> +
> +        band_str = strchr(band_str + 1, '=');
> +        if (!band_str) {
> +            return xstrdup("must specify bands");
> +        }
> +
> +        band_str++;
> +    }
> +    for (name = strtok_r(string, "=, \t\r\n", &save_ptr); name;
> +         name = strtok_r(NULL, "=, \t\r\n", &save_ptr)) {
> +
> +        if (fields & F_FLAGS && !strcmp(name, "kbps")) {
> +            mm->meter.flags |= OFPMF13_KBPS;
> +        } else if (fields & F_FLAGS && !strcmp(name, "pktps")) {
> +            mm->meter.flags |= OFPMF13_PKTPS;
> +        } else if (fields & F_FLAGS && !strcmp(name, "burst")) {
> +            mm->meter.flags |= OFPMF13_BURST;
> +        } else if (fields & F_FLAGS && !strcmp(name, "stats")) {
> +            mm->meter.flags |= OFPMF13_STATS;
> +        } else {
> +            char *value;
> +
> +            value = strtok_r(NULL, ", \t\r\n", &save_ptr);
> +            if (!value) {
> +                return xasprintf("field %s missing value", name);
> +            }
> +
> +            if (!strcmp(name, "meter")) {
> +                if (!strcmp(value, "all")) {
> +                    mm->meter.meter_id = OFPM13_ALL;
> +                } else if (!strcmp(value, "controller")) {
> +                    mm->meter.meter_id = OFPM13_CONTROLLER;
> +                } else if (!strcmp(value, "slowpath")) {
> +                    mm->meter.meter_id = OFPM13_SLOWPATH;
> +                } else {
> +                    char *error = str_to_u32(value, &mm->meter.meter_id);
> +                    if (error) {
> +                        return error;
> +                    }
> +                    if (mm->meter.meter_id > OFPM13_MAX
> +                        || !mm->meter.meter_id) {
> +                        return xasprintf("invalid value for %s", name);
> +                    }
> +                }
> +            } else {
> +                return xasprintf("unknown keyword %s", name);
> +            }
> +        }
> +    }
> +    if (fields & F_METER && !mm->meter.meter_id) {
> +        return xstrdup("must specify 'meter'");
> +    }
> +    if (fields & F_FLAGS && !mm->meter.flags) {
> +        return xstrdup("meter must specify either 'kbps' or 'pktps'");
> +    }
> +
> +    if (fields & F_BANDS) {
> +        uint16_t n_bands = 0;
> +        struct ofputil_meter_band *band = NULL;
> +        int i;
> +
> +        for (name = strtok_r(band_str, "=, \t\r\n", &save_ptr); name;
> +             name = strtok_r(NULL, "=, \t\r\n", &save_ptr)) {
> +
> +            char *value;
> +
> +            value = strtok_r(NULL, ", \t\r\n", &save_ptr);
> +            if (!value) {
> +                return xasprintf("field %s missing value", name);
> +            }
> +
> +            if (!strcmp(name, "type")) {
> +                /* Start a new band */
> +                band = ofpbuf_put_zeros(bands, sizeof *band);
> +                n_bands++;
> +
> +                if (!strcmp(value, "drop")) {
> +                    band->type = OFPMBT13_DROP;
> +                } else if (!strcmp(value, "dscp_remark")) {
> +                    band->type = OFPMBT13_DSCP_REMARK;
> +                } else {
> +                    return xasprintf("field %s unknown value %s", name,
> value);
> +                }
> +            } else if (!band || !band->type) {
> +                return xstrdup("band must start with the 'type' keyword");
> +            } else if (!strcmp(name, "rate")) {
> +                char *error = str_to_u32(value, &band->rate);
> +                if (error) {
> +                    return error;
> +                }
> +            } else if (!strcmp(name, "burst_size")) {
> +                char *error = str_to_u32(value, &band->burst_size);
> +                if (error) {
> +                    return error;
> +                }
> +            } else if (!strcmp(name, "prec_level")) {
> +                char *error = str_to_u8(value, name, &band->prec_level);
> +                if (error) {
> +                    return error;
> +                }
> +            } else {
> +                return xasprintf("unknown keyword %s", name);
> +            }
> +        }
> +        /* validate bands */
> +        if (!n_bands) {
> +            return xstrdup("meter must have bands");
> +        }
> +
> +        mm->meter.n_bands = n_bands;
> +        mm->meter.bands = ofpbuf_steal_data(bands);
> +
> +        for (i = 0; i < n_bands; ++i) {
> +            band = &mm->meter.bands[i];
> +
> +            if (!band->type) {
> +                return xstrdup("band must have 'type'");
> +            }
> +            if (band->type == OFPMBT13_DSCP_REMARK) {
> +                if (!band->prec_level) {
> +                    return xstrdup("'dscp_remark' band must have"
> +                                   " 'prec_level'");
> +                }
> +            } else {
> +                if (band->prec_level) {
> +                    return xstrdup("Only 'dscp_remark' band may have"
> +                                   " 'prec_level'");
> +                }
> +            }
> +            if (!band->rate) {
> +                return xstrdup("band must have 'rate'");
> +            }
> +            if (mm->meter.flags & OFPMF13_BURST) {
> +                if (!band->burst_size) {
> +                    return xstrdup("band must have 'burst_size' "
> +                                   "when 'burst' flag is set");
> +                }
> +            } else {
> +                if (band->burst_size) {
> +                    return xstrdup("band may have 'burst_size' only "
> +                                   "when 'burst' flag is set");
> +                }
> +            }
> +        }
> +    }
> +
> +    return NULL;
> +}
> +
> +/* Convert 'str_' (as described in the Flow Syntax section of the
> ovs-ofctl man
> + * page) into 'mm' for sending the specified meter_mod 'command' to a
> switch.
> + *
> + * Returns NULL if successful, otherwise a malloc()'d string describing
> the
> + * error.  The caller is responsible for freeing the returned string.
> + * If successful, 'mm->meter.bands' must be free()d by the caller. */
> +char * OVS_WARN_UNUSED_RESULT
> +parse_ofp_meter_mod_str(struct ofputil_meter_mod *mm, const char *str_,
> +                        int command, enum ofputil_protocol
> *usable_protocols)
> +{
> +    struct ofpbuf bands;
> +    char *string;
> +    char *error;
> +
> +    ofpbuf_init(&bands, 64);
> +    string = xstrdup(str_);
> +
> +    error = parse_ofp_meter_mod_str__(mm, string, &bands, command,
> +                                      usable_protocols);
> +
> +    free(string);
> +    ofpbuf_uninit(&bands);
> +
> +    return error;
> +}
> diff --git a/lib/ofp-monitor.c b/lib/ofp-monitor.c
> new file mode 100644
> index 000000000000..49d623c35cff
> --- /dev/null
> +++ b/lib/ofp-monitor.c
> @@ -0,0 +1,689 @@
> +/*
> + * Copyright (c) 2008-2017 Nicira, Inc.
> + *
> + * Licensed under the Apache License, Version 2.0 (the "License");
> + * you may not use this file except in compliance with the License.
> + * You may obtain a copy of the License at:
> + *
> + *     http://www.apache.org/licenses/LICENSE-2.0
> + *
> + * Unless required by applicable law or agreed to in writing, software
> + * distributed under the License is distributed on an "AS IS" BASIS,
> + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
> implied.
> + * See the License for the specific language governing permissions and
> + * limitations under the License.
> + */
> +
> +#include <config.h>
> +#include "openvswitch/ofp-monitor.h"
> +#include "byte-order.h"
> +#include "nx-match.h"
> +#include "ovs-atomic.h"
> +#include "openvswitch/ofp-actions.h"
> +#include "openvswitch/ofp-errors.h"
> +#include "openvswitch/ofp-group.h"
> +#include "openvswitch/ofp-match.h"
> +#include "openvswitch/ofp-meter.h"
> +#include "openvswitch/ofp-msgs.h"
> +#include "openvswitch/ofp-parse.h"
> +#include "openvswitch/ofp-table.h"
> +#include "openvswitch/vlog.h"
> +
> +VLOG_DEFINE_THIS_MODULE(ofp_monitor);
> +
> +static struct vlog_rate_limit rl = VLOG_RATE_LIMIT_INIT(1, 5);
> +
> +/* Converts an OFPT_FLOW_REMOVED or NXT_FLOW_REMOVED message 'oh' into an
> + * abstract ofputil_flow_removed in 'fr'.  Returns 0 if successful,
> otherwise
> + * an OpenFlow error code. */
> +enum ofperr
> +ofputil_decode_flow_removed(struct ofputil_flow_removed *fr,
> +                            const struct ofp_header *oh)
> +{
> +    struct ofpbuf b = ofpbuf_const_initializer(oh, ntohs(oh->length));
> +    enum ofpraw raw = ofpraw_pull_assert(&b);
> +    if (raw == OFPRAW_OFPT11_FLOW_REMOVED) {
> +        const struct ofp12_flow_removed *ofr;
> +        enum ofperr error;
> +
> +        ofr = ofpbuf_pull(&b, sizeof *ofr);
> +
> +        error = ofputil_pull_ofp11_match(&b, NULL, NULL, &fr->match,
> NULL);
> +        if (error) {
> +            return error;
> +        }
> +
> +        fr->priority = ntohs(ofr->priority);
> +        fr->cookie = ofr->cookie;
> +        fr->reason = ofr->reason;
> +        fr->table_id = ofr->table_id;
> +        fr->duration_sec = ntohl(ofr->duration_sec);
> +        fr->duration_nsec = ntohl(ofr->duration_nsec);
> +        fr->idle_timeout = ntohs(ofr->idle_timeout);
> +        fr->hard_timeout = ntohs(ofr->hard_timeout);
> +        fr->packet_count = ntohll(ofr->packet_count);
> +        fr->byte_count = ntohll(ofr->byte_count);
> +    } else if (raw == OFPRAW_OFPT10_FLOW_REMOVED) {
> +        const struct ofp10_flow_removed *ofr;
> +
> +        ofr = ofpbuf_pull(&b, sizeof *ofr);
> +
> +        ofputil_match_from_ofp10_match(&ofr->match, &fr->match);
> +        fr->priority = ntohs(ofr->priority);
> +        fr->cookie = ofr->cookie;
> +        fr->reason = ofr->reason;
> +        fr->table_id = 255;
> +        fr->duration_sec = ntohl(ofr->duration_sec);
> +        fr->duration_nsec = ntohl(ofr->duration_nsec);
> +        fr->idle_timeout = ntohs(ofr->idle_timeout);
> +        fr->hard_timeout = 0;
> +        fr->packet_count = ntohll(ofr->packet_count);
> +        fr->byte_count = ntohll(ofr->byte_count);
> +    } else if (raw == OFPRAW_NXT_FLOW_REMOVED) {
> +        struct nx_flow_removed *nfr;
> +        enum ofperr error;
> +
> +        nfr = ofpbuf_pull(&b, sizeof *nfr);
> +        error = nx_pull_match(&b, ntohs(nfr->match_len), &fr->match, NULL,
> +                              NULL, false, NULL, NULL);
> +        if (error) {
> +            return error;
> +        }
> +        if (b.size) {
> +            return OFPERR_OFPBRC_BAD_LEN;
> +        }
> +
> +        fr->priority = ntohs(nfr->priority);
> +        fr->cookie = nfr->cookie;
> +        fr->reason = nfr->reason;
> +        fr->table_id = nfr->table_id ? nfr->table_id - 1 : 255;
> +        fr->duration_sec = ntohl(nfr->duration_sec);
> +        fr->duration_nsec = ntohl(nfr->duration_nsec);
> +        fr->idle_timeout = ntohs(nfr->idle_timeout);
> +        fr->hard_timeout = 0;
> +        fr->packet_count = ntohll(nfr->packet_count);
> +        fr->byte_count = ntohll(nfr->byte_count);
> +    } else {
> +        OVS_NOT_REACHED();
> +    }
> +
> +    return 0;
> +}
> +
> +/* Returns 'count' unchanged except that UINT64_MAX becomes 0.
> + *
> + * We use this in situations where OVS internally uses UINT64_MAX to mean
> + * "value unknown" but OpenFlow 1.0 does not define any unknown value. */
> +static uint64_t
> +unknown_to_zero(uint64_t count)
> +{
> +    return count != UINT64_MAX ? count : 0;
> +}
> +
> +/* Converts abstract ofputil_flow_removed 'fr' into an OFPT_FLOW_REMOVED
> or
> + * NXT_FLOW_REMOVED message 'oh' according to 'protocol', and returns the
> + * message. */
> +struct ofpbuf *
> +ofputil_encode_flow_removed(const struct ofputil_flow_removed *fr,
> +                            enum ofputil_protocol protocol)
> +{
> +    struct ofpbuf *msg;
> +    enum ofp_flow_removed_reason reason = fr->reason;
> +
> +    if (reason == OFPRR_METER_DELETE && !(protocol & OFPUTIL_P_OF14_UP)) {
> +        reason = OFPRR_DELETE;
> +    }
> +
> +    switch (protocol) {
> +    case OFPUTIL_P_OF11_STD:
> +    case OFPUTIL_P_OF12_OXM:
> +    case OFPUTIL_P_OF13_OXM:
> +    case OFPUTIL_P_OF14_OXM:
> +    case OFPUTIL_P_OF15_OXM:
> +    case OFPUTIL_P_OF16_OXM: {
> +        struct ofp12_flow_removed *ofr;
> +
> +        msg = ofpraw_alloc_xid(OFPRAW_OFPT11_FLOW_REMOVED,
> +                               ofputil_protocol_to_ofp_version(protocol),
> +                               htonl(0),
> +                               ofputil_match_typical_len(protocol));
> +        ofr = ofpbuf_put_zeros(msg, sizeof *ofr);
> +        ofr->cookie = fr->cookie;
> +        ofr->priority = htons(fr->priority);
> +        ofr->reason = reason;
> +        ofr->table_id = fr->table_id;
> +        ofr->duration_sec = htonl(fr->duration_sec);
> +        ofr->duration_nsec = htonl(fr->duration_nsec);
> +        ofr->idle_timeout = htons(fr->idle_timeout);
> +        ofr->hard_timeout = htons(fr->hard_timeout);
> +        ofr->packet_count = htonll(fr->packet_count);
> +        ofr->byte_count = htonll(fr->byte_count);
> +        ofputil_put_ofp11_match(msg, &fr->match, protocol);
> +        break;
> +    }
> +
> +    case OFPUTIL_P_OF10_STD:
> +    case OFPUTIL_P_OF10_STD_TID: {
> +        struct ofp10_flow_removed *ofr;
> +
> +        msg = ofpraw_alloc_xid(OFPRAW_OFPT10_FLOW_REMOVED, OFP10_VERSION,
> +                               htonl(0), 0);
> +        ofr = ofpbuf_put_zeros(msg, sizeof *ofr);
> +        ofputil_match_to_ofp10_match(&fr->match, &ofr->match);
> +        ofr->cookie = fr->cookie;
> +        ofr->priority = htons(fr->priority);
> +        ofr->reason = reason;
> +        ofr->duration_sec = htonl(fr->duration_sec);
> +        ofr->duration_nsec = htonl(fr->duration_nsec);
> +        ofr->idle_timeout = htons(fr->idle_timeout);
> +        ofr->packet_count = htonll(unknown_to_zero(fr->packet_count));
> +        ofr->byte_count = htonll(unknown_to_zero(fr->byte_count));
> +        break;
> +    }
> +
> +    case OFPUTIL_P_OF10_NXM:
> +    case OFPUTIL_P_OF10_NXM_TID: {
> +        struct nx_flow_removed *nfr;
> +        int match_len;
> +
> +        msg = ofpraw_alloc_xid(OFPRAW_NXT_FLOW_REMOVED, OFP10_VERSION,
> +                               htonl(0), NXM_TYPICAL_LEN);
> +        ofpbuf_put_zeros(msg, sizeof *nfr);
> +        match_len = nx_put_match(msg, &fr->match, 0, 0);
> +
> +        nfr = msg->msg;
> +        nfr->cookie = fr->cookie;
> +        nfr->priority = htons(fr->priority);
> +        nfr->reason = reason;
> +        nfr->table_id = fr->table_id + 1;
> +        nfr->duration_sec = htonl(fr->duration_sec);
> +        nfr->duration_nsec = htonl(fr->duration_nsec);
> +        nfr->idle_timeout = htons(fr->idle_timeout);
> +        nfr->match_len = htons(match_len);
> +        nfr->packet_count = htonll(fr->packet_count);
> +        nfr->byte_count = htonll(fr->byte_count);
> +        break;
> +    }
> +
> +    default:
> +        OVS_NOT_REACHED();
> +    }
> +
> +    return msg;
> +}
> +
> +/* ofputil_flow_monitor_request */
> +
> +/* Converts an NXST_FLOW_MONITOR request in 'msg' into an abstract
> + * ofputil_flow_monitor_request in 'rq'.
> + *
> + * Multiple NXST_FLOW_MONITOR requests can be packed into a single
> OpenFlow
> + * message.  Calling this function multiple times for a single 'msg'
> iterates
> + * through the requests.  The caller must initially leave 'msg''s layer
> + * pointers null and not modify them between calls.
> + *
> + * Returns 0 if successful, EOF if no requests were left in this 'msg',
> + * otherwise an OFPERR_* value. */
> +int
> +ofputil_decode_flow_monitor_request(struct ofputil_flow_monitor_request
> *rq,
> +                                    struct ofpbuf *msg)
> +{
> +    struct nx_flow_monitor_request *nfmr;
> +    uint16_t flags;
> +
> +    if (!msg->header) {
> +        ofpraw_pull_assert(msg);
> +    }
> +
> +    if (!msg->size) {
> +        return EOF;
> +    }
> +
> +    nfmr = ofpbuf_try_pull(msg, sizeof *nfmr);
> +    if (!nfmr) {
> +        VLOG_WARN_RL(&rl, "NXST_FLOW_MONITOR request has %"PRIu32" "
> +                     "leftover bytes at end", msg->size);
> +        return OFPERR_OFPBRC_BAD_LEN;
> +    }
> +
> +    flags = ntohs(nfmr->flags);
> +    if (!(flags & (NXFMF_ADD | NXFMF_DELETE | NXFMF_MODIFY))
> +        || flags & ~(NXFMF_INITIAL | NXFMF_ADD | NXFMF_DELETE
> +                     | NXFMF_MODIFY | NXFMF_ACTIONS | NXFMF_OWN)) {
> +        VLOG_WARN_RL(&rl, "NXST_FLOW_MONITOR has bad flags %#"PRIx16,
> flags);
> +        return OFPERR_OFPMOFC_BAD_FLAGS;
> +    }
> +
> +    if (!is_all_zeros(nfmr->zeros, sizeof nfmr->zeros)) {
> +        return OFPERR_NXBRC_MUST_BE_ZERO;
> +    }
> +
> +    rq->id = ntohl(nfmr->id);
> +    rq->flags = flags;
> +    rq->out_port = u16_to_ofp(ntohs(nfmr->out_port));
> +    rq->table_id = nfmr->table_id;
> +
> +    return nx_pull_match(msg, ntohs(nfmr->match_len), &rq->match, NULL,
> +                         NULL, false, NULL, NULL);
> +}
> +
> +void
> +ofputil_append_flow_monitor_request(
> +    const struct ofputil_flow_monitor_request *rq, struct ofpbuf *msg)
> +{
> +    struct nx_flow_monitor_request *nfmr;
> +    size_t start_ofs;
> +    int match_len;
> +
> +    if (!msg->size) {
> +        ofpraw_put(OFPRAW_NXST_FLOW_MONITOR_REQUEST, OFP10_VERSION, msg);
> +    }
> +
> +    start_ofs = msg->size;
> +    ofpbuf_put_zeros(msg, sizeof *nfmr);
> +    match_len = nx_put_match(msg, &rq->match, htonll(0), htonll(0));
> +
> +    nfmr = ofpbuf_at_assert(msg, start_ofs, sizeof *nfmr);
> +    nfmr->id = htonl(rq->id);
> +    nfmr->flags = htons(rq->flags);
> +    nfmr->out_port = htons(ofp_to_u16(rq->out_port));
> +    nfmr->match_len = htons(match_len);
> +    nfmr->table_id = rq->table_id;
> +}
> +
> +static char * OVS_WARN_UNUSED_RESULT
> +parse_flow_monitor_request__(struct ofputil_flow_monitor_request *fmr,
> +                             const char *str_,
> +                             const struct ofputil_port_map *port_map,
> +                             const struct ofputil_table_map *table_map,
> +                             char *string,
> +                             enum ofputil_protocol *usable_protocols)
> +{
> +    static atomic_count id = ATOMIC_COUNT_INIT(0);
> +    char *name, *value;
> +
> +    fmr->id = atomic_count_inc(&id);
> +
> +    fmr->flags = (NXFMF_INITIAL | NXFMF_ADD | NXFMF_DELETE | NXFMF_MODIFY
> +                  | NXFMF_OWN | NXFMF_ACTIONS);
> +    fmr->out_port = OFPP_NONE;
> +    fmr->table_id = 0xff;
> +    match_init_catchall(&fmr->match);
> +
> +    while (ofputil_parse_key_value(&string, &name, &value)) {
> +        const struct ofp_protocol *p;
> +        char *error = NULL;
> +
> +        if (!strcmp(name, "!initial")) {
> +            fmr->flags &= ~NXFMF_INITIAL;
> +        } else if (!strcmp(name, "!add")) {
> +            fmr->flags &= ~NXFMF_ADD;
> +        } else if (!strcmp(name, "!delete")) {
> +            fmr->flags &= ~NXFMF_DELETE;
> +        } else if (!strcmp(name, "!modify")) {
> +            fmr->flags &= ~NXFMF_MODIFY;
> +        } else if (!strcmp(name, "!actions")) {
> +            fmr->flags &= ~NXFMF_ACTIONS;
> +        } else if (!strcmp(name, "!own")) {
> +            fmr->flags &= ~NXFMF_OWN;
> +        } else if (ofp_parse_protocol(name, &p)) {
> +            match_set_dl_type(&fmr->match, htons(p->dl_type));
> +            if (p->nw_proto) {
> +                match_set_nw_proto(&fmr->match, p->nw_proto);
> +            }
> +        } else if (mf_from_name(name)) {
> +            error = ofp_parse_field(mf_from_name(name), value, port_map,
> +                                    &fmr->match, usable_protocols);
> +        } else {
> +            if (!*value) {
> +                return xasprintf("%s: field %s missing value", str_,
> name);
> +            }
> +
> +            if (!strcmp(name, "table")) {
> +                if (!ofputil_table_from_string(value, table_map,
> +                                               &fmr->table_id)) {
> +                    error = xasprintf("unknown table \"%s\"", value);
> +                }
> +            } else if (!strcmp(name, "out_port")) {
> +                fmr->out_port = u16_to_ofp(atoi(value));
> +            } else {
> +                return xasprintf("%s: unknown keyword %s", str_, name);
> +            }
> +        }
> +
> +        if (error) {
> +            return error;
> +        }
> +    }
> +    return NULL;
> +}
> +
> +/* Convert 'str_' (as described in the documentation for the "monitor"
> command
> + * in the ovs-ofctl man page) into 'fmr'.
> + *
> + * Returns NULL if successful, otherwise a malloc()'d string describing
> the
> + * error.  The caller is responsible for freeing the returned string. */
> +char * OVS_WARN_UNUSED_RESULT
> +parse_flow_monitor_request(struct ofputil_flow_monitor_request *fmr,
> +                           const char *str_,
> +                           const struct ofputil_port_map *port_map,
> +                           const struct ofputil_table_map *table_map,
> +                           enum ofputil_protocol *usable_protocols)
> +{
> +    char *string = xstrdup(str_);
> +    char *error = parse_flow_monitor_request__(fmr, str_, port_map,
> table_map,
> +                                               string, usable_protocols);
> +    free(string);
> +    return error;
> +}
> +
> +/* Converts an NXST_FLOW_MONITOR reply (also known as a flow update) in
> 'msg'
> + * into an abstract ofputil_flow_update in 'update'.  The caller must have
> + * initialized update->match to point to space allocated for a match.
> + *
> + * Uses 'ofpacts' to store the abstract OFPACT_* version of the update's
> + * actions (except for NXFME_ABBREV, which never includes actions).  The
> caller
> + * must initialize 'ofpacts' and retains ownership of it.
> 'update->ofpacts'
> + * will point into the 'ofpacts' buffer.
> + *
> + * Multiple flow updates can be packed into a single OpenFlow message.
> Calling
> + * this function multiple times for a single 'msg' iterates through the
> + * updates.  The caller must initially leave 'msg''s layer pointers null
> and
> + * not modify them between calls.
> + *
> + * Returns 0 if successful, EOF if no updates were left in this 'msg',
> + * otherwise an OFPERR_* value. */
> +int
> +ofputil_decode_flow_update(struct ofputil_flow_update *update,
> +                           struct ofpbuf *msg, struct ofpbuf *ofpacts)
> +{
> +    struct nx_flow_update_header *nfuh;
> +    unsigned int length;
> +    struct ofp_header *oh;
> +
> +    if (!msg->header) {
> +        ofpraw_pull_assert(msg);
> +    }
> +
> +    ofpbuf_clear(ofpacts);
> +    if (!msg->size) {
> +        return EOF;
> +    }
> +
> +    if (msg->size < sizeof(struct nx_flow_update_header)) {
> +        goto bad_len;
> +    }
> +
> +    oh = msg->header;
> +
> +    nfuh = msg->data;
> +    update->event = ntohs(nfuh->event);
> +    length = ntohs(nfuh->length);
> +    if (length > msg->size || length % 8) {
> +        goto bad_len;
> +    }
> +
> +    if (update->event == NXFME_ABBREV) {
> +        struct nx_flow_update_abbrev *nfua;
> +
> +        if (length != sizeof *nfua) {
> +            goto bad_len;
> +        }
> +
> +        nfua = ofpbuf_pull(msg, sizeof *nfua);
> +        update->xid = nfua->xid;
> +        return 0;
> +    } else if (update->event == NXFME_ADDED
> +               || update->event == NXFME_DELETED
> +               || update->event == NXFME_MODIFIED) {
> +        struct nx_flow_update_full *nfuf;
> +        unsigned int actions_len;
> +        unsigned int match_len;
> +        enum ofperr error;
> +
> +        if (length < sizeof *nfuf) {
> +            goto bad_len;
> +        }
> +
> +        nfuf = ofpbuf_pull(msg, sizeof *nfuf);
> +        match_len = ntohs(nfuf->match_len);
> +        if (sizeof *nfuf + match_len > length) {
> +            goto bad_len;
> +        }
> +
> +        update->reason = ntohs(nfuf->reason);
> +        update->idle_timeout = ntohs(nfuf->idle_timeout);
> +        update->hard_timeout = ntohs(nfuf->hard_timeout);
> +        update->table_id = nfuf->table_id;
> +        update->cookie = nfuf->cookie;
> +        update->priority = ntohs(nfuf->priority);
> +
> +        error = nx_pull_match(msg, match_len, &update->match, NULL, NULL,
> +                              false, NULL, NULL);
> +        if (error) {
> +            return error;
> +        }
> +
> +        actions_len = length - sizeof *nfuf - ROUND_UP(match_len, 8);
> +        error = ofpacts_pull_openflow_actions(msg, actions_len,
> oh->version,
> +                                              NULL, NULL, ofpacts);
> +        if (error) {
> +            return error;
> +        }
> +
> +        update->ofpacts = ofpacts->data;
> +        update->ofpacts_len = ofpacts->size;
> +        return 0;
> +    } else {
> +        VLOG_WARN_RL(&rl, "NXST_FLOW_MONITOR reply has bad event %"PRIu16,
> +                     ntohs(nfuh->event));
> +        return OFPERR_NXBRC_FM_BAD_EVENT;
> +    }
> +
> +bad_len:
> +    VLOG_WARN_RL(&rl, "NXST_FLOW_MONITOR reply has %"PRIu32" "
> +                 "leftover bytes at end", msg->size);
> +    return OFPERR_OFPBRC_BAD_LEN;
> +}
> +
> +uint32_t
> +ofputil_decode_flow_monitor_cancel(const struct ofp_header *oh)
> +{
> +    const struct nx_flow_monitor_cancel *cancel = ofpmsg_body(oh);
> +
> +    return ntohl(cancel->id);
> +}
> +
> +struct ofpbuf *
> +ofputil_encode_flow_monitor_cancel(uint32_t id)
> +{
> +    struct nx_flow_monitor_cancel *nfmc;
> +    struct ofpbuf *msg;
> +
> +    msg = ofpraw_alloc(OFPRAW_NXT_FLOW_MONITOR_CANCEL, OFP10_VERSION, 0);
> +    nfmc = ofpbuf_put_uninit(msg, sizeof *nfmc);
> +    nfmc->id = htonl(id);
> +    return msg;
> +}
> +
> +void
> +ofputil_start_flow_update(struct ovs_list *replies)
> +{
> +    struct ofpbuf *msg;
> +
> +    msg = ofpraw_alloc_xid(OFPRAW_NXST_FLOW_MONITOR_REPLY, OFP10_VERSION,
> +                           htonl(0), 1024);
> +
> +    ovs_list_init(replies);
> +    ovs_list_push_back(replies, &msg->list_node);
> +}
> +
> +void
> +ofputil_append_flow_update(const struct ofputil_flow_update *update,
> +                           struct ovs_list *replies,
> +                           const struct tun_table *tun_table)
> +{
> +    struct ofputil_flow_update *update_ =
> +        CONST_CAST(struct ofputil_flow_update *, update);
> +    const struct tun_table *orig_tun_table;
> +    enum ofp_version version = ofpmp_version(replies);
> +    struct nx_flow_update_header *nfuh;
> +    struct ofpbuf *msg;
> +    size_t start_ofs;
> +
> +    orig_tun_table = update->match.flow.tunnel.metadata.tab;
> +    update_->match.flow.tunnel.metadata.tab = tun_table;
> +
> +    msg = ofpbuf_from_list(ovs_list_back(replies));
> +    start_ofs = msg->size;
> +
> +    if (update->event == NXFME_ABBREV) {
> +        struct nx_flow_update_abbrev *nfua;
> +
> +        nfua = ofpbuf_put_zeros(msg, sizeof *nfua);
> +        nfua->xid = update->xid;
> +    } else {
> +        struct nx_flow_update_full *nfuf;
> +        int match_len;
> +
> +        ofpbuf_put_zeros(msg, sizeof *nfuf);
> +        match_len = nx_put_match(msg, &update->match, htonll(0),
> htonll(0));
> +        ofpacts_put_openflow_actions(update->ofpacts,
> update->ofpacts_len, msg,
> +                                     version);
> +        nfuf = ofpbuf_at_assert(msg, start_ofs, sizeof *nfuf);
> +        nfuf->reason = htons(update->reason);
> +        nfuf->priority = htons(update->priority);
> +        nfuf->idle_timeout = htons(update->idle_timeout);
> +        nfuf->hard_timeout = htons(update->hard_timeout);
> +        nfuf->match_len = htons(match_len);
> +        nfuf->table_id = update->table_id;
> +        nfuf->cookie = update->cookie;
> +    }
> +
> +    nfuh = ofpbuf_at_assert(msg, start_ofs, sizeof *nfuh);
> +    nfuh->length = htons(msg->size - start_ofs);
> +    nfuh->event = htons(update->event);
> +
> +    ofpmp_postappend(replies, start_ofs);
> +    update_->match.flow.tunnel.metadata.tab = orig_tun_table;
> +}
> +
> +/* Encodes 'rf' according to 'protocol', and returns the encoded message.
> + * 'protocol' must be for OpenFlow 1.4 or later. */
> +struct ofpbuf *
> +ofputil_encode_requestforward(const struct ofputil_requestforward *rf,
> +                              enum ofputil_protocol protocol)
> +{
> +    enum ofp_version ofp_version = ofputil_protocol_to_ofp_
> version(protocol);
> +    struct ofpbuf *inner;
> +
> +    switch (rf->reason) {
> +    case OFPRFR_GROUP_MOD:
> +        inner = ofputil_encode_group_mod(ofp_version, rf->group_mod);
> +        break;
> +
> +    case OFPRFR_METER_MOD:
> +        inner = ofputil_encode_meter_mod(ofp_version, rf->meter_mod);
> +        break;
> +
> +    case OFPRFR_N_REASONS:
> +    default:
> +        OVS_NOT_REACHED();
> +    }
> +
> +    struct ofp_header *inner_oh = inner->data;
> +    inner_oh->xid = rf->xid;
> +    inner_oh->length = htons(inner->size);
> +
> +    struct ofpbuf *outer = ofpraw_alloc_xid(OFPRAW_OFPT14_REQUESTFORWARD,
> +                                            ofp_version, htonl(0),
> +                                            inner->size);
> +    ofpbuf_put(outer, inner->data, inner->size);
> +    ofpbuf_delete(inner);
> +
> +    return outer;
> +}
> +
> +/* Decodes OFPT_REQUESTFORWARD message 'outer'.  On success, puts the
> decoded
> + * form into '*rf' and returns 0, and the caller is later responsible for
> + * freeing the content of 'rf', with ofputil_destroy_requestforward(rf).
> On
> + * failure, returns an ofperr and '*rf' is indeterminate. */
> +enum ofperr
> +ofputil_decode_requestforward(const struct ofp_header *outer,
> +                              struct ofputil_requestforward *rf)
> +{
> +    struct ofpbuf b = ofpbuf_const_initializer(outer,
> ntohs(outer->length));
> +
> +    /* Skip past outer message. */
> +    ovs_assert(ofpraw_pull_assert(&b) == OFPRAW_OFPT14_REQUESTFORWARD);
> +
> +    /* Validate inner message. */
> +    if (b.size < sizeof(struct ofp_header)) {
> +        return OFPERR_OFPBFC_MSG_BAD_LEN;
> +    }
> +    const struct ofp_header *inner = b.data;
> +    unsigned int inner_len = ntohs(inner->length);
> +    if (inner_len < sizeof(struct ofp_header) || inner_len > b.size) {
> +        return OFPERR_OFPBFC_MSG_BAD_LEN;
> +    }
> +    if (inner->version != outer->version) {
> +        return OFPERR_OFPBRC_BAD_VERSION;
> +    }
> +
> +    /* Parse inner message. */
> +    enum ofptype type;
> +    enum ofperr error = ofptype_decode(&type, inner);
> +    if (error) {
> +        return error;
> +    }
> +
> +    rf->xid = inner->xid;
> +    if (type == OFPTYPE_GROUP_MOD) {
> +        rf->reason = OFPRFR_GROUP_MOD;
> +        rf->group_mod = xmalloc(sizeof *rf->group_mod);
> +        error = ofputil_decode_group_mod(inner, rf->group_mod);
> +        if (error) {
> +            free(rf->group_mod);
> +            return error;
> +        }
> +    } else if (type == OFPTYPE_METER_MOD) {
> +        rf->reason = OFPRFR_METER_MOD;
> +        rf->meter_mod = xmalloc(sizeof *rf->meter_mod);
> +        ofpbuf_init(&rf->bands, 64);
> +        error = ofputil_decode_meter_mod(inner, rf->meter_mod,
> &rf->bands);
> +        if (error) {
> +            free(rf->meter_mod);
> +            ofpbuf_uninit(&rf->bands);
> +            return error;
> +        }
> +    } else {
> +        return OFPERR_OFPBFC_MSG_UNSUP;
> +    }
> +
> +    return 0;
> +}
> +
> +/* Frees the content of 'rf', which should have been initialized through a
> + * successful call to ofputil_decode_requestforward(). */
> +void
> +ofputil_destroy_requestforward(struct ofputil_requestforward *rf)
> +{
> +    if (!rf) {
> +        return;
> +    }
> +
> +    switch (rf->reason) {
> +    case OFPRFR_GROUP_MOD:
> +        ofputil_uninit_group_mod(rf->group_mod);
> +        free(rf->group_mod);
> +        break;
> +
> +    case OFPRFR_METER_MOD:
> +        ofpbuf_uninit(&rf->bands);
> +        free(rf->meter_mod);
> +        break;
> +
> +    case OFPRFR_N_REASONS:
> +        OVS_NOT_REACHED();
> +    }
> +}
> diff --git a/lib/ofp-packet.c b/lib/ofp-packet.c
> new file mode 100644
> index 000000000000..05cbea15b7e2
> --- /dev/null
> +++ b/lib/ofp-packet.c
> @@ -0,0 +1,1233 @@
> +/*
> + * Copyright (c) 2008-2017 Nicira, Inc.
> + *
> + * Licensed under the Apache License, Version 2.0 (the "License");
> + * you may not use this file except in compliance with the License.
> + * You may obtain a copy of the License at:
> + *
> + *     http://www.apache.org/licenses/LICENSE-2.0
> + *
> + * Unless required by applicable law or agreed to in writing, software
> + * distributed under the License is distributed on an "AS IS" BASIS,
> + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
> implied.
> + * See the License for the specific language governing permissions and
> + * limitations under the License.
> + */
> +
> +#include <config.h>
> +#include "openvswitch/ofp-packet.h"
> +#include <string.h>
> +#include "dp-packet.h"
> +#include "nx-match.h"
> +#include "openvswitch/ofp-actions.h"
> +#include "openvswitch/ofp-errors.h"
> +#include "openvswitch/ofp-msgs.h"
> +#include "openvswitch/ofp-parse.h"
> +#include "openvswitch/ofp-port.h"
> +#include "openvswitch/ofp-prop.h"
> +#include "openvswitch/ofpbuf.h"
> +#include "openvswitch/vlog.h"
> +#include "util.h"
> +#include "uuid.h"
> +
> +VLOG_DEFINE_THIS_MODULE(ofp_packet);
> +
> +static struct vlog_rate_limit rl = VLOG_RATE_LIMIT_INIT(1, 5);
> +
> +bool
> +ofputil_packet_in_format_is_valid(enum nx_packet_in_format
> packet_in_format)
> +{
> +    switch (packet_in_format) {
> +    case NXPIF_STANDARD:
> +    case NXPIF_NXT_PACKET_IN:
> +    case NXPIF_NXT_PACKET_IN2:
> +        return true;
> +    }
> +
> +    return false;
> +}
> +
> +const char *
> +ofputil_packet_in_format_to_string(enum nx_packet_in_format
> packet_in_format)
> +{
> +    switch (packet_in_format) {
> +    case NXPIF_STANDARD:
> +        return "standard";
> +    case NXPIF_NXT_PACKET_IN:
> +        return "nxt_packet_in";
> +    case NXPIF_NXT_PACKET_IN2:
> +        return "nxt_packet_in2";
> +    default:
> +        OVS_NOT_REACHED();
> +    }
> +}
> +
> +int
> +ofputil_packet_in_format_from_string(const char *s)
> +{
> +    return (!strcmp(s, "standard") || !strcmp(s, "openflow10")
> +            ? NXPIF_STANDARD
> +            : !strcmp(s, "nxt_packet_in") || !strcmp(s, "nxm")
> +            ? NXPIF_NXT_PACKET_IN
> +            : !strcmp(s, "nxt_packet_in2")
> +            ? NXPIF_NXT_PACKET_IN2
> +            : -1);
> +}
> +
> +struct ofpbuf *
> +ofputil_make_set_packet_in_format(enum ofp_version ofp_version,
> +                                  enum nx_packet_in_format
> packet_in_format)
> +{
> +    struct nx_set_packet_in_format *spif;
> +    struct ofpbuf *msg;
> +
> +    msg = ofpraw_alloc(OFPRAW_NXT_SET_PACKET_IN_FORMAT, ofp_version, 0);
> +    spif = ofpbuf_put_zeros(msg, sizeof *spif);
> +    spif->format = htonl(packet_in_format);
> +
> +    return msg;
> +}
> +
> +/* The caller has done basic initialization of '*pin'; the other output
> + * arguments needs to be initialized. */
> +static enum ofperr
> +decode_nx_packet_in2(const struct ofp_header *oh, bool loose,
> +                     const struct tun_table *tun_table,
> +                     const struct vl_mff_map *vl_mff_map,
> +                     struct ofputil_packet_in *pin,
> +                     size_t *total_len, uint32_t *buffer_id,
> +                     struct ofpbuf *continuation)
> +{
> +    *total_len = 0;
> +    *buffer_id = UINT32_MAX;
> +
> +    struct ofpbuf properties;
> +    ofpbuf_use_const(&properties, oh, ntohs(oh->length));
> +    ofpraw_pull_assert(&properties);
> +
> +    while (properties.size > 0) {
> +        struct ofpbuf payload;
> +        uint64_t type;
> +
> +        enum ofperr error = ofpprop_pull(&properties, &payload, &type);
> +        if (error) {
> +            return error;
> +        }
> +
> +        switch (type) {
> +        case NXPINT_PACKET:
> +            pin->packet = payload.msg;
> +            pin->packet_len = ofpbuf_msgsize(&payload);
> +            break;
> +
> +        case NXPINT_FULL_LEN: {
> +            uint32_t u32;
> +            error = ofpprop_parse_u32(&payload, &u32);
> +            *total_len = u32;
> +            break;
> +        }
> +
> +        case NXPINT_BUFFER_ID:
> +            error = ofpprop_parse_u32(&payload, buffer_id);
> +            break;
> +
> +        case NXPINT_TABLE_ID:
> +            error = ofpprop_parse_u8(&payload, &pin->table_id);
> +            break;
> +
> +        case NXPINT_COOKIE:
> +            error = ofpprop_parse_be64(&payload, &pin->cookie);
> +            break;
> +
> +        case NXPINT_REASON: {
> +            uint8_t reason;
> +            error = ofpprop_parse_u8(&payload, &reason);
> +            pin->reason = reason;
> +            break;
> +        }
> +
> +        case NXPINT_METADATA:
> +            error = oxm_decode_match(payload.msg,
> ofpbuf_msgsize(&payload),
> +                                     loose, tun_table, vl_mff_map,
> +                                     &pin->flow_metadata);
> +            break;
> +
> +        case NXPINT_USERDATA:
> +            pin->userdata = payload.msg;
> +            pin->userdata_len = ofpbuf_msgsize(&payload);
> +            break;
> +
> +        case NXPINT_CONTINUATION:
> +            if (continuation) {
> +                error = ofpprop_parse_nested(&payload, continuation);
> +            }
> +            break;
> +
> +        default:
> +            error = OFPPROP_UNKNOWN(loose, "NX_PACKET_IN2", type);
> +            break;
> +        }
> +        if (error) {
> +            return error;
> +        }
> +    }
> +
> +    if (!pin->packet_len) {
> +        VLOG_WARN_RL(&rl, "NXT_PACKET_IN2 lacks packet");
> +        return OFPERR_OFPBRC_BAD_LEN;
> +    } else if (!*total_len) {
> +        *total_len = pin->packet_len;
> +    } else if (*total_len < pin->packet_len) {
> +        VLOG_WARN_RL(&rl, "NXT_PACKET_IN2 claimed full_len < len");
> +        return OFPERR_OFPBRC_BAD_LEN;
> +    }
> +
> +    return 0;
> +}
> +
> +/* Decodes the packet-in message starting at 'oh' into '*pin'.  Populates
> + * 'pin->packet' and 'pin->packet_len' with the part of the packet
> actually
> + * included in the message.  If 'total_lenp' is nonnull, populates
> + * '*total_lenp' with the original length of the packet (which is larger
> than
> + * 'packet->len' if only part of the packet was included).  If
> 'buffer_idp' is
> + * nonnull, stores the packet's buffer ID in '*buffer_idp' (UINT32_MAX if
> it
> + * was not buffered).
> + *
> + * Populates 'continuation', if nonnull, with the continuation data from
> the
> + * packet-in (an empty buffer, if 'oh' did not contain continuation
> data).  The
> + * format of this data is supposed to be opaque to anything other than
> + * ovs-vswitchd, so that in any other process the only reasonable use of
> this
> + * data is to be copied into an NXT_RESUME message via
> ofputil_encode_resume().
> + *
> + * This function points 'pin->packet' into 'oh', so the caller should not
> free
> + * it separately from the original OpenFlow message.  This is also true
> for
> + * 'pin->userdata' (which could also end up NULL if there is no userdata).
> + *
> + * 'vl_mff_map' is an optional parameter that is used to validate the
> length
> + * of variable length mf_fields in 'match'. If it is not provided, the
> + * default mf_fields with maximum length will be used.
> + *
> + * Returns 0 if successful, otherwise an OpenFlow error code. */
> +enum ofperr
> +ofputil_decode_packet_in(const struct ofp_header *oh, bool loose,
> +                         const struct tun_table *tun_table,
> +                         const struct vl_mff_map *vl_mff_map,
> +                         struct ofputil_packet_in *pin,
> +                         size_t *total_lenp, uint32_t *buffer_idp,
> +                         struct ofpbuf *continuation)
> +{
> +    uint32_t buffer_id;
> +    size_t total_len;
> +
> +    memset(pin, 0, sizeof *pin);
> +    pin->cookie = OVS_BE64_MAX;
> +    if (continuation) {
> +        ofpbuf_use_const(continuation, NULL, 0);
> +    }
> +
> +    struct ofpbuf b = ofpbuf_const_initializer(oh, ntohs(oh->length));
> +    enum ofpraw raw = ofpraw_pull_assert(&b);
> +    if (raw == OFPRAW_OFPT13_PACKET_IN || raw == OFPRAW_OFPT12_PACKET_IN)
> {
> +        const struct ofp12_packet_in *opi = ofpbuf_pull(&b, sizeof *opi);
> +        const ovs_be64 *cookie = (raw == OFPRAW_OFPT13_PACKET_IN
> +                                  ? ofpbuf_pull(&b, sizeof *cookie)
> +                                  : NULL);
> +        enum ofperr error = oxm_pull_match_loose(&b, false, tun_table,
> +                                                 &pin->flow_metadata);
> +        if (error) {
> +            return error;
> +        }
> +
> +        if (!ofpbuf_try_pull(&b, 2)) {
> +            return OFPERR_OFPBRC_BAD_LEN;
> +        }
> +
> +        pin->reason = opi->reason;
> +        pin->table_id = opi->table_id;
> +        buffer_id = ntohl(opi->buffer_id);
> +        total_len = ntohs(opi->total_len);
> +        if (cookie) {
> +            pin->cookie = *cookie;
> +        }
> +
> +        pin->packet = b.data;
> +        pin->packet_len = b.size;
> +    } else if (raw == OFPRAW_OFPT10_PACKET_IN) {
> +        const struct ofp10_packet_in *opi;
> +
> +        opi = ofpbuf_pull(&b, offsetof(struct ofp10_packet_in, data));
> +
> +        pin->packet = CONST_CAST(uint8_t *, opi->data);
> +        pin->packet_len = b.size;
> +
> +        match_init_catchall(&pin->flow_metadata);
> +        match_set_in_port(&pin->flow_metadata,
> +                          u16_to_ofp(ntohs(opi->in_port)));
> +        pin->reason = opi->reason;
> +        buffer_id = ntohl(opi->buffer_id);
> +        total_len = ntohs(opi->total_len);
> +    } else if (raw == OFPRAW_OFPT11_PACKET_IN) {
> +        const struct ofp11_packet_in *opi;
> +        ofp_port_t in_port;
> +        enum ofperr error;
> +
> +        opi = ofpbuf_pull(&b, sizeof *opi);
> +
> +        pin->packet = b.data;
> +        pin->packet_len = b.size;
> +
> +        buffer_id = ntohl(opi->buffer_id);
> +        error = ofputil_port_from_ofp11(opi->in_port, &in_port);
> +        if (error) {
> +            return error;
> +        }
> +        match_init_catchall(&pin->flow_metadata);
> +        match_set_in_port(&pin->flow_metadata, in_port);
> +        total_len = ntohs(opi->total_len);
> +        pin->reason = opi->reason;
> +        pin->table_id = opi->table_id;
> +    } else if (raw == OFPRAW_NXT_PACKET_IN) {
> +        const struct nx_packet_in *npi;
> +        int error;
> +
> +        npi = ofpbuf_pull(&b, sizeof *npi);
> +        error = nx_pull_match_loose(&b, ntohs(npi->match_len),
> +                                    &pin->flow_metadata, NULL, NULL,
> false,
> +                                    NULL);
> +        if (error) {
> +            return error;
> +        }
> +
> +        if (!ofpbuf_try_pull(&b, 2)) {
> +            return OFPERR_OFPBRC_BAD_LEN;
> +        }
> +
> +        pin->reason = npi->reason;
> +        pin->table_id = npi->table_id;
> +        pin->cookie = npi->cookie;
> +
> +        buffer_id = ntohl(npi->buffer_id);
> +        total_len = ntohs(npi->total_len);
> +
> +        pin->packet = b.data;
> +        pin->packet_len = b.size;
> +    } else if (raw == OFPRAW_NXT_PACKET_IN2 || raw == OFPRAW_NXT_RESUME) {
> +        enum ofperr error = decode_nx_packet_in2(oh, loose, tun_table,
> +                                                 vl_mff_map, pin,
> &total_len,
> +                                                 &buffer_id,
> continuation);
> +        if (error) {
> +            return error;
> +        }
> +    } else {
> +        OVS_NOT_REACHED();
> +    }
> +
> +    if (total_lenp) {
> +        *total_lenp = total_len;
> +    }
> +    if (buffer_idp) {
> +        *buffer_idp = buffer_id;
> +    }
> +
> +    return 0;
> +}
> +
> +static int
> +encode_packet_in_reason(enum ofp_packet_in_reason reason,
> +                        enum ofp_version version)
> +{
> +    switch (reason) {
> +    case OFPR_NO_MATCH:
> +    case OFPR_ACTION:
> +    case OFPR_INVALID_TTL:
> +        return reason;
> +
> +    case OFPR_ACTION_SET:
> +    case OFPR_GROUP:
> +    case OFPR_PACKET_OUT:
> +        return version < OFP14_VERSION ? OFPR_ACTION : reason;
> +
> +    case OFPR_EXPLICIT_MISS:
> +        return version < OFP13_VERSION ? OFPR_ACTION : OFPR_NO_MATCH;
> +
> +    case OFPR_IMPLICIT_MISS:
> +        return OFPR_NO_MATCH;
> +
> +    case OFPR_N_REASONS:
> +    default:
> +        OVS_NOT_REACHED();
> +    }
> +}
> +
> +/* Only NXT_PACKET_IN2 (not NXT_RESUME) should include NXCPT_USERDATA, so
> this
> + * function omits it.  The caller can add it itself if desired. */
> +static void
> +ofputil_put_packet_in(const struct ofputil_packet_in *pin,
> +                      enum ofp_version version, size_t include_bytes,
> +                      struct ofpbuf *msg)
> +{
> +    /* Add packet properties. */
> +    ofpprop_put(msg, NXPINT_PACKET, pin->packet, include_bytes);
> +    if (include_bytes != pin->packet_len) {
> +        ofpprop_put_u32(msg, NXPINT_FULL_LEN, pin->packet_len);
> +    }
> +
> +    /* Add flow properties. */
> +    ofpprop_put_u8(msg, NXPINT_TABLE_ID, pin->table_id);
> +    if (pin->cookie != OVS_BE64_MAX) {
> +        ofpprop_put_be64(msg, NXPINT_COOKIE, pin->cookie);
> +    }
> +
> +    /* Add other properties. */
> +    ofpprop_put_u8(msg, NXPINT_REASON,
> +                   encode_packet_in_reason(pin->reason, version));
> +
> +    size_t start = ofpprop_start(msg, NXPINT_METADATA);
> +    oxm_put_raw(msg, &pin->flow_metadata, version);
> +    ofpprop_end(msg, start);
> +}
> +
> +static void
> +put_actions_property(struct ofpbuf *msg, uint64_t prop_type,
> +                     enum ofp_version version,
> +                     const struct ofpact *actions, size_t actions_len)
> +{
> +    if (actions_len) {
> +        size_t start = ofpprop_start_nested(msg, prop_type);
> +        ofpacts_put_openflow_actions(actions, actions_len, msg, version);
> +        ofpprop_end(msg, start);
> +    }
> +}
> +
> +enum nx_continuation_prop_type {
> +    NXCPT_BRIDGE = 0x8000,
> +    NXCPT_STACK,
> +    NXCPT_MIRRORS,
> +    NXCPT_CONNTRACKED,
> +    NXCPT_TABLE_ID,
> +    NXCPT_COOKIE,
> +    NXCPT_ACTIONS,
> +    NXCPT_ACTION_SET,
> +};
> +
> +/* Only NXT_PACKET_IN2 (not NXT_RESUME) should include NXCPT_USERDATA, so
> this
> + * function omits it.  The caller can add it itself if desired. */
> +static void
> +ofputil_put_packet_in_private(const struct ofputil_packet_in_private
> *pin,
> +                              enum ofp_version version, size_t
> include_bytes,
> +                              struct ofpbuf *msg)
> +{
> +    ofputil_put_packet_in(&pin->base, version, include_bytes, msg);
> +
> +    size_t continuation_ofs = ofpprop_start_nested(msg,
> NXPINT_CONTINUATION);
> +    size_t inner_ofs = msg->size;
> +
> +    if (!uuid_is_zero(&pin->bridge)) {
> +        ofpprop_put_uuid(msg, NXCPT_BRIDGE, &pin->bridge);
> +    }
> +
> +    struct ofpbuf pin_stack;
> +    ofpbuf_use_const(&pin_stack, pin->stack, pin->stack_size);
> +
> +    while (pin_stack.size) {
> +        uint8_t len;
> +        uint8_t *val = nx_stack_pop(&pin_stack, &len);
> +        ofpprop_put(msg, NXCPT_STACK, val, len);
> +    }
> +
> +    if (pin->mirrors) {
> +        ofpprop_put_u32(msg, NXCPT_MIRRORS, pin->mirrors);
> +    }
> +
> +    if (pin->conntracked) {
> +        ofpprop_put_flag(msg, NXCPT_CONNTRACKED);
> +    }
> +
> +    if (pin->actions_len) {
> +        /* Divide 'pin->actions' into groups that begins with an
> +         * unroll_xlate action.  For each group, emit a NXCPT_TABLE_ID and
> +         * NXCPT_COOKIE property (if either has changed; each is initially
> +         * assumed 0), then a NXCPT_ACTIONS property with the grouped
> +         * actions.
> +         *
> +         * The alternative is to make OFPACT_UNROLL_XLATE public.  We can
> +         * always do that later, since this is a private property. */
> +        const struct ofpact *const end = ofpact_end(pin->actions,
> +                                                    pin->actions_len);
> +        const struct ofpact_unroll_xlate *unroll = NULL;
> +        uint8_t table_id = 0;
> +        ovs_be64 cookie = 0;
> +
> +        const struct ofpact *a;
> +        for (a = pin->actions; ; a = ofpact_next(a)) {
> +            if (a == end || a->type == OFPACT_UNROLL_XLATE) {
> +                if (unroll) {
> +                    if (table_id != unroll->rule_table_id) {
> +                        ofpprop_put_u8(msg, NXCPT_TABLE_ID,
> +                                       unroll->rule_table_id);
> +                        table_id = unroll->rule_table_id;
> +                    }
> +                    if (cookie != unroll->rule_cookie) {
> +                        ofpprop_put_be64(msg, NXCPT_COOKIE,
> +                                         unroll->rule_cookie);
> +                        cookie = unroll->rule_cookie;
> +                    }
> +                }
> +
> +                const struct ofpact *start
> +                    = unroll ? ofpact_next(&unroll->ofpact) :
> pin->actions;
> +                put_actions_property(msg, NXCPT_ACTIONS, version,
> +                                     start, (a - start) * sizeof *a);
> +
> +                if (a == end) {
> +                    break;
> +                }
> +                unroll = ofpact_get_UNROLL_XLATE(a);
> +            }
> +        }
> +    }
> +
> +    if (pin->action_set_len) {
> +        size_t start = ofpprop_start_nested(msg, NXCPT_ACTION_SET);
> +        ofpacts_put_openflow_actions(pin->action_set,
> +                                     pin->action_set_len, msg, version);
> +        ofpprop_end(msg, start);
> +    }
> +
> +    if (msg->size > inner_ofs) {
> +        ofpprop_end(msg, continuation_ofs);
> +    } else {
> +        msg->size = continuation_ofs;
> +    }
> +}
> +
> +static struct ofpbuf *
> +ofputil_encode_ofp10_packet_in(const struct ofputil_packet_in *pin)
> +{
> +    struct ofp10_packet_in *opi;
> +    struct ofpbuf *msg;
> +
> +    msg = ofpraw_alloc_xid(OFPRAW_OFPT10_PACKET_IN, OFP10_VERSION,
> +                           htonl(0), pin->packet_len);
> +    opi = ofpbuf_put_zeros(msg, offsetof(struct ofp10_packet_in, data));
> +    opi->total_len = htons(pin->packet_len);
> +    opi->in_port = htons(ofp_to_u16(pin->flow_metadata.flow.in_port.ofp_
> port));
> +    opi->reason = encode_packet_in_reason(pin->reason, OFP10_VERSION);
> +    opi->buffer_id = htonl(UINT32_MAX);
> +
> +    return msg;
> +}
> +
> +static struct ofpbuf *
> +ofputil_encode_nx_packet_in(const struct ofputil_packet_in *pin,
> +                            enum ofp_version version)
> +{
> +    struct nx_packet_in *npi;
> +    struct ofpbuf *msg;
> +    size_t match_len;
> +
> +    /* The final argument is just an estimate of the space required. */
> +    msg = ofpraw_alloc_xid(OFPRAW_NXT_PACKET_IN, version,
> +                           htonl(0), NXM_TYPICAL_LEN + 2 +
> pin->packet_len);
> +    ofpbuf_put_zeros(msg, sizeof *npi);
> +    match_len = nx_put_match(msg, &pin->flow_metadata, 0, 0);
> +    ofpbuf_put_zeros(msg, 2);
> +
> +    npi = msg->msg;
> +    npi->buffer_id = htonl(UINT32_MAX);
> +    npi->total_len = htons(pin->packet_len);
> +    npi->reason = encode_packet_in_reason(pin->reason, version);
> +    npi->table_id = pin->table_id;
> +    npi->cookie = pin->cookie;
> +    npi->match_len = htons(match_len);
> +
> +    return msg;
> +}
> +
> +static struct ofpbuf *
> +ofputil_encode_nx_packet_in2(const struct ofputil_packet_in_private *pin,
> +                             enum ofp_version version, size_t
> include_bytes)
> +{
> +    /* 'extra' is just an estimate of the space required. */
> +    size_t extra = (pin->base.packet_len
> +                    + NXM_TYPICAL_LEN   /* flow_metadata */
> +                    + pin->stack_size * 4
> +                    + pin->actions_len
> +                    + pin->action_set_len
> +                    + 256);     /* fudge factor */
> +    struct ofpbuf *msg = ofpraw_alloc_xid(OFPRAW_NXT_PACKET_IN2, version,
> +                                          htonl(0), extra);
> +
> +    ofputil_put_packet_in_private(pin, version, include_bytes, msg);
> +    if (pin->base.userdata_len) {
> +        ofpprop_put(msg, NXPINT_USERDATA, pin->base.userdata,
> +                    pin->base.userdata_len);
> +    }
> +
> +    ofpmsg_update_length(msg);
> +    return msg;
> +}
> +
> +static struct ofpbuf *
> +ofputil_encode_ofp11_packet_in(const struct ofputil_packet_in *pin)
> +{
> +    struct ofp11_packet_in *opi;
> +    struct ofpbuf *msg;
> +
> +    msg = ofpraw_alloc_xid(OFPRAW_OFPT11_PACKET_IN, OFP11_VERSION,
> +                           htonl(0), pin->packet_len);
> +    opi = ofpbuf_put_zeros(msg, sizeof *opi);
> +    opi->buffer_id = htonl(UINT32_MAX);
> +    opi->in_port = ofputil_port_to_ofp11(
> +        pin->flow_metadata.flow.in_port.ofp_port);
> +    opi->in_phy_port = opi->in_port;
> +    opi->total_len = htons(pin->packet_len);
> +    opi->reason = encode_packet_in_reason(pin->reason, OFP11_VERSION);
> +    opi->table_id = pin->table_id;
> +
> +    return msg;
> +}
> +
> +static struct ofpbuf *
> +ofputil_encode_ofp12_packet_in(const struct ofputil_packet_in *pin,
> +                               enum ofp_version version)
> +{
> +    enum ofpraw raw = (version >= OFP13_VERSION
> +                       ? OFPRAW_OFPT13_PACKET_IN
> +                       : OFPRAW_OFPT12_PACKET_IN);
> +    struct ofpbuf *msg;
> +
> +    /* The final argument is just an estimate of the space required. */
> +    msg = ofpraw_alloc_xid(raw, version,
> +                           htonl(0), NXM_TYPICAL_LEN + 2 +
> pin->packet_len);
> +
> +    struct ofp12_packet_in *opi = ofpbuf_put_zeros(msg, sizeof *opi);
> +    opi->buffer_id = htonl(UINT32_MAX);
> +    opi->total_len = htons(pin->packet_len);
> +    opi->reason = encode_packet_in_reason(pin->reason, version);
> +    opi->table_id = pin->table_id;
> +
> +    if (version >= OFP13_VERSION) {
> +        ovs_be64 cookie = pin->cookie;
> +        ofpbuf_put(msg, &cookie, sizeof cookie);
> +    }
> +
> +    oxm_put_match(msg, &pin->flow_metadata, version);
> +    ofpbuf_put_zeros(msg, 2);
> +
> +    return msg;
> +}
> +
> +/* Converts abstract ofputil_packet_in_private 'pin' into a PACKET_IN
> message
> + * for 'protocol', using the packet-in format specified by
> 'packet_in_format'.
> + *
> + * This function is really meant only for use by ovs-vswitchd.  To any
> other
> + * code, the "continuation" data, i.e. the data that is in struct
> + * ofputil_packet_in_private but not in struct ofputil_packet_in, is
> supposed
> + * to be opaque (and it might change from one OVS version to another).
> Thus,
> + * if any other code wants to encode a packet-in, it should use a
> non-"private"
> + * version of this function.  (Such a version doesn't currently exist
> because
> + * only ovs-vswitchd currently wants to encode packet-ins.  If you need
> one,
> + * write it...) */
> +struct ofpbuf *
> +ofputil_encode_packet_in_private(const struct ofputil_packet_in_private
> *pin,
> +                                 enum ofputil_protocol protocol,
> +                                 enum nx_packet_in_format
> packet_in_format)
> +{
> +    enum ofp_version version = ofputil_protocol_to_ofp_version(protocol);
> +
> +    struct ofpbuf *msg;
> +    switch (packet_in_format) {
> +    case NXPIF_STANDARD:
> +        switch (protocol) {
> +        case OFPUTIL_P_OF10_STD:
> +        case OFPUTIL_P_OF10_STD_TID:
> +        case OFPUTIL_P_OF10_NXM:
> +        case OFPUTIL_P_OF10_NXM_TID:
> +            msg = ofputil_encode_ofp10_packet_in(&pin->base);
> +            break;
> +
> +        case OFPUTIL_P_OF11_STD:
> +            msg = ofputil_encode_ofp11_packet_in(&pin->base);
> +            break;
> +
> +        case OFPUTIL_P_OF12_OXM:
> +        case OFPUTIL_P_OF13_OXM:
> +        case OFPUTIL_P_OF14_OXM:
> +        case OFPUTIL_P_OF15_OXM:
> +        case OFPUTIL_P_OF16_OXM:
> +            msg = ofputil_encode_ofp12_packet_in(&pin->base, version);
> +            break;
> +
> +        default:
> +            OVS_NOT_REACHED();
> +        }
> +        break;
> +
> +    case NXPIF_NXT_PACKET_IN:
> +        msg = ofputil_encode_nx_packet_in(&pin->base, version);
> +        break;
> +
> +    case NXPIF_NXT_PACKET_IN2:
> +        return ofputil_encode_nx_packet_in2(pin, version,
> +                                            pin->base.packet_len);
> +
> +    default:
> +        OVS_NOT_REACHED();
> +    }
> +
> +    ofpbuf_put(msg, pin->base.packet, pin->base.packet_len);
> +    ofpmsg_update_length(msg);
> +    return msg;
> +}
> +
> +/* Returns a string form of 'reason'.  The return value is either a
> statically
> + * allocated constant string or the 'bufsize'-byte buffer 'reasonbuf'.
> + * 'bufsize' should be at least OFPUTIL_PACKET_IN_REASON_BUFSIZE. */
> +const char *
> +ofputil_packet_in_reason_to_string(enum ofp_packet_in_reason reason,
> +                                   char *reasonbuf, size_t bufsize)
> +{
> +    switch (reason) {
> +    case OFPR_NO_MATCH:
> +        return "no_match";
> +    case OFPR_ACTION:
> +        return "action";
> +    case OFPR_INVALID_TTL:
> +        return "invalid_ttl";
> +    case OFPR_ACTION_SET:
> +        return "action_set";
> +    case OFPR_GROUP:
> +        return "group";
> +    case OFPR_PACKET_OUT:
> +        return "packet_out";
> +    case OFPR_EXPLICIT_MISS:
> +    case OFPR_IMPLICIT_MISS:
> +        return "";
> +
> +    case OFPR_N_REASONS:
> +    default:
> +        snprintf(reasonbuf, bufsize, "%d", (int) reason);
> +        return reasonbuf;
> +    }
> +}
> +
> +bool
> +ofputil_packet_in_reason_from_string(const char *s,
> +                                     enum ofp_packet_in_reason *reason)
> +{
> +    int i;
> +
> +    for (i = 0; i < OFPR_N_REASONS; i++) {
> +        char reasonbuf[OFPUTIL_PACKET_IN_REASON_BUFSIZE];
> +        const char *reason_s;
> +
> +        reason_s = ofputil_packet_in_reason_to_string(i, reasonbuf,
> +                                                      sizeof reasonbuf);
> +        if (!strcasecmp(s, reason_s)) {
> +            *reason = i;
> +            return true;
> +        }
> +    }
> +    return false;
> +}
> +
> +/* Returns a newly allocated NXT_RESUME message for 'pin', with the given
> + * 'continuation', for 'protocol'.  This message is suitable for resuming
> the
> + * pipeline traveral of the packet represented by 'pin', if sent to the
> switch
> + * from which 'pin' was received. */
> +struct ofpbuf *
> +ofputil_encode_resume(const struct ofputil_packet_in *pin,
> +                      const struct ofpbuf *continuation,
> +                      enum ofputil_protocol protocol)
> +{
> +    enum ofp_version version = ofputil_protocol_to_ofp_version(protocol);
> +    size_t extra = pin->packet_len + NXM_TYPICAL_LEN + continuation->size;
> +    struct ofpbuf *msg = ofpraw_alloc_xid(OFPRAW_NXT_RESUME, version,
> +                                          0, extra);
> +    ofputil_put_packet_in(pin, version, pin->packet_len, msg);
> +    ofpprop_put_nested(msg, NXPINT_CONTINUATION, continuation);
> +    ofpmsg_update_length(msg);
> +    return msg;
> +}
> +
> +static enum ofperr
> +parse_stack_prop(const struct ofpbuf *property, struct ofpbuf *stack)
> +{
> +    unsigned int len = ofpbuf_msgsize(property);
> +    if (len > sizeof(union mf_subvalue)) {
> +        VLOG_WARN_RL(&rl, "NXCPT_STACK property has bad length %u",
> +                     len);
> +        return OFPERR_OFPBPC_BAD_LEN;
> +    }
> +    nx_stack_push_bottom(stack, property->msg, len);
> +    return 0;
> +}
> +
> +static enum ofperr
> +parse_actions_property(struct ofpbuf *property, enum ofp_version version,
> +                       struct ofpbuf *ofpacts)
> +{
> +    if (!ofpbuf_try_pull(property, ROUND_UP(ofpbuf_headersize(property),
> 8))) {
> +        VLOG_WARN_RL(&rl, "actions property has bad length %"PRIu32,
> +                     property->size);
> +        return OFPERR_OFPBPC_BAD_LEN;
> +    }
> +
> +    return ofpacts_pull_openflow_actions(property, property->size,
> +                                         version, NULL, NULL, ofpacts);
> +}
> +
> +/* This is like ofputil_decode_packet_in(), except that it decodes the
> + * continuation data into 'pin'.  The format of this data is supposed to
> be
> + * opaque to any process other than ovs-vswitchd, so this function should
> not
> + * be used outside ovs-vswitchd.
> + *
> + * 'vl_mff_map' is an optional parameter that is used to validate the
> length
> + * of variable length mf_fields in 'match'. If it is not provided, the
> + * default mf_fields with maximum length will be used.
> + *
> + * When successful, 'pin' contains some dynamically allocated data.  Call
> + * ofputil_packet_in_private_destroy() to free this data. */
> +enum ofperr
> +ofputil_decode_packet_in_private(const struct ofp_header *oh, bool loose,
> +                                 const struct tun_table *tun_table,
> +                                 const struct vl_mff_map *vl_mff_map,
> +                                 struct ofputil_packet_in_private *pin,
> +                                 size_t *total_len, uint32_t *buffer_id)
> +{
> +    memset(pin, 0, sizeof *pin);
> +
> +    struct ofpbuf continuation;
> +    enum ofperr error;
> +    error = ofputil_decode_packet_in(oh, loose, tun_table, vl_mff_map,
> +                                     &pin->base, total_len, buffer_id,
> +                                     &continuation);
> +    if (error) {
> +        return error;
> +    }
> +
> +    struct ofpbuf actions, action_set;
> +    ofpbuf_init(&actions, 0);
> +    ofpbuf_init(&action_set, 0);
> +
> +    uint8_t table_id = 0;
> +    ovs_be64 cookie = 0;
> +
> +    struct ofpbuf stack;
> +    ofpbuf_init(&stack, 0);
> +
> +    while (continuation.size > 0) {
> +        struct ofpbuf payload;
> +        uint64_t type;
> +
> +        error = ofpprop_pull(&continuation, &payload, &type);
> +        if (error) {
> +            break;
> +        }
> +
> +        switch (type) {
> +        case NXCPT_BRIDGE:
> +            error = ofpprop_parse_uuid(&payload, &pin->bridge);
> +            break;
> +
> +        case NXCPT_STACK:
> +            error = parse_stack_prop(&payload, &stack);
> +            break;
> +
> +        case NXCPT_MIRRORS:
> +            error = ofpprop_parse_u32(&payload, &pin->mirrors);
> +            break;
> +
> +        case NXCPT_CONNTRACKED:
> +            pin->conntracked = true;
> +            break;
> +
> +        case NXCPT_TABLE_ID:
> +            error = ofpprop_parse_u8(&payload, &table_id);
> +            break;
> +
> +        case NXCPT_COOKIE:
> +            error = ofpprop_parse_be64(&payload, &cookie);
> +            break;
> +
> +        case NXCPT_ACTIONS: {
> +            struct ofpact_unroll_xlate *unroll
> +                = ofpact_put_UNROLL_XLATE(&actions);
> +            unroll->rule_table_id = table_id;
> +            unroll->rule_cookie = cookie;
> +            error = parse_actions_property(&payload, oh->version,
> &actions);
> +            break;
> +        }
> +
> +        case NXCPT_ACTION_SET:
> +            error = parse_actions_property(&payload, oh->version,
> &action_set);
> +            break;
> +
> +        default:
> +            error = OFPPROP_UNKNOWN(loose, "continuation", type);
> +            break;
> +        }
> +        if (error) {
> +            break;
> +        }
> +    }
> +
> +    pin->actions_len = actions.size;
> +    pin->actions = ofpbuf_steal_data(&actions);
> +    pin->action_set_len = action_set.size;
> +    pin->action_set = ofpbuf_steal_data(&action_set);
> +    pin->stack_size = stack.size;
> +    pin->stack = ofpbuf_steal_data(&stack);
> +
> +    if (error) {
> +        ofputil_packet_in_private_destroy(pin);
> +    }
> +
> +    return error;
> +}
> +
> +/* Frees data in 'pin' that is dynamically allocated by
> + * ofputil_decode_packet_in_private().
> + *
> + * 'pin->base' contains some pointer members that
> + * ofputil_decode_packet_in_private() doesn't initialize to newly
> allocated
> + * data, so this function doesn't free those. */
> +void
> +ofputil_packet_in_private_destroy(struct ofputil_packet_in_private *pin)
> +{
> +    if (pin) {
> +        free(pin->stack);
> +        free(pin->actions);
> +        free(pin->action_set);
> +    }
> +}
> +
> +/* Converts an OFPT_PACKET_OUT in 'opo' into an abstract
> ofputil_packet_out in
> + * 'po'.
> + *
> + * Uses 'ofpacts' to store the abstract OFPACT_* version of the packet out
> + * message's actions.  The caller must initialize 'ofpacts' and retains
> + * ownership of it.  'po->ofpacts' will point into the 'ofpacts' buffer.
> + *
> + * 'po->packet' refers to the packet data in 'oh', so the buffer
> containing
> + * 'oh' must not be destroyed while 'po' is being used.
> + *
> + * Returns 0 if successful, otherwise an OFPERR_* value. */
> +enum ofperr
> +ofputil_decode_packet_out(struct ofputil_packet_out *po,
> +                          const struct ofp_header *oh,
> +                          const struct tun_table *tun_table,
> +                          struct ofpbuf *ofpacts)
> +{
> +    struct ofpbuf b = ofpbuf_const_initializer(oh, ntohs(oh->length));
> +    enum ofpraw raw = ofpraw_pull_assert(&b);
> +
> +    ofpbuf_clear(ofpacts);
> +    match_init_catchall(&po->flow_metadata);
> +    if (raw == OFPRAW_OFPT15_PACKET_OUT) {
> +        enum ofperr error;
> +        const struct ofp15_packet_out *opo = ofpbuf_pull(&b, sizeof *opo);
> +
> +        po->buffer_id = ntohl(opo->buffer_id);
> +        error = oxm_pull_match_loose(&b, true, tun_table,
> &po->flow_metadata);
> +        if (error) {
> +            return error;
> +        }
> +
> +        if (!po->flow_metadata.wc.masks.in_port.ofp_port) {
> +            return OFPERR_OFPBRC_BAD_PORT;
> +        }
> +
> +        error = ofpacts_pull_openflow_actions(&b,
> ntohs(opo->actions_len),
> +                                              oh->version, NULL, NULL,
> +                                              ofpacts);
> +        if (error) {
> +            return error;
> +        }
> +    } else if (raw == OFPRAW_OFPT11_PACKET_OUT) {
> +        enum ofperr error;
> +        ofp_port_t in_port;
> +        const struct ofp11_packet_out *opo = ofpbuf_pull(&b, sizeof *opo);
> +
> +        po->buffer_id = ntohl(opo->buffer_id);
> +        error = ofputil_port_from_ofp11(opo->in_port, &in_port);
> +        if (error) {
> +            return error;
> +        }
> +        match_set_packet_type(&po->flow_metadata, htonl(PT_ETH));
> +        match_set_in_port(&po->flow_metadata, in_port);
> +
> +        error = ofpacts_pull_openflow_actions(&b,
> ntohs(opo->actions_len),
> +                                              oh->version, NULL, NULL,
> +                                              ofpacts);
> +        if (error) {
> +            return error;
> +        }
> +    } else if (raw == OFPRAW_OFPT10_PACKET_OUT) {
> +        enum ofperr error;
> +        const struct ofp10_packet_out *opo = ofpbuf_pull(&b, sizeof *opo);
> +
> +        po->buffer_id = ntohl(opo->buffer_id);
> +        match_set_packet_type(&po->flow_metadata, htonl(PT_ETH));
> +        match_set_in_port(&po->flow_metadata,
> u16_to_ofp(ntohs(opo->in_port)));
> +
> +        error = ofpacts_pull_openflow_actions(&b,
> ntohs(opo->actions_len),
> +                                              oh->version, NULL, NULL,
> +                                              ofpacts);
> +        if (error) {
> +            return error;
> +        }
> +    } else {
> +        OVS_NOT_REACHED();
> +    }
> +
> +    ofp_port_t in_port = po->flow_metadata.flow.in_port.ofp_port;
> +    if (ofp_to_u16(in_port) >= ofp_to_u16(OFPP_MAX)
> +        && in_port != OFPP_LOCAL
> +        && in_port != OFPP_NONE
> +        && in_port != OFPP_CONTROLLER) {
> +        VLOG_WARN_RL(&rl, "packet-out has bad input port %#"PRIx32,
> +                     po->flow_metadata.flow.in_port.ofp_port);
> +        return OFPERR_OFPBRC_BAD_PORT;
> +    }
> +
> +    po->ofpacts = ofpacts->data;
> +    po->ofpacts_len = ofpacts->size;
> +
> +    if (po->buffer_id == UINT32_MAX) {
> +        po->packet = b.data;
> +        po->packet_len = b.size;
> +    } else {
> +        po->packet = NULL;
> +        po->packet_len = 0;
> +    }
> +
> +    return 0;
> +}
> +
> +struct ofpbuf *
> +ofputil_encode_packet_out(const struct ofputil_packet_out *po,
> +                          enum ofputil_protocol protocol)
> +{
> +    enum ofp_version ofp_version = ofputil_protocol_to_ofp_
> version(protocol);
> +    struct ofpbuf *msg;
> +    size_t size;
> +
> +    size = po->ofpacts_len;
> +    if (po->buffer_id == UINT32_MAX) {
> +        size += po->packet_len;
> +    }
> +
> +    switch (ofp_version) {
> +    case OFP10_VERSION: {
> +        struct ofp10_packet_out *opo;
> +        size_t actions_ofs;
> +
> +        msg = ofpraw_alloc(OFPRAW_OFPT10_PACKET_OUT, OFP10_VERSION,
> size);
> +        ofpbuf_put_zeros(msg, sizeof *opo);
> +        actions_ofs = msg->size;
> +        ofpacts_put_openflow_actions(po->ofpacts, po->ofpacts_len, msg,
> +                                     ofp_version);
> +
> +        opo = msg->msg;
> +        opo->buffer_id = htonl(po->buffer_id);
> +        opo->in_port =htons(ofp_to_u16(
> +                                po->flow_metadata.flow.in_
> port.ofp_port));
> +        opo->actions_len = htons(msg->size - actions_ofs);
> +        break;
> +    }
> +
> +    case OFP11_VERSION:
> +    case OFP12_VERSION:
> +    case OFP13_VERSION:
> +    case OFP14_VERSION: {
> +        struct ofp11_packet_out *opo;
> +        size_t len;
> +
> +        msg = ofpraw_alloc(OFPRAW_OFPT11_PACKET_OUT, ofp_version, size);
> +        ofpbuf_put_zeros(msg, sizeof *opo);
> +        len = ofpacts_put_openflow_actions(po->ofpacts, po->ofpacts_len,
> msg,
> +                                           ofp_version);
> +        opo = msg->msg;
> +        opo->buffer_id = htonl(po->buffer_id);
> +        opo->in_port =
> +            ofputil_port_to_ofp11(po->flow_metadata.flow.in_port.
> ofp_port);
> +        opo->actions_len = htons(len);
> +        break;
> +    }
> +
> +    case OFP15_VERSION:
> +    case OFP16_VERSION: {
> +        struct ofp15_packet_out *opo;
> +        size_t len;
> +
> +        /* The final argument is just an estimate of the space required.
> */
> +        msg = ofpraw_alloc(OFPRAW_OFPT15_PACKET_OUT, ofp_version,
> +                           size + NXM_TYPICAL_LEN);
> +        ofpbuf_put_zeros(msg, sizeof *opo);
> +        oxm_put_match(msg, &po->flow_metadata, ofp_version);
> +        len = ofpacts_put_openflow_actions(po->ofpacts, po->ofpacts_len,
> msg,
> +                                           ofp_version);
> +        opo = msg->msg;
> +        opo->buffer_id = htonl(po->buffer_id);
> +        opo->actions_len = htons(len);
> +        break;
> +    }
> +
> +    default:
> +        OVS_NOT_REACHED();
> +    }
> +
> +    if (po->buffer_id == UINT32_MAX) {
> +        ofpbuf_put(msg, po->packet, po->packet_len);
> +    }
> +
> +    ofpmsg_update_length(msg);
> +
> +    return msg;
> +}
> +
> +/* Parse a string representation of a OFPT_PACKET_OUT to '*po'.  If
> successful,
> + * both 'po->ofpacts' and 'po->packet' must be free()d by the caller. */
> +static char * OVS_WARN_UNUSED_RESULT
> +parse_ofp_packet_out_str__(struct ofputil_packet_out *po, char *string,
> +                           const struct ofputil_port_map *port_map,
> +                           const struct ofputil_table_map *table_map,
> +                           enum ofputil_protocol *usable_protocols)
> +{
> +    enum ofputil_protocol action_usable_protocols;
> +    uint64_t stub[256 / 8];
> +    struct ofpbuf ofpacts = OFPBUF_STUB_INITIALIZER(stub);
> +    struct dp_packet *packet = NULL;
> +    char *act_str = NULL;
> +    char *name, *value;
> +    char *error = NULL;
> +
> +    *usable_protocols = OFPUTIL_P_ANY;
> +
> +    *po = (struct ofputil_packet_out) {
> +        .buffer_id = UINT32_MAX,
> +    };
> +    match_init_catchall(&po->flow_metadata);
> +    match_set_in_port(&po->flow_metadata, OFPP_CONTROLLER);
> +
> +    act_str = ofp_extract_actions(string);
> +
> +    while (ofputil_parse_key_value(&string, &name, &value)) {
> +        if (!*value) {
> +            error = xasprintf("field %s missing value", name);
> +            goto out;
> +        }
> +
> +        if (!strcmp(name, "in_port")) {
> +            ofp_port_t in_port;
> +            if (!ofputil_port_from_string(value, port_map, &in_port)) {
> +                error = xasprintf("%s is not a valid OpenFlow port",
> value);
> +                goto out;
> +            }
> +            if (ofp_to_u16(in_port) > ofp_to_u16(OFPP_MAX)
> +                && in_port != OFPP_LOCAL
> +                && in_port != OFPP_NONE
> +                && in_port != OFPP_CONTROLLER) {
> +                error = xasprintf(
> +                              "%s is not a valid OpenFlow port for
> PACKET_OUT",
> +                              value);
> +                goto out;
> +            }
> +            match_set_in_port(&po->flow_metadata, in_port);
> +        } else if (!strcmp(name, "packet_type")) {
> +            char *ns = value;
> +            char *ns_type = strstr(value, ",");
> +            if (ns_type) {
> +                ovs_be32 packet_type;
> +                *ns_type = '\0';
> +                packet_type = PACKET_TYPE_BE(strtoul(ns, NULL, 0),
> +                                             strtoul(++ns_type, NULL, 0));
> +                match_set_packet_type(&po->flow_metadata, packet_type);
> +            } else {
> +                error = xasprintf("%s(%s) can't be interpreted", name,
> value);
> +                goto out;
> +            }
> +        } else if (!strcmp(name, "packet")) {
> +            const char *error_msg = eth_from_hex(value, &packet);
> +            if (error_msg) {
> +                error = xasprintf("%s: %s", name, error_msg);
> +                goto out;
> +            }
> +        } else {
> +            const struct mf_field *mf = mf_from_name(name);
> +            if (!mf) {
> +                error = xasprintf("unknown keyword %s", name);
> +                goto out;
> +            }
> +
> +            error = ofp_parse_field(mf, value, port_map,
> &po->flow_metadata,
> +                                    usable_protocols);
> +            if (error) {
> +                goto out;
> +            }
> +            if (!mf_is_pipeline_field(mf)) {
> +                error = xasprintf("%s is not a valid pipeline field "
> +                                  "for PACKET_OUT", name);
> +                goto out;
> +            }
> +        }
> +    }
> +
> +    if (!packet || !dp_packet_size(packet)) {
> +        error = xstrdup("must specify packet");
> +        goto out;
> +    }
> +
> +    if (act_str) {
> +        struct ofpact_parse_params pp = {
> +            .port_map = port_map,
> +            .table_map = table_map,
> +            .ofpacts = &ofpacts,
> +            .usable_protocols = &action_usable_protocols,
> +        };
> +        error = ofpacts_parse_actions(act_str, &pp);
> +        *usable_protocols &= action_usable_protocols;
> +        if (error) {
> +            goto out;
> +        }
> +    }
> +    po->ofpacts_len = ofpacts.size;
> +    po->ofpacts = ofpbuf_steal_data(&ofpacts);
> +
> +    po->packet_len = dp_packet_size(packet);
> +    po->packet = dp_packet_steal_data(packet);
> +out:
> +    ofpbuf_uninit(&ofpacts);
> +    dp_packet_delete(packet);
> +    return error;
> +}
> +
> +/* Convert 'str_' (as described in the Packet-Out Syntax section of the
> + * ovs-ofctl man page) into 'po' for sending a OFPT_PACKET_OUT message to
> a
> + * switch.  Returns the set of usable protocols in '*usable_protocols'.
> + *
> + * Returns NULL if successful, otherwise a malloc()'d string describing
> the
> + * error.  The caller is responsible for freeing the returned string.
> + * If successful, both 'po->ofpacts' and 'po->packet' must be free()d by
> + * the caller. */
> +char * OVS_WARN_UNUSED_RESULT
> +parse_ofp_packet_out_str(struct ofputil_packet_out *po, const char *str_,
> +                         const struct ofputil_port_map *port_map,
> +                         const struct ofputil_table_map *table_map,
> +                         enum ofputil_protocol *usable_protocols)
> +{
> +    char *string = xstrdup(str_);
> +    char *error;
> +
> +    error = parse_ofp_packet_out_str__(po, string, port_map, table_map,
> +                                       usable_protocols);
> +    if (error) {
> +        po->ofpacts = NULL;
> +        po->ofpacts_len = 0;
> +    }
> +
> +    free(string);
> +    return error;
> +}
> diff --git a/lib/ofp-parse.c b/lib/ofp-parse.c
> index 1e30c20f4966..3e8b553f9e1b 100644
> --- a/lib/ofp-parse.c
> +++ b/lib/ofp-parse.c
> @@ -15,30 +15,15 @@
>   */
>
>  #include <config.h>
> -
> -#include <ctype.h>
> +#include "openvswitch/ofp-parse.h"
>  #include <errno.h>
> -#include <stdlib.h>
> -#include <sys/types.h>
> -#include <netinet/in.h>
> -
>  #include "byte-order.h"
> -#include "dp-packet.h"
> -#include "learn.h"
> -#include "multipath.h"
> -#include "netdev.h"
> -#include "nx-match.h"
> -#include "openflow/openflow.h"
> -#include "openvswitch/dynamic-string.h"
> +#include "openvswitch/match.h"
>  #include "openvswitch/meta-flow.h"
> -#include "openvswitch/ofp-actions.h"
> -#include "openvswitch/ofp-parse.h"
> -#include "openvswitch/ofp-util.h"
> -#include "openvswitch/ofpbuf.h"
> -#include "openvswitch/vconn.h"
> -#include "ovs-thread.h"
> +#include "openvswitch/ofp-flow.h"
> +#include "openvswitch/ofp-match.h"
> +#include "openvswitch/ofp-table.h"
>  #include "packets.h"
> -#include "simap.h"
>  #include "socket-util.h"
>  #include "util.h"
>
> @@ -189,16 +174,10 @@ str_to_connhelper(const char *str, uint16_t *alg)
>      return xasprintf("invalid conntrack helper \"%s\"", str);
>  }
>
> -struct protocol {
> -    const char *name;
> -    uint16_t dl_type;
> -    uint8_t nw_proto;
> -};
> -
> -static bool
> -parse_protocol(const char *name, const struct protocol **p_out)
> +bool
> +ofp_parse_protocol(const char *name, const struct ofp_protocol **p_out)
>  {
> -    static const struct protocol protocols[] = {
> +    static const struct ofp_protocol protocols[] = {
>          { "ip", ETH_TYPE_IP, 0 },
>          { "ipv4", ETH_TYPE_IP, 0 },
>          { "ip4", ETH_TYPE_IP, 0 },
> @@ -217,7 +196,7 @@ parse_protocol(const char *name, const struct protocol
> **p_out)
>          { "mpls", ETH_TYPE_MPLS, 0 },
>          { "mplsm", ETH_TYPE_MPLS_MCAST, 0 },
>      };
> -    const struct protocol *p;
> +    const struct ofp_protocol *p;
>
>      for (p = protocols; p < &protocols[ARRAY_SIZE(protocols)]; p++) {
>          if (!strcmp(p->name, name)) {
> @@ -235,10 +214,10 @@ parse_protocol(const char *name, const struct
> protocol **p_out)
>   *
>   * Returns NULL if successful, otherwise a malloc()'d string describing
> the
>   * error.  The caller is responsible for freeing the returned string. */
> -static char * OVS_WARN_UNUSED_RESULT
> -parse_field(const struct mf_field *mf, const char *s,
> -            const struct ofputil_port_map *port_map, struct match *match,
> -            enum ofputil_protocol *usable_protocols)
> +char * OVS_WARN_UNUSED_RESULT
> +ofp_parse_field(const struct mf_field *mf, const char *s,
> +                const struct ofputil_port_map *port_map, struct match
> *match,
> +                enum ofputil_protocol *usable_protocols)
>  {
>      union mf_value value, mask;
>      char *error;
> @@ -257,56 +236,8 @@ parse_field(const struct mf_field *mf, const char *s,
>      return error;
>  }
>
> -/* Parses 'str_value' as the value of subfield 'name', and updates
> - * 'match' appropriately.  Restricts the set of usable protocols to ones
> - * supporting the parsed field.
> - *
> - * Returns NULL if successful, otherwise a malloc()'d string describing
> the
> - * error.  The caller is responsible for freeing the returned string. */
> -static char * OVS_WARN_UNUSED_RESULT
> -parse_subfield(const char *name, const char *str_value, struct match
> *match,
> -               enum ofputil_protocol *usable_protocols)
> -{
> -    struct mf_subfield sf;
> -    char *error;
> -
> -    error = mf_parse_subfield(&sf, name);
> -    if (!error) {
> -        union mf_value val;
> -        char *tail;
> -        if (parse_int_string(str_value, (uint8_t *)&val,
> sf.field->n_bytes,
> -                             &tail) || *tail != 0) {
> -            return xasprintf("%s: cannot parse integer value: %s", name,
> -                             str_value);
> -        }
> -        if (!bitwise_is_all_zeros(&val, sf.field->n_bytes, sf.n_bits,
> -                                  sf.field->n_bytes * 8 - sf.n_bits)) {
> -            struct ds ds;
> -
> -            ds_init(&ds);
> -            mf_format(sf.field, &val, NULL, NULL, &ds);
> -            error = xasprintf("%s: value %s does not fit into %d bits",
> -                              name, ds_cstr(&ds), sf.n_bits);
> -            ds_destroy(&ds);
> -            return error;
> -        }
> -
> -        const struct mf_field *field = sf.field;
> -        union mf_value value, mask;
> -        unsigned int size = field->n_bytes;
> -
> -        mf_get(field, match, &value, &mask);
> -        bitwise_copy(&val, size, 0, &value, size, sf.ofs, sf.n_bits);
> -        bitwise_one (               &mask,  size, sf.ofs, sf.n_bits);
> -        *usable_protocols &= mf_set(field, &value, &mask, match, &error);
> -
> -        match_add_ethernet_prereq(match, sf.field);
> -    }
> -    return error;
> -}
> -
> -static char *
> -extract_actions(char *s)
> +char *
> +ofp_extract_actions(char *s)
>  {
>      s = strstr(s, "action");
>      if (s) {
> @@ -318,777 +249,6 @@ extract_actions(char *s)
>      }
>  }
>
> -
> -static char * OVS_WARN_UNUSED_RESULT
> -parse_ofp_str__(struct ofputil_flow_mod *fm, int command, char *string,
> -                const struct ofputil_port_map *port_map,
> -                const struct ofputil_table_map *table_map,
> -                enum ofputil_protocol *usable_protocols)
> -{
> -    enum {
> -        F_OUT_PORT = 1 << 0,
> -        F_ACTIONS = 1 << 1,
> -        F_IMPORTANCE = 1 << 2,
> -        F_TIMEOUT = 1 << 3,
> -        F_PRIORITY = 1 << 4,
> -        F_FLAGS = 1 << 5,
> -    } fields;
> -    char *act_str = NULL;
> -    char *name, *value;
> -
> -    *usable_protocols = OFPUTIL_P_ANY;
> -
> -    if (command == -2) {
> -        size_t len;
> -
> -        string += strspn(string, " \t\r\n");   /* Skip white space. */
> -        len = strcspn(string, ", \t\r\n"); /* Get length of the first
> token. */
> -
> -        if (!strncmp(string, "add", len)) {
> -            command = OFPFC_ADD;
> -        } else if (!strncmp(string, "delete", len)) {
> -            command = OFPFC_DELETE;
> -        } else if (!strncmp(string, "delete_strict", len)) {
> -            command = OFPFC_DELETE_STRICT;
> -        } else if (!strncmp(string, "modify", len)) {
> -            command = OFPFC_MODIFY;
> -        } else if (!strncmp(string, "modify_strict", len)) {
> -            command = OFPFC_MODIFY_STRICT;
> -        } else {
> -            len = 0;
> -            command = OFPFC_ADD;
> -        }
> -        string += len;
> -    }
> -
> -    switch (command) {
> -    case -1:
> -        fields = F_OUT_PORT;
> -        break;
> -
> -    case OFPFC_ADD:
> -        fields = F_ACTIONS | F_TIMEOUT | F_PRIORITY | F_FLAGS |
> F_IMPORTANCE;
> -        break;
> -
> -    case OFPFC_DELETE:
> -        fields = F_OUT_PORT;
> -        break;
> -
> -    case OFPFC_DELETE_STRICT:
> -        fields = F_OUT_PORT | F_PRIORITY;
> -        break;
> -
> -    case OFPFC_MODIFY:
> -        fields = F_ACTIONS | F_TIMEOUT | F_PRIORITY | F_FLAGS;
> -        break;
> -
> -    case OFPFC_MODIFY_STRICT:
> -        fields = F_ACTIONS | F_TIMEOUT | F_PRIORITY | F_FLAGS;
> -        break;
> -
> -    default:
> -        OVS_NOT_REACHED();
> -    }
> -
> -    *fm = (struct ofputil_flow_mod) {
> -        .match = MATCH_CATCHALL_INITIALIZER,
> -        .priority = OFP_DEFAULT_PRIORITY,
> -        .table_id = 0xff,
> -        .command = command,
> -        .buffer_id = UINT32_MAX,
> -        .out_port = OFPP_ANY,
> -        .out_group = OFPG_ANY,
> -    };
> -    /* For modify, by default, don't update the cookie. */
> -    if (command == OFPFC_MODIFY || command == OFPFC_MODIFY_STRICT) {
> -        fm->new_cookie = OVS_BE64_MAX;
> -    }
> -
> -    if (fields & F_ACTIONS) {
> -        act_str = extract_actions(string);
> -        if (!act_str) {
> -            return xstrdup("must specify an action");
> -        }
> -    }
> -
> -    while (ofputil_parse_key_value(&string, &name, &value)) {
> -        const struct protocol *p;
> -        const struct mf_field *mf;
> -        char *error = NULL;
> -
> -        if (parse_protocol(name, &p)) {
> -            match_set_dl_type(&fm->match, htons(p->dl_type));
> -            if (p->nw_proto) {
> -                match_set_nw_proto(&fm->match, p->nw_proto);
> -            }
> -            match_set_default_packet_type(&fm->match);
> -        } else if (!strcmp(name, "eth")) {
> -            match_set_packet_type(&fm->match, htonl(PT_ETH));
> -        } else if (fields & F_FLAGS && !strcmp(name, "send_flow_rem")) {
> -            fm->flags |= OFPUTIL_FF_SEND_FLOW_REM;
> -        } else if (fields & F_FLAGS && !strcmp(name, "check_overlap")) {
> -            fm->flags |= OFPUTIL_FF_CHECK_OVERLAP;
> -        } else if (fields & F_FLAGS && !strcmp(name, "reset_counts")) {
> -            fm->flags |= OFPUTIL_FF_RESET_COUNTS;
> -            *usable_protocols &= OFPUTIL_P_OF12_UP;
> -        } else if (fields & F_FLAGS && !strcmp(name, "no_packet_counts"))
> {
> -            fm->flags |= OFPUTIL_FF_NO_PKT_COUNTS;
> -            *usable_protocols &= OFPUTIL_P_OF13_UP;
> -        } else if (fields & F_FLAGS && !strcmp(name, "no_byte_counts")) {
> -            fm->flags |= OFPUTIL_FF_NO_BYT_COUNTS;
> -            *usable_protocols &= OFPUTIL_P_OF13_UP;
> -        } else if (!strcmp(name, "no_readonly_table")
> -                   || !strcmp(name, "allow_hidden_fields")) {
> -             /* ignore these fields. */
> -        } else if ((mf = mf_from_name(name)) != NULL) {
> -            error = parse_field(mf, value, port_map,
> -                                &fm->match, usable_protocols);
> -        } else if (strchr(name, '[')) {
> -            error = parse_subfield(name, value, &fm->match,
> usable_protocols);
> -        } else {
> -            if (!*value) {
> -                return xasprintf("field %s missing value", name);
> -            }
> -
> -            if (!strcmp(name, "table")) {
> -                if (!ofputil_table_from_string(value, table_map,
> -                                               &fm->table_id)) {
> -                    return xasprintf("unknown table \"%s\"", value);
> -                }
> -                if (fm->table_id != 0xff) {
> -                    *usable_protocols &= OFPUTIL_P_TID;
> -                }
> -            } else if (fields & F_OUT_PORT && !strcmp(name, "out_port")) {
> -                if (!ofputil_port_from_string(value, port_map,
> -                                              &fm->out_port)) {
> -                    error = xasprintf("%s is not a valid OpenFlow port",
> -                                      value);
> -                }
> -            } else if (fields & F_OUT_PORT && !strcmp(name, "out_group"))
> {
> -                *usable_protocols &= OFPUTIL_P_OF11_UP;
> -                if (!ofputil_group_from_string(value, &fm->out_group)) {
> -                    error = xasprintf("%s is not a valid OpenFlow group",
> -                                      value);
> -                }
> -            } else if (fields & F_PRIORITY && !strcmp(name, "priority")) {
> -                uint16_t priority = 0;
> -
> -                error = str_to_u16(value, name, &priority);
> -                fm->priority = priority;
> -            } else if (fields & F_TIMEOUT && !strcmp(name,
> "idle_timeout")) {
> -                error = str_to_u16(value, name, &fm->idle_timeout);
> -            } else if (fields & F_TIMEOUT && !strcmp(name,
> "hard_timeout")) {
> -                error = str_to_u16(value, name, &fm->hard_timeout);
> -            } else if (fields & F_IMPORTANCE && !strcmp(name,
> "importance")) {
> -                error = str_to_u16(value, name, &fm->importance);
> -            } else if (!strcmp(name, "cookie")) {
> -                char *mask = strchr(value, '/');
> -
> -                if (mask) {
> -                    /* A mask means we're searching for a cookie. */
> -                    if (command == OFPFC_ADD) {
> -                        return xstrdup("flow additions cannot use "
> -                                       "a cookie mask");
> -                    }
> -                    *mask = '\0';
> -                    error = str_to_be64(value, &fm->cookie);
> -                    if (error) {
> -                        return error;
> -                    }
> -                    error = str_to_be64(mask + 1, &fm->cookie_mask);
> -
> -                    /* Matching of the cookie is only supported through
> NXM or
> -                     * OF1.1+. */
> -                    if (fm->cookie_mask != htonll(0)) {
> -                        *usable_protocols &= OFPUTIL_P_NXM_OF11_UP;
> -                    }
> -                } else {
> -                    /* No mask means that the cookie is being set. */
> -                    if (command != OFPFC_ADD && command != OFPFC_MODIFY
> -                        && command != OFPFC_MODIFY_STRICT) {
> -                        return xstrdup("cannot set cookie");
> -                    }
> -                    error = str_to_be64(value, &fm->new_cookie);
> -                    fm->modify_cookie = true;
> -                }
> -            } else if (!strcmp(name, "duration")
> -                       || !strcmp(name, "n_packets")
> -                       || !strcmp(name, "n_bytes")
> -                       || !strcmp(name, "idle_age")
> -                       || !strcmp(name, "hard_age")) {
> -                /* Ignore these, so that users can feed the output of
> -                 * "ovs-ofctl dump-flows" back into commands that parse
> -                 * flows. */
> -            } else {
> -                error = xasprintf("unknown keyword %s", name);
> -            }
> -        }
> -
> -        if (error) {
> -            return error;
> -        }
> -    }
> -    /* Copy ethertype to flow->dl_type for matches on packet_type
> -     * (OFPHTN_ETHERTYPE, ethertype). */
> -    if (fm->match.wc.masks.packet_type == OVS_BE32_MAX &&
> -            pt_ns(fm->match.flow.packet_type) == OFPHTN_ETHERTYPE) {
> -        fm->match.flow.dl_type = pt_ns_type_be(fm->match.flow.
> packet_type);
> -    }
> -    /* Check for usable protocol interdependencies between match fields.
> */
> -    if (fm->match.flow.dl_type == htons(ETH_TYPE_IPV6)) {
> -        const struct flow_wildcards *wc = &fm->match.wc;
> -        /* Only NXM and OXM support matching L3 and L4 fields within IPv6.
> -         *
> -         * (IPv6 specific fields as well as arp_sha, arp_tha, nw_frag, and
> -         *  nw_ttl are covered elsewhere so they don't need to be
> included in
> -         *  this test too.)
> -         */
> -        if (wc->masks.nw_proto || wc->masks.nw_tos
> -            || wc->masks.tp_src || wc->masks.tp_dst) {
> -            *usable_protocols &= OFPUTIL_P_NXM_OXM_ANY;
> -        }
> -    }
> -    if (!fm->cookie_mask && fm->new_cookie == OVS_BE64_MAX
> -        && (command == OFPFC_MODIFY || command == OFPFC_MODIFY_STRICT)) {
> -        /* On modifies without a mask, we are supposed to add a flow if
> -         * one does not exist.  If a cookie wasn't been specified, use a
> -         * default of zero. */
> -        fm->new_cookie = htonll(0);
> -    }
> -    if (fields & F_ACTIONS) {
> -        enum ofputil_protocol action_usable_protocols;
> -        struct ofpbuf ofpacts;
> -        char *error;
> -
> -        ofpbuf_init(&ofpacts, 32);
> -        struct ofpact_parse_params pp = {
> -            .port_map = port_map,
> -            .table_map = table_map,
> -            .ofpacts = &ofpacts,
> -            .usable_protocols = &action_usable_protocols
> -        };
> -        error = ofpacts_parse_instructions(act_str, &pp);
> -        *usable_protocols &= action_usable_protocols;
> -        if (!error) {
> -            enum ofperr err;
> -
> -            err = ofpacts_check(ofpacts.data, ofpacts.size, &fm->match,
> -                                OFPP_MAX, fm->table_id, 255,
> usable_protocols);
> -            if (!err && !*usable_protocols) {
> -                err = OFPERR_OFPBAC_MATCH_INCONSISTENT;
> -            }
> -            if (err) {
> -                error = xasprintf("actions are invalid with specified
> match "
> -                                  "(%s)", ofperr_to_string(err));
> -            }
> -
> -        }
> -        if (error) {
> -            ofpbuf_uninit(&ofpacts);
> -            return error;
> -        }
> -
> -        fm->ofpacts_len = ofpacts.size;
> -        fm->ofpacts = ofpbuf_steal_data(&ofpacts);
> -    } else {
> -        fm->ofpacts_len = 0;
> -        fm->ofpacts = NULL;
> -    }
> -
> -    return NULL;
> -}
> -
> -/* Convert 'str_' (as described in the Flow Syntax section of the
> ovs-ofctl man
> - * page) into 'fm' for sending the specified flow_mod 'command' to a
> switch.
> - * Returns the set of usable protocols in '*usable_protocols'.
> - *
> - * To parse syntax for an OFPT_FLOW_MOD (or NXT_FLOW_MOD), use an OFPFC_*
> - * constant for 'command'.  To parse syntax for an OFPST_FLOW or
> - * OFPST_AGGREGATE (or NXST_FLOW or NXST_AGGREGATE), use -1 for 'command'.
> - *
> - * If 'command' is given as -2, 'str_' may begin with a command name
> ("add",
> - * "modify", "delete", "modify_strict", or "delete_strict").  A missing
> command
> - * name is treated as "add".
> - *
> - * Returns NULL if successful, otherwise a malloc()'d string describing
> the
> - * error.  The caller is responsible for freeing the returned string. */
> -char * OVS_WARN_UNUSED_RESULT
> -parse_ofp_str(struct ofputil_flow_mod *fm, int command, const char *str_,
> -              const struct ofputil_port_map *port_map,
> -              const struct ofputil_table_map *table_map,
> -              enum ofputil_protocol *usable_protocols)
> -{
> -    char *string = xstrdup(str_);
> -    char *error;
> -
> -    error = parse_ofp_str__(fm, command, string, port_map, table_map,
> -                            usable_protocols);
> -    if (error) {
> -        fm->ofpacts = NULL;
> -        fm->ofpacts_len = 0;
> -    }
> -
> -    free(string);
> -    return error;
> -}
> -
> -/* Parse a string representation of a OFPT_PACKET_OUT to '*po'.  If
> successful,
> - * both 'po->ofpacts' and 'po->packet' must be free()d by the caller. */
> -static char * OVS_WARN_UNUSED_RESULT
> -parse_ofp_packet_out_str__(struct ofputil_packet_out *po, char *string,
> -                           const struct ofputil_port_map *port_map,
> -                           const struct ofputil_table_map *table_map,
> -                           enum ofputil_protocol *usable_protocols)
> -{
> -    enum ofputil_protocol action_usable_protocols;
> -    uint64_t stub[256 / 8];
> -    struct ofpbuf ofpacts = OFPBUF_STUB_INITIALIZER(stub);
> -    struct dp_packet *packet = NULL;
> -    char *act_str = NULL;
> -    char *name, *value;
> -    char *error = NULL;
> -
> -    *usable_protocols = OFPUTIL_P_ANY;
> -
> -    *po = (struct ofputil_packet_out) {
> -        .buffer_id = UINT32_MAX,
> -    };
> -    match_init_catchall(&po->flow_metadata);
> -    match_set_in_port(&po->flow_metadata, OFPP_CONTROLLER);
> -
> -    act_str = extract_actions(string);
> -
> -    while (ofputil_parse_key_value(&string, &name, &value)) {
> -        if (!*value) {
> -            error = xasprintf("field %s missing value", name);
> -            goto out;
> -        }
> -
> -        if (!strcmp(name, "in_port")) {
> -            ofp_port_t in_port;
> -            if (!ofputil_port_from_string(value, port_map, &in_port)) {
> -                error = xasprintf("%s is not a valid OpenFlow port",
> value);
> -                goto out;
> -            }
> -            if (ofp_to_u16(in_port) > ofp_to_u16(OFPP_MAX)
> -                && in_port != OFPP_LOCAL
> -                && in_port != OFPP_NONE
> -                && in_port != OFPP_CONTROLLER) {
> -                error = xasprintf(
> -                              "%s is not a valid OpenFlow port for
> PACKET_OUT",
> -                              value);
> -                goto out;
> -            }
> -            match_set_in_port(&po->flow_metadata, in_port);
> -        } else if (!strcmp(name, "packet_type")) {
> -            char *ns = value;
> -            char *ns_type = strstr(value, ",");
> -            if (ns_type) {
> -                ovs_be32 packet_type;
> -                *ns_type = '\0';
> -                packet_type = PACKET_TYPE_BE(strtoul(ns, NULL, 0),
> -                                             strtoul(++ns_type, NULL, 0));
> -                match_set_packet_type(&po->flow_metadata, packet_type);
> -            } else {
> -                error = xasprintf("%s(%s) can't be interpreted", name,
> value);
> -                goto out;
> -            }
> -        } else if (!strcmp(name, "packet")) {
> -            const char *error_msg = eth_from_hex(value, &packet);
> -            if (error_msg) {
> -                error = xasprintf("%s: %s", name, error_msg);
> -                goto out;
> -            }
> -        } else {
> -            const struct mf_field *mf = mf_from_name(name);
> -            if (!mf) {
> -                error = xasprintf("unknown keyword %s", name);
> -                goto out;
> -            }
> -
> -            error = parse_field(mf, value, port_map, &po->flow_metadata,
> -                                usable_protocols);
> -            if (error) {
> -                goto out;
> -            }
> -            if (!mf_is_pipeline_field(mf)) {
> -                error = xasprintf("%s is not a valid pipeline field "
> -                                  "for PACKET_OUT", name);
> -                goto out;
> -            }
> -        }
> -    }
> -
> -    if (!packet || !dp_packet_size(packet)) {
> -        error = xstrdup("must specify packet");
> -        goto out;
> -    }
> -
> -    if (act_str) {
> -        struct ofpact_parse_params pp = {
> -            .port_map = port_map,
> -            .table_map = table_map,
> -            .ofpacts = &ofpacts,
> -            .usable_protocols = &action_usable_protocols,
> -        };
> -        error = ofpacts_parse_actions(act_str, &pp);
> -        *usable_protocols &= action_usable_protocols;
> -        if (error) {
> -            goto out;
> -        }
> -    }
> -    po->ofpacts_len = ofpacts.size;
> -    po->ofpacts = ofpbuf_steal_data(&ofpacts);
> -
> -    po->packet_len = dp_packet_size(packet);
> -    po->packet = dp_packet_steal_data(packet);
> -out:
> -    ofpbuf_uninit(&ofpacts);
> -    dp_packet_delete(packet);
> -    return error;
> -}
> -
> -/* Convert 'str_' (as described in the Packet-Out Syntax section of the
> - * ovs-ofctl man page) into 'po' for sending a OFPT_PACKET_OUT message to
> a
> - * switch.  Returns the set of usable protocols in '*usable_protocols'.
> - *
> - * Returns NULL if successful, otherwise a malloc()'d string describing
> the
> - * error.  The caller is responsible for freeing the returned string.
> - * If successful, both 'po->ofpacts' and 'po->packet' must be free()d by
> - * the caller. */
> -char * OVS_WARN_UNUSED_RESULT
> -parse_ofp_packet_out_str(struct ofputil_packet_out *po, const char *str_,
> -                         const struct ofputil_port_map *port_map,
> -                         const struct ofputil_table_map *table_map,
> -                         enum ofputil_protocol *usable_protocols)
> -{
> -    char *string = xstrdup(str_);
> -    char *error;
> -
> -    error = parse_ofp_packet_out_str__(po, string, port_map, table_map,
> -                                       usable_protocols);
> -    if (error) {
> -        po->ofpacts = NULL;
> -        po->ofpacts_len = 0;
> -    }
> -
> -    free(string);
> -    return error;
> -}
> -
> -/* Parse a string representation of a meter modification message to '*mm'.
> - * If successful, 'mm->meter.bands' must be free()d by the caller. */
> -static char * OVS_WARN_UNUSED_RESULT
> -parse_ofp_meter_mod_str__(struct ofputil_meter_mod *mm, char *string,
> -                          struct ofpbuf *bands, int command,
> -                          enum ofputil_protocol *usable_protocols)
> -{
> -    enum {
> -        F_METER = 1 << 0,
> -        F_FLAGS = 1 << 1,
> -        F_BANDS = 1 << 2,
> -    } fields;
> -    char *save_ptr = NULL;
> -    char *band_str = NULL;
> -    char *name;
> -
> -    /* Meters require at least OF 1.3. */
> -    *usable_protocols = OFPUTIL_P_OF13_UP;
> -
> -    switch (command) {
> -    case -1:
> -        fields = F_METER;
> -        break;
> -
> -    case OFPMC13_ADD:
> -        fields = F_METER | F_FLAGS | F_BANDS;
> -        break;
> -
> -    case OFPMC13_DELETE:
> -        fields = F_METER;
> -        break;
> -
> -    case OFPMC13_MODIFY:
> -        fields = F_METER | F_FLAGS | F_BANDS;
> -        break;
> -
> -    default:
> -        OVS_NOT_REACHED();
> -    }
> -
> -    mm->command = command;
> -    mm->meter.meter_id = 0;
> -    mm->meter.flags = 0;
> -    mm->meter.n_bands = 0;
> -    mm->meter.bands = NULL;
> -
> -    if (fields & F_BANDS) {
> -        band_str = strstr(string, "band");
> -        if (!band_str) {
> -            return xstrdup("must specify bands");
> -        }
> -        *band_str = '\0';
> -
> -        band_str = strchr(band_str + 1, '=');
> -        if (!band_str) {
> -            return xstrdup("must specify bands");
> -        }
> -
> -        band_str++;
> -    }
> -    for (name = strtok_r(string, "=, \t\r\n", &save_ptr); name;
> -         name = strtok_r(NULL, "=, \t\r\n", &save_ptr)) {
> -
> -        if (fields & F_FLAGS && !strcmp(name, "kbps")) {
> -            mm->meter.flags |= OFPMF13_KBPS;
> -        } else if (fields & F_FLAGS && !strcmp(name, "pktps")) {
> -            mm->meter.flags |= OFPMF13_PKTPS;
> -        } else if (fields & F_FLAGS && !strcmp(name, "burst")) {
> -            mm->meter.flags |= OFPMF13_BURST;
> -        } else if (fields & F_FLAGS && !strcmp(name, "stats")) {
> -            mm->meter.flags |= OFPMF13_STATS;
> -        } else {
> -            char *value;
> -
> -            value = strtok_r(NULL, ", \t\r\n", &save_ptr);
> -            if (!value) {
> -                return xasprintf("field %s missing value", name);
> -            }
> -
> -            if (!strcmp(name, "meter")) {
> -                if (!strcmp(value, "all")) {
> -                    mm->meter.meter_id = OFPM13_ALL;
> -                } else if (!strcmp(value, "controller")) {
> -                    mm->meter.meter_id = OFPM13_CONTROLLER;
> -                } else if (!strcmp(value, "slowpath")) {
> -                    mm->meter.meter_id = OFPM13_SLOWPATH;
> -                } else {
> -                    char *error = str_to_u32(value, &mm->meter.meter_id);
> -                    if (error) {
> -                        return error;
> -                    }
> -                    if (mm->meter.meter_id > OFPM13_MAX
> -                        || !mm->meter.meter_id) {
> -                        return xasprintf("invalid value for %s", name);
> -                    }
> -                }
> -            } else {
> -                return xasprintf("unknown keyword %s", name);
> -            }
> -        }
> -    }
> -    if (fields & F_METER && !mm->meter.meter_id) {
> -        return xstrdup("must specify 'meter'");
> -    }
> -    if (fields & F_FLAGS && !mm->meter.flags) {
> -        return xstrdup("meter must specify either 'kbps' or 'pktps'");
> -    }
> -
> -    if (fields & F_BANDS) {
> -        uint16_t n_bands = 0;
> -        struct ofputil_meter_band *band = NULL;
> -        int i;
> -
> -        for (name = strtok_r(band_str, "=, \t\r\n", &save_ptr); name;
> -             name = strtok_r(NULL, "=, \t\r\n", &save_ptr)) {
> -
> -            char *value;
> -
> -            value = strtok_r(NULL, ", \t\r\n", &save_ptr);
> -            if (!value) {
> -                return xasprintf("field %s missing value", name);
> -            }
> -
> -            if (!strcmp(name, "type")) {
> -                /* Start a new band */
> -                band = ofpbuf_put_zeros(bands, sizeof *band);
> -                n_bands++;
> -
> -                if (!strcmp(value, "drop")) {
> -                    band->type = OFPMBT13_DROP;
> -                } else if (!strcmp(value, "dscp_remark")) {
> -                    band->type = OFPMBT13_DSCP_REMARK;
> -                } else {
> -                    return xasprintf("field %s unknown value %s", name,
> value);
> -                }
> -            } else if (!band || !band->type) {
> -                return xstrdup("band must start with the 'type' keyword");
> -            } else if (!strcmp(name, "rate")) {
> -                char *error = str_to_u32(value, &band->rate);
> -                if (error) {
> -                    return error;
> -                }
> -            } else if (!strcmp(name, "burst_size")) {
> -                char *error = str_to_u32(value, &band->burst_size);
> -                if (error) {
> -                    return error;
> -                }
> -            } else if (!strcmp(name, "prec_level")) {
> -                char *error = str_to_u8(value, name, &band->prec_level);
> -                if (error) {
> -                    return error;
> -                }
> -            } else {
> -                return xasprintf("unknown keyword %s", name);
> -            }
> -        }
> -        /* validate bands */
> -        if (!n_bands) {
> -            return xstrdup("meter must have bands");
> -        }
> -
> -        mm->meter.n_bands = n_bands;
> -        mm->meter.bands = ofpbuf_steal_data(bands);
> -
> -        for (i = 0; i < n_bands; ++i) {
> -            band = &mm->meter.bands[i];
> -
> -            if (!band->type) {
> -                return xstrdup("band must have 'type'");
> -            }
> -            if (band->type == OFPMBT13_DSCP_REMARK) {
> -                if (!band->prec_level) {
> -                    return xstrdup("'dscp_remark' band must have"
> -                                   " 'prec_level'");
> -                }
> -            } else {
> -                if (band->prec_level) {
> -                    return xstrdup("Only 'dscp_remark' band may have"
> -                                   " 'prec_level'");
> -                }
> -            }
> -            if (!band->rate) {
> -                return xstrdup("band must have 'rate'");
> -            }
> -            if (mm->meter.flags & OFPMF13_BURST) {
> -                if (!band->burst_size) {
> -                    return xstrdup("band must have 'burst_size' "
> -                                   "when 'burst' flag is set");
> -                }
> -            } else {
> -                if (band->burst_size) {
> -                    return xstrdup("band may have 'burst_size' only "
> -                                   "when 'burst' flag is set");
> -                }
> -            }
> -        }
> -    }
> -
> -    return NULL;
> -}
> -
> -/* Convert 'str_' (as described in the Flow Syntax section of the
> ovs-ofctl man
> - * page) into 'mm' for sending the specified meter_mod 'command' to a
> switch.
> - *
> - * Returns NULL if successful, otherwise a malloc()'d string describing
> the
> - * error.  The caller is responsible for freeing the returned string.
> - * If successful, 'mm->meter.bands' must be free()d by the caller. */
> -char * OVS_WARN_UNUSED_RESULT
> -parse_ofp_meter_mod_str(struct ofputil_meter_mod *mm, const char *str_,
> -                        int command, enum ofputil_protocol
> *usable_protocols)
> -{
> -    struct ofpbuf bands;
> -    char *string;
> -    char *error;
> -
> -    ofpbuf_init(&bands, 64);
> -    string = xstrdup(str_);
> -
> -    error = parse_ofp_meter_mod_str__(mm, string, &bands, command,
> -                                      usable_protocols);
> -
> -    free(string);
> -    ofpbuf_uninit(&bands);
> -
> -    return error;
> -}
> -
> -static char * OVS_WARN_UNUSED_RESULT
> -parse_flow_monitor_request__(struct ofputil_flow_monitor_request *fmr,
> -                             const char *str_,
> -                             const struct ofputil_port_map *port_map,
> -                             const struct ofputil_table_map *table_map,
> -                             char *string,
> -                             enum ofputil_protocol *usable_protocols)
> -{
> -    static atomic_count id = ATOMIC_COUNT_INIT(0);
> -    char *name, *value;
> -
> -    fmr->id = atomic_count_inc(&id);
> -
> -    fmr->flags = (NXFMF_INITIAL | NXFMF_ADD | NXFMF_DELETE | NXFMF_MODIFY
> -                  | NXFMF_OWN | NXFMF_ACTIONS);
> -    fmr->out_port = OFPP_NONE;
> -    fmr->table_id = 0xff;
> -    match_init_catchall(&fmr->match);
> -
> -    while (ofputil_parse_key_value(&string, &name, &value)) {
> -        const struct protocol *p;
> -        char *error = NULL;
> -
> -        if (!strcmp(name, "!initial")) {
> -            fmr->flags &= ~NXFMF_INITIAL;
> -        } else if (!strcmp(name, "!add")) {
> -            fmr->flags &= ~NXFMF_ADD;
> -        } else if (!strcmp(name, "!delete")) {
> -            fmr->flags &= ~NXFMF_DELETE;
> -        } else if (!strcmp(name, "!modify")) {
> -            fmr->flags &= ~NXFMF_MODIFY;
> -        } else if (!strcmp(name, "!actions")) {
> -            fmr->flags &= ~NXFMF_ACTIONS;
> -        } else if (!strcmp(name, "!own")) {
> -            fmr->flags &= ~NXFMF_OWN;
> -        } else if (parse_protocol(name, &p)) {
> -            match_set_dl_type(&fmr->match, htons(p->dl_type));
> -            if (p->nw_proto) {
> -                match_set_nw_proto(&fmr->match, p->nw_proto);
> -            }
> -        } else if (mf_from_name(name)) {
> -            error = parse_field(mf_from_name(name), value, port_map,
> -                                &fmr->match, usable_protocols);
> -        } else {
> -            if (!*value) {
> -                return xasprintf("%s: field %s missing value", str_,
> name);
> -            }
> -
> -            if (!strcmp(name, "table")) {
> -                if (!ofputil_table_from_string(value, table_map,
> -                                               &fmr->table_id)) {
> -                    error = xasprintf("unknown table \"%s\"", value);
> -                }
> -            } else if (!strcmp(name, "out_port")) {
> -                fmr->out_port = u16_to_ofp(atoi(value));
> -            } else {
> -                return xasprintf("%s: unknown keyword %s", str_, name);
> -            }
> -        }
> -
> -        if (error) {
> -            return error;
> -        }
> -    }
> -    return NULL;
> -}
> -
> -/* Convert 'str_' (as described in the documentation for the "monitor"
> command
> - * in the ovs-ofctl man page) into 'fmr'.
> - *
> - * Returns NULL if successful, otherwise a malloc()'d string describing
> the
> - * error.  The caller is responsible for freeing the returned string. */
> -char * OVS_WARN_UNUSED_RESULT
> -parse_flow_monitor_request(struct ofputil_flow_monitor_request *fmr,
> -                           const char *str_,
> -                           const struct ofputil_port_map *port_map,
> -                           const struct ofputil_table_map *table_map,
> -                           enum ofputil_protocol *usable_protocols)
> -{
> -    char *string = xstrdup(str_);
> -    char *error = parse_flow_monitor_request__(fmr, str_, port_map,
> table_map,
> -                                               string, usable_protocols);
> -    free(string);
> -    return error;
> -}
> -
>  /* Parses 'string' as an OFPT_FLOW_MOD or NXT_FLOW_MOD with command
> 'command'
>   * (one of OFPFC_*) into 'fm'.
>   *
> @@ -1118,996 +278,96 @@ parse_ofp_flow_mod_str(struct ofputil_flow_mod
> *fm, const char *string,
>
>      return error;
>  }
> -
> -/* Convert 'setting' (as described for the "mod-table" command
> - * in ovs-ofctl man page) into 'tm->table_vacancy->vacancy_up' and
> - * 'tm->table_vacancy->vacancy_down' threshold values.
> - * For the two threshold values, value of vacancy_up is always greater
> - * than value of vacancy_down.
> - *
> - * Returns NULL if successful, otherwise a malloc()'d string describing
> the
> - * error.  The caller is responsible for freeing the returned string. */
> -char * OVS_WARN_UNUSED_RESULT
> -parse_ofp_table_vacancy(struct ofputil_table_mod *tm, const char
> *setting)
> -{
> -    char *save_ptr = NULL;
> -    char *vac_up, *vac_down;
> -    char *value = xstrdup(setting);
> -    char *ret_msg;
> -    int vacancy_up, vacancy_down;
> -
> -    strtok_r(value, ":", &save_ptr);
> -    vac_down = strtok_r(NULL, ",", &save_ptr);
> -    if (!vac_down) {
> -        ret_msg = xasprintf("Vacancy down value missing");
> -        goto exit;
> -    }
> -    if (!str_to_int(vac_down, 0, &vacancy_down) ||
> -        vacancy_down < 0 || vacancy_down > 100) {
> -        ret_msg = xasprintf("Invalid vacancy down value \"%s\"",
> vac_down);
> -        goto exit;
> -    }
> -    vac_up = strtok_r(NULL, ",", &save_ptr);
> -    if (!vac_up) {
> -        ret_msg = xasprintf("Vacancy up value missing");
> -        goto exit;
> -    }
> -    if (!str_to_int(vac_up, 0, &vacancy_up) ||
> -        vacancy_up < 0 || vacancy_up > 100) {
> -        ret_msg = xasprintf("Invalid vacancy up value \"%s\"", vac_up);
> -        goto exit;
> -    }
> -    if (vacancy_down > vacancy_up) {
> -        ret_msg = xasprintf("Invalid vacancy range, vacancy up should be "
> -                            "greater than vacancy down (%s)",
> -                            ofperr_to_string(OFPERR_OFPBPC_BAD_VALUE));
> -        goto exit;
> -    }
> -
> -    free(value);
> -    tm->table_vacancy.vacancy_down = vacancy_down;
> -    tm->table_vacancy.vacancy_up = vacancy_up;
> -    return NULL;
> -
> -exit:
> -    free(value);
> -    return ret_msg;
> -}
> -
> -/* Convert 'table_id' and 'setting' (as described for the "mod-table"
> command
> - * in the ovs-ofctl man page) into 'tm' for sending a table_mod command
> to a
> - * switch.
> - *
> - * Stores a bitmap of the OpenFlow versions that are usable for 'tm' into
> - * '*usable_versions'.
> - *
> - * Returns NULL if successful, otherwise a malloc()'d string describing
> the
> - * error.  The caller is responsible for freeing the returned string. */
> -char * OVS_WARN_UNUSED_RESULT
> -parse_ofp_table_mod(struct ofputil_table_mod *tm, const char *table_id,
> -                    const char *setting,
> -                    const struct ofputil_table_map *table_map,
> -                    uint32_t *usable_versions)
> -{
> -    *usable_versions = 0;
> -    if (!strcasecmp(table_id, "all")) {
> -        tm->table_id = OFPTT_ALL;
> -    } else if (!ofputil_table_from_string(table_id, table_map,
> -                                          &tm->table_id)) {
> -        return xasprintf("unknown table \"%s\"", table_id);
> -    }
> -
> -    tm->miss = OFPUTIL_TABLE_MISS_DEFAULT;
> -    tm->eviction = OFPUTIL_TABLE_EVICTION_DEFAULT;
> -    tm->eviction_flags = UINT32_MAX;
> -    tm->vacancy = OFPUTIL_TABLE_VACANCY_DEFAULT;
> -    tm->table_vacancy.vacancy_down = 0;
> -    tm->table_vacancy.vacancy_up = 0;
> -    tm->table_vacancy.vacancy = 0;
> -    /* Only OpenFlow 1.1 and 1.2 can configure table-miss via table_mod.
> -     * Only OpenFlow 1.4+ can configure eviction and vacancy events
> -     * via table_mod.
> -     */
> -    if (!strcmp(setting, "controller")) {
> -        tm->miss = OFPUTIL_TABLE_MISS_CONTROLLER;
> -        *usable_versions = (1u << OFP11_VERSION) | (1u << OFP12_VERSION);
> -    } else if (!strcmp(setting, "continue")) {
> -        tm->miss = OFPUTIL_TABLE_MISS_CONTINUE;
> -        *usable_versions = (1u << OFP11_VERSION) | (1u << OFP12_VERSION);
> -    } else if (!strcmp(setting, "drop")) {
> -        tm->miss = OFPUTIL_TABLE_MISS_DROP;
> -        *usable_versions = (1u << OFP11_VERSION) | (1u << OFP12_VERSION);
> -    } else if (!strcmp(setting, "evict")) {
> -        tm->eviction = OFPUTIL_TABLE_EVICTION_ON;
> -        *usable_versions = (1 << OFP14_VERSION) | (1u << OFP15_VERSION);
> -    } else if (!strcmp(setting, "noevict")) {
> -        tm->eviction = OFPUTIL_TABLE_EVICTION_OFF;
> -        *usable_versions = (1 << OFP14_VERSION) | (1u << OFP15_VERSION);
> -    } else if (!strncmp(setting, "vacancy", strcspn(setting, ":"))) {
> -        tm->vacancy = OFPUTIL_TABLE_VACANCY_ON;
> -        *usable_versions = (1 << OFP14_VERSION) | (1u << OFP15_VERSION);
> -        char *error = parse_ofp_table_vacancy(tm, setting);
> -        if (error) {
> -            return error;
> -        }
> -    } else if (!strcmp(setting, "novacancy")) {
> -        tm->vacancy = OFPUTIL_TABLE_VACANCY_OFF;
> -        *usable_versions = (1 << OFP14_VERSION) | (1u << OFP15_VERSION);
> -    } else {
> -        return xasprintf("invalid table_mod setting %s", setting);
> -    }
> -
> -    if (tm->table_id == 0xfe
> -        && tm->miss == OFPUTIL_TABLE_MISS_CONTINUE) {
> -        return xstrdup("last table's flow miss handling can not be
> continue");
> -    }
> -
> -    return NULL;
> -}
> -
> -
> -/* Opens file 'file_name' and reads each line as a flow_mod of the
> specified
> - * type (one of OFPFC_*).  Stores each flow_mod in '*fm', an array
> allocated
> - * on the caller's behalf, and the number of flow_mods in '*n_fms'.
> - *
> - * If 'command' is given as -2, each line may start with a command name
> - * ("add", "modify", "delete", "modify_strict", or "delete_strict").  A
> missing
> - * command name is treated as "add".
> - *
> - * Returns NULL if successful, otherwise a malloc()'d string describing
> the
> - * error.  The caller is responsible for freeing the returned string. */
> -char * OVS_WARN_UNUSED_RESULT
> -parse_ofp_flow_mod_file(const char *file_name,
> -                        const struct ofputil_port_map *port_map,
> -                        const struct ofputil_table_map *table_map,
> -                        int command,
> -                        struct ofputil_flow_mod **fms, size_t *n_fms,
> -                        enum ofputil_protocol *usable_protocols)
> -{
> -    size_t allocated_fms;
> -    int line_number;
> -    FILE *stream;
> -    struct ds s;
> -
> -    *usable_protocols = OFPUTIL_P_ANY;
> -
> -    *fms = NULL;
> -    *n_fms = 0;
> -
> -    stream = !strcmp(file_name, "-") ? stdin : fopen(file_name, "r");
> -    if (stream == NULL) {
> -        return xasprintf("%s: open failed (%s)",
> -                         file_name, ovs_strerror(errno));
> -    }
> -
> -    allocated_fms = *n_fms;
> -    ds_init(&s);
> -    line_number = 0;
> -    while (!ds_get_preprocessed_line(&s, stream, &line_number)) {
> -        char *error;
> -        enum ofputil_protocol usable;
> -
> -        if (*n_fms >= allocated_fms) {
> -            *fms = x2nrealloc(*fms, &allocated_fms, sizeof **fms);
> -        }
> -        error = parse_ofp_flow_mod_str(&(*fms)[*n_fms], ds_cstr(&s),
> port_map,
> -                                       table_map, command, &usable);
> -        if (error) {
> -            char *err_msg;
> -            size_t i;
> -
> -            for (i = 0; i < *n_fms; i++) {
> -                free(CONST_CAST(struct ofpact *, (*fms)[i].ofpacts));
> -            }
> -            free(*fms);
> -            *fms = NULL;
> -            *n_fms = 0;
> -
> -            ds_destroy(&s);
> -            if (stream != stdin) {
> -                fclose(stream);
> -            }
> -
> -            err_msg = xasprintf("%s:%d: %s", file_name, line_number,
> error);
> -            free(error);
> -            return err_msg;
> -        }
> -        *usable_protocols &= usable; /* Each line can narrow the set. */
> -        *n_fms += 1;
> -    }
> -
> -    ds_destroy(&s);
> -    if (stream != stdin) {
> -        fclose(stream);
> -    }
> -    return NULL;
> -}
> -
> -char * OVS_WARN_UNUSED_RESULT
> -parse_ofp_flow_stats_request_str(struct ofputil_flow_stats_request *fsr,
> -                                 bool aggregate, const char *string,
> -                                 const struct ofputil_port_map *port_map,
> -                                 const struct ofputil_table_map
> *table_map,
> -                                 enum ofputil_protocol *usable_protocols)
> -{
> -    struct ofputil_flow_mod fm;
> -    char *error;
> -
> -    error = parse_ofp_str(&fm, -1, string, port_map, table_map,
> -                          usable_protocols);
> -    if (error) {
> -        return error;
> -    }
> -
> -    /* Special table ID support not required for stats requests. */
> -    if (*usable_protocols & OFPUTIL_P_OF10_STD_TID) {
> -        *usable_protocols |= OFPUTIL_P_OF10_STD;
> -    }
> -    if (*usable_protocols & OFPUTIL_P_OF10_NXM_TID) {
> -        *usable_protocols |= OFPUTIL_P_OF10_NXM;
> -    }
> -
> -    fsr->aggregate = aggregate;
> -    fsr->cookie = fm.cookie;
> -    fsr->cookie_mask = fm.cookie_mask;
> -    fsr->match = fm.match;
> -    fsr->out_port = fm.out_port;
> -    fsr->out_group = fm.out_group;
> -    fsr->table_id = fm.table_id;
> -    return NULL;
> -}
> -
> -/* Parses a specification of a flow from 's' into 'flow'.  's' must take
> the
> - * form FIELD=VALUE[,FIELD=VALUE]... where each FIELD is the name of a
> - * mf_field.  Fields must be specified in a natural order for satisfying
> - * prerequisites. If 'wc' is specified, masks the field in 'wc' for each
> of the
> - * field specified in flow. If the map, 'names_portno' is specfied,
> converts
> - * the in_port name into port no while setting the 'flow'.
> - *
> - * Returns NULL on success, otherwise a malloc()'d string that explains
> the
> - * problem. */
> -char *
> -parse_ofp_exact_flow(struct flow *flow, struct flow_wildcards *wc,
> -                     const struct tun_table *tun_table, const char *s,
> -                     const struct ofputil_port_map *port_map)
> -{
> -    char *pos, *key, *value_s;
> -    char *error = NULL;
> -    char *copy;
> -
> -    memset(flow, 0, sizeof *flow);
> -    if (wc) {
> -        memset(wc, 0, sizeof *wc);
> -    }
> -    flow->tunnel.metadata.tab = tun_table;
> -
> -    pos = copy = xstrdup(s);
> -    while (ofputil_parse_key_value(&pos, &key, &value_s)) {
> -        const struct protocol *p;
> -        if (parse_protocol(key, &p)) {
> -            if (flow->dl_type) {
> -                error = xasprintf("%s: Ethernet type set multiple times",
> s);
> -                goto exit;
> -            }
> -            flow->dl_type = htons(p->dl_type);
> -            if (wc) {
> -                wc->masks.dl_type = OVS_BE16_MAX;
> -            }
> -
> -            if (p->nw_proto) {
> -                if (flow->nw_proto) {
> -                    error = xasprintf("%s: network protocol set "
> -                                      "multiple times", s);
> -                    goto exit;
> -                }
> -                flow->nw_proto = p->nw_proto;
> -                if (wc) {
> -                    wc->masks.nw_proto = UINT8_MAX;
> -                }
> -            }
> -        } else {
> -            const struct mf_field *mf;
> -            union mf_value value;
> -            char *field_error;
> -
> -            mf = mf_from_name(key);
> -            if (!mf) {
> -                error = xasprintf("%s: unknown field %s", s, key);
> -                goto exit;
> -            }
> -
> -            if (!mf_are_prereqs_ok(mf, flow, NULL)) {
> -                error = xasprintf("%s: prerequisites not met for setting
> %s",
> -                                  s, key);
> -                goto exit;
> -            }
> -
> -            if (mf_is_set(mf, flow)) {
> -                error = xasprintf("%s: field %s set multiple times", s,
> key);
> -                goto exit;
> -            }
> -
> -            field_error = mf_parse_value(mf, value_s, port_map, &value);
> -            if (field_error) {
> -                error = xasprintf("%s: bad value for %s (%s)",
> -                                  s, key, field_error);
> -                free(field_error);
> -                goto exit;
> -            }
> -
> -            mf_set_flow_value(mf, &value, flow);
> -            if (wc) {
> -                mf_mask_field(mf, wc);
> -            }
> -        }
> -    }
> -
> -    if (!flow->in_port.ofp_port) {
> -        flow->in_port.ofp_port = OFPP_NONE;
> -    }
> -
> -exit:
> -    free(copy);
> -
> -    if (error) {
> -        memset(flow, 0, sizeof *flow);
> -        if (wc) {
> -            memset(wc, 0, sizeof *wc);
> -        }
> -    }
> -    return error;
> -}
> -
> -static char * OVS_WARN_UNUSED_RESULT
> -parse_bucket_str(struct ofputil_bucket *bucket, char *str_,
> -                 const struct ofputil_port_map *port_map,
> -                 const struct ofputil_table_map *table_map,
> -                 uint8_t group_type, enum ofputil_protocol
> *usable_protocols)
> -{
> -    char *pos, *key, *value;
> -    struct ofpbuf ofpacts;
> -    struct ds actions;
> -    char *error;
> -
> -    bucket->weight = group_type == OFPGT11_SELECT ? 1 : 0;
> -    bucket->bucket_id = OFPG15_BUCKET_ALL;
> -    bucket->watch_port = OFPP_ANY;
> -    bucket->watch_group = OFPG_ANY;
> -
> -    ds_init(&actions);
> -
> -    pos = str_;
> -    error = NULL;
> -    while (ofputil_parse_key_value(&pos, &key, &value)) {
> -        if (!strcasecmp(key, "weight")) {
> -            error = str_to_u16(value, "weight", &bucket->weight);
> -        } else if (!strcasecmp(key, "watch_port")) {
> -            if (!ofputil_port_from_string(value, port_map,
> &bucket->watch_port)
> -                || (ofp_to_u16(bucket->watch_port) >=
> ofp_to_u16(OFPP_MAX)
> -                    && bucket->watch_port != OFPP_ANY)) {
> -                error = xasprintf("%s: invalid watch_port", value);
> -            }
> -        } else if (!strcasecmp(key, "watch_group")) {
> -            error = str_to_u32(value, &bucket->watch_group);
> -            if (!error && bucket->watch_group > OFPG_MAX) {
> -                error = xasprintf("invalid watch_group id %"PRIu32,
> -                                  bucket->watch_group);
> -            }
> -        } else if (!strcasecmp(key, "bucket_id")) {
> -            error = str_to_u32(value, &bucket->bucket_id);
> -            if (!error && bucket->bucket_id > OFPG15_BUCKET_MAX) {
> -                error = xasprintf("invalid bucket_id id %"PRIu32,
> -                                  bucket->bucket_id);
> -            }
> -            *usable_protocols &= OFPUTIL_P_OF15_UP;
> -        } else if (!strcasecmp(key, "action") || !strcasecmp(key,
> "actions")) {
> -            ds_put_format(&actions, "%s,", value);
> -        } else {
> -            ds_put_format(&actions, "%s(%s),", key, value);
> -        }
> -
> -        if (error) {
> -            ds_destroy(&actions);
> -            return error;
> -        }
> -    }
> -
> -    if (!actions.length) {
> -        return xstrdup("bucket must specify actions");
> -    }
> -    ds_chomp(&actions, ',');
> -
> -    ofpbuf_init(&ofpacts, 0);
> -    struct ofpact_parse_params pp = {
> -        .port_map = port_map,
> -        .table_map = table_map,
> -        .ofpacts = &ofpacts,
> -        .usable_protocols = usable_protocols,
> -    };
> -    error = ofpacts_parse_actions(ds_cstr(&actions), &pp);
> -    ds_destroy(&actions);
> -    if (error) {
> -        ofpbuf_uninit(&ofpacts);
> -        return error;
> -    }
> -    bucket->ofpacts = ofpacts.data;
> -    bucket->ofpacts_len = ofpacts.size;
> -
> -    return NULL;
> -}
> -
> -static char * OVS_WARN_UNUSED_RESULT
> -parse_select_group_field(char *s, const struct ofputil_port_map *port_map,
> -                         struct field_array *fa,
> -                         enum ofputil_protocol *usable_protocols)
> -{
> -    char *name, *value_str;
> -
> -    while (ofputil_parse_key_value(&s, &name, &value_str)) {
> -        const struct mf_field *mf = mf_from_name(name);
> -
> -        if (mf) {
> -            char *error;
> -            union mf_value value;
> -
> -            if (bitmap_is_set(fa->used.bm, mf->id)) {
> -                return xasprintf("%s: duplicate field", name);
> -            }
> -
> -            if (*value_str) {
> -                error = mf_parse_value(mf, value_str, port_map, &value);
> -                if (error) {
> -                    return error;
> -                }
> -
> -                /* The mask cannot be all-zeros */
> -                if (!mf_is_tun_metadata(mf) &&
> -                    is_all_zeros(&value, mf->n_bytes)) {
> -                    return xasprintf("%s: values are wildcards here "
> -                                     "and must not be all-zeros", s);
> -                }
> -
> -                /* The values parsed are masks for fields used
> -                 * by the selection method */
> -                if (!mf_is_mask_valid(mf, &value)) {
> -                    return xasprintf("%s: invalid mask for field %s",
> -                                     value_str, mf->name);
> -                }
> -            } else {
> -                memset(&value, 0xff, mf->n_bytes);
> -            }
> -
> -            field_array_set(mf->id, &value, fa);
> -
> -            if (is_all_ones(&value, mf->n_bytes)) {
> -                *usable_protocols &= mf->usable_protocols_exact;
> -            } else if (mf->usable_protocols_bitwise ==
> mf->usable_protocols_cidr
> -                       || ip_is_cidr(value.be32)) {
> -                *usable_protocols &= mf->usable_protocols_cidr;
> -            } else {
> -                *usable_protocols &= mf->usable_protocols_bitwise;
> -            }
> -        } else {
> -            return xasprintf("%s: unknown field %s", s, name);
> -        }
> -    }
> -
> -    return NULL;
> -}
> -
> -static char * OVS_WARN_UNUSED_RESULT
> -parse_ofp_group_mod_str__(struct ofputil_group_mod *gm, int command,
> -                          char *string,
> -                          const struct ofputil_port_map *port_map,
> -                          const struct ofputil_table_map *table_map,
> -                          e