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 const char *
 303 ovs_frag_type_to_string(enum ovs_frag_type type)
 304 {
 305     switch (type) {
 306     case OVS_FRAG_TYPE_NONE:
 307         return "no";
 308     case OVS_FRAG_TYPE_FIRST:
 309         return "first";
 310     case OVS_FRAG_TYPE_LATER:
 311         return "later";
 312     case __OVS_FRAG_TYPE_MAX:
 313     default:
 314         return "<error>";
 315     }
 316 }
 317
 318 static void
 319 format_odp_key_attr(const struct nlattr *a, struct ds *ds)
 320 {
 321     const struct ovs_key_ethernet *eth_key;
 322     const struct ovs_key_8021q *q_key;
 323     const struct ovs_key_ipv4 *ipv4_key;
 324     const struct ovs_key_ipv6 *ipv6_key;
 325     const struct ovs_key_tcp *tcp_key;
 326     const struct ovs_key_udp *udp_key;
 327     const struct ovs_key_icmp *icmp_key;
 328     const struct ovs_key_icmpv6 *icmpv6_key;
 329     const struct ovs_key_arp *arp_key;
 330     const struct ovs_key_nd *nd_key;
 331
 332     if (nl_attr_get_size(a) != odp_flow_key_attr_len(nl_attr_type(a))) {
 333         ds_put_format(ds, "bad length %zu, expected %d for: ",
 334                       nl_attr_get_size(a),
 335                       odp_flow_key_attr_len(nl_attr_type(a)));
 336         format_generic_odp_key(a, ds);
 337         return;
 338     }
 339
 340     switch (nl_attr_type(a)) {
 341     case OVS_KEY_ATTR_TUN_ID:
 342         ds_put_format(ds, "tun_id(%#"PRIx64")", ntohll(nl_attr_get_be64(a)));
 343         break;
 344
 345     case OVS_KEY_ATTR_IN_PORT:
 346         ds_put_format(ds, "in_port(%"PRIu32")", nl_attr_get_u32(a));
 347         break;
 348
 349     case OVS_KEY_ATTR_ETHERNET:
 350         eth_key = nl_attr_get(a);
 351         ds_put_format(ds, "eth(src="ETH_ADDR_FMT",dst="ETH_ADDR_FMT")",
 352                       ETH_ADDR_ARGS(eth_key->eth_src),
 353                       ETH_ADDR_ARGS(eth_key->eth_dst));
 354         break;
 355
 356     case OVS_KEY_ATTR_8021Q:
 357         q_key = nl_attr_get(a);
 358         ds_put_cstr(ds, "vlan(");
 359         if (q_key->q_tpid != htons(ETH_TYPE_VLAN)) {
 360             ds_put_format(ds, "tpid=0x%04"PRIx16",", ntohs(q_key->q_tpid));
 361         }
 362         ds_put_format(ds, "vid=%"PRIu16",pcp=%d)",
 363                       vlan_tci_to_vid(q_key->q_tci),
 364                       vlan_tci_to_pcp(q_key->q_tci));
 365         break;
 366
 367     case OVS_KEY_ATTR_ETHERTYPE:
 368         ds_put_format(ds, "eth_type(0x%04"PRIx16")",
 369                       ntohs(nl_attr_get_be16(a)));
 370         break;
 371
 372     case OVS_KEY_ATTR_IPV4:
 373         ipv4_key = nl_attr_get(a);
 374         ds_put_format(ds, "ipv4(src="IP_FMT",dst="IP_FMT","
 375                       "proto=%"PRId8",tos=%"PRIu8",frag=%s)",
 376                       IP_ARGS(&ipv4_key->ipv4_src),
 377                       IP_ARGS(&ipv4_key->ipv4_dst),
 378                       ipv4_key->ipv4_proto, ipv4_key->ipv4_tos,
 379                       ovs_frag_type_to_string(ipv4_key->ipv4_frag));
 380         break;
 381
 382     case OVS_KEY_ATTR_IPV6: {
 383         char src_str[INET6_ADDRSTRLEN];
 384         char dst_str[INET6_ADDRSTRLEN];
 385
 386         ipv6_key = nl_attr_get(a);
 387         inet_ntop(AF_INET6, ipv6_key->ipv6_src, src_str, sizeof src_str);
 388         inet_ntop(AF_INET6, ipv6_key->ipv6_dst, dst_str, sizeof dst_str);
 389
 390         ds_put_format(ds, "ipv6(src=%s,dst=%s,proto=%"PRId8",tos=%"PRIu8","
 391                       "frag=%s)",
 392                       src_str, dst_str, ipv6_key->ipv6_proto,
 393                       ipv6_key->ipv6_tos,
 394                       ovs_frag_type_to_string(ipv6_key->ipv6_frag));
 395         break;
 396     }
 397
 398     case OVS_KEY_ATTR_TCP:
 399         tcp_key = nl_attr_get(a);
 400         ds_put_format(ds, "tcp(src=%"PRIu16",dst=%"PRIu16")",
 401                       ntohs(tcp_key->tcp_src), ntohs(tcp_key->tcp_dst));
 402         break;
 403
 404     case OVS_KEY_ATTR_UDP:
 405         udp_key = nl_attr_get(a);
 406         ds_put_format(ds, "udp(src=%"PRIu16",dst=%"PRIu16")",
 407                       ntohs(udp_key->udp_src), ntohs(udp_key->udp_dst));
 408         break;
 409
 410     case OVS_KEY_ATTR_ICMP:
 411         icmp_key = nl_attr_get(a);
 412         ds_put_format(ds, "icmp(type=%"PRIu8",code=%"PRIu8")",
 413                       icmp_key->icmp_type, icmp_key->icmp_code);
 414         break;
 415
 416     case OVS_KEY_ATTR_ICMPV6:
 417         icmpv6_key = nl_attr_get(a);
 418         ds_put_format(ds, "icmpv6(type=%"PRIu8",code=%"PRIu8")",
 419                       icmpv6_key->icmpv6_type, icmpv6_key->icmpv6_code);
 420         break;
 421
 422     case OVS_KEY_ATTR_ARP:
 423         arp_key = nl_attr_get(a);
 424         ds_put_format(ds, "arp(sip="IP_FMT",tip="IP_FMT",op=%"PRIu16","
 425                       "sha="ETH_ADDR_FMT",tha="ETH_ADDR_FMT")",
 426                       IP_ARGS(&arp_key->arp_sip), IP_ARGS(&arp_key->arp_tip),
 427                       ntohs(arp_key->arp_op), ETH_ADDR_ARGS(arp_key->arp_sha),
 428                       ETH_ADDR_ARGS(arp_key->arp_tha));
 429         break;
 430
 431     case OVS_KEY_ATTR_ND: {
 432         char target[INET6_ADDRSTRLEN];
 433
 434         nd_key = nl_attr_get(a);
 435         inet_ntop(AF_INET6, nd_key->nd_target, target, sizeof target);
 436
 437         ds_put_format(ds, "nd(target=%s", target);
 438         if (!eth_addr_is_zero(nd_key->nd_sll)) {
 439             ds_put_format(ds, ",sll="ETH_ADDR_FMT,
 440                           ETH_ADDR_ARGS(nd_key->nd_sll));
 441         }
 442         if (!eth_addr_is_zero(nd_key->nd_tll)) {
 443             ds_put_format(ds, ",tll="ETH_ADDR_FMT,
 444                           ETH_ADDR_ARGS(nd_key->nd_tll));
 445         }
 446         ds_put_char(ds, ')');
 447         break;
 448     }
 449
 450     default:
 451         format_generic_odp_key(a, ds);
 452         break;
 453     }
 454 }
 455
 456 /* Appends to 'ds' a string representation of the 'key_len' bytes of
 457  * OVS_KEY_ATTR_* attributes in 'key'. */
 458 void
 459 odp_flow_key_format(const struct nlattr *key, size_t key_len, struct ds *ds)
 460 {
 461     if (key_len) {
 462         const struct nlattr *a;
 463         unsigned int left;
 464
 465         NL_ATTR_FOR_EACH (a, left, key, key_len) {
 466             if (a != key) {
 467                 ds_put_char(ds, ',');
 468             }
 469             format_odp_key_attr(a, ds);
 470         }
 471         if (left) {
 472             if (left == key_len) {
 473                 ds_put_cstr(ds, "<empty>");
 474             }
 475             ds_put_format(ds, ",***%u leftover bytes***", left);
 476         }
 477     } else {
 478         ds_put_cstr(ds, "<empty>");
 479     }
 480 }
 481
 482 static int
 483 put_nd_key(int n, const char *nd_target_s,
 484            const uint8_t *nd_sll, const uint8_t *nd_tll, struct ofpbuf *key)
 485 {
 486     struct ovs_key_nd nd_key;
 487
 488     memset(&nd_key, 0, sizeof nd_key);
 489     if (inet_pton(AF_INET6, nd_target_s, nd_key.nd_target) != 1) {
 490         return -EINVAL;
 491     }
 492     if (nd_sll) {
 493         memcpy(nd_key.nd_sll, nd_sll, ETH_ADDR_LEN);
 494     }
 495     if (nd_tll) {
 496         memcpy(nd_key.nd_tll, nd_tll, ETH_ADDR_LEN);
 497     }
 498     nl_msg_put_unspec(key, OVS_KEY_ATTR_ND, &nd_key, sizeof nd_key);
 499     return n;
 500 }
 501
 502 static bool
 503 ovs_frag_type_from_string(const char *s, enum ovs_frag_type *type)
 504 {
 505     if (!strcasecmp(s, "no")) {
 506         *type = OVS_FRAG_TYPE_NONE;
 507     } else if (!strcasecmp(s, "first")) {
 508         *type = OVS_FRAG_TYPE_FIRST;
 509     } else if (!strcasecmp(s, "later")) {
 510         *type = OVS_FRAG_TYPE_LATER;
 511     } else {
 512         return false;
 513     }
 514     return true;
 515 }
 516
 517 static int
 518 parse_odp_key_attr(const char *s, struct ofpbuf *key)
 519 {
 520     /* Many of the sscanf calls in this function use oversized destination
 521      * fields because some sscanf() implementations truncate the range of %i
 522      * directives, so that e.g. "%"SCNi16 interprets input of "0xfedc" as a
 523      * value of 0x7fff.  The other alternatives are to allow only a single
 524      * radix (e.g. decimal or hexadecimal) or to write more sophisticated
 525      * parsers.
 526      *
 527      * The tun_id parser has to use an alternative approach because there is no
 528      * type larger than 64 bits. */
 529
 530     {
 531         char tun_id_s[32];
 532         int n = -1;
 533
 534         if (sscanf(s, "tun_id(%31[x0123456789abcdefABCDEF])%n",
 535                    tun_id_s, &n) > 0 && n > 0) {
 536             uint64_t tun_id = strtoull(tun_id_s, NULL, 0);
 537             nl_msg_put_be64(key, OVS_KEY_ATTR_TUN_ID, htonll(tun_id));
 538             return n;
 539         }
 540     }
 541
 542     {
 543         unsigned long long int in_port;
 544         int n = -1;
 545
 546         if (sscanf(s, "in_port(%lli)%n", &in_port, &n) > 0 && n > 0) {
 547             nl_msg_put_u32(key, OVS_KEY_ATTR_IN_PORT, in_port);
 548             return n;
 549         }
 550     }
 551
 552     {
 553         struct ovs_key_ethernet eth_key;
 554         int n = -1;
 555
 556         if (sscanf(s,
 557                    "eth(src="ETH_ADDR_SCAN_FMT",dst="ETH_ADDR_SCAN_FMT")%n",
 558                    ETH_ADDR_SCAN_ARGS(eth_key.eth_src),
 559                    ETH_ADDR_SCAN_ARGS(eth_key.eth_dst), &n) > 0 && n > 0) {
 560             nl_msg_put_unspec(key, OVS_KEY_ATTR_ETHERNET,
 561                               &eth_key, sizeof eth_key);
 562             return n;
 563         }
 564     }
 565
 566     {
 567         uint16_t tpid = ETH_TYPE_VLAN;
 568         uint16_t vid;
 569         int pcp;
 570         int n = -1;
 571
 572         if ((sscanf(s, "vlan(vid=%"SCNi16",pcp=%i)%n",
 573                     &vid, &pcp, &n) > 0 && n > 0) ||
 574             (sscanf(s, "vlan(tpid=%"SCNi16",vid=%"SCNi16",pcp=%i)%n",
 575                     &tpid, &vid, &pcp, &n) > 0 && n > 0)) {
 576             struct ovs_key_8021q q_key;
 577
 578             q_key.q_tpid = htons(tpid);
 579             q_key.q_tci = htons((vid << VLAN_VID_SHIFT) |
 580                                 (pcp << VLAN_PCP_SHIFT));
 581             nl_msg_put_unspec(key, OVS_KEY_ATTR_8021Q, &q_key, sizeof q_key);
 582             return n;
 583         }
 584     }
 585
 586     {
 587         int eth_type;
 588         int n = -1;
 589
 590         if (sscanf(s, "eth_type(%i)%n", &eth_type, &n) > 0 && n > 0) {
 591             nl_msg_put_be16(key, OVS_KEY_ATTR_ETHERTYPE, htons(eth_type));
 592             return n;
 593         }
 594     }
 595
 596     {
 597         ovs_be32 ipv4_src;
 598         ovs_be32 ipv4_dst;
 599         int ipv4_proto;
 600         int ipv4_tos;
 601         char frag[8];
 602         enum ovs_frag_type ipv4_frag;
 603         int n = -1;
 604
 605         if (sscanf(s, "ipv4(src="IP_SCAN_FMT",dst="IP_SCAN_FMT","
 606                    "proto=%i,tos=%i,frag=%7[a-z])%n",
 607                    IP_SCAN_ARGS(&ipv4_src), IP_SCAN_ARGS(&ipv4_dst),
 608                    &ipv4_proto, &ipv4_tos, frag, &n) > 0
 609             && n > 0
 610             && ovs_frag_type_from_string(frag, &ipv4_frag)) {
 611             struct ovs_key_ipv4 ipv4_key;
 612
 613             memset(&ipv4_key, 0, sizeof ipv4_key);
 614             ipv4_key.ipv4_src = ipv4_src;
 615             ipv4_key.ipv4_dst = ipv4_dst;
 616             ipv4_key.ipv4_proto = ipv4_proto;
 617             ipv4_key.ipv4_tos = ipv4_tos;
 618             ipv4_key.ipv4_frag = ipv4_frag;
 619             nl_msg_put_unspec(key, OVS_KEY_ATTR_IPV4,
 620                               &ipv4_key, sizeof ipv4_key);
 621             return n;
 622         }
 623     }
 624
 625     {
 626         char ipv6_src_s[IPV6_SCAN_LEN + 1];
 627         char ipv6_dst_s[IPV6_SCAN_LEN + 1];
 628         int ipv6_proto;
 629         int ipv6_tos;
 630         char frag[8];
 631         enum ovs_frag_type ipv6_frag;
 632         int n = -1;
 633
 634         if (sscanf(s, "ipv6(src="IPV6_SCAN_FMT",dst="IPV6_SCAN_FMT","
 635                    "proto=%i,tos=%i,frag=%7[a-z])%n",
 636                    ipv6_src_s, ipv6_dst_s,
 637                    &ipv6_proto, &ipv6_tos, frag, &n) > 0
 638             && n > 0
 639             && ovs_frag_type_from_string(frag, &ipv6_frag)) {
 640             struct ovs_key_ipv6 ipv6_key;
 641
 642             memset(&ipv6_key, 0, sizeof ipv6_key);
 643             if (inet_pton(AF_INET6, ipv6_src_s, &ipv6_key.ipv6_src) != 1 ||
 644                 inet_pton(AF_INET6, ipv6_dst_s, &ipv6_key.ipv6_dst) != 1) {
 645                 return -EINVAL;
 646             }
 647             ipv6_key.ipv6_proto = ipv6_proto;
 648             ipv6_key.ipv6_tos = ipv6_tos;
 649             ipv6_key.ipv6_frag = ipv6_frag;
 650             nl_msg_put_unspec(key, OVS_KEY_ATTR_IPV6,
 651                               &ipv6_key, sizeof ipv6_key);
 652             return n;
 653         }
 654     }
 655
 656     {
 657         int tcp_src;
 658         int tcp_dst;
 659         int n = -1;
 660
 661         if (sscanf(s, "tcp(src=%i,dst=%i)%n",&tcp_src, &tcp_dst, &n) > 0
 662             && n > 0) {
 663             struct ovs_key_tcp tcp_key;
 664
 665             tcp_key.tcp_src = htons(tcp_src);
 666             tcp_key.tcp_dst = htons(tcp_dst);
 667             nl_msg_put_unspec(key, OVS_KEY_ATTR_TCP, &tcp_key, sizeof tcp_key);
 668             return n;
 669         }
 670     }
 671
 672     {
 673         int udp_src;
 674         int udp_dst;
 675         int n = -1;
 676
 677         if (sscanf(s, "udp(src=%i,dst=%i)%n", &udp_src, &udp_dst, &n) > 0
 678             && n > 0) {
 679             struct ovs_key_udp udp_key;
 680
 681             udp_key.udp_src = htons(udp_src);
 682             udp_key.udp_dst = htons(udp_dst);
 683             nl_msg_put_unspec(key, OVS_KEY_ATTR_UDP, &udp_key, sizeof udp_key);
 684             return n;
 685         }
 686     }
 687
 688     {
 689         int icmp_type;
 690         int icmp_code;
 691         int n = -1;
 692
 693         if (sscanf(s, "icmp(type=%i,code=%i)%n",
 694                    &icmp_type, &icmp_code, &n) > 0
 695             && n > 0) {
 696             struct ovs_key_icmp icmp_key;
 697
 698             icmp_key.icmp_type = icmp_type;
 699             icmp_key.icmp_code = icmp_code;
 700             nl_msg_put_unspec(key, OVS_KEY_ATTR_ICMP,
 701                               &icmp_key, sizeof icmp_key);
 702             return n;
 703         }
 704     }
 705
 706     {
 707         struct ovs_key_icmpv6 icmpv6_key;
 708         int n = -1;
 709
 710         if (sscanf(s, "icmpv6(type=%"SCNi8",code=%"SCNi8")%n",
 711                    &icmpv6_key.icmpv6_type, &icmpv6_key.icmpv6_code,&n) > 0
 712             && n > 0) {
 713             nl_msg_put_unspec(key, OVS_KEY_ATTR_ICMPV6,
 714                               &icmpv6_key, sizeof icmpv6_key);
 715             return n;
 716         }
 717     }
 718
 719     {
 720         ovs_be32 arp_sip;
 721         ovs_be32 arp_tip;
 722         int arp_op;
 723         uint8_t arp_sha[ETH_ADDR_LEN];
 724         uint8_t arp_tha[ETH_ADDR_LEN];
 725         int n = -1;
 726
 727         if (sscanf(s, "arp(sip="IP_SCAN_FMT",tip="IP_SCAN_FMT","
 728                    "op=%i,sha="ETH_ADDR_SCAN_FMT",tha="ETH_ADDR_SCAN_FMT")%n",
 729                    IP_SCAN_ARGS(&arp_sip),
 730                    IP_SCAN_ARGS(&arp_tip),
 731                    &arp_op,
 732                    ETH_ADDR_SCAN_ARGS(arp_sha),
 733                    ETH_ADDR_SCAN_ARGS(arp_tha), &n) > 0 && n > 0) {
 734             struct ovs_key_arp arp_key;
 735
 736             memset(&arp_key, 0, sizeof arp_key);
 737             arp_key.arp_sip = arp_sip;
 738             arp_key.arp_tip = arp_tip;
 739             arp_key.arp_op = htons(arp_op);
 740             memcpy(arp_key.arp_sha, arp_sha, ETH_ADDR_LEN);
 741             memcpy(arp_key.arp_tha, arp_tha, ETH_ADDR_LEN);
 742             nl_msg_put_unspec(key, OVS_KEY_ATTR_ARP, &arp_key, sizeof arp_key);
 743             return n;
 744         }
 745     }
 746
 747     {
 748         char nd_target_s[IPV6_SCAN_LEN + 1];
 749         uint8_t nd_sll[ETH_ADDR_LEN];
 750         uint8_t nd_tll[ETH_ADDR_LEN];
 751         int n = -1;
 752
 753         if (sscanf(s, "nd(target="IPV6_SCAN_FMT")%n",
 754                    nd_target_s, &n) > 0 && n > 0) {
 755             return put_nd_key(n, nd_target_s, NULL, NULL, key);
 756         }
 757         if (sscanf(s, "nd(target="IPV6_SCAN_FMT",sll="ETH_ADDR_SCAN_FMT")%n",
 758                    nd_target_s, ETH_ADDR_SCAN_ARGS(nd_sll), &n) > 0
 759             && n > 0) {
 760             return put_nd_key(n, nd_target_s, nd_sll, NULL, key);
 761         }
 762         if (sscanf(s, "nd(target="IPV6_SCAN_FMT",tll="ETH_ADDR_SCAN_FMT")%n",
 763                    nd_target_s, ETH_ADDR_SCAN_ARGS(nd_tll), &n) > 0
 764             && n > 0) {
 765             return put_nd_key(n, nd_target_s, NULL, nd_tll, key);
 766         }
 767         if (sscanf(s, "nd(target="IPV6_SCAN_FMT",sll="ETH_ADDR_SCAN_FMT","
 768                    "tll="ETH_ADDR_SCAN_FMT")%n",
 769                    nd_target_s, ETH_ADDR_SCAN_ARGS(nd_sll),
 770                    ETH_ADDR_SCAN_ARGS(nd_tll), &n) > 0
 771             && n > 0) {
 772             return put_nd_key(n, nd_target_s, nd_sll, nd_tll, key);
 773         }
 774     }
 775
 776     return -EINVAL;
 777 }
 778
 779 /* Parses the string representation of a datapath flow key, in the
 780  * format output by odp_flow_key_format().  Returns 0 if successful,
 781  * otherwise a positive errno value.  On success, the flow key is
 782  * appended to 'key' as a series of Netlink attributes.  On failure, no
 783  * data is appended to 'key'.  Either way, 'key''s data might be
 784  * reallocated.
 785  *
 786  * On success, the attributes appended to 'key' are individually syntactically
 787  * valid, but they may not be valid as a sequence.  'key' might, for example,
 788  * be missing an "in_port" key, have duplicated keys, or have keys in the wrong
 789  * order.  odp_flow_key_to_flow() will detect those errors. */
 790 int
 791 odp_flow_key_from_string(const char *s, struct ofpbuf *key)
 792 {
 793     const size_t old_size = key->size;
 794     for (;;) {
 795         int retval;
 796
 797         s += strspn(s, ", \t\r\n");
 798         if (!*s) {
 799             return 0;
 800         }
 801
 802         retval = parse_odp_key_attr(s, key);
 803         if (retval < 0) {
 804             key->size = old_size;
 805             return -retval;
 806         }
 807         s += retval;
 808     }
 809
 810     return 0;
 811 }
 812
 813 static uint8_t
 814 tos_frag_to_odp_frag(uint8_t tos_frag)
 815 {
 816     return (tos_frag & FLOW_FRAG_LATER ? OVS_FRAG_TYPE_LATER
 817             : tos_frag & FLOW_FRAG_ANY ? OVS_FRAG_TYPE_FIRST
 818             : OVS_FRAG_TYPE_NONE);
 819 }
 820
 821 /* Appends a representation of 'flow' as OVS_KEY_ATTR_* attributes to 'buf'. */
 822 void
 823 odp_flow_key_from_flow(struct ofpbuf *buf, const struct flow *flow)
 824 {
 825     struct ovs_key_ethernet *eth_key;
 826
 827     if (flow->tun_id != htonll(0)) {
 828         nl_msg_put_be64(buf, OVS_KEY_ATTR_TUN_ID, flow->tun_id);
 829     }
 830
 831     if (flow->in_port != OFPP_NONE) {
 832         nl_msg_put_u32(buf, OVS_KEY_ATTR_IN_PORT,
 833                        ofp_port_to_odp_port(flow->in_port));
 834     }
 835
 836     eth_key = nl_msg_put_unspec_uninit(buf, OVS_KEY_ATTR_ETHERNET,
 837                                        sizeof *eth_key);
 838     memcpy(eth_key->eth_src, flow->dl_src, ETH_ADDR_LEN);
 839     memcpy(eth_key->eth_dst, flow->dl_dst, ETH_ADDR_LEN);
 840
 841     if (flow->vlan_tci != htons(0)) {
 842         struct ovs_key_8021q *q_key;
 843
 844         q_key = nl_msg_put_unspec_uninit(buf, OVS_KEY_ATTR_8021Q,
 845                                          sizeof *q_key);
 846         q_key->q_tpid = htons(ETH_TYPE_VLAN);
 847         q_key->q_tci = flow->vlan_tci & ~htons(VLAN_CFI);
 848     }
 849
 850     if (ntohs(flow->dl_type) < ETH_TYPE_MIN) {
 851         return;
 852     }
 853
 854     nl_msg_put_be16(buf, OVS_KEY_ATTR_ETHERTYPE, flow->dl_type);
 855
 856     if (flow->dl_type == htons(ETH_TYPE_IP)) {
 857         struct ovs_key_ipv4 *ipv4_key;
 858
 859         ipv4_key = nl_msg_put_unspec_uninit(buf, OVS_KEY_ATTR_IPV4,
 860                                             sizeof *ipv4_key);
 861         memset(ipv4_key, 0, sizeof *ipv4_key);
 862         ipv4_key->ipv4_src = flow->nw_src;
 863         ipv4_key->ipv4_dst = flow->nw_dst;
 864         ipv4_key->ipv4_proto = flow->nw_proto;
 865         ipv4_key->ipv4_tos = flow->tos_frag & IP_DSCP_MASK;
 866         ipv4_key->ipv4_frag = tos_frag_to_odp_frag(flow->tos_frag);
 867     } else if (flow->dl_type == htons(ETH_TYPE_IPV6)) {
 868         struct ovs_key_ipv6 *ipv6_key;
 869
 870         ipv6_key = nl_msg_put_unspec_uninit(buf, OVS_KEY_ATTR_IPV6,
 871                                             sizeof *ipv6_key);
 872         memset(ipv6_key, 0, sizeof *ipv6_key);
 873         memcpy(ipv6_key->ipv6_src, &flow->ipv6_src, sizeof ipv6_key->ipv6_src);
 874         memcpy(ipv6_key->ipv6_dst, &flow->ipv6_dst, sizeof ipv6_key->ipv6_dst);
 875         ipv6_key->ipv6_proto = flow->nw_proto;
 876         ipv6_key->ipv6_tos = flow->tos_frag & IP_DSCP_MASK;
 877         ipv6_key->ipv6_frag = tos_frag_to_odp_frag(flow->tos_frag);
 878     } else if (flow->dl_type == htons(ETH_TYPE_ARP)) {
 879         struct ovs_key_arp *arp_key;
 880
 881         arp_key = nl_msg_put_unspec_uninit(buf, OVS_KEY_ATTR_ARP,
 882                                            sizeof *arp_key);
 883         memset(arp_key, 0, sizeof *arp_key);
 884         arp_key->arp_sip = flow->nw_src;
 885         arp_key->arp_tip = flow->nw_dst;
 886         arp_key->arp_op = htons(flow->nw_proto);
 887         memcpy(arp_key->arp_sha, flow->arp_sha, ETH_ADDR_LEN);
 888         memcpy(arp_key->arp_tha, flow->arp_tha, ETH_ADDR_LEN);
 889     }
 890
 891     if ((flow->dl_type == htons(ETH_TYPE_IP)
 892          || flow->dl_type == htons(ETH_TYPE_IPV6))
 893         && !(flow->tos_frag & FLOW_FRAG_LATER)) {
 894
 895         if (flow->nw_proto == IPPROTO_TCP) {
 896             struct ovs_key_tcp *tcp_key;
 897
 898             tcp_key = nl_msg_put_unspec_uninit(buf, OVS_KEY_ATTR_TCP,
 899                                                sizeof *tcp_key);
 900             tcp_key->tcp_src = flow->tp_src;
 901             tcp_key->tcp_dst = flow->tp_dst;
 902         } else if (flow->nw_proto == IPPROTO_UDP) {
 903             struct ovs_key_udp *udp_key;
 904
 905             udp_key = nl_msg_put_unspec_uninit(buf, OVS_KEY_ATTR_UDP,
 906                                                sizeof *udp_key);
 907             udp_key->udp_src = flow->tp_src;
 908             udp_key->udp_dst = flow->tp_dst;
 909         } else if (flow->dl_type == htons(ETH_TYPE_IP)
 910                 && flow->nw_proto == IPPROTO_ICMP) {
 911             struct ovs_key_icmp *icmp_key;
 912
 913             icmp_key = nl_msg_put_unspec_uninit(buf, OVS_KEY_ATTR_ICMP,
 914                                                 sizeof *icmp_key);
 915             icmp_key->icmp_type = ntohs(flow->tp_src);
 916             icmp_key->icmp_code = ntohs(flow->tp_dst);
 917         } else if (flow->dl_type == htons(ETH_TYPE_IPV6)
 918                 && flow->nw_proto == IPPROTO_ICMPV6) {
 919             struct ovs_key_icmpv6 *icmpv6_key;
 920
 921             icmpv6_key = nl_msg_put_unspec_uninit(buf, OVS_KEY_ATTR_ICMPV6,
 922                                                   sizeof *icmpv6_key);
 923             icmpv6_key->icmpv6_type = ntohs(flow->tp_src);
 924             icmpv6_key->icmpv6_code = ntohs(flow->tp_dst);
 925
 926             if (icmpv6_key->icmpv6_type == ND_NEIGHBOR_SOLICIT
 927                     || icmpv6_key->icmpv6_type == ND_NEIGHBOR_ADVERT) {
 928                 struct ovs_key_nd *nd_key;
 929
 930                 nd_key = nl_msg_put_unspec_uninit(buf, OVS_KEY_ATTR_ND,
 931                                                     sizeof *nd_key);
 932                 memcpy(nd_key->nd_target, &flow->nd_target,
 933                         sizeof nd_key->nd_target);
 934                 memcpy(nd_key->nd_sll, flow->arp_sha, ETH_ADDR_LEN);
 935                 memcpy(nd_key->nd_tll, flow->arp_tha, ETH_ADDR_LEN);
 936             }
 937         }
 938     }
 939 }
 940
 941 static bool
 942 odp_to_tos_frag(uint8_t odp_tos, uint8_t odp_frag, struct flow *flow)
 943 {
 944     if (odp_tos & ~IP_DSCP_MASK || odp_frag > OVS_FRAG_TYPE_LATER) {
 945         return false;
 946     }
 947
 948     flow->tos_frag = odp_tos;
 949     if (odp_frag != OVS_FRAG_TYPE_NONE) {
 950         flow->tos_frag |= FLOW_FRAG_ANY;
 951         if (odp_frag == OVS_FRAG_TYPE_LATER) {
 952             flow->tos_frag |= FLOW_FRAG_LATER;
 953         }
 954     }
 955     return true;
 956 }
 957
 958 /* Converts the 'key_len' bytes of OVS_KEY_ATTR_* attributes in 'key' to a flow
 959  * structure in 'flow'.  Returns 0 if successful, otherwise EINVAL. */
 960 int
 961 odp_flow_key_to_flow(const struct nlattr *key, size_t key_len,
 962                      struct flow *flow)
 963 {
 964     const struct nlattr *nla;
 965     enum ovs_key_attr prev_type;
 966     size_t left;
 967
 968     memset(flow, 0, sizeof *flow);
 969     flow->dl_type = htons(FLOW_DL_TYPE_NONE);
 970     flow->in_port = OFPP_NONE;
 971
 972     prev_type = OVS_KEY_ATTR_UNSPEC;
 973     NL_ATTR_FOR_EACH (nla, left, key, key_len) {
 974         const struct ovs_key_ethernet *eth_key;
 975         const struct ovs_key_8021q *q_key;
 976         const struct ovs_key_ipv4 *ipv4_key;
 977         const struct ovs_key_ipv6 *ipv6_key;
 978         const struct ovs_key_tcp *tcp_key;
 979         const struct ovs_key_udp *udp_key;
 980         const struct ovs_key_icmp *icmp_key;
 981         const struct ovs_key_icmpv6 *icmpv6_key;
 982         const struct ovs_key_arp *arp_key;
 983         const struct ovs_key_nd *nd_key;
 984
 985         uint16_t type = nl_attr_type(nla);
 986         int len = odp_flow_key_attr_len(type);
 987
 988         if (nl_attr_get_size(nla) != len && len != -1) {
 989             return EINVAL;
 990         }
 991
 992 #define TRANSITION(PREV_TYPE, TYPE) (((PREV_TYPE) << 16) | (TYPE))
 993         switch (TRANSITION(prev_type, type)) {
 994         case TRANSITION(OVS_KEY_ATTR_UNSPEC, OVS_KEY_ATTR_TUN_ID):
 995             flow->tun_id = nl_attr_get_be64(nla);
 996             break;
 997
 998         case TRANSITION(OVS_KEY_ATTR_UNSPEC, OVS_KEY_ATTR_IN_PORT):
 999         case TRANSITION(OVS_KEY_ATTR_TUN_ID, OVS_KEY_ATTR_IN_PORT):
1000             if (nl_attr_get_u32(nla) >= UINT16_MAX) {
1001                 return EINVAL;
1002             }
1003             flow->in_port = odp_port_to_ofp_port(nl_attr_get_u32(nla));
1004             break;
1005
1006         case TRANSITION(OVS_KEY_ATTR_UNSPEC, OVS_KEY_ATTR_ETHERNET):
1007         case TRANSITION(OVS_KEY_ATTR_TUN_ID, OVS_KEY_ATTR_ETHERNET):
1008         case TRANSITION(OVS_KEY_ATTR_IN_PORT, OVS_KEY_ATTR_ETHERNET):
1009             eth_key = nl_attr_get(nla);
1010             memcpy(flow->dl_src, eth_key->eth_src, ETH_ADDR_LEN);
1011             memcpy(flow->dl_dst, eth_key->eth_dst, ETH_ADDR_LEN);
1012             break;
1013
1014         case TRANSITION(OVS_KEY_ATTR_ETHERNET, OVS_KEY_ATTR_8021Q):
1015             q_key = nl_attr_get(nla);
1016             if (q_key->q_tpid != htons(ETH_TYPE_VLAN)) {
1017                 /* Only standard 0x8100 VLANs currently supported. */
1018                 return EINVAL;
1019             }
1020             if (q_key->q_tci & htons(VLAN_CFI)) {
1021                 return EINVAL;
1022             }
1023             flow->vlan_tci = q_key->q_tci | htons(VLAN_CFI);
1024             break;
1025
1026         case TRANSITION(OVS_KEY_ATTR_8021Q, OVS_KEY_ATTR_ETHERTYPE):
1027         case TRANSITION(OVS_KEY_ATTR_ETHERNET, OVS_KEY_ATTR_ETHERTYPE):
1028             flow->dl_type = nl_attr_get_be16(nla);
1029             if (ntohs(flow->dl_type) < 1536) {
1030                 return EINVAL;
1031             }
1032             break;
1033
1034         case TRANSITION(OVS_KEY_ATTR_ETHERTYPE, OVS_KEY_ATTR_IPV4):
1035             if (flow->dl_type != htons(ETH_TYPE_IP)) {
1036                 return EINVAL;
1037             }
1038             ipv4_key = nl_attr_get(nla);
1039             flow->nw_src = ipv4_key->ipv4_src;
1040             flow->nw_dst = ipv4_key->ipv4_dst;
1041             flow->nw_proto = ipv4_key->ipv4_proto;
1042             if (!odp_to_tos_frag(ipv4_key->ipv4_tos, ipv4_key->ipv4_frag,
1043                                  flow)) {
1044                 return EINVAL;
1045             }
1046             break;
1047
1048         case TRANSITION(OVS_KEY_ATTR_ETHERTYPE, OVS_KEY_ATTR_IPV6):
1049             if (flow->dl_type != htons(ETH_TYPE_IPV6)) {
1050                 return EINVAL;
1051             }
1052             ipv6_key = nl_attr_get(nla);
1053             memcpy(&flow->ipv6_src, ipv6_key->ipv6_src, sizeof flow->ipv6_src);
1054             memcpy(&flow->ipv6_dst, ipv6_key->ipv6_dst, sizeof flow->ipv6_dst);
1055             flow->nw_proto = ipv6_key->ipv6_proto;
1056             if (!odp_to_tos_frag(ipv6_key->ipv6_tos, ipv6_key->ipv6_frag,
1057                                  flow)) {
1058                 return EINVAL;
1059             }
1060             break;
1061
1062         case TRANSITION(OVS_KEY_ATTR_IPV4, OVS_KEY_ATTR_TCP):
1063         case TRANSITION(OVS_KEY_ATTR_IPV6, OVS_KEY_ATTR_TCP):
1064             if (flow->nw_proto != IPPROTO_TCP) {
1065                 return EINVAL;
1066             }
1067             tcp_key = nl_attr_get(nla);
1068             flow->tp_src = tcp_key->tcp_src;
1069             flow->tp_dst = tcp_key->tcp_dst;
1070             break;
1071
1072         case TRANSITION(OVS_KEY_ATTR_IPV4, OVS_KEY_ATTR_UDP):
1073         case TRANSITION(OVS_KEY_ATTR_IPV6, OVS_KEY_ATTR_UDP):
1074             if (flow->nw_proto != IPPROTO_UDP) {
1075                 return EINVAL;
1076             }
1077             udp_key = nl_attr_get(nla);
1078             flow->tp_src = udp_key->udp_src;
1079             flow->tp_dst = udp_key->udp_dst;
1080             break;
1081
1082         case TRANSITION(OVS_KEY_ATTR_IPV4, OVS_KEY_ATTR_ICMP):
1083             if (flow->nw_proto != IPPROTO_ICMP) {
1084                 return EINVAL;
1085             }
1086             icmp_key = nl_attr_get(nla);
1087             flow->tp_src = htons(icmp_key->icmp_type);
1088             flow->tp_dst = htons(icmp_key->icmp_code);
1089             break;
1090
1091         case TRANSITION(OVS_KEY_ATTR_IPV6, OVS_KEY_ATTR_ICMPV6):
1092             if (flow->nw_proto != IPPROTO_ICMPV6) {
1093                 return EINVAL;
1094             }
1095             icmpv6_key = nl_attr_get(nla);
1096             flow->tp_src = htons(icmpv6_key->icmpv6_type);
1097             flow->tp_dst = htons(icmpv6_key->icmpv6_code);
1098             break;
1099
1100         case TRANSITION(OVS_KEY_ATTR_ETHERTYPE, OVS_KEY_ATTR_ARP):
1101             if (flow->dl_type != htons(ETH_TYPE_ARP)) {
1102                 return EINVAL;
1103             }
1104             arp_key = nl_attr_get(nla);
1105             flow->nw_src = arp_key->arp_sip;
1106             flow->nw_dst = arp_key->arp_tip;
1107             if (arp_key->arp_op & htons(0xff00)) {
1108                 return EINVAL;
1109             }
1110             flow->nw_proto = ntohs(arp_key->arp_op);
1111             memcpy(flow->arp_sha, arp_key->arp_sha, ETH_ADDR_LEN);
1112             memcpy(flow->arp_tha, arp_key->arp_tha, ETH_ADDR_LEN);
1113             break;
1114
1115         case TRANSITION(OVS_KEY_ATTR_ICMPV6, OVS_KEY_ATTR_ND):
1116             if (flow->tp_src != htons(ND_NEIGHBOR_SOLICIT)
1117                     && flow->tp_src != htons(ND_NEIGHBOR_ADVERT)) {
1118                 return EINVAL;
1119             }
1120             nd_key = nl_attr_get(nla);
1121             memcpy(&flow->nd_target, nd_key->nd_target, sizeof flow->nd_target);
1122             memcpy(flow->arp_sha, nd_key->nd_sll, ETH_ADDR_LEN);
1123             memcpy(flow->arp_tha, nd_key->nd_tll, ETH_ADDR_LEN);
1124             break;
1125
1126         default:
1127             return EINVAL;
1128         }
1129
1130         prev_type = type;
1131     }
1132     if (left) {
1133         return EINVAL;
1134     }
1135
1136     switch (prev_type) {
1137     case OVS_KEY_ATTR_UNSPEC:
1138         return EINVAL;
1139
1140     case OVS_KEY_ATTR_TUN_ID:
1141     case OVS_KEY_ATTR_IN_PORT:
1142         return EINVAL;
1143
1144     case OVS_KEY_ATTR_ETHERNET:
1145     case OVS_KEY_ATTR_8021Q:
1146         return 0;
1147
1148     case OVS_KEY_ATTR_ETHERTYPE:
1149         if (flow->dl_type == htons(ETH_TYPE_IP)
1150             || flow->dl_type == htons(ETH_TYPE_IPV6)
1151             || flow->dl_type == htons(ETH_TYPE_ARP)) {
1152             return EINVAL;
1153         }
1154         return 0;
1155
1156     case OVS_KEY_ATTR_IPV4:
1157         if (flow->tos_frag & FLOW_FRAG_LATER) {
1158             return 0;
1159         }
1160         if (flow->nw_proto == IPPROTO_TCP
1161             || flow->nw_proto == IPPROTO_UDP
1162             || flow->nw_proto == IPPROTO_ICMP) {
1163             return EINVAL;
1164         }
1165         return 0;
1166
1167     case OVS_KEY_ATTR_IPV6:
1168         if (flow->tos_frag & FLOW_FRAG_LATER) {
1169             return 0;
1170         }
1171         if (flow->nw_proto == IPPROTO_TCP
1172             || flow->nw_proto == IPPROTO_UDP
1173             || flow->nw_proto == IPPROTO_ICMPV6) {
1174             return EINVAL;
1175         }
1176         return 0;
1177
1178     case OVS_KEY_ATTR_ICMPV6:
1179         if (flow->tp_src == htons(ND_NEIGHBOR_SOLICIT)
1180             || flow->tp_src == htons(ND_NEIGHBOR_ADVERT)
1181             || flow->tos_frag & FLOW_FRAG_LATER) {
1182             return EINVAL;
1183         }
1184         return 0;
1185
1186     case OVS_KEY_ATTR_TCP:
1187     case OVS_KEY_ATTR_UDP:
1188     case OVS_KEY_ATTR_ICMP:
1189     case OVS_KEY_ATTR_ND:
1190         if (flow->tos_frag & FLOW_FRAG_LATER) {
1191             return EINVAL;
1192         }
1193         return 0;
1194
1195     case OVS_KEY_ATTR_ARP:
1196         return 0;
1197
1198     case __OVS_KEY_ATTR_MAX:
1199     default:
1200         NOT_REACHED();
1201     }
1202 }