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 <stdlib.h>
  23 #include <string.h>
  24 #include "byte-order.h"
  25 #include "coverage.h"
  26 #include "dynamic-string.h"
  27 #include "flow.h"
  28 #include "netlink.h"
  29 #include "openvswitch/tunnel.h"
  30 #include "packets.h"
  31 #include "timeval.h"
  32 #include "util.h"
  33
  34 int
  35 odp_action_len(uint16_t type)
  36 {
  37     if (type > ODP_ACTION_ATTR_MAX) {
  38         return -1;
  39     }
  40
  41     switch ((enum odp_action_type) type) {
  42     case ODP_ACTION_ATTR_OUTPUT: return 4;
  43     case ODP_ACTION_ATTR_CONTROLLER: return 8;
  44     case ODP_ACTION_ATTR_SET_DL_TCI: return 2;
  45     case ODP_ACTION_ATTR_STRIP_VLAN: return 0;
  46     case ODP_ACTION_ATTR_SET_DL_SRC: return ETH_ADDR_LEN;
  47     case ODP_ACTION_ATTR_SET_DL_DST: return ETH_ADDR_LEN;
  48     case ODP_ACTION_ATTR_SET_NW_SRC: return 4;
  49     case ODP_ACTION_ATTR_SET_NW_DST: return 4;
  50     case ODP_ACTION_ATTR_SET_NW_TOS: return 1;
  51     case ODP_ACTION_ATTR_SET_TP_SRC: return 2;
  52     case ODP_ACTION_ATTR_SET_TP_DST: return 2;
  53     case ODP_ACTION_ATTR_SET_TUNNEL: return 8;
  54     case ODP_ACTION_ATTR_SET_PRIORITY: return 4;
  55     case ODP_ACTION_ATTR_POP_PRIORITY: return 0;
  56     case ODP_ACTION_ATTR_DROP_SPOOFED_ARP: return 0;
  57
  58     case ODP_ACTION_ATTR_UNSPEC:
  59     case __ODP_ACTION_ATTR_MAX:
  60         return -1;
  61     }
  62
  63     return -1;
  64 }
  65
  66 static void
  67 format_generic_odp_action(struct ds *ds, const struct nlattr *a)
  68 {
  69     size_t len = nl_attr_get_size(a);
  70
  71     ds_put_format(ds, "action%"PRId16, nl_attr_type(a));
  72     if (len) {
  73         const uint8_t *unspec;
  74         unsigned int i;
  75
  76         unspec = nl_attr_get(a);
  77         for (i = 0; i < len; i++) {
  78             ds_put_char(ds, i ? ' ': '(');
  79             ds_put_format(ds, "%02x", unspec[i]);
  80         }
  81         ds_put_char(ds, ')');
  82     }
  83 }
  84
  85 void
  86 format_odp_action(struct ds *ds, const struct nlattr *a)
  87 {
  88     const uint8_t *eth;
  89     ovs_be32 ip;
  90
  91     if (nl_attr_get_size(a) != odp_action_len(nl_attr_type(a))) {
  92         ds_put_format(ds, "bad length %zu, expected %d for: ",
  93                       nl_attr_get_size(a), odp_action_len(nl_attr_type(a)));
  94         format_generic_odp_action(ds, a);
  95         return;
  96     }
  97
  98     switch (nl_attr_type(a)) {
  99     case ODP_ACTION_ATTR_OUTPUT:
 100         ds_put_format(ds, "%"PRIu16, nl_attr_get_u32(a));
 101         break;
 102     case ODP_ACTION_ATTR_CONTROLLER:
 103         ds_put_format(ds, "ctl(%"PRIu64")", nl_attr_get_u64(a));
 104         break;
 105     case ODP_ACTION_ATTR_SET_TUNNEL:
 106         ds_put_format(ds, "set_tunnel(%#"PRIx64")",
 107                       ntohll(nl_attr_get_be64(a)));
 108         break;
 109     case ODP_ACTION_ATTR_SET_DL_TCI:
 110         ds_put_format(ds, "set_tci(vid=%"PRIu16",pcp=%d)",
 111                       vlan_tci_to_vid(nl_attr_get_be16(a)),
 112                       vlan_tci_to_pcp(nl_attr_get_be16(a)));
 113         break;
 114     case ODP_ACTION_ATTR_STRIP_VLAN:
 115         ds_put_format(ds, "strip_vlan");
 116         break;
 117     case ODP_ACTION_ATTR_SET_DL_SRC:
 118         eth = nl_attr_get_unspec(a, ETH_ADDR_LEN);
 119         ds_put_format(ds, "set_dl_src("ETH_ADDR_FMT")", ETH_ADDR_ARGS(eth));
 120         break;
 121     case ODP_ACTION_ATTR_SET_DL_DST:
 122         eth = nl_attr_get_unspec(a, ETH_ADDR_LEN);
 123         ds_put_format(ds, "set_dl_dst("ETH_ADDR_FMT")", ETH_ADDR_ARGS(eth));
 124         break;
 125     case ODP_ACTION_ATTR_SET_NW_SRC:
 126         ip = nl_attr_get_be32(a);
 127         ds_put_format(ds, "set_nw_src("IP_FMT")", IP_ARGS(&ip));
 128         break;
 129     case ODP_ACTION_ATTR_SET_NW_DST:
 130         ip = nl_attr_get_be32(a);
 131         ds_put_format(ds, "set_nw_dst("IP_FMT")", IP_ARGS(&ip));
 132         break;
 133     case ODP_ACTION_ATTR_SET_NW_TOS:
 134         ds_put_format(ds, "set_nw_tos(%"PRIu8")", nl_attr_get_u8(a));
 135         break;
 136     case ODP_ACTION_ATTR_SET_TP_SRC:
 137         ds_put_format(ds, "set_tp_src(%"PRIu16")", ntohs(nl_attr_get_be16(a)));
 138         break;
 139     case ODP_ACTION_ATTR_SET_TP_DST:
 140         ds_put_format(ds, "set_tp_dst(%"PRIu16")", ntohs(nl_attr_get_be16(a)));
 141         break;
 142     case ODP_ACTION_ATTR_SET_PRIORITY:
 143         ds_put_format(ds, "set_priority(%#"PRIx32")", nl_attr_get_u32(a));
 144         break;
 145     case ODP_ACTION_ATTR_POP_PRIORITY:
 146         ds_put_cstr(ds, "pop_priority");
 147         break;
 148     case ODP_ACTION_ATTR_DROP_SPOOFED_ARP:
 149         ds_put_cstr(ds, "drop_spoofed_arp");
 150         break;
 151     default:
 152         format_generic_odp_action(ds, a);
 153         break;
 154     }
 155 }
 156
 157 void
 158 format_odp_actions(struct ds *ds, const struct nlattr *actions,
 159                    size_t actions_len)
 160 {
 161     if (actions_len) {
 162         const struct nlattr *a;
 163         unsigned int left;
 164
 165         NL_ATTR_FOR_EACH (a, left, actions, actions_len) {
 166             if (a != actions) {
 167                 ds_put_char(ds, ',');
 168             }
 169             format_odp_action(ds, a);
 170         }
 171         if (left) {
 172             if (left == actions_len) {
 173                 ds_put_cstr(ds, "<empty>");
 174             }
 175             ds_put_format(ds, ",***%u leftover bytes***", left);
 176         }
 177     } else {
 178         ds_put_cstr(ds, "drop");
 179     }
 180 }
 181 \f
 182 /* Returns the correct length of the payload for a flow key attribute of the
 183  * specified 'type', or -1 if 'type' is unknown. */
 184 static int
 185 odp_flow_key_attr_len(uint16_t type)
 186 {
 187     if (type > ODP_KEY_ATTR_MAX) {
 188         return -1;
 189     }
 190
 191     switch ((enum odp_key_type) type) {
 192     case ODP_KEY_ATTR_TUN_ID: return 8;
 193     case ODP_KEY_ATTR_IN_PORT: return 4;
 194     case ODP_KEY_ATTR_ETHERNET: return sizeof(struct odp_key_ethernet);
 195     case ODP_KEY_ATTR_8021Q: return sizeof(struct odp_key_8021q);
 196     case ODP_KEY_ATTR_ETHERTYPE: return 2;
 197     case ODP_KEY_ATTR_IPV4: return sizeof(struct odp_key_ipv4);
 198     case ODP_KEY_ATTR_IPV6: return sizeof(struct odp_key_ipv6);
 199     case ODP_KEY_ATTR_TCP: return sizeof(struct odp_key_tcp);
 200     case ODP_KEY_ATTR_UDP: return sizeof(struct odp_key_udp);
 201     case ODP_KEY_ATTR_ICMP: return sizeof(struct odp_key_icmp);
 202     case ODP_KEY_ATTR_ICMPV6: return sizeof(struct odp_key_icmpv6);
 203     case ODP_KEY_ATTR_ARP: return sizeof(struct odp_key_arp);
 204
 205     case ODP_KEY_ATTR_UNSPEC:
 206     case __ODP_KEY_ATTR_MAX:
 207         return -1;
 208     }
 209
 210     return -1;
 211 }
 212
 213
 214 static void
 215 format_generic_odp_key(const struct nlattr *a, struct ds *ds)
 216 {
 217     size_t len = nl_attr_get_size(a);
 218
 219     ds_put_format(ds, "key%"PRId16, nl_attr_type(a));
 220     if (len) {
 221         const uint8_t *unspec;
 222         unsigned int i;
 223
 224         unspec = nl_attr_get(a);
 225         for (i = 0; i < len; i++) {
 226             ds_put_char(ds, i ? ' ': '(');
 227             ds_put_format(ds, "%02x", unspec[i]);
 228         }
 229         ds_put_char(ds, ')');
 230     }
 231 }
 232
 233 static void
 234 format_odp_key_attr(const struct nlattr *a, struct ds *ds)
 235 {
 236     const struct odp_key_ethernet *eth_key;
 237     const struct odp_key_8021q *q_key;
 238     const struct odp_key_ipv4 *ipv4_key;
 239     const struct odp_key_ipv6 *ipv6_key;
 240     const struct odp_key_tcp *tcp_key;
 241     const struct odp_key_udp *udp_key;
 242     const struct odp_key_icmp *icmp_key;
 243     const struct odp_key_icmpv6 *icmpv6_key;
 244     const struct odp_key_arp *arp_key;
 245
 246     if (nl_attr_get_size(a) != odp_flow_key_attr_len(nl_attr_type(a))) {
 247         ds_put_format(ds, "bad length %zu, expected %d for: ",
 248                       nl_attr_get_size(a),
 249                       odp_flow_key_attr_len(nl_attr_type(a)));
 250         format_generic_odp_key(a, ds);
 251         return;
 252     }
 253
 254     switch (nl_attr_type(a)) {
 255     case ODP_KEY_ATTR_TUN_ID:
 256         ds_put_format(ds, "tun_id(%#"PRIx64")", nl_attr_get_be64(a));
 257         break;
 258
 259     case ODP_KEY_ATTR_IN_PORT:
 260         ds_put_format(ds, "in_port(%"PRIu32")", nl_attr_get_u32(a));
 261         break;
 262
 263     case ODP_KEY_ATTR_ETHERNET:
 264         eth_key = nl_attr_get(a);
 265         ds_put_format(ds, "eth(src="ETH_ADDR_FMT",dst="ETH_ADDR_FMT")",
 266                       ETH_ADDR_ARGS(eth_key->eth_src),
 267                       ETH_ADDR_ARGS(eth_key->eth_dst));
 268         break;
 269
 270     case ODP_KEY_ATTR_8021Q:
 271         q_key = nl_attr_get(a);
 272         ds_put_cstr(ds, "vlan(");
 273         if (q_key->q_tpid != htons(ETH_TYPE_VLAN)) {
 274             ds_put_format(ds, "tpid=0x%04"PRIx16",", ntohs(q_key->q_tpid));
 275         }
 276         ds_put_format(ds, "vid%"PRIu16",pcp%d)",
 277                       vlan_tci_to_vid(q_key->q_tci),
 278                       vlan_tci_to_pcp(q_key->q_tci));
 279         break;
 280
 281     case ODP_KEY_ATTR_ETHERTYPE:
 282         ds_put_format(ds, "eth_type(0x%04"PRIx16")",
 283                       ntohs(nl_attr_get_be16(a)));
 284         break;
 285
 286     case ODP_KEY_ATTR_IPV4:
 287         ipv4_key = nl_attr_get(a);
 288         ds_put_format(ds, "ipv4(src="IP_FMT",dst="IP_FMT","
 289                       "proto=%"PRId8",tos=%"PRIu8")",
 290                       IP_ARGS(&ipv4_key->ipv4_src),
 291                       IP_ARGS(&ipv4_key->ipv4_dst),
 292                       ipv4_key->ipv4_proto, ipv4_key->ipv4_tos);
 293         break;
 294
 295     case ODP_KEY_ATTR_IPV6: {
 296         char src_str[INET6_ADDRSTRLEN];
 297         char dst_str[INET6_ADDRSTRLEN];
 298
 299         ipv6_key = nl_attr_get(a);
 300         inet_ntop(AF_INET6, ipv6_key->ipv6_src, src_str, sizeof src_str);
 301         inet_ntop(AF_INET6, ipv6_key->ipv6_dst, dst_str, sizeof dst_str);
 302
 303         ds_put_format(ds, "ipv6(src=%s,dst=%s,proto=%"PRId8",tos=%"PRIu8")",
 304                       src_str, dst_str, ipv6_key->ipv6_proto,
 305                       ipv6_key->ipv6_tos);
 306         break;
 307     }
 308
 309     case ODP_KEY_ATTR_TCP:
 310         tcp_key = nl_attr_get(a);
 311         ds_put_format(ds, "tcp(src=%"PRIu16",dst=%"PRIu16")",
 312                       ntohs(tcp_key->tcp_src), ntohs(tcp_key->tcp_dst));
 313         break;
 314
 315     case ODP_KEY_ATTR_UDP:
 316         udp_key = nl_attr_get(a);
 317         ds_put_format(ds, "udp(src=%"PRIu16",dst=%"PRIu16")",
 318                       ntohs(udp_key->udp_src), ntohs(udp_key->udp_dst));
 319         break;
 320
 321     case ODP_KEY_ATTR_ICMP:
 322         icmp_key = nl_attr_get(a);
 323         ds_put_format(ds, "icmp(type=%"PRIu8",code=%"PRIu8")",
 324                       icmp_key->icmp_type, icmp_key->icmp_code);
 325         break;
 326
 327     case ODP_KEY_ATTR_ICMPV6:
 328         icmpv6_key = nl_attr_get(a);
 329         ds_put_format(ds, "icmpv6(type=%"PRIu8",code=%"PRIu8")",
 330                       icmpv6_key->icmpv6_type, icmpv6_key->icmpv6_code);
 331         break;
 332
 333     case ODP_KEY_ATTR_ARP:
 334         arp_key = nl_attr_get(a);
 335         ds_put_format(ds, "arp(sip="IP_FMT",tip="IP_FMT",op=%"PRIu16","
 336                       "sha="ETH_ADDR_FMT",tha="ETH_ADDR_FMT")",
 337                       IP_ARGS(&arp_key->arp_sip), IP_ARGS(&arp_key->arp_tip),
 338                       ntohs(arp_key->arp_op), ETH_ADDR_ARGS(arp_key->arp_sha),
 339                       ETH_ADDR_ARGS(arp_key->arp_tha));
 340         break;
 341
 342     default:
 343         format_generic_odp_key(a, ds);
 344         break;
 345     }
 346 }
 347
 348 /* Appends to 'ds' a string representation of the 'key_len' bytes of
 349  * ODP_KEY_ATTR_* attributes in 'key'. */
 350 void
 351 odp_flow_key_format(const struct nlattr *key, size_t key_len, struct ds *ds)
 352 {
 353     if (key_len) {
 354         const struct nlattr *a;
 355         unsigned int left;
 356
 357         NL_ATTR_FOR_EACH (a, left, key, key_len) {
 358             if (a != key) {
 359                 ds_put_char(ds, ',');
 360             }
 361             format_odp_key_attr(a, ds);
 362         }
 363         if (left) {
 364             if (left == key_len) {
 365                 ds_put_cstr(ds, "<empty>");
 366             }
 367             ds_put_format(ds, ",***%u leftover bytes***", left);
 368         }
 369     } else {
 370         ds_put_cstr(ds, "<empty>");
 371     }
 372 }
 373
 374 /* Appends a representation of 'flow' as ODP_KEY_ATTR_* attributes to 'buf'. */
 375 void
 376 odp_flow_key_from_flow(struct ofpbuf *buf, const struct flow *flow)
 377 {
 378     struct odp_key_ethernet *eth_key;
 379
 380     if (flow->tun_id != htonll(0)) {
 381         nl_msg_put_be64(buf, ODP_KEY_ATTR_TUN_ID, flow->tun_id);
 382     }
 383
 384     nl_msg_put_u32(buf, ODP_KEY_ATTR_IN_PORT, flow->in_port);
 385
 386     eth_key = nl_msg_put_unspec_uninit(buf, ODP_KEY_ATTR_ETHERNET,
 387                                        sizeof *eth_key);
 388     memcpy(eth_key->eth_src, flow->dl_src, ETH_ADDR_LEN);
 389     memcpy(eth_key->eth_dst, flow->dl_dst, ETH_ADDR_LEN);
 390
 391     if (flow->vlan_tci != htons(0)) {
 392         struct odp_key_8021q *q_key;
 393
 394         q_key = nl_msg_put_unspec_uninit(buf, ODP_KEY_ATTR_8021Q,
 395                                          sizeof *q_key);
 396         q_key->q_tpid = htons(ETH_TYPE_VLAN);
 397         q_key->q_tci = flow->vlan_tci & ~htons(VLAN_CFI);
 398     }
 399
 400     if (ntohs(flow->dl_type) < ETH_TYPE_MIN) {
 401         return;
 402     }
 403
 404     nl_msg_put_be16(buf, ODP_KEY_ATTR_ETHERTYPE, flow->dl_type);
 405
 406     if (flow->dl_type == htons(ETH_TYPE_IP)) {
 407         struct odp_key_ipv4 *ipv4_key;
 408
 409         ipv4_key = nl_msg_put_unspec_uninit(buf, ODP_KEY_ATTR_IPV4,
 410                                             sizeof *ipv4_key);
 411         ipv4_key->ipv4_src = flow->nw_src;
 412         ipv4_key->ipv4_dst = flow->nw_dst;
 413         ipv4_key->ipv4_proto = flow->nw_proto;
 414         ipv4_key->ipv4_tos = flow->nw_tos;
 415     } else if (flow->dl_type == htons(ETH_TYPE_IPV6)) {
 416         struct odp_key_ipv6 *ipv6_key;
 417
 418         ipv6_key = nl_msg_put_unspec_uninit(buf, ODP_KEY_ATTR_IPV6,
 419                                             sizeof *ipv6_key);
 420         memcpy(ipv6_key->ipv6_src, &flow->ipv6_src, sizeof ipv6_key->ipv6_src);
 421         memcpy(ipv6_key->ipv6_dst, &flow->ipv6_dst, sizeof ipv6_key->ipv6_dst);
 422         ipv6_key->ipv6_proto = flow->nw_proto;
 423         ipv6_key->ipv6_tos = flow->nw_tos;
 424     } else if (flow->dl_type == htons(ETH_TYPE_ARP)) {
 425         struct odp_key_arp *arp_key;
 426
 427         arp_key = nl_msg_put_unspec_uninit(buf, ODP_KEY_ATTR_ARP,
 428                                            sizeof *arp_key);
 429         arp_key->arp_sip = flow->nw_src;
 430         arp_key->arp_tip = flow->nw_dst;
 431         arp_key->arp_op = htons(flow->nw_proto);
 432         memcpy(arp_key->arp_sha, flow->arp_sha, ETH_ADDR_LEN);
 433         memcpy(arp_key->arp_tha, flow->arp_tha, ETH_ADDR_LEN);
 434     }
 435
 436     if (flow->dl_type == htons(ETH_TYPE_IP)
 437             || flow->dl_type == htons(ETH_TYPE_IPV6)) {
 438
 439         if (flow->nw_proto == IPPROTO_TCP) {
 440             struct odp_key_tcp *tcp_key;
 441
 442             tcp_key = nl_msg_put_unspec_uninit(buf, ODP_KEY_ATTR_TCP,
 443                                                sizeof *tcp_key);
 444             tcp_key->tcp_src = flow->tp_src;
 445             tcp_key->tcp_dst = flow->tp_dst;
 446         } else if (flow->nw_proto == IPPROTO_UDP) {
 447             struct odp_key_udp *udp_key;
 448
 449             udp_key = nl_msg_put_unspec_uninit(buf, ODP_KEY_ATTR_UDP,
 450                                                sizeof *udp_key);
 451             udp_key->udp_src = flow->tp_src;
 452             udp_key->udp_dst = flow->tp_dst;
 453         } else if (flow->dl_type == htons(ETH_TYPE_IP)
 454                 && flow->nw_proto == IPPROTO_ICMP) {
 455             struct odp_key_icmp *icmp_key;
 456
 457             icmp_key = nl_msg_put_unspec_uninit(buf, ODP_KEY_ATTR_ICMP,
 458                                                 sizeof *icmp_key);
 459             icmp_key->icmp_type = ntohs(flow->tp_src);
 460             icmp_key->icmp_code = ntohs(flow->tp_dst);
 461         } else if (flow->dl_type == htons(ETH_TYPE_IPV6)
 462                 && flow->nw_proto == IPPROTO_ICMPV6) {
 463             struct odp_key_icmpv6 *icmpv6_key;
 464
 465             icmpv6_key = nl_msg_put_unspec_uninit(buf, ODP_KEY_ATTR_ICMPV6,
 466                                                   sizeof *icmpv6_key);
 467             icmpv6_key->icmpv6_type = ntohs(flow->tp_src);
 468             icmpv6_key->icmpv6_code = ntohs(flow->tp_dst);
 469         }
 470     }
 471 }
 472
 473 /* Converts the 'key_len' bytes of ODP_KEY_ATTR_* attributes in 'key' to a flow
 474  * structure in 'flow'.  Returns 0 if successful, otherwise EINVAL. */
 475 int
 476 odp_flow_key_to_flow(const struct nlattr *key, size_t key_len,
 477                      struct flow *flow)
 478 {
 479     const struct nlattr *nla;
 480     enum odp_key_type prev_type;
 481     size_t left;
 482
 483     memset(flow, 0, sizeof *flow);
 484     flow->dl_type = htons(FLOW_DL_TYPE_NONE);
 485
 486     prev_type = ODP_KEY_ATTR_UNSPEC;
 487     NL_ATTR_FOR_EACH (nla, left, key, key_len) {
 488         const struct odp_key_ethernet *eth_key;
 489         const struct odp_key_8021q *q_key;
 490         const struct odp_key_ipv4 *ipv4_key;
 491         const struct odp_key_ipv6 *ipv6_key;
 492         const struct odp_key_tcp *tcp_key;
 493         const struct odp_key_udp *udp_key;
 494         const struct odp_key_icmp *icmp_key;
 495         const struct odp_key_icmpv6 *icmpv6_key;
 496         const struct odp_key_arp *arp_key;
 497
 498         uint16_t type = nl_attr_type(nla);
 499         int len = odp_flow_key_attr_len(type);
 500
 501         if (nl_attr_get_size(nla) != len && len != -1) {
 502             return EINVAL;
 503         }
 504
 505 #define TRANSITION(PREV_TYPE, TYPE) (((PREV_TYPE) << 16) | (TYPE))
 506         switch (TRANSITION(prev_type, type)) {
 507         case TRANSITION(ODP_KEY_ATTR_UNSPEC, ODP_KEY_ATTR_TUN_ID):
 508             flow->tun_id = nl_attr_get_be64(nla);
 509             break;
 510
 511         case TRANSITION(ODP_KEY_ATTR_UNSPEC, ODP_KEY_ATTR_IN_PORT):
 512         case TRANSITION(ODP_KEY_ATTR_TUN_ID, ODP_KEY_ATTR_IN_PORT):
 513             if (nl_attr_get_u32(nla) >= UINT16_MAX) {
 514                 return EINVAL;
 515             }
 516             flow->in_port = nl_attr_get_u32(nla);
 517             break;
 518
 519         case TRANSITION(ODP_KEY_ATTR_IN_PORT, ODP_KEY_ATTR_ETHERNET):
 520             eth_key = nl_attr_get(nla);
 521             memcpy(flow->dl_src, eth_key->eth_src, ETH_ADDR_LEN);
 522             memcpy(flow->dl_dst, eth_key->eth_dst, ETH_ADDR_LEN);
 523             break;
 524
 525         case TRANSITION(ODP_KEY_ATTR_ETHERNET, ODP_KEY_ATTR_8021Q):
 526             q_key = nl_attr_get(nla);
 527             if (q_key->q_tpid != htons(ETH_TYPE_VLAN)) {
 528                 /* Only standard 0x8100 VLANs currently supported. */
 529                 return EINVAL;
 530             }
 531             if (q_key->q_tci & htons(VLAN_CFI)) {
 532                 return EINVAL;
 533             }
 534             flow->vlan_tci = q_key->q_tci | htons(VLAN_CFI);
 535             break;
 536
 537         case TRANSITION(ODP_KEY_ATTR_8021Q, ODP_KEY_ATTR_ETHERTYPE):
 538         case TRANSITION(ODP_KEY_ATTR_ETHERNET, ODP_KEY_ATTR_ETHERTYPE):
 539             flow->dl_type = nl_attr_get_be16(nla);
 540             if (ntohs(flow->dl_type) < 1536) {
 541                 return EINVAL;
 542             }
 543             break;
 544
 545         case TRANSITION(ODP_KEY_ATTR_ETHERTYPE, ODP_KEY_ATTR_IPV4):
 546             if (flow->dl_type != htons(ETH_TYPE_IP)) {
 547                 return EINVAL;
 548             }
 549             ipv4_key = nl_attr_get(nla);
 550             flow->nw_src = ipv4_key->ipv4_src;
 551             flow->nw_dst = ipv4_key->ipv4_dst;
 552             flow->nw_proto = ipv4_key->ipv4_proto;
 553             flow->nw_tos = ipv4_key->ipv4_tos;
 554             if (flow->nw_tos & IP_ECN_MASK) {
 555                 return EINVAL;
 556             }
 557             break;
 558
 559         case TRANSITION(ODP_KEY_ATTR_ETHERTYPE, ODP_KEY_ATTR_IPV6):
 560             if (flow->dl_type != htons(ETH_TYPE_IPV6)) {
 561                 return EINVAL;
 562             }
 563             ipv6_key = nl_attr_get(nla);
 564             memcpy(&flow->ipv6_src, ipv6_key->ipv6_src, sizeof flow->ipv6_src);
 565             memcpy(&flow->ipv6_dst, ipv6_key->ipv6_dst, sizeof flow->ipv6_dst);
 566             flow->nw_proto = ipv6_key->ipv6_proto;
 567             flow->nw_tos = ipv6_key->ipv6_tos;
 568             if (flow->nw_tos & IP_ECN_MASK) {
 569                 return EINVAL;
 570             }
 571             break;
 572
 573         case TRANSITION(ODP_KEY_ATTR_IPV4, ODP_KEY_ATTR_TCP):
 574         case TRANSITION(ODP_KEY_ATTR_IPV6, ODP_KEY_ATTR_TCP):
 575             if (flow->nw_proto != IPPROTO_TCP) {
 576                 return EINVAL;
 577             }
 578             tcp_key = nl_attr_get(nla);
 579             flow->tp_src = tcp_key->tcp_src;
 580             flow->tp_dst = tcp_key->tcp_dst;
 581             break;
 582
 583         case TRANSITION(ODP_KEY_ATTR_IPV4, ODP_KEY_ATTR_UDP):
 584         case TRANSITION(ODP_KEY_ATTR_IPV6, ODP_KEY_ATTR_UDP):
 585             if (flow->nw_proto != IPPROTO_UDP) {
 586                 return EINVAL;
 587             }
 588             udp_key = nl_attr_get(nla);
 589             flow->tp_src = udp_key->udp_src;
 590             flow->tp_dst = udp_key->udp_dst;
 591             break;
 592
 593         case TRANSITION(ODP_KEY_ATTR_IPV4, ODP_KEY_ATTR_ICMP):
 594             if (flow->nw_proto != IPPROTO_ICMP) {
 595                 return EINVAL;
 596             }
 597             icmp_key = nl_attr_get(nla);
 598             flow->tp_src = htons(icmp_key->icmp_type);
 599             flow->tp_dst = htons(icmp_key->icmp_code);
 600             break;
 601
 602         case TRANSITION(ODP_KEY_ATTR_IPV6, ODP_KEY_ATTR_ICMPV6):
 603             if (flow->nw_proto != IPPROTO_ICMPV6) {
 604                 return EINVAL;
 605             }
 606             icmpv6_key = nl_attr_get(nla);
 607             flow->tp_src = htons(icmpv6_key->icmpv6_type);
 608             flow->tp_dst = htons(icmpv6_key->icmpv6_code);
 609             break;
 610
 611         case TRANSITION(ODP_KEY_ATTR_ETHERTYPE, ODP_KEY_ATTR_ARP):
 612             if (flow->dl_type != htons(ETH_TYPE_ARP)) {
 613                 return EINVAL;
 614             }
 615             arp_key = nl_attr_get(nla);
 616             flow->nw_src = arp_key->arp_sip;
 617             flow->nw_dst = arp_key->arp_tip;
 618             if (arp_key->arp_op & htons(0xff00)) {
 619                 return EINVAL;
 620             }
 621             flow->nw_proto = ntohs(arp_key->arp_op);
 622             memcpy(flow->arp_sha, arp_key->arp_sha, ETH_ADDR_LEN);
 623             memcpy(flow->arp_tha, arp_key->arp_tha, ETH_ADDR_LEN);
 624             break;
 625
 626         default:
 627             if (type == ODP_KEY_ATTR_UNSPEC
 628                 || prev_type == ODP_KEY_ATTR_UNSPEC) {
 629                 return EINVAL;
 630             }
 631             return EINVAL;
 632         }
 633
 634         prev_type = type;
 635     }
 636     if (left) {
 637         return EINVAL;
 638     }
 639
 640     switch (prev_type) {
 641     case ODP_KEY_ATTR_UNSPEC:
 642         return EINVAL;
 643
 644     case ODP_KEY_ATTR_TUN_ID:
 645     case ODP_KEY_ATTR_IN_PORT:
 646         return EINVAL;
 647
 648     case ODP_KEY_ATTR_ETHERNET:
 649     case ODP_KEY_ATTR_8021Q:
 650         return 0;
 651
 652     case ODP_KEY_ATTR_ETHERTYPE:
 653         if (flow->dl_type == htons(ETH_TYPE_IP)
 654             || flow->dl_type == htons(ETH_TYPE_IPV6)
 655             || flow->dl_type == htons(ETH_TYPE_ARP)) {
 656             return EINVAL;
 657         }
 658         return 0;
 659
 660     case ODP_KEY_ATTR_IPV4:
 661         if (flow->nw_proto == IPPROTO_TCP
 662             || flow->nw_proto == IPPROTO_UDP
 663             || flow->nw_proto == IPPROTO_ICMP) {
 664             return EINVAL;
 665         }
 666         return 0;
 667
 668     case ODP_KEY_ATTR_IPV6:
 669         if (flow->nw_proto == IPPROTO_TCP
 670             || flow->nw_proto == IPPROTO_UDP
 671             || flow->nw_proto == IPPROTO_ICMPV6) {
 672             return EINVAL;
 673         }
 674         return 0;
 675
 676     case ODP_KEY_ATTR_TCP:
 677     case ODP_KEY_ATTR_UDP:
 678     case ODP_KEY_ATTR_ICMP:
 679     case ODP_KEY_ATTR_ICMPV6:
 680     case ODP_KEY_ATTR_ARP:
 681         return 0;
 682
 683     case __ODP_KEY_ATTR_MAX:
 684     default:
 685         NOT_REACHED();
 686     }
 687 }