lib/meta-flow.c

   1 /*
   2  * Copyright (c) 2011, 2012, 2013 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 "meta-flow.h"
  20
  21 #include <errno.h>
  22 #include <limits.h>
  23 #include <netinet/icmp6.h>
  24 #include <netinet/ip6.h>
  25
  26 #include "classifier.h"
  27 #include "dynamic-string.h"
  28 #include "ofp-errors.h"
  29 #include "ofp-util.h"
  30 #include "ovs-thread.h"
  31 #include "packets.h"
  32 #include "random.h"
  33 #include "shash.h"
  34 #include "socket-util.h"
  35 #include "unaligned.h"
  36 #include "vlog.h"
  37
  38 VLOG_DEFINE_THIS_MODULE(meta_flow);
  39
  40 #define FLOW_U32OFS(FIELD)                                              \
  41     offsetof(struct flow, FIELD) % 4 ? -1 : offsetof(struct flow, FIELD) / 4
  42
  43 #define MF_FIELD_SIZES(MEMBER)                  \
  44     sizeof ((union mf_value *)0)->MEMBER,       \
  45     8 * sizeof ((union mf_value *)0)->MEMBER
  46
  47 extern const struct mf_field mf_fields[MFF_N_IDS]; /* Silence a warning. */
  48
  49 const struct mf_field mf_fields[MFF_N_IDS] = {
  50     /* ## -------- ## */
  51     /* ## metadata ## */
  52     /* ## -------- ## */
  53
  54     {
  55         MFF_DP_HASH, "dp_hash", NULL,
  56         MF_FIELD_SIZES(be32),
  57         MFM_FULLY,
  58         MFS_HEXADECIMAL,
  59         MFP_NONE,
  60         false,
  61         NXM_NX_DP_HASH, "NXM_NX_DP_HASH",
  62         NXM_NX_DP_HASH, "NXM_NX_DP_HASH",
  63         OFPUTIL_P_NXM_OXM_ANY,
  64         OFPUTIL_P_NXM_OXM_ANY,
  65         -1,
  66     }, {
  67         MFF_RECIRC_ID, "recirc_id", NULL,
  68         MF_FIELD_SIZES(be32),
  69         MFM_NONE,
  70         MFS_DECIMAL,
  71         MFP_NONE,
  72         false,
  73         NXM_NX_RECIRC_ID, "NXM_NX_RECIRC_ID",
  74         NXM_NX_RECIRC_ID, "NXM_NX_RECIRC_ID",
  75         OFPUTIL_P_NXM_OXM_ANY,
  76         OFPUTIL_P_NXM_OXM_ANY,
  77         -1,
  78     }, {
  79         MFF_TUN_ID, "tun_id", "tunnel_id",
  80         MF_FIELD_SIZES(be64),
  81         MFM_FULLY,
  82         MFS_HEXADECIMAL,
  83         MFP_NONE,
  84         true,
  85         NXM_NX_TUN_ID, "NXM_NX_TUN_ID",
  86         OXM_OF_TUNNEL_ID, "OXM_OF_TUNNEL_ID",
  87         OFPUTIL_P_NXM_OXM_ANY,
  88         OFPUTIL_P_NXM_OXM_ANY,
  89         FLOW_U32OFS(tunnel.tun_id),
  90     }, {
  91         MFF_TUN_SRC, "tun_src", NULL,
  92         MF_FIELD_SIZES(be32),
  93         MFM_FULLY,
  94         MFS_IPV4,
  95         MFP_NONE,
  96         true,
  97         NXM_NX_TUN_IPV4_SRC, "NXM_NX_TUN_IPV4_SRC",
  98         NXM_NX_TUN_IPV4_SRC, "NXM_NX_TUN_IPV4_SRC",
  99         OFPUTIL_P_NXM_OXM_ANY,
 100         OFPUTIL_P_NXM_OXM_ANY,
 101         FLOW_U32OFS(tunnel.ip_src),
 102     }, {
 103         MFF_TUN_DST, "tun_dst", NULL,
 104         MF_FIELD_SIZES(be32),
 105         MFM_FULLY,
 106         MFS_IPV4,
 107         MFP_NONE,
 108         true,
 109         NXM_NX_TUN_IPV4_DST, "NXM_NX_TUN_IPV4_DST",
 110         NXM_NX_TUN_IPV4_DST, "NXM_NX_TUN_IPV4_DST",
 111         OFPUTIL_P_NXM_OXM_ANY,
 112         OFPUTIL_P_NXM_OXM_ANY,
 113         FLOW_U32OFS(tunnel.ip_dst),
 114     }, {
 115         MFF_TUN_FLAGS, "tun_flags", NULL,
 116         MF_FIELD_SIZES(be16),
 117         MFM_NONE,
 118         MFS_TNL_FLAGS,
 119         MFP_NONE,
 120         false,
 121         0, NULL,
 122         0, NULL,
 123         OFPUTIL_P_NONE,
 124         OFPUTIL_P_NONE,
 125         -1,
 126     }, {
 127         MFF_TUN_TTL, "tun_ttl", NULL,
 128         MF_FIELD_SIZES(u8),
 129         MFM_NONE,
 130         MFS_DECIMAL,
 131         MFP_NONE,
 132         false,
 133         0, NULL,
 134         0, NULL,
 135         OFPUTIL_P_NONE,
 136         OFPUTIL_P_NONE,
 137         -1,
 138     }, {
 139         MFF_TUN_TOS, "tun_tos", NULL,
 140         MF_FIELD_SIZES(u8),
 141         MFM_NONE,
 142         MFS_DECIMAL,
 143         MFP_NONE,
 144         false,
 145         0, NULL,
 146         0, NULL,
 147         OFPUTIL_P_NONE,
 148         OFPUTIL_P_NONE,
 149         -1,
 150     }, {
 151         MFF_METADATA, "metadata", NULL,
 152         MF_FIELD_SIZES(be64),
 153         MFM_FULLY,
 154         MFS_HEXADECIMAL,
 155         MFP_NONE,
 156         true,
 157         OXM_OF_METADATA, "OXM_OF_METADATA",
 158         OXM_OF_METADATA, "OXM_OF_METADATA",
 159         OFPUTIL_P_NXM_OF11_UP,
 160         OFPUTIL_P_NXM_OF11_UP,
 161         -1,
 162     }, {
 163         MFF_IN_PORT, "in_port", NULL,
 164         MF_FIELD_SIZES(be16),
 165         MFM_NONE,
 166         MFS_OFP_PORT,
 167         MFP_NONE,
 168         true,
 169         NXM_OF_IN_PORT, "NXM_OF_IN_PORT",
 170         NXM_OF_IN_PORT, "NXM_OF_IN_PORT",
 171         OFPUTIL_P_ANY,   /* OF11+ via mapping to 32 bits. */
 172         OFPUTIL_P_NONE,
 173         -1,
 174     }, {
 175         MFF_IN_PORT_OXM, "in_port_oxm", NULL,
 176         MF_FIELD_SIZES(be32),
 177         MFM_NONE,
 178         MFS_OFP_PORT_OXM,
 179         MFP_NONE,
 180         true,
 181         OXM_OF_IN_PORT, "OXM_OF_IN_PORT",
 182         OXM_OF_IN_PORT, "OXM_OF_IN_PORT",
 183         OFPUTIL_P_OF11_UP,
 184         OFPUTIL_P_NONE,
 185         -1,
 186     }, {
 187         MFF_SKB_PRIORITY, "skb_priority", NULL,
 188         MF_FIELD_SIZES(be32),
 189         MFM_NONE,
 190         MFS_HEXADECIMAL,
 191         MFP_NONE,
 192         false,
 193         0, NULL,
 194         0, NULL,
 195         OFPUTIL_P_NONE,
 196         OFPUTIL_P_NONE,
 197         -1,
 198     }, {
 199         MFF_PKT_MARK, "pkt_mark", NULL,
 200         MF_FIELD_SIZES(be32),
 201         MFM_FULLY,
 202         MFS_HEXADECIMAL,
 203         MFP_NONE,
 204         true,
 205         NXM_NX_PKT_MARK, "NXM_NX_PKT_MARK",
 206         NXM_NX_PKT_MARK, "NXM_NX_PKT_MARK",
 207         OFPUTIL_P_NXM_OXM_ANY,
 208         OFPUTIL_P_NXM_OXM_ANY,
 209         -1,
 210     },
 211
 212 #define REGISTER(IDX)                           \
 213     {                                           \
 214         MFF_REG##IDX, "reg" #IDX, NULL,         \
 215         MF_FIELD_SIZES(be32),                   \
 216         MFM_FULLY,                              \
 217         MFS_HEXADECIMAL,                        \
 218         MFP_NONE,                               \
 219         true,                                   \
 220         NXM_NX_REG(IDX), "NXM_NX_REG" #IDX,     \
 221         NXM_NX_REG(IDX), "NXM_NX_REG" #IDX,     \
 222         OFPUTIL_P_NXM_OXM_ANY,                  \
 223         OFPUTIL_P_NXM_OXM_ANY,                  \
 224         -1,                                     \
 225     }
 226 #if FLOW_N_REGS > 0
 227     REGISTER(0),
 228 #endif
 229 #if FLOW_N_REGS > 1
 230     REGISTER(1),
 231 #endif
 232 #if FLOW_N_REGS > 2
 233     REGISTER(2),
 234 #endif
 235 #if FLOW_N_REGS > 3
 236     REGISTER(3),
 237 #endif
 238 #if FLOW_N_REGS > 4
 239     REGISTER(4),
 240 #endif
 241 #if FLOW_N_REGS > 5
 242     REGISTER(5),
 243 #endif
 244 #if FLOW_N_REGS > 6
 245     REGISTER(6),
 246 #endif
 247 #if FLOW_N_REGS > 7
 248     REGISTER(7),
 249 #endif
 250 #if FLOW_N_REGS > 8
 251 #error
 252 #endif
 253
 254     /* ## -- ## */
 255     /* ## L2 ## */
 256     /* ## -- ## */
 257
 258     {
 259         MFF_ETH_SRC, "eth_src", "dl_src",
 260         MF_FIELD_SIZES(mac),
 261         MFM_FULLY,
 262         MFS_ETHERNET,
 263         MFP_NONE,
 264         true,
 265         NXM_OF_ETH_SRC, "NXM_OF_ETH_SRC",
 266         OXM_OF_ETH_SRC, "OXM_OF_ETH_SRC",
 267         OFPUTIL_P_ANY,
 268         OFPUTIL_P_NXM_OF11_UP,   /* Bitwise masking only with NXM and OF11+! */
 269         -1,
 270     }, {
 271         MFF_ETH_DST, "eth_dst", "dl_dst",
 272         MF_FIELD_SIZES(mac),
 273         MFM_FULLY,
 274         MFS_ETHERNET,
 275         MFP_NONE,
 276         true,
 277         NXM_OF_ETH_DST, "NXM_OF_ETH_DST",
 278         OXM_OF_ETH_DST, "OXM_OF_ETH_DST",
 279         OFPUTIL_P_ANY,
 280         OFPUTIL_P_NXM_OF11_UP,   /* Bitwise masking only with NXM and OF11+! */
 281         -1,
 282     }, {
 283         MFF_ETH_TYPE, "eth_type", "dl_type",
 284         MF_FIELD_SIZES(be16),
 285         MFM_NONE,
 286         MFS_HEXADECIMAL,
 287         MFP_NONE,
 288         false,
 289         NXM_OF_ETH_TYPE, "NXM_OF_ETH_TYPE",
 290         OXM_OF_ETH_TYPE, "OXM_OF_ETH_TYPE",
 291         OFPUTIL_P_ANY,
 292         OFPUTIL_P_NONE,
 293         -1,
 294     },
 295
 296     {
 297         MFF_VLAN_TCI, "vlan_tci", NULL,
 298         MF_FIELD_SIZES(be16),
 299         MFM_FULLY,
 300         MFS_HEXADECIMAL,
 301         MFP_NONE,
 302         true,
 303         NXM_OF_VLAN_TCI, "NXM_OF_VLAN_TCI",
 304         NXM_OF_VLAN_TCI, "NXM_OF_VLAN_TCI",
 305         OFPUTIL_P_ANY,
 306         OFPUTIL_P_NXM_OXM_ANY,
 307         -1,
 308     }, {
 309         MFF_DL_VLAN, "dl_vlan", NULL,
 310         sizeof(ovs_be16), 12,
 311         MFM_NONE,
 312         MFS_DECIMAL,
 313         MFP_NONE,
 314         true,
 315         0, NULL,
 316         0, NULL,
 317         OFPUTIL_P_ANY,
 318         OFPUTIL_P_NXM_OXM_ANY,
 319         -1,
 320     }, {
 321         MFF_VLAN_VID, "vlan_vid", NULL,
 322         sizeof(ovs_be16), 12,
 323         MFM_FULLY,
 324         MFS_DECIMAL,
 325         MFP_NONE,
 326         true,
 327         OXM_OF_VLAN_VID, "OXM_OF_VLAN_VID",
 328         OXM_OF_VLAN_VID, "OXM_OF_VLAN_VID",
 329         OFPUTIL_P_ANY,
 330         OFPUTIL_P_NXM_OXM_ANY,
 331         -1,
 332     }, {
 333         MFF_DL_VLAN_PCP, "dl_vlan_pcp", NULL,
 334         1, 3,
 335         MFM_NONE,
 336         MFS_DECIMAL,
 337         MFP_NONE,
 338         true,
 339         0, NULL,
 340         0, NULL,
 341         OFPUTIL_P_ANY,   /* Will be mapped to NXM and OXM. */
 342         OFPUTIL_P_NONE,
 343         -1,
 344     }, {
 345         MFF_VLAN_PCP, "vlan_pcp", NULL,
 346         1, 3,
 347         MFM_NONE,
 348         MFS_DECIMAL,
 349         MFP_VLAN_VID,
 350         true,
 351         OXM_OF_VLAN_PCP, "OXM_OF_VLAN_PCP",
 352         OXM_OF_VLAN_PCP, "OXM_OF_VLAN_PCP",
 353         OFPUTIL_P_ANY,   /* Will be mapped to OF10 and NXM. */
 354         OFPUTIL_P_NONE,
 355         -1,
 356     },
 357
 358     /* ## ---- ## */
 359     /* ## L2.5 ## */
 360     /* ## ---- ## */
 361     {
 362         MFF_MPLS_LABEL, "mpls_label", NULL,
 363         4, 20,
 364         MFM_NONE,
 365         MFS_DECIMAL,
 366         MFP_MPLS,
 367         true,
 368         OXM_OF_MPLS_LABEL, "OXM_OF_MPLS_LABEL",
 369         OXM_OF_MPLS_LABEL, "OXM_OF_MPLS_LABEL",
 370         OFPUTIL_P_NXM_OF11_UP,
 371         OFPUTIL_P_NONE,
 372         -1,
 373     }, {
 374         MFF_MPLS_TC, "mpls_tc", NULL,
 375         1, 3,
 376         MFM_NONE,
 377         MFS_DECIMAL,
 378         MFP_MPLS,
 379         true,
 380         OXM_OF_MPLS_TC, "OXM_OF_MPLS_TC",
 381         OXM_OF_MPLS_TC, "OXM_OF_MPLS_TC",
 382         OFPUTIL_P_NXM_OF11_UP,
 383         OFPUTIL_P_NONE,
 384         -1,
 385     }, {
 386         MFF_MPLS_BOS, "mpls_bos", NULL,
 387         1, 1,
 388         MFM_NONE,
 389         MFS_DECIMAL,
 390         MFP_MPLS,
 391         false,
 392         OXM_OF_MPLS_BOS, "OXM_OF_MPLS_BOS",
 393         OXM_OF_MPLS_BOS, "OXM_OF_MPLS_BOS",
 394         OFPUTIL_P_NXM_OXM_ANY,
 395         OFPUTIL_P_NONE,
 396         -1,
 397     },
 398
 399     /* ## -- ## */
 400     /* ## L3 ## */
 401     /* ## -- ## */
 402
 403     {
 404         MFF_IPV4_SRC, "ip_src", "nw_src",
 405         MF_FIELD_SIZES(be32),
 406         MFM_FULLY,
 407         MFS_IPV4,
 408         MFP_IPV4,
 409         true,
 410         NXM_OF_IP_SRC, "NXM_OF_IP_SRC",
 411         OXM_OF_IPV4_SRC, "OXM_OF_IPV4_SRC",
 412         OFPUTIL_P_ANY,
 413         OFPUTIL_P_NXM_OF11_UP,
 414         FLOW_U32OFS(nw_src),
 415     }, {
 416         MFF_IPV4_DST, "ip_dst", "nw_dst",
 417         MF_FIELD_SIZES(be32),
 418         MFM_FULLY,
 419         MFS_IPV4,
 420         MFP_IPV4,
 421         true,
 422         NXM_OF_IP_DST, "NXM_OF_IP_DST",
 423         OXM_OF_IPV4_DST, "OXM_OF_IPV4_DST",
 424         OFPUTIL_P_ANY,
 425         OFPUTIL_P_NXM_OF11_UP,
 426         FLOW_U32OFS(nw_dst),
 427     },
 428
 429     {
 430         MFF_IPV6_SRC, "ipv6_src", NULL,
 431         MF_FIELD_SIZES(ipv6),
 432         MFM_FULLY,
 433         MFS_IPV6,
 434         MFP_IPV6,
 435         true,
 436         NXM_NX_IPV6_SRC, "NXM_NX_IPV6_SRC",
 437         OXM_OF_IPV6_SRC, "OXM_OF_IPV6_SRC",
 438         OFPUTIL_P_NXM_OXM_ANY,
 439         OFPUTIL_P_NXM_OXM_ANY,
 440         FLOW_U32OFS(ipv6_src),
 441     }, {
 442         MFF_IPV6_DST, "ipv6_dst", NULL,
 443         MF_FIELD_SIZES(ipv6),
 444         MFM_FULLY,
 445         MFS_IPV6,
 446         MFP_IPV6,
 447         true,
 448         NXM_NX_IPV6_DST, "NXM_NX_IPV6_DST",
 449         OXM_OF_IPV6_DST, "OXM_OF_IPV6_DST",
 450         OFPUTIL_P_NXM_OXM_ANY,
 451         OFPUTIL_P_NXM_OXM_ANY,
 452         FLOW_U32OFS(ipv6_dst),
 453     },
 454     {
 455         MFF_IPV6_LABEL, "ipv6_label", NULL,
 456         4, 20,
 457         MFM_FULLY,
 458         MFS_HEXADECIMAL,
 459         MFP_IPV6,
 460         false,
 461         NXM_NX_IPV6_LABEL, "NXM_NX_IPV6_LABEL",
 462         OXM_OF_IPV6_FLABEL, "OXM_OF_IPV6_FLABEL",
 463         OFPUTIL_P_NXM_OXM_ANY,
 464         OFPUTIL_P_NXM_OXM_ANY,
 465         -1,
 466     },
 467
 468     {
 469         MFF_IP_PROTO, "nw_proto", "ip_proto",
 470         MF_FIELD_SIZES(u8),
 471         MFM_NONE,
 472         MFS_DECIMAL,
 473         MFP_IP_ANY,
 474         false,
 475         NXM_OF_IP_PROTO, "NXM_OF_IP_PROTO",
 476         OXM_OF_IP_PROTO, "OXM_OF_IP_PROTO",
 477         OFPUTIL_P_ANY,
 478         OFPUTIL_P_NONE,
 479         -1,
 480     }, {
 481         MFF_IP_DSCP, "nw_tos", NULL,
 482         MF_FIELD_SIZES(u8),
 483         MFM_NONE,
 484         MFS_DECIMAL,
 485         MFP_IP_ANY,
 486         true,
 487         NXM_OF_IP_TOS, "NXM_OF_IP_TOS",
 488         NXM_OF_IP_TOS, "NXM_OF_IP_TOS",
 489         OFPUTIL_P_ANY,   /* Will be shifted for OXM. */
 490         OFPUTIL_P_NONE,
 491         -1,
 492     }, {
 493         MFF_IP_DSCP_SHIFTED, "ip_dscp", NULL,
 494         1, 6,
 495         MFM_NONE,
 496         MFS_DECIMAL,
 497         MFP_IP_ANY,
 498         true,
 499         OXM_OF_IP_DSCP, "OXM_OF_IP_DSCP",
 500         OXM_OF_IP_DSCP, "OXM_OF_IP_DSCP",
 501         OFPUTIL_P_ANY,   /* Will be shifted for non-OXM. */
 502         OFPUTIL_P_NONE,
 503         -1,
 504     }, {
 505         MFF_IP_ECN, "nw_ecn", "ip_ecn",
 506         1, 2,
 507         MFM_NONE,
 508         MFS_DECIMAL,
 509         MFP_IP_ANY,
 510         true,
 511         NXM_NX_IP_ECN, "NXM_NX_IP_ECN",
 512         OXM_OF_IP_ECN, "OXM_OF_IP_ECN",
 513         OFPUTIL_P_NXM_OXM_ANY,
 514         OFPUTIL_P_NONE,
 515         -1,
 516     }, {
 517         MFF_IP_TTL, "nw_ttl", NULL,
 518         MF_FIELD_SIZES(u8),
 519         MFM_NONE,
 520         MFS_DECIMAL,
 521         MFP_IP_ANY,
 522         true,
 523         NXM_NX_IP_TTL, "NXM_NX_IP_TTL",
 524         NXM_NX_IP_TTL, "NXM_NX_IP_TTL",
 525         OFPUTIL_P_NXM_OXM_ANY,
 526         OFPUTIL_P_NONE,
 527         -1,
 528     }, {
 529         MFF_IP_FRAG, "ip_frag", NULL,
 530         1, 2,
 531         MFM_FULLY,
 532         MFS_FRAG,
 533         MFP_IP_ANY,
 534         false,
 535         NXM_NX_IP_FRAG, "NXM_NX_IP_FRAG",
 536         NXM_NX_IP_FRAG, "NXM_NX_IP_FRAG",
 537         OFPUTIL_P_NXM_OXM_ANY,
 538         OFPUTIL_P_NXM_OXM_ANY,
 539         -1,
 540     },
 541
 542     {
 543         MFF_ARP_OP, "arp_op", NULL,
 544         MF_FIELD_SIZES(be16),
 545         MFM_NONE,
 546         MFS_DECIMAL,
 547         MFP_ARP,
 548         true,
 549         NXM_OF_ARP_OP, "NXM_OF_ARP_OP",
 550         OXM_OF_ARP_OP, "OXM_OF_ARP_OP",
 551         OFPUTIL_P_ANY,
 552         OFPUTIL_P_NONE,
 553         -1,
 554     }, {
 555         MFF_ARP_SPA, "arp_spa", NULL,
 556         MF_FIELD_SIZES(be32),
 557         MFM_FULLY,
 558         MFS_IPV4,
 559         MFP_ARP,
 560         true,
 561         NXM_OF_ARP_SPA, "NXM_OF_ARP_SPA",
 562         OXM_OF_ARP_SPA, "OXM_OF_ARP_SPA",
 563         OFPUTIL_P_ANY,
 564         OFPUTIL_P_NXM_OF11_UP,
 565         -1,
 566     }, {
 567         MFF_ARP_TPA, "arp_tpa", NULL,
 568         MF_FIELD_SIZES(be32),
 569         MFM_FULLY,
 570         MFS_IPV4,
 571         MFP_ARP,
 572         true,
 573         NXM_OF_ARP_TPA, "NXM_OF_ARP_TPA",
 574         OXM_OF_ARP_TPA, "OXM_OF_ARP_TPA",
 575         OFPUTIL_P_ANY,
 576         OFPUTIL_P_NXM_OF11_UP,
 577         -1,
 578     }, {
 579         MFF_ARP_SHA, "arp_sha", NULL,
 580         MF_FIELD_SIZES(mac),
 581         MFM_FULLY,
 582         MFS_ETHERNET,
 583         MFP_ARP,
 584         true,
 585         NXM_NX_ARP_SHA, "NXM_NX_ARP_SHA",
 586         OXM_OF_ARP_SHA, "OXM_OF_ARP_SHA",
 587         OFPUTIL_P_NXM_OXM_ANY,
 588         OFPUTIL_P_NXM_OXM_ANY,
 589         -1,
 590     }, {
 591         MFF_ARP_THA, "arp_tha", NULL,
 592         MF_FIELD_SIZES(mac),
 593         MFM_FULLY,
 594         MFS_ETHERNET,
 595         MFP_ARP,
 596         true,
 597         NXM_NX_ARP_THA, "NXM_NX_ARP_THA",
 598         OXM_OF_ARP_THA, "OXM_OF_ARP_THA",
 599         OFPUTIL_P_NXM_OXM_ANY,
 600         OFPUTIL_P_NXM_OXM_ANY,
 601         -1,
 602     },
 603
 604     /* ## -- ## */
 605     /* ## L4 ## */
 606     /* ## -- ## */
 607
 608     {
 609         MFF_TCP_SRC, "tcp_src", "tp_src",
 610         MF_FIELD_SIZES(be16),
 611         MFM_FULLY,
 612         MFS_DECIMAL,
 613         MFP_TCP,
 614         true,
 615         NXM_OF_TCP_SRC, "NXM_OF_TCP_SRC",
 616         OXM_OF_TCP_SRC, "OXM_OF_TCP_SRC",
 617         OFPUTIL_P_ANY,
 618         OFPUTIL_P_NXM_OXM_ANY,
 619         -1,
 620     }, {
 621         MFF_TCP_DST, "tcp_dst", "tp_dst",
 622         MF_FIELD_SIZES(be16),
 623         MFM_FULLY,
 624         MFS_DECIMAL,
 625         MFP_TCP,
 626         true,
 627         NXM_OF_TCP_DST, "NXM_OF_TCP_DST",
 628         OXM_OF_TCP_DST, "OXM_OF_TCP_DST",
 629         OFPUTIL_P_ANY,
 630         OFPUTIL_P_NXM_OXM_ANY,
 631         -1,
 632     }, {
 633         MFF_TCP_FLAGS, "tcp_flags", NULL,
 634         2, 12,
 635         MFM_FULLY,
 636         MFS_TCP_FLAGS,
 637         MFP_TCP,
 638         false,
 639         NXM_NX_TCP_FLAGS, "NXM_NX_TCP_FLAGS",
 640         NXM_NX_TCP_FLAGS, "NXM_NX_TCP_FLAGS",
 641         OFPUTIL_P_NXM_OXM_ANY,
 642         OFPUTIL_P_NXM_OXM_ANY,
 643         -1,
 644     },
 645
 646     {
 647         MFF_UDP_SRC, "udp_src", NULL,
 648         MF_FIELD_SIZES(be16),
 649         MFM_FULLY,
 650         MFS_DECIMAL,
 651         MFP_UDP,
 652         true,
 653         NXM_OF_UDP_SRC, "NXM_OF_UDP_SRC",
 654         OXM_OF_UDP_SRC, "OXM_OF_UDP_SRC",
 655         OFPUTIL_P_ANY,
 656         OFPUTIL_P_NXM_OXM_ANY,
 657         -1,
 658     }, {
 659         MFF_UDP_DST, "udp_dst", NULL,
 660         MF_FIELD_SIZES(be16),
 661         MFM_FULLY,
 662         MFS_DECIMAL,
 663         MFP_UDP,
 664         true,
 665         NXM_OF_UDP_DST, "NXM_OF_UDP_DST",
 666         OXM_OF_UDP_DST, "OXM_OF_UDP_DST",
 667         OFPUTIL_P_ANY,
 668         OFPUTIL_P_NXM_OXM_ANY,
 669         -1,
 670     },
 671
 672     {
 673         MFF_SCTP_SRC, "sctp_src", NULL,
 674         MF_FIELD_SIZES(be16),
 675         MFM_FULLY,
 676         MFS_DECIMAL,
 677         MFP_SCTP,
 678         true,
 679         OXM_OF_SCTP_SRC, "OXM_OF_SCTP_SRC",
 680         OXM_OF_SCTP_SRC, "OXM_OF_SCTP_SRC",
 681         OFPUTIL_P_NXM_OF11_UP,
 682         OFPUTIL_P_NXM_OXM_ANY,
 683         -1,
 684     }, {
 685         MFF_SCTP_DST, "sctp_dst", NULL,
 686         MF_FIELD_SIZES(be16),
 687         MFM_FULLY,
 688         MFS_DECIMAL,
 689         MFP_SCTP,
 690         true,
 691         OXM_OF_SCTP_DST, "OXM_OF_SCTP_DST",
 692         OXM_OF_SCTP_DST, "OXM_OF_SCTP_DST",
 693         OFPUTIL_P_NXM_OF11_UP,
 694         OFPUTIL_P_NXM_OXM_ANY,
 695         -1,
 696     },
 697
 698     {
 699         MFF_ICMPV4_TYPE, "icmp_type", NULL,
 700         MF_FIELD_SIZES(u8),
 701         MFM_NONE,
 702         MFS_DECIMAL,
 703         MFP_ICMPV4,
 704         false,
 705         NXM_OF_ICMP_TYPE, "NXM_OF_ICMP_TYPE",
 706         OXM_OF_ICMPV4_TYPE, "OXM_OF_ICMPV4_TYPE",
 707         OFPUTIL_P_ANY,
 708         OFPUTIL_P_NONE,
 709         -1,
 710     }, {
 711         MFF_ICMPV4_CODE, "icmp_code", NULL,
 712         MF_FIELD_SIZES(u8),
 713         MFM_NONE,
 714         MFS_DECIMAL,
 715         MFP_ICMPV4,
 716         false,
 717         NXM_OF_ICMP_CODE, "NXM_OF_ICMP_CODE",
 718         OXM_OF_ICMPV4_CODE, "OXM_OF_ICMPV4_CODE",
 719         OFPUTIL_P_ANY,
 720         OFPUTIL_P_NONE,
 721         -1,
 722     },
 723
 724     {
 725         MFF_ICMPV6_TYPE, "icmpv6_type", NULL,
 726         MF_FIELD_SIZES(u8),
 727         MFM_NONE,
 728         MFS_DECIMAL,
 729         MFP_ICMPV6,
 730         false,
 731         NXM_NX_ICMPV6_TYPE, "NXM_NX_ICMPV6_TYPE",
 732         OXM_OF_ICMPV6_TYPE, "OXM_OF_ICMPV6_TYPE",
 733         OFPUTIL_P_NXM_OXM_ANY,
 734         OFPUTIL_P_NONE,
 735         -1,
 736     }, {
 737         MFF_ICMPV6_CODE, "icmpv6_code", NULL,
 738         MF_FIELD_SIZES(u8),
 739         MFM_NONE,
 740         MFS_DECIMAL,
 741         MFP_ICMPV6,
 742         false,
 743         NXM_NX_ICMPV6_CODE, "NXM_NX_ICMPV6_CODE",
 744         OXM_OF_ICMPV6_CODE, "OXM_OF_ICMPV6_CODE",
 745         OFPUTIL_P_NXM_OXM_ANY,
 746         OFPUTIL_P_NONE,
 747         -1,
 748     },
 749
 750     /* ## ---- ## */
 751     /* ## L"5" ## */
 752     /* ## ---- ## */
 753
 754     {
 755         MFF_ND_TARGET, "nd_target", NULL,
 756         MF_FIELD_SIZES(ipv6),
 757         MFM_FULLY,
 758         MFS_IPV6,
 759         MFP_ND,
 760         false,
 761         NXM_NX_ND_TARGET, "NXM_NX_ND_TARGET",
 762         OXM_OF_IPV6_ND_TARGET, "OXM_OF_IPV6_ND_TARGET",
 763         OFPUTIL_P_NXM_OXM_ANY,
 764         OFPUTIL_P_NXM_OXM_ANY,
 765         -1,
 766     }, {
 767         MFF_ND_SLL, "nd_sll", NULL,
 768         MF_FIELD_SIZES(mac),
 769         MFM_FULLY,
 770         MFS_ETHERNET,
 771         MFP_ND_SOLICIT,
 772         false,
 773         NXM_NX_ND_SLL, "NXM_NX_ND_SLL",
 774         OXM_OF_IPV6_ND_SLL, "OXM_OF_IPV6_ND_SLL",
 775         OFPUTIL_P_NXM_OXM_ANY,
 776         OFPUTIL_P_NXM_OXM_ANY,
 777         -1,
 778     }, {
 779         MFF_ND_TLL, "nd_tll", NULL,
 780         MF_FIELD_SIZES(mac),
 781         MFM_FULLY,
 782         MFS_ETHERNET,
 783         MFP_ND_ADVERT,
 784         false,
 785         NXM_NX_ND_TLL, "NXM_NX_ND_TLL",
 786         OXM_OF_IPV6_ND_TLL, "OXM_OF_IPV6_ND_TLL",
 787         OFPUTIL_P_NXM_OXM_ANY,
 788         OFPUTIL_P_NXM_OXM_ANY,
 789         -1,
 790     }
 791 };
 792
 793 /* Maps an NXM or OXM header value to an mf_field. */
 794 struct nxm_field {
 795     struct hmap_node hmap_node; /* In 'all_fields' hmap. */
 796     uint32_t header;            /* NXM or OXM header value. */
 797     const struct mf_field *mf;
 798 };
 799
 800 /* Contains 'struct nxm_field's. */
 801 static struct hmap all_fields;
 802
 803 /* Maps from an mf_field's 'name' or 'extra_name' to the mf_field. */
 804 static struct shash mf_by_name;
 805
 806 /* Rate limit for parse errors.  These always indicate a bug in an OpenFlow
 807  * controller and so there's not much point in showing a lot of them. */
 808 static struct vlog_rate_limit rl = VLOG_RATE_LIMIT_INIT(1, 5);
 809
 810 const struct mf_field *mf_from_nxm_header__(uint32_t header);
 811 static void nxm_init(void);
 812
 813 /* Returns the field with the given 'name', or a null pointer if no field has
 814  * that name. */
 815 const struct mf_field *
 816 mf_from_name(const char *name)
 817 {
 818     nxm_init();
 819     return shash_find_data(&mf_by_name, name);
 820 }
 821
 822 static void
 823 add_nxm_field(uint32_t header, const struct mf_field *mf)
 824 {
 825     struct nxm_field *f;
 826
 827     f = xmalloc(sizeof *f);
 828     hmap_insert(&all_fields, &f->hmap_node, hash_int(header, 0));
 829     f->header = header;
 830     f->mf = mf;
 831 }
 832
 833 static void
 834 nxm_init_add_field(const struct mf_field *mf, uint32_t header)
 835 {
 836     if (header) {
 837         ovs_assert(!mf_from_nxm_header__(header));
 838         add_nxm_field(header, mf);
 839         if (mf->maskable != MFM_NONE) {
 840             add_nxm_field(NXM_MAKE_WILD_HEADER(header), mf);
 841         }
 842     }
 843 }
 844
 845 static void
 846 nxm_do_init(void)
 847 {
 848     int i;
 849
 850     hmap_init(&all_fields);
 851     shash_init(&mf_by_name);
 852     for (i = 0; i < MFF_N_IDS; i++) {
 853         const struct mf_field *mf = &mf_fields[i];
 854
 855         ovs_assert(mf->id == i); /* Fields must be in the enum order. */
 856
 857         nxm_init_add_field(mf, mf->nxm_header);
 858         if (mf->oxm_header != mf->nxm_header) {
 859             nxm_init_add_field(mf, mf->oxm_header);
 860         }
 861
 862         shash_add_once(&mf_by_name, mf->name, mf);
 863         if (mf->extra_name) {
 864             shash_add_once(&mf_by_name, mf->extra_name, mf);
 865         }
 866     }
 867 }
 868
 869 static void
 870 nxm_init(void)
 871 {
 872     static pthread_once_t once = PTHREAD_ONCE_INIT;
 873     pthread_once(&once, nxm_do_init);
 874 }
 875
 876 const struct mf_field *
 877 mf_from_nxm_header(uint32_t header)
 878 {
 879     nxm_init();
 880     return mf_from_nxm_header__(header);
 881 }
 882
 883 const struct mf_field *
 884 mf_from_nxm_header__(uint32_t header)
 885 {
 886     const struct nxm_field *f;
 887
 888     HMAP_FOR_EACH_IN_BUCKET (f, hmap_node, hash_int(header, 0), &all_fields) {
 889         if (f->header == header) {
 890             return f->mf;
 891         }
 892     }
 893
 894     return NULL;
 895 }
 896
 897 /* Returns true if 'wc' wildcards all the bits in field 'mf', false if 'wc'
 898  * specifies at least one bit in the field.
 899  *
 900  * The caller is responsible for ensuring that 'wc' corresponds to a flow that
 901  * meets 'mf''s prerequisites. */
 902 bool
 903 mf_is_all_wild(const struct mf_field *mf, const struct flow_wildcards *wc)
 904 {
 905     switch (mf->id) {
 906     case MFF_DP_HASH:
 907         return !wc->masks.dp_hash;
 908     case MFF_RECIRC_ID:
 909         return !wc->masks.recirc_id;
 910     case MFF_TUN_SRC:
 911         return !wc->masks.tunnel.ip_src;
 912     case MFF_TUN_DST:
 913         return !wc->masks.tunnel.ip_dst;
 914     case MFF_TUN_ID:
 915     case MFF_TUN_TOS:
 916     case MFF_TUN_TTL:
 917     case MFF_TUN_FLAGS:
 918         return !wc->masks.tunnel.tun_id;
 919     case MFF_METADATA:
 920         return !wc->masks.metadata;
 921     case MFF_IN_PORT:
 922     case MFF_IN_PORT_OXM:
 923         return !wc->masks.in_port.ofp_port;
 924     case MFF_SKB_PRIORITY:
 925         return !wc->masks.skb_priority;
 926     case MFF_PKT_MARK:
 927         return !wc->masks.pkt_mark;
 928     CASE_MFF_REGS:
 929         return !wc->masks.regs[mf->id - MFF_REG0];
 930
 931     case MFF_ETH_SRC:
 932         return eth_addr_is_zero(wc->masks.dl_src);
 933     case MFF_ETH_DST:
 934         return eth_addr_is_zero(wc->masks.dl_dst);
 935     case MFF_ETH_TYPE:
 936         return !wc->masks.dl_type;
 937
 938     case MFF_ARP_SHA:
 939     case MFF_ND_SLL:
 940         return eth_addr_is_zero(wc->masks.arp_sha);
 941
 942     case MFF_ARP_THA:
 943     case MFF_ND_TLL:
 944         return eth_addr_is_zero(wc->masks.arp_tha);
 945
 946     case MFF_VLAN_TCI:
 947         return !wc->masks.vlan_tci;
 948     case MFF_DL_VLAN:
 949         return !(wc->masks.vlan_tci & htons(VLAN_VID_MASK));
 950     case MFF_VLAN_VID:
 951         return !(wc->masks.vlan_tci & htons(VLAN_VID_MASK | VLAN_CFI));
 952     case MFF_DL_VLAN_PCP:
 953     case MFF_VLAN_PCP:
 954         return !(wc->masks.vlan_tci & htons(VLAN_PCP_MASK));
 955
 956     case MFF_MPLS_LABEL:
 957         return !(wc->masks.mpls_lse[0] & htonl(MPLS_LABEL_MASK));
 958     case MFF_MPLS_TC:
 959         return !(wc->masks.mpls_lse[1] & htonl(MPLS_TC_MASK));
 960     case MFF_MPLS_BOS:
 961         return !(wc->masks.mpls_lse[2] & htonl(MPLS_BOS_MASK));
 962
 963     case MFF_IPV4_SRC:
 964         return !wc->masks.nw_src;
 965     case MFF_IPV4_DST:
 966         return !wc->masks.nw_dst;
 967
 968     case MFF_IPV6_SRC:
 969         return ipv6_mask_is_any(&wc->masks.ipv6_src);
 970     case MFF_IPV6_DST:
 971         return ipv6_mask_is_any(&wc->masks.ipv6_dst);
 972
 973     case MFF_IPV6_LABEL:
 974         return !wc->masks.ipv6_label;
 975
 976     case MFF_IP_PROTO:
 977         return !wc->masks.nw_proto;
 978     case MFF_IP_DSCP:
 979     case MFF_IP_DSCP_SHIFTED:
 980         return !(wc->masks.nw_tos & IP_DSCP_MASK);
 981     case MFF_IP_ECN:
 982         return !(wc->masks.nw_tos & IP_ECN_MASK);
 983     case MFF_IP_TTL:
 984         return !wc->masks.nw_ttl;
 985
 986     case MFF_ND_TARGET:
 987         return ipv6_mask_is_any(&wc->masks.nd_target);
 988
 989     case MFF_IP_FRAG:
 990         return !(wc->masks.nw_frag & FLOW_NW_FRAG_MASK);
 991
 992     case MFF_ARP_OP:
 993         return !wc->masks.nw_proto;
 994     case MFF_ARP_SPA:
 995         return !wc->masks.nw_src;
 996     case MFF_ARP_TPA:
 997         return !wc->masks.nw_dst;
 998
 999     case MFF_TCP_SRC:
1000     case MFF_UDP_SRC:
1001     case MFF_SCTP_SRC:
1002     case MFF_ICMPV4_TYPE:
1003     case MFF_ICMPV6_TYPE:
1004         return !wc->masks.tp_src;
1005     case MFF_TCP_DST:
1006     case MFF_UDP_DST:
1007     case MFF_SCTP_DST:
1008     case MFF_ICMPV4_CODE:
1009     case MFF_ICMPV6_CODE:
1010         return !wc->masks.tp_dst;
1011     case MFF_TCP_FLAGS:
1012         return !wc->masks.tcp_flags;
1013
1014     case MFF_N_IDS:
1015     default:
1016         OVS_NOT_REACHED();
1017     }
1018 }
1019
1020 /* Initializes 'mask' with the wildcard bit pattern for field 'mf' within 'wc'.
1021  * Each bit in 'mask' will be set to 1 if the bit is significant for matching
1022  * purposes, or to 0 if it is wildcarded.
1023  *
1024  * The caller is responsible for ensuring that 'wc' corresponds to a flow that
1025  * meets 'mf''s prerequisites. */
1026 void
1027 mf_get_mask(const struct mf_field *mf, const struct flow_wildcards *wc,
1028             union mf_value *mask)
1029 {
1030     mf_get_value(mf, &wc->masks, mask);
1031 }
1032
1033 /* Tests whether 'mask' is a valid wildcard bit pattern for 'mf'.  Returns true
1034  * if the mask is valid, false otherwise. */
1035 bool
1036 mf_is_mask_valid(const struct mf_field *mf, const union mf_value *mask)
1037 {
1038     switch (mf->maskable) {
1039     case MFM_NONE:
1040         return (is_all_zeros((const uint8_t *) mask, mf->n_bytes) ||
1041                 is_all_ones((const uint8_t *) mask, mf->n_bytes));
1042
1043     case MFM_FULLY:
1044         return true;
1045     }
1046
1047     OVS_NOT_REACHED();
1048 }
1049
1050 /* Returns true if 'flow' meets the prerequisites for 'mf', false otherwise. */
1051 bool
1052 mf_are_prereqs_ok(const struct mf_field *mf, const struct flow *flow)
1053 {
1054     switch (mf->prereqs) {
1055     case MFP_NONE:
1056         return true;
1057
1058     case MFP_ARP:
1059       return (flow->dl_type == htons(ETH_TYPE_ARP) ||
1060               flow->dl_type == htons(ETH_TYPE_RARP));
1061     case MFP_IPV4:
1062         return flow->dl_type == htons(ETH_TYPE_IP);
1063     case MFP_IPV6:
1064         return flow->dl_type == htons(ETH_TYPE_IPV6);
1065     case MFP_VLAN_VID:
1066         return (flow->vlan_tci & htons(VLAN_CFI)) != 0;
1067     case MFP_MPLS:
1068         return eth_type_mpls(flow->dl_type);
1069     case MFP_IP_ANY:
1070         return is_ip_any(flow);
1071
1072     case MFP_TCP:
1073         return is_ip_any(flow) && flow->nw_proto == IPPROTO_TCP;
1074     case MFP_UDP:
1075         return is_ip_any(flow) && flow->nw_proto == IPPROTO_UDP;
1076     case MFP_SCTP:
1077         return is_ip_any(flow) && flow->nw_proto == IPPROTO_SCTP;
1078     case MFP_ICMPV4:
1079         return is_icmpv4(flow);
1080     case MFP_ICMPV6:
1081         return is_icmpv6(flow);
1082
1083     case MFP_ND:
1084         return (is_icmpv6(flow)
1085                 && flow->tp_dst == htons(0)
1086                 && (flow->tp_src == htons(ND_NEIGHBOR_SOLICIT) ||
1087                     flow->tp_src == htons(ND_NEIGHBOR_ADVERT)));
1088     case MFP_ND_SOLICIT:
1089         return (is_icmpv6(flow)
1090                 && flow->tp_dst == htons(0)
1091                 && (flow->tp_src == htons(ND_NEIGHBOR_SOLICIT)));
1092     case MFP_ND_ADVERT:
1093         return (is_icmpv6(flow)
1094                 && flow->tp_dst == htons(0)
1095                 && (flow->tp_src == htons(ND_NEIGHBOR_ADVERT)));
1096     }
1097
1098     OVS_NOT_REACHED();
1099 }
1100
1101 /* Set field and it's prerequisities in the mask.
1102  * This is only ever called for writeable 'mf's, but we do not make the
1103  * distinction here. */
1104 void
1105 mf_mask_field_and_prereqs(const struct mf_field *mf, struct flow *mask)
1106 {
1107     static const union mf_value exact_match_mask = MF_EXACT_MASK_INITIALIZER;
1108
1109     mf_set_flow_value(mf, &exact_match_mask, mask);
1110
1111     switch (mf->prereqs) {
1112     case MFP_ND:
1113     case MFP_ND_SOLICIT:
1114     case MFP_ND_ADVERT:
1115         mask->tp_src = OVS_BE16_MAX;
1116         mask->tp_dst = OVS_BE16_MAX;
1117         /* Fall through. */
1118     case MFP_TCP:
1119     case MFP_UDP:
1120     case MFP_SCTP:
1121     case MFP_ICMPV4:
1122     case MFP_ICMPV6:
1123         mask->nw_proto = 0xff;
1124         /* Fall through. */
1125     case MFP_ARP:
1126     case MFP_IPV4:
1127     case MFP_IPV6:
1128     case MFP_MPLS:
1129     case MFP_IP_ANY:
1130         mask->dl_type = OVS_BE16_MAX;
1131         break;
1132     case MFP_VLAN_VID:
1133         mask->vlan_tci |= htons(VLAN_CFI);
1134         break;
1135     case MFP_NONE:
1136         break;
1137     }
1138 }
1139
1140
1141 /* Returns true if 'value' may be a valid value *as part of a masked match*,
1142  * false otherwise.
1143  *
1144  * A value is not rejected just because it is not valid for the field in
1145  * question, but only if it doesn't make sense to test the bits in question at
1146  * all.  For example, the MFF_VLAN_TCI field will never have a nonzero value
1147  * without the VLAN_CFI bit being set, but we can't reject those values because
1148  * it is still legitimate to test just for those bits (see the documentation
1149  * for NXM_OF_VLAN_TCI in nicira-ext.h).  On the other hand, there is never a
1150  * reason to set the low bit of MFF_IP_DSCP to 1, so we reject that. */
1151 bool
1152 mf_is_value_valid(const struct mf_field *mf, const union mf_value *value)
1153 {
1154     switch (mf->id) {
1155     case MFF_DP_HASH:
1156     case MFF_RECIRC_ID:
1157     case MFF_TUN_ID:
1158     case MFF_TUN_SRC:
1159     case MFF_TUN_DST:
1160     case MFF_TUN_TOS:
1161     case MFF_TUN_TTL:
1162     case MFF_TUN_FLAGS:
1163     case MFF_METADATA:
1164     case MFF_IN_PORT:
1165     case MFF_SKB_PRIORITY:
1166     case MFF_PKT_MARK:
1167     CASE_MFF_REGS:
1168     case MFF_ETH_SRC:
1169     case MFF_ETH_DST:
1170     case MFF_ETH_TYPE:
1171     case MFF_VLAN_TCI:
1172     case MFF_IPV4_SRC:
1173     case MFF_IPV4_DST:
1174     case MFF_IPV6_SRC:
1175     case MFF_IPV6_DST:
1176     case MFF_IP_PROTO:
1177     case MFF_IP_TTL:
1178     case MFF_ARP_SPA:
1179     case MFF_ARP_TPA:
1180     case MFF_ARP_SHA:
1181     case MFF_ARP_THA:
1182     case MFF_TCP_SRC:
1183     case MFF_TCP_DST:
1184     case MFF_UDP_SRC:
1185     case MFF_UDP_DST:
1186     case MFF_SCTP_SRC:
1187     case MFF_SCTP_DST:
1188     case MFF_ICMPV4_TYPE:
1189     case MFF_ICMPV4_CODE:
1190     case MFF_ICMPV6_TYPE:
1191     case MFF_ICMPV6_CODE:
1192     case MFF_ND_TARGET:
1193     case MFF_ND_SLL:
1194     case MFF_ND_TLL:
1195         return true;
1196
1197     case MFF_IN_PORT_OXM: {
1198         ofp_port_t port;
1199         return !ofputil_port_from_ofp11(value->be32, &port);
1200     }
1201
1202     case MFF_IP_DSCP:
1203         return !(value->u8 & ~IP_DSCP_MASK);
1204     case MFF_IP_DSCP_SHIFTED:
1205         return !(value->u8 & (~IP_DSCP_MASK >> 2));
1206     case MFF_IP_ECN:
1207         return !(value->u8 & ~IP_ECN_MASK);
1208     case MFF_IP_FRAG:
1209         return !(value->u8 & ~FLOW_NW_FRAG_MASK);
1210     case MFF_TCP_FLAGS:
1211         return !(value->be16 & ~htons(0x0fff));
1212
1213     case MFF_ARP_OP:
1214         return !(value->be16 & htons(0xff00));
1215
1216     case MFF_DL_VLAN:
1217         return !(value->be16 & htons(VLAN_CFI | VLAN_PCP_MASK));
1218     case MFF_VLAN_VID:
1219         return !(value->be16 & htons(VLAN_PCP_MASK));
1220
1221     case MFF_DL_VLAN_PCP:
1222     case MFF_VLAN_PCP:
1223         return !(value->u8 & ~(VLAN_PCP_MASK >> VLAN_PCP_SHIFT));
1224
1225     case MFF_IPV6_LABEL:
1226         return !(value->be32 & ~htonl(IPV6_LABEL_MASK));
1227
1228     case MFF_MPLS_LABEL:
1229         return !(value->be32 & ~htonl(MPLS_LABEL_MASK >> MPLS_LABEL_SHIFT));
1230
1231     case MFF_MPLS_TC:
1232         return !(value->u8 & ~(MPLS_TC_MASK >> MPLS_TC_SHIFT));
1233
1234     case MFF_MPLS_BOS:
1235         return !(value->u8 & ~(MPLS_BOS_MASK >> MPLS_BOS_SHIFT));
1236
1237     case MFF_N_IDS:
1238     default:
1239         OVS_NOT_REACHED();
1240     }
1241 }
1242
1243 /* Copies the value of field 'mf' from 'flow' into 'value'.  The caller is
1244  * responsible for ensuring that 'flow' meets 'mf''s prerequisites. */
1245 void
1246 mf_get_value(const struct mf_field *mf, const struct flow *flow,
1247              union mf_value *value)
1248 {
1249     switch (mf->id) {
1250     case MFF_DP_HASH:
1251         value->be32 = htonl(flow->dp_hash);
1252         break;
1253     case MFF_RECIRC_ID:
1254         value->be32 = htonl(flow->recirc_id);
1255         break;
1256     case MFF_TUN_ID:
1257         value->be64 = flow->tunnel.tun_id;
1258         break;
1259     case MFF_TUN_SRC:
1260         value->be32 = flow->tunnel.ip_src;
1261         break;
1262     case MFF_TUN_DST:
1263         value->be32 = flow->tunnel.ip_dst;
1264         break;
1265     case MFF_TUN_FLAGS:
1266         value->be16 = htons(flow->tunnel.flags);
1267         break;
1268     case MFF_TUN_TTL:
1269         value->u8 = flow->tunnel.ip_ttl;
1270         break;
1271     case MFF_TUN_TOS:
1272         value->u8 = flow->tunnel.ip_tos;
1273         break;
1274
1275     case MFF_METADATA:
1276         value->be64 = flow->metadata;
1277         break;
1278
1279     case MFF_IN_PORT:
1280         value->be16 = htons(ofp_to_u16(flow->in_port.ofp_port));
1281         break;
1282     case MFF_IN_PORT_OXM:
1283         value->be32 = ofputil_port_to_ofp11(flow->in_port.ofp_port);
1284         break;
1285
1286     case MFF_SKB_PRIORITY:
1287         value->be32 = htonl(flow->skb_priority);
1288         break;
1289
1290     case MFF_PKT_MARK:
1291         value->be32 = htonl(flow->pkt_mark);
1292         break;
1293
1294     CASE_MFF_REGS:
1295         value->be32 = htonl(flow->regs[mf->id - MFF_REG0]);
1296         break;
1297
1298     case MFF_ETH_SRC:
1299         memcpy(value->mac, flow->dl_src, ETH_ADDR_LEN);
1300         break;
1301
1302     case MFF_ETH_DST:
1303         memcpy(value->mac, flow->dl_dst, ETH_ADDR_LEN);
1304         break;
1305
1306     case MFF_ETH_TYPE:
1307         value->be16 = flow->dl_type;
1308         break;
1309
1310     case MFF_VLAN_TCI:
1311         value->be16 = flow->vlan_tci;
1312         break;
1313
1314     case MFF_DL_VLAN:
1315         value->be16 = flow->vlan_tci & htons(VLAN_VID_MASK);
1316         break;
1317     case MFF_VLAN_VID:
1318         value->be16 = flow->vlan_tci & htons(VLAN_VID_MASK | VLAN_CFI);
1319         break;
1320
1321     case MFF_DL_VLAN_PCP:
1322     case MFF_VLAN_PCP:
1323         value->u8 = vlan_tci_to_pcp(flow->vlan_tci);
1324         break;
1325
1326     case MFF_MPLS_LABEL:
1327         value->be32 = htonl(mpls_lse_to_label(flow->mpls_lse[0]));
1328         break;
1329
1330     case MFF_MPLS_TC:
1331         value->u8 = mpls_lse_to_tc(flow->mpls_lse[0]);
1332         break;
1333
1334     case MFF_MPLS_BOS:
1335         value->u8 = mpls_lse_to_bos(flow->mpls_lse[0]);
1336         break;
1337
1338     case MFF_IPV4_SRC:
1339         value->be32 = flow->nw_src;
1340         break;
1341
1342     case MFF_IPV4_DST:
1343         value->be32 = flow->nw_dst;
1344         break;
1345
1346     case MFF_IPV6_SRC:
1347         value->ipv6 = flow->ipv6_src;
1348         break;
1349
1350     case MFF_IPV6_DST:
1351         value->ipv6 = flow->ipv6_dst;
1352         break;
1353
1354     case MFF_IPV6_LABEL:
1355         value->be32 = flow->ipv6_label;
1356         break;
1357
1358     case MFF_IP_PROTO:
1359         value->u8 = flow->nw_proto;
1360         break;
1361
1362     case MFF_IP_DSCP:
1363         value->u8 = flow->nw_tos & IP_DSCP_MASK;
1364         break;
1365
1366     case MFF_IP_DSCP_SHIFTED:
1367         value->u8 = flow->nw_tos >> 2;
1368         break;
1369
1370     case MFF_IP_ECN:
1371         value->u8 = flow->nw_tos & IP_ECN_MASK;
1372         break;
1373
1374     case MFF_IP_TTL:
1375         value->u8 = flow->nw_ttl;
1376         break;
1377
1378     case MFF_IP_FRAG:
1379         value->u8 = flow->nw_frag;
1380         break;
1381
1382     case MFF_ARP_OP:
1383         value->be16 = htons(flow->nw_proto);
1384         break;
1385
1386     case MFF_ARP_SPA:
1387         value->be32 = flow->nw_src;
1388         break;
1389
1390     case MFF_ARP_TPA:
1391         value->be32 = flow->nw_dst;
1392         break;
1393
1394     case MFF_ARP_SHA:
1395     case MFF_ND_SLL:
1396         memcpy(value->mac, flow->arp_sha, ETH_ADDR_LEN);
1397         break;
1398
1399     case MFF_ARP_THA:
1400     case MFF_ND_TLL:
1401         memcpy(value->mac, flow->arp_tha, ETH_ADDR_LEN);
1402         break;
1403
1404     case MFF_TCP_SRC:
1405     case MFF_UDP_SRC:
1406     case MFF_SCTP_SRC:
1407         value->be16 = flow->tp_src;
1408         break;
1409
1410     case MFF_TCP_DST:
1411     case MFF_UDP_DST:
1412     case MFF_SCTP_DST:
1413         value->be16 = flow->tp_dst;
1414         break;
1415
1416     case MFF_TCP_FLAGS:
1417         value->be16 = flow->tcp_flags;
1418         break;
1419
1420     case MFF_ICMPV4_TYPE:
1421     case MFF_ICMPV6_TYPE:
1422         value->u8 = ntohs(flow->tp_src);
1423         break;
1424
1425     case MFF_ICMPV4_CODE:
1426     case MFF_ICMPV6_CODE:
1427         value->u8 = ntohs(flow->tp_dst);
1428         break;
1429
1430     case MFF_ND_TARGET:
1431         value->ipv6 = flow->nd_target;
1432         break;
1433
1434     case MFF_N_IDS:
1435     default:
1436         OVS_NOT_REACHED();
1437     }
1438 }
1439
1440 /* Makes 'match' match field 'mf' exactly, with the value matched taken from
1441  * 'value'.  The caller is responsible for ensuring that 'match' meets 'mf''s
1442  * prerequisites. */
1443 void
1444 mf_set_value(const struct mf_field *mf,
1445              const union mf_value *value, struct match *match)
1446 {
1447     switch (mf->id) {
1448     case MFF_DP_HASH:
1449         match_set_dp_hash(match, ntohl(value->be32));
1450         break;
1451     case MFF_RECIRC_ID:
1452         match_set_recirc_id(match, ntohl(value->be32));
1453         break;
1454     case MFF_TUN_ID:
1455         match_set_tun_id(match, value->be64);
1456         break;
1457     case MFF_TUN_SRC:
1458         match_set_tun_src(match, value->be32);
1459         break;
1460     case MFF_TUN_DST:
1461         match_set_tun_dst(match, value->be32);
1462         break;
1463     case MFF_TUN_FLAGS:
1464         match_set_tun_flags(match, ntohs(value->be16));
1465         break;
1466     case MFF_TUN_TOS:
1467         match_set_tun_tos(match, value->u8);
1468         break;
1469     case MFF_TUN_TTL:
1470         match_set_tun_ttl(match, value->u8);
1471         break;
1472
1473     case MFF_METADATA:
1474         match_set_metadata(match, value->be64);
1475         break;
1476
1477     case MFF_IN_PORT:
1478         match_set_in_port(match, u16_to_ofp(ntohs(value->be16)));
1479         break;
1480
1481     case MFF_IN_PORT_OXM: {
1482         ofp_port_t port;
1483         ofputil_port_from_ofp11(value->be32, &port);
1484         match_set_in_port(match, port);
1485         break;
1486     }
1487
1488     case MFF_SKB_PRIORITY:
1489         match_set_skb_priority(match, ntohl(value->be32));
1490         break;
1491
1492     case MFF_PKT_MARK:
1493         match_set_pkt_mark(match, ntohl(value->be32));
1494         break;
1495
1496     CASE_MFF_REGS:
1497         match_set_reg(match, mf->id - MFF_REG0, ntohl(value->be32));
1498         break;
1499
1500     case MFF_ETH_SRC:
1501         match_set_dl_src(match, value->mac);
1502         break;
1503
1504     case MFF_ETH_DST:
1505         match_set_dl_dst(match, value->mac);
1506         break;
1507
1508     case MFF_ETH_TYPE:
1509         match_set_dl_type(match, value->be16);
1510         break;
1511
1512     case MFF_VLAN_TCI:
1513         match_set_dl_tci(match, value->be16);
1514         break;
1515
1516     case MFF_DL_VLAN:
1517         match_set_dl_vlan(match, value->be16);
1518         break;
1519     case MFF_VLAN_VID:
1520         match_set_vlan_vid(match, value->be16);
1521         break;
1522
1523     case MFF_DL_VLAN_PCP:
1524     case MFF_VLAN_PCP:
1525         match_set_dl_vlan_pcp(match, value->u8);
1526         break;
1527
1528     case MFF_MPLS_LABEL:
1529         match_set_mpls_label(match, 0, value->be32);
1530         break;
1531
1532     case MFF_MPLS_TC:
1533         match_set_mpls_tc(match, 0, value->u8);
1534         break;
1535
1536     case MFF_MPLS_BOS:
1537         match_set_mpls_bos(match, 0, value->u8);
1538         break;
1539
1540     case MFF_IPV4_SRC:
1541         match_set_nw_src(match, value->be32);
1542         break;
1543
1544     case MFF_IPV4_DST:
1545         match_set_nw_dst(match, value->be32);
1546         break;
1547
1548     case MFF_IPV6_SRC:
1549         match_set_ipv6_src(match, &value->ipv6);
1550         break;
1551
1552     case MFF_IPV6_DST:
1553         match_set_ipv6_dst(match, &value->ipv6);
1554         break;
1555
1556     case MFF_IPV6_LABEL:
1557         match_set_ipv6_label(match, value->be32);
1558         break;
1559
1560     case MFF_IP_PROTO:
1561         match_set_nw_proto(match, value->u8);
1562         break;
1563
1564     case MFF_IP_DSCP:
1565         match_set_nw_dscp(match, value->u8);
1566         break;
1567
1568     case MFF_IP_DSCP_SHIFTED:
1569         match_set_nw_dscp(match, value->u8 << 2);
1570         break;
1571
1572     case MFF_IP_ECN:
1573         match_set_nw_ecn(match, value->u8);
1574         break;
1575
1576     case MFF_IP_TTL:
1577         match_set_nw_ttl(match, value->u8);
1578         break;
1579
1580     case MFF_IP_FRAG:
1581         match_set_nw_frag(match, value->u8);
1582         break;
1583
1584     case MFF_ARP_OP:
1585         match_set_nw_proto(match, ntohs(value->be16));
1586         break;
1587
1588     case MFF_ARP_SPA:
1589         match_set_nw_src(match, value->be32);
1590         break;
1591
1592     case MFF_ARP_TPA:
1593         match_set_nw_dst(match, value->be32);
1594         break;
1595
1596     case MFF_ARP_SHA:
1597     case MFF_ND_SLL:
1598         match_set_arp_sha(match, value->mac);
1599         break;
1600
1601     case MFF_ARP_THA:
1602     case MFF_ND_TLL:
1603         match_set_arp_tha(match, value->mac);
1604         break;
1605
1606     case MFF_TCP_SRC:
1607     case MFF_UDP_SRC:
1608     case MFF_SCTP_SRC:
1609         match_set_tp_src(match, value->be16);
1610         break;
1611
1612     case MFF_TCP_DST:
1613     case MFF_UDP_DST:
1614     case MFF_SCTP_DST:
1615         match_set_tp_dst(match, value->be16);
1616         break;
1617
1618     case MFF_TCP_FLAGS:
1619         match_set_tcp_flags(match, value->be16);
1620         break;
1621
1622     case MFF_ICMPV4_TYPE:
1623     case MFF_ICMPV6_TYPE:
1624         match_set_icmp_type(match, value->u8);
1625         break;
1626
1627     case MFF_ICMPV4_CODE:
1628     case MFF_ICMPV6_CODE:
1629         match_set_icmp_code(match, value->u8);
1630         break;
1631
1632     case MFF_ND_TARGET:
1633         match_set_nd_target(match, &value->ipv6);
1634         break;
1635
1636     case MFF_N_IDS:
1637     default:
1638         OVS_NOT_REACHED();
1639     }
1640 }
1641
1642 /* Unwildcard 'mask' member field described by 'mf'.  The caller is
1643  * responsible for ensuring that 'mask' meets 'mf''s prerequisites. */
1644 void
1645 mf_mask_field(const struct mf_field *mf, struct flow *mask)
1646 {
1647     static const union mf_value exact_match_mask = MF_EXACT_MASK_INITIALIZER;
1648
1649     /* For MFF_DL_VLAN, we cannot send a all 1's to flow_set_dl_vlan()
1650      * as that will be considered as OFP10_VLAN_NONE. So consider it as a
1651      * special case. For the rest, calling mf_set_flow_value() is good
1652      * enough. */
1653     if (mf->id == MFF_DL_VLAN) {
1654         flow_set_dl_vlan(mask, htons(VLAN_VID_MASK));
1655     } else {
1656         mf_set_flow_value(mf, &exact_match_mask, mask);
1657     }
1658 }
1659
1660 /* Sets 'flow' member field described by 'mf' to 'value'.  The caller is
1661  * responsible for ensuring that 'flow' meets 'mf''s prerequisites.*/
1662 void
1663 mf_set_flow_value(const struct mf_field *mf,
1664                   const union mf_value *value, struct flow *flow)
1665 {
1666     switch (mf->id) {
1667     case MFF_DP_HASH:
1668         flow->dp_hash = ntohl(value->be32);
1669         break;
1670     case MFF_RECIRC_ID:
1671         flow->recirc_id = ntohl(value->be32);
1672         break;
1673     case MFF_TUN_ID:
1674         flow->tunnel.tun_id = value->be64;
1675         break;
1676     case MFF_TUN_SRC:
1677         flow->tunnel.ip_src = value->be32;
1678         break;
1679     case MFF_TUN_DST:
1680         flow->tunnel.ip_dst = value->be32;
1681         break;
1682     case MFF_TUN_FLAGS:
1683         flow->tunnel.flags = ntohs(value->be16);
1684         break;
1685     case MFF_TUN_TOS:
1686         flow->tunnel.ip_tos = value->u8;
1687         break;
1688     case MFF_TUN_TTL:
1689         flow->tunnel.ip_ttl = value->u8;
1690         break;
1691
1692     case MFF_METADATA:
1693         flow->metadata = value->be64;
1694         break;
1695
1696     case MFF_IN_PORT:
1697         flow->in_port.ofp_port = u16_to_ofp(ntohs(value->be16));
1698         break;
1699
1700     case MFF_IN_PORT_OXM: {
1701         ofp_port_t port;
1702         ofputil_port_from_ofp11(value->be32, &port);
1703         flow->in_port.ofp_port = port;
1704         break;
1705     }
1706
1707     case MFF_SKB_PRIORITY:
1708         flow->skb_priority = ntohl(value->be32);
1709         break;
1710
1711     case MFF_PKT_MARK:
1712         flow->pkt_mark = ntohl(value->be32);
1713         break;
1714
1715     CASE_MFF_REGS:
1716         flow->regs[mf->id - MFF_REG0] = ntohl(value->be32);
1717         break;
1718
1719     case MFF_ETH_SRC:
1720         memcpy(flow->dl_src, value->mac, ETH_ADDR_LEN);
1721         break;
1722
1723     case MFF_ETH_DST:
1724         memcpy(flow->dl_dst, value->mac, ETH_ADDR_LEN);
1725         break;
1726
1727     case MFF_ETH_TYPE:
1728         flow->dl_type = value->be16;
1729         break;
1730
1731     case MFF_VLAN_TCI:
1732         flow->vlan_tci = value->be16;
1733         break;
1734
1735     case MFF_DL_VLAN:
1736         flow_set_dl_vlan(flow, value->be16);
1737         break;
1738     case MFF_VLAN_VID:
1739         flow_set_vlan_vid(flow, value->be16);
1740         break;
1741
1742     case MFF_DL_VLAN_PCP:
1743     case MFF_VLAN_PCP:
1744         flow_set_vlan_pcp(flow, value->u8);
1745         break;
1746
1747     case MFF_MPLS_LABEL:
1748         flow_set_mpls_label(flow, 0, value->be32);
1749         break;
1750
1751     case MFF_MPLS_TC:
1752         flow_set_mpls_tc(flow, 0, value->u8);
1753         break;
1754
1755     case MFF_MPLS_BOS:
1756         flow_set_mpls_bos(flow, 0, value->u8);
1757         break;
1758
1759     case MFF_IPV4_SRC:
1760         flow->nw_src = value->be32;
1761         break;
1762
1763     case MFF_IPV4_DST:
1764         flow->nw_dst = value->be32;
1765         break;
1766
1767     case MFF_IPV6_SRC:
1768         flow->ipv6_src = value->ipv6;
1769         break;
1770
1771     case MFF_IPV6_DST:
1772         flow->ipv6_dst = value->ipv6;
1773         break;
1774
1775     case MFF_IPV6_LABEL:
1776         flow->ipv6_label = value->be32 & ~htonl(IPV6_LABEL_MASK);
1777         break;
1778
1779     case MFF_IP_PROTO:
1780         flow->nw_proto = value->u8;
1781         break;
1782
1783     case MFF_IP_DSCP:
1784         flow->nw_tos &= ~IP_DSCP_MASK;
1785         flow->nw_tos |= value->u8 & IP_DSCP_MASK;
1786         break;
1787
1788     case MFF_IP_DSCP_SHIFTED:
1789         flow->nw_tos &= ~IP_DSCP_MASK;
1790         flow->nw_tos |= value->u8 << 2;
1791         break;
1792
1793     case MFF_IP_ECN:
1794         flow->nw_tos &= ~IP_ECN_MASK;
1795         flow->nw_tos |= value->u8 & IP_ECN_MASK;
1796         break;
1797
1798     case MFF_IP_TTL:
1799         flow->nw_ttl = value->u8;
1800         break;
1801
1802     case MFF_IP_FRAG:
1803         flow->nw_frag = value->u8 & FLOW_NW_FRAG_MASK;
1804         break;
1805
1806     case MFF_ARP_OP:
1807         flow->nw_proto = ntohs(value->be16);
1808         break;
1809
1810     case MFF_ARP_SPA:
1811         flow->nw_src = value->be32;
1812         break;
1813
1814     case MFF_ARP_TPA:
1815         flow->nw_dst = value->be32;
1816         break;
1817
1818     case MFF_ARP_SHA:
1819     case MFF_ND_SLL:
1820         memcpy(flow->arp_sha, value->mac, ETH_ADDR_LEN);
1821         break;
1822
1823     case MFF_ARP_THA:
1824     case MFF_ND_TLL:
1825         memcpy(flow->arp_tha, value->mac, ETH_ADDR_LEN);
1826         break;
1827
1828     case MFF_TCP_SRC:
1829     case MFF_UDP_SRC:
1830     case MFF_SCTP_SRC:
1831         flow->tp_src = value->be16;
1832         break;
1833
1834     case MFF_TCP_DST:
1835     case MFF_UDP_DST:
1836     case MFF_SCTP_DST:
1837         flow->tp_dst = value->be16;
1838         break;
1839
1840     case MFF_TCP_FLAGS:
1841         flow->tcp_flags = value->be16;
1842         break;
1843
1844     case MFF_ICMPV4_TYPE:
1845     case MFF_ICMPV6_TYPE:
1846         flow->tp_src = htons(value->u8);
1847         break;
1848
1849     case MFF_ICMPV4_CODE:
1850     case MFF_ICMPV6_CODE:
1851         flow->tp_dst = htons(value->u8);
1852         break;
1853
1854     case MFF_ND_TARGET:
1855         flow->nd_target = value->ipv6;
1856         break;
1857
1858     case MFF_N_IDS:
1859     default:
1860         OVS_NOT_REACHED();
1861     }
1862 }
1863
1864 /* Returns true if 'mf' has a zero value in 'flow', false if it is nonzero.
1865  *
1866  * The caller is responsible for ensuring that 'flow' meets 'mf''s
1867  * prerequisites. */
1868 bool
1869 mf_is_zero(const struct mf_field *mf, const struct flow *flow)
1870 {
1871     union mf_value value;
1872
1873     mf_get_value(mf, flow, &value);
1874     return is_all_zeros((const uint8_t *) &value, mf->n_bytes);
1875 }
1876
1877 /* Makes 'match' wildcard field 'mf'.
1878  *
1879  * The caller is responsible for ensuring that 'match' meets 'mf''s
1880  * prerequisites. */
1881 void
1882 mf_set_wild(const struct mf_field *mf, struct match *match)
1883 {
1884     switch (mf->id) {
1885     case MFF_DP_HASH:
1886         match->flow.dp_hash = 0;
1887         match->wc.masks.dp_hash = 0;
1888         break;
1889     case MFF_RECIRC_ID:
1890         match->flow.recirc_id = 0;
1891         match->wc.masks.recirc_id = 0;
1892         break;
1893     case MFF_TUN_ID:
1894         match_set_tun_id_masked(match, htonll(0), htonll(0));
1895         break;
1896     case MFF_TUN_SRC:
1897         match_set_tun_src_masked(match, htonl(0), htonl(0));
1898         break;
1899     case MFF_TUN_DST:
1900         match_set_tun_dst_masked(match, htonl(0), htonl(0));
1901         break;
1902     case MFF_TUN_FLAGS:
1903         match_set_tun_flags_masked(match, 0, 0);
1904         break;
1905     case MFF_TUN_TOS:
1906         match_set_tun_tos_masked(match, 0, 0);
1907         break;
1908     case MFF_TUN_TTL:
1909         match_set_tun_ttl_masked(match, 0, 0);
1910         break;
1911
1912     case MFF_METADATA:
1913         match_set_metadata_masked(match, htonll(0), htonll(0));
1914         break;
1915
1916     case MFF_IN_PORT:
1917     case MFF_IN_PORT_OXM:
1918         match->flow.in_port.ofp_port = 0;
1919         match->wc.masks.in_port.ofp_port = 0;
1920         break;
1921
1922     case MFF_SKB_PRIORITY:
1923         match->flow.skb_priority = 0;
1924         match->wc.masks.skb_priority = 0;
1925         break;
1926
1927     case MFF_PKT_MARK:
1928         match->flow.pkt_mark = 0;
1929         match->wc.masks.pkt_mark = 0;
1930         break;
1931
1932     CASE_MFF_REGS:
1933         match_set_reg_masked(match, mf->id - MFF_REG0, 0, 0);
1934         break;
1935
1936     case MFF_ETH_SRC:
1937         memset(match->flow.dl_src, 0, ETH_ADDR_LEN);
1938         memset(match->wc.masks.dl_src, 0, ETH_ADDR_LEN);
1939         break;
1940
1941     case MFF_ETH_DST:
1942         memset(match->flow.dl_dst, 0, ETH_ADDR_LEN);
1943         memset(match->wc.masks.dl_dst, 0, ETH_ADDR_LEN);
1944         break;
1945
1946     case MFF_ETH_TYPE:
1947         match->flow.dl_type = htons(0);
1948         match->wc.masks.dl_type = htons(0);
1949         break;
1950
1951     case MFF_VLAN_TCI:
1952         match_set_dl_tci_masked(match, htons(0), htons(0));
1953         break;
1954
1955     case MFF_DL_VLAN:
1956     case MFF_VLAN_VID:
1957         match_set_any_vid(match);
1958         break;
1959
1960     case MFF_DL_VLAN_PCP:
1961     case MFF_VLAN_PCP:
1962         match_set_any_pcp(match);
1963         break;
1964
1965     case MFF_MPLS_LABEL:
1966         match_set_any_mpls_label(match, 0);
1967         break;
1968
1969     case MFF_MPLS_TC:
1970         match_set_any_mpls_tc(match, 0);
1971         break;
1972
1973     case MFF_MPLS_BOS:
1974         match_set_any_mpls_bos(match, 0);
1975         break;
1976
1977     case MFF_IPV4_SRC:
1978     case MFF_ARP_SPA:
1979         match_set_nw_src_masked(match, htonl(0), htonl(0));
1980         break;
1981
1982     case MFF_IPV4_DST:
1983     case MFF_ARP_TPA:
1984         match_set_nw_dst_masked(match, htonl(0), htonl(0));
1985         break;
1986
1987     case MFF_IPV6_SRC:
1988         memset(&match->wc.masks.ipv6_src, 0, sizeof match->wc.masks.ipv6_src);
1989         memset(&match->flow.ipv6_src, 0, sizeof match->flow.ipv6_src);
1990         break;
1991
1992     case MFF_IPV6_DST:
1993         memset(&match->wc.masks.ipv6_dst, 0, sizeof match->wc.masks.ipv6_dst);
1994         memset(&match->flow.ipv6_dst, 0, sizeof match->flow.ipv6_dst);
1995         break;
1996
1997     case MFF_IPV6_LABEL:
1998         match->wc.masks.ipv6_label = htonl(0);
1999         match->flow.ipv6_label = htonl(0);
2000         break;
2001
2002     case MFF_IP_PROTO:
2003         match->wc.masks.nw_proto = 0;
2004         match->flow.nw_proto = 0;
2005         break;
2006
2007     case MFF_IP_DSCP:
2008     case MFF_IP_DSCP_SHIFTED:
2009         match->wc.masks.nw_tos &= ~IP_DSCP_MASK;
2010         match->flow.nw_tos &= ~IP_DSCP_MASK;
2011         break;
2012
2013     case MFF_IP_ECN:
2014         match->wc.masks.nw_tos &= ~IP_ECN_MASK;
2015         match->flow.nw_tos &= ~IP_ECN_MASK;
2016         break;
2017
2018     case MFF_IP_TTL:
2019         match->wc.masks.nw_ttl = 0;
2020         match->flow.nw_ttl = 0;
2021         break;
2022
2023     case MFF_IP_FRAG:
2024         match->wc.masks.nw_frag |= FLOW_NW_FRAG_MASK;
2025         match->flow.nw_frag &= ~FLOW_NW_FRAG_MASK;
2026         break;
2027
2028     case MFF_ARP_OP:
2029         match->wc.masks.nw_proto = 0;
2030         match->flow.nw_proto = 0;
2031         break;
2032
2033     case MFF_ARP_SHA:
2034     case MFF_ND_SLL:
2035         memset(match->flow.arp_sha, 0, ETH_ADDR_LEN);
2036         memset(match->wc.masks.arp_sha, 0, ETH_ADDR_LEN);
2037         break;
2038
2039     case MFF_ARP_THA:
2040     case MFF_ND_TLL:
2041         memset(match->flow.arp_tha, 0, ETH_ADDR_LEN);
2042         memset(match->wc.masks.arp_tha, 0, ETH_ADDR_LEN);
2043         break;
2044
2045     case MFF_TCP_SRC:
2046     case MFF_UDP_SRC:
2047     case MFF_SCTP_SRC:
2048     case MFF_ICMPV4_TYPE:
2049     case MFF_ICMPV6_TYPE:
2050         match->wc.masks.tp_src = htons(0);
2051         match->flow.tp_src = htons(0);
2052         break;
2053
2054     case MFF_TCP_DST:
2055     case MFF_UDP_DST:
2056     case MFF_SCTP_DST:
2057     case MFF_ICMPV4_CODE:
2058     case MFF_ICMPV6_CODE:
2059         match->wc.masks.tp_dst = htons(0);
2060         match->flow.tp_dst = htons(0);
2061         break;
2062
2063     case MFF_TCP_FLAGS:
2064         match->wc.masks.tcp_flags = htons(0);
2065         match->flow.tcp_flags = htons(0);
2066         break;
2067
2068     case MFF_ND_TARGET:
2069         memset(&match->wc.masks.nd_target, 0,
2070                sizeof match->wc.masks.nd_target);
2071         memset(&match->flow.nd_target, 0, sizeof match->flow.nd_target);
2072         break;
2073
2074     case MFF_N_IDS:
2075     default:
2076         OVS_NOT_REACHED();
2077     }
2078 }
2079
2080 /* Makes 'match' match field 'mf' with the specified 'value' and 'mask'.
2081  * 'value' specifies a value to match and 'mask' specifies a wildcard pattern,
2082  * with a 1-bit indicating that the corresponding value bit must match and a
2083  * 0-bit indicating a don't-care.
2084  *
2085  * If 'mask' is NULL or points to all-1-bits, then this call is equivalent to
2086  * mf_set_value(mf, value, match).  If 'mask' points to all-0-bits, then this
2087  * call is equivalent to mf_set_wild(mf, match).
2088  *
2089  * 'mask' must be a valid mask for 'mf' (see mf_is_mask_valid()).  The caller
2090  * is responsible for ensuring that 'match' meets 'mf''s prerequisites. */
2091 enum ofputil_protocol
2092 mf_set(const struct mf_field *mf,
2093        const union mf_value *value, const union mf_value *mask,
2094        struct match *match)
2095 {
2096     if (!mask || is_all_ones((const uint8_t *) mask, mf->n_bytes)) {
2097         mf_set_value(mf, value, match);
2098         return mf->usable_protocols;
2099     } else if (is_all_zeros((const uint8_t *) mask, mf->n_bytes)) {
2100         mf_set_wild(mf, match);
2101         return OFPUTIL_P_ANY;
2102     }
2103
2104     switch (mf->id) {
2105     case MFF_RECIRC_ID:
2106     case MFF_IN_PORT:
2107     case MFF_IN_PORT_OXM:
2108     case MFF_SKB_PRIORITY:
2109     case MFF_ETH_TYPE:
2110     case MFF_DL_VLAN:
2111     case MFF_DL_VLAN_PCP:
2112     case MFF_VLAN_PCP:
2113     case MFF_MPLS_LABEL:
2114     case MFF_MPLS_TC:
2115     case MFF_MPLS_BOS:
2116     case MFF_IP_PROTO:
2117     case MFF_IP_TTL:
2118     case MFF_IP_DSCP:
2119     case MFF_IP_DSCP_SHIFTED:
2120     case MFF_IP_ECN:
2121     case MFF_ARP_OP:
2122     case MFF_ICMPV4_TYPE:
2123     case MFF_ICMPV4_CODE:
2124     case MFF_ICMPV6_TYPE:
2125     case MFF_ICMPV6_CODE:
2126         return OFPUTIL_P_NONE;
2127
2128     case MFF_DP_HASH:
2129         match_set_dp_hash_masked(match, ntohl(value->be32), ntohl(mask->be32));
2130         break;
2131     case MFF_TUN_ID:
2132         match_set_tun_id_masked(match, value->be64, mask->be64);
2133         break;
2134     case MFF_TUN_SRC:
2135         match_set_tun_src_masked(match, value->be32, mask->be32);
2136         break;
2137     case MFF_TUN_DST:
2138         match_set_tun_dst_masked(match, value->be32, mask->be32);
2139         break;
2140     case MFF_TUN_FLAGS:
2141         match_set_tun_flags_masked(match, ntohs(value->be16), ntohs(mask->be16));
2142         break;
2143     case MFF_TUN_TTL:
2144         match_set_tun_ttl_masked(match, value->u8, mask->u8);
2145         break;
2146     case MFF_TUN_TOS:
2147         match_set_tun_tos_masked(match, value->u8, mask->u8);
2148         break;
2149
2150     case MFF_METADATA:
2151         match_set_metadata_masked(match, value->be64, mask->be64);
2152         break;
2153
2154     CASE_MFF_REGS:
2155         match_set_reg_masked(match, mf->id - MFF_REG0,
2156                              ntohl(value->be32), ntohl(mask->be32));
2157         break;
2158
2159     case MFF_PKT_MARK:
2160         match_set_pkt_mark_masked(match, ntohl(value->be32),
2161                                   ntohl(mask->be32));
2162         break;
2163
2164     case MFF_ETH_DST:
2165         match_set_dl_dst_masked(match, value->mac, mask->mac);
2166         break;
2167
2168     case MFF_ETH_SRC:
2169         match_set_dl_src_masked(match, value->mac, mask->mac);
2170         break;
2171
2172     case MFF_ARP_SHA:
2173     case MFF_ND_SLL:
2174         match_set_arp_sha_masked(match, value->mac, mask->mac);
2175         break;
2176
2177     case MFF_ARP_THA:
2178     case MFF_ND_TLL:
2179         match_set_arp_tha_masked(match, value->mac, mask->mac);
2180         break;
2181
2182     case MFF_VLAN_TCI:
2183         match_set_dl_tci_masked(match, value->be16, mask->be16);
2184         break;
2185
2186     case MFF_VLAN_VID:
2187         match_set_vlan_vid_masked(match, value->be16, mask->be16);
2188         break;
2189
2190     case MFF_IPV4_SRC:
2191         match_set_nw_src_masked(match, value->be32, mask->be32);
2192         goto cidr_check;
2193
2194     case MFF_IPV4_DST:
2195         match_set_nw_dst_masked(match, value->be32, mask->be32);
2196         goto cidr_check;
2197
2198     case MFF_IPV6_SRC:
2199         match_set_ipv6_src_masked(match, &value->ipv6, &mask->ipv6);
2200         break;
2201
2202     case MFF_IPV6_DST:
2203         match_set_ipv6_dst_masked(match, &value->ipv6, &mask->ipv6);
2204         break;
2205
2206     case MFF_IPV6_LABEL:
2207         if ((mask->be32 & htonl(IPV6_LABEL_MASK)) == htonl(IPV6_LABEL_MASK)) {
2208             mf_set_value(mf, value, match);
2209         } else {
2210             match_set_ipv6_label_masked(match, value->be32, mask->be32);
2211         }
2212         break;
2213
2214     case MFF_ND_TARGET:
2215         match_set_nd_target_masked(match, &value->ipv6, &mask->ipv6);
2216         break;
2217
2218     case MFF_IP_FRAG:
2219         match_set_nw_frag_masked(match, value->u8, mask->u8);
2220         break;
2221
2222     case MFF_ARP_SPA:
2223         match_set_nw_src_masked(match, value->be32, mask->be32);
2224         goto cidr_check;
2225
2226     case MFF_ARP_TPA:
2227         match_set_nw_dst_masked(match, value->be32, mask->be32);
2228         goto cidr_check;
2229
2230     case MFF_TCP_SRC:
2231     case MFF_UDP_SRC:
2232     case MFF_SCTP_SRC:
2233         match_set_tp_src_masked(match, value->be16, mask->be16);
2234         break;
2235
2236     case MFF_TCP_DST:
2237     case MFF_UDP_DST:
2238     case MFF_SCTP_DST:
2239         match_set_tp_dst_masked(match, value->be16, mask->be16);
2240         break;
2241
2242     case MFF_TCP_FLAGS:
2243         match_set_tcp_flags_masked(match, value->be16, mask->be16);
2244         break;
2245
2246     case MFF_N_IDS:
2247     default:
2248         OVS_NOT_REACHED();
2249     }
2250
2251     return mf->usable_protocols_bitwise;
2252
2253 cidr_check:
2254     return ip_is_cidr(mask->be32) ? mf->usable_protocols :
2255             mf->usable_protocols_bitwise;
2256 }
2257
2258 static enum ofperr
2259 mf_check__(const struct mf_subfield *sf, const struct flow *flow,
2260            const char *type)
2261 {
2262     if (!sf->field) {
2263         VLOG_WARN_RL(&rl, "unknown %s field", type);
2264         return OFPERR_OFPBAC_BAD_SET_TYPE;
2265     } else if (!sf->n_bits) {
2266         VLOG_WARN_RL(&rl, "zero bit %s field %s", type, sf->field->name);
2267         return OFPERR_OFPBAC_BAD_SET_LEN;
2268     } else if (sf->ofs >= sf->field->n_bits) {
2269         VLOG_WARN_RL(&rl, "bit offset %d exceeds %d-bit width of %s field %s",
2270                      sf->ofs, sf->field->n_bits, type, sf->field->name);
2271         return OFPERR_OFPBAC_BAD_SET_LEN;
2272     } else if (sf->ofs + sf->n_bits > sf->field->n_bits) {
2273         VLOG_WARN_RL(&rl, "bit offset %d and width %d exceeds %d-bit width "
2274                      "of %s field %s", sf->ofs, sf->n_bits,
2275                      sf->field->n_bits, type, sf->field->name);
2276         return OFPERR_OFPBAC_BAD_SET_LEN;
2277     } else if (flow && !mf_are_prereqs_ok(sf->field, flow)) {
2278         VLOG_WARN_RL(&rl, "%s field %s lacks correct prerequisites",
2279                      type, sf->field->name);
2280         return OFPERR_OFPBAC_MATCH_INCONSISTENT;
2281     } else {
2282         return 0;
2283     }
2284 }
2285
2286 /* Checks whether 'sf' is valid for reading a subfield out of 'flow'.  Returns
2287  * 0 if so, otherwise an OpenFlow error code (e.g. as returned by
2288  * ofp_mkerr()).  */
2289 enum ofperr
2290 mf_check_src(const struct mf_subfield *sf, const struct flow *flow)
2291 {
2292     return mf_check__(sf, flow, "source");
2293 }
2294
2295 /* Checks whether 'sf' is valid for writing a subfield into 'flow'.  Returns 0
2296  * if so, otherwise an OpenFlow error code (e.g. as returned by
2297  * ofp_mkerr()). */
2298 enum ofperr
2299 mf_check_dst(const struct mf_subfield *sf, const struct flow *flow)
2300 {
2301     int error = mf_check__(sf, flow, "destination");
2302     if (!error && !sf->field->writable) {
2303         VLOG_WARN_RL(&rl, "destination field %s is not writable",
2304                      sf->field->name);
2305         return OFPERR_OFPBAC_BAD_SET_ARGUMENT;
2306     }
2307     return error;
2308 }
2309
2310 /* Copies the value and wildcard bit pattern for 'mf' from 'match' into the
2311  * 'value' and 'mask', respectively. */
2312 void
2313 mf_get(const struct mf_field *mf, const struct match *match,
2314        union mf_value *value, union mf_value *mask)
2315 {
2316     mf_get_value(mf, &match->flow, value);
2317     mf_get_mask(mf, &match->wc, mask);
2318 }
2319
2320 static char *
2321 mf_from_integer_string(const struct mf_field *mf, const char *s,
2322                        uint8_t *valuep, uint8_t *maskp)
2323 {
2324     unsigned long long int integer, mask;
2325     char *tail;
2326     int i;
2327
2328     errno = 0;
2329     integer = strtoull(s, &tail, 0);
2330     if (errno || (*tail != '\0' && *tail != '/')) {
2331         goto syntax_error;
2332     }
2333
2334     if (*tail == '/') {
2335         mask = strtoull(tail + 1, &tail, 0);
2336         if (errno || *tail != '\0') {
2337             goto syntax_error;
2338         }
2339     } else {
2340         mask = ULLONG_MAX;
2341     }
2342
2343     for (i = mf->n_bytes - 1; i >= 0; i--) {
2344         valuep[i] = integer;
2345         maskp[i] = mask;
2346         integer >>= 8;
2347         mask >>= 8;
2348     }
2349     if (integer) {
2350         return xasprintf("%s: value too large for %u-byte field %s",
2351                          s, mf->n_bytes, mf->name);
2352     }
2353     return NULL;
2354
2355 syntax_error:
2356     return xasprintf("%s: bad syntax for %s", s, mf->name);
2357 }
2358
2359 static char *
2360 mf_from_ethernet_string(const struct mf_field *mf, const char *s,
2361                         uint8_t mac[ETH_ADDR_LEN],
2362                         uint8_t mask[ETH_ADDR_LEN])
2363 {
2364     int n;
2365
2366     ovs_assert(mf->n_bytes == ETH_ADDR_LEN);
2367
2368     n = -1;
2369     if (ovs_scan(s, ETH_ADDR_SCAN_FMT"%n", ETH_ADDR_SCAN_ARGS(mac), &n)
2370         && n == strlen(s)) {
2371         memset(mask, 0xff, ETH_ADDR_LEN);
2372         return NULL;
2373     }
2374
2375     n = -1;
2376     if (ovs_scan(s, ETH_ADDR_SCAN_FMT"/"ETH_ADDR_SCAN_FMT"%n",
2377                  ETH_ADDR_SCAN_ARGS(mac), ETH_ADDR_SCAN_ARGS(mask), &n)
2378         && n == strlen(s)) {
2379         return NULL;
2380     }
2381
2382     return xasprintf("%s: invalid Ethernet address", s);
2383 }
2384
2385 static char *
2386 mf_from_ipv4_string(const struct mf_field *mf, const char *s,
2387                     ovs_be32 *ip, ovs_be32 *mask)
2388 {
2389     int prefix;
2390
2391     ovs_assert(mf->n_bytes == sizeof *ip);
2392
2393     if (ovs_scan(s, IP_SCAN_FMT"/"IP_SCAN_FMT,
2394                  IP_SCAN_ARGS(ip), IP_SCAN_ARGS(mask))) {
2395         /* OK. */
2396     } else if (ovs_scan(s, IP_SCAN_FMT"/%d", IP_SCAN_ARGS(ip), &prefix)) {
2397         if (prefix <= 0 || prefix > 32) {
2398             return xasprintf("%s: network prefix bits not between 1 and "
2399                              "32", s);
2400         } else if (prefix == 32) {
2401             *mask = OVS_BE32_MAX;
2402         } else {
2403             *mask = htonl(((1u << prefix) - 1) << (32 - prefix));
2404         }
2405     } else if (ovs_scan(s, IP_SCAN_FMT, IP_SCAN_ARGS(ip))) {
2406         *mask = OVS_BE32_MAX;
2407     } else {
2408         return xasprintf("%s: invalid IP address", s);
2409     }
2410     return NULL;
2411 }
2412
2413 static char *
2414 mf_from_ipv6_string(const struct mf_field *mf, const char *s,
2415                     struct in6_addr *value, struct in6_addr *mask)
2416 {
2417     char *str = xstrdup(s);
2418     char *save_ptr = NULL;
2419     const char *name, *netmask;
2420     int retval;
2421
2422     ovs_assert(mf->n_bytes == sizeof *value);
2423
2424     name = strtok_r(str, "/", &save_ptr);
2425     retval = name ? lookup_ipv6(name, value) : EINVAL;
2426     if (retval) {
2427         char *err;
2428
2429         err = xasprintf("%s: could not convert to IPv6 address", str);
2430         free(str);
2431
2432         return err;
2433     }
2434
2435     netmask = strtok_r(NULL, "/", &save_ptr);
2436     if (netmask) {
2437         if (inet_pton(AF_INET6, netmask, mask) != 1) {
2438             int prefix = atoi(netmask);
2439             if (prefix <= 0 || prefix > 128) {
2440                 free(str);
2441                 return xasprintf("%s: prefix bits not between 1 and 128", s);
2442             } else {
2443                 *mask = ipv6_create_mask(prefix);
2444             }
2445         }
2446     } else {
2447         *mask = in6addr_exact;
2448     }
2449     free(str);
2450
2451     return NULL;
2452 }
2453
2454 static char *
2455 mf_from_ofp_port_string(const struct mf_field *mf, const char *s,
2456                         ovs_be16 *valuep, ovs_be16 *maskp)
2457 {
2458     ofp_port_t port;
2459
2460     ovs_assert(mf->n_bytes == sizeof(ovs_be16));
2461
2462     if (ofputil_port_from_string(s, &port)) {
2463         *valuep = htons(ofp_to_u16(port));
2464         *maskp = OVS_BE16_MAX;
2465         return NULL;
2466     }
2467     return xasprintf("%s: port value out of range for %s", s, mf->name);
2468 }
2469
2470 static char *
2471 mf_from_ofp_port_string32(const struct mf_field *mf, const char *s,
2472                           ovs_be32 *valuep, ovs_be32 *maskp)
2473 {
2474     ofp_port_t port;
2475
2476     ovs_assert(mf->n_bytes == sizeof(ovs_be32));
2477     if (ofputil_port_from_string(s, &port)) {
2478         *valuep = ofputil_port_to_ofp11(port);
2479         *maskp = OVS_BE32_MAX;
2480         return NULL;
2481     }
2482     return xasprintf("%s: port value out of range for %s", s, mf->name);
2483 }
2484
2485 struct frag_handling {
2486     const char *name;
2487     uint8_t mask;
2488     uint8_t value;
2489 };
2490
2491 static const struct frag_handling all_frags[] = {
2492 #define A FLOW_NW_FRAG_ANY
2493 #define L FLOW_NW_FRAG_LATER
2494     /* name               mask  value */
2495
2496     { "no",               A|L,  0     },
2497     { "first",            A|L,  A     },
2498     { "later",            A|L,  A|L   },
2499
2500     { "no",               A,    0     },
2501     { "yes",              A,    A     },
2502
2503     { "not_later",        L,    0     },
2504     { "later",            L,    L     },
2505 #undef A
2506 #undef L
2507 };
2508
2509 static char *
2510 mf_from_frag_string(const char *s, uint8_t *valuep, uint8_t *maskp)
2511 {
2512     const struct frag_handling *h;
2513
2514     for (h = all_frags; h < &all_frags[ARRAY_SIZE(all_frags)]; h++) {
2515         if (!strcasecmp(s, h->name)) {
2516             /* We force the upper bits of the mask on to make mf_parse_value()
2517              * happy (otherwise it will never think it's an exact match.) */
2518             *maskp = h->mask | ~FLOW_NW_FRAG_MASK;
2519             *valuep = h->value;
2520             return NULL;
2521         }
2522     }
2523
2524     return xasprintf("%s: unknown fragment type (valid types are \"no\", "
2525                      "\"yes\", \"first\", \"later\", \"not_first\"", s);
2526 }
2527
2528 static int
2529 parse_flow_tun_flags(const char *s_, const char *(*bit_to_string)(uint32_t),
2530                      ovs_be16 *res)
2531 {
2532     uint32_t result = 0;
2533     char *save_ptr = NULL;
2534     char *name;
2535     int rc = 0;
2536     char *s = xstrdup(s_);
2537
2538     for (name = strtok_r((char *)s, " |", &save_ptr); name;
2539          name = strtok_r(NULL, " |", &save_ptr)) {
2540         int name_len;
2541         unsigned long long int flags;
2542         uint32_t bit;
2543
2544         if (ovs_scan(name, "%lli", &flags)) {
2545             result |= flags;
2546             continue;
2547         }
2548         name_len = strlen(name);
2549         for (bit = 1; bit; bit <<= 1) {
2550             const char *fname = bit_to_string(bit);
2551             size_t len;
2552
2553             if (!fname) {
2554                 continue;
2555             }
2556
2557             len = strlen(fname);
2558             if (len != name_len) {
2559                 continue;
2560             }
2561             if (!strncmp(name, fname, len)) {
2562                 result |= bit;
2563                 break;
2564             }
2565         }
2566
2567         if (!bit) {
2568             rc = -ENOENT;
2569             goto out;
2570         }
2571     }
2572
2573     *res = htons(result);
2574 out:
2575     free(s);
2576     return rc;
2577 }
2578
2579 static char *
2580 mf_from_tun_flags_string(const char *s, ovs_be16 *valuep, ovs_be16 *maskp)
2581 {
2582     if (!parse_flow_tun_flags(s, flow_tun_flag_to_string, valuep)) {
2583         *maskp = OVS_BE16_MAX;
2584         return NULL;
2585     }
2586
2587     return xasprintf("%s: unknown tunnel flags (valid flags are \"df\", "
2588                      "\"csum\", \"key\")", s);
2589 }
2590
2591 static char *
2592 mf_from_tcp_flags_string(const char *s, ovs_be16 *flagsp, ovs_be16 *maskp)
2593 {
2594     uint16_t flags = 0;
2595     uint16_t mask = 0;
2596     uint16_t bit;
2597     int n;
2598
2599     if (ovs_scan(s, "%"SCNi16"/%"SCNi16"%n", &flags, &mask, &n) && !s[n]) {
2600         *flagsp = htons(flags);
2601         *maskp = htons(mask);
2602         return NULL;
2603     }
2604     if (ovs_scan(s, "%"SCNi16"%n", &flags, &n) && !s[n]) {
2605         *flagsp = htons(flags);
2606         *maskp = OVS_BE16_MAX;
2607         return NULL;
2608     }
2609
2610     while (*s != '\0') {
2611         bool set;
2612         int name_len;
2613
2614         switch (*s) {
2615         case '+':
2616             set = true;
2617             break;
2618         case '-':
2619             set = false;
2620             break;
2621         default:
2622             return xasprintf("%s: TCP flag must be preceded by '+' (for SET) "
2623                              "or '-' (NOT SET)", s);
2624         }
2625         s++;
2626
2627         name_len = strcspn(s,"+-");
2628
2629         for (bit = 1; bit; bit <<= 1) {
2630             const char *fname = packet_tcp_flag_to_string(bit);
2631             size_t len;
2632
2633             if (!fname) {
2634                 continue;
2635             }
2636
2637             len = strlen(fname);
2638             if (len != name_len) {
2639                 continue;
2640             }
2641             if (!strncmp(s, fname, len)) {
2642                 if (mask & bit) {
2643                     return xasprintf("%s: Each TCP flag can be specified only "
2644                                      "once", s);
2645                 }
2646                 if (set) {
2647                     flags |= bit;
2648                 }
2649                 mask |= bit;
2650                 break;
2651             }
2652         }
2653
2654         if (!bit) {
2655             return xasprintf("%s: unknown TCP flag(s)", s);
2656         }
2657         s += name_len;
2658     }
2659
2660     *flagsp = htons(flags);
2661     *maskp = htons(mask);
2662     return NULL;
2663 }
2664
2665
2666 /* Parses 's', a string value for field 'mf', into 'value' and 'mask'.  Returns
2667  * NULL if successful, otherwise a malloc()'d string describing the error. */
2668 char *
2669 mf_parse(const struct mf_field *mf, const char *s,
2670          union mf_value *value, union mf_value *mask)
2671 {
2672     char *error;
2673
2674     if (!strcmp(s, "*")) {
2675         memset(value, 0, mf->n_bytes);
2676         memset(mask, 0, mf->n_bytes);
2677         return NULL;
2678     }
2679
2680     switch (mf->string) {
2681     case MFS_DECIMAL:
2682     case MFS_HEXADECIMAL:
2683         error = mf_from_integer_string(mf, s,
2684                                        (uint8_t *) value, (uint8_t *) mask);
2685         break;
2686
2687     case MFS_ETHERNET:
2688         error = mf_from_ethernet_string(mf, s, value->mac, mask->mac);
2689         break;
2690
2691     case MFS_IPV4:
2692         error = mf_from_ipv4_string(mf, s, &value->be32, &mask->be32);
2693         break;
2694
2695     case MFS_IPV6:
2696         error = mf_from_ipv6_string(mf, s, &value->ipv6, &mask->ipv6);
2697         break;
2698
2699     case MFS_OFP_PORT:
2700         error = mf_from_ofp_port_string(mf, s, &value->be16, &mask->be16);
2701         break;
2702
2703     case MFS_OFP_PORT_OXM:
2704         error = mf_from_ofp_port_string32(mf, s, &value->be32, &mask->be32);
2705         break;
2706
2707     case MFS_FRAG:
2708         error = mf_from_frag_string(s, &value->u8, &mask->u8);
2709         break;
2710
2711     case MFS_TNL_FLAGS:
2712         ovs_assert(mf->n_bytes == sizeof(ovs_be16));
2713         error = mf_from_tun_flags_string(s, &value->be16, &mask->be16);
2714         break;
2715
2716     case MFS_TCP_FLAGS:
2717         ovs_assert(mf->n_bytes == sizeof(ovs_be16));
2718         error = mf_from_tcp_flags_string(s, &value->be16, &mask->be16);
2719         break;
2720
2721     default:
2722         OVS_NOT_REACHED();
2723     }
2724
2725     if (!error && !mf_is_mask_valid(mf, mask)) {
2726         error = xasprintf("%s: invalid mask for field %s", s, mf->name);
2727     }
2728     return error;
2729 }
2730
2731 /* Parses 's', a string value for field 'mf', into 'value'.  Returns NULL if
2732  * successful, otherwise a malloc()'d string describing the error. */
2733 char *
2734 mf_parse_value(const struct mf_field *mf, const char *s, union mf_value *value)
2735 {
2736     union mf_value mask;
2737     char *error;
2738
2739     error = mf_parse(mf, s, value, &mask);
2740     if (error) {
2741         return error;
2742     }
2743
2744     if (!is_all_ones((const uint8_t *) &mask, mf->n_bytes)) {
2745         return xasprintf("%s: wildcards not allowed here", s);
2746     }
2747     return NULL;
2748 }
2749
2750 static void
2751 mf_format_integer_string(const struct mf_field *mf, const uint8_t *valuep,
2752                          const uint8_t *maskp, struct ds *s)
2753 {
2754     unsigned long long int integer;
2755     int i;
2756
2757     ovs_assert(mf->n_bytes <= 8);
2758
2759     integer = 0;
2760     for (i = 0; i < mf->n_bytes; i++) {
2761         integer = (integer << 8) | valuep[i];
2762     }
2763     if (mf->string == MFS_HEXADECIMAL) {
2764         ds_put_format(s, "%#llx", integer);
2765     } else {
2766         ds_put_format(s, "%lld", integer);
2767     }
2768
2769     if (maskp) {
2770         unsigned long long int mask;
2771
2772         mask = 0;
2773         for (i = 0; i < mf->n_bytes; i++) {
2774             mask = (mask << 8) | maskp[i];
2775         }
2776
2777         /* I guess we could write the mask in decimal for MFS_DECIMAL but I'm
2778          * not sure that that a bit-mask written in decimal is ever easier to
2779          * understand than the same bit-mask written in hexadecimal. */
2780         ds_put_format(s, "/%#llx", mask);
2781     }
2782 }
2783
2784 static void
2785 mf_format_frag_string(uint8_t value, uint8_t mask, struct ds *s)
2786 {
2787     const struct frag_handling *h;
2788
2789     mask &= FLOW_NW_FRAG_MASK;
2790     value &= mask;
2791
2792     for (h = all_frags; h < &all_frags[ARRAY_SIZE(all_frags)]; h++) {
2793         if (value == h->value && mask == h->mask) {
2794             ds_put_cstr(s, h->name);
2795             return;
2796         }
2797     }
2798     ds_put_cstr(s, "<error>");
2799 }
2800
2801 static void
2802 mf_format_tnl_flags_string(const ovs_be16 *valuep, struct ds *s)
2803 {
2804     format_flags(s, flow_tun_flag_to_string, ntohs(*valuep), '|');
2805 }
2806
2807 static void
2808 mf_format_tcp_flags_string(ovs_be16 value, ovs_be16 mask, struct ds *s)
2809 {
2810     format_flags_masked(s, NULL, packet_tcp_flag_to_string, ntohs(value),
2811                         TCP_FLAGS(mask));
2812 }
2813
2814 /* Appends to 's' a string representation of field 'mf' whose value is in
2815  * 'value' and 'mask'.  'mask' may be NULL to indicate an exact match. */
2816 void
2817 mf_format(const struct mf_field *mf,
2818           const union mf_value *value, const union mf_value *mask,
2819           struct ds *s)
2820 {
2821     if (mask) {
2822         if (is_all_zeros((const uint8_t *) mask, mf->n_bytes)) {
2823             ds_put_cstr(s, "ANY");
2824             return;
2825         } else if (is_all_ones((const uint8_t *) mask, mf->n_bytes)) {
2826             mask = NULL;
2827         }
2828     }
2829
2830     switch (mf->string) {
2831     case MFS_OFP_PORT_OXM:
2832         if (!mask) {
2833             ofp_port_t port;
2834             ofputil_port_from_ofp11(value->be32, &port);
2835             ofputil_format_port(port, s);
2836             break;
2837         }
2838         /* fall through */
2839     case MFS_OFP_PORT:
2840         if (!mask) {
2841             ofputil_format_port(u16_to_ofp(ntohs(value->be16)), s);
2842             break;
2843         }
2844         /* fall through */
2845     case MFS_DECIMAL:
2846     case MFS_HEXADECIMAL:
2847         mf_format_integer_string(mf, (uint8_t *) value, (uint8_t *) mask, s);
2848         break;
2849
2850     case MFS_ETHERNET:
2851         eth_format_masked(value->mac, mask->mac, s);
2852         break;
2853
2854     case MFS_IPV4:
2855         ip_format_masked(value->be32, mask ? mask->be32 : OVS_BE32_MAX, s);
2856         break;
2857
2858     case MFS_IPV6:
2859         print_ipv6_masked(s, &value->ipv6, mask ? &mask->ipv6 : NULL);
2860         break;
2861
2862     case MFS_FRAG:
2863         mf_format_frag_string(value->u8, mask ? mask->u8 : UINT8_MAX, s);
2864         break;
2865
2866     case MFS_TNL_FLAGS:
2867         mf_format_tnl_flags_string(&value->be16, s);
2868         break;
2869
2870     case MFS_TCP_FLAGS:
2871         mf_format_tcp_flags_string(value->be16,
2872                                    mask ? mask->be16 : OVS_BE16_MAX, s);
2873         break;
2874
2875     default:
2876         OVS_NOT_REACHED();
2877     }
2878 }
2879 \f
2880 /* Makes subfield 'sf' within 'flow' exactly match the 'sf->n_bits'
2881  * least-significant bits in 'x'.
2882  */
2883 void
2884 mf_write_subfield_flow(const struct mf_subfield *sf,
2885                        const union mf_subvalue *x, struct flow *flow)
2886 {
2887     const struct mf_field *field = sf->field;
2888     union mf_value value;
2889
2890     mf_get_value(field, flow, &value);
2891     bitwise_copy(x, sizeof *x, 0, &value, field->n_bytes,
2892                  sf->ofs, sf->n_bits);
2893     mf_set_flow_value(field, &value, flow);
2894 }
2895
2896 /* Makes subfield 'sf' within 'match' exactly match the 'sf->n_bits'
2897  * least-significant bits in 'x'.
2898  */
2899 void
2900 mf_write_subfield(const struct mf_subfield *sf, const union mf_subvalue *x,
2901                   struct match *match)
2902 {
2903     const struct mf_field *field = sf->field;
2904     union mf_value value, mask;
2905
2906     mf_get(field, match, &value, &mask);
2907     bitwise_copy(x, sizeof *x, 0, &value, field->n_bytes, sf->ofs, sf->n_bits);
2908     bitwise_one (                 &mask,  field->n_bytes, sf->ofs, sf->n_bits);
2909     mf_set(field, &value, &mask, match);
2910 }
2911
2912 /* Initializes 'x' to the value of 'sf' within 'flow'.  'sf' must be valid for
2913  * reading 'flow', e.g. as checked by mf_check_src(). */
2914 void
2915 mf_read_subfield(const struct mf_subfield *sf, const struct flow *flow,
2916                  union mf_subvalue *x)
2917 {
2918     union mf_value value;
2919
2920     mf_get_value(sf->field, flow, &value);
2921
2922     memset(x, 0, sizeof *x);
2923     bitwise_copy(&value, sf->field->n_bytes, sf->ofs,
2924                  x, sizeof *x, 0,
2925                  sf->n_bits);
2926 }
2927
2928 /* Returns the value of 'sf' within 'flow'.  'sf' must be valid for reading
2929  * 'flow', e.g. as checked by mf_check_src() and sf->n_bits must be 64 or
2930  * less. */
2931 uint64_t
2932 mf_get_subfield(const struct mf_subfield *sf, const struct flow *flow)
2933 {
2934     union mf_value value;
2935
2936     mf_get_value(sf->field, flow, &value);
2937     return bitwise_get(&value, sf->field->n_bytes, sf->ofs, sf->n_bits);
2938 }
2939
2940 /* Formats 'sf' into 's' in a format normally acceptable to
2941  * mf_parse_subfield().  (It won't be acceptable if sf->field is NULL or if
2942  * sf->field has no NXM name.) */
2943 void
2944 mf_format_subfield(const struct mf_subfield *sf, struct ds *s)
2945 {
2946     if (!sf->field) {
2947         ds_put_cstr(s, "<unknown>");
2948     } else if (sf->field->nxm_name) {
2949         ds_put_cstr(s, sf->field->nxm_name);
2950     } else if (sf->field->nxm_header) {
2951         uint32_t header = sf->field->nxm_header;
2952         ds_put_format(s, "%d:%d", NXM_VENDOR(header), NXM_FIELD(header));
2953     } else {
2954         ds_put_cstr(s, sf->field->name);
2955     }
2956
2957     if (sf->field && sf->ofs == 0 && sf->n_bits == sf->field->n_bits) {
2958         ds_put_cstr(s, "[]");
2959     } else if (sf->n_bits == 1) {
2960         ds_put_format(s, "[%d]", sf->ofs);
2961     } else {
2962         ds_put_format(s, "[%d..%d]", sf->ofs, sf->ofs + sf->n_bits - 1);
2963     }
2964 }
2965
2966 static const struct mf_field *
2967 mf_parse_subfield_name(const char *name, int name_len, bool *wild)
2968 {
2969     int i;
2970
2971     *wild = name_len > 2 && !memcmp(&name[name_len - 2], "_W", 2);
2972     if (*wild) {
2973         name_len -= 2;
2974     }
2975
2976     for (i = 0; i < MFF_N_IDS; i++) {
2977         const struct mf_field *mf = mf_from_id(i);
2978
2979         if (mf->nxm_name
2980             && !strncmp(mf->nxm_name, name, name_len)
2981             && mf->nxm_name[name_len] == '\0') {
2982             return mf;
2983         }
2984         if (mf->oxm_name
2985             && !strncmp(mf->oxm_name, name, name_len)
2986             && mf->oxm_name[name_len] == '\0') {
2987             return mf;
2988         }
2989     }
2990
2991     return NULL;
2992 }
2993
2994 /* Parses a subfield from the beginning of '*sp' into 'sf'.  If successful,
2995  * returns NULL and advances '*sp' to the first byte following the parsed
2996  * string.  On failure, returns a malloc()'d error message, does not modify
2997  * '*sp', and does not properly initialize 'sf'.
2998  *
2999  * The syntax parsed from '*sp' takes the form "header[start..end]" where
3000  * 'header' is the name of an NXM field and 'start' and 'end' are (inclusive)
3001  * bit indexes.  "..end" may be omitted to indicate a single bit.  "start..end"
3002  * may both be omitted (the [] are still required) to indicate an entire
3003  * field. */
3004 char * WARN_UNUSED_RESULT
3005 mf_parse_subfield__(struct mf_subfield *sf, const char **sp)
3006 {
3007     const struct mf_field *field;
3008     const char *name;
3009     int start, end;
3010     const char *s;
3011     int name_len;
3012     bool wild;
3013
3014     s = *sp;
3015     name = s;
3016     name_len = strcspn(s, "[");
3017     if (s[name_len] != '[') {
3018         return xasprintf("%s: missing [ looking for field name", *sp);
3019     }
3020
3021     field = mf_parse_subfield_name(name, name_len, &wild);
3022     if (!field) {
3023         return xasprintf("%s: unknown field `%.*s'", *sp, name_len, s);
3024     }
3025
3026     s += name_len;
3027     if (ovs_scan(s, "[%d..%d]", &start, &end)) {
3028         /* Nothing to do. */
3029     } else if (ovs_scan(s, "[%d]", &start)) {
3030         end = start;
3031     } else if (!strncmp(s, "[]", 2)) {
3032         start = 0;
3033         end = field->n_bits - 1;
3034     } else {
3035         return xasprintf("%s: syntax error expecting [] or [<bit>] or "
3036                          "[<start>..<end>]", *sp);
3037     }
3038     s = strchr(s, ']') + 1;
3039
3040     if (start > end) {
3041         return xasprintf("%s: starting bit %d is after ending bit %d",
3042                          *sp, start, end);
3043     } else if (start >= field->n_bits) {
3044         return xasprintf("%s: starting bit %d is not valid because field is "
3045                          "only %d bits wide", *sp, start, field->n_bits);
3046     } else if (end >= field->n_bits){
3047         return xasprintf("%s: ending bit %d is not valid because field is "
3048                          "only %d bits wide", *sp, end, field->n_bits);
3049     }
3050
3051     sf->field = field;
3052     sf->ofs = start;
3053     sf->n_bits = end - start + 1;
3054
3055     *sp = s;
3056     return NULL;
3057 }
3058
3059 /* Parses a subfield from the entirety of 's' into 'sf'.  Returns NULL if
3060  * successful, otherwise a malloc()'d string describing the error.  The caller
3061  * is responsible for freeing the returned string.
3062  *
3063  * The syntax parsed from 's' takes the form "header[start..end]" where
3064  * 'header' is the name of an NXM field and 'start' and 'end' are (inclusive)
3065  * bit indexes.  "..end" may be omitted to indicate a single bit.  "start..end"
3066  * may both be omitted (the [] are still required) to indicate an entire
3067  * field.  */
3068 char * WARN_UNUSED_RESULT
3069 mf_parse_subfield(struct mf_subfield *sf, const char *s)
3070 {
3071     char *error = mf_parse_subfield__(sf, &s);
3072     if (!error && s[0]) {
3073         error = xstrdup("unexpected input following field syntax");
3074     }
3075     return error;
3076 }
3077
3078 void
3079 mf_format_subvalue(const union mf_subvalue *subvalue, struct ds *s)
3080 {
3081     int i;
3082
3083     for (i = 0; i < ARRAY_SIZE(subvalue->u8); i++) {
3084         if (subvalue->u8[i]) {
3085             ds_put_format(s, "0x%"PRIx8, subvalue->u8[i]);
3086             for (i++; i < ARRAY_SIZE(subvalue->u8); i++) {
3087                 ds_put_format(s, "%02"PRIx8, subvalue->u8[i]);
3088             }
3089             return;
3090         }
3091     }
3092     ds_put_char(s, '0');
3093 }