2 * Copyright (c) 2009, 2010, 2011 Nicira Networks.
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:
8 * http://www.apache.org/licenses/LICENSE-2.0
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.
17 #include <arpa/inet.h>
22 #include <netinet/in.h>
23 #include <netinet/icmp6.h>
26 #include "byte-order.h"
28 #include "dynamic-string.h"
32 #include "openvswitch/tunnel.h"
37 /* The interface between userspace and kernel uses an "OVS_*" prefix.
38 * Since this is fairly non-specific for the OVS userspace components,
39 * "ODP_*" (Open vSwitch Datapath) is used as the prefix for
40 * interactions with the datapath.
43 static void format_odp_key_attr(const struct nlattr *a, struct ds *ds);
45 /* Returns one the following for the action with the given OVS_ACTION_ATTR_*
48 * - For an action whose argument has a fixed length, returned that
49 * nonnegative length in bytes.
51 * - For an action with a variable-length argument, returns -2.
53 * - For an invalid 'type', returns -1. */
55 odp_action_len(uint16_t type)
57 if (type > OVS_ACTION_ATTR_MAX) {
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_SAMPLE: return -2;
69 case OVS_ACTION_ATTR_UNSPEC:
70 case __OVS_ACTION_ATTR_MAX:
78 ovs_key_attr_to_string(enum ovs_key_attr attr)
80 static char unknown_attr[3 + INT_STRLEN(unsigned int) + 1];
83 case OVS_KEY_ATTR_UNSPEC: return "unspec";
84 case OVS_KEY_ATTR_PRIORITY: return "priority";
85 case OVS_KEY_ATTR_TUN_ID: return "tun_id";
86 case OVS_KEY_ATTR_IN_PORT: return "in_port";
87 case OVS_KEY_ATTR_ETHERNET: return "eth";
88 case OVS_KEY_ATTR_8021Q: return "vlan";
89 case OVS_KEY_ATTR_ETHERTYPE: return "eth_type";
90 case OVS_KEY_ATTR_IPV4: return "ipv4";
91 case OVS_KEY_ATTR_IPV6: return "ipv6";
92 case OVS_KEY_ATTR_TCP: return "tcp";
93 case OVS_KEY_ATTR_UDP: return "udp";
94 case OVS_KEY_ATTR_ICMP: return "icmp";
95 case OVS_KEY_ATTR_ICMPV6: return "icmpv6";
96 case OVS_KEY_ATTR_ARP: return "arp";
97 case OVS_KEY_ATTR_ND: return "nd";
99 case __OVS_KEY_ATTR_MAX:
101 snprintf(unknown_attr, sizeof unknown_attr, "key%u",
102 (unsigned int) attr);
108 format_generic_odp_action(struct ds *ds, const struct nlattr *a)
110 size_t len = nl_attr_get_size(a);
112 ds_put_format(ds, "action%"PRId16, nl_attr_type(a));
114 const uint8_t *unspec;
117 unspec = nl_attr_get(a);
118 for (i = 0; i < len; i++) {
119 ds_put_char(ds, i ? ' ': '(');
120 ds_put_format(ds, "%02x", unspec[i]);
122 ds_put_char(ds, ')');
127 format_odp_sample_action(struct ds *ds, const struct nlattr *attr)
129 static const struct nl_policy ovs_sample_policy[] = {
130 [OVS_SAMPLE_ATTR_PROBABILITY] = { .type = NL_A_U32 },
131 [OVS_SAMPLE_ATTR_ACTIONS] = { .type = NL_A_NESTED }
133 struct nlattr *a[ARRAY_SIZE(ovs_sample_policy)];
135 const struct nlattr *nla_acts;
138 ds_put_cstr(ds, "sample");
140 if (!nl_parse_nested(attr, ovs_sample_policy, a, ARRAY_SIZE(a))) {
141 ds_put_cstr(ds, "(error)");
145 percentage = (100.0 * nl_attr_get_u32(a[OVS_SAMPLE_ATTR_PROBABILITY])) /
148 ds_put_format(ds, "(sample=%.1f%%,", percentage);
150 ds_put_cstr(ds, "actions(");
151 nla_acts = nl_attr_get(a[OVS_SAMPLE_ATTR_ACTIONS]);
152 len = nl_attr_get_size(a[OVS_SAMPLE_ATTR_ACTIONS]);
153 format_odp_actions(ds, nla_acts, len);
154 ds_put_format(ds, "))");
158 format_odp_userspace_action(struct ds *ds, const struct nlattr *attr)
160 static const struct nl_policy ovs_userspace_policy[] = {
161 [OVS_USERSPACE_ATTR_PID] = { .type = NL_A_U32 },
162 [OVS_USERSPACE_ATTR_USERDATA] = { .type = NL_A_U64, .optional = true },
164 struct nlattr *a[ARRAY_SIZE(ovs_userspace_policy)];
166 if (!nl_parse_nested(attr, ovs_userspace_policy, a, ARRAY_SIZE(a))) {
167 ds_put_cstr(ds, "userspace(error)");
171 ds_put_format(ds, "userspace(pid=%"PRIu32,
172 nl_attr_get_u32(a[OVS_USERSPACE_ATTR_PID]));
174 if (a[OVS_USERSPACE_ATTR_USERDATA]) {
175 uint64_t userdata = nl_attr_get_u64(a[OVS_USERSPACE_ATTR_USERDATA]);
176 struct user_action_cookie cookie;
178 memcpy(&cookie, &userdata, sizeof cookie);
180 if (cookie.type == USER_ACTION_COOKIE_CONTROLLER) {
181 ds_put_format(ds, ",controller,length=%"PRIu32,
183 } else if (cookie.type == USER_ACTION_COOKIE_SFLOW) {
184 ds_put_format(ds, ",sFlow,n_output=%"PRIu8","
185 "vid=%"PRIu16",pcp=%"PRIu8",ifindex=%"PRIu32,
186 cookie.n_output, vlan_tci_to_vid(cookie.vlan_tci),
187 vlan_tci_to_pcp(cookie.vlan_tci), cookie.data);
189 ds_put_format(ds, ",userdata=0x%"PRIx64, userdata);
193 ds_put_char(ds, ')');
197 format_odp_action(struct ds *ds, const struct nlattr *a)
200 enum ovs_action_attr type = nl_attr_type(a);
202 expected_len = odp_action_len(nl_attr_type(a));
203 if (expected_len != -2 && nl_attr_get_size(a) != expected_len) {
204 ds_put_format(ds, "bad length %zu, expected %d for: ",
205 nl_attr_get_size(a), expected_len);
206 format_generic_odp_action(ds, a);
212 case OVS_ACTION_ATTR_OUTPUT:
213 ds_put_format(ds, "%"PRIu16, nl_attr_get_u32(a));
215 case OVS_ACTION_ATTR_USERSPACE:
216 format_odp_userspace_action(ds, a);
218 case OVS_ACTION_ATTR_SET:
219 ds_put_cstr(ds, "set(");
220 format_odp_key_attr(nl_attr_get(a), ds);
221 ds_put_cstr(ds, ")");
223 case OVS_ACTION_ATTR_PUSH:
224 ds_put_cstr(ds, "push(");
225 format_odp_key_attr(nl_attr_get(a), ds);
226 ds_put_cstr(ds, ")");
228 case OVS_ACTION_ATTR_POP:
229 ds_put_format(ds, "pop(%s)",
230 ovs_key_attr_to_string(nl_attr_get_u16(a)));
232 case OVS_ACTION_ATTR_SAMPLE:
233 format_odp_sample_action(ds, a);
235 case OVS_ACTION_ATTR_UNSPEC:
236 case __OVS_ACTION_ATTR_MAX:
238 format_generic_odp_action(ds, a);
244 format_odp_actions(struct ds *ds, const struct nlattr *actions,
248 const struct nlattr *a;
251 NL_ATTR_FOR_EACH (a, left, actions, actions_len) {
253 ds_put_char(ds, ',');
255 format_odp_action(ds, a);
258 if (left == actions_len) {
259 ds_put_cstr(ds, "<empty>");
261 ds_put_format(ds, ",***%u leftover bytes***", left);
264 ds_put_cstr(ds, "drop");
268 /* Returns the correct length of the payload for a flow key attribute of the
269 * specified 'type', or -1 if 'type' is unknown. */
271 odp_flow_key_attr_len(uint16_t type)
273 if (type > OVS_KEY_ATTR_MAX) {
277 switch ((enum ovs_key_attr) type) {
278 case OVS_KEY_ATTR_PRIORITY: return 4;
279 case OVS_KEY_ATTR_TUN_ID: return 8;
280 case OVS_KEY_ATTR_IN_PORT: return 4;
281 case OVS_KEY_ATTR_ETHERNET: return sizeof(struct ovs_key_ethernet);
282 case OVS_KEY_ATTR_8021Q: return sizeof(struct ovs_key_8021q);
283 case OVS_KEY_ATTR_ETHERTYPE: return 2;
284 case OVS_KEY_ATTR_IPV4: return sizeof(struct ovs_key_ipv4);
285 case OVS_KEY_ATTR_IPV6: return sizeof(struct ovs_key_ipv6);
286 case OVS_KEY_ATTR_TCP: return sizeof(struct ovs_key_tcp);
287 case OVS_KEY_ATTR_UDP: return sizeof(struct ovs_key_udp);
288 case OVS_KEY_ATTR_ICMP: return sizeof(struct ovs_key_icmp);
289 case OVS_KEY_ATTR_ICMPV6: return sizeof(struct ovs_key_icmpv6);
290 case OVS_KEY_ATTR_ARP: return sizeof(struct ovs_key_arp);
291 case OVS_KEY_ATTR_ND: return sizeof(struct ovs_key_nd);
293 case OVS_KEY_ATTR_UNSPEC:
294 case __OVS_KEY_ATTR_MAX:
303 format_generic_odp_key(const struct nlattr *a, struct ds *ds)
305 size_t len = nl_attr_get_size(a);
307 ds_put_format(ds, "key%"PRId16, nl_attr_type(a));
309 const uint8_t *unspec;
312 unspec = nl_attr_get(a);
313 for (i = 0; i < len; i++) {
314 ds_put_char(ds, i ? ' ': '(');
315 ds_put_format(ds, "%02x", unspec[i]);
317 ds_put_char(ds, ')');
322 ovs_frag_type_to_string(enum ovs_frag_type type)
325 case OVS_FRAG_TYPE_NONE:
327 case OVS_FRAG_TYPE_FIRST:
329 case OVS_FRAG_TYPE_LATER:
331 case __OVS_FRAG_TYPE_MAX:
338 format_odp_key_attr(const struct nlattr *a, struct ds *ds)
340 const struct ovs_key_ethernet *eth_key;
341 const struct ovs_key_8021q *q_key;
342 const struct ovs_key_ipv4 *ipv4_key;
343 const struct ovs_key_ipv6 *ipv6_key;
344 const struct ovs_key_tcp *tcp_key;
345 const struct ovs_key_udp *udp_key;
346 const struct ovs_key_icmp *icmp_key;
347 const struct ovs_key_icmpv6 *icmpv6_key;
348 const struct ovs_key_arp *arp_key;
349 const struct ovs_key_nd *nd_key;
350 enum ovs_key_attr attr = nl_attr_type(a);
352 if (nl_attr_get_size(a) != odp_flow_key_attr_len(nl_attr_type(a))) {
353 ds_put_format(ds, "bad length %zu, expected %d for: ",
355 odp_flow_key_attr_len(nl_attr_type(a)));
356 format_generic_odp_key(a, ds);
361 case OVS_KEY_ATTR_PRIORITY:
362 ds_put_format(ds, "priority(%"PRIu32")", nl_attr_get_u32(a));
365 case OVS_KEY_ATTR_TUN_ID:
366 ds_put_format(ds, "tun_id(%#"PRIx64")", ntohll(nl_attr_get_be64(a)));
369 case OVS_KEY_ATTR_IN_PORT:
370 ds_put_format(ds, "in_port(%"PRIu32")", nl_attr_get_u32(a));
373 case OVS_KEY_ATTR_ETHERNET:
374 eth_key = nl_attr_get(a);
375 ds_put_format(ds, "eth(src="ETH_ADDR_FMT",dst="ETH_ADDR_FMT")",
376 ETH_ADDR_ARGS(eth_key->eth_src),
377 ETH_ADDR_ARGS(eth_key->eth_dst));
380 case OVS_KEY_ATTR_8021Q:
381 q_key = nl_attr_get(a);
382 ds_put_cstr(ds, "vlan(");
383 if (q_key->q_tpid != htons(ETH_TYPE_VLAN)) {
384 ds_put_format(ds, "tpid=0x%04"PRIx16",", ntohs(q_key->q_tpid));
386 ds_put_format(ds, "vid=%"PRIu16",pcp=%d)",
387 vlan_tci_to_vid(q_key->q_tci),
388 vlan_tci_to_pcp(q_key->q_tci));
391 case OVS_KEY_ATTR_ETHERTYPE:
392 ds_put_format(ds, "eth_type(0x%04"PRIx16")",
393 ntohs(nl_attr_get_be16(a)));
396 case OVS_KEY_ATTR_IPV4:
397 ipv4_key = nl_attr_get(a);
398 ds_put_format(ds, "ipv4(src="IP_FMT",dst="IP_FMT",proto=%"PRIu8
399 ",tos=%#"PRIx8",ttl=%"PRIu8",frag=%s)",
400 IP_ARGS(&ipv4_key->ipv4_src),
401 IP_ARGS(&ipv4_key->ipv4_dst),
402 ipv4_key->ipv4_proto, ipv4_key->ipv4_tos,
404 ovs_frag_type_to_string(ipv4_key->ipv4_frag));
407 case OVS_KEY_ATTR_IPV6: {
408 char src_str[INET6_ADDRSTRLEN];
409 char dst_str[INET6_ADDRSTRLEN];
411 ipv6_key = nl_attr_get(a);
412 inet_ntop(AF_INET6, ipv6_key->ipv6_src, src_str, sizeof src_str);
413 inet_ntop(AF_INET6, ipv6_key->ipv6_dst, dst_str, sizeof dst_str);
415 ds_put_format(ds, "ipv6(src=%s,dst=%s,label=%#"PRIx32",proto=%"PRIu8
416 ",tclass=%#"PRIx8",hlimit=%"PRIu8",frag=%s)",
417 src_str, dst_str, ntohl(ipv6_key->ipv6_label),
418 ipv6_key->ipv6_proto, ipv6_key->ipv6_tclass,
419 ipv6_key->ipv6_hlimit,
420 ovs_frag_type_to_string(ipv6_key->ipv6_frag));
424 case OVS_KEY_ATTR_TCP:
425 tcp_key = nl_attr_get(a);
426 ds_put_format(ds, "tcp(src=%"PRIu16",dst=%"PRIu16")",
427 ntohs(tcp_key->tcp_src), ntohs(tcp_key->tcp_dst));
430 case OVS_KEY_ATTR_UDP:
431 udp_key = nl_attr_get(a);
432 ds_put_format(ds, "udp(src=%"PRIu16",dst=%"PRIu16")",
433 ntohs(udp_key->udp_src), ntohs(udp_key->udp_dst));
436 case OVS_KEY_ATTR_ICMP:
437 icmp_key = nl_attr_get(a);
438 ds_put_format(ds, "icmp(type=%"PRIu8",code=%"PRIu8")",
439 icmp_key->icmp_type, icmp_key->icmp_code);
442 case OVS_KEY_ATTR_ICMPV6:
443 icmpv6_key = nl_attr_get(a);
444 ds_put_format(ds, "icmpv6(type=%"PRIu8",code=%"PRIu8")",
445 icmpv6_key->icmpv6_type, icmpv6_key->icmpv6_code);
448 case OVS_KEY_ATTR_ARP:
449 arp_key = nl_attr_get(a);
450 ds_put_format(ds, "arp(sip="IP_FMT",tip="IP_FMT",op=%"PRIu16","
451 "sha="ETH_ADDR_FMT",tha="ETH_ADDR_FMT")",
452 IP_ARGS(&arp_key->arp_sip), IP_ARGS(&arp_key->arp_tip),
453 ntohs(arp_key->arp_op), ETH_ADDR_ARGS(arp_key->arp_sha),
454 ETH_ADDR_ARGS(arp_key->arp_tha));
457 case OVS_KEY_ATTR_ND: {
458 char target[INET6_ADDRSTRLEN];
460 nd_key = nl_attr_get(a);
461 inet_ntop(AF_INET6, nd_key->nd_target, target, sizeof target);
463 ds_put_format(ds, "nd(target=%s", target);
464 if (!eth_addr_is_zero(nd_key->nd_sll)) {
465 ds_put_format(ds, ",sll="ETH_ADDR_FMT,
466 ETH_ADDR_ARGS(nd_key->nd_sll));
468 if (!eth_addr_is_zero(nd_key->nd_tll)) {
469 ds_put_format(ds, ",tll="ETH_ADDR_FMT,
470 ETH_ADDR_ARGS(nd_key->nd_tll));
472 ds_put_char(ds, ')');
476 case OVS_KEY_ATTR_UNSPEC:
477 case __OVS_KEY_ATTR_MAX:
479 format_generic_odp_key(a, ds);
484 /* Appends to 'ds' a string representation of the 'key_len' bytes of
485 * OVS_KEY_ATTR_* attributes in 'key'. */
487 odp_flow_key_format(const struct nlattr *key, size_t key_len, struct ds *ds)
490 const struct nlattr *a;
493 NL_ATTR_FOR_EACH (a, left, key, key_len) {
495 ds_put_char(ds, ',');
497 format_odp_key_attr(a, ds);
500 if (left == key_len) {
501 ds_put_cstr(ds, "<empty>");
503 ds_put_format(ds, ",***%u leftover bytes***", left);
506 ds_put_cstr(ds, "<empty>");
511 put_nd_key(int n, const char *nd_target_s,
512 const uint8_t *nd_sll, const uint8_t *nd_tll, struct ofpbuf *key)
514 struct ovs_key_nd nd_key;
516 memset(&nd_key, 0, sizeof nd_key);
517 if (inet_pton(AF_INET6, nd_target_s, nd_key.nd_target) != 1) {
521 memcpy(nd_key.nd_sll, nd_sll, ETH_ADDR_LEN);
524 memcpy(nd_key.nd_tll, nd_tll, ETH_ADDR_LEN);
526 nl_msg_put_unspec(key, OVS_KEY_ATTR_ND, &nd_key, sizeof nd_key);
531 ovs_frag_type_from_string(const char *s, enum ovs_frag_type *type)
533 if (!strcasecmp(s, "no")) {
534 *type = OVS_FRAG_TYPE_NONE;
535 } else if (!strcasecmp(s, "first")) {
536 *type = OVS_FRAG_TYPE_FIRST;
537 } else if (!strcasecmp(s, "later")) {
538 *type = OVS_FRAG_TYPE_LATER;
546 parse_odp_key_attr(const char *s, struct ofpbuf *key)
548 /* Many of the sscanf calls in this function use oversized destination
549 * fields because some sscanf() implementations truncate the range of %i
550 * directives, so that e.g. "%"SCNi16 interprets input of "0xfedc" as a
551 * value of 0x7fff. The other alternatives are to allow only a single
552 * radix (e.g. decimal or hexadecimal) or to write more sophisticated
555 * The tun_id parser has to use an alternative approach because there is no
556 * type larger than 64 bits. */
559 unsigned long long int priority;
562 if (sscanf(s, "priority(%lli)%n", &priority, &n) > 0 && n > 0) {
563 nl_msg_put_u32(key, OVS_KEY_ATTR_PRIORITY, priority);
572 if (sscanf(s, "tun_id(%31[x0123456789abcdefABCDEF])%n",
573 tun_id_s, &n) > 0 && n > 0) {
574 uint64_t tun_id = strtoull(tun_id_s, NULL, 0);
575 nl_msg_put_be64(key, OVS_KEY_ATTR_TUN_ID, htonll(tun_id));
581 unsigned long long int in_port;
584 if (sscanf(s, "in_port(%lli)%n", &in_port, &n) > 0 && n > 0) {
585 nl_msg_put_u32(key, OVS_KEY_ATTR_IN_PORT, in_port);
591 struct ovs_key_ethernet eth_key;
595 "eth(src="ETH_ADDR_SCAN_FMT",dst="ETH_ADDR_SCAN_FMT")%n",
596 ETH_ADDR_SCAN_ARGS(eth_key.eth_src),
597 ETH_ADDR_SCAN_ARGS(eth_key.eth_dst), &n) > 0 && n > 0) {
598 nl_msg_put_unspec(key, OVS_KEY_ATTR_ETHERNET,
599 ð_key, sizeof eth_key);
605 uint16_t tpid = ETH_TYPE_VLAN;
610 if ((sscanf(s, "vlan(vid=%"SCNi16",pcp=%i)%n",
611 &vid, &pcp, &n) > 0 && n > 0) ||
612 (sscanf(s, "vlan(tpid=%"SCNi16",vid=%"SCNi16",pcp=%i)%n",
613 &tpid, &vid, &pcp, &n) > 0 && n > 0)) {
614 struct ovs_key_8021q q_key;
616 q_key.q_tpid = htons(tpid);
617 q_key.q_tci = htons((vid << VLAN_VID_SHIFT) |
618 (pcp << VLAN_PCP_SHIFT));
619 nl_msg_put_unspec(key, OVS_KEY_ATTR_8021Q, &q_key, sizeof q_key);
628 if (sscanf(s, "eth_type(%i)%n", ð_type, &n) > 0 && n > 0) {
629 nl_msg_put_be16(key, OVS_KEY_ATTR_ETHERTYPE, htons(eth_type));
641 enum ovs_frag_type ipv4_frag;
644 if (sscanf(s, "ipv4(src="IP_SCAN_FMT",dst="IP_SCAN_FMT","
645 "proto=%i,tos=%i,ttl=%i,frag=%7[a-z])%n",
646 IP_SCAN_ARGS(&ipv4_src), IP_SCAN_ARGS(&ipv4_dst),
647 &ipv4_proto, &ipv4_tos, &ipv4_ttl, frag, &n) > 0
649 && ovs_frag_type_from_string(frag, &ipv4_frag)) {
650 struct ovs_key_ipv4 ipv4_key;
652 ipv4_key.ipv4_src = ipv4_src;
653 ipv4_key.ipv4_dst = ipv4_dst;
654 ipv4_key.ipv4_proto = ipv4_proto;
655 ipv4_key.ipv4_tos = ipv4_tos;
656 ipv4_key.ipv4_ttl = ipv4_ttl;
657 ipv4_key.ipv4_frag = ipv4_frag;
658 nl_msg_put_unspec(key, OVS_KEY_ATTR_IPV4,
659 &ipv4_key, sizeof ipv4_key);
665 char ipv6_src_s[IPV6_SCAN_LEN + 1];
666 char ipv6_dst_s[IPV6_SCAN_LEN + 1];
672 enum ovs_frag_type ipv6_frag;
675 if (sscanf(s, "ipv6(src="IPV6_SCAN_FMT",dst="IPV6_SCAN_FMT","
676 "label=%i,proto=%i,tclass=%i,hlimit=%i,frag=%7[a-z])%n",
677 ipv6_src_s, ipv6_dst_s, &ipv6_label,
678 &ipv6_proto, &ipv6_tclass, &ipv6_hlimit, frag, &n) > 0
680 && ovs_frag_type_from_string(frag, &ipv6_frag)) {
681 struct ovs_key_ipv6 ipv6_key;
683 if (inet_pton(AF_INET6, ipv6_src_s, &ipv6_key.ipv6_src) != 1 ||
684 inet_pton(AF_INET6, ipv6_dst_s, &ipv6_key.ipv6_dst) != 1) {
687 ipv6_key.ipv6_label = htonl(ipv6_label);
688 ipv6_key.ipv6_proto = ipv6_proto;
689 ipv6_key.ipv6_tclass = ipv6_tclass;
690 ipv6_key.ipv6_hlimit = ipv6_hlimit;
691 ipv6_key.ipv6_frag = ipv6_frag;
692 nl_msg_put_unspec(key, OVS_KEY_ATTR_IPV6,
693 &ipv6_key, sizeof ipv6_key);
703 if (sscanf(s, "tcp(src=%i,dst=%i)%n",&tcp_src, &tcp_dst, &n) > 0
705 struct ovs_key_tcp tcp_key;
707 tcp_key.tcp_src = htons(tcp_src);
708 tcp_key.tcp_dst = htons(tcp_dst);
709 nl_msg_put_unspec(key, OVS_KEY_ATTR_TCP, &tcp_key, sizeof tcp_key);
719 if (sscanf(s, "udp(src=%i,dst=%i)%n", &udp_src, &udp_dst, &n) > 0
721 struct ovs_key_udp udp_key;
723 udp_key.udp_src = htons(udp_src);
724 udp_key.udp_dst = htons(udp_dst);
725 nl_msg_put_unspec(key, OVS_KEY_ATTR_UDP, &udp_key, sizeof udp_key);
735 if (sscanf(s, "icmp(type=%i,code=%i)%n",
736 &icmp_type, &icmp_code, &n) > 0
738 struct ovs_key_icmp icmp_key;
740 icmp_key.icmp_type = icmp_type;
741 icmp_key.icmp_code = icmp_code;
742 nl_msg_put_unspec(key, OVS_KEY_ATTR_ICMP,
743 &icmp_key, sizeof icmp_key);
749 struct ovs_key_icmpv6 icmpv6_key;
752 if (sscanf(s, "icmpv6(type=%"SCNi8",code=%"SCNi8")%n",
753 &icmpv6_key.icmpv6_type, &icmpv6_key.icmpv6_code,&n) > 0
755 nl_msg_put_unspec(key, OVS_KEY_ATTR_ICMPV6,
756 &icmpv6_key, sizeof icmpv6_key);
765 uint8_t arp_sha[ETH_ADDR_LEN];
766 uint8_t arp_tha[ETH_ADDR_LEN];
769 if (sscanf(s, "arp(sip="IP_SCAN_FMT",tip="IP_SCAN_FMT","
770 "op=%i,sha="ETH_ADDR_SCAN_FMT",tha="ETH_ADDR_SCAN_FMT")%n",
771 IP_SCAN_ARGS(&arp_sip),
772 IP_SCAN_ARGS(&arp_tip),
774 ETH_ADDR_SCAN_ARGS(arp_sha),
775 ETH_ADDR_SCAN_ARGS(arp_tha), &n) > 0 && n > 0) {
776 struct ovs_key_arp arp_key;
778 memset(&arp_key, 0, sizeof arp_key);
779 arp_key.arp_sip = arp_sip;
780 arp_key.arp_tip = arp_tip;
781 arp_key.arp_op = htons(arp_op);
782 memcpy(arp_key.arp_sha, arp_sha, ETH_ADDR_LEN);
783 memcpy(arp_key.arp_tha, arp_tha, ETH_ADDR_LEN);
784 nl_msg_put_unspec(key, OVS_KEY_ATTR_ARP, &arp_key, sizeof arp_key);
790 char nd_target_s[IPV6_SCAN_LEN + 1];
791 uint8_t nd_sll[ETH_ADDR_LEN];
792 uint8_t nd_tll[ETH_ADDR_LEN];
795 if (sscanf(s, "nd(target="IPV6_SCAN_FMT")%n",
796 nd_target_s, &n) > 0 && n > 0) {
797 return put_nd_key(n, nd_target_s, NULL, NULL, key);
799 if (sscanf(s, "nd(target="IPV6_SCAN_FMT",sll="ETH_ADDR_SCAN_FMT")%n",
800 nd_target_s, ETH_ADDR_SCAN_ARGS(nd_sll), &n) > 0
802 return put_nd_key(n, nd_target_s, nd_sll, NULL, key);
804 if (sscanf(s, "nd(target="IPV6_SCAN_FMT",tll="ETH_ADDR_SCAN_FMT")%n",
805 nd_target_s, ETH_ADDR_SCAN_ARGS(nd_tll), &n) > 0
807 return put_nd_key(n, nd_target_s, NULL, nd_tll, key);
809 if (sscanf(s, "nd(target="IPV6_SCAN_FMT",sll="ETH_ADDR_SCAN_FMT","
810 "tll="ETH_ADDR_SCAN_FMT")%n",
811 nd_target_s, ETH_ADDR_SCAN_ARGS(nd_sll),
812 ETH_ADDR_SCAN_ARGS(nd_tll), &n) > 0
814 return put_nd_key(n, nd_target_s, nd_sll, nd_tll, key);
821 /* Parses the string representation of a datapath flow key, in the
822 * format output by odp_flow_key_format(). Returns 0 if successful,
823 * otherwise a positive errno value. On success, the flow key is
824 * appended to 'key' as a series of Netlink attributes. On failure, no
825 * data is appended to 'key'. Either way, 'key''s data might be
828 * On success, the attributes appended to 'key' are individually syntactically
829 * valid, but they may not be valid as a sequence. 'key' might, for example,
830 * be missing an "in_port" key, have duplicated keys, or have keys in the wrong
831 * order. odp_flow_key_to_flow() will detect those errors. */
833 odp_flow_key_from_string(const char *s, struct ofpbuf *key)
835 const size_t old_size = key->size;
839 s += strspn(s, ", \t\r\n");
844 retval = parse_odp_key_attr(s, key);
846 key->size = old_size;
856 ovs_to_odp_frag(uint8_t ovs_frag)
858 return (ovs_frag & FLOW_NW_FRAG_LATER ? OVS_FRAG_TYPE_LATER
859 : ovs_frag & FLOW_NW_FRAG_ANY ? OVS_FRAG_TYPE_FIRST
860 : OVS_FRAG_TYPE_NONE);
863 /* Appends a representation of 'flow' as OVS_KEY_ATTR_* attributes to 'buf'. */
865 odp_flow_key_from_flow(struct ofpbuf *buf, const struct flow *flow)
867 struct ovs_key_ethernet *eth_key;
869 if (flow->priority) {
870 nl_msg_put_u32(buf, OVS_KEY_ATTR_PRIORITY, flow->priority);
873 if (flow->tun_id != htonll(0)) {
874 nl_msg_put_be64(buf, OVS_KEY_ATTR_TUN_ID, flow->tun_id);
877 if (flow->in_port != OFPP_NONE) {
878 nl_msg_put_u32(buf, OVS_KEY_ATTR_IN_PORT,
879 ofp_port_to_odp_port(flow->in_port));
882 eth_key = nl_msg_put_unspec_uninit(buf, OVS_KEY_ATTR_ETHERNET,
884 memcpy(eth_key->eth_src, flow->dl_src, ETH_ADDR_LEN);
885 memcpy(eth_key->eth_dst, flow->dl_dst, ETH_ADDR_LEN);
887 if (flow->vlan_tci != htons(0)) {
888 struct ovs_key_8021q *q_key;
890 q_key = nl_msg_put_unspec_uninit(buf, OVS_KEY_ATTR_8021Q,
892 q_key->q_tpid = htons(ETH_TYPE_VLAN);
893 q_key->q_tci = flow->vlan_tci & ~htons(VLAN_CFI);
896 if (ntohs(flow->dl_type) < ETH_TYPE_MIN) {
900 nl_msg_put_be16(buf, OVS_KEY_ATTR_ETHERTYPE, flow->dl_type);
902 if (flow->dl_type == htons(ETH_TYPE_IP)) {
903 struct ovs_key_ipv4 *ipv4_key;
905 ipv4_key = nl_msg_put_unspec_uninit(buf, OVS_KEY_ATTR_IPV4,
907 ipv4_key->ipv4_src = flow->nw_src;
908 ipv4_key->ipv4_dst = flow->nw_dst;
909 ipv4_key->ipv4_proto = flow->nw_proto;
910 ipv4_key->ipv4_tos = flow->nw_tos;
911 ipv4_key->ipv4_ttl = flow->nw_ttl;
912 ipv4_key->ipv4_frag = ovs_to_odp_frag(flow->nw_frag);
913 } else if (flow->dl_type == htons(ETH_TYPE_IPV6)) {
914 struct ovs_key_ipv6 *ipv6_key;
916 ipv6_key = nl_msg_put_unspec_uninit(buf, OVS_KEY_ATTR_IPV6,
918 memcpy(ipv6_key->ipv6_src, &flow->ipv6_src, sizeof ipv6_key->ipv6_src);
919 memcpy(ipv6_key->ipv6_dst, &flow->ipv6_dst, sizeof ipv6_key->ipv6_dst);
920 ipv6_key->ipv6_label = flow->ipv6_label;
921 ipv6_key->ipv6_proto = flow->nw_proto;
922 ipv6_key->ipv6_tclass = flow->nw_tos;
923 ipv6_key->ipv6_hlimit = flow->nw_ttl;
924 ipv6_key->ipv6_frag = ovs_to_odp_frag(flow->nw_frag);
925 } else if (flow->dl_type == htons(ETH_TYPE_ARP)) {
926 struct ovs_key_arp *arp_key;
928 arp_key = nl_msg_put_unspec_uninit(buf, OVS_KEY_ATTR_ARP,
930 memset(arp_key, 0, sizeof *arp_key);
931 arp_key->arp_sip = flow->nw_src;
932 arp_key->arp_tip = flow->nw_dst;
933 arp_key->arp_op = htons(flow->nw_proto);
934 memcpy(arp_key->arp_sha, flow->arp_sha, ETH_ADDR_LEN);
935 memcpy(arp_key->arp_tha, flow->arp_tha, ETH_ADDR_LEN);
938 if ((flow->dl_type == htons(ETH_TYPE_IP)
939 || flow->dl_type == htons(ETH_TYPE_IPV6))
940 && !(flow->nw_frag & FLOW_NW_FRAG_LATER)) {
942 if (flow->nw_proto == IPPROTO_TCP) {
943 struct ovs_key_tcp *tcp_key;
945 tcp_key = nl_msg_put_unspec_uninit(buf, OVS_KEY_ATTR_TCP,
947 tcp_key->tcp_src = flow->tp_src;
948 tcp_key->tcp_dst = flow->tp_dst;
949 } else if (flow->nw_proto == IPPROTO_UDP) {
950 struct ovs_key_udp *udp_key;
952 udp_key = nl_msg_put_unspec_uninit(buf, OVS_KEY_ATTR_UDP,
954 udp_key->udp_src = flow->tp_src;
955 udp_key->udp_dst = flow->tp_dst;
956 } else if (flow->dl_type == htons(ETH_TYPE_IP)
957 && flow->nw_proto == IPPROTO_ICMP) {
958 struct ovs_key_icmp *icmp_key;
960 icmp_key = nl_msg_put_unspec_uninit(buf, OVS_KEY_ATTR_ICMP,
962 icmp_key->icmp_type = ntohs(flow->tp_src);
963 icmp_key->icmp_code = ntohs(flow->tp_dst);
964 } else if (flow->dl_type == htons(ETH_TYPE_IPV6)
965 && flow->nw_proto == IPPROTO_ICMPV6) {
966 struct ovs_key_icmpv6 *icmpv6_key;
968 icmpv6_key = nl_msg_put_unspec_uninit(buf, OVS_KEY_ATTR_ICMPV6,
970 icmpv6_key->icmpv6_type = ntohs(flow->tp_src);
971 icmpv6_key->icmpv6_code = ntohs(flow->tp_dst);
973 if (icmpv6_key->icmpv6_type == ND_NEIGHBOR_SOLICIT
974 || icmpv6_key->icmpv6_type == ND_NEIGHBOR_ADVERT) {
975 struct ovs_key_nd *nd_key;
977 nd_key = nl_msg_put_unspec_uninit(buf, OVS_KEY_ATTR_ND,
979 memcpy(nd_key->nd_target, &flow->nd_target,
980 sizeof nd_key->nd_target);
981 memcpy(nd_key->nd_sll, flow->arp_sha, ETH_ADDR_LEN);
982 memcpy(nd_key->nd_tll, flow->arp_tha, ETH_ADDR_LEN);
989 odp_to_ovs_frag(uint8_t odp_frag, struct flow *flow)
991 if (odp_frag > OVS_FRAG_TYPE_LATER) {
995 if (odp_frag != OVS_FRAG_TYPE_NONE) {
996 flow->nw_frag |= FLOW_NW_FRAG_ANY;
997 if (odp_frag == OVS_FRAG_TYPE_LATER) {
998 flow->nw_frag |= FLOW_NW_FRAG_LATER;
1004 /* Converts the 'key_len' bytes of OVS_KEY_ATTR_* attributes in 'key' to a flow
1005 * structure in 'flow'. Returns 0 if successful, otherwise EINVAL. */
1007 odp_flow_key_to_flow(const struct nlattr *key, size_t key_len,
1010 const struct nlattr *nla;
1011 enum ovs_key_attr prev_type;
1014 memset(flow, 0, sizeof *flow);
1015 flow->dl_type = htons(FLOW_DL_TYPE_NONE);
1016 flow->in_port = OFPP_NONE;
1018 prev_type = OVS_KEY_ATTR_UNSPEC;
1019 NL_ATTR_FOR_EACH (nla, left, key, key_len) {
1020 const struct ovs_key_ethernet *eth_key;
1021 const struct ovs_key_8021q *q_key;
1022 const struct ovs_key_ipv4 *ipv4_key;
1023 const struct ovs_key_ipv6 *ipv6_key;
1024 const struct ovs_key_tcp *tcp_key;
1025 const struct ovs_key_udp *udp_key;
1026 const struct ovs_key_icmp *icmp_key;
1027 const struct ovs_key_icmpv6 *icmpv6_key;
1028 const struct ovs_key_arp *arp_key;
1029 const struct ovs_key_nd *nd_key;
1031 uint16_t type = nl_attr_type(nla);
1032 int len = odp_flow_key_attr_len(type);
1034 if (nl_attr_get_size(nla) != len && len != -1) {
1038 #define TRANSITION(PREV_TYPE, TYPE) (((PREV_TYPE) << 16) | (TYPE))
1039 switch (TRANSITION(prev_type, type)) {
1040 case TRANSITION(OVS_KEY_ATTR_UNSPEC, OVS_KEY_ATTR_PRIORITY):
1041 flow->priority = nl_attr_get_u32(nla);
1044 case TRANSITION(OVS_KEY_ATTR_UNSPEC, OVS_KEY_ATTR_TUN_ID):
1045 case TRANSITION(OVS_KEY_ATTR_PRIORITY, OVS_KEY_ATTR_TUN_ID):
1046 flow->tun_id = nl_attr_get_be64(nla);
1049 case TRANSITION(OVS_KEY_ATTR_UNSPEC, OVS_KEY_ATTR_IN_PORT):
1050 case TRANSITION(OVS_KEY_ATTR_PRIORITY, OVS_KEY_ATTR_IN_PORT):
1051 case TRANSITION(OVS_KEY_ATTR_TUN_ID, OVS_KEY_ATTR_IN_PORT):
1052 if (nl_attr_get_u32(nla) >= UINT16_MAX) {
1055 flow->in_port = odp_port_to_ofp_port(nl_attr_get_u32(nla));
1058 case TRANSITION(OVS_KEY_ATTR_UNSPEC, OVS_KEY_ATTR_ETHERNET):
1059 case TRANSITION(OVS_KEY_ATTR_PRIORITY, OVS_KEY_ATTR_ETHERNET):
1060 case TRANSITION(OVS_KEY_ATTR_TUN_ID, OVS_KEY_ATTR_ETHERNET):
1061 case TRANSITION(OVS_KEY_ATTR_IN_PORT, OVS_KEY_ATTR_ETHERNET):
1062 eth_key = nl_attr_get(nla);
1063 memcpy(flow->dl_src, eth_key->eth_src, ETH_ADDR_LEN);
1064 memcpy(flow->dl_dst, eth_key->eth_dst, ETH_ADDR_LEN);
1067 case TRANSITION(OVS_KEY_ATTR_ETHERNET, OVS_KEY_ATTR_8021Q):
1068 q_key = nl_attr_get(nla);
1069 if (q_key->q_tpid != htons(ETH_TYPE_VLAN)) {
1070 /* Only standard 0x8100 VLANs currently supported. */
1073 if (q_key->q_tci & htons(VLAN_CFI)) {
1076 flow->vlan_tci = q_key->q_tci | htons(VLAN_CFI);
1079 case TRANSITION(OVS_KEY_ATTR_8021Q, OVS_KEY_ATTR_ETHERTYPE):
1080 case TRANSITION(OVS_KEY_ATTR_ETHERNET, OVS_KEY_ATTR_ETHERTYPE):
1081 flow->dl_type = nl_attr_get_be16(nla);
1082 if (ntohs(flow->dl_type) < 1536) {
1087 case TRANSITION(OVS_KEY_ATTR_ETHERTYPE, OVS_KEY_ATTR_IPV4):
1088 if (flow->dl_type != htons(ETH_TYPE_IP)) {
1091 ipv4_key = nl_attr_get(nla);
1092 flow->nw_src = ipv4_key->ipv4_src;
1093 flow->nw_dst = ipv4_key->ipv4_dst;
1094 flow->nw_proto = ipv4_key->ipv4_proto;
1095 flow->nw_tos = ipv4_key->ipv4_tos;
1096 flow->nw_ttl = ipv4_key->ipv4_ttl;
1097 if (!odp_to_ovs_frag(ipv4_key->ipv4_frag, flow)) {
1102 case TRANSITION(OVS_KEY_ATTR_ETHERTYPE, OVS_KEY_ATTR_IPV6):
1103 if (flow->dl_type != htons(ETH_TYPE_IPV6)) {
1106 ipv6_key = nl_attr_get(nla);
1107 memcpy(&flow->ipv6_src, ipv6_key->ipv6_src, sizeof flow->ipv6_src);
1108 memcpy(&flow->ipv6_dst, ipv6_key->ipv6_dst, sizeof flow->ipv6_dst);
1109 flow->ipv6_label = ipv6_key->ipv6_label;
1110 flow->nw_proto = ipv6_key->ipv6_proto;
1111 flow->nw_tos = ipv6_key->ipv6_tclass;
1112 flow->nw_ttl = ipv6_key->ipv6_hlimit;
1113 if (!odp_to_ovs_frag(ipv6_key->ipv6_frag, flow)) {
1118 case TRANSITION(OVS_KEY_ATTR_IPV4, OVS_KEY_ATTR_TCP):
1119 case TRANSITION(OVS_KEY_ATTR_IPV6, OVS_KEY_ATTR_TCP):
1120 if (flow->nw_proto != IPPROTO_TCP) {
1123 tcp_key = nl_attr_get(nla);
1124 flow->tp_src = tcp_key->tcp_src;
1125 flow->tp_dst = tcp_key->tcp_dst;
1128 case TRANSITION(OVS_KEY_ATTR_IPV4, OVS_KEY_ATTR_UDP):
1129 case TRANSITION(OVS_KEY_ATTR_IPV6, OVS_KEY_ATTR_UDP):
1130 if (flow->nw_proto != IPPROTO_UDP) {
1133 udp_key = nl_attr_get(nla);
1134 flow->tp_src = udp_key->udp_src;
1135 flow->tp_dst = udp_key->udp_dst;
1138 case TRANSITION(OVS_KEY_ATTR_IPV4, OVS_KEY_ATTR_ICMP):
1139 if (flow->nw_proto != IPPROTO_ICMP) {
1142 icmp_key = nl_attr_get(nla);
1143 flow->tp_src = htons(icmp_key->icmp_type);
1144 flow->tp_dst = htons(icmp_key->icmp_code);
1147 case TRANSITION(OVS_KEY_ATTR_IPV6, OVS_KEY_ATTR_ICMPV6):
1148 if (flow->nw_proto != IPPROTO_ICMPV6) {
1151 icmpv6_key = nl_attr_get(nla);
1152 flow->tp_src = htons(icmpv6_key->icmpv6_type);
1153 flow->tp_dst = htons(icmpv6_key->icmpv6_code);
1156 case TRANSITION(OVS_KEY_ATTR_ETHERTYPE, OVS_KEY_ATTR_ARP):
1157 if (flow->dl_type != htons(ETH_TYPE_ARP)) {
1160 arp_key = nl_attr_get(nla);
1161 flow->nw_src = arp_key->arp_sip;
1162 flow->nw_dst = arp_key->arp_tip;
1163 if (arp_key->arp_op & htons(0xff00)) {
1166 flow->nw_proto = ntohs(arp_key->arp_op);
1167 memcpy(flow->arp_sha, arp_key->arp_sha, ETH_ADDR_LEN);
1168 memcpy(flow->arp_tha, arp_key->arp_tha, ETH_ADDR_LEN);
1171 case TRANSITION(OVS_KEY_ATTR_ICMPV6, OVS_KEY_ATTR_ND):
1172 if (flow->tp_src != htons(ND_NEIGHBOR_SOLICIT)
1173 && flow->tp_src != htons(ND_NEIGHBOR_ADVERT)) {
1176 nd_key = nl_attr_get(nla);
1177 memcpy(&flow->nd_target, nd_key->nd_target, sizeof flow->nd_target);
1178 memcpy(flow->arp_sha, nd_key->nd_sll, ETH_ADDR_LEN);
1179 memcpy(flow->arp_tha, nd_key->nd_tll, ETH_ADDR_LEN);
1192 switch (prev_type) {
1193 case OVS_KEY_ATTR_UNSPEC:
1196 case OVS_KEY_ATTR_PRIORITY:
1197 case OVS_KEY_ATTR_TUN_ID:
1198 case OVS_KEY_ATTR_IN_PORT:
1201 case OVS_KEY_ATTR_ETHERNET:
1202 case OVS_KEY_ATTR_8021Q:
1205 case OVS_KEY_ATTR_ETHERTYPE:
1206 if (flow->dl_type == htons(ETH_TYPE_IP)
1207 || flow->dl_type == htons(ETH_TYPE_IPV6)
1208 || flow->dl_type == htons(ETH_TYPE_ARP)) {
1213 case OVS_KEY_ATTR_IPV4:
1214 if (flow->nw_frag & FLOW_NW_FRAG_LATER) {
1217 if (flow->nw_proto == IPPROTO_TCP
1218 || flow->nw_proto == IPPROTO_UDP
1219 || flow->nw_proto == IPPROTO_ICMP) {
1224 case OVS_KEY_ATTR_IPV6:
1225 if (flow->nw_frag & FLOW_NW_FRAG_LATER) {
1228 if (flow->nw_proto == IPPROTO_TCP
1229 || flow->nw_proto == IPPROTO_UDP
1230 || flow->nw_proto == IPPROTO_ICMPV6) {
1235 case OVS_KEY_ATTR_ICMPV6:
1236 if (flow->tp_src == htons(ND_NEIGHBOR_SOLICIT)
1237 || flow->tp_src == htons(ND_NEIGHBOR_ADVERT)
1238 || flow->nw_frag & FLOW_NW_FRAG_LATER) {
1243 case OVS_KEY_ATTR_TCP:
1244 case OVS_KEY_ATTR_UDP:
1245 case OVS_KEY_ATTR_ICMP:
1246 case OVS_KEY_ATTR_ND:
1247 if (flow->nw_frag & FLOW_NW_FRAG_LATER) {
1252 case OVS_KEY_ATTR_ARP:
1255 case __OVS_KEY_ATTR_MAX: