proxynt 2.0.3__tar.gz → 2.0.8__tar.gz

{proxynt-2.0.3/proxynt.egg-info → proxynt-2.0.8}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: proxynt
-Version: 2.0.3
+Version: 2.0.8
 Summary: UNKNOWN
 Home-page: https://github.com/sazima/proxynt
 License: UNKNOWN

proxynt-2.0.8/client/p2p_hole_punch.py

@@ -0,0 +1,257 @@
+"""
+UDP Hole Punching Module for P2P Connection
+"""
+import os
+import socket
+import threading
+import time
+import traceback
+from typing import Dict, Optional, Callable
+
+from common.logger_factory import LoggerFactory
+from constant.system_constant import SystemConstant
+
+
+class P2PConnection:
+    """Represents a P2P connection"""
+    def __init__(self, uid: bytes, local_socket: socket.socket, remote_addr: tuple):
+        self.uid = uid
+        self.local_socket = local_socket
+        self.remote_addr = remote_addr  # (ip, port)
+        self.established = False
+        self.last_receive_time = 0
+        self.last_send_time = 0
+
+
+class P2PHolePunch:
+    """UDP Hole Punching Manager"""
+
+    def __init__(self):
+        self.connections: Dict[bytes, P2PConnection] = {}
+        self.lock = threading.Lock()
+        self.running = False
+        self.receive_thread: Optional[threading.Thread] = None
+
+        # Callbacks
+        self.on_connection_established: Optional[Callable[[bytes], None]] = None
+        self.on_connection_failed: Optional[Callable[[bytes], None]] = None
+        self.on_data_received: Optional[Callable[[bytes, bytes], None]] = None
+
+    def start(self):
+        """Start the hole punching service"""
+        if self.running:
+            return
+
+        self.running = True
+        self.receive_thread = threading.Thread(target=self._receive_loop, daemon=True)
+        self.receive_thread.start()
+        LoggerFactory.get_logger().info('P2P hole punching service started')
+
+    def stop(self):
+        """Stop the hole punching service"""
+        self.running = False
+        with self.lock:
+            for uid, conn in list(self.connections.items()):
+                try:
+                    conn.local_socket.close()
+                except Exception:
+                    pass
+            self.connections.clear()
+        LoggerFactory.get_logger().info('P2P hole punching service stopped')
+
+    def initiate_connection(self, uid: bytes, remote_ip: str, remote_port: int, local_port: int = 0) -> bool:
+        """
+        Initiate a P2P connection
+
+        :param uid: Unique connection ID
+        :param remote_ip: Remote peer's public IP
+        :param remote_port: Remote peer's public port
+        :param local_port: Local port to bind (0 for random)
+        :return: True if initiated successfully
+        """
+        try:
+            # Create UDP socket
+            udp_socket = socket.socket(socket.AF_INET, socket.SOCK_DGRAM)
+            udp_socket.setsockopt(socket.SOL_SOCKET, socket.SO_REUSEADDR, 1)
+
+            # Bind to local port
+            if local_port > 0:
+                udp_socket.bind(('0.0.0.0', local_port))
+            else:
+                udp_socket.bind(('0.0.0.0', 0))  # Let OS assign port
+
+            local_addr = udp_socket.getsockname()
+            LoggerFactory.get_logger().info(f'P2P connection initiated: UID {uid.hex()}, local port: {local_addr[1]}, remote: {remote_ip}:{remote_port}')
+
+            # Create connection object
+            remote_addr = (remote_ip, remote_port)
+            connection = P2PConnection(uid, udp_socket, remote_addr)
+
+            with self.lock:
+                self.connections[uid] = connection
+
+            # Start hole punching process
+            self._start_hole_punching(connection)
+            return True
+
+        except Exception as e:
+            LoggerFactory.get_logger().error(f'Failed to initiate P2P connection: {e}')
+            LoggerFactory.get_logger().error(traceback.format_exc())
+            return False
+
+    def _start_hole_punching(self, connection: P2PConnection):
+        """
+        Start the hole punching process
+        Send periodic punch packets to remote peer
+        """
+        def punch_loop():
+            uid = connection.uid
+            sock = connection.local_socket
+            remote_addr = connection.remote_addr
+            retry_count = 0
+            max_retries = SystemConstant.P2P_MAX_RETRY
+
+            # Punch packet format: "PUNCH:" + UID (to distinguish from data packets)
+            punch_packet = b'PUNCH:' + uid
+
+            while self.running and not connection.established and retry_count < max_retries:
+                try:
+                    # Send punch packet
+                    sock.sendto(punch_packet, remote_addr)
+                    connection.last_send_time = time.time()
+                    LoggerFactory.get_logger().debug(f'Sent punch packet to {remote_addr}, attempt {retry_count + 1}/{max_retries}')
+
+                    # Wait for response
+                    time.sleep(1)
+                    retry_count += 1
+
+                    # Check if connection established (by receive loop)
+                    if connection.established:
+                        LoggerFactory.get_logger().info(f'P2P connection established: UID {uid.hex()}, remote: {remote_addr}')
+                        if self.on_connection_established:
+                            self.on_connection_established(uid)
+                        return
+
+                except Exception as e:
+                    LoggerFactory.get_logger().error(f'Error during hole punching: {e}')
+                    break
+
+            # Timeout or failed
+            if not connection.established:
+                LoggerFactory.get_logger().warning(f'P2P hole punching failed: UID {uid.hex()}, remote: {remote_addr}')
+                self.close_connection(uid)
+                if self.on_connection_failed:
+                    self.on_connection_failed(uid)
+
+        # Start punch thread
+        punch_thread = threading.Thread(target=punch_loop, daemon=True)
+        punch_thread.start()
+
+    def _receive_loop(self):
+        """Receive loop for all P2P connections"""
+        while self.running:
+            try:
+                # Check all connections for incoming data
+                with self.lock:
+                    connections = list(self.connections.values())
+
+                for conn in connections:
+                    try:
+                        conn.local_socket.settimeout(0.1)  # Non-blocking with short timeout
+                        data, addr = conn.local_socket.recvfrom(65536)
+
+                        if not data:
+                            continue
+
+                        # Check if this is a punch packet
+                        if data.startswith(b'PUNCH:'):
+                            punch_uid = data[6:10]  # Extract UID from punch packet
+                            if punch_uid == conn.uid:
+                                # Received punch packet from remote peer
+                                LoggerFactory.get_logger().info(f'Received punch packet from {addr} for UID {conn.uid.hex()}')
+
+                                # Send punch reply
+                                reply_packet = b'PUNCH_ACK:' + conn.uid
+                                conn.local_socket.sendto(reply_packet, addr)
+
+                                # Update remote address (might have changed due to NAT)
+                                conn.remote_addr = addr
+                                conn.established = True
+                                conn.last_receive_time = time.time()
+
+                        elif data.startswith(b'PUNCH_ACK:'):
+                            # Received punch acknowledgment
+                            LoggerFactory.get_logger().info(f'Received punch ACK from {addr} for UID {conn.uid.hex()}')
+                            conn.remote_addr = addr
+                            conn.established = True
+                            conn.last_receive_time = time.time()
+
+                        else:
+                            # Regular data packet
+                            if conn.established:
+                                conn.last_receive_time = time.time()
+                                if self.on_data_received:
+                                    self.on_data_received(conn.uid, data)
+                            else:
+                                LoggerFactory.get_logger().warning(f'Received data on unestablished connection: UID {conn.uid.hex()}')
+
+                    except socket.timeout:
+                        continue
+                    except OSError:
+                        # Socket might be closed
+                        continue
+                    except Exception as e:
+                        LoggerFactory.get_logger().error(f'Error in receive loop: {e}')
+
+                # Small sleep to prevent CPU spinning
+                time.sleep(0.01)
+
+            except Exception as e:
+                LoggerFactory.get_logger().error(f'Fatal error in P2P receive loop: {e}')
+                LoggerFactory.get_logger().error(traceback.format_exc())
+                time.sleep(1)
+
+    def send_data(self, uid: bytes, data: bytes) -> bool:
+        """
+        Send data over P2P connection
+
+        :param uid: Connection UID
+        :param data: Data to send
+        :return: True if sent successfully
+        """
+        with self.lock:
+            connection = self.connections.get(uid)
+
+        if not connection:
+            LoggerFactory.get_logger().warning(f'P2P connection not found: UID {uid.hex()}')
+            return False
+
+        if not connection.established:
+            LoggerFactory.get_logger().warning(f'P2P connection not established: UID {uid.hex()}')
+            return False
+
+        try:
+            connection.local_socket.sendto(data, connection.remote_addr)
+            connection.last_send_time = time.time()
+            return True
+        except Exception as e:
+            LoggerFactory.get_logger().error(f'Failed to send P2P data: {e}')
+            return False
+
+    def is_established(self, uid: bytes) -> bool:
+        """Check if P2P connection is established"""
+        with self.lock:
+            connection = self.connections.get(uid)
+        return connection is not None and connection.established
+
+    def close_connection(self, uid: bytes):
+        """Close a P2P connection"""
+        with self.lock:
+            connection = self.connections.pop(uid, None)
+
+        if connection:
+            try:
+                connection.local_socket.close()
+            except Exception:
+                pass
+            LoggerFactory.get_logger().info(f'P2P connection closed: UID {uid.hex()}')

{proxynt-2.0.3 → proxynt-2.0.8}/client/tcp_forward_client.py

@@ -319,6 +319,12 @@ class TcpForwardClient:
             try:
                 if LoggerFactory.get_logger().isEnabledFor(logging.DEBUG):
                     LoggerFactory.get_logger().debug(f'create socket {name}, {uid}')
+
+                # Validate ip_port before splitting
+                if not ip_port or ':' not in ip_port:
+                    LoggerFactory.get_logger().error(f'Invalid ip_port: {repr(ip_port)}, name: {name}, uid: {uid.hex()}')
+                    return False
+
                 s = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
                 s.settimeout(5)
                 # Enable TCP_NODELAY to reduce latency (disable Nagle algorithm)

{proxynt-2.0.3 → proxynt-2.0.8}/common/nat_serialization.py

@@ -85,6 +85,12 @@ class NatSerialization:
             body =  json.dumps(data).encode()
         elif type_ == MessageTypeConstant.PING:
             body =  b''
+        elif type_ in (MessageTypeConstant.P2P_OFFER, MessageTypeConstant.P2P_ANSWER,
+                      MessageTypeConstant.P2P_CANDIDATE, MessageTypeConstant.P2P_SUCCESS,
+                      MessageTypeConstant.P2P_FAILED):
+            # P2P messages: use JSON encoding of data content only
+            data_content = data.get('data', {})
+            body = json.dumps(data_content).encode()
         else:
             body =  b'error'
         body_len = len(body)
@@ -207,6 +213,16 @@ class NatSerialization:
                 'data': None
             }
             return return_data
+        elif type_.decode() in (MessageTypeConstant.P2P_OFFER, MessageTypeConstant.P2P_ANSWER,
+                                MessageTypeConstant.P2P_CANDIDATE, MessageTypeConstant.P2P_SUCCESS,
+                                MessageTypeConstant.P2P_FAILED):
+            # P2P messages: JSON decode
+            data = json.loads(body.decode())
+            return_data: MessageEntity = {
+                'type_': type_.decode(),
+                'data': data
+            }
+            return return_data
         else:
             raise Exception('error ')
 

{proxynt-2.0.3 → proxynt-2.0.8}/constant/message_type_constnat.py

@@ -17,3 +17,10 @@ class MessageTypeConstant:
 
     # 客户端到客户端转发
     CLIENT_TO_CLIENT_FORWARD = 'a'  # 客户端请求转发到另一个客户端
+
+    # P2P hole punching
+    P2P_OFFER = 'b'           # Client A requests P2P connection with client B
+    P2P_ANSWER = 'c'          # Client B responds to P2P request
+    P2P_CANDIDATE = 'd'       # Exchange NAT traversal information
+    P2P_SUCCESS = 'e'         # P2P connection established successfully
+    P2P_FAILED = 'f'          # P2P connection failed, fallback to relay

{proxynt-2.0.3 → proxynt-2.0.8}/constant/system_constant.py

@@ -15,6 +15,11 @@ class SystemConstant:
 
     COOKIE_EXPIRE_SECONDS = 3600 * 24
 
-    VERSION = '2.0.3'
+    VERSION = '2.0.8'
 
     GITHUB = 'https://github.com/sazima/proxynt'
+
+    # P2P settings
+    P2P_SUPPORTED_VERSION = '2.0.3'  # Minimum version that supports P2P
+    P2P_HOLE_PUNCH_TIMEOUT = 5       # Seconds to wait for hole punching
+    P2P_MAX_RETRY = 3                # Max retry attempts for hole punching

{proxynt-2.0.3 → proxynt-2.0.8}/entity/message/push_config_entity.py

@@ -23,11 +23,15 @@ class ClientToClientRule(TypedDict, total=False):
     local_ip: str            # Source client local listening IP
     protocol: str            # tcp or udp
     speed_limit: float       # Speed limit
+    p2p_enabled: bool        # Whether to enable P2P for this rule (default: True)
 
 
-class PushConfigEntity(TypedDict):
+class PushConfigEntity(TypedDict, total=False):
     key: str
     version: str
-    config_list: List[ClientData]  # 转发配置列表
-    client_name: str  # 客户端名称
-    client_to_client_rules: List[ClientToClientRule]  # C2C 转发规则（可选）
+    config_list: List[ClientData]  # Forward configuration list
+    client_name: str  # Client name
+    client_to_client_rules: List[ClientToClientRule]  # C2C forward rules (optional)
+    p2p_supported: bool  # Whether client supports P2P (optional)
+    public_ip: str  # Client's public IP (filled by server, optional)
+    public_port: int  # Client's public port (filled by server, optional)

{proxynt-2.0.3 → proxynt-2.0.8}/entity/server_config_entity.py

@@ -21,6 +21,7 @@ class _ClientToClientRule(TypedDict, total=False):
     protocol: str
     speed_limit: float
     enabled: bool
+    p2p_enabled: bool        # Whether to enable P2P for this rule (default: True)
 
 
 class AdminEntity(TypedDict):

{proxynt-2.0.3 → proxynt-2.0.8/proxynt.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: proxynt
-Version: 2.0.3
+Version: 2.0.8
 Summary: UNKNOWN
 Home-page: https://github.com/sazima/proxynt
 License: UNKNOWN

proxynt-2.0.8/proxynt.egg-info/SOURCES.txt

@@ -0,0 +1,84 @@
+LICENSE
+MANIFEST.in
+setup.py
+./__init__.py
+./run_client.py
+./run_server.py
+./client/__init__.py
+./client/clear_nonce_task.py
+./client/heart_beat_task.py
+./client/p2p_hole_punch.py
+./client/tcp_forward_client.py
+./client/udp_forward_client.py
+./common/__init__.py
+./common/encrypt_utils.py
+./common/logger_factory.py
+./common/nat_serialization.py
+./common/pool.py
+./common/register_append_data.py
+./common/speed_limit.py
+./common/crypto/__init__.py
+./common/crypto/table.py
+./common/websocket/__init__.py
+./common/websocket/_abnf.py
+./common/websocket/_app.py
+./common/websocket/_cookiejar.py
+./common/websocket/_core.py
+./common/websocket/_exceptions.py
+./common/websocket/_handshake.py
+./common/websocket/_http.py
+./common/websocket/_logging.py
+./common/websocket/_socket.py
+./common/websocket/_ssl_compat.py
+./common/websocket/_url.py
+./common/websocket/_utils.py
+./common/websocket/_wsdump.py
+./common/websocket/tests/__init__.py
+./common/websocket/tests/echo-server.py
+./common/websocket/tests/test_abnf.py
+./common/websocket/tests/test_app.py
+./common/websocket/tests/test_cookiejar.py
+./common/websocket/tests/test_http.py
+./common/websocket/tests/test_url.py
+./common/websocket/tests/test_websocket.py
+./constant/__init__.py
+./constant/message_type_constnat.py
+./constant/system_constant.py
+./context/__init__.py
+./context/context_utils.py
+./entity/__init__.py
+./entity/client_config_entity.py
+./entity/server_config_entity.py
+./entity/message/__init__.py
+./entity/message/message_entity.py
+./entity/message/push_config_entity.py
+./entity/message/tcp_over_websocket_message.py
+./exceptions/__init__.py
+./exceptions/duplicated_name.py
+./exceptions/invalid_password.py
+./exceptions/replay_error.py
+./exceptions/signature_error.py
+./server/__init__.py
+./server/admin_http_handler.py
+./server/tcp_forward_client.py
+./server/udp_forward_client.py
+./server/websocket_handler.py
+./server/task/__init__.py
+./server/task/check_cookie_task.py
+./server/task/clear_nonce_task.py
+./server/task/heart_beat_task.py
+./server/template/__init__.py
+./server/template/base.html
+./server/template/ele_index.html
+./server/template/login.html
+./server/template/css/index.css
+./server/template/css/fonts/element-icons.woff
+./server/template/js/axios.min.js
+./server/template/js/index.js
+./server/template/js/vue.min.js
+proxynt.egg-info/PKG-INFO
+proxynt.egg-info/SOURCES.txt
+proxynt.egg-info/dependency_links.txt
+proxynt.egg-info/entry_points.txt
+proxynt.egg-info/requires.txt
+proxynt.egg-info/top_level.txt