/* The set of characters that may separate one action or one key attribute
* from another. */
static const char *delimiters = ", \t\r\n";
+static const char *delimiters_end = ", \t\r\n)";
struct attr_len_tbl {
int len;
static struct nlattr *generate_all_wildcard_mask(const struct attr_len_tbl tbl[],
int max, struct ofpbuf *,
const struct nlattr *key);
+static void format_u128(struct ds *ds, const ovs_u128 *value,
+ const ovs_u128 *mask, bool verbose);
+static int scan_u128(const char *s, ovs_u128 *value, ovs_u128 *mask);
+
/* Returns one the following for the action with the given OVS_ACTION_ATTR_*
* 'type':
*
case OVS_ACTION_ATTR_SET: return ATTR_LEN_VARIABLE;
case OVS_ACTION_ATTR_SET_MASKED: return ATTR_LEN_VARIABLE;
case OVS_ACTION_ATTR_SAMPLE: return ATTR_LEN_VARIABLE;
+ case OVS_ACTION_ATTR_CT: return ATTR_LEN_VARIABLE;
case OVS_ACTION_ATTR_UNSPEC:
case __OVS_ACTION_ATTR_MAX:
case OVS_KEY_ATTR_ENCAP: return "encap";
case OVS_KEY_ATTR_PRIORITY: return "skb_priority";
case OVS_KEY_ATTR_SKB_MARK: return "skb_mark";
+ case OVS_KEY_ATTR_CT_STATE: return "ct_state";
+ case OVS_KEY_ATTR_CT_ZONE: return "ct_zone";
+ case OVS_KEY_ATTR_CT_MARK: return "ct_mark";
+ case OVS_KEY_ATTR_CT_LABELS: return "ct_label";
case OVS_KEY_ATTR_TUNNEL: return "tunnel";
case OVS_KEY_ATTR_IN_PORT: return "in_port";
case OVS_KEY_ATTR_ETHERNET: return "eth";
ds_put_format(ds, ",out_port(%"PRIu32"))", data->out_port);
}
+static const struct nl_policy ovs_nat_policy[] = {
+ [OVS_NAT_ATTR_SRC] = { .type = NL_A_FLAG, .optional = true, },
+ [OVS_NAT_ATTR_DST] = { .type = NL_A_FLAG, .optional = true, },
+ [OVS_NAT_ATTR_IP_MIN] = { .type = NL_A_UNSPEC, .optional = true,
+ .min_len = sizeof(struct in_addr),
+ .max_len = sizeof(struct in6_addr)},
+ [OVS_NAT_ATTR_IP_MAX] = { .type = NL_A_UNSPEC, .optional = true,
+ .min_len = sizeof(struct in_addr),
+ .max_len = sizeof(struct in6_addr)},
+ [OVS_NAT_ATTR_PROTO_MIN] = { .type = NL_A_U16, .optional = true, },
+ [OVS_NAT_ATTR_PROTO_MAX] = { .type = NL_A_U16, .optional = true, },
+ [OVS_NAT_ATTR_PERSISTENT] = { .type = NL_A_FLAG, .optional = true, },
+ [OVS_NAT_ATTR_PROTO_HASH] = { .type = NL_A_FLAG, .optional = true, },
+ [OVS_NAT_ATTR_PROTO_RANDOM] = { .type = NL_A_FLAG, .optional = true, },
+};
+
+static void
+format_odp_ct_nat(struct ds *ds, const struct nlattr *attr)
+{
+ struct nlattr *a[ARRAY_SIZE(ovs_nat_policy)];
+ size_t addr_len;
+ ovs_be32 ip_min, ip_max;
+ struct in6_addr ip6_min, ip6_max;
+ uint16_t proto_min, proto_max;
+
+ if (!nl_parse_nested(attr, ovs_nat_policy, a, ARRAY_SIZE(a))) {
+ ds_put_cstr(ds, "nat(error: nl_parse_nested() failed.)");
+ return;
+ }
+ /* If no type, then nothing else either. */
+ if (!(a[OVS_NAT_ATTR_SRC] || a[OVS_NAT_ATTR_DST])
+ && (a[OVS_NAT_ATTR_IP_MIN] || a[OVS_NAT_ATTR_IP_MAX]
+ || a[OVS_NAT_ATTR_PROTO_MIN] || a[OVS_NAT_ATTR_PROTO_MAX]
+ || a[OVS_NAT_ATTR_PERSISTENT] || a[OVS_NAT_ATTR_PROTO_HASH]
+ || a[OVS_NAT_ATTR_PROTO_RANDOM])) {
+ ds_put_cstr(ds, "nat(error: options allowed only with \"src\" or \"dst\")");
+ return;
+ }
+ /* Both SNAT & DNAT may not be specified. */
+ if (a[OVS_NAT_ATTR_SRC] && a[OVS_NAT_ATTR_DST]) {
+ ds_put_cstr(ds, "nat(error: Only one of \"src\" or \"dst\" may be present.)");
+ return;
+ }
+ /* proto may not appear without ip. */
+ if (!a[OVS_NAT_ATTR_IP_MIN] && a[OVS_NAT_ATTR_PROTO_MIN]) {
+ ds_put_cstr(ds, "nat(error: proto but no IP.)");
+ return;
+ }
+ /* MAX may not appear without MIN. */
+ if ((!a[OVS_NAT_ATTR_IP_MIN] && a[OVS_NAT_ATTR_IP_MAX])
+ || (!a[OVS_NAT_ATTR_PROTO_MIN] && a[OVS_NAT_ATTR_PROTO_MAX])) {
+ ds_put_cstr(ds, "nat(error: range max without min.)");
+ return;
+ }
+ /* Address sizes must match. */
+ if ((a[OVS_NAT_ATTR_IP_MIN]
+ && (nl_attr_get_size(a[OVS_NAT_ATTR_IP_MIN]) != sizeof(ovs_be32) &&
+ nl_attr_get_size(a[OVS_NAT_ATTR_IP_MIN]) != sizeof(struct in6_addr)))
+ || (a[OVS_NAT_ATTR_IP_MIN] && a[OVS_NAT_ATTR_IP_MAX]
+ && (nl_attr_get_size(a[OVS_NAT_ATTR_IP_MIN])
+ != nl_attr_get_size(a[OVS_NAT_ATTR_IP_MAX])))) {
+ ds_put_cstr(ds, "nat(error: IP address sizes do not match)");
+ return;
+ }
+
+ addr_len = a[OVS_NAT_ATTR_IP_MIN]
+ ? nl_attr_get_size(a[OVS_NAT_ATTR_IP_MIN]) : 0;
+ ip_min = addr_len == sizeof(ovs_be32) && a[OVS_NAT_ATTR_IP_MIN]
+ ? nl_attr_get_be32(a[OVS_NAT_ATTR_IP_MIN]) : 0;
+ ip_max = addr_len == sizeof(ovs_be32) && a[OVS_NAT_ATTR_IP_MAX]
+ ? nl_attr_get_be32(a[OVS_NAT_ATTR_IP_MAX]) : 0;
+ if (addr_len == sizeof ip6_min) {
+ ip6_min = a[OVS_NAT_ATTR_IP_MIN]
+ ? *(struct in6_addr *)nl_attr_get(a[OVS_NAT_ATTR_IP_MIN])
+ : in6addr_any;
+ ip6_max = a[OVS_NAT_ATTR_IP_MAX]
+ ? *(struct in6_addr *)nl_attr_get(a[OVS_NAT_ATTR_IP_MAX])
+ : in6addr_any;
+ }
+ proto_min = a[OVS_NAT_ATTR_PROTO_MIN]
+ ? nl_attr_get_u16(a[OVS_NAT_ATTR_PROTO_MIN]) : 0;
+ proto_max = a[OVS_NAT_ATTR_PROTO_MAX]
+ ? nl_attr_get_u16(a[OVS_NAT_ATTR_PROTO_MAX]) : 0;
+
+ if ((addr_len == sizeof(ovs_be32)
+ && ip_max && ntohl(ip_min) > ntohl(ip_max))
+ || (addr_len == sizeof(struct in6_addr)
+ && !ipv6_mask_is_any(&ip6_max)
+ && memcmp(&ip6_min, &ip6_max, sizeof ip6_min) > 0)
+ || (proto_max && proto_min > proto_max)) {
+ ds_put_cstr(ds, "nat(range error)");
+ return;
+ }
+
+ ds_put_cstr(ds, "nat");
+ if (a[OVS_NAT_ATTR_SRC] || a[OVS_NAT_ATTR_DST]) {
+ ds_put_char(ds, '(');
+ if (a[OVS_NAT_ATTR_SRC]) {
+ ds_put_cstr(ds, "src");
+ } else if (a[OVS_NAT_ATTR_DST]) {
+ ds_put_cstr(ds, "dst");
+ }
+
+ if (addr_len > 0) {
+ ds_put_cstr(ds, "=");
+
+ if (addr_len == sizeof ip_min) {
+ ds_put_format(ds, IP_FMT, IP_ARGS(ip_min));
+
+ if (ip_max && ip_max != ip_min) {
+ ds_put_format(ds, "-"IP_FMT, IP_ARGS(ip_max));
+ }
+ } else if (addr_len == sizeof ip6_min) {
+ ipv6_format_addr_bracket(&ip6_min, ds, proto_min);
+
+ if (!ipv6_mask_is_any(&ip6_max) &&
+ memcmp(&ip6_max, &ip6_min, sizeof ip6_max) != 0) {
+ ds_put_char(ds, '-');
+ ipv6_format_addr_bracket(&ip6_max, ds, proto_min);
+ }
+ }
+ if (proto_min) {
+ ds_put_format(ds, ":%"PRIu16, proto_min);
+
+ if (proto_max && proto_max != proto_min) {
+ ds_put_format(ds, "-%"PRIu16, proto_max);
+ }
+ }
+ }
+ ds_put_char(ds, ',');
+ if (a[OVS_NAT_ATTR_PERSISTENT]) {
+ ds_put_cstr(ds, "persistent,");
+ }
+ if (a[OVS_NAT_ATTR_PROTO_HASH]) {
+ ds_put_cstr(ds, "hash,");
+ }
+ if (a[OVS_NAT_ATTR_PROTO_RANDOM]) {
+ ds_put_cstr(ds, "random,");
+ }
+ ds_chomp(ds, ',');
+ ds_put_char(ds, ')');
+ }
+}
+
+static const struct nl_policy ovs_conntrack_policy[] = {
+ [OVS_CT_ATTR_COMMIT] = { .type = NL_A_FLAG, .optional = true, },
+ [OVS_CT_ATTR_ZONE] = { .type = NL_A_U16, .optional = true, },
+ [OVS_CT_ATTR_MARK] = { .type = NL_A_UNSPEC, .optional = true,
+ .min_len = sizeof(uint32_t) * 2 },
+ [OVS_CT_ATTR_LABELS] = { .type = NL_A_UNSPEC, .optional = true,
+ .min_len = sizeof(struct ovs_key_ct_labels) * 2 },
+ [OVS_CT_ATTR_HELPER] = { .type = NL_A_STRING, .optional = true,
+ .min_len = 1, .max_len = 16 },
+ [OVS_CT_ATTR_NAT] = { .type = NL_A_UNSPEC, .optional = true },
+};
+
+static void
+format_odp_conntrack_action(struct ds *ds, const struct nlattr *attr)
+{
+ struct nlattr *a[ARRAY_SIZE(ovs_conntrack_policy)];
+ const ovs_u128 *label;
+ const uint32_t *mark;
+ const char *helper;
+ uint16_t zone;
+ bool commit;
+ const struct nlattr *nat;
+
+ if (!nl_parse_nested(attr, ovs_conntrack_policy, a, ARRAY_SIZE(a))) {
+ ds_put_cstr(ds, "ct(error)");
+ return;
+ }
+
+ commit = a[OVS_CT_ATTR_COMMIT] ? true : false;
+ zone = a[OVS_CT_ATTR_ZONE] ? nl_attr_get_u16(a[OVS_CT_ATTR_ZONE]) : 0;
+ mark = a[OVS_CT_ATTR_MARK] ? nl_attr_get(a[OVS_CT_ATTR_MARK]) : NULL;
+ label = a[OVS_CT_ATTR_LABELS] ? nl_attr_get(a[OVS_CT_ATTR_LABELS]): NULL;
+ helper = a[OVS_CT_ATTR_HELPER] ? nl_attr_get(a[OVS_CT_ATTR_HELPER]) : NULL;
+ nat = a[OVS_CT_ATTR_NAT];
+
+ ds_put_format(ds, "ct");
+ if (commit || zone || mark || label || helper || nat) {
+ ds_put_cstr(ds, "(");
+ if (commit) {
+ ds_put_format(ds, "commit,");
+ }
+ if (zone) {
+ ds_put_format(ds, "zone=%"PRIu16",", zone);
+ }
+ if (mark) {
+ ds_put_format(ds, "mark=%#"PRIx32"/%#"PRIx32",", *mark,
+ *(mark + 1));
+ }
+ if (label) {
+ ds_put_format(ds, "label=");
+ format_u128(ds, label, label + 1, true);
+ ds_put_char(ds, ',');
+ }
+ if (helper) {
+ ds_put_format(ds, "helper=%s,", helper);
+ }
+ if (nat) {
+ format_odp_ct_nat(ds, nat);
+ }
+ ds_chomp(ds, ',');
+ ds_put_cstr(ds, ")");
+ }
+}
+
static void
format_odp_action(struct ds *ds, const struct nlattr *a)
{
case OVS_ACTION_ATTR_SAMPLE:
format_odp_sample_action(ds, a);
break;
+ case OVS_ACTION_ATTR_CT:
+ format_odp_conntrack_action(ds, a);
+ break;
case OVS_ACTION_ATTR_UNSPEC:
case __OVS_ACTION_ATTR_MAX:
default:
l4 = ((uint8_t *) l3 + sizeof (struct ip_header));
ip = (struct ip_header *) l3;
if (!ovs_scan_len(s, &n, "header(size=%"SCNi32",type=%"SCNi32","
- "eth(dst="ETH_ADDR_SCAN_FMT",",
- &data->header_len,
- &data->tnl_type,
- ETH_ADDR_SCAN_ARGS(eth->eth_dst))) {
+ "eth(dst="ETH_ADDR_SCAN_FMT",",
+ &data->header_len,
+ &data->tnl_type,
+ ETH_ADDR_SCAN_ARGS(eth->eth_dst))) {
return -EINVAL;
}
if (!ovs_scan_len(s, &n, "src="ETH_ADDR_SCAN_FMT",",
- ETH_ADDR_SCAN_ARGS(eth->eth_src))) {
+ ETH_ADDR_SCAN_ARGS(eth->eth_src))) {
return -EINVAL;
}
if (!ovs_scan_len(s, &n, "dl_type=0x%"SCNx16"),", &dl_type)) {
/* IPv4 */
if (!ovs_scan_len(s, &n, "ipv4(src="IP_SCAN_FMT",dst="IP_SCAN_FMT",proto=%"SCNi8
- ",tos=%"SCNi8",ttl=%"SCNi8",frag=0x%"SCNx16"),",
- IP_SCAN_ARGS(&sip),
- IP_SCAN_ARGS(&dip),
- &ip->ip_proto, &ip->ip_tos,
- &ip->ip_ttl, &ip->ip_frag_off)) {
+ ",tos=%"SCNi8",ttl=%"SCNi8",frag=0x%"SCNx16"),",
+ IP_SCAN_ARGS(&sip),
+ IP_SCAN_ARGS(&dip),
+ &ip->ip_proto, &ip->ip_tos,
+ &ip->ip_ttl, &ip->ip_frag_off)) {
return -EINVAL;
}
put_16aligned_be32(&ip->ip_src, sip);
udp = (struct udp_header *) l4;
greh = (struct gre_base_hdr *) l4;
if (ovs_scan_len(s, &n, "udp(src=%"SCNi16",dst=%"SCNi16",csum=0x%"SCNx16"),",
- &udp_src, &udp_dst, &csum)) {
+ &udp_src, &udp_dst, &csum)) {
uint32_t vx_flags, vni;
udp->udp_src = htons(udp_src);
udp->udp_csum = htons(csum);
if (ovs_scan_len(s, &n, "vxlan(flags=0x%"SCNx32",vni=0x%"SCNx32"))",
- &vx_flags, &vni)) {
+ &vx_flags, &vni)) {
struct vxlanhdr *vxh = (struct vxlanhdr *) (udp + 1);
put_16aligned_be32(&vxh->vx_flags, htonl(vx_flags));
return -EINVAL;
}
} else if (ovs_scan_len(s, &n, "gre((flags=0x%"SCNx16",proto=0x%"SCNx16")",
- &gre_flags, &gre_proto)){
+ &gre_flags, &gre_proto)){
tnl_type = OVS_VPORT_TYPE_GRE;
greh->flags = htons(gre_flags);
return n;
}
+struct ct_nat_params {
+ bool snat;
+ bool dnat;
+ size_t addr_len;
+ union {
+ ovs_be32 ip;
+ struct in6_addr ip6;
+ } addr_min;
+ union {
+ ovs_be32 ip;
+ struct in6_addr ip6;
+ } addr_max;
+ uint16_t proto_min;
+ uint16_t proto_max;
+ bool persistent;
+ bool proto_hash;
+ bool proto_random;
+};
+
+static int
+scan_ct_nat_range(const char *s, int *n, struct ct_nat_params *p)
+{
+ if (ovs_scan_len(s, n, "=")) {
+ char ipv6_s[IPV6_SCAN_LEN + 1];
+ struct in6_addr ipv6;
+
+ if (ovs_scan_len(s, n, IP_SCAN_FMT, IP_SCAN_ARGS(&p->addr_min.ip))) {
+ p->addr_len = sizeof p->addr_min.ip;
+ if (ovs_scan_len(s, n, "-")) {
+ if (!ovs_scan_len(s, n, IP_SCAN_FMT,
+ IP_SCAN_ARGS(&p->addr_max.ip))) {
+ return -EINVAL;
+ }
+ }
+ } else if ((ovs_scan_len(s, n, IPV6_SCAN_FMT, ipv6_s)
+ || ovs_scan_len(s, n, "["IPV6_SCAN_FMT"]", ipv6_s))
+ && inet_pton(AF_INET6, ipv6_s, &ipv6) == 1) {
+ p->addr_len = sizeof p->addr_min.ip6;
+ p->addr_min.ip6 = ipv6;
+ if (ovs_scan_len(s, n, "-")) {
+ if ((ovs_scan_len(s, n, IPV6_SCAN_FMT, ipv6_s)
+ || ovs_scan_len(s, n, "["IPV6_SCAN_FMT"]", ipv6_s))
+ && inet_pton(AF_INET6, ipv6_s, &ipv6) == 1) {
+ p->addr_max.ip6 = ipv6;
+ } else {
+ return -EINVAL;
+ }
+ }
+ } else {
+ return -EINVAL;
+ }
+ if (ovs_scan_len(s, n, ":%"SCNu16, &p->proto_min)) {
+ if (ovs_scan_len(s, n, "-")) {
+ if (!ovs_scan_len(s, n, "%"SCNu16, &p->proto_max)) {
+ return -EINVAL;
+ }
+ }
+ }
+ }
+ return 0;
+}
+
+static int
+scan_ct_nat(const char *s, struct ct_nat_params *p)
+{
+ int n = 0;
+
+ if (ovs_scan_len(s, &n, "nat")) {
+ memset(p, 0, sizeof *p);
+
+ if (ovs_scan_len(s, &n, "(")) {
+ char *end;
+ int end_n;
+
+ end = strchr(s + n, ')');
+ if (!end) {
+ return -EINVAL;
+ }
+ end_n = end - s;
+
+ while (n < end_n) {
+ n += strspn(s + n, delimiters);
+ if (ovs_scan_len(s, &n, "src")) {
+ int err = scan_ct_nat_range(s, &n, p);
+ if (err) {
+ return err;
+ }
+ p->snat = true;
+ continue;
+ }
+ if (ovs_scan_len(s, &n, "dst")) {
+ int err = scan_ct_nat_range(s, &n, p);
+ if (err) {
+ return err;
+ }
+ p->dnat = true;
+ continue;
+ }
+ if (ovs_scan_len(s, &n, "persistent")) {
+ p->persistent = true;
+ continue;
+ }
+ if (ovs_scan_len(s, &n, "hash")) {
+ p->proto_hash = true;
+ continue;
+ }
+ if (ovs_scan_len(s, &n, "random")) {
+ p->proto_random = true;
+ continue;
+ }
+ return -EINVAL;
+ }
+
+ if (p->snat && p->dnat) {
+ return -EINVAL;
+ }
+ if ((p->addr_len != 0 &&
+ memcmp(&p->addr_max, &in6addr_any, p->addr_len) &&
+ memcmp(&p->addr_max, &p->addr_min, p->addr_len) < 0) ||
+ (p->proto_max && p->proto_max < p->proto_min)) {
+ return -EINVAL;
+ }
+ if (p->proto_hash && p->proto_random) {
+ return -EINVAL;
+ }
+ n++;
+ }
+ }
+ return n;
+}
+
+static void
+nl_msg_put_ct_nat(struct ct_nat_params *p, struct ofpbuf *actions)
+{
+ size_t start = nl_msg_start_nested(actions, OVS_CT_ATTR_NAT);
+
+ if (p->snat) {
+ nl_msg_put_flag(actions, OVS_NAT_ATTR_SRC);
+ } else if (p->dnat) {
+ nl_msg_put_flag(actions, OVS_NAT_ATTR_DST);
+ } else {
+ goto out;
+ }
+ if (p->addr_len != 0) {
+ nl_msg_put_unspec(actions, OVS_NAT_ATTR_IP_MIN, &p->addr_min,
+ p->addr_len);
+ if (memcmp(&p->addr_max, &p->addr_min, p->addr_len) > 0) {
+ nl_msg_put_unspec(actions, OVS_NAT_ATTR_IP_MAX, &p->addr_max,
+ p->addr_len);
+ }
+ if (p->proto_min) {
+ nl_msg_put_u16(actions, OVS_NAT_ATTR_PROTO_MIN, p->proto_min);
+ if (p->proto_max && p->proto_max > p->proto_min) {
+ nl_msg_put_u16(actions, OVS_NAT_ATTR_PROTO_MAX, p->proto_max);
+ }
+ }
+ if (p->persistent) {
+ nl_msg_put_flag(actions, OVS_NAT_ATTR_PERSISTENT);
+ }
+ if (p->proto_hash) {
+ nl_msg_put_flag(actions, OVS_NAT_ATTR_PROTO_HASH);
+ }
+ if (p->proto_random) {
+ nl_msg_put_flag(actions, OVS_NAT_ATTR_PROTO_RANDOM);
+ }
+ }
+out:
+ nl_msg_end_nested(actions, start);
+}
+
+static int
+parse_conntrack_action(const char *s_, struct ofpbuf *actions)
+{
+ const char *s = s_;
+
+ if (ovs_scan(s, "ct")) {
+ const char *helper = NULL;
+ size_t helper_len = 0;
+ bool commit = false;
+ uint16_t zone = 0;
+ struct {
+ uint32_t value;
+ uint32_t mask;
+ } ct_mark = { 0, 0 };
+ struct {
+ ovs_u128 value;
+ ovs_u128 mask;
+ } ct_label;
+ struct ct_nat_params nat_params;
+ bool have_nat = false;
+ size_t start;
+ char *end;
+
+ memset(&ct_label, 0, sizeof(ct_label));
+
+ s += 2;
+ if (ovs_scan(s, "(")) {
+ s++;
+find_end:
+ end = strchr(s, ')');
+ if (!end) {
+ return -EINVAL;
+ }
+
+ while (s != end) {
+ int n;
+
+ s += strspn(s, delimiters);
+ if (ovs_scan(s, "commit%n", &n)) {
+ commit = true;
+ s += n;
+ continue;
+ }
+ if (ovs_scan(s, "zone=%"SCNu16"%n", &zone, &n)) {
+ s += n;
+ continue;
+ }
+ if (ovs_scan(s, "mark=%"SCNx32"%n", &ct_mark.value, &n)) {
+ s += n;
+ n = -1;
+ if (ovs_scan(s, "/%"SCNx32"%n", &ct_mark.mask, &n)) {
+ s += n;
+ } else {
+ ct_mark.mask = UINT32_MAX;
+ }
+ continue;
+ }
+ if (ovs_scan(s, "label=%n", &n)) {
+ int retval;
+
+ s += n;
+ retval = scan_u128(s, &ct_label.value, &ct_label.mask);
+ if (retval < 0) {
+ return retval;
+ }
+ s += retval;
+ continue;
+ }
+ if (ovs_scan(s, "helper=%n", &n)) {
+ s += n;
+ helper_len = strcspn(s, delimiters_end);
+ if (!helper_len || helper_len > 15) {
+ return -EINVAL;
+ }
+ helper = s;
+ s += helper_len;
+ continue;
+ }
+
+ n = scan_ct_nat(s, &nat_params);
+ if (n > 0) {
+ s += n;
+ have_nat = true;
+
+ /* end points to the end of the nested, nat action.
+ * find the real end. */
+ goto find_end;
+ }
+ /* Nothing matched. */
+ return -EINVAL;
+ }
+ s++;
+ }
+
+ start = nl_msg_start_nested(actions, OVS_ACTION_ATTR_CT);
+ if (commit) {
+ nl_msg_put_flag(actions, OVS_CT_ATTR_COMMIT);
+ }
+ if (zone) {
+ nl_msg_put_u16(actions, OVS_CT_ATTR_ZONE, zone);
+ }
+ if (ct_mark.mask) {
+ nl_msg_put_unspec(actions, OVS_CT_ATTR_MARK, &ct_mark,
+ sizeof(ct_mark));
+ }
+ if (!ovs_u128_is_zero(&ct_label.mask)) {
+ nl_msg_put_unspec(actions, OVS_CT_ATTR_LABELS, &ct_label,
+ sizeof ct_label);
+ }
+ if (helper) {
+ nl_msg_put_string__(actions, OVS_CT_ATTR_HELPER, helper,
+ helper_len);
+ }
+ if (have_nat) {
+ nl_msg_put_ct_nat(&nat_params, actions);
+ }
+ nl_msg_end_nested(actions, start);
+ }
+
+ return s - s_;
+}
+
static int
parse_odp_action(const char *s, const struct simap *port_names,
struct ofpbuf *actions)
}
}
+ {
+ int retval;
+
+ retval = parse_conntrack_action(s, actions);
+ if (retval) {
+ return retval;
+ }
+ }
+
{
struct ovs_action_push_tnl data;
int n;
[OVS_KEY_ATTR_ICMPV6] = { .len = sizeof(struct ovs_key_icmpv6) },
[OVS_KEY_ATTR_ARP] = { .len = sizeof(struct ovs_key_arp) },
[OVS_KEY_ATTR_ND] = { .len = sizeof(struct ovs_key_nd) },
+ [OVS_KEY_ATTR_CT_STATE] = { .len = 4 },
+ [OVS_KEY_ATTR_CT_ZONE] = { .len = 2 },
+ [OVS_KEY_ATTR_CT_MARK] = { .len = 4 },
+ [OVS_KEY_ATTR_CT_LABELS] = { .len = sizeof(struct ovs_key_ct_labels) },
};
/* Returns the correct length of the payload for a flow key attribute of the
/* Format helpers. */
static void
-format_eth(struct ds *ds, const char *name, const uint8_t key[ETH_ADDR_LEN],
- const uint8_t (*mask)[ETH_ADDR_LEN], bool verbose)
+format_eth(struct ds *ds, const char *name, const struct eth_addr key,
+ const struct eth_addr *mask, bool verbose)
{
bool mask_empty = mask && eth_addr_is_zero(*mask);
ds_put_format(ds, "%s="ETH_ADDR_FMT",", name, ETH_ADDR_ARGS(key));
} else {
ds_put_format(ds, "%s=", name);
- eth_format_masked(key, *mask, ds);
+ eth_format_masked(key, mask, ds);
ds_put_char(ds, ',');
}
}
verbose);
format_u8x(ds, "type", opt->type, MASK(mask, type), verbose);
format_u8u(ds, "len", data_len, mask ? &data_len_mask : NULL, verbose);
- if (verbose || !mask || !is_all_zeros(mask + 1, data_len)) {
+ if (data_len &&
+ (verbose || !mask || !is_all_zeros(mask + 1, data_len))) {
ds_put_hex(ds, opt + 1, data_len);
if (mask && !is_all_ones(mask + 1, data_len)) {
ds_put_char(ds, '/');
ofpbuf_uninit(&ofp);
}
+static const char *
+odp_ct_state_to_string(uint32_t flag)
+{
+ switch (flag) {
+ case OVS_CS_F_REPLY_DIR:
+ return "rpl";
+ case OVS_CS_F_TRACKED:
+ return "trk";
+ case OVS_CS_F_NEW:
+ return "new";
+ case OVS_CS_F_ESTABLISHED:
+ return "est";
+ case OVS_CS_F_RELATED:
+ return "rel";
+ case OVS_CS_F_INVALID:
+ return "inv";
+ default:
+ return NULL;
+ }
+}
+
static void
format_frag(struct ds *ds, const char *name, uint8_t key,
const uint8_t *mask, bool verbose)
}
}
+static bool
+mask_empty(const struct nlattr *ma)
+{
+ const void *mask;
+ size_t n;
+
+ if (!ma) {
+ return true;
+ }
+ mask = nl_attr_get(ma);
+ n = nl_attr_get_size(ma);
+
+ return is_all_zeros(mask, n);
+}
+
static void
format_odp_key_attr(const struct nlattr *a, const struct nlattr *ma,
const struct hmap *portno_names, struct ds *ds,
}
break;
+ case OVS_KEY_ATTR_CT_MARK:
+ if (verbose || !mask_empty(ma)) {
+ ds_put_format(ds, "%#"PRIx32, nl_attr_get_u32(a));
+ if (!is_exact) {
+ ds_put_format(ds, "/%#"PRIx32, nl_attr_get_u32(ma));
+ }
+ }
+ break;
+
+ case OVS_KEY_ATTR_CT_STATE:
+ if (verbose) {
+ ds_put_format(ds, "%#"PRIx32, nl_attr_get_u32(a));
+ if (!is_exact) {
+ ds_put_format(ds, "/%#"PRIx32,
+ mask_empty(ma) ? 0 : nl_attr_get_u32(ma));
+ }
+ } else if (!is_exact) {
+ format_flags_masked(ds, NULL, odp_ct_state_to_string,
+ nl_attr_get_u32(a),
+ mask_empty(ma) ? 0 : nl_attr_get_u32(ma),
+ UINT32_MAX);
+ } else {
+ format_flags(ds, odp_ct_state_to_string, nl_attr_get_u32(a), '|');
+ }
+ break;
+
+ case OVS_KEY_ATTR_CT_ZONE:
+ if (verbose || !mask_empty(ma)) {
+ ds_put_format(ds, "%#"PRIx16, nl_attr_get_u16(a));
+ if (!is_exact) {
+ ds_put_format(ds, "/%#"PRIx16, nl_attr_get_u16(ma));
+ }
+ }
+ break;
+
+ case OVS_KEY_ATTR_CT_LABELS: {
+ const ovs_u128 *value = nl_attr_get(a);
+ const ovs_u128 *mask = ma ? nl_attr_get(ma) : NULL;
+
+ format_u128(ds, value, mask, verbose);
+ break;
+ }
+
case OVS_KEY_ATTR_TUNNEL:
format_odp_tun_attr(a, ma, ds, verbose);
break;
return ofp->base;
}
+static void
+format_u128(struct ds *ds, const ovs_u128 *key, const ovs_u128 *mask,
+ bool verbose)
+{
+ if (verbose || (mask && !ovs_u128_is_zero(mask))) {
+ ovs_be128 value;
+
+ value = hton128(*key);
+ ds_put_hex(ds, &value, sizeof value);
+ if (mask && !(ovs_u128_is_ones(mask))) {
+ value = hton128(*mask);
+ ds_put_char(ds, '/');
+ ds_put_hex(ds, &value, sizeof value);
+ }
+ }
+}
+
+static int
+scan_u128(const char *s_, ovs_u128 *value, ovs_u128 *mask)
+{
+ char *s = CONST_CAST(char *, s_);
+ ovs_be128 be_value;
+ ovs_be128 be_mask;
+
+ if (!parse_int_string(s, (uint8_t *)&be_value, sizeof be_value, &s)) {
+ *value = ntoh128(be_value);
+
+ if (mask) {
+ int n;
+
+ if (ovs_scan(s, "/%n", &n)) {
+ int error;
+
+ s += n;
+ error = parse_int_string(s, (uint8_t *)&be_mask,
+ sizeof be_mask, &s);
+ if (error) {
+ return error;
+ }
+ *mask = ntoh128(be_mask);
+ } else {
+ *mask = OVS_U128_MAX;
+ }
+ }
+ return s - s_;
+ }
+
+ return 0;
+}
+
int
odp_ufid_from_string(const char *s_, ovs_u128 *ufid)
{
/* Parsing. */
static int
-scan_eth(const char *s, uint8_t (*key)[ETH_ADDR_LEN],
- uint8_t (*mask)[ETH_ADDR_LEN])
+scan_eth(const char *s, struct eth_addr *key, struct eth_addr *mask)
{
int n;
- if (ovs_scan(s, ETH_ADDR_SCAN_FMT"%n", ETH_ADDR_SCAN_ARGS(*key), &n)) {
+ if (ovs_scan(s, ETH_ADDR_SCAN_FMT"%n",
+ ETH_ADDR_SCAN_ARGS(*key), &n)) {
int len = n;
if (mask) {
return 0;
}
+static int
+scan_u16(const char *s, uint16_t *key, uint16_t *mask)
+{
+ int n;
+
+ if (ovs_scan(s, "%"SCNi16"%n", key, &n)) {
+ int len = n;
+
+ if (mask) {
+ if (ovs_scan(s + len, "/%"SCNi16"%n", mask, &n)) {
+ len += n;
+ } else {
+ *mask = UINT16_MAX;
+ }
+ }
+ return len;
+ }
+ return 0;
+}
+
static int
scan_u32(const char *s, uint32_t *key, uint32_t *mask)
{
return 0;
}
+static uint32_t
+ovs_to_odp_ct_state(uint8_t state)
+{
+ uint32_t odp = 0;
+
+ if (state & CS_NEW) {
+ odp |= OVS_CS_F_NEW;
+ }
+ if (state & CS_ESTABLISHED) {
+ odp |= OVS_CS_F_ESTABLISHED;
+ }
+ if (state & CS_RELATED) {
+ odp |= OVS_CS_F_RELATED;
+ }
+ if (state & CS_INVALID) {
+ odp |= OVS_CS_F_INVALID;
+ }
+ if (state & CS_REPLY_DIR) {
+ odp |= OVS_CS_F_REPLY_DIR;
+ }
+ if (state & CS_TRACKED) {
+ odp |= OVS_CS_F_TRACKED;
+ }
+
+ return odp;
+}
+
+static uint8_t
+odp_to_ovs_ct_state(uint32_t flags)
+{
+ uint32_t state = 0;
+
+ if (flags & OVS_CS_F_NEW) {
+ state |= CS_NEW;
+ }
+ if (flags & OVS_CS_F_ESTABLISHED) {
+ state |= CS_ESTABLISHED;
+ }
+ if (flags & OVS_CS_F_RELATED) {
+ state |= CS_RELATED;
+ }
+ if (flags & OVS_CS_F_INVALID) {
+ state |= CS_INVALID;
+ }
+ if (flags & OVS_CS_F_REPLY_DIR) {
+ state |= CS_REPLY_DIR;
+ }
+ if (flags & OVS_CS_F_TRACKED) {
+ state |= CS_TRACKED;
+ }
+
+ return state;
+}
+
+static int
+scan_ct_state(const char *s, uint32_t *key, uint32_t *mask)
+{
+ uint32_t flags, fmask;
+ int n;
+
+ n = parse_flags(s, odp_ct_state_to_string, ')', NULL, NULL, &flags,
+ ovs_to_odp_ct_state(CS_SUPPORTED_MASK),
+ mask ? &fmask : NULL);
+
+ if (n >= 0) {
+ *key = flags;
+ if (mask) {
+ *mask = fmask;
+ }
+ return n;
+ }
+ return 0;
+}
+
static int
scan_frag(const char *s, uint8_t *key, uint8_t *mask)
{
OVS_KEY_ATTR_RECIRC_ID);
SCAN_SINGLE("dp_hash(", uint32_t, u32, OVS_KEY_ATTR_DP_HASH);
+ SCAN_SINGLE("ct_state(", uint32_t, ct_state, OVS_KEY_ATTR_CT_STATE);
+ SCAN_SINGLE("ct_zone(", uint16_t, u16, OVS_KEY_ATTR_CT_ZONE);
+ SCAN_SINGLE("ct_mark(", uint32_t, u32, OVS_KEY_ATTR_CT_MARK);
+ SCAN_SINGLE("ct_label(", ovs_u128, u128, OVS_KEY_ATTR_CT_LABELS);
+
SCAN_BEGIN_NESTED("tunnel(", OVS_KEY_ATTR_TUNNEL) {
SCAN_FIELD_NESTED("tun_id=", ovs_be64, be64, OVS_TUNNEL_KEY_ATTR_ID);
SCAN_FIELD_NESTED("src=", ovs_be32, ipv4, OVS_TUNNEL_KEY_ATTR_IPV4_SRC);
nl_msg_put_u32(buf, OVS_KEY_ATTR_SKB_MARK, data->pkt_mark);
+ if (parms->support.ct_state) {
+ nl_msg_put_u32(buf, OVS_KEY_ATTR_CT_STATE,
+ ovs_to_odp_ct_state(data->ct_state));
+ }
+ if (parms->support.ct_zone) {
+ nl_msg_put_u16(buf, OVS_KEY_ATTR_CT_ZONE, data->ct_zone);
+ }
+ if (parms->support.ct_mark) {
+ nl_msg_put_u32(buf, OVS_KEY_ATTR_CT_MARK, data->ct_mark);
+ }
+ if (parms->support.ct_label) {
+ nl_msg_put_unspec(buf, OVS_KEY_ATTR_CT_LABELS, &data->ct_label,
+ sizeof(data->ct_label));
+ }
if (parms->support.recirc) {
nl_msg_put_u32(buf, OVS_KEY_ATTR_RECIRC_ID, data->recirc_id);
nl_msg_put_u32(buf, OVS_KEY_ATTR_DP_HASH, data->dp_hash);
sizeof *nd_key);
memcpy(nd_key->nd_target, &data->nd_target,
sizeof nd_key->nd_target);
- memcpy(nd_key->nd_sll, data->arp_sha, ETH_ADDR_LEN);
- memcpy(nd_key->nd_tll, data->arp_tha, ETH_ADDR_LEN);
+ nd_key->nd_sll = data->arp_sha;
+ nd_key->nd_tll = data->arp_tha;
}
}
}
nl_msg_put_u32(buf, OVS_KEY_ATTR_SKB_MARK, md->pkt_mark);
+ if (md->ct_state) {
+ nl_msg_put_u32(buf, OVS_KEY_ATTR_CT_STATE,
+ ovs_to_odp_ct_state(md->ct_state));
+ if (md->ct_zone) {
+ nl_msg_put_u16(buf, OVS_KEY_ATTR_CT_ZONE, md->ct_zone);
+ }
+ if (md->ct_mark) {
+ nl_msg_put_u32(buf, OVS_KEY_ATTR_CT_MARK, md->ct_mark);
+ }
+ if (!ovs_u128_is_zero(&md->ct_label)) {
+ nl_msg_put_unspec(buf, OVS_KEY_ATTR_CT_LABELS, &md->ct_label,
+ sizeof(md->ct_label));
+ }
+ }
+
/* Add an ingress port attribute if 'odp_in_port' is not the magical
* value "ODPP_NONE". */
if (md->in_port.odp_port != ODPP_NONE) {
md->pkt_mark = nl_attr_get_u32(nla);
wanted_attrs &= ~(1u << OVS_KEY_ATTR_SKB_MARK);
break;
+ case OVS_KEY_ATTR_CT_STATE:
+ md->ct_state = odp_to_ovs_ct_state(nl_attr_get_u32(nla));
+ wanted_attrs &= ~(1u << OVS_KEY_ATTR_CT_STATE);
+ break;
+ case OVS_KEY_ATTR_CT_ZONE:
+ md->ct_zone = nl_attr_get_u16(nla);
+ wanted_attrs &= ~(1u << OVS_KEY_ATTR_CT_ZONE);
+ break;
+ case OVS_KEY_ATTR_CT_MARK:
+ md->ct_mark = nl_attr_get_u32(nla);
+ wanted_attrs &= ~(1u << OVS_KEY_ATTR_CT_MARK);
+ break;
+ case OVS_KEY_ATTR_CT_LABELS: {
+ const ovs_u128 *cl = nl_attr_get(nla);
+
+ md->ct_label = *cl;
+ wanted_attrs &= ~(1u << OVS_KEY_ATTR_CT_LABELS);
+ break;
+ }
case OVS_KEY_ATTR_TUNNEL: {
enum odp_key_fitness res;
nd_key = nl_attr_get(attrs[OVS_KEY_ATTR_ND]);
memcpy(&flow->nd_target, nd_key->nd_target,
sizeof flow->nd_target);
- memcpy(flow->arp_sha, nd_key->nd_sll, ETH_ADDR_LEN);
- memcpy(flow->arp_tha, nd_key->nd_tll, ETH_ADDR_LEN);
+ flow->arp_sha = nd_key->nd_sll;
+ flow->arp_tha = nd_key->nd_tll;
if (is_mask) {
if (!is_all_zeros(nd_key, sizeof *nd_key) &&
(flow->tp_src != htons(0xffff) ||
expected_attrs |= UINT64_C(1) << OVS_KEY_ATTR_SKB_MARK;
}
+ if (present_attrs & (UINT64_C(1) << OVS_KEY_ATTR_CT_STATE)) {
+ uint32_t odp_state = nl_attr_get_u32(attrs[OVS_KEY_ATTR_CT_STATE]);
+
+ flow->ct_state = odp_to_ovs_ct_state(odp_state);
+ expected_attrs |= UINT64_C(1) << OVS_KEY_ATTR_CT_STATE;
+ }
+ if (present_attrs & (UINT64_C(1) << OVS_KEY_ATTR_CT_ZONE)) {
+ flow->ct_zone = nl_attr_get_u16(attrs[OVS_KEY_ATTR_CT_ZONE]);
+ expected_attrs |= UINT64_C(1) << OVS_KEY_ATTR_CT_ZONE;
+ }
+ if (present_attrs & (UINT64_C(1) << OVS_KEY_ATTR_CT_MARK)) {
+ flow->ct_mark = nl_attr_get_u32(attrs[OVS_KEY_ATTR_CT_MARK]);
+ expected_attrs |= UINT64_C(1) << OVS_KEY_ATTR_CT_MARK;
+ }
+ if (present_attrs & (UINT64_C(1) << OVS_KEY_ATTR_CT_LABELS)) {
+ const ovs_u128 *cl = nl_attr_get(attrs[OVS_KEY_ATTR_CT_LABELS]);
+
+ flow->ct_label = *cl;
+ expected_attrs |= UINT64_C(1) << OVS_KEY_ATTR_CT_LABELS;
+ }
+
if (present_attrs & (UINT64_C(1) << OVS_KEY_ATTR_TUNNEL)) {
enum odp_key_fitness res;
expected_attrs, flow, key, key_len, src_flow);
}
if (is_mask) {
+ /* A missing VLAN mask means exact match on vlan_tci 0 (== no VLAN). */
flow->vlan_tci = htons(0xffff);
if (present_attrs & (UINT64_C(1) << OVS_KEY_ATTR_VLAN)) {
flow->vlan_tci = nl_attr_get_be16(attrs[OVS_KEY_ATTR_VLAN]);
static void
get_ethernet_key(const struct flow *flow, struct ovs_key_ethernet *eth)
{
- memcpy(eth->eth_src, flow->dl_src, ETH_ADDR_LEN);
- memcpy(eth->eth_dst, flow->dl_dst, ETH_ADDR_LEN);
+ eth->eth_src = flow->dl_src;
+ eth->eth_dst = flow->dl_dst;
}
static void
put_ethernet_key(const struct ovs_key_ethernet *eth, struct flow *flow)
{
- memcpy(flow->dl_src, eth->eth_src, ETH_ADDR_LEN);
- memcpy(flow->dl_dst, eth->eth_dst, ETH_ADDR_LEN);
+ flow->dl_src = eth->eth_src;
+ flow->dl_dst = eth->eth_dst;
}
static void
arp->arp_sip = flow->nw_src;
arp->arp_tip = flow->nw_dst;
arp->arp_op = htons(flow->nw_proto);
- memcpy(arp->arp_sha, flow->arp_sha, ETH_ADDR_LEN);
- memcpy(arp->arp_tha, flow->arp_tha, ETH_ADDR_LEN);
+ arp->arp_sha = flow->arp_sha;
+ arp->arp_tha = flow->arp_tha;
}
static void
flow->nw_src = arp->arp_sip;
flow->nw_dst = arp->arp_tip;
flow->nw_proto = ntohs(arp->arp_op);
- memcpy(flow->arp_sha, arp->arp_sha, ETH_ADDR_LEN);
- memcpy(flow->arp_tha, arp->arp_tha, ETH_ADDR_LEN);
+ flow->arp_sha = arp->arp_sha;
+ flow->arp_tha = arp->arp_tha;
}
static enum slow_path_reason
return 0;
}
+static void
+get_icmp_key(const struct flow *flow, struct ovs_key_icmp *icmp)
+{
+ /* icmp_type and icmp_code are stored in tp_src and tp_dst, respectively */
+ icmp->icmp_type = ntohs(flow->tp_src);
+ icmp->icmp_code = ntohs(flow->tp_dst);
+}
+
+static void
+put_icmp_key(const struct ovs_key_icmp *icmp, struct flow *flow)
+{
+ /* icmp_type and icmp_code are stored in tp_src and tp_dst, respectively */
+ flow->tp_src = htons(icmp->icmp_type);
+ flow->tp_dst = htons(icmp->icmp_code);
+}
+
+static enum slow_path_reason
+commit_set_icmp_action(const struct flow *flow, struct flow *base_flow,
+ struct ofpbuf *odp_actions, struct flow_wildcards *wc)
+{
+ struct ovs_key_icmp key, mask, base;
+ enum ovs_key_attr attr;
+
+ get_icmp_key(flow, &key);
+ get_icmp_key(base_flow, &base);
+ get_icmp_key(&wc->masks, &mask);
+
+ attr = flow->dl_type == htons(ETH_TYPE_IP) ? OVS_KEY_ATTR_ICMP
+ : OVS_KEY_ATTR_ICMPV6;
+ if (commit(attr, false, &key, &base, &mask, sizeof key, odp_actions)) {
+ put_icmp_key(&base, base_flow);
+ put_icmp_key(&mask, &wc->masks);
+ return SLOW_ACTION;
+ }
+ return 0;
+}
+
static void
get_nd_key(const struct flow *flow, struct ovs_key_nd *nd)
{
memcpy(nd->nd_target, &flow->nd_target, sizeof flow->nd_target);
/* nd_sll and nd_tll are stored in arp_sha and arp_tha, respectively */
- memcpy(nd->nd_sll, flow->arp_sha, ETH_ADDR_LEN);
- memcpy(nd->nd_tll, flow->arp_tha, ETH_ADDR_LEN);
+ nd->nd_sll = flow->arp_sha;
+ nd->nd_tll = flow->arp_tha;
}
static void
{
memcpy(&flow->nd_target, nd->nd_target, sizeof flow->nd_target);
/* nd_sll and nd_tll are stored in arp_sha and arp_tha, respectively */
- memcpy(flow->arp_sha, nd->nd_sll, ETH_ADDR_LEN);
- memcpy(flow->arp_tha, nd->nd_tll, ETH_ADDR_LEN);
+ flow->arp_sha = nd->nd_sll;
+ flow->arp_tha = nd->nd_tll;
}
static enum slow_path_reason
struct ofpbuf *odp_actions, struct flow_wildcards *wc,
bool use_masked)
{
- enum slow_path_reason slow;
+ enum slow_path_reason slow1, slow2;
commit_set_ether_addr_action(flow, base, odp_actions, wc, use_masked);
- slow = commit_set_nw_action(flow, base, odp_actions, wc, use_masked);
+ slow1 = commit_set_nw_action(flow, base, odp_actions, wc, use_masked);
commit_set_port_action(flow, base, odp_actions, wc, use_masked);
+ slow2 = commit_set_icmp_action(flow, base, odp_actions, wc);
commit_mpls_action(flow, base, odp_actions);
commit_vlan_action(flow->vlan_tci, base, odp_actions, wc);
commit_set_priority_action(flow, base, odp_actions, wc, use_masked);
commit_set_pkt_mark_action(flow, base, odp_actions, wc, use_masked);
- return slow;
+ return slow1 ? slow1 : slow2;
}
projects / cascardo / ovs.git / blobdiff