pyproxytools 0.4.1__tar.gz → 0.4.2__tar.gz

{pyproxytools-0.4.1/pyproxytools.egg-info → pyproxytools-0.4.2}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: pyproxytools
-Version: 0.4.1
+Version: 0.4.2
 Summary: Lightweight and fast python web proxy
 Author: 6C656C65
 License-Expression: MIT

{pyproxytools-0.4.1 → pyproxytools-0.4.2}/pyproxy/__init__.py

@@ -5,7 +5,7 @@ that holds the current version number of the application.
 
 import os
 
-__version__ = "0.4.1"
+__version__ = "0.4.2"
 
 if os.path.isdir("pyproxy/monitoring"):
     __slim__ = False

{pyproxytools-0.4.1 → pyproxytools-0.4.2}/pyproxy/handlers/client.py

@@ -39,9 +39,7 @@ class ProxyHandlers:
         shortcuts,
         custom_header,
         active_connections,
-        proxy_enable,
-        proxy_host,
-        proxy_port,
+        proxy_config,
     ):
         self.html_403 = html_403
         self.logger_config = logger_config
@@ -58,11 +56,32 @@ class ProxyHandlers:
         self.console_logger = console_logger
         self.config_shortcuts = shortcuts
         self.config_custom_header = custom_header
-        self.proxy_enable = proxy_enable
-        self.proxy_host = proxy_host
-        self.proxy_port = proxy_port
+        self.proxy_config = proxy_config
         self.active_connections = active_connections
 
+    def _create_handler(self, handler_class, **extra_kwargs):
+        """
+        Factory to create handler instance with shared common parameters.
+        """
+        params = dict(
+            html_403=self.html_403,
+            logger_config=self.logger_config,
+            filter_config=self.filter_config,
+            filter_queue=self.filter_queue,
+            filter_result_queue=self.filter_result_queue,
+            shortcuts_queue=self.shortcuts_queue,
+            shortcuts_result_queue=self.shortcuts_result_queue,
+            custom_header_queue=self.custom_header_queue,
+            custom_header_result_queue=self.custom_header_result_queue,
+            console_logger=self.console_logger,
+            shortcuts=self.config_shortcuts,
+            custom_header=self.config_custom_header,
+            proxy_config=self.proxy_config,
+            active_connections=self.active_connections,
+        )
+        params.update(extra_kwargs)
+        return handler_class(**params)
+
     def handle_client(self, client_socket):
         """
         Handles an incoming client connection by processing the request and forwarding
@@ -82,45 +101,13 @@ class ProxyHandlers:
         first_line = request.decode(errors="ignore").split("\n")[0]
 
         if first_line.startswith("CONNECT"):
-            client_https_handler = HttpsHandler(
-                html_403=self.html_403,
-                logger_config=self.logger_config,
-                filter_config=self.filter_config,
+            https_handler = self._create_handler(
+                HttpsHandler,
                 ssl_config=self.ssl_config,
-                filter_queue=self.filter_queue,
-                filter_result_queue=self.filter_result_queue,
-                shortcuts_queue=self.shortcuts_queue,
-                shortcuts_result_queue=self.shortcuts_result_queue,
                 cancel_inspect_queue=self.cancel_inspect_queue,
                 cancel_inspect_result_queue=self.cancel_inspect_result_queue,
-                custom_header_queue=self.custom_header_queue,
-                custom_header_result_queue=self.custom_header_result_queue,
-                console_logger=self.console_logger,
-                shortcuts=self.config_shortcuts,
-                custom_header=self.config_custom_header,
-                proxy_enable=self.proxy_enable,
-                proxy_host=self.proxy_host,
-                proxy_port=self.proxy_port,
-                active_connections=self.active_connections,
             )
-            client_https_handler.handle_https_connection(client_socket, first_line)
+            https_handler.handle_https_connection(client_socket, first_line)
         else:
-            client_http_handler = HttpHandler(
-                html_403=self.html_403,
-                logger_config=self.logger_config,
-                filter_config=self.filter_config,
-                filter_queue=self.filter_queue,
-                filter_result_queue=self.filter_result_queue,
-                shortcuts_queue=self.shortcuts_queue,
-                shortcuts_result_queue=self.shortcuts_result_queue,
-                custom_header_queue=self.custom_header_queue,
-                custom_header_result_queue=self.custom_header_result_queue,
-                console_logger=self.console_logger,
-                shortcuts=self.config_shortcuts,
-                custom_header=self.config_custom_header,
-                proxy_enable=self.proxy_enable,
-                proxy_host=self.proxy_host,
-                proxy_port=self.proxy_port,
-                active_connections=self.active_connections,
-            )
-            client_http_handler.handle_http_request(client_socket, request)
+            http_handler = self._create_handler(HttpHandler)
+            http_handler.handle_http_request(client_socket, request)

{pyproxytools-0.4.1 → pyproxytools-0.4.2}/pyproxy/handlers/http.py

@@ -8,8 +8,9 @@ HTTP client connections. It handles request forwarding, blocking, and custom hea
 import socket
 import os
 import threading
+from urllib.parse import urlparse
 
-from pyproxy.utils.http_req import extract_headers, parse_url
+from pyproxy.utils.http_req import extract_headers
 
 
 class HttpHandler:
@@ -34,9 +35,7 @@ class HttpHandler:
         shortcuts,
         custom_header,
         active_connections,
-        proxy_enable,
-        proxy_host,
-        proxy_port,
+        proxy_config,
     ):
         self.html_403 = html_403
         self.logger_config = logger_config
@@ -50,11 +49,81 @@ class HttpHandler:
         self.console_logger = console_logger
         self.config_shortcuts = shortcuts
         self.config_custom_header = custom_header
-        self.proxy_enable = proxy_enable
-        self.proxy_host = proxy_host
-        self.proxy_port = proxy_port
+        self.proxy_config = proxy_config
         self.active_connections = active_connections
 
+    def _get_modified_headers(self, url, request_text):
+        """
+        Extract headers from a request
+        """
+        headers = extract_headers(request_text)
+        self.custom_header_queue.put(url)
+        try:
+            new_headers = self.custom_header_result_queue.get(timeout=5)
+            headers.update(new_headers)
+        except Exception:
+            self.console_logger.warning(
+                "Timeout while getting custom headers for %s", url
+            )
+        return headers
+
+    def _rebuild_http_request(self, request_line, headers, body=""):
+        """
+        Reconstructs an HTTP request with the new headers.
+        """
+        header_lines = [f"{key}: {value}" for key, value in headers.items()]
+        reconstructed_headers = "\r\n".join(header_lines)
+        return f"{request_line}\r\n{reconstructed_headers}\r\n\r\n{body}".encode()
+
+    def _apply_shortcut(self, url: str) -> str | None:
+        """
+        Checks if a shortcut is defined for the given domain.
+        """
+        if self.config_shortcuts and os.path.isfile(self.config_shortcuts):
+            parsed_url = urlparse(url)
+            domain = parsed_url.hostname
+            self.shortcuts_queue.put(domain)
+            try:
+                return self.shortcuts_result_queue.get(timeout=5)
+            except Exception:
+                self.console_logger.warning(
+                    "Timeout while getting shortcut for %s", url
+                )
+        return None
+
+    def _is_blocked(self, url: str) -> bool:
+        """
+        Checks if a URL is blocked by the configuration filter.
+        """
+        if not self.filter_config.no_filter:
+            self.filter_queue.put(url)
+            try:
+                result = self.filter_result_queue.get(timeout=5)
+                return result[1] == "Blocked"
+            except Exception:
+                self.console_logger.warning("Timeout while filtering %s", url)
+        return False
+
+    def _send_403(self, client_socket, url, first_line):
+        """
+        Sends an HTTP 403 Forbidden response to the client.
+        """
+        if not self.logger_config.no_logging_block:
+            self.logger_config.block_logger.info(
+                "%s - %s - %s", client_socket.getpeername()[0], url, first_line
+            )
+        with open(self.html_403, "r", encoding="utf-8") as f:
+            custom_403_page = f.read()
+        response = (
+            f"HTTP/1.1 403 Forbidden\r\n"
+            f"Content-Length: {len(custom_403_page)}\r\n"
+            f"\r\n"
+            f"{custom_403_page}"
+        )
+        client_socket.sendall(response.encode())
+        client_socket.close()
+        self.active_connections.pop(threading.get_ident(), None)
+
     def handle_http_request(self, client_socket, request):
         """
         Processes an HTTP request, checks for URL filtering, applies shortcuts,
@@ -67,16 +136,8 @@ class HttpHandler:
         first_line = request.decode(errors="ignore").split("\n")[0]
         url = first_line.split(" ")[1]
 
-        if self.config_custom_header and os.path.isfile(self.config_custom_header):
-            headers = extract_headers(request.decode(errors="ignore"))
-            self.custom_header_queue.put(url)
-            new_headers = self.custom_header_result_queue.get(timeout=5)
-            headers.update(new_headers)
-
         if self.config_shortcuts and os.path.isfile(self.config_shortcuts):
-            domain, _ = parse_url(url)
-            self.shortcuts_queue.put(domain)
-            shortcut_url = self.shortcuts_result_queue.get(timeout=5)
+            shortcut_url = self._apply_shortcut(url)
             if shortcut_url:
                 response = (
                     f"HTTP/1.1 302 Found\r\n"
@@ -90,27 +151,12 @@ class HttpHandler:
                 self.active_connections.pop(threading.get_ident(), None)
                 return
 
-        if not self.filter_config.no_filter:
-            self.filter_queue.put(url)
-            result = self.filter_result_queue.get(timeout=5)
-            if result[1] == "Blocked":
-                if not self.logger_config.no_logging_block:
-                    self.logger_config.block_logger.info(
-                        "%s - %s - %s", client_socket.getpeername()[0], url, first_line
-                    )
-                with open(self.html_403, "r", encoding="utf-8") as f:
-                    custom_403_page = f.read()
-                response = (
-                    f"HTTP/1.1 403 Forbidden\r\n"
-                    f"Content-Length: {len(custom_403_page)}\r\n"
-                    f"\r\n"
-                    f"{custom_403_page}"
-                )
-                client_socket.sendall(response.encode())
-                client_socket.close()
-                self.active_connections.pop(threading.get_ident(), None)
-                return
-        server_host, _ = parse_url(url)
+        if self._is_blocked(url):
+            self._send_403(client_socket, url, first_line)
+            return
+
+        parsed_url = urlparse(url)
+        server_host = parsed_url.hostname
         if not self.logger_config.no_logging_access:
             self.logger_config.access_logger.info(
                 "%s - %s - %s",
@@ -120,20 +166,16 @@ class HttpHandler:
             )
 
         if self.config_custom_header and os.path.isfile(self.config_custom_header):
-            request_lines = request.decode(errors="ignore").split("\r\n")
-            request_line = request_lines[0]  # GET / HTTP/1.1
-
-            header_lines = [f"{key}: {value}" for key, value in headers.items()]
-            reconstructed_headers = "\r\n".join(header_lines)
-
-            if "\r\n\r\n" in request.decode(errors="ignore"):
-                body = request.decode(errors="ignore").split("\r\n\r\n", 1)[1]
-            else:
-                body = ""
-
-            modified_request = (
-                f"{request_line}\r\n{reconstructed_headers}\r\n\r\n{body}".encode()
+            request_text = request.decode(errors="ignore")
+            request_lines = request_text.split("\r\n")
+            headers = self._get_modified_headers(url, request_text)
+            request_line = request_lines[0]
+            body = (
+                request_text.split("\r\n\r\n", 1)[1]
+                if "\r\n\r\n" in request_text
+                else ""
             )
+            modified_request = self._rebuild_http_request(request_line, headers, body)
 
             self.forward_request_to_server(client_socket, modified_request, url)
 
@@ -149,10 +191,14 @@ class HttpHandler:
             request (bytes): The raw HTTP request sent by the client.
             url (str): The target URL from the HTTP request.
         """
-        if self.proxy_enable:
-            server_host, server_port = self.proxy_host, self.proxy_port
+        if self.proxy_config.enable:
+            server_host, server_port = self.proxy_config.host, self.proxy_config.port
         else:
-            server_host, server_port = parse_url(url)
+            parsed_url = urlparse(url)
+            server_host = parsed_url.hostname
+            server_port = parsed_url.port or (
+                443 if parsed_url.scheme == "https" else 80
+            )
         thread_id = threading.get_ident()
 
         if thread_id in self.active_connections:

{pyproxytools-0.4.1 → pyproxytools-0.4.2}/pyproxy/handlers/https.py

@@ -42,9 +42,7 @@ class HttpsHandler:
         shortcuts,
         custom_header,
         active_connections,
-        proxy_enable,
-        proxy_host,
-        proxy_port,
+        proxy_config,
     ):
         self.html_403 = html_403
         self.logger_config = logger_config
@@ -61,11 +59,149 @@ class HttpsHandler:
         self.console_logger = console_logger
         self.config_shortcuts = shortcuts
         self.config_custom_header = custom_header
-        self.proxy_enable = proxy_enable
-        self.proxy_host = proxy_host
-        self.proxy_port = proxy_port
+        self.proxy_config = proxy_config
         self.active_connections = active_connections
 
+    def _is_blocked(self, url: str) -> bool:
+        """
+        Checks if a URL is blocked by the configuration filter.
+        """
+        if not self.filter_config.no_filter:
+            self.filter_queue.put(url)
+            try:
+                result = self.filter_result_queue.get(timeout=5)
+                return result[1] == "Blocked"
+            except Exception:
+                self.console_logger.warning("Timeout while filtering %s", url)
+        return False
+
+    def _send_403(self, client_socket, url, first_line):
+        """
+        Sends an HTTP 403 Forbidden response to the client.
+        """
+        if not self.logger_config.no_logging_block:
+            self.logger_config.block_logger.info(
+                "%s - %s - %s", client_socket.getpeername()[0], url, first_line
+            )
+        with open(self.html_403, "r", encoding="utf-8") as f:
+            custom_403_page = f.read()
+        response = (
+            f"HTTP/1.1 403 Forbidden\r\n"
+            f"Content-Length: {len(custom_403_page)}\r\n"
+            f"\r\n"
+            f"{custom_403_page}"
+        )
+        client_socket.sendall(response.encode())
+        client_socket.close()
+        self.active_connections.pop(threading.get_ident(), None)
+
+    def _should_skip_inspection(self, server_host: str) -> bool:
+        """
+        Determine if SSL inspection should be skipped for the given host.
+        """
+        if (
+            self.ssl_config.ssl_inspect
+            and self.ssl_config.cancel_inspect
+            and os.path.isfile(self.ssl_config.cancel_inspect)
+        ):
+            self.cancel_inspect_queue.put(server_host)
+            return self.cancel_inspect_result_queue.get(timeout=5)
+        return False
+
+    def _establish_server_connection(self, server_host, server_port):
+        """
+        Create and return a socket connected to the target server.
+        """
+        if self.proxy_config.enable:
+            next_proxy_socket = socket.create_connection(
+                (self.proxy_config.host, self.proxy_config.port)
+            )
+            connect_command = (
+                f"CONNECT {server_host}:{server_port} HTTP/1.1\r\n"
+                f"Host: {server_host}:{server_port}\r\n\r\n"
+            )
+            next_proxy_socket.sendall(connect_command.encode())
+
+            response = b""
+            while b"\r\n\r\n" not in response:
+                chunk = next_proxy_socket.recv(4096)
+                if not chunk:
+                    raise ConnectionError("Connection to next proxy failed")
+                response += chunk
+
+            if b"200 Connection Established" not in response:
+                raise ConnectionRefusedError("Next proxy refused CONNECT")
+
+            return next_proxy_socket
+        else:
+            return socket.create_connection((server_host, server_port))
+
+    def _wrap_client_socket_with_ssl(self, client_socket, cert_path, key_path):
+        """
+        Wrap the client socket with an SSL context for interception.
+        """
+        client_context = ssl.SSLContext(ssl.PROTOCOL_TLS_SERVER)
+        client_context.load_cert_chain(certfile=cert_path, keyfile=key_path)
+        client_context.options |= (
+            ssl.OP_NO_SSLv2 | ssl.OP_NO_SSLv3 | ssl.OP_NO_TLSv1 | ssl.OP_NO_TLSv1_1
+        )
+        client_context.load_verify_locations(self.ssl_config.inspect_ca_cert)
+
+        ssl_client_socket = client_context.wrap_socket(
+            client_socket, server_side=True, do_handshake_on_connect=False
+        )
+        ssl_client_socket.do_handshake()
+        return ssl_client_socket
+
+    def _wrap_server_socket_with_ssl(self, server_socket, server_host):
+        """
+        Wrap the server socket with an SSL context to enable encrypted communication.
+        """
+        server_context = ssl.SSLContext(ssl.PROTOCOL_TLS_CLIENT)
+        if self.proxy_config.enable:
+            server_context.check_hostname = False
+            server_context.verify_mode = ssl.CERT_NONE
+        else:
+            server_context.load_default_certs()
+
+        ssl_server_socket = server_context.wrap_socket(
+            server_socket,
+            server_hostname=server_host,
+            do_handshake_on_connect=True,
+        )
+        return ssl_server_socket
+
+    def _process_first_ssl_request(self, ssl_client_socket, server_host):
+        """
+        Reads and processes the first SSL client request, extracts the method and full URL.
+        """
+        try:
+            first_request = ssl_client_socket.recv(4096).decode(errors="ignore")
+            if not first_request:
+                raise ConnectionError("Empty request received")
+
+            request_line = first_request.split("\r\n")[0]
+            method, path, _ = request_line.split(" ")
+
+            full_url = f"https://{server_host}{path}"
+
+            if self._is_blocked(f"{server_host}{path}"):
+                return None, full_url, True
+
+            if not self.logger_config.no_logging_access:
+                self.logger_config.access_logger.info(
+                    "%s - %s - %s %s",
+                    ssl_client_socket.getpeername()[0],
+                    f"https://{server_host}",
+                    method,
+                    full_url,
+                )
+
+            return first_request, full_url, False
+        except Exception as e:
+            self.logger_config.error_logger.error(f"SSL request processing error : {e}")
+            return None, None, False
+
     def handle_https_connection(self, client_socket, first_line):
         """
         Handles HTTPS connections by establishing a connection with the target server
@@ -79,146 +215,45 @@ class HttpsHandler:
         server_host, server_port = target.split(":")
         server_port = int(server_port)
 
-        if not self.filter_config.no_filter:
-            self.filter_queue.put(target)
-            result = self.filter_result_queue.get(timeout=5)
-            if result[1] == "Blocked":
-                if not self.logger_config.no_logging_block:
-                    self.logger_config.block_logger.info(
-                        "%s - %s - %s",
-                        client_socket.getpeername()[0],
-                        target,
-                        first_line,
-                    )
-                with open(self.html_403, "r", encoding="utf-8") as f:
-                    custom_403_page = f.read()
-                response = (
-                    f"HTTP/1.1 403 Forbidden\r\n"
-                    f"Content-Length: {len(custom_403_page)}\r\n"
-                    f"\r\n"
-                    f"{custom_403_page}"
-                )
-                client_socket.sendall(response.encode())
-                client_socket.close()
-                self.active_connections.pop(threading.get_ident(), None)
-                return
+        if self._is_blocked(target):
+            self._send_403(client_socket, target, first_line)
+            return
 
-        not_inspect = False
-        if (
-            self.ssl_config.ssl_inspect
-            and self.ssl_config.cancel_inspect
-            and os.path.isfile(self.ssl_config.cancel_inspect)
-        ):
-            self.cancel_inspect_queue.put(server_host)
-            not_inspect = self.cancel_inspect_result_queue.get(timeout=5)
+        not_inspect = self._should_skip_inspection(server_host)
 
         if self.ssl_config.ssl_inspect and not not_inspect:
-            cert_path, key_path = generate_certificate(
-                server_host,
-                self.ssl_config.inspect_certs_folder,
-                self.ssl_config.inspect_ca_cert,
-                self.ssl_config.inspect_ca_key,
-            )
-            client_context = ssl.SSLContext(ssl.PROTOCOL_TLS_SERVER)
-            client_context.load_cert_chain(certfile=cert_path, keyfile=key_path)
-            client_context.options |= (
-                ssl.OP_NO_SSLv2 | ssl.OP_NO_SSLv3 | ssl.OP_NO_TLSv1 | ssl.OP_NO_TLSv1_1
-            )
-            client_context.load_verify_locations(self.ssl_config.inspect_ca_cert)
-
             try:
-                client_socket.sendall(b"HTTP/1.1 200 Connection Established\r\n\r\n")
-                ssl_client_socket = client_context.wrap_socket(
-                    client_socket, server_side=True, do_handshake_on_connect=False
-                )
-                ssl_client_socket.do_handshake()
-
-                if self.proxy_enable:
-                    next_proxy_socket = socket.create_connection(
-                        (self.proxy_host, self.proxy_port)
-                    )
-                    connect_command = (
-                        f"CONNECT {server_host}:{server_port} HTTP/1.1\r\n"
-                        f"Host: {server_host}:{server_port}\r\n\r\n"
-                    )
-                    next_proxy_socket.sendall(connect_command.encode())
-
-                    response = b""
-                    while b"\r\n\r\n" not in response:
-                        chunk = next_proxy_socket.recv(4096)
-                        if not chunk:
-                            raise ConnectionError("Connection to next proxy failed")
-                        response += chunk
-
-                    if b"200 Connection Established" not in response:
-                        raise ConnectionRefusedError("Next proxy refused CONNECT")
-
-                    server_socket = next_proxy_socket
-                else:
-                    server_socket = socket.create_connection((server_host, server_port))
-
-                server_context = ssl.SSLContext(ssl.PROTOCOL_TLS_CLIENT)
-                if self.proxy_enable:
-                    server_context.check_hostname = False
-                    server_context.verify_mode = ssl.CERT_NONE
-                else:
-                    server_context.load_default_certs()
-
-                ssl_server_socket = server_context.wrap_socket(
-                    server_socket,
-                    server_hostname=server_host,
-                    do_handshake_on_connect=True,
+                cert_path, key_path = generate_certificate(
+                    server_host,
+                    self.ssl_config.inspect_certs_folder,
+                    self.ssl_config.inspect_ca_cert,
+                    self.ssl_config.inspect_ca_key,
                 )
 
-                try:
-                    first_request = ssl_client_socket.recv(4096).decode(errors="ignore")
-                    request_line = first_request.split("\r\n")[0]
-                    method, path, _ = request_line.split(" ")
-
-                    full_url = f"https://{server_host}{path}"
-
-                    if not self.filter_config.no_filter:
-                        self.filter_queue.put(f"{server_host}{path}")
-                        result = self.filter_result_queue.get(timeout=5)
-                        if result[1] == "Blocked":
-                            if not self.logger_config.no_logging_block:
-                                self.logger_config.block_logger.info(
-                                    "%s - %s - %s",
-                                    ssl_client_socket.getpeername()[0],
-                                    target,
-                                    first_line,
-                                )
-                            with open(self.html_403, "r", encoding="utf-8") as f:
-                                custom_403_page = f.read()
-                            response = (
-                                f"HTTP/1.1 403 Forbidden\r\n"
-                                f"Content-Length: {len(custom_403_page)}\r\n"
-                                f"\r\n"
-                                f"{custom_403_page}"
-                            )
-                            ssl_client_socket.sendall(response.encode())
-                            ssl_client_socket.close()
-                            self.active_connections.pop(threading.get_ident(), None)
-                            return
-
-                    if not self.logger_config.no_logging_access:
-                        self.logger_config.access_logger.info(
-                            "%s - %s - %s %s",
-                            ssl_client_socket.getpeername()[0],
-                            f"https://{server_host}",
-                            method,
-                            full_url,
-                        )
+                client_socket.sendall(b"HTTP/1.1 200 Connection Established\r\n\r\n")
 
-                    ssl_server_socket.sendall(first_request.encode())
+                ssl_client_socket = self._wrap_client_socket_with_ssl(
+                    client_socket, cert_path, key_path
+                )
 
-                except ValueError:
-                    self.console_logger.error(
-                        "Error parsing request: malformed request line."
-                    )
+                server_socket = self._establish_server_connection(
+                    server_host, server_port
+                )
+                ssl_server_socket = self._wrap_server_socket_with_ssl(
+                    server_socket, server_host
+                )
 
-                except (socket.error, ssl.SSLError) as e:
-                    self.console_logger.error("Network or SSL error : %s", str(e))
+                first_request, full_url, is_blocked = self._process_first_ssl_request(
+                    ssl_client_socket, server_host
+                )
+                if is_blocked:
+                    self._send_403(ssl_client_socket, target, first_line)
+                    return
+                if first_request is None:
+                    ssl_client_socket.close()
+                    return
+
+                ssl_server_socket.sendall(first_request.encode())
 
                 self.transfer_data_between_sockets(ssl_client_socket, ssl_server_socket)