add license, readme and example

Author: philmayers

LICENSE

@@ -0,0 +1,19 @@
+Copyright (c) 2009 Phil Mayers
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+THE SOFTWARE.

README

@@ -0,0 +1,20 @@
+This code is a simple python BGP implementation. It only speaks the protocol;
+there is no code for building or maintaining a RIB, or doing kernel-layer
+stuff such as inserting or deleting routes.
+
+Whilst I'm not opposed to someone else adding those things, I have no use
+for them, so please don't ask me to write them ;o)
+
+The intended use is for things such as anycast load-balancing, as with DNS
+or similar services. There is a script in "examples" which is very similar
+to the code we use.
+
+There are a few tests; there could and should be more.
+
+The code as written requires Python 2.5 struct.unpack_from. It would be pretty
+easy to either remove this requirement or make a compatibility layer for older
+python versions.
+
+The project is run, somewhat against my better judgement, in Launchpad:
+
+ https://launchpad.net/pybgp

examples/dnsanycast

@@ -0,0 +1,128 @@
+#!/usr/bin/python2.5
+
+from twisted.internet import reactor, protocol
+
+from pybgp import speaker, pathattr, proto
+
+import tcpcheck
+
+# This script is a simple example of the pybgp library. The setup below
+# assumes the following config:
+#
+# router 192.168.1.1 AS# 65000
+#  |
+# us     192.168.1.2 AS# 65001
+#
+# ...and virtual IPs bound to the loopback interface, on which a DNS
+# server will be listening - e.g. under linux:
+#
+# ip addr add 192.168.2.1/32 dev lo
+# ip addr add 192.168.2.2/32 dev lo
+# rndc reload
+#
+# As long as the virtual IPs continue to answer TCP port 53 connects the
+# VIPs will be advertised by eBGP to the router
+
+class Checker(tcpcheck.Checker):
+    def change(self, old, new):
+        if new=='up':
+            self.bgp.advertise('%s/32' % (self.host,))
+        else:
+            self.bgp.withdraw('%s/32' % (self.host,))
+
+class BGPp(speaker.BGP):
+    def send(self, msg):
+        print "sending", msg
+        speaker.BGP.send(self, msg)
+
+class BGPd:
+    # This is all a bit hacky. Proper support for both listening and
+    # connecting, the BGP state machine, disconnects and so forth are
+    # all needed...
+
+    def __init__(self, asnum, bgpid):
+        self.cc = protocol.ClientCreator(reactor, BGPp)
+        self.asnum = asnum
+        self.bgpid = bgpid
+        self.peers = {}
+
+    def peer(self, ip, remoteas):
+        if ip in self.peers:
+            raise Exception('connection already established')
+
+        self.peers[ip] = {'remoteas': remoteas, 'state': 'opening', 'proto': None, 'queue': []}
+
+        d = self.cc.connectTCP(ip, 179)
+        d.addCallbacks(self.ok, self.err, (ip,), {}, (ip,), {})
+
+    def ok(self, proto, ip):
+        print "connection to", ip, "up"
+        self.peers[ip]['proto'] = proto
+        self.peers[ip]['state'] = 'open'
+
+        # send our Open message
+        proto.open(self.asnum, self.bgpid)
+        proto.handle_msg = lambda x: self.msg(ip, x)
+
+    def msg(self, ip, msg):
+        if not ip in self.peers:
+            return
+        proto = self.peers[ip]['proto']
+
+        if msg.kind=='open':
+            proto.start_timer(msg.holdtime)
+
+            q = self.peers[ip]['queue']
+            while q:
+                action, data = q.pop(0)
+                if action=='update':
+                    proto.send(data)
+
+        elif msg.kind=='notification':
+            print "notification from", ip, msg
+            proto.transport.loseConnection()
+            del self.peers[ip]
+
+    def err(self, reason, ip):
+        if not ip in self.peers:
+            return
+        print "connection to", ip, "failed", reason
+        del self.peers[ip]
+
+    def advertise(self, prefix):
+        up = proto.Update(
+            pathattr.Origin('incomplete'),
+            pathattr.Med(0),
+            pathattr.AsPath([[self.asnum]]),
+            pathattr.NextHop('155.198.62.12'),
+            nlri=[prefix],
+            )
+        for p, info in self.peers.items():
+            if info['state']=='open':
+                info['proto'].send(up)
+            else:
+                info['queue'].append(('update', up))
+        
+    def withdraw(self, prefix):
+        up = proto.Update(
+            withdraw=[prefix],
+            )
+        for p, info in self.peers.items():
+            if info['state']=='open':
+                info['proto'].send(up)
+            else:
+                info['queue'].append(('update', up))
+        
+
+def main():
+    b = BGPd(65001, '192.168.1.2')
+    b.peer('192.168.1.1', 65000)
+
+    for ip in ('192.168.2.1', '192.168.2.2'):
+        c = Checker(ip, 53, '127.0.0.1')
+        c.bgp = b
+        c.start(5)
+
+if __name__=='__main__':
+    reactor.callWhenRunning(main)
+    reactor.run()

examples/tcpcheck.py

@@ -0,0 +1,55 @@
+#!/usr/bin/python2.5
+
+from twisted.internet import reactor, protocol, task
+
+class TcpProbeProt(protocol.Protocol):
+    def connectionMade(self):
+        self.factory.ok()
+        self.transport.loseConnection()
+
+class TcpProbe(protocol.ClientFactory):
+    protocol = TcpProbeProt
+    ok = 0
+
+    def clientConnectionFailed(self, connector, reason):
+        self.callback(False)
+
+    def ok(self):
+        self.ok = 1
+
+    def clientConnectionLost(self, connector, reason):
+        if self.ok:
+            self.callback(True)
+        else:
+            self.callback(False)
+
+class Checker:
+    def __init__(self, host, port, localif=''):
+        self.state = 'down'
+        self.host = host
+        self.port = port
+        self.localif = localif
+        self.timeout = 2
+
+    def start(self, interval):
+        self.task = task.LoopingCall(self.check_tcp)
+        self.task.start(interval)
+
+    def check_tcp(self):
+        f = TcpProbe()
+        f.callback = self.callback
+        reactor.connectTCP(self.host, self.port, f, timeout=self.timeout, bindAddress=(self.localif,0))
+
+    def callback(self, up):
+        print "state", up
+        if up:
+            if self.state=='down':
+                self.change('down', 'up')
+            self.state = 'up'
+        else:
+            if self.state=='up':
+                self.change('up', 'down')
+            self.state = 'down'
+
+    def change(self, old, new):
+        print "state for %s:%s (from %s) changes from %s to %s" % (self.host, self.port, self.localif, old, new)