pintos-os.org Git - openvswitch/blob - lib/odp-util.c

   1 /*
   2  * Copyright (c) 2009, 2010, 2011 Nicira Networks.
   3  *
   4  * Licensed under the Apache License, Version 2.0 (the "License");
   5  * you may not use this file except in compliance with the License.
   6  * You may obtain a copy of the License at:
   7  *
   8  *     http://www.apache.org/licenses/LICENSE-2.0
   9  *
  10  * Unless required by applicable law or agreed to in writing, software
  11  * distributed under the License is distributed on an "AS IS" BASIS,
  12  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  13  * See the License for the specific language governing permissions and
  14  * limitations under the License.
  15  */
  16
  17 #include <arpa/inet.h>
  18 #include <config.h>
  19 #include "odp-util.h"
  20 #include <errno.h>
  21 #include <inttypes.h>
  22 #include <netinet/icmp6.h>
  23 #include <stdlib.h>
  24 #include <string.h>
  25 #include "byte-order.h"
  26 #include "coverage.h"
  27 #include "dynamic-string.h"
  28 #include "flow.h"
  29 #include "netlink.h"
  30 #include "ofpbuf.h"
  31 #include "openvswitch/tunnel.h"
  32 #include "packets.h"
  33 #include "timeval.h"
  34 #include "util.h"
  35
  36 static void
  37 format_odp_key_attr(const struct nlattr *a, struct ds *ds);
  38
  39 /* The interface between userspace and kernel uses an "OVS_*" prefix.
  40  * Since this is fairly non-specific for the OVS userspace components,
  41  * "ODP_*" (Open vSwitch Datapath) is used as the prefix for
  42  * interactions with the datapath.
  43  */
  44
  45 /* Returns one the following for the action with the given OVS_ACTION_ATTR_*
  46  * 'type':
  47  *
  48  *   - For an action whose argument has a fixed length, returned that
  49  *     nonnegative length in bytes.
  50  *
  51  *   - For an action with a variable-length argument, returns -2.
  52  *
  53  *   - For an invalid 'type', returns -1. */
  54 static int
  55 odp_action_len(uint16_t type)
  56 {
  57     if (type > OVS_ACTION_ATTR_MAX) {
  58         return -1;
  59     }
  60
  61     switch ((enum ovs_action_attr) type) {
  62     case OVS_ACTION_ATTR_OUTPUT: return 4;
  63     case OVS_ACTION_ATTR_USERSPACE: return -2;
  64     case OVS_ACTION_ATTR_PUSH: return -2;
  65     case OVS_ACTION_ATTR_POP: return 2;
  66     case OVS_ACTION_ATTR_SET: return -2;
  67     case OVS_ACTION_ATTR_SET_PRIORITY: return 4;
  68     case OVS_ACTION_ATTR_POP_PRIORITY: return 0;
  69     case OVS_ACTION_ATTR_SAMPLE: return -2;
  70
  71     case OVS_ACTION_ATTR_UNSPEC:
  72     case __OVS_ACTION_ATTR_MAX:
  73         return -1;
  74     }
  75
  76     return -1;
  77 }
  78
  79 static void
  80 format_generic_odp_action(struct ds *ds, const struct nlattr *a)
  81 {
  82     size_t len = nl_attr_get_size(a);
  83
  84     ds_put_format(ds, "action%"PRId16, nl_attr_type(a));
  85     if (len) {
  86         const uint8_t *unspec;
  87         unsigned int i;
  88
  89         unspec = nl_attr_get(a);
  90         for (i = 0; i < len; i++) {
  91             ds_put_char(ds, i ? ' ': '(');
  92             ds_put_format(ds, "%02x", unspec[i]);
  93         }
  94         ds_put_char(ds, ')');
  95     }
  96 }
  97
  98 static void
  99 format_odp_sample_action(struct ds *ds, const struct nlattr *attr)
 100 {
 101     static const struct nl_policy ovs_sample_policy[] = {
 102         [OVS_SAMPLE_ATTR_PROBABILITY] = { .type = NL_A_U32 },
 103         [OVS_SAMPLE_ATTR_ACTIONS] = { .type = NL_A_NESTED }
 104     };
 105     struct nlattr *a[ARRAY_SIZE(ovs_sample_policy)];
 106     double percentage;
 107     const struct nlattr *nla_acts;
 108     int len;
 109
 110     ds_put_cstr(ds, "sample");
 111
 112     if (!nl_parse_nested(attr, ovs_sample_policy, a, ARRAY_SIZE(a))) {
 113         ds_put_cstr(ds, "(error)");
 114         return;
 115     }
 116
 117     percentage = (100.0 * nl_attr_get_u32(a[OVS_SAMPLE_ATTR_PROBABILITY])) /
 118                         UINT32_MAX;
 119
 120     ds_put_format(ds, "(sample=%.1f%%,", percentage);
 121
 122     ds_put_cstr(ds, "actions(");
 123     nla_acts = nl_attr_get(a[OVS_SAMPLE_ATTR_ACTIONS]);
 124     len = nl_attr_get_size(a[OVS_SAMPLE_ATTR_ACTIONS]);
 125     format_odp_actions(ds, nla_acts, len);
 126     ds_put_format(ds, "))");
 127 }
 128
 129 static void
 130 format_odp_userspace_action(struct ds *ds, const struct nlattr *attr)
 131 {
 132     static const struct nl_policy ovs_userspace_policy[] = {
 133         [OVS_USERSPACE_ATTR_PID] = { .type = NL_A_U32 },
 134         [OVS_USERSPACE_ATTR_USERDATA] = { .type = NL_A_U64, .optional = true },
 135     };
 136     struct nlattr *a[ARRAY_SIZE(ovs_userspace_policy)];
 137
 138     if (!nl_parse_nested(attr, ovs_userspace_policy, a, ARRAY_SIZE(a))) {
 139         ds_put_cstr(ds, "userspace(error)");
 140         return;
 141     }
 142
 143     ds_put_format(ds, "userspace(pid=%"PRIu32,
 144                   nl_attr_get_u32(a[OVS_USERSPACE_ATTR_PID]));
 145
 146     if (a[OVS_USERSPACE_ATTR_USERDATA]) {
 147         uint64_t userdata = nl_attr_get_u64(a[OVS_USERSPACE_ATTR_USERDATA]);
 148         struct user_action_cookie cookie;
 149
 150         memcpy(&cookie, &userdata, sizeof cookie);
 151
 152         if (cookie.type == USER_ACTION_COOKIE_CONTROLLER) {
 153             ds_put_format(ds, ",controller,length=%"PRIu32,
 154                           cookie.data);
 155         } else if (cookie.type == USER_ACTION_COOKIE_SFLOW) {
 156             ds_put_format(ds, ",sFlow,n_output=%"PRIu8","
 157                           "vid=%"PRIu16",pcp=%"PRIu8",ifindex=%"PRIu32,
 158                           cookie.n_output, vlan_tci_to_vid(cookie.vlan_tci),
 159                           vlan_tci_to_pcp(cookie.vlan_tci), cookie.data);
 160         } else {
 161             ds_put_format(ds, ",userdata=0x%"PRIx64, userdata);
 162         }
 163     }
 164
 165     ds_put_char(ds, ')');
 166 }
 167
 168
 169 static void
 170 format_odp_action(struct ds *ds, const struct nlattr *a)
 171 {
 172     int expected_len;
 173     enum ovs_action_attr type = nl_attr_type(a);
 174
 175     expected_len = odp_action_len(nl_attr_type(a));
 176     if (expected_len != -2 && nl_attr_get_size(a) != expected_len) {
 177         ds_put_format(ds, "bad length %zu, expected %d for: ",
 178                       nl_attr_get_size(a), expected_len);
 179         format_generic_odp_action(ds, a);
 180         return;
 181     }
 182
 183     switch (type) {
 184
 185     case OVS_ACTION_ATTR_OUTPUT:
 186         ds_put_format(ds, "%"PRIu16, nl_attr_get_u32(a));
 187         break;
 188     case OVS_ACTION_ATTR_USERSPACE:
 189         format_odp_userspace_action(ds, a);
 190         break;
 191     case OVS_ACTION_ATTR_SET:
 192         ds_put_cstr(ds, "set(");
 193         format_odp_key_attr(nl_attr_get(a), ds);
 194         ds_put_cstr(ds, ")");
 195         break;
 196     case OVS_ACTION_ATTR_PUSH:
 197         ds_put_cstr(ds, "push(");
 198         format_odp_key_attr(nl_attr_get(a), ds);
 199         ds_put_cstr(ds, ")");
 200         break;
 201     case OVS_ACTION_ATTR_POP:
 202         if (nl_attr_get_u16(a) == OVS_KEY_ATTR_8021Q) {
 203             ds_put_cstr(ds, "pop(vlan)");
 204         } else {
 205             ds_put_format(ds, "pop(key%"PRIu16")", nl_attr_get_u16(a));
 206         }
 207         break;
 208     case OVS_ACTION_ATTR_SET_PRIORITY:
 209         ds_put_format(ds, "set_priority(%#"PRIx32")", nl_attr_get_u32(a));
 210         break;
 211     case OVS_ACTION_ATTR_POP_PRIORITY:
 212         ds_put_cstr(ds, "pop_priority");
 213         break;
 214     case OVS_ACTION_ATTR_SAMPLE:
 215         format_odp_sample_action(ds, a);
 216         break;
 217     case OVS_ACTION_ATTR_UNSPEC:
 218     case __OVS_ACTION_ATTR_MAX:
 219     default:
 220         format_generic_odp_action(ds, a);
 221         break;
 222     }
 223 }
 224
 225 void
 226 format_odp_actions(struct ds *ds, const struct nlattr *actions,
 227                    size_t actions_len)
 228 {
 229     if (actions_len) {
 230         const struct nlattr *a;
 231         unsigned int left;
 232
 233         NL_ATTR_FOR_EACH (a, left, actions, actions_len) {
 234             if (a != actions) {
 235                 ds_put_char(ds, ',');
 236             }
 237             format_odp_action(ds, a);
 238         }
 239         if (left) {
 240             if (left == actions_len) {
 241                 ds_put_cstr(ds, "<empty>");
 242             }
 243             ds_put_format(ds, ",***%u leftover bytes***", left);
 244         }
 245     } else {
 246         ds_put_cstr(ds, "drop");
 247     }
 248 }
 249 \f
 250 /* Returns the correct length of the payload for a flow key attribute of the
 251  * specified 'type', or -1 if 'type' is unknown. */
 252 static int
 253 odp_flow_key_attr_len(uint16_t type)
 254 {
 255     if (type > OVS_KEY_ATTR_MAX) {
 256         return -1;
 257     }
 258
 259     switch ((enum ovs_key_attr) type) {
 260     case OVS_KEY_ATTR_TUN_ID: return 8;
 261     case OVS_KEY_ATTR_IN_PORT: return 4;
 262     case OVS_KEY_ATTR_ETHERNET: return sizeof(struct ovs_key_ethernet);
 263     case OVS_KEY_ATTR_8021Q: return sizeof(struct ovs_key_8021q);
 264     case OVS_KEY_ATTR_ETHERTYPE: return 2;
 265     case OVS_KEY_ATTR_IPV4: return sizeof(struct ovs_key_ipv4);
 266     case OVS_KEY_ATTR_IPV6: return sizeof(struct ovs_key_ipv6);
 267     case OVS_KEY_ATTR_TCP: return sizeof(struct ovs_key_tcp);
 268     case OVS_KEY_ATTR_UDP: return sizeof(struct ovs_key_udp);
 269     case OVS_KEY_ATTR_ICMP: return sizeof(struct ovs_key_icmp);
 270     case OVS_KEY_ATTR_ICMPV6: return sizeof(struct ovs_key_icmpv6);
 271     case OVS_KEY_ATTR_ARP: return sizeof(struct ovs_key_arp);
 272     case OVS_KEY_ATTR_ND: return sizeof(struct ovs_key_nd);
 273
 274     case OVS_KEY_ATTR_UNSPEC:
 275     case __OVS_KEY_ATTR_MAX:
 276         return -1;
 277     }
 278
 279     return -1;
 280 }
 281
 282
 283 static void
 284 format_generic_odp_key(const struct nlattr *a, struct ds *ds)
 285 {
 286     size_t len = nl_attr_get_size(a);
 287
 288     ds_put_format(ds, "key%"PRId16, nl_attr_type(a));
 289     if (len) {
 290         const uint8_t *unspec;
 291         unsigned int i;
 292
 293         unspec = nl_attr_get(a);
 294         for (i = 0; i < len; i++) {
 295             ds_put_char(ds, i ? ' ': '(');
 296             ds_put_format(ds, "%02x", unspec[i]);
 297         }
 298         ds_put_char(ds, ')');
 299     }
 300 }
 301
 302 static void
 303 format_odp_key_attr(const struct nlattr *a, struct ds *ds)
 304 {
 305     const struct ovs_key_ethernet *eth_key;
 306     const struct ovs_key_8021q *q_key;
 307     const struct ovs_key_ipv4 *ipv4_key;
 308     const struct ovs_key_ipv6 *ipv6_key;
 309     const struct ovs_key_tcp *tcp_key;
 310     const struct ovs_key_udp *udp_key;
 311     const struct ovs_key_icmp *icmp_key;
 312     const struct ovs_key_icmpv6 *icmpv6_key;
 313     const struct ovs_key_arp *arp_key;
 314     const struct ovs_key_nd *nd_key;
 315
 316     if (nl_attr_get_size(a) != odp_flow_key_attr_len(nl_attr_type(a))) {
 317         ds_put_format(ds, "bad length %zu, expected %d for: ",
 318                       nl_attr_get_size(a),
 319                       odp_flow_key_attr_len(nl_attr_type(a)));
 320         format_generic_odp_key(a, ds);
 321         return;
 322     }
 323
 324     switch (nl_attr_type(a)) {
 325     case OVS_KEY_ATTR_TUN_ID:
 326         ds_put_format(ds, "tun_id(%#"PRIx64")", ntohll(nl_attr_get_be64(a)));
 327         break;
 328
 329     case OVS_KEY_ATTR_IN_PORT:
 330         ds_put_format(ds, "in_port(%"PRIu32")", nl_attr_get_u32(a));
 331         break;
 332
 333     case OVS_KEY_ATTR_ETHERNET:
 334         eth_key = nl_attr_get(a);
 335         ds_put_format(ds, "eth(src="ETH_ADDR_FMT",dst="ETH_ADDR_FMT")",
 336                       ETH_ADDR_ARGS(eth_key->eth_src),
 337                       ETH_ADDR_ARGS(eth_key->eth_dst));
 338         break;
 339
 340     case OVS_KEY_ATTR_8021Q:
 341         q_key = nl_attr_get(a);
 342         ds_put_cstr(ds, "vlan(");
 343         if (q_key->q_tpid != htons(ETH_TYPE_VLAN)) {
 344             ds_put_format(ds, "tpid=0x%04"PRIx16",", ntohs(q_key->q_tpid));
 345         }
 346         ds_put_format(ds, "vid=%"PRIu16",pcp=%d)",
 347                       vlan_tci_to_vid(q_key->q_tci),
 348                       vlan_tci_to_pcp(q_key->q_tci));
 349         break;
 350
 351     case OVS_KEY_ATTR_ETHERTYPE:
 352         ds_put_format(ds, "eth_type(0x%04"PRIx16")",
 353                       ntohs(nl_attr_get_be16(a)));
 354         break;
 355
 356     case OVS_KEY_ATTR_IPV4:
 357         ipv4_key = nl_attr_get(a);
 358         ds_put_format(ds, "ipv4(src="IP_FMT",dst="IP_FMT","
 359                       "proto=%"PRId8",tos=%"PRIu8")",
 360                       IP_ARGS(&ipv4_key->ipv4_src),
 361                       IP_ARGS(&ipv4_key->ipv4_dst),
 362                       ipv4_key->ipv4_proto, ipv4_key->ipv4_tos);
 363         break;
 364
 365     case OVS_KEY_ATTR_IPV6: {
 366         char src_str[INET6_ADDRSTRLEN];
 367         char dst_str[INET6_ADDRSTRLEN];
 368
 369         ipv6_key = nl_attr_get(a);
 370         inet_ntop(AF_INET6, ipv6_key->ipv6_src, src_str, sizeof src_str);
 371         inet_ntop(AF_INET6, ipv6_key->ipv6_dst, dst_str, sizeof dst_str);
 372
 373         ds_put_format(ds, "ipv6(src=%s,dst=%s,proto=%"PRId8",tos=%"PRIu8")",
 374                       src_str, dst_str, ipv6_key->ipv6_proto,
 375                       ipv6_key->ipv6_tos);
 376         break;
 377     }
 378
 379     case OVS_KEY_ATTR_TCP:
 380         tcp_key = nl_attr_get(a);
 381         ds_put_format(ds, "tcp(src=%"PRIu16",dst=%"PRIu16")",
 382                       ntohs(tcp_key->tcp_src), ntohs(tcp_key->tcp_dst));
 383         break;
 384
 385     case OVS_KEY_ATTR_UDP:
 386         udp_key = nl_attr_get(a);
 387         ds_put_format(ds, "udp(src=%"PRIu16",dst=%"PRIu16")",
 388                       ntohs(udp_key->udp_src), ntohs(udp_key->udp_dst));
 389         break;
 390
 391     case OVS_KEY_ATTR_ICMP:
 392         icmp_key = nl_attr_get(a);
 393         ds_put_format(ds, "icmp(type=%"PRIu8",code=%"PRIu8")",
 394                       icmp_key->icmp_type, icmp_key->icmp_code);
 395         break;
 396
 397     case OVS_KEY_ATTR_ICMPV6:
 398         icmpv6_key = nl_attr_get(a);
 399         ds_put_format(ds, "icmpv6(type=%"PRIu8",code=%"PRIu8")",
 400                       icmpv6_key->icmpv6_type, icmpv6_key->icmpv6_code);
 401         break;
 402
 403     case OVS_KEY_ATTR_ARP:
 404         arp_key = nl_attr_get(a);
 405         ds_put_format(ds, "arp(sip="IP_FMT",tip="IP_FMT",op=%"PRIu16","
 406                       "sha="ETH_ADDR_FMT",tha="ETH_ADDR_FMT")",
 407                       IP_ARGS(&arp_key->arp_sip), IP_ARGS(&arp_key->arp_tip),
 408                       ntohs(arp_key->arp_op), ETH_ADDR_ARGS(arp_key->arp_sha),
 409                       ETH_ADDR_ARGS(arp_key->arp_tha));
 410         break;
 411
 412     case OVS_KEY_ATTR_ND: {
 413         char target[INET6_ADDRSTRLEN];
 414
 415         nd_key = nl_attr_get(a);
 416         inet_ntop(AF_INET6, nd_key->nd_target, target, sizeof target);
 417
 418         ds_put_format(ds, "nd(target=%s", target);
 419         if (!eth_addr_is_zero(nd_key->nd_sll)) {
 420             ds_put_format(ds, ",sll="ETH_ADDR_FMT,
 421                           ETH_ADDR_ARGS(nd_key->nd_sll));
 422         }
 423         if (!eth_addr_is_zero(nd_key->nd_tll)) {
 424             ds_put_format(ds, ",tll="ETH_ADDR_FMT,
 425                           ETH_ADDR_ARGS(nd_key->nd_tll));
 426         }
 427         ds_put_char(ds, ')');
 428         break;
 429     }
 430
 431     default:
 432         format_generic_odp_key(a, ds);
 433         break;
 434     }
 435 }
 436
 437 /* Appends to 'ds' a string representation of the 'key_len' bytes of
 438  * OVS_KEY_ATTR_* attributes in 'key'. */
 439 void
 440 odp_flow_key_format(const struct nlattr *key, size_t key_len, struct ds *ds)
 441 {
 442     if (key_len) {
 443         const struct nlattr *a;
 444         unsigned int left;
 445
 446         NL_ATTR_FOR_EACH (a, left, key, key_len) {
 447             if (a != key) {
 448                 ds_put_char(ds, ',');
 449             }
 450             format_odp_key_attr(a, ds);
 451         }
 452         if (left) {
 453             if (left == key_len) {
 454                 ds_put_cstr(ds, "<empty>");
 455             }
 456             ds_put_format(ds, ",***%u leftover bytes***", left);
 457         }
 458     } else {
 459         ds_put_cstr(ds, "<empty>");
 460     }
 461 }
 462
 463 static int
 464 put_nd_key(int n, const char *nd_target_s,
 465            const uint8_t *nd_sll, const uint8_t *nd_tll, struct ofpbuf *key)
 466 {
 467     struct ovs_key_nd nd_key;
 468
 469     memset(&nd_key, 0, sizeof nd_key);
 470     if (inet_pton(AF_INET6, nd_target_s, nd_key.nd_target) != 1) {
 471         return -EINVAL;
 472     }
 473     if (nd_sll) {
 474         memcpy(nd_key.nd_sll, nd_sll, ETH_ADDR_LEN);
 475     }
 476     if (nd_tll) {
 477         memcpy(nd_key.nd_tll, nd_tll, ETH_ADDR_LEN);
 478     }
 479     nl_msg_put_unspec(key, OVS_KEY_ATTR_ND, &nd_key, sizeof nd_key);
 480     return n;
 481 }
 482
 483 static int
 484 parse_odp_key_attr(const char *s, struct ofpbuf *key)
 485 {
 486     /* Many of the sscanf calls in this function use oversized destination
 487      * fields because some sscanf() implementations truncate the range of %i
 488      * directives, so that e.g. "%"SCNi16 interprets input of "0xfedc" as a
 489      * value of 0x7fff.  The other alternatives are to allow only a single
 490      * radix (e.g. decimal or hexadecimal) or to write more sophisticated
 491      * parsers.
 492      *
 493      * The tun_id parser has to use an alternative approach because there is no
 494      * type larger than 64 bits. */
 495
 496     {
 497         char tun_id_s[32];
 498         int n = -1;
 499
 500         if (sscanf(s, "tun_id(%31[x0123456789abcdefABCDEF])%n",
 501                    tun_id_s, &n) > 0 && n > 0) {
 502             uint64_t tun_id = strtoull(tun_id_s, NULL, 0);
 503             nl_msg_put_be64(key, OVS_KEY_ATTR_TUN_ID, htonll(tun_id));
 504             return n;
 505         }
 506     }
 507
 508     {
 509         unsigned long long int in_port;
 510         int n = -1;
 511
 512         if (sscanf(s, "in_port(%lli)%n", &in_port, &n) > 0 && n > 0) {
 513             nl_msg_put_u32(key, OVS_KEY_ATTR_IN_PORT, in_port);
 514             return n;
 515         }
 516     }
 517
 518     {
 519         struct ovs_key_ethernet eth_key;
 520         int n = -1;
 521
 522         if (sscanf(s,
 523                    "eth(src="ETH_ADDR_SCAN_FMT",dst="ETH_ADDR_SCAN_FMT")%n",
 524                    ETH_ADDR_SCAN_ARGS(eth_key.eth_src),
 525                    ETH_ADDR_SCAN_ARGS(eth_key.eth_dst), &n) > 0 && n > 0) {
 526             nl_msg_put_unspec(key, OVS_KEY_ATTR_ETHERNET,
 527                               &eth_key, sizeof eth_key);
 528             return n;
 529         }
 530     }
 531
 532     {
 533         uint16_t tpid = ETH_TYPE_VLAN;
 534         uint16_t vid;
 535         int pcp;
 536         int n = -1;
 537
 538         if ((sscanf(s, "vlan(vid=%"SCNi16",pcp=%i)%n",
 539                     &vid, &pcp, &n) > 0 && n > 0) ||
 540             (sscanf(s, "vlan(tpid=%"SCNi16",vid=%"SCNi16",pcp=%i)%n",
 541                     &tpid, &vid, &pcp, &n) > 0 && n > 0)) {
 542             struct ovs_key_8021q q_key;
 543
 544             q_key.q_tpid = htons(tpid);
 545             q_key.q_tci = htons((vid << VLAN_VID_SHIFT) |
 546                                 (pcp << VLAN_PCP_SHIFT));
 547             nl_msg_put_unspec(key, OVS_KEY_ATTR_8021Q, &q_key, sizeof q_key);
 548             return n;
 549         }
 550     }
 551
 552     {
 553         int eth_type;
 554         int n = -1;
 555
 556         if (sscanf(s, "eth_type(%i)%n", &eth_type, &n) > 0 && n > 0) {
 557             nl_msg_put_be16(key, OVS_KEY_ATTR_ETHERTYPE, htons(eth_type));
 558             return n;
 559         }
 560     }
 561
 562     {
 563         ovs_be32 ipv4_src;
 564         ovs_be32 ipv4_dst;
 565         int ipv4_proto;
 566         int ipv4_tos;
 567         int n = -1;
 568
 569         if (sscanf(s, "ipv4(src="IP_SCAN_FMT",dst="IP_SCAN_FMT","
 570                    "proto=%i,tos=%i)%n",
 571                    IP_SCAN_ARGS(&ipv4_src),
 572                    IP_SCAN_ARGS(&ipv4_dst), &ipv4_proto, &ipv4_tos, &n) > 0
 573             && n > 0) {
 574             struct ovs_key_ipv4 ipv4_key;
 575
 576             memset(&ipv4_key, 0, sizeof ipv4_key);
 577             ipv4_key.ipv4_src = ipv4_src;
 578             ipv4_key.ipv4_dst = ipv4_dst;
 579             ipv4_key.ipv4_proto = ipv4_proto;
 580             ipv4_key.ipv4_tos = ipv4_tos;
 581             nl_msg_put_unspec(key, OVS_KEY_ATTR_IPV4,
 582                               &ipv4_key, sizeof ipv4_key);
 583             return n;
 584         }
 585     }
 586
 587     {
 588         char ipv6_src_s[IPV6_SCAN_LEN + 1];
 589         char ipv6_dst_s[IPV6_SCAN_LEN + 1];
 590         int ipv6_proto;
 591         int ipv6_tos;
 592         int n = -1;
 593
 594         if (sscanf(s, "ipv6(src="IPV6_SCAN_FMT",dst="IPV6_SCAN_FMT","
 595                    "proto=%i,tos=%i)%n",
 596                    ipv6_src_s, ipv6_dst_s,
 597                    &ipv6_proto, &ipv6_tos, &n) > 0 && n > 0) {
 598             struct ovs_key_ipv6 ipv6_key;
 599
 600             memset(&ipv6_key, 0, sizeof ipv6_key);
 601             if (inet_pton(AF_INET6, ipv6_src_s, &ipv6_key.ipv6_src) != 1 ||
 602                 inet_pton(AF_INET6, ipv6_dst_s, &ipv6_key.ipv6_dst) != 1) {
 603                 return -EINVAL;
 604             }
 605             ipv6_key.ipv6_proto = ipv6_proto;
 606             ipv6_key.ipv6_tos = ipv6_tos;
 607             nl_msg_put_unspec(key, OVS_KEY_ATTR_IPV6,
 608                               &ipv6_key, sizeof ipv6_key);
 609             return n;
 610         }
 611     }
 612
 613     {
 614         int tcp_src;
 615         int tcp_dst;
 616         int n = -1;
 617
 618         if (sscanf(s, "tcp(src=%i,dst=%i)%n",&tcp_src, &tcp_dst, &n) > 0
 619             && n > 0) {
 620             struct ovs_key_tcp tcp_key;
 621
 622             tcp_key.tcp_src = htons(tcp_src);
 623             tcp_key.tcp_dst = htons(tcp_dst);
 624             nl_msg_put_unspec(key, OVS_KEY_ATTR_TCP, &tcp_key, sizeof tcp_key);
 625             return n;
 626         }
 627     }
 628
 629     {
 630         int udp_src;
 631         int udp_dst;
 632         int n = -1;
 633
 634         if (sscanf(s, "udp(src=%i,dst=%i)%n", &udp_src, &udp_dst, &n) > 0
 635             && n > 0) {
 636             struct ovs_key_udp udp_key;
 637
 638             udp_key.udp_src = htons(udp_src);
 639             udp_key.udp_dst = htons(udp_dst);
 640             nl_msg_put_unspec(key, OVS_KEY_ATTR_UDP, &udp_key, sizeof udp_key);
 641             return n;
 642         }
 643     }
 644
 645     {
 646         int icmp_type;
 647         int icmp_code;
 648         int n = -1;
 649
 650         if (sscanf(s, "icmp(type=%i,code=%i)%n",
 651                    &icmp_type, &icmp_code, &n) > 0
 652             && n > 0) {
 653             struct ovs_key_icmp icmp_key;
 654
 655             icmp_key.icmp_type = icmp_type;
 656             icmp_key.icmp_code = icmp_code;
 657             nl_msg_put_unspec(key, OVS_KEY_ATTR_ICMP,
 658                               &icmp_key, sizeof icmp_key);
 659             return n;
 660         }
 661     }
 662
 663     {
 664         struct ovs_key_icmpv6 icmpv6_key;
 665         int n = -1;
 666
 667         if (sscanf(s, "icmpv6(type=%"SCNi8",code=%"SCNi8")%n",
 668                    &icmpv6_key.icmpv6_type, &icmpv6_key.icmpv6_code,&n) > 0
 669             && n > 0) {
 670             nl_msg_put_unspec(key, OVS_KEY_ATTR_ICMPV6,
 671                               &icmpv6_key, sizeof icmpv6_key);
 672             return n;
 673         }
 674     }
 675
 676     {
 677         ovs_be32 arp_sip;
 678         ovs_be32 arp_tip;
 679         int arp_op;
 680         uint8_t arp_sha[ETH_ADDR_LEN];
 681         uint8_t arp_tha[ETH_ADDR_LEN];
 682         int n = -1;
 683
 684         if (sscanf(s, "arp(sip="IP_SCAN_FMT",tip="IP_SCAN_FMT","
 685                    "op=%i,sha="ETH_ADDR_SCAN_FMT",tha="ETH_ADDR_SCAN_FMT")%n",
 686                    IP_SCAN_ARGS(&arp_sip),
 687                    IP_SCAN_ARGS(&arp_tip),
 688                    &arp_op,
 689                    ETH_ADDR_SCAN_ARGS(arp_sha),
 690                    ETH_ADDR_SCAN_ARGS(arp_tha), &n) > 0 && n > 0) {
 691             struct ovs_key_arp arp_key;
 692
 693             memset(&arp_key, 0, sizeof arp_key);
 694             arp_key.arp_sip = arp_sip;
 695             arp_key.arp_tip = arp_tip;
 696             arp_key.arp_op = htons(arp_op);
 697             memcpy(arp_key.arp_sha, arp_sha, ETH_ADDR_LEN);
 698             memcpy(arp_key.arp_tha, arp_tha, ETH_ADDR_LEN);
 699             nl_msg_put_unspec(key, OVS_KEY_ATTR_ARP, &arp_key, sizeof arp_key);
 700             return n;
 701         }
 702     }
 703
 704     {
 705         char nd_target_s[IPV6_SCAN_LEN + 1];
 706         uint8_t nd_sll[ETH_ADDR_LEN];
 707         uint8_t nd_tll[ETH_ADDR_LEN];
 708         int n = -1;
 709
 710         if (sscanf(s, "nd(target="IPV6_SCAN_FMT")%n",
 711                    nd_target_s, &n) > 0 && n > 0) {
 712             return put_nd_key(n, nd_target_s, NULL, NULL, key);
 713         }
 714         if (sscanf(s, "nd(target="IPV6_SCAN_FMT",sll="ETH_ADDR_SCAN_FMT")%n",
 715                    nd_target_s, ETH_ADDR_SCAN_ARGS(nd_sll), &n) > 0
 716             && n > 0) {
 717             return put_nd_key(n, nd_target_s, nd_sll, NULL, key);
 718         }
 719         if (sscanf(s, "nd(target="IPV6_SCAN_FMT",tll="ETH_ADDR_SCAN_FMT")%n",
 720                    nd_target_s, ETH_ADDR_SCAN_ARGS(nd_tll), &n) > 0
 721             && n > 0) {
 722             return put_nd_key(n, nd_target_s, NULL, nd_tll, key);
 723         }
 724         if (sscanf(s, "nd(target="IPV6_SCAN_FMT",sll="ETH_ADDR_SCAN_FMT","
 725                    "tll="ETH_ADDR_SCAN_FMT")%n",
 726                    nd_target_s, ETH_ADDR_SCAN_ARGS(nd_sll),
 727                    ETH_ADDR_SCAN_ARGS(nd_tll), &n) > 0
 728             && n > 0) {
 729             return put_nd_key(n, nd_target_s, nd_sll, nd_tll, key);
 730         }
 731     }
 732
 733     return -EINVAL;
 734 }
 735
 736 /* Parses the string representation of a datapath flow key, in the
 737  * format output by odp_flow_key_format().  Returns 0 if successful,
 738  * otherwise a positive errno value.  On success, the flow key is
 739  * appended to 'key' as a series of Netlink attributes.  On failure, no
 740  * data is appended to 'key'.  Either way, 'key''s data might be
 741  * reallocated.
 742  *
 743  * On success, the attributes appended to 'key' are individually syntactically
 744  * valid, but they may not be valid as a sequence.  'key' might, for example,
 745  * be missing an "in_port" key, have duplicated keys, or have keys in the wrong
 746  * order.  odp_flow_key_to_flow() will detect those errors. */
 747 int
 748 odp_flow_key_from_string(const char *s, struct ofpbuf *key)
 749 {
 750     const size_t old_size = key->size;
 751     for (;;) {
 752         int retval;
 753
 754         s += strspn(s, ", \t\r\n");
 755         if (!*s) {
 756             return 0;
 757         }
 758
 759         retval = parse_odp_key_attr(s, key);
 760         if (retval < 0) {
 761             key->size = old_size;
 762             return -retval;
 763         }
 764         s += retval;
 765     }
 766
 767     return 0;
 768 }
 769
 770 /* Appends a representation of 'flow' as OVS_KEY_ATTR_* attributes to 'buf'. */
 771 void
 772 odp_flow_key_from_flow(struct ofpbuf *buf, const struct flow *flow)
 773 {
 774     struct ovs_key_ethernet *eth_key;
 775
 776     if (flow->tun_id != htonll(0)) {
 777         nl_msg_put_be64(buf, OVS_KEY_ATTR_TUN_ID, flow->tun_id);
 778     }
 779
 780     if (flow->in_port != OFPP_NONE) {
 781         nl_msg_put_u32(buf, OVS_KEY_ATTR_IN_PORT,
 782                        ofp_port_to_odp_port(flow->in_port));
 783     }
 784
 785     eth_key = nl_msg_put_unspec_uninit(buf, OVS_KEY_ATTR_ETHERNET,
 786                                        sizeof *eth_key);
 787     memcpy(eth_key->eth_src, flow->dl_src, ETH_ADDR_LEN);
 788     memcpy(eth_key->eth_dst, flow->dl_dst, ETH_ADDR_LEN);
 789
 790     if (flow->vlan_tci != htons(0)) {
 791         struct ovs_key_8021q *q_key;
 792
 793         q_key = nl_msg_put_unspec_uninit(buf, OVS_KEY_ATTR_8021Q,
 794                                          sizeof *q_key);
 795         q_key->q_tpid = htons(ETH_TYPE_VLAN);
 796         q_key->q_tci = flow->vlan_tci & ~htons(VLAN_CFI);
 797     }
 798
 799     if (ntohs(flow->dl_type) < ETH_TYPE_MIN) {
 800         return;
 801     }
 802
 803     nl_msg_put_be16(buf, OVS_KEY_ATTR_ETHERTYPE, flow->dl_type);
 804
 805     if (flow->dl_type == htons(ETH_TYPE_IP)) {
 806         struct ovs_key_ipv4 *ipv4_key;
 807
 808         ipv4_key = nl_msg_put_unspec_uninit(buf, OVS_KEY_ATTR_IPV4,
 809                                             sizeof *ipv4_key);
 810         memset(ipv4_key, 0, sizeof *ipv4_key);
 811         ipv4_key->ipv4_src = flow->nw_src;
 812         ipv4_key->ipv4_dst = flow->nw_dst;
 813         ipv4_key->ipv4_proto = flow->nw_proto;
 814         ipv4_key->ipv4_tos = flow->nw_tos;
 815     } else if (flow->dl_type == htons(ETH_TYPE_IPV6)) {
 816         struct ovs_key_ipv6 *ipv6_key;
 817
 818         ipv6_key = nl_msg_put_unspec_uninit(buf, OVS_KEY_ATTR_IPV6,
 819                                             sizeof *ipv6_key);
 820         memset(ipv6_key, 0, sizeof *ipv6_key);
 821         memcpy(ipv6_key->ipv6_src, &flow->ipv6_src, sizeof ipv6_key->ipv6_src);
 822         memcpy(ipv6_key->ipv6_dst, &flow->ipv6_dst, sizeof ipv6_key->ipv6_dst);
 823         ipv6_key->ipv6_proto = flow->nw_proto;
 824         ipv6_key->ipv6_tos = flow->nw_tos;
 825     } else if (flow->dl_type == htons(ETH_TYPE_ARP)) {
 826         struct ovs_key_arp *arp_key;
 827
 828         arp_key = nl_msg_put_unspec_uninit(buf, OVS_KEY_ATTR_ARP,
 829                                            sizeof *arp_key);
 830         memset(arp_key, 0, sizeof *arp_key);
 831         arp_key->arp_sip = flow->nw_src;
 832         arp_key->arp_tip = flow->nw_dst;
 833         arp_key->arp_op = htons(flow->nw_proto);
 834         memcpy(arp_key->arp_sha, flow->arp_sha, ETH_ADDR_LEN);
 835         memcpy(arp_key->arp_tha, flow->arp_tha, ETH_ADDR_LEN);
 836     }
 837
 838     if (flow->dl_type == htons(ETH_TYPE_IP)
 839             || flow->dl_type == htons(ETH_TYPE_IPV6)) {
 840
 841         if (flow->nw_proto == IPPROTO_TCP) {
 842             struct ovs_key_tcp *tcp_key;
 843
 844             tcp_key = nl_msg_put_unspec_uninit(buf, OVS_KEY_ATTR_TCP,
 845                                                sizeof *tcp_key);
 846             tcp_key->tcp_src = flow->tp_src;
 847             tcp_key->tcp_dst = flow->tp_dst;
 848         } else if (flow->nw_proto == IPPROTO_UDP) {
 849             struct ovs_key_udp *udp_key;
 850
 851             udp_key = nl_msg_put_unspec_uninit(buf, OVS_KEY_ATTR_UDP,
 852                                                sizeof *udp_key);
 853             udp_key->udp_src = flow->tp_src;
 854             udp_key->udp_dst = flow->tp_dst;
 855         } else if (flow->dl_type == htons(ETH_TYPE_IP)
 856                 && flow->nw_proto == IPPROTO_ICMP) {
 857             struct ovs_key_icmp *icmp_key;
 858
 859             icmp_key = nl_msg_put_unspec_uninit(buf, OVS_KEY_ATTR_ICMP,
 860                                                 sizeof *icmp_key);
 861             icmp_key->icmp_type = ntohs(flow->tp_src);
 862             icmp_key->icmp_code = ntohs(flow->tp_dst);
 863         } else if (flow->dl_type == htons(ETH_TYPE_IPV6)
 864                 && flow->nw_proto == IPPROTO_ICMPV6) {
 865             struct ovs_key_icmpv6 *icmpv6_key;
 866
 867             icmpv6_key = nl_msg_put_unspec_uninit(buf, OVS_KEY_ATTR_ICMPV6,
 868                                                   sizeof *icmpv6_key);
 869             icmpv6_key->icmpv6_type = ntohs(flow->tp_src);
 870             icmpv6_key->icmpv6_code = ntohs(flow->tp_dst);
 871
 872             if (icmpv6_key->icmpv6_type == ND_NEIGHBOR_SOLICIT
 873                     || icmpv6_key->icmpv6_type == ND_NEIGHBOR_ADVERT) {
 874                 struct ovs_key_nd *nd_key;
 875
 876                 nd_key = nl_msg_put_unspec_uninit(buf, OVS_KEY_ATTR_ND,
 877                                                     sizeof *nd_key);
 878                 memcpy(nd_key->nd_target, &flow->nd_target,
 879                         sizeof nd_key->nd_target);
 880                 memcpy(nd_key->nd_sll, flow->arp_sha, ETH_ADDR_LEN);
 881                 memcpy(nd_key->nd_tll, flow->arp_tha, ETH_ADDR_LEN);
 882             }
 883         }
 884     }
 885 }
 886
 887 /* Converts the 'key_len' bytes of OVS_KEY_ATTR_* attributes in 'key' to a flow
 888  * structure in 'flow'.  Returns 0 if successful, otherwise EINVAL. */
 889 int
 890 odp_flow_key_to_flow(const struct nlattr *key, size_t key_len,
 891                      struct flow *flow)
 892 {
 893     const struct nlattr *nla;
 894     enum ovs_key_attr prev_type;
 895     size_t left;
 896
 897     memset(flow, 0, sizeof *flow);
 898     flow->dl_type = htons(FLOW_DL_TYPE_NONE);
 899     flow->in_port = OFPP_NONE;
 900
 901     prev_type = OVS_KEY_ATTR_UNSPEC;
 902     NL_ATTR_FOR_EACH (nla, left, key, key_len) {
 903         const struct ovs_key_ethernet *eth_key;
 904         const struct ovs_key_8021q *q_key;
 905         const struct ovs_key_ipv4 *ipv4_key;
 906         const struct ovs_key_ipv6 *ipv6_key;
 907         const struct ovs_key_tcp *tcp_key;
 908         const struct ovs_key_udp *udp_key;
 909         const struct ovs_key_icmp *icmp_key;
 910         const struct ovs_key_icmpv6 *icmpv6_key;
 911         const struct ovs_key_arp *arp_key;
 912         const struct ovs_key_nd *nd_key;
 913
 914         uint16_t type = nl_attr_type(nla);
 915         int len = odp_flow_key_attr_len(type);
 916
 917         if (nl_attr_get_size(nla) != len && len != -1) {
 918             return EINVAL;
 919         }
 920
 921 #define TRANSITION(PREV_TYPE, TYPE) (((PREV_TYPE) << 16) | (TYPE))
 922         switch (TRANSITION(prev_type, type)) {
 923         case TRANSITION(OVS_KEY_ATTR_UNSPEC, OVS_KEY_ATTR_TUN_ID):
 924             flow->tun_id = nl_attr_get_be64(nla);
 925             break;
 926
 927         case TRANSITION(OVS_KEY_ATTR_UNSPEC, OVS_KEY_ATTR_IN_PORT):
 928         case TRANSITION(OVS_KEY_ATTR_TUN_ID, OVS_KEY_ATTR_IN_PORT):
 929             if (nl_attr_get_u32(nla) >= UINT16_MAX) {
 930                 return EINVAL;
 931             }
 932             flow->in_port = odp_port_to_ofp_port(nl_attr_get_u32(nla));
 933             break;
 934
 935         case TRANSITION(OVS_KEY_ATTR_UNSPEC, OVS_KEY_ATTR_ETHERNET):
 936         case TRANSITION(OVS_KEY_ATTR_TUN_ID, OVS_KEY_ATTR_ETHERNET):
 937         case TRANSITION(OVS_KEY_ATTR_IN_PORT, OVS_KEY_ATTR_ETHERNET):
 938             eth_key = nl_attr_get(nla);
 939             memcpy(flow->dl_src, eth_key->eth_src, ETH_ADDR_LEN);
 940             memcpy(flow->dl_dst, eth_key->eth_dst, ETH_ADDR_LEN);
 941             break;
 942
 943         case TRANSITION(OVS_KEY_ATTR_ETHERNET, OVS_KEY_ATTR_8021Q):
 944             q_key = nl_attr_get(nla);
 945             if (q_key->q_tpid != htons(ETH_TYPE_VLAN)) {
 946                 /* Only standard 0x8100 VLANs currently supported. */
 947                 return EINVAL;
 948             }
 949             if (q_key->q_tci & htons(VLAN_CFI)) {
 950                 return EINVAL;
 951             }
 952             flow->vlan_tci = q_key->q_tci | htons(VLAN_CFI);
 953             break;
 954
 955         case TRANSITION(OVS_KEY_ATTR_8021Q, OVS_KEY_ATTR_ETHERTYPE):
 956         case TRANSITION(OVS_KEY_ATTR_ETHERNET, OVS_KEY_ATTR_ETHERTYPE):
 957             flow->dl_type = nl_attr_get_be16(nla);
 958             if (ntohs(flow->dl_type) < 1536) {
 959                 return EINVAL;
 960             }
 961             break;
 962
 963         case TRANSITION(OVS_KEY_ATTR_ETHERTYPE, OVS_KEY_ATTR_IPV4):
 964             if (flow->dl_type != htons(ETH_TYPE_IP)) {
 965                 return EINVAL;
 966             }
 967             ipv4_key = nl_attr_get(nla);
 968             flow->nw_src = ipv4_key->ipv4_src;
 969             flow->nw_dst = ipv4_key->ipv4_dst;
 970             flow->nw_proto = ipv4_key->ipv4_proto;
 971             flow->nw_tos = ipv4_key->ipv4_tos;
 972             if (flow->nw_tos & IP_ECN_MASK) {
 973                 return EINVAL;
 974             }
 975             break;
 976
 977         case TRANSITION(OVS_KEY_ATTR_ETHERTYPE, OVS_KEY_ATTR_IPV6):
 978             if (flow->dl_type != htons(ETH_TYPE_IPV6)) {
 979                 return EINVAL;
 980             }
 981             ipv6_key = nl_attr_get(nla);
 982             memcpy(&flow->ipv6_src, ipv6_key->ipv6_src, sizeof flow->ipv6_src);
 983             memcpy(&flow->ipv6_dst, ipv6_key->ipv6_dst, sizeof flow->ipv6_dst);
 984             flow->nw_proto = ipv6_key->ipv6_proto;
 985             flow->nw_tos = ipv6_key->ipv6_tos;
 986             if (flow->nw_tos & IP_ECN_MASK) {
 987                 return EINVAL;
 988             }
 989             break;
 990
 991         case TRANSITION(OVS_KEY_ATTR_IPV4, OVS_KEY_ATTR_TCP):
 992         case TRANSITION(OVS_KEY_ATTR_IPV6, OVS_KEY_ATTR_TCP):
 993             if (flow->nw_proto != IPPROTO_TCP) {
 994                 return EINVAL;
 995             }
 996             tcp_key = nl_attr_get(nla);
 997             flow->tp_src = tcp_key->tcp_src;
 998             flow->tp_dst = tcp_key->tcp_dst;
 999             break;
1000
1001         case TRANSITION(OVS_KEY_ATTR_IPV4, OVS_KEY_ATTR_UDP):
1002         case TRANSITION(OVS_KEY_ATTR_IPV6, OVS_KEY_ATTR_UDP):
1003             if (flow->nw_proto != IPPROTO_UDP) {
1004                 return EINVAL;
1005             }
1006             udp_key = nl_attr_get(nla);
1007             flow->tp_src = udp_key->udp_src;
1008             flow->tp_dst = udp_key->udp_dst;
1009             break;
1010
1011         case TRANSITION(OVS_KEY_ATTR_IPV4, OVS_KEY_ATTR_ICMP):
1012             if (flow->nw_proto != IPPROTO_ICMP) {
1013                 return EINVAL;
1014             }
1015             icmp_key = nl_attr_get(nla);
1016             flow->tp_src = htons(icmp_key->icmp_type);
1017             flow->tp_dst = htons(icmp_key->icmp_code);
1018             break;
1019
1020         case TRANSITION(OVS_KEY_ATTR_IPV6, OVS_KEY_ATTR_ICMPV6):
1021             if (flow->nw_proto != IPPROTO_ICMPV6) {
1022                 return EINVAL;
1023             }
1024             icmpv6_key = nl_attr_get(nla);
1025             flow->tp_src = htons(icmpv6_key->icmpv6_type);
1026             flow->tp_dst = htons(icmpv6_key->icmpv6_code);
1027             break;
1028
1029         case TRANSITION(OVS_KEY_ATTR_ETHERTYPE, OVS_KEY_ATTR_ARP):
1030             if (flow->dl_type != htons(ETH_TYPE_ARP)) {
1031                 return EINVAL;
1032             }
1033             arp_key = nl_attr_get(nla);
1034             flow->nw_src = arp_key->arp_sip;
1035             flow->nw_dst = arp_key->arp_tip;
1036             if (arp_key->arp_op & htons(0xff00)) {
1037                 return EINVAL;
1038             }
1039             flow->nw_proto = ntohs(arp_key->arp_op);
1040             memcpy(flow->arp_sha, arp_key->arp_sha, ETH_ADDR_LEN);
1041             memcpy(flow->arp_tha, arp_key->arp_tha, ETH_ADDR_LEN);
1042             break;
1043
1044         case TRANSITION(OVS_KEY_ATTR_ICMPV6, OVS_KEY_ATTR_ND):
1045             if (flow->tp_src != htons(ND_NEIGHBOR_SOLICIT)
1046                     && flow->tp_src != htons(ND_NEIGHBOR_ADVERT)) {
1047                 return EINVAL;
1048             }
1049             nd_key = nl_attr_get(nla);
1050             memcpy(&flow->nd_target, nd_key->nd_target, sizeof flow->nd_target);
1051             memcpy(flow->arp_sha, nd_key->nd_sll, ETH_ADDR_LEN);
1052             memcpy(flow->arp_tha, nd_key->nd_tll, ETH_ADDR_LEN);
1053             break;
1054
1055         default:
1056             return EINVAL;
1057         }
1058
1059         prev_type = type;
1060     }
1061     if (left) {
1062         return EINVAL;
1063     }
1064
1065     switch (prev_type) {
1066     case OVS_KEY_ATTR_UNSPEC:
1067         return EINVAL;
1068
1069     case OVS_KEY_ATTR_TUN_ID:
1070     case OVS_KEY_ATTR_IN_PORT:
1071         return EINVAL;
1072
1073     case OVS_KEY_ATTR_ETHERNET:
1074     case OVS_KEY_ATTR_8021Q:
1075         return 0;
1076
1077     case OVS_KEY_ATTR_ETHERTYPE:
1078         if (flow->dl_type == htons(ETH_TYPE_IP)
1079             || flow->dl_type == htons(ETH_TYPE_IPV6)
1080             || flow->dl_type == htons(ETH_TYPE_ARP)) {
1081             return EINVAL;
1082         }
1083         return 0;
1084
1085     case OVS_KEY_ATTR_IPV4:
1086         if (flow->nw_proto == IPPROTO_TCP
1087             || flow->nw_proto == IPPROTO_UDP
1088             || flow->nw_proto == IPPROTO_ICMP) {
1089             return EINVAL;
1090         }
1091         return 0;
1092
1093     case OVS_KEY_ATTR_IPV6:
1094         if (flow->nw_proto == IPPROTO_TCP
1095             || flow->nw_proto == IPPROTO_UDP
1096             || flow->nw_proto == IPPROTO_ICMPV6) {
1097             return EINVAL;
1098         }
1099         return 0;
1100
1101     case OVS_KEY_ATTR_ICMPV6:
1102         if (flow->tp_src == htons(ND_NEIGHBOR_SOLICIT)
1103             || flow->tp_src == htons(ND_NEIGHBOR_ADVERT)) {
1104             return EINVAL;
1105         }
1106         return 0;
1107
1108     case OVS_KEY_ATTR_TCP:
1109     case OVS_KEY_ATTR_UDP:
1110     case OVS_KEY_ATTR_ICMP:
1111     case OVS_KEY_ATTR_ARP:
1112     case OVS_KEY_ATTR_ND:
1113         return 0;
1114
1115     case __OVS_KEY_ATTR_MAX:
1116     default:
1117         NOT_REACHED();
1118     }
1119 }