[ovs-dev] [PATCH 2/2] ofp-util, ofp-parse: Break up into many separate modules.
Yifeng Sun
pkusunyifeng at gmail.com
Tue Feb 13 18:17:43 UTC 2018
Looks good to me. Thanks.
Reviewed-by: Yifeng Sun <pkusunyifeng at gmail.com>
On Fri, Feb 9, 2018 at 2:57 PM, Ben Pfaff <blp at 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 at 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,
> - 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;
> +
> +static size_t
> +parse_value(const char *s, const char *delimiters)
> +{
> + size_t n = 0;
> +
> + /* Iterate until we reach a delimiter.
> + *
> + * strchr(s, '\0') returns s+strlen(s), so this test handles the null
> + * terminator at the end of 's'. */
> + while (!strchr(delimiters, s[n])) {
> + if (s[n] == '(') {
> + int level = 0;
> + do {
> + switch (s[n]) {
> + case '\0':
> + return n;
> + case '(':
> + level++;
> + break;
> + case ')':
> + level--;
> + break;
> }
> - }
> - 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;
> + n++;
> + } while (level > 0);
> } 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;
> + n++;
> }
> - *usable_protocols &= usable;
> - *n_gms += 1;
> }
> -
> - ds_destroy(&s);
> - if (stream != stdin) {
> - fclose(stream);
> - }
> - return NULL;
> + return n;
> }
>
> -/* 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'.
> +/* Parses a key or a key-value pair from '*stringp'.
> *
> - * 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);
> + * On success: Stores the key into '*keyp'. Stores the value, if
> present, into
> + * '*valuep', otherwise an empty string. Advances '*stringp' past the
> end of
> + * the key-value pair, preparing it for another call. '*keyp' and
> '*valuep'
> + * are substrings of '*stringp' created by replacing some of its bytes by
> null
> + * terminators. Returns true.
> + *
> + * If '*stringp' is just white space or commas, sets '*keyp' and
> '*valuep' to
> + * NULL and returns false. */
> +bool
> +ofputil_parse_key_value(char **stringp, char **keyp, char **valuep)
> +{
> + /* Skip white space and delimiters. If that brings us to the end of
> the
> + * input string, we are done and there are no more key-value pairs. */
> + *stringp += strspn(*stringp, ", \t\r\n");
> + if (**stringp == '\0') {
> + *keyp = *valuep = NULL;
> + return false;
> + }
> +
> + /* Extract the key and the delimiter that ends the key-value pair or
> begins
> + * the value. Advance the input position past the key and delimiter.
> */
> + char *key = *stringp;
> + size_t key_len = strcspn(key, ":=(, \t\r\n");
> + char key_delim = key[key_len];
> + key[key_len] = '\0';
> + *stringp += key_len + (key_delim != '\0');
> +
> + /* Figure out what delimiter ends the value:
> + *
> + * - If key_delim is ":" or "=", the value extends until white
> space
> + * or a comma.
> + *
> + * - If key_delim is "(", the value extends until ")".
> + *
> + * If there is no value, we are done. */
> + const char *value_delims;
> + if (key_delim == ':' || key_delim == '=') {
> + value_delims = ", \t\r\n";
> + } else if (key_delim == '(') {
> + value_delims = ")";
> + } else {
> + *keyp = key;
> + *valuep = key + key_len; /* Empty string. */
> + return true;
> }
>
> - 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;
> -}
> + /* Extract the value. Advance the input position past the value and
> + * delimiter. */
> + char *value = *stringp;
> + size_t value_len = parse_value(value, value_delims);
> + char value_delim = value[value_len];
> + value[value_len] = '\0';
> + *stringp += value_len + (value_delim != '\0');
>
> -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;
> + *keyp = key;
> + *valuep = value;
> + return true;
> }
> diff --git a/lib/ofp-port.c b/lib/ofp-port.c
> new file mode 100644
> index 000000000000..78c7dd866921
> --- /dev/null
> +++ b/lib/ofp-port.c
> @@ -0,0 +1,1626 @@
> +/*
> + * 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-port.h"
> +#include "byte-order.h"
> +#include "flow.h"
> +#include "openflow/intel-ext.h"
> +#include "openvswitch/json.h"
> +#include "openvswitch/ofp-errors.h"
> +#include "openvswitch/ofp-msgs.h"
> +#include "openvswitch/ofp-prop.h"
> +#include "openvswitch/ofpbuf.h"
> +#include "openvswitch/vlog.h"
> +
> +VLOG_DEFINE_THIS_MODULE(ofp_port);
> +
> +static struct vlog_rate_limit rl = VLOG_RATE_LIMIT_INIT(1, 5);
> +
> +/* ofputil_port_map. */
> +
> +void
> +ofputil_port_map_init(struct ofputil_port_map *map)
> +{
> + namemap_init(&map->map);
> +}
> +
> +void
> +ofputil_port_map_put(struct ofputil_port_map *map,
> + ofp_port_t ofp_port, const char *name)
> +{
> + namemap_put(&map->map, ofp_to_u16(ofp_port), name);
> +}
> +
> +const char *
> +ofputil_port_map_get_name(const struct ofputil_port_map *map,
> + ofp_port_t ofp_port)
> +{
> + struct namemap_node *node
> + = (map
> + ? namemap_find_by_number(&map->map, ofp_to_u16(ofp_port))
> + : NULL);
> + return node && !node->duplicate ? node->name : NULL;
> +}
> +
> +ofp_port_t
> +ofputil_port_map_get_number(const struct ofputil_port_map *map,
> + const char *name)
> +{
> + struct namemap_node *node
> + = map ? namemap_find_by_name(&map->map, name) : NULL;
> + return node && !node->duplicate ? u16_to_ofp(node->number) :
> OFPP_NONE;
> +}
> +
> +void
> +ofputil_port_map_destroy(struct ofputil_port_map *map)
> +{
> + namemap_destroy(&map->map);
> +}
> +
> +/* Converts the OpenFlow 1.1+ port number 'ofp11_port' into an OpenFlow
> 1.0
> + * port number and stores the latter in '*ofp10_port', for the purpose of
> + * decoding OpenFlow 1.1+ protocol messages. Returns 0 if successful,
> + * otherwise an OFPERR_* number. On error, stores OFPP_NONE in
> '*ofp10_port'.
> + *
> + * See the definition of OFP11_MAX for an explanation of the mapping. */
> +enum ofperr
> +ofputil_port_from_ofp11(ovs_be32 ofp11_port, ofp_port_t *ofp10_port)
> +{
> + uint32_t ofp11_port_h = ntohl(ofp11_port);
> +
> + if (ofp11_port_h < ofp_to_u16(OFPP_MAX)) {
> + *ofp10_port = u16_to_ofp(ofp11_port_h);
> + return 0;
> + } else if (ofp11_port_h >= ofp11_to_u32(OFPP11_MAX)) {
> + *ofp10_port = u16_to_ofp(ofp11_port_h - OFPP11_OFFSET);
> + return 0;
> + } else {
> + *ofp10_port = OFPP_NONE;
> +
> + static struct vlog_rate_limit rl = VLOG_RATE_LIMIT_INIT(1, 5);
> + VLOG_WARN_RL(&rl, "port %"PRIu32" is outside the supported "
> + "range 0 through %d or 0x%"PRIx32" through
> 0x%"PRIx32,
> + ofp11_port_h, ofp_to_u16(OFPP_MAX) - 1,
> + ofp11_to_u32(OFPP11_MAX), UINT32_MAX);
> +
> + return OFPERR_OFPBAC_BAD_OUT_PORT;
> + }
> +}
> +
> +/* Returns the OpenFlow 1.1+ port number equivalent to the OpenFlow 1.0
> port
> + * number 'ofp10_port', for encoding OpenFlow 1.1+ protocol messages.
> + *
> + * See the definition of OFP11_MAX for an explanation of the mapping. */
> +ovs_be32
> +ofputil_port_to_ofp11(ofp_port_t ofp10_port)
> +{
> + return htonl(ofp_to_u16(ofp10_port) < ofp_to_u16(OFPP_MAX)
> + ? ofp_to_u16(ofp10_port)
> + : ofp_to_u16(ofp10_port) + OFPP11_OFFSET);
> +}
> +
> +#define OFPUTIL_NAMED_PORTS \
> + OFPUTIL_NAMED_PORT(IN_PORT) \
> + OFPUTIL_NAMED_PORT(TABLE) \
> + OFPUTIL_NAMED_PORT(NORMAL) \
> + OFPUTIL_NAMED_PORT(FLOOD) \
> + OFPUTIL_NAMED_PORT(ALL) \
> + OFPUTIL_NAMED_PORT(CONTROLLER) \
> + OFPUTIL_NAMED_PORT(LOCAL) \
> + OFPUTIL_NAMED_PORT(ANY) \
> + OFPUTIL_NAMED_PORT(UNSET)
> +
> +/* For backwards compatibility, so that "none" is recognized as OFPP_ANY
> */
> +#define OFPUTIL_NAMED_PORTS_WITH_NONE \
> + OFPUTIL_NAMED_PORTS \
> + OFPUTIL_NAMED_PORT(NONE)
> +
> +/* Stores the port number represented by 's' into '*portp'. 's' may be an
> + * integer or, for reserved ports, the standard OpenFlow name for the port
> + * (e.g. "LOCAL"). If 'port_map' is nonnull, also accepts names in it
> (quoted
> + * or unquoted).
> + *
> + * Returns true if successful, false if 's' is not a valid OpenFlow port
> number
> + * or name. The caller should issue an error message in this case,
> because
> + * this function usually does not. (This gives the caller an opportunity
> to
> + * look up the port name another way, e.g. by contacting the switch and
> listing
> + * the names of all its ports).
> + *
> + * This function accepts OpenFlow 1.0 port numbers. It also accepts a
> subset
> + * of OpenFlow 1.1+ port numbers, mapping those port numbers into the
> 16-bit
> + * range as described in include/openflow/openflow-1.1.h. */
> +bool
> +ofputil_port_from_string(const char *s,
> + const struct ofputil_port_map *port_map,
> + ofp_port_t *portp)
> +{
> + unsigned int port32; /* int is at least 32 bits wide. */
> +
> + if (*s == '-') {
> + VLOG_WARN("Negative value %s is not a valid port number.", s);
> + return false;
> + }
> + *portp = 0;
> + if (str_to_uint(s, 10, &port32)) {
> + if (port32 < ofp_to_u16(OFPP_MAX)) {
> + /* Pass. */
> + } else if (port32 < ofp_to_u16(OFPP_FIRST_RESV)) {
> + VLOG_WARN("port %u is a reserved OF1.0 port number that will "
> + "be translated to %u when talking to an OF1.1 or "
> + "later controller", port32, port32 + OFPP11_OFFSET);
> + } else if (port32 <= ofp_to_u16(OFPP_LAST_RESV)) {
> + char name[OFP10_MAX_PORT_NAME_LEN];
> +
> + ofputil_port_to_string(u16_to_ofp(port32), NULL,
> + name, sizeof name);
> + VLOG_WARN_ONCE("referring to port %s as %"PRIu32" is
> deprecated "
> + "for compatibility with OpenFlow 1.1 and
> later",
> + name, port32);
> + } else if (port32 < ofp11_to_u32(OFPP11_MAX)) {
> + VLOG_WARN("port %u is outside the supported range 0 through "
> + "%x or 0x%x through 0x%"PRIx32, port32,
> + UINT16_MAX, ofp11_to_u32(OFPP11_MAX), UINT32_MAX);
> + return false;
> + } else {
> + port32 -= OFPP11_OFFSET;
> + }
> +
> + *portp = u16_to_ofp(port32);
> + return true;
> + } else {
> + struct pair {
> + const char *name;
> + ofp_port_t value;
> + };
> + static const struct pair pairs[] = {
> +#define OFPUTIL_NAMED_PORT(NAME) {#NAME, OFPP_##NAME},
> + OFPUTIL_NAMED_PORTS_WITH_NONE
> +#undef OFPUTIL_NAMED_PORT
> + };
> + const struct pair *p;
> +
> + for (p = pairs; p < &pairs[ARRAY_SIZE(pairs)]; p++) {
> + if (!strcasecmp(s, p->name)) {
> + *portp = p->value;
> + return true;
> + }
> + }
> +
> + ofp_port_t ofp_port = OFPP_NONE;
> + if (s[0] != '"') {
> + ofp_port = ofputil_port_map_get_number(port_map, s);
> + } else {
> + size_t length = strlen(s);
> + char *name = NULL;
> + if (length > 1
> + && s[length - 1] == '"'
> + && json_string_unescape(s + 1, length - 2, &name)) {
> + ofp_port = ofputil_port_map_get_number(port_map, name);
> + }
> + free(name);
> + }
> + if (ofp_port != OFPP_NONE) {
> + *portp = ofp_port;
> + return true;
> + }
> +
> + return false;
> + }
> +}
> +
> +const char *
> +ofputil_port_get_reserved_name(ofp_port_t port)
> +{
> + switch (port) {
> +#define OFPUTIL_NAMED_PORT(NAME) case OFPP_##NAME: return #NAME;
> + OFPUTIL_NAMED_PORTS
> +#undef OFPUTIL_NAMED_PORT
> +
> + default:
> + return NULL;
> + }
> +}
> +
> +/* Appends to 's' a string representation of the OpenFlow port number
> 'port'.
> + * Most ports' string representation is just the port number, but for
> special
> + * ports, e.g. OFPP_LOCAL, it is the name, e.g. "LOCAL". */
> +void
> +ofputil_format_port(ofp_port_t port, const struct ofputil_port_map
> *port_map,
> + struct ds *s)
> +{
> + const char *reserved_name = ofputil_port_get_reserved_name(port);
> + if (reserved_name) {
> + ds_put_cstr(s, reserved_name);
> + return;
> + }
> +
> + const char *port_name = ofputil_port_map_get_name(port_map, port);
> + if (port_name) {
> + namemap_put_name(port_name, s);
> + return;
> + }
> +
> + ds_put_format(s, "%"PRIu32, port);
> +}
> +
> +/* Puts in the 'bufsize' byte in 'namebuf' a null-terminated string
> + * representation of OpenFlow port number 'port'. Most ports are
> represented
> + * as just the port number, but special ports, e.g. OFPP_LOCAL, are
> represented
> + * by name, e.g. "LOCAL". */
> +void
> +ofputil_port_to_string(ofp_port_t port,
> + const struct ofputil_port_map *port_map,
> + char *namebuf, size_t bufsize)
> +{
> + const char *reserved_name = ofputil_port_get_reserved_name(port);
> + if (reserved_name) {
> + ovs_strlcpy(namebuf, reserved_name, bufsize);
> + return;
> + }
> +
> + const char *port_name = ofputil_port_map_get_name(port_map, port);
> + if (port_name) {
> + struct ds s = DS_EMPTY_INITIALIZER;
> + namemap_put_name(port_name, &s);
> + ovs_strlcpy(namebuf, ds_cstr(&s), bufsize);
> + ds_destroy(&s);
> + return;
> + }
> +
> + snprintf(namebuf, bufsize, "%"PRIu32, port);
> +}
> +
> +/* ofputil_phy_port */
> +
> +/* NETDEV_F_* to and from OFPPF_* and OFPPF10_*. */
> +BUILD_ASSERT_DECL((int) NETDEV_F_10MB_HD == OFPPF_10MB_HD); /* bit 0
> */
> +BUILD_ASSERT_DECL((int) NETDEV_F_10MB_FD == OFPPF_10MB_FD); /* bit 1
> */
> +BUILD_ASSERT_DECL((int) NETDEV_F_100MB_HD == OFPPF_100MB_HD); /* bit 2
> */
> +BUILD_ASSERT_DECL((int) NETDEV_F_100MB_FD == OFPPF_100MB_FD); /* bit 3
> */
> +BUILD_ASSERT_DECL((int) NETDEV_F_1GB_HD == OFPPF_1GB_HD); /* bit 4
> */
> +BUILD_ASSERT_DECL((int) NETDEV_F_1GB_FD == OFPPF_1GB_FD); /* bit 5
> */
> +BUILD_ASSERT_DECL((int) NETDEV_F_10GB_FD == OFPPF_10GB_FD); /* bit 6
> */
> +
> +/* NETDEV_F_ bits 11...15 are OFPPF10_ bits 7...11: */
> +BUILD_ASSERT_DECL((int) NETDEV_F_COPPER == (OFPPF10_COPPER << 4));
> +BUILD_ASSERT_DECL((int) NETDEV_F_FIBER == (OFPPF10_FIBER << 4));
> +BUILD_ASSERT_DECL((int) NETDEV_F_AUTONEG == (OFPPF10_AUTONEG << 4));
> +BUILD_ASSERT_DECL((int) NETDEV_F_PAUSE == (OFPPF10_PAUSE << 4));
> +BUILD_ASSERT_DECL((int) NETDEV_F_PAUSE_ASYM == (OFPPF10_PAUSE_ASYM << 4));
> +
> +static enum netdev_features
> +netdev_port_features_from_ofp10(ovs_be32 ofp10_)
> +{
> + uint32_t ofp10 = ntohl(ofp10_);
> + return (ofp10 & 0x7f) | ((ofp10 & 0xf80) << 4);
> +}
> +
> +static ovs_be32
> +netdev_port_features_to_ofp10(enum netdev_features features)
> +{
> + return htonl((features & 0x7f) | ((features & 0xf800) >> 4));
> +}
> +
> +BUILD_ASSERT_DECL((int) NETDEV_F_10MB_HD == OFPPF_10MB_HD); /* bit
> 0 */
> +BUILD_ASSERT_DECL((int) NETDEV_F_10MB_FD == OFPPF_10MB_FD); /* bit
> 1 */
> +BUILD_ASSERT_DECL((int) NETDEV_F_100MB_HD == OFPPF_100MB_HD); /* bit
> 2 */
> +BUILD_ASSERT_DECL((int) NETDEV_F_100MB_FD == OFPPF_100MB_FD); /* bit
> 3 */
> +BUILD_ASSERT_DECL((int) NETDEV_F_1GB_HD == OFPPF_1GB_HD); /* bit
> 4 */
> +BUILD_ASSERT_DECL((int) NETDEV_F_1GB_FD == OFPPF_1GB_FD); /* bit
> 5 */
> +BUILD_ASSERT_DECL((int) NETDEV_F_10GB_FD == OFPPF_10GB_FD); /* bit
> 6 */
> +BUILD_ASSERT_DECL((int) NETDEV_F_40GB_FD == OFPPF11_40GB_FD); /* bit
> 7 */
> +BUILD_ASSERT_DECL((int) NETDEV_F_100GB_FD == OFPPF11_100GB_FD); /* bit
> 8 */
> +BUILD_ASSERT_DECL((int) NETDEV_F_1TB_FD == OFPPF11_1TB_FD); /* bit
> 9 */
> +BUILD_ASSERT_DECL((int) NETDEV_F_OTHER == OFPPF11_OTHER); /* bit
> 10 */
> +BUILD_ASSERT_DECL((int) NETDEV_F_COPPER == OFPPF11_COPPER); /* bit
> 11 */
> +BUILD_ASSERT_DECL((int) NETDEV_F_FIBER == OFPPF11_FIBER); /* bit
> 12 */
> +BUILD_ASSERT_DECL((int) NETDEV_F_AUTONEG == OFPPF11_AUTONEG); /* bit
> 13 */
> +BUILD_ASSERT_DECL((int) NETDEV_F_PAUSE == OFPPF11_PAUSE); /* bit
> 14 */
> +BUILD_ASSERT_DECL((int) NETDEV_F_PAUSE_ASYM == OFPPF11_PAUSE_ASYM);/* bit
> 15 */
> +
> +static enum netdev_features
> +netdev_port_features_from_ofp11(ovs_be32 ofp11)
> +{
> + return ntohl(ofp11) & 0xffff;
> +}
> +
> +static ovs_be32
> +netdev_port_features_to_ofp11(enum netdev_features features)
> +{
> + return htonl(features & 0xffff);
> +}
> +
> +static enum ofperr
> +ofputil_decode_ofp10_phy_port(struct ofputil_phy_port *pp,
> + const struct ofp10_phy_port *opp)
> +{
> + pp->port_no = u16_to_ofp(ntohs(opp->port_no));
> + pp->hw_addr = opp->hw_addr;
> + ovs_strlcpy_arrays(pp->name, opp->name);
> +
> + pp->config = ntohl(opp->config) & OFPPC10_ALL;
> + pp->state = ntohl(opp->state) & OFPPS10_ALL;
> +
> + pp->curr = netdev_port_features_from_ofp10(opp->curr);
> + pp->advertised = netdev_port_features_from_ofp10(opp->advertised);
> + pp->supported = netdev_port_features_from_ofp10(opp->supported);
> + pp->peer = netdev_port_features_from_ofp10(opp->peer);
> +
> + pp->curr_speed = netdev_features_to_bps(pp->curr, 0) / 1000;
> + pp->max_speed = netdev_features_to_bps(pp->supported, 0) / 1000;
> +
> + return 0;
> +}
> +
> +static enum ofperr
> +ofputil_decode_ofp11_port(struct ofputil_phy_port *pp,
> + const struct ofp11_port *op)
> +{
> + enum ofperr error;
> +
> + error = ofputil_port_from_ofp11(op->port_no, &pp->port_no);
> + if (error) {
> + return error;
> + }
> + pp->hw_addr = op->hw_addr;
> + ovs_strlcpy_arrays(pp->name, op->name);
> +
> + pp->config = ntohl(op->config) & OFPPC11_ALL;
> + pp->state = ntohl(op->state) & OFPPS11_ALL;
> +
> + pp->curr = netdev_port_features_from_ofp11(op->curr);
> + pp->advertised = netdev_port_features_from_ofp11(op->advertised);
> + pp->supported = netdev_port_features_from_ofp11(op->supported);
> + pp->peer = netdev_port_features_from_ofp11(op->peer);
> +
> + pp->curr_speed = ntohl(op->curr_speed);
> + pp->max_speed = ntohl(op->max_speed);
> +
> + return 0;
> +}
> +
> +static enum ofperr
> +parse_ofp14_port_ethernet_property(const struct ofpbuf *payload,
> + struct ofputil_phy_port *pp)
> +{
> + struct ofp14_port_desc_prop_ethernet *eth = payload->data;
> +
> + if (payload->size != sizeof *eth) {
> + return OFPERR_OFPBPC_BAD_LEN;
> + }
> +
> + pp->curr = netdev_port_features_from_ofp11(eth->curr);
> + pp->advertised = netdev_port_features_from_ofp11(eth->advertised);
> + pp->supported = netdev_port_features_from_ofp11(eth->supported);
> + pp->peer = netdev_port_features_from_ofp11(eth->peer);
> +
> + pp->curr_speed = ntohl(eth->curr_speed);
> + pp->max_speed = ntohl(eth->max_speed);
> +
> + return 0;
> +}
> +
> +static enum ofperr
> +ofputil_pull_ofp14_port_properties(const void *props, size_t len,
> + struct ofputil_phy_port *pp)
> +{
> + struct ofpbuf properties = ofpbuf_const_initializer(props, 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 OFPPDPT14_ETHERNET:
> + error = parse_ofp14_port_ethernet_property(&payload, pp);
> + break;
> +
> + default:
> + error = OFPPROP_UNKNOWN(true, "port", type);
> + break;
> + }
> +
> + if (error) {
> + return error;
> + }
> + }
> +
> + return 0;
> +}
> +
> +static enum ofperr
> +ofputil_pull_ofp14_port(struct ofputil_phy_port *pp, struct ofpbuf *msg)
> +{
> + const struct ofp14_port *op = ofpbuf_try_pull(msg, sizeof *op);
> + if (!op) {
> + return OFPERR_OFPBRC_BAD_LEN;
> + }
> +
> + size_t len = ntohs(op->length);
> + if (len < sizeof *op || len - sizeof *op > msg->size) {
> + return OFPERR_OFPBRC_BAD_LEN;
> + }
> + len -= sizeof *op;
> +
> + enum ofperr error = ofputil_port_from_ofp11(op->port_no,
> &pp->port_no);
> + if (error) {
> + return error;
> + }
> + pp->hw_addr = op->hw_addr;
> + ovs_strlcpy_arrays(pp->name, op->name);
> +
> + pp->config = ntohl(op->config) & OFPPC11_ALL;
> + pp->state = ntohl(op->state) & OFPPS11_ALL;
> +
> + return ofputil_pull_ofp14_port_properties(ofpbuf_pull(msg, len),
> len, pp);
> +}
> +
> +static enum ofperr
> +ofputil_pull_ofp16_port(struct ofputil_phy_port *pp, struct ofpbuf *msg)
> +{
> + const struct ofp16_port *op = ofpbuf_try_pull(msg, sizeof *op);
> + if (!op) {
> + return OFPERR_OFPBRC_BAD_LEN;
> + }
> +
> + size_t len = ntohs(op->length);
> + if (len < sizeof *op || len - sizeof *op > msg->size) {
> + return OFPERR_OFPBRC_BAD_LEN;
> + }
> + len -= sizeof *op;
> +
> + enum ofperr error = ofputil_port_from_ofp11(op->port_no,
> &pp->port_no);
> + if (error) {
> + return error;
> + }
> + pp->hw_addr = op->hw_addr;
> + pp->hw_addr64 = op->hw_addr64;
> + ovs_strlcpy_arrays(pp->name, op->name);
> +
> + pp->config = ntohl(op->config) & OFPPC11_ALL;
> + pp->state = ntohl(op->state) & OFPPS11_ALL;
> +
> + return ofputil_pull_ofp14_port_properties(ofpbuf_pull(msg, len),
> len, pp);
> +}
> +
> +static void
> +ofputil_encode_ofp10_phy_port(const struct ofputil_phy_port *pp,
> + struct ofp10_phy_port *opp)
> +{
> + memset(opp, 0, sizeof *opp);
> +
> + opp->port_no = htons(ofp_to_u16(pp->port_no));
> + opp->hw_addr = pp->hw_addr;
> + ovs_strlcpy_arrays(opp->name, pp->name);
> +
> + opp->config = htonl(pp->config & OFPPC10_ALL);
> + opp->state = htonl(pp->state & OFPPS10_ALL);
> +
> + opp->curr = netdev_port_features_to_ofp10(pp->curr);
> + opp->advertised = netdev_port_features_to_ofp10(pp->advertised);
> + opp->supported = netdev_port_features_to_ofp10(pp->supported);
> + opp->peer = netdev_port_features_to_ofp10(pp->peer);
> +}
> +
> +static void
> +ofputil_encode_ofp11_port(const struct ofputil_phy_port *pp,
> + struct ofp11_port *op)
> +{
> + memset(op, 0, sizeof *op);
> +
> + op->port_no = ofputil_port_to_ofp11(pp->port_no);
> + op->hw_addr = pp->hw_addr;
> + ovs_strlcpy_arrays(op->name, pp->name);
> +
> + op->config = htonl(pp->config & OFPPC11_ALL);
> + op->state = htonl(pp->state & OFPPS11_ALL);
> +
> + op->curr = netdev_port_features_to_ofp11(pp->curr);
> + op->advertised = netdev_port_features_to_ofp11(pp->advertised);
> + op->supported = netdev_port_features_to_ofp11(pp->supported);
> + op->peer = netdev_port_features_to_ofp11(pp->peer);
> +
> + op->curr_speed = htonl(pp->curr_speed);
> + op->max_speed = htonl(pp->max_speed);
> +}
> +
> +static void
> +ofputil_encode_ofp14_port_ethernet_prop(
> + const struct ofputil_phy_port *pp,
> + struct ofp14_port_desc_prop_ethernet *eth)
> +{
> + eth->curr = netdev_port_features_to_ofp11(pp->curr);
> + eth->advertised = netdev_port_features_to_ofp11(pp->advertised);
> + eth->supported = netdev_port_features_to_ofp11(pp->supported);
> + eth->peer = netdev_port_features_to_ofp11(pp->peer);
> + eth->curr_speed = htonl(pp->curr_speed);
> + eth->max_speed = htonl(pp->max_speed);
> +}
> +
> +static void
> +ofputil_put_ofp14_port(const struct ofputil_phy_port *pp, struct ofpbuf
> *b)
> +{
> + struct ofp14_port *op;
> + struct ofp14_port_desc_prop_ethernet *eth;
> +
> + ofpbuf_prealloc_tailroom(b, sizeof *op + sizeof *eth);
> +
> + op = ofpbuf_put_zeros(b, sizeof *op);
> + op->port_no = ofputil_port_to_ofp11(pp->port_no);
> + op->length = htons(sizeof *op + sizeof *eth);
> + op->hw_addr = pp->hw_addr;
> + ovs_strlcpy_arrays(op->name, pp->name);
> + op->config = htonl(pp->config & OFPPC11_ALL);
> + op->state = htonl(pp->state & OFPPS11_ALL);
> +
> + eth = ofpprop_put_zeros(b, OFPPDPT14_ETHERNET, sizeof *eth);
> + ofputil_encode_ofp14_port_ethernet_prop(pp, eth);
> +}
> +
> +static void
> +ofputil_put_ofp16_port(const struct ofputil_phy_port *pp, struct ofpbuf
> *b)
> +{
> + struct ofp16_port *op;
> + struct ofp14_port_desc_prop_ethernet *eth;
> +
> + ofpbuf_prealloc_tailroom(b, sizeof *op + sizeof *eth);
> +
> + op = ofpbuf_put_zeros(b, sizeof *op);
> + op->port_no = ofputil_port_to_ofp11(pp->port_no);
> + op->length = htons(sizeof *op + sizeof *eth);
> + op->hw_addr = pp->hw_addr;
> + op->hw_addr64 = pp->hw_addr64;
> + ovs_strlcpy_arrays(op->name, pp->name);
> + op->config = htonl(pp->config & OFPPC11_ALL);
> + op->state = htonl(pp->state & OFPPS11_ALL);
> +
> + eth = ofpprop_put_zeros(b, OFPPDPT14_ETHERNET, sizeof *eth);
> + ofputil_encode_ofp14_port_ethernet_prop(pp, eth);
> +}
> +
> +void
> +ofputil_put_phy_port(enum ofp_version ofp_version,
> + const struct ofputil_phy_port *pp, struct ofpbuf *b)
> +{
> + switch (ofp_version) {
> + case OFP10_VERSION: {
> + struct ofp10_phy_port *opp = ofpbuf_put_uninit(b, sizeof *opp);
> + ofputil_encode_ofp10_phy_port(pp, opp);
> + break;
> + }
> +
> + case OFP11_VERSION:
> + case OFP12_VERSION:
> + case OFP13_VERSION: {
> + struct ofp11_port *op = ofpbuf_put_uninit(b, sizeof *op);
> + ofputil_encode_ofp11_port(pp, op);
> + break;
> + }
> +
> + case OFP14_VERSION:
> + case OFP15_VERSION:
> + ofputil_put_ofp14_port(pp, b);
> + break;
> + case OFP16_VERSION:
> + ofputil_put_ofp16_port(pp, b);
> + break;
> +
> + default:
> + OVS_NOT_REACHED();
> + }
> +}
> +
> +enum ofperr
> +ofputil_decode_port_desc_stats_request(const struct ofp_header *request,
> + ofp_port_t *port)
> +{
> + struct ofpbuf b = ofpbuf_const_initializer(request,
> + ntohs(request->length));
> + enum ofpraw raw = ofpraw_pull_assert(&b);
> + if (raw == OFPRAW_OFPST10_PORT_DESC_REQUEST) {
> + *port = OFPP_ANY;
> + return 0;
> + } else if (raw == OFPRAW_OFPST15_PORT_DESC_REQUEST) {
> + ovs_be32 *ofp11_port;
> +
> + ofp11_port = ofpbuf_pull(&b, sizeof *ofp11_port);
> + return ofputil_port_from_ofp11(*ofp11_port, port);
> + } else {
> + OVS_NOT_REACHED();
> + }
> +}
> +
> +struct ofpbuf *
> +ofputil_encode_port_desc_stats_request(enum ofp_version ofp_version,
> + ofp_port_t port)
> +{
> + struct ofpbuf *request;
> +
> + switch (ofp_version) {
> + case OFP10_VERSION:
> + case OFP11_VERSION:
> + case OFP12_VERSION:
> + case OFP13_VERSION:
> + case OFP14_VERSION:
> + request = ofpraw_alloc(OFPRAW_OFPST10_PORT_DESC_REQUEST,
> + ofp_version, 0);
> + break;
> + case OFP15_VERSION:
> + case OFP16_VERSION:{
> + struct ofp15_port_desc_request *req;
> + request = ofpraw_alloc(OFPRAW_OFPST15_PORT_DESC_REQUEST,
> + ofp_version, 0);
> + req = ofpbuf_put_zeros(request, sizeof *req);
> + req->port_no = ofputil_port_to_ofp11(port);
> + break;
> + }
> + default:
> + OVS_NOT_REACHED();
> + }
> +
> + return request;
> +}
> +
> +void
> +ofputil_append_port_desc_stats_reply(const struct ofputil_phy_port *pp,
> + struct ovs_list *replies)
> +{
> + struct ofpbuf *reply = ofpbuf_from_list(ovs_list_back(replies));
> + size_t start_ofs = reply->size;
> +
> + ofputil_put_phy_port(ofpmp_version(replies), pp, reply);
> + ofpmp_postappend(replies, start_ofs);
> +}
> +
> +/* Given a buffer 'b' that contains an array of OpenFlow ports of type
> + * 'ofp_version', tries to pull the first element from the array. If
> + * successful, initializes '*pp' with an abstract representation of the
> + * port and returns 0. If no ports remain to be decoded, returns EOF.
> + * On an error, returns a positive OFPERR_* value. */
> +int
> +ofputil_pull_phy_port(enum ofp_version ofp_version, struct ofpbuf *b,
> + struct ofputil_phy_port *pp)
> +{
> + memset(pp, 0, sizeof *pp);
> +
> + switch (ofp_version) {
> + case OFP10_VERSION: {
> + const struct ofp10_phy_port *opp = ofpbuf_try_pull(b, sizeof
> *opp);
> + return opp ? ofputil_decode_ofp10_phy_port(pp, opp) : EOF;
> + }
> + case OFP11_VERSION:
> + case OFP12_VERSION:
> + case OFP13_VERSION: {
> + const struct ofp11_port *op = ofpbuf_try_pull(b, sizeof *op);
> + return op ? ofputil_decode_ofp11_port(pp, op) : EOF;
> + }
> + case OFP14_VERSION:
> + case OFP15_VERSION:
> + return b->size ? ofputil_pull_ofp14_port(pp, b) : EOF;
> + case OFP16_VERSION:
> + return b->size ? ofputil_pull_ofp16_port(pp, b) : EOF;
> + default:
> + OVS_NOT_REACHED();
> + }
> +}
> +
> +/* ofputil_port_status */
> +
> +/* Decodes the OpenFlow "port status" message in '*ops' into an abstract
> form
> + * in '*ps'. Returns 0 if successful, otherwise an OFPERR_* value. */
> +enum ofperr
> +ofputil_decode_port_status(const struct ofp_header *oh,
> + struct ofputil_port_status *ps)
> +{
> + struct ofpbuf b = ofpbuf_const_initializer(oh, ntohs(oh->length));
> + ofpraw_pull_assert(&b);
> +
> + const struct ofp_port_status *ops = ofpbuf_pull(&b, sizeof *ops);
> + if (ops->reason != OFPPR_ADD &&
> + ops->reason != OFPPR_DELETE &&
> + ops->reason != OFPPR_MODIFY) {
> + return OFPERR_NXBRC_BAD_REASON;
> + }
> + ps->reason = ops->reason;
> +
> + int retval = ofputil_pull_phy_port(oh->version, &b, &ps->desc);
> + ovs_assert(retval != EOF);
> + return retval;
> +}
> +
> +/* Converts the abstract form of a "port status" message in '*ps' into an
> + * OpenFlow message suitable for 'protocol', and returns that encoded
> form in
> + * a buffer owned by the caller. */
> +struct ofpbuf *
> +ofputil_encode_port_status(const struct ofputil_port_status *ps,
> + enum ofputil_protocol protocol)
> +{
> + struct ofp_port_status *ops;
> + struct ofpbuf *b;
> + enum ofp_version version;
> + enum ofpraw raw;
> +
> + version = ofputil_protocol_to_ofp_version(protocol);
> + switch (version) {
> + case OFP10_VERSION:
> + raw = OFPRAW_OFPT10_PORT_STATUS;
> + break;
> +
> + case OFP11_VERSION:
> + case OFP12_VERSION:
> + case OFP13_VERSION:
> + raw = OFPRAW_OFPT11_PORT_STATUS;
> + break;
> +
> + case OFP14_VERSION:
> + case OFP15_VERSION:
> + raw = OFPRAW_OFPT14_PORT_STATUS;
> + break;
> +
> + case OFP16_VERSION:
> + raw = OFPRAW_OFPT16_PORT_STATUS;
> + break;
> +
> + default:
> + OVS_NOT_REACHED();
> + }
> +
> + b = ofpraw_alloc_xid(raw, version, htonl(0), 0);
> + ops = ofpbuf_put_zeros(b, sizeof *ops);
> + ops->reason = ps->reason;
> + ofputil_put_phy_port(version, &ps->desc, b);
> + ofpmsg_update_length(b);
> + return b;
> +}
> +
> +/* ofputil_port_mod */
> +
> +static enum ofperr
> +parse_port_mod_ethernet_property(struct ofpbuf *property,
> + struct ofputil_port_mod *pm)
> +{
> + ovs_be32 advertise;
> + enum ofperr error;
> +
> + error = ofpprop_parse_be32(property, &advertise);
> + if (!error) {
> + pm->advertise = netdev_port_features_from_ofp11(advertise);
> + }
> + return error;
> +}
> +
> +static enum ofperr
> +ofputil_decode_ofp10_port_mod(const struct ofp10_port_mod *opm,
> + struct ofputil_port_mod *pm)
> +{
> + pm->port_no = u16_to_ofp(ntohs(opm->port_no));
> + pm->hw_addr = opm->hw_addr;
> + pm->config = ntohl(opm->config) & OFPPC10_ALL;
> + pm->mask = ntohl(opm->mask) & OFPPC10_ALL;
> + pm->advertise = netdev_port_features_from_ofp10(opm->advertise);
> + return 0;
> +}
> +
> +static enum ofperr
> +ofputil_decode_ofp11_port_mod(const struct ofp11_port_mod *opm,
> + struct ofputil_port_mod *pm)
> +{
> + enum ofperr error;
> +
> + error = ofputil_port_from_ofp11(opm->port_no, &pm->port_no);
> + if (error) {
> + return error;
> + }
> +
> + pm->hw_addr = opm->hw_addr;
> + pm->config = ntohl(opm->config) & OFPPC11_ALL;
> + pm->mask = ntohl(opm->mask) & OFPPC11_ALL;
> + pm->advertise = netdev_port_features_from_ofp11(opm->advertise);
> +
> + return 0;
> +}
> +
> +static enum ofperr
> +ofputil_decode_ofp14_port_mod_properties(struct ofpbuf *b, bool loose,
> + struct ofputil_port_mod *pm)
> +{
> + while (b->size > 0) {
> + struct ofpbuf property;
> + enum ofperr error;
> + uint64_t type;
> +
> + error = ofpprop_pull(b, &property, &type);
> + if (error) {
> + return error;
> + }
> +
> + switch (type) {
> + case OFPPMPT14_ETHERNET:
> + error = parse_port_mod_ethernet_property(&property, pm);
> + break;
> +
> + default:
> + error = OFPPROP_UNKNOWN(loose, "port_mod", type);
> + break;
> + }
> +
> + if (error) {
> + return error;
> + }
> + }
> + return 0;
> +}
> +
> +static enum ofperr
> +ofputil_decode_ofp14_port_mod(struct ofpbuf *b, bool loose,
> + struct ofputil_port_mod *pm)
> +{
> + const struct ofp14_port_mod *opm = ofpbuf_pull(b, sizeof *opm);
> + enum ofperr error = ofputil_port_from_ofp11(opm->port_no,
> &pm->port_no);
> + if (error) {
> + return error;
> + }
> +
> + pm->hw_addr = opm->hw_addr;
> + pm->config = ntohl(opm->config) & OFPPC11_ALL;
> + pm->mask = ntohl(opm->mask) & OFPPC11_ALL;
> +
> + return ofputil_decode_ofp14_port_mod_properties(b, loose, pm);
> +}
> +
> +static enum ofperr
> +ofputil_decode_ofp16_port_mod(struct ofpbuf *b, bool loose,
> + struct ofputil_port_mod *pm)
> +{
> + const struct ofp16_port_mod *opm = ofpbuf_pull(b, sizeof *opm);
> + enum ofperr error = ofputil_port_from_ofp11(opm->port_no,
> &pm->port_no);
> + if (error) {
> + return error;
> + }
> +
> + pm->hw_addr = opm->hw_addr;
> + pm->hw_addr64 = opm->hw_addr64;
> + pm->config = ntohl(opm->config) & OFPPC11_ALL;
> + pm->mask = ntohl(opm->mask) & OFPPC11_ALL;
> +
> + return ofputil_decode_ofp14_port_mod_properties(b, loose, pm);
> +}
> +
> +/* Decodes the OpenFlow "port mod" message in '*oh' into an abstract form
> in
> + * '*pm'. Returns 0 if successful, otherwise an OFPERR_* value. */
> +enum ofperr
> +ofputil_decode_port_mod(const struct ofp_header *oh,
> + struct ofputil_port_mod *pm, bool loose)
> +{
> + memset(pm, 0, sizeof *pm);
> +
> + struct ofpbuf b = ofpbuf_const_initializer(oh, ntohs(oh->length));
> + enum ofpraw raw = ofpraw_pull_assert(&b);
> +
> + enum ofperr error;
> + if (raw == OFPRAW_OFPT10_PORT_MOD) {
> + error = ofputil_decode_ofp10_port_mod(b.data, pm);
> + } else if (raw == OFPRAW_OFPT11_PORT_MOD) {
> + error = ofputil_decode_ofp11_port_mod(b.data, pm);
> + } else if (raw == OFPRAW_OFPT14_PORT_MOD) {
> + error = ofputil_decode_ofp14_port_mod(&b, loose, pm);
> + } else if (raw == OFPRAW_OFPT16_PORT_MOD) {
> + error = ofputil_decode_ofp16_port_mod(&b, loose, pm);
> + } else {
> + error = OFPERR_OFPBRC_BAD_TYPE;
> + }
> +
> + pm->config &= pm->mask;
> + return error;
> +}
> +
> +/* Converts the abstract form of a "port mod" message in '*pm' into an
> OpenFlow
> + * message suitable for 'protocol', and returns that encoded form in a
> buffer
> + * owned by the caller. */
> +struct ofpbuf *
> +ofputil_encode_port_mod(const struct ofputil_port_mod *pm,
> + enum ofputil_protocol protocol)
> +{
> + enum ofp_version ofp_version = ofputil_protocol_to_ofp_
> version(protocol);
> + struct ofpbuf *b;
> +
> + switch (ofp_version) {
> + case OFP10_VERSION: {
> + struct ofp10_port_mod *opm;
> +
> + b = ofpraw_alloc(OFPRAW_OFPT10_PORT_MOD, ofp_version, 0);
> + opm = ofpbuf_put_zeros(b, sizeof *opm);
> + opm->port_no = htons(ofp_to_u16(pm->port_no));
> + opm->hw_addr = pm->hw_addr;
> + opm->config = htonl(pm->config & OFPPC10_ALL);
> + opm->mask = htonl(pm->mask & OFPPC10_ALL);
> + opm->advertise = netdev_port_features_to_ofp10(pm->advertise);
> + break;
> + }
> +
> + case OFP11_VERSION:
> + case OFP12_VERSION:
> + case OFP13_VERSION: {
> + struct ofp11_port_mod *opm;
> +
> + b = ofpraw_alloc(OFPRAW_OFPT11_PORT_MOD, ofp_version, 0);
> + opm = ofpbuf_put_zeros(b, sizeof *opm);
> + opm->port_no = ofputil_port_to_ofp11(pm->port_no);
> + opm->hw_addr = pm->hw_addr;
> + opm->config = htonl(pm->config & OFPPC11_ALL);
> + opm->mask = htonl(pm->mask & OFPPC11_ALL);
> + opm->advertise = netdev_port_features_to_ofp11(pm->advertise);
> + break;
> + }
> + case OFP14_VERSION:
> + case OFP15_VERSION: {
> + struct ofp14_port_mod *opm;
> +
> + b = ofpraw_alloc(OFPRAW_OFPT14_PORT_MOD, ofp_version, 0);
> + opm = ofpbuf_put_zeros(b, sizeof *opm);
> + opm->port_no = ofputil_port_to_ofp11(pm->port_no);
> + opm->hw_addr = pm->hw_addr;
> + opm->config = htonl(pm->config & OFPPC11_ALL);
> + opm->mask = htonl(pm->mask & OFPPC11_ALL);
> +
> + if (pm->advertise) {
> + ofpprop_put_be32(b, OFPPMPT14_ETHERNET,
> + netdev_port_features_to_ofp11(
> pm->advertise));
> + }
> + break;
> + }
> + case OFP16_VERSION: {
> + struct ofp16_port_mod *opm;
> +
> + b = ofpraw_alloc(OFPRAW_OFPT16_PORT_MOD, ofp_version, 0);
> + opm = ofpbuf_put_zeros(b, sizeof *opm);
> + opm->port_no = ofputil_port_to_ofp11(pm->port_no);
> + opm->hw_addr = pm->hw_addr;
> + opm->hw_addr64 = pm->hw_addr64;
> + opm->config = htonl(pm->config & OFPPC11_ALL);
> + opm->mask = htonl(pm->mask & OFPPC11_ALL);
> +
> + if (pm->advertise) {
> + ofpprop_put_be32(b, OFPPMPT14_ETHERNET,
> + netdev_port_features_to_ofp11(
> pm->advertise));
> + }
> + break;
> + }
> + default:
> + OVS_NOT_REACHED();
> + }
> +
> + return b;
> +}
> +
> +/* Encode a dump ports request for 'port', the encoded message
> + * will be for OpenFlow version 'ofp_version'. Returns message
> + * as a struct ofpbuf. Returns encoded message on success, NULL on error
> */
> +struct ofpbuf *
> +ofputil_encode_dump_ports_request(enum ofp_version ofp_version,
> ofp_port_t port)
> +{
> + struct ofpbuf *request;
> +
> + switch (ofp_version) {
> + case OFP10_VERSION: {
> + struct ofp10_port_stats_request *req;
> + request = ofpraw_alloc(OFPRAW_OFPST10_PORT_REQUEST, ofp_version,
> 0);
> + req = ofpbuf_put_zeros(request, sizeof *req);
> + req->port_no = htons(ofp_to_u16(port));
> + break;
> + }
> + case OFP11_VERSION:
> + case OFP12_VERSION:
> + case OFP13_VERSION:
> + case OFP14_VERSION:
> + case OFP15_VERSION:
> + case OFP16_VERSION: {
> + struct ofp11_port_stats_request *req;
> + request = ofpraw_alloc(OFPRAW_OFPST11_PORT_REQUEST, ofp_version,
> 0);
> + req = ofpbuf_put_zeros(request, sizeof *req);
> + req->port_no = ofputil_port_to_ofp11(port);
> + break;
> + }
> + default:
> + OVS_NOT_REACHED();
> + }
> +
> + return request;
> +}
> +
> +static void
> +ofputil_port_stats_to_ofp10(const struct ofputil_port_stats *ops,
> + struct ofp10_port_stats *ps10)
> +{
> + ps10->port_no = htons(ofp_to_u16(ops->port_no));
> + memset(ps10->pad, 0, sizeof ps10->pad);
> + put_32aligned_be64(&ps10->rx_packets, htonll(ops->stats.rx_packets));
> + put_32aligned_be64(&ps10->tx_packets, htonll(ops->stats.tx_packets));
> + put_32aligned_be64(&ps10->rx_bytes, htonll(ops->stats.rx_bytes));
> + put_32aligned_be64(&ps10->tx_bytes, htonll(ops->stats.tx_bytes));
> + put_32aligned_be64(&ps10->rx_dropped, htonll(ops->stats.rx_dropped));
> + put_32aligned_be64(&ps10->tx_dropped, htonll(ops->stats.tx_dropped));
> + put_32aligned_be64(&ps10->rx_errors, htonll(ops->stats.rx_errors));
> + put_32aligned_be64(&ps10->tx_errors, htonll(ops->stats.tx_errors));
> + put_32aligned_be64(&ps10->rx_frame_err, htonll(ops->stats.rx_frame_
> errors));
> + put_32aligned_be64(&ps10->rx_over_err, htonll(ops->stats.rx_over_
> errors));
> + put_32aligned_be64(&ps10->rx_crc_err, htonll(ops->stats.rx_crc_
> errors));
> + put_32aligned_be64(&ps10->collisions, htonll(ops->stats.collisions));
> +}
> +
> +static void
> +ofputil_port_stats_to_ofp11(const struct ofputil_port_stats *ops,
> + struct ofp11_port_stats *ps11)
> +{
> + ps11->port_no = ofputil_port_to_ofp11(ops->port_no);
> + memset(ps11->pad, 0, sizeof ps11->pad);
> + ps11->rx_packets = htonll(ops->stats.rx_packets);
> + ps11->tx_packets = htonll(ops->stats.tx_packets);
> + ps11->rx_bytes = htonll(ops->stats.rx_bytes);
> + ps11->tx_bytes = htonll(ops->stats.tx_bytes);
> + ps11->rx_dropped = htonll(ops->stats.rx_dropped);
> + ps11->tx_dropped = htonll(ops->stats.tx_dropped);
> + ps11->rx_errors = htonll(ops->stats.rx_errors);
> + ps11->tx_errors = htonll(ops->stats.tx_errors);
> + ps11->rx_frame_err = htonll(ops->stats.rx_frame_errors);
> + ps11->rx_over_err = htonll(ops->stats.rx_over_errors);
> + ps11->rx_crc_err = htonll(ops->stats.rx_crc_errors);
> + ps11->collisions = htonll(ops->stats.collisions);
> +}
> +
> +static void
> +ofputil_port_stats_to_ofp13(const struct ofputil_port_stats *ops,
> + struct ofp13_port_stats *ps13)
> +{
> + ofputil_port_stats_to_ofp11(ops, &ps13->ps);
> + ps13->duration_sec = htonl(ops->duration_sec);
> + ps13->duration_nsec = htonl(ops->duration_nsec);
> +}
> +
> +static void
> +ofputil_append_ofp14_port_stats(const struct ofputil_port_stats *ops,
> + struct ovs_list *replies)
> +{
> + struct ofp14_port_stats_prop_ethernet *eth;
> + struct intel_port_stats_rfc2819 *stats_rfc2819;
> + struct intel_port_custom_stats *stats_custom;
> + struct ofp14_port_stats *ps14;
> + struct ofpbuf *reply;
> + uint16_t i;
> + ovs_be64 counter_value;
> + size_t custom_stats_start, start_ofs;
> +
> + reply = ofpbuf_from_list(ovs_list_back(replies));
> + start_ofs = reply->size;
> +
> + ps14 = ofpbuf_put_uninit(reply, sizeof *ps14);
> +
> + memset(ps14->pad, 0, sizeof ps14->pad);
> + ps14->port_no = ofputil_port_to_ofp11(ops->port_no);
> + ps14->duration_sec = htonl(ops->duration_sec);
> + ps14->duration_nsec = htonl(ops->duration_nsec);
> + ps14->rx_packets = htonll(ops->stats.rx_packets);
> + ps14->tx_packets = htonll(ops->stats.tx_packets);
> + ps14->rx_bytes = htonll(ops->stats.rx_bytes);
> + ps14->tx_bytes = htonll(ops->stats.tx_bytes);
> + ps14->rx_dropped = htonll(ops->stats.rx_dropped);
> + ps14->tx_dropped = htonll(ops->stats.tx_dropped);
> + ps14->rx_errors = htonll(ops->stats.rx_errors);
> + ps14->tx_errors = htonll(ops->stats.tx_errors);
> +
> + eth = ofpprop_put_zeros(reply, OFPPSPT14_ETHERNET, sizeof *eth);
> + eth->rx_frame_err = htonll(ops->stats.rx_frame_errors);
> + eth->rx_over_err = htonll(ops->stats.rx_over_errors);
> + eth->rx_crc_err = htonll(ops->stats.rx_crc_errors);
> + eth->collisions = htonll(ops->stats.collisions);
> +
> + uint64_t prop_type_stats = OFPPROP_EXP(INTEL_VENDOR_ID,
> + INTEL_PORT_STATS_RFC2819);
> +
> + stats_rfc2819 = ofpprop_put_zeros(reply, prop_type_stats,
> + sizeof *stats_rfc2819);
> +
> + memset(stats_rfc2819->pad, 0, sizeof stats_rfc2819->pad);
> + stats_rfc2819->rx_1_to_64_packets = htonll(ops->stats.rx_1_to_64_
> packets);
> + stats_rfc2819->rx_65_to_127_packets =
> + htonll(ops->stats.rx_65_to_127_packets);
> + stats_rfc2819->rx_128_to_255_packets =
> + htonll(ops->stats.rx_128_to_255_packets);
> + stats_rfc2819->rx_256_to_511_packets =
> + htonll(ops->stats.rx_256_to_511_packets);
> + stats_rfc2819->rx_512_to_1023_packets =
> + htonll(ops->stats.rx_512_to_1023_packets);
> + stats_rfc2819->rx_1024_to_1522_packets =
> + htonll(ops->stats.rx_1024_to_1522_packets);
> + stats_rfc2819->rx_1523_to_max_packets =
> + htonll(ops->stats.rx_1523_to_max_packets);
> +
> + stats_rfc2819->tx_1_to_64_packets = htonll(ops->stats.tx_1_to_64_
> packets);
> + stats_rfc2819->tx_65_to_127_packets =
> + htonll(ops->stats.tx_65_to_127_packets);
> + stats_rfc2819->tx_128_to_255_packets =
> + htonll(ops->stats.tx_128_to_255_packets);
> + stats_rfc2819->tx_256_to_511_packets =
> + htonll(ops->stats.tx_256_to_511_packets);
> + stats_rfc2819->tx_512_to_1023_packets =
> + htonll(ops->stats.tx_512_to_1023_packets);
> + stats_rfc2819->tx_1024_to_1522_packets =
> + htonll(ops->stats.tx_1024_to_1522_packets);
> + stats_rfc2819->tx_1523_to_max_packets =
> + htonll(ops->stats.tx_1523_to_max_packets);
> +
> + stats_rfc2819->tx_multicast_packets =
> + htonll(ops->stats.tx_multicast_packets);
> + stats_rfc2819->rx_broadcast_packets =
> + htonll(ops->stats.rx_broadcast_packets);
> + stats_rfc2819->tx_broadcast_packets =
> + htonll(ops->stats.tx_broadcast_packets);
> + stats_rfc2819->rx_undersized_errors =
> + htonll(ops->stats.rx_undersized_errors);
> + stats_rfc2819->rx_oversize_errors =
> + htonll(ops->stats.rx_oversize_errors);
> + stats_rfc2819->rx_fragmented_errors =
> + htonll(ops->stats.rx_fragmented_errors);
> + stats_rfc2819->rx_jabber_errors =
> + htonll(ops->stats.rx_jabber_errors);
> +
> + if (ops->custom_stats.counters && ops->custom_stats.size) {
> + custom_stats_start = reply->size;
> +
> + uint64_t prop_type_custom = OFPPROP_EXP(INTEL_VENDOR_ID,
> + INTEL_PORT_STATS_CUSTOM);
> +
> + stats_custom = ofpprop_put_zeros(reply, prop_type_custom,
> + sizeof *stats_custom);
> +
> + stats_custom->stats_array_size = htons(ops->custom_stats.size);
> +
> + for (i = 0; i < ops->custom_stats.size; i++) {
> + uint8_t counter_size = strlen(ops->custom_stats.
> counters[i].name);
> + /* Counter name size */
> + ofpbuf_put(reply, &counter_size, sizeof(counter_size));
> + /* Counter name */
> + ofpbuf_put(reply, ops->custom_stats.counters[i].name,
> + counter_size);
> + /* Counter value */
> + counter_value = htonll(ops->custom_stats.counters[i].value);
> + ofpbuf_put(reply, &counter_value,
> + sizeof(ops->custom_stats.counters[i].value));
> + }
> +
> + ofpprop_end(reply, custom_stats_start);
> + }
> +
> + ps14 = ofpbuf_at_assert(reply, start_ofs, sizeof *ps14);
> + ps14->length = htons(reply->size - start_ofs);
> +
> + ofpmp_postappend(replies, start_ofs);
> +}
> +
> +/* Encode a ports stat for 'ops' and append it to 'replies'. */
> +void
> +ofputil_append_port_stat(struct ovs_list *replies,
> + const struct ofputil_port_stats *ops)
> +{
> + switch (ofpmp_version(replies)) {
> + case OFP13_VERSION: {
> + struct ofp13_port_stats *reply = ofpmp_append(replies, sizeof
> *reply);
> + ofputil_port_stats_to_ofp13(ops, reply);
> + break;
> + }
> + case OFP12_VERSION:
> + case OFP11_VERSION: {
> + struct ofp11_port_stats *reply = ofpmp_append(replies, sizeof
> *reply);
> + ofputil_port_stats_to_ofp11(ops, reply);
> + break;
> + }
> +
> + case OFP10_VERSION: {
> + struct ofp10_port_stats *reply = ofpmp_append(replies, sizeof
> *reply);
> + ofputil_port_stats_to_ofp10(ops, reply);
> + break;
> + }
> +
> + case OFP14_VERSION:
> + case OFP15_VERSION:
> + case OFP16_VERSION:
> + ofputil_append_ofp14_port_stats(ops, replies);
> + break;
> +
> + default:
> + OVS_NOT_REACHED();
> + }
> +}
> +
> +static enum ofperr
> +ofputil_port_stats_from_ofp10(struct ofputil_port_stats *ops,
> + const struct ofp10_port_stats *ps10)
> +{
> +
> + ops->port_no = u16_to_ofp(ntohs(ps10->port_no));
> + ops->stats.rx_packets = ntohll(get_32aligned_be64(&
> ps10->rx_packets));
> + ops->stats.tx_packets = ntohll(get_32aligned_be64(&
> ps10->tx_packets));
> + ops->stats.rx_bytes = ntohll(get_32aligned_be64(&ps10->rx_bytes));
> + ops->stats.tx_bytes = ntohll(get_32aligned_be64(&ps10->tx_bytes));
> + ops->stats.rx_dropped = ntohll(get_32aligned_be64(&
> ps10->rx_dropped));
> + ops->stats.tx_dropped = ntohll(get_32aligned_be64(&
> ps10->tx_dropped));
> + ops->stats.rx_errors = ntohll(get_32aligned_be64(&ps10->rx_errors));
> + ops->stats.tx_errors = ntohll(get_32aligned_be64(&ps10->tx_errors));
> + ops->stats.rx_frame_errors =
> + ntohll(get_32aligned_be64(&ps10->rx_frame_err));
> + ops->stats.rx_over_errors = ntohll(get_32aligned_be64(&
> ps10->rx_over_err));
> + ops->stats.rx_crc_errors = ntohll(get_32aligned_be64(&
> ps10->rx_crc_err));
> + ops->stats.collisions = ntohll(get_32aligned_be64(&
> ps10->collisions));
> + ops->duration_sec = ops->duration_nsec = UINT32_MAX;
> +
> + return 0;
> +}
> +
> +static enum ofperr
> +ofputil_port_stats_from_ofp11(struct ofputil_port_stats *ops,
> + const struct ofp11_port_stats *ps11)
> +{
> + enum ofperr error;
> +
> + error = ofputil_port_from_ofp11(ps11->port_no, &ops->port_no);
> + if (error) {
> + return error;
> + }
> +
> + ops->stats.rx_packets = ntohll(ps11->rx_packets);
> + ops->stats.tx_packets = ntohll(ps11->tx_packets);
> + ops->stats.rx_bytes = ntohll(ps11->rx_bytes);
> + ops->stats.tx_bytes = ntohll(ps11->tx_bytes);
> + ops->stats.rx_dropped = ntohll(ps11->rx_dropped);
> + ops->stats.tx_dropped = ntohll(ps11->tx_dropped);
> + ops->stats.rx_errors = ntohll(ps11->rx_errors);
> + ops->stats.tx_errors = ntohll(ps11->tx_errors);
> + ops->stats.rx_frame_errors = ntohll(ps11->rx_frame_err);
> + ops->stats.rx_over_errors = ntohll(ps11->rx_over_err);
> + ops->stats.rx_crc_errors = ntohll(ps11->rx_crc_err);
> + ops->stats.collisions = ntohll(ps11->collisions);
> + ops->duration_sec = ops->duration_nsec = UINT32_MAX;
> +
> + return 0;
> +}
> +
> +static enum ofperr
> +ofputil_port_stats_from_ofp13(struct ofputil_port_stats *ops,
> + const struct ofp13_port_stats *ps13)
> +{
> + enum ofperr error = ofputil_port_stats_from_ofp11(ops, &ps13->ps);
> + if (!error) {
> + ops->duration_sec = ntohl(ps13->duration_sec);
> + ops->duration_nsec = ntohl(ps13->duration_nsec);
> + }
> + return error;
> +}
> +
> +static enum ofperr
> +parse_ofp14_port_stats_ethernet_property(const struct ofpbuf *payload,
> + struct ofputil_port_stats *ops)
> +{
> + const struct ofp14_port_stats_prop_ethernet *eth = payload->data;
> +
> + if (payload->size != sizeof *eth) {
> + return OFPERR_OFPBPC_BAD_LEN;
> + }
> +
> + ops->stats.rx_frame_errors = ntohll(eth->rx_frame_err);
> + ops->stats.rx_over_errors = ntohll(eth->rx_over_err);
> + ops->stats.rx_crc_errors = ntohll(eth->rx_crc_err);
> + ops->stats.collisions = ntohll(eth->collisions);
> +
> + return 0;
> +}
> +
> +static enum ofperr
> +parse_intel_port_stats_rfc2819_property(const struct ofpbuf *payload,
> + struct ofputil_port_stats *ops)
> +{
> + const struct intel_port_stats_rfc2819 *rfc2819 = payload->data;
> +
> + if (payload->size != sizeof *rfc2819) {
> + return OFPERR_OFPBPC_BAD_LEN;
> + }
> + ops->stats.rx_1_to_64_packets = ntohll(rfc2819->rx_1_to_64_packets);
> + ops->stats.rx_65_to_127_packets = ntohll(rfc2819->rx_65_to_127_
> packets);
> + ops->stats.rx_128_to_255_packets = ntohll(rfc2819->rx_128_to_255_
> packets);
> + ops->stats.rx_256_to_511_packets = ntohll(rfc2819->rx_256_to_511_
> packets);
> + ops->stats.rx_512_to_1023_packets =
> + ntohll(rfc2819->rx_512_to_1023_packets);
> + ops->stats.rx_1024_to_1522_packets =
> + ntohll(rfc2819->rx_1024_to_1522_packets);
> + ops->stats.rx_1523_to_max_packets =
> + ntohll(rfc2819->rx_1523_to_max_packets);
> +
> + ops->stats.tx_1_to_64_packets = ntohll(rfc2819->tx_1_to_64_packets);
> + ops->stats.tx_65_to_127_packets = ntohll(rfc2819->tx_65_to_127_
> packets);
> + ops->stats.tx_128_to_255_packets = ntohll(rfc2819->tx_128_to_255_
> packets);
> + ops->stats.tx_256_to_511_packets = ntohll(rfc2819->tx_256_to_511_
> packets);
> + ops->stats.tx_512_to_1023_packets =
> + ntohll(rfc2819->tx_512_to_1023_packets);
> + ops->stats.tx_1024_to_1522_packets =
> + ntohll(rfc2819->tx_1024_to_1522_packets);
> + ops->stats.tx_1523_to_max_packets =
> + ntohll(rfc2819->tx_1523_to_max_packets);
> +
> + ops->stats.tx_multicast_packets = ntohll(rfc2819->tx_multicast_
> packets);
> + ops->stats.rx_broadcast_packets = ntohll(rfc2819->rx_broadcast_
> packets);
> + ops->stats.tx_broadcast_packets = ntohll(rfc2819->tx_broadcast_
> packets);
> + ops->stats.rx_undersized_errors = ntohll(rfc2819->rx_undersized_
> errors);
> +
> + ops->stats.rx_oversize_errors = ntohll(rfc2819->rx_oversize_errors);
> + ops->stats.rx_fragmented_errors = ntohll(rfc2819->rx_fragmented_
> errors);
> + ops->stats.rx_jabber_errors = ntohll(rfc2819->rx_jabber_errors);
> +
> + return 0;
> +}
> +
> +static enum ofperr
> +parse_intel_port_custom_property(const struct ofpbuf *payload,
> + struct ofputil_port_stats *ops)
> +{
> + const struct intel_port_custom_stats *custom_stats = payload->data;
> +
> + ops->custom_stats.size = ntohs(custom_stats->stats_array_size);
> +
> + ops->custom_stats.counters = xcalloc(ops->custom_stats.size,
> + sizeof
> *ops->custom_stats.counters);
> +
> + uint16_t msg_size = ntohs(custom_stats->length);
> + uint16_t current_len = sizeof *custom_stats;
> + uint8_t *current = (uint8_t *)payload->data + current_len;
> + uint8_t string_size = 0;
> + uint8_t value_size = 0;
> + ovs_be64 counter_value = 0;
> +
> + for (int i = 0; i < ops->custom_stats.size; i++) {
> + current_len += string_size + value_size;
> + current += string_size + value_size;
> +
> + value_size = sizeof(uint64_t);
> + /* Counter name size */
> + string_size = *current;
> +
> + /* Buffer overrun check */
> + if (current_len + string_size + value_size > msg_size) {
> + VLOG_WARN_RL(&rl, "Custom statistics buffer overrun! "
> + "Further message parsing is aborted.");
> + break;
> + }
> +
> + current++;
> + current_len++;
> +
> + /* Counter name. */
> + struct netdev_custom_counter *c = &ops->custom_stats.counters[i];
> + size_t len = MIN(string_size, sizeof c->name - 1);
> + memcpy(c->name, current, len);
> + c->name[len] = '\0';
> + memcpy(&counter_value, current + string_size, value_size);
> +
> + /* Counter value. */
> + c->value = ntohll(counter_value);
> + }
> +
> + return 0;
> +}
> +
> +static enum ofperr
> +parse_intel_port_stats_property(const struct ofpbuf *payload,
> + uint32_t exp_type,
> + struct ofputil_port_stats *ops)
> +{
> + enum ofperr error;
> +
> + switch (exp_type) {
> + case INTEL_PORT_STATS_RFC2819:
> + error = parse_intel_port_stats_rfc2819_property(payload, ops);
> + break;
> + case INTEL_PORT_STATS_CUSTOM:
> + error = parse_intel_port_custom_property(payload, ops);
> + break;
> + default:
> + error = OFPERR_OFPBPC_BAD_EXP_TYPE;
> + break;
> + }
> +
> + return error;
> +}
> +
> +static enum ofperr
> +ofputil_pull_ofp14_port_stats(struct ofputil_port_stats *ops,
> + struct ofpbuf *msg)
> +{
> + const struct ofp14_port_stats *ps14 = ofpbuf_try_pull(msg, sizeof
> *ps14);
> + if (!ps14) {
> + return OFPERR_OFPBRC_BAD_LEN;
> + }
> +
> + size_t len = ntohs(ps14->length);
> + if (len < sizeof *ps14 || len - sizeof *ps14 > msg->size) {
> + return OFPERR_OFPBRC_BAD_LEN;
> + }
> + len -= sizeof *ps14;
> +
> + enum ofperr error = ofputil_port_from_ofp11(ps14->port_no,
> &ops->port_no);
> + if (error) {
> + return error;
> + }
> +
> + ops->duration_sec = ntohl(ps14->duration_sec);
> + ops->duration_nsec = ntohl(ps14->duration_nsec);
> + ops->stats.rx_packets = ntohll(ps14->rx_packets);
> + ops->stats.tx_packets = ntohll(ps14->tx_packets);
> + ops->stats.rx_bytes = ntohll(ps14->rx_bytes);
> + ops->stats.tx_bytes = ntohll(ps14->tx_bytes);
> + ops->stats.rx_dropped = ntohll(ps14->rx_dropped);
> + ops->stats.tx_dropped = ntohll(ps14->tx_dropped);
> + ops->stats.rx_errors = ntohll(ps14->rx_errors);
> + ops->stats.tx_errors = ntohll(ps14->tx_errors);
> +
> +
> + struct ofpbuf properties = ofpbuf_const_initializer(ofpbuf_pull(msg,
> len),
> + len);
> + while (properties.size > 0) {
> + struct ofpbuf payload;
> + uint64_t type = 0;
> +
> + error = ofpprop_pull(&properties, &payload, &type);
> + if (error) {
> + return error;
> + }
> + switch (type) {
> + case OFPPSPT14_ETHERNET:
> + error = parse_ofp14_port_stats_ethernet_property(&payload,
> ops);
> + break;
> + case OFPPROP_EXP(INTEL_VENDOR_ID, INTEL_PORT_STATS_RFC2819):
> + error = parse_intel_port_stats_property(&payload,
> +
> INTEL_PORT_STATS_RFC2819,
> + ops);
> + break;
> + case OFPPROP_EXP(INTEL_VENDOR_ID, INTEL_PORT_STATS_CUSTOM):
> + error = parse_intel_port_stats_property(&payload,
> +
> INTEL_PORT_STATS_CUSTOM,
> + ops);
> + break;
> + default:
> + error = OFPPROP_UNKNOWN(true, "port stats", type);
> + break;
> + }
> +
> + if (error) {
> + return error;
> + }
> + }
> +
> + return 0;
> +}
> +
> +/* Returns the number of port stats elements in OFPTYPE_PORT_STATS_REPLY
> + * message 'oh'. */
> +size_t
> +ofputil_count_port_stats(const struct ofp_header *oh)
> +{
> + struct ofpbuf b = ofpbuf_const_initializer(oh, ntohs(oh->length));
> + ofpraw_pull_assert(&b);
> +
> + for (size_t n = 0; ; n++) {
> + struct ofputil_port_stats ps;
> + if (ofputil_decode_port_stats(&ps, &b)) {
> + return n;
> + }
> + }
> +}
> +
> +/* Converts an OFPST_PORT_STATS reply in 'msg' into an abstract
> + * ofputil_port_stats in 'ps'.
> + *
> + * Multiple OFPST_PORT_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_port_stats(struct ofputil_port_stats *ps, struct ofpbuf
> *msg)
> +{
> + enum ofperr error;
> + enum ofpraw raw;
> +
> + memset(&(ps->stats), 0xFF, sizeof (ps->stats));
> + memset(&(ps->custom_stats), 0, sizeof (ps->custom_stats));
> +
> + 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_OFPST14_PORT_REPLY) {
> + return ofputil_pull_ofp14_port_stats(ps, msg);
> + } else if (raw == OFPRAW_OFPST13_PORT_REPLY) {
> + const struct ofp13_port_stats *ps13;
> + ps13 = ofpbuf_try_pull(msg, sizeof *ps13);
> + if (!ps13) {
> + goto bad_len;
> + }
> + return ofputil_port_stats_from_ofp13(ps, ps13);
> + } else if (raw == OFPRAW_OFPST11_PORT_REPLY) {
> + const struct ofp11_port_stats *ps11;
> +
> + ps11 = ofpbuf_try_pull(msg, sizeof *ps11);
> + if (!ps11) {
> + goto bad_len;
> + }
> + return ofputil_port_stats_from_ofp11(ps, ps11);
> + } else if (raw == OFPRAW_OFPST10_PORT_REPLY) {
> + const struct ofp10_port_stats *ps10;
> +
> + ps10 = ofpbuf_try_pull(msg, sizeof *ps10);
> + if (!ps10) {
> + goto bad_len;
> + }
> + return ofputil_port_stats_from_ofp10(ps, ps10);
> + } else {
> + OVS_NOT_REACHED();
> + }
> +
> + bad_len:
> + VLOG_WARN_RL(&rl, "OFPST_PORT reply has %"PRIu32" leftover "
> + "bytes at end", msg->size);
> + return OFPERR_OFPBRC_BAD_LEN;
> +}
> +
> +/* Parse a port status request message into a 16 bit OpenFlow 1.0
> + * port number and stores the latter in '*ofp10_port'.
> + * Returns 0 if successful, otherwise an OFPERR_* number. */
> +enum ofperr
> +ofputil_decode_port_stats_request(const struct ofp_header *request,
> + ofp_port_t *ofp10_port)
> +{
> + switch ((enum ofp_version)request->version) {
> + case OFP16_VERSION:
> + case OFP15_VERSION:
> + case OFP14_VERSION:
> + case OFP13_VERSION:
> + case OFP12_VERSION:
> + case OFP11_VERSION: {
> + const struct ofp11_port_stats_request *psr11 =
> ofpmsg_body(request);
> + return ofputil_port_from_ofp11(psr11->port_no, ofp10_port);
> + }
> +
> + case OFP10_VERSION: {
> + const struct ofp10_port_stats_request *psr10 =
> ofpmsg_body(request);
> + *ofp10_port = u16_to_ofp(ntohs(psr10->port_no));
> + return 0;
> + }
> +
> + default:
> + OVS_NOT_REACHED();
> + }
> +}
> +
> diff --git a/lib/ofp-print.c b/lib/ofp-print.c
> index dede3197cb98..2f96b1863928 100644
> --- a/lib/ofp-print.c
> +++ b/lib/ofp-print.c
> @@ -43,8 +43,19 @@
> #include "openvswitch/dynamic-string.h"
> #include "openvswitch/meta-flow.h"
> #include "openvswitch/ofp-actions.h"
> +#include "openvswitch/ofp-bundle.h"
> +#include "openvswitch/ofp-connection.h"
> #include "openvswitch/ofp-errors.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-port.h"
> +#include "openvswitch/ofp-queue.h"
> +#include "openvswitch/ofp-switch.h"
> +#include "openvswitch/ofp-table.h"
> #include "openvswitch/ofp-util.h"
> #include "openvswitch/ofpbuf.h"
> #include "openvswitch/type-props.h"
> diff --git a/lib/ofp-protocol.c b/lib/ofp-protocol.c
> new file mode 100644
> index 000000000000..175318380f3b
> --- /dev/null
> +++ b/lib/ofp-protocol.c
> @@ -0,0 +1,623 @@
> +/*
> + * 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-protocol.h"
> +#include <ctype.h>
> +#include "openvswitch/dynamic-string.h"
> +#include "openvswitch/ofp-flow.h"
> +#include "openvswitch/vlog.h"
> +#include "util.h"
> +
> +VLOG_DEFINE_THIS_MODULE(ofp_protocol);
> +
> +/* Protocols. */
> +
> +struct proto_abbrev {
> + enum ofputil_protocol protocol;
> + const char *name;
> +};
> +
> +/* Most users really don't care about some of the differences between
> + * protocols. These abbreviations help with that. */
> +static const struct proto_abbrev proto_abbrevs[] = {
> + { OFPUTIL_P_ANY, "any" },
> + { OFPUTIL_P_OF10_STD_ANY, "OpenFlow10" },
> + { OFPUTIL_P_OF10_NXM_ANY, "NXM" },
> + { OFPUTIL_P_ANY_OXM, "OXM" },
> +};
> +#define N_PROTO_ABBREVS ARRAY_SIZE(proto_abbrevs)
> +
> +enum ofputil_protocol ofputil_flow_dump_protocols[] = {
> + OFPUTIL_P_OF16_OXM,
> + OFPUTIL_P_OF15_OXM,
> + OFPUTIL_P_OF14_OXM,
> + OFPUTIL_P_OF13_OXM,
> + OFPUTIL_P_OF12_OXM,
> + OFPUTIL_P_OF11_STD,
> + OFPUTIL_P_OF10_NXM,
> + OFPUTIL_P_OF10_STD,
> +};
> +size_t ofputil_n_flow_dump_protocols = ARRAY_SIZE(ofputil_flow_dump_
> protocols);
> +
> +/* Returns the set of ofputil_protocols that are supported with the given
> + * OpenFlow 'version'. 'version' should normally be an 8-bit OpenFlow
> version
> + * identifier (e.g. 0x01 for OpenFlow 1.0, 0x02 for OpenFlow 1.1).
> Returns 0
> + * if 'version' is not supported or outside the valid range. */
> +enum ofputil_protocol
> +ofputil_protocols_from_ofp_version(enum ofp_version version)
> +{
> + switch (version) {
> + case OFP10_VERSION:
> + return OFPUTIL_P_OF10_STD_ANY | OFPUTIL_P_OF10_NXM_ANY;
> + case OFP11_VERSION:
> + return OFPUTIL_P_OF11_STD;
> + case OFP12_VERSION:
> + return OFPUTIL_P_OF12_OXM;
> + case OFP13_VERSION:
> + return OFPUTIL_P_OF13_OXM;
> + case OFP14_VERSION:
> + return OFPUTIL_P_OF14_OXM;
> + case OFP15_VERSION:
> + return OFPUTIL_P_OF15_OXM;
> + case OFP16_VERSION:
> + return OFPUTIL_P_OF16_OXM;
> + default:
> + return 0;
> + }
> +}
> +
> +/* Returns the ofputil_protocol that is initially in effect on an OpenFlow
> + * connection that has negotiated the given 'version'. 'version' should
> + * normally be an 8-bit OpenFlow version identifier (e.g. 0x01 for
> OpenFlow
> + * 1.0, 0x02 for OpenFlow 1.1). Returns 0 if 'version' is not supported
> or
> + * outside the valid range. */
> +enum ofputil_protocol
> +ofputil_protocol_from_ofp_version(enum ofp_version version)
> +{
> + return rightmost_1bit(ofputil_protocols_from_ofp_version(version));
> +}
> +
> +/* Returns the OpenFlow protocol version number (e.g. OFP10_VERSION,
> + * etc.) that corresponds to 'protocol'. */
> +enum ofp_version
> +ofputil_protocol_to_ofp_version(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:
> + return OFP10_VERSION;
> + case OFPUTIL_P_OF11_STD:
> + return OFP11_VERSION;
> + case OFPUTIL_P_OF12_OXM:
> + return OFP12_VERSION;
> + case OFPUTIL_P_OF13_OXM:
> + return OFP13_VERSION;
> + case OFPUTIL_P_OF14_OXM:
> + return OFP14_VERSION;
> + case OFPUTIL_P_OF15_OXM:
> + return OFP15_VERSION;
> + case OFPUTIL_P_OF16_OXM:
> + return OFP16_VERSION;
> + }
> +
> + OVS_NOT_REACHED();
> +}
> +
> +/* Returns a bitmap of OpenFlow versions that are supported by at
> + * least one of the 'protocols'. */
> +uint32_t
> +ofputil_protocols_to_version_bitmap(enum ofputil_protocol protocols)
> +{
> + uint32_t bitmap = 0;
> +
> + for (; protocols; protocols = zero_rightmost_1bit(protocols)) {
> + enum ofputil_protocol protocol = rightmost_1bit(protocols);
> +
> + bitmap |= 1u << ofputil_protocol_to_ofp_version(protocol);
> + }
> +
> + return bitmap;
> +}
> +
> +/* Returns the set of protocols that are supported on top of the
> + * OpenFlow versions included in 'bitmap'. */
> +enum ofputil_protocol
> +ofputil_protocols_from_version_bitmap(uint32_t bitmap)
> +{
> + enum ofputil_protocol protocols = 0;
> +
> + for (; bitmap; bitmap = zero_rightmost_1bit(bitmap)) {
> + enum ofp_version version = rightmost_1bit_idx(bitmap);
> +
> + protocols |= ofputil_protocols_from_ofp_version(version);
> + }
> +
> + return protocols;
> +}
> +
> +/* Returns true if 'protocol' is a single OFPUTIL_P_* value, false
> + * otherwise. */
> +bool
> +ofputil_protocol_is_valid(enum ofputil_protocol protocol)
> +{
> + return protocol & OFPUTIL_P_ANY && is_pow2(protocol);
> +}
> +
> +/* Returns the equivalent of 'protocol' with the Nicira flow_mod_table_id
> + * extension turned on or off if 'enable' is true or false, respectively.
> + *
> + * This extension is only useful for protocols whose "standard" version
> does
> + * not allow specific tables to be modified. In particular, this is true
> of
> + * OpenFlow 1.0. In later versions of OpenFlow, a flow_mod request always
> + * specifies a table ID and so there is no need for such an extension.
> When
> + * 'protocol' is such a protocol that doesn't need a flow_mod_table_id
> + * extension, this function just returns its 'protocol' argument unchanged
> + * regardless of the value of 'enable'. */
> +enum ofputil_protocol
> +ofputil_protocol_set_tid(enum ofputil_protocol protocol, bool enable)
> +{
> + switch (protocol) {
> + case OFPUTIL_P_OF10_STD:
> + case OFPUTIL_P_OF10_STD_TID:
> + return enable ? OFPUTIL_P_OF10_STD_TID : OFPUTIL_P_OF10_STD;
> +
> + case OFPUTIL_P_OF10_NXM:
> + case OFPUTIL_P_OF10_NXM_TID:
> + return enable ? OFPUTIL_P_OF10_NXM_TID : OFPUTIL_P_OF10_NXM;
> +
> + case OFPUTIL_P_OF11_STD:
> + return OFPUTIL_P_OF11_STD;
> +
> + case OFPUTIL_P_OF12_OXM:
> + return OFPUTIL_P_OF12_OXM;
> +
> + case OFPUTIL_P_OF13_OXM:
> + return OFPUTIL_P_OF13_OXM;
> +
> + case OFPUTIL_P_OF14_OXM:
> + return OFPUTIL_P_OF14_OXM;
> +
> + case OFPUTIL_P_OF15_OXM:
> + return OFPUTIL_P_OF15_OXM;
> +
> + case OFPUTIL_P_OF16_OXM:
> + return OFPUTIL_P_OF16_OXM;
> +
> + default:
> + OVS_NOT_REACHED();
> + }
> +}
> +
> +/* Returns the "base" version of 'protocol'. That is, if 'protocol'
> includes
> + * some extension to a standard protocol version, the return value is the
> + * standard version of that protocol without any extension. If
> 'protocol' is a
> + * standard protocol version, returns 'protocol' unchanged. */
> +enum ofputil_protocol
> +ofputil_protocol_to_base(enum ofputil_protocol protocol)
> +{
> + return ofputil_protocol_set_tid(protocol, false);
> +}
> +
> +/* Returns 'new_base' with any extensions taken from 'cur'. */
> +enum ofputil_protocol
> +ofputil_protocol_set_base(enum ofputil_protocol cur,
> + enum ofputil_protocol new_base)
> +{
> + bool tid = (cur & OFPUTIL_P_TID) != 0;
> +
> + switch (new_base) {
> + case OFPUTIL_P_OF10_STD:
> + case OFPUTIL_P_OF10_STD_TID:
> + return ofputil_protocol_set_tid(OFPUTIL_P_OF10_STD, tid);
> +
> + case OFPUTIL_P_OF10_NXM:
> + case OFPUTIL_P_OF10_NXM_TID:
> + return ofputil_protocol_set_tid(OFPUTIL_P_OF10_NXM, tid);
> +
> + case OFPUTIL_P_OF11_STD:
> + return ofputil_protocol_set_tid(OFPUTIL_P_OF11_STD, tid);
> +
> + case OFPUTIL_P_OF12_OXM:
> + return ofputil_protocol_set_tid(OFPUTIL_P_OF12_OXM, tid);
> +
> + case OFPUTIL_P_OF13_OXM:
> + return ofputil_protocol_set_tid(OFPUTIL_P_OF13_OXM, tid);
> +
> + case OFPUTIL_P_OF14_OXM:
> + return ofputil_protocol_set_tid(OFPUTIL_P_OF14_OXM, tid);
> +
> + case OFPUTIL_P_OF15_OXM:
> + return ofputil_protocol_set_tid(OFPUTIL_P_OF15_OXM, tid);
> +
> + case OFPUTIL_P_OF16_OXM:
> + return ofputil_protocol_set_tid(OFPUTIL_P_OF16_OXM, tid);
> +
> + default:
> + OVS_NOT_REACHED();
> + }
> +}
> +
> +/* Returns a string form of 'protocol', if a simple form exists (that is,
> if
> + * 'protocol' is either a single protocol or it is a combination of
> protocols
> + * that have a single abbreviation). Otherwise, returns NULL. */
> +const char *
> +ofputil_protocol_to_string(enum ofputil_protocol protocol)
> +{
> + const struct proto_abbrev *p;
> +
> + /* Use a "switch" statement for single-bit names so that we get a
> compiler
> + * warning if we forget any. */
> + switch (protocol) {
> + case OFPUTIL_P_OF10_NXM:
> + return "NXM-table_id";
> +
> + case OFPUTIL_P_OF10_NXM_TID:
> + return "NXM+table_id";
> +
> + case OFPUTIL_P_OF10_STD:
> + return "OpenFlow10-table_id";
> +
> + case OFPUTIL_P_OF10_STD_TID:
> + return "OpenFlow10+table_id";
> +
> + case OFPUTIL_P_OF11_STD:
> + return "OpenFlow11";
> +
> + case OFPUTIL_P_OF12_OXM:
> + return "OXM-OpenFlow12";
> +
> + case OFPUTIL_P_OF13_OXM:
> + return "OXM-OpenFlow13";
> +
> + case OFPUTIL_P_OF14_OXM:
> + return "OXM-OpenFlow14";
> +
> + case OFPUTIL_P_OF15_OXM:
> + return "OXM-OpenFlow15";
> +
> + case OFPUTIL_P_OF16_OXM:
> + return "OXM-OpenFlow16";
> + }
> +
> + /* Check abbreviations. */
> + for (p = proto_abbrevs; p < &proto_abbrevs[N_PROTO_ABBREVS]; p++) {
> + if (protocol == p->protocol) {
> + return p->name;
> + }
> + }
> +
> + return NULL;
> +}
> +
> +/* Returns a string that represents 'protocols'. The return value might
> be a
> + * comma-separated list if 'protocols' doesn't have a simple name. The
> return
> + * value is "none" if 'protocols' is 0.
> + *
> + * The caller must free the returned string (with free()). */
> +char *
> +ofputil_protocols_to_string(enum ofputil_protocol protocols)
> +{
> + struct ds s;
> +
> + ovs_assert(!(protocols & ~OFPUTIL_P_ANY));
> + if (protocols == 0) {
> + return xstrdup("none");
> + }
> +
> + ds_init(&s);
> + while (protocols) {
> + const struct proto_abbrev *p;
> + int i;
> +
> + if (s.length) {
> + ds_put_char(&s, ',');
> + }
> +
> + for (p = proto_abbrevs; p < &proto_abbrevs[N_PROTO_ABBREVS];
> p++) {
> + if ((protocols & p->protocol) == p->protocol) {
> + ds_put_cstr(&s, p->name);
> + protocols &= ~p->protocol;
> + goto match;
> + }
> + }
> +
> + for (i = 0; i < CHAR_BIT * sizeof(enum ofputil_protocol); i++) {
> + enum ofputil_protocol bit = 1u << i;
> +
> + if (protocols & bit) {
> + ds_put_cstr(&s, ofputil_protocol_to_string(bit));
> + protocols &= ~bit;
> + goto match;
> + }
> + }
> + OVS_NOT_REACHED();
> +
> + match: ;
> + }
> + return ds_steal_cstr(&s);
> +}
> +
> +static enum ofputil_protocol
> +ofputil_protocol_from_string__(const char *s, size_t n)
> +{
> + const struct proto_abbrev *p;
> + int i;
> +
> + for (i = 0; i < CHAR_BIT * sizeof(enum ofputil_protocol); i++) {
> + enum ofputil_protocol bit = 1u << i;
> + const char *name = ofputil_protocol_to_string(bit);
> +
> + if (name && n == strlen(name) && !strncasecmp(s, name, n)) {
> + return bit;
> + }
> + }
> +
> + for (p = proto_abbrevs; p < &proto_abbrevs[N_PROTO_ABBREVS]; p++) {
> + if (n == strlen(p->name) && !strncasecmp(s, p->name, n)) {
> + return p->protocol;
> + }
> + }
> +
> + return 0;
> +}
> +
> +/* Returns the nonempty set of protocols represented by 's', which can be
> a
> + * single protocol name or abbreviation or a comma-separated list of them.
> + *
> + * Aborts the program with an error message if 's' is invalid. */
> +enum ofputil_protocol
> +ofputil_protocols_from_string(const char *s)
> +{
> + const char *orig_s = s;
> + enum ofputil_protocol protocols;
> +
> + protocols = 0;
> + while (*s) {
> + enum ofputil_protocol p;
> + size_t n;
> +
> + n = strcspn(s, ",");
> + if (n == 0) {
> + s++;
> + continue;
> + }
> +
> + p = ofputil_protocol_from_string__(s, n);
> + if (!p) {
> + ovs_fatal(0, "%.*s: unknown flow protocol", (int) n, s);
> + }
> + protocols |= p;
> +
> + s += n;
> + }
> +
> + if (!protocols) {
> + ovs_fatal(0, "%s: no flow protocol specified", orig_s);
> + }
> + return protocols;
> +}
> +
> +enum ofp_version
> +ofputil_version_from_string(const char *s)
> +{
> + if (!strcasecmp(s, "OpenFlow10")) {
> + return OFP10_VERSION;
> + }
> + if (!strcasecmp(s, "OpenFlow11")) {
> + return OFP11_VERSION;
> + }
> + if (!strcasecmp(s, "OpenFlow12")) {
> + return OFP12_VERSION;
> + }
> + if (!strcasecmp(s, "OpenFlow13")) {
> + return OFP13_VERSION;
> + }
> + if (!strcasecmp(s, "OpenFlow14")) {
> + return OFP14_VERSION;
> + }
> + if (!strcasecmp(s, "OpenFlow15")) {
> + return OFP15_VERSION;
> + }
> + if (!strcasecmp(s, "OpenFlow16")) {
> + return OFP16_VERSION;
> + }
> + return 0;
> +}
> +
> +static bool
> +is_delimiter(unsigned char c)
> +{
> + return isspace(c) || c == ',';
> +}
> +
> +uint32_t
> +ofputil_versions_from_string(const char *s)
> +{
> + size_t i = 0;
> + uint32_t bitmap = 0;
> +
> + while (s[i]) {
> + size_t j;
> + int version;
> + char *key;
> +
> + if (is_delimiter(s[i])) {
> + i++;
> + continue;
> + }
> + j = 0;
> + while (s[i + j] && !is_delimiter(s[i + j])) {
> + j++;
> + }
> + key = xmemdup0(s + i, j);
> + version = ofputil_version_from_string(key);
> + if (!version) {
> + VLOG_FATAL("Unknown OpenFlow version: \"%s\"", key);
> + }
> + free(key);
> + bitmap |= 1u << version;
> + i += j;
> + }
> +
> + return bitmap;
> +}
> +
> +uint32_t
> +ofputil_versions_from_strings(char ** const s, size_t count)
> +{
> + uint32_t bitmap = 0;
> +
> + while (count--) {
> + int version = ofputil_version_from_string(s[count]);
> + if (!version) {
> + VLOG_WARN("Unknown OpenFlow version: \"%s\"", s[count]);
> + } else {
> + bitmap |= 1u << version;
> + }
> + }
> +
> + return bitmap;
> +}
> +
> +const char *
> +ofputil_version_to_string(enum ofp_version ofp_version)
> +{
> + switch (ofp_version) {
> + case OFP10_VERSION:
> + return "OpenFlow10";
> + case OFP11_VERSION:
> + return "OpenFlow11";
> + case OFP12_VERSION:
> + return "OpenFlow12";
> + case OFP13_VERSION:
> + return "OpenFlow13";
> + case OFP14_VERSION:
> + return "OpenFlow14";
> + case OFP15_VERSION:
> + return "OpenFlow15";
> + case OFP16_VERSION:
> + return "OpenFlow16";
> + default:
> + OVS_NOT_REACHED();
> + }
> +}
> +
> +void
> +ofputil_format_version(struct ds *msg, enum ofp_version version)
> +{
> + ds_put_format(msg, "0x%02x", version);
> +}
> +
> +void
> +ofputil_format_version_name(struct ds *msg, enum ofp_version version)
> +{
> + ds_put_cstr(msg, ofputil_version_to_string(version));
> +}
> +
> +static void
> +ofputil_format_version_bitmap__(struct ds *msg, uint32_t bitmap,
> + void (*format_version)(struct ds *msg,
> + enum ofp_version))
> +{
> + while (bitmap) {
> + format_version(msg, raw_ctz(bitmap));
> + bitmap = zero_rightmost_1bit(bitmap);
> + if (bitmap) {
> + ds_put_cstr(msg, ", ");
> + }
> + }
> +}
> +
> +void
> +ofputil_format_version_bitmap(struct ds *msg, uint32_t bitmap)
> +{
> + ofputil_format_version_bitmap__(msg, bitmap, ofputil_format_version);
> +}
> +
> +void
> +ofputil_format_version_bitmap_names(struct ds *msg, uint32_t bitmap)
> +{
> + ofputil_format_version_bitmap__(msg, bitmap,
> ofputil_format_version_name);
> +}
> +
> +/* Returns an OpenFlow message that, sent on an OpenFlow connection whose
> + * protocol is 'current', at least partly transitions the protocol to
> 'want'.
> + * Stores in '*next' the protocol that will be in effect on the OpenFlow
> + * connection if the switch processes the returned message correctly. (If
> + * '*next != want' then the caller will have to iterate.)
> + *
> + * If 'current == want', or if it is not possible to transition from
> 'current'
> + * to 'want' (because, for example, 'current' and 'want' use different
> OpenFlow
> + * protocol versions), returns NULL and stores 'current' in '*next'. */
> +struct ofpbuf *
> +ofputil_encode_set_protocol(enum ofputil_protocol current,
> + enum ofputil_protocol want,
> + enum ofputil_protocol *next)
> +{
> + enum ofp_version cur_version, want_version;
> + enum ofputil_protocol cur_base, want_base;
> + bool cur_tid, want_tid;
> +
> + cur_version = ofputil_protocol_to_ofp_version(current);
> + want_version = ofputil_protocol_to_ofp_version(want);
> + if (cur_version != want_version) {
> + *next = current;
> + return NULL;
> + }
> +
> + cur_base = ofputil_protocol_to_base(current);
> + want_base = ofputil_protocol_to_base(want);
> + if (cur_base != want_base) {
> + *next = ofputil_protocol_set_base(current, want_base);
> +
> + switch (want_base) {
> + case OFPUTIL_P_OF10_NXM:
> + return ofputil_encode_nx_set_flow_format(NXFF_NXM);
> +
> + case OFPUTIL_P_OF10_STD:
> + return ofputil_encode_nx_set_flow_format(NXFF_OPENFLOW10);
> +
> + 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:
> + /* There is only one variant of each OpenFlow 1.1+ protocol,
> and we
> + * verified above that we're not trying to change versions. */
> + OVS_NOT_REACHED();
> +
> + case OFPUTIL_P_OF10_STD_TID:
> + case OFPUTIL_P_OF10_NXM_TID:
> + OVS_NOT_REACHED();
> + }
> + }
> +
> + cur_tid = (current & OFPUTIL_P_TID) != 0;
> + want_tid = (want & OFPUTIL_P_TID) != 0;
> + if (cur_tid != want_tid) {
> + *next = ofputil_protocol_set_tid(current, want_tid);
> + return ofputil_make_flow_mod_table_id(want_tid);
> + }
> +
> + ovs_assert(current == want);
> +
> + *next = current;
> + return NULL;
> +}
> diff --git a/lib/ofp-queue.c b/lib/ofp-queue.c
> new file mode 100644
> index 000000000000..3768e7a5a519
> --- /dev/null
> +++ b/lib/ofp-queue.c
> @@ -0,0 +1,727 @@
> +/*
> + * 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-queue.h"
> +#include "byte-order.h"
> +#include "flow.h"
> +#include "openvswitch/ofp-msgs.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_queue);
> +
> +static struct vlog_rate_limit rl = VLOG_RATE_LIMIT_INIT(1, 5);
> +
> +/* Constructs and returns an OFPT_QUEUE_GET_CONFIG request for the
> specified
> + * 'port' and 'queue', suitable for OpenFlow version 'version'.
> + *
> + * 'queue' is honored only for OpenFlow 1.4 and later; older versions
> always
> + * request all queues. */
> +struct ofpbuf *
> +ofputil_encode_queue_get_config_request(enum ofp_version version,
> + ofp_port_t port,
> + uint32_t queue)
> +{
> + struct ofpbuf *request;
> +
> + if (version == OFP10_VERSION) {
> + struct ofp10_queue_get_config_request *qgcr10;
> +
> + request = ofpraw_alloc(OFPRAW_OFPT10_QUEUE_GET_CONFIG_REQUEST,
> + version, 0);
> + qgcr10 = ofpbuf_put_zeros(request, sizeof *qgcr10);
> + qgcr10->port = htons(ofp_to_u16(port));
> + } else if (version < OFP14_VERSION) {
> + struct ofp11_queue_get_config_request *qgcr11;
> +
> + request = ofpraw_alloc(OFPRAW_OFPT11_QUEUE_GET_CONFIG_REQUEST,
> + version, 0);
> + qgcr11 = ofpbuf_put_zeros(request, sizeof *qgcr11);
> + qgcr11->port = ofputil_port_to_ofp11(port);
> + } else {
> + struct ofp14_queue_desc_request *qdr14;
> +
> + request = ofpraw_alloc(OFPRAW_OFPST14_QUEUE_DESC_REQUEST,
> + version, 0);
> + qdr14 = ofpbuf_put_zeros(request, sizeof *qdr14);
> + qdr14->port = ofputil_port_to_ofp11(port);
> + qdr14->queue = htonl(queue);
> + }
> +
> + return request;
> +}
> +
> +/* Parses OFPT_QUEUE_GET_CONFIG request 'oh', storing the port specified
> by the
> + * request into '*port'. Returns 0 if successful, otherwise an OpenFlow
> error
> + * code. */
> +enum ofperr
> +ofputil_decode_queue_get_config_request(const struct ofp_header *oh,
> + ofp_port_t *port, uint32_t *queue)
> +{
> + const struct ofp10_queue_get_config_request *qgcr10;
> + const struct ofp11_queue_get_config_request *qgcr11;
> + const struct ofp14_queue_desc_request *qdr14;
> + struct ofpbuf b = ofpbuf_const_initializer(oh, ntohs(oh->length));
> + enum ofpraw raw = ofpraw_pull_assert(&b);
> +
> + switch ((int) raw) {
> + case OFPRAW_OFPT10_QUEUE_GET_CONFIG_REQUEST:
> + qgcr10 = b.data;
> + *port = u16_to_ofp(ntohs(qgcr10->port));
> + *queue = OFPQ_ALL;
> + break;
> +
> + case OFPRAW_OFPT11_QUEUE_GET_CONFIG_REQUEST:
> + qgcr11 = b.data;
> + *queue = OFPQ_ALL;
> + enum ofperr error = ofputil_port_from_ofp11(qgcr11->port, port);
> + if (error || *port == OFPP_ANY) {
> + return error;
> + }
> + break;
> +
> + case OFPRAW_OFPST14_QUEUE_DESC_REQUEST:
> + qdr14 = b.data;
> + *queue = ntohl(qdr14->queue);
> + return ofputil_port_from_ofp11(qdr14->port, port);
> +
> + default:
> + OVS_NOT_REACHED();
> + }
> +
> + return (ofp_to_u16(*port) < ofp_to_u16(OFPP_MAX)
> + ? 0
> + : OFPERR_OFPQOFC_BAD_PORT);
> +}
> +
> +/* Constructs and returns the beginning of a reply to
> + * OFPT_QUEUE_GET_CONFIG_REQUEST or OFPMP_QUEUE_DESC request 'oh'. The
> caller
> + * may append information about individual queues with
> + * ofputil_append_queue_get_config_reply(). */
> +void
> +ofputil_start_queue_get_config_reply(const struct ofp_header *request,
> + struct ovs_list *replies)
> +{
> + struct ofpbuf *reply;
> + ofp_port_t port;
> + uint32_t queue;
> +
> + ovs_assert(!ofputil_decode_queue_get_config_request(request, &port,
> + &queue));
> +
> + enum ofpraw raw = ofpraw_decode_assert(request);
> + switch ((int) raw) {
> + case OFPRAW_OFPT10_QUEUE_GET_CONFIG_REQUEST:
> + reply = ofpraw_alloc_reply(OFPRAW_OFPT10_QUEUE_GET_CONFIG_REPLY,
> + request, 0);
> + struct ofp10_queue_get_config_reply *qgcr10
> + = ofpbuf_put_zeros(reply, sizeof *qgcr10);
> + qgcr10->port = htons(ofp_to_u16(port));
> + break;
> +
> + case OFPRAW_OFPT11_QUEUE_GET_CONFIG_REQUEST:
> + reply = ofpraw_alloc_reply(OFPRAW_OFPT11_QUEUE_GET_CONFIG_REPLY,
> + request, 0);
> + struct ofp11_queue_get_config_reply *qgcr11
> + = ofpbuf_put_zeros(reply, sizeof *qgcr11);
> + qgcr11->port = ofputil_port_to_ofp11(port);
> + break;
> +
> + case OFPRAW_OFPST14_QUEUE_DESC_REQUEST:
> + reply = ofpraw_alloc_stats_reply(request, 0);
> + break;
> +
> + default:
> + OVS_NOT_REACHED();
> + }
> +
> + ovs_list_init(replies);
> + ovs_list_push_back(replies, &reply->list_node);
> +}
> +
> +static void
> +put_ofp10_queue_rate(struct ofpbuf *reply,
> + enum ofp10_queue_properties property, uint16_t rate)
> +{
> + if (rate != UINT16_MAX) {
> + struct ofp10_queue_prop_rate *oqpr;
> +
> + oqpr = ofpbuf_put_zeros(reply, sizeof *oqpr);
> + oqpr->prop_header.property = htons(property);
> + oqpr->prop_header.len = htons(sizeof *oqpr);
> + oqpr->rate = htons(rate);
> + }
> +}
> +
> +static void
> +put_ofp14_queue_rate(struct ofpbuf *reply,
> + enum ofp14_queue_desc_prop_type type, uint16_t rate)
> +{
> + if (rate != UINT16_MAX) {
> + ofpprop_put_u16(reply, type, rate);
> + }
> +}
> +
> +void
> +ofputil_append_queue_get_config_reply(const struct ofputil_queue_config
> *qc,
> + struct ovs_list *replies)
> +{
> + enum ofp_version ofp_version = ofpmp_version(replies);
> + struct ofpbuf *reply = ofpbuf_from_list(ovs_list_back(replies));
> + size_t start_ofs = reply->size;
> + size_t len_ofs;
> + ovs_be16 *len;
> +
> + if (ofp_version < OFP14_VERSION) {
> + if (ofp_version < OFP12_VERSION) {
> + struct ofp10_packet_queue *opq10;
> +
> + opq10 = ofpbuf_put_zeros(reply, sizeof *opq10);
> + opq10->queue_id = htonl(qc->queue);
> + len_ofs = (char *) &opq10->len - (char *) reply->data;
> + } else {
> + struct ofp12_packet_queue *opq12;
> +
> + opq12 = ofpbuf_put_zeros(reply, sizeof *opq12);
> + opq12->port = ofputil_port_to_ofp11(qc->port);
> + opq12->queue_id = htonl(qc->queue);
> + len_ofs = (char *) &opq12->len - (char *) reply->data;
> + }
> +
> + put_ofp10_queue_rate(reply, OFPQT10_MIN_RATE, qc->min_rate);
> + put_ofp10_queue_rate(reply, OFPQT11_MAX_RATE, qc->max_rate);
> + } else {
> + struct ofp14_queue_desc *oqd = ofpbuf_put_zeros(reply, sizeof
> *oqd);
> + oqd->port_no = ofputil_port_to_ofp11(qc->port);
> + oqd->queue_id = htonl(qc->queue);
> + len_ofs = (char *) &oqd->len - (char *) reply->data;
> + put_ofp14_queue_rate(reply, OFPQDPT14_MIN_RATE, qc->min_rate);
> + put_ofp14_queue_rate(reply, OFPQDPT14_MAX_RATE, qc->max_rate);
> + }
> +
> + len = ofpbuf_at(reply, len_ofs, sizeof *len);
> + *len = htons(reply->size - start_ofs);
> +
> + if (ofp_version >= OFP14_VERSION) {
> + ofpmp_postappend(replies, start_ofs);
> + }
> +}
> +
> +static enum ofperr
> +parse_ofp10_queue_rate(const struct ofp10_queue_prop_header *hdr,
> + uint16_t *rate)
> +{
> + const struct ofp10_queue_prop_rate *oqpr;
> +
> + if (hdr->len == htons(sizeof *oqpr)) {
> + oqpr = (const struct ofp10_queue_prop_rate *) hdr;
> + *rate = ntohs(oqpr->rate);
> + return 0;
> + } else {
> + return OFPERR_OFPBRC_BAD_LEN;
> + }
> +}
> +
> +static int
> +ofputil_pull_queue_get_config_reply10(struct ofpbuf *msg,
> + struct ofputil_queue_config *queue)
> +{
> + const struct ofp_header *oh = msg->header;
> + unsigned int opq_len; /* Length of protocol-specific queue
> header. */
> + unsigned int len; /* Total length of queue + properties. */
> +
> + /* Obtain the port number from the message header. */
> + if (oh->version == OFP10_VERSION) {
> + const struct ofp10_queue_get_config_reply *oqgcr10 = msg->msg;
> + queue->port = u16_to_ofp(ntohs(oqgcr10->port));
> + } else {
> + const struct ofp11_queue_get_config_reply *oqgcr11 = msg->msg;
> + enum ofperr error = ofputil_port_from_ofp11(oqgcr11->port,
> + &queue->port);
> + if (error) {
> + return error;
> + }
> + }
> +
> + /* Pull off the queue header and get the queue number and length. */
> + if (oh->version < OFP12_VERSION) {
> + const struct ofp10_packet_queue *opq10;
> + opq10 = ofpbuf_try_pull(msg, sizeof *opq10);
> + if (!opq10) {
> + return OFPERR_OFPBRC_BAD_LEN;
> + }
> + queue->queue = ntohl(opq10->queue_id);
> + len = ntohs(opq10->len);
> + opq_len = sizeof *opq10;
> + } else {
> + const struct ofp12_packet_queue *opq12;
> + opq12 = ofpbuf_try_pull(msg, sizeof *opq12);
> + if (!opq12) {
> + return OFPERR_OFPBRC_BAD_LEN;
> + }
> + queue->queue = ntohl(opq12->queue_id);
> + len = ntohs(opq12->len);
> + opq_len = sizeof *opq12;
> + }
> +
> + /* Length check. */
> + if (len < opq_len || len > msg->size + opq_len || len % 8) {
> + return OFPERR_OFPBRC_BAD_LEN;
> + }
> + len -= opq_len;
> +
> + /* Pull properties. The format of these properties differs from used
> in
> + * OF1.4+ so we can't use the common property functions. */
> + while (len > 0) {
> + const struct ofp10_queue_prop_header *hdr;
> + unsigned int property;
> + unsigned int prop_len;
> + enum ofperr error = 0;
> +
> + hdr = ofpbuf_at_assert(msg, 0, sizeof *hdr);
> + prop_len = ntohs(hdr->len);
> + if (prop_len < sizeof *hdr || prop_len > len || prop_len % 8) {
> + return OFPERR_OFPBRC_BAD_LEN;
> + }
> +
> + property = ntohs(hdr->property);
> + switch (property) {
> + case OFPQT10_MIN_RATE:
> + error = parse_ofp10_queue_rate(hdr, &queue->min_rate);
> + break;
> +
> + case OFPQT11_MAX_RATE:
> + error = parse_ofp10_queue_rate(hdr, &queue->max_rate);
> + break;
> +
> + default:
> + VLOG_INFO_RL(&rl, "unknown queue property %u", property);
> + break;
> + }
> + if (error) {
> + return error;
> + }
> +
> + ofpbuf_pull(msg, prop_len);
> + len -= prop_len;
> + }
> + return 0;
> +}
> +
> +static int
> +ofputil_pull_queue_get_config_reply14(struct ofpbuf *msg,
> + struct ofputil_queue_config *queue)
> +{
> + struct ofp14_queue_desc *oqd14 = ofpbuf_try_pull(msg, sizeof *oqd14);
> + if (!oqd14) {
> + return OFPERR_OFPBRC_BAD_LEN;
> + }
> + enum ofperr error = ofputil_port_from_ofp11(oqd14->port_no,
> &queue->port);
> + if (error) {
> + return error;
> + }
> + queue->queue = ntohl(oqd14->queue_id);
> +
> + /* Length check. */
> + unsigned int len = ntohs(oqd14->len);
> + if (len < sizeof *oqd14 || len > msg->size + sizeof *oqd14 || len %
> 8) {
> + return OFPERR_OFPBRC_BAD_LEN;
> + }
> + len -= sizeof *oqd14;
> +
> + struct ofpbuf properties = ofpbuf_const_initializer(ofpbuf_pull(msg,
> len),
> + len);
> + while (properties.size > 0) {
> + struct ofpbuf payload;
> + uint64_t type;
> +
> + error = ofpprop_pull(&properties, &payload, &type);
> + if (error) {
> + return error;
> + }
> +
> + switch (type) {
> + case OFPQDPT14_MIN_RATE:
> + error = ofpprop_parse_u16(&payload, &queue->min_rate);
> + break;
> +
> + case OFPQDPT14_MAX_RATE:
> + error = ofpprop_parse_u16(&payload, &queue->max_rate);
> + break;
> +
> + default:
> + error = OFPPROP_UNKNOWN(true, "queue desc", type);
> + break;
> + }
> +
> + if (error) {
> + return error;
> + }
> + }
> +
> + return 0;
> +}
> +
> +/* Decodes information about a queue from the OFPT_QUEUE_GET_CONFIG_REPLY
> in
> + * 'reply' and stores it in '*queue'. ofputil_decode_queue_get_
> config_reply()
> + * must already have pulled off the main header.
> + *
> + * This function returns EOF if the last queue has already been decoded,
> 0 if a
> + * queue was successfully decoded into '*queue', or an ofperr if there
> was a
> + * problem decoding 'reply'. */
> +int
> +ofputil_pull_queue_get_config_reply(struct ofpbuf *msg,
> + struct ofputil_queue_config *queue)
> +{
> + enum ofpraw raw;
> + if (!msg->header) {
> + /* Pull OpenFlow header. */
> + raw = ofpraw_pull_assert(msg);
> +
> + /* Pull protocol-specific ofp_queue_get_config_reply header (OF1.4
> + * doesn't have one at all). */
> + if (raw == OFPRAW_OFPT10_QUEUE_GET_CONFIG_REPLY) {
> + ofpbuf_pull(msg, sizeof(struct ofp10_queue_get_config_reply))
> ;
> + } else if (raw == OFPRAW_OFPT11_QUEUE_GET_CONFIG_REPLY) {
> + ofpbuf_pull(msg, sizeof(struct ofp11_queue_get_config_reply))
> ;
> + } else {
> + ovs_assert(raw == OFPRAW_OFPST14_QUEUE_DESC_REPLY);
> + }
> + } else {
> + raw = ofpraw_decode_assert(msg->header);
> + }
> +
> + queue->min_rate = UINT16_MAX;
> + queue->max_rate = UINT16_MAX;
> +
> + if (!msg->size) {
> + return EOF;
> + } else if (raw == OFPRAW_OFPST14_QUEUE_DESC_REPLY) {
> + return ofputil_pull_queue_get_config_reply14(msg, queue);
> + } else {
> + return ofputil_pull_queue_get_config_reply10(msg, queue);
> + }
> +}
> +
> +/* Parse a queue status request message into 'oqsr'.
> + * Returns 0 if successful, otherwise an OFPERR_* number. */
> +enum ofperr
> +ofputil_decode_queue_stats_request(const struct ofp_header *request,
> + struct ofputil_queue_stats_request
> *oqsr)
> +{
> + switch ((enum ofp_version)request->version) {
> + case OFP16_VERSION:
> + case OFP15_VERSION:
> + case OFP14_VERSION:
> + case OFP13_VERSION:
> + case OFP12_VERSION:
> + case OFP11_VERSION: {
> + const struct ofp11_queue_stats_request *qsr11 =
> ofpmsg_body(request);
> + oqsr->queue_id = ntohl(qsr11->queue_id);
> + return ofputil_port_from_ofp11(qsr11->port_no, &oqsr->port_no);
> + }
> +
> + case OFP10_VERSION: {
> + const struct ofp10_queue_stats_request *qsr10 =
> ofpmsg_body(request);
> + oqsr->queue_id = ntohl(qsr10->queue_id);
> + oqsr->port_no = u16_to_ofp(ntohs(qsr10->port_no));
> + /* OF 1.0 uses OFPP_ALL for OFPP_ANY */
> + if (oqsr->port_no == OFPP_ALL) {
> + oqsr->port_no = OFPP_ANY;
> + }
> + return 0;
> + }
> +
> + default:
> + OVS_NOT_REACHED();
> + }
> +}
> +
> +/* Encode a queue stats request for 'oqsr', the encoded message
> + * will be for OpenFlow version 'ofp_version'. Returns message
> + * as a struct ofpbuf. Returns encoded message on success, NULL on error.
> */
> +struct ofpbuf *
> +ofputil_encode_queue_stats_request(enum ofp_version ofp_version,
> + const struct
> ofputil_queue_stats_request *oqsr)
> +{
> + struct ofpbuf *request;
> +
> + switch (ofp_version) {
> + case OFP11_VERSION:
> + case OFP12_VERSION:
> + case OFP13_VERSION:
> + case OFP14_VERSION:
> + case OFP15_VERSION:
> + case OFP16_VERSION: {
> + struct ofp11_queue_stats_request *req;
> + request = ofpraw_alloc(OFPRAW_OFPST11_QUEUE_REQUEST,
> ofp_version, 0);
> + req = ofpbuf_put_zeros(request, sizeof *req);
> + req->port_no = ofputil_port_to_ofp11(oqsr->port_no);
> + req->queue_id = htonl(oqsr->queue_id);
> + break;
> + }
> + case OFP10_VERSION: {
> + struct ofp10_queue_stats_request *req;
> + request = ofpraw_alloc(OFPRAW_OFPST10_QUEUE_REQUEST,
> ofp_version, 0);
> + req = ofpbuf_put_zeros(request, sizeof *req);
> + /* OpenFlow 1.0 needs OFPP_ALL instead of OFPP_ANY */
> + req->port_no = htons(ofp_to_u16(oqsr->port_no == OFPP_ANY
> + ? OFPP_ALL : oqsr->port_no));
> + req->queue_id = htonl(oqsr->queue_id);
> + break;
> + }
> + default:
> + OVS_NOT_REACHED();
> + }
> +
> + return request;
> +}
> +
> +/* Returns the number of queue stats elements in OFPTYPE_QUEUE_STATS_REPLY
> + * message 'oh'. */
> +size_t
> +ofputil_count_queue_stats(const struct ofp_header *oh)
> +{
> + struct ofpbuf b = ofpbuf_const_initializer(oh, ntohs(oh->length));
> + ofpraw_pull_assert(&b);
> +
> + for (size_t n = 0; ; n++) {
> + struct ofputil_queue_stats qs;
> + if (ofputil_decode_queue_stats(&qs, &b)) {
> + return n;
> + }
> + }
> +}
> +
> +static enum ofperr
> +ofputil_queue_stats_from_ofp10(struct ofputil_queue_stats *oqs,
> + const struct ofp10_queue_stats *qs10)
> +{
> + oqs->port_no = u16_to_ofp(ntohs(qs10->port_no));
> + oqs->queue_id = ntohl(qs10->queue_id);
> + oqs->tx_bytes = ntohll(get_32aligned_be64(&qs10->tx_bytes));
> + oqs->tx_packets = ntohll(get_32aligned_be64(&qs10->tx_packets));
> + oqs->tx_errors = ntohll(get_32aligned_be64(&qs10->tx_errors));
> + oqs->duration_sec = oqs->duration_nsec = UINT32_MAX;
> +
> + return 0;
> +}
> +
> +static enum ofperr
> +ofputil_queue_stats_from_ofp11(struct ofputil_queue_stats *oqs,
> + const struct ofp11_queue_stats *qs11)
> +{
> + enum ofperr error;
> +
> + error = ofputil_port_from_ofp11(qs11->port_no, &oqs->port_no);
> + if (error) {
> + return error;
> + }
> +
> + oqs->queue_id = ntohl(qs11->queue_id);
> + oqs->tx_bytes = ntohll(qs11->tx_bytes);
> + oqs->tx_packets = ntohll(qs11->tx_packets);
> + oqs->tx_errors = ntohll(qs11->tx_errors);
> + oqs->duration_sec = oqs->duration_nsec = UINT32_MAX;
> +
> + return 0;
> +}
> +
> +static enum ofperr
> +ofputil_queue_stats_from_ofp13(struct ofputil_queue_stats *oqs,
> + const struct ofp13_queue_stats *qs13)
> +{
> + enum ofperr error = ofputil_queue_stats_from_ofp11(oqs, &qs13->qs);
> + if (!error) {
> + oqs->duration_sec = ntohl(qs13->duration_sec);
> + oqs->duration_nsec = ntohl(qs13->duration_nsec);
> + }
> +
> + return error;
> +}
> +
> +static enum ofperr
> +ofputil_pull_ofp14_queue_stats(struct ofputil_queue_stats *oqs,
> + struct ofpbuf *msg)
> +{
> + const struct ofp14_queue_stats *qs14;
> + size_t len;
> +
> + qs14 = ofpbuf_try_pull(msg, sizeof *qs14);
> + if (!qs14) {
> + return OFPERR_OFPBRC_BAD_LEN;
> + }
> +
> + len = ntohs(qs14->length);
> + if (len < sizeof *qs14 || len - sizeof *qs14 > msg->size) {
> + return OFPERR_OFPBRC_BAD_LEN;
> + }
> + ofpbuf_pull(msg, len - sizeof *qs14);
> +
> + /* No properties yet defined, so ignore them for now. */
> +
> + return ofputil_queue_stats_from_ofp13(oqs, &qs14->qs);
> +}
> +
> +/* Converts an OFPST_QUEUE_STATS reply in 'msg' into an abstract
> + * ofputil_queue_stats in 'qs'.
> + *
> + * Multiple OFPST_QUEUE_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_queue_stats(struct ofputil_queue_stats *qs, struct ofpbuf
> *msg)
> +{
> + enum ofperr error;
> + enum ofpraw raw;
> +
> + 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_OFPST14_QUEUE_REPLY) {
> + return ofputil_pull_ofp14_queue_stats(qs, msg);
> + } else if (raw == OFPRAW_OFPST13_QUEUE_REPLY) {
> + const struct ofp13_queue_stats *qs13;
> +
> + qs13 = ofpbuf_try_pull(msg, sizeof *qs13);
> + if (!qs13) {
> + goto bad_len;
> + }
> + return ofputil_queue_stats_from_ofp13(qs, qs13);
> + } else if (raw == OFPRAW_OFPST11_QUEUE_REPLY) {
> + const struct ofp11_queue_stats *qs11;
> +
> + qs11 = ofpbuf_try_pull(msg, sizeof *qs11);
> + if (!qs11) {
> + goto bad_len;
> + }
> + return ofputil_queue_stats_from_ofp11(qs, qs11);
> + } else if (raw == OFPRAW_OFPST10_QUEUE_REPLY) {
> + const struct ofp10_queue_stats *qs10;
> +
> + qs10 = ofpbuf_try_pull(msg, sizeof *qs10);
> + if (!qs10) {
> + goto bad_len;
> + }
> + return ofputil_queue_stats_from_ofp10(qs, qs10);
> + } else {
> + OVS_NOT_REACHED();
> + }
> +
> + bad_len:
> + VLOG_WARN_RL(&rl, "OFPST_QUEUE reply has %"PRIu32" leftover "
> + "bytes at end", msg->size);
> + return OFPERR_OFPBRC_BAD_LEN;
> +}
> +
> +static void
> +ofputil_queue_stats_to_ofp10(const struct ofputil_queue_stats *oqs,
> + struct ofp10_queue_stats *qs10)
> +{
> + qs10->port_no = htons(ofp_to_u16(oqs->port_no));
> + memset(qs10->pad, 0, sizeof qs10->pad);
> + qs10->queue_id = htonl(oqs->queue_id);
> + put_32aligned_be64(&qs10->tx_bytes, htonll(oqs->tx_bytes));
> + put_32aligned_be64(&qs10->tx_packets, htonll(oqs->tx_packets));
> + put_32aligned_be64(&qs10->tx_errors, htonll(oqs->tx_errors));
> +}
> +
> +static void
> +ofputil_queue_stats_to_ofp11(const struct ofputil_queue_stats *oqs,
> + struct ofp11_queue_stats *qs11)
> +{
> + qs11->port_no = ofputil_port_to_ofp11(oqs->port_no);
> + qs11->queue_id = htonl(oqs->queue_id);
> + qs11->tx_bytes = htonll(oqs->tx_bytes);
> + qs11->tx_packets = htonll(oqs->tx_packets);
> + qs11->tx_errors = htonll(oqs->tx_errors);
> +}
> +
> +static void
> +ofputil_queue_stats_to_ofp13(const struct ofputil_queue_stats *oqs,
> + struct ofp13_queue_stats *qs13)
> +{
> + ofputil_queue_stats_to_ofp11(oqs, &qs13->qs);
> + if (oqs->duration_sec != UINT32_MAX) {
> + qs13->duration_sec = htonl(oqs->duration_sec);
> + qs13->duration_nsec = htonl(oqs->duration_nsec);
> + } else {
> + qs13->duration_sec = OVS_BE32_MAX;
> + qs13->duration_nsec = OVS_BE32_MAX;
> + }
> +}
> +
> +static void
> +ofputil_queue_stats_to_ofp14(const struct ofputil_queue_stats *oqs,
> + struct ofp14_queue_stats *qs14)
> +{
> + qs14->length = htons(sizeof *qs14);
> + memset(qs14->pad, 0, sizeof qs14->pad);
> + ofputil_queue_stats_to_ofp13(oqs, &qs14->qs);
> +}
> +
> +
> +/* Encode a queue stat for 'oqs' and append it to 'replies'. */
> +void
> +ofputil_append_queue_stat(struct ovs_list *replies,
> + const struct ofputil_queue_stats *oqs)
> +{
> + switch (ofpmp_version(replies)) {
> + case OFP13_VERSION: {
> + struct ofp13_queue_stats *reply = ofpmp_append(replies, sizeof
> *reply);
> + ofputil_queue_stats_to_ofp13(oqs, reply);
> + break;
> + }
> +
> + case OFP12_VERSION:
> + case OFP11_VERSION: {
> + struct ofp11_queue_stats *reply = ofpmp_append(replies, sizeof
> *reply);
> + ofputil_queue_stats_to_ofp11(oqs, reply);
> + break;
> + }
> +
> + case OFP10_VERSION: {
> + struct ofp10_queue_stats *reply = ofpmp_append(replies, sizeof
> *reply);
> + ofputil_queue_stats_to_ofp10(oqs, reply);
> + break;
> + }
> +
> + case OFP14_VERSION:
> + case OFP15_VERSION:
> + case OFP16_VERSION: {
> + struct ofp14_queue_stats *reply = ofpmp_append(replies, sizeof
> *reply);
> + ofputil_queue_stats_to_ofp14(oqs, reply);
> + break;
> + }
> +
> + default:
> + OVS_NOT_REACHED();
> + }
> +}
> +
> diff --git a/lib/ofp-switch.c b/lib/ofp-switch.c
> new file mode 100644
> index 000000000000..3cd0fcae833f
> --- /dev/null
> +++ b/lib/ofp-switch.c
> @@ -0,0 +1,336 @@
> +/*
> + * 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-switch.h"
> +#include "byte-order.h"
> +#include "openvswitch/ofpbuf.h"
> +#include "openvswitch/ofp-actions.h"
> +#include "openvswitch/ofp-errors.h"
> +#include "openvswitch/ofp-msgs.h"
> +#include "openvswitch/ofp-port.h"
> +#include "util.h"
> +
> +/* ofputil_switch_features */
> +
> +#define OFPC_COMMON (OFPC_FLOW_STATS | OFPC_TABLE_STATS | OFPC_PORT_STATS
> | \
> + OFPC_IP_REASM | OFPC_QUEUE_STATS)
> +BUILD_ASSERT_DECL((int) OFPUTIL_C_FLOW_STATS == OFPC_FLOW_STATS);
> +BUILD_ASSERT_DECL((int) OFPUTIL_C_TABLE_STATS == OFPC_TABLE_STATS);
> +BUILD_ASSERT_DECL((int) OFPUTIL_C_PORT_STATS == OFPC_PORT_STATS);
> +BUILD_ASSERT_DECL((int) OFPUTIL_C_IP_REASM == OFPC_IP_REASM);
> +BUILD_ASSERT_DECL((int) OFPUTIL_C_QUEUE_STATS == OFPC_QUEUE_STATS);
> +BUILD_ASSERT_DECL((int) OFPUTIL_C_ARP_MATCH_IP == OFPC_ARP_MATCH_IP);
> +BUILD_ASSERT_DECL((int) OFPUTIL_C_PORT_BLOCKED == OFPC12_PORT_BLOCKED);
> +BUILD_ASSERT_DECL((int) OFPUTIL_C_BUNDLES == OFPC14_BUNDLES);
> +BUILD_ASSERT_DECL((int) OFPUTIL_C_FLOW_MONITORING ==
> OFPC14_FLOW_MONITORING);
> +
> +static uint32_t
> +ofputil_capabilities_mask(enum ofp_version ofp_version)
> +{
> + /* Handle capabilities whose bit is unique for all OpenFlow versions
> */
> + switch (ofp_version) {
> + case OFP10_VERSION:
> + case OFP11_VERSION:
> + return OFPC_COMMON | OFPC_ARP_MATCH_IP;
> + case OFP12_VERSION:
> + case OFP13_VERSION:
> + return OFPC_COMMON | OFPC12_PORT_BLOCKED;
> + case OFP14_VERSION:
> + case OFP15_VERSION:
> + case OFP16_VERSION:
> + return OFPC_COMMON | OFPC12_PORT_BLOCKED | OFPC14_BUNDLES
> + | OFPC14_FLOW_MONITORING;
> + default:
> + /* Caller needs to check osf->header.version itself */
> + return 0;
> + }
> +}
> +
> +/* Pulls an OpenFlow "switch_features" structure from 'b' and decodes it
> into
> + * an abstract representation in '*features', readying 'b' to iterate
> over the
> + * OpenFlow port structures following 'osf' with later calls to
> + * ofputil_pull_phy_port(). Returns 0 if successful, otherwise an
> OFPERR_*
> + * value. */
> +enum ofperr
> +ofputil_pull_switch_features(struct ofpbuf *b,
> + struct ofputil_switch_features *features)
> +{
> + const struct ofp_header *oh = b->data;
> + enum ofpraw raw = ofpraw_pull_assert(b);
> + const struct ofp_switch_features *osf = ofpbuf_pull(b, sizeof *osf);
> + features->datapath_id = ntohll(osf->datapath_id);
> + features->n_buffers = ntohl(osf->n_buffers);
> + features->n_tables = osf->n_tables;
> + features->auxiliary_id = 0;
> +
> + features->capabilities = ntohl(osf->capabilities) &
> + ofputil_capabilities_mask(oh->version);
> +
> + if (raw == OFPRAW_OFPT10_FEATURES_REPLY) {
> + if (osf->capabilities & htonl(OFPC10_STP)) {
> + features->capabilities |= OFPUTIL_C_STP;
> + }
> + features->ofpacts = ofpact_bitmap_from_openflow(osf->actions,
> + OFP10_VERSION);
> + } else if (raw == OFPRAW_OFPT11_FEATURES_REPLY
> + || raw == OFPRAW_OFPT13_FEATURES_REPLY) {
> + if (osf->capabilities & htonl(OFPC11_GROUP_STATS)) {
> + features->capabilities |= OFPUTIL_C_GROUP_STATS;
> + }
> + features->ofpacts = 0;
> + if (raw == OFPRAW_OFPT13_FEATURES_REPLY) {
> + features->auxiliary_id = osf->auxiliary_id;
> + }
> + } else {
> + return OFPERR_OFPBRC_BAD_VERSION;
> + }
> +
> + return 0;
> +}
> +
> +/* In OpenFlow 1.0, 1.1, and 1.2, an OFPT_FEATURES_REPLY message lists
> all the
> + * switch's ports, unless there are too many to fit. In OpenFlow 1.3 and
> + * later, an OFPT_FEATURES_REPLY does not list ports at all.
> + *
> + * Given a buffer 'b' that contains a Features Reply message, this message
> + * checks if it contains a complete list of the switch's ports. Returns
> true,
> + * if so. Returns false if the list is missing (OF1.3+) or incomplete
> + * (OF1.0/1.1/1.2), and in the latter case removes all of the ports from
> the
> + * message.
> + *
> + * When this function returns false, the caller should send an
> OFPST_PORT_DESC
> + * stats request to get the ports. */
> +bool
> +ofputil_switch_features_has_ports(struct ofpbuf *b)
> +{
> + struct ofp_header *oh = b->data;
> + size_t phy_port_size;
> +
> + if (oh->version >= OFP13_VERSION) {
> + /* OpenFlow 1.3+ never has ports in the feature reply. */
> + return false;
> + }
> +
> + phy_port_size = (oh->version == OFP10_VERSION
> + ? sizeof(struct ofp10_phy_port)
> + : sizeof(struct ofp11_port));
> + if (ntohs(oh->length) + phy_port_size <= UINT16_MAX) {
> + /* There's room for additional ports in the feature reply.
> + * Assume that the list is complete. */
> + return true;
> + }
> +
> + /* The feature reply has no room for more ports. Probably the list is
> + * truncated. Drop the ports and tell the caller to retrieve them
> with
> + * OFPST_PORT_DESC. */
> + b->size = sizeof *oh + sizeof(struct ofp_switch_features);
> + ofpmsg_update_length(b);
> + return false;
> +}
> +
> +/* Returns a buffer owned by the caller that encodes 'features' in the
> format
> + * required by 'protocol' with the given 'xid'. The caller should append
> port
> + * information to the buffer with subsequent calls to
> + * ofputil_put_switch_features_port(). */
> +struct ofpbuf *
> +ofputil_encode_switch_features(const struct ofputil_switch_features
> *features,
> + enum ofputil_protocol protocol, ovs_be32
> xid)
> +{
> + struct ofp_switch_features *osf;
> + struct ofpbuf *b;
> + enum ofp_version version;
> + enum ofpraw raw;
> +
> + version = ofputil_protocol_to_ofp_version(protocol);
> + switch (version) {
> + case OFP10_VERSION:
> + raw = OFPRAW_OFPT10_FEATURES_REPLY;
> + break;
> + case OFP11_VERSION:
> + case OFP12_VERSION:
> + raw = OFPRAW_OFPT11_FEATURES_REPLY;
> + break;
> + case OFP13_VERSION:
> + case OFP14_VERSION:
> + case OFP15_VERSION:
> + case OFP16_VERSION:
> + raw = OFPRAW_OFPT13_FEATURES_REPLY;
> + break;
> + default:
> + OVS_NOT_REACHED();
> + }
> + b = ofpraw_alloc_xid(raw, version, xid, 0);
> + osf = ofpbuf_put_zeros(b, sizeof *osf);
> + osf->datapath_id = htonll(features->datapath_id);
> + osf->n_buffers = htonl(features->n_buffers);
> + osf->n_tables = features->n_tables;
> +
> + osf->capabilities = htonl(features->capabilities &
> + ofputil_capabilities_mask(version));
> + switch (version) {
> + case OFP10_VERSION:
> + if (features->capabilities & OFPUTIL_C_STP) {
> + osf->capabilities |= htonl(OFPC10_STP);
> + }
> + osf->actions = ofpact_bitmap_to_openflow(features->ofpacts,
> + OFP10_VERSION);
> + break;
> + case OFP13_VERSION:
> + case OFP14_VERSION:
> + case OFP15_VERSION:
> + case OFP16_VERSION:
> + osf->auxiliary_id = features->auxiliary_id;
> + /* fall through */
> + case OFP11_VERSION:
> + case OFP12_VERSION:
> + if (features->capabilities & OFPUTIL_C_GROUP_STATS) {
> + osf->capabilities |= htonl(OFPC11_GROUP_STATS);
> + }
> + break;
> + default:
> + OVS_NOT_REACHED();
> + }
> +
> + return b;
> +}
> +
> +/* Encodes 'pp' into the format required by the switch_features message
> already
> + * in 'b', which should have been returned by ofputil_encode_switch_
> features(),
> + * and appends the encoded version to 'b'. */
> +void
> +ofputil_put_switch_features_port(const struct ofputil_phy_port *pp,
> + struct ofpbuf *b)
> +{
> + const struct ofp_header *oh = b->data;
> +
> + if (oh->version < OFP13_VERSION) {
> + /* Try adding a port description to the message, but drop it
> again if
> + * the buffer overflows. (This possibility for overflow is why
> + * OpenFlow 1.3+ moved port descriptions into a multipart
> message.) */
> + size_t start_ofs = b->size;
> + ofputil_put_phy_port(oh->version, pp, b);
> + if (b->size > UINT16_MAX) {
> + b->size = start_ofs;
> + }
> + }
> +}
> +
> +const char *
> +ofputil_frag_handling_to_string(enum ofputil_frag_handling frag)
> +{
> + switch (frag) {
> + case OFPUTIL_FRAG_NORMAL: return "normal";
> + case OFPUTIL_FRAG_DROP: return "drop";
> + case OFPUTIL_FRAG_REASM: return "reassemble";
> + case OFPUTIL_FRAG_NX_MATCH: return "nx-match";
> + }
> +
> + OVS_NOT_REACHED();
> +}
> +
> +bool
> +ofputil_frag_handling_from_string(const char *s,
> + enum ofputil_frag_handling *frag)
> +{
> + if (!strcasecmp(s, "normal")) {
> + *frag = OFPUTIL_FRAG_NORMAL;
> + } else if (!strcasecmp(s, "drop")) {
> + *frag = OFPUTIL_FRAG_DROP;
> + } else if (!strcasecmp(s, "reassemble")) {
> + *frag = OFPUTIL_FRAG_REASM;
> + } else if (!strcasecmp(s, "nx-match")) {
> + *frag = OFPUTIL_FRAG_NX_MATCH;
> + } else {
> + return false;
> + }
> + return true;
> +}
> +
> +/* ofputil_switch_config */
> +
> +/* Decodes 'oh', which must be an OFPT_GET_CONFIG_REPLY or OFPT_SET_CONFIG
> + * message, into 'config'. Returns false if 'oh' contained any flags that
> + * aren't specified in its version of OpenFlow, true otherwise. */
> +static bool
> +ofputil_decode_switch_config(const struct ofp_header *oh,
> + struct ofputil_switch_config *config)
> +{
> + struct ofpbuf b = ofpbuf_const_initializer(oh, ntohs(oh->length));
> + ofpraw_pull_assert(&b);
> +
> + const struct ofp_switch_config *osc = ofpbuf_pull(&b, sizeof *osc);
> + config->frag = ntohs(osc->flags) & OFPC_FRAG_MASK;
> + config->miss_send_len = ntohs(osc->miss_send_len);
> +
> + ovs_be16 valid_mask = htons(OFPC_FRAG_MASK);
> + if (oh->version < OFP13_VERSION) {
> + const ovs_be16 ttl_bit = htons(OFPC_INVALID_TTL_TO_CONTROLLER);
> + valid_mask |= ttl_bit;
> + config->invalid_ttl_to_controller = (osc->flags & ttl_bit) != 0;
> + } else {
> + config->invalid_ttl_to_controller = -1;
> + }
> +
> + return !(osc->flags & ~valid_mask);
> +}
> +
> +void
> +ofputil_decode_get_config_reply(const struct ofp_header *oh,
> + struct ofputil_switch_config *config)
> +{
> + ofputil_decode_switch_config(oh, config);
> +}
> +
> +enum ofperr
> +ofputil_decode_set_config(const struct ofp_header *oh,
> + struct ofputil_switch_config *config)
> +{
> + return (ofputil_decode_switch_config(oh, config)
> + ? 0
> + : OFPERR_OFPSCFC_BAD_FLAGS);
> +}
> +
> +static struct ofpbuf *
> +ofputil_put_switch_config(const struct ofputil_switch_config *config,
> + struct ofpbuf *b)
> +{
> + const struct ofp_header *oh = b->data;
> + struct ofp_switch_config *osc = ofpbuf_put_zeros(b, sizeof *osc);
> + osc->flags = htons(config->frag);
> + if (config->invalid_ttl_to_controller > 0 && oh->version <
> OFP13_VERSION) {
> + osc->flags |= htons(OFPC_INVALID_TTL_TO_CONTROLLER);
> + }
> + osc->miss_send_len = htons(config->miss_send_len);
> + return b;
> +}
> +
> +struct ofpbuf *
> +ofputil_encode_get_config_reply(const struct ofp_header *request,
> + const struct ofputil_switch_config
> *config)
> +{
> + struct ofpbuf *b = ofpraw_alloc_reply(OFPRAW_OFPT_GET_CONFIG_REPLY,
> + request, 0);
> + return ofputil_put_switch_config(config, b);
> +}
> +
> +struct ofpbuf *
> +ofputil_encode_set_config(const struct ofputil_switch_config *config,
> + enum ofp_version version)
> +{
> + struct ofpbuf *b = ofpraw_alloc(OFPRAW_OFPT_SET_CONFIG, version, 0);
> + return ofputil_put_switch_config(config, b);
> +}
> diff --git a/lib/ofp-table.c b/lib/ofp-table.c
> new file mode 100644
> index 000000000000..558e4bcd9127
> --- /dev/null
> +++ b/lib/ofp-table.c
> @@ -0,0 +1,1613 @@
> +/*
> + * 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-table.h"
> +#include "bitmap.h"
> +#include "nx-match.h"
> +#include "openvswitch/dynamic-string.h"
> +#include "openvswitch/json.h"
> +#include "openvswitch/ofp-actions.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_table);
> +
> +static struct vlog_rate_limit rl = VLOG_RATE_LIMIT_INIT(1, 5);
> +
> +static ovs_be32 ofputil_encode_table_config(enum ofputil_table_miss,
> + enum ofputil_table_eviction,
> + enum ofputil_table_vacancy,
> + enum ofp_version);
> +static enum ofputil_table_vacancy ofputil_decode_table_vacancy(
> + ovs_be32 config, enum ofp_version);
> +static enum ofputil_table_eviction ofputil_decode_table_eviction(
> + ovs_be32 config, enum ofp_version);
> +
> +/* ofputil_table_map. */
> +
> +void
> +ofputil_table_map_init(struct ofputil_table_map *map)
> +{
> + namemap_init(&map->map);
> +}
> +
> +void
> +ofputil_table_map_put(struct ofputil_table_map *map,
> + uint8_t table_id, const char *name)
> +{
> + namemap_put(&map->map, table_id, name);
> +}
> +
> +const char *
> +ofputil_table_map_get_name(const struct ofputil_table_map *map,
> + uint8_t table_id)
> +{
> + struct namemap_node *node
> + = map ? namemap_find_by_number(&map->map, table_id) : NULL;
> + return node && !node->duplicate ? node->name : NULL;
> +}
> +
> +uint8_t
> +ofputil_table_map_get_number(const struct ofputil_table_map *map,
> + const char *name)
> +{
> + struct namemap_node *node
> + = map ? namemap_find_by_name(&map->map, name) : NULL;
> + return node && !node->duplicate ? node->number : UINT8_MAX;
> +}
> +
> +void
> +ofputil_table_map_destroy(struct ofputil_table_map *map)
> +{
> + namemap_destroy(&map->map);
> +}
> +
> +/* Table numbers. */
> +
> +/* Stores the table number represented by 's' into '*tablep'. 's' may be
> an
> + * integer or, if 'table_map' is nonnull, a name (quoted or unquoted).
> + *
> + * Returns true if successful, false if 's' is not a valid OpenFlow table
> + * number or name. The caller should issue an error message in this case,
> + * because this function usually does not. (This gives the caller an
> + * opportunity to look up the table name another way, e.g. by contacting
> the
> + * switch and listing the names of all its tables). */
> +bool
> +ofputil_table_from_string(const char *s,
> + const struct ofputil_table_map *table_map,
> + uint8_t *tablep)
> +{
> + *tablep = 0;
> + if (*s == '-') {
> + VLOG_WARN("Negative value %s is not a valid table number.", s);
> + return false;
> + }
> +
> + unsigned int table;
> + if (str_to_uint(s, 10, &table)) {
> + if (table > 255) {
> + VLOG_WARN("table %u is outside the supported range 0 through
> 255",
> + table);
> + return false;
> + }
> + *tablep = table;
> + return true;
> + } else {
> + if (s[0] != '"') {
> + table = ofputil_table_map_get_number(table_map, s);
> + } else {
> + size_t length = strlen(s);
> + char *name = NULL;
> + if (length > 1
> + && s[length - 1] == '"'
> + && json_string_unescape(s + 1, length - 2, &name)) {
> + table = ofputil_table_map_get_number(table_map, name);
> + }
> + free(name);
> + }
> + if (table != UINT8_MAX) {
> + *tablep = table;
> + return true;
> + }
> +
> + return false;
> + }
> +}
> +
> +/* Appends to 's' a string representation of the OpenFlow table number
> 'table',
> + * either the table number or a name drawn from 'table_map'. */
> +void
> +ofputil_format_table(uint8_t table, const struct ofputil_table_map
> *table_map,
> + struct ds *s)
> +{
> + const char *table_name = ofputil_table_map_get_name(table_map,
> table);
> + if (table_name) {
> + namemap_put_name(table_name, s);
> + } else {
> + ds_put_format(s, "%"PRIu8, table);
> + }
> +}
> +
> +/* Puts in the 'bufsize' byte in 'namebuf' a null-terminated string
> + * representation of OpenFlow table number 'table', either the table's
> number
> + * or a name drawn from 'table_map'. */
> +void
> +ofputil_table_to_string(uint8_t table,
> + const struct ofputil_table_map *table_map,
> + char *namebuf, size_t bufsize)
> +{
> + const char *table_name = ofputil_table_map_get_name(table_map,
> table);
> + if (table_name) {
> + struct ds s = DS_EMPTY_INITIALIZER;
> + namemap_put_name(table_name, &s);
> + ovs_strlcpy(namebuf, ds_cstr(&s), bufsize);
> + ds_destroy(&s);
> + return;
> + }
> +
> + snprintf(namebuf, bufsize, "%"PRIu8, table);
> +}
> +
> +/* Table features. */
> +
> +static enum ofperr
> +pull_table_feature_property(struct ofpbuf *msg, struct ofpbuf *payload,
> + uint64_t *typep)
> +{
> + enum ofperr error;
> +
> + error = ofpprop_pull(msg, payload, typep);
> + if (payload && !error) {
> + ofpbuf_pull(payload, (char *)payload->msg - (char
> *)payload->header);
> + }
> + return error;
> +}
> +
> +static enum ofperr
> +parse_action_bitmap(struct ofpbuf *payload, enum ofp_version ofp_version,
> + uint64_t *ofpacts)
> +{
> + uint32_t types = 0;
> +
> + while (payload->size > 0) {
> + enum ofperr error;
> + uint64_t type;
> +
> + error = ofpprop_pull__(payload, NULL, 1, 0x10000, &type);
> + if (error) {
> + return error;
> + }
> + if (type < CHAR_BIT * sizeof types) {
> + types |= 1u << type;
> + }
> + }
> +
> + *ofpacts = ofpact_bitmap_from_openflow(htonl(types), ofp_version);
> + return 0;
> +}
> +
> +static enum ofperr
> +parse_instruction_ids(struct ofpbuf *payload, bool loose, uint32_t *insts)
> +{
> + *insts = 0;
> + while (payload->size > 0) {
> + enum ovs_instruction_type inst;
> + enum ofperr error;
> + uint64_t ofpit;
> +
> + /* OF1.3 and OF1.4 aren't clear about padding in the instruction
> IDs.
> + * It seems clear that they aren't padded to 8 bytes, though,
> because
> + * both standards say that "non-experimenter instructions are 4
> bytes"
> + * and do not mention any padding before the first instruction ID.
> + * (There wouldn't be any point in padding to 8 bytes if the IDs
> were
> + * aligned on an odd 4-byte boundary.)
> + *
> + * Anyway, we just assume they're all glommed together on byte
> + * boundaries. */
> + error = ofpprop_pull__(payload, NULL, 1, 0x10000, &ofpit);
> + if (error) {
> + return error;
> + }
> +
> + error = ovs_instruction_type_from_inst_type(&inst, ofpit);
> + if (!error) {
> + *insts |= 1u << inst;
> + } else if (!loose) {
> + return error;
> + }
> + }
> + return 0;
> +}
> +
> +static enum ofperr
> +parse_table_features_next_table(struct ofpbuf *payload,
> + unsigned long int *next_tables)
> +{
> + size_t i;
> +
> + memset(next_tables, 0, bitmap_n_bytes(255));
> + for (i = 0; i < payload->size; i++) {
> + uint8_t id = ((const uint8_t *) payload->data)[i];
> + if (id >= 255) {
> + return OFPERR_OFPBPC_BAD_VALUE;
> + }
> + bitmap_set1(next_tables, id);
> + }
> + return 0;
> +}
> +
> +static enum ofperr
> +parse_oxms(struct ofpbuf *payload, bool loose,
> + struct mf_bitmap *exactp, struct mf_bitmap *maskedp)
> +{
> + struct mf_bitmap exact = MF_BITMAP_INITIALIZER;
> + struct mf_bitmap masked = MF_BITMAP_INITIALIZER;
> +
> + while (payload->size > 0) {
> + const struct mf_field *field;
> + enum ofperr error;
> + bool hasmask;
> +
> + error = nx_pull_header(payload, NULL, &field, &hasmask);
> + if (!error) {
> + bitmap_set1(hasmask ? masked.bm : exact.bm, field->id);
> + } else if (error != OFPERR_OFPBMC_BAD_FIELD || !loose) {
> + return error;
> + }
> + }
> + if (exactp) {
> + *exactp = exact;
> + } else if (!bitmap_is_all_zeros(exact.bm, MFF_N_IDS)) {
> + return OFPERR_OFPBMC_BAD_MASK;
> + }
> + if (maskedp) {
> + *maskedp = masked;
> + } else if (!bitmap_is_all_zeros(masked.bm, MFF_N_IDS)) {
> + return OFPERR_OFPBMC_BAD_MASK;
> + }
> + return 0;
> +}
> +
> +/* Converts an OFPMP_TABLE_FEATURES request or reply in 'msg' into an
> abstract
> + * ofputil_table_features in 'tf'.
> + *
> + * If 'loose' is true, this function ignores properties and values that
> it does
> + * not understand, as a controller would want to do when interpreting
> + * capabilities provided by a switch. If 'loose' is false, this function
> + * treats unknown properties and values as an error, as a switch would
> want to
> + * do when interpreting a configuration request made by a controller.
> + *
> + * A single OpenFlow message can specify features for multiple tables.
> Calling
> + * this function multiple times for a single 'msg' iterates through the
> tables
> + * in the message. The caller must initially leave 'msg''s layer
> pointers null
> + * and not modify them between calls.
> + *
> + * Returns 0 if successful, EOF if no tables were left in this 'msg',
> otherwise
> + * a positive "enum ofperr" value. */
> +int
> +ofputil_decode_table_features(struct ofpbuf *msg,
> + struct ofputil_table_features *tf, bool
> loose)
> +{
> + memset(tf, 0, sizeof *tf);
> +
> + if (!msg->header) {
> + ofpraw_pull_assert(msg);
> + }
> +
> + if (!msg->size) {
> + return EOF;
> + }
> +
> + const struct ofp_header *oh = msg->header;
> + struct ofp13_table_features *otf = msg->data;
> + if (msg->size < sizeof *otf) {
> + return OFPERR_OFPBPC_BAD_LEN;
> + }
> +
> + unsigned int len = ntohs(otf->length);
> + if (len < sizeof *otf || len % 8 || len > msg->size) {
> + return OFPERR_OFPBPC_BAD_LEN;
> + }
> +
> + tf->table_id = otf->table_id;
> + if (tf->table_id == OFPTT_ALL) {
> + return OFPERR_OFPTFFC_BAD_TABLE;
> + }
> +
> + ovs_strlcpy_arrays(tf->name, otf->name);
> + tf->metadata_match = otf->metadata_match;
> + tf->metadata_write = otf->metadata_write;
> + tf->miss_config = OFPUTIL_TABLE_MISS_DEFAULT;
> + if (oh->version >= OFP14_VERSION) {
> + uint32_t caps = ntohl(otf->capabilities);
> + tf->supports_eviction = (caps & OFPTC14_EVICTION) != 0;
> + tf->supports_vacancy_events = (caps & OFPTC14_VACANCY_EVENTS) !=
> 0;
> + } else {
> + tf->supports_eviction = -1;
> + tf->supports_vacancy_events = -1;
> + }
> + tf->max_entries = ntohl(otf->max_entries);
> +
> + struct ofpbuf properties = ofpbuf_const_initializer(ofpbuf_pull(msg,
> len),
> + len);
> + ofpbuf_pull(&properties, sizeof *otf);
> + while (properties.size > 0) {
> + struct ofpbuf payload;
> + enum ofperr error;
> + uint64_t type;
> +
> + error = pull_table_feature_property(&properties, &payload,
> &type);
> + if (error) {
> + return error;
> + }
> +
> + switch ((enum ofp13_table_feature_prop_type) type) {
> + case OFPTFPT13_INSTRUCTIONS:
> + error = parse_instruction_ids(&payload, loose,
> + &tf->nonmiss.instructions);
> + break;
> + case OFPTFPT13_INSTRUCTIONS_MISS:
> + error = parse_instruction_ids(&payload, loose,
> + &tf->miss.instructions);
> + break;
> +
> + case OFPTFPT13_NEXT_TABLES:
> + error = parse_table_features_next_table(&payload,
> + tf->nonmiss.next);
> + break;
> + case OFPTFPT13_NEXT_TABLES_MISS:
> + error = parse_table_features_next_table(&payload,
> tf->miss.next);
> + break;
> +
> + case OFPTFPT13_WRITE_ACTIONS:
> + error = parse_action_bitmap(&payload, oh->version,
> + &tf->nonmiss.write.ofpacts);
> + break;
> + case OFPTFPT13_WRITE_ACTIONS_MISS:
> + error = parse_action_bitmap(&payload, oh->version,
> + &tf->miss.write.ofpacts);
> + break;
> +
> + case OFPTFPT13_APPLY_ACTIONS:
> + error = parse_action_bitmap(&payload, oh->version,
> + &tf->nonmiss.apply.ofpacts);
> + break;
> + case OFPTFPT13_APPLY_ACTIONS_MISS:
> + error = parse_action_bitmap(&payload, oh->version,
> + &tf->miss.apply.ofpacts);
> + break;
> +
> + case OFPTFPT13_MATCH:
> + error = parse_oxms(&payload, loose, &tf->match, &tf->mask);
> + break;
> + case OFPTFPT13_WILDCARDS:
> + error = parse_oxms(&payload, loose, &tf->wildcard, NULL);
> + break;
> +
> + case OFPTFPT13_WRITE_SETFIELD:
> + error = parse_oxms(&payload, loose,
> + &tf->nonmiss.write.set_fields, NULL);
> + break;
> + case OFPTFPT13_WRITE_SETFIELD_MISS:
> + error = parse_oxms(&payload, loose,
> + &tf->miss.write.set_fields, NULL);
> + break;
> + case OFPTFPT13_APPLY_SETFIELD:
> + error = parse_oxms(&payload, loose,
> + &tf->nonmiss.apply.set_fields, NULL);
> + break;
> + case OFPTFPT13_APPLY_SETFIELD_MISS:
> + error = parse_oxms(&payload, loose,
> + &tf->miss.apply.set_fields, NULL);
> + break;
> +
> + case OFPTFPT13_EXPERIMENTER:
> + case OFPTFPT13_EXPERIMENTER_MISS:
> + default:
> + error = OFPPROP_UNKNOWN(loose, "table features", type);
> + break;
> + }
> + if (error) {
> + return error;
> + }
> + }
> +
> + /* Fix inconsistencies:
> + *
> + * - Turn on 'match' bits that are set in 'mask', because maskable
> + * fields are matchable.
> + *
> + * - Turn on 'wildcard' bits that are set in 'mask', because a
> field
> + * that is arbitrarily maskable can be wildcarded entirely.
> + *
> + * - Turn off 'wildcard' bits that are not in 'match', because a
> field
> + * must be matchable for it to be meaningfully wildcarded. */
> + bitmap_or(tf->match.bm, tf->mask.bm, MFF_N_IDS);
> + bitmap_or(tf->wildcard.bm, tf->mask.bm, MFF_N_IDS);
> + bitmap_and(tf->wildcard.bm, tf->match.bm, MFF_N_IDS);
> +
> + return 0;
> +}
> +
> +/* Encodes and returns a request to obtain the table features of a switch.
> + * The message is encoded for OpenFlow version 'ofp_version'. */
> +struct ofpbuf *
> +ofputil_encode_table_features_request(enum ofp_version ofp_version)
> +{
> + struct ofpbuf *request = NULL;
> +
> + switch (ofp_version) {
> + case OFP10_VERSION:
> + case OFP11_VERSION:
> + case OFP12_VERSION:
> + ovs_fatal(0, "dump-table-features needs OpenFlow 1.3 or later "
> + "(\'-O OpenFlow13\')");
> + case OFP13_VERSION:
> + case OFP14_VERSION:
> + case OFP15_VERSION:
> + case OFP16_VERSION:
> + request = ofpraw_alloc(OFPRAW_OFPST13_TABLE_FEATURES_REQUEST,
> + ofp_version, 0);
> + break;
> + default:
> + OVS_NOT_REACHED();
> + }
> +
> + return request;
> +}
> +
> +static void
> +put_fields_property(struct ofpbuf *reply,
> + const struct mf_bitmap *fields,
> + const struct mf_bitmap *masks,
> + enum ofp13_table_feature_prop_type property,
> + enum ofp_version version)
> +{
> + size_t start_ofs;
> + int field;
> +
> + start_ofs = ofpprop_start(reply, property);
> + BITMAP_FOR_EACH_1 (field, MFF_N_IDS, fields->bm) {
> + nx_put_header(reply, field, version,
> + masks && bitmap_is_set(masks->bm, field));
> + }
> + ofpprop_end(reply, start_ofs);
> +}
> +
> +static void
> +put_table_action_features(struct ofpbuf *reply,
> + const struct ofputil_table_action_features *taf,
> + enum ofp13_table_feature_prop_type actions_type,
> + enum ofp13_table_feature_prop_type
> set_fields_type,
> + int miss_offset, enum ofp_version version)
> +{
> + ofpprop_put_bitmap(reply, actions_type + miss_offset,
> + ntohl(ofpact_bitmap_to_openflow(taf->ofpacts,
> + version)));
> + put_fields_property(reply, &taf->set_fields, NULL,
> + set_fields_type + miss_offset, version);
> +}
> +
> +static void
> +put_table_instruction_features(
> + struct ofpbuf *reply, const struct ofputil_table_instruction_features
> *tif,
> + int miss_offset, enum ofp_version version)
> +{
> + size_t start_ofs;
> + uint8_t table_id;
> +
> + ofpprop_put_bitmap(reply, OFPTFPT13_INSTRUCTIONS + miss_offset,
> + ntohl(ovsinst_bitmap_to_
> openflow(tif->instructions,
> + version)));
> +
> + start_ofs = ofpprop_start(reply, OFPTFPT13_NEXT_TABLES + miss_offset);
> + BITMAP_FOR_EACH_1 (table_id, 255, tif->next) {
> + ofpbuf_put(reply, &table_id, 1);
> + }
> + ofpprop_end(reply, start_ofs);
> +
> + put_table_action_features(reply, &tif->write,
> + OFPTFPT13_WRITE_ACTIONS,
> + OFPTFPT13_WRITE_SETFIELD, miss_offset,
> version);
> + put_table_action_features(reply, &tif->apply,
> + OFPTFPT13_APPLY_ACTIONS,
> + OFPTFPT13_APPLY_SETFIELD, miss_offset,
> version);
> +}
> +
> +void
> +ofputil_append_table_features_reply(const struct ofputil_table_features
> *tf,
> + struct ovs_list *replies)
> +{
> + struct ofpbuf *reply = ofpbuf_from_list(ovs_list_back(replies));
> + enum ofp_version version = ofpmp_version(replies);
> + size_t start_ofs = reply->size;
> + struct ofp13_table_features *otf;
> +
> + otf = ofpbuf_put_zeros(reply, sizeof *otf);
> + otf->table_id = tf->table_id;
> + ovs_strlcpy_arrays(otf->name, tf->name);
> + otf->metadata_match = tf->metadata_match;
> + otf->metadata_write = tf->metadata_write;
> + if (version >= OFP14_VERSION) {
> + if (tf->supports_eviction) {
> + otf->capabilities |= htonl(OFPTC14_EVICTION);
> + }
> + if (tf->supports_vacancy_events) {
> + otf->capabilities |= htonl(OFPTC14_VACANCY_EVENTS);
> + }
> + }
> + otf->max_entries = htonl(tf->max_entries);
> +
> + put_table_instruction_features(reply, &tf->nonmiss, 0, version);
> + put_table_instruction_features(reply, &tf->miss, 1, version);
> +
> + put_fields_property(reply, &tf->match, &tf->mask,
> + OFPTFPT13_MATCH, version);
> + put_fields_property(reply, &tf->wildcard, NULL,
> + OFPTFPT13_WILDCARDS, version);
> +
> + otf = ofpbuf_at_assert(reply, start_ofs, sizeof *otf);
> + otf->length = htons(reply->size - start_ofs);
> + ofpmp_postappend(replies, start_ofs);
> +}
> +
> +static enum ofperr
> +parse_table_desc_vacancy_property(struct ofpbuf *property,
> + struct ofputil_table_desc *td)
> +{
> + struct ofp14_table_mod_prop_vacancy *otv = property->data;
> +
> + if (property->size != sizeof *otv) {
> + return OFPERR_OFPBPC_BAD_LEN;
> + }
> +
> + td->table_vacancy.vacancy_down = otv->vacancy_down;
> + td->table_vacancy.vacancy_up = otv->vacancy_up;
> + td->table_vacancy.vacancy = otv->vacancy;
> + return 0;
> +}
> +
> +/* Decodes the next OpenFlow "table desc" message (of possibly several)
> from
> + * 'msg' into an abstract form in '*td'. Returns 0 if successful, EOF if
> the
> + * last "table desc" in 'msg' was already decoded, otherwise an OFPERR_*
> + * value. */
> +int
> +ofputil_decode_table_desc(struct ofpbuf *msg,
> + struct ofputil_table_desc *td,
> + enum ofp_version version)
> +{
> + memset(td, 0, sizeof *td);
> +
> + if (!msg->header) {
> + ofpraw_pull_assert(msg);
> + }
> +
> + if (!msg->size) {
> + return EOF;
> + }
> +
> + struct ofp14_table_desc *otd = ofpbuf_try_pull(msg, sizeof *otd);
> + if (!otd) {
> + VLOG_WARN_RL(&rl, "OFP14_TABLE_DESC reply has %"PRIu32" "
> + "leftover bytes at end", msg->size);
> + return OFPERR_OFPBRC_BAD_LEN;
> + }
> +
> + td->table_id = otd->table_id;
> + size_t length = ntohs(otd->length);
> + if (length < sizeof *otd || length - sizeof *otd > msg->size) {
> + VLOG_WARN_RL(&rl, "OFP14_TABLE_DESC reply claims invalid "
> + "length %"PRIuSIZE, length);
> + return OFPERR_OFPBRC_BAD_LEN;
> + }
> + length -= sizeof *otd;
> +
> + td->eviction = ofputil_decode_table_eviction(otd->config, version);
> + td->vacancy = ofputil_decode_table_vacancy(otd->config, version);
> + td->eviction_flags = UINT32_MAX;
> +
> + struct ofpbuf properties = ofpbuf_const_initializer(
> + ofpbuf_pull(msg, length), length);
> + 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 OFPTMPT14_EVICTION:
> + error = ofpprop_parse_u32(&payload, &td->eviction_flags);
> + break;
> +
> + case OFPTMPT14_VACANCY:
> + error = parse_table_desc_vacancy_property(&payload, td);
> + break;
> +
> + default:
> + error = OFPPROP_UNKNOWN(true, "table_desc", type);
> + break;
> + }
> +
> + if (error) {
> + return error;
> + }
> + }
> +
> + return 0;
> +}
> +
> +/* Encodes and returns a request to obtain description of tables of a
> switch.
> + * The message is encoded for OpenFlow version 'ofp_version'. */
> +struct ofpbuf *
> +ofputil_encode_table_desc_request(enum ofp_version ofp_version)
> +{
> + struct ofpbuf *request = NULL;
> +
> + if (ofp_version >= OFP14_VERSION) {
> + request = ofpraw_alloc(OFPRAW_OFPST14_TABLE_DESC_REQUEST,
> + ofp_version, 0);
> + } else {
> + ovs_fatal(0, "dump-table-desc needs OpenFlow 1.4 or later "
> + "(\'-O OpenFlow14\')");
> + }
> +
> + return request;
> +}
> +
> +/* Function to append Table desc information in a reply list. */
> +void
> +ofputil_append_table_desc_reply(const struct ofputil_table_desc *td,
> + struct ovs_list *replies,
> + enum ofp_version version)
> +{
> + struct ofpbuf *reply = ofpbuf_from_list(ovs_list_back(replies));
> + size_t start_otd;
> + struct ofp14_table_desc *otd;
> +
> + start_otd = reply->size;
> + ofpbuf_put_zeros(reply, sizeof *otd);
> + if (td->eviction_flags != UINT32_MAX) {
> + ofpprop_put_u32(reply, OFPTMPT14_EVICTION, td->eviction_flags);
> + }
> + if (td->vacancy == OFPUTIL_TABLE_VACANCY_ON) {
> + struct ofp14_table_mod_prop_vacancy *otv;
> +
> + otv = ofpprop_put_zeros(reply, OFPTMPT14_VACANCY, sizeof *otv);
> + otv->vacancy_down = td->table_vacancy.vacancy_down;
> + otv->vacancy_up = td->table_vacancy.vacancy_up;
> + otv->vacancy = td->table_vacancy.vacancy;
> + }
> +
> + otd = ofpbuf_at_assert(reply, start_otd, sizeof *otd);
> + otd->length = htons(reply->size - start_otd);
> + otd->table_id = td->table_id;
> + otd->config = ofputil_encode_table_config(OFPUTIL_TABLE_MISS_DEFAULT,
> + td->eviction, td->vacancy,
> + version);
> + ofpmp_postappend(replies, start_otd);
> +}
> +
> +/* This function parses Vacancy property, and decodes the
> + * ofp14_table_mod_prop_vacancy in ofputil_table_mod.
> + * Returns OFPERR_OFPBPC_BAD_VALUE error code when vacancy_down is
> + * greater than vacancy_up and also when current vacancy has non-zero
> + * value. Returns 0 on success. */
> +static enum ofperr
> +parse_table_mod_vacancy_property(struct ofpbuf *property,
> + struct ofputil_table_mod *tm)
> +{
> + struct ofp14_table_mod_prop_vacancy *otv = property->data;
> +
> + if (property->size != sizeof *otv) {
> + return OFPERR_OFPBPC_BAD_LEN;
> + }
> + tm->table_vacancy.vacancy_down = otv->vacancy_down;
> + tm->table_vacancy.vacancy_up = otv->vacancy_up;
> + if (tm->table_vacancy.vacancy_down > tm->table_vacancy.vacancy_up) {
> + OFPPROP_LOG(&rl, false,
> + "Value of vacancy_down is greater than vacancy_up");
> + return OFPERR_OFPBPC_BAD_VALUE;
> + }
> + if (tm->table_vacancy.vacancy_down > 100 ||
> + tm->table_vacancy.vacancy_up > 100) {
> + OFPPROP_LOG(&rl, false, "Vacancy threshold percentage "
> + "should not be greater than 100");
> + return OFPERR_OFPBPC_BAD_VALUE;
> + }
> + tm->table_vacancy.vacancy = otv->vacancy;
> + if (tm->table_vacancy.vacancy) {
> + OFPPROP_LOG(&rl, false,
> + "Vacancy value should be zero for table-mod
> messages");
> + return OFPERR_OFPBPC_BAD_VALUE;
> + }
> + return 0;
> +}
> +
> +/* Given 'config', taken from an OpenFlow 'version' message that specifies
> + * table configuration (a table mod, table stats, or table features
> message),
> + * returns the table vacancy configuration that it specifies.
> + *
> + * Only OpenFlow 1.4 and later specify table vacancy configuration this
> way,
> + * so for other 'version' this function always returns
> + * OFPUTIL_TABLE_VACANCY_DEFAULT. */
> +static enum ofputil_table_vacancy
> +ofputil_decode_table_vacancy(ovs_be32 config, enum ofp_version version)
> +{
> + return (version < OFP14_VERSION ? OFPUTIL_TABLE_VACANCY_DEFAULT
> + : config & htonl(OFPTC14_VACANCY_EVENTS) ?
> OFPUTIL_TABLE_VACANCY_ON
> + : OFPUTIL_TABLE_VACANCY_OFF);
> +}
> +
> +/* Given 'config', taken from an OpenFlow 'version' message that specifies
> + * table configuration (a table mod, table stats, or table features
> message),
> + * returns the table eviction configuration that it specifies.
> + *
> + * Only OpenFlow 1.4 and later specify table eviction configuration this
> way,
> + * so for other 'version' values this function always returns
> + * OFPUTIL_TABLE_EVICTION_DEFAULT. */
> +static enum ofputil_table_eviction
> +ofputil_decode_table_eviction(ovs_be32 config, enum ofp_version version)
> +{
> + return (version < OFP14_VERSION ? OFPUTIL_TABLE_EVICTION_DEFAULT
> + : config & htonl(OFPTC14_EVICTION) ? OFPUTIL_TABLE_EVICTION_ON
> + : OFPUTIL_TABLE_EVICTION_OFF);
> +}
> +
> +/* Returns a bitmap of OFPTC* values suitable for 'config' fields in
> various
> + * OpenFlow messages of the given 'version', based on the provided 'miss'
> and
> + * 'eviction' values. */
> +static ovs_be32
> +ofputil_encode_table_config(enum ofputil_table_miss miss,
> + enum ofputil_table_eviction eviction,
> + enum ofputil_table_vacancy vacancy,
> + enum ofp_version version)
> +{
> + uint32_t config = 0;
> + /* Search for "OFPTC_* Table Configuration" in the documentation for
> more
> + * information on the crazy evolution of this field. */
> + switch (version) {
> + case OFP10_VERSION:
> + /* OpenFlow 1.0 didn't have such a field, any value ought to do.
> */
> + return htonl(0);
> +
> + case OFP11_VERSION:
> + case OFP12_VERSION:
> + /* OpenFlow 1.1 and 1.2 define only OFPTC11_TABLE_MISS_*. */
> + switch (miss) {
> + case OFPUTIL_TABLE_MISS_DEFAULT:
> + /* Really this shouldn't be used for encoding (the caller
> should
> + * provide a specific value) but I can't imagine that
> defaulting to
> + * the fall-through case here will hurt. */
> + case OFPUTIL_TABLE_MISS_CONTROLLER:
> + default:
> + return htonl(OFPTC11_TABLE_MISS_CONTROLLER);
> + case OFPUTIL_TABLE_MISS_CONTINUE:
> + return htonl(OFPTC11_TABLE_MISS_CONTINUE);
> + case OFPUTIL_TABLE_MISS_DROP:
> + return htonl(OFPTC11_TABLE_MISS_DROP);
> + }
> + OVS_NOT_REACHED();
> +
> + case OFP13_VERSION:
> + /* OpenFlow 1.3 removed OFPTC11_TABLE_MISS_* and didn't define
> any new
> + * flags, so this is correct. */
> + return htonl(0);
> +
> + case OFP14_VERSION:
> + case OFP15_VERSION:
> + case OFP16_VERSION:
> + /* OpenFlow 1.4 introduced OFPTC14_EVICTION and
> + * OFPTC14_VACANCY_EVENTS. */
> + if (eviction == OFPUTIL_TABLE_EVICTION_ON) {
> + config |= OFPTC14_EVICTION;
> + }
> + if (vacancy == OFPUTIL_TABLE_VACANCY_ON) {
> + config |= OFPTC14_VACANCY_EVENTS;
> + }
> + return htonl(config);
> + }
> +
> + OVS_NOT_REACHED();
> +}
> +
> +/* Given 'config', taken from an OpenFlow 'version' message that specifies
> + * table configuration (a table mod, table stats, or table features
> message),
> + * returns the table miss configuration that it specifies.
> + *
> + * Only OpenFlow 1.1 and 1.2 specify table miss configurations this way,
> so for
> + * other 'version' values this function always returns
> + * OFPUTIL_TABLE_MISS_DEFAULT. */
> +static enum ofputil_table_miss
> +ofputil_decode_table_miss(ovs_be32 config_, enum ofp_version version)
> +{
> + uint32_t config = ntohl(config_);
> +
> + if (version == OFP11_VERSION || version == OFP12_VERSION) {
> + switch (config & OFPTC11_TABLE_MISS_MASK) {
> + case OFPTC11_TABLE_MISS_CONTROLLER:
> + return OFPUTIL_TABLE_MISS_CONTROLLER;
> +
> + case OFPTC11_TABLE_MISS_CONTINUE:
> + return OFPUTIL_TABLE_MISS_CONTINUE;
> +
> + case OFPTC11_TABLE_MISS_DROP:
> + return OFPUTIL_TABLE_MISS_DROP;
> +
> + default:
> + VLOG_WARN_RL(&rl, "bad table miss config %d", config);
> + return OFPUTIL_TABLE_MISS_CONTROLLER;
> + }
> + } else {
> + return OFPUTIL_TABLE_MISS_DEFAULT;
> + }
> +}
> +
> +/* Decodes the OpenFlow "table mod" message in '*oh' into an abstract
> form in
> + * '*pm'. Returns 0 if successful, otherwise an OFPERR_* value. */
> +enum ofperr
> +ofputil_decode_table_mod(const struct ofp_header *oh,
> + struct ofputil_table_mod *pm)
> +{
> + memset(pm, 0, sizeof *pm);
> + pm->miss = OFPUTIL_TABLE_MISS_DEFAULT;
> + pm->eviction = OFPUTIL_TABLE_EVICTION_DEFAULT;
> + pm->eviction_flags = UINT32_MAX;
> + pm->vacancy = OFPUTIL_TABLE_VACANCY_DEFAULT;
> +
> + struct ofpbuf b = ofpbuf_const_initializer(oh, ntohs(oh->length));
> + enum ofpraw raw = ofpraw_pull_assert(&b);
> + if (raw == OFPRAW_OFPT11_TABLE_MOD) {
> + const struct ofp11_table_mod *otm = b.data;
> +
> + pm->table_id = otm->table_id;
> + pm->miss = ofputil_decode_table_miss(otm->config, oh->version);
> + } else if (raw == OFPRAW_OFPT14_TABLE_MOD) {
> + const struct ofp14_table_mod *otm = ofpbuf_pull(&b, sizeof *otm);
> +
> + pm->table_id = otm->table_id;
> + pm->miss = ofputil_decode_table_miss(otm->config, oh->version);
> + pm->eviction = ofputil_decode_table_eviction(otm->config,
> oh->version);
> + pm->vacancy = ofputil_decode_table_vacancy(otm->config,
> oh->version);
> + while (b.size > 0) {
> + struct ofpbuf property;
> + enum ofperr error;
> + uint64_t type;
> +
> + error = ofpprop_pull(&b, &property, &type);
> + if (error) {
> + return error;
> + }
> +
> + switch (type) {
> + case OFPTMPT14_EVICTION:
> + error = ofpprop_parse_u32(&property, &pm->eviction);
> + break;
> +
> + case OFPTMPT14_VACANCY:
> + error = parse_table_mod_vacancy_property(&property, pm);
> + break;
> +
> + default:
> + error = OFPERR_OFPBRC_BAD_TYPE;
> + break;
> + }
> +
> + if (error) {
> + return error;
> + }
> + }
> + } else {
> + return OFPERR_OFPBRC_BAD_TYPE;
> + }
> +
> + return 0;
> +}
> +
> +/* Converts the abstract form of a "table mod" message in '*tm' into an
> + * OpenFlow message suitable for 'protocol', and returns that encoded
> form in a
> + * buffer owned by the caller. */
> +struct ofpbuf *
> +ofputil_encode_table_mod(const struct ofputil_table_mod *tm,
> + enum ofputil_protocol protocol)
> +{
> + enum ofp_version ofp_version = ofputil_protocol_to_ofp_
> version(protocol);
> + struct ofpbuf *b;
> +
> + switch (ofp_version) {
> + case OFP10_VERSION: {
> + ovs_fatal(0, "table mod needs OpenFlow 1.1 or later "
> + "(\'-O OpenFlow11\')");
> + break;
> + }
> + case OFP11_VERSION:
> + case OFP12_VERSION:
> + case OFP13_VERSION: {
> + struct ofp11_table_mod *otm;
> +
> + b = ofpraw_alloc(OFPRAW_OFPT11_TABLE_MOD, ofp_version, 0);
> + otm = ofpbuf_put_zeros(b, sizeof *otm);
> + otm->table_id = tm->table_id;
> + otm->config = ofputil_encode_table_config(tm->miss, tm->eviction,
> + tm->vacancy,
> ofp_version);
> + break;
> + }
> + case OFP14_VERSION:
> + case OFP15_VERSION:
> + case OFP16_VERSION: {
> + struct ofp14_table_mod *otm;
> +
> + b = ofpraw_alloc(OFPRAW_OFPT14_TABLE_MOD, ofp_version, 0);
> + otm = ofpbuf_put_zeros(b, sizeof *otm);
> + otm->table_id = tm->table_id;
> + otm->config = ofputil_encode_table_config(tm->miss, tm->eviction,
> + tm->vacancy,
> ofp_version);
> +
> + if (tm->eviction_flags != UINT32_MAX) {
> + ofpprop_put_u32(b, OFPTMPT14_EVICTION, tm->eviction_flags);
> + }
> + if (tm->vacancy == OFPUTIL_TABLE_VACANCY_ON) {
> + struct ofp14_table_mod_prop_vacancy *otv;
> +
> + otv = ofpprop_put_zeros(b, OFPTMPT14_VACANCY, sizeof *otv);
> + otv->vacancy_down = tm->table_vacancy.vacancy_down;
> + otv->vacancy_up = tm->table_vacancy.vacancy_up;
> + }
> + break;
> + }
> + default:
> + OVS_NOT_REACHED();
> + }
> +
> + return b;
> +}
> +
> +/* 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. */
> +static 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;
> +}
> +
> +/* Table stats. */
> +
> +/* OpenFlow 1.0 and 1.1 don't distinguish between a field that cannot be
> + * matched and a field that must be wildcarded. This function returns a
> bitmap
> + * that contains both kinds of fields. */
> +static struct mf_bitmap
> +wild_or_nonmatchable_fields(const struct ofputil_table_features
> *features)
> +{
> + struct mf_bitmap wc = features->match;
> + bitmap_not(wc.bm, MFF_N_IDS);
> + bitmap_or(wc.bm, features->wildcard.bm, MFF_N_IDS);
> + return wc;
> +}
> +
> +struct ofp10_wc_map {
> + enum ofp10_flow_wildcards wc10;
> + enum mf_field_id mf;
> +};
> +
> +static const struct ofp10_wc_map ofp10_wc_map[] = {
> + { OFPFW10_IN_PORT, MFF_IN_PORT },
> + { OFPFW10_DL_VLAN, MFF_VLAN_VID },
> + { OFPFW10_DL_SRC, MFF_ETH_SRC },
> + { OFPFW10_DL_DST, MFF_ETH_DST},
> + { OFPFW10_DL_TYPE, MFF_ETH_TYPE },
> + { OFPFW10_NW_PROTO, MFF_IP_PROTO },
> + { OFPFW10_TP_SRC, MFF_TCP_SRC },
> + { OFPFW10_TP_DST, MFF_TCP_DST },
> + { OFPFW10_NW_SRC_MASK, MFF_IPV4_SRC },
> + { OFPFW10_NW_DST_MASK, MFF_IPV4_DST },
> + { OFPFW10_DL_VLAN_PCP, MFF_VLAN_PCP },
> + { OFPFW10_NW_TOS, MFF_IP_DSCP },
> +};
> +
> +static ovs_be32
> +mf_bitmap_to_of10(const struct mf_bitmap *fields)
> +{
> + const struct ofp10_wc_map *p;
> + uint32_t wc10 = 0;
> +
> + for (p = ofp10_wc_map; p < &ofp10_wc_map[ARRAY_SIZE(ofp10_wc_map)];
> p++) {
> + if (bitmap_is_set(fields->bm, p->mf)) {
> + wc10 |= p->wc10;
> + }
> + }
> + return htonl(wc10);
> +}
> +
> +static struct mf_bitmap
> +mf_bitmap_from_of10(ovs_be32 wc10_)
> +{
> + struct mf_bitmap fields = MF_BITMAP_INITIALIZER;
> + const struct ofp10_wc_map *p;
> + uint32_t wc10 = ntohl(wc10_);
> +
> + for (p = ofp10_wc_map; p < &ofp10_wc_map[ARRAY_SIZE(ofp10_wc_map)];
> p++) {
> + if (wc10 & p->wc10) {
> + bitmap_set1(fields.bm, p->mf);
> + }
> + }
> + return fields;
> +}
> +
> +static void
> +ofputil_put_ofp10_table_stats(const struct ofputil_table_stats *stats,
> + const struct ofputil_table_features
> *features,
> + struct ofpbuf *buf)
> +{
> + struct mf_bitmap wc = wild_or_nonmatchable_fields(features);
> + struct ofp10_table_stats *out;
> +
> + out = ofpbuf_put_zeros(buf, sizeof *out);
> + out->table_id = features->table_id;
> + ovs_strlcpy_arrays(out->name, features->name);
> + out->wildcards = mf_bitmap_to_of10(&wc);
> + out->max_entries = htonl(features->max_entries);
> + out->active_count = htonl(stats->active_count);
> + put_32aligned_be64(&out->lookup_count, htonll(stats->lookup_count));
> + put_32aligned_be64(&out->matched_count,
> htonll(stats->matched_count));
> +}
> +
> +struct ofp11_wc_map {
> + enum ofp11_flow_match_fields wc11;
> + enum mf_field_id mf;
> +};
> +
> +static const struct ofp11_wc_map ofp11_wc_map[] = {
> + { OFPFMF11_IN_PORT, MFF_IN_PORT },
> + { OFPFMF11_DL_VLAN, MFF_VLAN_VID },
> + { OFPFMF11_DL_VLAN_PCP, MFF_VLAN_PCP },
> + { OFPFMF11_DL_TYPE, MFF_ETH_TYPE },
> + { OFPFMF11_NW_TOS, MFF_IP_DSCP },
> + { OFPFMF11_NW_PROTO, MFF_IP_PROTO },
> + { OFPFMF11_TP_SRC, MFF_TCP_SRC },
> + { OFPFMF11_TP_DST, MFF_TCP_DST },
> + { OFPFMF11_MPLS_LABEL, MFF_MPLS_LABEL },
> + { OFPFMF11_MPLS_TC, MFF_MPLS_TC },
> + /* I don't know what OFPFMF11_TYPE means. */
> + { OFPFMF11_DL_SRC, MFF_ETH_SRC },
> + { OFPFMF11_DL_DST, MFF_ETH_DST },
> + { OFPFMF11_NW_SRC, MFF_IPV4_SRC },
> + { OFPFMF11_NW_DST, MFF_IPV4_DST },
> + { OFPFMF11_METADATA, MFF_METADATA },
> +};
> +
> +static ovs_be32
> +mf_bitmap_to_of11(const struct mf_bitmap *fields)
> +{
> + const struct ofp11_wc_map *p;
> + uint32_t wc11 = 0;
> +
> + for (p = ofp11_wc_map; p < &ofp11_wc_map[ARRAY_SIZE(ofp11_wc_map)];
> p++) {
> + if (bitmap_is_set(fields->bm, p->mf)) {
> + wc11 |= p->wc11;
> + }
> + }
> + return htonl(wc11);
> +}
> +
> +static struct mf_bitmap
> +mf_bitmap_from_of11(ovs_be32 wc11_)
> +{
> + struct mf_bitmap fields = MF_BITMAP_INITIALIZER;
> + const struct ofp11_wc_map *p;
> + uint32_t wc11 = ntohl(wc11_);
> +
> + for (p = ofp11_wc_map; p < &ofp11_wc_map[ARRAY_SIZE(ofp11_wc_map)];
> p++) {
> + if (wc11 & p->wc11) {
> + bitmap_set1(fields.bm, p->mf);
> + }
> + }
> + return fields;
> +}
> +
> +static void
> +ofputil_put_ofp11_table_stats(const struct ofputil_table_stats *stats,
> + const struct ofputil_table_features
> *features,
> + struct ofpbuf *buf)
> +{
> + struct mf_bitmap wc = wild_or_nonmatchable_fields(features);
> + struct ofp11_table_stats *out;
> +
> + out = ofpbuf_put_zeros(buf, sizeof *out);
> + out->table_id = features->table_id;
> + ovs_strlcpy_arrays(out->name, features->name);
> + out->wildcards = mf_bitmap_to_of11(&wc);
> + out->match = mf_bitmap_to_of11(&features->match);
> + out->instructions = ovsinst_bitmap_to_openflow(
> + features->nonmiss.instructions, OFP11_VERSION);
> + out->write_actions = ofpact_bitmap_to_openflow(
> + features->nonmiss.write.ofpacts, OFP11_VERSION);
> + out->apply_actions = ofpact_bitmap_to_openflow(
> + features->nonmiss.apply.ofpacts, OFP11_VERSION);
> + out->config = htonl(features->miss_config);
> + out->max_entries = htonl(features->max_entries);
> + out->active_count = htonl(stats->active_count);
> + out->lookup_count = htonll(stats->lookup_count);
> + out->matched_count = htonll(stats->matched_count);
> +}
> +
> +static void
> +ofputil_put_ofp12_table_stats(const struct ofputil_table_stats *stats,
> + const struct ofputil_table_features
> *features,
> + struct ofpbuf *buf)
> +{
> + struct ofp12_table_stats *out;
> +
> + out = ofpbuf_put_zeros(buf, sizeof *out);
> + out->table_id = features->table_id;
> + ovs_strlcpy_arrays(out->name, features->name);
> + out->match = oxm_bitmap_from_mf_bitmap(&features->match,
> OFP12_VERSION);
> + out->wildcards = oxm_bitmap_from_mf_bitmap(&features->wildcard,
> + OFP12_VERSION);
> + out->write_actions = ofpact_bitmap_to_openflow(
> + features->nonmiss.write.ofpacts, OFP12_VERSION);
> + out->apply_actions = ofpact_bitmap_to_openflow(
> + features->nonmiss.apply.ofpacts, OFP12_VERSION);
> + out->write_setfields = oxm_bitmap_from_mf_bitmap(
> + &features->nonmiss.write.set_fields, OFP12_VERSION);
> + out->apply_setfields = oxm_bitmap_from_mf_bitmap(
> + &features->nonmiss.apply.set_fields, OFP12_VERSION);
> + out->metadata_match = features->metadata_match;
> + out->metadata_write = features->metadata_write;
> + out->instructions = ovsinst_bitmap_to_openflow(
> + features->nonmiss.instructions, OFP12_VERSION);
> + out->config = ofputil_encode_table_config(features->miss_config,
> + OFPUTIL_TABLE_EVICTION_
> DEFAULT,
> +
> OFPUTIL_TABLE_VACANCY_DEFAULT,
> + OFP12_VERSION);
> + out->max_entries = htonl(features->max_entries);
> + out->active_count = htonl(stats->active_count);
> + out->lookup_count = htonll(stats->lookup_count);
> + out->matched_count = htonll(stats->matched_count);
> +}
> +
> +static void
> +ofputil_put_ofp13_table_stats(const struct ofputil_table_stats *stats,
> + struct ofpbuf *buf)
> +{
> + struct ofp13_table_stats *out;
> +
> + out = ofpbuf_put_zeros(buf, sizeof *out);
> + out->table_id = stats->table_id;
> + out->active_count = htonl(stats->active_count);
> + out->lookup_count = htonll(stats->lookup_count);
> + out->matched_count = htonll(stats->matched_count);
> +}
> +
> +struct ofpbuf *
> +ofputil_encode_table_stats_reply(const struct ofp_header *request)
> +{
> + return ofpraw_alloc_stats_reply(request, 0);
> +}
> +
> +void
> +ofputil_append_table_stats_reply(struct ofpbuf *reply,
> + const struct ofputil_table_stats *stats,
> + const struct ofputil_table_features
> *features)
> +{
> + struct ofp_header *oh = reply->header;
> +
> + ovs_assert(stats->table_id == features->table_id);
> +
> + switch ((enum ofp_version) oh->version) {
> + case OFP10_VERSION:
> + ofputil_put_ofp10_table_stats(stats, features, reply);
> + break;
> +
> + case OFP11_VERSION:
> + ofputil_put_ofp11_table_stats(stats, features, reply);
> + break;
> +
> + case OFP12_VERSION:
> + ofputil_put_ofp12_table_stats(stats, features, reply);
> + break;
> +
> + case OFP13_VERSION:
> + case OFP14_VERSION:
> + case OFP15_VERSION:
> + case OFP16_VERSION:
> + ofputil_put_ofp13_table_stats(stats, reply);
> + break;
> +
> + default:
> + OVS_NOT_REACHED();
> + }
> +}
> +
> +static int
> +ofputil_decode_ofp10_table_stats(struct ofpbuf *msg,
> + struct ofputil_table_stats *stats,
> + struct ofputil_table_features *features)
> +{
> + struct ofp10_table_stats *ots;
> +
> + ots = ofpbuf_try_pull(msg, sizeof *ots);
> + if (!ots) {
> + return OFPERR_OFPBRC_BAD_LEN;
> + }
> +
> + features->table_id = ots->table_id;
> + ovs_strlcpy_arrays(features->name, ots->name);
> + features->max_entries = ntohl(ots->max_entries);
> + features->match = features->wildcard = mf_bitmap_from_of10(ots->
> wildcards);
> +
> + stats->table_id = ots->table_id;
> + stats->active_count = ntohl(ots->active_count);
> + stats->lookup_count = ntohll(get_32aligned_be64(&ots->lookup_count));
> + stats->matched_count = ntohll(get_32aligned_be64(&
> ots->matched_count));
> +
> + return 0;
> +}
> +
> +static int
> +ofputil_decode_ofp11_table_stats(struct ofpbuf *msg,
> + struct ofputil_table_stats *stats,
> + struct ofputil_table_features *features)
> +{
> + struct ofp11_table_stats *ots;
> +
> + ots = ofpbuf_try_pull(msg, sizeof *ots);
> + if (!ots) {
> + return OFPERR_OFPBRC_BAD_LEN;
> + }
> +
> + features->table_id = ots->table_id;
> + ovs_strlcpy_arrays(features->name, ots->name);
> + features->max_entries = ntohl(ots->max_entries);
> + features->nonmiss.instructions = ovsinst_bitmap_from_openflow(
> + ots->instructions, OFP11_VERSION);
> + features->nonmiss.write.ofpacts = ofpact_bitmap_from_openflow(
> + ots->write_actions, OFP11_VERSION);
> + features->nonmiss.apply.ofpacts = ofpact_bitmap_from_openflow(
> + ots->write_actions, OFP11_VERSION);
> + features->miss = features->nonmiss;
> + features->miss_config = ofputil_decode_table_miss(ots->config,
> + OFP11_VERSION);
> + features->match = mf_bitmap_from_of11(ots->match);
> + features->wildcard = mf_bitmap_from_of11(ots->wildcards);
> + bitmap_or(features->match.bm, features->wildcard.bm, MFF_N_IDS);
> +
> + stats->table_id = ots->table_id;
> + stats->active_count = ntohl(ots->active_count);
> + stats->lookup_count = ntohll(ots->lookup_count);
> + stats->matched_count = ntohll(ots->matched_count);
> +
> + return 0;
> +}
> +
> +static int
> +ofputil_decode_ofp12_table_stats(struct ofpbuf *msg,
> + struct ofputil_table_stats *stats,
> + struct ofputil_table_features *features)
> +{
> + struct ofp12_table_stats *ots;
> +
> + ots = ofpbuf_try_pull(msg, sizeof *ots);
> + if (!ots) {
> + return OFPERR_OFPBRC_BAD_LEN;
> + }
> +
> + features->table_id = ots->table_id;
> + ovs_strlcpy_arrays(features->name, ots->name);
> + features->metadata_match = ots->metadata_match;
> + features->metadata_write = ots->metadata_write;
> + features->miss_config = ofputil_decode_table_miss(ots->config,
> + OFP12_VERSION);
> + features->max_entries = ntohl(ots->max_entries);
> +
> + features->nonmiss.instructions = ovsinst_bitmap_from_openflow(
> + ots->instructions, OFP12_VERSION);
> + features->nonmiss.write.ofpacts = ofpact_bitmap_from_openflow(
> + ots->write_actions, OFP12_VERSION);
> + features->nonmiss.apply.ofpacts = ofpact_bitmap_from_openflow(
> + ots->apply_actions, OFP12_VERSION);
> + features->nonmiss.write.set_fields = oxm_bitmap_to_mf_bitmap(
> + ots->write_setfields, OFP12_VERSION);
> + features->nonmiss.apply.set_fields = oxm_bitmap_to_mf_bitmap(
> + ots->apply_setfields, OFP12_VERSION);
> + features->miss = features->nonmiss;
> +
> + features->match = oxm_bitmap_to_mf_bitmap(ots->match, OFP12_VERSION);
> + features->wildcard = oxm_bitmap_to_mf_bitmap(ots->wildcards,
> + OFP12_VERSION);
> + bitmap_or(features->match.bm, features->wildcard.bm, MFF_N_IDS);
> +
> + stats->table_id = ots->table_id;
> + stats->active_count = ntohl(ots->active_count);
> + stats->lookup_count = ntohll(ots->lookup_count);
> + stats->matched_count = ntohll(ots->matched_count);
> +
> + return 0;
> +}
> +
> +static int
> +ofputil_decode_ofp13_table_stats(struct ofpbuf *msg,
> + struct ofputil_table_stats *stats,
> + struct ofputil_table_features *features)
> +{
> + struct ofp13_table_stats *ots;
> +
> + ots = ofpbuf_try_pull(msg, sizeof *ots);
> + if (!ots) {
> + return OFPERR_OFPBRC_BAD_LEN;
> + }
> +
> + features->table_id = ots->table_id;
> +
> + stats->table_id = ots->table_id;
> + stats->active_count = ntohl(ots->active_count);
> + stats->lookup_count = ntohll(ots->lookup_count);
> + stats->matched_count = ntohll(ots->matched_count);
> +
> + return 0;
> +}
> +
> +int
> +ofputil_decode_table_stats_reply(struct ofpbuf *msg,
> + struct ofputil_table_stats *stats,
> + struct ofputil_table_features *features)
> +{
> + const struct ofp_header *oh;
> +
> + if (!msg->header) {
> + ofpraw_pull_assert(msg);
> + }
> + oh = msg->header;
> +
> + if (!msg->size) {
> + return EOF;
> + }
> +
> + memset(stats, 0, sizeof *stats);
> + memset(features, 0, sizeof *features);
> + features->supports_eviction = -1;
> + features->supports_vacancy_events = -1;
> +
> + switch ((enum ofp_version) oh->version) {
> + case OFP10_VERSION:
> + return ofputil_decode_ofp10_table_stats(msg, stats, features);
> +
> + case OFP11_VERSION:
> + return ofputil_decode_ofp11_table_stats(msg, stats, features);
> +
> + case OFP12_VERSION:
> + return ofputil_decode_ofp12_table_stats(msg, stats, features);
> +
> + case OFP13_VERSION:
> + case OFP14_VERSION:
> + case OFP15_VERSION:
> + case OFP16_VERSION:
> + return ofputil_decode_ofp13_table_stats(msg, stats, features);
> +
> + default:
> + OVS_NOT_REACHED();
> + }
> +}
> +
> +static void
> +ofputil_put_ofp14_table_desc(const struct ofputil_table_desc *td,
> + struct ofpbuf *b, enum ofp_version version)
> +{
> + struct ofp14_table_desc *otd;
> + struct ofp14_table_mod_prop_vacancy *otv;
> + size_t start_otd;
> +
> + start_otd = b->size;
> + ofpbuf_put_zeros(b, sizeof *otd);
> +
> + ofpprop_put_u32(b, OFPTMPT14_EVICTION, td->eviction_flags);
> +
> + otv = ofpbuf_put_zeros(b, sizeof *otv);
> + otv->type = htons(OFPTMPT14_VACANCY);
> + otv->length = htons(sizeof *otv);
> + otv->vacancy_down = td->table_vacancy.vacancy_down;
> + otv->vacancy_up = td->table_vacancy.vacancy_up;
> + otv->vacancy = td->table_vacancy.vacancy;
> +
> + otd = ofpbuf_at_assert(b, start_otd, sizeof *otd);
> + otd->length = htons(b->size - start_otd);
> + otd->table_id = td->table_id;
> + otd->config = ofputil_encode_table_config(OFPUTIL_TABLE_MISS_DEFAULT,
> + td->eviction, td->vacancy,
> + version);
> +}
> +
> +/* Converts the abstract form of a "table status" message in '*ts' into an
> + * OpenFlow message suitable for 'protocol', and returns that encoded
> form in
> + * a buffer owned by the caller. */
> +struct ofpbuf *
> +ofputil_encode_table_status(const struct ofputil_table_status *ts,
> + enum ofputil_protocol protocol)
> +{
> + enum ofp_version version;
> + struct ofpbuf *b;
> +
> + version = ofputil_protocol_to_ofp_version(protocol);
> + if (version >= OFP14_VERSION) {
> + enum ofpraw raw;
> + struct ofp14_table_status *ots;
> +
> + raw = OFPRAW_OFPT14_TABLE_STATUS;
> + b = ofpraw_alloc_xid(raw, version, htonl(0), 0);
> + ots = ofpbuf_put_zeros(b, sizeof *ots);
> + ots->reason = ts->reason;
> + ofputil_put_ofp14_table_desc(&ts->desc, b, version);
> + ofpmsg_update_length(b);
> + return b;
> + } else {
> + return NULL;
> + }
> +}
> +
> +/* Decodes the OpenFlow "table status" message in '*ots' into an abstract
> form
> + * in '*ts'. Returns 0 if successful, otherwise an OFPERR_* value. */
> +enum ofperr
> +ofputil_decode_table_status(const struct ofp_header *oh,
> + struct ofputil_table_status *ts)
> +{
> + const struct ofp14_table_status *ots;
> + struct ofpbuf b;
> + enum ofperr error;
> + enum ofpraw raw;
> +
> + ofpbuf_use_const(&b, oh, ntohs(oh->length));
> + raw = ofpraw_pull_assert(&b);
> + ots = ofpbuf_pull(&b, sizeof *ots);
> +
> + if (raw == OFPRAW_OFPT14_TABLE_STATUS) {
> + if (ots->reason != OFPTR_VACANCY_DOWN
> + && ots->reason != OFPTR_VACANCY_UP) {
> + return OFPERR_OFPBPC_BAD_VALUE;
> + }
> + ts->reason = ots->reason;
> +
> + error = ofputil_decode_table_desc(&b, &ts->desc, oh->version);
> + return error;
> + } else {
> + return OFPERR_OFPBRC_BAD_VERSION;
> + }
> +
> + return 0;
> +}
> diff --git a/lib/ofp-util.c b/lib/ofp-util.c
> index 59fbf5f58425..df5a9dcb9777 100644
> --- a/lib/ofp-util.c
> +++ b/lib/ofp-util.c
> @@ -15,6 +15,7 @@
> */
>
> #include <config.h>
> +#include "openvswitch/ofp-util.h"
> #include <ctype.h>
> #include <errno.h>
> #include <inttypes.h>
> @@ -40,7 +41,6 @@
> #include "openvswitch/ofp-msgs.h"
> #include "openvswitch/ofp-print.h"
> #include "openvswitch/ofp-prop.h"
> -#include "openvswitch/ofp-util.h"
> #include "openvswitch/ofpbuf.h"
> #include "openvswitch/type-props.h"
> #include "openvswitch/vlog.h"
> @@ -57,11349 +57,167 @@ VLOG_DEFINE_THIS_MODULE(ofp_util);
> /* Rate limit for OpenFlow message parse errors. These always indicate a
> bug
> * in the peer and so there's not much point in showing a lot of them. */
> static struct vlog_rate_limit bad_ofmsg_rl = VLOG_RATE_LIMIT_INIT(1, 5);
> -
> -static enum ofputil_table_vacancy ofputil_decode_table_vacancy(
> - ovs_be32 config, enum ofp_version);
> -static enum ofputil_table_eviction ofputil_decode_table_eviction(
> - ovs_be32 config, enum ofp_version);
> -static ovs_be32 ofputil_encode_table_config(enum ofputil_table_miss,
> - enum ofputil_table_eviction,
> - enum ofputil_table_vacancy,
> - enum ofp_version);
> -
> -/* 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)
> +
> +static bool
> +ofputil_decode_hello_bitmap(const struct ofp_hello_elem_header *oheh,
> + uint32_t *allowed_versionsp)
> {
> - 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);
> - }
> + uint16_t bitmap_len = ntohs(oheh->length) - sizeof *oheh;
> + const ovs_be32 *bitmap = ALIGNED_CAST(const ovs_be32 *, oheh + 1);
> + uint32_t allowed_versions;
>
> - if (!(ofpfw & OFPFW10_NW_TOS)) {
> - wc->masks.nw_tos |= IP_DSCP_MASK;
> + if (!bitmap_len || bitmap_len % sizeof *bitmap) {
> + return false;
> }
>
> - 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);
> + /* Only use the first 32-bit element of the bitmap as that is all the
> + * current implementation supports. Subsequent elements are ignored
> which
> + * should have no effect on session negotiation until Open vSwitch
> supports
> + * wire-protocol versions greater than 31.
> + */
> + allowed_versions = ntohl(bitmap[0]);
>
> - 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 (allowed_versions & 1) {
> + /* There's no OpenFlow version 0. */
> + VLOG_WARN_RL(&bad_ofmsg_rl, "peer claims to support invalid
> OpenFlow "
> + "version 0x00");
> + allowed_versions &= ~1u;
> }
>
> - 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;
> + if (!allowed_versions) {
> + VLOG_WARN_RL(&bad_ofmsg_rl, "peer does not support any OpenFlow "
> + "version (between 0x01 and 0x1f)");
> + return false;
> }
>
> - /* 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);
> - }
> + *allowed_versionsp = allowed_versions;
> + return true;
> }
>
> -/* 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)
> +static uint32_t
> +version_bitmap_from_version(uint8_t ofp_version)
> {
> - 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);
> + return ((ofp_version < 32 ? 1u << ofp_version : 0) - 1) << 1;
> }
>
> -/* Convert 'match' into the OpenFlow 1.0 match structure 'ofmatch'. */
> -void
> -ofputil_match_to_ofp10_match(const struct match *match,
> - struct ofp10_match *ofmatch)
> +/* Decodes OpenFlow OFPT_HELLO message 'oh', storing into
> '*allowed_versions'
> + * the set of OpenFlow versions for which 'oh' announces support.
> + *
> + * Because of how OpenFlow defines OFPT_HELLO messages, this function is
> always
> + * successful, and thus '*allowed_versions' is always initialized.
> However, it
> + * returns false if 'oh' contains some data that could not be fully
> understood,
> + * true if 'oh' was completely parsed. */
> +bool
> +ofputil_decode_hello(const struct ofp_header *oh, uint32_t
> *allowed_versions)
> {
> - const struct flow_wildcards *wc = &match->wc;
> - uint32_t ofpfw;
> + struct ofpbuf msg = ofpbuf_const_initializer(oh, ntohs(oh->length));
> + ofpbuf_pull(&msg, sizeof *oh);
>
> - /* 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;
> - }
> + *allowed_versions = version_bitmap_from_version(oh->version);
>
> - /* 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));
> - }
> + bool ok = true;
> + while (msg.size) {
> + const struct ofp_hello_elem_header *oheh;
> + unsigned int len;
>
> - 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);
> + if (msg.size < sizeof *oheh) {
> + return false;
> }
> - }
> -
> - /* 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;
> + oheh = msg.data;
> + len = ntohs(oheh->length);
> + if (len < sizeof *oheh || !ofpbuf_try_pull(&msg, ROUND_UP(len,
> 8))) {
> + return false;
> }
> - return ofputil_match_from_ofp11_match(om, match);
> - }
>
> - case OFPMT_OXM:
> - if (padded_match_len) {
> - *padded_match_len = ROUND_UP(match_len, 8);
> + if (oheh->type != htons(OFPHET_VERSIONBITMAP)
> + || !ofputil_decode_hello_bitmap(oheh, allowed_versions)) {
> + ok = false;
> }
> - return oxm_pull_match(buf, false, tun_table, vl_mff_map, match);
> -
> - default:
> - return OFPERR_OFPBMC_BAD_TYPE;
> }
> +
> + return ok;
> }
>
> -/* 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)
> +/* Returns true if 'allowed_versions' needs to be accompanied by a version
> + * bitmap to be correctly expressed in an OFPT_HELLO message. */
> +static bool
> +should_send_version_bitmap(uint32_t allowed_versions)
> {
> - 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;
> + return !is_pow2((allowed_versions >> 1) + 1);
> }
>
> -/* Convert 'match' into the OpenFlow 1.1 match structure 'ofmatch'. */
> -void
> -ofputil_match_to_ofp11_match(const struct match *match,
> - struct ofp11_match *ofmatch)
> +/* Create an OFPT_HELLO message that expresses support for the OpenFlow
> + * versions in the 'allowed_versions' bitmaps and returns the message. */
> +struct ofpbuf *
> +ofputil_encode_hello(uint32_t allowed_versions)
> {
> - 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;
> + enum ofp_version ofp_version;
> + struct ofpbuf *msg;
>
> - if (!match->wc.masks.tp_src) {
> - wc |= OFPFW11_TP_SRC;
> - } else {
> - ofmatch->tp_src = match->flow.tp_src;
> - }
> + ofp_version = leftmost_1bit_idx(allowed_versions);
> + msg = ofpraw_alloc(OFPRAW_OFPT_HELLO, ofp_version, 0);
>
> - if (!match->wc.masks.tp_dst) {
> - wc |= OFPFW11_TP_DST;
> - } else {
> - ofmatch->tp_dst = match->flow.tp_dst;
> - }
> + if (should_send_version_bitmap(allowed_versions)) {
> + struct ofp_hello_elem_header *oheh;
> + uint16_t map_len;
>
> - 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]));
> - }
> + map_len = sizeof allowed_versions;
> + oheh = ofpbuf_put_zeros(msg, ROUND_UP(map_len + sizeof *oheh, 8));
> + oheh->type = htons(OFPHET_VERSIONBITMAP);
> + oheh->length = htons(map_len + sizeof *oheh);
> + *ALIGNED_CAST(ovs_be32 *, oheh + 1) = htonl(allowed_versions);
>
> - 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]);
> + ofpmsg_update_length(msg);
> }
>
> - ofmatch->metadata = match->flow.metadata;
> - ofmatch->metadata_mask = ~match->wc.masks.metadata;
> -
> - ofmatch->wildcards = htonl(wc);
> + return msg;
> }
> -
> -/* 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)
> +
> +/* Creates and returns an OFPT_ECHO_REQUEST message with an empty
> payload. */
> +struct ofpbuf *
> +make_echo_request(enum ofp_version ofp_version)
> {
> - 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();
> - }
> + return ofpraw_alloc_xid(OFPRAW_OFPT_ECHO_REQUEST, ofp_version,
> + htonl(0), 0);
> }
>
> -/* 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)
> +/* Creates and returns an OFPT_ECHO_REPLY message matching the
> + * OFPT_ECHO_REQUEST message in 'rq'. */
> +struct ofpbuf *
> +make_echo_reply(const struct ofp_header *rq)
> {
> - 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();
> -}
> + struct ofpbuf rq_buf = ofpbuf_const_initializer(rq,
> ntohs(rq->length));
> + ofpraw_pull_assert(&rq_buf);
>
> -/* 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);
> + struct ofpbuf *reply = ofpraw_alloc_reply(OFPRAW_OFPT_ECHO_REPLY,
> + rq, rq_buf.size);
> + ofpbuf_put(reply, rq_buf.data, rq_buf.size);
> + return reply;
> }
>
> -/* 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)
> +struct ofpbuf *
> +ofputil_encode_barrier_request(enum ofp_version ofp_version)
> {
> - return (ofp_dl_type == htons(OFP_DL_TYPE_NOT_ETH_TYPE)
> - ? htons(FLOW_DL_TYPE_NONE)
> - : ofp_dl_type);
> -}
> -
> -/* Protocols. */
> -
> -struct proto_abbrev {
> - enum ofputil_protocol protocol;
> - const char *name;
> -};
> -
> -/* Most users really don't care about some of the differences between
> - * protocols. These abbreviations help with that. */
> -static const struct proto_abbrev proto_abbrevs[] = {
> - { OFPUTIL_P_ANY, "any" },
> - { OFPUTIL_P_OF10_STD_ANY, "OpenFlow10" },
> - { OFPUTIL_P_OF10_NXM_ANY, "NXM" },
> - { OFPUTIL_P_ANY_OXM, "OXM" },
> -};
> -#define N_PROTO_ABBREVS ARRAY_SIZE(proto_abbrevs)
> -
> -enum ofputil_protocol ofputil_flow_dump_protocols[] = {
> - OFPUTIL_P_OF16_OXM,
> - OFPUTIL_P_OF15_OXM,
> - OFPUTIL_P_OF14_OXM,
> - OFPUTIL_P_OF13_OXM,
> - OFPUTIL_P_OF12_OXM,
> - OFPUTIL_P_OF11_STD,
> - OFPUTIL_P_OF10_NXM,
> - OFPUTIL_P_OF10_STD,
> -};
> -size_t ofputil_n_flow_dump_protocols = ARRAY_SIZE(ofputil_flow_dump_
> protocols);
> + enum ofpraw type;
>
> -/* Returns the set of ofputil_protocols that are supported with the given
> - * OpenFlow 'version'. 'version' should normally be an 8-bit OpenFlow
> version
> - * identifier (e.g. 0x01 for OpenFlow 1.0, 0x02 for OpenFlow 1.1).
> Returns 0
> - * if 'version' is not supported or outside the valid range. */
> -enum ofputil_protocol
> -ofputil_protocols_from_ofp_version(enum ofp_version version)
> -{
> - switch (version) {
> - case OFP10_VERSION:
> - return OFPUTIL_P_OF10_STD_ANY | OFPUTIL_P_OF10_NXM_ANY;
> - case OFP11_VERSION:
> - return OFPUTIL_P_OF11_STD;
> - case OFP12_VERSION:
> - return OFPUTIL_P_OF12_OXM;
> - case OFP13_VERSION:
> - return OFPUTIL_P_OF13_OXM;
> - case OFP14_VERSION:
> - return OFPUTIL_P_OF14_OXM;
> - case OFP15_VERSION:
> - return OFPUTIL_P_OF15_OXM;
> + switch (ofp_version) {
> case OFP16_VERSION:
> - return OFPUTIL_P_OF16_OXM;
> - default:
> - return 0;
> - }
> -}
> + case OFP15_VERSION:
> + case OFP14_VERSION:
> + case OFP13_VERSION:
> + case OFP12_VERSION:
> + case OFP11_VERSION:
> + type = OFPRAW_OFPT11_BARRIER_REQUEST;
> + break;
>
> -/* Returns the ofputil_protocol that is initially in effect on an OpenFlow
> - * connection that has negotiated the given 'version'. 'version' should
> - * normally be an 8-bit OpenFlow version identifier (e.g. 0x01 for
> OpenFlow
> - * 1.0, 0x02 for OpenFlow 1.1). Returns 0 if 'version' is not supported
> or
> - * outside the valid range. */
> -enum ofputil_protocol
> -ofputil_protocol_from_ofp_version(enum ofp_version version)
> -{
> - return rightmost_1bit(ofputil_protocols_from_ofp_version(version));
> -}
> + case OFP10_VERSION:
> + type = OFPRAW_OFPT10_BARRIER_REQUEST;
> + break;
>
> -/* Returns the OpenFlow protocol version number (e.g. OFP10_VERSION,
> - * etc.) that corresponds to 'protocol'. */
> -enum ofp_version
> -ofputil_protocol_to_ofp_version(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:
> - return OFP10_VERSION;
> - case OFPUTIL_P_OF11_STD:
> - return OFP11_VERSION;
> - case OFPUTIL_P_OF12_OXM:
> - return OFP12_VERSION;
> - case OFPUTIL_P_OF13_OXM:
> - return OFP13_VERSION;
> - case OFPUTIL_P_OF14_OXM:
> - return OFP14_VERSION;
> - case OFPUTIL_P_OF15_OXM:
> - return OFP15_VERSION;
> - case OFPUTIL_P_OF16_OXM:
> - return OFP16_VERSION;
> + default:
> + OVS_NOT_REACHED();
> }
>
> - OVS_NOT_REACHED();
> -}
> -
> -/* Returns a bitmap of OpenFlow versions that are supported by at
> - * least one of the 'protocols'. */
> -uint32_t
> -ofputil_protocols_to_version_bitmap(enum ofputil_protocol protocols)
> -{
> - uint32_t bitmap = 0;
> -
> - for (; protocols; protocols = zero_rightmost_1bit(protocols)) {
> - enum ofputil_protocol protocol = rightmost_1bit(protocols);
> -
> - bitmap |= 1u << ofputil_protocol_to_ofp_version(protocol);
> - }
> -
> - return bitmap;
> -}
> -
> -/* Returns the set of protocols that are supported on top of the
> - * OpenFlow versions included in 'bitmap'. */
> -enum ofputil_protocol
> -ofputil_protocols_from_version_bitmap(uint32_t bitmap)
> -{
> - enum ofputil_protocol protocols = 0;
> -
> - for (; bitmap; bitmap = zero_rightmost_1bit(bitmap)) {
> - enum ofp_version version = rightmost_1bit_idx(bitmap);
> -
> - protocols |= ofputil_protocols_from_ofp_version(version);
> - }
> -
> - return protocols;
> -}
> -
> -/* Returns true if 'protocol' is a single OFPUTIL_P_* value, false
> - * otherwise. */
> -bool
> -ofputil_protocol_is_valid(enum ofputil_protocol protocol)
> -{
> - return protocol & OFPUTIL_P_ANY && is_pow2(protocol);
> -}
> -
> -/* Returns the equivalent of 'protocol' with the Nicira flow_mod_table_id
> - * extension turned on or off if 'enable' is true or false, respectively.
> - *
> - * This extension is only useful for protocols whose "standard" version
> does
> - * not allow specific tables to be modified. In particular, this is true
> of
> - * OpenFlow 1.0. In later versions of OpenFlow, a flow_mod request always
> - * specifies a table ID and so there is no need for such an extension.
> When
> - * 'protocol' is such a protocol that doesn't need a flow_mod_table_id
> - * extension, this function just returns its 'protocol' argument unchanged
> - * regardless of the value of 'enable'. */
> -enum ofputil_protocol
> -ofputil_protocol_set_tid(enum ofputil_protocol protocol, bool enable)
> -{
> - switch (protocol) {
> - case OFPUTIL_P_OF10_STD:
> - case OFPUTIL_P_OF10_STD_TID:
> - return enable ? OFPUTIL_P_OF10_STD_TID : OFPUTIL_P_OF10_STD;
> -
> - case OFPUTIL_P_OF10_NXM:
> - case OFPUTIL_P_OF10_NXM_TID:
> - return enable ? OFPUTIL_P_OF10_NXM_TID : OFPUTIL_P_OF10_NXM;
> -
> - case OFPUTIL_P_OF11_STD:
> - return OFPUTIL_P_OF11_STD;
> -
> - case OFPUTIL_P_OF12_OXM:
> - return OFPUTIL_P_OF12_OXM;
> -
> - case OFPUTIL_P_OF13_OXM:
> - return OFPUTIL_P_OF13_OXM;
> -
> - case OFPUTIL_P_OF14_OXM:
> - return OFPUTIL_P_OF14_OXM;
> -
> - case OFPUTIL_P_OF15_OXM:
> - return OFPUTIL_P_OF15_OXM;
> -
> - case OFPUTIL_P_OF16_OXM:
> - return OFPUTIL_P_OF16_OXM;
> -
> - default:
> - OVS_NOT_REACHED();
> - }
> -}
> -
> -/* Returns the "base" version of 'protocol'. That is, if 'protocol'
> includes
> - * some extension to a standard protocol version, the return value is the
> - * standard version of that protocol without any extension. If
> 'protocol' is a
> - * standard protocol version, returns 'protocol' unchanged. */
> -enum ofputil_protocol
> -ofputil_protocol_to_base(enum ofputil_protocol protocol)
> -{
> - return ofputil_protocol_set_tid(protocol, false);
> -}
> -
> -/* Returns 'new_base' with any extensions taken from 'cur'. */
> -enum ofputil_protocol
> -ofputil_protocol_set_base(enum ofputil_protocol cur,
> - enum ofputil_protocol new_base)
> -{
> - bool tid = (cur & OFPUTIL_P_TID) != 0;
> -
> - switch (new_base) {
> - case OFPUTIL_P_OF10_STD:
> - case OFPUTIL_P_OF10_STD_TID:
> - return ofputil_protocol_set_tid(OFPUTIL_P_OF10_STD, tid);
> -
> - case OFPUTIL_P_OF10_NXM:
> - case OFPUTIL_P_OF10_NXM_TID:
> - return ofputil_protocol_set_tid(OFPUTIL_P_OF10_NXM, tid);
> -
> - case OFPUTIL_P_OF11_STD:
> - return ofputil_protocol_set_tid(OFPUTIL_P_OF11_STD, tid);
> -
> - case OFPUTIL_P_OF12_OXM:
> - return ofputil_protocol_set_tid(OFPUTIL_P_OF12_OXM, tid);
> -
> - case OFPUTIL_P_OF13_OXM:
> - return ofputil_protocol_set_tid(OFPUTIL_P_OF13_OXM, tid);
> -
> - case OFPUTIL_P_OF14_OXM:
> - return ofputil_protocol_set_tid(OFPUTIL_P_OF14_OXM, tid);
> -
> - case OFPUTIL_P_OF15_OXM:
> - return ofputil_protocol_set_tid(OFPUTIL_P_OF15_OXM, tid);
> -
> - case OFPUTIL_P_OF16_OXM:
> - return ofputil_protocol_set_tid(OFPUTIL_P_OF16_OXM, tid);
> -
> - default:
> - OVS_NOT_REACHED();
> - }
> -}
> -
> -/* Returns a string form of 'protocol', if a simple form exists (that is,
> if
> - * 'protocol' is either a single protocol or it is a combination of
> protocols
> - * that have a single abbreviation). Otherwise, returns NULL. */
> -const char *
> -ofputil_protocol_to_string(enum ofputil_protocol protocol)
> -{
> - const struct proto_abbrev *p;
> -
> - /* Use a "switch" statement for single-bit names so that we get a
> compiler
> - * warning if we forget any. */
> - switch (protocol) {
> - case OFPUTIL_P_OF10_NXM:
> - return "NXM-table_id";
> -
> - case OFPUTIL_P_OF10_NXM_TID:
> - return "NXM+table_id";
> -
> - case OFPUTIL_P_OF10_STD:
> - return "OpenFlow10-table_id";
> -
> - case OFPUTIL_P_OF10_STD_TID:
> - return "OpenFlow10+table_id";
> -
> - case OFPUTIL_P_OF11_STD:
> - return "OpenFlow11";
> -
> - case OFPUTIL_P_OF12_OXM:
> - return "OXM-OpenFlow12";
> -
> - case OFPUTIL_P_OF13_OXM:
> - return "OXM-OpenFlow13";
> -
> - case OFPUTIL_P_OF14_OXM:
> - return "OXM-OpenFlow14";
> -
> - case OFPUTIL_P_OF15_OXM:
> - return "OXM-OpenFlow15";
> -
> - case OFPUTIL_P_OF16_OXM:
> - return "OXM-OpenFlow16";
> - }
> -
> - /* Check abbreviations. */
> - for (p = proto_abbrevs; p < &proto_abbrevs[N_PROTO_ABBREVS]; p++) {
> - if (protocol == p->protocol) {
> - return p->name;
> - }
> - }
> -
> - return NULL;
> -}
> -
> -/* Returns a string that represents 'protocols'. The return value might
> be a
> - * comma-separated list if 'protocols' doesn't have a simple name. The
> return
> - * value is "none" if 'protocols' is 0.
> - *
> - * The caller must free the returned string (with free()). */
> -char *
> -ofputil_protocols_to_string(enum ofputil_protocol protocols)
> -{
> - struct ds s;
> -
> - ovs_assert(!(protocols & ~OFPUTIL_P_ANY));
> - if (protocols == 0) {
> - return xstrdup("none");
> - }
> -
> - ds_init(&s);
> - while (protocols) {
> - const struct proto_abbrev *p;
> - int i;
> -
> - if (s.length) {
> - ds_put_char(&s, ',');
> - }
> -
> - for (p = proto_abbrevs; p < &proto_abbrevs[N_PROTO_ABBREVS];
> p++) {
> - if ((protocols & p->protocol) == p->protocol) {
> - ds_put_cstr(&s, p->name);
> - protocols &= ~p->protocol;
> - goto match;
> - }
> - }
> -
> - for (i = 0; i < CHAR_BIT * sizeof(enum ofputil_protocol); i++) {
> - enum ofputil_protocol bit = 1u << i;
> -
> - if (protocols & bit) {
> - ds_put_cstr(&s, ofputil_protocol_to_string(bit));
> - protocols &= ~bit;
> - goto match;
> - }
> - }
> - OVS_NOT_REACHED();
> -
> - match: ;
> - }
> - return ds_steal_cstr(&s);
> -}
> -
> -static enum ofputil_protocol
> -ofputil_protocol_from_string__(const char *s, size_t n)
> -{
> - const struct proto_abbrev *p;
> - int i;
> -
> - for (i = 0; i < CHAR_BIT * sizeof(enum ofputil_protocol); i++) {
> - enum ofputil_protocol bit = 1u << i;
> - const char *name = ofputil_protocol_to_string(bit);
> -
> - if (name && n == strlen(name) && !strncasecmp(s, name, n)) {
> - return bit;
> - }
> - }
> -
> - for (p = proto_abbrevs; p < &proto_abbrevs[N_PROTO_ABBREVS]; p++) {
> - if (n == strlen(p->name) && !strncasecmp(s, p->name, n)) {
> - return p->protocol;
> - }
> - }
> -
> - return 0;
> -}
> -
> -/* Returns the nonempty set of protocols represented by 's', which can be
> a
> - * single protocol name or abbreviation or a comma-separated list of them.
> - *
> - * Aborts the program with an error message if 's' is invalid. */
> -enum ofputil_protocol
> -ofputil_protocols_from_string(const char *s)
> -{
> - const char *orig_s = s;
> - enum ofputil_protocol protocols;
> -
> - protocols = 0;
> - while (*s) {
> - enum ofputil_protocol p;
> - size_t n;
> -
> - n = strcspn(s, ",");
> - if (n == 0) {
> - s++;
> - continue;
> - }
> -
> - p = ofputil_protocol_from_string__(s, n);
> - if (!p) {
> - ovs_fatal(0, "%.*s: unknown flow protocol", (int) n, s);
> - }
> - protocols |= p;
> -
> - s += n;
> - }
> -
> - if (!protocols) {
> - ovs_fatal(0, "%s: no flow protocol specified", orig_s);
> - }
> - return protocols;
> -}
> -
> -enum ofp_version
> -ofputil_version_from_string(const char *s)
> -{
> - if (!strcasecmp(s, "OpenFlow10")) {
> - return OFP10_VERSION;
> - }
> - if (!strcasecmp(s, "OpenFlow11")) {
> - return OFP11_VERSION;
> - }
> - if (!strcasecmp(s, "OpenFlow12")) {
> - return OFP12_VERSION;
> - }
> - if (!strcasecmp(s, "OpenFlow13")) {
> - return OFP13_VERSION;
> - }
> - if (!strcasecmp(s, "OpenFlow14")) {
> - return OFP14_VERSION;
> - }
> - if (!strcasecmp(s, "OpenFlow15")) {
> - return OFP15_VERSION;
> - }
> - if (!strcasecmp(s, "OpenFlow16")) {
> - return OFP16_VERSION;
> - }
> - return 0;
> -}
> -
> -static bool
> -is_delimiter(unsigned char c)
> -{
> - return isspace(c) || c == ',';
> -}
> -
> -uint32_t
> -ofputil_versions_from_string(const char *s)
> -{
> - size_t i = 0;
> - uint32_t bitmap = 0;
> -
> - while (s[i]) {
> - size_t j;
> - int version;
> - char *key;
> -
> - if (is_delimiter(s[i])) {
> - i++;
> - continue;
> - }
> - j = 0;
> - while (s[i + j] && !is_delimiter(s[i + j])) {
> - j++;
> - }
> - key = xmemdup0(s + i, j);
> - version = ofputil_version_from_string(key);
> - if (!version) {
> - VLOG_FATAL("Unknown OpenFlow version: \"%s\"", key);
> - }
> - free(key);
> - bitmap |= 1u << version;
> - i += j;
> - }
> -
> - return bitmap;
> -}
> -
> -uint32_t
> -ofputil_versions_from_strings(char ** const s, size_t count)
> -{
> - uint32_t bitmap = 0;
> -
> - while (count--) {
> - int version = ofputil_version_from_string(s[count]);
> - if (!version) {
> - VLOG_WARN("Unknown OpenFlow version: \"%s\"", s[count]);
> - } else {
> - bitmap |= 1u << version;
> - }
> - }
> -
> - return bitmap;
> -}
> -
> -const char *
> -ofputil_version_to_string(enum ofp_version ofp_version)
> -{
> - switch (ofp_version) {
> - case OFP10_VERSION:
> - return "OpenFlow10";
> - case OFP11_VERSION:
> - return "OpenFlow11";
> - case OFP12_VERSION:
> - return "OpenFlow12";
> - case OFP13_VERSION:
> - return "OpenFlow13";
> - case OFP14_VERSION:
> - return "OpenFlow14";
> - case OFP15_VERSION:
> - return "OpenFlow15";
> - case OFP16_VERSION:
> - return "OpenFlow16";
> - default:
> - OVS_NOT_REACHED();
> - }
> -}
> -
> -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);
> -}
> -
> -void
> -ofputil_format_version(struct ds *msg, enum ofp_version version)
> -{
> - ds_put_format(msg, "0x%02x", version);
> -}
> -
> -void
> -ofputil_format_version_name(struct ds *msg, enum ofp_version version)
> -{
> - ds_put_cstr(msg, ofputil_version_to_string(version));
> -}
> -
> -static void
> -ofputil_format_version_bitmap__(struct ds *msg, uint32_t bitmap,
> - void (*format_version)(struct ds *msg,
> - enum ofp_version))
> -{
> - while (bitmap) {
> - format_version(msg, raw_ctz(bitmap));
> - bitmap = zero_rightmost_1bit(bitmap);
> - if (bitmap) {
> - ds_put_cstr(msg, ", ");
> - }
> - }
> -}
> -
> -void
> -ofputil_format_version_bitmap(struct ds *msg, uint32_t bitmap)
> -{
> - ofputil_format_version_bitmap__(msg, bitmap, ofputil_format_version);
> -}
> -
> -void
> -ofputil_format_version_bitmap_names(struct ds *msg, uint32_t bitmap)
> -{
> - ofputil_format_version_bitmap__(msg, bitmap,
> ofputil_format_version_name);
> -}
> -
> -static bool
> -ofputil_decode_hello_bitmap(const struct ofp_hello_elem_header *oheh,
> - uint32_t *allowed_versionsp)
> -{
> - uint16_t bitmap_len = ntohs(oheh->length) - sizeof *oheh;
> - const ovs_be32 *bitmap = ALIGNED_CAST(const ovs_be32 *, oheh + 1);
> - uint32_t allowed_versions;
> -
> - if (!bitmap_len || bitmap_len % sizeof *bitmap) {
> - return false;
> - }
> -
> - /* Only use the first 32-bit element of the bitmap as that is all the
> - * current implementation supports. Subsequent elements are ignored
> which
> - * should have no effect on session negotiation until Open vSwitch
> supports
> - * wire-protocol versions greater than 31.
> - */
> - allowed_versions = ntohl(bitmap[0]);
> -
> - if (allowed_versions & 1) {
> - /* There's no OpenFlow version 0. */
> - VLOG_WARN_RL(&bad_ofmsg_rl, "peer claims to support invalid
> OpenFlow "
> - "version 0x00");
> - allowed_versions &= ~1u;
> - }
> -
> - if (!allowed_versions) {
> - VLOG_WARN_RL(&bad_ofmsg_rl, "peer does not support any OpenFlow "
> - "version (between 0x01 and 0x1f)");
> - return false;
> - }
> -
> - *allowed_versionsp = allowed_versions;
> - return true;
> -}
> -
> -static uint32_t
> -version_bitmap_from_version(uint8_t ofp_version)
> -{
> - return ((ofp_version < 32 ? 1u << ofp_version : 0) - 1) << 1;
> -}
> -
> -/* Decodes OpenFlow OFPT_HELLO message 'oh', storing into
> '*allowed_versions'
> - * the set of OpenFlow versions for which 'oh' announces support.
> - *
> - * Because of how OpenFlow defines OFPT_HELLO messages, this function is
> always
> - * successful, and thus '*allowed_versions' is always initialized.
> However, it
> - * returns false if 'oh' contains some data that could not be fully
> understood,
> - * true if 'oh' was completely parsed. */
> -bool
> -ofputil_decode_hello(const struct ofp_header *oh, uint32_t
> *allowed_versions)
> -{
> - struct ofpbuf msg = ofpbuf_const_initializer(oh, ntohs(oh->length));
> - ofpbuf_pull(&msg, sizeof *oh);
> -
> - *allowed_versions = version_bitmap_from_version(oh->version);
> -
> - bool ok = true;
> - while (msg.size) {
> - const struct ofp_hello_elem_header *oheh;
> - unsigned int len;
> -
> - if (msg.size < sizeof *oheh) {
> - return false;
> - }
> -
> - oheh = msg.data;
> - len = ntohs(oheh->length);
> - if (len < sizeof *oheh || !ofpbuf_try_pull(&msg, ROUND_UP(len,
> 8))) {
> - return false;
> - }
> -
> - if (oheh->type != htons(OFPHET_VERSIONBITMAP)
> - || !ofputil_decode_hello_bitmap(oheh, allowed_versions)) {
> - ok = false;
> - }
> - }
> -
> - return ok;
> -}
> -
> -/* Returns true if 'allowed_versions' needs to be accompanied by a version
> - * bitmap to be correctly expressed in an OFPT_HELLO message. */
> -static bool
> -should_send_version_bitmap(uint32_t allowed_versions)
> -{
> - return !is_pow2((allowed_versions >> 1) + 1);
> -}
> -
> -/* Create an OFPT_HELLO message that expresses support for the OpenFlow
> - * versions in the 'allowed_versions' bitmaps and returns the message. */
> -struct ofpbuf *
> -ofputil_encode_hello(uint32_t allowed_versions)
> -{
> - enum ofp_version ofp_version;
> - struct ofpbuf *msg;
> -
> - ofp_version = leftmost_1bit_idx(allowed_versions);
> - msg = ofpraw_alloc(OFPRAW_OFPT_HELLO, ofp_version, 0);
> -
> - if (should_send_version_bitmap(allowed_versions)) {
> - struct ofp_hello_elem_header *oheh;
> - uint16_t map_len;
> -
> - map_len = sizeof allowed_versions;
> - oheh = ofpbuf_put_zeros(msg, ROUND_UP(map_len + sizeof *oheh, 8));
> - oheh->type = htons(OFPHET_VERSIONBITMAP);
> - oheh->length = htons(map_len + sizeof *oheh);
> - *ALIGNED_CAST(ovs_be32 *, oheh + 1) = htonl(allowed_versions);
> -
> - ofpmsg_update_length(msg);
> - }
> -
> - return msg;
> -}
> -
> -/* Returns an OpenFlow message that, sent on an OpenFlow connection whose
> - * protocol is 'current', at least partly transitions the protocol to
> 'want'.
> - * Stores in '*next' the protocol that will be in effect on the OpenFlow
> - * connection if the switch processes the returned message correctly. (If
> - * '*next != want' then the caller will have to iterate.)
> - *
> - * If 'current == want', or if it is not possible to transition from
> 'current'
> - * to 'want' (because, for example, 'current' and 'want' use different
> OpenFlow
> - * protocol versions), returns NULL and stores 'current' in '*next'. */
> -struct ofpbuf *
> -ofputil_encode_set_protocol(enum ofputil_protocol current,
> - enum ofputil_protocol want,
> - enum ofputil_protocol *next)
> -{
> - enum ofp_version cur_version, want_version;
> - enum ofputil_protocol cur_base, want_base;
> - bool cur_tid, want_tid;
> -
> - cur_version = ofputil_protocol_to_ofp_version(current);
> - want_version = ofputil_protocol_to_ofp_version(want);
> - if (cur_version != want_version) {
> - *next = current;
> - return NULL;
> - }
> -
> - cur_base = ofputil_protocol_to_base(current);
> - want_base = ofputil_protocol_to_base(want);
> - if (cur_base != want_base) {
> - *next = ofputil_protocol_set_base(current, want_base);
> -
> - switch (want_base) {
> - case OFPUTIL_P_OF10_NXM:
> - return ofputil_encode_nx_set_flow_format(NXFF_NXM);
> -
> - case OFPUTIL_P_OF10_STD:
> - return ofputil_encode_nx_set_flow_format(NXFF_OPENFLOW10);
> -
> - 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:
> - /* There is only one variant of each OpenFlow 1.1+ protocol,
> and we
> - * verified above that we're not trying to change versions. */
> - OVS_NOT_REACHED();
> -
> - case OFPUTIL_P_OF10_STD_TID:
> - case OFPUTIL_P_OF10_NXM_TID:
> - OVS_NOT_REACHED();
> - }
> - }
> -
> - cur_tid = (current & OFPUTIL_P_TID) != 0;
> - want_tid = (want & OFPUTIL_P_TID) != 0;
> - if (cur_tid != want_tid) {
> - *next = ofputil_protocol_set_tid(current, want_tid);
> - return ofputil_make_flow_mod_table_id(want_tid);
> - }
> -
> - ovs_assert(current == want);
> -
> - *next = current;
> - return NULL;
> -}
> -
> -/* 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();
> - }
> -}
> -
> -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;
> -}
> -
> -/* 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(&bad_ofmsg_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 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(&bad_ofmsg_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(&bad_ofmsg_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;
> -}
> -
> -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;
> -}
> -
> -/* Constructs and returns an OFPT_QUEUE_GET_CONFIG request for the
> specified
> - * 'port' and 'queue', suitable for OpenFlow version 'version'.
> - *
> - * 'queue' is honored only for OpenFlow 1.4 and later; older versions
> always
> - * request all queues. */
> -struct ofpbuf *
> -ofputil_encode_queue_get_config_request(enum ofp_version version,
> - ofp_port_t port,
> - uint32_t queue)
> -{
> - struct ofpbuf *request;
> -
> - if (version == OFP10_VERSION) {
> - struct ofp10_queue_get_config_request *qgcr10;
> -
> - request = ofpraw_alloc(OFPRAW_OFPT10_QUEUE_GET_CONFIG_REQUEST,
> - version, 0);
> - qgcr10 = ofpbuf_put_zeros(request, sizeof *qgcr10);
> - qgcr10->port = htons(ofp_to_u16(port));
> - } else if (version < OFP14_VERSION) {
> - struct ofp11_queue_get_config_request *qgcr11;
> -
> - request = ofpraw_alloc(OFPRAW_OFPT11_QUEUE_GET_CONFIG_REQUEST,
> - version, 0);
> - qgcr11 = ofpbuf_put_zeros(request, sizeof *qgcr11);
> - qgcr11->port = ofputil_port_to_ofp11(port);
> - } else {
> - struct ofp14_queue_desc_request *qdr14;
> -
> - request = ofpraw_alloc(OFPRAW_OFPST14_QUEUE_DESC_REQUEST,
> - version, 0);
> - qdr14 = ofpbuf_put_zeros(request, sizeof *qdr14);
> - qdr14->port = ofputil_port_to_ofp11(port);
> - qdr14->queue = htonl(queue);
> - }
> -
> - return request;
> -}
> -
> -/* Parses OFPT_QUEUE_GET_CONFIG request 'oh', storing the port specified
> by the
> - * request into '*port'. Returns 0 if successful, otherwise an OpenFlow
> error
> - * code. */
> -enum ofperr
> -ofputil_decode_queue_get_config_request(const struct ofp_header *oh,
> - ofp_port_t *port, uint32_t *queue)
> -{
> - const struct ofp10_queue_get_config_request *qgcr10;
> - const struct ofp11_queue_get_config_request *qgcr11;
> - const struct ofp14_queue_desc_request *qdr14;
> - struct ofpbuf b = ofpbuf_const_initializer(oh, ntohs(oh->length));
> - enum ofpraw raw = ofpraw_pull_assert(&b);
> -
> - switch ((int) raw) {
> - case OFPRAW_OFPT10_QUEUE_GET_CONFIG_REQUEST:
> - qgcr10 = b.data;
> - *port = u16_to_ofp(ntohs(qgcr10->port));
> - *queue = OFPQ_ALL;
> - break;
> -
> - case OFPRAW_OFPT11_QUEUE_GET_CONFIG_REQUEST:
> - qgcr11 = b.data;
> - *queue = OFPQ_ALL;
> - enum ofperr error = ofputil_port_from_ofp11(qgcr11->port, port);
> - if (error || *port == OFPP_ANY) {
> - return error;
> - }
> - break;
> -
> - case OFPRAW_OFPST14_QUEUE_DESC_REQUEST:
> - qdr14 = b.data;
> - *queue = ntohl(qdr14->queue);
> - return ofputil_port_from_ofp11(qdr14->port, port);
> -
> - default:
> - OVS_NOT_REACHED();
> - }
> -
> - return (ofp_to_u16(*port) < ofp_to_u16(OFPP_MAX)
> - ? 0
> - : OFPERR_OFPQOFC_BAD_PORT);
> -}
> -
> -/* Constructs and returns the beginning of a reply to
> - * OFPT_QUEUE_GET_CONFIG_REQUEST or OFPMP_QUEUE_DESC request 'oh'. The
> caller
> - * may append information about individual queues with
> - * ofputil_append_queue_get_config_reply(). */
> -void
> -ofputil_start_queue_get_config_reply(const struct ofp_header *request,
> - struct ovs_list *replies)
> -{
> - struct ofpbuf *reply;
> - ofp_port_t port;
> - uint32_t queue;
> -
> - ovs_assert(!ofputil_decode_queue_get_config_request(request, &port,
> - &queue));
> -
> - enum ofpraw raw = ofpraw_decode_assert(request);
> - switch ((int) raw) {
> - case OFPRAW_OFPT10_QUEUE_GET_CONFIG_REQUEST:
> - reply = ofpraw_alloc_reply(OFPRAW_OFPT10_QUEUE_GET_CONFIG_REPLY,
> - request, 0);
> - struct ofp10_queue_get_config_reply *qgcr10
> - = ofpbuf_put_zeros(reply, sizeof *qgcr10);
> - qgcr10->port = htons(ofp_to_u16(port));
> - break;
> -
> - case OFPRAW_OFPT11_QUEUE_GET_CONFIG_REQUEST:
> - reply = ofpraw_alloc_reply(OFPRAW_OFPT11_QUEUE_GET_CONFIG_REPLY,
> - request, 0);
> - struct ofp11_queue_get_config_reply *qgcr11
> - = ofpbuf_put_zeros(reply, sizeof *qgcr11);
> - qgcr11->port = ofputil_port_to_ofp11(port);
> - break;
> -
> - case OFPRAW_OFPST14_QUEUE_DESC_REQUEST:
> - reply = ofpraw_alloc_stats_reply(request, 0);
> - break;
> -
> - default:
> - OVS_NOT_REACHED();
> - }
> -
> - ovs_list_init(replies);
> - ovs_list_push_back(replies, &reply->list_node);
> -}
> -
> -static void
> -put_ofp10_queue_rate(struct ofpbuf *reply,
> - enum ofp10_queue_properties property, uint16_t rate)
> -{
> - if (rate != UINT16_MAX) {
> - struct ofp10_queue_prop_rate *oqpr;
> -
> - oqpr = ofpbuf_put_zeros(reply, sizeof *oqpr);
> - oqpr->prop_header.property = htons(property);
> - oqpr->prop_header.len = htons(sizeof *oqpr);
> - oqpr->rate = htons(rate);
> - }
> -}
> -
> -static void
> -put_ofp14_queue_rate(struct ofpbuf *reply,
> - enum ofp14_queue_desc_prop_type type, uint16_t rate)
> -{
> - if (rate != UINT16_MAX) {
> - ofpprop_put_u16(reply, type, rate);
> - }
> -}
> -
> -void
> -ofputil_append_queue_get_config_reply(const struct ofputil_queue_config
> *qc,
> - struct ovs_list *replies)
> -{
> - enum ofp_version ofp_version = ofpmp_version(replies);
> - struct ofpbuf *reply = ofpbuf_from_list(ovs_list_back(replies));
> - size_t start_ofs = reply->size;
> - size_t len_ofs;
> - ovs_be16 *len;
> -
> - if (ofp_version < OFP14_VERSION) {
> - if (ofp_version < OFP12_VERSION) {
> - struct ofp10_packet_queue *opq10;
> -
> - opq10 = ofpbuf_put_zeros(reply, sizeof *opq10);
> - opq10->queue_id = htonl(qc->queue);
> - len_ofs = (char *) &opq10->len - (char *) reply->data;
> - } else {
> - struct ofp12_packet_queue *opq12;
> -
> - opq12 = ofpbuf_put_zeros(reply, sizeof *opq12);
> - opq12->port = ofputil_port_to_ofp11(qc->port);
> - opq12->queue_id = htonl(qc->queue);
> - len_ofs = (char *) &opq12->len - (char *) reply->data;
> - }
> -
> - put_ofp10_queue_rate(reply, OFPQT10_MIN_RATE, qc->min_rate);
> - put_ofp10_queue_rate(reply, OFPQT11_MAX_RATE, qc->max_rate);
> - } else {
> - struct ofp14_queue_desc *oqd = ofpbuf_put_zeros(reply, sizeof
> *oqd);
> - oqd->port_no = ofputil_port_to_ofp11(qc->port);
> - oqd->queue_id = htonl(qc->queue);
> - len_ofs = (char *) &oqd->len - (char *) reply->data;
> - put_ofp14_queue_rate(reply, OFPQDPT14_MIN_RATE, qc->min_rate);
> - put_ofp14_queue_rate(reply, OFPQDPT14_MAX_RATE, qc->max_rate);
> - }
> -
> - len = ofpbuf_at(reply, len_ofs, sizeof *len);
> - *len = htons(reply->size - start_ofs);
> -
> - if (ofp_version >= OFP14_VERSION) {
> - ofpmp_postappend(replies, start_ofs);
> - }
> -}
> -
> -static enum ofperr
> -parse_ofp10_queue_rate(const struct ofp10_queue_prop_header *hdr,
> - uint16_t *rate)
> -{
> - const struct ofp10_queue_prop_rate *oqpr;
> -
> - if (hdr->len == htons(sizeof *oqpr)) {
> - oqpr = (const struct ofp10_queue_prop_rate *) hdr;
> - *rate = ntohs(oqpr->rate);
> - return 0;
> - } else {
> - return OFPERR_OFPBRC_BAD_LEN;
> - }
> -}
> -
> -static int
> -ofputil_pull_queue_get_config_reply10(struct ofpbuf *msg,
> - struct ofputil_queue_config *queue)
> -{
> - const struct ofp_header *oh = msg->header;
> - unsigned int opq_len; /* Length of protocol-specific queue
> header. */
> - unsigned int len; /* Total length of queue + properties. */
> -
> - /* Obtain the port number from the message header. */
> - if (oh->version == OFP10_VERSION) {
> - const struct ofp10_queue_get_config_reply *oqgcr10 = msg->msg;
> - queue->port = u16_to_ofp(ntohs(oqgcr10->port));
> - } else {
> - const struct ofp11_queue_get_config_reply *oqgcr11 = msg->msg;
> - enum ofperr error = ofputil_port_from_ofp11(oqgcr11->port,
> - &queue->port);
> - if (error) {
> - return error;
> - }
> - }
> -
> - /* Pull off the queue header and get the queue number and length. */
> - if (oh->version < OFP12_VERSION) {
> - const struct ofp10_packet_queue *opq10;
> - opq10 = ofpbuf_try_pull(msg, sizeof *opq10);
> - if (!opq10) {
> - return OFPERR_OFPBRC_BAD_LEN;
> - }
> - queue->queue = ntohl(opq10->queue_id);
> - len = ntohs(opq10->len);
> - opq_len = sizeof *opq10;
> - } else {
> - const struct ofp12_packet_queue *opq12;
> - opq12 = ofpbuf_try_pull(msg, sizeof *opq12);
> - if (!opq12) {
> - return OFPERR_OFPBRC_BAD_LEN;
> - }
> - queue->queue = ntohl(opq12->queue_id);
> - len = ntohs(opq12->len);
> - opq_len = sizeof *opq12;
> - }
> -
> - /* Length check. */
> - if (len < opq_len || len > msg->size + opq_len || len % 8) {
> - return OFPERR_OFPBRC_BAD_LEN;
> - }
> - len -= opq_len;
> -
> - /* Pull properties. The format of these properties differs from used
> in
> - * OF1.4+ so we can't use the common property functions. */
> - while (len > 0) {
> - const struct ofp10_queue_prop_header *hdr;
> - unsigned int property;
> - unsigned int prop_len;
> - enum ofperr error = 0;
> -
> - hdr = ofpbuf_at_assert(msg, 0, sizeof *hdr);
> - prop_len = ntohs(hdr->len);
> - if (prop_len < sizeof *hdr || prop_len > len || prop_len % 8) {
> - return OFPERR_OFPBRC_BAD_LEN;
> - }
> -
> - property = ntohs(hdr->property);
> - switch (property) {
> - case OFPQT10_MIN_RATE:
> - error = parse_ofp10_queue_rate(hdr, &queue->min_rate);
> - break;
> -
> - case OFPQT11_MAX_RATE:
> - error = parse_ofp10_queue_rate(hdr, &queue->max_rate);
> - break;
> -
> - default:
> - VLOG_INFO_RL(&bad_ofmsg_rl, "unknown queue property %u",
> property);
> - break;
> - }
> - if (error) {
> - return error;
> - }
> -
> - ofpbuf_pull(msg, prop_len);
> - len -= prop_len;
> - }
> - return 0;
> -}
> -
> -static int
> -ofputil_pull_queue_get_config_reply14(struct ofpbuf *msg,
> - struct ofputil_queue_config *queue)
> -{
> - struct ofp14_queue_desc *oqd14 = ofpbuf_try_pull(msg, sizeof *oqd14);
> - if (!oqd14) {
> - return OFPERR_OFPBRC_BAD_LEN;
> - }
> - enum ofperr error = ofputil_port_from_ofp11(oqd14->port_no,
> &queue->port);
> - if (error) {
> - return error;
> - }
> - queue->queue = ntohl(oqd14->queue_id);
> -
> - /* Length check. */
> - unsigned int len = ntohs(oqd14->len);
> - if (len < sizeof *oqd14 || len > msg->size + sizeof *oqd14 || len %
> 8) {
> - return OFPERR_OFPBRC_BAD_LEN;
> - }
> - len -= sizeof *oqd14;
> -
> - struct ofpbuf properties = ofpbuf_const_initializer(ofpbuf_pull(msg,
> len),
> - len);
> - while (properties.size > 0) {
> - struct ofpbuf payload;
> - uint64_t type;
> -
> - error = ofpprop_pull(&properties, &payload, &type);
> - if (error) {
> - return error;
> - }
> -
> - switch (type) {
> - case OFPQDPT14_MIN_RATE:
> - error = ofpprop_parse_u16(&payload, &queue->min_rate);
> - break;
> -
> - case OFPQDPT14_MAX_RATE:
> - error = ofpprop_parse_u16(&payload, &queue->max_rate);
> - break;
> -
> - default:
> - error = OFPPROP_UNKNOWN(true, "queue desc", type);
> - break;
> - }
> -
> - if (error) {
> - return error;
> - }
> - }
> -
> - return 0;
> -}
> -
> -/* Decodes information about a queue from the OFPT_QUEUE_GET_CONFIG_REPLY
> in
> - * 'reply' and stores it in '*queue'. ofputil_decode_queue_get_
> config_reply()
> - * must already have pulled off the main header.
> - *
> - * This function returns EOF if the last queue has already been decoded,
> 0 if a
> - * queue was successfully decoded into '*queue', or an ofperr if there
> was a
> - * problem decoding 'reply'. */
> -int
> -ofputil_pull_queue_get_config_reply(struct ofpbuf *msg,
> - struct ofputil_queue_config *queue)
> -{
> - enum ofpraw raw;
> - if (!msg->header) {
> - /* Pull OpenFlow header. */
> - raw = ofpraw_pull_assert(msg);
> -
> - /* Pull protocol-specific ofp_queue_get_config_reply header (OF1.4
> - * doesn't have one at all). */
> - if (raw == OFPRAW_OFPT10_QUEUE_GET_CONFIG_REPLY) {
> - ofpbuf_pull(msg, sizeof(struct ofp10_queue_get_config_reply))
> ;
> - } else if (raw == OFPRAW_OFPT11_QUEUE_GET_CONFIG_REPLY) {
> - ofpbuf_pull(msg, sizeof(struct ofp11_queue_get_config_reply))
> ;
> - } else {
> - ovs_assert(raw == OFPRAW_OFPST14_QUEUE_DESC_REPLY);
> - }
> - } else {
> - raw = ofpraw_decode_assert(msg->header);
> - }
> -
> - queue->min_rate = UINT16_MAX;
> - queue->max_rate = UINT16_MAX;
> -
> - if (!msg->size) {
> - return EOF;
> - } else if (raw == OFPRAW_OFPST14_QUEUE_DESC_REPLY) {
> - return ofputil_pull_queue_get_config_reply14(msg, queue);
> - } else {
> - return ofputil_pull_queue_get_config_reply10(msg, queue);
> - }
> -}
> -
> -/* 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;
> -}
> -
> -/* 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(&bad_ofmsg_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(&bad_ofmsg_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(&bad_ofmsg_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(&bad_ofmsg_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(&bad_ofmsg_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(&bad_ofmsg_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(&bad_ofmsg_rl, "NXST_FLOW reply with
> match_len=%"PRIuSIZE" "
> - "claims invalid length %"PRIuSIZE, match_len,
> length);
> - return EINVAL;
> - }
> - if (nx_pull_match(msg, match_len, &fs->match, NULL, NULL, 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(&bad_ofmsg_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;
> -}
> -
> -/* 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;
> -}
> -
> -/* 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;
> -}
> -
> -/* 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(&bad_ofmsg_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(&bad_ofmsg_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(&bad_ofmsg_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(&bad_ofmsg_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(&bad_ofmsg_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;
> -}
> -
> -/* ofputil_phy_port */
> -
> -/* NETDEV_F_* to and from OFPPF_* and OFPPF10_*. */
> -BUILD_ASSERT_DECL((int) NETDEV_F_10MB_HD == OFPPF_10MB_HD); /* bit 0
> */
> -BUILD_ASSERT_DECL((int) NETDEV_F_10MB_FD == OFPPF_10MB_FD); /* bit 1
> */
> -BUILD_ASSERT_DECL((int) NETDEV_F_100MB_HD == OFPPF_100MB_HD); /* bit 2
> */
> -BUILD_ASSERT_DECL((int) NETDEV_F_100MB_FD == OFPPF_100MB_FD); /* bit 3
> */
> -BUILD_ASSERT_DECL((int) NETDEV_F_1GB_HD == OFPPF_1GB_HD); /* bit 4
> */
> -BUILD_ASSERT_DECL((int) NETDEV_F_1GB_FD == OFPPF_1GB_FD); /* bit 5
> */
> -BUILD_ASSERT_DECL((int) NETDEV_F_10GB_FD == OFPPF_10GB_FD); /* bit 6
> */
> -
> -/* NETDEV_F_ bits 11...15 are OFPPF10_ bits 7...11: */
> -BUILD_ASSERT_DECL((int) NETDEV_F_COPPER == (OFPPF10_COPPER << 4));
> -BUILD_ASSERT_DECL((int) NETDEV_F_FIBER == (OFPPF10_FIBER << 4));
> -BUILD_ASSERT_DECL((int) NETDEV_F_AUTONEG == (OFPPF10_AUTONEG << 4));
> -BUILD_ASSERT_DECL((int) NETDEV_F_PAUSE == (OFPPF10_PAUSE << 4));
> -BUILD_ASSERT_DECL((int) NETDEV_F_PAUSE_ASYM == (OFPPF10_PAUSE_ASYM << 4));
> -
> -static enum netdev_features
> -netdev_port_features_from_ofp10(ovs_be32 ofp10_)
> -{
> - uint32_t ofp10 = ntohl(ofp10_);
> - return (ofp10 & 0x7f) | ((ofp10 & 0xf80) << 4);
> -}
> -
> -static ovs_be32
> -netdev_port_features_to_ofp10(enum netdev_features features)
> -{
> - return htonl((features & 0x7f) | ((features & 0xf800) >> 4));
> -}
> -
> -BUILD_ASSERT_DECL((int) NETDEV_F_10MB_HD == OFPPF_10MB_HD); /* bit
> 0 */
> -BUILD_ASSERT_DECL((int) NETDEV_F_10MB_FD == OFPPF_10MB_FD); /* bit
> 1 */
> -BUILD_ASSERT_DECL((int) NETDEV_F_100MB_HD == OFPPF_100MB_HD); /* bit
> 2 */
> -BUILD_ASSERT_DECL((int) NETDEV_F_100MB_FD == OFPPF_100MB_FD); /* bit
> 3 */
> -BUILD_ASSERT_DECL((int) NETDEV_F_1GB_HD == OFPPF_1GB_HD); /* bit
> 4 */
> -BUILD_ASSERT_DECL((int) NETDEV_F_1GB_FD == OFPPF_1GB_FD); /* bit
> 5 */
> -BUILD_ASSERT_DECL((int) NETDEV_F_10GB_FD == OFPPF_10GB_FD); /* bit
> 6 */
> -BUILD_ASSERT_DECL((int) NETDEV_F_40GB_FD == OFPPF11_40GB_FD); /* bit
> 7 */
> -BUILD_ASSERT_DECL((int) NETDEV_F_100GB_FD == OFPPF11_100GB_FD); /* bit
> 8 */
> -BUILD_ASSERT_DECL((int) NETDEV_F_1TB_FD == OFPPF11_1TB_FD); /* bit
> 9 */
> -BUILD_ASSERT_DECL((int) NETDEV_F_OTHER == OFPPF11_OTHER); /* bit
> 10 */
> -BUILD_ASSERT_DECL((int) NETDEV_F_COPPER == OFPPF11_COPPER); /* bit
> 11 */
> -BUILD_ASSERT_DECL((int) NETDEV_F_FIBER == OFPPF11_FIBER); /* bit
> 12 */
> -BUILD_ASSERT_DECL((int) NETDEV_F_AUTONEG == OFPPF11_AUTONEG); /* bit
> 13 */
> -BUILD_ASSERT_DECL((int) NETDEV_F_PAUSE == OFPPF11_PAUSE); /* bit
> 14 */
> -BUILD_ASSERT_DECL((int) NETDEV_F_PAUSE_ASYM == OFPPF11_PAUSE_ASYM);/* bit
> 15 */
> -
> -static enum netdev_features
> -netdev_port_features_from_ofp11(ovs_be32 ofp11)
> -{
> - return ntohl(ofp11) & 0xffff;
> -}
> -
> -static ovs_be32
> -netdev_port_features_to_ofp11(enum netdev_features features)
> -{
> - return htonl(features & 0xffff);
> -}
> -
> -static enum ofperr
> -ofputil_decode_ofp10_phy_port(struct ofputil_phy_port *pp,
> - const struct ofp10_phy_port *opp)
> -{
> - pp->port_no = u16_to_ofp(ntohs(opp->port_no));
> - pp->hw_addr = opp->hw_addr;
> - ovs_strlcpy_arrays(pp->name, opp->name);
> -
> - pp->config = ntohl(opp->config) & OFPPC10_ALL;
> - pp->state = ntohl(opp->state) & OFPPS10_ALL;
> -
> - pp->curr = netdev_port_features_from_ofp10(opp->curr);
> - pp->advertised = netdev_port_features_from_ofp10(opp->advertised);
> - pp->supported = netdev_port_features_from_ofp10(opp->supported);
> - pp->peer = netdev_port_features_from_ofp10(opp->peer);
> -
> - pp->curr_speed = netdev_features_to_bps(pp->curr, 0) / 1000;
> - pp->max_speed = netdev_features_to_bps(pp->supported, 0) / 1000;
> -
> - return 0;
> -}
> -
> -static enum ofperr
> -ofputil_decode_ofp11_port(struct ofputil_phy_port *pp,
> - const struct ofp11_port *op)
> -{
> - enum ofperr error;
> -
> - error = ofputil_port_from_ofp11(op->port_no, &pp->port_no);
> - if (error) {
> - return error;
> - }
> - pp->hw_addr = op->hw_addr;
> - ovs_strlcpy_arrays(pp->name, op->name);
> -
> - pp->config = ntohl(op->config) & OFPPC11_ALL;
> - pp->state = ntohl(op->state) & OFPPS11_ALL;
> -
> - pp->curr = netdev_port_features_from_ofp11(op->curr);
> - pp->advertised = netdev_port_features_from_ofp11(op->advertised);
> - pp->supported = netdev_port_features_from_ofp11(op->supported);
> - pp->peer = netdev_port_features_from_ofp11(op->peer);
> -
> - pp->curr_speed = ntohl(op->curr_speed);
> - pp->max_speed = ntohl(op->max_speed);
> -
> - return 0;
> -}
> -
> -static enum ofperr
> -parse_ofp14_port_ethernet_property(const struct ofpbuf *payload,
> - struct ofputil_phy_port *pp)
> -{
> - struct ofp14_port_desc_prop_ethernet *eth = payload->data;
> -
> - if (payload->size != sizeof *eth) {
> - return OFPERR_OFPBPC_BAD_LEN;
> - }
> -
> - pp->curr = netdev_port_features_from_ofp11(eth->curr);
> - pp->advertised = netdev_port_features_from_ofp11(eth->advertised);
> - pp->supported = netdev_port_features_from_ofp11(eth->supported);
> - pp->peer = netdev_port_features_from_ofp11(eth->peer);
> -
> - pp->curr_speed = ntohl(eth->curr_speed);
> - pp->max_speed = ntohl(eth->max_speed);
> -
> - return 0;
> -}
> -
> -static enum ofperr
> -ofputil_pull_ofp14_port_properties(const void *props, size_t len,
> - struct ofputil_phy_port *pp)
> -{
> - struct ofpbuf properties = ofpbuf_const_initializer(props, 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 OFPPDPT14_ETHERNET:
> - error = parse_ofp14_port_ethernet_property(&payload, pp);
> - break;
> -
> - default:
> - error = OFPPROP_UNKNOWN(true, "port", type);
> - break;
> - }
> -
> - if (error) {
> - return error;
> - }
> - }
> -
> - return 0;
> -}
> -
> -static enum ofperr
> -ofputil_pull_ofp14_port(struct ofputil_phy_port *pp, struct ofpbuf *msg)
> -{
> - const struct ofp14_port *op = ofpbuf_try_pull(msg, sizeof *op);
> - if (!op) {
> - return OFPERR_OFPBRC_BAD_LEN;
> - }
> -
> - size_t len = ntohs(op->length);
> - if (len < sizeof *op || len - sizeof *op > msg->size) {
> - return OFPERR_OFPBRC_BAD_LEN;
> - }
> - len -= sizeof *op;
> -
> - enum ofperr error = ofputil_port_from_ofp11(op->port_no,
> &pp->port_no);
> - if (error) {
> - return error;
> - }
> - pp->hw_addr = op->hw_addr;
> - ovs_strlcpy_arrays(pp->name, op->name);
> -
> - pp->config = ntohl(op->config) & OFPPC11_ALL;
> - pp->state = ntohl(op->state) & OFPPS11_ALL;
> -
> - return ofputil_pull_ofp14_port_properties(ofpbuf_pull(msg, len),
> len, pp);
> -}
> -
> -static enum ofperr
> -ofputil_pull_ofp16_port(struct ofputil_phy_port *pp, struct ofpbuf *msg)
> -{
> - const struct ofp16_port *op = ofpbuf_try_pull(msg, sizeof *op);
> - if (!op) {
> - return OFPERR_OFPBRC_BAD_LEN;
> - }
> -
> - size_t len = ntohs(op->length);
> - if (len < sizeof *op || len - sizeof *op > msg->size) {
> - return OFPERR_OFPBRC_BAD_LEN;
> - }
> - len -= sizeof *op;
> -
> - enum ofperr error = ofputil_port_from_ofp11(op->port_no,
> &pp->port_no);
> - if (error) {
> - return error;
> - }
> - pp->hw_addr = op->hw_addr;
> - pp->hw_addr64 = op->hw_addr64;
> - ovs_strlcpy_arrays(pp->name, op->name);
> -
> - pp->config = ntohl(op->config) & OFPPC11_ALL;
> - pp->state = ntohl(op->state) & OFPPS11_ALL;
> -
> - return ofputil_pull_ofp14_port_properties(ofpbuf_pull(msg, len),
> len, pp);
> -}
> -
> -static void
> -ofputil_encode_ofp10_phy_port(const struct ofputil_phy_port *pp,
> - struct ofp10_phy_port *opp)
> -{
> - memset(opp, 0, sizeof *opp);
> -
> - opp->port_no = htons(ofp_to_u16(pp->port_no));
> - opp->hw_addr = pp->hw_addr;
> - ovs_strlcpy_arrays(opp->name, pp->name);
> -
> - opp->config = htonl(pp->config & OFPPC10_ALL);
> - opp->state = htonl(pp->state & OFPPS10_ALL);
> -
> - opp->curr = netdev_port_features_to_ofp10(pp->curr);
> - opp->advertised = netdev_port_features_to_ofp10(pp->advertised);
> - opp->supported = netdev_port_features_to_ofp10(pp->supported);
> - opp->peer = netdev_port_features_to_ofp10(pp->peer);
> -}
> -
> -static void
> -ofputil_encode_ofp11_port(const struct ofputil_phy_port *pp,
> - struct ofp11_port *op)
> -{
> - memset(op, 0, sizeof *op);
> -
> - op->port_no = ofputil_port_to_ofp11(pp->port_no);
> - op->hw_addr = pp->hw_addr;
> - ovs_strlcpy_arrays(op->name, pp->name);
> -
> - op->config = htonl(pp->config & OFPPC11_ALL);
> - op->state = htonl(pp->state & OFPPS11_ALL);
> -
> - op->curr = netdev_port_features_to_ofp11(pp->curr);
> - op->advertised = netdev_port_features_to_ofp11(pp->advertised);
> - op->supported = netdev_port_features_to_ofp11(pp->supported);
> - op->peer = netdev_port_features_to_ofp11(pp->peer);
> -
> - op->curr_speed = htonl(pp->curr_speed);
> - op->max_speed = htonl(pp->max_speed);
> -}
> -
> -static void
> -ofputil_encode_ofp14_port_ethernet_prop(
> - const struct ofputil_phy_port *pp,
> - struct ofp14_port_desc_prop_ethernet *eth)
> -{
> - eth->curr = netdev_port_features_to_ofp11(pp->curr);
> - eth->advertised = netdev_port_features_to_ofp11(pp->advertised);
> - eth->supported = netdev_port_features_to_ofp11(pp->supported);
> - eth->peer = netdev_port_features_to_ofp11(pp->peer);
> - eth->curr_speed = htonl(pp->curr_speed);
> - eth->max_speed = htonl(pp->max_speed);
> -}
> -
> -static void
> -ofputil_put_ofp14_port(const struct ofputil_phy_port *pp, struct ofpbuf
> *b)
> -{
> - struct ofp14_port *op;
> - struct ofp14_port_desc_prop_ethernet *eth;
> -
> - ofpbuf_prealloc_tailroom(b, sizeof *op + sizeof *eth);
> -
> - op = ofpbuf_put_zeros(b, sizeof *op);
> - op->port_no = ofputil_port_to_ofp11(pp->port_no);
> - op->length = htons(sizeof *op + sizeof *eth);
> - op->hw_addr = pp->hw_addr;
> - ovs_strlcpy_arrays(op->name, pp->name);
> - op->config = htonl(pp->config & OFPPC11_ALL);
> - op->state = htonl(pp->state & OFPPS11_ALL);
> -
> - eth = ofpprop_put_zeros(b, OFPPDPT14_ETHERNET, sizeof *eth);
> - ofputil_encode_ofp14_port_ethernet_prop(pp, eth);
> -}
> -
> -static void
> -ofputil_put_ofp16_port(const struct ofputil_phy_port *pp, struct ofpbuf
> *b)
> -{
> - struct ofp16_port *op;
> - struct ofp14_port_desc_prop_ethernet *eth;
> -
> - ofpbuf_prealloc_tailroom(b, sizeof *op + sizeof *eth);
> -
> - op = ofpbuf_put_zeros(b, sizeof *op);
> - op->port_no = ofputil_port_to_ofp11(pp->port_no);
> - op->length = htons(sizeof *op + sizeof *eth);
> - op->hw_addr = pp->hw_addr;
> - op->hw_addr64 = pp->hw_addr64;
> - ovs_strlcpy_arrays(op->name, pp->name);
> - op->config = htonl(pp->config & OFPPC11_ALL);
> - op->state = htonl(pp->state & OFPPS11_ALL);
> -
> - eth = ofpprop_put_zeros(b, OFPPDPT14_ETHERNET, sizeof *eth);
> - ofputil_encode_ofp14_port_ethernet_prop(pp, eth);
> -}
> -
> -static void
> -ofputil_put_phy_port(enum ofp_version ofp_version,
> - const struct ofputil_phy_port *pp, struct ofpbuf *b)
> -{
> - switch (ofp_version) {
> - case OFP10_VERSION: {
> - struct ofp10_phy_port *opp = ofpbuf_put_uninit(b, sizeof *opp);
> - ofputil_encode_ofp10_phy_port(pp, opp);
> - break;
> - }
> -
> - case OFP11_VERSION:
> - case OFP12_VERSION:
> - case OFP13_VERSION: {
> - struct ofp11_port *op = ofpbuf_put_uninit(b, sizeof *op);
> - ofputil_encode_ofp11_port(pp, op);
> - break;
> - }
> -
> - case OFP14_VERSION:
> - case OFP15_VERSION:
> - ofputil_put_ofp14_port(pp, b);
> - break;
> - case OFP16_VERSION:
> - ofputil_put_ofp16_port(pp, b);
> - break;
> -
> - default:
> - OVS_NOT_REACHED();
> - }
> -}
> -
> -enum ofperr
> -ofputil_decode_port_desc_stats_request(const struct ofp_header *request,
> - ofp_port_t *port)
> -{
> - struct ofpbuf b = ofpbuf_const_initializer(request,
> - ntohs(request->length));
> - enum ofpraw raw = ofpraw_pull_assert(&b);
> - if (raw == OFPRAW_OFPST10_PORT_DESC_REQUEST) {
> - *port = OFPP_ANY;
> - return 0;
> - } else if (raw == OFPRAW_OFPST15_PORT_DESC_REQUEST) {
> - ovs_be32 *ofp11_port;
> -
> - ofp11_port = ofpbuf_pull(&b, sizeof *ofp11_port);
> - return ofputil_port_from_ofp11(*ofp11_port, port);
> - } else {
> - OVS_NOT_REACHED();
> - }
> -}
> -
> -struct ofpbuf *
> -ofputil_encode_port_desc_stats_request(enum ofp_version ofp_version,
> - ofp_port_t port)
> -{
> - struct ofpbuf *request;
> -
> - switch (ofp_version) {
> - case OFP10_VERSION:
> - case OFP11_VERSION:
> - case OFP12_VERSION:
> - case OFP13_VERSION:
> - case OFP14_VERSION:
> - request = ofpraw_alloc(OFPRAW_OFPST10_PORT_DESC_REQUEST,
> - ofp_version, 0);
> - break;
> - case OFP15_VERSION:
> - case OFP16_VERSION:{
> - struct ofp15_port_desc_request *req;
> - request = ofpraw_alloc(OFPRAW_OFPST15_PORT_DESC_REQUEST,
> - ofp_version, 0);
> - req = ofpbuf_put_zeros(request, sizeof *req);
> - req->port_no = ofputil_port_to_ofp11(port);
> - break;
> - }
> - default:
> - OVS_NOT_REACHED();
> - }
> -
> - return request;
> -}
> -
> -void
> -ofputil_append_port_desc_stats_reply(const struct ofputil_phy_port *pp,
> - struct ovs_list *replies)
> -{
> - struct ofpbuf *reply = ofpbuf_from_list(ovs_list_back(replies));
> - size_t start_ofs = reply->size;
> -
> - ofputil_put_phy_port(ofpmp_version(replies), pp, reply);
> - ofpmp_postappend(replies, start_ofs);
> -}
> -
> -/* ofputil_switch_config */
> -
> -/* Decodes 'oh', which must be an OFPT_GET_CONFIG_REPLY or OFPT_SET_CONFIG
> - * message, into 'config'. Returns false if 'oh' contained any flags that
> - * aren't specified in its version of OpenFlow, true otherwise. */
> -static bool
> -ofputil_decode_switch_config(const struct ofp_header *oh,
> - struct ofputil_switch_config *config)
> -{
> - struct ofpbuf b = ofpbuf_const_initializer(oh, ntohs(oh->length));
> - ofpraw_pull_assert(&b);
> -
> - const struct ofp_switch_config *osc = ofpbuf_pull(&b, sizeof *osc);
> - config->frag = ntohs(osc->flags) & OFPC_FRAG_MASK;
> - config->miss_send_len = ntohs(osc->miss_send_len);
> -
> - ovs_be16 valid_mask = htons(OFPC_FRAG_MASK);
> - if (oh->version < OFP13_VERSION) {
> - const ovs_be16 ttl_bit = htons(OFPC_INVALID_TTL_TO_CONTROLLER);
> - valid_mask |= ttl_bit;
> - config->invalid_ttl_to_controller = (osc->flags & ttl_bit) != 0;
> - } else {
> - config->invalid_ttl_to_controller = -1;
> - }
> -
> - return !(osc->flags & ~valid_mask);
> -}
> -
> -void
> -ofputil_decode_get_config_reply(const struct ofp_header *oh,
> - struct ofputil_switch_config *config)
> -{
> - ofputil_decode_switch_config(oh, config);
> -}
> -
> -enum ofperr
> -ofputil_decode_set_config(const struct ofp_header *oh,
> - struct ofputil_switch_config *config)
> -{
> - return (ofputil_decode_switch_config(oh, config)
> - ? 0
> - : OFPERR_OFPSCFC_BAD_FLAGS);
> -}
> -
> -static struct ofpbuf *
> -ofputil_put_switch_config(const struct ofputil_switch_config *config,
> - struct ofpbuf *b)
> -{
> - const struct ofp_header *oh = b->data;
> - struct ofp_switch_config *osc = ofpbuf_put_zeros(b, sizeof *osc);
> - osc->flags = htons(config->frag);
> - if (config->invalid_ttl_to_controller > 0 && oh->version <
> OFP13_VERSION) {
> - osc->flags |= htons(OFPC_INVALID_TTL_TO_CONTROLLER);
> - }
> - osc->miss_send_len = htons(config->miss_send_len);
> - return b;
> -}
> -
> -struct ofpbuf *
> -ofputil_encode_get_config_reply(const struct ofp_header *request,
> - const struct ofputil_switch_config
> *config)
> -{
> - struct ofpbuf *b = ofpraw_alloc_reply(OFPRAW_OFPT_GET_CONFIG_REPLY,
> - request, 0);
> - return ofputil_put_switch_config(config, b);
> -}
> -
> -struct ofpbuf *
> -ofputil_encode_set_config(const struct ofputil_switch_config *config,
> - enum ofp_version version)
> -{
> - struct ofpbuf *b = ofpraw_alloc(OFPRAW_OFPT_SET_CONFIG, version, 0);
> - return ofputil_put_switch_config(config, b);
> -}
> -
> -/* ofputil_switch_features */
> -
> -#define OFPC_COMMON (OFPC_FLOW_STATS | OFPC_TABLE_STATS | OFPC_PORT_STATS
> | \
> - OFPC_IP_REASM | OFPC_QUEUE_STATS)
> -BUILD_ASSERT_DECL((int) OFPUTIL_C_FLOW_STATS == OFPC_FLOW_STATS);
> -BUILD_ASSERT_DECL((int) OFPUTIL_C_TABLE_STATS == OFPC_TABLE_STATS);
> -BUILD_ASSERT_DECL((int) OFPUTIL_C_PORT_STATS == OFPC_PORT_STATS);
> -BUILD_ASSERT_DECL((int) OFPUTIL_C_IP_REASM == OFPC_IP_REASM);
> -BUILD_ASSERT_DECL((int) OFPUTIL_C_QUEUE_STATS == OFPC_QUEUE_STATS);
> -BUILD_ASSERT_DECL((int) OFPUTIL_C_ARP_MATCH_IP == OFPC_ARP_MATCH_IP);
> -BUILD_ASSERT_DECL((int) OFPUTIL_C_PORT_BLOCKED == OFPC12_PORT_BLOCKED);
> -BUILD_ASSERT_DECL((int) OFPUTIL_C_BUNDLES == OFPC14_BUNDLES);
> -BUILD_ASSERT_DECL((int) OFPUTIL_C_FLOW_MONITORING ==
> OFPC14_FLOW_MONITORING);
> -
> -static uint32_t
> -ofputil_capabilities_mask(enum ofp_version ofp_version)
> -{
> - /* Handle capabilities whose bit is unique for all OpenFlow versions
> */
> - switch (ofp_version) {
> - case OFP10_VERSION:
> - case OFP11_VERSION:
> - return OFPC_COMMON | OFPC_ARP_MATCH_IP;
> - case OFP12_VERSION:
> - case OFP13_VERSION:
> - return OFPC_COMMON | OFPC12_PORT_BLOCKED;
> - case OFP14_VERSION:
> - case OFP15_VERSION:
> - case OFP16_VERSION:
> - return OFPC_COMMON | OFPC12_PORT_BLOCKED | OFPC14_BUNDLES
> - | OFPC14_FLOW_MONITORING;
> - default:
> - /* Caller needs to check osf->header.version itself */
> - return 0;
> - }
> -}
> -
> -/* Pulls an OpenFlow "switch_features" structure from 'b' and decodes it
> into
> - * an abstract representation in '*features', readying 'b' to iterate
> over the
> - * OpenFlow port structures following 'osf' with later calls to
> - * ofputil_pull_phy_port(). Returns 0 if successful, otherwise an
> OFPERR_*
> - * value. */
> -enum ofperr
> -ofputil_pull_switch_features(struct ofpbuf *b,
> - struct ofputil_switch_features *features)
> -{
> - const struct ofp_header *oh = b->data;
> - enum ofpraw raw = ofpraw_pull_assert(b);
> - const struct ofp_switch_features *osf = ofpbuf_pull(b, sizeof *osf);
> - features->datapath_id = ntohll(osf->datapath_id);
> - features->n_buffers = ntohl(osf->n_buffers);
> - features->n_tables = osf->n_tables;
> - features->auxiliary_id = 0;
> -
> - features->capabilities = ntohl(osf->capabilities) &
> - ofputil_capabilities_mask(oh->version);
> -
> - if (raw == OFPRAW_OFPT10_FEATURES_REPLY) {
> - if (osf->capabilities & htonl(OFPC10_STP)) {
> - features->capabilities |= OFPUTIL_C_STP;
> - }
> - features->ofpacts = ofpact_bitmap_from_openflow(osf->actions,
> - OFP10_VERSION);
> - } else if (raw == OFPRAW_OFPT11_FEATURES_REPLY
> - || raw == OFPRAW_OFPT13_FEATURES_REPLY) {
> - if (osf->capabilities & htonl(OFPC11_GROUP_STATS)) {
> - features->capabilities |= OFPUTIL_C_GROUP_STATS;
> - }
> - features->ofpacts = 0;
> - if (raw == OFPRAW_OFPT13_FEATURES_REPLY) {
> - features->auxiliary_id = osf->auxiliary_id;
> - }
> - } else {
> - return OFPERR_OFPBRC_BAD_VERSION;
> - }
> -
> - return 0;
> -}
> -
> -/* In OpenFlow 1.0, 1.1, and 1.2, an OFPT_FEATURES_REPLY message lists
> all the
> - * switch's ports, unless there are too many to fit. In OpenFlow 1.3 and
> - * later, an OFPT_FEATURES_REPLY does not list ports at all.
> - *
> - * Given a buffer 'b' that contains a Features Reply message, this message
> - * checks if it contains a complete list of the switch's ports. Returns
> true,
> - * if so. Returns false if the list is missing (OF1.3+) or incomplete
> - * (OF1.0/1.1/1.2), and in the latter case removes all of the ports from
> the
> - * message.
> - *
> - * When this function returns false, the caller should send an
> OFPST_PORT_DESC
> - * stats request to get the ports. */
> -bool
> -ofputil_switch_features_has_ports(struct ofpbuf *b)
> -{
> - struct ofp_header *oh = b->data;
> - size_t phy_port_size;
> -
> - if (oh->version >= OFP13_VERSION) {
> - /* OpenFlow 1.3+ never has ports in the feature reply. */
> - return false;
> - }
> -
> - phy_port_size = (oh->version == OFP10_VERSION
> - ? sizeof(struct ofp10_phy_port)
> - : sizeof(struct ofp11_port));
> - if (ntohs(oh->length) + phy_port_size <= UINT16_MAX) {
> - /* There's room for additional ports in the feature reply.
> - * Assume that the list is complete. */
> - return true;
> - }
> -
> - /* The feature reply has no room for more ports. Probably the list is
> - * truncated. Drop the ports and tell the caller to retrieve them
> with
> - * OFPST_PORT_DESC. */
> - b->size = sizeof *oh + sizeof(struct ofp_switch_features);
> - ofpmsg_update_length(b);
> - return false;
> -}
> -
> -/* Returns a buffer owned by the caller that encodes 'features' in the
> format
> - * required by 'protocol' with the given 'xid'. The caller should append
> port
> - * information to the buffer with subsequent calls to
> - * ofputil_put_switch_features_port(). */
> -struct ofpbuf *
> -ofputil_encode_switch_features(const struct ofputil_switch_features
> *features,
> - enum ofputil_protocol protocol, ovs_be32
> xid)
> -{
> - struct ofp_switch_features *osf;
> - struct ofpbuf *b;
> - enum ofp_version version;
> - enum ofpraw raw;
> -
> - version = ofputil_protocol_to_ofp_version(protocol);
> - switch (version) {
> - case OFP10_VERSION:
> - raw = OFPRAW_OFPT10_FEATURES_REPLY;
> - break;
> - case OFP11_VERSION:
> - case OFP12_VERSION:
> - raw = OFPRAW_OFPT11_FEATURES_REPLY;
> - break;
> - case OFP13_VERSION:
> - case OFP14_VERSION:
> - case OFP15_VERSION:
> - case OFP16_VERSION:
> - raw = OFPRAW_OFPT13_FEATURES_REPLY;
> - break;
> - default:
> - OVS_NOT_REACHED();
> - }
> - b = ofpraw_alloc_xid(raw, version, xid, 0);
> - osf = ofpbuf_put_zeros(b, sizeof *osf);
> - osf->datapath_id = htonll(features->datapath_id);
> - osf->n_buffers = htonl(features->n_buffers);
> - osf->n_tables = features->n_tables;
> -
> - osf->capabilities = htonl(features->capabilities &
> - ofputil_capabilities_mask(version));
> - switch (version) {
> - case OFP10_VERSION:
> - if (features->capabilities & OFPUTIL_C_STP) {
> - osf->capabilities |= htonl(OFPC10_STP);
> - }
> - osf->actions = ofpact_bitmap_to_openflow(features->ofpacts,
> - OFP10_VERSION);
> - break;
> - case OFP13_VERSION:
> - case OFP14_VERSION:
> - case OFP15_VERSION:
> - case OFP16_VERSION:
> - osf->auxiliary_id = features->auxiliary_id;
> - /* fall through */
> - case OFP11_VERSION:
> - case OFP12_VERSION:
> - if (features->capabilities & OFPUTIL_C_GROUP_STATS) {
> - osf->capabilities |= htonl(OFPC11_GROUP_STATS);
> - }
> - break;
> - default:
> - OVS_NOT_REACHED();
> - }
> -
> - return b;
> -}
> -
> -/* Encodes 'pp' into the format required by the switch_features message
> already
> - * in 'b', which should have been returned by ofputil_encode_switch_
> features(),
> - * and appends the encoded version to 'b'. */
> -void
> -ofputil_put_switch_features_port(const struct ofputil_phy_port *pp,
> - struct ofpbuf *b)
> -{
> - const struct ofp_header *oh = b->data;
> -
> - if (oh->version < OFP13_VERSION) {
> - /* Try adding a port description to the message, but drop it
> again if
> - * the buffer overflows. (This possibility for overflow is why
> - * OpenFlow 1.3+ moved port descriptions into a multipart
> message.) */
> - size_t start_ofs = b->size;
> - ofputil_put_phy_port(oh->version, pp, b);
> - if (b->size > UINT16_MAX) {
> - b->size = start_ofs;
> - }
> - }
> -}
> -
> -/* ofputil_port_status */
> -
> -/* Decodes the OpenFlow "port status" message in '*ops' into an abstract
> form
> - * in '*ps'. Returns 0 if successful, otherwise an OFPERR_* value. */
> -enum ofperr
> -ofputil_decode_port_status(const struct ofp_header *oh,
> - struct ofputil_port_status *ps)
> -{
> - struct ofpbuf b = ofpbuf_const_initializer(oh, ntohs(oh->length));
> - ofpraw_pull_assert(&b);
> -
> - const struct ofp_port_status *ops = ofpbuf_pull(&b, sizeof *ops);
> - if (ops->reason != OFPPR_ADD &&
> - ops->reason != OFPPR_DELETE &&
> - ops->reason != OFPPR_MODIFY) {
> - return OFPERR_NXBRC_BAD_REASON;
> - }
> - ps->reason = ops->reason;
> -
> - int retval = ofputil_pull_phy_port(oh->version, &b, &ps->desc);
> - ovs_assert(retval != EOF);
> - return retval;
> -}
> -
> -/* Converts the abstract form of a "port status" message in '*ps' into an
> - * OpenFlow message suitable for 'protocol', and returns that encoded
> form in
> - * a buffer owned by the caller. */
> -struct ofpbuf *
> -ofputil_encode_port_status(const struct ofputil_port_status *ps,
> - enum ofputil_protocol protocol)
> -{
> - struct ofp_port_status *ops;
> - struct ofpbuf *b;
> - enum ofp_version version;
> - enum ofpraw raw;
> -
> - version = ofputil_protocol_to_ofp_version(protocol);
> - switch (version) {
> - case OFP10_VERSION:
> - raw = OFPRAW_OFPT10_PORT_STATUS;
> - break;
> -
> - case OFP11_VERSION:
> - case OFP12_VERSION:
> - case OFP13_VERSION:
> - raw = OFPRAW_OFPT11_PORT_STATUS;
> - break;
> -
> - case OFP14_VERSION:
> - case OFP15_VERSION:
> - raw = OFPRAW_OFPT14_PORT_STATUS;
> - break;
> -
> - case OFP16_VERSION:
> - raw = OFPRAW_OFPT16_PORT_STATUS;
> - break;
> -
> - default:
> - OVS_NOT_REACHED();
> - }
> -
> - b = ofpraw_alloc_xid(raw, version, htonl(0), 0);
> - ops = ofpbuf_put_zeros(b, sizeof *ops);
> - ops->reason = ps->reason;
> - ofputil_put_phy_port(version, &ps->desc, b);
> - ofpmsg_update_length(b);
> - return b;
> -}
> -
> -/* ofputil_port_mod */
> -
> -static enum ofperr
> -parse_port_mod_ethernet_property(struct ofpbuf *property,
> - struct ofputil_port_mod *pm)
> -{
> - ovs_be32 advertise;
> - enum ofperr error;
> -
> - error = ofpprop_parse_be32(property, &advertise);
> - if (!error) {
> - pm->advertise = netdev_port_features_from_ofp11(advertise);
> - }
> - return error;
> -}
> -
> -static enum ofperr
> -ofputil_decode_ofp10_port_mod(const struct ofp10_port_mod *opm,
> - struct ofputil_port_mod *pm)
> -{
> - pm->port_no = u16_to_ofp(ntohs(opm->port_no));
> - pm->hw_addr = opm->hw_addr;
> - pm->config = ntohl(opm->config) & OFPPC10_ALL;
> - pm->mask = ntohl(opm->mask) & OFPPC10_ALL;
> - pm->advertise = netdev_port_features_from_ofp10(opm->advertise);
> - return 0;
> -}
> -
> -static enum ofperr
> -ofputil_decode_ofp11_port_mod(const struct ofp11_port_mod *opm,
> - struct ofputil_port_mod *pm)
> -{
> - enum ofperr error;
> -
> - error = ofputil_port_from_ofp11(opm->port_no, &pm->port_no);
> - if (error) {
> - return error;
> - }
> -
> - pm->hw_addr = opm->hw_addr;
> - pm->config = ntohl(opm->config) & OFPPC11_ALL;
> - pm->mask = ntohl(opm->mask) & OFPPC11_ALL;
> - pm->advertise = netdev_port_features_from_ofp11(opm->advertise);
> -
> - return 0;
> -}
> -
> -static enum ofperr
> -ofputil_decode_ofp14_port_mod_properties(struct ofpbuf *b, bool loose,
> - struct ofputil_port_mod *pm)
> -{
> - while (b->size > 0) {
> - struct ofpbuf property;
> - enum ofperr error;
> - uint64_t type;
> -
> - error = ofpprop_pull(b, &property, &type);
> - if (error) {
> - return error;
> - }
> -
> - switch (type) {
> - case OFPPMPT14_ETHERNET:
> - error = parse_port_mod_ethernet_property(&property, pm);
> - break;
> -
> - default:
> - error = OFPPROP_UNKNOWN(loose, "port_mod", type);
> - break;
> - }
> -
> - if (error) {
> - return error;
> - }
> - }
> - return 0;
> -}
> -
> -static enum ofperr
> -ofputil_decode_ofp14_port_mod(struct ofpbuf *b, bool loose,
> - struct ofputil_port_mod *pm)
> -{
> - const struct ofp14_port_mod *opm = ofpbuf_pull(b, sizeof *opm);
> - enum ofperr error = ofputil_port_from_ofp11(opm->port_no,
> &pm->port_no);
> - if (error) {
> - return error;
> - }
> -
> - pm->hw_addr = opm->hw_addr;
> - pm->config = ntohl(opm->config) & OFPPC11_ALL;
> - pm->mask = ntohl(opm->mask) & OFPPC11_ALL;
> -
> - return ofputil_decode_ofp14_port_mod_properties(b, loose, pm);
> -}
> -
> -static enum ofperr
> -ofputil_decode_ofp16_port_mod(struct ofpbuf *b, bool loose,
> - struct ofputil_port_mod *pm)
> -{
> - const struct ofp16_port_mod *opm = ofpbuf_pull(b, sizeof *opm);
> - enum ofperr error = ofputil_port_from_ofp11(opm->port_no,
> &pm->port_no);
> - if (error) {
> - return error;
> - }
> -
> - pm->hw_addr = opm->hw_addr;
> - pm->hw_addr64 = opm->hw_addr64;
> - pm->config = ntohl(opm->config) & OFPPC11_ALL;
> - pm->mask = ntohl(opm->mask) & OFPPC11_ALL;
> -
> - return ofputil_decode_ofp14_port_mod_properties(b, loose, pm);
> -}
> -
> -/* Decodes the OpenFlow "port mod" message in '*oh' into an abstract form
> in
> - * '*pm'. Returns 0 if successful, otherwise an OFPERR_* value. */
> -enum ofperr
> -ofputil_decode_port_mod(const struct ofp_header *oh,
> - struct ofputil_port_mod *pm, bool loose)
> -{
> - memset(pm, 0, sizeof *pm);
> -
> - struct ofpbuf b = ofpbuf_const_initializer(oh, ntohs(oh->length));
> - enum ofpraw raw = ofpraw_pull_assert(&b);
> -
> - enum ofperr error;
> - if (raw == OFPRAW_OFPT10_PORT_MOD) {
> - error = ofputil_decode_ofp10_port_mod(b.data, pm);
> - } else if (raw == OFPRAW_OFPT11_PORT_MOD) {
> - error = ofputil_decode_ofp11_port_mod(b.data, pm);
> - } else if (raw == OFPRAW_OFPT14_PORT_MOD) {
> - error = ofputil_decode_ofp14_port_mod(&b, loose, pm);
> - } else if (raw == OFPRAW_OFPT16_PORT_MOD) {
> - error = ofputil_decode_ofp16_port_mod(&b, loose, pm);
> - } else {
> - error = OFPERR_OFPBRC_BAD_TYPE;
> - }
> -
> - pm->config &= pm->mask;
> - return error;
> -}
> -
> -/* Converts the abstract form of a "port mod" message in '*pm' into an
> OpenFlow
> - * message suitable for 'protocol', and returns that encoded form in a
> buffer
> - * owned by the caller. */
> -struct ofpbuf *
> -ofputil_encode_port_mod(const struct ofputil_port_mod *pm,
> - enum ofputil_protocol protocol)
> -{
> - enum ofp_version ofp_version = ofputil_protocol_to_ofp_
> version(protocol);
> - struct ofpbuf *b;
> -
> - switch (ofp_version) {
> - case OFP10_VERSION: {
> - struct ofp10_port_mod *opm;
> -
> - b = ofpraw_alloc(OFPRAW_OFPT10_PORT_MOD, ofp_version, 0);
> - opm = ofpbuf_put_zeros(b, sizeof *opm);
> - opm->port_no = htons(ofp_to_u16(pm->port_no));
> - opm->hw_addr = pm->hw_addr;
> - opm->config = htonl(pm->config & OFPPC10_ALL);
> - opm->mask = htonl(pm->mask & OFPPC10_ALL);
> - opm->advertise = netdev_port_features_to_ofp10(pm->advertise);
> - break;
> - }
> -
> - case OFP11_VERSION:
> - case OFP12_VERSION:
> - case OFP13_VERSION: {
> - struct ofp11_port_mod *opm;
> -
> - b = ofpraw_alloc(OFPRAW_OFPT11_PORT_MOD, ofp_version, 0);
> - opm = ofpbuf_put_zeros(b, sizeof *opm);
> - opm->port_no = ofputil_port_to_ofp11(pm->port_no);
> - opm->hw_addr = pm->hw_addr;
> - opm->config = htonl(pm->config & OFPPC11_ALL);
> - opm->mask = htonl(pm->mask & OFPPC11_ALL);
> - opm->advertise = netdev_port_features_to_ofp11(pm->advertise);
> - break;
> - }
> - case OFP14_VERSION:
> - case OFP15_VERSION: {
> - struct ofp14_port_mod *opm;
> -
> - b = ofpraw_alloc(OFPRAW_OFPT14_PORT_MOD, ofp_version, 0);
> - opm = ofpbuf_put_zeros(b, sizeof *opm);
> - opm->port_no = ofputil_port_to_ofp11(pm->port_no);
> - opm->hw_addr = pm->hw_addr;
> - opm->config = htonl(pm->config & OFPPC11_ALL);
> - opm->mask = htonl(pm->mask & OFPPC11_ALL);
> -
> - if (pm->advertise) {
> - ofpprop_put_be32(b, OFPPMPT14_ETHERNET,
> - netdev_port_features_to_ofp11(
> pm->advertise));
> - }
> - break;
> - }
> - case OFP16_VERSION: {
> - struct ofp16_port_mod *opm;
> -
> - b = ofpraw_alloc(OFPRAW_OFPT16_PORT_MOD, ofp_version, 0);
> - opm = ofpbuf_put_zeros(b, sizeof *opm);
> - opm->port_no = ofputil_port_to_ofp11(pm->port_no);
> - opm->hw_addr = pm->hw_addr;
> - opm->hw_addr64 = pm->hw_addr64;
> - opm->config = htonl(pm->config & OFPPC11_ALL);
> - opm->mask = htonl(pm->mask & OFPPC11_ALL);
> -
> - if (pm->advertise) {
> - ofpprop_put_be32(b, OFPPMPT14_ETHERNET,
> - netdev_port_features_to_ofp11(
> pm->advertise));
> - }
> - break;
> - }
> - default:
> - OVS_NOT_REACHED();
> - }
> -
> - return b;
> -}
> -
> -/* Table features. */
> -
> -static enum ofperr
> -pull_table_feature_property(struct ofpbuf *msg, struct ofpbuf *payload,
> - uint64_t *typep)
> -{
> - enum ofperr error;
> -
> - error = ofpprop_pull(msg, payload, typep);
> - if (payload && !error) {
> - ofpbuf_pull(payload, (char *)payload->msg - (char
> *)payload->header);
> - }
> - return error;
> -}
> -
> -static enum ofperr
> -parse_action_bitmap(struct ofpbuf *payload, enum ofp_version ofp_version,
> - uint64_t *ofpacts)
> -{
> - uint32_t types = 0;
> -
> - while (payload->size > 0) {
> - enum ofperr error;
> - uint64_t type;
> -
> - error = ofpprop_pull__(payload, NULL, 1, 0x10000, &type);
> - if (error) {
> - return error;
> - }
> - if (type < CHAR_BIT * sizeof types) {
> - types |= 1u << type;
> - }
> - }
> -
> - *ofpacts = ofpact_bitmap_from_openflow(htonl(types), ofp_version);
> - return 0;
> -}
> -
> -static enum ofperr
> -parse_instruction_ids(struct ofpbuf *payload, bool loose, uint32_t *insts)
> -{
> - *insts = 0;
> - while (payload->size > 0) {
> - enum ovs_instruction_type inst;
> - enum ofperr error;
> - uint64_t ofpit;
> -
> - /* OF1.3 and OF1.4 aren't clear about padding in the instruction
> IDs.
> - * It seems clear that they aren't padded to 8 bytes, though,
> because
> - * both standards say that "non-experimenter instructions are 4
> bytes"
> - * and do not mention any padding before the first instruction ID.
> - * (There wouldn't be any point in padding to 8 bytes if the IDs
> were
> - * aligned on an odd 4-byte boundary.)
> - *
> - * Anyway, we just assume they're all glommed together on byte
> - * boundaries. */
> - error = ofpprop_pull__(payload, NULL, 1, 0x10000, &ofpit);
> - if (error) {
> - return error;
> - }
> -
> - error = ovs_instruction_type_from_inst_type(&inst, ofpit);
> - if (!error) {
> - *insts |= 1u << inst;
> - } else if (!loose) {
> - return error;
> - }
> - }
> - return 0;
> -}
> -
> -static enum ofperr
> -parse_table_features_next_table(struct ofpbuf *payload,
> - unsigned long int *next_tables)
> -{
> - size_t i;
> -
> - memset(next_tables, 0, bitmap_n_bytes(255));
> - for (i = 0; i < payload->size; i++) {
> - uint8_t id = ((const uint8_t *) payload->data)[i];
> - if (id >= 255) {
> - return OFPERR_OFPBPC_BAD_VALUE;
> - }
> - bitmap_set1(next_tables, id);
> - }
> - return 0;
> -}
> -
> -static enum ofperr
> -parse_oxms(struct ofpbuf *payload, bool loose,
> - struct mf_bitmap *exactp, struct mf_bitmap *maskedp)
> -{
> - struct mf_bitmap exact = MF_BITMAP_INITIALIZER;
> - struct mf_bitmap masked = MF_BITMAP_INITIALIZER;
> -
> - while (payload->size > 0) {
> - const struct mf_field *field;
> - enum ofperr error;
> - bool hasmask;
> -
> - error = nx_pull_header(payload, NULL, &field, &hasmask);
> - if (!error) {
> - bitmap_set1(hasmask ? masked.bm : exact.bm, field->id);
> - } else if (error != OFPERR_OFPBMC_BAD_FIELD || !loose) {
> - return error;
> - }
> - }
> - if (exactp) {
> - *exactp = exact;
> - } else if (!bitmap_is_all_zeros(exact.bm, MFF_N_IDS)) {
> - return OFPERR_OFPBMC_BAD_MASK;
> - }
> - if (maskedp) {
> - *maskedp = masked;
> - } else if (!bitmap_is_all_zeros(masked.bm, MFF_N_IDS)) {
> - return OFPERR_OFPBMC_BAD_MASK;
> - }
> - return 0;
> -}
> -
> -/* Converts an OFPMP_TABLE_FEATURES request or reply in 'msg' into an
> abstract
> - * ofputil_table_features in 'tf'.
> - *
> - * If 'loose' is true, this function ignores properties and values that
> it does
> - * not understand, as a controller would want to do when interpreting
> - * capabilities provided by a switch. If 'loose' is false, this function
> - * treats unknown properties and values as an error, as a switch would
> want to
> - * do when interpreting a configuration request made by a controller.
> - *
> - * A single OpenFlow message can specify features for multiple tables.
> Calling
> - * this function multiple times for a single 'msg' iterates through the
> tables
> - * in the message. The caller must initially leave 'msg''s layer
> pointers null
> - * and not modify them between calls.
> - *
> - * Returns 0 if successful, EOF if no tables were left in this 'msg',
> otherwise
> - * a positive "enum ofperr" value. */
> -int
> -ofputil_decode_table_features(struct ofpbuf *msg,
> - struct ofputil_table_features *tf, bool
> loose)
> -{
> - memset(tf, 0, sizeof *tf);
> -
> - if (!msg->header) {
> - ofpraw_pull_assert(msg);
> - }
> -
> - if (!msg->size) {
> - return EOF;
> - }
> -
> - const struct ofp_header *oh = msg->header;
> - struct ofp13_table_features *otf = msg->data;
> - if (msg->size < sizeof *otf) {
> - return OFPERR_OFPBPC_BAD_LEN;
> - }
> -
> - unsigned int len = ntohs(otf->length);
> - if (len < sizeof *otf || len % 8 || len > msg->size) {
> - return OFPERR_OFPBPC_BAD_LEN;
> - }
> -
> - tf->table_id = otf->table_id;
> - if (tf->table_id == OFPTT_ALL) {
> - return OFPERR_OFPTFFC_BAD_TABLE;
> - }
> -
> - ovs_strlcpy_arrays(tf->name, otf->name);
> - tf->metadata_match = otf->metadata_match;
> - tf->metadata_write = otf->metadata_write;
> - tf->miss_config = OFPUTIL_TABLE_MISS_DEFAULT;
> - if (oh->version >= OFP14_VERSION) {
> - uint32_t caps = ntohl(otf->capabilities);
> - tf->supports_eviction = (caps & OFPTC14_EVICTION) != 0;
> - tf->supports_vacancy_events = (caps & OFPTC14_VACANCY_EVENTS) !=
> 0;
> - } else {
> - tf->supports_eviction = -1;
> - tf->supports_vacancy_events = -1;
> - }
> - tf->max_entries = ntohl(otf->max_entries);
> -
> - struct ofpbuf properties = ofpbuf_const_initializer(ofpbuf_pull(msg,
> len),
> - len);
> - ofpbuf_pull(&properties, sizeof *otf);
> - while (properties.size > 0) {
> - struct ofpbuf payload;
> - enum ofperr error;
> - uint64_t type;
> -
> - error = pull_table_feature_property(&properties, &payload,
> &type);
> - if (error) {
> - return error;
> - }
> -
> - switch ((enum ofp13_table_feature_prop_type) type) {
> - case OFPTFPT13_INSTRUCTIONS:
> - error = parse_instruction_ids(&payload, loose,
> - &tf->nonmiss.instructions);
> - break;
> - case OFPTFPT13_INSTRUCTIONS_MISS:
> - error = parse_instruction_ids(&payload, loose,
> - &tf->miss.instructions);
> - break;
> -
> - case OFPTFPT13_NEXT_TABLES:
> - error = parse_table_features_next_table(&payload,
> - tf->nonmiss.next);
> - break;
> - case OFPTFPT13_NEXT_TABLES_MISS:
> - error = parse_table_features_next_table(&payload,
> tf->miss.next);
> - break;
> -
> - case OFPTFPT13_WRITE_ACTIONS:
> - error = parse_action_bitmap(&payload, oh->version,
> - &tf->nonmiss.write.ofpacts);
> - break;
> - case OFPTFPT13_WRITE_ACTIONS_MISS:
> - error = parse_action_bitmap(&payload, oh->version,
> - &tf->miss.write.ofpacts);
> - break;
> -
> - case OFPTFPT13_APPLY_ACTIONS:
> - error = parse_action_bitmap(&payload, oh->version,
> - &tf->nonmiss.apply.ofpacts);
> - break;
> - case OFPTFPT13_APPLY_ACTIONS_MISS:
> - error = parse_action_bitmap(&payload, oh->version,
> - &tf->miss.apply.ofpacts);
> - break;
> -
> - case OFPTFPT13_MATCH:
> - error = parse_oxms(&payload, loose, &tf->match, &tf->mask);
> - break;
> - case OFPTFPT13_WILDCARDS:
> - error = parse_oxms(&payload, loose, &tf->wildcard, NULL);
> - break;
> -
> - case OFPTFPT13_WRITE_SETFIELD:
> - error = parse_oxms(&payload, loose,
> - &tf->nonmiss.write.set_fields, NULL);
> - break;
> - case OFPTFPT13_WRITE_SETFIELD_MISS:
> - error = parse_oxms(&payload, loose,
> - &tf->miss.write.set_fields, NULL);
> - break;
> - case OFPTFPT13_APPLY_SETFIELD:
> - error = parse_oxms(&payload, loose,
> - &tf->nonmiss.apply.set_fields, NULL);
> - break;
> - case OFPTFPT13_APPLY_SETFIELD_MISS:
> - error = parse_oxms(&payload, loose,
> - &tf->miss.apply.set_fields, NULL);
> - break;
> -
> - case OFPTFPT13_EXPERIMENTER:
> - case OFPTFPT13_EXPERIMENTER_MISS:
> - default:
> - error = OFPPROP_UNKNOWN(loose, "table features", type);
> - break;
> - }
> - if (error) {
> - return error;
> - }
> - }
> -
> - /* Fix inconsistencies:
> - *
> - * - Turn on 'match' bits that are set in 'mask', because maskable
> - * fields are matchable.
> - *
> - * - Turn on 'wildcard' bits that are set in 'mask', because a
> field
> - * that is arbitrarily maskable can be wildcarded entirely.
> - *
> - * - Turn off 'wildcard' bits that are not in 'match', because a
> field
> - * must be matchable for it to be meaningfully wildcarded. */
> - bitmap_or(tf->match.bm, tf->mask.bm, MFF_N_IDS);
> - bitmap_or(tf->wildcard.bm, tf->mask.bm, MFF_N_IDS);
> - bitmap_and(tf->wildcard.bm, tf->match.bm, MFF_N_IDS);
> -
> - return 0;
> -}
> -
> -/* Encodes and returns a request to obtain the table features of a switch.
> - * The message is encoded for OpenFlow version 'ofp_version'. */
> -struct ofpbuf *
> -ofputil_encode_table_features_request(enum ofp_version ofp_version)
> -{
> - struct ofpbuf *request = NULL;
> -
> - switch (ofp_version) {
> - case OFP10_VERSION:
> - case OFP11_VERSION:
> - case OFP12_VERSION:
> - ovs_fatal(0, "dump-table-features needs OpenFlow 1.3 or later "
> - "(\'-O OpenFlow13\')");
> - case OFP13_VERSION:
> - case OFP14_VERSION:
> - case OFP15_VERSION:
> - case OFP16_VERSION:
> - request = ofpraw_alloc(OFPRAW_OFPST13_TABLE_FEATURES_REQUEST,
> - ofp_version, 0);
> - break;
> - default:
> - OVS_NOT_REACHED();
> - }
> -
> - return request;
> -}
> -
> -static void
> -put_fields_property(struct ofpbuf *reply,
> - const struct mf_bitmap *fields,
> - const struct mf_bitmap *masks,
> - enum ofp13_table_feature_prop_type property,
> - enum ofp_version version)
> -{
> - size_t start_ofs;
> - int field;
> -
> - start_ofs = ofpprop_start(reply, property);
> - BITMAP_FOR_EACH_1 (field, MFF_N_IDS, fields->bm) {
> - nx_put_header(reply, field, version,
> - masks && bitmap_is_set(masks->bm, field));
> - }
> - ofpprop_end(reply, start_ofs);
> -}
> -
> -static void
> -put_table_action_features(struct ofpbuf *reply,
> - const struct ofputil_table_action_features *taf,
> - enum ofp13_table_feature_prop_type actions_type,
> - enum ofp13_table_feature_prop_type
> set_fields_type,
> - int miss_offset, enum ofp_version version)
> -{
> - ofpprop_put_bitmap(reply, actions_type + miss_offset,
> - ntohl(ofpact_bitmap_to_openflow(taf->ofpacts,
> - version)));
> - put_fields_property(reply, &taf->set_fields, NULL,
> - set_fields_type + miss_offset, version);
> -}
> -
> -static void
> -put_table_instruction_features(
> - struct ofpbuf *reply, const struct ofputil_table_instruction_features
> *tif,
> - int miss_offset, enum ofp_version version)
> -{
> - size_t start_ofs;
> - uint8_t table_id;
> -
> - ofpprop_put_bitmap(reply, OFPTFPT13_INSTRUCTIONS + miss_offset,
> - ntohl(ovsinst_bitmap_to_
> openflow(tif->instructions,
> - version)));
> -
> - start_ofs = ofpprop_start(reply, OFPTFPT13_NEXT_TABLES + miss_offset);
> - BITMAP_FOR_EACH_1 (table_id, 255, tif->next) {
> - ofpbuf_put(reply, &table_id, 1);
> - }
> - ofpprop_end(reply, start_ofs);
> -
> - put_table_action_features(reply, &tif->write,
> - OFPTFPT13_WRITE_ACTIONS,
> - OFPTFPT13_WRITE_SETFIELD, miss_offset,
> version);
> - put_table_action_features(reply, &tif->apply,
> - OFPTFPT13_APPLY_ACTIONS,
> - OFPTFPT13_APPLY_SETFIELD, miss_offset,
> version);
> -}
> -
> -void
> -ofputil_append_table_features_reply(const struct ofputil_table_features
> *tf,
> - struct ovs_list *replies)
> -{
> - struct ofpbuf *reply = ofpbuf_from_list(ovs_list_back(replies));
> - enum ofp_version version = ofpmp_version(replies);
> - size_t start_ofs = reply->size;
> - struct ofp13_table_features *otf;
> -
> - otf = ofpbuf_put_zeros(reply, sizeof *otf);
> - otf->table_id = tf->table_id;
> - ovs_strlcpy_arrays(otf->name, tf->name);
> - otf->metadata_match = tf->metadata_match;
> - otf->metadata_write = tf->metadata_write;
> - if (version >= OFP14_VERSION) {
> - if (tf->supports_eviction) {
> - otf->capabilities |= htonl(OFPTC14_EVICTION);
> - }
> - if (tf->supports_vacancy_events) {
> - otf->capabilities |= htonl(OFPTC14_VACANCY_EVENTS);
> - }
> - }
> - otf->max_entries = htonl(tf->max_entries);
> -
> - put_table_instruction_features(reply, &tf->nonmiss, 0, version);
> - put_table_instruction_features(reply, &tf->miss, 1, version);
> -
> - put_fields_property(reply, &tf->match, &tf->mask,
> - OFPTFPT13_MATCH, version);
> - put_fields_property(reply, &tf->wildcard, NULL,
> - OFPTFPT13_WILDCARDS, version);
> -
> - otf = ofpbuf_at_assert(reply, start_ofs, sizeof *otf);
> - otf->length = htons(reply->size - start_ofs);
> - ofpmp_postappend(replies, start_ofs);
> -}
> -
> -static enum ofperr
> -parse_table_desc_vacancy_property(struct ofpbuf *property,
> - struct ofputil_table_desc *td)
> -{
> - struct ofp14_table_mod_prop_vacancy *otv = property->data;
> -
> - if (property->size != sizeof *otv) {
> - return OFPERR_OFPBPC_BAD_LEN;
> - }
> -
> - td->table_vacancy.vacancy_down = otv->vacancy_down;
> - td->table_vacancy.vacancy_up = otv->vacancy_up;
> - td->table_vacancy.vacancy = otv->vacancy;
> - return 0;
> -}
> -
> -/* Decodes the next OpenFlow "table desc" message (of possibly several)
> from
> - * 'msg' into an abstract form in '*td'. Returns 0 if successful, EOF if
> the
> - * last "table desc" in 'msg' was already decoded, otherwise an OFPERR_*
> - * value. */
> -int
> -ofputil_decode_table_desc(struct ofpbuf *msg,
> - struct ofputil_table_desc *td,
> - enum ofp_version version)
> -{
> - memset(td, 0, sizeof *td);
> -
> - if (!msg->header) {
> - ofpraw_pull_assert(msg);
> - }
> -
> - if (!msg->size) {
> - return EOF;
> - }
> -
> - struct ofp14_table_desc *otd = ofpbuf_try_pull(msg, sizeof *otd);
> - if (!otd) {
> - VLOG_WARN_RL(&bad_ofmsg_rl, "OFP14_TABLE_DESC reply has %"PRIu32"
> "
> - "leftover bytes at end", msg->size);
> - return OFPERR_OFPBRC_BAD_LEN;
> - }
> -
> - td->table_id = otd->table_id;
> - size_t length = ntohs(otd->length);
> - if (length < sizeof *otd || length - sizeof *otd > msg->size) {
> - VLOG_WARN_RL(&bad_ofmsg_rl, "OFP14_TABLE_DESC reply claims
> invalid "
> - "length %"PRIuSIZE, length);
> - return OFPERR_OFPBRC_BAD_LEN;
> - }
> - length -= sizeof *otd;
> -
> - td->eviction = ofputil_decode_table_eviction(otd->config, version);
> - td->vacancy = ofputil_decode_table_vacancy(otd->config, version);
> - td->eviction_flags = UINT32_MAX;
> -
> - struct ofpbuf properties = ofpbuf_const_initializer(
> - ofpbuf_pull(msg, length), length);
> - 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 OFPTMPT14_EVICTION:
> - error = ofpprop_parse_u32(&payload, &td->eviction_flags);
> - break;
> -
> - case OFPTMPT14_VACANCY:
> - error = parse_table_desc_vacancy_property(&payload, td);
> - break;
> -
> - default:
> - error = OFPPROP_UNKNOWN(true, "table_desc", type);
> - break;
> - }
> -
> - if (error) {
> - return error;
> - }
> - }
> -
> - return 0;
> -}
> -
> -/* Encodes and returns a request to obtain description of tables of a
> switch.
> - * The message is encoded for OpenFlow version 'ofp_version'. */
> -struct ofpbuf *
> -ofputil_encode_table_desc_request(enum ofp_version ofp_version)
> -{
> - struct ofpbuf *request = NULL;
> -
> - if (ofp_version >= OFP14_VERSION) {
> - request = ofpraw_alloc(OFPRAW_OFPST14_TABLE_DESC_REQUEST,
> - ofp_version, 0);
> - } else {
> - ovs_fatal(0, "dump-table-desc needs OpenFlow 1.4 or later "
> - "(\'-O OpenFlow14\')");
> - }
> -
> - return request;
> -}
> -
> -/* Function to append Table desc information in a reply list. */
> -void
> -ofputil_append_table_desc_reply(const struct ofputil_table_desc *td,
> - struct ovs_list *replies,
> - enum ofp_version version)
> -{
> - struct ofpbuf *reply = ofpbuf_from_list(ovs_list_back(replies));
> - size_t start_otd;
> - struct ofp14_table_desc *otd;
> -
> - start_otd = reply->size;
> - ofpbuf_put_zeros(reply, sizeof *otd);
> - if (td->eviction_flags != UINT32_MAX) {
> - ofpprop_put_u32(reply, OFPTMPT14_EVICTION, td->eviction_flags);
> - }
> - if (td->vacancy == OFPUTIL_TABLE_VACANCY_ON) {
> - struct ofp14_table_mod_prop_vacancy *otv;
> -
> - otv = ofpprop_put_zeros(reply, OFPTMPT14_VACANCY, sizeof *otv);
> - otv->vacancy_down = td->table_vacancy.vacancy_down;
> - otv->vacancy_up = td->table_vacancy.vacancy_up;
> - otv->vacancy = td->table_vacancy.vacancy;
> - }
> -
> - otd = ofpbuf_at_assert(reply, start_otd, sizeof *otd);
> - otd->length = htons(reply->size - start_otd);
> - otd->table_id = td->table_id;
> - otd->config = ofputil_encode_table_config(OFPUTIL_TABLE_MISS_DEFAULT,
> - td->eviction, td->vacancy,
> - version);
> - ofpmp_postappend(replies, start_otd);
> -}
> -
> -/* This function parses Vacancy property, and decodes the
> - * ofp14_table_mod_prop_vacancy in ofputil_table_mod.
> - * Returns OFPERR_OFPBPC_BAD_VALUE error code when vacancy_down is
> - * greater than vacancy_up and also when current vacancy has non-zero
> - * value. Returns 0 on success. */
> -static enum ofperr
> -parse_table_mod_vacancy_property(struct ofpbuf *property,
> - struct ofputil_table_mod *tm)
> -{
> - struct ofp14_table_mod_prop_vacancy *otv = property->data;
> -
> - if (property->size != sizeof *otv) {
> - return OFPERR_OFPBPC_BAD_LEN;
> - }
> - tm->table_vacancy.vacancy_down = otv->vacancy_down;
> - tm->table_vacancy.vacancy_up = otv->vacancy_up;
> - if (tm->table_vacancy.vacancy_down > tm->table_vacancy.vacancy_up) {
> - OFPPROP_LOG(&bad_ofmsg_rl, false,
> - "Value of vacancy_down is greater than vacancy_up");
> - return OFPERR_OFPBPC_BAD_VALUE;
> - }
> - if (tm->table_vacancy.vacancy_down > 100 ||
> - tm->table_vacancy.vacancy_up > 100) {
> - OFPPROP_LOG(&bad_ofmsg_rl, false, "Vacancy threshold percentage "
> - "should not be greater than 100");
> - return OFPERR_OFPBPC_BAD_VALUE;
> - }
> - tm->table_vacancy.vacancy = otv->vacancy;
> - if (tm->table_vacancy.vacancy) {
> - OFPPROP_LOG(&bad_ofmsg_rl, false,
> - "Vacancy value should be zero for table-mod
> messages");
> - return OFPERR_OFPBPC_BAD_VALUE;
> - }
> - return 0;
> -}
> -
> -/* Given 'config', taken from an OpenFlow 'version' message that specifies
> - * table configuration (a table mod, table stats, or table features
> message),
> - * returns the table vacancy configuration that it specifies.
> - *
> - * Only OpenFlow 1.4 and later specify table vacancy configuration this
> way,
> - * so for other 'version' this function always returns
> - * OFPUTIL_TABLE_VACANCY_DEFAULT. */
> -static enum ofputil_table_vacancy
> -ofputil_decode_table_vacancy(ovs_be32 config, enum ofp_version version)
> -{
> - return (version < OFP14_VERSION ? OFPUTIL_TABLE_VACANCY_DEFAULT
> - : config & htonl(OFPTC14_VACANCY_EVENTS) ?
> OFPUTIL_TABLE_VACANCY_ON
> - : OFPUTIL_TABLE_VACANCY_OFF);
> -}
> -
> -/* Given 'config', taken from an OpenFlow 'version' message that specifies
> - * table configuration (a table mod, table stats, or table features
> message),
> - * returns the table eviction configuration that it specifies.
> - *
> - * Only OpenFlow 1.4 and later specify table eviction configuration this
> way,
> - * so for other 'version' values this function always returns
> - * OFPUTIL_TABLE_EVICTION_DEFAULT. */
> -static enum ofputil_table_eviction
> -ofputil_decode_table_eviction(ovs_be32 config, enum ofp_version version)
> -{
> - return (version < OFP14_VERSION ? OFPUTIL_TABLE_EVICTION_DEFAULT
> - : config & htonl(OFPTC14_EVICTION) ? OFPUTIL_TABLE_EVICTION_ON
> - : OFPUTIL_TABLE_EVICTION_OFF);
> -}
> -
> -/* Returns a bitmap of OFPTC* values suitable for 'config' fields in
> various
> - * OpenFlow messages of the given 'version', based on the provided 'miss'
> and
> - * 'eviction' values. */
> -static ovs_be32
> -ofputil_encode_table_config(enum ofputil_table_miss miss,
> - enum ofputil_table_eviction eviction,
> - enum ofputil_table_vacancy vacancy,
> - enum ofp_version version)
> -{
> - uint32_t config = 0;
> - /* Search for "OFPTC_* Table Configuration" in the documentation for
> more
> - * information on the crazy evolution of this field. */
> - switch (version) {
> - case OFP10_VERSION:
> - /* OpenFlow 1.0 didn't have such a field, any value ought to do.
> */
> - return htonl(0);
> -
> - case OFP11_VERSION:
> - case OFP12_VERSION:
> - /* OpenFlow 1.1 and 1.2 define only OFPTC11_TABLE_MISS_*. */
> - switch (miss) {
> - case OFPUTIL_TABLE_MISS_DEFAULT:
> - /* Really this shouldn't be used for encoding (the caller
> should
> - * provide a specific value) but I can't imagine that
> defaulting to
> - * the fall-through case here will hurt. */
> - case OFPUTIL_TABLE_MISS_CONTROLLER:
> - default:
> - return htonl(OFPTC11_TABLE_MISS_CONTROLLER);
> - case OFPUTIL_TABLE_MISS_CONTINUE:
> - return htonl(OFPTC11_TABLE_MISS_CONTINUE);
> - case OFPUTIL_TABLE_MISS_DROP:
> - return htonl(OFPTC11_TABLE_MISS_DROP);
> - }
> - OVS_NOT_REACHED();
> -
> - case OFP13_VERSION:
> - /* OpenFlow 1.3 removed OFPTC11_TABLE_MISS_* and didn't define
> any new
> - * flags, so this is correct. */
> - return htonl(0);
> -
> - case OFP14_VERSION:
> - case OFP15_VERSION:
> - case OFP16_VERSION:
> - /* OpenFlow 1.4 introduced OFPTC14_EVICTION and
> - * OFPTC14_VACANCY_EVENTS. */
> - if (eviction == OFPUTIL_TABLE_EVICTION_ON) {
> - config |= OFPTC14_EVICTION;
> - }
> - if (vacancy == OFPUTIL_TABLE_VACANCY_ON) {
> - config |= OFPTC14_VACANCY_EVENTS;
> - }
> - return htonl(config);
> - }
> -
> - OVS_NOT_REACHED();
> -}
> -
> -/* Given 'config', taken from an OpenFlow 'version' message that specifies
> - * table configuration (a table mod, table stats, or table features
> message),
> - * returns the table miss configuration that it specifies.
> - *
> - * Only OpenFlow 1.1 and 1.2 specify table miss configurations this way,
> so for
> - * other 'version' values this function always returns
> - * OFPUTIL_TABLE_MISS_DEFAULT. */
> -static enum ofputil_table_miss
> -ofputil_decode_table_miss(ovs_be32 config_, enum ofp_version version)
> -{
> - uint32_t config = ntohl(config_);
> -
> - if (version == OFP11_VERSION || version == OFP12_VERSION) {
> - switch (config & OFPTC11_TABLE_MISS_MASK) {
> - case OFPTC11_TABLE_MISS_CONTROLLER:
> - return OFPUTIL_TABLE_MISS_CONTROLLER;
> -
> - case OFPTC11_TABLE_MISS_CONTINUE:
> - return OFPUTIL_TABLE_MISS_CONTINUE;
> -
> - case OFPTC11_TABLE_MISS_DROP:
> - return OFPUTIL_TABLE_MISS_DROP;
> -
> - default:
> - VLOG_WARN_RL(&bad_ofmsg_rl, "bad table miss config %d",
> config);
> - return OFPUTIL_TABLE_MISS_CONTROLLER;
> - }
> - } else {
> - return OFPUTIL_TABLE_MISS_DEFAULT;
> - }
> -}
> -
> -/* Decodes the OpenFlow "table mod" message in '*oh' into an abstract
> form in
> - * '*pm'. Returns 0 if successful, otherwise an OFPERR_* value. */
> -enum ofperr
> -ofputil_decode_table_mod(const struct ofp_header *oh,
> - struct ofputil_table_mod *pm)
> -{
> - memset(pm, 0, sizeof *pm);
> - pm->miss = OFPUTIL_TABLE_MISS_DEFAULT;
> - pm->eviction = OFPUTIL_TABLE_EVICTION_DEFAULT;
> - pm->eviction_flags = UINT32_MAX;
> - pm->vacancy = OFPUTIL_TABLE_VACANCY_DEFAULT;
> -
> - struct ofpbuf b = ofpbuf_const_initializer(oh, ntohs(oh->length));
> - enum ofpraw raw = ofpraw_pull_assert(&b);
> - if (raw == OFPRAW_OFPT11_TABLE_MOD) {
> - const struct ofp11_table_mod *otm = b.data;
> -
> - pm->table_id = otm->table_id;
> - pm->miss = ofputil_decode_table_miss(otm->config, oh->version);
> - } else if (raw == OFPRAW_OFPT14_TABLE_MOD) {
> - const struct ofp14_table_mod *otm = ofpbuf_pull(&b, sizeof *otm);
> -
> - pm->table_id = otm->table_id;
> - pm->miss = ofputil_decode_table_miss(otm->config, oh->version);
> - pm->eviction = ofputil_decode_table_eviction(otm->config,
> oh->version);
> - pm->vacancy = ofputil_decode_table_vacancy(otm->config,
> oh->version);
> - while (b.size > 0) {
> - struct ofpbuf property;
> - enum ofperr error;
> - uint64_t type;
> -
> - error = ofpprop_pull(&b, &property, &type);
> - if (error) {
> - return error;
> - }
> -
> - switch (type) {
> - case OFPTMPT14_EVICTION:
> - error = ofpprop_parse_u32(&property, &pm->eviction);
> - break;
> -
> - case OFPTMPT14_VACANCY:
> - error = parse_table_mod_vacancy_property(&property, pm);
> - break;
> -
> - default:
> - error = OFPERR_OFPBRC_BAD_TYPE;
> - break;
> - }
> -
> - if (error) {
> - return error;
> - }
> - }
> - } else {
> - return OFPERR_OFPBRC_BAD_TYPE;
> - }
> -
> - return 0;
> -}
> -
> -/* Converts the abstract form of a "table mod" message in '*tm' into an
> - * OpenFlow message suitable for 'protocol', and returns that encoded
> form in a
> - * buffer owned by the caller. */
> -struct ofpbuf *
> -ofputil_encode_table_mod(const struct ofputil_table_mod *tm,
> - enum ofputil_protocol protocol)
> -{
> - enum ofp_version ofp_version = ofputil_protocol_to_ofp_
> version(protocol);
> - struct ofpbuf *b;
> -
> - switch (ofp_version) {
> - case OFP10_VERSION: {
> - ovs_fatal(0, "table mod needs OpenFlow 1.1 or later "
> - "(\'-O OpenFlow11\')");
> - break;
> - }
> - case OFP11_VERSION:
> - case OFP12_VERSION:
> - case OFP13_VERSION: {
> - struct ofp11_table_mod *otm;
> -
> - b = ofpraw_alloc(OFPRAW_OFPT11_TABLE_MOD, ofp_version, 0);
> - otm = ofpbuf_put_zeros(b, sizeof *otm);
> - otm->table_id = tm->table_id;
> - otm->config = ofputil_encode_table_config(tm->miss, tm->eviction,
> - tm->vacancy,
> ofp_version);
> - break;
> - }
> - case OFP14_VERSION:
> - case OFP15_VERSION:
> - case OFP16_VERSION: {
> - struct ofp14_table_mod *otm;
> -
> - b = ofpraw_alloc(OFPRAW_OFPT14_TABLE_MOD, ofp_version, 0);
> - otm = ofpbuf_put_zeros(b, sizeof *otm);
> - otm->table_id = tm->table_id;
> - otm->config = ofputil_encode_table_config(tm->miss, tm->eviction,
> - tm->vacancy,
> ofp_version);
> -
> - if (tm->eviction_flags != UINT32_MAX) {
> - ofpprop_put_u32(b, OFPTMPT14_EVICTION, tm->eviction_flags);
> - }
> - if (tm->vacancy == OFPUTIL_TABLE_VACANCY_ON) {
> - struct ofp14_table_mod_prop_vacancy *otv;
> -
> - otv = ofpprop_put_zeros(b, OFPTMPT14_VACANCY, sizeof *otv);
> - otv->vacancy_down = tm->table_vacancy.vacancy_down;
> - otv->vacancy_up = tm->table_vacancy.vacancy_up;
> - }
> - break;
> - }
> - default:
> - OVS_NOT_REACHED();
> - }
> -
> - return b;
> -}
> -
> -/* 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;
> -}
> -
> -/* 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();
> - }
> -}
> -
> -/* Table stats. */
> -
> -/* OpenFlow 1.0 and 1.1 don't distinguish between a field that cannot be
> - * matched and a field that must be wildcarded. This function returns a
> bitmap
> - * that contains both kinds of fields. */
> -static struct mf_bitmap
> -wild_or_nonmatchable_fields(const struct ofputil_table_features
> *features)
> -{
> - struct mf_bitmap wc = features->match;
> - bitmap_not(wc.bm, MFF_N_IDS);
> - bitmap_or(wc.bm, features->wildcard.bm, MFF_N_IDS);
> - return wc;
> -}
> -
> -struct ofp10_wc_map {
> - enum ofp10_flow_wildcards wc10;
> - enum mf_field_id mf;
> -};
> -
> -static const struct ofp10_wc_map ofp10_wc_map[] = {
> - { OFPFW10_IN_PORT, MFF_IN_PORT },
> - { OFPFW10_DL_VLAN, MFF_VLAN_VID },
> - { OFPFW10_DL_SRC, MFF_ETH_SRC },
> - { OFPFW10_DL_DST, MFF_ETH_DST},
> - { OFPFW10_DL_TYPE, MFF_ETH_TYPE },
> - { OFPFW10_NW_PROTO, MFF_IP_PROTO },
> - { OFPFW10_TP_SRC, MFF_TCP_SRC },
> - { OFPFW10_TP_DST, MFF_TCP_DST },
> - { OFPFW10_NW_SRC_MASK, MFF_IPV4_SRC },
> - { OFPFW10_NW_DST_MASK, MFF_IPV4_DST },
> - { OFPFW10_DL_VLAN_PCP, MFF_VLAN_PCP },
> - { OFPFW10_NW_TOS, MFF_IP_DSCP },
> -};
> -
> -static ovs_be32
> -mf_bitmap_to_of10(const struct mf_bitmap *fields)
> -{
> - const struct ofp10_wc_map *p;
> - uint32_t wc10 = 0;
> -
> - for (p = ofp10_wc_map; p < &ofp10_wc_map[ARRAY_SIZE(ofp10_wc_map)];
> p++) {
> - if (bitmap_is_set(fields->bm, p->mf)) {
> - wc10 |= p->wc10;
> - }
> - }
> - return htonl(wc10);
> -}
> -
> -static struct mf_bitmap
> -mf_bitmap_from_of10(ovs_be32 wc10_)
> -{
> - struct mf_bitmap fields = MF_BITMAP_INITIALIZER;
> - const struct ofp10_wc_map *p;
> - uint32_t wc10 = ntohl(wc10_);
> -
> - for (p = ofp10_wc_map; p < &ofp10_wc_map[ARRAY_SIZE(ofp10_wc_map)];
> p++) {
> - if (wc10 & p->wc10) {
> - bitmap_set1(fields.bm, p->mf);
> - }
> - }
> - return fields;
> -}
> -
> -static void
> -ofputil_put_ofp10_table_stats(const struct ofputil_table_stats *stats,
> - const struct ofputil_table_features
> *features,
> - struct ofpbuf *buf)
> -{
> - struct mf_bitmap wc = wild_or_nonmatchable_fields(features);
> - struct ofp10_table_stats *out;
> -
> - out = ofpbuf_put_zeros(buf, sizeof *out);
> - out->table_id = features->table_id;
> - ovs_strlcpy_arrays(out->name, features->name);
> - out->wildcards = mf_bitmap_to_of10(&wc);
> - out->max_entries = htonl(features->max_entries);
> - out->active_count = htonl(stats->active_count);
> - put_32aligned_be64(&out->lookup_count, htonll(stats->lookup_count));
> - put_32aligned_be64(&out->matched_count,
> htonll(stats->matched_count));
> -}
> -
> -struct ofp11_wc_map {
> - enum ofp11_flow_match_fields wc11;
> - enum mf_field_id mf;
> -};
> -
> -static const struct ofp11_wc_map ofp11_wc_map[] = {
> - { OFPFMF11_IN_PORT, MFF_IN_PORT },
> - { OFPFMF11_DL_VLAN, MFF_VLAN_VID },
> - { OFPFMF11_DL_VLAN_PCP, MFF_VLAN_PCP },
> - { OFPFMF11_DL_TYPE, MFF_ETH_TYPE },
> - { OFPFMF11_NW_TOS, MFF_IP_DSCP },
> - { OFPFMF11_NW_PROTO, MFF_IP_PROTO },
> - { OFPFMF11_TP_SRC, MFF_TCP_SRC },
> - { OFPFMF11_TP_DST, MFF_TCP_DST },
> - { OFPFMF11_MPLS_LABEL, MFF_MPLS_LABEL },
> - { OFPFMF11_MPLS_TC, MFF_MPLS_TC },
> - /* I don't know what OFPFMF11_TYPE means. */
> - { OFPFMF11_DL_SRC, MFF_ETH_SRC },
> - { OFPFMF11_DL_DST, MFF_ETH_DST },
> - { OFPFMF11_NW_SRC, MFF_IPV4_SRC },
> - { OFPFMF11_NW_DST, MFF_IPV4_DST },
> - { OFPFMF11_METADATA, MFF_METADATA },
> -};
> -
> -static ovs_be32
> -mf_bitmap_to_of11(const struct mf_bitmap *fields)
> -{
> - const struct ofp11_wc_map *p;
> - uint32_t wc11 = 0;
> -
> - for (p = ofp11_wc_map; p < &ofp11_wc_map[ARRAY_SIZE(ofp11_wc_map)];
> p++) {
> - if (bitmap_is_set(fields->bm, p->mf)) {
> - wc11 |= p->wc11;
> - }
> - }
> - return htonl(wc11);
> -}
> -
> -static struct mf_bitmap
> -mf_bitmap_from_of11(ovs_be32 wc11_)
> -{
> - struct mf_bitmap fields = MF_BITMAP_INITIALIZER;
> - const struct ofp11_wc_map *p;
> - uint32_t wc11 = ntohl(wc11_);
> -
> - for (p = ofp11_wc_map; p < &ofp11_wc_map[ARRAY_SIZE(ofp11_wc_map)];
> p++) {
> - if (wc11 & p->wc11) {
> - bitmap_set1(fields.bm, p->mf);
> - }
> - }
> - return fields;
> -}
> -
> -static void
> -ofputil_put_ofp11_table_stats(const struct ofputil_table_stats *stats,
> - const struct ofputil_table_features
> *features,
> - struct ofpbuf *buf)
> -{
> - struct mf_bitmap wc = wild_or_nonmatchable_fields(features);
> - struct ofp11_table_stats *out;
> -
> - out = ofpbuf_put_zeros(buf, sizeof *out);
> - out->table_id = features->table_id;
> - ovs_strlcpy_arrays(out->name, features->name);
> - out->wildcards = mf_bitmap_to_of11(&wc);
> - out->match = mf_bitmap_to_of11(&features->match);
> - out->instructions = ovsinst_bitmap_to_openflow(
> - features->nonmiss.instructions, OFP11_VERSION);
> - out->write_actions = ofpact_bitmap_to_openflow(
> - features->nonmiss.write.ofpacts, OFP11_VERSION);
> - out->apply_actions = ofpact_bitmap_to_openflow(
> - features->nonmiss.apply.ofpacts, OFP11_VERSION);
> - out->config = htonl(features->miss_config);
> - out->max_entries = htonl(features->max_entries);
> - out->active_count = htonl(stats->active_count);
> - out->lookup_count = htonll(stats->lookup_count);
> - out->matched_count = htonll(stats->matched_count);
> -}
> -
> -static void
> -ofputil_put_ofp12_table_stats(const struct ofputil_table_stats *stats,
> - const struct ofputil_table_features
> *features,
> - struct ofpbuf *buf)
> -{
> - struct ofp12_table_stats *out;
> -
> - out = ofpbuf_put_zeros(buf, sizeof *out);
> - out->table_id = features->table_id;
> - ovs_strlcpy_arrays(out->name, features->name);
> - out->match = oxm_bitmap_from_mf_bitmap(&features->match,
> OFP12_VERSION);
> - out->wildcards = oxm_bitmap_from_mf_bitmap(&features->wildcard,
> - OFP12_VERSION);
> - out->write_actions = ofpact_bitmap_to_openflow(
> - features->nonmiss.write.ofpacts, OFP12_VERSION);
> - out->apply_actions = ofpact_bitmap_to_openflow(
> - features->nonmiss.apply.ofpacts, OFP12_VERSION);
> - out->write_setfields = oxm_bitmap_from_mf_bitmap(
> - &features->nonmiss.write.set_fields, OFP12_VERSION);
> - out->apply_setfields = oxm_bitmap_from_mf_bitmap(
> - &features->nonmiss.apply.set_fields, OFP12_VERSION);
> - out->metadata_match = features->metadata_match;
> - out->metadata_write = features->metadata_write;
> - out->instructions = ovsinst_bitmap_to_openflow(
> - features->nonmiss.instructions, OFP12_VERSION);
> - out->config = ofputil_encode_table_config(features->miss_config,
> - OFPUTIL_TABLE_EVICTION_
> DEFAULT,
> -
> OFPUTIL_TABLE_VACANCY_DEFAULT,
> - OFP12_VERSION);
> - out->max_entries = htonl(features->max_entries);
> - out->active_count = htonl(stats->active_count);
> - out->lookup_count = htonll(stats->lookup_count);
> - out->matched_count = htonll(stats->matched_count);
> -}
> -
> -static void
> -ofputil_put_ofp13_table_stats(const struct ofputil_table_stats *stats,
> - struct ofpbuf *buf)
> -{
> - struct ofp13_table_stats *out;
> -
> - out = ofpbuf_put_zeros(buf, sizeof *out);
> - out->table_id = stats->table_id;
> - out->active_count = htonl(stats->active_count);
> - out->lookup_count = htonll(stats->lookup_count);
> - out->matched_count = htonll(stats->matched_count);
> -}
> -
> -struct ofpbuf *
> -ofputil_encode_table_stats_reply(const struct ofp_header *request)
> -{
> - return ofpraw_alloc_stats_reply(request, 0);
> -}
> -
> -void
> -ofputil_append_table_stats_reply(struct ofpbuf *reply,
> - const struct ofputil_table_stats *stats,
> - const struct ofputil_table_features
> *features)
> -{
> - struct ofp_header *oh = reply->header;
> -
> - ovs_assert(stats->table_id == features->table_id);
> -
> - switch ((enum ofp_version) oh->version) {
> - case OFP10_VERSION:
> - ofputil_put_ofp10_table_stats(stats, features, reply);
> - break;
> -
> - case OFP11_VERSION:
> - ofputil_put_ofp11_table_stats(stats, features, reply);
> - break;
> -
> - case OFP12_VERSION:
> - ofputil_put_ofp12_table_stats(stats, features, reply);
> - break;
> -
> - case OFP13_VERSION:
> - case OFP14_VERSION:
> - case OFP15_VERSION:
> - case OFP16_VERSION:
> - ofputil_put_ofp13_table_stats(stats, reply);
> - break;
> -
> - default:
> - OVS_NOT_REACHED();
> - }
> -}
> -
> -static int
> -ofputil_decode_ofp10_table_stats(struct ofpbuf *msg,
> - struct ofputil_table_stats *stats,
> - struct ofputil_table_features *features)
> -{
> - struct ofp10_table_stats *ots;
> -
> - ots = ofpbuf_try_pull(msg, sizeof *ots);
> - if (!ots) {
> - return OFPERR_OFPBRC_BAD_LEN;
> - }
> -
> - features->table_id = ots->table_id;
> - ovs_strlcpy_arrays(features->name, ots->name);
> - features->max_entries = ntohl(ots->max_entries);
> - features->match = features->wildcard = mf_bitmap_from_of10(ots->
> wildcards);
> -
> - stats->table_id = ots->table_id;
> - stats->active_count = ntohl(ots->active_count);
> - stats->lookup_count = ntohll(get_32aligned_be64(&ots->lookup_count));
> - stats->matched_count = ntohll(get_32aligned_be64(&
> ots->matched_count));
> -
> - return 0;
> -}
> -
> -static int
> -ofputil_decode_ofp11_table_stats(struct ofpbuf *msg,
> - struct ofputil_table_stats *stats,
> - struct ofputil_table_features *features)
> -{
> - struct ofp11_table_stats *ots;
> -
> - ots = ofpbuf_try_pull(msg, sizeof *ots);
> - if (!ots) {
> - return OFPERR_OFPBRC_BAD_LEN;
> - }
> -
> - features->table_id = ots->table_id;
> - ovs_strlcpy_arrays(features->name, ots->name);
> - features->max_entries = ntohl(ots->max_entries);
> - features->nonmiss.instructions = ovsinst_bitmap_from_openflow(
> - ots->instructions, OFP11_VERSION);
> - features->nonmiss.write.ofpacts = ofpact_bitmap_from_openflow(
> - ots->write_actions, OFP11_VERSION);
> - features->nonmiss.apply.ofpacts = ofpact_bitmap_from_openflow(
> - ots->write_actions, OFP11_VERSION);
> - features->miss = features->nonmiss;
> - features->miss_config = ofputil_decode_table_miss(ots->config,
> - OFP11_VERSION);
> - features->match = mf_bitmap_from_of11(ots->match);
> - features->wildcard = mf_bitmap_from_of11(ots->wildcards);
> - bitmap_or(features->match.bm, features->wildcard.bm, MFF_N_IDS);
> -
> - stats->table_id = ots->table_id;
> - stats->active_count = ntohl(ots->active_count);
> - stats->lookup_count = ntohll(ots->lookup_count);
> - stats->matched_count = ntohll(ots->matched_count);
> -
> - return 0;
> -}
> -
> -static int
> -ofputil_decode_ofp12_table_stats(struct ofpbuf *msg,
> - struct ofputil_table_stats *stats,
> - struct ofputil_table_features *features)
> -{
> - struct ofp12_table_stats *ots;
> -
> - ots = ofpbuf_try_pull(msg, sizeof *ots);
> - if (!ots) {
> - return OFPERR_OFPBRC_BAD_LEN;
> - }
> -
> - features->table_id = ots->table_id;
> - ovs_strlcpy_arrays(features->name, ots->name);
> - features->metadata_match = ots->metadata_match;
> - features->metadata_write = ots->metadata_write;
> - features->miss_config = ofputil_decode_table_miss(ots->config,
> - OFP12_VERSION);
> - features->max_entries = ntohl(ots->max_entries);
> -
> - features->nonmiss.instructions = ovsinst_bitmap_from_openflow(
> - ots->instructions, OFP12_VERSION);
> - features->nonmiss.write.ofpacts = ofpact_bitmap_from_openflow(
> - ots->write_actions, OFP12_VERSION);
> - features->nonmiss.apply.ofpacts = ofpact_bitmap_from_openflow(
> - ots->apply_actions, OFP12_VERSION);
> - features->nonmiss.write.set_fields = oxm_bitmap_to_mf_bitmap(
> - ots->write_setfields, OFP12_VERSION);
> - features->nonmiss.apply.set_fields = oxm_bitmap_to_mf_bitmap(
> - ots->apply_setfields, OFP12_VERSION);
> - features->miss = features->nonmiss;
> -
> - features->match = oxm_bitmap_to_mf_bitmap(ots->match, OFP12_VERSION);
> - features->wildcard = oxm_bitmap_to_mf_bitmap(ots->wildcards,
> - OFP12_VERSION);
> - bitmap_or(features->match.bm, features->wildcard.bm, MFF_N_IDS);
> -
> - stats->table_id = ots->table_id;
> - stats->active_count = ntohl(ots->active_count);
> - stats->lookup_count = ntohll(ots->lookup_count);
> - stats->matched_count = ntohll(ots->matched_count);
> -
> - return 0;
> -}
> -
> -static int
> -ofputil_decode_ofp13_table_stats(struct ofpbuf *msg,
> - struct ofputil_table_stats *stats,
> - struct ofputil_table_features *features)
> -{
> - struct ofp13_table_stats *ots;
> -
> - ots = ofpbuf_try_pull(msg, sizeof *ots);
> - if (!ots) {
> - return OFPERR_OFPBRC_BAD_LEN;
> - }
> -
> - features->table_id = ots->table_id;
> -
> - stats->table_id = ots->table_id;
> - stats->active_count = ntohl(ots->active_count);
> - stats->lookup_count = ntohll(ots->lookup_count);
> - stats->matched_count = ntohll(ots->matched_count);
> -
> - return 0;
> -}
> -
> -int
> -ofputil_decode_table_stats_reply(struct ofpbuf *msg,
> - struct ofputil_table_stats *stats,
> - struct ofputil_table_features *features)
> -{
> - const struct ofp_header *oh;
> -
> - if (!msg->header) {
> - ofpraw_pull_assert(msg);
> - }
> - oh = msg->header;
> -
> - if (!msg->size) {
> - return EOF;
> - }
> -
> - memset(stats, 0, sizeof *stats);
> - memset(features, 0, sizeof *features);
> - features->supports_eviction = -1;
> - features->supports_vacancy_events = -1;
> -
> - switch ((enum ofp_version) oh->version) {
> - case OFP10_VERSION:
> - return ofputil_decode_ofp10_table_stats(msg, stats, features);
> -
> - case OFP11_VERSION:
> - return ofputil_decode_ofp11_table_stats(msg, stats, features);
> -
> - case OFP12_VERSION:
> - return ofputil_decode_ofp12_table_stats(msg, stats, features);
> -
> - case OFP13_VERSION:
> - case OFP14_VERSION:
> - case OFP15_VERSION:
> - case OFP16_VERSION:
> - return ofputil_decode_ofp13_table_stats(msg, stats, features);
> -
> - default:
> - OVS_NOT_REACHED();
> - }
> -}
> -
> -/* ofputil_flow_monitor_request */
> -
> -/* Converts an NXST_FLOW_MONITOR request in 'msg' into an abstract
> - * ofputil_flow_monitor_request in 'rq'.
> - *
> - * Multiple NXST_FLOW_MONITOR requests can be packed into a single
> OpenFlow
> - * message. Calling this function multiple times for a single 'msg'
> iterates
> - * through the requests. The caller must initially leave 'msg''s layer
> - * pointers null and not modify them between calls.
> - *
> - * Returns 0 if successful, EOF if no requests were left in this 'msg',
> - * otherwise an OFPERR_* value. */
> -int
> -ofputil_decode_flow_monitor_request(struct ofputil_flow_monitor_request
> *rq,
> - struct ofpbuf *msg)
> -{
> - struct nx_flow_monitor_request *nfmr;
> - uint16_t flags;
> -
> - if (!msg->header) {
> - ofpraw_pull_assert(msg);
> - }
> -
> - if (!msg->size) {
> - return EOF;
> - }
> -
> - nfmr = ofpbuf_try_pull(msg, sizeof *nfmr);
> - if (!nfmr) {
> - VLOG_WARN_RL(&bad_ofmsg_rl, "NXST_FLOW_MONITOR request has
> %"PRIu32" "
> - "leftover bytes at end", 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(&bad_ofmsg_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;
> -}
> -
> -/* 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(&bad_ofmsg_rl,
> - "NXST_FLOW_MONITOR reply has bad event %"PRIu16,
> - ntohs(nfuh->event));
> - return OFPERR_NXBRC_FM_BAD_EVENT;
> - }
> -
> -bad_len:
> - VLOG_WARN_RL(&bad_ofmsg_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;
> -}
> -
> -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;
> -}
> -
> -/* Creates and returns an OFPT_ECHO_REQUEST message with an empty
> payload. */
> -struct ofpbuf *
> -make_echo_request(enum ofp_version ofp_version)
> -{
> - return ofpraw_alloc_xid(OFPRAW_OFPT_ECHO_REQUEST, ofp_version,
> - htonl(0), 0);
> -}
> -
> -/* Creates and returns an OFPT_ECHO_REPLY message matching the
> - * OFPT_ECHO_REQUEST message in 'rq'. */
> -struct ofpbuf *
> -make_echo_reply(const struct ofp_header *rq)
> -{
> - struct ofpbuf rq_buf = ofpbuf_const_initializer(rq,
> ntohs(rq->length));
> - ofpraw_pull_assert(&rq_buf);
> -
> - struct ofpbuf *reply = ofpraw_alloc_reply(OFPRAW_OFPT_ECHO_REPLY,
> - rq, rq_buf.size);
> - ofpbuf_put(reply, rq_buf.data, rq_buf.size);
> - return reply;
> -}
> -
> -struct ofpbuf *
> -ofputil_encode_barrier_request(enum ofp_version ofp_version)
> -{
> - enum ofpraw type;
> -
> - switch (ofp_version) {
> - case OFP16_VERSION:
> - case OFP15_VERSION:
> - case OFP14_VERSION:
> - case OFP13_VERSION:
> - case OFP12_VERSION:
> - case OFP11_VERSION:
> - type = OFPRAW_OFPT11_BARRIER_REQUEST;
> - break;
> -
> - case OFP10_VERSION:
> - type = OFPRAW_OFPT10_BARRIER_REQUEST;
> - break;
> -
> - default:
> - OVS_NOT_REACHED();
> - }
> -
> - return ofpraw_alloc(type, ofp_version, 0);
> -}
> -
> -const char *
> -ofputil_frag_handling_to_string(enum ofputil_frag_handling frag)
> -{
> - switch (frag) {
> - case OFPUTIL_FRAG_NORMAL: return "normal";
> - case OFPUTIL_FRAG_DROP: return "drop";
> - case OFPUTIL_FRAG_REASM: return "reassemble";
> - case OFPUTIL_FRAG_NX_MATCH: return "nx-match";
> - }
> -
> - OVS_NOT_REACHED();
> -}
> -
> -bool
> -ofputil_frag_handling_from_string(const char *s,
> - enum ofputil_frag_handling *frag)
> -{
> - if (!strcasecmp(s, "normal")) {
> - *frag = OFPUTIL_FRAG_NORMAL;
> - } else if (!strcasecmp(s, "drop")) {
> - *frag = OFPUTIL_FRAG_DROP;
> - } else if (!strcasecmp(s, "reassemble")) {
> - *frag = OFPUTIL_FRAG_REASM;
> - } else if (!strcasecmp(s, "nx-match")) {
> - *frag = OFPUTIL_FRAG_NX_MATCH;
> - } else {
> - return false;
> - }
> - return true;
> -}
> -
> -/* Converts the OpenFlow 1.1+ port number 'ofp11_port' into an OpenFlow
> 1.0
> - * port number and stores the latter in '*ofp10_port', for the purpose of
> - * decoding OpenFlow 1.1+ protocol messages. Returns 0 if successful,
> - * otherwise an OFPERR_* number. On error, stores OFPP_NONE in
> '*ofp10_port'.
> - *
> - * See the definition of OFP11_MAX for an explanation of the mapping. */
> -enum ofperr
> -ofputil_port_from_ofp11(ovs_be32 ofp11_port, ofp_port_t *ofp10_port)
> -{
> - uint32_t ofp11_port_h = ntohl(ofp11_port);
> -
> - if (ofp11_port_h < ofp_to_u16(OFPP_MAX)) {
> - *ofp10_port = u16_to_ofp(ofp11_port_h);
> - return 0;
> - } else if (ofp11_port_h >= ofp11_to_u32(OFPP11_MAX)) {
> - *ofp10_port = u16_to_ofp(ofp11_port_h - OFPP11_OFFSET);
> - return 0;
> - } else {
> - *ofp10_port = OFPP_NONE;
> - VLOG_WARN_RL(&bad_ofmsg_rl, "port %"PRIu32" is outside the
> supported "
> - "range 0 through %d or 0x%"PRIx32" through
> 0x%"PRIx32,
> - ofp11_port_h, ofp_to_u16(OFPP_MAX) - 1,
> - ofp11_to_u32(OFPP11_MAX), UINT32_MAX);
> - return OFPERR_OFPBAC_BAD_OUT_PORT;
> - }
> -}
> -
> -/* Returns the OpenFlow 1.1+ port number equivalent to the OpenFlow 1.0
> port
> - * number 'ofp10_port', for encoding OpenFlow 1.1+ protocol messages.
> - *
> - * See the definition of OFP11_MAX for an explanation of the mapping. */
> -ovs_be32
> -ofputil_port_to_ofp11(ofp_port_t ofp10_port)
> -{
> - return htonl(ofp_to_u16(ofp10_port) < ofp_to_u16(OFPP_MAX)
> - ? ofp_to_u16(ofp10_port)
> - : ofp_to_u16(ofp10_port) + OFPP11_OFFSET);
> -}
> -
> -#define OFPUTIL_NAMED_PORTS \
> - OFPUTIL_NAMED_PORT(IN_PORT) \
> - OFPUTIL_NAMED_PORT(TABLE) \
> - OFPUTIL_NAMED_PORT(NORMAL) \
> - OFPUTIL_NAMED_PORT(FLOOD) \
> - OFPUTIL_NAMED_PORT(ALL) \
> - OFPUTIL_NAMED_PORT(CONTROLLER) \
> - OFPUTIL_NAMED_PORT(LOCAL) \
> - OFPUTIL_NAMED_PORT(ANY) \
> - OFPUTIL_NAMED_PORT(UNSET)
> -
> -/* For backwards compatibility, so that "none" is recognized as OFPP_ANY
> */
> -#define OFPUTIL_NAMED_PORTS_WITH_NONE \
> - OFPUTIL_NAMED_PORTS \
> - OFPUTIL_NAMED_PORT(NONE)
> -
> -/* Stores the port number represented by 's' into '*portp'. 's' may be an
> - * integer or, for reserved ports, the standard OpenFlow name for the port
> - * (e.g. "LOCAL"). If 'port_map' is nonnull, also accepts names in it
> (quoted
> - * or unquoted).
> - *
> - * Returns true if successful, false if 's' is not a valid OpenFlow port
> number
> - * or name. The caller should issue an error message in this case,
> because
> - * this function usually does not. (This gives the caller an opportunity
> to
> - * look up the port name another way, e.g. by contacting the switch and
> listing
> - * the names of all its ports).
> - *
> - * This function accepts OpenFlow 1.0 port numbers. It also accepts a
> subset
> - * of OpenFlow 1.1+ port numbers, mapping those port numbers into the
> 16-bit
> - * range as described in include/openflow/openflow-1.1.h. */
> -bool
> -ofputil_port_from_string(const char *s,
> - const struct ofputil_port_map *port_map,
> - ofp_port_t *portp)
> -{
> - unsigned int port32; /* int is at least 32 bits wide. */
> -
> - if (*s == '-') {
> - VLOG_WARN("Negative value %s is not a valid port number.", s);
> - return false;
> - }
> - *portp = 0;
> - if (str_to_uint(s, 10, &port32)) {
> - if (port32 < ofp_to_u16(OFPP_MAX)) {
> - /* Pass. */
> - } else if (port32 < ofp_to_u16(OFPP_FIRST_RESV)) {
> - VLOG_WARN("port %u is a reserved OF1.0 port number that will "
> - "be translated to %u when talking to an OF1.1 or "
> - "later controller", port32, port32 + OFPP11_OFFSET);
> - } else if (port32 <= ofp_to_u16(OFPP_LAST_RESV)) {
> - char name[OFP10_MAX_PORT_NAME_LEN];
> -
> - ofputil_port_to_string(u16_to_ofp(port32), NULL,
> - name, sizeof name);
> - VLOG_WARN_ONCE("referring to port %s as %"PRIu32" is
> deprecated "
> - "for compatibility with OpenFlow 1.1 and
> later",
> - name, port32);
> - } else if (port32 < ofp11_to_u32(OFPP11_MAX)) {
> - VLOG_WARN("port %u is outside the supported range 0 through "
> - "%x or 0x%x through 0x%"PRIx32, port32,
> - UINT16_MAX, ofp11_to_u32(OFPP11_MAX), UINT32_MAX);
> - return false;
> - } else {
> - port32 -= OFPP11_OFFSET;
> - }
> -
> - *portp = u16_to_ofp(port32);
> - return true;
> - } else {
> - struct pair {
> - const char *name;
> - ofp_port_t value;
> - };
> - static const struct pair pairs[] = {
> -#define OFPUTIL_NAMED_PORT(NAME) {#NAME, OFPP_##NAME},
> - OFPUTIL_NAMED_PORTS_WITH_NONE
> -#undef OFPUTIL_NAMED_PORT
> - };
> - const struct pair *p;
> -
> - for (p = pairs; p < &pairs[ARRAY_SIZE(pairs)]; p++) {
> - if (!strcasecmp(s, p->name)) {
> - *portp = p->value;
> - return true;
> - }
> - }
> -
> - ofp_port_t ofp_port = OFPP_NONE;
> - if (s[0] != '"') {
> - ofp_port = ofputil_port_map_get_number(port_map, s);
> - } else {
> - size_t length = strlen(s);
> - char *name = NULL;
> - if (length > 1
> - && s[length - 1] == '"'
> - && json_string_unescape(s + 1, length - 2, &name)) {
> - ofp_port = ofputil_port_map_get_number(port_map, name);
> - }
> - free(name);
> - }
> - if (ofp_port != OFPP_NONE) {
> - *portp = ofp_port;
> - return true;
> - }
> -
> - return false;
> - }
> -}
> -
> -const char *
> -ofputil_port_get_reserved_name(ofp_port_t port)
> -{
> - switch (port) {
> -#define OFPUTIL_NAMED_PORT(NAME) case OFPP_##NAME: return #NAME;
> - OFPUTIL_NAMED_PORTS
> -#undef OFPUTIL_NAMED_PORT
> -
> - default:
> - return NULL;
> - }
> -}
> -
> -/* 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. */
> -static void
> -put_name(const char *name, struct ds *s)
> -{
> - if (name_needs_quotes(name)) {
> - json_string_escape(name, s);
> - } else {
> - ds_put_cstr(s, name);
> - }
> -}
> -
> -/* Appends to 's' a string representation of the OpenFlow port number
> 'port'.
> - * Most ports' string representation is just the port number, but for
> special
> - * ports, e.g. OFPP_LOCAL, it is the name, e.g. "LOCAL". */
> -void
> -ofputil_format_port(ofp_port_t port, const struct ofputil_port_map
> *port_map,
> - struct ds *s)
> -{
> - const char *reserved_name = ofputil_port_get_reserved_name(port);
> - if (reserved_name) {
> - ds_put_cstr(s, reserved_name);
> - return;
> - }
> -
> - const char *port_name = ofputil_port_map_get_name(port_map, port);
> - if (port_name) {
> - put_name(port_name, s);
> - return;
> - }
> -
> - ds_put_format(s, "%"PRIu32, port);
> -}
> -
> -/* Puts in the 'bufsize' byte in 'namebuf' a null-terminated string
> - * representation of OpenFlow port number 'port'. Most ports are
> represented
> - * as just the port number, but special ports, e.g. OFPP_LOCAL, are
> represented
> - * by name, e.g. "LOCAL". */
> -void
> -ofputil_port_to_string(ofp_port_t port,
> - const struct ofputil_port_map *port_map,
> - char *namebuf, size_t bufsize)
> -{
> - const char *reserved_name = ofputil_port_get_reserved_name(port);
> - if (reserved_name) {
> - ovs_strlcpy(namebuf, reserved_name, bufsize);
> - return;
> - }
> -
> - const char *port_name = ofputil_port_map_get_name(port_map, port);
> - if (port_name) {
> - struct ds s = DS_EMPTY_INITIALIZER;
> - put_name(port_name, &s);
> - ovs_strlcpy(namebuf, ds_cstr(&s), bufsize);
> - ds_destroy(&s);
> - return;
> - }
> -
> - snprintf(namebuf, bufsize, "%"PRIu32, port);
> -}
> -
> -/* ofputil_name_map. */
> -
> -struct ofputil_name_map_node {
> - struct hmap_node name_node;
> - struct hmap_node number_node;
> -
> - uint32_t number;
> - char *name;
> -
> - /* OpenFlow doesn't require port names to be unique, although that's
> the
> - * only sensible way. However, even in Open vSwitch 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. So, we
> guard
> - * against duplicate names to avoid giving unexpected results in this
> - * corner case.
> - *
> - * OpenFlow does require port numbers to be unique. We check for
> duplicate
> - * ports numbers just in case a switch has a bug.
> - *
> - * OpenFlow doesn't require table names to be unique and Open vSwitch
> - * doesn't try to make them unique. */
> - bool duplicate;
> -};
> -
> -static void
> -ofputil_name_map_init(struct ofputil_name_map *map)
> -{
> - hmap_init(&map->by_name);
> - hmap_init(&map->by_number);
> -}
> -
> -static struct ofputil_name_map_node *
> -ofputil_name_map_find_by_name(const struct ofputil_name_map *map,
> - const char *name)
> -{
> - struct ofputil_name_map_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;
> -}
> -
> -static struct ofputil_name_map_node *
> -ofputil_name_map_find_by_number(const struct ofputil_name_map *map,
> - uint32_t number)
> -{
> - struct ofputil_name_map_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;
> -}
> -
> -static void
> -ofputil_name_map_put(struct ofputil_name_map *map,
> - uint32_t number, const char *name)
> -{
> - struct ofputil_name_map_node *node;
> -
> - /* Look for duplicate name. */
> - node = ofputil_name_map_find_by_name(map, name);
> - if (node) {
> - if (node->number != number) {
> - node->duplicate = true;
> - }
> - return;
> - }
> -
> - /* Look for duplicate number. */
> - node = ofputil_name_map_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;
> -}
> -
> -static void
> -ofputil_name_map_destroy(struct ofputil_name_map *map)
> -{
> - if (map) {
> - struct ofputil_name_map_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);
> - }
> -}
> -
> -/* ofputil_port_map. */
> -
> -void
> -ofputil_port_map_init(struct ofputil_port_map *map)
> -{
> - ofputil_name_map_init(&map->map);
> -}
> -
> -void
> -ofputil_port_map_put(struct ofputil_port_map *map,
> - ofp_port_t ofp_port, const char *name)
> -{
> - ofputil_name_map_put(&map->map, ofp_to_u16(ofp_port), name);
> -}
> -
> -const char *
> -ofputil_port_map_get_name(const struct ofputil_port_map *map,
> - ofp_port_t ofp_port)
> -{
> - struct ofputil_name_map_node *node
> - = (map
> - ? ofputil_name_map_find_by_number(&map->map,
> ofp_to_u16(ofp_port))
> - : NULL);
> - return node && !node->duplicate ? node->name : NULL;
> -}
> -
> -ofp_port_t
> -ofputil_port_map_get_number(const struct ofputil_port_map *map,
> - const char *name)
> -{
> - struct ofputil_name_map_node *node
> - = map ? ofputil_name_map_find_by_name(&map->map, name) : NULL;
> - return node && !node->duplicate ? u16_to_ofp(node->number) :
> OFPP_NONE;
> -}
> -
> -void
> -ofputil_port_map_destroy(struct ofputil_port_map *map)
> -{
> - ofputil_name_map_destroy(&map->map);
> -}
> -
> -
> -/* ofputil_table_map. */
> -
> -void
> -ofputil_table_map_init(struct ofputil_table_map *map)
> -{
> - ofputil_name_map_init(&map->map);
> -}
> -
> -void
> -ofputil_table_map_put(struct ofputil_table_map *map,
> - uint8_t table_id, const char *name)
> -{
> - ofputil_name_map_put(&map->map, table_id, name);
> -}
> -
> -const char *
> -ofputil_table_map_get_name(const struct ofputil_table_map *map,
> - uint8_t table_id)
> -{
> - struct ofputil_name_map_node *node
> - = map ? ofputil_name_map_find_by_number(&map->map, table_id) :
> NULL;
> - return node && !node->duplicate ? node->name : NULL;
> -}
> -
> -uint8_t
> -ofputil_table_map_get_number(const struct ofputil_table_map *map,
> - const char *name)
> -{
> - struct ofputil_name_map_node *node
> - = map ? ofputil_name_map_find_by_name(&map->map, name) : NULL;
> - return node && !node->duplicate ? node->number : UINT8_MAX;
> -}
> -
> -void
> -ofputil_table_map_destroy(struct ofputil_table_map *map)
> -{
> - ofputil_name_map_destroy(&map->map);
> -}
> -
> -/* Table numbers. */
> -
> -/* Stores the table number represented by 's' into '*tablep'. 's' may be
> an
> - * integer or, if 'table_map' is nonnull, a name (quoted or unquoted).
> - *
> - * Returns true if successful, false if 's' is not a valid OpenFlow table
> - * number or name. The caller should issue an error message in this case,
> - * because this function usually does not. (This gives the caller an
> - * opportunity to look up the table name another way, e.g. by contacting
> the
> - * switch and listing the names of all its tables). */
> -bool
> -ofputil_table_from_string(const char *s,
> - const struct ofputil_table_map *table_map,
> - uint8_t *tablep)
> -{
> - *tablep = 0;
> - if (*s == '-') {
> - VLOG_WARN("Negative value %s is not a valid table number.", s);
> - return false;
> - }
> -
> - unsigned int table;
> - if (str_to_uint(s, 10, &table)) {
> - if (table > 255) {
> - VLOG_WARN("table %u is outside the supported range 0 through
> 255",
> - table);
> - return false;
> - }
> - *tablep = table;
> - return true;
> - } else {
> - if (s[0] != '"') {
> - table = ofputil_table_map_get_number(table_map, s);
> - } else {
> - size_t length = strlen(s);
> - char *name = NULL;
> - if (length > 1
> - && s[length - 1] == '"'
> - && json_string_unescape(s + 1, length - 2, &name)) {
> - table = ofputil_table_map_get_number(table_map, name);
> - }
> - free(name);
> - }
> - if (table != UINT8_MAX) {
> - *tablep = table;
> - return true;
> - }
> -
> - return false;
> - }
> -}
> -
> -/* Appends to 's' a string representation of the OpenFlow table number
> 'table',
> - * either the table number or a name drawn from 'table_map'. */
> -void
> -ofputil_format_table(uint8_t table, const struct ofputil_table_map
> *table_map,
> - struct ds *s)
> -{
> - const char *table_name = ofputil_table_map_get_name(table_map,
> table);
> - if (table_name) {
> - put_name(table_name, s);
> - } else {
> - ds_put_format(s, "%"PRIu8, table);
> - }
> -}
> -
> -/* Puts in the 'bufsize' byte in 'namebuf' a null-terminated string
> - * representation of OpenFlow table number 'table', either the table's
> number
> - * or a name drawn from 'table_map'. */
> -void
> -ofputil_table_to_string(uint8_t table,
> - const struct ofputil_table_map *table_map,
> - char *namebuf, size_t bufsize)
> -{
> - const char *table_name = ofputil_table_map_get_name(table_map,
> table);
> - if (table_name) {
> - struct ds s = DS_EMPTY_INITIALIZER;
> - put_name(table_name, &s);
> - ovs_strlcpy(namebuf, ds_cstr(&s), bufsize);
> - ds_destroy(&s);
> - return;
> - }
> -
> - snprintf(namebuf, bufsize, "%"PRIu8, table);
> -}
> -
> -/* 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;
> - }
> -}
> -
> -/* Given a buffer 'b' that contains an array of OpenFlow ports of type
> - * 'ofp_version', tries to pull the first element from the array. If
> - * successful, initializes '*pp' with an abstract representation of the
> - * port and returns 0. If no ports remain to be decoded, returns EOF.
> - * On an error, returns a positive OFPERR_* value. */
> -int
> -ofputil_pull_phy_port(enum ofp_version ofp_version, struct ofpbuf *b,
> - struct ofputil_phy_port *pp)
> -{
> - memset(pp, 0, sizeof *pp);
> -
> - switch (ofp_version) {
> - case OFP10_VERSION: {
> - const struct ofp10_phy_port *opp = ofpbuf_try_pull(b, sizeof
> *opp);
> - return opp ? ofputil_decode_ofp10_phy_port(pp, opp) : EOF;
> - }
> - case OFP11_VERSION:
> - case OFP12_VERSION:
> - case OFP13_VERSION: {
> - const struct ofp11_port *op = ofpbuf_try_pull(b, sizeof *op);
> - return op ? ofputil_decode_ofp11_port(pp, op) : EOF;
> - }
> - case OFP14_VERSION:
> - case OFP15_VERSION:
> - return b->size ? ofputil_pull_ofp14_port(pp, b) : EOF;
> - case OFP16_VERSION:
> - return b->size ? ofputil_pull_ofp16_port(pp, b) : EOF;
> - default:
> - OVS_NOT_REACHED();
> - }
> -}
> -
> -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(&bad_ofmsg_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);
> -}
> -
> -static size_t
> -parse_value(const char *s, const char *delimiters)
> -{
> - size_t n = 0;
> -
> - /* Iterate until we reach a delimiter.
> - *
> - * strchr(s, '\0') returns s+strlen(s), so this test handles the null
> - * terminator at the end of 's'. */
> - while (!strchr(delimiters, s[n])) {
> - if (s[n] == '(') {
> - int level = 0;
> - do {
> - switch (s[n]) {
> - case '\0':
> - return n;
> - case '(':
> - level++;
> - break;
> - case ')':
> - level--;
> - break;
> - }
> - n++;
> - } while (level > 0);
> - } else {
> - n++;
> - }
> - }
> - return n;
> -}
> -
> -/* Parses a key or a key-value pair from '*stringp'.
> - *
> - * On success: Stores the key into '*keyp'. Stores the value, if
> present, into
> - * '*valuep', otherwise an empty string. Advances '*stringp' past the
> end of
> - * the key-value pair, preparing it for another call. '*keyp' and
> '*valuep'
> - * are substrings of '*stringp' created by replacing some of its bytes by
> null
> - * terminators. Returns true.
> - *
> - * If '*stringp' is just white space or commas, sets '*keyp' and
> '*valuep' to
> - * NULL and returns false. */
> -bool
> -ofputil_parse_key_value(char **stringp, char **keyp, char **valuep)
> -{
> - /* Skip white space and delimiters. If that brings us to the end of
> the
> - * input string, we are done and there are no more key-value pairs. */
> - *stringp += strspn(*stringp, ", \t\r\n");
> - if (**stringp == '\0') {
> - *keyp = *valuep = NULL;
> - return false;
> - }
> -
> - /* Extract the key and the delimiter that ends the key-value pair or
> begins
> - * the value. Advance the input position past the key and delimiter.
> */
> - char *key = *stringp;
> - size_t key_len = strcspn(key, ":=(, \t\r\n");
> - char key_delim = key[key_len];
> - key[key_len] = '\0';
> - *stringp += key_len + (key_delim != '\0');
> -
> - /* Figure out what delimiter ends the value:
> - *
> - * - If key_delim is ":" or "=", the value extends until white
> space
> - * or a comma.
> - *
> - * - If key_delim is "(", the value extends until ")".
> - *
> - * If there is no value, we are done. */
> - const char *value_delims;
> - if (key_delim == ':' || key_delim == '=') {
> - value_delims = ", \t\r\n";
> - } else if (key_delim == '(') {
> - value_delims = ")";
> - } else {
> - *keyp = key;
> - *valuep = key + key_len; /* Empty string. */
> - return true;
> - }
> -
> - /* Extract the value. Advance the input position past the value and
> - * delimiter. */
> - char *value = *stringp;
> - size_t value_len = parse_value(value, value_delims);
> - char value_delim = value[value_len];
> - value[value_len] = '\0';
> - *stringp += value_len + (value_delim != '\0');
> -
> - *keyp = key;
> - *valuep = value;
> - return true;
> -}
> -
> -/* Encode a dump ports request for 'port', the encoded message
> - * will be for OpenFlow version 'ofp_version'. Returns message
> - * as a struct ofpbuf. Returns encoded message on success, NULL on error
> */
> -struct ofpbuf *
> -ofputil_encode_dump_ports_request(enum ofp_version ofp_version,
> ofp_port_t port)
> -{
> - struct ofpbuf *request;
> -
> - switch (ofp_version) {
> - case OFP10_VERSION: {
> - struct ofp10_port_stats_request *req;
> - request = ofpraw_alloc(OFPRAW_OFPST10_PORT_REQUEST, ofp_version,
> 0);
> - req = ofpbuf_put_zeros(request, sizeof *req);
> - req->port_no = htons(ofp_to_u16(port));
> - break;
> - }
> - case OFP11_VERSION:
> - case OFP12_VERSION:
> - case OFP13_VERSION:
> - case OFP14_VERSION:
> - case OFP15_VERSION:
> - case OFP16_VERSION: {
> - struct ofp11_port_stats_request *req;
> - request = ofpraw_alloc(OFPRAW_OFPST11_PORT_REQUEST, ofp_version,
> 0);
> - req = ofpbuf_put_zeros(request, sizeof *req);
> - req->port_no = ofputil_port_to_ofp11(port);
> - break;
> - }
> - default:
> - OVS_NOT_REACHED();
> - }
> -
> - return request;
> -}
> -
> -static void
> -ofputil_port_stats_to_ofp10(const struct ofputil_port_stats *ops,
> - struct ofp10_port_stats *ps10)
> -{
> - ps10->port_no = htons(ofp_to_u16(ops->port_no));
> - memset(ps10->pad, 0, sizeof ps10->pad);
> - put_32aligned_be64(&ps10->rx_packets, htonll(ops->stats.rx_packets));
> - put_32aligned_be64(&ps10->tx_packets, htonll(ops->stats.tx_packets));
> - put_32aligned_be64(&ps10->rx_bytes, htonll(ops->stats.rx_bytes));
> - put_32aligned_be64(&ps10->tx_bytes, htonll(ops->stats.tx_bytes));
> - put_32aligned_be64(&ps10->rx_dropped, htonll(ops->stats.rx_dropped));
> - put_32aligned_be64(&ps10->tx_dropped, htonll(ops->stats.tx_dropped));
> - put_32aligned_be64(&ps10->rx_errors, htonll(ops->stats.rx_errors));
> - put_32aligned_be64(&ps10->tx_errors, htonll(ops->stats.tx_errors));
> - put_32aligned_be64(&ps10->rx_frame_err, htonll(ops->stats.rx_frame_
> errors));
> - put_32aligned_be64(&ps10->rx_over_err, htonll(ops->stats.rx_over_
> errors));
> - put_32aligned_be64(&ps10->rx_crc_err, htonll(ops->stats.rx_crc_
> errors));
> - put_32aligned_be64(&ps10->collisions, htonll(ops->stats.collisions));
> -}
> -
> -static void
> -ofputil_port_stats_to_ofp11(const struct ofputil_port_stats *ops,
> - struct ofp11_port_stats *ps11)
> -{
> - ps11->port_no = ofputil_port_to_ofp11(ops->port_no);
> - memset(ps11->pad, 0, sizeof ps11->pad);
> - ps11->rx_packets = htonll(ops->stats.rx_packets);
> - ps11->tx_packets = htonll(ops->stats.tx_packets);
> - ps11->rx_bytes = htonll(ops->stats.rx_bytes);
> - ps11->tx_bytes = htonll(ops->stats.tx_bytes);
> - ps11->rx_dropped = htonll(ops->stats.rx_dropped);
> - ps11->tx_dropped = htonll(ops->stats.tx_dropped);
> - ps11->rx_errors = htonll(ops->stats.rx_errors);
> - ps11->tx_errors = htonll(ops->stats.tx_errors);
> - ps11->rx_frame_err = htonll(ops->stats.rx_frame_errors);
> - ps11->rx_over_err = htonll(ops->stats.rx_over_errors);
> - ps11->rx_crc_err = htonll(ops->stats.rx_crc_errors);
> - ps11->collisions = htonll(ops->stats.collisions);
> -}
> -
> -static void
> -ofputil_port_stats_to_ofp13(const struct ofputil_port_stats *ops,
> - struct ofp13_port_stats *ps13)
> -{
> - ofputil_port_stats_to_ofp11(ops, &ps13->ps);
> - ps13->duration_sec = htonl(ops->duration_sec);
> - ps13->duration_nsec = htonl(ops->duration_nsec);
> -}
> -
> -static void
> -ofputil_append_ofp14_port_stats(const struct ofputil_port_stats *ops,
> - struct ovs_list *replies)
> -{
> - struct ofp14_port_stats_prop_ethernet *eth;
> - struct intel_port_stats_rfc2819 *stats_rfc2819;
> - struct intel_port_custom_stats *stats_custom;
> - struct ofp14_port_stats *ps14;
> - struct ofpbuf *reply;
> - uint16_t i;
> - ovs_be64 counter_value;
> - size_t custom_stats_start, start_ofs;
> -
> - reply = ofpbuf_from_list(ovs_list_back(replies));
> - start_ofs = reply->size;
> -
> - ps14 = ofpbuf_put_uninit(reply, sizeof *ps14);
> -
> - memset(ps14->pad, 0, sizeof ps14->pad);
> - ps14->port_no = ofputil_port_to_ofp11(ops->port_no);
> - ps14->duration_sec = htonl(ops->duration_sec);
> - ps14->duration_nsec = htonl(ops->duration_nsec);
> - ps14->rx_packets = htonll(ops->stats.rx_packets);
> - ps14->tx_packets = htonll(ops->stats.tx_packets);
> - ps14->rx_bytes = htonll(ops->stats.rx_bytes);
> - ps14->tx_bytes = htonll(ops->stats.tx_bytes);
> - ps14->rx_dropped = htonll(ops->stats.rx_dropped);
> - ps14->tx_dropped = htonll(ops->stats.tx_dropped);
> - ps14->rx_errors = htonll(ops->stats.rx_errors);
> - ps14->tx_errors = htonll(ops->stats.tx_errors);
> -
> - eth = ofpprop_put_zeros(reply, OFPPSPT14_ETHERNET, sizeof *eth);
> - eth->rx_frame_err = htonll(ops->stats.rx_frame_errors);
> - eth->rx_over_err = htonll(ops->stats.rx_over_errors);
> - eth->rx_crc_err = htonll(ops->stats.rx_crc_errors);
> - eth->collisions = htonll(ops->stats.collisions);
> -
> - uint64_t prop_type_stats = OFPPROP_EXP(INTEL_VENDOR_ID,
> - INTEL_PORT_STATS_RFC2819);
> -
> - stats_rfc2819 = ofpprop_put_zeros(reply, prop_type_stats,
> - sizeof *stats_rfc2819);
> -
> - memset(stats_rfc2819->pad, 0, sizeof stats_rfc2819->pad);
> - stats_rfc2819->rx_1_to_64_packets = htonll(ops->stats.rx_1_to_64_
> packets);
> - stats_rfc2819->rx_65_to_127_packets =
> - htonll(ops->stats.rx_65_to_127_packets);
> - stats_rfc2819->rx_128_to_255_packets =
> - htonll(ops->stats.rx_128_to_255_packets);
> - stats_rfc2819->rx_256_to_511_packets =
> - htonll(ops->stats.rx_256_to_511_packets);
> - stats_rfc2819->rx_512_to_1023_packets =
> - htonll(ops->stats.rx_512_to_1023_packets);
> - stats_rfc2819->rx_1024_to_1522_packets =
> - htonll(ops->stats.rx_1024_to_1522_packets);
> - stats_rfc2819->rx_1523_to_max_packets =
> - htonll(ops->stats.rx_1523_to_max_packets);
> -
> - stats_rfc2819->tx_1_to_64_packets = htonll(ops->stats.tx_1_to_64_
> packets);
> - stats_rfc2819->tx_65_to_127_packets =
> - htonll(ops->stats.tx_65_to_127_packets);
> - stats_rfc2819->tx_128_to_255_packets =
> - htonll(ops->stats.tx_128_to_255_packets);
> - stats_rfc2819->tx_256_to_511_packets =
> - htonll(ops->stats.tx_256_to_511_packets);
> - stats_rfc2819->tx_512_to_1023_packets =
> - htonll(ops->stats.tx_512_to_1023_packets);
> - stats_rfc2819->tx_1024_to_1522_packets =
> - htonll(ops->stats.tx_1024_to_1522_packets);
> - stats_rfc2819->tx_1523_to_max_packets =
> - htonll(ops->stats.tx_1523_to_max_packets);
> -
> - stats_rfc2819->tx_multicast_packets =
> - htonll(ops->stats.tx_multicast_packets);
> - stats_rfc2819->rx_broadcast_packets =
> - htonll(ops->stats.rx_broadcast_packets);
> - stats_rfc2819->tx_broadcast_packets =
> - htonll(ops->stats.tx_broadcast_packets);
> - stats_rfc2819->rx_undersized_errors =
> - htonll(ops->stats.rx_undersized_errors);
> - stats_rfc2819->rx_oversize_errors =
> - htonll(ops->stats.rx_oversize_errors);
> - stats_rfc2819->rx_fragmented_errors =
> - htonll(ops->stats.rx_fragmented_errors);
> - stats_rfc2819->rx_jabber_errors =
> - htonll(ops->stats.rx_jabber_errors);
> -
> - if (ops->custom_stats.counters && ops->custom_stats.size) {
> - custom_stats_start = reply->size;
> -
> - uint64_t prop_type_custom = OFPPROP_EXP(INTEL_VENDOR_ID,
> - INTEL_PORT_STATS_CUSTOM);
> -
> - stats_custom = ofpprop_put_zeros(reply, prop_type_custom,
> - sizeof *stats_custom);
> -
> - stats_custom->stats_array_size = htons(ops->custom_stats.size);
> -
> - for (i = 0; i < ops->custom_stats.size; i++) {
> - uint8_t counter_size = strlen(ops->custom_stats.
> counters[i].name);
> - /* Counter name size */
> - ofpbuf_put(reply, &counter_size, sizeof(counter_size));
> - /* Counter name */
> - ofpbuf_put(reply, ops->custom_stats.counters[i].name,
> - counter_size);
> - /* Counter value */
> - counter_value = htonll(ops->custom_stats.counters[i].value);
> - ofpbuf_put(reply, &counter_value,
> - sizeof(ops->custom_stats.counters[i].value));
> - }
> -
> - ofpprop_end(reply, custom_stats_start);
> - }
> -
> - ps14 = ofpbuf_at_assert(reply, start_ofs, sizeof *ps14);
> - ps14->length = htons(reply->size - start_ofs);
> -
> - ofpmp_postappend(replies, start_ofs);
> -}
> -
> -/* Encode a ports stat for 'ops' and append it to 'replies'. */
> -void
> -ofputil_append_port_stat(struct ovs_list *replies,
> - const struct ofputil_port_stats *ops)
> -{
> - switch (ofpmp_version(replies)) {
> - case OFP13_VERSION: {
> - struct ofp13_port_stats *reply = ofpmp_append(replies, sizeof
> *reply);
> - ofputil_port_stats_to_ofp13(ops, reply);
> - break;
> - }
> - case OFP12_VERSION:
> - case OFP11_VERSION: {
> - struct ofp11_port_stats *reply = ofpmp_append(replies, sizeof
> *reply);
> - ofputil_port_stats_to_ofp11(ops, reply);
> - break;
> - }
> -
> - case OFP10_VERSION: {
> - struct ofp10_port_stats *reply = ofpmp_append(replies, sizeof
> *reply);
> - ofputil_port_stats_to_ofp10(ops, reply);
> - break;
> - }
> -
> - case OFP14_VERSION:
> - case OFP15_VERSION:
> - case OFP16_VERSION:
> - ofputil_append_ofp14_port_stats(ops, replies);
> - break;
> -
> - default:
> - OVS_NOT_REACHED();
> - }
> -}
> -
> -static enum ofperr
> -ofputil_port_stats_from_ofp10(struct ofputil_port_stats *ops,
> - const struct ofp10_port_stats *ps10)
> -{
> -
> - ops->port_no = u16_to_ofp(ntohs(ps10->port_no));
> - ops->stats.rx_packets = ntohll(get_32aligned_be64(&
> ps10->rx_packets));
> - ops->stats.tx_packets = ntohll(get_32aligned_be64(&
> ps10->tx_packets));
> - ops->stats.rx_bytes = ntohll(get_32aligned_be64(&ps10->rx_bytes));
> - ops->stats.tx_bytes = ntohll(get_32aligned_be64(&ps10->tx_bytes));
> - ops->stats.rx_dropped = ntohll(get_32aligned_be64(&
> ps10->rx_dropped));
> - ops->stats.tx_dropped = ntohll(get_32aligned_be64(&
> ps10->tx_dropped));
> - ops->stats.rx_errors = ntohll(get_32aligned_be64(&ps10->rx_errors));
> - ops->stats.tx_errors = ntohll(get_32aligned_be64(&ps10->tx_errors));
> - ops->stats.rx_frame_errors =
> - ntohll(get_32aligned_be64(&ps10->rx_frame_err));
> - ops->stats.rx_over_errors = ntohll(get_32aligned_be64(&
> ps10->rx_over_err));
> - ops->stats.rx_crc_errors = ntohll(get_32aligned_be64(&
> ps10->rx_crc_err));
> - ops->stats.collisions = ntohll(get_32aligned_be64(&
> ps10->collisions));
> - ops->duration_sec = ops->duration_nsec = UINT32_MAX;
> -
> - return 0;
> -}
> -
> -static enum ofperr
> -ofputil_port_stats_from_ofp11(struct ofputil_port_stats *ops,
> - const struct ofp11_port_stats *ps11)
> -{
> - enum ofperr error;
> -
> - error = ofputil_port_from_ofp11(ps11->port_no, &ops->port_no);
> - if (error) {
> - return error;
> - }
> -
> - ops->stats.rx_packets = ntohll(ps11->rx_packets);
> - ops->stats.tx_packets = ntohll(ps11->tx_packets);
> - ops->stats.rx_bytes = ntohll(ps11->rx_bytes);
> - ops->stats.tx_bytes = ntohll(ps11->tx_bytes);
> - ops->stats.rx_dropped = ntohll(ps11->rx_dropped);
> - ops->stats.tx_dropped = ntohll(ps11->tx_dropped);
> - ops->stats.rx_errors = ntohll(ps11->rx_errors);
> - ops->stats.tx_errors = ntohll(ps11->tx_errors);
> - ops->stats.rx_frame_errors = ntohll(ps11->rx_frame_err);
> - ops->stats.rx_over_errors = ntohll(ps11->rx_over_err);
> - ops->stats.rx_crc_errors = ntohll(ps11->rx_crc_err);
> - ops->stats.collisions = ntohll(ps11->collisions);
> - ops->duration_sec = ops->duration_nsec = UINT32_MAX;
> -
> - return 0;
> -}
> -
> -static enum ofperr
> -ofputil_port_stats_from_ofp13(struct ofputil_port_stats *ops,
> - const struct ofp13_port_stats *ps13)
> -{
> - enum ofperr error = ofputil_port_stats_from_ofp11(ops, &ps13->ps);
> - if (!error) {
> - ops->duration_sec = ntohl(ps13->duration_sec);
> - ops->duration_nsec = ntohl(ps13->duration_nsec);
> - }
> - return error;
> -}
> -
> -static enum ofperr
> -parse_ofp14_port_stats_ethernet_property(const struct ofpbuf *payload,
> - struct ofputil_port_stats *ops)
> -{
> - const struct ofp14_port_stats_prop_ethernet *eth = payload->data;
> -
> - if (payload->size != sizeof *eth) {
> - return OFPERR_OFPBPC_BAD_LEN;
> - }
> -
> - ops->stats.rx_frame_errors = ntohll(eth->rx_frame_err);
> - ops->stats.rx_over_errors = ntohll(eth->rx_over_err);
> - ops->stats.rx_crc_errors = ntohll(eth->rx_crc_err);
> - ops->stats.collisions = ntohll(eth->collisions);
> -
> - return 0;
> -}
> -
> -static enum ofperr
> -parse_intel_port_stats_rfc2819_property(const struct ofpbuf *payload,
> - struct ofputil_port_stats *ops)
> -{
> - const struct intel_port_stats_rfc2819 *rfc2819 = payload->data;
> -
> - if (payload->size != sizeof *rfc2819) {
> - return OFPERR_OFPBPC_BAD_LEN;
> - }
> - ops->stats.rx_1_to_64_packets = ntohll(rfc2819->rx_1_to_64_packets);
> - ops->stats.rx_65_to_127_packets = ntohll(rfc2819->rx_65_to_127_
> packets);
> - ops->stats.rx_128_to_255_packets = ntohll(rfc2819->rx_128_to_255_
> packets);
> - ops->stats.rx_256_to_511_packets = ntohll(rfc2819->rx_256_to_511_
> packets);
> - ops->stats.rx_512_to_1023_packets =
> - ntohll(rfc2819->rx_512_to_1023_packets);
> - ops->stats.rx_1024_to_1522_packets =
> - ntohll(rfc2819->rx_1024_to_1522_packets);
> - ops->stats.rx_1523_to_max_packets =
> - ntohll(rfc2819->rx_1523_to_max_packets);
> -
> - ops->stats.tx_1_to_64_packets = ntohll(rfc2819->tx_1_to_64_packets);
> - ops->stats.tx_65_to_127_packets = ntohll(rfc2819->tx_65_to_127_
> packets);
> - ops->stats.tx_128_to_255_packets = ntohll(rfc2819->tx_128_to_255_
> packets);
> - ops->stats.tx_256_to_511_packets = ntohll(rfc2819->tx_256_to_511_
> packets);
> - ops->stats.tx_512_to_1023_packets =
> - ntohll(rfc2819->tx_512_to_1023_packets);
> - ops->stats.tx_1024_to_1522_packets =
> - ntohll(rfc2819->tx_1024_to_1522_packets);
> - ops->stats.tx_1523_to_max_packets =
> - ntohll(rfc2819->tx_1523_to_max_packets);
> -
> - ops->stats.tx_multicast_packets = ntohll(rfc2819->tx_multicast_
> packets);
> - ops->stats.rx_broadcast_packets = ntohll(rfc2819->rx_broadcast_
> packets);
> - ops->stats.tx_broadcast_packets = ntohll(rfc2819->tx_broadcast_
> packets);
> - ops->stats.rx_undersized_errors = ntohll(rfc2819->rx_undersized_
> errors);
> -
> - ops->stats.rx_oversize_errors = ntohll(rfc2819->rx_oversize_errors);
> - ops->stats.rx_fragmented_errors = ntohll(rfc2819->rx_fragmented_
> errors);
> - ops->stats.rx_jabber_errors = ntohll(rfc2819->rx_jabber_errors);
> -
> - return 0;
> -}
> -
> -static enum ofperr
> -parse_intel_port_custom_property(const struct ofpbuf *payload,
> - struct ofputil_port_stats *ops)
> -{
> - const struct intel_port_custom_stats *custom_stats = payload->data;
> -
> - ops->custom_stats.size = ntohs(custom_stats->stats_array_size);
> -
> - ops->custom_stats.counters = xcalloc(ops->custom_stats.size,
> - sizeof
> *ops->custom_stats.counters);
> -
> - uint16_t msg_size = ntohs(custom_stats->length);
> - uint16_t current_len = sizeof *custom_stats;
> - uint8_t *current = (uint8_t *)payload->data + current_len;
> - uint8_t string_size = 0;
> - uint8_t value_size = 0;
> - ovs_be64 counter_value = 0;
> -
> - for (int i = 0; i < ops->custom_stats.size; i++) {
> - current_len += string_size + value_size;
> - current += string_size + value_size;
> -
> - value_size = sizeof(uint64_t);
> - /* Counter name size */
> - string_size = *current;
> -
> - /* Buffer overrun check */
> - if (current_len + string_size + value_size > msg_size) {
> - VLOG_WARN_RL(&bad_ofmsg_rl, "Custom statistics buffer
> overrun! "
> - "Further message parsing is aborted.");
> - break;
> - }
> -
> - current++;
> - current_len++;
> -
> - /* Counter name. */
> - struct netdev_custom_counter *c = &ops->custom_stats.counters[i];
> - size_t len = MIN(string_size, sizeof c->name - 1);
> - memcpy(c->name, current, len);
> - c->name[len] = '\0';
> - memcpy(&counter_value, current + string_size, value_size);
> -
> - /* Counter value. */
> - c->value = ntohll(counter_value);
> - }
> -
> - return 0;
> -}
> -
> -static enum ofperr
> -parse_intel_port_stats_property(const struct ofpbuf *payload,
> - uint32_t exp_type,
> - struct ofputil_port_stats *ops)
> -{
> - enum ofperr error;
> -
> - switch (exp_type) {
> - case INTEL_PORT_STATS_RFC2819:
> - error = parse_intel_port_stats_rfc2819_property(payload, ops);
> - break;
> - case INTEL_PORT_STATS_CUSTOM:
> - error = parse_intel_port_custom_property(payload, ops);
> - break;
> - default:
> - error = OFPERR_OFPBPC_BAD_EXP_TYPE;
> - break;
> - }
> -
> - return error;
> -}
> -
> -static enum ofperr
> -ofputil_pull_ofp14_port_stats(struct ofputil_port_stats *ops,
> - struct ofpbuf *msg)
> -{
> - const struct ofp14_port_stats *ps14 = ofpbuf_try_pull(msg, sizeof
> *ps14);
> - if (!ps14) {
> - return OFPERR_OFPBRC_BAD_LEN;
> - }
> -
> - size_t len = ntohs(ps14->length);
> - if (len < sizeof *ps14 || len - sizeof *ps14 > msg->size) {
> - return OFPERR_OFPBRC_BAD_LEN;
> - }
> - len -= sizeof *ps14;
> -
> - enum ofperr error = ofputil_port_from_ofp11(ps14->port_no,
> &ops->port_no);
> - if (error) {
> - return error;
> - }
> -
> - ops->duration_sec = ntohl(ps14->duration_sec);
> - ops->duration_nsec = ntohl(ps14->duration_nsec);
> - ops->stats.rx_packets = ntohll(ps14->rx_packets);
> - ops->stats.tx_packets = ntohll(ps14->tx_packets);
> - ops->stats.rx_bytes = ntohll(ps14->rx_bytes);
> - ops->stats.tx_bytes = ntohll(ps14->tx_bytes);
> - ops->stats.rx_dropped = ntohll(ps14->rx_dropped);
> - ops->stats.tx_dropped = ntohll(ps14->tx_dropped);
> - ops->stats.rx_errors = ntohll(ps14->rx_errors);
> - ops->stats.tx_errors = ntohll(ps14->tx_errors);
> -
> -
> - struct ofpbuf properties = ofpbuf_const_initializer(ofpbuf_pull(msg,
> len),
> - len);
> - while (properties.size > 0) {
> - struct ofpbuf payload;
> - uint64_t type = 0;
> -
> - error = ofpprop_pull(&properties, &payload, &type);
> - if (error) {
> - return error;
> - }
> - switch (type) {
> - case OFPPSPT14_ETHERNET:
> - error = parse_ofp14_port_stats_ethernet_property(&payload,
> ops);
> - break;
> - case OFPPROP_EXP(INTEL_VENDOR_ID, INTEL_PORT_STATS_RFC2819):
> - error = parse_intel_port_stats_property(&payload,
> -
> INTEL_PORT_STATS_RFC2819,
> - ops);
> - break;
> - case OFPPROP_EXP(INTEL_VENDOR_ID, INTEL_PORT_STATS_CUSTOM):
> - error = parse_intel_port_stats_property(&payload,
> -
> INTEL_PORT_STATS_CUSTOM,
> - ops);
> - break;
> - default:
> - error = OFPPROP_UNKNOWN(true, "port stats", type);
> - break;
> - }
> -
> - if (error) {
> - return error;
> - }
> - }
> -
> - return 0;
> -}
> -
> -/* Returns the number of port stats elements in OFPTYPE_PORT_STATS_REPLY
> - * message 'oh'. */
> -size_t
> -ofputil_count_port_stats(const struct ofp_header *oh)
> -{
> - struct ofpbuf b = ofpbuf_const_initializer(oh, ntohs(oh->length));
> - ofpraw_pull_assert(&b);
> -
> - for (size_t n = 0; ; n++) {
> - struct ofputil_port_stats ps;
> - if (ofputil_decode_port_stats(&ps, &b)) {
> - return n;
> - }
> - }
> -}
> -
> -/* Converts an OFPST_PORT_STATS reply in 'msg' into an abstract
> - * ofputil_port_stats in 'ps'.
> - *
> - * Multiple OFPST_PORT_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_port_stats(struct ofputil_port_stats *ps, struct ofpbuf
> *msg)
> -{
> - enum ofperr error;
> - enum ofpraw raw;
> -
> - memset(&(ps->stats), 0xFF, sizeof (ps->stats));
> - memset(&(ps->custom_stats), 0, sizeof (ps->custom_stats));
> -
> - 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_OFPST14_PORT_REPLY) {
> - return ofputil_pull_ofp14_port_stats(ps, msg);
> - } else if (raw == OFPRAW_OFPST13_PORT_REPLY) {
> - const struct ofp13_port_stats *ps13;
> - ps13 = ofpbuf_try_pull(msg, sizeof *ps13);
> - if (!ps13) {
> - goto bad_len;
> - }
> - return ofputil_port_stats_from_ofp13(ps, ps13);
> - } else if (raw == OFPRAW_OFPST11_PORT_REPLY) {
> - const struct ofp11_port_stats *ps11;
> -
> - ps11 = ofpbuf_try_pull(msg, sizeof *ps11);
> - if (!ps11) {
> - goto bad_len;
> - }
> - return ofputil_port_stats_from_ofp11(ps, ps11);
> - } else if (raw == OFPRAW_OFPST10_PORT_REPLY) {
> - const struct ofp10_port_stats *ps10;
> -
> - ps10 = ofpbuf_try_pull(msg, sizeof *ps10);
> - if (!ps10) {
> - goto bad_len;
> - }
> - return ofputil_port_stats_from_ofp10(ps, ps10);
> - } else {
> - OVS_NOT_REACHED();
> - }
> -
> - bad_len:
> - VLOG_WARN_RL(&bad_ofmsg_rl, "OFPST_PORT reply has %"PRIu32" leftover "
> - "bytes at end", msg->size);
> - return OFPERR_OFPBRC_BAD_LEN;
> -}
> -
> -/* Parse a port status request message into a 16 bit OpenFlow 1.0
> - * port number and stores the latter in '*ofp10_port'.
> - * Returns 0 if successful, otherwise an OFPERR_* number. */
> -enum ofperr
> -ofputil_decode_port_stats_request(const struct ofp_header *request,
> - ofp_port_t *ofp10_port)
> -{
> - switch ((enum ofp_version)request->version) {
> - case OFP16_VERSION:
> - case OFP15_VERSION:
> - case OFP14_VERSION:
> - case OFP13_VERSION:
> - case OFP12_VERSION:
> - case OFP11_VERSION: {
> - const struct ofp11_port_stats_request *psr11 =
> ofpmsg_body(request);
> - return ofputil_port_from_ofp11(psr11->port_no, ofp10_port);
> - }
> -
> - case OFP10_VERSION: {
> - const struct ofp10_port_stats_request *psr10 =
> ofpmsg_body(request);
> - *ofp10_port = u16_to_ofp(ntohs(psr10->port_no));
> - return 0;
> - }
> -
> - default:
> - OVS_NOT_REACHED();
> - }
> -}
> -
> -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);
> -}
> -
> -/* 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(&bad_ofmsg_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(&bad_ofmsg_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(&bad_ofmsg_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 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(&bad_ofmsg_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(&bad_ofmsg_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(&bad_ofmsg_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(&bad_ofmsg_rl, "buckets end with %"PRIuSIZE
> - " leftover bytes", buckets_length);
> - goto err;
> - }
> -
> - ob_len = ntohs(ob->len);
> - actions_len = ntohs(ob->action_array_len);
> -
> - if (ob_len < sizeof *ob) {
> - VLOG_WARN_RL(&bad_ofmsg_rl, "OpenFlow message bucket length "
> - "%"PRIuSIZE" is not valid", ob_len);
> - goto err;
> - } else if (ob_len > buckets_length) {
> - VLOG_WARN_RL(&bad_ofmsg_rl, "OpenFlow message bucket length "
> - "%"PRIuSIZE" exceeds remaining buckets data size
> %"
> - PRIuSIZE, ob_len, buckets_length);
> - goto err;
> - } else if (actions_len > ob_len - sizeof *ob) {
> - VLOG_WARN_RL(&bad_ofmsg_rl, "OpenFlow message bucket actions "
> - "length %"PRIuSIZE" exceeds remaining bucket "
> - "data size %"PRIuSIZE, actions_len,
> - ob_len - sizeof *ob);
> - goto err;
> - }
> - buckets_length -= ob_len;
> -
> - err = ofpacts_pull_openflow_actions(msg, actions_len, version,
> - 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(&bad_ofmsg_rl, "bucket id (%u) is out of range",
> - bucket->bucket_id);
> - err = OFPERR_OFPGMFC_BAD_BUCKET;
> - goto err;
> - }
> -
> - bucket->ofpacts = ofpbuf_steal_data(&ofpacts);
> - bucket->ofpacts_len = ofpacts.size;
> - 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(&bad_ofmsg_rl, "Duplicate bucket id");
> - ofputil_bucket_list_destroy(buckets);
> - return OFPERR_OFPGMFC_BAD_BUCKET;
> - }
> -
> - return 0;
> -}
> -
> -static void
> -ofputil_init_group_properties(struct ofputil_group_props *gp)
> -{
> - memset(gp, 0, sizeof *gp);
> -}
> -
> -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(&bad_ofmsg_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(&bad_ofmsg_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(&bad_ofmsg_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(&bad_ofmsg_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(&bad_ofmsg_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(&bad_ofmsg_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(&bad_ofmsg_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(&bad_ofmsg_rl, "OFPST11_GROUP_DESC reply has
> %"PRIu32" "
> - "leftover bytes at end", msg->size);
> - return OFPERR_OFPBRC_BAD_LEN;
> - }
> - gd->type = ogds->type;
> - gd->group_id = ntohl(ogds->group_id);
> -
> - length = ntohs(ogds->length);
> - if (length < sizeof *ogds || length - sizeof *ogds > msg->size) {
> - VLOG_WARN_RL(&bad_ofmsg_rl, "OFPST11_GROUP_DESC reply claims
> invalid "
> - "length %"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(&bad_ofmsg_rl, "OFPST11_GROUP_DESC reply has
> %"PRIu32" "
> - "leftover bytes at end", msg->size);
> - return OFPERR_OFPBRC_BAD_LEN;
> - }
> - gd->type = ogds->type;
> - gd->group_id = ntohl(ogds->group_id);
> -
> - length = ntohs(ogds->length);
> - if (length < sizeof *ogds || length - sizeof *ogds > msg->size) {
> - VLOG_WARN_RL(&bad_ofmsg_rl, "OFPST11_GROUP_DESC reply claims
> invalid "
> - "length %u", length);
> - return OFPERR_OFPBRC_BAD_LEN;
> - }
> -
> - bucket_list_len = ntohs(ogds->bucket_list_len);
> - if (length < bucket_list_len + sizeof *ogds) {
> - VLOG_WARN_RL(&bad_ofmsg_rl, "OFPST11_GROUP_DESC reply claims
> invalid "
> - "bucket list length %u", bucket_list_len);
> - return OFPERR_OFPBRC_BAD_LEN;
> - }
> - error = ofputil_pull_ofp15_buckets(msg, bucket_list_len, version,
> gd->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(&bad_ofmsg_rl,
> - "group command bucket id (%u) is out of range",
> - gm->command_bucket_id);
> - return OFPERR_OFPGMFC_BAD_BUCKET;
> - }
> -
> - bucket_list_len = ntohs(ogm->bucket_array_len);
> - 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;
> -}
> -
> -/* 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);
> - }
> - }
> -}
> -
> -/* Parse a queue status request message into 'oqsr'.
> - * Returns 0 if successful, otherwise an OFPERR_* number. */
> -enum ofperr
> -ofputil_decode_queue_stats_request(const struct ofp_header *request,
> - struct ofputil_queue_stats_request
> *oqsr)
> -{
> - switch ((enum ofp_version)request->version) {
> - case OFP16_VERSION:
> - case OFP15_VERSION:
> - case OFP14_VERSION:
> - case OFP13_VERSION:
> - case OFP12_VERSION:
> - case OFP11_VERSION: {
> - const struct ofp11_queue_stats_request *qsr11 =
> ofpmsg_body(request);
> - oqsr->queue_id = ntohl(qsr11->queue_id);
> - return ofputil_port_from_ofp11(qsr11->port_no, &oqsr->port_no);
> - }
> -
> - case OFP10_VERSION: {
> - const struct ofp10_queue_stats_request *qsr10 =
> ofpmsg_body(request);
> - oqsr->queue_id = ntohl(qsr10->queue_id);
> - oqsr->port_no = u16_to_ofp(ntohs(qsr10->port_no));
> - /* OF 1.0 uses OFPP_ALL for OFPP_ANY */
> - if (oqsr->port_no == OFPP_ALL) {
> - oqsr->port_no = OFPP_ANY;
> - }
> - return 0;
> - }
> -
> - default:
> - OVS_NOT_REACHED();
> - }
> -}
> -
> -/* Encode a queue stats request for 'oqsr', the encoded message
> - * will be for OpenFlow version 'ofp_version'. Returns message
> - * as a struct ofpbuf. Returns encoded message on success, NULL on error.
> */
> -struct ofpbuf *
> -ofputil_encode_queue_stats_request(enum ofp_version ofp_version,
> - const struct
> ofputil_queue_stats_request *oqsr)
> -{
> - struct ofpbuf *request;
> -
> - switch (ofp_version) {
> - case OFP11_VERSION:
> - case OFP12_VERSION:
> - case OFP13_VERSION:
> - case OFP14_VERSION:
> - case OFP15_VERSION:
> - case OFP16_VERSION: {
> - struct ofp11_queue_stats_request *req;
> - request = ofpraw_alloc(OFPRAW_OFPST11_QUEUE_REQUEST,
> ofp_version, 0);
> - req = ofpbuf_put_zeros(request, sizeof *req);
> - req->port_no = ofputil_port_to_ofp11(oqsr->port_no);
> - req->queue_id = htonl(oqsr->queue_id);
> - break;
> - }
> - case OFP10_VERSION: {
> - struct ofp10_queue_stats_request *req;
> - request = ofpraw_alloc(OFPRAW_OFPST10_QUEUE_REQUEST,
> ofp_version, 0);
> - req = ofpbuf_put_zeros(request, sizeof *req);
> - /* OpenFlow 1.0 needs OFPP_ALL instead of OFPP_ANY */
> - req->port_no = htons(ofp_to_u16(oqsr->port_no == OFPP_ANY
> - ? OFPP_ALL : oqsr->port_no));
> - req->queue_id = htonl(oqsr->queue_id);
> - break;
> - }
> - default:
> - OVS_NOT_REACHED();
> - }
> -
> - return request;
> -}
> -
> -/* Returns the number of queue stats elements in OFPTYPE_QUEUE_STATS_REPLY
> - * message 'oh'. */
> -size_t
> -ofputil_count_queue_stats(const struct ofp_header *oh)
> -{
> - struct ofpbuf b = ofpbuf_const_initializer(oh, ntohs(oh->length));
> - ofpraw_pull_assert(&b);
> -
> - for (size_t n = 0; ; n++) {
> - struct ofputil_queue_stats qs;
> - if (ofputil_decode_queue_stats(&qs, &b)) {
> - return n;
> - }
> - }
> -}
> -
> -static enum ofperr
> -ofputil_queue_stats_from_ofp10(struct ofputil_queue_stats *oqs,
> - const struct ofp10_queue_stats *qs10)
> -{
> - oqs->port_no = u16_to_ofp(ntohs(qs10->port_no));
> - oqs->queue_id = ntohl(qs10->queue_id);
> - oqs->tx_bytes = ntohll(get_32aligned_be64(&qs10->tx_bytes));
> - oqs->tx_packets = ntohll(get_32aligned_be64(&qs10->tx_packets));
> - oqs->tx_errors = ntohll(get_32aligned_be64(&qs10->tx_errors));
> - oqs->duration_sec = oqs->duration_nsec = UINT32_MAX;
> -
> - return 0;
> -}
> -
> -static enum ofperr
> -ofputil_queue_stats_from_ofp11(struct ofputil_queue_stats *oqs,
> - const struct ofp11_queue_stats *qs11)
> -{
> - enum ofperr error;
> -
> - error = ofputil_port_from_ofp11(qs11->port_no, &oqs->port_no);
> - if (error) {
> - return error;
> - }
> -
> - oqs->queue_id = ntohl(qs11->queue_id);
> - oqs->tx_bytes = ntohll(qs11->tx_bytes);
> - oqs->tx_packets = ntohll(qs11->tx_packets);
> - oqs->tx_errors = ntohll(qs11->tx_errors);
> - oqs->duration_sec = oqs->duration_nsec = UINT32_MAX;
> -
> - return 0;
> -}
> -
> -static enum ofperr
> -ofputil_queue_stats_from_ofp13(struct ofputil_queue_stats *oqs,
> - const struct ofp13_queue_stats *qs13)
> -{
> - enum ofperr error = ofputil_queue_stats_from_ofp11(oqs, &qs13->qs);
> - if (!error) {
> - oqs->duration_sec = ntohl(qs13->duration_sec);
> - oqs->duration_nsec = ntohl(qs13->duration_nsec);
> - }
> -
> - return error;
> -}
> -
> -static enum ofperr
> -ofputil_pull_ofp14_queue_stats(struct ofputil_queue_stats *oqs,
> - struct ofpbuf *msg)
> -{
> - const struct ofp14_queue_stats *qs14;
> - size_t len;
> -
> - qs14 = ofpbuf_try_pull(msg, sizeof *qs14);
> - if (!qs14) {
> - return OFPERR_OFPBRC_BAD_LEN;
> - }
> -
> - len = ntohs(qs14->length);
> - if (len < sizeof *qs14 || len - sizeof *qs14 > msg->size) {
> - return OFPERR_OFPBRC_BAD_LEN;
> - }
> - ofpbuf_pull(msg, len - sizeof *qs14);
> -
> - /* No properties yet defined, so ignore them for now. */
> -
> - return ofputil_queue_stats_from_ofp13(oqs, &qs14->qs);
> -}
> -
> -/* Converts an OFPST_QUEUE_STATS reply in 'msg' into an abstract
> - * ofputil_queue_stats in 'qs'.
> - *
> - * Multiple OFPST_QUEUE_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_queue_stats(struct ofputil_queue_stats *qs, struct ofpbuf
> *msg)
> -{
> - enum ofperr error;
> - enum ofpraw raw;
> -
> - 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_OFPST14_QUEUE_REPLY) {
> - return ofputil_pull_ofp14_queue_stats(qs, msg);
> - } else if (raw == OFPRAW_OFPST13_QUEUE_REPLY) {
> - const struct ofp13_queue_stats *qs13;
> -
> - qs13 = ofpbuf_try_pull(msg, sizeof *qs13);
> - if (!qs13) {
> - goto bad_len;
> - }
> - return ofputil_queue_stats_from_ofp13(qs, qs13);
> - } else if (raw == OFPRAW_OFPST11_QUEUE_REPLY) {
> - const struct ofp11_queue_stats *qs11;
> -
> - qs11 = ofpbuf_try_pull(msg, sizeof *qs11);
> - if (!qs11) {
> - goto bad_len;
> - }
> - return ofputil_queue_stats_from_ofp11(qs, qs11);
> - } else if (raw == OFPRAW_OFPST10_QUEUE_REPLY) {
> - const struct ofp10_queue_stats *qs10;
> -
> - qs10 = ofpbuf_try_pull(msg, sizeof *qs10);
> - if (!qs10) {
> - goto bad_len;
> - }
> - return ofputil_queue_stats_from_ofp10(qs, qs10);
> - } else {
> - OVS_NOT_REACHED();
> - }
> -
> - bad_len:
> - VLOG_WARN_RL(&bad_ofmsg_rl, "OFPST_QUEUE reply has %"PRIu32" leftover
> "
> - "bytes at end", msg->size);
> - return OFPERR_OFPBRC_BAD_LEN;
> -}
> -
> -static void
> -ofputil_queue_stats_to_ofp10(const struct ofputil_queue_stats *oqs,
> - struct ofp10_queue_stats *qs10)
> -{
> - qs10->port_no = htons(ofp_to_u16(oqs->port_no));
> - memset(qs10->pad, 0, sizeof qs10->pad);
> - qs10->queue_id = htonl(oqs->queue_id);
> - put_32aligned_be64(&qs10->tx_bytes, htonll(oqs->tx_bytes));
> - put_32aligned_be64(&qs10->tx_packets, htonll(oqs->tx_packets));
> - put_32aligned_be64(&qs10->tx_errors, htonll(oqs->tx_errors));
> -}
> -
> -static void
> -ofputil_queue_stats_to_ofp11(const struct ofputil_queue_stats *oqs,
> - struct ofp11_queue_stats *qs11)
> -{
> - qs11->port_no = ofputil_port_to_ofp11(oqs->port_no);
> - qs11->queue_id = htonl(oqs->queue_id);
> - qs11->tx_bytes = htonll(oqs->tx_bytes);
> - qs11->tx_packets = htonll(oqs->tx_packets);
> - qs11->tx_errors = htonll(oqs->tx_errors);
> -}
> -
> -static void
> -ofputil_queue_stats_to_ofp13(const struct ofputil_queue_stats *oqs,
> - struct ofp13_queue_stats *qs13)
> -{
> - ofputil_queue_stats_to_ofp11(oqs, &qs13->qs);
> - if (oqs->duration_sec != UINT32_MAX) {
> - qs13->duration_sec = htonl(oqs->duration_sec);
> - qs13->duration_nsec = htonl(oqs->duration_nsec);
> - } else {
> - qs13->duration_sec = OVS_BE32_MAX;
> - qs13->duration_nsec = OVS_BE32_MAX;
> - }
> -}
> -
> -static void
> -ofputil_queue_stats_to_ofp14(const struct ofputil_queue_stats *oqs,
> - struct ofp14_queue_stats *qs14)
> -{
> - qs14->length = htons(sizeof *qs14);
> - memset(qs14->pad, 0, sizeof qs14->pad);
> - ofputil_queue_stats_to_ofp13(oqs, &qs14->qs);
> -}
> -
> -
> -/* Encode a queue stat for 'oqs' and append it to 'replies'. */
> -void
> -ofputil_append_queue_stat(struct ovs_list *replies,
> - const struct ofputil_queue_stats *oqs)
> -{
> - switch (ofpmp_version(replies)) {
> - case OFP13_VERSION: {
> - struct ofp13_queue_stats *reply = ofpmp_append(replies, sizeof
> *reply);
> - ofputil_queue_stats_to_ofp13(oqs, reply);
> - break;
> - }
> -
> - case OFP12_VERSION:
> - case OFP11_VERSION: {
> - struct ofp11_queue_stats *reply = ofpmp_append(replies, sizeof
> *reply);
> - ofputil_queue_stats_to_ofp11(oqs, reply);
> - break;
> - }
> -
> - case OFP10_VERSION: {
> - struct ofp10_queue_stats *reply = ofpmp_append(replies, sizeof
> *reply);
> - ofputil_queue_stats_to_ofp10(oqs, reply);
> - break;
> - }
> -
> - case OFP14_VERSION:
> - case OFP15_VERSION:
> - case OFP16_VERSION: {
> - struct ofp14_queue_stats *reply = ofpmp_append(replies, sizeof
> *reply);
> - ofputil_queue_stats_to_ofp14(oqs, reply);
> - break;
> - }
> -
> - default:
> - OVS_NOT_REACHED();
> - }
> -}
> -
> -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) {
> - VLOG_WARN_RL(&bad_ofmsg_rl, "OFPT14_BUNDLE_ADD_MESSAGE contained "
> - "message is unparsable (%s)",
> ofperr_get_name(error));
> - return OFPERR_OFPBFC_MSG_UNSUP; /* 'error' would be confusing. */
> - }
> -
> - if (!ofputil_is_bundlable(type)) {
> - VLOG_WARN_RL(&bad_ofmsg_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;
> -}
> -
> -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(&bad_ofmsg_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(&bad_ofmsg_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(&bad_ofmsg_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);
> -}
> -
> -void
> -ofputil_uninit_tlv_table(struct ovs_list *mappings)
> -{
> - struct ofputil_tlv_map *map;
> -
> - LIST_FOR_EACH_POP (map, list_node, mappings) {
> - free(map);
> - }
> -}
> -
> -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) {
> - OFPPROP_LOG(&bad_ofmsg_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) {
> - VLOG_WARN_RL(&bad_ofmsg_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;
> -}
> -
> -static void
> -ofputil_put_ofp14_table_desc(const struct ofputil_table_desc *td,
> - struct ofpbuf *b, enum ofp_version version)
> -{
> - struct ofp14_table_desc *otd;
> - struct ofp14_table_mod_prop_vacancy *otv;
> - size_t start_otd;
> -
> - start_otd = b->size;
> - ofpbuf_put_zeros(b, sizeof *otd);
> -
> - ofpprop_put_u32(b, OFPTMPT14_EVICTION, td->eviction_flags);
> -
> - otv = ofpbuf_put_zeros(b, sizeof *otv);
> - otv->type = htons(OFPTMPT14_VACANCY);
> - otv->length = htons(sizeof *otv);
> - otv->vacancy_down = td->table_vacancy.vacancy_down;
> - otv->vacancy_up = td->table_vacancy.vacancy_up;
> - otv->vacancy = td->table_vacancy.vacancy;
> -
> - otd = ofpbuf_at_assert(b, start_otd, sizeof *otd);
> - otd->length = htons(b->size - start_otd);
> - otd->table_id = td->table_id;
> - otd->config = ofputil_encode_table_config(OFPUTIL_TABLE_MISS_DEFAULT,
> - td->eviction, td->vacancy,
> - version);
> -}
> -
> -/* Converts the abstract form of a "table status" message in '*ts' into an
> - * OpenFlow message suitable for 'protocol', and returns that encoded
> form in
> - * a buffer owned by the caller. */
> -struct ofpbuf *
> -ofputil_encode_table_status(const struct ofputil_table_status *ts,
> - enum ofputil_protocol protocol)
> -{
> - enum ofp_version version;
> - struct ofpbuf *b;
> -
> - version = ofputil_protocol_to_ofp_version(protocol);
> - if (version >= OFP14_VERSION) {
> - enum ofpraw raw;
> - struct ofp14_table_status *ots;
> -
> - raw = OFPRAW_OFPT14_TABLE_STATUS;
> - b = ofpraw_alloc_xid(raw, version, htonl(0), 0);
> - ots = ofpbuf_put_zeros(b, sizeof *ots);
> - ots->reason = ts->reason;
> - ofputil_put_ofp14_table_desc(&ts->desc, b, version);
> - ofpmsg_update_length(b);
> - return b;
> - } else {
> - return NULL;
> - }
> -}
> -
> -/* Decodes the OpenFlow "table status" message in '*ots' into an abstract
> form
> - * in '*ts'. Returns 0 if successful, otherwise an OFPERR_* value. */
> -enum ofperr
> -ofputil_decode_table_status(const struct ofp_header *oh,
> - struct ofputil_table_status *ts)
> -{
> - const struct ofp14_table_status *ots;
> - struct ofpbuf b;
> - enum ofperr error;
> - enum ofpraw raw;
> -
> - ofpbuf_use_const(&b, oh, ntohs(oh->length));
> - raw = ofpraw_pull_assert(&b);
> - ots = ofpbuf_pull(&b, sizeof *ots);
> -
> - if (raw == OFPRAW_OFPT14_TABLE_STATUS) {
> - if (ots->reason != OFPTR_VACANCY_DOWN
> - && ots->reason != OFPTR_VACANCY_UP) {
> - return OFPERR_OFPBPC_BAD_VALUE;
> - }
> - ts->reason = ots->reason;
> -
> - error = ofputil_decode_table_desc(&b, &ts->desc, oh->version);
> - return error;
> - } else {
> - return OFPERR_OFPBRC_BAD_VERSION;
> - }
> -
> - return 0;
> + return ofpraw_alloc(type, ofp_version, 0);
> }
> diff --git a/lib/ofp-version-opt.c b/lib/ofp-version-opt.c
> index 89e33fa97146..f97d7b738946 100644
> --- a/lib/ofp-version-opt.c
> +++ b/lib/ofp-version-opt.c
> @@ -1,6 +1,6 @@
> #include <config.h>
> #include "openvswitch/dynamic-string.h"
> -#include "openvswitch/ofp-util.h"
> +#include "openvswitch/ofp-protocol.h"
> #include "ofp-version-opt.h"
> #include "ovs-thread.h"
>
> diff --git a/lib/ofp-version-opt.h b/lib/ofp-version-opt.h
> index 74cad5b3f4af..525fd8ac41b9 100644
> --- a/lib/ofp-version-opt.h
> +++ b/lib/ofp-version-opt.h
> @@ -3,7 +3,6 @@
>
> #include <openflow/openflow-common.h>
> #include "util.h"
> -#include "openvswitch/ofp-util.h"
>
> #define OFP_VERSION_LONG_OPTIONS \
> {"version", no_argument, NULL, 'V'}, \
> diff --git a/lib/tun-metadata.c b/lib/tun-metadata.c
> index 0cb2456a781e..c0d9180e020e 100644
> --- a/lib/tun-metadata.c
> +++ b/lib/tun-metadata.c
> @@ -24,7 +24,7 @@
> #include "openvswitch/match.h"
> #include "nx-match.h"
> #include "odp-netlink.h"
> -#include "openvswitch/ofp-util.h"
> +#include "openvswitch/ofp-match.h"
> #include "ovs-rcu.h"
> #include "packets.h"
> #include "tun-metadata.h"
> diff --git a/lib/vconn.c b/lib/vconn.c
> index f0d00eec104f..aeb2cd7dd826 100644
> --- a/lib/vconn.c
> +++ b/lib/vconn.c
> @@ -29,6 +29,7 @@
> #include "openflow/nicira-ext.h"
> #include "openflow/openflow.h"
> #include "openvswitch/dynamic-string.h"
> +#include "openvswitch/ofp-bundle.h"
> #include "openvswitch/ofp-errors.h"
> #include "openvswitch/ofp-msgs.h"
> #include "openvswitch/ofp-print.h"
> diff --git a/ofproto/bond.c b/ofproto/bond.c
> index 6f3d7b5b3817..11d28e1379b9 100644
> --- a/ofproto/bond.c
> +++ b/ofproto/bond.c
> @@ -38,7 +38,6 @@
> #include "openvswitch/list.h"
> #include "openvswitch/match.h"
> #include "openvswitch/ofp-actions.h"
> -#include "openvswitch/ofp-util.h"
> #include "openvswitch/ofpbuf.h"
> #include "openvswitch/vlog.h"
> #include "packets.h"
> diff --git a/ofproto/bundles.c b/ofproto/bundles.c
> index aab15be79c65..405ec8cc1e7c 100644
> --- a/ofproto/bundles.c
> +++ b/ofproto/bundles.c
> @@ -26,7 +26,6 @@
> #include "ofproto-provider.h"
> #include "openvswitch/ofp-actions.h"
> #include "openvswitch/ofp-msgs.h"
> -#include "openvswitch/ofp-util.h"
> #include "openvswitch/ofpbuf.h"
> #include "openvswitch/vconn.h"
> #include "openvswitch/vlog.h"
> diff --git a/ofproto/bundles.h b/ofproto/bundles.h
> index 65ac5cb52b90..806e853d6883 100644
> --- a/ofproto/bundles.h
> +++ b/ofproto/bundles.h
> @@ -24,7 +24,6 @@
> #include "connmgr.h"
> #include "ofproto-provider.h"
> #include "openvswitch/ofp-msgs.h"
> -#include "openvswitch/ofp-util.h"
> #include "util.h"
>
> #ifdef __cplusplus
> diff --git a/ofproto/connmgr.c b/ofproto/connmgr.c
> index 283b80d8d415..e0e78a1e1a78 100644
> --- a/ofproto/connmgr.c
> +++ b/ofproto/connmgr.c
> @@ -28,7 +28,7 @@
> #include "openvswitch/dynamic-string.h"
> #include "openvswitch/ofp-actions.h"
> #include "openvswitch/ofp-msgs.h"
> -#include "openvswitch/ofp-util.h"
> +#include "openvswitch/ofp-monitor.h"
> #include "openvswitch/ofpbuf.h"
> #include "openvswitch/vconn.h"
> #include "openvswitch/vlog.h"
> diff --git a/ofproto/connmgr.h b/ofproto/connmgr.h
> index a3c534d66611..c41189216b37 100644
> --- a/ofproto/connmgr.h
> +++ b/ofproto/connmgr.h
> @@ -21,15 +21,18 @@
> #include "openvswitch/hmap.h"
> #include "openvswitch/list.h"
> #include "openvswitch/match.h"
> -#include "openvswitch/ofp-util.h"
> +#include "openvswitch/ofp-connection.h"
> #include "ofproto.h"
> #include "ofproto-provider.h"
> #include "openflow/nicira-ext.h"
> #include "openvswitch/ofp-errors.h"
> +#include "openvswitch/ofp-packet.h"
> #include "openvswitch/types.h"
>
> struct nlattr;
> struct ofconn;
> +struct ofputil_flow_removed;
> +struct ofputil_requestforward;
> struct rule;
> struct simap;
> struct sset;
> diff --git a/ofproto/fail-open.c b/ofproto/fail-open.c
> index 7f7ffc43ff9a..03552a92deb5 100644
> --- a/ofproto/fail-open.c
> +++ b/ofproto/fail-open.c
> @@ -25,7 +25,6 @@
> #include "mac-learning.h"
> #include "odp-util.h"
> #include "openvswitch/ofp-actions.h"
> -#include "openvswitch/ofp-util.h"
> #include "openvswitch/ofpbuf.h"
> #include "openvswitch/vconn.h"
> #include "openvswitch/vlog.h"
> diff --git a/ofproto/ofproto-dpif-ipfix.c b/ofproto/ofproto-dpif-ipfix.c
> index 97dbc3d29fe1..c7ddeb96e1dc 100644
> --- a/ofproto/ofproto-dpif-ipfix.c
> +++ b/ofproto/ofproto-dpif-ipfix.c
> @@ -24,6 +24,7 @@
> #include "openvswitch/hmap.h"
> #include "netdev.h"
> #include "openvswitch/list.h"
> +#include "openvswitch/ofp-ipfix.h"
> #include "openvswitch/ofpbuf.h"
> #include "ofproto.h"
> #include "ofproto-dpif.h"
> diff --git a/ofproto/ofproto-dpif-trace.c b/ofproto/ofproto-dpif-trace.c
> index 3811e03b106d..4071cc0ffd65 100644
> --- a/ofproto/ofproto-dpif-trace.c
> +++ b/ofproto/ofproto-dpif-trace.c
> @@ -21,7 +21,6 @@
> #include "conntrack.h"
> #include "dpif.h"
> #include "ofproto-dpif-xlate.h"
> -#include "openvswitch/ofp-parse.h"
> #include "unixctl.h"
>
> static void ofproto_trace(struct ofproto_dpif *, const struct flow *,
> diff --git a/ofproto/ofproto-dpif.c b/ofproto/ofproto-dpif.c
> index e78e7529c421..0fee6f9c5065 100644
> --- a/ofproto/ofproto-dpif.c
> +++ b/ofproto/ofproto-dpif.c
> @@ -54,9 +54,7 @@
> #include "openvswitch/ofp-actions.h"
> #include "openvswitch/dynamic-string.h"
> #include "openvswitch/meta-flow.h"
> -#include "openvswitch/ofp-parse.h"
> #include "openvswitch/ofp-print.h"
> -#include "openvswitch/ofp-util.h"
> #include "openvswitch/ofpbuf.h"
> #include "openvswitch/uuid.h"
> #include "openvswitch/vlog.h"
> diff --git a/ofproto/ofproto-dpif.h b/ofproto/ofproto-dpif.h
> index 6443cc5b2d63..2433a548c6d0 100644
> --- a/ofproto/ofproto-dpif.h
> +++ b/ofproto/ofproto-dpif.h
> @@ -50,7 +50,6 @@
> #include "fail-open.h"
> #include "hmapx.h"
> #include "odp-util.h"
> -#include "openvswitch/ofp-util.h"
> #include "id-pool.h"
> #include "ovs-thread.h"
> #include "ofproto-provider.h"
> diff --git a/ofproto/ofproto-provider.h b/ofproto/ofproto-provider.h
> index ae4af4525705..92d4622b3290 100644
> --- a/ofproto/ofproto-provider.h
> +++ b/ofproto/ofproto-provider.h
> @@ -42,8 +42,13 @@
> #include "ofproto/ofproto.h"
> #include "openvswitch/list.h"
> #include "openvswitch/ofp-actions.h"
> -#include "openvswitch/ofp-util.h"
> #include "openvswitch/ofp-errors.h"
> +#include "openvswitch/ofp-flow.h"
> +#include "openvswitch/ofp-group.h"
> +#include "openvswitch/ofp-meter.h"
> +#include "openvswitch/ofp-port.h"
> +#include "openvswitch/ofp-switch.h"
> +#include "openvswitch/ofp-table.h"
> #include "ovs-atomic.h"
> #include "ovs-rcu.h"
> #include "ovs-thread.h"
> @@ -56,6 +61,7 @@
>
> struct match;
> struct ofputil_flow_mod;
> +struct ofputil_packet_in_private;
> struct bfd_cfg;
> struct meter;
> struct ofoperation;
> diff --git a/ofproto/ofproto.c b/ofproto/ofproto.c
> index 02dd12b50f6a..f28bb896eee9 100644
> --- a/ofproto/ofproto.c
> +++ b/ofproto/ofproto.c
> @@ -41,9 +41,13 @@
> #include "openvswitch/dynamic-string.h"
> #include "openvswitch/meta-flow.h"
> #include "openvswitch/ofp-actions.h"
> +#include "openvswitch/ofp-bundle.h"
> #include "openvswitch/ofp-errors.h"
> +#include "openvswitch/ofp-match.h"
> #include "openvswitch/ofp-msgs.h"
> +#include "openvswitch/ofp-monitor.h"
> #include "openvswitch/ofp-print.h"
> +#include "openvswitch/ofp-queue.h"
> #include "openvswitch/ofp-util.h"
> #include "openvswitch/ofpbuf.h"
> #include "openvswitch/vlog.h"
> diff --git a/ovn/controller/ofctrl.c b/ovn/controller/ofctrl.c
> index f0a0f4aa9885..897ff3694bfa 100644
> --- a/ovn/controller/ofctrl.c
> +++ b/ovn/controller/ofctrl.c
> @@ -28,8 +28,12 @@
> #include "openvswitch/list.h"
> #include "openvswitch/match.h"
> #include "openvswitch/ofp-actions.h"
> +#include "openvswitch/ofp-flow.h"
> +#include "openvswitch/ofp-group.h"
> +#include "openvswitch/ofp-match.h"
> #include "openvswitch/ofp-msgs.h"
> -#include "openvswitch/ofp-parse.h"
> +#include "openvswitch/ofp-meter.h"
> +#include "openvswitch/ofp-packet.h"
> #include "openvswitch/ofp-print.h"
> #include "openvswitch/ofp-util.h"
> #include "openvswitch/ofpbuf.h"
> diff --git a/ovn/controller/pinctrl.c b/ovn/controller/pinctrl.c
> index 14c95ff547ff..8a11672a1029 100644
> --- a/ovn/controller/pinctrl.c
> +++ b/ovn/controller/pinctrl.c
> @@ -31,7 +31,9 @@
> #include "lib/sset.h"
> #include "openvswitch/ofp-actions.h"
> #include "openvswitch/ofp-msgs.h"
> +#include "openvswitch/ofp-packet.h"
> #include "openvswitch/ofp-print.h"
> +#include "openvswitch/ofp-switch.h"
> #include "openvswitch/ofp-util.h"
> #include "openvswitch/vlog.h"
>
> diff --git a/ovn/utilities/ovn-sbctl.c b/ovn/utilities/ovn-sbctl.c
> index dc56d864c986..5764ee336837 100644
> --- a/ovn/utilities/ovn-sbctl.c
> +++ b/ovn/utilities/ovn-sbctl.c
> @@ -36,6 +36,7 @@
> #include "openvswitch/dynamic-string.h"
> #include "openvswitch/json.h"
> #include "openvswitch/ofp-actions.h"
> +#include "openvswitch/ofp-flow.h"
> #include "openvswitch/ofp-print.h"
> #include "openvswitch/shash.h"
> #include "openvswitch/vconn.h"
> diff --git a/ovn/utilities/ovn-trace.c b/ovn/utilities/ovn-trace.c
> index 7e88594faa18..db39c49618be 100644
> --- a/ovn/utilities/ovn-trace.c
> +++ b/ovn/utilities/ovn-trace.c
> @@ -28,6 +28,7 @@
> #include "openvswitch/dynamic-string.h"
> #include "openvswitch/json.h"
> #include "openvswitch/ofp-actions.h"
> +#include "openvswitch/ofp-flow.h"
> #include "openvswitch/ofp-print.h"
> #include "openvswitch/vconn.h"
> #include "openvswitch/vlog.h"
> diff --git a/tests/learn.at b/tests/learn.at
> index 406a827aae36..5f1d6df9de49 100644
> --- a/tests/learn.at
> +++ b/tests/learn.at
> @@ -28,7 +28,7 @@ AT_CLEANUP
> AT_SETUP([learning action - parsing and formatting - illegal in_port_oxm])
> AT_CHECK([[ovs-ofctl parse-flow 'actions=learn(table=1,
> in_port_oxm=123456)']],
> [1], [], [stderr])
> -AT_CHECK([sed -e 's/.*|ofp_util|WARN|//' < stderr], [0],
> +AT_CHECK([sed -e 's/.*|ofp_port|WARN|//' < stderr], [0],
> [[port 123456 is outside the supported range 0 through ffff or
> 0xffffff00 through 0xffffffff
> ovs-ofctl: table=1, in_port_oxm=123456: in_port_oxm value 123456 cannot
> be parsed as a subfield (123456: unknown field `123456') or an immediate
> value (123456: port value out of range for in_port_oxm)
> ]], [[]])
> diff --git a/tests/ofp-print.at b/tests/ofp-print.at
> index 821087ce108f..1061609512b9 100644
> --- a/tests/ofp-print.at
> +++ b/tests/ofp-print.at
> @@ -876,9 +876,9 @@ AT_CHECK([ovs-ofctl '-vPATTERN:console:%c|%p|%m'
> ofp-print "\
> " 2], [0], [dnl
> OFPT_FLOW_MOD (xid=0x0): ADD priority=65535,arp,in_port=1,
> vlan_tci=0x0000,dl_src=50:54:00:00:00:06,dl_dst=50:54:00:
> 00:00:05,arp_spa=192.168.0.2,arp_tpa=192.168.0.1,arp_op=2 idle:5
> buf:0x10e out_port:0 actions=output:3
> ], [dnl
> -ofp_util|INFO|normalization changed ofp_match, details:
> -ofp_util|INFO| pre: arp,in_port=1,vlan_tci=0x0000,
> dl_src=50:54:00:00:00:06,dl_dst=50:54:00:00:00:05,arp_spa=
> 192.168.0.2,arp_tpa=192.168.0.1,arp_op=2,nw_tos=0,tp_src=0,tp_dst=0
> -ofp_util|INFO|post: arp,in_port=1,vlan_tci=0x0000,
> dl_src=50:54:00:00:00:06,dl_dst=50:54:00:00:00:05,arp_spa=
> 192.168.0.2,arp_tpa=192.168.0.1,arp_op=2
> +ofp_match|INFO|normalization changed ofp_match, details:
> +ofp_match|INFO| pre: arp,in_port=1,vlan_tci=0x0000,
> dl_src=50:54:00:00:00:06,dl_dst=50:54:00:00:00:05,arp_spa=
> 192.168.0.2,arp_tpa=192.168.0.1,arp_op=2,nw_tos=0,tp_src=0,tp_dst=0
> +ofp_match|INFO|post: arp,in_port=1,vlan_tci=0x0000,
> dl_src=50:54:00:00:00:06,dl_dst=50:54:00:00:00:05,arp_spa=
> 192.168.0.2,arp_tpa=192.168.0.1,arp_op=2
> ])
> AT_CLEANUP
>
> @@ -934,9 +934,9 @@ AT_CHECK([ovs-ofctl '-vPATTERN:console:%c|%p|%m'
> ofp-print "\
> " 3], [0], [dnl
> OFPT_FLOW_MOD (xid=0x0): ADD arp,in_port=1,dl_vlan=65535,
> dl_vlan_pcp=0,dl_src=50:54:00:00:00:06,dl_dst=50:54:00:00:
> 00:05,nw_src=192.168.0.2,nw_dst=192.168.0.1,arp_op=2,nw_tos=0,tp_src=0,tp_dst=0
> idle:5 pri:65535 buf:0x10e out_port:0 actions=output:3
> ], [dnl
> -ofp_util|INFO|normalization changed ofp_match, details:
> -ofp_util|INFO| pre: arp,in_port=1,vlan_tci=0x0000,
> dl_src=50:54:00:00:00:06,dl_dst=50:54:00:00:00:05,arp_spa=
> 192.168.0.2,arp_tpa=192.168.0.1,arp_op=2,nw_tos=0,tp_src=0,tp_dst=0
> -ofp_util|INFO|post: arp,in_port=1,vlan_tci=0x0000,
> dl_src=50:54:00:00:00:06,dl_dst=50:54:00:00:00:05,arp_spa=
> 192.168.0.2,arp_tpa=192.168.0.1,arp_op=2
> +ofp_match|INFO|normalization changed ofp_match, details:
> +ofp_match|INFO| pre: arp,in_port=1,vlan_tci=0x0000,
> dl_src=50:54:00:00:00:06,dl_dst=50:54:00:00:00:05,arp_spa=
> 192.168.0.2,arp_tpa=192.168.0.1,arp_op=2,nw_tos=0,tp_src=0,tp_dst=0
> +ofp_match|INFO|post: arp,in_port=1,vlan_tci=0x0000,
> dl_src=50:54:00:00:00:06,dl_dst=50:54:00:00:00:05,arp_spa=
> 192.168.0.2,arp_tpa=192.168.0.1,arp_op=2
> ])
> AT_CLEANUP
>
> @@ -3617,7 +3617,7 @@ OFPT_BUNDLE_ADD_MESSAGE (OF1.4) (xid=0x0): ***decode
> error: OFPBFC_MSG_UNSUP***
> 00000000 05 22 00 20 00 00 00 00-00 00 00 01 00 00 00 01 |.".
> ............|
> 00000010 05 00 00 10 00 00 00 00-00 00 00 00 00 00 00 00
> |................|
> ], [dnl
> -ofp_util|WARN|OFPT_HELLO message not allowed inside
> OFPT14_BUNDLE_ADD_MESSAGE
> +ofp_bundle|WARN|OFPT_HELLO message not allowed inside
> OFPT14_BUNDLE_ADD_MESSAGE
> ])
> AT_CLEANUP
>
> diff --git a/tests/ovs-ofctl.at b/tests/ovs-ofctl.at
> index f8d43adccd33..e1fc8299a2df 100644
> --- a/tests/ovs-ofctl.at
> +++ b/tests/ovs-ofctl.at
> @@ -1316,9 +1316,9 @@ dnl Ignore nw_proto if not IP or ARP:
> # dl_type=0x1234,nw_proto=5
> # normal: 3: cf -> ef
> # normal: 25: 05 -> 00
> -& ofp_util|INFO|normalization changed ofp_match, details:
> -& ofp_util|INFO| pre: dl_type=0x1234,nw_proto=5
> -& ofp_util|INFO|post: dl_type=0x1234
> +& ofp_match|INFO|normalization changed ofp_match, details:
> +& ofp_match|INFO| pre: dl_type=0x1234,nw_proto=5
> +& ofp_match|INFO|post: dl_type=0x1234
> 003820cf xxxx xxxxxxxxxxxx xxxxxxxxxxxx xxxx xx xx 1234 xx 05 xxxx dnl
> xxxxxxxx xxxxxxxx xxxx xxxx
>
> @@ -1331,9 +1331,9 @@ dnl Ignore nw_tos if not IP:
> # 24: 05 -> 04
> # normal: 1: 18 -> 38
> # normal: 24: 04 -> 00
> -& ofp_util|INFO|normalization changed ofp_match, details:
> -& ofp_util|INFO| pre: arp,nw_tos=4
> -& ofp_util|INFO|post: arp
> +& ofp_match|INFO|normalization changed ofp_match, details:
> +& ofp_match|INFO| pre: arp,nw_tos=4
> +& ofp_match|INFO|post: arp
> 001820ef xxxx xxxxxxxxxxxx xxxxxxxxxxxx xxxx xx xx 0806 05 xx xxxx dnl
> xxxxxxxx xxxxxxxx xxxx xxxx
>
> @@ -1390,9 +1390,9 @@ dnl Ignore nw_src if not IP or ARP:
> # normal: 28: c0 -> 00
> # normal: 29: a8 -> 00
> # normal: 30: 80 -> 00
> -& ofp_util|INFO|normalization changed ofp_match, details:
> -& ofp_util|INFO| pre: dl_type=0x1234,nw_src=192.168.128.0/24
> -& ofp_util|INFO|post: dl_type=0x1234
> +& ofp_match|INFO|normalization changed ofp_match, details:
> +& ofp_match|INFO| pre: dl_type=0x1234,nw_src=192.168.128.0/24
> +& ofp_match|INFO|post: dl_type=0x1234
> 003808ef xxxx xxxxxxxxxxxx xxxxxxxxxxxx xxxx xx xx 1234 xx xx xxxx dnl
> c0a88055 xxxxxxxx xxxx xxxx
>
> @@ -1403,9 +1403,9 @@ dnl Ignore nw_dst if not IP or ARP:
> # normal: 32: c0 -> 00
> # normal: 33: a8 -> 00
> # normal: 34: 80 -> 00
> -& ofp_util|INFO|normalization changed ofp_match, details:
> -& ofp_util|INFO| pre: dl_type=0x1234,nw_dst=192.168.128.0/24
> -& ofp_util|INFO|post: dl_type=0x1234
> +& ofp_match|INFO|normalization changed ofp_match, details:
> +& ofp_match|INFO| pre: dl_type=0x1234,nw_dst=192.168.128.0/24
> +& ofp_match|INFO|post: dl_type=0x1234
> 003220ef xxxx xxxxxxxxxxxx xxxxxxxxxxxx xxxx xx xx 1234 xx xx xxxx dnl
> xxxxxxxx c0a88055 xxxx xxxx
>
> @@ -1446,9 +1446,9 @@ dnl Ignore tp_src if not TCP/UDP/SCTP:
> # normal: 3: 8f -> cf
> # normal: 36: 01 -> 00
> # normal: 37: bb -> 00
> -& ofp_util|INFO|normalization changed ofp_match, details:
> -& ofp_util|INFO| pre: ip,nw_proto=21,tp_src=443
> -& ofp_util|INFO|post: ip,nw_proto=21
> +& ofp_match|INFO|normalization changed ofp_match, details:
> +& ofp_match|INFO| pre: ip,nw_proto=21,tp_src=443
> +& ofp_match|INFO|post: ip,nw_proto=21
> 0038208f xxxx xxxxxxxxxxxx xxxxxxxxxxxx xxxx xx xx 0800 xx 15 xxxx dnl
> xxxxxxxx xxxxxxxx 01bb xxxx
>
> @@ -1483,7 +1483,7 @@ AT_DATA([test-data], [dnl
> 00000000 00 000000 0000000000000000ffffffffffffffff
>
> # bad ofp11_match: OFPBMC_BAD_VALUE
> -& ofp_util|WARN|port 305419896 is outside the supported range 0 through
> 65279 or 0xffffff00 through 0xffffffff
> +& ofp_port|WARN|port 305419896 is outside the supported range 0 through
> 65279 or 0xffffff00 through 0xffffffff
> 0000 0058 12345678 000003fe dnl
> 000000000000ffffffffffff 000000000000ffffffffffff dnl
> 0000 00 00 0000 00 00 00000000ffffffff 00000000ffffffff 0000 0000 dnl
> @@ -2651,9 +2651,9 @@ AT_SETUP([ovs-ofctl add-flow reports non-normalized
> flows])
> OVS_VSWITCHD_START
> AT_CHECK([ovs-ofctl TESTABLE_LOG add-flow br0 nw_src=1.2.3.4,actions=5],
> [0], [], [dnl
> -ofp_util|INFO|normalization changed ofp_match, details:
> -ofp_util|INFO| pre: nw_src=1.2.3.4
> -ofp_util|INFO|post: @&t@
> +ofp_match|INFO|normalization changed ofp_match, details:
> +ofp_match|INFO| pre: nw_src=1.2.3.4
> +ofp_match|INFO|post: @&t@
> ])
> OVS_VSWITCHD_STOP
> AT_CLEANUP
> diff --git a/tests/test-classifier.c b/tests/test-classifier.c
> index ef6693e61bcb..909260d11c00 100644
> --- a/tests/test-classifier.c
> +++ b/tests/test-classifier.c
> @@ -36,7 +36,6 @@
> #include "command-line.h"
> #include "fatal-signal.h"
> #include "flow.h"
> -#include "openvswitch/ofp-util.h"
> #include "ovstest.h"
> #include "ovs-atomic.h"
> #include "ovs-thread.h"
> diff --git a/tests/test-flows.c b/tests/test-flows.c
> index d7fa798df17d..871b729ebf65 100644
> --- a/tests/test-flows.c
> +++ b/tests/test-flows.c
> @@ -23,8 +23,8 @@
> #include <string.h>
> #include "classifier.h"
> #include "openflow/openflow.h"
> +#include "openvswitch/ofp-match.h"
> #include "openvswitch/ofp-print.h"
> -#include "openvswitch/ofp-util.h"
> #include "openvswitch/ofpbuf.h"
> #include "openvswitch/vlog.h"
> #include "ovstest.h"
> diff --git a/tests/test-odp.c b/tests/test-odp.c
> index 1f1ff9ad630f..f61846422051 100644
> --- a/tests/test-odp.c
> +++ b/tests/test-odp.c
> @@ -24,7 +24,7 @@
> #include "openvswitch/ofpbuf.h"
> #include "ovstest.h"
> #include "util.h"
> -#include "openvswitch/ofp-parse.h"
> +#include "openvswitch/ofp-flow.h"
> #include "openvswitch/vlog.h"
>
> static int
> diff --git a/tests/test-vconn.c b/tests/test-vconn.c
> index 07997a1bcc9d..0c17a8395b95 100644
> --- a/tests/test-vconn.c
> +++ b/tests/test-vconn.c
> @@ -26,7 +26,6 @@
> #include "fatal-signal.h"
> #include "openflow/openflow.h"
> #include "openvswitch/ofp-msgs.h"
> -#include "openvswitch/ofp-util.h"
> #include "openvswitch/ofpbuf.h"
> #include "openvswitch/vconn.h"
> #include "openvswitch/vlog.h"
> diff --git a/utilities/ovs-dpctl.c b/utilities/ovs-dpctl.c
> index 7e6101632c38..c4db97b8ba29 100644
> --- a/utilities/ovs-dpctl.c
> +++ b/utilities/ovs-dpctl.c
> @@ -40,7 +40,6 @@
> #include "packets.h"
> #include "timeval.h"
> #include "util.h"
> -#include "openvswitch/ofp-parse.h"
> #include "openvswitch/vlog.h"
>
> static struct dpctl_params dpctl_p;
> diff --git a/utilities/ovs-ofctl.c b/utilities/ovs-ofctl.c
> index 6a30efe8c4c3..e47891ddb353 100644
> --- a/utilities/ovs-ofctl.c
> +++ b/utilities/ovs-ofctl.c
> @@ -47,11 +47,20 @@
> #include "openvswitch/dynamic-string.h"
> #include "openvswitch/meta-flow.h"
> #include "openvswitch/ofp-actions.h"
> +#include "openvswitch/ofp-bundle.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-monitor.h"
> +#include "openvswitch/ofp-port.h"
> #include "openvswitch/ofp-print.h"
> #include "openvswitch/ofp-util.h"
> #include "openvswitch/ofp-parse.h"
> +#include "openvswitch/ofp-queue.h"
> +#include "openvswitch/ofp-switch.h"
> +#include "openvswitch/ofp-table.h"
> #include "openvswitch/ofpbuf.h"
> #include "openvswitch/shash.h"
> #include "openvswitch/vconn.h"
> diff --git a/utilities/ovs-testcontroller.c b/utilities/ovs-
> testcontroller.c
> index 571af0c7f971..b489ff5fc7a7 100644
> --- a/utilities/ovs-testcontroller.c
> +++ b/utilities/ovs-testcontroller.c
> @@ -39,11 +39,11 @@
> #include "timeval.h"
> #include "unixctl.h"
> #include "util.h"
> -#include "openvswitch/ofp-parse.h"
> +#include "openvswitch/ofp-flow.h"
> #include "openvswitch/vconn.h"
> #include "openvswitch/vlog.h"
> #include "socket-util.h"
> -#include "openvswitch/ofp-util.h"
> +
>
> VLOG_DEFINE_THIS_MODULE(controller);
>
> diff --git a/vswitchd/bridge.c b/vswitchd/bridge.c
> index f44f950a4fce..cf9c79fd77cf 100644
> --- a/vswitchd/bridge.c
> +++ b/vswitchd/bridge.c
> @@ -45,7 +45,6 @@
> #include "openvswitch/list.h"
> #include "openvswitch/meta-flow.h"
> #include "openvswitch/ofp-print.h"
> -#include "openvswitch/ofp-util.h"
> #include "openvswitch/ofpbuf.h"
> #include "openvswitch/vlog.h"
> #include "ovs-lldp.h"
> --
> 2.15.1
>
> _______________________________________________
> dev mailing list
> dev at openvswitch.org
> https://mail.openvswitch.org/mailman/listinfo/ovs-dev
>
More information about the dev
mailing list