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):
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 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 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 _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 = environment.settings().log.routes
def setUp(self):
#env.log.all = True
self.negotiated = {}
for asn4 in (True, False):
neighbor = Neighbor()
neighbor.asn4 = asn4
capa = Capabilities().new(neighbor, False)
capa[Capability.ID.MULTIPROTOCOL] = neighbor.families()
# path = {}
# for f in known_families():
# if neighbor.add_path:
# path[f] = neighbor.add_path
# capa[Capability.ID.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 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 __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
port = os.environ.get('exabgp.tcp.port','')
self.port = int(port) if port.isdigit() else 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
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
port = os.environ.get('exabgp.tcp.port','')
self.port = int(port) if port.isdigit() else 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
class Transcoder (object):
seen_open = {
'send': None,
'receive': None,
}
negotiated = None
json = 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':
return self.encoder.notification(neighbor,direction,ord(message[0]),ord(message[1]),message[2:],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 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
port = os.environ.get('exabgp.tcp.port','') or os.environ.get('exabgp_tcp_port','')
self.port = int(port) if port.isdigit() else 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 __del__ (self):
self.close('automatic protocol cleanup')
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
self.peer.reactor.processes.reset(self.peer)
if self.peer.neighbor.api.neighbor_changes:
self.peer.reactor.processes.connected(self.peer)
# 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:
peer = self.neighbor.peer_address
local = self.neighbor.local_address
md5 = self.neighbor.md5
ttl = self.neighbor.ttl
self.connection = Outgoing(peer.afi,peer.ip,local.ip,self.port,md5,ttl)
connected = False
try:
generator = self.connection.establish()
while True:
connected = generator.next()
if not connected:
yield False
continue
self.peer.reactor.processes.reset(self.peer)
if self.peer.neighbor.api.neighbor_changes:
self.peer.reactor.processes.connected(self.peer)
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,reason)
except ProcessError:
self.logger.message(self.me('could not send notification of neighbor close to API'))
def write (self,message):
if self.neighbor.api.send_packets:
self.peer.reactor.processes.send(self.peer,ord(message[18]),message[:19],message[19:])
for boolean in self.connection.writer(message):
yield boolean
# Read from network .......................................................
def read_message (self,comment=''):
self.peer.reactor.processes.increase(self.peer)
for length,msg,header,body,notify in self.connection.reader():
if notify:
if self.neighbor.api.receive_packets:
self.peer.reactor.processes.receive(self.peer,msg,header,body)
if self.neighbor.api.receive_notifications:
self.peer.reactor.processes.notification(self.peer,notify.code,notify.subcode,str(notify))
# XXX: is notify not already Notify class ?
raise Notify(notify.code,notify.subcode,str(notify))
if not length:
yield _NOP
if self.neighbor.api.receive_packets:
self.peer.reactor.processes.receive(self.peer,msg,header,body)
if msg == Message.Type.UPDATE:
self.logger.message(self.me('<< UPDATE'))
# This could be speed up massively by changing the order of the IF
if length == 23:
update = EORFactory()
if self.neighbor.api.receive_updates:
if self.neighbor.api.consolidate:
self.peer.reactor.processes.update(self.peer,update,header,body)
else:
self.peer.reactor.processes.update(self.peer,update,'','')
elif length == 30 and body.startswith(EOR.MP):
update = EORFactory(body)
if self.neighbor.api.receive_updates:
if self.neighbor.api.consolidate:
self.peer.reactor.processes.update(self.peer,update,header,body)
else:
self.peer.reactor.processes.update(self.peer,update,'','')
elif self.neighbor.api.receive_updates:
update = UpdateFactory(self.negotiated,body)
if self.neighbor.api.consolidate:
self.peer.reactor.processes.update(self.peer,update,header,body)
else:
self.peer.reactor.processes.update(self.peer,update,'','')
elif self.log_routes:
update = UpdateFactory(self.negotiated,body)
else:
update = _UPDATE
yield update
elif msg == Message.Type.KEEPALIVE:
self.logger.message(self.me('<< KEEPALIVE%s' % (' (%s)' % comment if comment else '')))
if self.neighbor.api.receive_keepalives:
if self.neighbor.api.consolidate:
self.peer.reactor.processes.keepalive(self.peer,msg,header,body)
else:
self.peer.reactor.processes.keepalive(self.peer,msg,'','')
yield KeepAlive()
elif msg == Message.Type.NOTIFICATION:
self.logger.message(self.me('<< NOTIFICATION'))
yield NotificationFactory(body)
elif msg == Message.Type.ROUTE_REFRESH:
if self.negotiated.refresh != REFRESH.absent:
self.logger.message(self.me('<< ROUTE-REFRESH'))
refresh = RouteRefreshFactory(body)
if self.neighbor.api.receive_refresh:
if refresh.reserved in (RouteRefresh.start,RouteRefresh.end):
if self.neighbor.api.consolidate:
self.peer.reactor.process.refresh(self.peer,refresh,header,body)
else:
self.peer.reactor.processes.refresh(self.peer,refresh,'','')
else:
# XXX: FIXME: really should raise, we are too nice
self.logger.message(self.me('<< NOP (un-negotiated type %d)' % msg))
refresh = UnknownMessageFactory(body)
yield refresh
elif msg == Message.Type.OPERATIONAL:
if self.peer.neighbor.operational:
operational = OperationalFactory(body)
what = OperationalGroup[operational.what][0]
if self.neighbor.api.consolidate:
self.peer.reactor.processes.operational(self.peer,what,operational,header,body)
else:
self.peer.reactor.processes.operational(self.peer,what,operational,'','')
else:
operational = _OPERATIONAL
yield operational
elif msg == Message.Type.OPEN:
if self.neighbor.api.receive_opens:
open_message = OpenFactory(body)
if self.neighbor.api.consolidate:
self.peer.reactor.processes.open(self.peer,'received',open_message,header,body)
else:
self.peer.reactor.processes.open(self.peer,'received',open_message,'','')
yield OpenFactory(body)
else:
# XXX: FIXME: really should raise, we are too nice
self.logger.message(self.me('<< NOP (unknow type %d)' % msg))
yield UnknownMessageFactory(msg)
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 == Notification.TYPE:
raise received_open
if received_open.TYPE != Open.TYPE:
raise Notify(5,1,'The first packet recevied is not an open message (%s)' % received_open)
self.logger.message(self.me('<< %s' % received_open))
yield received_open
def read_keepalive (self,comment=''):
for message in self.read_message(comment):
if message.TYPE == NOP.TYPE:
yield message
else:
break
if message.TYPE == Notification.TYPE:
raise message
if message.TYPE != KeepAlive.TYPE:
raise Notify(5,2)
yield message
#
# Sending message to peer
#
def new_open (self,restarted):
sent_open = Open(
4,
self.neighbor.local_as,
self.neighbor.router_id.ip,
Capabilities().new(self.neighbor,restarted),
self.neighbor.hold_time
)
# we do not buffer open message in purpose
msg_send = sent_open.message()
for _ in self.write(msg_send):
yield _NOP
self.logger.message(self.me('>> %s' % sent_open))
if self.neighbor.api.receive_opens:
if self.neighbor.api.consolidate:
header = msg_send[0:38]
body = msg_send[38:]
self.peer.reactor.processes.open(self.peer,'sent',sent_open,header,body)
else:
self.peer.reactor.processes.open(self.peer,'sent',sent_open,'','')
yield sent_open
def new_keepalive (self,comment=''):
keepalive = KeepAlive()
for _ in self.write(keepalive.message()):
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.message()):
yield _NOP
self.logger.message(self.me('>> NOTIFICATION (%d,%d,"%s")' % (notification.code,notification.subcode,notification.data)))
yield notification
def new_update (self):
updates = self.neighbor.rib.outgoing.updates(self.neighbor.group_updates)
number = 0
for update in updates:
for message in update.messages(self.negotiated):
number += 1
for boolean in self.write(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_eors (self):
# Send EOR to let our peer know he can perform a RIB update
if self.negotiated.families:
for afi,safi in self.negotiated.families:
eor = EOR(afi,safi).message()
for _ in self.write(eor):
yield _NOP
yield _UPDATE
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.message(negotiated)):
yield _NOP
self.logger.message(self.me('>> OPERATIONAL %s' % str(operational)))
yield operational
def new_refresh (self,refresh,negotiated):
for refresh in refresh.messages(negotiated):
for _ in self.write(refresh):
yield _NOP
self.logger.message(self.me('>> REFRESH %s' % str(refresh)))
yield refresh
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_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
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
port = os.environ.get('exabgp.tcp.port', '') or os.environ.get(
'exabgp_tcp_port', '')
self.port = int(port) if port.isdigit() else 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 __del__(self):
self.close('automatic protocol cleanup')
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
self.peer.reactor.processes.reset(self.peer)
if self.peer.neighbor.api['neighbor-changes']:
self.peer.reactor.processes.connected(self.peer)
# 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:
peer = self.neighbor.peer_address
local = self.neighbor.local_address
md5 = self.neighbor.md5
ttl = self.neighbor.ttl
self.connection = Outgoing(peer.afi, peer.ip, local.ip, self.port,
md5, ttl)
connected = False
try:
generator = self.connection.establish()
while True:
connected = generator.next()
if not connected:
yield False
continue
self.peer.reactor.processes.reset(self.peer)
if self.peer.neighbor.api['neighbor-changes']:
self.peer.reactor.processes.connected(self.peer)
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, reason)
except ProcessError:
self.logger.message(
self.
me('could not send notification of neighbor close to API'))
def write(self, message):
if self.neighbor.api[
'send-packets'] and not self.neighbor.api['consolidate']:
self.peer.reactor.processes.send(self.peer, ord(message[18]),
message[:19], message[19:])
for boolean in self.connection.writer(message):
yield boolean
# Read from network .......................................................
def read_message(self, comment=''):
for length, msg, header, body, notify in self.connection.reader():
if notify:
if self.neighbor.api['receive-packets']:
self.peer.reactor.processes.receive(
self.peer, msg, header, body)
if self.neighbor.api[Message.ID.NOTIFICATION]:
self.peer.reactor.processes.notification(
self.peer, notify.code, notify.subcode, str(notify))
# XXX: is notify not already Notify class ?
raise Notify(notify.code, notify.subcode, str(notify))
if not length:
yield _NOP
if self.neighbor.api[
'receive-packets'] and not self.neighbor.api['consolidate']:
self.peer.reactor.processes.receive(self.peer, msg, header, body)
if msg == Message.ID.UPDATE and not self.neighbor.api[
'receive-parsed'] and not self.log_routes:
yield _UPDATE
return
message = Message.unpack_message(msg, body, self.negotiated)
self.logger.message(self.me('<< %s' % Message.ID.name(msg)))
if message.TYPE == Notification.TYPE:
raise message
if self.neighbor.api[msg]:
if self.neighbor.api['receive-parsed']:
if self.neighbor.api['consolidate'] and self.neighbor.api[
'receive-packets']:
self.peer.reactor.processes.message(
msg, self.peer, message, header, body)
else:
self.peer.reactor.processes.message(
msg, self.peer, message, '', '')
yield message
return
# XXX: FIXME: check it is well 2,4
raise Notify(2, 4, 'unknown message received')
# elif msg == Message.ID.ROUTE_REFRESH:
# if self.negotiated.refresh != REFRESH.absent:
# self.logger.message(self.me('<< ROUTE-REFRESH'))
# refresh = RouteRefresh.unpack_message(body,self.negotiated)
# if self.neighbor.api.receive_refresh:
# if refresh.reserved in (RouteRefresh.start,RouteRefresh.end):
# if self.neighbor.api.consolidate:
# self.peer.reactor.process.refresh(self.peer,refresh,header,body)
# else:
# self.peer.reactor.processes.refresh(self.peer,refresh,'','')
# else:
# # XXX: FIXME: really should raise, we are too nice
# self.logger.message(self.me('<< NOP (un-negotiated type %d)' % msg))
# refresh = UnknownMessage.unpack_message(body,self.negotiated)
# yield refresh
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 recevied is not an open message (%s)' %
received_open)
self.logger.message(self.me('<< %s' % received_open))
yield received_open
def read_keepalive(self, comment=''):
for message in self.read_message(comment):
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(4, self.neighbor.local_as, self.neighbor.router_id.ip,
Capabilities().new(self.neighbor, restarted),
self.neighbor.hold_time)
# we do not buffer open message in purpose
msg_send = sent_open.message()
for _ in self.write(msg_send):
yield _NOP
self.logger.message(self.me('>> %s' % sent_open))
if self.neighbor.api[Message.ID.OPEN]:
if self.neighbor.api['consolidate']:
header = msg_send[0:38]
body = msg_send[38:]
self.peer.reactor.processes.message(Message.ID.OPEN, self.peer,
sent_open, header, body,
'sent')
else:
self.peer.reactor.processes.message(Message.ID.OPEN, self.peer,
sent_open, '', '', 'sent')
yield sent_open
def new_keepalive(self, comment=''):
keepalive = KeepAlive()
for _ in self.write(keepalive.message()):
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.message()):
yield _NOP
self.logger.message(
self.me(
'>> NOTIFICATION (%d,%d,"%s")' %
(notification.code, notification.subcode, notification.data)))
yield notification
def new_update(self):
updates = self.neighbor.rib.outgoing.updates(
self.neighbor.group_updates)
number = 0
for update in updates:
for message in update.messages(self.negotiated):
number += 1
for boolean in self.write(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_eors(self):
# Send EOR to let our peer know he can perform a RIB update
if self.negotiated.families:
for afi, safi in self.negotiated.families:
eor = EOR(afi, safi).message()
for _ in self.write(eor):
yield _NOP
yield _UPDATE
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.message(negotiated)):
yield _NOP
self.logger.message(self.me('>> OPERATIONAL %s' % str(operational)))
yield operational
def new_refresh(self, refresh, negotiated):
for refresh in refresh.messages(negotiated):
for _ in self.write(refresh):
yield _NOP
self.logger.message(self.me('>> REFRESH %s' % str(refresh)))
yield refresh
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 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
class Transcoder(object):
seen_open = {
'send': None,
'receive': None,
}
negotiated = None
json = 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':
return self.encoder.notification(neighbor, direction,
ord(message[0]), ord(message[1]),
message[2:], 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')