92e94f88e6dc24afbc1e537f28838ecaa7498031
[openvswitch] / lib / nx-match.c
1 /*
2  * Copyright (c) 2010, 2011, 2012 Nicira, Inc.
3  *
4  * Licensed under the Apache License, Version 2.0 (the "License");
5  * you may not use this file except in compliance with the License.
6  * You may obtain a copy of the License at:
7  *
8  *     http://www.apache.org/licenses/LICENSE-2.0
9  *
10  * Unless required by applicable law or agreed to in writing, software
11  * distributed under the License is distributed on an "AS IS" BASIS,
12  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
13  * See the License for the specific language governing permissions and
14  * limitations under the License.
15  */
16
17 #include <config.h>
18
19 #include "nx-match.h"
20
21 #include <netinet/icmp6.h>
22
23 #include "classifier.h"
24 #include "dynamic-string.h"
25 #include "meta-flow.h"
26 #include "ofp-errors.h"
27 #include "ofp-util.h"
28 #include "ofpbuf.h"
29 #include "openflow/nicira-ext.h"
30 #include "packets.h"
31 #include "unaligned.h"
32 #include "util.h"
33 #include "vlog.h"
34
35 VLOG_DEFINE_THIS_MODULE(nx_match);
36
37 /* Rate limit for nx_match parse errors.  These always indicate a bug in the
38  * peer and so there's not much point in showing a lot of them. */
39 static struct vlog_rate_limit rl = VLOG_RATE_LIMIT_INIT(1, 5);
40
41 /* Returns the width of the data for a field with the given 'header', in
42  * bytes. */
43 int
44 nxm_field_bytes(uint32_t header)
45 {
46     unsigned int length = NXM_LENGTH(header);
47     return NXM_HASMASK(header) ? length / 2 : length;
48 }
49
50 /* Returns the width of the data for a field with the given 'header', in
51  * bits. */
52 int
53 nxm_field_bits(uint32_t header)
54 {
55     return nxm_field_bytes(header) * 8;
56 }
57 \f
58 /* nx_pull_match() and helpers. */
59
60 static uint32_t
61 nx_entry_ok(const void *p, unsigned int match_len)
62 {
63     unsigned int payload_len;
64     ovs_be32 header_be;
65     uint32_t header;
66
67     if (match_len < 4) {
68         if (match_len) {
69             VLOG_DBG_RL(&rl, "nx_match ends with partial nxm_header");
70         }
71         return 0;
72     }
73     memcpy(&header_be, p, 4);
74     header = ntohl(header_be);
75
76     payload_len = NXM_LENGTH(header);
77     if (!payload_len) {
78         VLOG_DBG_RL(&rl, "nxm_entry %08"PRIx32" has invalid payload "
79                     "length 0", header);
80         return 0;
81     }
82     if (match_len < payload_len + 4) {
83         VLOG_DBG_RL(&rl, "%"PRIu32"-byte nxm_entry but only "
84                     "%u bytes left in nx_match", payload_len + 4, match_len);
85         return 0;
86     }
87
88     return header;
89 }
90
91 static enum ofperr
92 nx_pull_match__(struct ofpbuf *b, unsigned int match_len, bool strict,
93                 uint16_t priority, struct cls_rule *rule,
94                 ovs_be64 *cookie, ovs_be64 *cookie_mask)
95 {
96     uint32_t header;
97     uint8_t *p;
98
99     assert((cookie != NULL) == (cookie_mask != NULL));
100
101     p = ofpbuf_try_pull(b, ROUND_UP(match_len, 8));
102     if (!p) {
103         VLOG_DBG_RL(&rl, "nx_match length %u, rounded up to a "
104                     "multiple of 8, is longer than space in message (max "
105                     "length %zu)", match_len, b->size);
106         return OFPERR_OFPBMC_BAD_LEN;
107     }
108
109     cls_rule_init_catchall(rule, priority);
110     if (cookie) {
111         *cookie = *cookie_mask = htonll(0);
112     }
113     for (;
114          (header = nx_entry_ok(p, match_len)) != 0;
115          p += 4 + NXM_LENGTH(header), match_len -= 4 + NXM_LENGTH(header)) {
116         const struct mf_field *mf;
117         enum ofperr error;
118
119         mf = mf_from_nxm_header(header);
120         if (!mf) {
121             if (strict) {
122                 error = OFPERR_OFPBMC_BAD_FIELD;
123             } else {
124                 continue;
125             }
126         } else if (!mf_are_prereqs_ok(mf, &rule->flow)) {
127             error = OFPERR_OFPBMC_BAD_PREREQ;
128         } else if (!mf_is_all_wild(mf, &rule->wc)) {
129             error = OFPERR_OFPBMC_DUP_FIELD;
130         } else if (header != OXM_OF_IN_PORT) {
131             unsigned int width = mf->n_bytes;
132             union mf_value value;
133
134             memcpy(&value, p + 4, width);
135             if (!mf_is_value_valid(mf, &value)) {
136                 error = OFPERR_OFPBMC_BAD_VALUE;
137             } else if (!NXM_HASMASK(header)) {
138                 error = 0;
139                 mf_set_value(mf, &value, rule);
140             } else {
141                 union mf_value mask;
142
143                 memcpy(&mask, p + 4 + width, width);
144                 if (!mf_is_mask_valid(mf, &mask)) {
145                     error = OFPERR_OFPBMC_BAD_MASK;
146                 } else {
147                     error = 0;
148                     mf_set(mf, &value, &mask, rule);
149                 }
150             }
151         } else {
152             /* Special case for 32bit ports when using OXM,
153              * ports are 16 bits wide otherwise. */
154             ovs_be32 port_of11;
155             uint16_t port;
156
157             memcpy(&port_of11, p + 4, sizeof port_of11);
158             error = ofputil_port_from_ofp11(port_of11, &port);
159             if (!error) {
160                 cls_rule_set_in_port(rule, port);
161             }
162         }
163
164         /* Check if the match is for a cookie rather than a classifier rule. */
165         if ((header == NXM_NX_COOKIE || header == NXM_NX_COOKIE_W) && cookie) {
166             if (*cookie_mask) {
167                 error = OFPERR_OFPBMC_DUP_FIELD;
168             } else {
169                 unsigned int width = sizeof *cookie;
170
171                 memcpy(cookie, p + 4, width);
172                 if (NXM_HASMASK(header)) {
173                     memcpy(cookie_mask, p + 4 + width, width);
174                 } else {
175                     *cookie_mask = htonll(UINT64_MAX);
176                 }
177                 error = 0;
178             }
179         }
180
181         if (error) {
182             VLOG_DBG_RL(&rl, "bad nxm_entry %#08"PRIx32" (vendor=%"PRIu32", "
183                         "field=%"PRIu32", hasmask=%"PRIu32", len=%"PRIu32"), "
184                         "(%s)", header,
185                         NXM_VENDOR(header), NXM_FIELD(header),
186                         NXM_HASMASK(header), NXM_LENGTH(header),
187                         ofperr_to_string(error));
188             return error;
189         }
190     }
191
192     return match_len ? OFPERR_OFPBMC_BAD_LEN : 0;
193 }
194
195 /* Parses the nx_match formatted match description in 'b' with length
196  * 'match_len'.  The results are stored in 'rule', which is initialized with
197  * 'priority'.  If 'cookie' and 'cookie_mask' contain valid pointers, then the
198  * cookie and mask will be stored in them if a "NXM_NX_COOKIE*" match is
199  * defined.  Otherwise, 0 is stored in both.
200  *
201  * Fails with an error when encountering unknown NXM headers.
202  *
203  * Returns 0 if successful, otherwise an OpenFlow error code. */
204 enum ofperr
205 nx_pull_match(struct ofpbuf *b, unsigned int match_len,
206               uint16_t priority, struct cls_rule *rule,
207               ovs_be64 *cookie, ovs_be64 *cookie_mask)
208 {
209     return nx_pull_match__(b, match_len, true, priority, rule, cookie,
210                            cookie_mask);
211 }
212
213 /* Behaves the same as nx_pull_match() with one exception.  Skips over unknown
214  * NXM headers instead of failing with an error when they are encountered. */
215 enum ofperr
216 nx_pull_match_loose(struct ofpbuf *b, unsigned int match_len,
217                     uint16_t priority, struct cls_rule *rule,
218                     ovs_be64 *cookie, ovs_be64 *cookie_mask)
219 {
220     return nx_pull_match__(b, match_len, false, priority, rule, cookie,
221                            cookie_mask);
222 }
223 \f
224 /* nx_put_match() and helpers.
225  *
226  * 'put' functions whose names end in 'w' add a wildcarded field.
227  * 'put' functions whose names end in 'm' add a field that might be wildcarded.
228  * Other 'put' functions add exact-match fields.
229  */
230
231 static void
232 nxm_put_header(struct ofpbuf *b, uint32_t header)
233 {
234     ovs_be32 n_header = htonl(header);
235     ofpbuf_put(b, &n_header, sizeof n_header);
236 }
237
238 static void
239 nxm_put_8(struct ofpbuf *b, uint32_t header, uint8_t value)
240 {
241     nxm_put_header(b, header);
242     ofpbuf_put(b, &value, sizeof value);
243 }
244
245 static void
246 nxm_put_8m(struct ofpbuf *b, uint32_t header, uint8_t value, uint8_t mask)
247 {
248     switch (mask) {
249     case 0:
250         break;
251
252     case UINT8_MAX:
253         nxm_put_8(b, header, value);
254         break;
255
256     default:
257         nxm_put_header(b, NXM_MAKE_WILD_HEADER(header));
258         ofpbuf_put(b, &value, sizeof value);
259         ofpbuf_put(b, &mask, sizeof mask);
260     }
261 }
262
263 static void
264 nxm_put_16(struct ofpbuf *b, uint32_t header, ovs_be16 value)
265 {
266     nxm_put_header(b, header);
267     ofpbuf_put(b, &value, sizeof value);
268 }
269
270 static void
271 nxm_put_16w(struct ofpbuf *b, uint32_t header, ovs_be16 value, ovs_be16 mask)
272 {
273     nxm_put_header(b, header);
274     ofpbuf_put(b, &value, sizeof value);
275     ofpbuf_put(b, &mask, sizeof mask);
276 }
277
278 static void
279 nxm_put_16m(struct ofpbuf *b, uint32_t header, ovs_be16 value, ovs_be16 mask)
280 {
281     switch (mask) {
282     case 0:
283         break;
284
285     case CONSTANT_HTONS(UINT16_MAX):
286         nxm_put_16(b, header, value);
287         break;
288
289     default:
290         nxm_put_16w(b, NXM_MAKE_WILD_HEADER(header), value, mask);
291         break;
292     }
293 }
294
295 static void
296 nxm_put_32(struct ofpbuf *b, uint32_t header, ovs_be32 value)
297 {
298     nxm_put_header(b, header);
299     ofpbuf_put(b, &value, sizeof value);
300 }
301
302 static void
303 nxm_put_32w(struct ofpbuf *b, uint32_t header, ovs_be32 value, ovs_be32 mask)
304 {
305     nxm_put_header(b, header);
306     ofpbuf_put(b, &value, sizeof value);
307     ofpbuf_put(b, &mask, sizeof mask);
308 }
309
310 static void
311 nxm_put_32m(struct ofpbuf *b, uint32_t header, ovs_be32 value, ovs_be32 mask)
312 {
313     switch (mask) {
314     case 0:
315         break;
316
317     case CONSTANT_HTONL(UINT32_MAX):
318         nxm_put_32(b, header, value);
319         break;
320
321     default:
322         nxm_put_32w(b, NXM_MAKE_WILD_HEADER(header), value, mask);
323         break;
324     }
325 }
326
327 static void
328 nxm_put_64(struct ofpbuf *b, uint32_t header, ovs_be64 value)
329 {
330     nxm_put_header(b, header);
331     ofpbuf_put(b, &value, sizeof value);
332 }
333
334 static void
335 nxm_put_64w(struct ofpbuf *b, uint32_t header, ovs_be64 value, ovs_be64 mask)
336 {
337     nxm_put_header(b, header);
338     ofpbuf_put(b, &value, sizeof value);
339     ofpbuf_put(b, &mask, sizeof mask);
340 }
341
342 static void
343 nxm_put_64m(struct ofpbuf *b, uint32_t header, ovs_be64 value, ovs_be64 mask)
344 {
345     switch (mask) {
346     case 0:
347         break;
348
349     case CONSTANT_HTONLL(UINT64_MAX):
350         nxm_put_64(b, header, value);
351         break;
352
353     default:
354         nxm_put_64w(b, NXM_MAKE_WILD_HEADER(header), value, mask);
355         break;
356     }
357 }
358
359 static void
360 nxm_put_eth(struct ofpbuf *b, uint32_t header,
361             const uint8_t value[ETH_ADDR_LEN])
362 {
363     nxm_put_header(b, header);
364     ofpbuf_put(b, value, ETH_ADDR_LEN);
365 }
366
367 static void
368 nxm_put_eth_masked(struct ofpbuf *b, uint32_t header,
369                    const uint8_t value[ETH_ADDR_LEN],
370                    const uint8_t mask[ETH_ADDR_LEN])
371 {
372     if (!eth_addr_is_zero(mask)) {
373         if (eth_mask_is_exact(mask)) {
374             nxm_put_eth(b, header, value);
375         } else {
376             nxm_put_header(b, NXM_MAKE_WILD_HEADER(header));
377             ofpbuf_put(b, value, ETH_ADDR_LEN);
378             ofpbuf_put(b, mask, ETH_ADDR_LEN);
379         }
380     }
381 }
382
383 static void
384 nxm_put_ipv6(struct ofpbuf *b, uint32_t header,
385              const struct in6_addr *value, const struct in6_addr *mask)
386 {
387     if (ipv6_mask_is_any(mask)) {
388         return;
389     } else if (ipv6_mask_is_exact(mask)) {
390         nxm_put_header(b, header);
391         ofpbuf_put(b, value, sizeof *value);
392     } else {
393         nxm_put_header(b, NXM_MAKE_WILD_HEADER(header));
394         ofpbuf_put(b, value, sizeof *value);
395         ofpbuf_put(b, mask, sizeof *mask);
396     }
397 }
398
399 static void
400 nxm_put_frag(struct ofpbuf *b, const struct cls_rule *cr)
401 {
402     uint8_t nw_frag = cr->flow.nw_frag;
403     uint8_t nw_frag_mask = cr->wc.nw_frag_mask;
404
405     switch (nw_frag_mask) {
406     case 0:
407         break;
408
409     case FLOW_NW_FRAG_MASK:
410         nxm_put_8(b, NXM_NX_IP_FRAG, nw_frag);
411         break;
412
413     default:
414         nxm_put_8m(b, NXM_NX_IP_FRAG, nw_frag,
415                    nw_frag_mask & FLOW_NW_FRAG_MASK);
416         break;
417     }
418 }
419
420 static void
421 nxm_put_ip(struct ofpbuf *b, const struct cls_rule *cr,
422            uint8_t icmp_proto, uint32_t icmp_type, uint32_t icmp_code,
423            bool oxm)
424 {
425     const flow_wildcards_t wc = cr->wc.wildcards;
426     const struct flow *flow = &cr->flow;
427
428     nxm_put_frag(b, cr);
429
430     if (!(wc & FWW_NW_DSCP)) {
431         nxm_put_8(b, oxm ? OXM_OF_IP_DSCP : NXM_OF_IP_TOS,
432                   flow->nw_tos & IP_DSCP_MASK);
433     }
434
435     if (!(wc & FWW_NW_ECN)) {
436         nxm_put_8(b, oxm ? OXM_OF_IP_ECN : NXM_NX_IP_ECN,
437                   flow->nw_tos & IP_ECN_MASK);
438     }
439
440     if (!oxm && !(wc & FWW_NW_TTL)) {
441         nxm_put_8(b, NXM_NX_IP_TTL, flow->nw_ttl);
442     }
443
444     if (!(wc & FWW_NW_PROTO)) {
445         nxm_put_8(b, oxm ? OXM_OF_IP_PROTO : NXM_OF_IP_PROTO, flow->nw_proto);
446
447         if (flow->nw_proto == IPPROTO_TCP) {
448             nxm_put_16m(b, oxm ? OXM_OF_TCP_SRC : NXM_OF_TCP_SRC,
449                         flow->tp_src, cr->wc.tp_src_mask);
450             nxm_put_16m(b, oxm ? OXM_OF_TCP_DST : NXM_OF_TCP_DST,
451                         flow->tp_dst, cr->wc.tp_dst_mask);
452         } else if (flow->nw_proto == IPPROTO_UDP) {
453             nxm_put_16m(b, oxm ? OXM_OF_UDP_SRC : NXM_OF_UDP_SRC,
454                         flow->tp_src, cr->wc.tp_src_mask);
455             nxm_put_16m(b, oxm ? OXM_OF_UDP_DST : NXM_OF_UDP_DST,
456                         flow->tp_dst, cr->wc.tp_dst_mask);
457         } else if (flow->nw_proto == icmp_proto) {
458             if (cr->wc.tp_src_mask) {
459                 nxm_put_8(b, icmp_type, ntohs(flow->tp_src));
460             }
461             if (cr->wc.tp_dst_mask) {
462                 nxm_put_8(b, icmp_code, ntohs(flow->tp_dst));
463             }
464         }
465     }
466 }
467
468 /* Appends to 'b' the nx_match format that expresses 'cr' (except for
469  * 'cr->priority', because priority is not part of nx_match), plus enough
470  * zero bytes to pad the nx_match out to a multiple of 8.  For Flow Mod
471  * and Flow Stats Requests messages, a 'cookie' and 'cookie_mask' may be
472  * supplied.  Otherwise, 'cookie_mask' should be zero.
473  *
474  * This function can cause 'b''s data to be reallocated.
475  *
476  * Returns the number of bytes appended to 'b', excluding padding.
477  *
478  * If 'cr' is a catch-all rule that matches every packet, then this function
479  * appends nothing to 'b' and returns 0. */
480 int
481 nx_put_match(struct ofpbuf *b, bool oxm, const struct cls_rule *cr,
482              ovs_be64 cookie, ovs_be64 cookie_mask)
483 {
484     const flow_wildcards_t wc = cr->wc.wildcards;
485     const struct flow *flow = &cr->flow;
486     const size_t start_len = b->size;
487     int match_len;
488     int i;
489
490     BUILD_ASSERT_DECL(FLOW_WC_SEQ == 12);
491
492     /* Metadata. */
493     if (!(wc & FWW_IN_PORT)) {
494         uint16_t in_port = flow->in_port;
495         if (oxm) {
496             nxm_put_32(b, OXM_OF_IN_PORT, ofputil_port_to_ofp11(in_port));
497         } else {
498             nxm_put_16(b, NXM_OF_IN_PORT, htons(in_port));
499         }
500     }
501
502     /* Ethernet. */
503     nxm_put_eth_masked(b, oxm ? OXM_OF_ETH_SRC : NXM_OF_ETH_SRC,
504                        flow->dl_src, cr->wc.dl_src_mask);
505     nxm_put_eth_masked(b, oxm ? OXM_OF_ETH_DST : NXM_OF_ETH_DST,
506                        flow->dl_dst, cr->wc.dl_dst_mask);
507     if (!(wc & FWW_DL_TYPE)) {
508         nxm_put_16(b, oxm ? OXM_OF_ETH_TYPE : NXM_OF_ETH_TYPE,
509                    ofputil_dl_type_to_openflow(flow->dl_type));
510     }
511
512     /* 802.1Q.
513      *
514      * XXX missing OXM support */
515     nxm_put_16m(b, NXM_OF_VLAN_TCI, flow->vlan_tci, cr->wc.vlan_tci_mask);
516
517     /* L3. */
518     if (!(wc & FWW_DL_TYPE) && flow->dl_type == htons(ETH_TYPE_IP)) {
519         /* IP. */
520         nxm_put_32m(b, oxm ? OXM_OF_IPV4_SRC : NXM_OF_IP_SRC,
521                     flow->nw_src, cr->wc.nw_src_mask);
522         nxm_put_32m(b, oxm ? OXM_OF_IPV4_DST : NXM_OF_IP_DST,
523                     flow->nw_dst, cr->wc.nw_dst_mask);
524         nxm_put_ip(b, cr, IPPROTO_ICMP,
525                    oxm ? OXM_OF_ICMPV4_TYPE : NXM_OF_ICMP_TYPE,
526                    oxm ? OXM_OF_ICMPV4_CODE : NXM_OF_ICMP_CODE, oxm);
527     } else if (!(wc & FWW_DL_TYPE) && flow->dl_type == htons(ETH_TYPE_IPV6)) {
528         /* IPv6. */
529         nxm_put_ipv6(b, oxm ? OXM_OF_IPV6_SRC : NXM_NX_IPV6_SRC,
530                      &flow->ipv6_src, &cr->wc.ipv6_src_mask);
531         nxm_put_ipv6(b, oxm ? OXM_OF_IPV6_DST : NXM_NX_IPV6_DST,
532                      &flow->ipv6_dst, &cr->wc.ipv6_dst_mask);
533         nxm_put_ip(b, cr, IPPROTO_ICMPV6,
534                    oxm ? OXM_OF_ICMPV6_TYPE : NXM_NX_ICMPV6_TYPE,
535                    oxm ? OXM_OF_ICMPV6_CODE : NXM_NX_ICMPV6_CODE, oxm);
536
537         if (!(wc & FWW_IPV6_LABEL)) {
538             nxm_put_32(b, oxm ? OXM_OF_IPV6_FLABEL : NXM_NX_IPV6_LABEL,
539                        flow->ipv6_label);
540         }
541
542         if (flow->nw_proto == IPPROTO_ICMPV6
543             && (flow->tp_src == htons(ND_NEIGHBOR_SOLICIT) ||
544                 flow->tp_src == htons(ND_NEIGHBOR_ADVERT))) {
545             nxm_put_ipv6(b, oxm ? OXM_OF_IPV6_ND_TARGET : NXM_NX_ND_TARGET,
546                          &flow->nd_target, &cr->wc.nd_target_mask);
547             if (!(wc & FWW_ARP_SHA)
548                 && flow->tp_src == htons(ND_NEIGHBOR_SOLICIT)) {
549                 nxm_put_eth(b, oxm ? OXM_OF_IPV6_ND_SLL : NXM_NX_ND_SLL,
550                             flow->arp_sha);
551             }
552             if (!(wc & FWW_ARP_THA)
553                 && flow->tp_src == htons(ND_NEIGHBOR_ADVERT)) {
554                 nxm_put_eth(b, oxm ? OXM_OF_IPV6_ND_TLL : NXM_NX_ND_TLL,
555                             flow->arp_tha);
556             }
557         }
558     } else if (!(wc & FWW_DL_TYPE) && flow->dl_type == htons(ETH_TYPE_ARP)) {
559         /* ARP. */
560         if (!(wc & FWW_NW_PROTO)) {
561             nxm_put_16(b, oxm ? OXM_OF_ARP_OP : NXM_OF_ARP_OP,
562                        htons(flow->nw_proto));
563         }
564         nxm_put_32m(b, oxm ? OXM_OF_ARP_SPA : NXM_OF_ARP_SPA,
565                     flow->nw_src, cr->wc.nw_src_mask);
566         nxm_put_32m(b, oxm ? OXM_OF_ARP_TPA : NXM_OF_ARP_TPA,
567                     flow->nw_dst, cr->wc.nw_dst_mask);
568         if (!(wc & FWW_ARP_SHA)) {
569             nxm_put_eth(b, oxm ? OXM_OF_ARP_SHA : NXM_NX_ARP_SHA,
570                         flow->arp_sha);
571         }
572         if (!(wc & FWW_ARP_THA)) {
573             nxm_put_eth(b, oxm ? OXM_OF_ARP_THA : NXM_NX_ARP_THA,
574                         flow->arp_tha);
575         }
576     }
577
578     /* Tunnel ID. */
579     nxm_put_64m(b, NXM_NX_TUN_ID, flow->tun_id, cr->wc.tun_id_mask);
580
581     /* Registers. */
582     for (i = 0; i < FLOW_N_REGS; i++) {
583         nxm_put_32m(b, NXM_NX_REG(i),
584                     htonl(flow->regs[i]), htonl(cr->wc.reg_masks[i]));
585     }
586
587     /* OpenFlow 1.1+ Metadata. */
588     nxm_put_64m(b, OXM_OF_METADATA, flow->metadata, cr->wc.metadata_mask);
589
590     /* Cookie. */
591     nxm_put_64m(b, NXM_NX_COOKIE, cookie, cookie_mask);
592
593     match_len = b->size - start_len;
594     ofpbuf_put_zeros(b, ROUND_UP(match_len, 8) - match_len);
595     return match_len;
596 }
597 \f
598 /* nx_match_to_string() and helpers. */
599
600 static void format_nxm_field_name(struct ds *, uint32_t header);
601
602 char *
603 nx_match_to_string(const uint8_t *p, unsigned int match_len)
604 {
605     uint32_t header;
606     struct ds s;
607
608     if (!match_len) {
609         return xstrdup("<any>");
610     }
611
612     ds_init(&s);
613     while ((header = nx_entry_ok(p, match_len)) != 0) {
614         unsigned int length = NXM_LENGTH(header);
615         unsigned int value_len = nxm_field_bytes(header);
616         const uint8_t *value = p + 4;
617         const uint8_t *mask = value + value_len;
618         unsigned int i;
619
620         if (s.length) {
621             ds_put_cstr(&s, ", ");
622         }
623
624         format_nxm_field_name(&s, header);
625         ds_put_char(&s, '(');
626
627         for (i = 0; i < value_len; i++) {
628             ds_put_format(&s, "%02x", value[i]);
629         }
630         if (NXM_HASMASK(header)) {
631             ds_put_char(&s, '/');
632             for (i = 0; i < value_len; i++) {
633                 ds_put_format(&s, "%02x", mask[i]);
634             }
635         }
636         ds_put_char(&s, ')');
637
638         p += 4 + length;
639         match_len -= 4 + length;
640     }
641
642     if (match_len) {
643         if (s.length) {
644             ds_put_cstr(&s, ", ");
645         }
646
647         ds_put_format(&s, "<%u invalid bytes>", match_len);
648     }
649
650     return ds_steal_cstr(&s);
651 }
652
653 static void
654 format_nxm_field_name(struct ds *s, uint32_t header)
655 {
656     const struct mf_field *mf = mf_from_nxm_header(header);
657     if (mf) {
658         ds_put_cstr(s, IS_OXM_HEADER(header) ? mf->oxm_name : mf->nxm_name);
659         if (NXM_HASMASK(header)) {
660             ds_put_cstr(s, "_W");
661         }
662     } else if (header == NXM_NX_COOKIE) {
663         ds_put_cstr(s, "NXM_NX_COOKIE");
664     } else if (header == NXM_NX_COOKIE_W) {
665         ds_put_cstr(s, "NXM_NX_COOKIE_W");
666     } else {
667         ds_put_format(s, "%d:%d", NXM_VENDOR(header), NXM_FIELD(header));
668     }
669 }
670
671 static uint32_t
672 parse_nxm_field_name(const char *name, int name_len)
673 {
674     bool wild;
675     int i;
676
677     /* Check whether it's a field name. */
678     wild = name_len > 2 && !memcmp(&name[name_len - 2], "_W", 2);
679     if (wild) {
680         name_len -= 2;
681     }
682
683     for (i = 0; i < MFF_N_IDS; i++) {
684         const struct mf_field *mf = mf_from_id(i);
685         uint32_t header;
686
687         if (mf->nxm_name &&
688             !strncmp(mf->nxm_name, name, name_len) &&
689             mf->nxm_name[name_len] == '\0') {
690             header = mf->nxm_header;
691         } else if (mf->oxm_name &&
692                    !strncmp(mf->oxm_name, name, name_len) &&
693                    mf->oxm_name[name_len] == '\0') {
694             header = mf->oxm_header;
695         } else {
696             continue;
697         }
698
699         if (!wild) {
700             return header;
701         } else if (mf->maskable != MFM_NONE) {
702             return NXM_MAKE_WILD_HEADER(header);
703         }
704     }
705
706     if (!strncmp("NXM_NX_COOKIE", name, name_len) &&
707         (name_len == strlen("NXM_NX_COOKIE"))) {
708         if (!wild) {
709             return NXM_NX_COOKIE;
710         } else {
711             return NXM_NX_COOKIE_W;
712         }
713     }
714
715     /* Check whether it's a 32-bit field header value as hex.
716      * (This isn't ordinarily useful except for testing error behavior.) */
717     if (name_len == 8) {
718         uint32_t header = hexits_value(name, name_len, NULL);
719         if (header != UINT_MAX) {
720             return header;
721         }
722     }
723
724     return 0;
725 }
726 \f
727 /* nx_match_from_string(). */
728
729 int
730 nx_match_from_string(const char *s, struct ofpbuf *b)
731 {
732     const char *full_s = s;
733     const size_t start_len = b->size;
734     int match_len;
735
736     if (!strcmp(s, "<any>")) {
737         /* Ensure that 'b->data' isn't actually null. */
738         ofpbuf_prealloc_tailroom(b, 1);
739         return 0;
740     }
741
742     for (s += strspn(s, ", "); *s; s += strspn(s, ", ")) {
743         const char *name;
744         uint32_t header;
745         int name_len;
746         size_t n;
747
748         name = s;
749         name_len = strcspn(s, "(");
750         if (s[name_len] != '(') {
751             ovs_fatal(0, "%s: missing ( at end of nx_match", full_s);
752         }
753
754         header = parse_nxm_field_name(name, name_len);
755         if (!header) {
756             ovs_fatal(0, "%s: unknown field `%.*s'", full_s, name_len, s);
757         }
758
759         s += name_len + 1;
760
761         nxm_put_header(b, header);
762         s = ofpbuf_put_hex(b, s, &n);
763         if (n != nxm_field_bytes(header)) {
764             ovs_fatal(0, "%.2s: hex digits expected", s);
765         }
766         if (NXM_HASMASK(header)) {
767             s += strspn(s, " ");
768             if (*s != '/') {
769                 ovs_fatal(0, "%s: missing / in masked field %.*s",
770                           full_s, name_len, name);
771             }
772             s = ofpbuf_put_hex(b, s + 1, &n);
773             if (n != nxm_field_bytes(header)) {
774                 ovs_fatal(0, "%.2s: hex digits expected", s);
775             }
776         }
777
778         s += strspn(s, " ");
779         if (*s != ')') {
780             ovs_fatal(0, "%s: missing ) following field %.*s",
781                       full_s, name_len, name);
782         }
783         s++;
784     }
785
786     match_len = b->size - start_len;
787     ofpbuf_put_zeros(b, ROUND_UP(match_len, 8) - match_len);
788     return match_len;
789 }
790 \f
791 void
792 nxm_parse_reg_move(struct nx_action_reg_move *move, const char *s)
793 {
794     const char *full_s = s;
795     struct mf_subfield src, dst;
796
797     s = mf_parse_subfield(&src, s);
798     if (strncmp(s, "->", 2)) {
799         ovs_fatal(0, "%s: missing `->' following source", full_s);
800     }
801     s += 2;
802     s = mf_parse_subfield(&dst, s);
803     if (*s != '\0') {
804         ovs_fatal(0, "%s: trailing garbage following destination", full_s);
805     }
806
807     if (src.n_bits != dst.n_bits) {
808         ovs_fatal(0, "%s: source field is %d bits wide but destination is "
809                   "%d bits wide", full_s, src.n_bits, dst.n_bits);
810     }
811
812     ofputil_init_NXAST_REG_MOVE(move);
813     move->n_bits = htons(src.n_bits);
814     move->src_ofs = htons(src.ofs);
815     move->dst_ofs = htons(dst.ofs);
816     move->src = htonl(src.field->nxm_header);
817     move->dst = htonl(dst.field->nxm_header);
818 }
819
820 void
821 nxm_parse_reg_load(struct nx_action_reg_load *load, const char *s)
822 {
823     const char *full_s = s;
824     struct mf_subfield dst;
825     uint64_t value;
826
827     value = strtoull(s, (char **) &s, 0);
828     if (strncmp(s, "->", 2)) {
829         ovs_fatal(0, "%s: missing `->' following value", full_s);
830     }
831     s += 2;
832     s = mf_parse_subfield(&dst, s);
833     if (*s != '\0') {
834         ovs_fatal(0, "%s: trailing garbage following destination", full_s);
835     }
836
837     if (dst.n_bits < 64 && (value >> dst.n_bits) != 0) {
838         ovs_fatal(0, "%s: value %"PRIu64" does not fit into %u bits",
839                   full_s, value, dst.n_bits);
840     }
841
842     ofputil_init_NXAST_REG_LOAD(load);
843     load->ofs_nbits = nxm_encode_ofs_nbits(dst.ofs, dst.n_bits);
844     load->dst = htonl(dst.field->nxm_header);
845     load->value = htonll(value);
846 }
847 \f
848 /* nxm_format_reg_move(), nxm_format_reg_load(). */
849
850 void
851 nxm_format_reg_move(const struct nx_action_reg_move *move, struct ds *s)
852 {
853     struct mf_subfield src, dst;
854
855     nxm_decode_discrete(&src, move->src, move->src_ofs, move->n_bits);
856     nxm_decode_discrete(&dst, move->dst, move->dst_ofs, move->n_bits);
857
858     ds_put_format(s, "move:");
859     mf_format_subfield(&src, s);
860     ds_put_cstr(s, "->");
861     mf_format_subfield(&dst, s);
862 }
863
864 void
865 nxm_format_reg_load(const struct nx_action_reg_load *load, struct ds *s)
866 {
867     struct mf_subfield dst;
868
869     ds_put_format(s, "load:%#"PRIx64"->", ntohll(load->value));
870
871     nxm_decode(&dst, load->dst, load->ofs_nbits);
872     mf_format_subfield(&dst, s);
873 }
874 \f
875 /* nxm_check_reg_move(), nxm_check_reg_load(). */
876
877 enum ofperr
878 nxm_check_reg_move(const struct nx_action_reg_move *action,
879                    const struct flow *flow)
880 {
881     struct mf_subfield src;
882     struct mf_subfield dst;
883     int error;
884
885     nxm_decode_discrete(&src, action->src, action->src_ofs, action->n_bits);
886     error = mf_check_src(&src, flow);
887     if (error) {
888         return error;
889     }
890
891     nxm_decode_discrete(&dst, action->dst, action->dst_ofs, action->n_bits);
892     return mf_check_dst(&dst, flow);
893 }
894
895 enum ofperr
896 nxm_check_reg_load(const struct nx_action_reg_load *action,
897                    const struct flow *flow)
898 {
899     struct mf_subfield dst;
900     enum ofperr error;
901
902     nxm_decode(&dst, action->dst, action->ofs_nbits);
903     error = mf_check_dst(&dst, flow);
904     if (error) {
905         return error;
906     }
907
908     /* Reject 'action' if a bit numbered 'n_bits' or higher is set to 1 in
909      * action->value. */
910     if (dst.n_bits < 64 && ntohll(action->value) >> dst.n_bits) {
911         return OFPERR_OFPBAC_BAD_ARGUMENT;
912     }
913
914     return 0;
915 }
916 \f
917 /* nxm_execute_reg_move(), nxm_execute_reg_load(). */
918
919 void
920 nxm_execute_reg_move(const struct nx_action_reg_move *action,
921                      struct flow *flow)
922 {
923     struct mf_subfield src, dst;
924     union mf_value src_value;
925     union mf_value dst_value;
926
927     nxm_decode_discrete(&src, action->src, action->src_ofs, action->n_bits);
928     nxm_decode_discrete(&dst, action->dst, action->dst_ofs, action->n_bits);
929
930     mf_get_value(dst.field, flow, &dst_value);
931     mf_get_value(src.field, flow, &src_value);
932     bitwise_copy(&src_value, src.field->n_bytes, src.ofs,
933                  &dst_value, dst.field->n_bytes, dst.ofs,
934                  src.n_bits);
935     mf_set_flow_value(dst.field, &dst_value, flow);
936 }
937
938 void
939 nxm_execute_reg_load(const struct nx_action_reg_load *action,
940                      struct flow *flow)
941 {
942     struct mf_subfield dst;
943
944     nxm_decode(&dst, action->dst, action->ofs_nbits);
945     mf_set_subfield_value(&dst, ntohll(action->value), flow);
946 }
947
948 /* Initializes 'sf->field' with the field corresponding to the given NXM
949  * 'header' and 'sf->ofs' and 'sf->n_bits' decoded from 'ofs_nbits' with
950  * nxm_decode_ofs() and nxm_decode_n_bits(), respectively.
951  *
952  * Afterward, 'sf' might be invalid in a few different ways:
953  *
954  *   - 'sf->field' will be NULL if 'header' is unknown.
955  *
956  *   - 'sf->ofs' and 'sf->n_bits' might exceed the width of sf->field.
957  *
958  * The caller should call mf_check_src() or mf_check_dst() to check for these
959  * problems. */
960 void
961 nxm_decode(struct mf_subfield *sf, ovs_be32 header, ovs_be16 ofs_nbits)
962 {
963     sf->field = mf_from_nxm_header(ntohl(header));
964     sf->ofs = nxm_decode_ofs(ofs_nbits);
965     sf->n_bits = nxm_decode_n_bits(ofs_nbits);
966 }
967
968 /* Initializes 'sf->field' with the field corresponding to the given NXM
969  * 'header' and 'sf->ofs' and 'sf->n_bits' from 'ofs' and 'n_bits',
970  * respectively.
971  *
972  * Afterward, 'sf' might be invalid in a few different ways:
973  *
974  *   - 'sf->field' will be NULL if 'header' is unknown.
975  *
976  *   - 'sf->ofs' and 'sf->n_bits' might exceed the width of sf->field.
977  *
978  * The caller should call mf_check_src() or mf_check_dst() to check for these
979  * problems. */
980 void
981 nxm_decode_discrete(struct mf_subfield *sf, ovs_be32 header,
982                     ovs_be16 ofs, ovs_be16 n_bits)
983 {
984     sf->field = mf_from_nxm_header(ntohl(header));
985     sf->ofs = ntohs(ofs);
986     sf->n_bits = ntohs(n_bits);
987 }