+ opp->port_no = htons(pp->port_no);
+ memcpy(opp->hw_addr, pp->hw_addr, ETH_ADDR_LEN);
+ ovs_strlcpy(opp->name, pp->name, OFP_MAX_PORT_NAME_LEN);
+
+ 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);
+ memcpy(op->hw_addr, pp->hw_addr, ETH_ADDR_LEN);
+ ovs_strlcpy(op->name, pp->name, OFP_MAX_PORT_NAME_LEN);
+
+ 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_put_phy_port(uint8_t ofp_version, const struct ofputil_phy_port *pp,
+ struct ofpbuf *b)
+{
+ if (ofp_version == OFP10_VERSION) {
+ struct ofp10_phy_port *opp;
+ if (b->size + sizeof *opp <= UINT16_MAX) {
+ opp = ofpbuf_put_uninit(b, sizeof *opp);
+ ofputil_encode_ofp10_phy_port(pp, opp);
+ }
+ } else {
+ struct ofp11_port *op;
+ if (b->size + sizeof *op <= UINT16_MAX) {
+ op = ofpbuf_put_uninit(b, sizeof *op);
+ ofputil_encode_ofp11_port(pp, op);
+ }
+ }
+}
+
+void
+ofputil_append_port_desc_stats_reply(uint8_t ofp_version,
+ const struct ofputil_phy_port *pp,
+ struct list *replies)
+{
+ if (ofp_version == OFP10_VERSION) {
+ struct ofp10_phy_port *opp;
+
+ opp = ofputil_append_stats_reply(sizeof *opp, replies);
+ ofputil_encode_ofp10_phy_port(pp, opp);
+ } else {
+ struct ofp11_port *op;
+
+ op = ofputil_append_stats_reply(sizeof *op, replies);
+ ofputil_encode_ofp11_port(pp, op);
+ }
+}
+\f
+/* ofputil_switch_features */
+
+#define OFPC_COMMON (OFPC_FLOW_STATS | OFPC_TABLE_STATS | OFPC_PORT_STATS | \
+ OFPC_IP_REASM | OFPC_QUEUE_STATS | OFPC_ARP_MATCH_IP)
+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);
+
+struct ofputil_action_bit_translation {
+ enum ofputil_action_bitmap ofputil_bit;
+ int of_bit;
+};
+
+static const struct ofputil_action_bit_translation of10_action_bits[] = {
+ { OFPUTIL_A_OUTPUT, OFPAT10_OUTPUT },
+ { OFPUTIL_A_SET_VLAN_VID, OFPAT10_SET_VLAN_VID },
+ { OFPUTIL_A_SET_VLAN_PCP, OFPAT10_SET_VLAN_PCP },
+ { OFPUTIL_A_STRIP_VLAN, OFPAT10_STRIP_VLAN },
+ { OFPUTIL_A_SET_DL_SRC, OFPAT10_SET_DL_SRC },
+ { OFPUTIL_A_SET_DL_DST, OFPAT10_SET_DL_DST },
+ { OFPUTIL_A_SET_NW_SRC, OFPAT10_SET_NW_SRC },
+ { OFPUTIL_A_SET_NW_DST, OFPAT10_SET_NW_DST },
+ { OFPUTIL_A_SET_NW_TOS, OFPAT10_SET_NW_TOS },
+ { OFPUTIL_A_SET_TP_SRC, OFPAT10_SET_TP_SRC },
+ { OFPUTIL_A_SET_TP_DST, OFPAT10_SET_TP_DST },
+ { OFPUTIL_A_ENQUEUE, OFPAT10_ENQUEUE },
+ { 0, 0 },
+};
+
+static const struct ofputil_action_bit_translation of11_action_bits[] = {
+ { OFPUTIL_A_OUTPUT, OFPAT11_OUTPUT },
+ { OFPUTIL_A_SET_VLAN_VID, OFPAT11_SET_VLAN_VID },
+ { OFPUTIL_A_SET_VLAN_PCP, OFPAT11_SET_VLAN_PCP },
+ { OFPUTIL_A_SET_DL_SRC, OFPAT11_SET_DL_SRC },
+ { OFPUTIL_A_SET_DL_DST, OFPAT11_SET_DL_DST },
+ { OFPUTIL_A_SET_NW_SRC, OFPAT11_SET_NW_SRC },
+ { OFPUTIL_A_SET_NW_DST, OFPAT11_SET_NW_DST },
+ { OFPUTIL_A_SET_NW_TOS, OFPAT11_SET_NW_TOS },
+ { OFPUTIL_A_SET_NW_ECN, OFPAT11_SET_NW_ECN },
+ { OFPUTIL_A_SET_TP_SRC, OFPAT11_SET_TP_SRC },
+ { OFPUTIL_A_SET_TP_DST, OFPAT11_SET_TP_DST },
+ { OFPUTIL_A_COPY_TTL_OUT, OFPAT11_COPY_TTL_OUT },
+ { OFPUTIL_A_COPY_TTL_IN, OFPAT11_COPY_TTL_IN },
+ { OFPUTIL_A_SET_MPLS_LABEL, OFPAT11_SET_MPLS_LABEL },
+ { OFPUTIL_A_SET_MPLS_TC, OFPAT11_SET_MPLS_TC },
+ { OFPUTIL_A_SET_MPLS_TTL, OFPAT11_SET_MPLS_TTL },
+ { OFPUTIL_A_DEC_MPLS_TTL, OFPAT11_DEC_MPLS_TTL },
+ { OFPUTIL_A_PUSH_VLAN, OFPAT11_PUSH_VLAN },
+ { OFPUTIL_A_POP_VLAN, OFPAT11_POP_VLAN },
+ { OFPUTIL_A_PUSH_MPLS, OFPAT11_PUSH_MPLS },
+ { OFPUTIL_A_POP_MPLS, OFPAT11_POP_MPLS },
+ { OFPUTIL_A_SET_QUEUE, OFPAT11_SET_QUEUE },
+ { OFPUTIL_A_GROUP, OFPAT11_GROUP },
+ { OFPUTIL_A_SET_NW_TTL, OFPAT11_SET_NW_TTL },
+ { OFPUTIL_A_DEC_NW_TTL, OFPAT11_DEC_NW_TTL },
+ { 0, 0 },
+};
+
+static enum ofputil_action_bitmap
+decode_action_bits(ovs_be32 of_actions,
+ const struct ofputil_action_bit_translation *x)
+{
+ enum ofputil_action_bitmap ofputil_actions;
+
+ ofputil_actions = 0;
+ for (; x->ofputil_bit; x++) {
+ if (of_actions & htonl(1u << x->of_bit)) {
+ ofputil_actions |= x->ofputil_bit;
+ }
+ }
+ return ofputil_actions;
+}
+
+/* Decodes an OpenFlow 1.0 or 1.1 "switch_features" structure 'osf' into an
+ * abstract representation in '*features'. Initializes '*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_decode_switch_features(const struct ofp_switch_features *osf,
+ struct ofputil_switch_features *features,
+ struct ofpbuf *b)
+{
+ ofpbuf_use_const(b, osf, ntohs(osf->header.length));
+ 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->capabilities = ntohl(osf->capabilities) & OFPC_COMMON;
+
+ if (b->size % ofputil_get_phy_port_size(osf->header.version)) {
+ return OFPERR_OFPBRC_BAD_LEN;
+ }
+
+ if (osf->header.version == OFP10_VERSION) {
+ if (osf->capabilities & htonl(OFPC10_STP)) {
+ features->capabilities |= OFPUTIL_C_STP;
+ }
+ features->actions = decode_action_bits(osf->actions, of10_action_bits);
+ } else if (osf->header.version == OFP11_VERSION) {
+ if (osf->capabilities & htonl(OFPC11_GROUP_STATS)) {
+ features->capabilities |= OFPUTIL_C_GROUP_STATS;
+ }
+ features->actions = decode_action_bits(osf->actions, of11_action_bits);
+ } else {
+ return OFPERR_OFPBRC_BAD_VERSION;
+ }
+
+ return 0;
+}
+
+/* Returns true if the maximum number of ports are in 'osf'. */
+static bool
+max_ports_in_features(const struct ofp_switch_features *osf)
+{
+ size_t pp_size = ofputil_get_phy_port_size(osf->header.version);
+ return ntohs(osf->header.length) + pp_size > UINT16_MAX;
+}
+
+/* Given a buffer 'b' that contains a Features Reply message, checks if
+ * it contains the maximum number of ports that will fit. If so, it
+ * returns true and removes the ports from the message. The caller
+ * should then send an OFPST_PORT_DESC stats request to get the ports,
+ * since the switch may have more ports than could be represented in the
+ * Features Reply. Otherwise, returns false.
+ */
+bool
+ofputil_switch_features_ports_trunc(struct ofpbuf *b)
+{
+ struct ofp_switch_features *osf = b->data;
+
+ if (max_ports_in_features(osf)) {
+ /* Remove all the ports. */
+ b->size = sizeof(*osf);
+ update_openflow_length(b);
+
+ return true;
+ }
+
+ return false;
+}
+
+static ovs_be32
+encode_action_bits(enum ofputil_action_bitmap ofputil_actions,
+ const struct ofputil_action_bit_translation *x)
+{
+ uint32_t of_actions;
+
+ of_actions = 0;
+ for (; x->ofputil_bit; x++) {
+ if (ofputil_actions & x->ofputil_bit) {
+ of_actions |= 1 << x->of_bit;
+ }
+ }
+ return htonl(of_actions);
+}
+
+/* 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;
+
+ osf = make_openflow_xid(sizeof *osf, OFPT_FEATURES_REPLY, xid, &b);
+ osf->header.version = ofputil_protocol_to_ofp_version(protocol);
+ 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 & OFPC_COMMON);
+ if (osf->header.version == OFP10_VERSION) {
+ if (features->capabilities & OFPUTIL_C_STP) {
+ osf->capabilities |= htonl(OFPC10_STP);
+ }
+ osf->actions = encode_action_bits(features->actions, of10_action_bits);
+ } else {
+ if (features->capabilities & OFPUTIL_C_GROUP_STATS) {
+ osf->capabilities |= htonl(OFPC11_GROUP_STATS);
+ }
+ osf->actions = encode_action_bits(features->actions, of11_action_bits);
+ }
+
+ 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_switch_features *osf = b->data;
+
+ ofputil_put_phy_port(osf->header.version, pp, b);
+}
+\f
+/* 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_port_status *ops,
+ struct ofputil_port_status *ps)
+{
+ struct ofpbuf b;
+ int retval;
+
+ if (ops->reason != OFPPR_ADD &&
+ ops->reason != OFPPR_DELETE &&
+ ops->reason != OFPPR_MODIFY) {
+ return OFPERR_NXBRC_BAD_REASON;
+ }
+ ps->reason = ops->reason;
+
+ ofpbuf_use_const(&b, ops, ntohs(ops->header.length));
+ ofpbuf_pull(&b, sizeof *ops);
+ retval = ofputil_pull_phy_port(ops->header.version, &b, &ps->desc);
+ 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;
+
+ b = ofpbuf_new(sizeof *ops + sizeof(struct ofp11_port));
+ ops = put_openflow_xid(sizeof *ops, OFPT_PORT_STATUS, htonl(0), b);
+ ops->header.version = ofputil_protocol_to_ofp_version(protocol);
+ ops->reason = ps->reason;
+ ofputil_put_phy_port(ops->header.version, &ps->desc, b);
+ update_openflow_length(b);
+ return b;
+}
+\f
+/* ofputil_port_mod */
+
+/* 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)
+{
+ if (oh->version == OFP10_VERSION) {
+ const struct ofp10_port_mod *opm = (const struct ofp10_port_mod *) oh;
+
+ if (oh->length != htons(sizeof *opm)) {
+ return OFPERR_OFPBRC_BAD_LEN;
+ }
+
+ pm->port_no = ntohs(opm->port_no);
+ memcpy(pm->hw_addr, opm->hw_addr, ETH_ADDR_LEN);
+ pm->config = ntohl(opm->config) & OFPPC10_ALL;
+ pm->mask = ntohl(opm->mask) & OFPPC10_ALL;
+ pm->advertise = netdev_port_features_from_ofp10(opm->advertise);
+ } else if (oh->version == OFP11_VERSION) {
+ const struct ofp11_port_mod *opm = (const struct ofp11_port_mod *) oh;
+ enum ofperr error;
+
+ if (oh->length != htons(sizeof *opm)) {
+ return OFPERR_OFPBRC_BAD_LEN;
+ }
+
+ error = ofputil_port_from_ofp11(opm->port_no, &pm->port_no);
+ if (error) {
+ return error;
+ }
+
+ memcpy(pm->hw_addr, opm->hw_addr, ETH_ADDR_LEN);
+ pm->config = ntohl(opm->config) & OFPPC11_ALL;
+ pm->mask = ntohl(opm->mask) & OFPPC11_ALL;
+ pm->advertise = netdev_port_features_from_ofp11(opm->advertise);
+ } else {
+ return OFPERR_OFPBRC_BAD_VERSION;
+ }
+
+ pm->config &= pm->mask;
+ return 0;
+}
+
+/* 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)
+{
+ uint8_t ofp_version = ofputil_protocol_to_ofp_version(protocol);
+ struct ofpbuf *b;
+
+ if (ofp_version == OFP10_VERSION) {
+ struct ofp10_port_mod *opm;
+
+ opm = make_openflow(sizeof *opm, OFPT10_PORT_MOD, &b);
+ opm->port_no = htons(pm->port_no);
+ memcpy(opm->hw_addr, pm->hw_addr, ETH_ADDR_LEN);
+ opm->config = htonl(pm->config & OFPPC10_ALL);
+ opm->mask = htonl(pm->mask & OFPPC10_ALL);
+ opm->advertise = netdev_port_features_to_ofp10(pm->advertise);
+ } else if (ofp_version == OFP11_VERSION) {
+ struct ofp11_port_mod *opm;
+
+ opm = make_openflow(sizeof *opm, OFPT11_PORT_MOD, &b);
+ opm->port_no = htonl(pm->port_no);
+ memcpy(opm->hw_addr, pm->hw_addr, ETH_ADDR_LEN);
+ opm->config = htonl(pm->config & OFPPC11_ALL);
+ opm->mask = htonl(pm->mask & OFPPC11_ALL);
+ opm->advertise = netdev_port_features_to_ofp11(pm->advertise);
+ } else {
+ NOT_REACHED();
+ }
+
+ return b;
+}
+\f
+/* 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->l2) {
+ msg->l2 = msg->data;
+ ofpbuf_pull(msg, sizeof(struct nicira_stats_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 %zu "
+ "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_NXBRC_FM_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 = ntohs(nfmr->out_port);
+ rq->table_id = nfmr->table_id;
+
+ return nx_pull_match(msg, ntohs(nfmr->match_len), OFP_DEFAULT_PRIORITY,
+ &rq->match, 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) {
+ ofputil_put_stats_header(alloc_xid(), OFPT10_STATS_REQUEST,
+ htons(OFPST_VENDOR),
+ htonl(NXST_FLOW_MONITOR), msg);
+ }
+
+ start_ofs = msg->size;
+ ofpbuf_put_zeros(msg, sizeof *nfmr);
+ match_len = nx_put_match(msg, false, &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(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 cls_rule.
+ *
+ * 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;
+
+ if (!msg->l2) {
+ msg->l2 = msg->data;
+ ofpbuf_pull(msg, sizeof(struct nicira_stats_msg));
+ }
+
+ if (!msg->size) {
+ return EOF;
+ }
+
+ if (msg->size < sizeof(struct nx_flow_update_header)) {
+ goto bad_len;
+ }
+
+ 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;
+
+ error = nx_pull_match(msg, match_len, ntohs(nfuf->priority),
+ update->match, NULL, NULL);
+ if (error) {
+ return error;
+ }
+
+ actions_len = length - sizeof *nfuf - ROUND_UP(match_len, 8);
+ error = ofpacts_pull_openflow10(msg, actions_len, 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_OFPET_BAD_REQUEST;
+ }
+
+bad_len:
+ VLOG_WARN_RL(&bad_ofmsg_rl, "NXST_FLOW_MONITOR reply has %zu "
+ "leftover bytes at end", msg->size);
+ return OFPERR_OFPBRC_BAD_LEN;
+}
+
+uint32_t
+ofputil_decode_flow_monitor_cancel(const struct ofp_header *oh)
+{
+ return ntohl(((const struct nx_flow_monitor_cancel *) oh)->id);
+}
+
+struct ofpbuf *
+ofputil_encode_flow_monitor_cancel(uint32_t id)
+{
+ struct nx_flow_monitor_cancel *nfmc;
+ struct ofpbuf *msg;
+
+ nfmc = make_nxmsg(sizeof *nfmc, NXT_FLOW_MONITOR_CANCEL, &msg);
+ nfmc->id = htonl(id);
+ return msg;
+}
+
+void
+ofputil_start_flow_update(struct list *replies)
+{
+ struct ofpbuf *msg;
+
+ msg = ofpbuf_new(1024);
+ ofputil_put_stats_header(htonl(0), OFPT10_STATS_REPLY,
+ htons(OFPST_VENDOR),
+ htonl(NXST_FLOW_MONITOR), msg);
+
+ list_init(replies);
+ list_push_back(replies, &msg->list_node);
+}
+
+void
+ofputil_append_flow_update(const struct ofputil_flow_update *update,
+ struct list *replies)
+{
+ struct nx_flow_update_header *nfuh;
+ struct ofpbuf *msg;
+ size_t start_ofs;
+
+ msg = ofpbuf_from_list(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, false, update->match,
+ htonll(0), htonll(0));
+ ofpacts_put_openflow10(update->ofpacts, update->ofpacts_len, msg);
+
+ nfuf = ofpbuf_at_assert(msg, start_ofs, sizeof *nfuf);
+ nfuf->reason = htons(update->reason);
+ nfuf->priority = htons(update->match->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);
+
+ ofputil_postappend_stats_reply(start_ofs, replies);
+}
+\f
+struct ofpbuf *
+ofputil_encode_packet_out(const struct ofputil_packet_out *po)
+{
+ struct ofp_packet_out *opo;
+ struct ofpbuf *msg;
+ size_t size;
+
+ size = sizeof *opo + po->ofpacts_len;
+ if (po->buffer_id == UINT32_MAX) {
+ size += po->packet_len;
+ }
+
+ msg = ofpbuf_new(size);
+ put_openflow(sizeof *opo, OFPT_PACKET_OUT, msg);
+ ofpacts_put_openflow10(po->ofpacts, po->ofpacts_len, msg);
+
+ opo = msg->data;
+ opo->buffer_id = htonl(po->buffer_id);
+ opo->in_port = htons(po->in_port);
+ opo->actions_len = htons(msg->size - sizeof *opo);
+
+ if (po->buffer_id == UINT32_MAX) {
+ ofpbuf_put(msg, po->packet, po->packet_len);
+ }
+
+ update_openflow_length(msg);
+
+ return msg;
+}
+
+/* Returns a string representing the message type of 'type'. The string is the
+ * enumeration constant for the type, e.g. "OFPT_HELLO". For statistics
+ * messages, the constant is followed by "request" or "reply",
+ * e.g. "OFPST_AGGREGATE reply". */
+const char *
+ofputil_msg_type_name(const struct ofputil_msg_type *type)
+{
+ return type->name;
+}
+\f
+/* Allocates and stores in '*bufferp' a new ofpbuf with a size of
+ * 'openflow_len', starting with an OpenFlow header with the given 'type' and
+ * an arbitrary transaction id. Allocated bytes beyond the header, if any, are
+ * zeroed.
+ *
+ * The caller is responsible for freeing '*bufferp' when it is no longer
+ * needed.
+ *
+ * The OpenFlow header length is initially set to 'openflow_len'; if the
+ * message is later extended, the length should be updated with
+ * update_openflow_length() before sending.
+ *
+ * Returns the header. */
+void *
+make_openflow(size_t openflow_len, uint8_t type, struct ofpbuf **bufferp)
+{
+ *bufferp = ofpbuf_new(openflow_len);
+ return put_openflow_xid(openflow_len, type, alloc_xid(), *bufferp);
+}
+
+/* Similar to make_openflow() but creates a Nicira vendor extension message
+ * with the specific 'subtype'. 'subtype' should be in host byte order. */
+void *
+make_nxmsg(size_t openflow_len, uint32_t subtype, struct ofpbuf **bufferp)
+{
+ return make_nxmsg_xid(openflow_len, subtype, alloc_xid(), bufferp);
+}
+
+/* Allocates and stores in '*bufferp' a new ofpbuf with a size of
+ * 'openflow_len', starting with an OpenFlow header with the given 'type' and
+ * transaction id 'xid'. Allocated bytes beyond the header, if any, are
+ * zeroed.
+ *
+ * The caller is responsible for freeing '*bufferp' when it is no longer
+ * needed.
+ *
+ * The OpenFlow header length is initially set to 'openflow_len'; if the
+ * message is later extended, the length should be updated with
+ * update_openflow_length() before sending.
+ *
+ * Returns the header. */
+void *
+make_openflow_xid(size_t openflow_len, uint8_t type, ovs_be32 xid,
+ struct ofpbuf **bufferp)
+{
+ *bufferp = ofpbuf_new(openflow_len);
+ return put_openflow_xid(openflow_len, type, xid, *bufferp);
+}
+
+/* Similar to make_openflow_xid() but creates a Nicira vendor extension message
+ * with the specific 'subtype'. 'subtype' should be in host byte order. */
+void *
+make_nxmsg_xid(size_t openflow_len, uint32_t subtype, ovs_be32 xid,
+ struct ofpbuf **bufferp)
+{
+ *bufferp = ofpbuf_new(openflow_len);
+ return put_nxmsg_xid(openflow_len, subtype, xid, *bufferp);
+}
+
+/* Appends 'openflow_len' bytes to 'buffer', starting with an OpenFlow header
+ * with the given 'type' and an arbitrary transaction id. Allocated bytes
+ * beyond the header, if any, are zeroed.
+ *
+ * The OpenFlow header length is initially set to 'openflow_len'; if the
+ * message is later extended, the length should be updated with
+ * update_openflow_length() before sending.
+ *
+ * Returns the header. */
+void *
+put_openflow(size_t openflow_len, uint8_t type, struct ofpbuf *buffer)
+{
+ return put_openflow_xid(openflow_len, type, alloc_xid(), buffer);
+}
+
+/* Appends 'openflow_len' bytes to 'buffer', starting with an OpenFlow header
+ * with the given 'type' and an transaction id 'xid'. Allocated bytes beyond
+ * the header, if any, are zeroed.
+ *
+ * The OpenFlow header length is initially set to 'openflow_len'; if the
+ * message is later extended, the length should be updated with
+ * update_openflow_length() before sending.
+ *
+ * Returns the header. */
+void *
+put_openflow_xid(size_t openflow_len, uint8_t type, ovs_be32 xid,
+ struct ofpbuf *buffer)
+{
+ struct ofp_header *oh;
+
+ assert(openflow_len >= sizeof *oh);
+ assert(openflow_len <= UINT16_MAX);
+
+ oh = ofpbuf_put_uninit(buffer, openflow_len);
+ oh->version = OFP10_VERSION;
+ oh->type = type;
+ oh->length = htons(openflow_len);
+ oh->xid = xid;
+ memset(oh + 1, 0, openflow_len - sizeof *oh);
+ return oh;
+}
+
+/* Similar to put_openflow() but append a Nicira vendor extension message with
+ * the specific 'subtype'. 'subtype' should be in host byte order. */
+void *
+put_nxmsg(size_t openflow_len, uint32_t subtype, struct ofpbuf *buffer)
+{
+ return put_nxmsg_xid(openflow_len, subtype, alloc_xid(), buffer);
+}
+
+/* Similar to put_openflow_xid() but append a Nicira vendor extension message
+ * with the specific 'subtype'. 'subtype' should be in host byte order. */
+void *
+put_nxmsg_xid(size_t openflow_len, uint32_t subtype, ovs_be32 xid,
+ struct ofpbuf *buffer)
+{
+ struct nicira_header *nxh;
+
+ nxh = put_openflow_xid(openflow_len, OFPT_VENDOR, xid, buffer);
+ nxh->vendor = htonl(NX_VENDOR_ID);
+ nxh->subtype = htonl(subtype);
+ return nxh;