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)]