1

scripts/proxy/proxy.py

@@ -19,6 +19,6 @@ parser.add_option("-f",
 (options, args) = parser.parse_args()
 
 if options.forward:
-    cliside.ClientSide(options.port, args[0]).run()
+    cliside.ClientSide(options.forward, args[0]).run()
 else:
-    srvside.ServerSide(options.forward, args[0]).run()
+    srvside.ServerSide(options.port, args[0]).run()

scripts/proxy/srvside.py

@@ -1,24 +1,88 @@
 # -*- coding: utf-8 -*-
 import os
+import json
 import tornado.ioloop
 import tornado.web
 import tornado.websocket
+import tornado.tcpserver
 
-class ChatSocketHandler(tornado.websocket.WebSocketHandler):
+app = None
-
-    def __init__(self):
-        pass
-
 class ServerSide:
 
     def __init__(self, local_port, remote_port):
-        self._local_port = local_port
+        self._local_port = int(local_port)
-        self._remote_port = remote_port
+        self._remote_port = int(remote_port)
+        app = self
+        self.local = None
+        self.remote = None
+        self.localHandlerHash = {}
 
     def run(self):
-        settings = {}
+        webapp = tornado.web.Application([
-        app = tornado.web.Application([
+            (r"/websocket", LocalSocketHandler)
-            (r"/websocket", ChatSocketHandler)
+        ], {})
-        ], **settings)
+        webapp.listen(self._local_port)
-        app.listen(8181)
+
+        remote_server = RemoteServer()
+        remote_server.listen(self._remote_port)
+
+        self.local = webapp
+        self.remote = remote_server
         tornado.ioloop.IOLoop.instance().start()
+
+    def addRemoteConn(conn):
+        pass
+
+    def addLocalConn(conn):
+        self.localHandlerHash[conn] = conn
+
+    def removeLocalConn(conn):
+        del self.localHandlerHash[conn]
+
+class RemoteServerConnection(object):
+
+    def __init__(self, steam, address):
+        self.steam = steam
+        self.address = address
+
+    async def handle_stream():
+        while True:
+            try:
+                data = await self.stream.read_until(b"\n")
+                await self.stream.write(data)
+            except tornado.iostream.StreamClosedError:
+                break
+
+class RemoteServer(tornado.tcpserver.TCPServer):
+
+    async def handle_stream(self, stream, address):
+        conn = RemoteServerConnection(steam, address)
+        app.addRemoteConn(conn)
+        conn.handle_stream()
+
+class LocalSocketHandler(tornado.websocket.WebSocketHandler):
+
+    def open(self):
+        self._recvBuf = ''
+        app.addLocalConn(self)
+
+    def on_message(self, message):
+        self._recvBuf += message
+        self.parsePacket()
+
+    def on_close(self):
+        app.removeLocalConn(self)
+
+    def parsePacket(self):
+        if len(self._recvBuf) <= 0:
+            return
+        lines = self._recvBuf.split('\n')
+        if self._recvBuf[-1] == '\n':
+            self._recvbuf = lines[-1]
+            lines = lines[:-1]
+        for line in lines:
+            msg = json.loads(line)
+            self.dispatchMsg(msg)
+
+    def dispatchMsg(self, msg):
+        pass