split up proxy.py

4 files changed, 170 insertions, 0 deletions

diff --git a/libmproxy/prxy/__init__.py b/libmproxy/prxy/__init__.py
new file mode 100644
index 00000000..e69de29b
--- /dev/null
+++ b/libmproxy/prxy/__init__.py
diff --git a/libmproxy/prxy/connection.py b/libmproxy/prxy/connection.py
new file mode 100644
index 00000000..b1040c1c
--- /dev/null
+++ b/libmproxy/prxy/connection.py
@@ -0,0 +1,138 @@
+import copy
+import os
+from .. import stateobject, utils
+from .exception import ProxyError
+from netlib import tcp, certutils
+
+class ClientConnection(tcp.BaseHandler, stateobject.SimpleStateObject):
+    def __init__(self, client_connection, address, server):
+        if client_connection:  # Eventually, this object is restored from state. We don't have a connection then.
+            tcp.BaseHandler.__init__(self, client_connection, address, server)
+        else:
+            self.connection = None
+            self.server = None
+            self.wfile = None
+            self.rfile = None
+            self.address = None
+            self.clientcert = None
+
+        self.timestamp_start = utils.timestamp()
+        self.timestamp_end = None
+        self.timestamp_ssl_setup = None
+
+    _stateobject_attributes = dict(
+        timestamp_start=float,
+        timestamp_end=float,
+        timestamp_ssl_setup=float
+    )
+
+    def _get_state(self):
+        d = super(ClientConnection, self)._get_state()
+        d.update(
+            address={"address": self.address(), "use_ipv6": self.address.use_ipv6},
+            clientcert=self.cert.to_pem() if self.clientcert else None
+        )
+        return d
+
+    def _load_state(self, state):
+        super(ClientConnection, self)._load_state(state)
+        self.address = tcp.Address(**state["address"]) if state["address"] else None
+        self.clientcert = certutils.SSLCert.from_pem(state["clientcert"]) if state["clientcert"] else None
+
+    def copy(self):
+        return copy.copy(self)
+
+    def send(self, message):
+        self.wfile.write(message)
+        self.wfile.flush()
+
+    @classmethod
+    def _from_state(cls, state):
+        f = cls(None, tuple(), None)
+        f._load_state(state)
+        return f
+
+    def convert_to_ssl(self, *args, **kwargs):
+        tcp.BaseHandler.convert_to_ssl(self, *args, **kwargs)
+        self.timestamp_ssl_setup = utils.timestamp()
+
+    def finish(self):
+        tcp.BaseHandler.finish(self)
+        self.timestamp_end = utils.timestamp()
+
+
+class ServerConnection(tcp.TCPClient, stateobject.SimpleStateObject):
+    def __init__(self, address, priority):
+        tcp.TCPClient.__init__(self, address)
+        self.priority = priority
+
+        self.peername = None
+        self.timestamp_start = None
+        self.timestamp_end = None
+        self.timestamp_tcp_setup = None
+        self.timestamp_ssl_setup = None
+
+    _stateobject_attributes = dict(
+        peername=tuple,
+        timestamp_start=float,
+        timestamp_end=float,
+        timestamp_tcp_setup=float,
+        timestamp_ssl_setup=float,
+        address=tcp.Address,
+        source_address=tcp.Address,
+        cert=certutils.SSLCert,
+        ssl_established=bool,
+        sni=str
+    )
+
+    def _get_state(self):
+        d = super(ServerConnection, self)._get_state()
+        d.update(
+            address={"address": self.address(), "use_ipv6": self.address.use_ipv6},
+            source_address= {"address": self.source_address(),
+                             "use_ipv6": self.source_address.use_ipv6} if self.source_address else None,
+            cert=self.cert.to_pem() if self.cert else None
+        )
+        return d
+
+    def _load_state(self, state):
+        super(ServerConnection, self)._load_state(state)
+
+        self.address = tcp.Address(**state["address"]) if state["address"] else None
+        self.source_address = tcp.Address(**state["source_address"]) if state["source_address"] else None
+        self.cert = certutils.SSLCert.from_pem(state["cert"]) if state["cert"] else None
+
+    @classmethod
+    def _from_state(cls, state):
+        f = cls(tuple(), None)
+        f._load_state(state)
+        return f
+
+    def copy(self):
+        return copy.copy(self)
+
+    def connect(self):
+        self.timestamp_start = utils.timestamp()
+        tcp.TCPClient.connect(self)
+        self.peername = self.connection.getpeername()
+        self.timestamp_tcp_setup = utils.timestamp()
+
+    def send(self, message):
+        self.wfile.write(message)
+        self.wfile.flush()
+
+    def establish_ssl(self, clientcerts, sni):
+        clientcert = None
+        if clientcerts:
+            path = os.path.join(clientcerts, self.address.host.encode("idna")) + ".pem"
+            if os.path.exists(path):
+                clientcert = path
+        try:
+            self.convert_to_ssl(cert=clientcert, sni=sni)
+            self.timestamp_ssl_setup = utils.timestamp()
+        except tcp.NetLibError, v:
+            raise ProxyError(400, str(v))
+
+    def finish(self):
+        tcp.TCPClient.finish(self)
+        self.timestamp_end = utils.timestamp()
\ No newline at end of file
diff --git a/libmproxy/prxy/exception.py b/libmproxy/prxy/exception.py
new file mode 100644
index 00000000..c43a5d75
--- /dev/null
+++ b/libmproxy/prxy/exception.py
@@ -0,0 +1,14 @@
+class ProxyError(Exception):
+    def __init__(self, code, msg, headers=None):
+        self.code, self.msg, self.headers = code, msg, headers
+
+    def __str__(self):
+        return "ProxyError(%s, %s)" % (self.code, self.msg)
+
+
+class ConnectionTypeChange(Exception):
+    """
+    Gets raised if the connection type has been changed (e.g. after HTTP/1.1 101 Switching Protocols).
+    It's up to the raising ProtocolHandler to specify the new conntype before raising the exception.
+    """
+    pass
\ No newline at end of file
diff --git a/libmproxy/prxy/server.py b/libmproxy/prxy/server.py
new file mode 100644
index 00000000..441b29b4
--- /dev/null
+++ b/libmproxy/prxy/server.py
@@ -0,0 +1,18 @@
+__author__ = 'user'
+
+
+class AddressPriority(object):
+    """
+    Enum that signifies the priority of the given address when choosing the destination host.
+    Higher is better (None < i)
+    """
+    FORCE = 5
+    """forward mode"""
+    MANUALLY_CHANGED = 4
+    """user changed the target address in the ui"""
+    FROM_SETTINGS = 3
+    """reverse proxy mode"""
+    FROM_CONNECTION = 2
+    """derived from transparent resolver"""
+    FROM_PROTOCOL = 1
+    """derived from protocol (e.g. absolute-form http requests)"""
\ No newline at end of file