2 * Copyright (c) 2008-2017 Nicira, Inc.
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.
18 #include "openvswitch/ofp-match.h"
19 #include "byte-order.h"
22 #include "openvswitch/match.h"
23 #include "openvswitch/ofp-errors.h"
24 #include "openvswitch/ofp-msgs.h"
25 #include "openvswitch/ofp-port.h"
26 #include "openvswitch/packets.h"
27 #include "openvswitch/vlog.h"
29 VLOG_DEFINE_THIS_MODULE(ofp_match
);
31 static struct vlog_rate_limit rl
= VLOG_RATE_LIMIT_INIT(1, 5);
33 /* Given the wildcard bit count in the least-significant 6 of 'wcbits', returns
34 * an IP netmask with a 1 in each bit that must match and a 0 in each bit that
37 * The bits in 'wcbits' are in the format used in enum ofp_flow_wildcards: 0
38 * is exact match, 1 ignores the LSB, 2 ignores the 2 least-significant bits,
39 * ..., 32 and higher wildcard the entire field. This is the *opposite* of the
40 * usual convention where e.g. /24 indicates that 8 bits (not 24 bits) are
43 ofputil_wcbits_to_netmask(int wcbits
)
46 return wcbits
< 32 ? htonl(~((1u << wcbits
) - 1)) : 0;
49 /* Given the IP netmask 'netmask', returns the number of bits of the IP address
50 * that it wildcards, that is, the number of 0-bits in 'netmask', a number
51 * between 0 and 32 inclusive.
53 * If 'netmask' is not a CIDR netmask (see ip_is_cidr()), the return value will
54 * still be in the valid range but isn't otherwise meaningful. */
56 ofputil_netmask_to_wcbits(ovs_be32 netmask
)
58 return 32 - ip_count_cidr_bits(netmask
);
61 /* Converts the OpenFlow 1.0 wildcards in 'ofpfw' (OFPFW10_*) into a
62 * flow_wildcards in 'wc' for use in struct match. It is the caller's
63 * responsibility to handle the special case where the flow match's dl_vlan is
64 * set to OFP_VLAN_NONE. */
66 ofputil_wildcard_from_ofpfw10(uint32_t ofpfw
, struct flow_wildcards
*wc
)
68 BUILD_ASSERT_DECL(FLOW_WC_SEQ
== 40);
70 /* Initialize most of wc. */
71 flow_wildcards_init_catchall(wc
);
73 if (!(ofpfw
& OFPFW10_IN_PORT
)) {
74 wc
->masks
.in_port
.ofp_port
= u16_to_ofp(UINT16_MAX
);
77 if (!(ofpfw
& OFPFW10_NW_TOS
)) {
78 wc
->masks
.nw_tos
|= IP_DSCP_MASK
;
81 if (!(ofpfw
& OFPFW10_NW_PROTO
)) {
82 wc
->masks
.nw_proto
= UINT8_MAX
;
84 wc
->masks
.nw_src
= ofputil_wcbits_to_netmask(ofpfw
85 >> OFPFW10_NW_SRC_SHIFT
);
86 wc
->masks
.nw_dst
= ofputil_wcbits_to_netmask(ofpfw
87 >> OFPFW10_NW_DST_SHIFT
);
89 if (!(ofpfw
& OFPFW10_TP_SRC
)) {
90 wc
->masks
.tp_src
= OVS_BE16_MAX
;
92 if (!(ofpfw
& OFPFW10_TP_DST
)) {
93 wc
->masks
.tp_dst
= OVS_BE16_MAX
;
96 if (!(ofpfw
& OFPFW10_DL_SRC
)) {
97 WC_MASK_FIELD(wc
, dl_src
);
99 if (!(ofpfw
& OFPFW10_DL_DST
)) {
100 WC_MASK_FIELD(wc
, dl_dst
);
102 if (!(ofpfw
& OFPFW10_DL_TYPE
)) {
103 wc
->masks
.dl_type
= OVS_BE16_MAX
;
107 if (!(ofpfw
& OFPFW10_DL_VLAN_PCP
)) {
108 wc
->masks
.vlans
[0].tci
|= htons(VLAN_PCP_MASK
| VLAN_CFI
);
110 if (!(ofpfw
& OFPFW10_DL_VLAN
)) {
111 wc
->masks
.vlans
[0].tci
|= htons(VLAN_VID_MASK
| VLAN_CFI
);
115 /* Converts the ofp10_match in 'ofmatch' into a struct match in 'match'. */
117 ofputil_match_from_ofp10_match(const struct ofp10_match
*ofmatch
,
120 uint32_t ofpfw
= ntohl(ofmatch
->wildcards
) & OFPFW10_ALL
;
122 /* Initialize match->wc. */
123 memset(&match
->flow
, 0, sizeof match
->flow
);
124 ofputil_wildcard_from_ofpfw10(ofpfw
, &match
->wc
);
125 memset(&match
->tun_md
, 0, sizeof match
->tun_md
);
127 /* If any fields, except in_port, are matched, then we also need to match
128 * on the Ethernet packet_type. */
129 const uint32_t ofpfw_data_bits
= (OFPFW10_NW_TOS
| OFPFW10_NW_PROTO
130 | OFPFW10_TP_SRC
| OFPFW10_TP_DST
131 | OFPFW10_DL_SRC
| OFPFW10_DL_DST
133 | OFPFW10_DL_VLAN
| OFPFW10_DL_VLAN_PCP
);
134 if ((ofpfw
& ofpfw_data_bits
) != ofpfw_data_bits
135 || ofputil_wcbits_to_netmask(ofpfw
>> OFPFW10_NW_SRC_SHIFT
)
136 || ofputil_wcbits_to_netmask(ofpfw
>> OFPFW10_NW_DST_SHIFT
)) {
137 match_set_default_packet_type(match
);
140 /* Initialize most of match->flow. */
141 match
->flow
.nw_src
= ofmatch
->nw_src
;
142 match
->flow
.nw_dst
= ofmatch
->nw_dst
;
143 match
->flow
.in_port
.ofp_port
= u16_to_ofp(ntohs(ofmatch
->in_port
));
144 match
->flow
.dl_type
= ofputil_dl_type_from_openflow(ofmatch
->dl_type
);
145 match
->flow
.tp_src
= ofmatch
->tp_src
;
146 match
->flow
.tp_dst
= ofmatch
->tp_dst
;
147 match
->flow
.dl_src
= ofmatch
->dl_src
;
148 match
->flow
.dl_dst
= ofmatch
->dl_dst
;
149 match
->flow
.nw_tos
= ofmatch
->nw_tos
& IP_DSCP_MASK
;
150 match
->flow
.nw_proto
= ofmatch
->nw_proto
;
152 /* Translate VLANs. */
153 if (!(ofpfw
& OFPFW10_DL_VLAN
) &&
154 ofmatch
->dl_vlan
== htons(OFP10_VLAN_NONE
)) {
155 /* Match only packets without 802.1Q header.
157 * When OFPFW10_DL_VLAN_PCP is wildcarded, this is obviously correct.
159 * If OFPFW10_DL_VLAN_PCP is matched, the flow match is contradictory,
160 * because we can't have a specific PCP without an 802.1Q header.
161 * However, older versions of OVS treated this as matching packets
162 * withut an 802.1Q header, so we do here too. */
163 match
->flow
.vlans
[0].tci
= htons(0);
164 match
->wc
.masks
.vlans
[0].tci
= htons(0xffff);
166 ovs_be16 vid
, pcp
, tci
;
169 vid
= ofmatch
->dl_vlan
& htons(VLAN_VID_MASK
);
170 hpcp
= (ofmatch
->dl_vlan_pcp
<< VLAN_PCP_SHIFT
) & VLAN_PCP_MASK
;
172 tci
= vid
| pcp
| htons(VLAN_CFI
);
173 match
->flow
.vlans
[0].tci
= tci
& match
->wc
.masks
.vlans
[0].tci
;
177 match_zero_wildcarded_fields(match
);
180 /* Convert 'match' into the OpenFlow 1.0 match structure 'ofmatch'. */
182 ofputil_match_to_ofp10_match(const struct match
*match
,
183 struct ofp10_match
*ofmatch
)
185 const struct flow_wildcards
*wc
= &match
->wc
;
188 /* Figure out most OpenFlow wildcards. */
190 if (!wc
->masks
.in_port
.ofp_port
) {
191 ofpfw
|= OFPFW10_IN_PORT
;
193 if (!wc
->masks
.dl_type
) {
194 ofpfw
|= OFPFW10_DL_TYPE
;
196 if (!wc
->masks
.nw_proto
) {
197 ofpfw
|= OFPFW10_NW_PROTO
;
199 ofpfw
|= (ofputil_netmask_to_wcbits(wc
->masks
.nw_src
)
200 << OFPFW10_NW_SRC_SHIFT
);
201 ofpfw
|= (ofputil_netmask_to_wcbits(wc
->masks
.nw_dst
)
202 << OFPFW10_NW_DST_SHIFT
);
203 if (!(wc
->masks
.nw_tos
& IP_DSCP_MASK
)) {
204 ofpfw
|= OFPFW10_NW_TOS
;
206 if (!wc
->masks
.tp_src
) {
207 ofpfw
|= OFPFW10_TP_SRC
;
209 if (!wc
->masks
.tp_dst
) {
210 ofpfw
|= OFPFW10_TP_DST
;
212 if (eth_addr_is_zero(wc
->masks
.dl_src
)) {
213 ofpfw
|= OFPFW10_DL_SRC
;
215 if (eth_addr_is_zero(wc
->masks
.dl_dst
)) {
216 ofpfw
|= OFPFW10_DL_DST
;
219 /* Translate VLANs. */
220 ofmatch
->dl_vlan
= htons(0);
221 ofmatch
->dl_vlan_pcp
= 0;
222 if (match
->wc
.masks
.vlans
[0].tci
== htons(0)) {
223 ofpfw
|= OFPFW10_DL_VLAN
| OFPFW10_DL_VLAN_PCP
;
224 } else if (match
->wc
.masks
.vlans
[0].tci
& htons(VLAN_CFI
)
225 && !(match
->flow
.vlans
[0].tci
& htons(VLAN_CFI
))) {
226 ofmatch
->dl_vlan
= htons(OFP10_VLAN_NONE
);
228 if (!(match
->wc
.masks
.vlans
[0].tci
& htons(VLAN_VID_MASK
))) {
229 ofpfw
|= OFPFW10_DL_VLAN
;
232 htons(vlan_tci_to_vid(match
->flow
.vlans
[0].tci
));
235 if (!(match
->wc
.masks
.vlans
[0].tci
& htons(VLAN_PCP_MASK
))) {
236 ofpfw
|= OFPFW10_DL_VLAN_PCP
;
238 ofmatch
->dl_vlan_pcp
= vlan_tci_to_pcp(match
->flow
.vlans
[0].tci
);
242 /* Compose most of the match structure. */
243 ofmatch
->wildcards
= htonl(ofpfw
);
244 ofmatch
->in_port
= htons(ofp_to_u16(match
->flow
.in_port
.ofp_port
));
245 ofmatch
->dl_src
= match
->flow
.dl_src
;
246 ofmatch
->dl_dst
= match
->flow
.dl_dst
;
247 ofmatch
->dl_type
= ofputil_dl_type_to_openflow(match
->flow
.dl_type
);
248 ofmatch
->nw_src
= match
->flow
.nw_src
;
249 ofmatch
->nw_dst
= match
->flow
.nw_dst
;
250 ofmatch
->nw_tos
= match
->flow
.nw_tos
& IP_DSCP_MASK
;
251 ofmatch
->nw_proto
= match
->flow
.nw_proto
;
252 ofmatch
->tp_src
= match
->flow
.tp_src
;
253 ofmatch
->tp_dst
= match
->flow
.tp_dst
;
254 memset(ofmatch
->pad1
, '\0', sizeof ofmatch
->pad1
);
255 memset(ofmatch
->pad2
, '\0', sizeof ofmatch
->pad2
);
259 ofputil_pull_ofp11_match(struct ofpbuf
*buf
, const struct tun_table
*tun_table
,
260 const struct vl_mff_map
*vl_mff_map
,
261 struct match
*match
, uint16_t *padded_match_len
)
263 struct ofp11_match_header
*omh
= buf
->data
;
266 if (buf
->size
< sizeof *omh
) {
267 return OFPERR_OFPBMC_BAD_LEN
;
270 match_len
= ntohs(omh
->length
);
272 switch (ntohs(omh
->type
)) {
273 case OFPMT_STANDARD
: {
274 struct ofp11_match
*om
;
276 if (match_len
!= sizeof *om
|| buf
->size
< sizeof *om
) {
277 return OFPERR_OFPBMC_BAD_LEN
;
279 om
= ofpbuf_pull(buf
, sizeof *om
);
280 if (padded_match_len
) {
281 *padded_match_len
= match_len
;
283 return ofputil_match_from_ofp11_match(om
, match
);
287 if (padded_match_len
) {
288 *padded_match_len
= ROUND_UP(match_len
, 8);
290 return oxm_pull_match(buf
, false, tun_table
, vl_mff_map
, match
);
293 return OFPERR_OFPBMC_BAD_TYPE
;
297 /* Converts the ofp11_match in 'ofmatch' into a struct match in 'match'.
298 * Returns 0 if successful, otherwise an OFPERR_* value. */
300 ofputil_match_from_ofp11_match(const struct ofp11_match
*ofmatch
,
303 uint16_t wc
= ntohl(ofmatch
->wildcards
);
304 bool ipv4
, arp
, rarp
;
306 match_init_catchall(match
);
307 match
->flow
.tunnel
.metadata
.tab
= NULL
;
309 if (!(wc
& OFPFW11_IN_PORT
)) {
313 error
= ofputil_port_from_ofp11(ofmatch
->in_port
, &ofp_port
);
315 return OFPERR_OFPBMC_BAD_VALUE
;
317 match_set_in_port(match
, ofp_port
);
320 struct eth_addr dl_src_mask
= eth_addr_invert(ofmatch
->dl_src_mask
);
321 struct eth_addr dl_dst_mask
= eth_addr_invert(ofmatch
->dl_dst_mask
);
322 if (!eth_addr_is_zero(dl_src_mask
) || !eth_addr_is_zero(dl_dst_mask
)) {
323 match_set_dl_src_masked(match
, ofmatch
->dl_src
, dl_src_mask
);
324 match_set_dl_dst_masked(match
, ofmatch
->dl_dst
, dl_dst_mask
);
325 match_set_default_packet_type(match
);
328 if (!(wc
& OFPFW11_DL_VLAN
)) {
329 if (ofmatch
->dl_vlan
== htons(OFPVID11_NONE
)) {
330 /* Match only packets without a VLAN tag. */
331 match
->flow
.vlans
[0].tci
= htons(0);
332 match
->wc
.masks
.vlans
[0].tci
= OVS_BE16_MAX
;
334 if (ofmatch
->dl_vlan
== htons(OFPVID11_ANY
)) {
335 /* Match any packet with a VLAN tag regardless of VID. */
336 match
->flow
.vlans
[0].tci
= htons(VLAN_CFI
);
337 match
->wc
.masks
.vlans
[0].tci
= htons(VLAN_CFI
);
338 } else if (ntohs(ofmatch
->dl_vlan
) < 4096) {
339 /* Match only packets with the specified VLAN VID. */
340 match
->flow
.vlans
[0].tci
= htons(VLAN_CFI
) | ofmatch
->dl_vlan
;
341 match
->wc
.masks
.vlans
[0].tci
= htons(VLAN_CFI
| VLAN_VID_MASK
);
344 return OFPERR_OFPBMC_BAD_VALUE
;
347 if (!(wc
& OFPFW11_DL_VLAN_PCP
)) {
348 if (ofmatch
->dl_vlan_pcp
<= 7) {
349 match
->flow
.vlans
[0].tci
|= htons(ofmatch
->dl_vlan_pcp
351 match
->wc
.masks
.vlans
[0].tci
|= htons(VLAN_PCP_MASK
);
354 return OFPERR_OFPBMC_BAD_VALUE
;
358 match_set_default_packet_type(match
);
361 if (!(wc
& OFPFW11_DL_TYPE
)) {
362 match_set_dl_type(match
,
363 ofputil_dl_type_from_openflow(ofmatch
->dl_type
));
364 match_set_default_packet_type(match
);
367 ipv4
= match
->flow
.dl_type
== htons(ETH_TYPE_IP
);
368 arp
= match
->flow
.dl_type
== htons(ETH_TYPE_ARP
);
369 rarp
= match
->flow
.dl_type
== htons(ETH_TYPE_RARP
);
371 if (ipv4
&& !(wc
& OFPFW11_NW_TOS
)) {
372 if (ofmatch
->nw_tos
& ~IP_DSCP_MASK
) {
374 return OFPERR_OFPBMC_BAD_VALUE
;
377 match_set_nw_dscp(match
, ofmatch
->nw_tos
);
380 if (ipv4
|| arp
|| rarp
) {
381 if (!(wc
& OFPFW11_NW_PROTO
)) {
382 match_set_nw_proto(match
, ofmatch
->nw_proto
);
384 match_set_nw_src_masked(match
, ofmatch
->nw_src
, ~ofmatch
->nw_src_mask
);
385 match_set_nw_dst_masked(match
, ofmatch
->nw_dst
, ~ofmatch
->nw_dst_mask
);
388 #define OFPFW11_TP_ALL (OFPFW11_TP_SRC | OFPFW11_TP_DST)
389 if (ipv4
&& (wc
& OFPFW11_TP_ALL
) != OFPFW11_TP_ALL
) {
390 switch (match
->flow
.nw_proto
) {
392 /* "A.2.3 Flow Match Structures" in OF1.1 says:
394 * The tp_src and tp_dst fields will be ignored unless the
395 * network protocol specified is as TCP, UDP or SCTP.
397 * but I'm pretty sure we should support ICMP too, otherwise
398 * that's a regression from OF1.0. */
399 if (!(wc
& OFPFW11_TP_SRC
)) {
400 uint16_t icmp_type
= ntohs(ofmatch
->tp_src
);
401 if (icmp_type
< 0x100) {
402 match_set_icmp_type(match
, icmp_type
);
404 return OFPERR_OFPBMC_BAD_FIELD
;
407 if (!(wc
& OFPFW11_TP_DST
)) {
408 uint16_t icmp_code
= ntohs(ofmatch
->tp_dst
);
409 if (icmp_code
< 0x100) {
410 match_set_icmp_code(match
, icmp_code
);
412 return OFPERR_OFPBMC_BAD_FIELD
;
420 if (!(wc
& (OFPFW11_TP_SRC
))) {
421 match_set_tp_src(match
, ofmatch
->tp_src
);
423 if (!(wc
& (OFPFW11_TP_DST
))) {
424 match_set_tp_dst(match
, ofmatch
->tp_dst
);
429 /* OF1.1 says explicitly to ignore this. */
434 if (eth_type_mpls(match
->flow
.dl_type
)) {
435 if (!(wc
& OFPFW11_MPLS_LABEL
)) {
436 match_set_mpls_label(match
, 0, ofmatch
->mpls_label
);
438 if (!(wc
& OFPFW11_MPLS_TC
)) {
439 match_set_mpls_tc(match
, 0, ofmatch
->mpls_tc
);
443 match_set_metadata_masked(match
, ofmatch
->metadata
,
444 ~ofmatch
->metadata_mask
);
449 /* Convert 'match' into the OpenFlow 1.1 match structure 'ofmatch'. */
451 ofputil_match_to_ofp11_match(const struct match
*match
,
452 struct ofp11_match
*ofmatch
)
456 memset(ofmatch
, 0, sizeof *ofmatch
);
457 ofmatch
->omh
.type
= htons(OFPMT_STANDARD
);
458 ofmatch
->omh
.length
= htons(OFPMT11_STANDARD_LENGTH
);
460 if (!match
->wc
.masks
.in_port
.ofp_port
) {
461 wc
|= OFPFW11_IN_PORT
;
463 ofmatch
->in_port
= ofputil_port_to_ofp11(match
->flow
.in_port
.ofp_port
);
466 ofmatch
->dl_src
= match
->flow
.dl_src
;
467 ofmatch
->dl_src_mask
= eth_addr_invert(match
->wc
.masks
.dl_src
);
468 ofmatch
->dl_dst
= match
->flow
.dl_dst
;
469 ofmatch
->dl_dst_mask
= eth_addr_invert(match
->wc
.masks
.dl_dst
);
471 if (match
->wc
.masks
.vlans
[0].tci
== htons(0)) {
472 wc
|= OFPFW11_DL_VLAN
| OFPFW11_DL_VLAN_PCP
;
473 } else if (match
->wc
.masks
.vlans
[0].tci
& htons(VLAN_CFI
)
474 && !(match
->flow
.vlans
[0].tci
& htons(VLAN_CFI
))) {
475 ofmatch
->dl_vlan
= htons(OFPVID11_NONE
);
476 wc
|= OFPFW11_DL_VLAN_PCP
;
478 if (!(match
->wc
.masks
.vlans
[0].tci
& htons(VLAN_VID_MASK
))) {
479 ofmatch
->dl_vlan
= htons(OFPVID11_ANY
);
482 htons(vlan_tci_to_vid(match
->flow
.vlans
[0].tci
));
485 if (!(match
->wc
.masks
.vlans
[0].tci
& htons(VLAN_PCP_MASK
))) {
486 wc
|= OFPFW11_DL_VLAN_PCP
;
488 ofmatch
->dl_vlan_pcp
= vlan_tci_to_pcp(match
->flow
.vlans
[0].tci
);
492 if (!match
->wc
.masks
.dl_type
) {
493 wc
|= OFPFW11_DL_TYPE
;
495 ofmatch
->dl_type
= ofputil_dl_type_to_openflow(match
->flow
.dl_type
);
498 if (!(match
->wc
.masks
.nw_tos
& IP_DSCP_MASK
)) {
499 wc
|= OFPFW11_NW_TOS
;
501 ofmatch
->nw_tos
= match
->flow
.nw_tos
& IP_DSCP_MASK
;
504 if (!match
->wc
.masks
.nw_proto
) {
505 wc
|= OFPFW11_NW_PROTO
;
507 ofmatch
->nw_proto
= match
->flow
.nw_proto
;
510 ofmatch
->nw_src
= match
->flow
.nw_src
;
511 ofmatch
->nw_src_mask
= ~match
->wc
.masks
.nw_src
;
512 ofmatch
->nw_dst
= match
->flow
.nw_dst
;
513 ofmatch
->nw_dst_mask
= ~match
->wc
.masks
.nw_dst
;
515 if (!match
->wc
.masks
.tp_src
) {
516 wc
|= OFPFW11_TP_SRC
;
518 ofmatch
->tp_src
= match
->flow
.tp_src
;
521 if (!match
->wc
.masks
.tp_dst
) {
522 wc
|= OFPFW11_TP_DST
;
524 ofmatch
->tp_dst
= match
->flow
.tp_dst
;
527 if (!(match
->wc
.masks
.mpls_lse
[0] & htonl(MPLS_LABEL_MASK
))) {
528 wc
|= OFPFW11_MPLS_LABEL
;
530 ofmatch
->mpls_label
= htonl(mpls_lse_to_label(
531 match
->flow
.mpls_lse
[0]));
534 if (!(match
->wc
.masks
.mpls_lse
[0] & htonl(MPLS_TC_MASK
))) {
535 wc
|= OFPFW11_MPLS_TC
;
537 ofmatch
->mpls_tc
= mpls_lse_to_tc(match
->flow
.mpls_lse
[0]);
540 ofmatch
->metadata
= match
->flow
.metadata
;
541 ofmatch
->metadata_mask
= ~match
->wc
.masks
.metadata
;
543 ofmatch
->wildcards
= htonl(wc
);
546 /* Returns the "typical" length of a match for 'protocol', for use in
547 * estimating space to preallocate. */
549 ofputil_match_typical_len(enum ofputil_protocol protocol
)
552 case OFPUTIL_P_OF10_STD
:
553 case OFPUTIL_P_OF10_STD_TID
:
554 return sizeof(struct ofp10_match
);
556 case OFPUTIL_P_OF10_NXM
:
557 case OFPUTIL_P_OF10_NXM_TID
:
558 return NXM_TYPICAL_LEN
;
560 case OFPUTIL_P_OF11_STD
:
561 return sizeof(struct ofp11_match
);
563 case OFPUTIL_P_OF12_OXM
:
564 case OFPUTIL_P_OF13_OXM
:
565 case OFPUTIL_P_OF14_OXM
:
566 case OFPUTIL_P_OF15_OXM
:
567 case OFPUTIL_P_OF16_OXM
:
568 return NXM_TYPICAL_LEN
;
575 /* Appends to 'b' an struct ofp11_match_header followed by a match that
576 * expresses 'match' properly for 'protocol', plus enough zero bytes to pad the
577 * data appended out to a multiple of 8. 'protocol' must be one that is usable
578 * in OpenFlow 1.1 or later.
580 * This function can cause 'b''s data to be reallocated.
582 * Returns the number of bytes appended to 'b', excluding the padding. Never
585 ofputil_put_ofp11_match(struct ofpbuf
*b
, const struct match
*match
,
586 enum ofputil_protocol protocol
)
589 case OFPUTIL_P_OF10_STD
:
590 case OFPUTIL_P_OF10_STD_TID
:
591 case OFPUTIL_P_OF10_NXM
:
592 case OFPUTIL_P_OF10_NXM_TID
:
595 case OFPUTIL_P_OF11_STD
: {
596 struct ofp11_match
*om
;
598 /* Make sure that no padding is needed. */
599 BUILD_ASSERT_DECL(sizeof *om
% 8 == 0);
601 om
= ofpbuf_put_uninit(b
, sizeof *om
);
602 ofputil_match_to_ofp11_match(match
, om
);
606 case OFPUTIL_P_OF12_OXM
:
607 case OFPUTIL_P_OF13_OXM
:
608 case OFPUTIL_P_OF14_OXM
:
609 case OFPUTIL_P_OF15_OXM
:
610 case OFPUTIL_P_OF16_OXM
:
611 return oxm_put_match(b
, match
,
612 ofputil_protocol_to_ofp_version(protocol
));
618 /* Given a 'dl_type' value in the format used in struct flow, returns the
619 * corresponding 'dl_type' value for use in an ofp10_match or ofp11_match
622 ofputil_dl_type_to_openflow(ovs_be16 flow_dl_type
)
624 return (flow_dl_type
== htons(FLOW_DL_TYPE_NONE
)
625 ? htons(OFP_DL_TYPE_NOT_ETH_TYPE
)
629 /* Given a 'dl_type' value in the format used in an ofp10_match or ofp11_match
630 * structure, returns the corresponding 'dl_type' value for use in struct
633 ofputil_dl_type_from_openflow(ovs_be16 ofp_dl_type
)
635 return (ofp_dl_type
== htons(OFP_DL_TYPE_NOT_ETH_TYPE
)
636 ? htons(FLOW_DL_TYPE_NONE
)
641 encode_tlv_table_mappings(struct ofpbuf
*b
, struct ovs_list
*mappings
)
643 struct ofputil_tlv_map
*map
;
645 LIST_FOR_EACH (map
, list_node
, mappings
) {
646 struct nx_tlv_map
*nx_map
;
648 nx_map
= ofpbuf_put_zeros(b
, sizeof *nx_map
);
649 nx_map
->option_class
= htons(map
->option_class
);
650 nx_map
->option_type
= map
->option_type
;
651 nx_map
->option_len
= map
->option_len
;
652 nx_map
->index
= htons(map
->index
);
657 ofputil_encode_tlv_table_mod(enum ofp_version ofp_version
,
658 struct ofputil_tlv_table_mod
*ttm
)
661 struct nx_tlv_table_mod
*nx_ttm
;
663 b
= ofpraw_alloc(OFPRAW_NXT_TLV_TABLE_MOD
, ofp_version
, 0);
664 nx_ttm
= ofpbuf_put_zeros(b
, sizeof *nx_ttm
);
665 nx_ttm
->command
= htons(ttm
->command
);
666 encode_tlv_table_mappings(b
, &ttm
->mappings
);
672 decode_tlv_table_mappings(struct ofpbuf
*msg
, unsigned int max_fields
,
673 struct ovs_list
*mappings
)
675 ovs_list_init(mappings
);
678 struct nx_tlv_map
*nx_map
;
679 struct ofputil_tlv_map
*map
;
681 nx_map
= ofpbuf_pull(msg
, sizeof *nx_map
);
682 map
= xmalloc(sizeof *map
);
683 ovs_list_push_back(mappings
, &map
->list_node
);
685 map
->option_class
= ntohs(nx_map
->option_class
);
686 map
->option_type
= nx_map
->option_type
;
688 map
->option_len
= nx_map
->option_len
;
689 if (map
->option_len
% 4 || map
->option_len
> TLV_MAX_OPT_SIZE
) {
690 VLOG_WARN_RL(&rl
, "tlv table option length (%u) is not a "
691 "valid option size", map
->option_len
);
692 ofputil_uninit_tlv_table(mappings
);
693 return OFPERR_NXTTMFC_BAD_OPT_LEN
;
696 map
->index
= ntohs(nx_map
->index
);
697 if (map
->index
>= max_fields
) {
698 VLOG_WARN_RL(&rl
, "tlv table field index (%u) is too large "
699 "(max %u)", map
->index
, max_fields
- 1);
700 ofputil_uninit_tlv_table(mappings
);
701 return OFPERR_NXTTMFC_BAD_FIELD_IDX
;
709 ofputil_decode_tlv_table_mod(const struct ofp_header
*oh
,
710 struct ofputil_tlv_table_mod
*ttm
)
712 struct ofpbuf msg
= ofpbuf_const_initializer(oh
, ntohs(oh
->length
));
713 ofpraw_pull_assert(&msg
);
715 struct nx_tlv_table_mod
*nx_ttm
= ofpbuf_pull(&msg
, sizeof *nx_ttm
);
716 ttm
->command
= ntohs(nx_ttm
->command
);
717 if (ttm
->command
> NXTTMC_CLEAR
) {
718 VLOG_WARN_RL(&rl
, "tlv table mod command (%u) is out of range",
720 return OFPERR_NXTTMFC_BAD_COMMAND
;
723 return decode_tlv_table_mappings(&msg
, TUN_METADATA_NUM_OPTS
,
728 ofputil_encode_tlv_table_reply(const struct ofp_header
*oh
,
729 struct ofputil_tlv_table_reply
*ttr
)
732 struct nx_tlv_table_reply
*nx_ttr
;
734 b
= ofpraw_alloc_reply(OFPRAW_NXT_TLV_TABLE_REPLY
, oh
, 0);
735 nx_ttr
= ofpbuf_put_zeros(b
, sizeof *nx_ttr
);
736 nx_ttr
->max_option_space
= htonl(ttr
->max_option_space
);
737 nx_ttr
->max_fields
= htons(ttr
->max_fields
);
739 encode_tlv_table_mappings(b
, &ttr
->mappings
);
744 /* Decodes the NXT_TLV_TABLE_REPLY message in 'oh' into '*ttr'. Returns 0
745 * if successful, otherwise an ofperr.
747 * The decoder verifies that the indexes in 'ttr->mappings' are less than
748 * 'ttr->max_fields', but the caller must ensure, if necessary, that they are
749 * less than TUN_METADATA_NUM_OPTS. */
751 ofputil_decode_tlv_table_reply(const struct ofp_header
*oh
,
752 struct ofputil_tlv_table_reply
*ttr
)
754 struct ofpbuf msg
= ofpbuf_const_initializer(oh
, ntohs(oh
->length
));
755 ofpraw_pull_assert(&msg
);
757 struct nx_tlv_table_reply
*nx_ttr
= ofpbuf_pull(&msg
, sizeof *nx_ttr
);
758 ttr
->max_option_space
= ntohl(nx_ttr
->max_option_space
);
759 ttr
->max_fields
= ntohs(nx_ttr
->max_fields
);
761 return decode_tlv_table_mappings(&msg
, ttr
->max_fields
, &ttr
->mappings
);
764 char * OVS_WARN_UNUSED_RESULT
765 parse_ofp_tlv_table_mod_str(struct ofputil_tlv_table_mod
*ttm
,
766 uint16_t command
, const char *s
,
767 enum ofputil_protocol
*usable_protocols
)
769 *usable_protocols
= OFPUTIL_P_NXM_OXM_ANY
;
771 ttm
->command
= command
;
772 ovs_list_init(&ttm
->mappings
);
775 struct ofputil_tlv_map
*map
= xmalloc(sizeof *map
);
782 ovs_list_push_back(&ttm
->mappings
, &map
->list_node
);
784 if (!ovs_scan(s
, "{class=%"SCNi16
",type=%"SCNi8
",len=%"SCNi8
"}"
785 "->tun_metadata%"SCNi16
"%n",
786 &map
->option_class
, &map
->option_type
, &map
->option_len
,
788 ofputil_uninit_tlv_table(&ttm
->mappings
);
789 return xstrdup("invalid tlv mapping");
799 ofputil_uninit_tlv_table(struct ovs_list
*mappings
)
801 struct ofputil_tlv_map
*map
;
803 LIST_FOR_EACH_POP (map
, list_node
, mappings
) {
809 ofputil_normalize_match__(struct match
*match
, bool may_log
)
812 MAY_NW_ADDR
= 1 << 0, /* nw_src, nw_dst */
813 MAY_TP_ADDR
= 1 << 1, /* tp_src, tp_dst */
814 MAY_NW_PROTO
= 1 << 2, /* nw_proto */
815 MAY_IPVx
= 1 << 3, /* tos, frag, ttl */
816 MAY_ARP_SHA
= 1 << 4, /* arp_sha */
817 MAY_ARP_THA
= 1 << 5, /* arp_tha */
818 MAY_IPV6
= 1 << 6, /* ipv6_src, ipv6_dst, ipv6_label */
819 MAY_ND_TARGET
= 1 << 7, /* nd_target */
820 MAY_MPLS
= 1 << 8, /* mpls label and tc */
821 MAY_ETHER
= 1 << 9, /* dl_src, dl_dst */
824 struct flow_wildcards wc
= match
->wc
;
827 /* Figure out what fields may be matched. */
828 /* Check the packet_type first and extract dl_type. */
829 if (wc
.masks
.packet_type
== 0 || match_has_default_packet_type(match
)) {
830 may_match
= MAY_ETHER
;
831 dl_type
= match
->flow
.dl_type
;
832 } else if (wc
.masks
.packet_type
== OVS_BE32_MAX
&&
833 pt_ns(match
->flow
.packet_type
) == OFPHTN_ETHERTYPE
) {
835 dl_type
= pt_ns_type_be(match
->flow
.packet_type
);
840 if (dl_type
== htons(ETH_TYPE_IP
)) {
841 may_match
|= MAY_NW_PROTO
| MAY_IPVx
| MAY_NW_ADDR
;
842 if (match
->flow
.nw_proto
== IPPROTO_TCP
||
843 match
->flow
.nw_proto
== IPPROTO_UDP
||
844 match
->flow
.nw_proto
== IPPROTO_SCTP
||
845 match
->flow
.nw_proto
== IPPROTO_ICMP
) {
846 may_match
|= MAY_TP_ADDR
;
848 } else if (dl_type
== htons(ETH_TYPE_IPV6
)) {
849 may_match
|= MAY_NW_PROTO
| MAY_IPVx
| MAY_IPV6
;
850 if (match
->flow
.nw_proto
== IPPROTO_TCP
||
851 match
->flow
.nw_proto
== IPPROTO_UDP
||
852 match
->flow
.nw_proto
== IPPROTO_SCTP
) {
853 may_match
|= MAY_TP_ADDR
;
854 } else if (match
->flow
.nw_proto
== IPPROTO_ICMPV6
) {
855 may_match
|= MAY_TP_ADDR
;
856 if (match
->flow
.tp_src
== htons(ND_NEIGHBOR_SOLICIT
)) {
857 may_match
|= MAY_ND_TARGET
| MAY_ARP_SHA
;
858 } else if (match
->flow
.tp_src
== htons(ND_NEIGHBOR_ADVERT
)) {
859 may_match
|= MAY_ND_TARGET
| MAY_ARP_THA
;
862 } else if (dl_type
== htons(ETH_TYPE_ARP
) ||
863 dl_type
== htons(ETH_TYPE_RARP
)) {
864 may_match
|= MAY_NW_PROTO
| MAY_NW_ADDR
| MAY_ARP_SHA
| MAY_ARP_THA
;
865 } else if (eth_type_mpls(dl_type
)) {
866 may_match
|= MAY_MPLS
;
869 /* Clear the fields that may not be matched. */
870 if (!(may_match
& MAY_ETHER
)) {
871 wc
.masks
.dl_src
= wc
.masks
.dl_dst
= eth_addr_zero
;
873 if (!(may_match
& MAY_NW_ADDR
)) {
874 wc
.masks
.nw_src
= wc
.masks
.nw_dst
= htonl(0);
876 if (!(may_match
& MAY_TP_ADDR
)) {
877 wc
.masks
.tp_src
= wc
.masks
.tp_dst
= htons(0);
879 if (!(may_match
& MAY_NW_PROTO
)) {
880 wc
.masks
.nw_proto
= 0;
882 if (!(may_match
& MAY_IPVx
)) {
886 if (!(may_match
& MAY_ARP_SHA
)) {
887 WC_UNMASK_FIELD(&wc
, arp_sha
);
889 if (!(may_match
& MAY_ARP_THA
)) {
890 WC_UNMASK_FIELD(&wc
, arp_tha
);
892 if (!(may_match
& MAY_IPV6
)) {
893 wc
.masks
.ipv6_src
= wc
.masks
.ipv6_dst
= in6addr_any
;
894 wc
.masks
.ipv6_label
= htonl(0);
896 if (!(may_match
& MAY_ND_TARGET
)) {
897 wc
.masks
.nd_target
= in6addr_any
;
899 if (!(may_match
& MAY_MPLS
)) {
900 memset(wc
.masks
.mpls_lse
, 0, sizeof wc
.masks
.mpls_lse
);
903 /* Log any changes. */
904 if (!flow_wildcards_equal(&wc
, &match
->wc
)) {
905 bool log
= may_log
&& !VLOG_DROP_INFO(&rl
);
907 ? match_to_string(match
, NULL
, OFP_DEFAULT_PRIORITY
)
911 match_zero_wildcarded_fields(match
);
914 char *post
= match_to_string(match
, NULL
, OFP_DEFAULT_PRIORITY
);
915 VLOG_INFO("normalization changed ofp_match, details:");
916 VLOG_INFO(" pre: %s", pre
);
917 VLOG_INFO("post: %s", post
);
924 /* "Normalizes" the wildcards in 'match'. That means:
926 * 1. If the type of level N is known, then only the valid fields for that
927 * level may be specified. For example, ARP does not have a TOS field,
928 * so nw_tos must be wildcarded if 'match' specifies an ARP flow.
929 * Similarly, IPv4 does not have any IPv6 addresses, so ipv6_src and
930 * ipv6_dst (and other fields) must be wildcarded if 'match' specifies an
933 * 2. If the type of level N is not known (or not understood by Open
934 * vSwitch), then no fields at all for that level may be specified. For
935 * example, Open vSwitch does not understand SCTP, an L4 protocol, so the
936 * L4 fields tp_src and tp_dst must be wildcarded if 'match' specifies an
939 * If this function changes 'match', it logs a rate-limited informational
942 ofputil_normalize_match(struct match
*match
)
944 ofputil_normalize_match__(match
, true);
947 /* Same as ofputil_normalize_match() without the logging. Thus, this function
948 * is suitable for a program's internal use, whereas ofputil_normalize_match()
949 * sense for use on flows received from elsewhere (so that a bug in the program
950 * that sent them can be reported and corrected). */
952 ofputil_normalize_match_quiet(struct match
*match
)
954 ofputil_normalize_match__(match
, false);
957 static void OVS_PRINTF_FORMAT(5, 6)
958 print_wild(struct ds
*string
, const char *leader
, int is_wild
,
959 int verbosity
, const char *format
, ...)
961 if (is_wild
&& verbosity
< 2) {
964 ds_put_cstr(string
, leader
);
968 va_start(args
, format
);
969 ds_put_format_valist(string
, format
, args
);
972 ds_put_char(string
, '*');
974 ds_put_char(string
, ',');
978 print_wild_port(struct ds
*string
, const char *leader
, int is_wild
,
979 int verbosity
, ofp_port_t port
,
980 const struct ofputil_port_map
*port_map
)
982 if (is_wild
&& verbosity
< 2) {
985 ds_put_cstr(string
, leader
);
987 ofputil_format_port(port
, port_map
, string
);
989 ds_put_char(string
, '*');
991 ds_put_char(string
, ',');
995 print_ip_netmask(struct ds
*string
, const char *leader
, ovs_be32 ip
,
996 uint32_t wild_bits
, int verbosity
)
998 if (wild_bits
>= 32 && verbosity
< 2) {
1001 ds_put_cstr(string
, leader
);
1002 if (wild_bits
< 32) {
1003 ds_put_format(string
, IP_FMT
, IP_ARGS(ip
));
1005 ds_put_format(string
, "/%d", 32 - wild_bits
);
1008 ds_put_char(string
, '*');
1010 ds_put_char(string
, ',');
1014 ofp10_match_print(struct ds
*f
, const struct ofp10_match
*om
,
1015 const struct ofputil_port_map
*port_map
, int verbosity
)
1017 char *s
= ofp10_match_to_string(om
, port_map
, verbosity
);
1023 ofp10_match_to_string(const struct ofp10_match
*om
,
1024 const struct ofputil_port_map
*port_map
, int verbosity
)
1026 struct ds f
= DS_EMPTY_INITIALIZER
;
1027 uint32_t w
= ntohl(om
->wildcards
);
1028 bool skip_type
= false;
1029 bool skip_proto
= false;
1031 if (!(w
& OFPFW10_DL_TYPE
)) {
1033 if (om
->dl_type
== htons(ETH_TYPE_IP
)) {
1034 if (!(w
& OFPFW10_NW_PROTO
)) {
1036 if (om
->nw_proto
== IPPROTO_ICMP
) {
1037 ds_put_cstr(&f
, "icmp,");
1038 } else if (om
->nw_proto
== IPPROTO_TCP
) {
1039 ds_put_cstr(&f
, "tcp,");
1040 } else if (om
->nw_proto
== IPPROTO_UDP
) {
1041 ds_put_cstr(&f
, "udp,");
1042 } else if (om
->nw_proto
== IPPROTO_SCTP
) {
1043 ds_put_cstr(&f
, "sctp,");
1045 ds_put_cstr(&f
, "ip,");
1049 ds_put_cstr(&f
, "ip,");
1051 } else if (om
->dl_type
== htons(ETH_TYPE_ARP
)) {
1052 ds_put_cstr(&f
, "arp,");
1053 } else if (om
->dl_type
== htons(ETH_TYPE_RARP
)){
1054 ds_put_cstr(&f
, "rarp,");
1055 } else if (om
->dl_type
== htons(ETH_TYPE_MPLS
)) {
1056 ds_put_cstr(&f
, "mpls,");
1057 } else if (om
->dl_type
== htons(ETH_TYPE_MPLS_MCAST
)) {
1058 ds_put_cstr(&f
, "mplsm,");
1063 print_wild_port(&f
, "in_port=", w
& OFPFW10_IN_PORT
, verbosity
,
1064 u16_to_ofp(ntohs(om
->in_port
)), port_map
);
1065 print_wild(&f
, "dl_vlan=", w
& OFPFW10_DL_VLAN
, verbosity
,
1066 "%d", ntohs(om
->dl_vlan
));
1067 print_wild(&f
, "dl_vlan_pcp=", w
& OFPFW10_DL_VLAN_PCP
, verbosity
,
1068 "%d", om
->dl_vlan_pcp
);
1069 print_wild(&f
, "dl_src=", w
& OFPFW10_DL_SRC
, verbosity
,
1070 ETH_ADDR_FMT
, ETH_ADDR_ARGS(om
->dl_src
));
1071 print_wild(&f
, "dl_dst=", w
& OFPFW10_DL_DST
, verbosity
,
1072 ETH_ADDR_FMT
, ETH_ADDR_ARGS(om
->dl_dst
));
1074 print_wild(&f
, "dl_type=", w
& OFPFW10_DL_TYPE
, verbosity
,
1075 "0x%04x", ntohs(om
->dl_type
));
1077 print_ip_netmask(&f
, "nw_src=", om
->nw_src
,
1078 (w
& OFPFW10_NW_SRC_MASK
) >> OFPFW10_NW_SRC_SHIFT
,
1080 print_ip_netmask(&f
, "nw_dst=", om
->nw_dst
,
1081 (w
& OFPFW10_NW_DST_MASK
) >> OFPFW10_NW_DST_SHIFT
,
1084 if (om
->dl_type
== htons(ETH_TYPE_ARP
) ||
1085 om
->dl_type
== htons(ETH_TYPE_RARP
)) {
1086 print_wild(&f
, "arp_op=", w
& OFPFW10_NW_PROTO
, verbosity
,
1087 "%u", om
->nw_proto
);
1089 print_wild(&f
, "nw_proto=", w
& OFPFW10_NW_PROTO
, verbosity
,
1090 "%u", om
->nw_proto
);
1093 print_wild(&f
, "nw_tos=", w
& OFPFW10_NW_TOS
, verbosity
,
1095 if (om
->nw_proto
== IPPROTO_ICMP
) {
1096 print_wild(&f
, "icmp_type=", w
& OFPFW10_ICMP_TYPE
, verbosity
,
1097 "%d", ntohs(om
->tp_src
));
1098 print_wild(&f
, "icmp_code=", w
& OFPFW10_ICMP_CODE
, verbosity
,
1099 "%d", ntohs(om
->tp_dst
));
1101 print_wild(&f
, "tp_src=", w
& OFPFW10_TP_SRC
, verbosity
,
1102 "%d", ntohs(om
->tp_src
));
1103 print_wild(&f
, "tp_dst=", w
& OFPFW10_TP_DST
, verbosity
,
1104 "%d", ntohs(om
->tp_dst
));