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
== 41);
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 print_tlv_table(struct ds
*s
, const struct ovs_list
*mappings
)
730 struct ofputil_tlv_map
*map
;
732 ds_put_cstr(s
, " mapping table:\n");
733 ds_put_cstr(s
, " class type length match field\n");
734 ds_put_cstr(s
, " ------ ---- ------ --------------");
736 LIST_FOR_EACH (map
, list_node
, mappings
) {
737 ds_put_format(s
, "\n %#6"PRIx16
" %#4"PRIx8
" %6"PRIu8
" "
738 "tun_metadata%"PRIu16
,
739 map
->option_class
, map
->option_type
, map
->option_len
,
745 ofputil_format_tlv_table_mod(struct ds
*s
,
746 const struct ofputil_tlv_table_mod
*ttm
)
748 ds_put_cstr(s
, "\n ");
750 switch (ttm
->command
) {
752 ds_put_cstr(s
, "ADD");
755 ds_put_cstr(s
, "DEL");
758 ds_put_cstr(s
, "CLEAR");
762 if (ttm
->command
!= NXTTMC_CLEAR
) {
763 print_tlv_table(s
, &ttm
->mappings
);
768 ofputil_encode_tlv_table_reply(const struct ofp_header
*oh
,
769 struct ofputil_tlv_table_reply
*ttr
)
772 struct nx_tlv_table_reply
*nx_ttr
;
774 b
= ofpraw_alloc_reply(OFPRAW_NXT_TLV_TABLE_REPLY
, oh
, 0);
775 nx_ttr
= ofpbuf_put_zeros(b
, sizeof *nx_ttr
);
776 nx_ttr
->max_option_space
= htonl(ttr
->max_option_space
);
777 nx_ttr
->max_fields
= htons(ttr
->max_fields
);
779 encode_tlv_table_mappings(b
, &ttr
->mappings
);
784 /* Decodes the NXT_TLV_TABLE_REPLY message in 'oh' into '*ttr'. Returns 0
785 * if successful, otherwise an ofperr.
787 * The decoder verifies that the indexes in 'ttr->mappings' are less than
788 * 'ttr->max_fields', but the caller must ensure, if necessary, that they are
789 * less than TUN_METADATA_NUM_OPTS. */
791 ofputil_decode_tlv_table_reply(const struct ofp_header
*oh
,
792 struct ofputil_tlv_table_reply
*ttr
)
794 struct ofpbuf msg
= ofpbuf_const_initializer(oh
, ntohs(oh
->length
));
795 ofpraw_pull_assert(&msg
);
797 struct nx_tlv_table_reply
*nx_ttr
= ofpbuf_pull(&msg
, sizeof *nx_ttr
);
798 ttr
->max_option_space
= ntohl(nx_ttr
->max_option_space
);
799 ttr
->max_fields
= ntohs(nx_ttr
->max_fields
);
801 return decode_tlv_table_mappings(&msg
, ttr
->max_fields
, &ttr
->mappings
);
804 char * OVS_WARN_UNUSED_RESULT
805 parse_ofp_tlv_table_mod_str(struct ofputil_tlv_table_mod
*ttm
,
806 uint16_t command
, const char *s
,
807 enum ofputil_protocol
*usable_protocols
)
809 *usable_protocols
= OFPUTIL_P_NXM_OXM_ANY
;
811 ttm
->command
= command
;
812 ovs_list_init(&ttm
->mappings
);
815 struct ofputil_tlv_map
*map
= xmalloc(sizeof *map
);
822 ovs_list_push_back(&ttm
->mappings
, &map
->list_node
);
824 if (!ovs_scan(s
, "{class=%"SCNi16
",type=%"SCNi8
",len=%"SCNi8
"}"
825 "->tun_metadata%"SCNi16
"%n",
826 &map
->option_class
, &map
->option_type
, &map
->option_len
,
828 ofputil_uninit_tlv_table(&ttm
->mappings
);
829 return xstrdup("invalid tlv mapping");
839 ofputil_format_tlv_table_reply(struct ds
*s
,
840 const struct ofputil_tlv_table_reply
*ttr
)
842 ds_put_char(s
, '\n');
844 const struct ofputil_tlv_map
*map
;
845 int allocated_space
= 0;
846 LIST_FOR_EACH (map
, list_node
, &ttr
->mappings
) {
847 allocated_space
+= map
->option_len
;
850 ds_put_format(s
, " max option space=%"PRIu32
" max fields=%"PRIu16
"\n",
851 ttr
->max_option_space
, ttr
->max_fields
);
852 ds_put_format(s
, " allocated option space=%d\n", allocated_space
);
853 ds_put_char(s
, '\n');
854 print_tlv_table(s
, &ttr
->mappings
);
858 ofputil_uninit_tlv_table(struct ovs_list
*mappings
)
860 struct ofputil_tlv_map
*map
;
862 LIST_FOR_EACH_POP (map
, list_node
, mappings
) {
868 ofputil_normalize_match__(struct match
*match
, bool may_log
)
871 MAY_NW_ADDR
= 1 << 0, /* nw_src, nw_dst */
872 MAY_TP_ADDR
= 1 << 1, /* tp_src, tp_dst */
873 MAY_NW_PROTO
= 1 << 2, /* nw_proto */
874 MAY_IPVx
= 1 << 3, /* tos, frag, ttl */
875 MAY_ARP_SHA
= 1 << 4, /* arp_sha */
876 MAY_ARP_THA
= 1 << 5, /* arp_tha */
877 MAY_IPV6
= 1 << 6, /* ipv6_src, ipv6_dst, ipv6_label */
878 MAY_ND_TARGET
= 1 << 7, /* nd_target */
879 MAY_MPLS
= 1 << 8, /* mpls label and tc */
880 MAY_ETHER
= 1 << 9, /* dl_src, dl_dst */
883 struct flow_wildcards wc
= match
->wc
;
886 /* Figure out what fields may be matched. */
887 /* Check the packet_type first and extract dl_type. */
888 if (wc
.masks
.packet_type
== 0 || match_has_default_packet_type(match
)) {
889 may_match
= MAY_ETHER
;
890 dl_type
= match
->flow
.dl_type
;
891 } else if (wc
.masks
.packet_type
== OVS_BE32_MAX
&&
892 pt_ns(match
->flow
.packet_type
) == OFPHTN_ETHERTYPE
) {
894 dl_type
= pt_ns_type_be(match
->flow
.packet_type
);
899 if (dl_type
== htons(ETH_TYPE_IP
)) {
900 may_match
|= MAY_NW_PROTO
| MAY_IPVx
| MAY_NW_ADDR
;
901 if (match
->flow
.nw_proto
== IPPROTO_TCP
||
902 match
->flow
.nw_proto
== IPPROTO_UDP
||
903 match
->flow
.nw_proto
== IPPROTO_SCTP
||
904 match
->flow
.nw_proto
== IPPROTO_ICMP
) {
905 may_match
|= MAY_TP_ADDR
;
907 } else if (dl_type
== htons(ETH_TYPE_IPV6
)) {
908 may_match
|= MAY_NW_PROTO
| MAY_IPVx
| MAY_IPV6
;
909 if (match
->flow
.nw_proto
== IPPROTO_TCP
||
910 match
->flow
.nw_proto
== IPPROTO_UDP
||
911 match
->flow
.nw_proto
== IPPROTO_SCTP
) {
912 may_match
|= MAY_TP_ADDR
;
913 } else if (match
->flow
.nw_proto
== IPPROTO_ICMPV6
) {
914 may_match
|= MAY_TP_ADDR
;
915 if (match
->flow
.tp_src
== htons(ND_NEIGHBOR_SOLICIT
)) {
916 may_match
|= MAY_ND_TARGET
| MAY_ARP_SHA
;
917 } else if (match
->flow
.tp_src
== htons(ND_NEIGHBOR_ADVERT
)) {
918 may_match
|= MAY_ND_TARGET
| MAY_ARP_THA
;
921 } else if (dl_type
== htons(ETH_TYPE_ARP
) ||
922 dl_type
== htons(ETH_TYPE_RARP
)) {
923 may_match
|= MAY_NW_PROTO
| MAY_NW_ADDR
| MAY_ARP_SHA
| MAY_ARP_THA
;
924 } else if (eth_type_mpls(dl_type
)) {
925 may_match
|= MAY_MPLS
;
928 /* Clear the fields that may not be matched. */
929 if (!(may_match
& MAY_ETHER
)) {
930 wc
.masks
.dl_src
= wc
.masks
.dl_dst
= eth_addr_zero
;
932 if (!(may_match
& MAY_NW_ADDR
)) {
933 wc
.masks
.nw_src
= wc
.masks
.nw_dst
= htonl(0);
935 if (!(may_match
& MAY_TP_ADDR
)) {
936 wc
.masks
.tp_src
= wc
.masks
.tp_dst
= htons(0);
938 if (!(may_match
& MAY_NW_PROTO
)) {
939 wc
.masks
.nw_proto
= 0;
941 if (!(may_match
& MAY_IPVx
)) {
945 if (!(may_match
& MAY_ARP_SHA
)) {
946 WC_UNMASK_FIELD(&wc
, arp_sha
);
948 if (!(may_match
& MAY_ARP_THA
)) {
949 WC_UNMASK_FIELD(&wc
, arp_tha
);
951 if (!(may_match
& MAY_IPV6
)) {
952 wc
.masks
.ipv6_src
= wc
.masks
.ipv6_dst
= in6addr_any
;
953 wc
.masks
.ipv6_label
= htonl(0);
955 if (!(may_match
& MAY_ND_TARGET
)) {
956 wc
.masks
.nd_target
= in6addr_any
;
958 if (!(may_match
& MAY_MPLS
)) {
959 memset(wc
.masks
.mpls_lse
, 0, sizeof wc
.masks
.mpls_lse
);
962 /* Log any changes. */
963 if (!flow_wildcards_equal(&wc
, &match
->wc
)) {
964 bool log
= may_log
&& !VLOG_DROP_INFO(&rl
);
966 ? match_to_string(match
, NULL
, OFP_DEFAULT_PRIORITY
)
970 match_zero_wildcarded_fields(match
);
973 char *post
= match_to_string(match
, NULL
, OFP_DEFAULT_PRIORITY
);
974 VLOG_INFO("normalization changed ofp_match, details:");
975 VLOG_INFO(" pre: %s", pre
);
976 VLOG_INFO("post: %s", post
);
983 /* "Normalizes" the wildcards in 'match'. That means:
985 * 1. If the type of level N is known, then only the valid fields for that
986 * level may be specified. For example, ARP does not have a TOS field,
987 * so nw_tos must be wildcarded if 'match' specifies an ARP flow.
988 * Similarly, IPv4 does not have any IPv6 addresses, so ipv6_src and
989 * ipv6_dst (and other fields) must be wildcarded if 'match' specifies an
992 * 2. If the type of level N is not known (or not understood by Open
993 * vSwitch), then no fields at all for that level may be specified. For
994 * example, Open vSwitch does not understand SCTP, an L4 protocol, so the
995 * L4 fields tp_src and tp_dst must be wildcarded if 'match' specifies an
998 * If this function changes 'match', it logs a rate-limited informational
1001 ofputil_normalize_match(struct match
*match
)
1003 ofputil_normalize_match__(match
, true);
1006 /* Same as ofputil_normalize_match() without the logging. Thus, this function
1007 * is suitable for a program's internal use, whereas ofputil_normalize_match()
1008 * sense for use on flows received from elsewhere (so that a bug in the program
1009 * that sent them can be reported and corrected). */
1011 ofputil_normalize_match_quiet(struct match
*match
)
1013 ofputil_normalize_match__(match
, false);
1016 static void OVS_PRINTF_FORMAT(5, 6)
1017 print_wild(struct ds
*string
, const char *leader
, int is_wild
,
1018 int verbosity
, const char *format
, ...)
1020 if (is_wild
&& verbosity
< 2) {
1023 ds_put_cstr(string
, leader
);
1027 va_start(args
, format
);
1028 ds_put_format_valist(string
, format
, args
);
1031 ds_put_char(string
, '*');
1033 ds_put_char(string
, ',');
1037 print_wild_port(struct ds
*string
, const char *leader
, int is_wild
,
1038 int verbosity
, ofp_port_t port
,
1039 const struct ofputil_port_map
*port_map
)
1041 if (is_wild
&& verbosity
< 2) {
1044 ds_put_cstr(string
, leader
);
1046 ofputil_format_port(port
, port_map
, string
);
1048 ds_put_char(string
, '*');
1050 ds_put_char(string
, ',');
1054 print_ip_netmask(struct ds
*string
, const char *leader
, ovs_be32 ip
,
1055 uint32_t wild_bits
, int verbosity
)
1057 if (wild_bits
>= 32 && verbosity
< 2) {
1060 ds_put_cstr(string
, leader
);
1061 if (wild_bits
< 32) {
1062 ds_put_format(string
, IP_FMT
, IP_ARGS(ip
));
1064 ds_put_format(string
, "/%d", 32 - wild_bits
);
1067 ds_put_char(string
, '*');
1069 ds_put_char(string
, ',');
1073 ofp10_match_print(struct ds
*f
, const struct ofp10_match
*om
,
1074 const struct ofputil_port_map
*port_map
, int verbosity
)
1076 char *s
= ofp10_match_to_string(om
, port_map
, verbosity
);
1082 ofp10_match_to_string(const struct ofp10_match
*om
,
1083 const struct ofputil_port_map
*port_map
, int verbosity
)
1085 struct ds f
= DS_EMPTY_INITIALIZER
;
1086 uint32_t w
= ntohl(om
->wildcards
);
1087 bool skip_type
= false;
1088 bool skip_proto
= false;
1090 if (!(w
& OFPFW10_DL_TYPE
)) {
1092 if (om
->dl_type
== htons(ETH_TYPE_IP
)) {
1093 if (!(w
& OFPFW10_NW_PROTO
)) {
1095 if (om
->nw_proto
== IPPROTO_ICMP
) {
1096 ds_put_cstr(&f
, "icmp,");
1097 } else if (om
->nw_proto
== IPPROTO_TCP
) {
1098 ds_put_cstr(&f
, "tcp,");
1099 } else if (om
->nw_proto
== IPPROTO_UDP
) {
1100 ds_put_cstr(&f
, "udp,");
1101 } else if (om
->nw_proto
== IPPROTO_SCTP
) {
1102 ds_put_cstr(&f
, "sctp,");
1104 ds_put_cstr(&f
, "ip,");
1108 ds_put_cstr(&f
, "ip,");
1110 } else if (om
->dl_type
== htons(ETH_TYPE_ARP
)) {
1111 ds_put_cstr(&f
, "arp,");
1112 } else if (om
->dl_type
== htons(ETH_TYPE_RARP
)){
1113 ds_put_cstr(&f
, "rarp,");
1114 } else if (om
->dl_type
== htons(ETH_TYPE_MPLS
)) {
1115 ds_put_cstr(&f
, "mpls,");
1116 } else if (om
->dl_type
== htons(ETH_TYPE_MPLS_MCAST
)) {
1117 ds_put_cstr(&f
, "mplsm,");
1122 print_wild_port(&f
, "in_port=", w
& OFPFW10_IN_PORT
, verbosity
,
1123 u16_to_ofp(ntohs(om
->in_port
)), port_map
);
1124 print_wild(&f
, "dl_vlan=", w
& OFPFW10_DL_VLAN
, verbosity
,
1125 "%d", ntohs(om
->dl_vlan
));
1126 print_wild(&f
, "dl_vlan_pcp=", w
& OFPFW10_DL_VLAN_PCP
, verbosity
,
1127 "%d", om
->dl_vlan_pcp
);
1128 print_wild(&f
, "dl_src=", w
& OFPFW10_DL_SRC
, verbosity
,
1129 ETH_ADDR_FMT
, ETH_ADDR_ARGS(om
->dl_src
));
1130 print_wild(&f
, "dl_dst=", w
& OFPFW10_DL_DST
, verbosity
,
1131 ETH_ADDR_FMT
, ETH_ADDR_ARGS(om
->dl_dst
));
1133 print_wild(&f
, "dl_type=", w
& OFPFW10_DL_TYPE
, verbosity
,
1134 "0x%04x", ntohs(om
->dl_type
));
1136 print_ip_netmask(&f
, "nw_src=", om
->nw_src
,
1137 (w
& OFPFW10_NW_SRC_MASK
) >> OFPFW10_NW_SRC_SHIFT
,
1139 print_ip_netmask(&f
, "nw_dst=", om
->nw_dst
,
1140 (w
& OFPFW10_NW_DST_MASK
) >> OFPFW10_NW_DST_SHIFT
,
1143 if (om
->dl_type
== htons(ETH_TYPE_ARP
) ||
1144 om
->dl_type
== htons(ETH_TYPE_RARP
)) {
1145 print_wild(&f
, "arp_op=", w
& OFPFW10_NW_PROTO
, verbosity
,
1146 "%u", om
->nw_proto
);
1148 print_wild(&f
, "nw_proto=", w
& OFPFW10_NW_PROTO
, verbosity
,
1149 "%u", om
->nw_proto
);
1152 print_wild(&f
, "nw_tos=", w
& OFPFW10_NW_TOS
, verbosity
,
1154 if (om
->nw_proto
== IPPROTO_ICMP
) {
1155 print_wild(&f
, "icmp_type=", w
& OFPFW10_ICMP_TYPE
, verbosity
,
1156 "%d", ntohs(om
->tp_src
));
1157 print_wild(&f
, "icmp_code=", w
& OFPFW10_ICMP_CODE
, verbosity
,
1158 "%d", ntohs(om
->tp_dst
));
1160 print_wild(&f
, "tp_src=", w
& OFPFW10_TP_SRC
, verbosity
,
1161 "%d", ntohs(om
->tp_src
));
1162 print_wild(&f
, "tp_dst=", w
& OFPFW10_TP_DST
, verbosity
,
1163 "%d", ntohs(om
->tp_dst
));