]>
git.proxmox.com Git - ovs.git/blob - lib/flow.c
ea7746c971ed9a2bdb3225817447ea08e899fe02
2 * Copyright (c) 2008, 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 <sys/types.h>
21 #include <netinet/in.h>
22 #include <netinet/icmp6.h>
23 #include <netinet/ip6.h>
26 #include "byte-order.h"
29 #include "dynamic-string.h"
32 #include "openflow/openflow.h"
33 #include "openvswitch/datapath-protocol.h"
35 #include "unaligned.h"
38 VLOG_DEFINE_THIS_MODULE(flow
);
40 COVERAGE_DEFINE(flow_extract
);
42 static struct arp_eth_header
*
43 pull_arp(struct ofpbuf
*packet
)
45 return ofpbuf_try_pull(packet
, ARP_ETH_HEADER_LEN
);
48 static struct ip_header
*
49 pull_ip(struct ofpbuf
*packet
)
51 if (packet
->size
>= IP_HEADER_LEN
) {
52 struct ip_header
*ip
= packet
->data
;
53 int ip_len
= IP_IHL(ip
->ip_ihl_ver
) * 4;
54 if (ip_len
>= IP_HEADER_LEN
&& packet
->size
>= ip_len
) {
55 return ofpbuf_pull(packet
, ip_len
);
61 static struct tcp_header
*
62 pull_tcp(struct ofpbuf
*packet
)
64 if (packet
->size
>= TCP_HEADER_LEN
) {
65 struct tcp_header
*tcp
= packet
->data
;
66 int tcp_len
= TCP_OFFSET(tcp
->tcp_ctl
) * 4;
67 if (tcp_len
>= TCP_HEADER_LEN
&& packet
->size
>= tcp_len
) {
68 return ofpbuf_pull(packet
, tcp_len
);
74 static struct udp_header
*
75 pull_udp(struct ofpbuf
*packet
)
77 return ofpbuf_try_pull(packet
, UDP_HEADER_LEN
);
80 static struct icmp_header
*
81 pull_icmp(struct ofpbuf
*packet
)
83 return ofpbuf_try_pull(packet
, ICMP_HEADER_LEN
);
86 static struct icmp6_hdr
*
87 pull_icmpv6(struct ofpbuf
*packet
)
89 return ofpbuf_try_pull(packet
, sizeof(struct icmp6_hdr
));
93 parse_vlan(struct ofpbuf
*b
, struct flow
*flow
)
96 ovs_be16 eth_type
; /* ETH_TYPE_VLAN */
100 if (b
->size
>= sizeof(struct qtag_prefix
) + sizeof(ovs_be16
)) {
101 struct qtag_prefix
*qp
= ofpbuf_pull(b
, sizeof *qp
);
102 flow
->vlan_tci
= qp
->tci
| htons(VLAN_CFI
);
107 parse_ethertype(struct ofpbuf
*b
)
109 struct llc_snap_header
*llc
;
112 proto
= *(ovs_be16
*) ofpbuf_pull(b
, sizeof proto
);
113 if (ntohs(proto
) >= ETH_TYPE_MIN
) {
117 if (b
->size
< sizeof *llc
) {
118 return htons(FLOW_DL_TYPE_NONE
);
122 if (llc
->llc
.llc_dsap
!= LLC_DSAP_SNAP
123 || llc
->llc
.llc_ssap
!= LLC_SSAP_SNAP
124 || llc
->llc
.llc_cntl
!= LLC_CNTL_SNAP
125 || memcmp(llc
->snap
.snap_org
, SNAP_ORG_ETHERNET
,
126 sizeof llc
->snap
.snap_org
)) {
127 return htons(FLOW_DL_TYPE_NONE
);
130 ofpbuf_pull(b
, sizeof *llc
);
131 return llc
->snap
.snap_type
;
135 parse_ipv6(struct ofpbuf
*packet
, struct flow
*flow
)
137 const struct ip6_hdr
*nh
;
141 nh
= ofpbuf_try_pull(packet
, sizeof *nh
);
146 nexthdr
= nh
->ip6_nxt
;
148 flow
->ipv6_src
= nh
->ip6_src
;
149 flow
->ipv6_dst
= nh
->ip6_dst
;
151 tc_flow
= get_unaligned_be32(&nh
->ip6_flow
);
152 flow
->nw_tos
= (ntohl(tc_flow
) >> 4) & IP_DSCP_MASK
;
153 flow
->nw_proto
= IPPROTO_NONE
;
156 if ((nexthdr
!= IPPROTO_HOPOPTS
)
157 && (nexthdr
!= IPPROTO_ROUTING
)
158 && (nexthdr
!= IPPROTO_DSTOPTS
)
159 && (nexthdr
!= IPPROTO_AH
)
160 && (nexthdr
!= IPPROTO_FRAGMENT
)) {
161 /* It's either a terminal header (e.g., TCP, UDP) or one we
162 * don't understand. In either case, we're done with the
163 * packet, so use it to fill in 'nw_proto'. */
167 /* We only verify that at least 8 bytes of the next header are
168 * available, but many of these headers are longer. Ensure that
169 * accesses within the extension header are within those first 8
170 * bytes. All extension headers are required to be at least 8
172 if (packet
->size
< 8) {
176 if ((nexthdr
== IPPROTO_HOPOPTS
)
177 || (nexthdr
== IPPROTO_ROUTING
)
178 || (nexthdr
== IPPROTO_DSTOPTS
)) {
179 /* These headers, while different, have the fields we care about
180 * in the same location and with the same interpretation. */
181 const struct ip6_ext
*ext_hdr
= (struct ip6_ext
*)packet
->data
;
182 nexthdr
= ext_hdr
->ip6e_nxt
;
183 if (!ofpbuf_try_pull(packet
, (ext_hdr
->ip6e_len
+ 1) * 8)) {
186 } else if (nexthdr
== IPPROTO_AH
) {
187 /* A standard AH definition isn't available, but the fields
188 * we care about are in the same location as the generic
189 * option header--only the header length is calculated
191 const struct ip6_ext
*ext_hdr
= (struct ip6_ext
*)packet
->data
;
192 nexthdr
= ext_hdr
->ip6e_nxt
;
193 if (!ofpbuf_try_pull(packet
, (ext_hdr
->ip6e_len
+ 2) * 4)) {
196 } else if (nexthdr
== IPPROTO_FRAGMENT
) {
197 const struct ip6_frag
*frag_hdr
= (struct ip6_frag
*)packet
->data
;
199 nexthdr
= frag_hdr
->ip6f_nxt
;
200 if (!ofpbuf_try_pull(packet
, sizeof *frag_hdr
)) {
204 /* We only process the first fragment. */
205 if ((frag_hdr
->ip6f_offlg
& IP6F_OFF_MASK
) != htons(0)) {
206 nexthdr
= IPPROTO_FRAGMENT
;
212 flow
->nw_proto
= nexthdr
;
217 parse_tcp(struct ofpbuf
*packet
, struct ofpbuf
*b
, struct flow
*flow
)
219 const struct tcp_header
*tcp
= pull_tcp(b
);
221 flow
->tp_src
= tcp
->tcp_src
;
222 flow
->tp_dst
= tcp
->tcp_dst
;
223 packet
->l7
= b
->data
;
228 parse_udp(struct ofpbuf
*packet
, struct ofpbuf
*b
, struct flow
*flow
)
230 const struct udp_header
*udp
= pull_udp(b
);
232 flow
->tp_src
= udp
->udp_src
;
233 flow
->tp_dst
= udp
->udp_dst
;
234 packet
->l7
= b
->data
;
239 parse_icmpv6(struct ofpbuf
*b
, struct flow
*flow
)
241 const struct icmp6_hdr
*icmp
= pull_icmpv6(b
);
247 /* The ICMPv6 type and code fields use the 16-bit transport port
248 * fields, so we need to store them in 16-bit network byte order. */
249 flow
->icmp_type
= htons(icmp
->icmp6_type
);
250 flow
->icmp_code
= htons(icmp
->icmp6_code
);
252 if (icmp
->icmp6_code
== 0 &&
253 (icmp
->icmp6_type
== ND_NEIGHBOR_SOLICIT
||
254 icmp
->icmp6_type
== ND_NEIGHBOR_ADVERT
)) {
255 const struct in6_addr
*nd_target
;
257 nd_target
= ofpbuf_try_pull(b
, sizeof *nd_target
);
261 flow
->nd_target
= *nd_target
;
263 while (b
->size
>= 8) {
264 /* The minimum size of an option is 8 bytes, which also is
265 * the size of Ethernet link-layer options. */
266 const struct nd_opt_hdr
*nd_opt
= b
->data
;
267 int opt_len
= nd_opt
->nd_opt_len
* 8;
269 if (!opt_len
|| opt_len
> b
->size
) {
273 /* Store the link layer address if the appropriate option is
274 * provided. It is considered an error if the same link
275 * layer option is specified twice. */
276 if (nd_opt
->nd_opt_type
== ND_OPT_SOURCE_LINKADDR
278 if (eth_addr_is_zero(flow
->arp_sha
)) {
279 memcpy(flow
->arp_sha
, nd_opt
+ 1, ETH_ADDR_LEN
);
283 } else if (nd_opt
->nd_opt_type
== ND_OPT_TARGET_LINKADDR
285 if (eth_addr_is_zero(flow
->arp_tha
)) {
286 memcpy(flow
->arp_tha
, nd_opt
+ 1, ETH_ADDR_LEN
);
292 if (!ofpbuf_try_pull(b
, opt_len
)) {
301 memset(&flow
->nd_target
, 0, sizeof(flow
->nd_target
));
302 memset(flow
->arp_sha
, 0, sizeof(flow
->arp_sha
));
303 memset(flow
->arp_tha
, 0, sizeof(flow
->arp_tha
));
309 /* Initializes 'flow' members from 'packet', 'tun_id', and 'ofp_in_port'.
310 * Initializes 'packet' header pointers as follows:
312 * - packet->l2 to the start of the Ethernet header.
314 * - packet->l3 to just past the Ethernet header, or just past the
315 * vlan_header if one is present, to the first byte of the payload of the
318 * - packet->l4 to just past the IPv4 header, if one is present and has a
319 * correct length, and otherwise NULL.
321 * - packet->l7 to just past the TCP or UDP or ICMP header, if one is
322 * present and has a correct length, and otherwise NULL.
325 flow_extract(struct ofpbuf
*packet
, ovs_be64 tun_id
, uint16_t ofp_in_port
,
328 struct ofpbuf b
= *packet
;
329 struct eth_header
*eth
;
332 COVERAGE_INC(flow_extract
);
334 memset(flow
, 0, sizeof *flow
);
335 flow
->tun_id
= tun_id
;
336 flow
->in_port
= ofp_in_port
;
343 if (b
.size
< sizeof *eth
) {
349 memcpy(flow
->dl_src
, eth
->eth_src
, ETH_ADDR_LEN
);
350 memcpy(flow
->dl_dst
, eth
->eth_dst
, ETH_ADDR_LEN
);
352 /* dl_type, vlan_tci. */
353 ofpbuf_pull(&b
, ETH_ADDR_LEN
* 2);
354 if (eth
->eth_type
== htons(ETH_TYPE_VLAN
)) {
355 parse_vlan(&b
, flow
);
357 flow
->dl_type
= parse_ethertype(&b
);
361 if (flow
->dl_type
== htons(ETH_TYPE_IP
)) {
362 const struct ip_header
*nh
= pull_ip(&b
);
364 flow
->nw_src
= get_unaligned_be32(&nh
->ip_src
);
365 flow
->nw_dst
= get_unaligned_be32(&nh
->ip_dst
);
366 flow
->nw_tos
= nh
->ip_tos
& IP_DSCP_MASK
;
367 flow
->nw_proto
= nh
->ip_proto
;
369 if (!IP_IS_FRAGMENT(nh
->ip_frag_off
)) {
370 if (flow
->nw_proto
== IPPROTO_TCP
) {
371 parse_tcp(packet
, &b
, flow
);
372 } else if (flow
->nw_proto
== IPPROTO_UDP
) {
373 parse_udp(packet
, &b
, flow
);
374 } else if (flow
->nw_proto
== IPPROTO_ICMP
) {
375 const struct icmp_header
*icmp
= pull_icmp(&b
);
377 flow
->icmp_type
= htons(icmp
->icmp_type
);
378 flow
->icmp_code
= htons(icmp
->icmp_code
);
386 } else if (flow
->dl_type
== htons(ETH_TYPE_IPV6
)) {
388 retval
= parse_ipv6(&b
, flow
);
394 if (flow
->nw_proto
== IPPROTO_TCP
) {
395 parse_tcp(packet
, &b
, flow
);
396 } else if (flow
->nw_proto
== IPPROTO_UDP
) {
397 parse_udp(packet
, &b
, flow
);
398 } else if (flow
->nw_proto
== IPPROTO_ICMPV6
) {
399 if (parse_icmpv6(&b
, flow
)) {
403 } else if (flow
->dl_type
== htons(ETH_TYPE_ARP
)) {
404 const struct arp_eth_header
*arp
= pull_arp(&b
);
405 if (arp
&& arp
->ar_hrd
== htons(1)
406 && arp
->ar_pro
== htons(ETH_TYPE_IP
)
407 && arp
->ar_hln
== ETH_ADDR_LEN
408 && arp
->ar_pln
== 4) {
409 /* We only match on the lower 8 bits of the opcode. */
410 if (ntohs(arp
->ar_op
) <= 0xff) {
411 flow
->nw_proto
= ntohs(arp
->ar_op
);
414 if ((flow
->nw_proto
== ARP_OP_REQUEST
)
415 || (flow
->nw_proto
== ARP_OP_REPLY
)) {
416 flow
->nw_src
= arp
->ar_spa
;
417 flow
->nw_dst
= arp
->ar_tpa
;
418 memcpy(flow
->arp_sha
, arp
->ar_sha
, ETH_ADDR_LEN
);
419 memcpy(flow
->arp_tha
, arp
->ar_tha
, ETH_ADDR_LEN
);
427 /* Extracts the flow stats for a packet. The 'flow' and 'packet'
428 * arguments must have been initialized through a call to flow_extract().
431 flow_extract_stats(const struct flow
*flow
, struct ofpbuf
*packet
,
432 struct dpif_flow_stats
*stats
)
434 memset(stats
, 0, sizeof(*stats
));
436 if ((flow
->dl_type
== htons(ETH_TYPE_IP
)) && packet
->l4
) {
437 if ((flow
->nw_proto
== IPPROTO_TCP
) && packet
->l7
) {
438 struct tcp_header
*tcp
= packet
->l4
;
439 stats
->tcp_flags
= TCP_FLAGS(tcp
->tcp_ctl
);
443 stats
->n_bytes
= packet
->size
;
444 stats
->n_packets
= 1;
448 flow_to_string(const struct flow
*flow
)
450 struct ds ds
= DS_EMPTY_INITIALIZER
;
451 flow_format(&ds
, flow
);
456 flow_format(struct ds
*ds
, const struct flow
*flow
)
458 ds_put_format(ds
, "tunnel%#"PRIx64
":in_port%04"PRIx16
":tci(",
459 flow
->tun_id
, flow
->in_port
);
460 if (flow
->vlan_tci
) {
461 ds_put_format(ds
, "vlan%"PRIu16
",pcp%d",
462 vlan_tci_to_vid(flow
->vlan_tci
),
463 vlan_tci_to_pcp(flow
->vlan_tci
));
465 ds_put_char(ds
, '0');
467 ds_put_format(ds
, ") mac"ETH_ADDR_FMT
"->"ETH_ADDR_FMT
469 ETH_ADDR_ARGS(flow
->dl_src
),
470 ETH_ADDR_ARGS(flow
->dl_dst
),
471 ntohs(flow
->dl_type
));
473 if (flow
->dl_type
== htons(ETH_TYPE_IPV6
)) {
474 ds_put_format(ds
, " proto%"PRIu8
" tos%"PRIu8
" ipv6",
475 flow
->nw_proto
, flow
->nw_tos
);
476 print_ipv6_addr(ds
, &flow
->ipv6_src
);
477 ds_put_cstr(ds
, "->");
478 print_ipv6_addr(ds
, &flow
->ipv6_dst
);
481 ds_put_format(ds
, " proto%"PRIu8
483 " ip"IP_FMT
"->"IP_FMT
,
486 IP_ARGS(&flow
->nw_src
),
487 IP_ARGS(&flow
->nw_dst
));
489 if (flow
->tp_src
|| flow
->tp_dst
) {
490 ds_put_format(ds
, " port%"PRIu16
"->%"PRIu16
,
491 ntohs(flow
->tp_src
), ntohs(flow
->tp_dst
));
493 if (!eth_addr_is_zero(flow
->arp_sha
) || !eth_addr_is_zero(flow
->arp_tha
)) {
494 ds_put_format(ds
, " arp_ha"ETH_ADDR_FMT
"->"ETH_ADDR_FMT
,
495 ETH_ADDR_ARGS(flow
->arp_sha
),
496 ETH_ADDR_ARGS(flow
->arp_tha
));
501 flow_print(FILE *stream
, const struct flow
*flow
)
503 char *s
= flow_to_string(flow
);
508 /* flow_wildcards functions. */
510 /* Initializes 'wc' as a set of wildcards that matches every packet. */
512 flow_wildcards_init_catchall(struct flow_wildcards
*wc
)
514 wc
->wildcards
= FWW_ALL
;
515 wc
->tun_id_mask
= htonll(0);
516 wc
->nw_src_mask
= htonl(0);
517 wc
->nw_dst_mask
= htonl(0);
518 wc
->ipv6_src_mask
= in6addr_any
;
519 wc
->ipv6_dst_mask
= in6addr_any
;
520 memset(wc
->reg_masks
, 0, sizeof wc
->reg_masks
);
521 wc
->vlan_tci_mask
= htons(0);
525 /* Initializes 'wc' as an exact-match set of wildcards; that is, 'wc' does not
526 * wildcard any bits or fields. */
528 flow_wildcards_init_exact(struct flow_wildcards
*wc
)
531 wc
->tun_id_mask
= htonll(UINT64_MAX
);
532 wc
->nw_src_mask
= htonl(UINT32_MAX
);
533 wc
->nw_dst_mask
= htonl(UINT32_MAX
);
534 wc
->ipv6_src_mask
= in6addr_exact
;
535 wc
->ipv6_dst_mask
= in6addr_exact
;
536 memset(wc
->reg_masks
, 0xff, sizeof wc
->reg_masks
);
537 wc
->vlan_tci_mask
= htons(UINT16_MAX
);
541 /* Returns true if 'wc' is exact-match, false if 'wc' wildcards any bits or
544 flow_wildcards_is_exact(const struct flow_wildcards
*wc
)
549 || wc
->tun_id_mask
!= htonll(UINT64_MAX
)
550 || wc
->nw_src_mask
!= htonl(UINT32_MAX
)
551 || wc
->nw_dst_mask
!= htonl(UINT32_MAX
)
552 || wc
->vlan_tci_mask
!= htons(UINT16_MAX
)
553 || !ipv6_mask_is_exact(&wc
->ipv6_src_mask
)
554 || !ipv6_mask_is_exact(&wc
->ipv6_dst_mask
)) {
558 for (i
= 0; i
< FLOW_N_REGS
; i
++) {
559 if (wc
->reg_masks
[i
] != htonl(UINT32_MAX
)) {
567 /* Initializes 'dst' as the combination of wildcards in 'src1' and 'src2'.
568 * That is, a bit or a field is wildcarded in 'dst' if it is wildcarded in
569 * 'src1' or 'src2' or both. */
571 flow_wildcards_combine(struct flow_wildcards
*dst
,
572 const struct flow_wildcards
*src1
,
573 const struct flow_wildcards
*src2
)
577 dst
->wildcards
= src1
->wildcards
| src2
->wildcards
;
578 dst
->tun_id_mask
= src1
->tun_id_mask
& src2
->tun_id_mask
;
579 dst
->nw_src_mask
= src1
->nw_src_mask
& src2
->nw_src_mask
;
580 dst
->nw_dst_mask
= src1
->nw_dst_mask
& src2
->nw_dst_mask
;
581 dst
->ipv6_src_mask
= ipv6_addr_bitand(&src1
->ipv6_src_mask
,
582 &src2
->ipv6_src_mask
);
583 dst
->ipv6_dst_mask
= ipv6_addr_bitand(&src1
->ipv6_dst_mask
,
584 &src2
->ipv6_dst_mask
);
585 for (i
= 0; i
< FLOW_N_REGS
; i
++) {
586 dst
->reg_masks
[i
] = src1
->reg_masks
[i
] & src2
->reg_masks
[i
];
588 dst
->vlan_tci_mask
= src1
->vlan_tci_mask
& src2
->vlan_tci_mask
;
591 /* Returns a hash of the wildcards in 'wc'. */
593 flow_wildcards_hash(const struct flow_wildcards
*wc
)
595 /* If you change struct flow_wildcards and thereby trigger this
596 * assertion, please check that the new struct flow_wildcards has no holes
597 * in it before you update the assertion. */
598 BUILD_ASSERT_DECL(sizeof *wc
== 56 + FLOW_N_REGS
* 4);
599 return hash_bytes(wc
, sizeof *wc
, 0);
602 /* Returns true if 'a' and 'b' represent the same wildcards, false if they are
605 flow_wildcards_equal(const struct flow_wildcards
*a
,
606 const struct flow_wildcards
*b
)
610 if (a
->wildcards
!= b
->wildcards
611 || a
->tun_id_mask
!= b
->tun_id_mask
612 || a
->nw_src_mask
!= b
->nw_src_mask
613 || a
->nw_dst_mask
!= b
->nw_dst_mask
614 || a
->vlan_tci_mask
!= b
->vlan_tci_mask
615 || !ipv6_addr_equals(&a
->ipv6_src_mask
, &b
->ipv6_src_mask
)
616 || !ipv6_addr_equals(&a
->ipv6_dst_mask
, &b
->ipv6_dst_mask
)) {
620 for (i
= 0; i
< FLOW_N_REGS
; i
++) {
621 if (a
->reg_masks
[i
] != b
->reg_masks
[i
]) {
629 /* Returns true if at least one bit or field is wildcarded in 'a' but not in
630 * 'b', false otherwise. */
632 flow_wildcards_has_extra(const struct flow_wildcards
*a
,
633 const struct flow_wildcards
*b
)
636 struct in6_addr ipv6_masked
;
638 for (i
= 0; i
< FLOW_N_REGS
; i
++) {
639 if ((a
->reg_masks
[i
] & b
->reg_masks
[i
]) != b
->reg_masks
[i
]) {
644 ipv6_masked
= ipv6_addr_bitand(&a
->ipv6_src_mask
, &b
->ipv6_src_mask
);
645 if (!ipv6_addr_equals(&ipv6_masked
, &b
->ipv6_src_mask
)) {
649 ipv6_masked
= ipv6_addr_bitand(&a
->ipv6_dst_mask
, &b
->ipv6_dst_mask
);
650 if (!ipv6_addr_equals(&ipv6_masked
, &b
->ipv6_dst_mask
)) {
654 return (a
->wildcards
& ~b
->wildcards
655 || (a
->tun_id_mask
& b
->tun_id_mask
) != b
->tun_id_mask
656 || (a
->nw_src_mask
& b
->nw_src_mask
) != b
->nw_src_mask
657 || (a
->nw_dst_mask
& b
->nw_dst_mask
) != b
->nw_dst_mask
658 || (a
->vlan_tci_mask
& b
->vlan_tci_mask
) != b
->vlan_tci_mask
);
662 set_nw_mask(ovs_be32
*maskp
, ovs_be32 mask
)
664 if (ip_is_cidr(mask
)) {
672 /* Sets the IP (or ARP) source wildcard mask to CIDR 'mask' (consisting of N
673 * high-order 1-bit and 32-N low-order 0-bits). Returns true if successful,
674 * false if 'mask' is not a CIDR mask. */
676 flow_wildcards_set_nw_src_mask(struct flow_wildcards
*wc
, ovs_be32 mask
)
678 return set_nw_mask(&wc
->nw_src_mask
, mask
);
681 /* Sets the IP (or ARP) destination wildcard mask to CIDR 'mask' (consisting of
682 * N high-order 1-bit and 32-N low-order 0-bits). Returns true if successful,
683 * false if 'mask' is not a CIDR mask. */
685 flow_wildcards_set_nw_dst_mask(struct flow_wildcards
*wc
, ovs_be32 mask
)
687 return set_nw_mask(&wc
->nw_dst_mask
, mask
);
691 set_ipv6_mask(struct in6_addr
*maskp
, const struct in6_addr
*mask
)
693 if (ipv6_is_cidr(mask
)) {
701 /* Sets the IPv6 source wildcard mask to CIDR 'mask' (consisting of N
702 * high-order 1-bit and 128-N low-order 0-bits). Returns true if successful,
703 * false if 'mask' is not a CIDR mask. */
705 flow_wildcards_set_ipv6_src_mask(struct flow_wildcards
*wc
,
706 const struct in6_addr
*mask
)
708 return set_ipv6_mask(&wc
->ipv6_src_mask
, mask
);
711 /* Sets the IPv6 destination wildcard mask to CIDR 'mask' (consisting of
712 * N high-order 1-bit and 128-N low-order 0-bits). Returns true if
713 * successful, false if 'mask' is not a CIDR mask. */
715 flow_wildcards_set_ipv6_dst_mask(struct flow_wildcards
*wc
,
716 const struct in6_addr
*mask
)
718 return set_ipv6_mask(&wc
->ipv6_dst_mask
, mask
);
721 /* Sets the wildcard mask for register 'idx' in 'wc' to 'mask'.
722 * (A 0-bit indicates a wildcard bit.) */
724 flow_wildcards_set_reg_mask(struct flow_wildcards
*wc
, int idx
, uint32_t mask
)
726 wc
->reg_masks
[idx
] = mask
;
729 /* Hashes 'flow' based on its L2 through L4 protocol information. */
731 flow_hash_symmetric_l4(const struct flow
*flow
, uint32_t basis
)
736 struct in6_addr ipv6_addr
;
741 uint8_t eth_addr
[ETH_ADDR_LEN
];
747 memset(&fields
, 0, sizeof fields
);
748 for (i
= 0; i
< ETH_ADDR_LEN
; i
++) {
749 fields
.eth_addr
[i
] = flow
->dl_src
[i
] ^ flow
->dl_dst
[i
];
751 fields
.vlan_tci
= flow
->vlan_tci
& htons(VLAN_VID_MASK
);
752 fields
.eth_type
= flow
->dl_type
;
753 if (fields
.eth_type
== htons(ETH_TYPE_IP
)) {
754 fields
.ipv4_addr
= flow
->nw_src
^ flow
->nw_dst
;
755 fields
.ip_proto
= flow
->nw_proto
;
756 if (fields
.ip_proto
== IPPROTO_TCP
|| fields
.ip_proto
== IPPROTO_UDP
) {
757 fields
.tp_addr
= flow
->tp_src
^ flow
->tp_dst
;
759 } else if (fields
.eth_type
== htons(ETH_TYPE_IPV6
)) {
760 const uint8_t *a
= &flow
->ipv6_src
.s6_addr
[0];
761 const uint8_t *b
= &flow
->ipv6_dst
.s6_addr
[0];
762 uint8_t *ipv6_addr
= &fields
.ipv6_addr
.s6_addr
[0];
764 for (i
=0; i
<16; i
++) {
765 ipv6_addr
[i
] = a
[i
] ^ b
[i
];
767 fields
.ip_proto
= flow
->nw_proto
;
768 if (fields
.ip_proto
== IPPROTO_TCP
|| fields
.ip_proto
== IPPROTO_UDP
) {
769 fields
.tp_addr
= flow
->tp_src
^ flow
->tp_dst
;
772 return hash_bytes(&fields
, sizeof fields
, basis
);