+#include "ofp-util.def"
+
+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_match;
+
+ struct flow_wildcards wc;
+
+ /* Figure out what fields may be matched. */
+ if (match->flow.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 (match->flow.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 (match->flow.dl_type == htons(ETH_TYPE_ARP) ||
+ match->flow.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(match->flow.dl_type)) {
+ may_match = MAY_MPLS;
+ } else {
+ may_match = 0;
+ }
+
+ /* Clear the fields that may not be matched. */
+ wc = match->wc;
+ 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)) {
+ memset(wc.masks.arp_sha, 0, ETH_ADDR_LEN);
+ }
+ if (!(may_match & MAY_ARP_THA)) {
+ memset(wc.masks.arp_tha, 0, ETH_ADDR_LEN);
+ }
+ 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, OFP_DEFAULT_PRIORITY) : NULL;
+
+ match->wc = wc;
+ match_zero_wildcarded_fields(match);
+
+ if (log) {
+ char *post = match_to_string(match, 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);
+}
+
+/* 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)
+{
+ char *pos, *key, *value;
+ size_t key_len;
+
+ pos = *stringp;
+ pos += strspn(pos, ", \t\r\n");
+ if (*pos == '\0') {
+ *keyp = *valuep = NULL;
+ return false;
+ }
+
+ key = pos;
+ key_len = strcspn(pos, ":=(, \t\r\n");
+ if (key[key_len] == ':' || key[key_len] == '=') {
+ /* The value can be separated by a colon. */
+ size_t value_len;
+
+ value = key + key_len + 1;
+ value_len = strcspn(value, ", \t\r\n");
+ pos = value + value_len + (value[value_len] != '\0');
+ value[value_len] = '\0';
+ } else if (key[key_len] == '(') {
+ /* The value can be surrounded by balanced parentheses. The outermost
+ * set of parentheses is removed. */
+ int level = 1;
+ size_t value_len;
+
+ value = key + key_len + 1;
+ for (value_len = 0; level > 0; value_len++) {
+ switch (value[value_len]) {
+ case '\0':
+ level = 0;
+ break;
+
+ case '(':
+ level++;
+ break;
+
+ case ')':
+ level--;
+ break;
+ }
+ }
+ value[value_len - 1] = '\0';
+ pos = value + value_len;
+ } else {
+ /* There might be no value at all. */
+ value = key + key_len; /* Will become the empty string below. */
+ pos = key + key_len + (key[key_len] != '\0');
+ }
+ key[key_len] = '\0';
+
+ *stringp = pos;
+ *keyp = key;
+ *valuep = value;
+ return true;
+}
+
+/* Encode a dump ports request for 'port', the encoded message
+ * will be for Open Flow 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:{
+ 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);
+}
+
+
+/* Encode a ports stat for 'ops' and append it to 'replies'. */
+void
+ofputil_append_port_stat(struct list *replies,
+ const struct ofputil_port_stats *ops)
+{
+ struct ofpbuf *msg = ofpbuf_from_list(list_back(replies));
+ struct ofp_header *oh = ofpbuf_data(msg);
+
+ switch ((enum ofp_version)oh->version) {
+ 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:
+ OVS_NOT_REACHED();
+ break;
+
+ default:
+ OVS_NOT_REACHED();
+ }
+}
+
+static enum ofperr
+ofputil_port_stats_from_ofp10(struct ofputil_port_stats *ops,
+ const struct ofp10_port_stats *ps10)
+{
+ memset(ops, 0, sizeof *ops);
+
+ 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;
+
+ memset(ops, 0, sizeof *ops);
+ 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 size_t
+ofputil_get_port_stats_size(enum ofp_version ofp_version)
+{
+ switch (ofp_version) {
+ case OFP10_VERSION:
+ return sizeof(struct ofp10_port_stats);
+ case OFP11_VERSION:
+ case OFP12_VERSION:
+ return sizeof(struct ofp11_port_stats);
+ case OFP13_VERSION:
+ return sizeof(struct ofp13_port_stats);
+ case OFP14_VERSION:
+ OVS_NOT_REACHED();
+ return 0;
+ default:
+ OVS_NOT_REACHED();
+ }
+}
+
+/* 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_use_const(&b, oh, ntohs(oh->length));
+ ofpraw_pull_assert(&b);
+
+ return ofpbuf_size(&b) / ofputil_get_port_stats_size(oh->version);
+}
+
+/* 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;
+
+ error = (msg->frame
+ ? ofpraw_decode(&raw, msg->frame)
+ : ofpraw_pull(&raw, msg));
+ if (error) {
+ return error;
+ }
+
+ if (!ofpbuf_size(msg)) {
+ return EOF;
+ } 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", ofpbuf_size(msg));
+ 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 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;
+ }
+
+ case OFP14_VERSION:
+ OVS_NOT_REACHED();
+ break;
+
+ default:
+ OVS_NOT_REACHED();
+ }
+}
+
+/* Frees all of the "struct ofputil_bucket"s in the 'buckets' list. */
+void
+ofputil_bucket_list_destroy(struct list *buckets)
+{
+ struct ofputil_bucket *bucket, *next_bucket;
+
+ LIST_FOR_EACH_SAFE (bucket, next_bucket, list_node, buckets) {
+ list_remove(&bucket->list_node);
+ free(bucket->ofpacts);
+ free(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: {
+ 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;
+}
+
+/* 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.)
+ *
+ * Group descriptions include the bucket and action configuration for each
+ * group. */
+struct ofpbuf *
+ofputil_encode_group_desc_request(enum ofp_version ofp_version)
+{
+ 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;
+ default:
+ OVS_NOT_REACHED();
+ }
+
+ return request;
+}
+
+static void *
+ofputil_group_stats_to_ofp11(const struct ofputil_group_stats *ogs,
+ size_t base_len, struct list *replies)
+{
+ struct ofp11_bucket_counter *bc11;
+ struct ofp11_group_stats *gs11;
+ size_t length;
+ int i;
+
+ length = base_len + sizeof(struct ofp11_bucket_counter) * ogs->n_buckets;
+
+ gs11 = ofpmp_append(replies, length);
+ memset(gs11, 0, base_len);
+ gs11->length = htons(length);
+ gs11->group_id = htonl(ogs->group_id);
+ gs11->ref_count = htonl(ogs->ref_count);
+ gs11->packet_count = htonll(ogs->packet_count);
+ gs11->byte_count = htonll(ogs->byte_count);
+
+ bc11 = (void *) (((uint8_t *) gs11) + base_len);
+ for (i = 0; i < ogs->n_buckets; i++) {
+ const struct bucket_counter *obc = &ogs->bucket_stats[i];
+
+ bc11[i].packet_count = htonll(obc->packet_count);
+ bc11[i].byte_count = htonll(obc->byte_count);
+ }
+
+ return gs11;
+}
+
+static void
+ofputil_append_of13_group_stats(const struct ofputil_group_stats *ogs,
+ struct list *replies)
+{
+ struct ofp13_group_stats *gs13;
+
+ gs13 = ofputil_group_stats_to_ofp11(ogs, sizeof *gs13, replies);
+ gs13->duration_sec = htonl(ogs->duration_sec);
+ gs13->duration_nsec = htonl(ogs->duration_nsec);
+}
+
+/* Encodes 'ogs' 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 list *replies,
+ const struct ofputil_group_stats *ogs)
+{
+ struct ofpbuf *msg = ofpbuf_from_list(list_back(replies));
+ struct ofp_header *oh = ofpbuf_data(msg);
+
+ switch ((enum ofp_version)oh->version) {
+ case OFP11_VERSION:
+ case OFP12_VERSION:
+ ofputil_group_stats_to_ofp11(ogs, sizeof(struct ofp11_group_stats),
+ replies);
+ break;
+
+ case OFP13_VERSION:
+ ofputil_append_of13_group_stats(ogs, replies);
+ break;
+
+ case OFP14_VERSION:
+ OVS_NOT_REACHED();
+ 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:
+ 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;
+
+ 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);
+ ogf->max_groups[0] = htonl(features->max_groups[0]);
+ ogf->max_groups[1] = htonl(features->max_groups[1]);
+ ogf->max_groups[2] = htonl(features->max_groups[2]);
+ ogf->max_groups[3] = htonl(features->max_groups[3]);
+ ogf->actions[0] = htonl(features->actions[0]);
+ ogf->actions[1] = htonl(features->actions[1]);
+ ogf->actions[2] = htonl(features->actions[2]);
+ ogf->actions[3] = htonl(features->actions[3]);
+
+ 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);
+
+ features->types = ntohl(ogf->types);
+ features->capabilities = ntohl(ogf->capabilities);
+ features->max_groups[0] = ntohl(ogf->max_groups[0]);
+ features->max_groups[1] = ntohl(ogf->max_groups[1]);
+ features->max_groups[2] = ntohl(ogf->max_groups[2]);
+ features->max_groups[3] = ntohl(ogf->max_groups[3]);
+ features->actions[0] = ntohl(ogf->actions[0]);
+ features->actions[1] = ntohl(ogf->actions[1]);
+ features->actions[2] = ntohl(ogf->actions[2]);
+ features->actions[3] = ntohl(ogf->actions[3]);
+}
+
+/* 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->frame
+ ? ofpraw_decode(&raw, msg->frame)
+ : ofpraw_pull(&raw, msg));
+ if (error) {
+ return error;
+ }
+
+ if (!ofpbuf_size(msg)) {
+ 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), ofpbuf_size(msg));
+ 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), ofpbuf_size(msg));
+ 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;
+}
+
+/* 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,
+ struct list *buckets,
+ struct list *replies)
+{
+ struct ofpbuf *reply = ofpbuf_from_list(list_back(replies));
+ struct ofp11_group_desc_stats *ogds;
+ struct ofputil_bucket *bucket;
+ size_t start_ogds;
+ enum ofp_version version = ((struct ofp_header *)ofpbuf_data(reply))->version;
+
+ start_ogds = ofpbuf_size(reply);
+ ofpbuf_put_zeros(reply, sizeof *ogds);
+ LIST_FOR_EACH (bucket, list_node, buckets) {
+ struct ofp11_bucket *ob;
+ size_t start_ob;
+
+ start_ob = ofpbuf_size(reply);
+ ofpbuf_put_zeros(reply, sizeof *ob);
+ ofpacts_put_openflow_actions(bucket->ofpacts, bucket->ofpacts_len,
+ reply, version);
+ ob = ofpbuf_at_assert(reply, start_ob, sizeof *ob);
+ ob->len = htons(ofpbuf_size(reply) - start_ob);
+ ob->weight = htons(bucket->weight);
+ ob->watch_port = ofputil_port_to_ofp11(bucket->watch_port);
+ ob->watch_group = htonl(bucket->watch_group);
+ }
+ ogds = ofpbuf_at_assert(reply, start_ogds, sizeof *ogds);
+ ogds->length = htons(ofpbuf_size(reply) - start_ogds);
+ ogds->type = gds->type;
+ ogds->group_id = htonl(gds->group_id);
+
+ ofpmp_postappend(replies, start_ogds);
+}
+
+static enum ofperr
+ofputil_pull_buckets(struct ofpbuf *msg, size_t buckets_length,
+ enum ofp_version version, struct list *buckets)
+{
+ struct ofp11_bucket *ob;
+
+ 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);
+ }
+
+ 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);
+ 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);
+ return OFPERR_OFPGMFC_BAD_BUCKET;
+ }
+ buckets_length -= ob_len;
+
+ ofpbuf_init(&ofpacts, 0);
+ error = ofpacts_pull_openflow_actions(msg, ob_len - sizeof *ob,
+ version, &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);
+ return OFPERR_OFPGMFC_BAD_WATCH;
+ }
+ bucket->watch_group = ntohl(ob->watch_group);
+ bucket->ofpacts = ofpbuf_steal_data(&ofpacts);
+ bucket->ofpacts_len = ofpbuf_size(&ofpacts);
+ list_push_back(buckets, &bucket->list_node);
+ }
+
+ return 0;
+}
+
+/* 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)
+{
+ struct ofp11_group_desc_stats *ogds;
+ size_t length;
+
+ if (!msg->frame) {
+ ofpraw_pull_assert(msg);
+ }
+
+ if (!ofpbuf_size(msg)) {
+ 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", ofpbuf_size(msg));
+ 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 > ofpbuf_size(msg)) {
+ VLOG_WARN_RL(&bad_ofmsg_rl, "OFPST11_GROUP_DESC reply claims invalid "
+ "length %"PRIuSIZE, length);
+ return OFPERR_OFPBRC_BAD_LEN;