kytos /
of_core
| @@ 487-526 (lines=40) @@ | ||
| 484 | return cls(value) |
|
| 485 | ||
| 486 | ||
| 487 | class MatchARPTHA(MatchField): |
|
| 488 | """Match for ARP Target MAC Address.""" |
|
| 489 | ||
| 490 | name = 'arp_tha' |
|
| 491 | oxm_field = OxmOfbMatchField.OFPXMT_OFB_ARP_THA |
|
| 492 | ||
| 493 | def as_of_tlv(self): |
|
| 494 | """Return a pyof OXM TLV instance.""" |
|
| 495 | if '/' in self.value: |
|
| 496 | value, mask = self.value.split('/') |
|
| 497 | if mask.upper() == 'FF:FF:FF:FF:FF:FF': |
|
| 498 | mask = None |
|
| 499 | oxm_hasmask = False |
|
| 500 | else: |
|
| 501 | mask = mask.upper() |
|
| 502 | oxm_hasmask = True |
|
| 503 | else: |
|
| 504 | value = self.value |
|
| 505 | mask = None |
|
| 506 | oxm_hasmask = False |
|
| 507 | value_bytes = HWAddress(value).pack() |
|
| 508 | if mask: |
|
| 509 | value_bytes += HWAddress(mask).pack() |
|
| 510 | return OxmTLV(oxm_field=self.oxm_field, |
|
| 511 | oxm_hasmask=oxm_hasmask, |
|
| 512 | oxm_value=value_bytes) |
|
| 513 | ||
| 514 | @classmethod |
|
| 515 | def from_of_tlv(cls, tlv): |
|
| 516 | """Return an instance from a pyof OXM TLV.""" |
|
| 517 | hw_address = HWAddress() |
|
| 518 | hw_address.unpack(tlv.oxm_value) |
|
| 519 | addr_str = str(hw_address) |
|
| 520 | value = addr_str |
|
| 521 | if tlv.oxm_hasmask: |
|
| 522 | hw_mask = HWAddress() |
|
| 523 | hw_mask.unpack(tlv.oxm_value[6:]) |
|
| 524 | mask_str = str(hw_mask) |
|
| 525 | value = f'{addr_str}/{mask_str}' |
|
| 526 | return cls(value) |
|
| 527 | ||
| 528 | ||
| 529 | class MatchIPV6Src(MatchField): |
|
| @@ 445-484 (lines=40) @@ | ||
| 442 | return cls(value) |
|
| 443 | ||
| 444 | ||
| 445 | class MatchARPSHA(MatchField): |
|
| 446 | """Match for ARP Sender MAC Address.""" |
|
| 447 | ||
| 448 | name = 'arp_sha' |
|
| 449 | oxm_field = OxmOfbMatchField.OFPXMT_OFB_ARP_SHA |
|
| 450 | ||
| 451 | def as_of_tlv(self): |
|
| 452 | """Return a pyof OXM TLV instance.""" |
|
| 453 | if '/' in self.value: |
|
| 454 | value, mask = self.value.split('/') |
|
| 455 | if mask.upper() == 'FF:FF:FF:FF:FF:FF': |
|
| 456 | mask = None |
|
| 457 | oxm_hasmask = False |
|
| 458 | else: |
|
| 459 | mask = mask.upper() |
|
| 460 | oxm_hasmask = True |
|
| 461 | else: |
|
| 462 | value = self.value |
|
| 463 | mask = None |
|
| 464 | oxm_hasmask = False |
|
| 465 | value_bytes = HWAddress(value).pack() |
|
| 466 | if mask: |
|
| 467 | value_bytes += HWAddress(mask).pack() |
|
| 468 | return OxmTLV(oxm_field=self.oxm_field, |
|
| 469 | oxm_hasmask=oxm_hasmask, |
|
| 470 | oxm_value=value_bytes) |
|
| 471 | ||
| 472 | @classmethod |
|
| 473 | def from_of_tlv(cls, tlv): |
|
| 474 | """Return an instance from a pyof OXM TLV.""" |
|
| 475 | hw_address = HWAddress() |
|
| 476 | hw_address.unpack(tlv.oxm_value) |
|
| 477 | addr_str = str(hw_address) |
|
| 478 | value = addr_str |
|
| 479 | if tlv.oxm_hasmask: |
|
| 480 | hw_mask = HWAddress() |
|
| 481 | hw_mask.unpack(tlv.oxm_value[6:]) |
|
| 482 | mask_str = str(hw_mask) |
|
| 483 | value = f'{addr_str}/{mask_str}' |
|
| 484 | return cls(value) |
|
| 485 | ||
| 486 | ||
| 487 | class MatchARPTHA(MatchField): |
|
| @@ 165-204 (lines=40) @@ | ||
| 162 | return cls(value) |
|
| 163 | ||
| 164 | ||
| 165 | class MatchDLDst(MatchField): |
|
| 166 | """Match for datalink destination.""" |
|
| 167 | ||
| 168 | name = 'dl_dst' |
|
| 169 | oxm_field = OxmOfbMatchField.OFPXMT_OFB_ETH_DST |
|
| 170 | ||
| 171 | def as_of_tlv(self): |
|
| 172 | """Return a pyof OXM TLV instance.""" |
|
| 173 | if '/' in self.value: |
|
| 174 | value, mask = self.value.split('/') |
|
| 175 | if mask.upper() == 'FF:FF:FF:FF:FF:FF': |
|
| 176 | mask = None |
|
| 177 | oxm_hasmask = False |
|
| 178 | else: |
|
| 179 | mask = mask.upper() |
|
| 180 | oxm_hasmask = True |
|
| 181 | else: |
|
| 182 | value = self.value |
|
| 183 | mask = None |
|
| 184 | oxm_hasmask = False |
|
| 185 | value_bytes = HWAddress(value).pack() |
|
| 186 | if mask: |
|
| 187 | value_bytes += HWAddress(mask).pack() |
|
| 188 | return OxmTLV(oxm_field=self.oxm_field, |
|
| 189 | oxm_hasmask=oxm_hasmask, |
|
| 190 | oxm_value=value_bytes) |
|
| 191 | ||
| 192 | @classmethod |
|
| 193 | def from_of_tlv(cls, tlv): |
|
| 194 | """Return an instance from a pyof OXM TLV.""" |
|
| 195 | hw_address = HWAddress() |
|
| 196 | hw_address.unpack(tlv.oxm_value) |
|
| 197 | addr_str = str(hw_address) |
|
| 198 | value = addr_str |
|
| 199 | if tlv.oxm_hasmask: |
|
| 200 | hw_mask = HWAddress() |
|
| 201 | hw_mask.unpack(tlv.oxm_value[6:]) |
|
| 202 | mask_str = str(hw_mask) |
|
| 203 | value = f'{addr_str}/{mask_str}' |
|
| 204 | return cls(value) |
|
| 205 | ||
| 206 | ||
| 207 | class MatchDLType(MatchField): |
|
| @@ 123-162 (lines=40) @@ | ||
| 120 | return cls(priority) |
|
| 121 | ||
| 122 | ||
| 123 | class MatchDLSrc(MatchField): |
|
| 124 | """Match for datalink source.""" |
|
| 125 | ||
| 126 | name = 'dl_src' |
|
| 127 | oxm_field = OxmOfbMatchField.OFPXMT_OFB_ETH_SRC |
|
| 128 | ||
| 129 | def as_of_tlv(self): |
|
| 130 | """Return a pyof OXM TLV instance.""" |
|
| 131 | if '/' in self.value: |
|
| 132 | value, mask = self.value.split('/') |
|
| 133 | if mask.upper() == 'FF:FF:FF:FF:FF:FF': |
|
| 134 | mask = None |
|
| 135 | oxm_hasmask = False |
|
| 136 | else: |
|
| 137 | mask = mask.upper() |
|
| 138 | oxm_hasmask = True |
|
| 139 | else: |
|
| 140 | value = self.value |
|
| 141 | mask = None |
|
| 142 | oxm_hasmask = False |
|
| 143 | value_bytes = HWAddress(value).pack() |
|
| 144 | if mask: |
|
| 145 | value_bytes += HWAddress(mask).pack() |
|
| 146 | return OxmTLV(oxm_field=self.oxm_field, |
|
| 147 | oxm_hasmask=oxm_hasmask, |
|
| 148 | oxm_value=value_bytes) |
|
| 149 | ||
| 150 | @classmethod |
|
| 151 | def from_of_tlv(cls, tlv): |
|
| 152 | """Return an instance from a pyof OXM TLV.""" |
|
| 153 | hw_address = HWAddress() |
|
| 154 | hw_address.unpack(tlv.oxm_value) |
|
| 155 | addr_str = str(hw_address) |
|
| 156 | value = addr_str |
|
| 157 | if tlv.oxm_hasmask: |
|
| 158 | hw_mask = HWAddress() |
|
| 159 | hw_mask.unpack(tlv.oxm_value[6:]) |
|
| 160 | mask_str = str(hw_mask) |
|
| 161 | value = f'{addr_str}/{mask_str}' |
|
| 162 | return cls(value) |
|
| 163 | ||
| 164 | ||
| 165 | class MatchDLDst(MatchField): |
|
