lib/meta-flow.c

   1 /*
   2  * Copyright (c) 2011, 2012, 2013, 2014 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", 0,
  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", 0,
  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", OFP13_VERSION,
  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", 0,
  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", 0,
 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, 0,
 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, 0,
 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, 0,
 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", OFP12_VERSION,
 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", 0,
 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", OFP12_VERSION,
 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, 0,
 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", 0,
 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, 0,  \
 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", OFP12_VERSION,
 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", OFP12_VERSION,
 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", OFP12_VERSION,
 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", 0,
 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, 0,
 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", OFP12_VERSION,
 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, 0,
 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", OFP12_VERSION,
 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", OFP12_VERSION,
 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", OFP12_VERSION,
 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", OFP13_VERSION,
 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", OFP12_VERSION,
 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", OFP12_VERSION,
 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", OFP12_VERSION,
 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", OFP12_VERSION,
 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", OFP12_VERSION,
 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", OFP12_VERSION,
 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", 0,
 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", OFP12_VERSION,
 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", OFP12_VERSION,
 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", 0,
 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", 0,
 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", OFP12_VERSION,
 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", OFP12_VERSION,
 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", OFP12_VERSION,
 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", OFP12_VERSION,
 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", OFP12_VERSION,
 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", OFP12_VERSION,
 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", OFP12_VERSION,
 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         OXM_OF_TCP_FLAGS, "OXM_OF_TCP_FLAGS", OFP15_VERSION,
 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", OFP12_VERSION,
 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", OFP12_VERSION,
 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", OFP12_VERSION,
 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", OFP12_VERSION,
 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", OFP12_VERSION,
 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", OFP12_VERSION,
 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", OFP12_VERSION,
 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", OFP12_VERSION,
 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", OFP12_VERSION,
 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", OFP12_VERSION,
 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", OFP12_VERSION,
 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 uint32_t
 898 mf_oxm_header(enum mf_field_id id, enum ofp_version oxm_version)
 899 {
 900     const struct mf_field *field = mf_from_id(id);
 901
 902     return (oxm_version >= field->oxm_version
 903             ? field->oxm_header
 904             : field->nxm_header);
 905 }
 906
 907 /* Returns true if 'wc' wildcards all the bits in field 'mf', false if 'wc'
 908  * specifies at least one bit in the field.
 909  *
 910  * The caller is responsible for ensuring that 'wc' corresponds to a flow that
 911  * meets 'mf''s prerequisites. */
 912 bool
 913 mf_is_all_wild(const struct mf_field *mf, const struct flow_wildcards *wc)
 914 {
 915     switch (mf->id) {
 916     case MFF_DP_HASH:
 917         return !wc->masks.dp_hash;
 918     case MFF_RECIRC_ID:
 919         return !wc->masks.recirc_id;
 920     case MFF_TUN_SRC:
 921         return !wc->masks.tunnel.ip_src;
 922     case MFF_TUN_DST:
 923         return !wc->masks.tunnel.ip_dst;
 924     case MFF_TUN_ID:
 925     case MFF_TUN_TOS:
 926     case MFF_TUN_TTL:
 927     case MFF_TUN_FLAGS:
 928         return !wc->masks.tunnel.tun_id;
 929     case MFF_METADATA:
 930         return !wc->masks.metadata;
 931     case MFF_IN_PORT:
 932     case MFF_IN_PORT_OXM:
 933         return !wc->masks.in_port.ofp_port;
 934     case MFF_SKB_PRIORITY:
 935         return !wc->masks.skb_priority;
 936     case MFF_PKT_MARK:
 937         return !wc->masks.pkt_mark;
 938     CASE_MFF_REGS:
 939         return !wc->masks.regs[mf->id - MFF_REG0];
 940
 941     case MFF_ETH_SRC:
 942         return eth_addr_is_zero(wc->masks.dl_src);
 943     case MFF_ETH_DST:
 944         return eth_addr_is_zero(wc->masks.dl_dst);
 945     case MFF_ETH_TYPE:
 946         return !wc->masks.dl_type;
 947
 948     case MFF_ARP_SHA:
 949     case MFF_ND_SLL:
 950         return eth_addr_is_zero(wc->masks.arp_sha);
 951
 952     case MFF_ARP_THA:
 953     case MFF_ND_TLL:
 954         return eth_addr_is_zero(wc->masks.arp_tha);
 955
 956     case MFF_VLAN_TCI:
 957         return !wc->masks.vlan_tci;
 958     case MFF_DL_VLAN:
 959         return !(wc->masks.vlan_tci & htons(VLAN_VID_MASK));
 960     case MFF_VLAN_VID:
 961         return !(wc->masks.vlan_tci & htons(VLAN_VID_MASK | VLAN_CFI));
 962     case MFF_DL_VLAN_PCP:
 963     case MFF_VLAN_PCP:
 964         return !(wc->masks.vlan_tci & htons(VLAN_PCP_MASK));
 965
 966     case MFF_MPLS_LABEL:
 967         return !(wc->masks.mpls_lse[0] & htonl(MPLS_LABEL_MASK));
 968     case MFF_MPLS_TC:
 969         return !(wc->masks.mpls_lse[0] & htonl(MPLS_TC_MASK));
 970     case MFF_MPLS_BOS:
 971         return !(wc->masks.mpls_lse[0] & htonl(MPLS_BOS_MASK));
 972
 973     case MFF_IPV4_SRC:
 974         return !wc->masks.nw_src;
 975     case MFF_IPV4_DST:
 976         return !wc->masks.nw_dst;
 977
 978     case MFF_IPV6_SRC:
 979         return ipv6_mask_is_any(&wc->masks.ipv6_src);
 980     case MFF_IPV6_DST:
 981         return ipv6_mask_is_any(&wc->masks.ipv6_dst);
 982
 983     case MFF_IPV6_LABEL:
 984         return !wc->masks.ipv6_label;
 985
 986     case MFF_IP_PROTO:
 987         return !wc->masks.nw_proto;
 988     case MFF_IP_DSCP:
 989     case MFF_IP_DSCP_SHIFTED:
 990         return !(wc->masks.nw_tos & IP_DSCP_MASK);
 991     case MFF_IP_ECN:
 992         return !(wc->masks.nw_tos & IP_ECN_MASK);
 993     case MFF_IP_TTL:
 994         return !wc->masks.nw_ttl;
 995
 996     case MFF_ND_TARGET:
 997         return ipv6_mask_is_any(&wc->masks.nd_target);
 998
 999     case MFF_IP_FRAG:
1000         return !(wc->masks.nw_frag & FLOW_NW_FRAG_MASK);
1001
1002     case MFF_ARP_OP:
1003         return !wc->masks.nw_proto;
1004     case MFF_ARP_SPA:
1005         return !wc->masks.nw_src;
1006     case MFF_ARP_TPA:
1007         return !wc->masks.nw_dst;
1008
1009     case MFF_TCP_SRC:
1010     case MFF_UDP_SRC:
1011     case MFF_SCTP_SRC:
1012     case MFF_ICMPV4_TYPE:
1013     case MFF_ICMPV6_TYPE:
1014         return !wc->masks.tp_src;
1015     case MFF_TCP_DST:
1016     case MFF_UDP_DST:
1017     case MFF_SCTP_DST:
1018     case MFF_ICMPV4_CODE:
1019     case MFF_ICMPV6_CODE:
1020         return !wc->masks.tp_dst;
1021     case MFF_TCP_FLAGS:
1022         return !wc->masks.tcp_flags;
1023
1024     case MFF_N_IDS:
1025     default:
1026         OVS_NOT_REACHED();
1027     }
1028 }
1029
1030 /* Initializes 'mask' with the wildcard bit pattern for field 'mf' within 'wc'.
1031  * Each bit in 'mask' will be set to 1 if the bit is significant for matching
1032  * purposes, or to 0 if it is wildcarded.
1033  *
1034  * The caller is responsible for ensuring that 'wc' corresponds to a flow that
1035  * meets 'mf''s prerequisites. */
1036 void
1037 mf_get_mask(const struct mf_field *mf, const struct flow_wildcards *wc,
1038             union mf_value *mask)
1039 {
1040     mf_get_value(mf, &wc->masks, mask);
1041 }
1042
1043 /* Tests whether 'mask' is a valid wildcard bit pattern for 'mf'.  Returns true
1044  * if the mask is valid, false otherwise. */
1045 bool
1046 mf_is_mask_valid(const struct mf_field *mf, const union mf_value *mask)
1047 {
1048     switch (mf->maskable) {
1049     case MFM_NONE:
1050         return (is_all_zeros((const uint8_t *) mask, mf->n_bytes) ||
1051                 is_all_ones((const uint8_t *) mask, mf->n_bytes));
1052
1053     case MFM_FULLY:
1054         return true;
1055     }
1056
1057     OVS_NOT_REACHED();
1058 }
1059
1060 /* Returns true if 'flow' meets the prerequisites for 'mf', false otherwise. */
1061 bool
1062 mf_are_prereqs_ok(const struct mf_field *mf, const struct flow *flow)
1063 {
1064     switch (mf->prereqs) {
1065     case MFP_NONE:
1066         return true;
1067
1068     case MFP_ARP:
1069       return (flow->dl_type == htons(ETH_TYPE_ARP) ||
1070               flow->dl_type == htons(ETH_TYPE_RARP));
1071     case MFP_IPV4:
1072         return flow->dl_type == htons(ETH_TYPE_IP);
1073     case MFP_IPV6:
1074         return flow->dl_type == htons(ETH_TYPE_IPV6);
1075     case MFP_VLAN_VID:
1076         return (flow->vlan_tci & htons(VLAN_CFI)) != 0;
1077     case MFP_MPLS:
1078         return eth_type_mpls(flow->dl_type);
1079     case MFP_IP_ANY:
1080         return is_ip_any(flow);
1081
1082     case MFP_TCP:
1083         return is_ip_any(flow) && flow->nw_proto == IPPROTO_TCP;
1084     case MFP_UDP:
1085         return is_ip_any(flow) && flow->nw_proto == IPPROTO_UDP;
1086     case MFP_SCTP:
1087         return is_ip_any(flow) && flow->nw_proto == IPPROTO_SCTP;
1088     case MFP_ICMPV4:
1089         return is_icmpv4(flow);
1090     case MFP_ICMPV6:
1091         return is_icmpv6(flow);
1092
1093     case MFP_ND:
1094         return (is_icmpv6(flow)
1095                 && flow->tp_dst == htons(0)
1096                 && (flow->tp_src == htons(ND_NEIGHBOR_SOLICIT) ||
1097                     flow->tp_src == htons(ND_NEIGHBOR_ADVERT)));
1098     case MFP_ND_SOLICIT:
1099         return (is_icmpv6(flow)
1100                 && flow->tp_dst == htons(0)
1101                 && (flow->tp_src == htons(ND_NEIGHBOR_SOLICIT)));
1102     case MFP_ND_ADVERT:
1103         return (is_icmpv6(flow)
1104                 && flow->tp_dst == htons(0)
1105                 && (flow->tp_src == htons(ND_NEIGHBOR_ADVERT)));
1106     }
1107
1108     OVS_NOT_REACHED();
1109 }
1110
1111 /* Set field and it's prerequisities in the mask.
1112  * This is only ever called for writeable 'mf's, but we do not make the
1113  * distinction here. */
1114 void
1115 mf_mask_field_and_prereqs(const struct mf_field *mf, struct flow *mask)
1116 {
1117     static const union mf_value exact_match_mask = MF_EXACT_MASK_INITIALIZER;
1118
1119     mf_set_flow_value(mf, &exact_match_mask, mask);
1120
1121     switch (mf->prereqs) {
1122     case MFP_ND:
1123     case MFP_ND_SOLICIT:
1124     case MFP_ND_ADVERT:
1125         mask->tp_src = OVS_BE16_MAX;
1126         mask->tp_dst = OVS_BE16_MAX;
1127         /* Fall through. */
1128     case MFP_TCP:
1129     case MFP_UDP:
1130     case MFP_SCTP:
1131     case MFP_ICMPV4:
1132     case MFP_ICMPV6:
1133         mask->nw_proto = 0xff;
1134         /* Fall through. */
1135     case MFP_ARP:
1136     case MFP_IPV4:
1137     case MFP_IPV6:
1138     case MFP_MPLS:
1139     case MFP_IP_ANY:
1140         mask->dl_type = OVS_BE16_MAX;
1141         break;
1142     case MFP_VLAN_VID:
1143         mask->vlan_tci |= htons(VLAN_CFI);
1144         break;
1145     case MFP_NONE:
1146         break;
1147     }
1148 }
1149
1150
1151 /* Returns true if 'value' may be a valid value *as part of a masked match*,
1152  * false otherwise.
1153  *
1154  * A value is not rejected just because it is not valid for the field in
1155  * question, but only if it doesn't make sense to test the bits in question at
1156  * all.  For example, the MFF_VLAN_TCI field will never have a nonzero value
1157  * without the VLAN_CFI bit being set, but we can't reject those values because
1158  * it is still legitimate to test just for those bits (see the documentation
1159  * for NXM_OF_VLAN_TCI in nicira-ext.h).  On the other hand, there is never a
1160  * reason to set the low bit of MFF_IP_DSCP to 1, so we reject that. */
1161 bool
1162 mf_is_value_valid(const struct mf_field *mf, const union mf_value *value)
1163 {
1164     switch (mf->id) {
1165     case MFF_DP_HASH:
1166     case MFF_RECIRC_ID:
1167     case MFF_TUN_ID:
1168     case MFF_TUN_SRC:
1169     case MFF_TUN_DST:
1170     case MFF_TUN_TOS:
1171     case MFF_TUN_TTL:
1172     case MFF_TUN_FLAGS:
1173     case MFF_METADATA:
1174     case MFF_IN_PORT:
1175     case MFF_SKB_PRIORITY:
1176     case MFF_PKT_MARK:
1177     CASE_MFF_REGS:
1178     case MFF_ETH_SRC:
1179     case MFF_ETH_DST:
1180     case MFF_ETH_TYPE:
1181     case MFF_VLAN_TCI:
1182     case MFF_IPV4_SRC:
1183     case MFF_IPV4_DST:
1184     case MFF_IPV6_SRC:
1185     case MFF_IPV6_DST:
1186     case MFF_IP_PROTO:
1187     case MFF_IP_TTL:
1188     case MFF_ARP_SPA:
1189     case MFF_ARP_TPA:
1190     case MFF_ARP_SHA:
1191     case MFF_ARP_THA:
1192     case MFF_TCP_SRC:
1193     case MFF_TCP_DST:
1194     case MFF_UDP_SRC:
1195     case MFF_UDP_DST:
1196     case MFF_SCTP_SRC:
1197     case MFF_SCTP_DST:
1198     case MFF_ICMPV4_TYPE:
1199     case MFF_ICMPV4_CODE:
1200     case MFF_ICMPV6_TYPE:
1201     case MFF_ICMPV6_CODE:
1202     case MFF_ND_TARGET:
1203     case MFF_ND_SLL:
1204     case MFF_ND_TLL:
1205         return true;
1206
1207     case MFF_IN_PORT_OXM: {
1208         ofp_port_t port;
1209         return !ofputil_port_from_ofp11(value->be32, &port);
1210     }
1211
1212     case MFF_IP_DSCP:
1213         return !(value->u8 & ~IP_DSCP_MASK);
1214     case MFF_IP_DSCP_SHIFTED:
1215         return !(value->u8 & (~IP_DSCP_MASK >> 2));
1216     case MFF_IP_ECN:
1217         return !(value->u8 & ~IP_ECN_MASK);
1218     case MFF_IP_FRAG:
1219         return !(value->u8 & ~FLOW_NW_FRAG_MASK);
1220     case MFF_TCP_FLAGS:
1221         return !(value->be16 & ~htons(0x0fff));
1222
1223     case MFF_ARP_OP:
1224         return !(value->be16 & htons(0xff00));
1225
1226     case MFF_DL_VLAN:
1227         return !(value->be16 & htons(VLAN_CFI | VLAN_PCP_MASK));
1228     case MFF_VLAN_VID:
1229         return !(value->be16 & htons(VLAN_PCP_MASK));
1230
1231     case MFF_DL_VLAN_PCP:
1232     case MFF_VLAN_PCP:
1233         return !(value->u8 & ~(VLAN_PCP_MASK >> VLAN_PCP_SHIFT));
1234
1235     case MFF_IPV6_LABEL:
1236         return !(value->be32 & ~htonl(IPV6_LABEL_MASK));
1237
1238     case MFF_MPLS_LABEL:
1239         return !(value->be32 & ~htonl(MPLS_LABEL_MASK >> MPLS_LABEL_SHIFT));
1240
1241     case MFF_MPLS_TC:
1242         return !(value->u8 & ~(MPLS_TC_MASK >> MPLS_TC_SHIFT));
1243
1244     case MFF_MPLS_BOS:
1245         return !(value->u8 & ~(MPLS_BOS_MASK >> MPLS_BOS_SHIFT));
1246
1247     case MFF_N_IDS:
1248     default:
1249         OVS_NOT_REACHED();
1250     }
1251 }
1252
1253 /* Copies the value of field 'mf' from 'flow' into 'value'.  The caller is
1254  * responsible for ensuring that 'flow' meets 'mf''s prerequisites. */
1255 void
1256 mf_get_value(const struct mf_field *mf, const struct flow *flow,
1257              union mf_value *value)
1258 {
1259     switch (mf->id) {
1260     case MFF_DP_HASH:
1261         value->be32 = htonl(flow->dp_hash);
1262         break;
1263     case MFF_RECIRC_ID:
1264         value->be32 = htonl(flow->recirc_id);
1265         break;
1266     case MFF_TUN_ID:
1267         value->be64 = flow->tunnel.tun_id;
1268         break;
1269     case MFF_TUN_SRC:
1270         value->be32 = flow->tunnel.ip_src;
1271         break;
1272     case MFF_TUN_DST:
1273         value->be32 = flow->tunnel.ip_dst;
1274         break;
1275     case MFF_TUN_FLAGS:
1276         value->be16 = htons(flow->tunnel.flags);
1277         break;
1278     case MFF_TUN_TTL:
1279         value->u8 = flow->tunnel.ip_ttl;
1280         break;
1281     case MFF_TUN_TOS:
1282         value->u8 = flow->tunnel.ip_tos;
1283         break;
1284
1285     case MFF_METADATA:
1286         value->be64 = flow->metadata;
1287         break;
1288
1289     case MFF_IN_PORT:
1290         value->be16 = htons(ofp_to_u16(flow->in_port.ofp_port));
1291         break;
1292     case MFF_IN_PORT_OXM:
1293         value->be32 = ofputil_port_to_ofp11(flow->in_port.ofp_port);
1294         break;
1295
1296     case MFF_SKB_PRIORITY:
1297         value->be32 = htonl(flow->skb_priority);
1298         break;
1299
1300     case MFF_PKT_MARK:
1301         value->be32 = htonl(flow->pkt_mark);
1302         break;
1303
1304     CASE_MFF_REGS:
1305         value->be32 = htonl(flow->regs[mf->id - MFF_REG0]);
1306         break;
1307
1308     case MFF_ETH_SRC:
1309         memcpy(value->mac, flow->dl_src, ETH_ADDR_LEN);
1310         break;
1311
1312     case MFF_ETH_DST:
1313         memcpy(value->mac, flow->dl_dst, ETH_ADDR_LEN);
1314         break;
1315
1316     case MFF_ETH_TYPE:
1317         value->be16 = flow->dl_type;
1318         break;
1319
1320     case MFF_VLAN_TCI:
1321         value->be16 = flow->vlan_tci;
1322         break;
1323
1324     case MFF_DL_VLAN:
1325         value->be16 = flow->vlan_tci & htons(VLAN_VID_MASK);
1326         break;
1327     case MFF_VLAN_VID:
1328         value->be16 = flow->vlan_tci & htons(VLAN_VID_MASK | VLAN_CFI);
1329         break;
1330
1331     case MFF_DL_VLAN_PCP:
1332     case MFF_VLAN_PCP:
1333         value->u8 = vlan_tci_to_pcp(flow->vlan_tci);
1334         break;
1335
1336     case MFF_MPLS_LABEL:
1337         value->be32 = htonl(mpls_lse_to_label(flow->mpls_lse[0]));
1338         break;
1339
1340     case MFF_MPLS_TC:
1341         value->u8 = mpls_lse_to_tc(flow->mpls_lse[0]);
1342         break;
1343
1344     case MFF_MPLS_BOS:
1345         value->u8 = mpls_lse_to_bos(flow->mpls_lse[0]);
1346         break;
1347
1348     case MFF_IPV4_SRC:
1349         value->be32 = flow->nw_src;
1350         break;
1351
1352     case MFF_IPV4_DST:
1353         value->be32 = flow->nw_dst;
1354         break;
1355
1356     case MFF_IPV6_SRC:
1357         value->ipv6 = flow->ipv6_src;
1358         break;
1359
1360     case MFF_IPV6_DST:
1361         value->ipv6 = flow->ipv6_dst;
1362         break;
1363
1364     case MFF_IPV6_LABEL:
1365         value->be32 = flow->ipv6_label;
1366         break;
1367
1368     case MFF_IP_PROTO:
1369         value->u8 = flow->nw_proto;
1370         break;
1371
1372     case MFF_IP_DSCP:
1373         value->u8 = flow->nw_tos & IP_DSCP_MASK;
1374         break;
1375
1376     case MFF_IP_DSCP_SHIFTED:
1377         value->u8 = flow->nw_tos >> 2;
1378         break;
1379
1380     case MFF_IP_ECN:
1381         value->u8 = flow->nw_tos & IP_ECN_MASK;
1382         break;
1383
1384     case MFF_IP_TTL:
1385         value->u8 = flow->nw_ttl;
1386         break;
1387
1388     case MFF_IP_FRAG:
1389         value->u8 = flow->nw_frag;
1390         break;
1391
1392     case MFF_ARP_OP:
1393         value->be16 = htons(flow->nw_proto);
1394         break;
1395
1396     case MFF_ARP_SPA:
1397         value->be32 = flow->nw_src;
1398         break;
1399
1400     case MFF_ARP_TPA:
1401         value->be32 = flow->nw_dst;
1402         break;
1403
1404     case MFF_ARP_SHA:
1405     case MFF_ND_SLL:
1406         memcpy(value->mac, flow->arp_sha, ETH_ADDR_LEN);
1407         break;
1408
1409     case MFF_ARP_THA:
1410     case MFF_ND_TLL:
1411         memcpy(value->mac, flow->arp_tha, ETH_ADDR_LEN);
1412         break;
1413
1414     case MFF_TCP_SRC:
1415     case MFF_UDP_SRC:
1416     case MFF_SCTP_SRC:
1417         value->be16 = flow->tp_src;
1418         break;
1419
1420     case MFF_TCP_DST:
1421     case MFF_UDP_DST:
1422     case MFF_SCTP_DST:
1423         value->be16 = flow->tp_dst;
1424         break;
1425
1426     case MFF_TCP_FLAGS:
1427         value->be16 = flow->tcp_flags;
1428         break;
1429
1430     case MFF_ICMPV4_TYPE:
1431     case MFF_ICMPV6_TYPE:
1432         value->u8 = ntohs(flow->tp_src);
1433         break;
1434
1435     case MFF_ICMPV4_CODE:
1436     case MFF_ICMPV6_CODE:
1437         value->u8 = ntohs(flow->tp_dst);
1438         break;
1439
1440     case MFF_ND_TARGET:
1441         value->ipv6 = flow->nd_target;
1442         break;
1443
1444     case MFF_N_IDS:
1445     default:
1446         OVS_NOT_REACHED();
1447     }
1448 }
1449
1450 /* Makes 'match' match field 'mf' exactly, with the value matched taken from
1451  * 'value'.  The caller is responsible for ensuring that 'match' meets 'mf''s
1452  * prerequisites. */
1453 void
1454 mf_set_value(const struct mf_field *mf,
1455              const union mf_value *value, struct match *match)
1456 {
1457     switch (mf->id) {
1458     case MFF_DP_HASH:
1459         match_set_dp_hash(match, ntohl(value->be32));
1460         break;
1461     case MFF_RECIRC_ID:
1462         match_set_recirc_id(match, ntohl(value->be32));
1463         break;
1464     case MFF_TUN_ID:
1465         match_set_tun_id(match, value->be64);
1466         break;
1467     case MFF_TUN_SRC:
1468         match_set_tun_src(match, value->be32);
1469         break;
1470     case MFF_TUN_DST:
1471         match_set_tun_dst(match, value->be32);
1472         break;
1473     case MFF_TUN_FLAGS:
1474         match_set_tun_flags(match, ntohs(value->be16));
1475         break;
1476     case MFF_TUN_TOS:
1477         match_set_tun_tos(match, value->u8);
1478         break;
1479     case MFF_TUN_TTL:
1480         match_set_tun_ttl(match, value->u8);
1481         break;
1482
1483     case MFF_METADATA:
1484         match_set_metadata(match, value->be64);
1485         break;
1486
1487     case MFF_IN_PORT:
1488         match_set_in_port(match, u16_to_ofp(ntohs(value->be16)));
1489         break;
1490
1491     case MFF_IN_PORT_OXM: {
1492         ofp_port_t port;
1493         ofputil_port_from_ofp11(value->be32, &port);
1494         match_set_in_port(match, port);
1495         break;
1496     }
1497
1498     case MFF_SKB_PRIORITY:
1499         match_set_skb_priority(match, ntohl(value->be32));
1500         break;
1501
1502     case MFF_PKT_MARK:
1503         match_set_pkt_mark(match, ntohl(value->be32));
1504         break;
1505
1506     CASE_MFF_REGS:
1507         match_set_reg(match, mf->id - MFF_REG0, ntohl(value->be32));
1508         break;
1509
1510     case MFF_ETH_SRC:
1511         match_set_dl_src(match, value->mac);
1512         break;
1513
1514     case MFF_ETH_DST:
1515         match_set_dl_dst(match, value->mac);
1516         break;
1517
1518     case MFF_ETH_TYPE:
1519         match_set_dl_type(match, value->be16);
1520         break;
1521
1522     case MFF_VLAN_TCI:
1523         match_set_dl_tci(match, value->be16);
1524         break;
1525
1526     case MFF_DL_VLAN:
1527         match_set_dl_vlan(match, value->be16);
1528         break;
1529     case MFF_VLAN_VID:
1530         match_set_vlan_vid(match, value->be16);
1531         break;
1532
1533     case MFF_DL_VLAN_PCP:
1534     case MFF_VLAN_PCP:
1535         match_set_dl_vlan_pcp(match, value->u8);
1536         break;
1537
1538     case MFF_MPLS_LABEL:
1539         match_set_mpls_label(match, 0, value->be32);
1540         break;
1541
1542     case MFF_MPLS_TC:
1543         match_set_mpls_tc(match, 0, value->u8);
1544         break;
1545
1546     case MFF_MPLS_BOS:
1547         match_set_mpls_bos(match, 0, value->u8);
1548         break;
1549
1550     case MFF_IPV4_SRC:
1551         match_set_nw_src(match, value->be32);
1552         break;
1553
1554     case MFF_IPV4_DST:
1555         match_set_nw_dst(match, value->be32);
1556         break;
1557
1558     case MFF_IPV6_SRC:
1559         match_set_ipv6_src(match, &value->ipv6);
1560         break;
1561
1562     case MFF_IPV6_DST:
1563         match_set_ipv6_dst(match, &value->ipv6);
1564         break;
1565
1566     case MFF_IPV6_LABEL:
1567         match_set_ipv6_label(match, value->be32);
1568         break;
1569
1570     case MFF_IP_PROTO:
1571         match_set_nw_proto(match, value->u8);
1572         break;
1573
1574     case MFF_IP_DSCP:
1575         match_set_nw_dscp(match, value->u8);
1576         break;
1577
1578     case MFF_IP_DSCP_SHIFTED:
1579         match_set_nw_dscp(match, value->u8 << 2);
1580         break;
1581
1582     case MFF_IP_ECN:
1583         match_set_nw_ecn(match, value->u8);
1584         break;
1585
1586     case MFF_IP_TTL:
1587         match_set_nw_ttl(match, value->u8);
1588         break;
1589
1590     case MFF_IP_FRAG:
1591         match_set_nw_frag(match, value->u8);
1592         break;
1593
1594     case MFF_ARP_OP:
1595         match_set_nw_proto(match, ntohs(value->be16));
1596         break;
1597
1598     case MFF_ARP_SPA:
1599         match_set_nw_src(match, value->be32);
1600         break;
1601
1602     case MFF_ARP_TPA:
1603         match_set_nw_dst(match, value->be32);
1604         break;
1605
1606     case MFF_ARP_SHA:
1607     case MFF_ND_SLL:
1608         match_set_arp_sha(match, value->mac);
1609         break;
1610
1611     case MFF_ARP_THA:
1612     case MFF_ND_TLL:
1613         match_set_arp_tha(match, value->mac);
1614         break;
1615
1616     case MFF_TCP_SRC:
1617     case MFF_UDP_SRC:
1618     case MFF_SCTP_SRC:
1619         match_set_tp_src(match, value->be16);
1620         break;
1621
1622     case MFF_TCP_DST:
1623     case MFF_UDP_DST:
1624     case MFF_SCTP_DST:
1625         match_set_tp_dst(match, value->be16);
1626         break;
1627
1628     case MFF_TCP_FLAGS:
1629         match_set_tcp_flags(match, value->be16);
1630         break;
1631
1632     case MFF_ICMPV4_TYPE:
1633     case MFF_ICMPV6_TYPE:
1634         match_set_icmp_type(match, value->u8);
1635         break;
1636
1637     case MFF_ICMPV4_CODE:
1638     case MFF_ICMPV6_CODE:
1639         match_set_icmp_code(match, value->u8);
1640         break;
1641
1642     case MFF_ND_TARGET:
1643         match_set_nd_target(match, &value->ipv6);
1644         break;
1645
1646     case MFF_N_IDS:
1647     default:
1648         OVS_NOT_REACHED();
1649     }
1650 }
1651
1652 /* Unwildcard 'mask' member field described by 'mf'.  The caller is
1653  * responsible for ensuring that 'mask' meets 'mf''s prerequisites. */
1654 void
1655 mf_mask_field(const struct mf_field *mf, struct flow *mask)
1656 {
1657     static const union mf_value exact_match_mask = MF_EXACT_MASK_INITIALIZER;
1658
1659     /* For MFF_DL_VLAN, we cannot send a all 1's to flow_set_dl_vlan()
1660      * as that will be considered as OFP10_VLAN_NONE. So consider it as a
1661      * special case. For the rest, calling mf_set_flow_value() is good
1662      * enough. */
1663     if (mf->id == MFF_DL_VLAN) {
1664         flow_set_dl_vlan(mask, htons(VLAN_VID_MASK));
1665     } else {
1666         mf_set_flow_value(mf, &exact_match_mask, mask);
1667     }
1668 }
1669
1670 /* Sets 'flow' member field described by 'mf' to 'value'.  The caller is
1671  * responsible for ensuring that 'flow' meets 'mf''s prerequisites.*/
1672 void
1673 mf_set_flow_value(const struct mf_field *mf,
1674                   const union mf_value *value, struct flow *flow)
1675 {
1676     switch (mf->id) {
1677     case MFF_DP_HASH:
1678         flow->dp_hash = ntohl(value->be32);
1679         break;
1680     case MFF_RECIRC_ID:
1681         flow->recirc_id = ntohl(value->be32);
1682         break;
1683     case MFF_TUN_ID:
1684         flow->tunnel.tun_id = value->be64;
1685         break;
1686     case MFF_TUN_SRC:
1687         flow->tunnel.ip_src = value->be32;
1688         break;
1689     case MFF_TUN_DST:
1690         flow->tunnel.ip_dst = value->be32;
1691         break;
1692     case MFF_TUN_FLAGS:
1693         flow->tunnel.flags = ntohs(value->be16);
1694         break;
1695     case MFF_TUN_TOS:
1696         flow->tunnel.ip_tos = value->u8;
1697         break;
1698     case MFF_TUN_TTL:
1699         flow->tunnel.ip_ttl = value->u8;
1700         break;
1701
1702     case MFF_METADATA:
1703         flow->metadata = value->be64;
1704         break;
1705
1706     case MFF_IN_PORT:
1707         flow->in_port.ofp_port = u16_to_ofp(ntohs(value->be16));
1708         break;
1709
1710     case MFF_IN_PORT_OXM: {
1711         ofp_port_t port;
1712         ofputil_port_from_ofp11(value->be32, &port);
1713         flow->in_port.ofp_port = port;
1714         break;
1715     }
1716
1717     case MFF_SKB_PRIORITY:
1718         flow->skb_priority = ntohl(value->be32);
1719         break;
1720
1721     case MFF_PKT_MARK:
1722         flow->pkt_mark = ntohl(value->be32);
1723         break;
1724
1725     CASE_MFF_REGS:
1726         flow->regs[mf->id - MFF_REG0] = ntohl(value->be32);
1727         break;
1728
1729     case MFF_ETH_SRC:
1730         memcpy(flow->dl_src, value->mac, ETH_ADDR_LEN);
1731         break;
1732
1733     case MFF_ETH_DST:
1734         memcpy(flow->dl_dst, value->mac, ETH_ADDR_LEN);
1735         break;
1736
1737     case MFF_ETH_TYPE:
1738         flow->dl_type = value->be16;
1739         break;
1740
1741     case MFF_VLAN_TCI:
1742         flow->vlan_tci = value->be16;
1743         break;
1744
1745     case MFF_DL_VLAN:
1746         flow_set_dl_vlan(flow, value->be16);
1747         break;
1748     case MFF_VLAN_VID:
1749         flow_set_vlan_vid(flow, value->be16);
1750         break;
1751
1752     case MFF_DL_VLAN_PCP:
1753     case MFF_VLAN_PCP:
1754         flow_set_vlan_pcp(flow, value->u8);
1755         break;
1756
1757     case MFF_MPLS_LABEL:
1758         flow_set_mpls_label(flow, 0, value->be32);
1759         break;
1760
1761     case MFF_MPLS_TC:
1762         flow_set_mpls_tc(flow, 0, value->u8);
1763         break;
1764
1765     case MFF_MPLS_BOS:
1766         flow_set_mpls_bos(flow, 0, value->u8);
1767         break;
1768
1769     case MFF_IPV4_SRC:
1770         flow->nw_src = value->be32;
1771         break;
1772
1773     case MFF_IPV4_DST:
1774         flow->nw_dst = value->be32;
1775         break;
1776
1777     case MFF_IPV6_SRC:
1778         flow->ipv6_src = value->ipv6;
1779         break;
1780
1781     case MFF_IPV6_DST:
1782         flow->ipv6_dst = value->ipv6;
1783         break;
1784
1785     case MFF_IPV6_LABEL:
1786         flow->ipv6_label = value->be32 & ~htonl(IPV6_LABEL_MASK);
1787         break;
1788
1789     case MFF_IP_PROTO:
1790         flow->nw_proto = value->u8;
1791         break;
1792
1793     case MFF_IP_DSCP:
1794         flow->nw_tos &= ~IP_DSCP_MASK;
1795         flow->nw_tos |= value->u8 & IP_DSCP_MASK;
1796         break;
1797
1798     case MFF_IP_DSCP_SHIFTED:
1799         flow->nw_tos &= ~IP_DSCP_MASK;
1800         flow->nw_tos |= value->u8 << 2;
1801         break;
1802
1803     case MFF_IP_ECN:
1804         flow->nw_tos &= ~IP_ECN_MASK;
1805         flow->nw_tos |= value->u8 & IP_ECN_MASK;
1806         break;
1807
1808     case MFF_IP_TTL:
1809         flow->nw_ttl = value->u8;
1810         break;
1811
1812     case MFF_IP_FRAG:
1813         flow->nw_frag = value->u8 & FLOW_NW_FRAG_MASK;
1814         break;
1815
1816     case MFF_ARP_OP:
1817         flow->nw_proto = ntohs(value->be16);
1818         break;
1819
1820     case MFF_ARP_SPA:
1821         flow->nw_src = value->be32;
1822         break;
1823
1824     case MFF_ARP_TPA:
1825         flow->nw_dst = value->be32;
1826         break;
1827
1828     case MFF_ARP_SHA:
1829     case MFF_ND_SLL:
1830         memcpy(flow->arp_sha, value->mac, ETH_ADDR_LEN);
1831         break;
1832
1833     case MFF_ARP_THA:
1834     case MFF_ND_TLL:
1835         memcpy(flow->arp_tha, value->mac, ETH_ADDR_LEN);
1836         break;
1837
1838     case MFF_TCP_SRC:
1839     case MFF_UDP_SRC:
1840     case MFF_SCTP_SRC:
1841         flow->tp_src = value->be16;
1842         break;
1843
1844     case MFF_TCP_DST:
1845     case MFF_UDP_DST:
1846     case MFF_SCTP_DST:
1847         flow->tp_dst = value->be16;
1848         break;
1849
1850     case MFF_TCP_FLAGS:
1851         flow->tcp_flags = value->be16;
1852         break;
1853
1854     case MFF_ICMPV4_TYPE:
1855     case MFF_ICMPV6_TYPE:
1856         flow->tp_src = htons(value->u8);
1857         break;
1858
1859     case MFF_ICMPV4_CODE:
1860     case MFF_ICMPV6_CODE:
1861         flow->tp_dst = htons(value->u8);
1862         break;
1863
1864     case MFF_ND_TARGET:
1865         flow->nd_target = value->ipv6;
1866         break;
1867
1868     case MFF_N_IDS:
1869     default:
1870         OVS_NOT_REACHED();
1871     }
1872 }
1873
1874 /* Returns true if 'mf' has a zero value in 'flow', false if it is nonzero.
1875  *
1876  * The caller is responsible for ensuring that 'flow' meets 'mf''s
1877  * prerequisites. */
1878 bool
1879 mf_is_zero(const struct mf_field *mf, const struct flow *flow)
1880 {
1881     union mf_value value;
1882
1883     mf_get_value(mf, flow, &value);
1884     return is_all_zeros((const uint8_t *) &value, mf->n_bytes);
1885 }
1886
1887 /* Makes 'match' wildcard field 'mf'.
1888  *
1889  * The caller is responsible for ensuring that 'match' meets 'mf''s
1890  * prerequisites. */
1891 void
1892 mf_set_wild(const struct mf_field *mf, struct match *match)
1893 {
1894     switch (mf->id) {
1895     case MFF_DP_HASH:
1896         match->flow.dp_hash = 0;
1897         match->wc.masks.dp_hash = 0;
1898         break;
1899     case MFF_RECIRC_ID:
1900         match->flow.recirc_id = 0;
1901         match->wc.masks.recirc_id = 0;
1902         break;
1903     case MFF_TUN_ID:
1904         match_set_tun_id_masked(match, htonll(0), htonll(0));
1905         break;
1906     case MFF_TUN_SRC:
1907         match_set_tun_src_masked(match, htonl(0), htonl(0));
1908         break;
1909     case MFF_TUN_DST:
1910         match_set_tun_dst_masked(match, htonl(0), htonl(0));
1911         break;
1912     case MFF_TUN_FLAGS:
1913         match_set_tun_flags_masked(match, 0, 0);
1914         break;
1915     case MFF_TUN_TOS:
1916         match_set_tun_tos_masked(match, 0, 0);
1917         break;
1918     case MFF_TUN_TTL:
1919         match_set_tun_ttl_masked(match, 0, 0);
1920         break;
1921
1922     case MFF_METADATA:
1923         match_set_metadata_masked(match, htonll(0), htonll(0));
1924         break;
1925
1926     case MFF_IN_PORT:
1927     case MFF_IN_PORT_OXM:
1928         match->flow.in_port.ofp_port = 0;
1929         match->wc.masks.in_port.ofp_port = 0;
1930         break;
1931
1932     case MFF_SKB_PRIORITY:
1933         match->flow.skb_priority = 0;
1934         match->wc.masks.skb_priority = 0;
1935         break;
1936
1937     case MFF_PKT_MARK:
1938         match->flow.pkt_mark = 0;
1939         match->wc.masks.pkt_mark = 0;
1940         break;
1941
1942     CASE_MFF_REGS:
1943         match_set_reg_masked(match, mf->id - MFF_REG0, 0, 0);
1944         break;
1945
1946     case MFF_ETH_SRC:
1947         memset(match->flow.dl_src, 0, ETH_ADDR_LEN);
1948         memset(match->wc.masks.dl_src, 0, ETH_ADDR_LEN);
1949         break;
1950
1951     case MFF_ETH_DST:
1952         memset(match->flow.dl_dst, 0, ETH_ADDR_LEN);
1953         memset(match->wc.masks.dl_dst, 0, ETH_ADDR_LEN);
1954         break;
1955
1956     case MFF_ETH_TYPE:
1957         match->flow.dl_type = htons(0);
1958         match->wc.masks.dl_type = htons(0);
1959         break;
1960
1961     case MFF_VLAN_TCI:
1962         match_set_dl_tci_masked(match, htons(0), htons(0));
1963         break;
1964
1965     case MFF_DL_VLAN:
1966     case MFF_VLAN_VID:
1967         match_set_any_vid(match);
1968         break;
1969
1970     case MFF_DL_VLAN_PCP:
1971     case MFF_VLAN_PCP:
1972         match_set_any_pcp(match);
1973         break;
1974
1975     case MFF_MPLS_LABEL:
1976         match_set_any_mpls_label(match, 0);
1977         break;
1978
1979     case MFF_MPLS_TC:
1980         match_set_any_mpls_tc(match, 0);
1981         break;
1982
1983     case MFF_MPLS_BOS:
1984         match_set_any_mpls_bos(match, 0);
1985         break;
1986
1987     case MFF_IPV4_SRC:
1988     case MFF_ARP_SPA:
1989         match_set_nw_src_masked(match, htonl(0), htonl(0));
1990         break;
1991
1992     case MFF_IPV4_DST:
1993     case MFF_ARP_TPA:
1994         match_set_nw_dst_masked(match, htonl(0), htonl(0));
1995         break;
1996
1997     case MFF_IPV6_SRC:
1998         memset(&match->wc.masks.ipv6_src, 0, sizeof match->wc.masks.ipv6_src);
1999         memset(&match->flow.ipv6_src, 0, sizeof match->flow.ipv6_src);
2000         break;
2001
2002     case MFF_IPV6_DST:
2003         memset(&match->wc.masks.ipv6_dst, 0, sizeof match->wc.masks.ipv6_dst);
2004         memset(&match->flow.ipv6_dst, 0, sizeof match->flow.ipv6_dst);
2005         break;
2006
2007     case MFF_IPV6_LABEL:
2008         match->wc.masks.ipv6_label = htonl(0);
2009         match->flow.ipv6_label = htonl(0);
2010         break;
2011
2012     case MFF_IP_PROTO:
2013         match->wc.masks.nw_proto = 0;
2014         match->flow.nw_proto = 0;
2015         break;
2016
2017     case MFF_IP_DSCP:
2018     case MFF_IP_DSCP_SHIFTED:
2019         match->wc.masks.nw_tos &= ~IP_DSCP_MASK;
2020         match->flow.nw_tos &= ~IP_DSCP_MASK;
2021         break;
2022
2023     case MFF_IP_ECN:
2024         match->wc.masks.nw_tos &= ~IP_ECN_MASK;
2025         match->flow.nw_tos &= ~IP_ECN_MASK;
2026         break;
2027
2028     case MFF_IP_TTL:
2029         match->wc.masks.nw_ttl = 0;
2030         match->flow.nw_ttl = 0;
2031         break;
2032
2033     case MFF_IP_FRAG:
2034         match->wc.masks.nw_frag |= FLOW_NW_FRAG_MASK;
2035         match->flow.nw_frag &= ~FLOW_NW_FRAG_MASK;
2036         break;
2037
2038     case MFF_ARP_OP:
2039         match->wc.masks.nw_proto = 0;
2040         match->flow.nw_proto = 0;
2041         break;
2042
2043     case MFF_ARP_SHA:
2044     case MFF_ND_SLL:
2045         memset(match->flow.arp_sha, 0, ETH_ADDR_LEN);
2046         memset(match->wc.masks.arp_sha, 0, ETH_ADDR_LEN);
2047         break;
2048
2049     case MFF_ARP_THA:
2050     case MFF_ND_TLL:
2051         memset(match->flow.arp_tha, 0, ETH_ADDR_LEN);
2052         memset(match->wc.masks.arp_tha, 0, ETH_ADDR_LEN);
2053         break;
2054
2055     case MFF_TCP_SRC:
2056     case MFF_UDP_SRC:
2057     case MFF_SCTP_SRC:
2058     case MFF_ICMPV4_TYPE:
2059     case MFF_ICMPV6_TYPE:
2060         match->wc.masks.tp_src = htons(0);
2061         match->flow.tp_src = htons(0);
2062         break;
2063
2064     case MFF_TCP_DST:
2065     case MFF_UDP_DST:
2066     case MFF_SCTP_DST:
2067     case MFF_ICMPV4_CODE:
2068     case MFF_ICMPV6_CODE:
2069         match->wc.masks.tp_dst = htons(0);
2070         match->flow.tp_dst = htons(0);
2071         break;
2072
2073     case MFF_TCP_FLAGS:
2074         match->wc.masks.tcp_flags = htons(0);
2075         match->flow.tcp_flags = htons(0);
2076         break;
2077
2078     case MFF_ND_TARGET:
2079         memset(&match->wc.masks.nd_target, 0,
2080                sizeof match->wc.masks.nd_target);
2081         memset(&match->flow.nd_target, 0, sizeof match->flow.nd_target);
2082         break;
2083
2084     case MFF_N_IDS:
2085     default:
2086         OVS_NOT_REACHED();
2087     }
2088 }
2089
2090 /* Makes 'match' match field 'mf' with the specified 'value' and 'mask'.
2091  * 'value' specifies a value to match and 'mask' specifies a wildcard pattern,
2092  * with a 1-bit indicating that the corresponding value bit must match and a
2093  * 0-bit indicating a don't-care.
2094  *
2095  * If 'mask' is NULL or points to all-1-bits, then this call is equivalent to
2096  * mf_set_value(mf, value, match).  If 'mask' points to all-0-bits, then this
2097  * call is equivalent to mf_set_wild(mf, match).
2098  *
2099  * 'mask' must be a valid mask for 'mf' (see mf_is_mask_valid()).  The caller
2100  * is responsible for ensuring that 'match' meets 'mf''s prerequisites. */
2101 enum ofputil_protocol
2102 mf_set(const struct mf_field *mf,
2103        const union mf_value *value, const union mf_value *mask,
2104        struct match *match)
2105 {
2106     if (!mask || is_all_ones((const uint8_t *) mask, mf->n_bytes)) {
2107         mf_set_value(mf, value, match);
2108         return mf->usable_protocols;
2109     } else if (is_all_zeros((const uint8_t *) mask, mf->n_bytes)) {
2110         mf_set_wild(mf, match);
2111         return OFPUTIL_P_ANY;
2112     }
2113
2114     switch (mf->id) {
2115     case MFF_RECIRC_ID:
2116     case MFF_IN_PORT:
2117     case MFF_IN_PORT_OXM:
2118     case MFF_SKB_PRIORITY:
2119     case MFF_ETH_TYPE:
2120     case MFF_DL_VLAN:
2121     case MFF_DL_VLAN_PCP:
2122     case MFF_VLAN_PCP:
2123     case MFF_MPLS_LABEL:
2124     case MFF_MPLS_TC:
2125     case MFF_MPLS_BOS:
2126     case MFF_IP_PROTO:
2127     case MFF_IP_TTL:
2128     case MFF_IP_DSCP:
2129     case MFF_IP_DSCP_SHIFTED:
2130     case MFF_IP_ECN:
2131     case MFF_ARP_OP:
2132     case MFF_ICMPV4_TYPE:
2133     case MFF_ICMPV4_CODE:
2134     case MFF_ICMPV6_TYPE:
2135     case MFF_ICMPV6_CODE:
2136         return OFPUTIL_P_NONE;
2137
2138     case MFF_DP_HASH:
2139         match_set_dp_hash_masked(match, ntohl(value->be32), ntohl(mask->be32));
2140         break;
2141     case MFF_TUN_ID:
2142         match_set_tun_id_masked(match, value->be64, mask->be64);
2143         break;
2144     case MFF_TUN_SRC:
2145         match_set_tun_src_masked(match, value->be32, mask->be32);
2146         break;
2147     case MFF_TUN_DST:
2148         match_set_tun_dst_masked(match, value->be32, mask->be32);
2149         break;
2150     case MFF_TUN_FLAGS:
2151         match_set_tun_flags_masked(match, ntohs(value->be16), ntohs(mask->be16));
2152         break;
2153     case MFF_TUN_TTL:
2154         match_set_tun_ttl_masked(match, value->u8, mask->u8);
2155         break;
2156     case MFF_TUN_TOS:
2157         match_set_tun_tos_masked(match, value->u8, mask->u8);
2158         break;
2159
2160     case MFF_METADATA:
2161         match_set_metadata_masked(match, value->be64, mask->be64);
2162         break;
2163
2164     CASE_MFF_REGS:
2165         match_set_reg_masked(match, mf->id - MFF_REG0,
2166                              ntohl(value->be32), ntohl(mask->be32));
2167         break;
2168
2169     case MFF_PKT_MARK:
2170         match_set_pkt_mark_masked(match, ntohl(value->be32),
2171                                   ntohl(mask->be32));
2172         break;
2173
2174     case MFF_ETH_DST:
2175         match_set_dl_dst_masked(match, value->mac, mask->mac);
2176         break;
2177
2178     case MFF_ETH_SRC:
2179         match_set_dl_src_masked(match, value->mac, mask->mac);
2180         break;
2181
2182     case MFF_ARP_SHA:
2183     case MFF_ND_SLL:
2184         match_set_arp_sha_masked(match, value->mac, mask->mac);
2185         break;
2186
2187     case MFF_ARP_THA:
2188     case MFF_ND_TLL:
2189         match_set_arp_tha_masked(match, value->mac, mask->mac);
2190         break;
2191
2192     case MFF_VLAN_TCI:
2193         match_set_dl_tci_masked(match, value->be16, mask->be16);
2194         break;
2195
2196     case MFF_VLAN_VID:
2197         match_set_vlan_vid_masked(match, value->be16, mask->be16);
2198         break;
2199
2200     case MFF_IPV4_SRC:
2201         match_set_nw_src_masked(match, value->be32, mask->be32);
2202         goto cidr_check;
2203
2204     case MFF_IPV4_DST:
2205         match_set_nw_dst_masked(match, value->be32, mask->be32);
2206         goto cidr_check;
2207
2208     case MFF_IPV6_SRC:
2209         match_set_ipv6_src_masked(match, &value->ipv6, &mask->ipv6);
2210         break;
2211
2212     case MFF_IPV6_DST:
2213         match_set_ipv6_dst_masked(match, &value->ipv6, &mask->ipv6);
2214         break;
2215
2216     case MFF_IPV6_LABEL:
2217         if ((mask->be32 & htonl(IPV6_LABEL_MASK)) == htonl(IPV6_LABEL_MASK)) {
2218             mf_set_value(mf, value, match);
2219         } else {
2220             match_set_ipv6_label_masked(match, value->be32, mask->be32);
2221         }
2222         break;
2223
2224     case MFF_ND_TARGET:
2225         match_set_nd_target_masked(match, &value->ipv6, &mask->ipv6);
2226         break;
2227
2228     case MFF_IP_FRAG:
2229         match_set_nw_frag_masked(match, value->u8, mask->u8);
2230         break;
2231
2232     case MFF_ARP_SPA:
2233         match_set_nw_src_masked(match, value->be32, mask->be32);
2234         goto cidr_check;
2235
2236     case MFF_ARP_TPA:
2237         match_set_nw_dst_masked(match, value->be32, mask->be32);
2238         goto cidr_check;
2239
2240     case MFF_TCP_SRC:
2241     case MFF_UDP_SRC:
2242     case MFF_SCTP_SRC:
2243         match_set_tp_src_masked(match, value->be16, mask->be16);
2244         break;
2245
2246     case MFF_TCP_DST:
2247     case MFF_UDP_DST:
2248     case MFF_SCTP_DST:
2249         match_set_tp_dst_masked(match, value->be16, mask->be16);
2250         break;
2251
2252     case MFF_TCP_FLAGS:
2253         match_set_tcp_flags_masked(match, value->be16, mask->be16);
2254         break;
2255
2256     case MFF_N_IDS:
2257     default:
2258         OVS_NOT_REACHED();
2259     }
2260
2261     return mf->usable_protocols_bitwise;
2262
2263 cidr_check:
2264     return ip_is_cidr(mask->be32) ? mf->usable_protocols :
2265             mf->usable_protocols_bitwise;
2266 }
2267
2268 static enum ofperr
2269 mf_check__(const struct mf_subfield *sf, const struct flow *flow,
2270            const char *type)
2271 {
2272     if (!sf->field) {
2273         VLOG_WARN_RL(&rl, "unknown %s field", type);
2274         return OFPERR_OFPBAC_BAD_SET_TYPE;
2275     } else if (!sf->n_bits) {
2276         VLOG_WARN_RL(&rl, "zero bit %s field %s", type, sf->field->name);
2277         return OFPERR_OFPBAC_BAD_SET_LEN;
2278     } else if (sf->ofs >= sf->field->n_bits) {
2279         VLOG_WARN_RL(&rl, "bit offset %d exceeds %d-bit width of %s field %s",
2280                      sf->ofs, sf->field->n_bits, type, sf->field->name);
2281         return OFPERR_OFPBAC_BAD_SET_LEN;
2282     } else if (sf->ofs + sf->n_bits > sf->field->n_bits) {
2283         VLOG_WARN_RL(&rl, "bit offset %d and width %d exceeds %d-bit width "
2284                      "of %s field %s", sf->ofs, sf->n_bits,
2285                      sf->field->n_bits, type, sf->field->name);
2286         return OFPERR_OFPBAC_BAD_SET_LEN;
2287     } else if (flow && !mf_are_prereqs_ok(sf->field, flow)) {
2288         VLOG_WARN_RL(&rl, "%s field %s lacks correct prerequisites",
2289                      type, sf->field->name);
2290         return OFPERR_OFPBAC_MATCH_INCONSISTENT;
2291     } else {
2292         return 0;
2293     }
2294 }
2295
2296 /* Checks whether 'sf' is valid for reading a subfield out of 'flow'.  Returns
2297  * 0 if so, otherwise an OpenFlow error code (e.g. as returned by
2298  * ofp_mkerr()).  */
2299 enum ofperr
2300 mf_check_src(const struct mf_subfield *sf, const struct flow *flow)
2301 {
2302     return mf_check__(sf, flow, "source");
2303 }
2304
2305 /* Checks whether 'sf' is valid for writing a subfield into 'flow'.  Returns 0
2306  * if so, otherwise an OpenFlow error code (e.g. as returned by
2307  * ofp_mkerr()). */
2308 enum ofperr
2309 mf_check_dst(const struct mf_subfield *sf, const struct flow *flow)
2310 {
2311     int error = mf_check__(sf, flow, "destination");
2312     if (!error && !sf->field->writable) {
2313         VLOG_WARN_RL(&rl, "destination field %s is not writable",
2314                      sf->field->name);
2315         return OFPERR_OFPBAC_BAD_SET_ARGUMENT;
2316     }
2317     return error;
2318 }
2319
2320 /* Copies the value and wildcard bit pattern for 'mf' from 'match' into the
2321  * 'value' and 'mask', respectively. */
2322 void
2323 mf_get(const struct mf_field *mf, const struct match *match,
2324        union mf_value *value, union mf_value *mask)
2325 {
2326     mf_get_value(mf, &match->flow, value);
2327     mf_get_mask(mf, &match->wc, mask);
2328 }
2329
2330 static char *
2331 mf_from_integer_string(const struct mf_field *mf, const char *s,
2332                        uint8_t *valuep, uint8_t *maskp)
2333 {
2334     unsigned long long int integer, mask;
2335     char *tail;
2336     int i;
2337
2338     errno = 0;
2339     integer = strtoull(s, &tail, 0);
2340     if (errno || (*tail != '\0' && *tail != '/')) {
2341         goto syntax_error;
2342     }
2343
2344     if (*tail == '/') {
2345         mask = strtoull(tail + 1, &tail, 0);
2346         if (errno || *tail != '\0') {
2347             goto syntax_error;
2348         }
2349     } else {
2350         mask = ULLONG_MAX;
2351     }
2352
2353     for (i = mf->n_bytes - 1; i >= 0; i--) {
2354         valuep[i] = integer;
2355         maskp[i] = mask;
2356         integer >>= 8;
2357         mask >>= 8;
2358     }
2359     if (integer) {
2360         return xasprintf("%s: value too large for %u-byte field %s",
2361                          s, mf->n_bytes, mf->name);
2362     }
2363     return NULL;
2364
2365 syntax_error:
2366     return xasprintf("%s: bad syntax for %s", s, mf->name);
2367 }
2368
2369 static char *
2370 mf_from_ethernet_string(const struct mf_field *mf, const char *s,
2371                         uint8_t mac[ETH_ADDR_LEN],
2372                         uint8_t mask[ETH_ADDR_LEN])
2373 {
2374     int n;
2375
2376     ovs_assert(mf->n_bytes == ETH_ADDR_LEN);
2377
2378     n = -1;
2379     if (ovs_scan(s, ETH_ADDR_SCAN_FMT"%n", ETH_ADDR_SCAN_ARGS(mac), &n)
2380         && n == strlen(s)) {
2381         memset(mask, 0xff, ETH_ADDR_LEN);
2382         return NULL;
2383     }
2384
2385     n = -1;
2386     if (ovs_scan(s, ETH_ADDR_SCAN_FMT"/"ETH_ADDR_SCAN_FMT"%n",
2387                  ETH_ADDR_SCAN_ARGS(mac), ETH_ADDR_SCAN_ARGS(mask), &n)
2388         && n == strlen(s)) {
2389         return NULL;
2390     }
2391
2392     return xasprintf("%s: invalid Ethernet address", s);
2393 }
2394
2395 static char *
2396 mf_from_ipv4_string(const struct mf_field *mf, const char *s,
2397                     ovs_be32 *ip, ovs_be32 *mask)
2398 {
2399     int prefix;
2400
2401     ovs_assert(mf->n_bytes == sizeof *ip);
2402
2403     if (ovs_scan(s, IP_SCAN_FMT"/"IP_SCAN_FMT,
2404                  IP_SCAN_ARGS(ip), IP_SCAN_ARGS(mask))) {
2405         /* OK. */
2406     } else if (ovs_scan(s, IP_SCAN_FMT"/%d", IP_SCAN_ARGS(ip), &prefix)) {
2407         if (prefix <= 0 || prefix > 32) {
2408             return xasprintf("%s: network prefix bits not between 1 and "
2409                              "32", s);
2410         } else if (prefix == 32) {
2411             *mask = OVS_BE32_MAX;
2412         } else {
2413             *mask = htonl(((1u << prefix) - 1) << (32 - prefix));
2414         }
2415     } else if (ovs_scan(s, IP_SCAN_FMT, IP_SCAN_ARGS(ip))) {
2416         *mask = OVS_BE32_MAX;
2417     } else {
2418         return xasprintf("%s: invalid IP address", s);
2419     }
2420     return NULL;
2421 }
2422
2423 static char *
2424 mf_from_ipv6_string(const struct mf_field *mf, const char *s,
2425                     struct in6_addr *value, struct in6_addr *mask)
2426 {
2427     char *str = xstrdup(s);
2428     char *save_ptr = NULL;
2429     const char *name, *netmask;
2430     int retval;
2431
2432     ovs_assert(mf->n_bytes == sizeof *value);
2433
2434     name = strtok_r(str, "/", &save_ptr);
2435     retval = name ? lookup_ipv6(name, value) : EINVAL;
2436     if (retval) {
2437         char *err;
2438
2439         err = xasprintf("%s: could not convert to IPv6 address", str);
2440         free(str);
2441
2442         return err;
2443     }
2444
2445     netmask = strtok_r(NULL, "/", &save_ptr);
2446     if (netmask) {
2447         if (inet_pton(AF_INET6, netmask, mask) != 1) {
2448             int prefix = atoi(netmask);
2449             if (prefix <= 0 || prefix > 128) {
2450                 free(str);
2451                 return xasprintf("%s: prefix bits not between 1 and 128", s);
2452             } else {
2453                 *mask = ipv6_create_mask(prefix);
2454             }
2455         }
2456     } else {
2457         *mask = in6addr_exact;
2458     }
2459     free(str);
2460
2461     return NULL;
2462 }
2463
2464 static char *
2465 mf_from_ofp_port_string(const struct mf_field *mf, const char *s,
2466                         ovs_be16 *valuep, ovs_be16 *maskp)
2467 {
2468     ofp_port_t port;
2469
2470     ovs_assert(mf->n_bytes == sizeof(ovs_be16));
2471
2472     if (ofputil_port_from_string(s, &port)) {
2473         *valuep = htons(ofp_to_u16(port));
2474         *maskp = OVS_BE16_MAX;
2475         return NULL;
2476     }
2477     return xasprintf("%s: port value out of range for %s", s, mf->name);
2478 }
2479
2480 static char *
2481 mf_from_ofp_port_string32(const struct mf_field *mf, const char *s,
2482                           ovs_be32 *valuep, ovs_be32 *maskp)
2483 {
2484     ofp_port_t port;
2485
2486     ovs_assert(mf->n_bytes == sizeof(ovs_be32));
2487     if (ofputil_port_from_string(s, &port)) {
2488         *valuep = ofputil_port_to_ofp11(port);
2489         *maskp = OVS_BE32_MAX;
2490         return NULL;
2491     }
2492     return xasprintf("%s: port value out of range for %s", s, mf->name);
2493 }
2494
2495 struct frag_handling {
2496     const char *name;
2497     uint8_t mask;
2498     uint8_t value;
2499 };
2500
2501 static const struct frag_handling all_frags[] = {
2502 #define A FLOW_NW_FRAG_ANY
2503 #define L FLOW_NW_FRAG_LATER
2504     /* name               mask  value */
2505
2506     { "no",               A|L,  0     },
2507     { "first",            A|L,  A     },
2508     { "later",            A|L,  A|L   },
2509
2510     { "no",               A,    0     },
2511     { "yes",              A,    A     },
2512
2513     { "not_later",        L,    0     },
2514     { "later",            L,    L     },
2515 #undef A
2516 #undef L
2517 };
2518
2519 static char *
2520 mf_from_frag_string(const char *s, uint8_t *valuep, uint8_t *maskp)
2521 {
2522     const struct frag_handling *h;
2523
2524     for (h = all_frags; h < &all_frags[ARRAY_SIZE(all_frags)]; h++) {
2525         if (!strcasecmp(s, h->name)) {
2526             /* We force the upper bits of the mask on to make mf_parse_value()
2527              * happy (otherwise it will never think it's an exact match.) */
2528             *maskp = h->mask | ~FLOW_NW_FRAG_MASK;
2529             *valuep = h->value;
2530             return NULL;
2531         }
2532     }
2533
2534     return xasprintf("%s: unknown fragment type (valid types are \"no\", "
2535                      "\"yes\", \"first\", \"later\", \"not_first\"", s);
2536 }
2537
2538 static int
2539 parse_flow_tun_flags(const char *s_, const char *(*bit_to_string)(uint32_t),
2540                      ovs_be16 *res)
2541 {
2542     uint32_t result = 0;
2543     char *save_ptr = NULL;
2544     char *name;
2545     int rc = 0;
2546     char *s = xstrdup(s_);
2547
2548     for (name = strtok_r((char *)s, " |", &save_ptr); name;
2549          name = strtok_r(NULL, " |", &save_ptr)) {
2550         int name_len;
2551         unsigned long long int flags;
2552         uint32_t bit;
2553
2554         if (ovs_scan(name, "%lli", &flags)) {
2555             result |= flags;
2556             continue;
2557         }
2558         name_len = strlen(name);
2559         for (bit = 1; bit; bit <<= 1) {
2560             const char *fname = bit_to_string(bit);
2561             size_t len;
2562
2563             if (!fname) {
2564                 continue;
2565             }
2566
2567             len = strlen(fname);
2568             if (len != name_len) {
2569                 continue;
2570             }
2571             if (!strncmp(name, fname, len)) {
2572                 result |= bit;
2573                 break;
2574             }
2575         }
2576
2577         if (!bit) {
2578             rc = -ENOENT;
2579             goto out;
2580         }
2581     }
2582
2583     *res = htons(result);
2584 out:
2585     free(s);
2586     return rc;
2587 }
2588
2589 static char *
2590 mf_from_tun_flags_string(const char *s, ovs_be16 *valuep, ovs_be16 *maskp)
2591 {
2592     if (!parse_flow_tun_flags(s, flow_tun_flag_to_string, valuep)) {
2593         *maskp = OVS_BE16_MAX;
2594         return NULL;
2595     }
2596
2597     return xasprintf("%s: unknown tunnel flags (valid flags are \"df\", "
2598                      "\"csum\", \"key\")", s);
2599 }
2600
2601 static char *
2602 mf_from_tcp_flags_string(const char *s, ovs_be16 *flagsp, ovs_be16 *maskp)
2603 {
2604     uint16_t flags = 0;
2605     uint16_t mask = 0;
2606     uint16_t bit;
2607     int n;
2608
2609     if (ovs_scan(s, "%"SCNi16"/%"SCNi16"%n", &flags, &mask, &n) && !s[n]) {
2610         *flagsp = htons(flags);
2611         *maskp = htons(mask);
2612         return NULL;
2613     }
2614     if (ovs_scan(s, "%"SCNi16"%n", &flags, &n) && !s[n]) {
2615         *flagsp = htons(flags);
2616         *maskp = OVS_BE16_MAX;
2617         return NULL;
2618     }
2619
2620     while (*s != '\0') {
2621         bool set;
2622         int name_len;
2623
2624         switch (*s) {
2625         case '+':
2626             set = true;
2627             break;
2628         case '-':
2629             set = false;
2630             break;
2631         default:
2632             return xasprintf("%s: TCP flag must be preceded by '+' (for SET) "
2633                              "or '-' (NOT SET)", s);
2634         }
2635         s++;
2636
2637         name_len = strcspn(s,"+-");
2638
2639         for (bit = 1; bit; bit <<= 1) {
2640             const char *fname = packet_tcp_flag_to_string(bit);
2641             size_t len;
2642
2643             if (!fname) {
2644                 continue;
2645             }
2646
2647             len = strlen(fname);
2648             if (len != name_len) {
2649                 continue;
2650             }
2651             if (!strncmp(s, fname, len)) {
2652                 if (mask & bit) {
2653                     return xasprintf("%s: Each TCP flag can be specified only "
2654                                      "once", s);
2655                 }
2656                 if (set) {
2657                     flags |= bit;
2658                 }
2659                 mask |= bit;
2660                 break;
2661             }
2662         }
2663
2664         if (!bit) {
2665             return xasprintf("%s: unknown TCP flag(s)", s);
2666         }
2667         s += name_len;
2668     }
2669
2670     *flagsp = htons(flags);
2671     *maskp = htons(mask);
2672     return NULL;
2673 }
2674
2675
2676 /* Parses 's', a string value for field 'mf', into 'value' and 'mask'.  Returns
2677  * NULL if successful, otherwise a malloc()'d string describing the error. */
2678 char *
2679 mf_parse(const struct mf_field *mf, const char *s,
2680          union mf_value *value, union mf_value *mask)
2681 {
2682     char *error;
2683
2684     if (!strcmp(s, "*")) {
2685         memset(value, 0, mf->n_bytes);
2686         memset(mask, 0, mf->n_bytes);
2687         return NULL;
2688     }
2689
2690     switch (mf->string) {
2691     case MFS_DECIMAL:
2692     case MFS_HEXADECIMAL:
2693         error = mf_from_integer_string(mf, s,
2694                                        (uint8_t *) value, (uint8_t *) mask);
2695         break;
2696
2697     case MFS_ETHERNET:
2698         error = mf_from_ethernet_string(mf, s, value->mac, mask->mac);
2699         break;
2700
2701     case MFS_IPV4:
2702         error = mf_from_ipv4_string(mf, s, &value->be32, &mask->be32);
2703         break;
2704
2705     case MFS_IPV6:
2706         error = mf_from_ipv6_string(mf, s, &value->ipv6, &mask->ipv6);
2707         break;
2708
2709     case MFS_OFP_PORT:
2710         error = mf_from_ofp_port_string(mf, s, &value->be16, &mask->be16);
2711         break;
2712
2713     case MFS_OFP_PORT_OXM:
2714         error = mf_from_ofp_port_string32(mf, s, &value->be32, &mask->be32);
2715         break;
2716
2717     case MFS_FRAG:
2718         error = mf_from_frag_string(s, &value->u8, &mask->u8);
2719         break;
2720
2721     case MFS_TNL_FLAGS:
2722         ovs_assert(mf->n_bytes == sizeof(ovs_be16));
2723         error = mf_from_tun_flags_string(s, &value->be16, &mask->be16);
2724         break;
2725
2726     case MFS_TCP_FLAGS:
2727         ovs_assert(mf->n_bytes == sizeof(ovs_be16));
2728         error = mf_from_tcp_flags_string(s, &value->be16, &mask->be16);
2729         break;
2730
2731     default:
2732         OVS_NOT_REACHED();
2733     }
2734
2735     if (!error && !mf_is_mask_valid(mf, mask)) {
2736         error = xasprintf("%s: invalid mask for field %s", s, mf->name);
2737     }
2738     return error;
2739 }
2740
2741 /* Parses 's', a string value for field 'mf', into 'value'.  Returns NULL if
2742  * successful, otherwise a malloc()'d string describing the error. */
2743 char *
2744 mf_parse_value(const struct mf_field *mf, const char *s, union mf_value *value)
2745 {
2746     union mf_value mask;
2747     char *error;
2748
2749     error = mf_parse(mf, s, value, &mask);
2750     if (error) {
2751         return error;
2752     }
2753
2754     if (!is_all_ones((const uint8_t *) &mask, mf->n_bytes)) {
2755         return xasprintf("%s: wildcards not allowed here", s);
2756     }
2757     return NULL;
2758 }
2759
2760 static void
2761 mf_format_integer_string(const struct mf_field *mf, const uint8_t *valuep,
2762                          const uint8_t *maskp, struct ds *s)
2763 {
2764     unsigned long long int integer;
2765     int i;
2766
2767     ovs_assert(mf->n_bytes <= 8);
2768
2769     integer = 0;
2770     for (i = 0; i < mf->n_bytes; i++) {
2771         integer = (integer << 8) | valuep[i];
2772     }
2773     if (mf->string == MFS_HEXADECIMAL) {
2774         ds_put_format(s, "%#llx", integer);
2775     } else {
2776         ds_put_format(s, "%lld", integer);
2777     }
2778
2779     if (maskp) {
2780         unsigned long long int mask;
2781
2782         mask = 0;
2783         for (i = 0; i < mf->n_bytes; i++) {
2784             mask = (mask << 8) | maskp[i];
2785         }
2786
2787         /* I guess we could write the mask in decimal for MFS_DECIMAL but I'm
2788          * not sure that that a bit-mask written in decimal is ever easier to
2789          * understand than the same bit-mask written in hexadecimal. */
2790         ds_put_format(s, "/%#llx", mask);
2791     }
2792 }
2793
2794 static void
2795 mf_format_frag_string(uint8_t value, uint8_t mask, struct ds *s)
2796 {
2797     const struct frag_handling *h;
2798
2799     mask &= FLOW_NW_FRAG_MASK;
2800     value &= mask;
2801
2802     for (h = all_frags; h < &all_frags[ARRAY_SIZE(all_frags)]; h++) {
2803         if (value == h->value && mask == h->mask) {
2804             ds_put_cstr(s, h->name);
2805             return;
2806         }
2807     }
2808     ds_put_cstr(s, "<error>");
2809 }
2810
2811 static void
2812 mf_format_tnl_flags_string(const ovs_be16 *valuep, struct ds *s)
2813 {
2814     format_flags(s, flow_tun_flag_to_string, ntohs(*valuep), '|');
2815 }
2816
2817 static void
2818 mf_format_tcp_flags_string(ovs_be16 value, ovs_be16 mask, struct ds *s)
2819 {
2820     format_flags_masked(s, NULL, packet_tcp_flag_to_string, ntohs(value),
2821                         TCP_FLAGS(mask));
2822 }
2823
2824 /* Appends to 's' a string representation of field 'mf' whose value is in
2825  * 'value' and 'mask'.  'mask' may be NULL to indicate an exact match. */
2826 void
2827 mf_format(const struct mf_field *mf,
2828           const union mf_value *value, const union mf_value *mask,
2829           struct ds *s)
2830 {
2831     if (mask) {
2832         if (is_all_zeros((const uint8_t *) mask, mf->n_bytes)) {
2833             ds_put_cstr(s, "ANY");
2834             return;
2835         } else if (is_all_ones((const uint8_t *) mask, mf->n_bytes)) {
2836             mask = NULL;
2837         }
2838     }
2839
2840     switch (mf->string) {
2841     case MFS_OFP_PORT_OXM:
2842         if (!mask) {
2843             ofp_port_t port;
2844             ofputil_port_from_ofp11(value->be32, &port);
2845             ofputil_format_port(port, s);
2846             break;
2847         }
2848         /* fall through */
2849     case MFS_OFP_PORT:
2850         if (!mask) {
2851             ofputil_format_port(u16_to_ofp(ntohs(value->be16)), s);
2852             break;
2853         }
2854         /* fall through */
2855     case MFS_DECIMAL:
2856     case MFS_HEXADECIMAL:
2857         mf_format_integer_string(mf, (uint8_t *) value, (uint8_t *) mask, s);
2858         break;
2859
2860     case MFS_ETHERNET:
2861         eth_format_masked(value->mac, mask->mac, s);
2862         break;
2863
2864     case MFS_IPV4:
2865         ip_format_masked(value->be32, mask ? mask->be32 : OVS_BE32_MAX, s);
2866         break;
2867
2868     case MFS_IPV6:
2869         print_ipv6_masked(s, &value->ipv6, mask ? &mask->ipv6 : NULL);
2870         break;
2871
2872     case MFS_FRAG:
2873         mf_format_frag_string(value->u8, mask ? mask->u8 : UINT8_MAX, s);
2874         break;
2875
2876     case MFS_TNL_FLAGS:
2877         mf_format_tnl_flags_string(&value->be16, s);
2878         break;
2879
2880     case MFS_TCP_FLAGS:
2881         mf_format_tcp_flags_string(value->be16,
2882                                    mask ? mask->be16 : OVS_BE16_MAX, s);
2883         break;
2884
2885     default:
2886         OVS_NOT_REACHED();
2887     }
2888 }
2889 \f
2890 /* Makes subfield 'sf' within 'flow' exactly match the 'sf->n_bits'
2891  * least-significant bits in 'x'.
2892  */
2893 void
2894 mf_write_subfield_flow(const struct mf_subfield *sf,
2895                        const union mf_subvalue *x, struct flow *flow)
2896 {
2897     const struct mf_field *field = sf->field;
2898     union mf_value value;
2899
2900     mf_get_value(field, flow, &value);
2901     bitwise_copy(x, sizeof *x, 0, &value, field->n_bytes,
2902                  sf->ofs, sf->n_bits);
2903     mf_set_flow_value(field, &value, flow);
2904 }
2905
2906 /* Makes subfield 'sf' within 'match' exactly match the 'sf->n_bits'
2907  * least-significant bits in 'x'.
2908  */
2909 void
2910 mf_write_subfield(const struct mf_subfield *sf, const union mf_subvalue *x,
2911                   struct match *match)
2912 {
2913     const struct mf_field *field = sf->field;
2914     union mf_value value, mask;
2915
2916     mf_get(field, match, &value, &mask);
2917     bitwise_copy(x, sizeof *x, 0, &value, field->n_bytes, sf->ofs, sf->n_bits);
2918     bitwise_one (                 &mask,  field->n_bytes, sf->ofs, sf->n_bits);
2919     mf_set(field, &value, &mask, match);
2920 }
2921
2922 /* Initializes 'x' to the value of 'sf' within 'flow'.  'sf' must be valid for
2923  * reading 'flow', e.g. as checked by mf_check_src(). */
2924 void
2925 mf_read_subfield(const struct mf_subfield *sf, const struct flow *flow,
2926                  union mf_subvalue *x)
2927 {
2928     union mf_value value;
2929
2930     mf_get_value(sf->field, flow, &value);
2931
2932     memset(x, 0, sizeof *x);
2933     bitwise_copy(&value, sf->field->n_bytes, sf->ofs,
2934                  x, sizeof *x, 0,
2935                  sf->n_bits);
2936 }
2937
2938 /* Returns the value of 'sf' within 'flow'.  'sf' must be valid for reading
2939  * 'flow', e.g. as checked by mf_check_src() and sf->n_bits must be 64 or
2940  * less. */
2941 uint64_t
2942 mf_get_subfield(const struct mf_subfield *sf, const struct flow *flow)
2943 {
2944     union mf_value value;
2945
2946     mf_get_value(sf->field, flow, &value);
2947     return bitwise_get(&value, sf->field->n_bytes, sf->ofs, sf->n_bits);
2948 }
2949
2950 /* Formats 'sf' into 's' in a format normally acceptable to
2951  * mf_parse_subfield().  (It won't be acceptable if sf->field is NULL or if
2952  * sf->field has no NXM name.) */
2953 void
2954 mf_format_subfield(const struct mf_subfield *sf, struct ds *s)
2955 {
2956     if (!sf->field) {
2957         ds_put_cstr(s, "<unknown>");
2958     } else if (sf->field->nxm_name) {
2959         ds_put_cstr(s, sf->field->nxm_name);
2960     } else if (sf->field->nxm_header) {
2961         uint32_t header = sf->field->nxm_header;
2962         ds_put_format(s, "%d:%d", NXM_VENDOR(header), NXM_FIELD(header));
2963     } else {
2964         ds_put_cstr(s, sf->field->name);
2965     }
2966
2967     if (sf->field && sf->ofs == 0 && sf->n_bits == sf->field->n_bits) {
2968         ds_put_cstr(s, "[]");
2969     } else if (sf->n_bits == 1) {
2970         ds_put_format(s, "[%d]", sf->ofs);
2971     } else {
2972         ds_put_format(s, "[%d..%d]", sf->ofs, sf->ofs + sf->n_bits - 1);
2973     }
2974 }
2975
2976 static const struct mf_field *
2977 mf_parse_subfield_name(const char *name, int name_len, bool *wild)
2978 {
2979     int i;
2980
2981     *wild = name_len > 2 && !memcmp(&name[name_len - 2], "_W", 2);
2982     if (*wild) {
2983         name_len -= 2;
2984     }
2985
2986     for (i = 0; i < MFF_N_IDS; i++) {
2987         const struct mf_field *mf = mf_from_id(i);
2988
2989         if (mf->nxm_name
2990             && !strncmp(mf->nxm_name, name, name_len)
2991             && mf->nxm_name[name_len] == '\0') {
2992             return mf;
2993         }
2994         if (mf->oxm_name
2995             && !strncmp(mf->oxm_name, name, name_len)
2996             && mf->oxm_name[name_len] == '\0') {
2997             return mf;
2998         }
2999     }
3000
3001     return NULL;
3002 }
3003
3004 /* Parses a subfield from the beginning of '*sp' into 'sf'.  If successful,
3005  * returns NULL and advances '*sp' to the first byte following the parsed
3006  * string.  On failure, returns a malloc()'d error message, does not modify
3007  * '*sp', and does not properly initialize 'sf'.
3008  *
3009  * The syntax parsed from '*sp' takes the form "header[start..end]" where
3010  * 'header' is the name of an NXM field and 'start' and 'end' are (inclusive)
3011  * bit indexes.  "..end" may be omitted to indicate a single bit.  "start..end"
3012  * may both be omitted (the [] are still required) to indicate an entire
3013  * field. */
3014 char * WARN_UNUSED_RESULT
3015 mf_parse_subfield__(struct mf_subfield *sf, const char **sp)
3016 {
3017     const struct mf_field *field;
3018     const char *name;
3019     int start, end;
3020     const char *s;
3021     int name_len;
3022     bool wild;
3023
3024     s = *sp;
3025     name = s;
3026     name_len = strcspn(s, "[");
3027     if (s[name_len] != '[') {
3028         return xasprintf("%s: missing [ looking for field name", *sp);
3029     }
3030
3031     field = mf_parse_subfield_name(name, name_len, &wild);
3032     if (!field) {
3033         return xasprintf("%s: unknown field `%.*s'", *sp, name_len, s);
3034     }
3035
3036     s += name_len;
3037     if (ovs_scan(s, "[%d..%d]", &start, &end)) {
3038         /* Nothing to do. */
3039     } else if (ovs_scan(s, "[%d]", &start)) {
3040         end = start;
3041     } else if (!strncmp(s, "[]", 2)) {
3042         start = 0;
3043         end = field->n_bits - 1;
3044     } else {
3045         return xasprintf("%s: syntax error expecting [] or [<bit>] or "
3046                          "[<start>..<end>]", *sp);
3047     }
3048     s = strchr(s, ']') + 1;
3049
3050     if (start > end) {
3051         return xasprintf("%s: starting bit %d is after ending bit %d",
3052                          *sp, start, end);
3053     } else if (start >= field->n_bits) {
3054         return xasprintf("%s: starting bit %d is not valid because field is "
3055                          "only %d bits wide", *sp, start, field->n_bits);
3056     } else if (end >= field->n_bits){
3057         return xasprintf("%s: ending bit %d is not valid because field is "
3058                          "only %d bits wide", *sp, end, field->n_bits);
3059     }
3060
3061     sf->field = field;
3062     sf->ofs = start;
3063     sf->n_bits = end - start + 1;
3064
3065     *sp = s;
3066     return NULL;
3067 }
3068
3069 /* Parses a subfield from the entirety of 's' into 'sf'.  Returns NULL if
3070  * successful, otherwise a malloc()'d string describing the error.  The caller
3071  * is responsible for freeing the returned string.
3072  *
3073  * The syntax parsed from 's' takes the form "header[start..end]" where
3074  * 'header' is the name of an NXM field and 'start' and 'end' are (inclusive)
3075  * bit indexes.  "..end" may be omitted to indicate a single bit.  "start..end"
3076  * may both be omitted (the [] are still required) to indicate an entire
3077  * field.  */
3078 char * WARN_UNUSED_RESULT
3079 mf_parse_subfield(struct mf_subfield *sf, const char *s)
3080 {
3081     char *error = mf_parse_subfield__(sf, &s);
3082     if (!error && s[0]) {
3083         error = xstrdup("unexpected input following field syntax");
3084     }
3085     return error;
3086 }
3087
3088 void
3089 mf_format_subvalue(const union mf_subvalue *subvalue, struct ds *s)
3090 {
3091     int i;
3092
3093     for (i = 0; i < ARRAY_SIZE(subvalue->u8); i++) {
3094         if (subvalue->u8[i]) {
3095             ds_put_format(s, "0x%"PRIx8, subvalue->u8[i]);
3096             for (i++; i < ARRAY_SIZE(subvalue->u8); i++) {
3097                 ds_put_format(s, "%02"PRIx8, subvalue->u8[i]);
3098             }
3099             return;
3100         }
3101     }
3102     ds_put_char(s, '0');
3103 }