bool
match_std_strict(struct ofl_match_standard *a, struct ofl_match_standard *b) {
return strict_wild32(a->in_port, b->in_port, a->wildcards, b->wildcards, OFPFW_IN_PORT) &&
strict_dladdr(a->dl_src, b->dl_src, a->dl_src_mask, b->dl_src_mask) &&
strict_dladdr(a->dl_dst, b->dl_dst, a->dl_dst_mask, b->dl_dst_mask) &&
strict_wild16(a->dl_vlan, b->dl_vlan, a->wildcards, b->wildcards, OFPFW_DL_VLAN) &&
strict_wild16(a->dl_vlan_pcp, b->dl_vlan_pcp, a->wildcards, b->wildcards, OFPFW_DL_VLAN_PCP) &&
strict_wild16(a->dl_type, b->dl_type, a->wildcards, b->wildcards, OFPFW_DL_TYPE) &&
strict_wild8 (a->nw_tos, b->nw_tos, a->wildcards, b->wildcards, OFPFW_NW_TOS) &&
strict_wild8 (a->nw_proto, b->nw_proto, a->wildcards, b->wildcards, OFPFW_NW_PROTO) &&
strict_mask32(a->nw_src, b->nw_src, a->nw_src_mask, b->nw_src_mask) &&
strict_mask32(a->nw_dst, b->nw_dst, a->nw_dst_mask, b->nw_dst_mask) &&
strict_wild16(a->tp_src, b->tp_src, a->wildcards, b->wildcards, OFPFW_TP_SRC) &&
strict_wild16(a->tp_dst, b->tp_dst, a->wildcards, b->wildcards, OFPFW_TP_DST) &&
strict_wild32(a->mpls_label, b->mpls_label, a->wildcards, b->wildcards, OFPFW_MPLS_LABEL) &&
strict_wild8 (a->mpls_tc, b->mpls_tc, a->wildcards, b->wildcards, OFPFW_MPLS_TC) &&
strict_mask64(a->metadata, b->metadata, a->metadata_mask, b->metadata_mask);
}
/* Two matches strictly match if their wildcard fields are the same, and all the
* non-wildcarded fields match on the same exact values.
* NOTE: Handling of bitmasked fields is not specified. In this implementation
* masked fields are checked for equality, and only unmasked bits are compared
* in the field.
*/
bool
match_std_strict(struct ofl_match *a, struct ofl_match *b, struct ofl_exp *exp) {
struct ofl_match_tlv *flow_mod_match;
struct ofl_match_tlv *flow_entry_match;
int field_len;
uint8_t *flow_mod_val, *flow_mod_mask=0;
uint8_t *flow_entry_val, *flow_entry_mask=0;
uint8_t oxm_field;
bool has_mask;
/* Both matches all wildcarded */
if(!a->header.length && !b->header.length )
return true;
/* If the matches differ in length, there is no reason to compare */
if (a->header.length != b->header.length)
return false;
/* Loop through the flow_mod match fields */
HMAP_FOR_EACH(flow_mod_match, struct ofl_match_tlv, hmap_node, &a->match_fields)
{
/* Check presence of match field in flow entry */
flow_entry_match = oxm_match_lookup(flow_mod_match->header, b);
if (!flow_entry_match) {
return false;
}
/* At this point match length and has_mask are equal */
oxm_field = OXM_FIELD(flow_mod_match->header);
has_mask = OXM_HASMASK(flow_mod_match->header);
flow_mod_val = flow_mod_match->value;
flow_entry_val = flow_entry_match->value;
switch (OXM_VENDOR(flow_mod_match->header))
{
case (OFPXMC_OPENFLOW_BASIC):
field_len = OXM_LENGTH(flow_mod_match->header);
if (has_mask)
{
field_len /= 2;
flow_mod_mask = flow_mod_val + field_len;
flow_entry_mask = flow_entry_val + field_len;
}
break;
case (OFPXMC_EXPERIMENTER):
if (exp == NULL || exp->field == NULL || exp->field->match_std == NULL) {
VLOG_WARN(LOG_MODULE,"Received match is experimental, but no callback was given.");
ofl_error(OFPET_BAD_MATCH, OFPBMC_BAD_TYPE);
}
exp->field->match_std(flow_mod_match, flow_entry_match, &field_len, &flow_mod_val, &flow_entry_val, &flow_mod_mask, &flow_entry_mask);
break;
default:
break;
}
switch (field_len) {
case 1:
if (has_mask) {
if (!strict_mask8(flow_mod_val, flow_entry_val, flow_mod_mask, flow_entry_mask)){
return false;
}
}
else {
if (!match_8(flow_mod_val, flow_entry_val)){
return false;
}
}
break;
case 2:
if (has_mask) {
if (!strict_mask16(flow_mod_val, flow_entry_val, flow_mod_mask, flow_entry_mask)){
return false;
}
}
else {
if (!match_16(flow_mod_val, flow_entry_val)){
return false;
}
}
break;
case 3:
if (has_mask) {
if (!strict_mask24(flow_mod_val, flow_entry_val, flow_mod_mask, flow_entry_mask))
return false;
}
else {
if (!match_24(flow_mod_val, flow_entry_val)){
return false;
}
}
break;
case 4:
if (has_mask) {
/* Quick and dirty fix for IP addresses matching
TODO: Matching needs a huge refactoring */
if (oxm_field == OFPXMT_OFB_IPV4_SRC ||
oxm_field == OFPXMT_OFB_IPV4_DST ||
oxm_field == OFPXMT_OFB_ARP_SPA ||
oxm_field == OFPXMT_OFB_ARP_TPA) {
if (!strict_mask_ip(flow_mod_val, flow_entry_val, flow_mod_mask, flow_entry_mask)){
return false;
}
}
if (!strict_mask32(flow_mod_val, flow_entry_val, flow_mod_mask, flow_entry_mask)){
return false;
}
}
else {
if (!match_32(flow_mod_val, flow_entry_val)){
return false;
}
}
break;
case 6:
if (has_mask) {
if (!strict_mask48(flow_mod_val, flow_entry_val, flow_mod_mask, flow_entry_mask)){
return false;
}
}
else {
if (!match_48(flow_mod_val, flow_entry_val)){
return false;
}
}
break;
case 8:
if (has_mask) {
if (!strict_mask64(flow_mod_val, flow_entry_val, flow_mod_mask, flow_entry_mask)){
return false;
}
}
else {
if (!match_64(flow_mod_val, flow_entry_val)){
return false;
}
}
break;
case 16:
if (has_mask) {
if (!strict_mask128(flow_mod_val, flow_entry_val, flow_mod_mask, flow_entry_mask)){
return false;
}
}
else {
if (!match_128(flow_mod_val, flow_entry_val)){
return false;
}
}
break;
default:
/* Should never happen */
break;
} /* switch (field_len) */
} /* HMAP_FOR_EACH */
/* If we get here, all match fields in flow_mod were equal to the ones in flow entry */
/* There can't be more fields in the flow entry as the lengths are the same */
return true;
}
static inline bool
strict_mask48(uint8_t *a, uint8_t *b, uint8_t *am, uint8_t *bm) {
return strict_mask32(a, b, am, bm) &&
strict_mask16(a+4, b+4, am+4, bm+4);
}
/* Two matches strictly match, if their wildcard fields are the same, and all the
* non-wildcarded fields match on the same exact values.
* NOTE: Handling of bitmasked fields is not specified. In this implementation
* masked fields are checked for equality, and only unmasked bits are compared
* in the field.
*/
bool
match_std_strict(struct ofl_match *a, struct ofl_match *b) {
struct ofl_match_tlv *flow_mod_match;
struct ofl_match_tlv *flow_entry_match;
bool ret = false;
/*Both matches all wildcarded */
if(!a->header.length && !b->header.length )
return true;
/* If the matches differ in length, there is no reason to compare
once they will differ in the number of fields */
if (a->header.length != b->header.length)
return false;
/* Loop through the match fields */
HMAP_FOR_EACH(flow_mod_match, struct ofl_match_tlv, hmap_node, &a->match_fields){
/* Check if the field is present in the flow entry */
HMAP_FOR_EACH_WITH_HASH(flow_entry_match, struct ofl_match_tlv, hmap_node, hash_int(flow_mod_match->header, 0), &b->match_fields){
int field_len = OXM_LENGTH(flow_mod_match->header);
bool has_mask;
/* Check if both fields have or not a mask */
if ( (OXM_HASMASK(flow_mod_match->header) && !OXM_HASMASK(flow_entry_match->header))
|| (!OXM_HASMASK(flow_mod_match->header) && OXM_HASMASK(flow_entry_match->header))){
return false;
}
ret = true;
has_mask = OXM_HASMASK(flow_mod_match->header);
if (has_mask)
{
field_len = field_len/2;
}
switch (field_len){
case (sizeof(uint8_t)):{
if (has_mask){
if (strict_mask8(flow_mod_match->value, flow_entry_match->value + field_len, flow_entry_match->value,flow_entry_match->value + field_len) == 0){
return false;
}
}
else
if (matches_8(flow_mod_match->value, flow_entry_match->value) == 0){
return false;
}
break;
}
case (sizeof(uint16_t)):{
if (has_mask){
if (strict_mask16(flow_mod_match->value,flow_entry_match->value + field_len, flow_entry_match->value,flow_entry_match->value + field_len) == 0){
return false;
}
}
else
if (matches_16(flow_mod_match->value, flow_entry_match->value) == 0){
return false;
}
break;
}
case (sizeof(uint32_t)):{
if (has_mask){
if (strict_mask32(flow_mod_match->value,flow_entry_match->value + field_len, flow_entry_match->value,flow_entry_match->value + field_len) == 0 ){
return false;
}
}
else
if (matches_32(flow_mod_match->value, flow_entry_match->value) == 0){
return false;
}
break;
}
case (ETH_ADDR_LEN):{
if (has_mask){
if (strict_ethaddr(flow_mod_match->value,flow_entry_match->value + field_len, flow_entry_match->value,flow_entry_match->value + field_len) == 0){
return false;
}
}
else
if (eth_match(flow_mod_match->value, flow_entry_match->value) == 0){
return false;
}
break;
}
case (sizeof(uint64_t)):{
if (has_mask) {
if (strict_mask64(flow_mod_match->value,flow_entry_match->value + field_len, flow_entry_match->value,flow_entry_match->value + field_len) == 0){
return false;
}
}
else
if (matches_64(flow_mod_match->value, flow_entry_match->value) == 0){
return false;
}
break;
}
case (16):{
if (has_mask){
if (strict_ipv6(flow_mod_match->value,flow_entry_match->value + field_len, flow_entry_match->value,flow_entry_match->value + field_len)== 0){
return false;
}
}
else
if (ipv6_match(flow_mod_match->value, flow_entry_match->value) == 0){
return false;
}
break;
}
}
}
if (!ret)
return ret;
else ret = false;
}
return true;
}
/* Two matches strictly match if their wildcard fields are the same, and all the
* non-wildcarded fields match on the same exact values.
* NOTE: Handling of bitmasked fields is not specified. In this implementation
* masked fields are checked for equality, and only unmasked bits are compared
* in the field.
*/
bool
match_std_strict(struct ofl_match *a, struct ofl_match *b) {
struct ofl_match_tlv *flow_mod_match;
struct ofl_match_tlv *flow_entry_match;
int field_len;
uint8_t *flow_mod_val, *flow_mod_mask=0;
uint8_t *flow_entry_val, *flow_entry_mask=0;
bool has_mask;
/* Both matches all wildcarded */
if(!a->header.length && !b->header.length )
return true;
/* If the matches differ in length, there is no reason to compare */
if (a->header.length != b->header.length)
return false;
/* Loop through the flow_mod match fields */
HMAP_FOR_EACH(flow_mod_match, struct ofl_match_tlv, hmap_node, &a->match_fields)
{
/* Check presence of match field in flow entry */
flow_entry_match = oxm_match_lookup(flow_mod_match->header, b);
if (!flow_entry_match) {
return false;
}
/* At this point match length and has_mask are equal */
has_mask = OXM_HASMASK(flow_mod_match->header);
field_len = OXM_LENGTH(flow_mod_match->header);
flow_mod_val = flow_mod_match->value;
flow_entry_val = flow_entry_match->value;
if (has_mask)
{
field_len /= 2;
flow_mod_mask = flow_mod_match->value + field_len;
flow_entry_mask = flow_entry_match->value + field_len;
}
switch (field_len) {
case 1:
if (has_mask) {
if (!strict_mask8(flow_mod_val, flow_entry_val, flow_mod_mask, flow_entry_mask))
return false;
}
else {
if (!match_8(flow_mod_val, flow_entry_val))
return false;
}
break;
case 2:
if (has_mask) {
if (!strict_mask16(flow_mod_val, flow_entry_val, flow_mod_mask, flow_entry_mask))
return false;
}
else {
if (!match_16(flow_mod_val, flow_entry_val))
return false;
}
break;
case 4:
if (has_mask) {
if (!strict_mask32(flow_mod_val, flow_entry_val, flow_mod_mask, flow_entry_mask))
return false;
}
else {
if (!match_32(flow_mod_val, flow_entry_val))
return false;
}
break;
case 6:
if (has_mask) {
if (!strict_mask48(flow_mod_val, flow_entry_val, flow_mod_mask, flow_entry_mask))
return false;
}
else {
if (!match_48(flow_mod_val, flow_entry_val))
return false;
}
break;
case 8:
if (has_mask) {
if (!strict_mask64(flow_mod_val, flow_entry_val, flow_mod_mask, flow_entry_mask))
return false;
}
else {
if (!match_64(flow_mod_val, flow_entry_val))
return false;
}
break;
case 16:
if (has_mask) {
if (!strict_mask128(flow_mod_val, flow_entry_val, flow_mod_mask, flow_entry_mask))
return false;
}
else {
if (!match_128(flow_mod_val, flow_entry_val))
return false;
}
break;
default:
/* Should never happen */
break;
} /* switch (field_len) */
} /* HMAP_FOR_EACH */
/* If we get here, all match fields in flow_mod were equal to the ones in flow entry */
/* There can't be more fields in the flow entry as the lengths are the same */
return true;
}
static inline bool
strict_dladdr(uint8_t *a, uint8_t *b, uint8_t *am, uint8_t *bm) {
return strict_mask32(*((uint32_t *)a), *((uint32_t *)b), *((uint32_t *)am), *((uint32_t *)bm)) &&
strict_mask16(*((uint16_t *)(a+4)), *((uint16_t *)(b+4)), *((uint16_t *)(am+4)), *((uint16_t *)(bm+4)));}