proxynt 2.0.26__tar.gz → 2.0.32__tar.gz

{proxynt-2.0.26 → proxynt-2.0.32}/PKG-INFO

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

{proxynt-2.0.26 → proxynt-2.0.32}/client/tcp_forward_client.py

@@ -146,9 +146,6 @@ class TcpForwardClient:
         # N4 Tunnel Manager for P2P data transfer
         self.tunnel_manager = None
 
-        # 多连接支持：DataConnectionManager（由 run_client 注入）
-        self.data_conn_manager = None
-
         # Pending data buffer: uid -> list of (data, timestamp)
         # Used to buffer P2P data that arrives before connection is established
         self.pending_data: Dict[bytes, list] = {}
@@ -303,16 +300,22 @@ class TcpForwardClient:
         except OSError:
             recv = b''
 
+        # --- 发送端限速：在发送前等待 ---
+        if data.speed_limiter and recv:
+            wait_time = data.speed_limiter.acquire(len(recv))
+            if wait_time > 0:
+                time.sleep(wait_time)
+
         # --- 无缝切换逻辑 ---
         if self.tunnel_manager:
             # 尝试走 P2P 隧道
             if self.tunnel_manager.send_data(connection.uid, recv):
                 # 如果发送成功返回 True，逻辑结束
-                if not recv:  # 本地连接关闭，通知隧道
+                if not recv: # 本地连接关闭，通知隧道
                     self.close_connection(each)
                 return
 
-        # --- 回退/初始逻辑：走 WebSocket ---
+                # --- 回退/初始逻辑：走 WebSocket ---
         send_message: MessageEntity = {
             'type_': MessageTypeConstant.WEBSOCKET_OVER_TCP,
             'data': {
@@ -323,21 +326,9 @@ class TcpForwardClient:
             }
         }
 
-        # 发送端限速：在发送前等待
-        if data.speed_limiter and recv:
-            wait_time = data.speed_limiter.acquire(len(recv))
-            if wait_time > 0:
-                time.sleep(wait_time)
-
-        # 多连接模式：优先使用数据连接
-        message_bytes = NatSerialization.dumps(send_message, ContextUtils.get_password(), self.compress_support)
-        if self.data_conn_manager and self.data_conn_manager.is_ready():
-            if not self.data_conn_manager.send_by_uid(connection.uid, message_bytes):
-                # 数据连接发送失败，回退到控制连接
-                connection.sender.enqueue_message(message_bytes)
-        else:
-            # 单连接模式：使用控制连接
-            connection.sender.enqueue_message(message_bytes)
+        connection.sender.enqueue_message(
+            NatSerialization.dumps(send_message, ContextUtils.get_password(), self.compress_support)
+        )
 
         if not recv:
             try:
@@ -496,16 +487,7 @@ class TcpForwardClient:
             }
         }
         start_time = time.time()
-        message_bytes = NatSerialization.dumps(send_message, ContextUtils.get_password(), self.compress_support)
-
-        # 多连接模式：优先使用数据连接
-        if self.data_conn_manager and self.data_conn_manager.is_ready():
-            if not self.data_conn_manager.send_by_uid(connection.uid, message_bytes):
-                # 数据连接发送失败，回退到控制连接
-                self.ws.send(message_bytes, websocket.ABNF.OPCODE_BINARY)
-        else:
-            # 单连接模式
-            self.ws.send(message_bytes, websocket.ABNF.OPCODE_BINARY)
+        self.ws.send(NatSerialization.dumps(send_message, ContextUtils.get_password(), self.compress_support), websocket.ABNF.OPCODE_BINARY)
         LoggerFactory.get_logger().debug(f'Send to websocket cost time {time.time() - start_time}')
 
     def send_by_uid(self, uid: bytes, msg: bytes):

{proxynt-2.0.26 → proxynt-2.0.32}/client/udp_forward_client.py

@@ -53,9 +53,6 @@ class UdpForwardClient:
         self.c2c_listeners: Dict[str, socket.socket] = {}   # rule_name → listener socket
         self.c2c_uid_to_rule: Dict[bytes, str] = {}         # UID → rule_name
 
-        # 多连接支持：DataConnectionManager（由 run_client 注入）
-        self.data_conn_manager = None
-
     def set_running(self, running: bool):
         """Set running state"""
         self.running = running
@@ -134,9 +131,6 @@ class UdpForwardClient:
         protocol = rule['protocol']
         speed_limit = rule.get('speed_limit', 0.0)
 
-        # 创建限速器
-        speed_limiter = SpeedLimiter(speed_limit) if speed_limit > 0 else None
-
         # Check if using direct mode (target_ip + target_port) or service mode (target_service)
         use_direct_mode = 'target_ip' in rule and 'target_port' in rule
 
@@ -211,22 +205,10 @@ class UdpForwardClient:
                         'ip_port': f"{source_addr[0]}:{source_addr[1]}"
                     }
                 }
-
-                # 发送端限速：在发送前等待
-                if speed_limiter and data:
-                    wait_time = speed_limiter.acquire(len(data))
-                    if wait_time > 0:
-                        time.sleep(wait_time)
-
-                message_bytes = NatSerialization.dumps(send_message, ContextUtils.get_password(), self.compress_support)
-                # 多连接模式：优先使用数据连接
-                if self.data_conn_manager and self.data_conn_manager.is_ready():
-                    if not self.data_conn_manager.send_by_uid(uid, message_bytes):
-                        # 数据连接发送失败，回退到控制连接
-                        self.ws.send(message_bytes, websocket.ABNF.OPCODE_BINARY)
-                else:
-                    # 单连接模式
-                    self.ws.send(message_bytes, websocket.ABNF.OPCODE_BINARY)
+                self.ws.send(
+                    NatSerialization.dumps(send_message, ContextUtils.get_password(), self.compress_support),
+                    websocket.ABNF.OPCODE_BINARY
+                )
                 LoggerFactory.get_logger().debug(f'C2C UDP data forwarded: {rule_name} UID: {uid.hex()}, len: {len(data)}')
 
             except OSError as e:
@@ -264,6 +246,12 @@ class UdpForwardClient:
 
     def _handle_udp_data(self, conn: UdpSocketConnection, data: bytes, addr):
         """Handle received UDP data"""
+        # --- 发送端限速：在发送前等待 ---
+        if conn.speed_limiter and data:
+            wait_time = conn.speed_limiter.acquire(len(data))
+            if wait_time > 0:
+                time.sleep(wait_time)
+
         # Construct UDP message and send to public server via WebSocket
         send_message: MessageEntity = {
             'type_': MessageTypeConstant.WEBSOCKET_OVER_UDP,
@@ -279,21 +267,7 @@ class UdpForwardClient:
             LoggerFactory.get_logger().debug(f'Sending UDP to WebSocket, uid: {conn.uid}, len: {len(data)}')
 
         try:
-            # 发送端限速：在发送前等待
-            if conn.speed_limiter and data:
-                wait_time = conn.speed_limiter.acquire(len(data))
-                if wait_time > 0:
-                    time.sleep(wait_time)
-
-            message_bytes = NatSerialization.dumps(send_message, ContextUtils.get_password(), self.compress_support)
-            # 多连接模式：优先使用数据连接
-            if self.data_conn_manager and self.data_conn_manager.is_ready():
-                if not self.data_conn_manager.send_by_uid(conn.uid, message_bytes):
-                    # 数据连接发送失败，回退到控制连接
-                    self.ws.send(message_bytes, websocket.ABNF.OPCODE_BINARY)
-            else:
-                # 单连接模式
-                self.ws.send(message_bytes, websocket.ABNF.OPCODE_BINARY)
+            self.ws.send(NatSerialization.dumps(send_message, ContextUtils.get_password(), self.compress_support), websocket.ABNF.OPCODE_BINARY)
         except Exception as e:
             LoggerFactory.get_logger().error(f"Failed to send UDP to WebSocket: {e}")
 

{proxynt-2.0.26 → proxynt-2.0.32}/common/speed_limit.py

@@ -1,5 +1,6 @@
 import time
 import threading
+from typing import Tuple
 
 
 class SpeedLimiter:
@@ -75,7 +76,7 @@ class SpeedLimiter:
         """兼容旧接口，等同于 acquire 但不返回等待时间"""
         self.acquire(data_len)
 
-    def is_exceed(self):
+    def is_exceed(self) -> Tuple[bool, float]:
         """兼容旧接口，返回 (是否超速, 剩余量)"""
         if self.max_speed <= 0:
             return False, 0

{proxynt-2.0.26 → proxynt-2.0.32}/constant/message_type_constnat.py

@@ -28,7 +28,4 @@ class MessageTypeConstant:
     P2P_PRE_CONNECT = 'g'
     P2P_EXCHANGE = 'h'        # UDP exchange to establish NAT mapping
     P2P_PEER_INFO = 'i'       # Server sends peer's actual UDP port
-    P2P_PUNCH_REQUEST = 'j'   # Request to initiate P2P hole punching
-
-    # 多连接支持
-    JOIN_SESSION = 'k'        # 数据连接加入会话（携带 session_token）
+    P2P_PUNCH_REQUEST = 'j'   # Request to initiate P2P hole punching

{proxynt-2.0.26 → proxynt-2.0.32}/constant/system_constant.py

@@ -15,7 +15,7 @@ class SystemConstant:
 
     COOKIE_EXPIRE_SECONDS = 3600 * 24
 
-    VERSION = '2.0.26'
+    VERSION = '2.0.32'
 
     GITHUB = 'https://github.com/sazima/proxynt'
 

{proxynt-2.0.26 → proxynt-2.0.32}/proxynt.egg-info/PKG-INFO

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

{proxynt-2.0.26 → proxynt-2.0.32}/proxynt.egg-info/SOURCES.txt

@@ -8,7 +8,6 @@ setup.py
 ./client/__init__.py
 ./client/abstract_tunnel.py
 ./client/clear_nonce_task.py
-./client/data_connection_manager.py
 ./client/heart_beat_task.py
 ./client/kcp_tunnel_impl.py
 ./client/n4_tunnel_manager.py
@@ -75,7 +74,6 @@ setup.py
 ./server/admin_http_handler.py
 ./server/n4.py
 ./server/n4_signal_service.py
-./server/session_manager.py
 ./server/tcp_forward_client.py
 ./server/udp_forward_client.py
 ./server/websocket_handler.py

{proxynt-2.0.26 → proxynt-2.0.32}/run_client.py

@@ -49,7 +49,6 @@ from client.udp_forward_client import UdpForwardClient
 from client.heart_beat_task import HeatBeatTask
 from client.tcp_forward_client import TcpForwardClient
 from client.n4_tunnel_manager import N4TunnelManager, get_pair_key
-from client.data_connection_manager import DataConnectionManager
 from common import websocket
 from common.logger_factory import LoggerFactory
 from common.nat_serialization import NatSerialization
@@ -152,19 +151,6 @@ class WebsocketClient:
         self.public_ip: str = None
         self.public_port: int = None
 
-        # 多连接支持
-        self.multi_connection_enabled: bool = config_data.get('multi_connection', True)
-        self.num_data_channels: int = config_data.get('num_data_channels', 4)
-        server_url = config_data['server']['url']
-        if self.compress_support:
-            sep = '&' if '?' in server_url else '?'
-            server_url += sep + 'c=' + json.dumps(self.compress_support)
-        self.data_conn_manager: DataConnectionManager = DataConnectionManager(
-            server_url=server_url,
-            compress_support=self.compress_support,
-            on_message_callback=self._on_data_connection_message
-        )
-
         # Get server info for N4 signaling
         server_url = config_data['server']['url']
         parsed = urlparse(server_url)
@@ -223,7 +209,14 @@ class WebsocketClient:
                     self.tunnel_manager.register_uid(uid, source_client)
                     LoggerFactory.get_logger().info(f'Registered UID {uid.hex()} to peer {source_client}')
 
-                self.forward_client.create_socket(name, uid, data['ip_port'], name_to_speed_limiter.get(name))
+                # 优先使用消息中携带的限速配置（C2C场景），否则使用本地配置
+                speed_limit = data.get('speed_limit', 0.0)
+                if speed_limit > 0:
+                    speed_limiter = SpeedLimiter(speed_limit)
+                else:
+                    speed_limiter = name_to_speed_limiter.get(name)
+
+                self.forward_client.create_socket(name, uid, data['ip_port'], speed_limiter)
 
             # Handle UDP messages
             elif msg_type == MessageTypeConstant.WEBSOCKET_OVER_UDP:
@@ -240,7 +233,15 @@ class WebsocketClient:
                 data: TcpOverWebsocketMessage = message_data['data']
                 uid = data['uid']
                 name = data['name']
-                self.udp_forward_client.create_udp_socket(name, uid, data['ip_port'], name_to_speed_limiter.get(name))
+
+                # 优先使用消息中携带的限速配置（C2C场景），否则使用本地配置
+                speed_limit = data.get('speed_limit', 0.0)
+                if speed_limit > 0:
+                    speed_limiter = SpeedLimiter(speed_limit)
+                else:
+                    speed_limiter = name_to_speed_limiter.get(name)
+
+                self.udp_forward_client.create_udp_socket(name, uid, data['ip_port'], speed_limiter)
 
             # Handle Heartbeat / Config
             elif msg_type == MessageTypeConstant.PING:
@@ -254,20 +255,6 @@ class WebsocketClient:
                     if d.get('speed_limit'):
                         name_to_speed_limiter[d['name']] = SpeedLimiter(d['speed_limit'])
 
-                # 多连接支持：如果服务端返回了 session_token，建立数据连接
-                session_token = push_config.get('session_token')
-                if session_token and self.multi_connection_enabled:
-                    LoggerFactory.get_logger().info(
-                        f'Multi-connection enabled, establishing {self.num_data_channels} data connections'
-                    )
-                    self.data_conn_manager.setup_data_connections(
-                        session_token=session_token,
-                        num_channels=self.num_data_channels
-                    )
-                    # 将 DataConnectionManager 注入到 forward_client
-                    self.forward_client.data_conn_manager = self.data_conn_manager
-                    self.udp_forward_client.data_conn_manager = self.data_conn_manager
-
                 # Setup Listeners
                 c2c_rules = push_config.get('client_to_client_rules', [])
                 if c2c_rules:
@@ -360,52 +347,6 @@ class WebsocketClient:
         # Start hole punching with peer info
         self.tunnel_manager.receive_peer_info(peer_name, peer_ip, peer_port)
 
-    def _on_data_connection_message(self, message_data: MessageEntity):
-        """处理数据连接收到的消息（和控制连接消息处理逻辑相同）"""
-        try:
-            msg_type = message_data['type_']
-
-            # Handle TCP messages
-            if msg_type == MessageTypeConstant.WEBSOCKET_OVER_TCP:
-                data: TcpOverWebsocketMessage = message_data['data']
-                uid = data['uid']
-                name = data['name']
-                b = data['data']
-
-                create_result = self.forward_client.create_socket(name, uid, data['ip_port'], name_to_speed_limiter.get(name))
-                if create_result:
-                    self.forward_client.send_by_uid(uid, b)
-
-            # Handle UDP messages
-            elif msg_type == MessageTypeConstant.WEBSOCKET_OVER_UDP:
-                data: TcpOverWebsocketMessage = message_data['data']
-                uid = data['uid']
-                name = data['name']
-                b = data['data']
-                create_result = self.udp_forward_client.create_udp_socket(name, uid, data['ip_port'], name_to_speed_limiter.get(name))
-                if create_result:
-                    self.udp_forward_client.send_by_uid(uid, b)
-
-            # Handle connection confirmed/failed (for C2C)
-            elif msg_type == MessageTypeConstant.CONNECT_CONFIRMED:
-                data: TcpOverWebsocketMessage = message_data['data']
-                uid = data['uid']
-                # C2C 连接确认，暂无特殊处理
-                LoggerFactory.get_logger().debug(f'C2C connection confirmed: {uid.hex()}')
-
-            elif msg_type == MessageTypeConstant.CONNECT_FAILED:
-                data: TcpOverWebsocketMessage = message_data['data']
-                uid = data['uid']
-                LoggerFactory.get_logger().info(f'C2C connection failed: {uid.hex()}')
-                # 关闭本地连接
-                conn = self.forward_client.uid_to_socket_connection.get(uid)
-                if conn:
-                    self.forward_client.close_connection(conn.socket)
-
-        except Exception as e:
-            LoggerFactory.get_logger().error(f'Data connection message handling error: {e}')
-            LoggerFactory.get_logger().error(traceback.format_exc())
-
     def _on_p2p_data_received(self, uid: bytes, data: bytes):
         """Callback when data comes from P2P Tunnel"""
         self.forward_client.send_by_uid(uid, data)
@@ -471,10 +412,6 @@ class WebsocketClient:
                 self.forward_client.close()
                 self.udp_forward_client.close()
 
-                # Stop data connections (will be re-established after PUSH_CONFIG response)
-                if self.data_conn_manager:
-                    self.data_conn_manager.stop_all()
-
                 # Restart tunnel manager
                 if self.tunnel_manager:
                     self.tunnel_manager.stop()
@@ -496,9 +433,7 @@ class WebsocketClient:
                     'config_list': push_client_data,
                     "client_name": client_name,
                     'version': SystemConstant.VERSION,
-                    'p2p_supported': True,
-                    'multi_connection': self.multi_connection_enabled,
-                    'num_data_channels': self.num_data_channels
+                    'p2p_supported': True
                 }
                 message: MessageEntity = {
                     'type_': MessageTypeConstant.PUSH_CONFIG,
@@ -522,9 +457,6 @@ class WebsocketClient:
             LoggerFactory.get_logger().info(f'WS Closed: {a}, {b}')
             self.heart_beat_task.is_running = False
             self.forward_client.close()
-            # Stop data connections
-            if self.data_conn_manager:
-                self.data_conn_manager.stop_all()
             # Stop tunnel manager
             if self.tunnel_manager:
                 self.tunnel_manager.stop()

{proxynt-2.0.26 → proxynt-2.0.32}/server/tcp_forward_client.py

@@ -21,7 +21,6 @@ from common.speed_limit import SpeedLimiter
 from constant.message_type_constnat import MessageTypeConstant
 from context.context_utils import ContextUtils
 from entity.message.message_entity import MessageEntity
-from server.session_manager import SessionManager
 
 
 class PublicSocketServer:
@@ -151,6 +150,12 @@ class TcpForwardClient:
                     LoggerFactory.get_logger().error(f'Close error: {traceback.format_exc()}')
             return
 
+        # --- 发送端限速：在发送前等待 ---
+        if data.speed_limiter and recv:
+            wait_time = data.speed_limiter.acquire(len(recv))
+            if wait_time > 0:
+                time.sleep(wait_time)
+
         if LoggerFactory.get_logger().isEnabledFor(logging.DEBUG):
             LoggerFactory.get_logger().debug(f'send to ws uid: {socket_connection.uid}, len: {len(recv)}')
         send_message: MessageEntity = {
@@ -169,22 +174,9 @@ class TcpForwardClient:
             except (OSError, ValueError, KeyError):
                 LoggerFactory.get_logger().error(f'close error: {traceback.format_exc()}')
         try:
-            # 发送端限速：在发送前等待
-            if data.speed_limiter and recv:
-                wait_time = data.speed_limiter.acquire(len(recv))
-                if wait_time > 0:
-                    time.sleep(wait_time)
-
-            # 使用多连接：根据 UID 选择数据通道
-            control_handler = socket_connection.socket_server.websocket_handler
-            session = SessionManager.get_instance().get_session_by_handler(control_handler)
-            if session:
-                target_handler = session.get_data_handler(socket_connection.uid)
-            else:
-                target_handler = control_handler
-            is_compress = target_handler.compress_support
+            is_compress = socket_connection.socket_server.websocket_handler.compress_support
             self.tornado_loop.add_callback(
-                partial(target_handler.write_message, NatSerialization.dumps(send_message, ContextUtils.get_password(), is_compress)), True)
+                partial(socket_connection.socket_server.websocket_handler.write_message, NatSerialization.dumps(send_message, ContextUtils.get_password(), is_compress)), True)
         except Exception:
             LoggerFactory.get_logger().error(traceback.format_exc())
 

{proxynt-2.0.26 → proxynt-2.0.32}/server/udp_forward_client.py

@@ -17,7 +17,6 @@ from common.speed_limit import SpeedLimiter
 from constant.message_type_constnat import MessageTypeConstant
 from context.context_utils import ContextUtils
 from entity.message.message_entity import MessageEntity
-from server.session_manager import SessionManager
 
 
 class UdpEndpoint:
@@ -204,7 +203,7 @@ class UdpForwardClient:
 
         uid = server.add_endpoint(address)
 
-        # 发送端限速：在发送前等待
+        # --- 发送端限速：在发送前等待 ---
         if server.speed_limiter and data:
             wait_time = server.speed_limiter.acquire(len(data))
             if wait_time > 0:
@@ -224,16 +223,10 @@ class UdpForwardClient:
         if LoggerFactory.get_logger().isEnabledFor(logging.DEBUG):
             LoggerFactory.get_logger().debug(f"Send UDP data to WebSocket, uid: {uid}, len: {len(data)}")
 
-        # 使用多连接：根据 UID 选择数据通道
-        control_handler = server.websocket_handler
-        session = SessionManager.get_instance().get_session_by_handler(control_handler)
-        if session:
-            target_handler = session.get_data_handler(uid)
-        else:
-            target_handler = control_handler
-        is_compress = target_handler.compress_support
+        # Schedule WebSocket send operation in the async loop
+        is_compress = server.websocket_handler.compress_support
         self.tornado_loop.add_callback(
-            partial(target_handler.write_message, NatSerialization.dumps(send_message, ContextUtils.get_password(), is_compress)), True)
+            partial(server.websocket_handler.write_message, NatSerialization.dumps(send_message, ContextUtils.get_password(), is_compress)), True)
 
     async def register_udp_server(self, port: int, name: str, ip_port: str, websocket_handler, speed_limit_size: float):
         """Register a UDP server"""