openstack
/
os-ken
Code Issues Proposed changes
os-ken/os_ken/lib/packet/vrrp.py

645 lines
24 KiB
Python
Raw Blame History

# Copyright (C) 2013 Nippon Telegraph and Telephone Corporation.
# Copyright (C) 2013 Isaku Yamahata <yamahata at private email ne jp>
#
# Licensed under the Apache License, Version 2.0 (the "License");
# you may not use this file except in compliance with the License.
# You may obtain a copy of the License at
#
# http://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applicable law or agreed to in writing, software
# distributed under the License is distributed on an "AS IS" BASIS,
# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
# implied.
# See the License for the specific language governing permissions and
# limitations under the License.
"""
VRRP packet parser/serializer
[RFC 3768] VRRP v2 packet format::
0 1 2 3
0 1 2 3 4 5 6 7 8 9 0 1 2 3 4 5 6 7 8 9 0 1 2 3 4 5 6 7 8 9 0 1
+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
|Version| Type | Virtual Rtr ID| Priority | Count IP Addrs|
+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
| Auth Type | Adver Int | Checksum |
+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
| IP Address (1) |
+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
| . |
| . |
| . |
+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
| IP Address (n) |
+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
| Authentication Data (1) |
+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
| Authentication Data (2) |
+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
[RFC 5798] VRRP v3 packet format::
0 1 2 3
0 1 2 3 4 5 6 7 8 9 0 1 2 3 4 5 6 7 8 9 0 1 2 3 4 5 6 7 8 9 0 1
+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
| IPv4 Fields or IPv6 Fields |
... ...
| |
+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
|Version| Type | Virtual Rtr ID| Priority |Count IPvX Addr|
+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
|(rsvd) | Max Adver Int | Checksum |
+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
| |
+ +
| IPvX Address(es) |
+ +
+ +
+ +
+ +
| |
+ +
| |
+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
"""
import struct
from os_ken.lib.packet import ethernet
from os_ken.lib.packet import ether_types as ether
from os_ken.lib.packet import in_proto as inet
from os_ken.lib.packet import ipv4
from os_ken.lib.packet import ipv6
from os_ken.lib.packet import packet
from os_ken.lib.packet import packet_base
from os_ken.lib.packet import packet_utils
from os_ken.lib.packet import vlan
from os_ken.lib import addrconv
# IPv4
# the LSB 8 bits is used for VRID
VRRP_IPV4_SRC_MAC_ADDRESS_FMT = '00:00:5E:00:01:%02x'
VRRP_IPV4_DST_MAC_ADDRESS = '01:00:5E:00:00:12'
VRRP_IPV4_DST_ADDRESS = '224.0.0.18'
VRRP_IPV4_TTL = 255
def vrrp_ipv4_src_mac_address(vrid):
return VRRP_IPV4_SRC_MAC_ADDRESS_FMT % vrid
# IPv6
# the LSB 8 bits is used for VRID
VRRP_IPV6_SRC_MAC_ADDRESS_FMT = '00:00:5E:00:02:%02x'
VRRP_IPV6_DST_MAC_ADDRESS = '33:33:00:00:00:12'
VRRP_IPV6_DST_ADDRESS = 'ff02::12'
VRRP_IPV6_HOP_LIMIT = 255
def vrrp_ipv6_src_mac_address(vrid):
return VRRP_IPV6_SRC_MAC_ADDRESS_FMT % vrid
VRRP_VERSION_SHIFT = 4
VRRP_TYPE_MASK = 0xf
def vrrp_from_version_type(version_type):
return (version_type >> VRRP_VERSION_SHIFT, version_type & VRRP_TYPE_MASK)
def vrrp_to_version_type(version, type_):
return (version << VRRP_VERSION_SHIFT) | type_
# VRRP version
VRRP_VERSION_V2 = 2
VRRP_VERSION_V3 = 3
# VRRP type
VRRP_TYPE_ADVERTISEMENT = 1
# VRRP VRID: 0 isn't used
VRRP_VRID_MIN = 1
VRRP_VRID_MAX = 255
# VRRP priority
VRRP_PRIORITY_MIN = 0
VRRP_PRIORITY_MAX = 255
VRRP_PRIORITY_RELEASE_RESPONSIBILITY = 0
VRRP_PRIORITY_BACKUP_MIN = 1
VRRP_PRIORITY_BACKUP_DEFAULT = 100
VRRP_PRIORITY_BACKUP_MAX = 254
VRRP_PRIORITY_ADDRESS_OWNER = 255
# VRRP auth type (VRRP v2 only)
VRRP_AUTH_NO_AUTH = 0
VRRP_AUTH_RESERVED1 = 1
VRRP_AUTH_RESERVED2 = 2
VRRP_AUTH_DATA1 = 0
VRRP_AUTH_DATA2 = 0
VRRP_AUTH_DATA = (VRRP_AUTH_DATA1, VRRP_AUTH_DATA2)
# VRRP Max advertisement interval
VRRP_MAX_ADVER_INT_DEFAULT_IN_SEC = 1 # 1 second
VRRP_V3_MAX_ADVER_INT_MASK = 0xfff # in centiseconds
VRRP_V3_MAX_ADVER_INT_DEFAULT = 100 # = 1 second
VRRP_V3_MAX_ADVER_INT_MIN = 1 # don't allow 0
VRRP_V3_MAX_ADVER_INT_MAX = 0xfff
VRRP_V2_MAX_ADVER_INT_MASK = 0xff # in seconds
VRRP_V2_MAX_ADVER_INT_DEFAULT = 1 # 1 second
VRRP_V2_MAX_ADVER_INT_MIN = 1 # don't allow 0
VRRP_V2_MAX_ADVER_INT_MAX = 0xff
def is_ipv6(ip_address):
assert type(ip_address) == str
try:
addrconv.ipv4.text_to_bin(ip_address)
except:
addrconv.ipv6.text_to_bin(ip_address) # sanity
return True
return False
def ip_text_to_bin(ip_text):
if is_ipv6(ip_text):
return addrconv.ipv6.text_to_bin(ip_text)
else:
return addrconv.ipv4.text_to_bin(ip_text)
# This is used for master selection
def ip_address_lt(ip1, ip2):
return ip_text_to_bin(ip1) < ip_text_to_bin(ip2)
class vrrp(packet_base.PacketBase):
"""The base class for VRRPv2 (RFC 3768) and VRRPv3 (RFC 5798)
header encoder/decoder classes.
Unlike other os_ken.lib.packet.packet_base.PacketBase derived classes,
This class should not be directly instantiated by user.
An instance has the following attributes at least.
Most of them are same to the on-wire counterparts but in host byte order.
============== ====================
Attribute Description
============== ====================
version Version
type Type
vrid Virtual Rtr ID (VRID)
priority Priority
count_ip Count IPvX Addr. \
Calculated automatically when encoding.
max_adver_int Maximum Advertisement Interval (Max Adver Int)
checksum Checksum. \
Calculated automatically when encoding.
ip_addresses IPvX Address(es). A python list of IP addresses.
auth_type Authentication Type (only for VRRPv2)
auth_data Authentication Data (only for VRRPv2)
============== ====================
"""
_VERSION_PACK_STR = '!B'
_IPV4_ADDRESS_PACK_STR_RAW = '4s'
_IPV4_ADDRESS_PACK_STR = '!' + _IPV4_ADDRESS_PACK_STR_RAW
_IPV4_ADDRESS_LEN = struct.calcsize(_IPV4_ADDRESS_PACK_STR)
_IPV6_ADDRESS_LEN = 16
_IPV6_ADDRESS_PACK_STR_RAW = '%ds' % _IPV6_ADDRESS_LEN
_IPV6_ADDRESS_PACK_STR = '!' + _IPV6_ADDRESS_PACK_STR_RAW
_IPV6_ADDRESS_LEN = struct.calcsize(_IPV6_ADDRESS_PACK_STR)
_VRRP_VERSIONS = {}
_SEC_IN_MAX_ADVER_INT_UNIT = {}
@staticmethod
def get_payload(packet_):
may_ip = None
may_vrrp = None
idx = 0
for protocol in packet_:
if isinstance(protocol, ipv4.ipv4) or isinstance(protocol,
ipv6.ipv6):
may_ip = protocol
try:
if isinstance(packet_.protocols[idx + 1], vrrp):
may_vrrp = packet_.protocols[idx + 1]
finally:
break
idx += 1
if may_ip and may_vrrp:
return may_ip, may_vrrp
else:
return None, None
@classmethod
def register_vrrp_version(cls, version,
sec_in_max_adver_int_unit):
def _register_vrrp_version(cls_):
cls._VRRP_VERSIONS[version] = cls_
cls._SEC_IN_MAX_ADVER_INT_UNIT[version] = sec_in_max_adver_int_unit
return cls_
return _register_vrrp_version
@staticmethod
def sec_to_max_adver_int(version, seconds):
return int(seconds * vrrp._SEC_IN_MAX_ADVER_INT_UNIT[version])
@staticmethod
def max_adver_int_to_sec(version, max_adver_int):
return float(max_adver_int) / vrrp._SEC_IN_MAX_ADVER_INT_UNIT[version]
def __init__(self, version, type_, vrid, priority, count_ip,
max_adver_int, checksum, ip_addresses,
# auth_type/auth_data is for vrrp v2
auth_type=None, auth_data=None):
super(vrrp, self).__init__()
self.version = version
self.type = type_
self.vrid = vrid
self.priority = priority
self.count_ip = count_ip
self.max_adver_int = max_adver_int
self.checksum = checksum
self.ip_addresses = ip_addresses
assert len(list(ip_addresses)) == self.count_ip
self.auth_type = auth_type
self.auth_data = auth_data
self._is_ipv6 = is_ipv6(list(self.ip_addresses)[0])
self.identification = 0 # used for ipv4 identification
def checksum_ok(self, ipvx, vrrp_buf):
cls_ = self._VRRP_VERSIONS[self.version]
return cls_.checksum_ok(self, ipvx, vrrp_buf)
@property
def max_adver_int_in_sec(self):
# return seconds of float as time.sleep() accepts such type.
return self.max_adver_int_to_sec(self.version, self.max_adver_int)
@property
def is_ipv6(self):
return self._is_ipv6
def __len__(self):
cls_ = self._VRRP_VERSIONS[self.version]
return cls_.__len__(self)
@staticmethod
def create_version(version, type_, vrid, priority, max_adver_int,
ip_addresses, auth_type=None, auth_data=None):
cls_ = vrrp._VRRP_VERSIONS.get(version, None)
if not cls_:
raise ValueError('unknown VRRP version %d' % version)
if priority is None:
priority = VRRP_PRIORITY_BACKUP_DEFAULT
count_ip = len(ip_addresses)
if max_adver_int is None:
max_adver_int = cls_.sec_to_max_adver_int(
VRRP_MAX_ADVER_INT_DEFAULT_IN_SEC)
return cls_(version, type_, vrid, priority, count_ip, max_adver_int,
None, ip_addresses,
auth_type=auth_type, auth_data=auth_data)
def get_identification(self):
self.identification += 1
self.identification &= 0xffff
if self.identification == 0:
self.identification += 1
self.identification &= 0xffff
return self.identification
def create_packet(self, primary_ip_address, vlan_id=None):
"""Prepare a VRRP packet.
Returns a newly created os_ken.lib.packet.packet.Packet object
with appropriate protocol header objects added by add_protocol().
It's caller's responsibility to serialize().
The serialized packet would looks like the ones described in
the following sections.
* RFC 3768 5.1. VRRP Packet Format
* RFC 5798 5.1. VRRP Packet Format
================== ====================
Argument Description
================== ====================
primary_ip_address Source IP address
vlan_id VLAN ID. None for no VLAN.
================== ====================
"""
if self.is_ipv6:
traffic_class = 0xc0 # set tos to internetwork control
flow_label = 0
payload_length = ipv6.ipv6._MIN_LEN + len(self) # XXX _MIN_LEN
e = ethernet.ethernet(VRRP_IPV6_DST_MAC_ADDRESS,
vrrp_ipv6_src_mac_address(self.vrid),
ether.ETH_TYPE_IPV6)
ip = ipv6.ipv6(6, traffic_class, flow_label, payload_length,
inet.IPPROTO_VRRP, VRRP_IPV6_HOP_LIMIT,
primary_ip_address, VRRP_IPV6_DST_ADDRESS)
else:
header_length = ipv4.ipv4._MIN_LEN // 4 # XXX _MIN_LEN
total_length = 0
tos = 0xc0 # set tos to internetwork control
identification = self.get_identification()
e = ethernet.ethernet(VRRP_IPV4_DST_MAC_ADDRESS,
vrrp_ipv4_src_mac_address(self.vrid),
ether.ETH_TYPE_IP)
ip = ipv4.ipv4(4, header_length, tos, total_length, identification,
0, 0, VRRP_IPV4_TTL, inet.IPPROTO_VRRP, 0,
primary_ip_address, VRRP_IPV4_DST_ADDRESS)
p = packet.Packet()
p.add_protocol(e)
if vlan_id is not None:
vlan_ = vlan.vlan(0, 0, vlan_id, e.ethertype)
e.ethertype = ether.ETH_TYPE_8021Q
p.add_protocol(vlan_)
p.add_protocol(ip)
p.add_protocol(self)
return p
@classmethod
def parser(cls, buf):
(version_type,) = struct.unpack_from(cls._VERSION_PACK_STR, buf)
version, _type = vrrp_from_version_type(version_type)
cls_ = cls._VRRP_VERSIONS[version]
return cls_.parser(buf)
@staticmethod
def serialize_static(vrrp_, prev):
# self can be a instance of vrrpv2 or vrrpv3.
assert isinstance(vrrp_, vrrp)
cls = vrrp._VRRP_VERSIONS[vrrp_.version]
return cls.serialize_static(vrrp_, prev)
def serialize(self, payload, prev):
return self.serialize_static(self, prev)
@staticmethod
def is_valid_ttl(ipvx):
version = ipvx.version
if version == 4:
return ipvx.ttl == VRRP_IPV4_TTL
if version == 6:
return ipvx.hop_limit == VRRP_IPV6_HOP_LIMIT
raise ValueError('invalid ip version %d' % version)
def is_valid(self):
cls = self._VRRP_VERSIONS.get(self.version, None)
if cls is None:
return False
return cls.is_valid(self)
# max_adver_int is in seconds
@vrrp.register_vrrp_version(VRRP_VERSION_V2, 1)
class vrrpv2(vrrp):
"""VRRPv2 (RFC 3768) header encoder/decoder class.
Unlike other os_ken.lib.packet.packet_base.PacketBase derived classes,
*create* method should be used to instantiate an object of this class.
"""
_PACK_STR = '!BBBBBBH'
_MIN_LEN = struct.calcsize(_PACK_STR)
_CHECKSUM_PACK_STR = '!H'
_CHECKSUM_OFFSET = 6
_AUTH_DATA_PACK_STR = '!II'
_AUTH_DATA_LEN = struct.calcsize('!II')
def __len__(self):
return (self._MIN_LEN + self._IPV4_ADDRESS_LEN * self.count_ip +
self._AUTH_DATA_LEN)
def checksum_ok(self, ipvx, vrrp_buf):
return packet_utils.checksum(vrrp_buf) == 0
@staticmethod
def create(type_, vrid, priority, max_adver_int, ip_addresses):
"""Unlike other os_ken.lib.packet.packet_base.PacketBase derived classes,
this method should be used to instantiate an object of this class.
This method's arguments are same as os_ken.lib.packet.vrrp.vrrp object's
attributes of the same name. (except that *type_* corresponds to
*type* attribute.)
"""
return vrrp.create_version(VRRP_VERSION_V2, type_, vrid, priority,
max_adver_int,
ip_addresses,
auth_type=VRRP_AUTH_NO_AUTH,
auth_data=VRRP_AUTH_DATA)
@staticmethod
def _ip_addresses_pack_str(count_ip):
return '!' + vrrpv2._IPV4_ADDRESS_PACK_STR_RAW * count_ip
@classmethod
def parser(cls, buf):
(version_type, vrid, priority, count_ip, auth_type, adver_int,
checksum) = struct.unpack_from(cls._PACK_STR, buf)
(version, type_) = vrrp_from_version_type(version_type)
offset = cls._MIN_LEN
ip_addresses_pack_str = cls._ip_addresses_pack_str(count_ip)
ip_addresses_bin = struct.unpack_from(ip_addresses_pack_str, buf,
offset)
ip_addresses = [addrconv.ipv4.bin_to_text(x) for x in ip_addresses_bin]
offset += struct.calcsize(ip_addresses_pack_str)
auth_data = struct.unpack_from(cls._AUTH_DATA_PACK_STR, buf, offset)
msg = cls(version, type_, vrid, priority, count_ip, adver_int,
checksum, ip_addresses, auth_type, auth_data)
return msg, None, buf[len(msg):]
@staticmethod
def serialize_static(vrrp_, prev):
assert not vrrp_.is_ipv6 # vrrpv2 defines only IPv4
ip_addresses_pack_str = vrrpv2._ip_addresses_pack_str(vrrp_.count_ip)
ip_addresses_len = struct.calcsize(ip_addresses_pack_str)
vrrp_len = vrrpv2._MIN_LEN + ip_addresses_len + vrrpv2._AUTH_DATA_LEN
checksum = False
if vrrp_.checksum is None:
checksum = True
vrrp_.checksum = 0
if vrrp_.auth_type is None:
vrrp_.auth_type = VRRP_AUTH_NO_AUTH
if vrrp_.auth_data is None:
vrrp_.auth_data = VRRP_AUTH_DATA
buf = bytearray(vrrp_len)
offset = 0
struct.pack_into(vrrpv2._PACK_STR, buf, offset,
vrrp_to_version_type(vrrp_.version, vrrp_.type),
vrrp_.vrid, vrrp_.priority,
vrrp_.count_ip, vrrp_.auth_type, vrrp_.max_adver_int,
vrrp_.checksum)
offset += vrrpv2._MIN_LEN
struct.pack_into(ip_addresses_pack_str, buf, offset,
*[addrconv.ipv4.text_to_bin(x) for x in vrrp_.ip_addresses])
offset += ip_addresses_len
struct.pack_into(vrrpv2._AUTH_DATA_PACK_STR, buf, offset,
*vrrp_.auth_data)
if checksum:
vrrp_.checksum = packet_utils.checksum(buf)
struct.pack_into(vrrpv2._CHECKSUM_PACK_STR, buf,
vrrpv2._CHECKSUM_OFFSET, vrrp_.checksum)
return buf
def is_valid(self):
return (self.version == VRRP_VERSION_V2 and
self.type == VRRP_TYPE_ADVERTISEMENT and
VRRP_VRID_MIN <= self.vrid and self.vrid <= VRRP_VRID_MAX and
VRRP_PRIORITY_MIN <= self.priority and
self.priority <= VRRP_PRIORITY_MAX and
self.auth_type == VRRP_AUTH_NO_AUTH and
VRRP_V2_MAX_ADVER_INT_MIN <= self.max_adver_int and
self.max_adver_int <= VRRP_V2_MAX_ADVER_INT_MAX and
self.count_ip == len(self.ip_addresses))
# max_adver_int is in centi seconds: 1 second = 100 centiseconds
@vrrp.register_vrrp_version(VRRP_VERSION_V3, 100)
class vrrpv3(vrrp):
"""VRRPv3 (RFC 5798) header encoder/decoder class.
Unlike other os_ken.lib.packet.packet_base.PacketBase derived classes,
*create* method should be used to instantiate an object of this class.
"""
_PACK_STR = '!BBBBHH'
_MIN_LEN = struct.calcsize(_PACK_STR)
_CHECKSUM_PACK_STR = '!H'
_CHECKSUM_OFFSET = 6
def __len__(self):
if self.is_ipv6:
address_len = self._IPV6_ADDRESS_LEN
else:
address_len = self._IPV4_ADDRESS_LEN
return self._MIN_LEN + address_len * self.count_ip
def checksum_ok(self, ipvx, vrrp_buf):
# There are two interpretation of IPv4 checksum
# include IPv4 pseudo header or not.
# http://www.ietf.org/mail-archive/web/vrrp/current/msg01473.html
# if not self.is_ipv6:
# return packet_utils.checksum(vrrp_buf) == 0
return packet_utils.checksum_ip(ipvx, len(self), vrrp_buf) == 0
@staticmethod
def create(type_, vrid, priority, max_adver_int, ip_addresses):
"""Unlike other os_ken.lib.packet.packet_base.PacketBase derived classes,
this method should be used to instantiate an object of this class.
This method's arguments are same as os_ken.lib.packet.vrrp.vrrp object's
attributes of the same name. (except that *type_* corresponds to
*type* attribute.)
"""
return vrrp.create_version(VRRP_VERSION_V3, type_, vrid, priority,
max_adver_int, ip_addresses)
@classmethod
def parser(cls, buf):
(version_type, vrid, priority, count_ip, max_adver_int,
checksum) = struct.unpack_from(cls._PACK_STR, buf)
(version, type_) = vrrp_from_version_type(version_type)
# _rsvd = (max_adver_int & ~VRRP_V3_MAX_ADVER_INT_MASK) >> 12
# asssert _rsvd == 0
max_adver_int &= VRRP_V3_MAX_ADVER_INT_MASK
offset = cls._MIN_LEN
address_len = (len(buf) - offset) // count_ip
# Address version (IPv4 or IPv6) is determined by network layer
# header type.
# Unfortunately it isn't available. Guess it by vrrp packet length.
if address_len == cls._IPV4_ADDRESS_LEN:
pack_str = '!' + cls._IPV4_ADDRESS_PACK_STR_RAW * count_ip
conv = addrconv.ipv4.bin_to_text
elif address_len == cls._IPV6_ADDRESS_LEN:
pack_str = '!' + cls._IPV6_ADDRESS_PACK_STR_RAW * count_ip
conv = addrconv.ipv6.bin_to_text
else:
raise ValueError(
'unknown address version address_len %d count_ip %d' % (
address_len, count_ip))
ip_addresses_bin = struct.unpack_from(pack_str, buf, offset)
ip_addresses = [conv(x) for x in ip_addresses_bin]
msg = cls(version, type_, vrid, priority,
count_ip, max_adver_int, checksum, ip_addresses)
return msg, None, buf[len(msg):]
@staticmethod
def serialize_static(vrrp_, prev):
if isinstance(prev, ipv4.ipv4):
assert type(vrrp_.ip_addresses[0]) == str
conv = addrconv.ipv4.text_to_bin
ip_address_pack_raw = vrrpv3._IPV4_ADDRESS_PACK_STR_RAW
elif isinstance(prev, ipv6.ipv6):
assert type(vrrp_.ip_addresses[0]) == str
conv = addrconv.ipv6.text_to_bin
ip_address_pack_raw = vrrpv3._IPV6_ADDRESS_PACK_STR_RAW
else:
raise ValueError('Unkown network layer %s' % type(prev))
ip_addresses_pack_str = '!' + ip_address_pack_raw * vrrp_.count_ip
ip_addresses_len = struct.calcsize(ip_addresses_pack_str)
vrrp_len = vrrpv3._MIN_LEN + ip_addresses_len
checksum = False
if vrrp_.checksum is None:
checksum = True
vrrp_.checksum = 0
buf = bytearray(vrrp_len)
assert vrrp_.max_adver_int <= VRRP_V3_MAX_ADVER_INT_MASK
struct.pack_into(vrrpv3._PACK_STR, buf, 0,
vrrp_to_version_type(vrrp_.version, vrrp_.type),
vrrp_.vrid, vrrp_.priority,
vrrp_.count_ip, vrrp_.max_adver_int, vrrp_.checksum)
struct.pack_into(ip_addresses_pack_str, buf, vrrpv3._MIN_LEN,
*[conv(x) for x in vrrp_.ip_addresses])
if checksum:
vrrp_.checksum = packet_utils.checksum_ip(prev, len(buf), buf)
struct.pack_into(vrrpv3._CHECKSUM_PACK_STR, buf,
vrrpv3._CHECKSUM_OFFSET, vrrp_.checksum)
return buf
def is_valid(self):
return (self.version == VRRP_VERSION_V3 and
self.type == VRRP_TYPE_ADVERTISEMENT and
VRRP_VRID_MIN <= self.vrid and self.vrid <= VRRP_VRID_MAX and
VRRP_PRIORITY_MIN <= self.priority and
self.priority <= VRRP_PRIORITY_MAX and
VRRP_V3_MAX_ADVER_INT_MIN <= self.max_adver_int and
self.max_adver_int <= VRRP_V3_MAX_ADVER_INT_MAX and
self.count_ip == len(self.ip_addresses))
ipv4.ipv4.register_packet_type(vrrp, inet.IPPROTO_VRRP)
ipv6.ipv6.register_packet_type(vrrp, inet.IPPROTO_VRRP)
View Git Blame Copy Permalink