Implement new "learn" action.
[openvswitch] / lib / meta-flow.c
1 /*
2  * Copyright (c) 2011 Nicira Networks.
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 "meta-flow.h"
20
21 #include <assert.h>
22 #include <errno.h>
23 #include <limits.h>
24 #include <netinet/icmp6.h>
25 #include <netinet/ip6.h>
26
27 #include "classifier.h"
28 #include "dynamic-string.h"
29 #include "ofp-util.h"
30 #include "packets.h"
31 #include "random.h"
32 #include "shash.h"
33 #include "socket-util.h"
34 #include "unaligned.h"
35
36 #define MF_FIELD_SIZES(MEMBER)                  \
37     sizeof ((union mf_value *)0)->MEMBER,       \
38     8 * sizeof ((union mf_value *)0)->MEMBER
39
40 static const struct mf_field mf_fields[MFF_N_IDS] = {
41     /* ## -------- ## */
42     /* ## metadata ## */
43     /* ## -------- ## */
44
45     {
46         MFF_TUN_ID, "tun_id", NULL,
47         MF_FIELD_SIZES(be64),
48         MFM_FULLY, 0,
49         MFS_HEXADECIMAL,
50         MFP_NONE,
51         NXM_NX_TUN_ID,
52     }, {
53         MFF_IN_PORT, "in_port", NULL,
54         MF_FIELD_SIZES(be16),
55         MFM_NONE, FWW_IN_PORT,
56         MFS_OFP_PORT,
57         MFP_NONE,
58         NXM_OF_IN_PORT,
59     },
60
61 #define REGISTER(IDX)                           \
62     {                                           \
63         MFF_REG##IDX, "reg" #IDX, NULL,         \
64         MF_FIELD_SIZES(be32),                   \
65         MFM_FULLY, 0,                           \
66         MFS_HEXADECIMAL,                        \
67         MFP_NONE,                               \
68         NXM_NX_REG(IDX),                        \
69     }
70 #if FLOW_N_REGS > 0
71     REGISTER(0),
72 #endif
73 #if FLOW_N_REGS > 1
74     REGISTER(1),
75 #endif
76 #if FLOW_N_REGS > 2
77     REGISTER(2),
78 #endif
79 #if FLOW_N_REGS > 3
80     REGISTER(3),
81 #endif
82 #if FLOW_N_REGS > 4
83 #error
84 #endif
85
86     /* ## -- ## */
87     /* ## L2 ## */
88     /* ## -- ## */
89
90     {
91         MFF_ETH_SRC, "eth_src", "dl_src",
92         MF_FIELD_SIZES(mac),
93         MFM_NONE, FWW_DL_SRC,
94         MFS_ETHERNET,
95         MFP_NONE,
96         NXM_OF_ETH_SRC,
97     }, {
98         MFF_ETH_DST, "eth_dst", "dl_dst",
99         MF_FIELD_SIZES(mac),
100         MFM_MCAST, 0,
101         MFS_ETHERNET,
102         MFP_NONE,
103         NXM_OF_ETH_DST,
104     }, {
105         MFF_ETH_TYPE, "eth_type", "dl_type",
106         MF_FIELD_SIZES(be16),
107         MFM_NONE, FWW_DL_TYPE,
108         MFS_HEXADECIMAL,
109         MFP_NONE,
110         NXM_OF_ETH_TYPE,
111     },
112
113     {
114         MFF_VLAN_TCI, "vlan_tci", NULL,
115         MF_FIELD_SIZES(be16),
116         MFM_FULLY, 0,
117         MFS_HEXADECIMAL,
118         MFP_NONE,
119         NXM_OF_VLAN_TCI,
120     }, {
121         MFF_VLAN_VID, "dl_vlan", NULL,
122         sizeof(ovs_be16), 12,
123         MFM_NONE, 0,
124         MFS_DECIMAL,
125         MFP_NONE,
126         0,
127     }, {
128         MFF_VLAN_PCP, "dl_vlan_pcp", NULL,
129         1, 3,
130         MFM_NONE, 0,
131         MFS_DECIMAL,
132         MFP_NONE,
133         0,
134     },
135
136     /* ## -- ## */
137     /* ## L3 ## */
138     /* ## -- ## */
139
140     {
141         MFF_IPV4_SRC, "ip_src", "nw_src",
142         MF_FIELD_SIZES(be32),
143         MFM_CIDR, 0,
144         MFS_IPV4,
145         MFP_IPV4,
146         NXM_OF_IP_SRC,
147     }, {
148         MFF_IPV4_DST, "ip_dst", "nw_dst",
149         MF_FIELD_SIZES(be32),
150         MFM_CIDR, 0,
151         MFS_IPV4,
152         MFP_IPV4,
153         NXM_OF_IP_DST,
154     },
155
156     {
157         MFF_IPV6_SRC, "ipv6_src", NULL,
158         MF_FIELD_SIZES(ipv6),
159         MFM_CIDR, 0,
160         MFS_IPV6,
161         MFP_IPV6,
162         NXM_NX_IPV6_SRC,
163     }, {
164         MFF_IPV6_DST, "ipv6_dst", NULL,
165         MF_FIELD_SIZES(ipv6),
166         MFM_CIDR, 0,
167         MFS_IPV6,
168         MFP_IPV6,
169         NXM_NX_IPV6_DST,
170     },
171
172     {
173         MFF_IP_PROTO, "nw_proto", NULL,
174         MF_FIELD_SIZES(u8),
175         MFM_NONE, FWW_NW_PROTO,
176         MFS_DECIMAL,
177         MFP_IP_ANY,
178         NXM_OF_IP_PROTO,
179     }, {
180         MFF_IP_TOS, "nw_tos", NULL,
181         MF_FIELD_SIZES(u8),
182         MFM_NONE, FWW_NW_TOS,
183         MFS_DECIMAL,
184         MFP_IP_ANY,
185         NXM_OF_IP_TOS,
186     },
187
188     {
189         MFF_ARP_OP, "arp_op", NULL,
190         MF_FIELD_SIZES(be16),
191         MFM_NONE, FWW_NW_PROTO,
192         MFS_DECIMAL,
193         MFP_ARP,
194         NXM_OF_ARP_OP,
195     }, {
196         MFF_ARP_SPA, "arp_spa", NULL,
197         MF_FIELD_SIZES(be32),
198         MFM_CIDR, 0,
199         MFS_IPV4,
200         MFP_ARP,
201         NXM_OF_ARP_SPA,
202     }, {
203         MFF_ARP_TPA, "arp_tpa", NULL,
204         MF_FIELD_SIZES(be32),
205         MFM_CIDR, 0,
206         MFS_IPV4,
207         MFP_ARP,
208         NXM_OF_ARP_TPA,
209     }, {
210         MFF_ARP_SHA, "arp_sha", NULL,
211         MF_FIELD_SIZES(mac),
212         MFM_NONE, FWW_ARP_SHA,
213         MFS_ETHERNET,
214         MFP_ARP,
215         NXM_NX_ARP_SHA,
216     }, {
217         MFF_ARP_THA, "arp_tha", NULL,
218         MF_FIELD_SIZES(mac),
219         MFM_NONE, FWW_ARP_THA,
220         MFS_ETHERNET,
221         MFP_ARP,
222         NXM_NX_ARP_THA,
223     },
224
225     /* ## -- ## */
226     /* ## L4 ## */
227     /* ## -- ## */
228
229     {
230         MFF_TCP_SRC, "tcp_src", "tp_src",
231         MF_FIELD_SIZES(be16),
232         MFM_NONE, FWW_TP_SRC,
233         MFS_DECIMAL,
234         MFP_TCP,
235         NXM_OF_TCP_SRC,
236     }, {
237         MFF_TCP_DST, "tcp_dst", "tp_dst",
238         MF_FIELD_SIZES(be16),
239         MFM_NONE, FWW_TP_DST,
240         MFS_DECIMAL,
241         MFP_TCP,
242         NXM_OF_TCP_DST,
243     },
244
245     {
246         MFF_UDP_SRC, "udp_src", NULL,
247         MF_FIELD_SIZES(be16),
248         MFM_NONE, FWW_TP_SRC,
249         MFS_DECIMAL,
250         MFP_UDP,
251         NXM_OF_UDP_SRC,
252     }, {
253         MFF_UDP_DST, "udp_dst", NULL,
254         MF_FIELD_SIZES(be16),
255         MFM_NONE, FWW_TP_DST,
256         MFS_DECIMAL,
257         MFP_UDP,
258         NXM_OF_UDP_DST,
259     },
260
261     {
262         MFF_ICMP_TYPE, "icmp_type", NULL,
263         MF_FIELD_SIZES(u8),
264         MFM_NONE, FWW_TP_SRC,
265         MFS_DECIMAL,
266         MFP_ICMP_ANY,
267         NXM_OF_ICMP_TYPE,
268     }, {
269         MFF_ICMP_CODE, "icmp_code", NULL,
270         MF_FIELD_SIZES(u8),
271         MFM_NONE, FWW_TP_SRC,
272         MFS_DECIMAL,
273         MFP_ICMP_ANY,
274         NXM_OF_ICMP_CODE,
275     },
276
277     /* ## ---- ## */
278     /* ## L"5" ## */
279     /* ## ---- ## */
280
281     {
282         MFF_ND_TARGET, "nd_target", NULL,
283         MF_FIELD_SIZES(ipv6),
284         MFM_NONE, FWW_ND_TARGET,
285         MFS_IPV6,
286         MFP_ND,
287         NXM_NX_ND_TARGET,
288     }, {
289         MFF_ND_SLL, "nd_sll", NULL,
290         MF_FIELD_SIZES(mac),
291         MFM_NONE, FWW_ARP_SHA,
292         MFS_ETHERNET,
293         MFP_ND_SOLICIT,
294         NXM_NX_ND_SLL,
295     }, {
296         MFF_ND_TLL, "nd_tll", NULL,
297         MF_FIELD_SIZES(mac),
298         MFM_NONE, FWW_ARP_THA,
299         MFS_ETHERNET,
300         MFP_ND_ADVERT,
301         NXM_NX_ND_TLL,
302     }
303 };
304
305 /* Returns the field with the given 'id'. */
306 const struct mf_field *
307 mf_from_id(enum mf_field_id id)
308 {
309     assert((unsigned int) id < MFF_N_IDS);
310     return &mf_fields[id];
311 }
312
313 /* Returns the field with the given 'name', or a null pointer if no field has
314  * that name. */
315 const struct mf_field *
316 mf_from_name(const char *name)
317 {
318     static struct shash mf_by_name = SHASH_INITIALIZER(&mf_by_name);
319
320     if (shash_is_empty(&mf_by_name)) {
321         const struct mf_field *mf;
322
323         for (mf = mf_fields; mf < &mf_fields[MFF_N_IDS]; mf++) {
324             shash_add_once(&mf_by_name, mf->name, mf);
325             if (mf->extra_name) {
326                 shash_add_once(&mf_by_name, mf->extra_name, mf);
327             }
328         }
329     }
330
331     return shash_find_data(&mf_by_name, name);
332 }
333
334 /* Returns true if 'wc' wildcards all the bits in field 'mf', false if 'wc'
335  * specifies at least one bit in the field.
336  *
337  * The caller is responsible for ensuring that 'wc' corresponds to a flow that
338  * meets 'mf''s prerequisites. */
339 bool
340 mf_is_all_wild(const struct mf_field *mf, const struct flow_wildcards *wc)
341 {
342     switch (mf->id) {
343     case MFF_IN_PORT:
344     case MFF_ETH_SRC:
345     case MFF_ETH_TYPE:
346     case MFF_IP_PROTO:
347     case MFF_IP_TOS:
348     case MFF_ARP_OP:
349     case MFF_ARP_SHA:
350     case MFF_ARP_THA:
351     case MFF_TCP_SRC:
352     case MFF_TCP_DST:
353     case MFF_UDP_SRC:
354     case MFF_UDP_DST:
355     case MFF_ICMP_TYPE:
356     case MFF_ICMP_CODE:
357     case MFF_ND_TARGET:
358     case MFF_ND_SLL:
359     case MFF_ND_TLL:
360         assert(mf->fww_bit != 0);
361         return (wc->wildcards & mf->fww_bit) != 0;
362
363     case MFF_TUN_ID:
364         return !wc->tun_id_mask;
365
366 #if FLOW_N_REGS > 0
367     case MFF_REG0:
368 #endif
369 #if FLOW_N_REGS > 1
370     case MFF_REG1:
371 #endif
372 #if FLOW_N_REGS > 2
373     case MFF_REG2:
374 #endif
375 #if FLOW_N_REGS > 3
376     case MFF_REG3:
377 #endif
378 #if FLOW_N_REGS > 4
379 #error
380 #endif
381         return !wc->reg_masks[mf->id - MFF_REG0];
382
383     case MFF_ETH_DST:
384         return ((wc->wildcards & (FWW_ETH_MCAST | FWW_DL_DST))
385                 == (FWW_ETH_MCAST | FWW_DL_DST));
386
387     case MFF_VLAN_TCI:
388         return !wc->vlan_tci_mask;
389     case MFF_VLAN_VID:
390         return !(wc->vlan_tci_mask & htons(VLAN_VID_MASK));
391     case MFF_VLAN_PCP:
392         return !(wc->vlan_tci_mask & htons(VLAN_PCP_MASK));
393
394     case MFF_IPV4_SRC:
395         return !wc->nw_src_mask;
396     case MFF_IPV4_DST:
397         return !wc->nw_dst_mask;
398
399     case MFF_IPV6_SRC:
400         return ipv6_mask_is_any(&wc->ipv6_src_mask);
401     case MFF_IPV6_DST:
402         return ipv6_mask_is_any(&wc->ipv6_dst_mask);
403
404     case MFF_ARP_SPA:
405         return !wc->nw_src_mask;
406     case MFF_ARP_TPA:
407         return !wc->nw_dst_mask;
408
409     case MFF_N_IDS:
410     default:
411         NOT_REACHED();
412     }
413 }
414
415 /* Initializes 'mask' with the wildcard bit pattern for field 'mf' within 'wc'.
416  * Each bit in 'mask' will be set to 1 if the bit is significant for matching
417  * purposes, or to 0 if it is wildcarded.
418  *
419  * The caller is responsible for ensuring that 'wc' corresponds to a flow that
420  * meets 'mf''s prerequisites. */
421 void
422 mf_get_mask(const struct mf_field *mf, const struct flow_wildcards *wc,
423             union mf_value *mask)
424 {
425     switch (mf->id) {
426     case MFF_IN_PORT:
427     case MFF_ETH_SRC:
428     case MFF_ETH_TYPE:
429     case MFF_IP_PROTO:
430     case MFF_IP_TOS:
431     case MFF_ARP_OP:
432     case MFF_ARP_SHA:
433     case MFF_ARP_THA:
434     case MFF_TCP_SRC:
435     case MFF_TCP_DST:
436     case MFF_UDP_SRC:
437     case MFF_UDP_DST:
438     case MFF_ICMP_TYPE:
439     case MFF_ICMP_CODE:
440     case MFF_ND_TARGET:
441     case MFF_ND_SLL:
442     case MFF_ND_TLL:
443         assert(mf->fww_bit != 0);
444         memset(mask, wc->wildcards & mf->fww_bit ? 0x00 : 0xff, mf->n_bytes);
445         break;
446
447     case MFF_TUN_ID:
448         mask->be64 = wc->tun_id_mask;
449         break;
450
451 #if FLOW_N_REGS > 0
452     case MFF_REG0:
453 #endif
454 #if FLOW_N_REGS > 1
455     case MFF_REG1:
456 #endif
457 #if FLOW_N_REGS > 2
458     case MFF_REG2:
459 #endif
460 #if FLOW_N_REGS > 3
461     case MFF_REG3:
462 #endif
463 #if FLOW_N_REGS > 4
464 #error
465 #endif
466         mask->be32 = htonl(wc->reg_masks[mf->id - MFF_REG0]);
467         break;
468
469     case MFF_ETH_DST:
470         memcpy(mask->mac, flow_wildcards_to_dl_dst_mask(wc->wildcards),
471                ETH_ADDR_LEN);
472         break;
473
474     case MFF_VLAN_TCI:
475         mask->be16 = wc->vlan_tci_mask;
476         break;
477     case MFF_VLAN_VID:
478         mask->be16 = wc->vlan_tci_mask & htons(VLAN_VID_MASK);
479         break;
480     case MFF_VLAN_PCP:
481         mask->u8 = vlan_tci_to_pcp(wc->vlan_tci_mask);
482         break;
483
484     case MFF_IPV4_SRC:
485         mask->be32 = wc->nw_src_mask;
486         break;
487     case MFF_IPV4_DST:
488         mask->be32 = wc->nw_dst_mask;
489         break;
490
491     case MFF_IPV6_SRC:
492         mask->ipv6 = wc->ipv6_src_mask;
493         break;
494     case MFF_IPV6_DST:
495         mask->ipv6 = wc->ipv6_dst_mask;
496         break;
497
498     case MFF_ARP_SPA:
499         mask->be32 = wc->nw_src_mask;
500         break;
501     case MFF_ARP_TPA:
502         mask->be32 = wc->nw_dst_mask;
503         break;
504
505     case MFF_N_IDS:
506     default:
507         NOT_REACHED();
508     }
509 }
510
511 /* Tests whether 'mask' is a valid wildcard bit pattern for 'mf'.  Returns true
512  * if the mask is valid, false otherwise. */
513 bool
514 mf_is_mask_valid(const struct mf_field *mf, const union mf_value *mask)
515 {
516     switch (mf->maskable) {
517     case MFM_NONE:
518         return (is_all_zeros((const uint8_t *) mask, mf->n_bytes) ||
519                 is_all_ones((const uint8_t *) mask, mf->n_bytes));
520
521     case MFM_FULLY:
522         return true;
523
524     case MFM_CIDR:
525         return (mf->n_bytes == 4
526                 ? ip_is_cidr(mask->be32)
527                 : ipv6_is_cidr(&mask->ipv6));
528
529     case MFM_MCAST:
530         return flow_wildcards_is_dl_dst_mask_valid(mask->mac);
531     }
532
533     NOT_REACHED();
534 }
535
536 static bool
537 is_ip_any(const struct flow *flow)
538 {
539     return (flow->dl_type == htons(ETH_TYPE_IP) ||
540             flow->dl_type == htons(ETH_TYPE_IPV6));
541 }
542
543 static bool
544 is_icmpv4(const struct flow *flow)
545 {
546     return (flow->dl_type == htons(ETH_TYPE_IP)
547             && flow->nw_proto == IPPROTO_ICMP);
548 }
549
550 static bool
551 is_icmpv6(const struct flow *flow)
552 {
553     return (flow->dl_type == htons(ETH_TYPE_IPV6)
554             && flow->nw_proto == IPPROTO_ICMPV6);
555 }
556
557 /* Returns true if 'flow' meets the prerequisites for 'mf', false otherwise. */
558 bool
559 mf_are_prereqs_ok(const struct mf_field *mf, const struct flow *flow)
560 {
561     switch (mf->prereqs) {
562     case MFP_NONE:
563         return true;
564
565     case MFP_ARP:
566         return flow->dl_type == htons(ETH_TYPE_ARP);
567     case MFP_IPV4:
568         return flow->dl_type == htons(ETH_TYPE_IP);
569     case MFP_IPV6:
570         return flow->dl_type == htons(ETH_TYPE_IPV6);
571     case MFP_IP_ANY:
572         return is_ip_any(flow);
573
574     case MFP_TCP:
575         return is_ip_any(flow) && flow->nw_proto == IPPROTO_TCP;
576     case MFP_UDP:
577         return is_ip_any(flow) && flow->nw_proto == IPPROTO_UDP;
578     case MFP_ICMPV6:
579         return is_icmpv6(flow);
580     case MFP_ICMP_ANY:
581         return is_icmpv4(flow) || is_icmpv6(flow);
582
583     case MFP_ND:
584         return (is_icmpv6(flow)
585                 && flow->icmp_code == htons(0)
586                 && (flow->icmp_type == htons(ND_NEIGHBOR_SOLICIT) ||
587                     flow->icmp_type == htons(ND_NEIGHBOR_ADVERT)));
588     case MFP_ND_SOLICIT:
589         return (is_icmpv6(flow)
590                 && flow->icmp_code == htons(0)
591                 && (flow->icmp_type == htons(ND_NEIGHBOR_SOLICIT)));
592     case MFP_ND_ADVERT:
593         return (is_icmpv6(flow)
594                 && flow->icmp_code == htons(0)
595                 && (flow->icmp_type == htons(ND_NEIGHBOR_ADVERT)));
596     }
597
598     NOT_REACHED();
599 }
600
601 /* Returns true if 'value' may be a valid value *as part of a masked match*,
602  * false otherwise.
603  *
604  * A value is not rejected just because it is not valid for the field in
605  * question, but only if it doesn't make sense to test the bits in question at
606  * all.  For example, the MFF_VLAN_TCI field will never have a nonzero value
607  * without the VLAN_CFI bit being set, but we can't reject those values because
608  * it is still legitimate to test just for those bits (see the documentation
609  * for NXM_OF_VLAN_TCI in nicira-ext.h).  On the other hand, there is never a
610  * reason to set the low bit of MFF_IP_TOS to 1, so we reject that. */
611 bool
612 mf_is_value_valid(const struct mf_field *mf, const union mf_value *value)
613 {
614     switch (mf->id) {
615     case MFF_TUN_ID:
616     case MFF_IN_PORT:
617 #if FLOW_N_REGS > 0
618     case MFF_REG0:
619 #endif
620 #if FLOW_N_REGS > 1
621     case MFF_REG1:
622 #endif
623 #if FLOW_N_REGS > 2
624     case MFF_REG2:
625 #endif
626 #if FLOW_N_REGS > 3
627     case MFF_REG3:
628 #endif
629 #if FLOW_N_REGS > 4
630 #error
631 #endif
632     case MFF_ETH_SRC:
633     case MFF_ETH_DST:
634     case MFF_ETH_TYPE:
635     case MFF_VLAN_TCI:
636     case MFF_IPV4_SRC:
637     case MFF_IPV4_DST:
638     case MFF_IPV6_SRC:
639     case MFF_IPV6_DST:
640     case MFF_IP_PROTO:
641     case MFF_ARP_SPA:
642     case MFF_ARP_TPA:
643     case MFF_ARP_SHA:
644     case MFF_ARP_THA:
645     case MFF_TCP_SRC:
646     case MFF_TCP_DST:
647     case MFF_UDP_SRC:
648     case MFF_UDP_DST:
649     case MFF_ICMP_TYPE:
650     case MFF_ICMP_CODE:
651     case MFF_ND_TARGET:
652     case MFF_ND_SLL:
653     case MFF_ND_TLL:
654         return true;
655
656     case MFF_IP_TOS:
657         return !(value->u8 & 0x03);
658
659     case MFF_ARP_OP:
660         return !(value->be16 & htons(0xff00));
661
662     case MFF_VLAN_VID:
663         return !(value->be16 & htons(VLAN_CFI | VLAN_PCP_MASK));
664
665     case MFF_VLAN_PCP:
666         return !(value->u8 & ~7);
667
668     case MFF_N_IDS:
669     default:
670         NOT_REACHED();
671     }
672 }
673
674 /* Copies the value of field 'mf' from 'flow' into 'value'.  The caller is
675  * responsible for ensuring that 'flow' meets 'mf''s prerequisites. */
676 void
677 mf_get_value(const struct mf_field *mf, const struct flow *flow,
678              union mf_value *value)
679 {
680     switch (mf->id) {
681     case MFF_TUN_ID:
682         value->be64 = flow->tun_id;
683         break;
684
685     case MFF_IN_PORT:
686         value->be16 = htons(flow->in_port);
687         break;
688
689 #if FLOW_N_REGS > 0
690     case MFF_REG0:
691 #endif
692 #if FLOW_N_REGS > 1
693     case MFF_REG1:
694 #endif
695 #if FLOW_N_REGS > 2
696     case MFF_REG2:
697 #endif
698 #if FLOW_N_REGS > 3
699     case MFF_REG3:
700 #endif
701 #if FLOW_N_REGS > 4
702 #error
703 #endif
704         value->be32 = htonl(flow->regs[0]);
705         break;
706
707     case MFF_ETH_SRC:
708         memcpy(value->mac, flow->dl_src, ETH_ADDR_LEN);
709         break;
710
711     case MFF_ETH_DST:
712         memcpy(value->mac, flow->dl_dst, ETH_ADDR_LEN);
713         break;
714
715     case MFF_ETH_TYPE:
716         value->be16 = flow->dl_type;
717         break;
718
719     case MFF_VLAN_TCI:
720         value->be16 = flow->vlan_tci;
721         break;
722
723     case MFF_VLAN_VID:
724         value->be16 = flow->vlan_tci & htons(VLAN_VID_MASK);
725         break;
726
727     case MFF_VLAN_PCP:
728         value->u8 = vlan_tci_to_pcp(flow->vlan_tci);
729         break;
730
731     case MFF_IPV4_SRC:
732         value->be32 = flow->nw_src;
733         break;
734
735     case MFF_IPV4_DST:
736         value->be32 = flow->nw_dst;
737         break;
738
739     case MFF_IPV6_SRC:
740         value->ipv6 = flow->ipv6_src;
741         break;
742
743     case MFF_IPV6_DST:
744         value->ipv6 = flow->ipv6_dst;
745         break;
746
747     case MFF_IP_PROTO:
748         value->u8 = flow->nw_proto;
749         break;
750
751     case MFF_IP_TOS:
752         value->u8 = flow->nw_tos;
753         break;
754
755     case MFF_ARP_OP:
756         value->be16 = htons(flow->nw_proto);
757         break;
758
759     case MFF_ARP_SPA:
760         value->be32 = flow->nw_src;
761         break;
762
763     case MFF_ARP_TPA:
764         value->be32 = flow->nw_dst;
765         break;
766
767     case MFF_ARP_SHA:
768     case MFF_ND_SLL:
769         memcpy(value->mac, flow->arp_sha, ETH_ADDR_LEN);
770         break;
771
772     case MFF_ARP_THA:
773     case MFF_ND_TLL:
774         memcpy(value->mac, flow->arp_tha, ETH_ADDR_LEN);
775         break;
776
777     case MFF_TCP_SRC:
778         value->be16 = flow->tp_src;
779         break;
780
781     case MFF_TCP_DST:
782         value->be16 = flow->tp_dst;
783         break;
784
785     case MFF_UDP_SRC:
786         value->be16 = flow->tp_src;
787         break;
788
789     case MFF_UDP_DST:
790         value->be16 = flow->tp_dst;
791         break;
792
793     case MFF_ICMP_TYPE:
794         value->u8 = ntohs(flow->tp_src);
795         break;
796
797     case MFF_ICMP_CODE:
798         value->u8 = ntohs(flow->tp_dst);
799         break;
800
801     case MFF_ND_TARGET:
802         value->ipv6 = flow->nd_target;
803         break;
804
805     case MFF_N_IDS:
806     default:
807         NOT_REACHED();
808     }
809 }
810
811 /* Makes 'rule' match field 'mf' exactly, with the value matched taken from
812  * 'value'.  The caller is responsible for ensuring that 'rule' meets 'mf''s
813  * prerequisites. */
814 void
815 mf_set_value(const struct mf_field *mf,
816              const union mf_value *value, struct cls_rule *rule)
817 {
818     switch (mf->id) {
819     case MFF_TUN_ID:
820         cls_rule_set_tun_id(rule, value->be64);
821         break;
822
823     case MFF_IN_PORT:
824         cls_rule_set_in_port(rule, ntohs(value->be16));
825         break;
826
827 #if FLOW_N_REGS > 0
828     case MFF_REG0:
829 #endif
830 #if FLOW_N_REGS > 1
831     case MFF_REG1:
832 #endif
833 #if FLOW_N_REGS > 2
834     case MFF_REG2:
835 #endif
836 #if FLOW_N_REGS > 3
837     case MFF_REG3:
838 #endif
839 #if FLOW_N_REGS > 4
840 #error
841 #endif
842 #if FLOW_N_REGS > 0
843         cls_rule_set_reg(rule, mf->id - MFF_REG0, ntohl(value->be32));
844         break;
845 #endif
846
847     case MFF_ETH_SRC:
848         cls_rule_set_dl_src(rule, value->mac);
849         break;
850
851     case MFF_ETH_DST:
852         cls_rule_set_dl_dst(rule, value->mac);
853         break;
854
855     case MFF_ETH_TYPE:
856         cls_rule_set_dl_type(rule, value->be16);
857         break;
858
859     case MFF_VLAN_TCI:
860         cls_rule_set_dl_tci(rule, value->be16);
861         break;
862
863     case MFF_VLAN_VID:
864         cls_rule_set_dl_vlan(rule, value->be16);
865         break;
866
867     case MFF_VLAN_PCP:
868         cls_rule_set_dl_vlan_pcp(rule, value->u8);
869         break;
870
871     case MFF_IPV4_SRC:
872         cls_rule_set_nw_src(rule, value->be32);
873         break;
874
875     case MFF_IPV4_DST:
876         cls_rule_set_nw_dst(rule, value->be32);
877         break;
878
879     case MFF_IPV6_SRC:
880         cls_rule_set_ipv6_src(rule, &value->ipv6);
881         break;
882
883     case MFF_IPV6_DST:
884         cls_rule_set_ipv6_dst(rule, &value->ipv6);
885         break;
886
887     case MFF_IP_PROTO:
888         cls_rule_set_nw_proto(rule, value->u8);
889         break;
890
891     case MFF_IP_TOS:
892         cls_rule_set_nw_tos(rule, value->u8);
893         break;
894
895     case MFF_ARP_OP:
896         cls_rule_set_nw_proto(rule, ntohs(value->be16));
897         break;
898
899     case MFF_ARP_SPA:
900         cls_rule_set_nw_src(rule, value->be32);
901         break;
902
903     case MFF_ARP_TPA:
904         cls_rule_set_nw_dst(rule, value->be32);
905         break;
906
907     case MFF_ARP_SHA:
908     case MFF_ND_SLL:
909         cls_rule_set_arp_sha(rule, value->mac);
910         break;
911
912     case MFF_ARP_THA:
913     case MFF_ND_TLL:
914         cls_rule_set_arp_tha(rule, value->mac);
915         break;
916
917     case MFF_TCP_SRC:
918         cls_rule_set_tp_src(rule, value->be16);
919         break;
920
921     case MFF_TCP_DST:
922         cls_rule_set_tp_dst(rule, value->be16);
923         break;
924
925     case MFF_UDP_SRC:
926         cls_rule_set_tp_src(rule, value->be16);
927         break;
928
929     case MFF_UDP_DST:
930         cls_rule_set_tp_dst(rule, value->be16);
931         break;
932
933     case MFF_ICMP_TYPE:
934         cls_rule_set_icmp_type(rule, value->u8);
935         break;
936
937     case MFF_ICMP_CODE:
938         cls_rule_set_icmp_code(rule, value->u8);
939         break;
940
941     case MFF_ND_TARGET:
942         cls_rule_set_nd_target(rule, &value->ipv6);
943         break;
944
945     case MFF_N_IDS:
946     default:
947         NOT_REACHED();
948     }
949 }
950
951 /* Makes 'rule' wildcard field 'mf'.
952  *
953  * The caller is responsible for ensuring that 'rule' meets 'mf''s
954  * prerequisites. */
955 void
956 mf_set_wild(const struct mf_field *mf, struct cls_rule *rule)
957 {
958     switch (mf->id) {
959     case MFF_TUN_ID:
960         cls_rule_set_tun_id_masked(rule, htonll(0), htonll(0));
961         break;
962
963     case MFF_IN_PORT:
964         rule->wc.wildcards |= FWW_IN_PORT;
965         rule->flow.in_port = 0;
966         break;
967
968 #if FLOW_N_REGS > 0
969     case MFF_REG0:
970         cls_rule_set_reg_masked(rule, 0, 0, 0);
971         break;
972 #endif
973 #if FLOW_N_REGS > 1
974     case MFF_REG1:
975         cls_rule_set_reg_masked(rule, 1, 0, 0);
976         break;
977 #endif
978 #if FLOW_N_REGS > 2
979     case MFF_REG2:
980         cls_rule_set_reg_masked(rule, 2, 0, 0);
981         break;
982 #endif
983 #if FLOW_N_REGS > 3
984     case MFF_REG3:
985         cls_rule_set_reg_masked(rule, 3, 0, 0);
986         break;
987 #endif
988 #if FLOW_N_REGS > 4
989 #error
990 #endif
991
992     case MFF_ETH_SRC:
993         rule->wc.wildcards |= FWW_DL_SRC;
994         memset(rule->flow.dl_src, 0, sizeof rule->flow.dl_src);
995         break;
996
997     case MFF_ETH_DST:
998         rule->wc.wildcards |= FWW_DL_DST | FWW_ETH_MCAST;
999         memset(rule->flow.dl_dst, 0, sizeof rule->flow.dl_dst);
1000         break;
1001
1002     case MFF_ETH_TYPE:
1003         rule->wc.wildcards |= FWW_DL_TYPE;
1004         rule->flow.dl_type = htons(0);
1005         break;
1006
1007     case MFF_VLAN_TCI:
1008         cls_rule_set_dl_tci_masked(rule, htons(0), htons(0));
1009         break;
1010
1011     case MFF_VLAN_VID:
1012         cls_rule_set_any_vid(rule);
1013         break;
1014
1015     case MFF_VLAN_PCP:
1016         cls_rule_set_any_pcp(rule);
1017         break;
1018
1019     case MFF_IPV4_SRC:
1020     case MFF_ARP_SPA:
1021         cls_rule_set_nw_src_masked(rule, htonl(0), htonl(0));
1022         break;
1023
1024     case MFF_IPV4_DST:
1025     case MFF_ARP_TPA:
1026         cls_rule_set_nw_dst_masked(rule, htonl(0), htonl(0));
1027         break;
1028
1029     case MFF_IPV6_SRC:
1030         memset(&rule->wc.ipv6_src_mask, 0, sizeof rule->wc.ipv6_src_mask);
1031         memset(&rule->flow.ipv6_src, 0, sizeof rule->flow.ipv6_src);
1032         break;
1033
1034     case MFF_IPV6_DST:
1035         memset(&rule->wc.ipv6_dst_mask, 0, sizeof rule->wc.ipv6_dst_mask);
1036         memset(&rule->flow.ipv6_dst, 0, sizeof rule->flow.ipv6_dst);
1037         break;
1038
1039     case MFF_IP_PROTO:
1040         rule->wc.wildcards |= FWW_NW_PROTO;
1041         rule->flow.nw_proto = 0;
1042         break;
1043
1044     case MFF_IP_TOS:
1045         rule->wc.wildcards |= FWW_NW_TOS;
1046         rule->flow.nw_tos = 0;
1047         break;
1048
1049     case MFF_ARP_OP:
1050         rule->wc.wildcards |= FWW_NW_PROTO;
1051         rule->flow.nw_proto = 0;
1052         break;
1053
1054     case MFF_ARP_SHA:
1055     case MFF_ND_SLL:
1056         rule->wc.wildcards |= FWW_ARP_SHA;
1057         memset(rule->flow.arp_sha, 0, sizeof rule->flow.arp_sha);
1058         break;
1059
1060     case MFF_ARP_THA:
1061     case MFF_ND_TLL:
1062         rule->wc.wildcards |= FWW_ARP_THA;
1063         memset(rule->flow.arp_tha, 0, sizeof rule->flow.arp_tha);
1064         break;
1065
1066     case MFF_TCP_SRC:
1067     case MFF_UDP_SRC:
1068     case MFF_ICMP_TYPE:
1069         rule->wc.wildcards |= FWW_TP_SRC;
1070         rule->flow.tp_src = htons(0);
1071         break;
1072
1073     case MFF_TCP_DST:
1074     case MFF_UDP_DST:
1075     case MFF_ICMP_CODE:
1076         rule->wc.wildcards |= FWW_TP_DST;
1077         rule->flow.tp_dst = htons(0);
1078         break;
1079
1080     case MFF_ND_TARGET:
1081         rule->wc.wildcards |= FWW_ND_TARGET;
1082         memset(&rule->flow.nd_target, 0, sizeof rule->flow.nd_target);
1083         break;
1084
1085     case MFF_N_IDS:
1086     default:
1087         NOT_REACHED();
1088     }
1089 }
1090
1091 /* Makes 'rule' match field 'mf' with the specified 'value' and 'mask'.
1092  * 'value' specifies a value to match and 'mask' specifies a wildcard pattern,
1093  * with a 1-bit indicating that the corresponding value bit must match and a
1094  * 0-bit indicating a don't-care.
1095  *
1096  * If 'mask' is NULL or points to all-1-bits, then this call is equivalent to
1097  * mf_set_value(mf, value, rule).  If 'mask' points to all-0-bits, then this
1098  * call is equivalent to mf_set_wild(mf, rule).
1099  *
1100  * 'mask' must be a valid mask for 'mf' (see mf_is_mask_valid()).  The caller
1101  * is responsible for ensuring that 'rule' meets 'mf''s prerequisites. */
1102 void
1103 mf_set(const struct mf_field *mf,
1104        const union mf_value *value, const union mf_value *mask,
1105        struct cls_rule *rule)
1106 {
1107     if (!mask || is_all_ones((const uint8_t *) mask, mf->n_bytes)) {
1108         mf_set_value(mf, value, rule);
1109         return;
1110     } else if (is_all_zeros((const uint8_t *) mask, mf->n_bytes)) {
1111         mf_set_wild(mf, rule);
1112         return;
1113     }
1114
1115     switch (mf->id) {
1116     case MFF_IN_PORT:
1117     case MFF_ETH_SRC:
1118     case MFF_ETH_TYPE:
1119     case MFF_VLAN_VID:
1120     case MFF_VLAN_PCP:
1121     case MFF_IP_PROTO:
1122     case MFF_IP_TOS:
1123     case MFF_ARP_OP:
1124     case MFF_ARP_SHA:
1125     case MFF_ARP_THA:
1126     case MFF_TCP_SRC:
1127     case MFF_TCP_DST:
1128     case MFF_UDP_SRC:
1129     case MFF_UDP_DST:
1130     case MFF_ICMP_TYPE:
1131     case MFF_ICMP_CODE:
1132     case MFF_ND_TARGET:
1133     case MFF_ND_SLL:
1134     case MFF_ND_TLL:
1135         NOT_REACHED();
1136
1137     case MFF_TUN_ID:
1138         cls_rule_set_tun_id_masked(rule, value->be64, mask->be64);
1139         break;
1140
1141 #if FLOW_N_REGS > 0
1142     case MFF_REG0:
1143 #endif
1144 #if FLOW_N_REGS > 1
1145     case MFF_REG1:
1146 #endif
1147 #if FLOW_N_REGS > 2
1148     case MFF_REG2:
1149 #endif
1150 #if FLOW_N_REGS > 3
1151     case MFF_REG3:
1152 #endif
1153 #if FLOW_N_REGS > 4
1154 #error
1155 #endif
1156         cls_rule_set_reg_masked(rule, mf->id - MFF_REG0,
1157                                 ntohl(value->be32), ntohl(mask->be32));
1158         break;
1159
1160     case MFF_ETH_DST:
1161         if (flow_wildcards_is_dl_dst_mask_valid(mask->mac)) {
1162             cls_rule_set_dl_dst_masked(rule, value->mac, mask->mac);
1163         }
1164         break;
1165
1166     case MFF_VLAN_TCI:
1167         cls_rule_set_dl_tci_masked(rule, value->be16, mask->be16);
1168         break;
1169
1170     case MFF_IPV4_SRC:
1171         cls_rule_set_nw_src_masked(rule, value->be32, mask->be32);
1172         break;
1173
1174     case MFF_IPV4_DST:
1175         cls_rule_set_nw_dst_masked(rule, value->be32, mask->be32);
1176         break;
1177
1178     case MFF_IPV6_SRC:
1179         cls_rule_set_ipv6_src_masked(rule, &value->ipv6, &mask->ipv6);
1180         break;
1181
1182     case MFF_IPV6_DST:
1183         cls_rule_set_ipv6_dst_masked(rule, &value->ipv6, &mask->ipv6);
1184         break;
1185
1186     case MFF_ARP_SPA:
1187         cls_rule_set_nw_src_masked(rule, value->be32, mask->be32);
1188         break;
1189
1190     case MFF_ARP_TPA:
1191         cls_rule_set_nw_dst_masked(rule, value->be32, mask->be32);
1192         break;
1193
1194     case MFF_N_IDS:
1195     default:
1196         NOT_REACHED();
1197     }
1198 }
1199
1200 /* Makes a subfield starting at bit offset 'ofs' and continuing for 'n_bits' in
1201  * 'rule''s field 'mf' exactly match the 'n_bits' least-significant bits of
1202  * 'x'.
1203  *
1204  * Example: suppose that 'mf' is originally the following 2-byte field in
1205  * 'rule':
1206  *
1207  *     value == 0xe00a == 2#1110000000001010
1208  *      mask == 0xfc3f == 2#1111110000111111
1209  *
1210  * The call mf_set_subfield(mf, 0x55, 8, 7, rule) would have the following
1211  * effect (note that 0x55 is 2#1010101):
1212  *
1213  *     value == 0xd50a == 2#1101010100001010
1214  *      mask == 0xff3f == 2#1111111100111111
1215  *
1216  * The caller is responsible for ensuring that the result will be a valid
1217  * wildcard pattern for 'mf'.  The caller is responsible for ensuring that
1218  * 'rule' meets 'mf''s prerequisites. */
1219 void
1220 mf_set_subfield(const struct mf_field *mf, uint64_t x, unsigned int ofs,
1221                 unsigned int n_bits, struct cls_rule *rule)
1222 {
1223     if (ofs == 0 && mf->n_bytes * 8 == n_bits) {
1224         union mf_value value;
1225         int i;
1226
1227         for (i = mf->n_bytes - 1; i >= 0; i--) {
1228             ((uint8_t *) &value)[i] = x;
1229             x >>= 8;
1230         }
1231         mf_set_value(mf, &value, rule);
1232     } else {
1233         union mf_value value, mask;
1234         uint8_t *vp, *mp;
1235         unsigned int byte_ofs;
1236
1237         mf_get(mf, rule, &value, &mask);
1238
1239         byte_ofs = mf->n_bytes - ofs / 8;
1240         vp = &((uint8_t *) &value)[byte_ofs];
1241         mp = &((uint8_t *) &mask)[byte_ofs];
1242         if (ofs % 8) {
1243             unsigned int chunk = MIN(8 - ofs % 8, n_bits);
1244             uint8_t chunk_mask = ((1 << chunk) - 1) << (ofs % 8);
1245
1246             *--vp &= ~chunk_mask;
1247             *vp   |= chunk_mask & (x << (ofs % 8));
1248             *--mp |= chunk_mask;
1249
1250             x >>= chunk;
1251             n_bits -= chunk;
1252             ofs += chunk;
1253         }
1254         while (n_bits >= 8) {
1255             *--vp = x;
1256             *--mp = 0xff;
1257             x >>= 8;
1258             n_bits -= 8;
1259             ofs += 8;
1260         }
1261         if (n_bits) {
1262             uint8_t chunk_mask = (1 << n_bits) - 1;
1263
1264             *--vp &= ~chunk_mask;
1265             *vp   |= chunk_mask & x;
1266             *--mp |= chunk_mask;
1267         }
1268
1269         mf_set(mf, &value, &mask, rule);
1270     }
1271 }
1272
1273 /* Copies the value and wildcard bit pattern for 'mf' from 'rule' into the
1274  * 'value' and 'mask', respectively. */
1275 void
1276 mf_get(const struct mf_field *mf, const struct cls_rule *rule,
1277        union mf_value *value, union mf_value *mask)
1278 {
1279     mf_get_value(mf, &rule->flow, value);
1280     mf_get_mask(mf, &rule->wc, mask);
1281 }
1282
1283 /* Assigns a random value for field 'mf' to 'value'. */
1284 void
1285 mf_random_value(const struct mf_field *mf, union mf_value *value)
1286 {
1287     random_bytes(value, mf->n_bytes);
1288
1289     switch (mf->id) {
1290     case MFF_TUN_ID:
1291     case MFF_IN_PORT:
1292 #if FLOW_N_REGS > 0
1293     case MFF_REG0:
1294 #endif
1295 #if FLOW_N_REGS > 1
1296     case MFF_REG1:
1297 #endif
1298 #if FLOW_N_REGS > 2
1299     case MFF_REG2:
1300 #endif
1301 #if FLOW_N_REGS > 3
1302     case MFF_REG3:
1303 #endif
1304 #if FLOW_N_REGS > 4
1305 #error
1306 #endif
1307     case MFF_ETH_SRC:
1308     case MFF_ETH_DST:
1309     case MFF_ETH_TYPE:
1310     case MFF_VLAN_TCI:
1311     case MFF_IPV4_SRC:
1312     case MFF_IPV4_DST:
1313     case MFF_IPV6_SRC:
1314     case MFF_IPV6_DST:
1315     case MFF_IP_PROTO:
1316     case MFF_ARP_SPA:
1317     case MFF_ARP_TPA:
1318     case MFF_ARP_SHA:
1319     case MFF_ARP_THA:
1320     case MFF_TCP_SRC:
1321     case MFF_TCP_DST:
1322     case MFF_UDP_SRC:
1323     case MFF_UDP_DST:
1324     case MFF_ICMP_TYPE:
1325     case MFF_ICMP_CODE:
1326     case MFF_ND_TARGET:
1327     case MFF_ND_SLL:
1328     case MFF_ND_TLL:
1329         break;
1330
1331     case MFF_IP_TOS:
1332         value->u8 &= ~0x03;
1333         break;
1334
1335     case MFF_ARP_OP:
1336         value->be16 &= htons(0xff);
1337         break;
1338
1339     case MFF_VLAN_VID:
1340         value->be16 &= htons(VLAN_VID_MASK);
1341         break;
1342
1343     case MFF_VLAN_PCP:
1344         value->u8 &= 0x07;
1345         break;
1346
1347     case MFF_N_IDS:
1348     default:
1349         NOT_REACHED();
1350     }
1351 }
1352
1353 static char *
1354 mf_from_integer_string(const struct mf_field *mf, const char *s,
1355                        uint8_t *valuep, uint8_t *maskp)
1356 {
1357     unsigned long long int integer, mask;
1358     char *tail;
1359     int i;
1360
1361     errno = 0;
1362     integer = strtoull(s, &tail, 0);
1363     if (errno || (*tail != '\0' && *tail != '/')) {
1364         goto syntax_error;
1365     }
1366
1367     if (*tail == '/') {
1368         mask = strtoull(tail + 1, &tail, 0);
1369         if (errno || *tail != '\0') {
1370             goto syntax_error;
1371         }
1372     } else {
1373         mask = ULLONG_MAX;
1374     }
1375
1376     for (i = mf->n_bytes - 1; i >= 0; i--) {
1377         valuep[i] = integer;
1378         maskp[i] = mask;
1379         integer >>= 8;
1380         mask >>= 8;
1381     }
1382     if (integer) {
1383         return xasprintf("%s: value too large for %u-byte field %s",
1384                          s, mf->n_bytes, mf->name);
1385     }
1386     return NULL;
1387
1388 syntax_error:
1389     return xasprintf("%s: bad syntax for %s", s, mf->name);
1390 }
1391
1392 static char *
1393 mf_from_ethernet_string(const struct mf_field *mf, const char *s,
1394                         uint8_t mac[ETH_ADDR_LEN],
1395                         uint8_t mask[ETH_ADDR_LEN])
1396 {
1397     assert(mf->n_bytes == ETH_ADDR_LEN);
1398
1399     switch (sscanf(s, ETH_ADDR_SCAN_FMT"/"ETH_ADDR_SCAN_FMT,
1400                    ETH_ADDR_SCAN_ARGS(mac), ETH_ADDR_SCAN_ARGS(mask))){
1401     case ETH_ADDR_SCAN_COUNT * 2:
1402         return NULL;
1403
1404     case ETH_ADDR_SCAN_COUNT:
1405         memset(mask, 0xff, ETH_ADDR_LEN);
1406         return NULL;
1407
1408     default:
1409         return xasprintf("%s: invalid Ethernet address", s);
1410     }
1411 }
1412
1413 static char *
1414 mf_from_ipv4_string(const struct mf_field *mf, const char *s,
1415                     ovs_be32 *ip, ovs_be32 *mask)
1416 {
1417     int prefix;
1418
1419     assert(mf->n_bytes == sizeof *ip);
1420
1421     if (sscanf(s, IP_SCAN_FMT"/"IP_SCAN_FMT,
1422                IP_SCAN_ARGS(ip), IP_SCAN_ARGS(mask)) == IP_SCAN_COUNT * 2) {
1423         /* OK. */
1424     } else if (sscanf(s, IP_SCAN_FMT"/%d",
1425                       IP_SCAN_ARGS(ip), &prefix) == IP_SCAN_COUNT + 1) {
1426         if (prefix <= 0 || prefix > 32) {
1427             return xasprintf("%s: network prefix bits not between 1 and "
1428                              "32", s);
1429         } else if (prefix == 32) {
1430             *mask = htonl(UINT32_MAX);
1431         } else {
1432             *mask = htonl(((1u << prefix) - 1) << (32 - prefix));
1433         }
1434     } else if (sscanf(s, IP_SCAN_FMT, IP_SCAN_ARGS(ip)) == IP_SCAN_COUNT) {
1435         *mask = htonl(UINT32_MAX);
1436     } else {
1437         return xasprintf("%s: invalid IP address", s);
1438     }
1439     return NULL;
1440 }
1441
1442 static char *
1443 mf_from_ipv6_string(const struct mf_field *mf, const char *s,
1444                     struct in6_addr *value, struct in6_addr *mask)
1445 {
1446     char *str = xstrdup(s);
1447     char *save_ptr = NULL;
1448     const char *name, *netmask;
1449     int retval;
1450
1451     assert(mf->n_bytes == sizeof *value);
1452
1453     name = strtok_r(str, "/", &save_ptr);
1454     retval = name ? lookup_ipv6(name, value) : EINVAL;
1455     if (retval) {
1456         char *err;
1457
1458         err = xasprintf("%s: could not convert to IPv6 address", str);
1459         free(str);
1460
1461         return err;
1462     }
1463
1464     netmask = strtok_r(NULL, "/", &save_ptr);
1465     if (netmask) {
1466         int prefix = atoi(netmask);
1467         if (prefix <= 0 || prefix > 128) {
1468             free(str);
1469             return xasprintf("%s: prefix bits not between 1 and 128", s);
1470         } else {
1471             *mask = ipv6_create_mask(prefix);
1472         }
1473     } else {
1474         *mask = in6addr_exact;
1475     }
1476     free(str);
1477
1478     return NULL;
1479 }
1480
1481 static char *
1482 mf_from_ofp_port_string(const struct mf_field *mf, const char *s,
1483                         ovs_be16 *valuep, ovs_be16 *maskp)
1484 {
1485     uint16_t port;
1486
1487     assert(mf->n_bytes == sizeof(ovs_be16));
1488     if (ofputil_port_from_string(s, &port)) {
1489         *valuep = htons(port);
1490         *maskp = htons(UINT16_MAX);
1491         return NULL;
1492     } else {
1493         return mf_from_integer_string(mf, s,
1494                                       (uint8_t *) valuep, (uint8_t *) maskp);
1495     }
1496 }
1497
1498 /* Parses 's', a string value for field 'mf', into 'value' and 'mask'.  Returns
1499  * NULL if successful, otherwise a malloc()'d string describing the error. */
1500 char *
1501 mf_parse(const struct mf_field *mf, const char *s,
1502          union mf_value *value, union mf_value *mask)
1503 {
1504     if (!strcasecmp(s, "any") || !strcmp(s, "*")) {
1505         memset(value, 0, mf->n_bytes);
1506         memset(mask, 0, mf->n_bytes);
1507         return NULL;
1508     }
1509
1510     switch (mf->string) {
1511     case MFS_DECIMAL:
1512     case MFS_HEXADECIMAL:
1513         return mf_from_integer_string(mf, s,
1514                                       (uint8_t *) value, (uint8_t *) mask);
1515
1516     case MFS_ETHERNET:
1517         return mf_from_ethernet_string(mf, s, value->mac, mask->mac);
1518
1519     case MFS_IPV4:
1520         return mf_from_ipv4_string(mf, s, &value->be32, &mask->be32);
1521
1522     case MFS_IPV6:
1523         return mf_from_ipv6_string(mf, s, &value->ipv6, &mask->ipv6);
1524
1525     case MFS_OFP_PORT:
1526         return mf_from_ofp_port_string(mf, s, &value->be16, &mask->be16);
1527     }
1528     NOT_REACHED();
1529 }
1530
1531 /* Parses 's', a string value for field 'mf', into 'value'.  Returns NULL if
1532  * successful, otherwise a malloc()'d string describing the error. */
1533 char *
1534 mf_parse_value(const struct mf_field *mf, const char *s, union mf_value *value)
1535 {
1536     union mf_value mask;
1537     char *error;
1538
1539     error = mf_parse(mf, s, value, &mask);
1540     if (error) {
1541         return error;
1542     }
1543
1544     if (!is_all_ones((const uint8_t *) &mask, mf->n_bytes)) {
1545         return xasprintf("%s: wildcards not allowed here", s);
1546     }
1547     return NULL;
1548 }
1549
1550 static void
1551 mf_format_integer_string(const struct mf_field *mf, const uint8_t *valuep,
1552                          const uint8_t *maskp, struct ds *s)
1553 {
1554     unsigned long long int integer;
1555     int i;
1556
1557     assert(mf->n_bytes <= 8);
1558
1559     integer = 0;
1560     for (i = 0; i < mf->n_bytes; i++) {
1561         integer = (integer << 8) | valuep[i];
1562     }
1563     if (mf->string == MFS_HEXADECIMAL) {
1564         ds_put_format(s, "%#llx", integer);
1565     } else {
1566         ds_put_format(s, "%lld", integer);
1567     }
1568
1569     if (maskp) {
1570         unsigned long long int mask;
1571
1572         mask = 0;
1573         for (i = 0; i < mf->n_bytes; i++) {
1574             mask = (mask << 8) | maskp[i];
1575         }
1576
1577         /* I guess we could write the mask in decimal for MFS_DECIMAL but I'm
1578          * not sure that that a bit-mask written in decimal is ever easier to
1579          * understand than the same bit-mask written in hexadecimal. */
1580         ds_put_format(s, "/%#llx", mask);
1581     }
1582 }
1583
1584 /* Appends to 's' a string representation of field 'mf' whose value is in
1585  * 'value' and 'mask'.  'mask' may be NULL to indicate an exact match. */
1586 void
1587 mf_format(const struct mf_field *mf,
1588           const union mf_value *value, const union mf_value *mask,
1589           struct ds *s)
1590 {
1591     if (mask) {
1592         if (is_all_zeros((const uint8_t *) mask, mf->n_bytes)) {
1593             ds_put_cstr(s, "ANY");
1594             return;
1595         } else if (is_all_ones((const uint8_t *) mask, mf->n_bytes)) {
1596             mask = NULL;
1597         }
1598     }
1599
1600     switch (mf->string) {
1601     case MFS_OFP_PORT:
1602         if (!mask) {
1603             ofputil_format_port(ntohs(value->be16), s);
1604             break;
1605         }
1606         /* fall through */
1607     case MFS_DECIMAL:
1608     case MFS_HEXADECIMAL:
1609         mf_format_integer_string(mf, (uint8_t *) value, (uint8_t *) mask, s);
1610         break;
1611
1612     case MFS_ETHERNET:
1613         ds_put_format(s, ETH_ADDR_FMT, ETH_ADDR_ARGS(value->mac));
1614         if (mask) {
1615             ds_put_format(s, "/"ETH_ADDR_FMT, ETH_ADDR_ARGS(mask->mac));
1616         }
1617         break;
1618
1619     case MFS_IPV4:
1620         ip_format_masked(value->be32, mask ? mask->be32 : htonl(UINT32_MAX),
1621                          s);
1622         break;
1623
1624     case MFS_IPV6:
1625         print_ipv6_masked(s, &value->ipv6, mask ? &mask->ipv6 : NULL);
1626         break;
1627
1628     default:
1629         NOT_REACHED();
1630     }
1631 }