def setUp(self):
self.negotiated = {}
for asn4 in (True, False):
neighbor = FakeNeighbor()
neighbor.asn4 = asn4
capa = Capabilities().new(neighbor, False)
capa[Capability.CODE.MULTIPROTOCOL] = neighbor.families()
# path = {}
# for f in NLRI.known_families():
# if neighbor.add_path:
# path[f] = neighbor.add_path
# capa[Capability.CODE.ADD_PATH] = path
routerid_1 = str(neighbor.router_id)
routerid_2 = ".".join(str((int(_) + 1) % 250) for _ in str(neighbor.router_id).split(".", -1))
o1 = Open(Version(4), ASN(neighbor.local_as), HoldTime(180), RouterID(routerid_1), capa)
o2 = Open(Version(4), ASN(neighbor.peer_as), HoldTime(180), RouterID(routerid_2), capa)
negotiated = Negotiated(neighbor)
negotiated.sent(o1)
negotiated.received(o2)
self.negotiated[asn4] = negotiated
def __init__(self, peer):
try:
self.logger = Logger()
except RuntimeError:
self.logger = FakeLogger()
self.peer = peer
self.neighbor = peer.neighbor
self.negotiated = Negotiated(self.neighbor)
self.connection = None
if self.neighbor.connect:
self.port = self.neighbor.connect
elif os.environ.get('exabgp.tcp.port', '').isdigit():
self.port = int(os.environ.get('exabgp.tcp.port'))
elif os.environ.get('exabgp_tcp_port', '').isdigit():
self.port = int(os.environ.get('exabgp_tcp_port'))
else:
self.port = 179
# XXX: FIXME: check the the -19 is correct (but it is harmless)
# The message size is the whole BGP message _without_ headers
self.message_size = Message.MAX_LEN - Message.HEADER_LEN
from exabgp.configuration.environment import environment
self.log_routes = peer.neighbor.adj_rib_in or environment.settings(
).log.routes
def setUp (self):
# env.log.all = True
self.negotiated = {}
for asn4 in (True,False):
neighbor = FakeNeighbor()
neighbor.asn4 = asn4
capa = Capabilities().new(neighbor,False)
capa[Capability.CODE.MULTIPROTOCOL] = neighbor.families()
# path = {}
# for f in NLRI.known_families():
# if neighbor.add_path:
# path[f] = neighbor.add_path
# capa[Capability.CODE.ADD_PATH] = path
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)
self.negotiated[asn4] = negotiated
def _open(self, direction, message):
self.seen_open[direction] = message
if all(self.seen_open.values()):
self.negotiated = Negotiated(None)
self.negotiated.sent(self.seen_open['send'])
self.negotiated.received(self.seen_open['receive'])
def check_update (neighbor, raw):
logger = Logger()
logger._option.parser = True
logger.parser('\ndecoding routes in configuration')
neighbor = neighbor[neighbor.keys()[0]]
path = {}
for f in NLRI.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()
# capa[Capability.CODE.FOUR_BYTES_ASN] = True
routerid_1 = str(neighbor.router_id)
routerid_2 = '.'.join(str((int(_)+1) % 250) for _ in str(neighbor.router_id).split('.',-1))
o1 = Open(4,neighbor.local_as,routerid_1,capa,180)
o2 = Open(4,neighbor.peer_as,routerid_2,capa,180)
negotiated = Negotiated(neighbor)
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 _open (self,direction,message): self.seen_open[direction] = message if all(self.seen_open.values()): self.negotiated = Negotiated(None) self.negotiated.sent(self.seen_open['send']) self.negotiated.received(self.seen_open['receive'])
def __init__ (self, peer):
try:
self.logger = Logger()
except RuntimeError:
self.logger = FakeLogger()
self.peer = peer
self.neighbor = peer.neighbor
self.negotiated = Negotiated(self.neighbor)
self.connection = None
if self.neighbor.connect:
self.port = self.neighbor.connect
elif os.environ.get('exabgp.tcp.port','').isdigit():
self.port = int(os.environ.get('exabgp.tcp.port'))
elif os.environ.get('exabgp_tcp_port','').isdigit():
self.port = int(os.environ.get('exabgp_tcp_port'))
else:
self.port = 179
# XXX: FIXME: check the the -19 is correct (but it is harmless)
# The message size is the whole BGP message _without_ headers
self.message_size = Message.MAX_LEN-Message.HEADER_LEN
from exabgp.configuration.environment import environment
self.log_routes = peer.neighbor.adj_rib_in or environment.settings().log.routes
def __init__(self, peer):
self.peer = peer
self.neighbor = peer.neighbor
self.negotiated = Negotiated(self.neighbor)
self.connection = None
if self.neighbor['connect']:
self.port = self.neighbor['connect']
elif os.environ.get('exabgp.tcp.port', '').isdigit():
self.port = int(os.environ.get('exabgp.tcp.port'))
elif os.environ.get('exabgp_tcp_port', '').isdigit():
self.port = int(os.environ.get('exabgp_tcp_port'))
else:
self.port = 179
from exabgp.environment import getenv
self.log_routes = peer.neighbor['adj-rib-in'] or getenv().log.routes
def __init__ (self, peer):
try:
self.logger = Logger()
except RuntimeError:
self.logger = FakeLogger()
self.peer = peer
self.neighbor = peer.neighbor
self.negotiated = Negotiated(self.neighbor)
self.connection = None
if self.neighbor.connect:
self.port = self.neighbor.connect
elif os.environ.get('exabgp.tcp.port','').isdigit():
self.port = int(os.environ.get('exabgp.tcp.port'))
elif os.environ.get('exabgp_tcp_port','').isdigit():
self.port = int(os.environ.get('exabgp_tcp_port'))
else:
self.port = 179
from exabgp.configuration.environment import environment
self.log_routes = peer.neighbor.adj_rib_in or environment.settings().log.routes
def setUp(self):
self.negotiated = {}
for asn4 in (True, False):
neighbor = FakeNeighbor()
neighbor.asn4 = asn4
capa = Capabilities().new(neighbor, False)
capa[Capability.CODE.MULTIPROTOCOL] = neighbor.families()
# path = {}
# for f in NLRI.known_families():
# if neighbor.add_path:
# path[f] = neighbor.add_path
# capa[Capability.CODE.ADD_PATH] = path
o1 = Open(Version(4), ASN(neighbor.local_as), HoldTime(180),
RouterID(neighbor.local_address.top()), capa)
o2 = Open(Version(4), ASN(neighbor.peer_as), HoldTime(180),
RouterID(neighbor.peer_address.top()), capa)
negotiated = Negotiated(neighbor)
negotiated.sent(o1)
negotiated.received(o2)
self.negotiated[asn4] = negotiated
def _negotiated(neighbor):
path = {}
for f in NLRI.known_families():
if neighbor['capability']['add-path']:
path[f] = neighbor['capability']['add-path']
capa = Capabilities().new(neighbor, False)
capa[Capability.CODE.ADD_PATH] = path
capa[Capability.CODE.MULTIPROTOCOL] = neighbor.families()
# capa[Capability.CODE.FOUR_BYTES_ASN] = True
routerid_1 = str(neighbor['router-id'])
routerid_2 = '.'.join(
str((int(_) + 1) % 250)
for _ in str(neighbor['router-id']).split('.', -1))
o1 = Open(Version(4), ASN(neighbor['local-as']), HoldTime(180),
RouterID(routerid_1), capa)
o2 = Open(Version(4), ASN(neighbor['peer-as']), HoldTime(180),
RouterID(routerid_2), capa)
negotiated = Negotiated(neighbor)
negotiated.sent(o1)
negotiated.received(o2)
# grouped = False
return negotiated
def setUp(self):
self.negotiated = {}
for asn4 in (True, False):
neighbor = FakeNeighbor()
neighbor.asn4 = asn4
capa = Capabilities().new(neighbor, False)
capa[Capability.CODE.MULTIPROTOCOL] = neighbor.families()
# path = {}
# for f in NLRI.known_families():
# if neighbor.add_path:
# path[f] = neighbor.add_path
# capa[Capability.CODE.ADD_PATH] = path
routerid_1 = str(neighbor.router_id)
routerid_2 = '.'.join(
str((int(_) + 1) % 250)
for _ in str(neighbor.router_id).split('.', -1))
o1 = Open(Version(4), ASN(neighbor.local_as), HoldTime(180),
RouterID(routerid_1), capa)
o2 = Open(Version(4), ASN(neighbor.peer_as), HoldTime(180),
RouterID(routerid_2), capa)
negotiated = Negotiated(neighbor)
negotiated.sent(o1)
negotiated.received(o2)
self.negotiated[asn4] = negotiated
def setUp (self):
self.negotiated = {}
for asn4 in (True,False):
neighbor = FakeNeighbor()
neighbor.asn4 = asn4
capa = Capabilities().new(neighbor,False)
capa[Capability.CODE.MULTIPROTOCOL] = neighbor.families()
# path = {}
# for f in NLRI.known_families():
# if neighbor.add_path:
# path[f] = neighbor.add_path
# capa[Capability.CODE.ADD_PATH] = path
o1 = Open(Version(4),ASN(neighbor.local_as),HoldTime(180),RouterID(neighbor.local_address.string),capa)
o2 = Open(Version(4),ASN(neighbor.peer_as),HoldTime(180),RouterID(neighbor.peer_address.string),capa)
negotiated = Negotiated(neighbor)
negotiated.sent(o1)
negotiated.received(o2)
self.negotiated[asn4] = negotiated
def __init__ (self, peer):
try:
self.logger = Logger()
except RuntimeError:
self.logger = FakeLogger()
self.peer = peer
self.neighbor = peer.neighbor
self.negotiated = Negotiated(self.neighbor)
self.connection = None
if self.neighbor.connect:
self.port = self.neighbor.connect
elif os.environ.get('exabgp.tcp.port','').isdigit():
self.port = int(os.environ.get('exabgp.tcp.port'))
elif os.environ.get('exabgp_tcp_port','').isdigit():
self.port = int(os.environ.get('exabgp_tcp_port'))
else:
self.port = 179
from exabgp.configuration.environment import environment
self.log_routes = peer.neighbor.adj_rib_in or environment.settings().log.routes
class Protocol(object):
decode = True
def __init__(self, peer):
self.peer = peer
self.neighbor = peer.neighbor
self.negotiated = Negotiated(self.neighbor)
self.connection = None
if self.neighbor['connect']:
self.port = self.neighbor['connect']
elif os.environ.get('exabgp.tcp.port', '').isdigit():
self.port = int(os.environ.get('exabgp.tcp.port'))
elif os.environ.get('exabgp_tcp_port', '').isdigit():
self.port = int(os.environ.get('exabgp_tcp_port'))
else:
self.port = 179
from exabgp.environment import getenv
self.log_routes = peer.neighbor['adj-rib-in'] or getenv().log.routes
def fd(self):
if self.connection is None:
return -1
return self.connection.fd()
# XXX: we use self.peer.neighbor['peer-address'] when we could use self.neighbor['peer-address']
def me(self, message):
return "%s/%s %s" % (self.peer.neighbor['peer-address'],
self.peer.neighbor['peer-as'], message)
def accept(self, incoming):
self.connection = incoming
if self.peer.neighbor.api['neighbor-changes']:
self.peer.reactor.processes.connected(self.peer.neighbor)
# very important - as we use this function on __init__
return self
def connect(self):
# allows to test the protocol code using modified StringIO with a extra 'pending' function
if self.connection:
return
local = self.neighbor['md5-ip'].top(
) if not self.neighbor.auto_discovery else None
peer = self.neighbor['peer-address'].top()
afi = self.neighbor['peer-address'].afi
md5 = self.neighbor['md5-password']
md5_base64 = self.neighbor['md5-base64']
ttl_out = self.neighbor['outgoing-ttl']
self.connection = Outgoing(afi, peer, local, self.port, md5,
md5_base64, ttl_out)
for connected in self.connection.establish():
yield False
if self.peer.neighbor.api['neighbor-changes']:
self.peer.reactor.processes.connected(self.peer.neighbor)
if not local:
self.neighbor['local-address'] = IP.create(self.connection.local)
if self.neighbor['router-id'] is None and self.neighbor[
'local-address'].afi == AFI.ipv4:
self.neighbor['router-id'] = self.neighbor['local-address']
yield True
def close(self, reason='protocol closed, reason unspecified'):
if self.connection:
log.debug(reason, self.connection.session())
self.peer.stats['down'] = self.peer.stats.get('down', 0) + 1
self.connection.close()
self.connection = None
def _to_api(self, direction, message, raw):
packets = self.neighbor.api['%s-packets' % direction]
parsed = self.neighbor.api['%s-parsed' % direction]
consolidate = self.neighbor.api['%s-consolidate' % direction]
negotiated = self.negotiated if self.neighbor.api[
'negotiated'] else None
if consolidate:
if packets:
self.peer.reactor.processes.message(message.ID,
self.peer.neighbor,
direction, message,
negotiated, raw[:19],
raw[19:])
else:
self.peer.reactor.processes.message(message.ID,
self.peer.neighbor,
direction, message,
negotiated, b'', b'')
else:
if packets:
self.peer.reactor.processes.packets(self.peer.neighbor,
direction, int(message.ID),
negotiated, raw[:19],
raw[19:])
if parsed:
self.peer.reactor.processes.message(message.ID,
self.peer.neighbor,
direction, message,
negotiated, b'', b'')
def write(self, message, negotiated=None):
raw = message.message(negotiated)
code = 'send-%s' % Message.CODE.short(message.ID)
self.peer.stats[code] = self.peer.stats.get(code, 0) + 1
if self.neighbor.api.get(code, False):
self._to_api('send', message, raw)
for boolean in self.connection.writer(raw):
yield boolean
def send(self, raw):
code = 'send-%s' % Message.CODE.short(raw[18])
self.peer.stats[code] = self.peer.stats.get(code, 0) + 1
if self.neighbor.api.get(code, False):
message = Update.unpack_message(raw[19:], Direction.OUT,
self.negotiated)
self._to_api('send', message, raw)
for boolean in self.connection.writer(raw):
yield boolean
# Read from network .......................................................
def read_message(self):
# This will always be defined by the loop but scope leaking upset scrutinizer/pylint
msg_id = None
packets = self.neighbor.api['receive-packets']
consolidate = self.neighbor.api['receive-consolidate']
parsed = self.neighbor.api['receive-parsed']
body, header = b'', b'' # just because pylint/pylama are getting more clever
for length, msg_id, header, body, notify in self.connection.reader():
# internal issue
if notify:
code = 'receive-%s' % Message.CODE.NOTIFICATION.SHORT
if self.neighbor.api.get(code, False):
if consolidate:
self.peer.reactor.processes.notification(
self.peer.neighbor, 'receive', notify.code,
notify.subcode, str(notify), None, header, body)
elif parsed:
self.peer.reactor.processes.notification(
self.peer.neighbor, 'receive', notify.code,
notify.subcode, str(notify), None, b'', b'')
elif packets:
self.peer.reactor.processes.packets(
self.peer.neighbor, 'receive', msg_id, None,
header, body)
# XXX: is notify not already Notify class ?
raise Notify(notify.code, notify.subcode, str(notify))
if not length:
yield _NOP
continue
log.debug('<< message of type %s' % Message.CODE.name(msg_id),
self.connection.session())
code = 'receive-%s' % Message.CODE.short(msg_id)
self.peer.stats[code] = self.peer.stats.get(code, 0) + 1
for_api = self.neighbor.api.get(code, False)
if for_api and packets and not consolidate:
negotiated = self.negotiated if self.neighbor.api.get(
'negotiated', False) else None
self.peer.reactor.processes.packets(self.peer.neighbor,
'receive', msg_id,
negotiated, header, body)
if msg_id == Message.CODE.UPDATE:
if not self.neighbor['adj-rib-in'] and not (
for_api or self.log_routes) and not (parsed
or consolidate):
yield _UPDATE
return
try:
message = Message.unpack(msg_id, body, Direction.IN,
self.negotiated)
except (KeyboardInterrupt, SystemExit, Notify):
raise
except Exception as exc:
log.debug('could not decode message "%d"' % msg_id,
self.connection.session())
log.debug('%s' % str(exc), self.connection.session())
log.debug(traceback.format_exc(), self.connection.session())
raise Notify(
1, 0,
'can not decode update message of type "%d"' % msg_id)
# raise Notify(5,0,'unknown message received')
if message.TYPE == Update.TYPE:
if Attribute.CODE.INTERNAL_TREAT_AS_WITHDRAW in message.attributes:
for nlri in message.nlris:
nlri.action = IN.WITHDRAWN
if for_api:
negotiated = self.negotiated if self.neighbor.api.get(
'negotiated', False) else None
if consolidate:
self.peer.reactor.processes.message(
msg_id, self.neighbor, 'receive', message, negotiated,
header, body)
elif parsed:
self.peer.reactor.processes.message(
msg_id, self.neighbor, 'receive', message, negotiated,
b'', b'')
if message.TYPE == Notification.TYPE:
raise message
if message.TYPE == Update.TYPE and Attribute.CODE.INTERNAL_DISCARD in message.attributes:
yield _NOP
else:
yield message
def validate_open(self):
error = self.negotiated.validate(self.neighbor)
if error is not None:
raise Notify(*error)
if self.neighbor.api['negotiated']:
self.peer.reactor.processes.negotiated(self.peer.neighbor,
self.negotiated)
if self.negotiated.mismatch:
log.warning(
'--------------------------------------------------------------------',
self.connection.session())
log.warning(
'the connection can not carry the following family/families',
self.connection.session())
for reason, (afi, safi) in self.negotiated.mismatch:
log.warning(
' - %s is not configured for %s/%s' % (reason, afi, safi),
self.connection.session())
log.warning(
'therefore no routes of this kind can be announced on the connection',
self.connection.session())
log.warning(
'--------------------------------------------------------------------',
self.connection.session())
def read_open(self, ip):
for received_open in self.read_message():
if received_open.TYPE == NOP.TYPE:
yield received_open
else:
break
if received_open.TYPE != Open.TYPE:
raise Notify(
5, 1, 'The first packet received is not an open message (%s)' %
received_open)
log.debug('<< %s' % received_open, self.connection.session())
yield received_open
def read_keepalive(self):
for message in self.read_message():
if message.TYPE == NOP.TYPE:
yield message
else:
break
if message.TYPE != KeepAlive.TYPE:
raise Notify(5, 2)
yield message
#
# Sending message to peer
#
def new_open(self):
if self.neighbor['local-as']:
local_as = self.neighbor['local-as']
elif self.negotiated.received_open:
local_as = self.negotiated.received_open.asn
else:
raise RuntimeError('no ASN available for the OPEN message')
sent_open = Open(
Version(4),
local_as,
self.neighbor['hold-time'],
self.neighbor['router-id'],
Capabilities().new(self.neighbor, self.peer._restarted),
)
# we do not buffer open message in purpose
for _ in self.write(sent_open):
yield _NOP
log.debug('>> %s' % sent_open, self.connection.session())
yield sent_open
def new_keepalive(self, comment=''):
keepalive = KeepAlive()
for _ in self.write(keepalive):
yield _NOP
log.debug('>> KEEPALIVE%s' % (' (%s)' % comment if comment else ''),
self.connection.session())
yield keepalive
def new_notification(self, notification):
for _ in self.write(notification):
yield _NOP
log.debug(
'>> NOTIFICATION (%d,%d,"%s")' %
(notification.code, notification.subcode,
notification.data.decode('utf-8')),
self.connection.session(),
)
yield notification
def new_update(self, include_withdraw):
updates = self.neighbor.rib.outgoing.updates(
self.neighbor['group-updates'])
number = 0
for update in updates:
for message in update.messages(self.negotiated, include_withdraw):
number += 1
for boolean in self.send(message):
# boolean is a transient network error we already announced
yield _NOP
if number:
log.debug('>> %d UPDATE(s)' % number, self.connection.session())
yield _UPDATE
def new_eor(self, afi, safi):
eor = EOR(afi, safi)
for _ in self.write(eor):
yield _NOP
log.debug('>> EOR %s %s' % (afi, safi), self.connection.session())
yield eor
def new_eors(self, afi=AFI.undefined, safi=SAFI.undefined):
# Send EOR to let our peer know he can perform a RIB update
if self.negotiated.families:
families = (self.negotiated.families if
(afi, safi) == (AFI.undefined, SAFI.undefined) else [
(afi, safi),
])
for eor_afi, eor_safi in families:
for _ in self.new_eor(eor_afi, eor_safi):
yield _
else:
# If we are not sending an EOR, send a keepalive as soon as when finished
# So the other routers knows that we have no (more) routes to send ...
# (is that behaviour documented somewhere ??)
for eor in self.new_keepalive('EOR'):
yield _NOP
yield _UPDATE
def new_operational(self, operational, negotiated):
for _ in self.write(operational, negotiated):
yield _NOP
log.debug('>> OPERATIONAL %s' % str(operational),
self.connection.session())
yield operational
def new_refresh(self, refresh):
for _ in self.write(refresh, None):
yield _NOP
log.debug('>> REFRESH %s' % str(refresh), self.connection.session())
yield refresh
def check_neighbor (neighbors):
logger = Logger()
logger._option.parser = True
logger.parser('\ndecoding routes in configuration')
for name in neighbors.keys():
neighbor = neighbors[name]
path = {}
for f in NLRI.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()
routerid_1 = str(neighbor.router_id)
routerid_2 = '.'.join(str((int(_)+1) % 250) for _ in str(neighbor.router_id).split('.',-1))
o1 = Open(Version(4),ASN(neighbor.local_as),HoldTime(180),RouterID(routerid_1),capa)
o2 = Open(Version(4),ASN(neighbor.peer_as),HoldTime(180),RouterID(routerid_2),capa)
negotiated = Negotiated(neighbor)
negotiated.sent(o1)
negotiated.received(o2)
# grouped = False
for _ 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))
str1 = str1.replace('attribute [ 0x04 0x80 0x00000064 ]','med 100')
str1r = str1.lower().replace(' med 100','').replace(' local-preference 100','').replace(' origin igp','')
str2r = str2.lower().replace(' med 100','').replace(' local-preference 100','').replace(' origin igp','')
if 'next-hop self' in str1r:
if ':' in str1r:
str1r = str1r.replace('next-hop self','next-hop ::1')
else:
str1r = str1r.replace('next-hop self','next-hop %s' % neighbor.local_address)
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_update (neighbor, raw):
logger = Logger()
logger._option.parser = True
logger.parser('\ndecoding routes in configuration')
neighbor = neighbor[neighbor.keys()[0]]
path = {}
for f in NLRI.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()
# capa[Capability.CODE.FOUR_BYTES_ASN] = True
routerid_1 = str(neighbor.router_id)
routerid_2 = '.'.join(str((int(_)+1) % 250) for _ in str(neighbor.router_id).split('.',-1))
o1 = Open(Version(4),ASN(neighbor.local_as),HoldTime(180),RouterID(routerid_1),capa)
o2 = Open(Version(4),ASN(neighbor.peer_as),HoldTime(180),RouterID(routerid_2),capa)
negotiated = Negotiated(neighbor)
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:
logger.parser('could not parse the message','error')
logger.parser(traceback.format_exc(),'error')
return False
except StandardError:
logger.parser('could not parse the message','error')
logger.parser(traceback.format_exc(),'error')
return False
logger.parser('') # new line
for number in range(len(update.nlris)):
change = Change(update.nlris[number],update.attributes)
logger.parser('decoded %s %s %s' % (decoding,change.nlri.action,change.extensive()))
logger.parser('update json %s' % Response.JSON(json_version).update(neighbor,'in',update,'',''))
return True
class Transcoder(object):
seen_open = {
'send': None,
'receive': None,
}
negotiated = None
json = Response.JSON(json_version)
def __init__(self, src='json', dst='json'):
if src != 'json':
raise RuntimeError('left as an exercise to the reader')
if dst != 'json':
raise RuntimeError('left as an exercise to the reader')
self.convert = self._from_json
self.encoder = self.json
def _state(self):
self.seen_open['send'] = None
self.seen_open['receive'] = None
self.negotiated = None
def _open(self, direction, message):
self.seen_open[direction] = message
if all(self.seen_open.values()):
self.negotiated = Negotiated(None)
self.negotiated.sent(self.seen_open['send'])
self.negotiated.received(self.seen_open['receive'])
def _from_json(self, string):
try:
parsed = json.loads(string)
except ValueError:
print >> sys.stderr, 'invalid JSON message'
sys.exit(1)
if parsed.get('exabgp', '0.0.0') != json_version:
print >> sys.stderr, 'invalid json version', string
sys.exit(1)
content = parsed.get('type', '')
if not content:
print >> sys.stderr, 'invalid json content', string
sys.exit(1)
neighbor = _FakeNeighbor(
parsed['neighbor']['address']['local'],
parsed['neighbor']['address']['peer'],
parsed['neighbor']['asn']['local'],
parsed['neighbor']['asn']['peer'],
)
if content == 'state':
self._state()
return string
direction = parsed['neighbor']['direction']
category = parsed['neighbor']['message']['category']
header = parsed['neighbor']['message']['header']
body = parsed['neighbor']['message']['body']
raw = ''.join(
chr(int(body[_:_ + 2], 16)) for _ in range(0, len(body), 2))
if content == 'open':
message = Open.unpack_message(raw)
self._open(direction, message)
return self.encoder.open(neighbor, direction, message, header,
body)
if content == 'keapalive':
return self.encoder.keepalive(neighbor, direction, header, body)
if content == 'notification':
message = Notification.unpack_message(raw)
return self.encoder.notification(neighbor, direction, message,
header, body)
if not self.negotiated:
print >> sys.stderr, 'invalid message sequence, open not exchange not complete', string
sys.exit(1)
message = Message.unpack(category, raw, self.negotiated)
if content == 'update':
return self.encoder.update(neighbor, direction, message, header,
body)
if content == 'eor': # XXX: Should not be required
return self.encoder.update(neighbor, direction, message, header,
body)
if content == 'refresh':
return self.json.refresh(neighbor, direction, message, header,
body)
if content == 'operational':
return self.json.refresh(neighbor, direction, message, header,
body)
raise RuntimeError(
'the programer is a monkey and forgot a JSON message type')
class Transcoder(object):
seen_open = {
'send': None,
'receive': None,
}
negotiated = None
json = Response.JSON(json_version)
def __init__(self, src='json', dst='json'):
if src != 'json':
raise RuntimeError('left as an exercise to the reader')
if dst != 'json':
raise RuntimeError('left as an exercise to the reader')
self.convert = self._from_json
self.encoder = self.json
def _state(self):
self.seen_open['send'] = None
self.seen_open['receive'] = None
self.negotiated = None
def _open(self, direction, message):
self.seen_open[direction] = message
if all(self.seen_open.values()):
self.negotiated = Negotiated(None)
self.negotiated.sent(self.seen_open['send'])
self.negotiated.received(self.seen_open['receive'])
def _from_json(self, direction, json_string):
try:
parsed = json.loads(json_string)
except ValueError:
print('invalid JSON message', file=sys.stderr)
sys.exit(1)
if parsed.get('exabgp', '0.0.0') != json_version:
print('invalid json version', json_string, file=sys.stderr)
sys.exit(1)
content = parsed.get('type', '')
if not content:
print('invalid json content', json_string, file=sys.stderr)
sys.exit(1)
neighbor = _FakeNeighbor(
parsed['neighbor']['address']['local'],
parsed['neighbor']['address']['peer'],
parsed['neighbor']['asn']['local'],
parsed['neighbor']['asn']['peer'],
)
if content == 'state':
self._state()
return json_string
direction = parsed['neighbor']['direction']
category = parsed['neighbor']['message']['category']
header = parsed['neighbor']['message']['header']
body = parsed['neighbor']['message']['body']
data = b''.join(bytes([int(body[_ : _ + 2], 16)]) for _ in range(0, len(body), 2))
if content == 'open':
message = Open.unpack_message(data)
self._open(direction, message)
return self.encoder.open(neighbor, direction, message, None, header, body)
if content == 'keepalive':
return self.encoder.keepalive(neighbor, direction, None, header, body)
if content == 'notification':
# XXX: Use the code of the Notifcation class here ..
message = Notification.unpack_message(data)
if (message.code, message.subcode) != (6, 2):
message.data = data if not len([_ for _ in data if _ not in string.printable]) else hexstring(data)
return self.encoder.notification(neighbor, direction, message, None, header, body)
if len(data) == 0:
# shutdown without shutdown communication (the old fashioned way)
message.data = ''
return self.encoder.notification(neighbor, direction, message, None, header, body)
# draft-ietf-idr-shutdown or the peer was using 6,2 with data
shutdown_length = data[0]
data = data[1:]
if shutdown_length == 0:
message.data = "empty Shutdown Communication."
# move offset past length field
return self.encoder.notification(neighbor, direction, message, None, header, body)
if len(data) < shutdown_length:
message.data = "invalid Shutdown Communication (buffer underrun) length : %i [%s]" % (
shutdown_length,
hexstring(data),
)
return self.encoder.notification(neighbor, direction, message, None, header, body)
if shutdown_length > 128:
message.data = "invalid Shutdown Communication (too large) length : %i [%s]" % (
shutdown_length,
hexstring(data),
)
return self.encoder.notification(neighbor, direction, message, None, header, body)
try:
message.data = 'Shutdown Communication: "%s"' % data[:shutdown_length].decode('utf-8').replace(
'\r', ' '
).replace('\n', ' ')
except UnicodeDecodeError:
message.data = "invalid Shutdown Communication (invalid UTF-8) length : %i [%s]" % (
shutdown_length,
hexstring(data),
)
return self.encoder.notification(neighbor, direction, message, None, header, body)
trailer = data[shutdown_length:]
if trailer:
message.data += ", trailing data: " + hexstring(trailer)
return self.encoder.notification(neighbor, direction, message, None, header, body)
if not self.negotiated:
print('invalid message sequence, open not exchange not complete', json_string, file=sys.stderr)
sys.exit(1)
message = Message.unpack(category, data, direction, self.negotiated)
if content == 'update':
return self.encoder.update(neighbor, direction, message, None, header, body)
if content == 'eor': # XXX: Should not be required
return self.encoder.update(neighbor, direction, message, None, header, body)
if content == 'refresh':
return self.json.refresh(neighbor, direction, message, None, header, body)
if content == 'operational':
return self.json.refresh(neighbor, direction, message, None, header, body)
raise RuntimeError('the programer is a monkey and forgot a JSON message type')
def check_update(neighbor, raw):
option.enabled['parser'] = True
neighbor = neighbor[list(neighbor)[0]]
path = {}
for f in NLRI.known_families():
if neighbor['capability']['add-path']:
path[f] = neighbor['capability']['add-path']
capa = Capabilities().new(neighbor, False)
capa[Capability.CODE.ADD_PATH] = path
capa[Capability.CODE.MULTIPROTOCOL] = neighbor.families()
# capa[Capability.CODE.FOUR_BYTES_ASN] = True
routerid_1 = str(neighbor['router-id'])
routerid_2 = '.'.join(
str((int(_) + 1) % 250)
for _ in str(neighbor['router-id']).split('.', -1))
o1 = Open(Version(4), ASN(neighbor['local-as']), HoldTime(180),
RouterID(routerid_1), capa)
o2 = Open(Version(4), ASN(neighbor['peer-as']), HoldTime(180),
RouterID(routerid_2), capa)
negotiated = Negotiated(neighbor)
negotiated.sent(o1)
negotiated.received(o2)
# grouped = False
while raw:
if raw.startswith(b'\xff' * 16):
kind = raw[18]
size = (raw[16] << 16) + raw[17]
injected, raw = raw[19:size], raw[size:]
if kind == 2:
log.debug('the message is an update', 'parser')
decoding = 'update'
else:
log.debug(
'the message is not an update (%d) - aborting' % kind,
'parser')
return False
else:
log.debug('header missing, assuming this message is ONE update',
'parser')
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 Notify:
import traceback
log.error('could not parse the message', 'parser')
log.error(traceback.format_exc(), 'parser')
return False
except Exception:
import traceback
log.error('could not parse the message', 'parser')
log.error(traceback.format_exc(), 'parser')
return False
log.debug('', 'parser') # new line
for number in range(len(update.nlris)):
change = Change(update.nlris[number], update.attributes)
log.info(
'decoded %s %s %s' %
(decoding, change.nlri.action, change.extensive()), 'parser')
log.info(
'update json %s' % Response.JSON(json_version).update(
neighbor, 'in', update, None, '', ''), 'parser')
return True
def check_update(neighbor, raw):
logger = Logger()
logger._option.parser = True
logger.parser('\ndecoding routes in configuration')
neighbor = neighbor[neighbor.keys()[0]]
path = {}
for f in NLRI.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()
# capa[Capability.CODE.FOUR_BYTES_ASN] = True
routerid_1 = str(neighbor.router_id)
routerid_2 = '.'.join(
str((int(_) + 1) % 250)
for _ in str(neighbor.router_id).split('.', -1))
o1 = Open(Version(4), ASN(neighbor.local_as), HoldTime(180),
RouterID(routerid_1), capa)
o2 = Open(Version(4), ASN(neighbor.peer_as), HoldTime(180),
RouterID(routerid_2), capa)
negotiated = Negotiated(neighbor)
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:
logger.parser('could not parse the message', 'error')
logger.parser(traceback.format_exc(), 'error')
return False
except StandardError:
logger.parser('could not parse the message', 'error')
logger.parser(traceback.format_exc(), 'error')
return False
logger.parser('') # new line
for number in range(len(update.nlris)):
change = Change(update.nlris[number], update.attributes)
logger.parser('decoded %s %s %s' %
(decoding, change.nlri.action, change.extensive()))
logger.parser(
'update json %s' %
Response.JSON(json_version).update(neighbor, 'in', update, '', ''))
return True
class Protocol (object):
decode = True
def __init__ (self, peer):
try:
self.logger = Logger()
except RuntimeError:
self.logger = FakeLogger()
self.peer = peer
self.neighbor = peer.neighbor
self.negotiated = Negotiated(self.neighbor)
self.connection = None
if self.neighbor.connect:
self.port = self.neighbor.connect
elif os.environ.get('exabgp.tcp.port','').isdigit():
self.port = int(os.environ.get('exabgp.tcp.port'))
elif os.environ.get('exabgp_tcp_port','').isdigit():
self.port = int(os.environ.get('exabgp_tcp_port'))
else:
self.port = 179
# XXX: FIXME: check the the -19 is correct (but it is harmless)
# The message size is the whole BGP message _without_ headers
self.message_size = Message.MAX_LEN-Message.HEADER_LEN
from exabgp.configuration.environment import environment
self.log_routes = peer.neighbor.adj_rib_in or environment.settings().log.routes
# XXX: we use self.peer.neighbor.peer_address when we could use self.neighbor.peer_address
def me (self, message):
return "%s/%s %s" % (self.peer.neighbor.peer_address,self.peer.neighbor.peer_as,message)
def accept (self, incoming):
self.connection = incoming
if self.peer.neighbor.api['neighbor-changes']:
self.peer.reactor.processes.connected(self.peer.neighbor)
# very important - as we use this function on __init__
return self
def connect (self):
# allows to test the protocol code using modified StringIO with a extra 'pending' function
if not self.connection:
local = self.neighbor.md5_ip.top() if not self.neighbor.auto_discovery else None
peer = self.neighbor.peer_address.top()
afi = self.neighbor.peer_address.afi
md5 = self.neighbor.md5_password
md5_base64 = self.neighbor.md5_base64
ttl_out = self.neighbor.ttl_out
self.connection = Outgoing(afi,peer,local,self.port,md5,md5_base64,ttl_out)
if not local and self.connection.init:
self.neighbor.local_address = IP.create(self.connection.local)
if self.neighbor.router_id is None and self.neighbor.local_address.afi == AFI.ipv4:
self.neighbor.router_id = self.neighbor.local_address
try:
generator = self.connection.establish()
while True:
connected = six.next(generator)
if not connected:
yield False
continue
if self.peer.neighbor.api['neighbor-changes']:
self.peer.reactor.processes.connected(self.peer.neighbor)
yield True
return
except StopIteration:
# close called by the caller
# self.close('could not connect to remote end')
yield False
return
def close (self, reason='protocol closed, reason unspecified'):
if self.connection:
self.logger.debug(reason,self.connection.session())
# must be first otherwise we could have a loop caused by the raise in the below
self.connection.close()
self.connection = None
self.peer.stats['down'] = self.peer.stats.get('down',0) + 1
try:
if self.peer.neighbor.api['neighbor-changes']:
self.peer.reactor.processes.down(self.peer.neighbor,reason)
except ProcessError:
self.logger.debug('could not send notification of neighbor close to API',self.connection.session())
def _to_api (self,direction,message,raw):
packets = self.neighbor.api['%s-packets' % direction]
parsed = self.neighbor.api['%s-parsed' % direction]
consolidate = self.neighbor.api['%s-consolidate' % direction]
negotiated = self.negotiated if self.neighbor.api['negotiated'] else None
if consolidate:
if packets:
self.peer.reactor.processes.message(self.peer.neighbor,direction,message,negotiated,raw[:19],raw[19:])
else:
self.peer.reactor.processes.message(self.peer.neighbor,direction,message,negotiated,b'',b'')
else:
if packets:
self.peer.reactor.processes.packets(self.peer.neighbor,direction,int(message.ID),negotiated,raw[:19],raw[19:])
if parsed:
self.peer.reactor.processes.message(message.ID,self.peer.neighbor,direction,message,negotiated,b'',b'')
def write (self, message, negotiated=None):
raw = message.message(negotiated)
code = 'send-%s' % Message.CODE.short(message.ID)
self.peer.stats[code] = self.peer.stats.get(code,0) + 1
if self.neighbor.api.get(code,False):
self._to_api('send',message,raw)
for boolean in self.connection.writer(raw):
yield boolean
def send (self, raw):
code = 'send-%s' % Message.CODE.short(ordinal(raw[18]))
self.peer.stats[code] = self.peer.stats.get(code,0) + 1
if self.neighbor.api.get(code,False):
message = Update.unpack_message(raw[19:],self.negotiated)
self._to_api('send',message,raw)
for boolean in self.connection.writer(raw):
yield boolean
# Read from network .......................................................
def read_message (self):
# This will always be defined by the loop but scope leaking upset scrutinizer/pylint
msg_id = None
packets = self.neighbor.api['receive-packets']
consolidate = self.neighbor.api['receive-consolidate']
parsed = self.neighbor.api['receive-parsed']
body,header = b'',b'' # just because pylint/pylama are getting more clever
for length,msg_id,header,body,notify in self.connection.reader():
# internal issue
if notify:
code = 'receive-%s' % Message.CODE.NOTIFICATION.SHORT
if self.neighbor.api.get(code,False):
if consolidate:
self.peer.reactor.processes.notification(self.peer.neighbor,'receive',notify.code,notify.subcode,str(notify),None,header,body)
elif parsed:
self.peer.reactor.processes.notification(self.peer.neighbor,'receive',notify.code,notify.subcode,str(notify),None,b'',b'')
elif packets:
self.peer.reactor.processes.packets(self.peer.neighbor,'receive',msg_id,None,header,body)
# XXX: is notify not already Notify class ?
raise Notify(notify.code,notify.subcode,str(notify))
if not length:
yield _NOP
continue
self.logger.debug('<< message of type %s' % Message.CODE.name(msg_id),self.connection.session())
code = 'receive-%s' % Message.CODE.short(msg_id)
self.peer.stats[code] = self.peer.stats.get(code,0) + 1
for_api = self.neighbor.api.get(code,False)
if for_api and packets and not consolidate:
negotiated = self.negotiated if self.neighbor.api.get('negotiated',False) else None
self.peer.reactor.processes.packets(self.peer.neighbor,'receive',msg_id,negotiated,header,body)
if msg_id == Message.CODE.UPDATE:
if not self.neighbor.adj_rib_in and not (for_api or self.log_routes) and not (parsed or consolidate):
yield _UPDATE
return
try:
message = Message.unpack(msg_id,body,self.negotiated)
except (KeyboardInterrupt,SystemExit,Notify):
raise
except Exception as exc:
self.logger.debug('could not decode message "%d"' % msg_id,self.connection.session())
self.logger.debug('%s' % str(exc),self.connection.session())
self.logger.debug(traceback.format_exc(),self.connection.session())
raise Notify(1,0,'can not decode update message of type "%d"' % msg_id)
# raise Notify(5,0,'unknown message received')
if message.TYPE == Update.TYPE:
if Attribute.CODE.INTERNAL_TREAT_AS_WITHDRAW in message.attributes:
for nlri in message.nlris:
nlri.action = IN.WITHDRAWN
if for_api:
negotiated = self.negotiated if self.neighbor.api.get('negotiated',False) else None
if consolidate:
self.peer.reactor.processes.message(msg_id,self.neighbor,'receive',message,negotiated,header,body)
elif parsed:
self.peer.reactor.processes.message(msg_id,self.neighbor,'receive',message,negotiated,b'',b'')
if message.TYPE == Notification.TYPE:
raise message
if message.TYPE == Update.TYPE and Attribute.CODE.INTERNAL_DISCARD in message.attributes:
yield _NOP
else:
yield message
def validate_open (self):
error = self.negotiated.validate(self.neighbor)
if error is not None:
raise Notify(*error)
if self.neighbor.api['negotiated']:
self.peer.reactor.processes.negotiated(self.peer.neighbor,self.negotiated)
if self.negotiated.mismatch:
self.logger.warning('--------------------------------------------------------------------',self.connection.session())
self.logger.warning('the connection can not carry the following family/families',self.connection.session())
for reason,(afi,safi) in self.negotiated.mismatch:
self.logger.warning(' - %s is not configured for %s/%s' % (reason,afi,safi),self.connection.session())
self.logger.warning('therefore no routes of this kind can be announced on the connection',self.connection.session())
self.logger.warning('--------------------------------------------------------------------',self.connection.session())
def read_open (self, ip):
for received_open in self.read_message():
if received_open.TYPE == NOP.TYPE:
yield received_open
else:
break
if received_open.TYPE != Open.TYPE:
raise Notify(5,1,'The first packet received is not an open message (%s)' % received_open)
self.logger.debug('<< %s' % received_open,self.connection.session())
yield received_open
def read_keepalive (self):
for message in self.read_message():
if message.TYPE == NOP.TYPE:
yield message
else:
break
if message.TYPE != KeepAlive.TYPE:
raise Notify(5,2)
yield message
#
# Sending message to peer
#
def new_open (self):
if self.neighbor.local_as:
local_as = self.neighbor.local_as
elif self.negotiated.received_open:
local_as = self.negotiated.received_open.asn
else:
raise RuntimeError('no ASN available for the OPEN message')
sent_open = Open(
Version(4),
local_as,
self.neighbor.hold_time,
self.neighbor.router_id,
Capabilities().new(self.neighbor,self.peer._restarted)
)
# we do not buffer open message in purpose
for _ in self.write(sent_open):
yield _NOP
self.logger.debug('>> %s' % sent_open,self.connection.session())
yield sent_open
def new_keepalive (self, comment=''):
keepalive = KeepAlive()
for _ in self.write(keepalive):
yield _NOP
self.logger.debug('>> KEEPALIVE%s' % (' (%s)' % comment if comment else ''),self.connection.session())
yield keepalive
def new_notification (self, notification):
for _ in self.write(notification):
yield _NOP
self.logger.debug('>> NOTIFICATION (%d,%d,"%s")' % (notification.code,notification.subcode,notification.data),self.connection.session())
yield notification
def new_update (self, include_withdraw):
updates = self.neighbor.rib.outgoing.updates(self.neighbor.group_updates)
number = 0
for update in updates:
for message in update.messages(self.negotiated,include_withdraw):
number += 1
for boolean in self.send(message):
# boolean is a transient network error we already announced
yield _NOP
if number:
self.logger.debug('>> %d UPDATE(s)' % number,self.connection.session())
yield _UPDATE
def new_eor (self, afi, safi):
eor = EOR(afi,safi)
for _ in self.write(eor):
yield _NOP
self.logger.debug('>> EOR %s %s' % (afi,safi),self.connection.session())
yield eor
def new_eors (self, afi=AFI.undefined,safi=SAFI.undefined):
# Send EOR to let our peer know he can perform a RIB update
if self.negotiated.families:
families = self.negotiated.families if (afi,safi) == (AFI.undefined,SAFI.undefined) else [(afi,safi),]
for eor_afi,eor_safi in families:
for _ in self.new_eor(eor_afi,eor_safi):
yield _
else:
# If we are not sending an EOR, send a keepalive as soon as when finished
# So the other routers knows that we have no (more) routes to send ...
# (is that behaviour documented somewhere ??)
for eor in self.new_keepalive('EOR'):
yield _NOP
yield _UPDATE
def new_operational (self, operational, negotiated):
for _ in self.write(operational,negotiated):
yield _NOP
self.logger.debug('>> OPERATIONAL %s' % str(operational),self.connection.session())
yield operational
def new_refresh (self, refresh):
for _ in self.write(refresh,None):
yield _NOP
self.logger.debug('>> REFRESH %s' % str(refresh),self.connection.session())
yield refresh
class Protocol(object):
decode = True
def __init__(self, peer):
try:
self.logger = Logger()
except RuntimeError:
self.logger = FakeLogger()
self.peer = peer
self.neighbor = peer.neighbor
self.negotiated = Negotiated(self.neighbor)
self.connection = None
if self.neighbor.connect:
self.port = self.neighbor.connect
elif os.environ.get('exabgp.tcp.port', '').isdigit():
self.port = int(os.environ.get('exabgp.tcp.port'))
elif os.environ.get('exabgp_tcp_port', '').isdigit():
self.port = int(os.environ.get('exabgp_tcp_port'))
else:
self.port = 179
# XXX: FIXME: check the the -19 is correct (but it is harmless)
# The message size is the whole BGP message _without_ headers
self.message_size = Message.MAX_LEN - Message.HEADER_LEN
from exabgp.configuration.environment import environment
self.log_routes = environment.settings().log.routes
# XXX: we use self.peer.neighbor.peer_address when we could use self.neighbor.peer_address
def me(self, message):
return "Peer %15s ASN %-7s %s" % (self.peer.neighbor.peer_address,
self.peer.neighbor.peer_as, message)
def accept(self, incoming):
self.connection = incoming
if self.peer.neighbor.api['neighbor-changes']:
self.peer.reactor.processes.connected(self.peer.neighbor)
# very important - as we use this function on __init__
return self
def connect(self):
# allows to test the protocol code using modified StringIO with a extra 'pending' function
if not self.connection:
local = self.neighbor.md5_ip
peer = self.neighbor.peer_address
md5 = self.neighbor.md5_password
ttl_out = self.neighbor.ttl_out
self.connection = Outgoing(peer.afi, peer.top(), local.top(),
self.port, md5, ttl_out)
try:
generator = self.connection.establish()
while True:
connected = six.next(generator)
if not connected:
yield False
continue
if self.peer.neighbor.api['neighbor-changes']:
self.peer.reactor.processes.connected(
self.peer.neighbor)
yield True
return
except StopIteration:
# close called by the caller
# self.close('could not connect to remote end')
yield False
return
def close(self, reason='protocol closed, reason unspecified'):
if self.connection:
self.logger.network(self.me(reason))
# must be first otherwise we could have a loop caused by the raise in the below
self.connection.close()
self.connection = None
try:
if self.peer.neighbor.api['neighbor-changes']:
self.peer.reactor.processes.down(self.peer.neighbor,
reason)
except ProcessError:
self.logger.message(
self.
me('could not send notification of neighbor close to API'))
def _to_api(self, direction, message, raw):
packets = self.neighbor.api['%s-packets' % direction]
parsed = self.neighbor.api['%s-parsed' % direction]
consolidate = self.neighbor.api['%s-consolidate' % direction]
if consolidate:
if packets:
self.peer.reactor.processes.message(self.peer.neighbor,
direction, message,
raw[:19], raw[19:])
else:
self.peer.reactor.processes.message(self.peer.neighbor,
direction, message, '', '')
else:
if packets:
self.peer.reactor.processes.packets(self.peer.neighbor,
direction, int(message.ID),
raw[:19], raw[19:])
if parsed:
self.peer.reactor.processes.message(message.ID,
self.peer.neighbor,
direction, message, '', '')
def write(self, message, negotiated=None):
raw = message.message(negotiated)
if self.neighbor.api.get('send-%s' % Message.CODE.short(message.ID),
False):
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-%s' % Message.CODE.short(ord(raw[18])),
False):
message = Update.unpack_message(raw[19:], self.negotiated)
self._to_api('send', message, raw)
for boolean in self.connection.writer(raw):
yield boolean
# Read from network .......................................................
def read_message(self):
# This will always be defined by the loop but scope leaking upset scrutinizer/pylint
msg_id = None
packets = self.neighbor.api['receive-packets']
consolidate = self.neighbor.api['receive-consolidate']
parsed = self.neighbor.api['receive-parsed']
body, header = '', '' # just because pylint/pylama are getting more clever
for length, msg_id, header, body, notify in self.connection.reader():
# internal issue
if notify:
if self.neighbor.api.get(
'send-%s' % Message.CODE.NOTIFICATION.SHORT, False):
if consolidate:
self.peer.reactor.processes.notification(
self.peer.neighbor, 'send', notify.code,
notify.subcode, str(notify), header, body)
elif parsed:
self.peer.reactor.processes.notification(
self.peer.neighbor, 'send', notify.code,
notify.subcode, str(notify), '', '')
elif packets:
self.peer.reactor.processes.packets(
self.peer.neighbor, 'send', msg_id, header, body)
# XXX: is notify not already Notify class ?
raise Notify(notify.code, notify.subcode, str(notify))
if not length:
yield _NOP
continue
self.logger.message(self.me('<< %s' % Message.CODE.name(msg_id)))
for_api = self.neighbor.api.get(
'receive-%s' % Message.CODE.short(msg_id), False)
if for_api and packets and not consolidate:
self.peer.reactor.processes.packets(self.peer.neighbor,
'receive', msg_id, header,
body)
if msg_id == Message.CODE.UPDATE:
if not (for_api or self.log_routes) and not (parsed
or consolidate):
yield _UPDATE
return
try:
message = Message.unpack(msg_id, body, self.negotiated)
except (KeyboardInterrupt, SystemExit, Notify):
raise
except Exception as exc:
self.logger.message(
self.me('Could not decode message "%d"' % msg_id))
self.logger.message(self.me('%s' % str(exc)))
self.logger.message(traceback.format_exc())
raise Notify(
1, 0,
'can not decode update message of type "%d"' % msg_id)
# raise Notify(5,0,'unknown message received')
if message.TYPE == Update.TYPE:
if Attribute.CODE.INTERNAL_TREAT_AS_WITHDRAW in message.attributes:
for nlri in message.nlris:
nlri.action = IN.WITHDRAWN
if for_api:
if consolidate:
self.peer.reactor.processes.message(
msg_id, self.neighbor, 'receive', message, header,
body)
elif parsed:
self.peer.reactor.processes.message(
msg_id, self.neighbor, 'receive', message, '', '')
if message.TYPE == Notification.TYPE:
raise message
if message.TYPE == Update.TYPE and Attribute.CODE.INTERNAL_DISCARD in message.attributes:
yield _NOP
else:
yield message
def validate_open(self):
error = self.negotiated.validate(self.neighbor)
if error is not None:
raise Notify(*error)
def read_open(self, ip):
for received_open in self.read_message():
if received_open.TYPE == NOP.TYPE:
yield received_open
else:
break
if received_open.TYPE != Open.TYPE:
raise Notify(
5, 1, 'The first packet received is not an open message (%s)' %
received_open)
self.logger.message(self.me('<< %s' % received_open))
yield received_open
def read_keepalive(self):
for message in self.read_message():
if message.TYPE == NOP.TYPE:
yield message
else:
break
if message.TYPE != KeepAlive.TYPE:
raise Notify(5, 2)
yield message
#
# Sending message to peer
#
def new_open(self, restarted):
sent_open = Open(Version(4), self.neighbor.local_as,
self.neighbor.hold_time, self.neighbor.router_id,
Capabilities().new(self.neighbor, restarted))
# we do not buffer open message in purpose
for _ in self.write(sent_open):
yield _NOP
self.logger.message(self.me('>> %s' % sent_open))
yield sent_open
def new_keepalive(self, comment=''):
keepalive = KeepAlive()
for _ in self.write(keepalive):
yield _NOP
self.logger.message(
self.me('>> KEEPALIVE%s' % (' (%s)' % comment if comment else '')))
yield keepalive
def new_notification(self, notification):
for _ in self.write(notification):
yield _NOP
self.logger.message(
self.me(
'>> NOTIFICATION (%d,%d,"%s")' %
(notification.code, notification.subcode, notification.data)))
yield notification
def new_update(self, include_withdraw):
updates = self.neighbor.rib.outgoing.updates(
self.neighbor.group_updates)
number = 0
for update in updates:
for message in update.messages(self.negotiated, include_withdraw):
number += 1
for boolean in self.send(message):
# boolean is a transient network error we already announced
yield _NOP
if number:
self.logger.message(self.me('>> %d UPDATE(s)' % number))
yield _UPDATE
def new_eor(self, afi, safi):
eor = EOR(afi, safi)
for _ in self.write(eor):
yield _NOP
self.logger.message(self.me('>> EOR %s %s' % (afi, safi)))
yield eor
def new_eors(self, afi=AFI.undefined, safi=SAFI.undefined):
# Send EOR to let our peer know he can perform a RIB update
if self.negotiated.families:
families = self.negotiated.families if (afi, safi) == (
AFI.undefined, SAFI.undefined) else [
(afi, safi),
]
for eor_afi, eor_safi in families:
for _ in self.new_eor(eor_afi, eor_safi):
yield _
else:
# If we are not sending an EOR, send a keepalive as soon as when finished
# So the other routers knows that we have no (more) routes to send ...
# (is that behaviour documented somewhere ??)
for eor in self.new_keepalive('EOR'):
yield _NOP
yield _UPDATE
def new_operational(self, operational, negotiated):
for _ in self.write(operational, negotiated):
yield _NOP
self.logger.message(self.me('>> OPERATIONAL %s' % str(operational)))
yield operational
def new_refresh(self, refresh):
for _ in self.write(refresh, None):
yield _NOP
self.logger.message(self.me('>> REFRESH %s' % str(refresh)))
yield refresh
class Transcoder (object):
seen_open = {
'send': None,
'receive': None,
}
negotiated = None
json = Response.JSON(json_version)
def __init__ (self, src='json', dst='json'):
if src != 'json':
raise RuntimeError('left as an exercise to the reader')
if dst != 'json':
raise RuntimeError('left as an exercise to the reader')
self.convert = self._from_json
self.encoder = self.json
def _state (self):
self.seen_open['send'] = None
self.seen_open['receive'] = None
self.negotiated = None
def _open (self,direction,message):
self.seen_open[direction] = message
if all(self.seen_open.values()):
self.negotiated = Negotiated(None)
self.negotiated.sent(self.seen_open['send'])
self.negotiated.received(self.seen_open['receive'])
def _from_json (self, string):
try:
parsed = json.loads(string)
except ValueError:
print >> sys.stderr, 'invalid JSON message'
sys.exit(1)
if parsed.get('exabgp','0.0.0') != json_version:
print >> sys.stderr, 'invalid json version', string
sys.exit(1)
content = parsed.get('type','')
if not content:
print >> sys.stderr, 'invalid json content', string
sys.exit(1)
neighbor = _FakeNeighbor(
parsed['neighbor']['address']['local'],
parsed['neighbor']['address']['peer'],
parsed['neighbor']['asn']['local'],
parsed['neighbor']['asn']['peer'],
)
if content == 'state':
self._state()
return string
direction = parsed['neighbor']['direction']
category = parsed['neighbor']['message']['category']
header = parsed['neighbor']['message']['header']
body = parsed['neighbor']['message']['body']
raw = ''.join(chr(int(body[_:_+2],16)) for _ in range(0,len(body),2))
if content == 'open':
message = Open.unpack_message(raw)
self._open(direction,message)
return self.encoder.open(neighbor,direction,message,header,body)
if content == 'keapalive':
return self.encoder.keepalive(neighbor,direction,header,body)
if content == 'notification':
message = Notification.unpack_message(raw)
return self.encoder.notification(neighbor,direction,message,header,body)
if not self.negotiated:
print >> sys.stderr, 'invalid message sequence, open not exchange not complete', string
sys.exit(1)
message = Message.unpack(category,raw,self.negotiated)
if content == 'update':
return self.encoder.update(neighbor, direction, message, header,body)
if content == 'eor': # XXX: Should not be required
return self.encoder.update(neighbor, direction, message, header,body)
if content == 'refresh':
return self.json.refresh(neighbor, direction, message, header,body)
if content == 'operational':
return self.json.refresh(neighbor, direction, message, header,body)
raise RuntimeError('the programer is a monkey and forgot a JSON message type')
def check_generation(neighbors):
option.enabled['parser'] = True
for name in neighbors.keys():
neighbor = copy.deepcopy(neighbors[name])
neighbor['local-as'] = neighbor['peer-as']
path = {}
for f in NLRI.known_families():
if neighbor['capability']['add-path']:
path[f] = neighbor['capability']['add-path']
capa = Capabilities().new(neighbor, False)
if path:
capa[Capability.CODE.ADD_PATH] = path
capa[Capability.CODE.MULTIPROTOCOL] = neighbor.families()
routerid_1 = str(neighbor['router-id'])
routerid_2 = '.'.join(
str((int(_) + 1) % 250)
for _ in str(neighbor['router-id']).split('.', -1))
o1 = Open(Version(4), ASN(neighbor['local-as']), HoldTime(180),
RouterID(routerid_1), capa)
o2 = Open(Version(4), ASN(neighbor['peer-as']), HoldTime(180),
RouterID(routerid_2), capa)
negotiated = Negotiated(neighbor)
negotiated.sent(o1)
negotiated.received(o2)
# grouped = False
for _ in neighbor.rib.outgoing.updates(False):
pass
for change1 in neighbor.rib.outgoing.cached_changes():
str1 = change1.extensive()
packed = list(
Update([change1.nlri],
change1.attributes).messages(negotiated))
pack1 = packed[0]
log.debug('parsed route requires %d updates' % len(packed),
'parser')
log.debug('update size is %d' % len(pack1), 'parser')
log.debug('parsed route %s' % str1, 'parser')
log.debug('parsed hex %s' % od(pack1), 'parser')
# This does not take the BGP header - let's assume we will not break that :)
try:
log.debug('') # new line
pack1s = pack1[19:] if pack1.startswith(b'\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]
log.debug('recoded route %s' % str2, 'parser')
log.debug('recoded hex %s' % od(pack2), 'parser')
str1 = str1.replace('attribute [ 0x04 0x80 0x00000064 ]',
'med 100')
str1r = (str1.lower().replace(' med 100', '').replace(
' local-preference 100', '').replace(' origin igp', ''))
str2r = (str2.lower().replace(' med 100', '').replace(
' local-preference 100', '').replace(' origin igp', ''))
str2r = str2r.replace(
'large-community [ 1:2:3 10:11:12 ]',
'attribute [ 0x20 0xc0 0x0000000100000002000000030000000a0000000b0000000c ]',
)
if 'next-hop self' in str1r:
if ':' in str1r:
str1r = str1r.replace('next-hop self', 'next-hop ::1')
else:
str1r = str1r.replace(
'next-hop self',
'next-hop %s' % neighbor['local-address'])
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
log.debug(
'skipping string check on update with non-transitive attribute(s)',
'parser')
skip = True
else:
log.debug('strings are different:', 'parser')
log.debug('[%s]' % (str1r), 'parser')
log.debug('[%s]' % (str2r), 'parser')
return False
else:
log.debug('strings are fine', 'parser')
if skip:
log.debug(
'skipping encoding for update with non-transitive attribute(s)',
'parser')
elif pack1 != pack2:
log.debug('encoding are different', 'parser')
log.debug('[%s]' % (od(pack1)), 'parser')
log.debug('[%s]' % (od(pack2)), 'parser')
return False
else:
log.debug('encoding is fine', 'parser')
log.debug('----------------------------------------',
'parser')
log.debug('JSON nlri %s' % change1.nlri.json(), 'parser')
log.debug('JSON attr %s' % change1.attributes.json(), 'parser')
except Notify as exc:
log.debug('----------------------------------------', 'parser')
log.debug(str(exc), 'parser')
log.debug('----------------------------------------', 'parser')
return False
neighbor.rib.clear()
return True
def check_neighbor(neighbors):
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 NLRI.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, 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 _ 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_update(neighbor, raw):
logger = Logger()
logger._option.parser = True
logger.parser('\ndecoding routes in configuration')
neighbor = neighbor[neighbor.keys()[0]]
path = {}
for f in NLRI.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()
# capa[Capability.CODE.FOUR_BYTES_ASN] = True
routerid_1 = str(neighbor.router_id)
routerid_2 = '.'.join(
str((int(_) + 1) % 250)
for _ in str(neighbor.router_id).split('.', -1))
o1 = Open(4, neighbor.local_as, routerid_1, capa, 180)
o2 = Open(4, neighbor.peer_as, routerid_2, capa, 180)
negotiated = Negotiated(neighbor)
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
class Transcoder (object):
seen_open = {
'send': None,
'receive': None,
}
negotiated = None
json = Response.JSON(json_version)
def __init__ (self, src='json', dst='json'):
if src != 'json':
raise RuntimeError('left as an exercise to the reader')
if dst != 'json':
raise RuntimeError('left as an exercise to the reader')
self.convert = self._from_json
self.encoder = self.json
def _state (self):
self.seen_open['send'] = None
self.seen_open['receive'] = None
self.negotiated = None
def _open (self,direction,message):
self.seen_open[direction] = message
if all(self.seen_open.values()):
self.negotiated = Negotiated(None)
self.negotiated.sent(self.seen_open['send'])
self.negotiated.received(self.seen_open['receive'])
def _from_json (self, json_string):
try:
parsed = json.loads(json_string)
except ValueError:
print('invalid JSON message', file=sys.stderr)
sys.exit(1)
if parsed.get('exabgp','0.0.0') != json_version:
print('invalid json version', json_string, file=sys.stderr)
sys.exit(1)
content = parsed.get('type','')
if not content:
print('invalid json content', json_string, file=sys.stderr)
sys.exit(1)
neighbor = _FakeNeighbor(
parsed['neighbor']['address']['local'],
parsed['neighbor']['address']['peer'],
parsed['neighbor']['asn']['local'],
parsed['neighbor']['asn']['peer'],
)
if content == 'state':
self._state()
return json_string
direction = parsed['neighbor']['direction']
category = parsed['neighbor']['message']['category']
header = parsed['neighbor']['message']['header']
body = parsed['neighbor']['message']['body']
data = concat_bytes_i(character(int(body[_:_+2],16)) for _ in range(0,len(body),2))
if content == 'open':
message = Open.unpack_message(data)
self._open(direction,message)
return self.encoder.open(neighbor,direction,message,None,header,body)
if content == 'keepalive':
return self.encoder.keepalive(neighbor,direction,None,header,body)
if content == 'notification':
# XXX: Use the code of the Notifcation class here ..
message = Notification.unpack_message(data)
if (message.code, message.subcode) != (6, 2):
message.data = data if not len([_ for _ in data if _ not in string.printable]) else hexstring(data)
return self.encoder.notification(neighbor,direction,message,None,header,body)
if len(data) == 0:
# shutdown without shutdown communication (the old fashioned way)
message.data = ''
return self.encoder.notification(neighbor,direction,message,None,header,body)
# draft-ietf-idr-shutdown or the peer was using 6,2 with data
shutdown_length = ordinal(data[0])
data = data[1:]
if shutdown_length == 0:
message.data = "empty Shutdown Communication."
# move offset past length field
return self.encoder.notification(neighbor,direction,message,None,header,body)
if len(data) < shutdown_length:
message.data = "invalid Shutdown Communication (buffer underrun) length : %i [%s]" % (shutdown_length, hexstring(data))
return self.encoder.notification(neighbor,direction,message,None,header,body)
if shutdown_length > 128:
message.data = "invalid Shutdown Communication (too large) length : %i [%s]" % (shutdown_length, hexstring(data))
return self.encoder.notification(neighbor,direction,message,None,header,body)
try:
message.data = 'Shutdown Communication: "%s"' % \
data[:shutdown_length].decode('utf-8').replace('\r',' ').replace('\n',' ')
except UnicodeDecodeError:
message.data = "invalid Shutdown Communication (invalid UTF-8) length : %i [%s]" % (shutdown_length, hexstring(data))
return self.encoder.notification(neighbor,direction,message,None,header,body)
trailer = data[shutdown_length:]
if trailer:
message.data += ", trailing data: " + hexstring(trailer)
return self.encoder.notification(neighbor,direction,message,None,header,body)
if not self.negotiated:
print('invalid message sequence, open not exchange not complete', json_string, file=sys.stderr)
sys.exit(1)
message = Message.unpack(category,data,self.negotiated)
if content == 'update':
return self.encoder.update(neighbor, direction, message, None, header,body)
if content == 'eor': # XXX: Should not be required
return self.encoder.update(neighbor, direction, message, None, header,body)
if content == 'refresh':
return self.json.refresh(neighbor, direction, message, None, header,body)
if content == 'operational':
return self.json.refresh(neighbor, direction, message, None, header,body)
raise RuntimeError('the programer is a monkey and forgot a JSON message type')
