Changeset 164 for etherws

Timestamp:

06/26/12 02:46:58 (12 years ago)

Author:

atzm

Message:

• switching support

File:

• etherws/trunk/etherws.py (modified) (7 diffs)

etherws/trunk/etherws.py

@@ -60 +60 @@
 
 class DebugMixIn(object):
-    def dprintf(self, msg, *args):
+    def dprintf(self, msg, func):
         if self._debug:
             prefix = '[%s] %s - ' % (time.asctime(), self.__class__.__name__)
-            sys.stderr.write(prefix + (msg % args))
+            sys.stderr.write(prefix + (msg % func()))
+
+
+class EthernetFrame(object):
+    def __init__(self, data):
+        self.data = data
+
+    @property
+    def multicast(self):
+        return ord(self.data[0]) & 1
+
+    @property
+    def dst_mac(self):
+        return self.data[:6]
+
+    @property
+    def src_mac(self):
+        return self.data[6:12]
+
+    @property
+    def tagged(self):
+        return ord(self.data[12]) == 0x81 and ord(self.data[13]) == 0
+
+    @property
+    def vid(self):
+        if self.tagged:
+            return ((ord(self.data[14]) << 8) | ord(self.data[15])) & 0x0fff
+        return -1
+
+
+class SwitchingTable(DebugMixIn):
+    def __init__(self, ageout=300, debug=False):
+        self._ageout = ageout
+        self._debug = debug
+        self._table = {}
+
+    def learn(self, frame, port):
+        mac = frame.src_mac
+        vid = frame.vid
+
+        if vid not in self._table:
+            self._table[vid] = {}
+
+        self._table[vid][mac] = {'time': time.time(), 'port': port}
+        self.dprintf('learned: [%d] %s\n',
+                     lambda: (vid, mac.encode('hex')))
+
+    def lookup(self, frame):
+        mac = frame.dst_mac
+        vid = frame.vid
+
+        group = self._table.get(vid, None)
+        if not group:
+            return None
+
+        entry = group.get(mac, None)
+        if not entry:
+            return None
+
+        if time.time() - entry['time'] > self._ageout:
+            del self._table[vid][mac]
+            if not self._table[vid]:
+                del self._table[vid]
+            self.dprintf('aged out: [%d] %s\n',
+                         lambda: (vid, mac.encode('hex')))
+            return None
+
+        return entry['port']
+
+    def delete(self, port):
+        for vid in self._table.keys():
+            for mac in self._table[vid].keys():
+                if self._table[vid][mac]['port'] is port:
+                    del self._table[vid][mac]
+                    self.dprintf('deleted: [%d] %s\n',
+                                 lambda: (vid, mac.encode('hex')))
+            if not self._table[vid]:
+                del self._table[vid]
 
 
@@ -72 +149 @@
         self._debug = debug
         self._clients = []
+        self._table = SwitchingTable(debug=debug)
+        self._tablelock = threading.Lock()
         self._tap = pytun.TunTapDevice(dev, pytun.IFF_TAP | pytun.IFF_NO_PI)
         self._tap.up()
         self._taplock = threading.Lock()
+        self.register_client(self)
 
     def fileno(self):
-        with self._taplock:
-            return self._tap.fileno()
+        return self._tap.fileno()
 
     def register_client(self, client):
@@ -84 +163 @@
 
     def unregister_client(self, client):
+        self._table.delete(client)
         self._clients.remove(client)
 
+    # synchronized methods
+    def write_message(self, message, binary=False):
+        with self._taplock:
+            self._tap.write(message)
+
     def write(self, caller, message):
+        frame = EthernetFrame(message)
+
+        with self._tablelock:
+            self._table.learn(frame, caller)
+
+        if not frame.multicast:
+            with self._tablelock:
+                dst = self._table.lookup(frame)
+
+            if dst:
+                dst.write_message(frame.data, True)
+                self.dprintf('sent unicast: [%d] %s -> %s\n',
+                             lambda: (frame.vid,
+                                      frame.src_mac.encode('hex'),
+                                      frame.dst_mac.encode('hex')))
+                return
+
         clients = self._clients[:]
-
-        if caller is not self:
-            clients.remove(caller)
-
-            with self._taplock:
-                self._tap.write(message)
+        clients.remove(caller)
 
         for c in clients:
-            c.write_message(message, True)
+            c.write_message(frame.data, True)
+
+        self.dprintf('sent broadcast: [%d] %s -> %s\n',
+                     lambda: (frame.vid,
+                              frame.src_mac.encode('hex'),
+                              frame.dst_mac.encode('hex')))
 
     def __call__(self, fd, events):
@@ -122 +224 @@
     def open(self):
         self._tap.register_client(self)
-        self.dprintf('connected: %s\n', self.request.remote_ip)
+        self.dprintf('connected: %s\n', lambda: self.request.remote_ip)
 
     def on_message(self, message):
         self._tap.write(self, message)
-        self.dprintf('received: %s %s\n',
-                     self.request.remote_ip, message.encode('hex'))
 
     def on_close(self):
         self._tap.unregister_client(self)
-        self.dprintf('disconnected: %s\n', self.request.remote_ip)
+        self.dprintf('disconnected: %s\n', lambda: self.request.remote_ip)
 
 
@@ -156 +256 @@
         self._sock = websocket.WebSocket()
         self._sock.connect(self._url, **self._options)
-        self.dprintf('connected: %s\n', self._url)
+        self.dprintf('connected: %s\n', lambda: self._url)
 
     def close(self):
@@ -163 +263 @@
         self._sock.close()
         self._sock = None
-        self.dprintf('disconnected: %s\n', self._url)
+        self.dprintf('disconnected: %s\n', lambda: self._url)
 
     def write_message(self, message, binary=False):
@@ -173 +273 @@
             flag = websocket.ABNF.OPCODE_TEXT
         self._sock.send(message, flag)
-        self.dprintf('sent: %s %s\n', self._url, message.encode('hex'))
 
     def run_forever(self):