def pack (self): rs = [] for k,capabilities in self.iteritems(): for capability in capabilities.extract(): rs.append(concat_strs(chr_(k),chr_(len(capability)),capability)) parameters = b''.join([concat_strs(chr_(2),chr_(len(r)),r) for r in rs]) return concat_strs(chr_(len(parameters)),parameters)
def extract (self): return [concat_strs( chr(len(self.host_name)), self.host_name, chr(len(self.domain_name)), self.domain_name, )]
def __init__ (self, afi, safi, sequence): OperationalFamily.__init__( self, Operational.CODE.NS, afi,safi, concat_strs(sequence,self.ERROR_SUBCODE) )
def _segment (self, seg_type, values, asn4): length = len(values) if length: if length > 255: return self._segment(seg_type,values[:255],asn4) + self._segment(seg_type,values[255:],asn4) return concat_strs(chr(seg_type),chr(len(values)),b''.join([v.pack(asn4) for v in values])) return b""
def message (self,negotiated=None): return self._message(concat_strs( self.version.pack(), self.asn.trans().pack(), self.hold_time.pack(), self.router_id.pack(), self.capabilities.pack() ))
def pack (self, negotiated=None):
flag = self.FLAG
length = len(self.data)
if length > 0xFF:
flag |= Attribute.Flag.EXTENDED_LENGTH
if flag & Attribute.Flag.EXTENDED_LENGTH:
len_value = pack('!H',length)
else:
len_value = chr_(length)
return concat_strs(chr_(flag),chr_(self.ID),len_value,self.data)
def _segment(self, seg_type, values, asn4):
length = len(values)
if length:
if length > 255:
return self._segment(seg_type, values[:255],
asn4) + self._segment(
seg_type, values[255:], asn4)
return concat_strs(chr(seg_type), chr(len(values)),
b''.join([v.pack(asn4) for v in values]))
return b""
def pack(self, negotiated=None):
flag = self.FLAG
length = len(self.data)
if length > 0xFF:
flag |= Attribute.Flag.EXTENDED_LENGTH
if flag & Attribute.Flag.EXTENDED_LENGTH:
len_value = pack('!H', length)
else:
len_value = chr_(length)
return concat_strs(chr_(flag), chr_(self.ID), len_value, self.data)
def _pack(self, packed=None):
if self._packed:
return self._packed
if packed:
self._packed = packed
return packed
self._packed = concat_strs(self.rd.pack(), self.esi.pack(),
self.etag.pack(), self.label.pack())
return self._packed
def _attribute (self, value):
flag = self.FLAG
if flag & Attribute.Flag.OPTIONAL and not value:
return b''
length = len(value)
if length > 0xFF:
flag |= Attribute.Flag.EXTENDED_LENGTH
if flag & Attribute.Flag.EXTENDED_LENGTH:
len_value = pack('!H',length)
else:
len_value = chr_(length)
return concat_strs(chr_(flag),chr_(self.ID),len_value,value)
def message (self, negotiated):
self.sent_routerid = self.routerid if self.routerid else negotiated.sent_open.router_id
if self.sequence is None:
self.sent_sequence = (self.__sequence_number.setdefault(self.routerid,0) + 1) % 0xFFFFFFFF
self.__sequence_number[self.sent_routerid] = self.sent_sequence
else:
self.sent_sequence = self.sequence
return self._message(concat_strs(
self.sent_routerid.pack(),pack('!L',self.sent_sequence),
self.data
))
def _pack(self, packed=None):
if self._packed:
return self._packed
if packed:
self._packed = packed
return packed
self._packed = concat_strs(self.rd.pack(), self.esi.pack(),
chr_(len(self.ip) * 8 if self.ip else 0),
self.ip.pack() if self.ip else b'')
return self._packed
def message(self, negotiated):
self.sent_routerid = self.routerid if self.routerid else negotiated.sent_open.router_id
if self.sequence is None:
self.sent_sequence = (self.__sequence_number.setdefault(
self.routerid, 0) + 1) % 0xFFFFFFFF
self.__sequence_number[self.sent_routerid] = self.sent_sequence
else:
self.sent_sequence = self.sequence
return self._message(
concat_strs(self.sent_routerid.pack(),
pack('!L', self.sent_sequence), self.data))
def _attribute(self, value):
flag = self.FLAG
if flag & Attribute.Flag.OPTIONAL and not value:
return b''
length = len(value)
if length > 0xFF:
flag |= Attribute.Flag.EXTENDED_LENGTH
if flag & Attribute.Flag.EXTENDED_LENGTH:
len_value = pack('!H', length)
else:
len_value = chr_(length)
return concat_strs(chr_(flag), chr_(self.ID), len_value, value)
def pack (self, negotiated=None):
ordered_rules = []
# the order is a RFC requirement
for ID in sorted(self.rules.keys()):
rules = self.rules[ID]
# for each component get all the operation to do
# the format use does not prevent two opposing rules meaning that no packet can ever match
for rule in rules:
rule.operations &= (CommonOperator.EOL ^ 0xFF)
rules[-1].operations |= CommonOperator.EOL
# and add it to the last rule
if ID not in (FlowDestination.ID,FlowSource.ID):
ordered_rules.append(chr_(ID))
ordered_rules.append(b''.join(rule.pack() for rule in rules))
components = self.rd.pack() + b''.join(ordered_rules)
l = len(components)
if l < 0xF0:
return concat_strs(chr_(l),components)
if l < 0x0FFF:
return concat_strs(pack('!H',l | 0xF000),components)
raise Notify(3,0,"my administrator attempted to announce a Flow Spec rule larger than encoding allows, protecting the innocent the only way I can")
def unpack(cls,data,pattern):
pad = pattern.count('RSV')
repeat = len(pattern) - pad
flag_array = binascii.b2a_hex(data)
hex_rep = hex(int(flag_array, 16))
bit_array = BitArray(hex_rep)
valid_flags = [concat_strs(''.join(item), ''.join(itertools.repeat('0',pad)))
for item in itertools.product('01', repeat=repeat)]
valid_flags.append('0000')
if bit_array.bin in valid_flags:
flags = dict(zip(pattern, bit_array.bin))
flags = {k:int(v) for k, v in flags.items()}
else:
raise Notify(3,5, "Invalid SR flags mask")
return cls(flags=flags)
def _pack (self, packed=None): if self._packed: return self._packed if packed: self._packed = packed return packed self._packed = concat_strs( self.rd.pack(), self.esi.pack(), chr_(len(self.ip)*8 if self.ip else 0), self.ip.pack() if self.ip else b'' ) return self._packed
def pack (self, negotiated=None):
return concat_strs(
'\x00\x11', # pack('!H',17)
self.rd.pack(),
pack(
'!HHH',
self.endpoint,
self.offset,
self.size
),
pack(
'!L',
(self.base << 4) | 0x1
)[1:] # setting the bottom of stack, should we ?
)
def _pack (self, packed=None): if self._packed: return self._packed if packed: self._packed = packed return packed self._packed = concat_strs( self.rd.pack(), self.etag.pack(), chr_(len(self.ip)*8), self.ip.pack() ) return self._packed
def _pack (self, packed=None): if self._packed: return self._packed if packed: self._packed = packed return packed self._packed = concat_strs( self.rd.pack(), self.esi.pack(), self.etag.pack(), self.label.pack() ) return self._packed
def unpack(cls,data,pattern):
pad = pattern.count('RSV')
repeat = len(pattern) - pad
flag_array = binascii.b2a_hex(data)
hex_rep = hex(int(flag_array, 16))
bit_array = BitArray(hex_rep)
valid_flags = [concat_strs(''.join(item), ''.join(itertools.repeat('0',pad)))
for item in itertools.product('01', repeat=repeat)]
valid_flags.append('0000')
if bit_array.bin in valid_flags:
flags = dict(zip(pattern, bit_array.bin))
flags = dict((k, int(v)) for k, v in flags.items())
else:
raise Notify(3,5, "Invalid SR flags mask")
return cls(flags=flags)
def _pack(self, packed=None):
if self._packed:
return self._packed
if packed:
self._packed = packed
return packed
self._packed = concat_strs(
self.rd.pack(),
self.esi.pack(),
self.etag.pack(),
chr_(self.maclen), # only 48 supported by the draft
self.mac.pack(),
chr_(len(self.ip) * 8 if self.ip else 0),
self.ip.pack() if self.ip else b'',
self.label.pack())
return self._packed
def _pack (self, packed=None): if self._packed: return self._packed if packed: self._packed = packed return packed self._packed = concat_strs( self.rd.pack(), self.esi.pack(), self.etag.pack(), chr_(self.maclen), # only 48 supported by the draft self.mac.pack(), chr_(len(self.ip)*8 if self.ip else 0), self.ip.pack() if self.ip else b'', self.label.pack() ) return self._packed
def pack (self): # ID is defined in subclasses return concat_strs(chr_(self.ID),chr_(self.cidr.mask),chr_(self.offset),self.cidr.pack_ip()) # pylint: disable=E1101
def from_rt(cls, route_target): packed = route_target.pack() return cls.unpack(concat_strs(packed[0:1], chr_(cls.COMMUNITY_SUBTYPE), packed[2:]))
def _message (self, data): return Operational._message(self,concat_strs( self.afi.pack(), self.safi.pack(), data ))
def pack (self): l,v = self.encode(self.value) op = self.operations | _len_to_bit(l) return concat_strs(chr_(op),v)
def from_rt(cls, route_target):
packed = route_target.pack()
return cls.unpack(
concat_strs(packed[0:1], chr_(cls.COMMUNITY_SUBTYPE), packed[2:]))
def _message (self, message):
message_len = pack('!H',19+len(message))
return concat_strs(self.MARKER,message_len,self.TYPE,message)
def message (self,negotiated=None): return self._message(concat_strs( chr_(self.code), chr_(self.subcode), self.data ))
def message(self, negotiated=None):
return self._message(
concat_strs(self.afi.pack(), chr(self.reserved), self.safi.pack()))
def prefix (data):
# This function needs renaming
return concat_strs(pack('!H',len(data)),data)
def _message(self, data):
return Message._message(
self, concat_strs(self.what.pack(), pack('!H', len(data)), data))
def _message (self, data):
return Message._message(self,concat_strs(
self.what.pack(),
pack('!H',len(data)),
data
))
def _message(self, message):
message_len = pack('!H', 19 + len(message))
return concat_strs(self.MARKER, message_len, self.TYPE, message)
def pack (self):
return b''.join(concat_strs(chr_(tlv.type),pack('!H',len(tlv.value)+3),tlv.value) for tlv in self)
def pack (self): raw = self.cidr.pack_nlri() # ID is defined in subclasses return concat_strs(chr_(self.ID),raw) # pylint: disable=E1101
def _message(self, data):
return Operational._message(
self, concat_strs(self.afi.pack(), self.safi.pack(), data))
def message(self, negotiated=None):
return self._message(
concat_strs(chr_(self.code), chr_(self.subcode), self.data))
def message (self,negotiated=None): return self._message(concat_strs(self.afi.pack(),chr(self.reserved),self.safi.pack()))
def __init__(self, afi, safi, sequence):
OperationalFamily.__init__(
self, Operational.CODE.NS, afi, safi,
concat_strs(sequence, self.ERROR_SUBCODE))
def extract (self):
restart = pack('!H',((self.restart_flag << 12) | (self.restart_time & Graceful.TIME_MASK)))
families = [(afi.pack(),safi.pack(),chr(self[(afi,safi)])) for (afi,safi) in self.keys()]
sfamilies = b''.join([concat_strs(pafi,psafi,family) for (pafi,psafi,family) in families])
return [concat_strs(restart,sfamilies)]
