/*
- * Copyright (c) 2011, 2012, 2013, 2014, 2015 Nicira, Inc.
+ * Copyright (c) 2011, 2012, 2013, 2014, 2015, 2016 Nicira, Inc.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
#include <config.h>
-#include "meta-flow.h"
+#include "openvswitch/meta-flow.h"
#include <errno.h>
#include <limits.h>
#include <netinet/ip6.h>
#include "classifier.h"
-#include "dynamic-string.h"
+#include "openvswitch/dynamic-string.h"
#include "nx-match.h"
-#include "ofp-errors.h"
-#include "ofp-util.h"
+#include "openvswitch/ofp-util.h"
#include "ovs-thread.h"
#include "packets.h"
#include "random.h"
#include "tun-metadata.h"
#include "unaligned.h"
#include "util.h"
+#include "openvswitch/ofp-errors.h"
#include "openvswitch/vlog.h"
VLOG_DEFINE_THIS_MODULE(meta_flow);
* controller and so there's not much point in showing a lot of them. */
static struct vlog_rate_limit rl = VLOG_RATE_LIMIT_INIT(1, 5);
+#define MF_VALUE_EXACT_8 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff
+#define MF_VALUE_EXACT_16 MF_VALUE_EXACT_8, MF_VALUE_EXACT_8
+#define MF_VALUE_EXACT_32 MF_VALUE_EXACT_16, MF_VALUE_EXACT_16
+#define MF_VALUE_EXACT_64 MF_VALUE_EXACT_32, MF_VALUE_EXACT_32
+#define MF_VALUE_EXACT_128 MF_VALUE_EXACT_64, MF_VALUE_EXACT_64
+#define MF_VALUE_EXACT_INITIALIZER { .tun_metadata = { MF_VALUE_EXACT_128 } }
+
+const union mf_value exact_match_mask = MF_VALUE_EXACT_INITIALIZER;
+
static void nxm_init(void);
/* Returns the field with the given 'name', or a null pointer if no field has
}
}
+/* Appends a formatted representation of 'sv' to 's'. */
+void
+mf_subvalue_format(const union mf_subvalue *sv, struct ds *s)
+{
+ ds_put_hex(s, sv, sizeof *sv);
+}
+
/* Returns true if 'wc' wildcards all the bits in field 'mf', false if 'wc'
* specifies at least one bit in the field.
*
return !wc->masks.tunnel.ip_src;
case MFF_TUN_DST:
return !wc->masks.tunnel.ip_dst;
+ case MFF_TUN_IPV6_SRC:
+ return ipv6_mask_is_any(&wc->masks.tunnel.ipv6_src);
+ case MFF_TUN_IPV6_DST:
+ return ipv6_mask_is_any(&wc->masks.tunnel.ipv6_dst);
case MFF_TUN_ID:
return !wc->masks.tunnel.tun_id;
case MFF_TUN_TOS:
return !wc->masks.tunnel.gbp_id;
case MFF_TUN_GBP_FLAGS:
return !wc->masks.tunnel.gbp_flags;
- CASE_MFF_TUN_METADATA: {
- union mf_value value;
-
- tun_metadata_read(&wc->masks.tunnel, mf, &value);
- return is_all_zeros(&value.tun_metadata, mf->n_bytes);
- }
+ CASE_MFF_TUN_METADATA:
+ return !ULLONG_GET(wc->masks.tunnel.metadata.present.map,
+ mf->id - MFF_TUN_METADATA0);
case MFF_METADATA:
return !wc->masks.metadata;
case MFF_IN_PORT:
return !wc->masks.skb_priority;
case MFF_PKT_MARK:
return !wc->masks.pkt_mark;
+ case MFF_CT_STATE:
+ return !wc->masks.ct_state;
+ case MFF_CT_ZONE:
+ return !wc->masks.ct_zone;
+ case MFF_CT_MARK:
+ return !wc->masks.ct_mark;
+ case MFF_CT_LABEL:
+ return ovs_u128_is_zero(wc->masks.ct_label);
CASE_MFF_REGS:
return !wc->masks.regs[mf->id - MFF_REG0];
CASE_MFF_XREGS:
return !(wc->masks.mpls_lse[0] & htonl(MPLS_TC_MASK));
case MFF_MPLS_BOS:
return !(wc->masks.mpls_lse[0] & htonl(MPLS_BOS_MASK));
+ case MFF_MPLS_TTL:
+ return !(wc->masks.mpls_lse[0] & htonl(MPLS_TTL_MASK));
case MFF_IPV4_SRC:
return !wc->masks.nw_src;
return is_ip_any(flow) && flow->nw_proto == IPPROTO_SCTP
&& !(flow->nw_frag & FLOW_NW_FRAG_LATER);
case MFP_ICMPV4:
- return is_icmpv4(flow);
+ return is_icmpv4(flow, NULL);
case MFP_ICMPV6:
- return is_icmpv6(flow);
+ return is_icmpv6(flow, NULL);
case MFP_ND:
- return (is_icmpv6(flow)
+ return (is_icmpv6(flow, NULL)
&& flow->tp_dst == htons(0)
&& (flow->tp_src == htons(ND_NEIGHBOR_SOLICIT) ||
flow->tp_src == htons(ND_NEIGHBOR_ADVERT)));
case MFP_ND_SOLICIT:
- return (is_icmpv6(flow)
+ return (is_icmpv6(flow, NULL)
&& flow->tp_dst == htons(0)
&& (flow->tp_src == htons(ND_NEIGHBOR_SOLICIT)));
case MFP_ND_ADVERT:
- return (is_icmpv6(flow)
+ return (is_icmpv6(flow, NULL)
&& flow->tp_dst == htons(0)
&& (flow->tp_src == htons(ND_NEIGHBOR_ADVERT)));
}
/* Set field and it's prerequisities in the mask.
* This is only ever called for writeable 'mf's, but we do not make the
- * distinction here.
- * The widest field this is ever called for an IPv6 address (16 bytes). */
+ * distinction here. */
void
-mf_mask_field_and_prereqs(const struct mf_field *mf, struct flow *mask)
+mf_mask_field_and_prereqs(const struct mf_field *mf, struct flow_wildcards *wc)
{
- static union mf_value exact_match_mask = { .ipv6 = IN6ADDR_EXACT_INIT };
+ mf_mask_field_and_prereqs__(mf, &exact_match_mask, wc);
+}
- mf_set_flow_value(mf, &exact_match_mask, mask);
+void
+mf_mask_field_and_prereqs__(const struct mf_field *mf,
+ const union mf_value *mask,
+ struct flow_wildcards *wc)
+{
+ mf_set_flow_value_masked(mf, &exact_match_mask, mask, &wc->masks);
switch (mf->prereqs) {
case MFP_ND:
case MFP_ND_SOLICIT:
case MFP_ND_ADVERT:
- mask->tp_src = OVS_BE16_MAX;
- mask->tp_dst = OVS_BE16_MAX;
+ WC_MASK_FIELD(wc, tp_src);
+ WC_MASK_FIELD(wc, tp_dst);
/* Fall through. */
case MFP_TCP:
case MFP_UDP:
case MFP_ICMPV4:
case MFP_ICMPV6:
/* nw_frag always unwildcarded. */
- mask->nw_proto = 0xff;
+ WC_MASK_FIELD(wc, nw_proto);
/* Fall through. */
case MFP_ARP:
case MFP_IPV4:
case MFP_IPV6:
case MFP_MPLS:
case MFP_IP_ANY:
- mask->dl_type = OVS_BE16_MAX;
+ /* dl_type always unwildcarded. */
break;
case MFP_VLAN_VID:
- mask->vlan_tci |= htons(VLAN_CFI);
+ WC_MASK_FIELD_MASK(wc, vlan_tci, htons(VLAN_CFI));
break;
case MFP_NONE:
break;
case MFF_TUN_ID:
case MFF_TUN_SRC:
case MFF_TUN_DST:
+ case MFF_TUN_IPV6_SRC:
+ case MFF_TUN_IPV6_DST:
case MFF_TUN_TOS:
case MFF_TUN_TTL:
case MFF_TUN_GBP_ID:
case MFF_IN_PORT:
case MFF_SKB_PRIORITY:
case MFF_PKT_MARK:
+ case MFF_CT_ZONE:
+ case MFF_CT_MARK:
+ case MFF_CT_LABEL:
CASE_MFF_REGS:
CASE_MFF_XREGS:
case MFF_ETH_SRC:
case MFF_ETH_DST:
case MFF_ETH_TYPE:
case MFF_VLAN_TCI:
+ case MFF_MPLS_TTL:
case MFF_IPV4_SRC:
case MFF_IPV4_DST:
case MFF_IPV6_SRC:
case MFF_TUN_FLAGS:
return !(value->be16 & ~htons(FLOW_TNL_PUB_F_MASK));
+ case MFF_CT_STATE:
+ return !(value->be32 & ~htonl(CS_SUPPORTED_MASK));
+
case MFF_N_IDS:
default:
OVS_NOT_REACHED();
case MFF_TUN_DST:
value->be32 = flow->tunnel.ip_dst;
break;
+ case MFF_TUN_IPV6_SRC:
+ value->ipv6 = flow->tunnel.ipv6_src;
+ break;
+ case MFF_TUN_IPV6_DST:
+ value->ipv6 = flow->tunnel.ipv6_dst;
+ break;
case MFF_TUN_FLAGS:
value->be16 = htons(flow->tunnel.flags & FLOW_TNL_PUB_F_MASK);
break;
value->be32 = htonl(flow->pkt_mark);
break;
+ case MFF_CT_STATE:
+ value->be32 = htonl(flow->ct_state);
+ break;
+
+ case MFF_CT_ZONE:
+ value->be16 = htons(flow->ct_zone);
+ break;
+
+ case MFF_CT_MARK:
+ value->be32 = htonl(flow->ct_mark);
+ break;
+
+ case MFF_CT_LABEL:
+ value->be128 = hton128(flow->ct_label);
+ break;
+
CASE_MFF_REGS:
value->be32 = htonl(flow->regs[mf->id - MFF_REG0]);
break;
break;
case MFF_ETH_SRC:
- memcpy(value->mac, flow->dl_src, ETH_ADDR_LEN);
+ value->mac = flow->dl_src;
break;
case MFF_ETH_DST:
- memcpy(value->mac, flow->dl_dst, ETH_ADDR_LEN);
+ value->mac = flow->dl_dst;
break;
case MFF_ETH_TYPE:
value->u8 = mpls_lse_to_bos(flow->mpls_lse[0]);
break;
+ case MFF_MPLS_TTL:
+ value->u8 = mpls_lse_to_ttl(flow->mpls_lse[0]);
+ break;
+
case MFF_IPV4_SRC:
value->be32 = flow->nw_src;
break;
case MFF_ARP_SHA:
case MFF_ND_SLL:
- memcpy(value->mac, flow->arp_sha, ETH_ADDR_LEN);
+ value->mac = flow->arp_sha;
break;
case MFF_ARP_THA:
case MFF_ND_TLL:
- memcpy(value->mac, flow->arp_tha, ETH_ADDR_LEN);
+ value->mac = flow->arp_tha;
break;
case MFF_TCP_SRC:
/* Makes 'match' match field 'mf' exactly, with the value matched taken from
* 'value'. The caller is responsible for ensuring that 'match' meets 'mf''s
- * prerequisites. */
+ * prerequisites.
+ *
+ * If non-NULL, 'err_str' returns a malloc'ed string describing any errors
+ * with the request or NULL if there is no error. The caller is reponsible
+ * for freeing the string. */
void
mf_set_value(const struct mf_field *mf,
- const union mf_value *value, struct match *match)
+ const union mf_value *value, struct match *match, char **err_str)
{
+ if (err_str) {
+ *err_str = NULL;
+ }
+
switch (mf->id) {
case MFF_DP_HASH:
match_set_dp_hash(match, ntohl(value->be32));
case MFF_TUN_DST:
match_set_tun_dst(match, value->be32);
break;
+ case MFF_TUN_IPV6_SRC:
+ match_set_tun_ipv6_src(match, &value->ipv6);
+ break;
+ case MFF_TUN_IPV6_DST:
+ match_set_tun_ipv6_dst(match, &value->ipv6);
+ break;
case MFF_TUN_FLAGS:
match_set_tun_flags(match, ntohs(value->be16));
break;
match_set_tun_ttl(match, value->u8);
break;
CASE_MFF_TUN_METADATA:
- tun_metadata_set_match(mf, value, NULL, match);
+ tun_metadata_set_match(mf, value, NULL, match, err_str);
break;
case MFF_METADATA:
match_set_pkt_mark(match, ntohl(value->be32));
break;
+ case MFF_CT_STATE:
+ match_set_ct_state(match, ntohl(value->be32));
+ break;
+
+ case MFF_CT_ZONE:
+ match_set_ct_zone(match, ntohs(value->be16));
+ break;
+
+ case MFF_CT_MARK:
+ match_set_ct_mark(match, ntohl(value->be32));
+ break;
+
+ case MFF_CT_LABEL:
+ match_set_ct_label(match, ntoh128(value->be128));
+ break;
+
CASE_MFF_REGS:
match_set_reg(match, mf->id - MFF_REG0, ntohl(value->be32));
break;
match_set_mpls_bos(match, 0, value->u8);
break;
+ case MFF_MPLS_TTL:
+ match_set_mpls_ttl(match, 0, value->u8);
+ break;
+
case MFF_IPV4_SRC:
match_set_nw_src(match, value->be32);
break;
void
mf_mask_field(const struct mf_field *mf, struct flow *mask)
{
- union mf_value exact_match_mask;
-
- memset(&exact_match_mask, 0xff, sizeof exact_match_mask);
-
/* For MFF_DL_VLAN, we cannot send a all 1's to flow_set_dl_vlan()
* as that will be considered as OFP10_VLAN_NONE. So consider it as a
* special case. For the rest, calling mf_set_flow_value() is good
/* Returns the effective length of the field. For fixed length fields,
* this is just the defined length. For variable length fields, it is
* the minimum size encoding that retains the same meaning (i.e.
- * discarding leading zeros). */
+ * discarding leading zeros).
+ *
+ * 'is_masked' returns (if non-NULL) whether the original contained
+ * a mask. Otherwise, a mask that is the same length as the value
+ * might be misinterpreted as an exact match. */
int
mf_field_len(const struct mf_field *mf, const union mf_value *value,
- const union mf_value *mask)
+ const union mf_value *mask, bool *is_masked_)
{
int len, mask_len;
+ bool is_masked = mask && !is_all_ones(mask, mf->n_bytes);
len = field_len(mf, value);
- if (mask && !is_all_ones(mask, mf->n_bytes)) {
+ if (is_masked) {
mask_len = field_len(mf, mask);
len = MAX(len, mask_len);
}
+ if (is_masked_) {
+ *is_masked_ = is_masked;
+ }
+
return len;
}
case MFF_TUN_DST:
flow->tunnel.ip_dst = value->be32;
break;
+ case MFF_TUN_IPV6_SRC:
+ flow->tunnel.ipv6_src = value->ipv6;
+ break;
+ case MFF_TUN_IPV6_DST:
+ flow->tunnel.ipv6_dst = value->ipv6;
+ break;
case MFF_TUN_FLAGS:
flow->tunnel.flags = (flow->tunnel.flags & ~FLOW_TNL_PUB_F_MASK) |
ntohs(value->be16);
flow->pkt_mark = ntohl(value->be32);
break;
+ case MFF_CT_STATE:
+ flow->ct_state = ntohl(value->be32);
+ break;
+
+ case MFF_CT_ZONE:
+ flow->ct_zone = ntohs(value->be16);
+ break;
+
+ case MFF_CT_MARK:
+ flow->ct_mark = ntohl(value->be32);
+ break;
+
+ case MFF_CT_LABEL:
+ flow->ct_label = ntoh128(value->be128);
+ break;
+
CASE_MFF_REGS:
flow->regs[mf->id - MFF_REG0] = ntohl(value->be32);
break;
break;
case MFF_ETH_SRC:
- memcpy(flow->dl_src, value->mac, ETH_ADDR_LEN);
+ flow->dl_src = value->mac;
break;
case MFF_ETH_DST:
- memcpy(flow->dl_dst, value->mac, ETH_ADDR_LEN);
+ flow->dl_dst = value->mac;
break;
case MFF_ETH_TYPE:
flow_set_mpls_bos(flow, 0, value->u8);
break;
+ case MFF_MPLS_TTL:
+ flow_set_mpls_ttl(flow, 0, value->u8);
+ break;
+
case MFF_IPV4_SRC:
flow->nw_src = value->be32;
break;
case MFF_ARP_SHA:
case MFF_ND_SLL:
- memcpy(flow->arp_sha, value->mac, ETH_ADDR_LEN);
+ flow->arp_sha = value->mac;
break;
case MFF_ARP_THA:
case MFF_ND_TLL:
- memcpy(flow->arp_tha, value->mac, ETH_ADDR_LEN);
+ flow->arp_tha = value->mac;
break;
case MFF_TCP_SRC:
mf_set_flow_value(field, &tmp, flow);
}
-/* Returns true if 'mf' has a zero value in 'flow', false if it is nonzero.
+bool
+mf_is_tun_metadata(const struct mf_field *mf)
+{
+ return mf->id >= MFF_TUN_METADATA0 &&
+ mf->id < MFF_TUN_METADATA0 + TUN_METADATA_NUM_OPTS;
+}
+
+/* Returns true if 'mf' has previously been set in 'flow', false if
+ * it contains a non-default value.
*
* The caller is responsible for ensuring that 'flow' meets 'mf''s
* prerequisites. */
bool
-mf_is_zero(const struct mf_field *mf, const struct flow *flow)
+mf_is_set(const struct mf_field *mf, const struct flow *flow)
{
- union mf_value value;
+ if (!mf_is_tun_metadata(mf)) {
+ union mf_value value;
- mf_get_value(mf, flow, &value);
- return is_all_zeros(&value, mf->n_bytes);
+ mf_get_value(mf, flow, &value);
+ return !is_all_zeros(&value, mf->n_bytes);
+ } else {
+ return ULLONG_GET(flow->tunnel.metadata.present.map,
+ mf->id - MFF_TUN_METADATA0);
+ }
}
/* Makes 'match' wildcard field 'mf'.
*
* The caller is responsible for ensuring that 'match' meets 'mf''s
- * prerequisites. */
+ * prerequisites.
+ *
+ * If non-NULL, 'err_str' returns a malloc'ed string describing any errors
+ * with the request or NULL if there is no error. The caller is reponsible
+ * for freeing the string. */
void
-mf_set_wild(const struct mf_field *mf, struct match *match)
+mf_set_wild(const struct mf_field *mf, struct match *match, char **err_str)
{
+ if (err_str) {
+ *err_str = NULL;
+ }
+
switch (mf->id) {
case MFF_DP_HASH:
match->flow.dp_hash = 0;
case MFF_TUN_DST:
match_set_tun_dst_masked(match, htonl(0), htonl(0));
break;
+ case MFF_TUN_IPV6_SRC:
+ memset(&match->wc.masks.tunnel.ipv6_src, 0,
+ sizeof match->wc.masks.tunnel.ipv6_src);
+ memset(&match->flow.tunnel.ipv6_src, 0,
+ sizeof match->flow.tunnel.ipv6_src);
+ break;
+ case MFF_TUN_IPV6_DST:
+ memset(&match->wc.masks.tunnel.ipv6_dst, 0,
+ sizeof match->wc.masks.tunnel.ipv6_dst);
+ memset(&match->flow.tunnel.ipv6_dst, 0,
+ sizeof match->flow.tunnel.ipv6_dst);
+ break;
case MFF_TUN_FLAGS:
match_set_tun_flags_masked(match, 0, 0);
break;
match_set_tun_ttl_masked(match, 0, 0);
break;
CASE_MFF_TUN_METADATA:
- tun_metadata_set_match(mf, NULL, NULL, match);
+ tun_metadata_set_match(mf, NULL, NULL, match, err_str);
break;
case MFF_METADATA:
match->wc.masks.pkt_mark = 0;
break;
+ case MFF_CT_STATE:
+ match->flow.ct_state = 0;
+ match->wc.masks.ct_state = 0;
+ break;
+
+ case MFF_CT_ZONE:
+ match->flow.ct_zone = 0;
+ match->wc.masks.ct_zone = 0;
+ break;
+
+ case MFF_CT_MARK:
+ match->flow.ct_mark = 0;
+ match->wc.masks.ct_mark = 0;
+ break;
+
+ case MFF_CT_LABEL:
+ memset(&match->flow.ct_label, 0, sizeof(match->flow.ct_label));
+ memset(&match->wc.masks.ct_label, 0, sizeof(match->wc.masks.ct_label));
+ break;
+
CASE_MFF_REGS:
match_set_reg_masked(match, mf->id - MFF_REG0, 0, 0);
break;
break;
case MFF_ETH_SRC:
- memset(match->flow.dl_src, 0, ETH_ADDR_LEN);
- memset(match->wc.masks.dl_src, 0, ETH_ADDR_LEN);
+ match->flow.dl_src = eth_addr_zero;
+ match->wc.masks.dl_src = eth_addr_zero;
break;
case MFF_ETH_DST:
- memset(match->flow.dl_dst, 0, ETH_ADDR_LEN);
- memset(match->wc.masks.dl_dst, 0, ETH_ADDR_LEN);
+ match->flow.dl_dst = eth_addr_zero;
+ match->wc.masks.dl_dst = eth_addr_zero;
break;
case MFF_ETH_TYPE:
match_set_any_mpls_bos(match, 0);
break;
+ case MFF_MPLS_TTL:
+ match_set_any_mpls_ttl(match, 0);
+ break;
+
case MFF_IPV4_SRC:
case MFF_ARP_SPA:
match_set_nw_src_masked(match, htonl(0), htonl(0));
case MFF_ARP_SHA:
case MFF_ND_SLL:
- memset(match->flow.arp_sha, 0, ETH_ADDR_LEN);
- memset(match->wc.masks.arp_sha, 0, ETH_ADDR_LEN);
+ match->flow.arp_sha = eth_addr_zero;
+ match->wc.masks.arp_sha = eth_addr_zero;
break;
case MFF_ARP_THA:
case MFF_ND_TLL:
- memset(match->flow.arp_tha, 0, ETH_ADDR_LEN);
- memset(match->wc.masks.arp_tha, 0, ETH_ADDR_LEN);
+ match->flow.arp_tha = eth_addr_zero;
+ match->wc.masks.arp_tha = eth_addr_zero;
break;
case MFF_TCP_SRC:
* call is equivalent to mf_set_wild(mf, match).
*
* 'mask' must be a valid mask for 'mf' (see mf_is_mask_valid()). The caller
- * is responsible for ensuring that 'match' meets 'mf''s prerequisites. */
-enum ofputil_protocol
+ * is responsible for ensuring that 'match' meets 'mf''s prerequisites.
+ *
+ * If non-NULL, 'err_str' returns a malloc'ed string describing any errors
+ * with the request or NULL if there is no error. The caller is reponsible
+ * for freeing the string.
+ *
+ * Return a set of enum ofputil_protocol bits (as an uint32_t to avoid circular
+ * dependency on enum ofputil_protocol definition) indicating which OpenFlow
+ * protocol versions can support this functionality. */
+uint32_t
mf_set(const struct mf_field *mf,
const union mf_value *value, const union mf_value *mask,
- struct match *match)
+ struct match *match, char **err_str)
{
if (!mask || is_all_ones(mask, mf->n_bytes)) {
- mf_set_value(mf, value, match);
+ mf_set_value(mf, value, match, err_str);
return mf->usable_protocols_exact;
- } else if (is_all_zeros(mask, mf->n_bytes)) {
- mf_set_wild(mf, match);
+ } else if (is_all_zeros(mask, mf->n_bytes) && !mf_is_tun_metadata(mf)) {
+ /* Tunnel metadata matches on the existence of the field itself, so
+ * it still needs to be encoded even if the value is wildcarded. */
+ mf_set_wild(mf, match, err_str);
return OFPUTIL_P_ANY;
}
+ if (err_str) {
+ *err_str = NULL;
+ }
+
switch (mf->id) {
+ case MFF_CT_ZONE:
case MFF_RECIRC_ID:
case MFF_CONJ_ID:
case MFF_IN_PORT:
case MFF_MPLS_LABEL:
case MFF_MPLS_TC:
case MFF_MPLS_BOS:
+ case MFF_MPLS_TTL:
case MFF_IP_PROTO:
case MFF_IP_TTL:
case MFF_IP_DSCP:
case MFF_TUN_DST:
match_set_tun_dst_masked(match, value->be32, mask->be32);
break;
+ case MFF_TUN_IPV6_SRC:
+ match_set_tun_ipv6_src_masked(match, &value->ipv6, &mask->ipv6);
+ break;
+ case MFF_TUN_IPV6_DST:
+ match_set_tun_ipv6_dst_masked(match, &value->ipv6, &mask->ipv6);
+ break;
case MFF_TUN_FLAGS:
match_set_tun_flags_masked(match, ntohs(value->be16), ntohs(mask->be16));
break;
match_set_tun_tos_masked(match, value->u8, mask->u8);
break;
CASE_MFF_TUN_METADATA:
- tun_metadata_set_match(mf, value, mask, match);
+ tun_metadata_set_match(mf, value, mask, match, err_str);
break;
case MFF_METADATA:
ntohl(mask->be32));
break;
+ case MFF_CT_STATE:
+ match_set_ct_state_masked(match, ntohl(value->be32), ntohl(mask->be32));
+ break;
+
+ case MFF_CT_MARK:
+ match_set_ct_mark_masked(match, ntohl(value->be32), ntohl(mask->be32));
+ break;
+
+ case MFF_CT_LABEL:
+ match_set_ct_label_masked(match, ntoh128(value->be128),
+ mask ? ntoh128(mask->be128) : OVS_U128_MAX);
+ break;
+
case MFF_ETH_DST:
match_set_dl_dst_masked(match, value->mac, mask->mac);
break;
case MFF_IPV6_LABEL:
if ((mask->be32 & htonl(IPV6_LABEL_MASK)) == htonl(IPV6_LABEL_MASK)) {
- mf_set_value(mf, value, match);
+ mf_set_value(mf, value, match, err_str);
} else {
match_set_ipv6_label_masked(match, value->be32, mask->be32);
}
static char *
mf_from_ethernet_string(const struct mf_field *mf, const char *s,
- uint8_t mac[ETH_ADDR_LEN],
- uint8_t mask[ETH_ADDR_LEN])
+ struct eth_addr *mac, struct eth_addr *mask)
{
int n;
ovs_assert(mf->n_bytes == ETH_ADDR_LEN);
n = -1;
- if (ovs_scan(s, ETH_ADDR_SCAN_FMT"%n", ETH_ADDR_SCAN_ARGS(mac), &n)
+ if (ovs_scan(s, ETH_ADDR_SCAN_FMT"%n", ETH_ADDR_SCAN_ARGS(*mac), &n)
&& n == strlen(s)) {
- memset(mask, 0xff, ETH_ADDR_LEN);
+ *mask = eth_addr_exact;
return NULL;
}
n = -1;
if (ovs_scan(s, ETH_ADDR_SCAN_FMT"/"ETH_ADDR_SCAN_FMT"%n",
- ETH_ADDR_SCAN_ARGS(mac), ETH_ADDR_SCAN_ARGS(mask), &n)
+ ETH_ADDR_SCAN_ARGS(*mac), ETH_ADDR_SCAN_ARGS(*mask), &n)
&& n == strlen(s)) {
return NULL;
}
mf_from_ipv4_string(const struct mf_field *mf, const char *s,
ovs_be32 *ip, ovs_be32 *mask)
{
- int prefix;
-
ovs_assert(mf->n_bytes == sizeof *ip);
-
- if (ovs_scan(s, IP_SCAN_FMT"/"IP_SCAN_FMT,
- IP_SCAN_ARGS(ip), IP_SCAN_ARGS(mask))) {
- /* OK. */
- } else if (ovs_scan(s, IP_SCAN_FMT"/%d", IP_SCAN_ARGS(ip), &prefix)) {
- if (prefix <= 0 || prefix > 32) {
- return xasprintf("%s: network prefix bits not between 0 and "
- "32", s);
- }
- *mask = be32_prefix_mask(prefix);
- } else if (ovs_scan(s, IP_SCAN_FMT, IP_SCAN_ARGS(ip))) {
- *mask = OVS_BE32_MAX;
- } else {
- return xasprintf("%s: invalid IP address", s);
- }
- return NULL;
+ return ip_parse_masked(s, ip, mask);
}
static char *
mf_from_ipv6_string(const struct mf_field *mf, const char *s,
- struct in6_addr *value, struct in6_addr *mask)
+ struct in6_addr *ipv6, struct in6_addr *mask)
{
- char *str = xstrdup(s);
- char *save_ptr = NULL;
- const char *name, *netmask;
- int retval;
-
- ovs_assert(mf->n_bytes == sizeof *value);
-
- name = strtok_r(str, "/", &save_ptr);
- retval = name ? lookup_ipv6(name, value) : EINVAL;
- if (retval) {
- char *err;
-
- err = xasprintf("%s: could not convert to IPv6 address", str);
- free(str);
-
- return err;
- }
-
- netmask = strtok_r(NULL, "/", &save_ptr);
- if (netmask) {
- if (inet_pton(AF_INET6, netmask, mask) != 1) {
- int prefix = atoi(netmask);
- if (prefix <= 0 || prefix > 128) {
- free(str);
- return xasprintf("%s: prefix bits not between 1 and 128", s);
- } else {
- *mask = ipv6_create_mask(prefix);
- }
- }
- } else {
- *mask = in6addr_exact;
- }
- free(str);
-
- return NULL;
+ ovs_assert(mf->n_bytes == sizeof *ipv6);
+ return ipv6_parse_masked(s, ipv6, mask);
}
static char *
htons(FLOW_TNL_PUB_F_MASK), maskp);
}
+static char *
+mf_from_ct_state_string(const char *s, ovs_be32 *flagsp, ovs_be32 *maskp)
+{
+ int err;
+ char *err_str;
+ uint32_t flags, mask;
+
+ err = parse_flags(s, ct_state_to_string, '\0', "ct_state", &err_str,
+ &flags, CS_SUPPORTED_MASK, maskp ? &mask : NULL);
+ if (err < 0) {
+ return err_str;
+ }
+
+ *flagsp = htonl(flags);
+ if (maskp) {
+ *maskp = htonl(mask);
+ }
+
+ return NULL;
+}
+
/* Parses 's', a string value for field 'mf', into 'value' and 'mask'. Returns
* NULL if successful, otherwise a malloc()'d string describing the error. */
char *
(uint8_t *) value, (uint8_t *) mask);
break;
+ case MFS_CT_STATE:
+ ovs_assert(mf->n_bytes == sizeof(ovs_be32));
+ error = mf_from_ct_state_string(s, &value->be32, &mask->be32);
+ break;
+
case MFS_ETHERNET:
- error = mf_from_ethernet_string(mf, s, value->mac, mask->mac);
+ error = mf_from_ethernet_string(mf, s, &value->mac, &mask->mac);
break;
case MFS_IPV4:
TCP_FLAGS(mask), TCP_FLAGS(OVS_BE16_MAX));
}
+static void
+mf_format_ct_state_string(ovs_be32 value, ovs_be32 mask, struct ds *s)
+{
+ format_flags_masked(s, NULL, ct_state_to_string, ntohl(value),
+ ntohl(mask), UINT16_MAX);
+}
+
/* Appends to 's' a string representation of field 'mf' whose value is in
* 'value' and 'mask'. 'mask' may be NULL to indicate an exact match. */
void
mf_format_integer_string(mf, (uint8_t *) value, (uint8_t *) mask, s);
break;
+ case MFS_CT_STATE:
+ mf_format_ct_state_string(value->be32,
+ mask ? mask->be32 : OVS_BE32_MAX, s);
+ break;
+
case MFS_ETHERNET:
- eth_format_masked(value->mac, mask->mac, s);
+ eth_format_masked(value->mac, mask ? &mask->mac : NULL, s);
break;
case MFS_IPV4:
break;
case MFS_IPV6:
- print_ipv6_masked(s, &value->ipv6, mask ? &mask->ipv6 : NULL);
+ ipv6_format_masked(&value->ipv6, mask ? &mask->ipv6 : NULL, s);
break;
case MFS_FRAG:
mf_get(field, match, &value, &mask);
bitwise_copy(x, sizeof *x, 0, &value, field->n_bytes, sf->ofs, sf->n_bits);
bitwise_one ( &mask, field->n_bytes, sf->ofs, sf->n_bits);
- mf_set(field, &value, &mask, match);
+ mf_set(field, &value, &mask, match, NULL);
}
/* 'v' and 'm' correspond to values of 'field'. This function copies them into
mf_get(field, match, &value, &mask);
bitwise_copy(v, sizeof *v, 0, &value, field->n_bytes, 0, field->n_bits);
bitwise_copy(m, sizeof *m, 0, &mask, field->n_bytes, 0, field->n_bits);
- mf_set(field, &value, &mask, match);
+ mf_set(field, &value, &mask, match, NULL);
}
/* Initializes 'x' to the value of 'sf' within 'flow'. 'sf' must be valid for
projects / cascardo / ovs.git / blobdiff