+ flow->nw_src = arp->ar_spa;
+ flow->nw_dst = arp->ar_tpa;
+ memcpy(flow->arp_sha, arp->ar_sha, ETH_ADDR_LEN);
+ memcpy(flow->arp_tha, arp->ar_tha, ETH_ADDR_LEN);
+ }
+ }
+}
+
+/* For every bit of a field that is wildcarded in 'wildcards', sets the
+ * corresponding bit in 'flow' to zero. */
+void
+flow_zero_wildcards(struct flow *flow, const struct flow_wildcards *wildcards)
+{
+ uint32_t *flow_u32 = (uint32_t *) flow;
+ const uint32_t *wc_u32 = (const uint32_t *) &wildcards->masks;
+ size_t i;
+
+ for (i = 0; i < FLOW_U32S; i++) {
+ flow_u32[i] &= wc_u32[i];
+ }
+}
+
+/* Initializes 'fmd' with the metadata found in 'flow'. */
+void
+flow_get_metadata(const struct flow *flow, struct flow_metadata *fmd)
+{
+ BUILD_ASSERT_DECL(FLOW_WC_SEQ == 17);
+
+ fmd->tun_id = flow->tunnel.tun_id;
+ fmd->metadata = flow->metadata;
+ memcpy(fmd->regs, flow->regs, sizeof fmd->regs);
+ fmd->in_port = flow->in_port;
+}
+
+char *
+flow_to_string(const struct flow *flow)
+{
+ struct ds ds = DS_EMPTY_INITIALIZER;
+ flow_format(&ds, flow);
+ return ds_cstr(&ds);
+}
+
+void
+flow_format(struct ds *ds, const struct flow *flow)
+{
+ struct match match;
+
+ match_wc_init(&match, flow);
+ match_format(&match, ds, flow->skb_priority);
+}
+
+void
+flow_print(FILE *stream, const struct flow *flow)
+{
+ char *s = flow_to_string(flow);
+ fputs(s, stream);
+ free(s);
+}
+\f
+/* flow_wildcards functions. */
+
+/* Initializes 'wc' as a set of wildcards that matches every packet. */
+void
+flow_wildcards_init_catchall(struct flow_wildcards *wc)
+{
+ memset(&wc->masks, 0, sizeof wc->masks);
+}
+
+/* Initializes 'wc' as an exact-match set of wildcards; that is, 'wc' does not
+ * wildcard any bits or fields. */
+void
+flow_wildcards_init_exact(struct flow_wildcards *wc)
+{
+ memset(&wc->masks, 0xff, sizeof wc->masks);
+}
+
+/* Returns true if 'wc' matches every packet, false if 'wc' fixes any bits or
+ * fields. */
+bool
+flow_wildcards_is_catchall(const struct flow_wildcards *wc)
+{
+ const uint32_t *wc_u32 = (const uint32_t *) &wc->masks;
+ size_t i;
+
+ for (i = 0; i < FLOW_U32S; i++) {
+ if (wc_u32[i]) {
+ return false;
+ }
+ }
+ return true;
+}
+
+/* Initializes 'dst' as the combination of wildcards in 'src1' and 'src2'.
+ * That is, a bit or a field is wildcarded in 'dst' if it is wildcarded in
+ * 'src1' or 'src2' or both. */
+void
+flow_wildcards_combine(struct flow_wildcards *dst,
+ const struct flow_wildcards *src1,
+ const struct flow_wildcards *src2)
+{
+ uint32_t *dst_u32 = (uint32_t *) &dst->masks;
+ const uint32_t *src1_u32 = (const uint32_t *) &src1->masks;
+ const uint32_t *src2_u32 = (const uint32_t *) &src2->masks;
+ size_t i;
+
+ for (i = 0; i < FLOW_U32S; i++) {
+ dst_u32[i] = src1_u32[i] & src2_u32[i];
+ }
+}
+
+/* Returns a hash of the wildcards in 'wc'. */
+uint32_t
+flow_wildcards_hash(const struct flow_wildcards *wc, uint32_t basis)
+{
+ return flow_hash(&wc->masks, basis);;
+}
+
+/* Returns true if 'a' and 'b' represent the same wildcards, false if they are
+ * different. */
+bool
+flow_wildcards_equal(const struct flow_wildcards *a,
+ const struct flow_wildcards *b)
+{
+ return flow_equal(&a->masks, &b->masks);
+}
+
+/* Returns true if at least one bit or field is wildcarded in 'a' but not in
+ * 'b', false otherwise. */
+bool
+flow_wildcards_has_extra(const struct flow_wildcards *a,
+ const struct flow_wildcards *b)
+{
+ const uint32_t *a_u32 = (const uint32_t *) &a->masks;
+ const uint32_t *b_u32 = (const uint32_t *) &b->masks;
+ size_t i;
+
+ for (i = 0; i < FLOW_U32S; i++) {
+ if ((a_u32[i] & b_u32[i]) != b_u32[i]) {
+ return true;
+ }
+ }
+ return false;
+}
+
+/* Returns true if 'a' and 'b' are equal, except that 0-bits (wildcarded bits)
+ * in 'wc' do not need to be equal in 'a' and 'b'. */
+bool
+flow_equal_except(const struct flow *a, const struct flow *b,
+ const struct flow_wildcards *wc)
+{
+ const uint32_t *a_u32 = (const uint32_t *) a;
+ const uint32_t *b_u32 = (const uint32_t *) b;
+ const uint32_t *wc_u32 = (const uint32_t *) &wc->masks;
+ size_t i;
+
+ for (i = 0; i < FLOW_U32S; i++) {
+ if ((a_u32[i] ^ b_u32[i]) & wc_u32[i]) {
+ return false;
+ }
+ }
+ return true;
+}
+
+/* Sets the wildcard mask for register 'idx' in 'wc' to 'mask'.
+ * (A 0-bit indicates a wildcard bit.) */
+void
+flow_wildcards_set_reg_mask(struct flow_wildcards *wc, int idx, uint32_t mask)
+{
+ wc->masks.regs[idx] = mask;
+}
+
+/* Hashes 'flow' based on its L2 through L4 protocol information. */
+uint32_t
+flow_hash_symmetric_l4(const struct flow *flow, uint32_t basis)
+{
+ struct {
+ union {
+ ovs_be32 ipv4_addr;
+ struct in6_addr ipv6_addr;
+ };
+ ovs_be16 eth_type;
+ ovs_be16 vlan_tci;
+ ovs_be16 tp_port;
+ uint8_t eth_addr[ETH_ADDR_LEN];
+ uint8_t ip_proto;
+ } fields;
+
+ int i;
+
+ memset(&fields, 0, sizeof fields);
+ for (i = 0; i < ETH_ADDR_LEN; i++) {
+ fields.eth_addr[i] = flow->dl_src[i] ^ flow->dl_dst[i];
+ }
+ fields.vlan_tci = flow->vlan_tci & htons(VLAN_VID_MASK);
+ fields.eth_type = flow->dl_type;
+
+ /* UDP source and destination port are not taken into account because they
+ * will not necessarily be symmetric in a bidirectional flow. */
+ if (fields.eth_type == htons(ETH_TYPE_IP)) {
+ fields.ipv4_addr = flow->nw_src ^ flow->nw_dst;
+ fields.ip_proto = flow->nw_proto;
+ if (fields.ip_proto == IPPROTO_TCP) {
+ fields.tp_port = flow->tp_src ^ flow->tp_dst;
+ }
+ } else if (fields.eth_type == htons(ETH_TYPE_IPV6)) {
+ const uint8_t *a = &flow->ipv6_src.s6_addr[0];
+ const uint8_t *b = &flow->ipv6_dst.s6_addr[0];
+ uint8_t *ipv6_addr = &fields.ipv6_addr.s6_addr[0];
+
+ for (i=0; i<16; i++) {
+ ipv6_addr[i] = a[i] ^ b[i];
+ }
+ fields.ip_proto = flow->nw_proto;
+ if (fields.ip_proto == IPPROTO_TCP) {
+ fields.tp_port = flow->tp_src ^ flow->tp_dst;
+ }
+ }
+ return hash_bytes(&fields, sizeof fields, basis);
+}
+
+/* Hashes the portions of 'flow' designated by 'fields'. */
+uint32_t
+flow_hash_fields(const struct flow *flow, enum nx_hash_fields fields,
+ uint16_t basis)
+{
+ switch (fields) {
+
+ case NX_HASH_FIELDS_ETH_SRC:
+ return hash_bytes(flow->dl_src, sizeof flow->dl_src, basis);
+
+ case NX_HASH_FIELDS_SYMMETRIC_L4:
+ return flow_hash_symmetric_l4(flow, basis);
+ }
+
+ NOT_REACHED();
+}
+
+/* Returns a string representation of 'fields'. */
+const char *
+flow_hash_fields_to_str(enum nx_hash_fields fields)
+{
+ switch (fields) {
+ case NX_HASH_FIELDS_ETH_SRC: return "eth_src";
+ case NX_HASH_FIELDS_SYMMETRIC_L4: return "symmetric_l4";
+ default: return "<unknown>";
+ }
+}
+
+/* Returns true if the value of 'fields' is supported. Otherwise false. */
+bool
+flow_hash_fields_valid(enum nx_hash_fields fields)
+{
+ return fields == NX_HASH_FIELDS_ETH_SRC
+ || fields == NX_HASH_FIELDS_SYMMETRIC_L4;
+}
+
+/* Sets the VLAN VID that 'flow' matches to 'vid', which is interpreted as an
+ * OpenFlow 1.0 "dl_vlan" value:
+ *
+ * - If it is in the range 0...4095, 'flow->vlan_tci' is set to match
+ * that VLAN. Any existing PCP match is unchanged (it becomes 0 if
+ * 'flow' previously matched packets without a VLAN header).
+ *
+ * - If it is OFP_VLAN_NONE, 'flow->vlan_tci' is set to match a packet
+ * without a VLAN tag.
+ *
+ * - Other values of 'vid' should not be used. */
+void
+flow_set_dl_vlan(struct flow *flow, ovs_be16 vid)
+{
+ if (vid == htons(OFP10_VLAN_NONE)) {
+ flow->vlan_tci = htons(0);
+ } else {
+ vid &= htons(VLAN_VID_MASK);
+ flow->vlan_tci &= ~htons(VLAN_VID_MASK);
+ flow->vlan_tci |= htons(VLAN_CFI) | vid;
+ }
+}
+
+/* Sets the VLAN VID that 'flow' matches to 'vid', which is interpreted as an
+ * OpenFlow 1.2 "vlan_vid" value, that is, the low 13 bits of 'vlan_tci' (VID
+ * plus CFI). */
+void
+flow_set_vlan_vid(struct flow *flow, ovs_be16 vid)
+{
+ ovs_be16 mask = htons(VLAN_VID_MASK | VLAN_CFI);
+ flow->vlan_tci &= ~mask;
+ flow->vlan_tci |= vid & mask;
+}
+
+/* Sets the VLAN PCP that 'flow' matches to 'pcp', which should be in the
+ * range 0...7.
+ *
+ * This function has no effect on the VLAN ID that 'flow' matches.
+ *
+ * After calling this function, 'flow' will not match packets without a VLAN
+ * header. */
+void
+flow_set_vlan_pcp(struct flow *flow, uint8_t pcp)
+{
+ pcp &= 0x07;
+ flow->vlan_tci &= ~htons(VLAN_PCP_MASK);
+ flow->vlan_tci |= htons((pcp << VLAN_PCP_SHIFT) | VLAN_CFI);
+}
+
+/* Puts into 'b' a packet that flow_extract() would parse as having the given
+ * 'flow'.
+ *
+ * (This is useful only for testing, obviously, and the packet isn't really
+ * valid. It hasn't got some checksums filled in, for one, and lots of fields
+ * are just zeroed.) */
+void
+flow_compose(struct ofpbuf *b, const struct flow *flow)
+{
+ eth_compose(b, flow->dl_dst, flow->dl_src, ntohs(flow->dl_type), 0);
+ if (flow->dl_type == htons(FLOW_DL_TYPE_NONE)) {
+ struct eth_header *eth = b->l2;
+ eth->eth_type = htons(b->size);
+ return;
+ }
+
+ if (flow->vlan_tci & htons(VLAN_CFI)) {
+ eth_push_vlan(b, flow->vlan_tci);
+ }
+
+ if (flow->dl_type == htons(ETH_TYPE_IP)) {
+ struct ip_header *ip;
+
+ b->l3 = ip = ofpbuf_put_zeros(b, sizeof *ip);
+ ip->ip_ihl_ver = IP_IHL_VER(5, 4);
+ ip->ip_tos = flow->nw_tos;
+ ip->ip_ttl = flow->nw_ttl;
+ ip->ip_proto = flow->nw_proto;
+ ip->ip_src = flow->nw_src;
+ ip->ip_dst = flow->nw_dst;
+
+ if (flow->nw_frag & FLOW_NW_FRAG_ANY) {
+ ip->ip_frag_off |= htons(IP_MORE_FRAGMENTS);
+ if (flow->nw_frag & FLOW_NW_FRAG_LATER) {
+ ip->ip_frag_off |= htons(100);