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