def test_decoding_udpate_asn4 (self):
try:
for asn4,body in bodies:
if not asn4: continue
Update.unpack_message(''.join(chr(_) for _ in body),self.negotiated[asn4])
except Notify:
self.assertEqual(1,0)
def check_update (neighbor, raw):
from exabgp.logger import Logger
logger = Logger()
logger._parser = True
logger.parser('\ndecoding routes in configuration')
n = neighbor[neighbor.keys()[0]]
p = Peer(n,None)
path = {}
for f in known_families():
if n.add_path:
path[f] = n.add_path
capa = Capabilities().new(n,False)
capa[Capability.CODE.ADD_PATH] = path
capa[Capability.CODE.MULTIPROTOCOL] = n.families()
routerid_1 = str(n.router_id)
routerid_2 = '.'.join(str((int(_)+1) % 250) for _ in str(n.router_id).split('.',-1))
o1 = Open(4,n.local_as,routerid_1,capa,180)
o2 = Open(4,n.peer_as,routerid_2,capa,180)
negotiated = Negotiated(n)
negotiated.sent(o1)
negotiated.received(o2)
# grouped = False
while raw:
if raw.startswith('\xff'*16):
kind = ord(raw[18])
size = (ord(raw[16]) << 16) + (ord(raw[17]))
injected,raw = raw[19:size],raw[size:]
if kind == 2:
logger.parser('the message is an update')
decoding = 'update'
else:
logger.parser('the message is not an update (%d) - aborting' % kind)
return False
else:
logger.parser('header missing, assuming this message is ONE update')
decoding = 'update'
injected,raw = raw,''
try:
# This does not take the BGP header - let's assume we will not break that :)
update = Update.unpack_message(injected,negotiated)
except KeyboardInterrupt:
raise
except Notify,exc:
logger.parser('could not parse the message')
logger.parser(str(exc))
return False
except Exception,exc:
logger.parser('could not parse the message')
logger.parser(str(exc))
return False
def check_update (neighbor, raw):
from exabgp.logger import Logger
logger = Logger()
logger._parser = True
logger.parser('\ndecoding routes in configuration')
n = neighbor[neighbor.keys()[0]]
p = Peer(n,None)
path = {}
for f in known_families():
if n.add_path:
path[f] = n.add_path
capa = Capabilities().new(n,False)
capa[Capability.CODE.ADD_PATH] = path
capa[Capability.CODE.MULTIPROTOCOL] = n.families()
routerid_1 = str(n.router_id)
routerid_2 = '.'.join(str((int(_)+1) % 250) for _ in str(n.router_id).split('.',-1))
o1 = Open(4,n.local_as,routerid_1,capa,180)
o2 = Open(4,n.peer_as,routerid_2,capa,180)
negotiated = Negotiated(n)
negotiated.sent(o1)
negotiated.received(o2)
# grouped = False
while raw:
if raw.startswith('\xff'*16):
kind = ord(raw[18])
size = (ord(raw[16]) << 16) + (ord(raw[17]))
injected,raw = raw[19:size],raw[size:]
if kind == 2:
logger.parser('the message is an update')
decoding = 'update'
else:
logger.parser('the message is not an update (%d) - aborting' % kind)
return False
else:
logger.parser('header missing, assuming this message is ONE update')
decoding = 'update'
injected,raw = raw,''
try:
# This does not take the BGP header - let's assume we will not break that :)
update = Update.unpack_message(injected,negotiated)
except KeyboardInterrupt:
raise
except Notify,exc:
logger.parser('could not parse the message','error')
logger.parser(str(exc),'error')
return False
except Exception,exc:
logger.parser('could not parse the message','error')
logger.parser(str(exc),'error')
return False
def send(self, raw):
if self.neighbor.api.get('send-%d' % ord(raw[19]), False):
message = Update.unpack_message(raw[19:], self.negotiated)
self._to_api('send', message, raw)
for boolean in self.connection.writer(raw):
yield boolean
def send (self,raw):
if self.neighbor.api.get('send-%d' % ord(raw[19]),False):
message = Update.unpack_message(raw[19:],self.negotiated)
self._to_api('send',message,raw)
for boolean in self.connection.writer(raw):
yield boolean
def check_update(neighbor, raw):
from exabgp.logger import Logger
logger = Logger()
logger._parser = True
logger.parser("\ndecoding routes in configuration")
n = neighbor[neighbor.keys()[0]]
p = Peer(n, None)
path = {}
for f in known_families():
if n.add_path:
path[f] = n.add_path
capa = Capabilities().new(n, False)
capa[Capability.ID.ADD_PATH] = path
capa[Capability.ID.MULTIPROTOCOL_EXTENSIONS] = n.families()
o1 = Open(4, n.local_as, str(n.local_address), capa, 180)
o2 = Open(4, n.peer_as, str(n.peer_address), capa, 180)
negotiated = Negotiated(n)
negotiated.sent(o1)
negotiated.received(o2)
# grouped = False
while raw:
if raw.startswith("\xff" * 16):
kind = ord(raw[18])
size = (ord(raw[16]) << 16) + (ord(raw[17]))
injected, raw = raw[19:size], raw[size:]
if kind == 2:
logger.parser("the message is an update")
decoding = "update"
else:
logger.parser("the message is not an update (%d) - aborting" % kind)
return False
else:
logger.parser("header missing, assuming this message is ONE update")
decoding = "update"
injected, raw = raw, ""
try:
# This does not take the BGP header - let's assume we will not break that :)
update = Update.unpack_message(injected, negotiated)
except KeyboardInterrupt:
raise
except Notify, e:
logger.parser("could not parse the message")
logger.parser(str(e))
return False
except Exception, e:
logger.parser("could not parse the message")
logger.parser(str(e))
return False
def _route (self, header):
bgp_header = self._read_data(19)
if bgp_header is None:
self.close()
return
length = unpack('!H',bgp_header[16:18])[0] - 19
bgp_body = self._read_data(length)
if bgp_body is None:
self.close()
return
negotiated = FakeNegotiated(header,self.asn4)
update = Update.unpack_message(bgp_body,negotiated)
if self.use_json:
print >> self.fd, self.json.bmp(self.ip,update)
else:
for route in update.routes:
print >> self.fd, route.extensive()
def _route(self, header):
bgp_header = self._read_data(19)
if bgp_header is None:
self.close()
return
length = unpack('!H', bgp_header[16:18])[0] - 19
bgp_body = self._read_data(length)
if bgp_body is None:
self.close()
return
negotiated = FakeNegotiated(header, self.asn4)
update = Update.unpack_message(bgp_body, negotiated)
if self.use_json:
print >> self.fd, self.json.bmp(self.ip, update)
else:
for route in update.routes:
print >> self.fd, route.extensive()
def check_neighbor (neighbors):
from exabgp.logger import Logger
logger = Logger()
logger._parser = True
if not neighbors:
logger.parser('\ncould not find neighbor(s) to check')
return False
logger.parser('\ndecoding routes in configuration')
for name in neighbors.keys():
neighbor = neighbors[name]
neighbor.rib.clear()
path = {}
for f in known_families():
if neighbor.add_path:
path[f] = neighbor.add_path
capa = Capabilities().new(neighbor,False)
capa[Capability.CODE.ADD_PATH] = path
capa[Capability.CODE.MULTIPROTOCOL] = neighbor.families()
o1 = Open(4,neighbor.local_as,str(neighbor.local_address),capa,180)
o2 = Open(4,neighbor.peer_as,str(neighbor.peer_address),capa,180)
negotiated = Negotiated(neighbor)
negotiated.sent(o1)
negotiated.received(o2)
# grouped = False
for message in neighbor.rib.outgoing.updates(False):
pass
for change1 in neighbor.rib.outgoing.sent_changes():
str1 = change1.extensive()
packed = list(Update([change1.nlri],change1.attributes).messages(negotiated))
pack1 = packed[0]
logger.parser('parsed route requires %d updates' % len(packed))
logger.parser('update size is %d' % len(pack1))
logger.parser('parsed route %s' % str1)
logger.parser('parsed hex %s' % od(pack1))
# This does not take the BGP header - let's assume we will not break that :)
try:
logger.parser('') # new line
pack1s = pack1[19:] if pack1.startswith('\xFF'*16) else pack1
update = Update.unpack_message(pack1s,negotiated)
change2 = Change(update.nlris[0],update.attributes)
str2 = change2.extensive()
pack2 = list(Update([update.nlris[0]],update.attributes).messages(negotiated))[0]
logger.parser('recoded route %s' % str2)
logger.parser('recoded hex %s' % od(pack2))
str1r = str1.replace(' med 100','').replace(' local-preference 100','').replace(' origin igp','')
str2r = str2.replace(' med 100','').replace(' local-preference 100','').replace(' origin igp','')
if ' name ' in str1r:
parts = str1r.split(' ')
pos = parts.index('name')
str1r = ' '.join(parts[:pos] + parts[pos+2:])
skip = False
if str1r != str2r:
if 'attribute [' in str1r and ' 0x00 ' in str1r:
# we do not decode non-transitive attributes
logger.parser('skipping string check on update with non-transitive attribute(s)')
skip = True
else:
logger.parser('strings are different:')
logger.parser('[%s]' % (str1r))
logger.parser('[%s]' % (str2r))
return False
else:
logger.parser('strings are fine')
if skip:
logger.parser('skipping encoding for update with non-transitive attribute(s)')
elif pack1 != pack2:
logger.parser('encoding are different')
logger.parser('[%s]' % (od(pack1)))
logger.parser('[%s]' % (od(pack2)))
return False
else:
logger.parser('encoding is fine')
logger.parser('----------------------------------------')
except Notify,exc:
logger.parser('----------------------------------------')
logger.parser(str(exc))
logger.parser('----------------------------------------')
return False
def test_decoding_udpate_asn4(self):
for asn4, body in bodies:
if not asn4: continue
Update.unpack_message(''.join(chr(_) for _ in body),
self.negotiated[asn4])
def check_neighbor (neighbors):
from exabgp.logger import Logger
logger = Logger()
logger._option.parser = True
if not neighbors:
logger.parser('\ncould not find neighbor(s) to check')
return False
logger.parser('\ndecoding routes in configuration')
for name in neighbors.keys():
neighbor = neighbors[name]
path = {}
for f in known_families():
if neighbor.add_path:
path[f] = neighbor.add_path
capa = Capabilities().new(neighbor,False)
if path:
capa[Capability.CODE.ADD_PATH] = path
capa[Capability.CODE.MULTIPROTOCOL] = neighbor.families()
o1 = Open(4,neighbor.local_as,'127.0.0.2',capa,180)
o2 = Open(4,neighbor.peer_as,'127.0.0.3',capa,180)
negotiated = Negotiated(neighbor)
negotiated.sent(o1)
negotiated.received(o2)
# grouped = False
for message in neighbor.rib.outgoing.updates(False):
pass
for change1 in neighbor.rib.outgoing.sent_changes():
str1 = change1.extensive()
packed = list(Update([change1.nlri],change1.attributes).messages(negotiated))
pack1 = packed[0]
logger.parser('parsed route requires %d updates' % len(packed))
logger.parser('parsed route requires %d updates' % len(packed))
logger.parser('update size is %d' % len(pack1))
logger.parser('parsed route %s' % str1)
logger.parser('parsed hex %s' % od(pack1))
# This does not take the BGP header - let's assume we will not break that :)
try:
logger.parser('') # new line
pack1s = pack1[19:] if pack1.startswith('\xFF'*16) else pack1
update = Update.unpack_message(pack1s,negotiated)
change2 = Change(update.nlris[0],update.attributes)
str2 = change2.extensive()
pack2 = list(Update([update.nlris[0]],update.attributes).messages(negotiated))[0]
logger.parser('recoded route %s' % str2)
logger.parser('recoded hex %s' % od(pack2))
str1r = str1.replace(' med 100','').replace(' local-preference 100','').replace(' origin igp','')
str2r = str2.replace(' med 100','').replace(' local-preference 100','').replace(' origin igp','')
if ' name ' in str1r:
parts = str1r.split(' ')
pos = parts.index('name')
str1r = ' '.join(parts[:pos] + parts[pos+2:])
skip = False
if str1r != str2r:
if 'attribute [' in str1r and ' 0x00 ' in str1r:
# we do not decode non-transitive attributes
logger.parser('skipping string check on update with non-transitive attribute(s)')
skip = True
else:
logger.parser('strings are different:')
logger.parser('[%s]' % (str1r))
logger.parser('[%s]' % (str2r))
return False
else:
logger.parser('strings are fine')
if skip:
logger.parser('skipping encoding for update with non-transitive attribute(s)')
elif pack1 != pack2:
logger.parser('encoding are different')
logger.parser('[%s]' % (od(pack1)))
logger.parser('[%s]' % (od(pack2)))
return False
else:
logger.parser('encoding is fine')
logger.parser('----------------------------------------')
logger.parser('JSON nlri %s' % change1.nlri.json())
logger.parser('JSON attr %s' % change1.attributes.json())
except Notify,exc:
logger.parser('----------------------------------------')
logger.parser(str(exc))
logger.parser('----------------------------------------')
return False
neighbor.rib.clear()
def check_neighbor(neighbor):
from exabgp.logger import Logger
logger = Logger()
logger._parser = True
logger.parser('\ndecoding routes in configuration')
n = neighbor[neighbor.keys()[0]]
path = {}
for f in known_families():
if n.add_path:
path[f] = n.add_path
capa = Capabilities().new(n, False)
capa[Capability.ID.ADD_PATH] = path
capa[Capability.ID.MULTIPROTOCOL] = n.families()
o1 = Open(4, n.local_as, str(n.local_address), capa, 180)
o2 = Open(4, n.peer_as, str(n.peer_address), capa, 180)
negotiated = Negotiated(n)
negotiated.sent(o1)
negotiated.received(o2)
#grouped = False
for nei in neighbor.keys():
for message in neighbor[nei].rib.outgoing.updates(False):
pass
for change1 in neighbor[nei].rib.outgoing.sent_changes():
str1 = change1.extensive()
packed = list(
Update([change1.nlri],
change1.attributes).messages(negotiated))
pack1 = packed[0]
logger.parser('parsed route requires %d updates' % len(packed))
logger.parser('update size is %d' % len(pack1))
logger.parser('parsed route %s' % str1)
logger.parser('parsed hex %s' % od(pack1))
# This does not take the BGP header - let's assume we will not break that :)
try:
logger.parser('') # new line
pack1s = pack1[19:] if pack1.startswith('\xFF' * 16) else pack1
update = Update.unpack_message(pack1s, negotiated)
change2 = Change(update.nlris[0], update.attributes)
str2 = change2.extensive()
pack2 = list(
Update([update.nlris[0]],
update.attributes).messages(negotiated))[0]
logger.parser('recoded route %s' % str2)
logger.parser('recoded hex %s' % od(pack2))
str1r = str1.replace(' med 100', '').replace(
' local-preference 100', '').replace(' origin igp', '')
str2r = str2.replace(' med 100', '').replace(
' local-preference 100', '').replace(' origin igp', '')
skip = False
if str1r != str2r:
if 'attribute [' in str1r and ' 0x00 ' in str1r:
# we do not decode non-transitive attributes
logger.parser(
'skipping string check on update with non-transitive attribute(s)'
)
skip = True
else:
logger.parser('strings are different:')
logger.parser('[%s]' % str1r)
logger.parser('[%s]' % str2r)
return False
else:
logger.parser('strings are fine')
if skip:
logger.parser(
'skipping encoding for update with non-transitive attribute(s)'
)
elif pack1 != pack2:
logger.parser('encoding are different')
logger.parser('[%s]' % od(pack1))
logger.parser('[%s]' % od(pack2))
return False
else:
logger.parser('encoding is fine')
logger.parser('----------------------------------------')
except Notify, e:
logger.parser('----------------------------------------')
logger.parser(str(e))
logger.parser('----------------------------------------')
return False
def test_decoding_udpate_asn4 (self):
for asn4,body in bodies:
if not asn4:
continue
Update.unpack_message(''.join(chr(_) for _ in body),self.negotiated[asn4])
def check_neighbor(neighbor):
from exabgp.logger import Logger
logger = Logger()
logger._parser = True
logger.parser("\ndecoding routes in configuration")
n = neighbor[neighbor.keys()[0]]
path = {}
for f in known_families():
if n.add_path:
path[f] = n.add_path
capa = Capabilities().new(n, False)
capa[Capability.ID.ADD_PATH] = path
capa[Capability.ID.MULTIPROTOCOL_EXTENSIONS] = n.families()
o1 = Open(4, n.local_as, str(n.local_address), capa, 180)
o2 = Open(4, n.peer_as, str(n.peer_address), capa, 180)
negotiated = Negotiated(n)
negotiated.sent(o1)
negotiated.received(o2)
# grouped = False
for nei in neighbor.keys():
for message in neighbor[nei].rib.outgoing.updates(False):
pass
for change1 in neighbor[nei].rib.outgoing.sent_changes():
str1 = change1.extensive()
packed = list(Update([change1.nlri], change1.attributes).messages(negotiated))
pack1 = packed[0]
logger.parser("parsed route requires %d updates" % len(packed))
logger.parser("update size is %d" % len(pack1))
logger.parser("parsed route %s" % str1)
logger.parser("parsed hex %s" % od(pack1))
# This does not take the BGP header - let's assume we will not break that :)
try:
logger.parser("") # new line
pack1s = pack1[19:] if pack1.startswith("\xFF" * 16) else pack1
update = Update.unpack_message(pack1s, negotiated)
change2 = Change(update.nlris[0], update.attributes)
str2 = change2.extensive()
pack2 = list(Update([update.nlris[0]], update.attributes).messages(negotiated))[0]
logger.parser("recoded route %s" % str2)
logger.parser("recoded hex %s" % od(pack2))
str1r = str1.replace(" med 100", "").replace(" local-preference 100", "").replace(" origin igp", "")
str2r = str2.replace(" med 100", "").replace(" local-preference 100", "").replace(" origin igp", "")
skip = False
if str1r != str2r:
if "attribute [" in str1r and " 0x00 " in str1r:
# we do not decode non-transitive attributes
logger.parser("skipping string check on update with non-transitive attribute(s)")
skip = True
else:
logger.parser("strings are different:")
logger.parser("[%s]" % str1r)
logger.parser("[%s]" % str2r)
return False
else:
logger.parser("strings are fine")
if skip:
logger.parser("skipping encoding for update with non-transitive attribute(s)")
elif pack1 != pack2:
logger.parser("encoding are different")
logger.parser("[%s]" % od(pack1))
logger.parser("[%s]" % od(pack2))
return False
else:
logger.parser("encoding is fine")
logger.parser("----------------------------------------")
except Notify, e:
logger.parser("----------------------------------------")
logger.parser(str(e))
logger.parser("----------------------------------------")
return False
