[fix]

wu-lazy-cloud-heartbeat-client/src/main/java/org/framework/lazy/cloud/network/heartbeat/client/config/HeartbeatClientConfiguration.java

@@ -55,7 +55,15 @@ public class HeartbeatClientConfiguration {
         return new ClientHandleDistributeClientTransferServerPermeateChannelConnectionSuccessfulTypeAdvanced();
     }
 
-
+    /**
+     * 处理 客户端渗透客户端数据传输通道连接成功
+     *
+     * @return ClientHandleDistributeClientTransferClientPermeateChannelConnectionSuccessfulTypeAdvanced
+     */
+    @Bean
+    public ClientHandleDistributeClientTransferClientPermeateChannelConnectionSuccessfulTypeAdvanced clientHandleDistributeClientTransferClientPermeateChannelConnectionSuccessfulTypeAdvanced() {
+        return new ClientHandleDistributeClientTransferClientPermeateChannelConnectionSuccessfulTypeAdvanced();
+    }
     @Bean
     public ClientHandleDistributeSingleClientRealCloseVisitorTypeAdvanced handleDistributeSingleClientRealCloseVisitorTypeAdvanced() {
         return new ClientHandleDistributeSingleClientRealCloseVisitorTypeAdvanced();

wu-lazy-cloud-heartbeat-client/src/main/java/org/framework/lazy/cloud/network/heartbeat/client/netty/advanced/ClientHandleDistributeClientTransferClientPermeateChannelConnectionSuccessfulTypeAdvanced.java

@@ -0,0 +1,49 @@
+package org.framework.lazy.cloud.network.heartbeat.client.netty.advanced;
+
+
+import io.netty.channel.Channel;
+import io.netty.channel.ChannelOption;
+import lombok.extern.slf4j.Slf4j;
+import org.framework.lazy.cloud.network.heartbeat.client.netty.handler.NettyClientPermeateServerVisitorHandler;
+import org.framework.lazy.cloud.network.heartbeat.client.netty.socket.NettyClientPermeateClientRealSocket;
+import org.framework.lazy.cloud.network.heartbeat.client.netty.socket.NettyClientTransferServerSocket;
+import org.framework.lazy.cloud.network.heartbeat.common.NettyProxyMsg;
+import org.framework.lazy.cloud.network.heartbeat.common.NettyRealIdContext;
+import org.framework.lazy.cloud.network.heartbeat.common.advanced.client.AbstractHandleDistributeClientTransferClientPermeateChannelConnectionSuccessfulTypeAdvanced;
+import org.framework.lazy.cloud.network.heartbeat.common.advanced.client.AbstractHandleDistributeClientTransferServerPermeateChannelConnectionSuccessfulTypeAdvanced;
+import org.framework.lazy.cloud.network.heartbeat.common.enums.MessageTypeEnums;
+import org.framework.lazy.cloud.network.heartbeat.common.utils.ChannelAttributeKeyUtils;
+
+
+/**
+ * 客户端渗透客户端数据传输通道连接成功
+ *
+ *
+ * @see MessageTypeEnums#DISTRIBUTE_CLIENT_TRANSFER_CLIENT_PERMEATE_CHANNEL_CONNECTION_SUCCESSFUL
+ */
+@Slf4j
+public class ClientHandleDistributeClientTransferClientPermeateChannelConnectionSuccessfulTypeAdvanced extends AbstractHandleDistributeClientTransferClientPermeateChannelConnectionSuccessfulTypeAdvanced<NettyProxyMsg> {
+
+
+
+    /**
+     * 处理当前数据
+     *
+     * @param channel       当前通道
+     * @param nettyProxyMsg 通道数据
+     */
+    @Override
+    public void doHandler(Channel channel, NettyProxyMsg nettyProxyMsg) {
+        // 连接成功 开启自动读取写
+        // 创建connect 然后发送创建成功
+        byte[] msgClientId = nettyProxyMsg.getClientId();
+        byte[] msgClientTargetIp = nettyProxyMsg.getClientTargetIp();
+        byte[] msgClientTargetPort = nettyProxyMsg.getClientTargetPort();
+        byte[] msgVisitorId = nettyProxyMsg.getVisitorId();
+        byte[] msgVisitorPort = nettyProxyMsg.getVisitorPort();
+
+        NettyClientPermeateClientRealSocket.buildRealServer();
+
+    }
+
+}

wu-lazy-cloud-heartbeat-client/src/main/java/org/framework/lazy/cloud/network/heartbeat/client/netty/advanced/ClientHandleDistributeSingleClientRealConnectTypeAdvanced.java

@@ -3,7 +3,7 @@ package org.framework.lazy.cloud.network.heartbeat.client.netty.advanced;
 import io.netty.channel.Channel;
 import lombok.extern.slf4j.Slf4j;
 import org.framework.lazy.cloud.network.heartbeat.client.config.NettyClientProperties;
-import org.framework.lazy.cloud.network.heartbeat.client.netty.socket.NettyClientRealSocket;
+import org.framework.lazy.cloud.network.heartbeat.client.netty.socket.NettyServerPermeateClientRealSocket;
 import org.framework.lazy.cloud.network.heartbeat.common.InternalNetworkPenetrationRealClient;
 import org.framework.lazy.cloud.network.heartbeat.common.NettyProxyMsg;
 import org.framework.lazy.cloud.network.heartbeat.common.advanced.HandleChannelTypeAdvanced;
@@ -50,7 +50,7 @@ public class ClientHandleDistributeSingleClientRealConnectTypeAdvanced extends A
                         .build();
 
         // 绑定真实服务端口
-        NettyClientRealSocket.buildRealServer(internalNetworkPenetrationRealClient, nettyClientProperties, handleChannelTypeAdvancedList);
+        NettyServerPermeateClientRealSocket.buildRealServer(internalNetworkPenetrationRealClient, nettyClientProperties, handleChannelTypeAdvancedList);
 
     }
 }

wu-lazy-cloud-heartbeat-client/src/main/java/org/framework/lazy/cloud/network/heartbeat/client/netty/filter/NettyClientPermeateClientRealFilter.java

@@ -1,17 +1,15 @@
 package org.framework.lazy.cloud.network.heartbeat.client.netty.filter;
 
 import io.netty.channel.Channel;
-import io.netty.channel.ChannelInitializer;
 import io.netty.channel.ChannelPipeline;
 import io.netty.channel.socket.SocketChannel;
-import io.netty.handler.codec.compression.JdkZlibDecoder;
+import org.framework.lazy.cloud.network.heartbeat.client.netty.handler.NettyClientPermeateClientRealHandler;
-import io.netty.handler.codec.compression.JdkZlibEncoder;
+import org.framework.lazy.cloud.network.heartbeat.client.netty.handler.NettyServerPermeateClientRealHandler;
-import org.framework.lazy.cloud.network.heartbeat.client.netty.handler.NettyClientRealHandler;
 import org.framework.lazy.cloud.network.heartbeat.common.decoder.TransferDecoder;
 import org.framework.lazy.cloud.network.heartbeat.common.encoder.TransferEncoder;
 import org.framework.lazy.cloud.network.heartbeat.common.filter.DebugChannelInitializer;
 
-public class NettyClientRealFilter extends DebugChannelInitializer<SocketChannel> {
+public class NettyClientPermeateClientRealFilter extends DebugChannelInitializer<SocketChannel> {
     /**
      * This method will be called once the {@link Channel} was registered. After the method returns this instance
      * will be removed from the {@link ChannelPipeline} of the {@link Channel}.
@@ -24,7 +22,7 @@ public class NettyClientRealFilter extends DebugChannelInitializer<SocketChannel
         // 解码、编码
         pipeline.addLast(new TransferDecoder(Integer.MAX_VALUE, 1024 * 1024*10));
         pipeline.addLast(new TransferEncoder());
-        pipeline.addLast(new NettyClientRealHandler());
+        pipeline.addLast(new NettyClientPermeateClientRealHandler());
 
     }
 }

wu-lazy-cloud-heartbeat-client/src/main/java/org/framework/lazy/cloud/network/heartbeat/client/netty/filter/NettyClientPermeateClientVisitorFilter.java

@@ -0,0 +1,37 @@
+package org.framework.lazy.cloud.network.heartbeat.client.netty.filter;
+
+import io.netty.channel.Channel;
+import io.netty.channel.ChannelDuplexHandler;
+import io.netty.channel.ChannelHandlerContext;
+import io.netty.channel.ChannelPipeline;
+import io.netty.channel.socket.SocketChannel;
+import org.framework.lazy.cloud.network.heartbeat.client.netty.InternalNetworkPermeateServerVisitor;
+import org.framework.lazy.cloud.network.heartbeat.client.netty.handler.NettyClientPermeateClientVisitorHandler;
+import org.framework.lazy.cloud.network.heartbeat.client.netty.handler.NettyClientPermeateServerVisitorHandler;
+import org.framework.lazy.cloud.network.heartbeat.common.filter.DebugChannelInitializer;
+
+public class NettyClientPermeateClientVisitorFilter extends DebugChannelInitializer<SocketChannel> {
+
+    private final InternalNetworkPermeateServerVisitor internalNetworkPermeateServerVisitor;
+
+    public NettyClientPermeateClientVisitorFilter(InternalNetworkPermeateServerVisitor internalNetworkPermeateServerVisitor) {
+        this.internalNetworkPermeateServerVisitor = internalNetworkPermeateServerVisitor;
+
+    }
+
+    /**
+     * This method will be called once the {@link Channel} was registered. After the method returns this instance
+     * will be removed from the {@link ChannelPipeline} of the {@link Channel}.
+     *
+     * @param ch the {@link Channel} which was registered.
+     * @throws Exception is thrown if an error occurs. In that case it will be handled by
+     *                   {@link #exceptionCaught(ChannelHandlerContext, Throwable)} which will by default connectionClose
+     *                   the {@link Channel}.
+     */
+    @Override
+    protected void initChannel0(SocketChannel ch) throws Exception {
+        ChannelPipeline pipeline = ch.pipeline();
+        pipeline.addLast(new ChannelDuplexHandler());
+        pipeline.addLast(new NettyClientPermeateClientVisitorHandler(internalNetworkPermeateServerVisitor));
+    }
+}

wu-lazy-cloud-heartbeat-client/src/main/java/org/framework/lazy/cloud/network/heartbeat/client/netty/filter/NettyServerPermeateClientRealFilter.java

@@ -0,0 +1,27 @@
+package org.framework.lazy.cloud.network.heartbeat.client.netty.filter;
+
+import io.netty.channel.Channel;
+import io.netty.channel.ChannelPipeline;
+import io.netty.channel.socket.SocketChannel;
+import org.framework.lazy.cloud.network.heartbeat.client.netty.handler.NettyServerPermeateClientRealHandler;
+import org.framework.lazy.cloud.network.heartbeat.common.decoder.TransferDecoder;
+import org.framework.lazy.cloud.network.heartbeat.common.encoder.TransferEncoder;
+import org.framework.lazy.cloud.network.heartbeat.common.filter.DebugChannelInitializer;
+
+public class NettyServerPermeateClientRealFilter extends DebugChannelInitializer<SocketChannel> {
+    /**
+     * This method will be called once the {@link Channel} was registered. After the method returns this instance
+     * will be removed from the {@link ChannelPipeline} of the {@link Channel}.
+     *
+     * @param ch the {@link Channel} which was registered.
+     */
+    @Override
+    protected void initChannel0(SocketChannel ch) {
+        ChannelPipeline pipeline = ch.pipeline();
+        // 解码、编码
+        pipeline.addLast(new TransferDecoder(Integer.MAX_VALUE, 1024 * 1024*10));
+        pipeline.addLast(new TransferEncoder());
+        pipeline.addLast(new NettyServerPermeateClientRealHandler());
+
+    }
+}

wu-lazy-cloud-heartbeat-client/src/main/java/org/framework/lazy/cloud/network/heartbeat/client/netty/handler/NettyClientPermeateClientRealHandler.java

@@ -17,7 +17,7 @@ import org.wu.framework.core.utils.ObjectUtils;
  * 来自客户端 真实服务器返回的数据请求
  */
 @Slf4j
-public class NettyClientRealHandler extends SimpleChannelInboundHandler<NettyByteBuf> {
+public class NettyClientPermeateClientRealHandler extends SimpleChannelInboundHandler<NettyByteBuf> {
 
 
     @Override

wu-lazy-cloud-heartbeat-client/src/main/java/org/framework/lazy/cloud/network/heartbeat/client/netty/handler/NettyClientPermeateClientVisitorHandler.java

@@ -0,0 +1,181 @@
+package org.framework.lazy.cloud.network.heartbeat.client.netty.handler;
+
+
+import io.netty.buffer.ByteBuf;
+import io.netty.channel.Channel;
+import io.netty.channel.ChannelHandlerContext;
+import io.netty.channel.ChannelOption;
+import io.netty.channel.SimpleChannelInboundHandler;
+import io.netty.util.internal.StringUtil;
+import lombok.extern.slf4j.Slf4j;
+import org.framework.lazy.cloud.network.heartbeat.client.netty.InternalNetworkPermeateServerVisitor;
+import org.framework.lazy.cloud.network.heartbeat.client.netty.advanced.ClientHandleDistributeClientTransferServerPermeateChannelConnectionSuccessfulTypeAdvanced;
+import org.framework.lazy.cloud.network.heartbeat.client.netty.socket.NettyClientTransferClientSocket;
+import org.framework.lazy.cloud.network.heartbeat.client.netty.socket.NettyClientTransferServerSocket;
+import org.framework.lazy.cloud.network.heartbeat.common.MessageType;
+import org.framework.lazy.cloud.network.heartbeat.common.NettyCommunicationIdContext;
+import org.framework.lazy.cloud.network.heartbeat.common.NettyProxyMsg;
+import org.framework.lazy.cloud.network.heartbeat.common.NettyRealIdContext;
+import org.framework.lazy.cloud.network.heartbeat.common.utils.ChannelAttributeKeyUtils;
+import org.wu.framework.core.utils.ObjectUtils;
+
+import java.util.UUID;
+
+@Slf4j
+public class NettyClientPermeateClientVisitorHandler extends SimpleChannelInboundHandler<ByteBuf> {
+    private final InternalNetworkPermeateServerVisitor internalNetworkPermeateServerVisitor;
+//    private final NettyChannelPool nettyChannelPool = new DefaultNettyChannelPool(10);
+
+    public NettyClientPermeateClientVisitorHandler(InternalNetworkPermeateServerVisitor internalNetworkPermeateServerVisitor) {
+        this.internalNetworkPermeateServerVisitor = internalNetworkPermeateServerVisitor;
+    }
+
+    /**
+     * @param ctx
+     * @throws Exception
+     * @see NettyClientTransferServerSocket
+     * @see ClientHandleDistributeClientTransferServerPermeateChannelConnectionSuccessfulTypeAdvanced
+     */
+    @Override
+    public void channelActive(ChannelHandlerContext ctx) throws Exception {
+        // 访客连接上代理服务器了
+        Channel visitorChannel = ctx.channel();
+        // 先不读取访客数据
+        visitorChannel.config().setOption(ChannelOption.AUTO_READ, false);
+
+
+        // 生成访客ID
+        String visitorId = UUID.randomUUID().toString();
+        // 绑定访客真实通道
+        NettyRealIdContext.pushReal(visitorChannel, visitorId);
+        // 当前通道绑定访客ID
+        ChannelAttributeKeyUtils.buildVisitorId(visitorChannel, visitorId);
+
+        internalNetworkPermeateServerVisitor.setVisitorId(visitorId);
+        // 判断是否有可用的通道 如果没有创建新的通道
+//        Channel transferChannel = nettyChannelPool.availableChannel(visitorId);
+        // 创建访客连接服务端通道
+        NettyClientTransferClientSocket.buildTransferServer(internalNetworkPermeateServerVisitor);
+        log.info("客户端渗透服务端访客端口连接成功了");
+        super.channelActive(ctx);
+    }
+
+    @Override
+    public void channelRead0(ChannelHandlerContext ctx, ByteBuf buf) {
+
+        // 访客通道
+        Channel visitorChannel = ctx.channel();
+
+        String visitorId = ChannelAttributeKeyUtils.getVisitorId(visitorChannel);
+        Channel nextChannel = ChannelAttributeKeyUtils.getNextChannel(visitorChannel);
+        byte[] bytes = new byte[buf.readableBytes()];
+        buf.readBytes(bytes);
+        // 获取客户端通道，而后进行数据下发
+        log.debug("【客户端渗透服务端】访客端口成功接收数据:{}", new String(bytes));
+
+        // 使用访客的通信通道
+        Integer visitorPort = internalNetworkPermeateServerVisitor.getVisitorPort();
+        NettyProxyMsg nettyProxyMsg = new NettyProxyMsg();
+        nettyProxyMsg.setType(MessageType.REPORT_CLIENT_TRANSFER);
+        nettyProxyMsg.setVisitorId(visitorId);
+        nettyProxyMsg.setVisitorPort(visitorPort);
+        nettyProxyMsg.setData(bytes);
+        nextChannel.writeAndFlush(nettyProxyMsg);
+        // 处理访客流量
+//        ServerChannelFlow serverChannelFlow = ServerChannelFlow
+//                .builder()
+//                .channelFlowEnum(ChannelFlowEnum.IN_FLOW)
+//                .port(visitorPort)
+//                .clientId(clientId)
+//                .flow(bytes.length)
+//                .build();
+//        channelFlowAdapter.asyncHandler(visitorChannel, serverChannelFlow);
+        log.debug("【客户端渗透服务端】访客端口成功发送数据了");
+    }
+
+    @Override
+    public void channelInactive(ChannelHandlerContext ctx) throws Exception {
+        Channel channel = ctx.channel();
+        String visitorId = ChannelAttributeKeyUtils.getVisitorId(channel);
+        String clientId = ChannelAttributeKeyUtils.getClientId(channel);
+        if (StringUtil.isNullOrEmpty(visitorId)) {
+            super.channelInactive(ctx);
+            return;
+        }
+        Channel nextChannel = ChannelAttributeKeyUtils.getNextChannel(channel);
+        // 通信通道自动读写打开 ，然后关闭通信通道
+
+        if (nextChannel != null && nextChannel.isActive()) {
+
+            nextChannel.config().setOption(ChannelOption.AUTO_READ, true);
+
+            //  通知服务端 关闭访问通道、真实通道
+            NettyProxyMsg myMsg = new NettyProxyMsg();
+            myMsg.setType(MessageType.DISTRIBUTE_SINGLE_CLIENT_REAL_CLOSE_VISITOR);
+            myMsg.setVisitorId(visitorId);
+            nextChannel.writeAndFlush(myMsg);
+        }
+        // 关闭 访客通信通道、访客真实通道
+        NettyRealIdContext.clear(visitorId);
+        NettyCommunicationIdContext.clear(visitorId);
+        log.warn("【客户端渗透服务端】访客端口断开连接");
+        super.channelInactive(ctx);
+    }
+
+    @Override
+    public void channelWritabilityChanged(ChannelHandlerContext ctx) throws Exception {
+
+        // 获取访客的传输通道
+        String visitorId = ChannelAttributeKeyUtils.getVisitorId(ctx.channel());
+        if(ObjectUtils.isEmpty(visitorId)) {
+            super.channelWritabilityChanged(ctx);
+            return;
+        }
+
+        Channel visitorCommunicationChannel = NettyCommunicationIdContext.getVisitor(visitorId);
+        if (visitorCommunicationChannel != null) {
+            log.debug("visitorId:{} transfer AUTO_READ:{} ",visitorId,ctx.channel().isWritable());
+            visitorCommunicationChannel.config().setOption(ChannelOption.AUTO_READ, ctx.channel().isWritable());
+        }
+        //        Channel visitorChannel = ctx.channel();
+        //        String vid = visitorChannel.attr(Constant.VID).get();
+        //        if (StringUtil.isNullOrEmpty(vid)) {
+        //            super.channelWritabilityChanged(ctx);
+        //            return;
+        //        }
+        //        Channel clientChannel = Constant.vcc.get(vid);
+        //        if (clientChannel != null) {
+        //            clientChannel.config().setOption(ChannelOption.AUTO_READ, visitorChannel.isWritable());
+        //        }
+        if (ctx.channel().isWritable()) {
+            log.debug("Channel is writable again");
+            // 恢复之前暂停的操作，如写入数据
+        } else {
+            log.debug("Channel is not writable");
+            // 暂停写入操作，等待可写状态
+        }
+        log.info("visitorId:{} channelWritabilityChanged!",visitorId);
+    }
+
+    @Override
+    public void exceptionCaught(ChannelHandlerContext ctx, Throwable cause) throws Exception {
+        log.error("exceptionCaught");
+
+        Channel channel = ctx.channel();
+        String clientId = ChannelAttributeKeyUtils.getClientId(channel);
+        String visitorId = ChannelAttributeKeyUtils.getVisitorId(channel);
+        // 使用通信通道 下发关闭访客
+        Channel visitorChannel = NettyCommunicationIdContext.getVisitor(visitorId);
+        Channel nextChannel = ChannelAttributeKeyUtils.getNextChannel(ctx.channel());
+        if (nextChannel != null) {
+            // 下发关闭访客
+            NettyProxyMsg closeRealClient = new NettyProxyMsg();
+            closeRealClient.setType(MessageType.DISTRIBUTE_SINGLE_CLIENT_REAL_CONNECT_AUTO_READ);
+            closeRealClient.setClientId(clientId);
+            closeRealClient.setVisitorId(visitorId);
+            nextChannel.writeAndFlush(closeRealClient);
+        }
+
+        ctx.close();
+    }
+}

wu-lazy-cloud-heartbeat-client/src/main/java/org/framework/lazy/cloud/network/heartbeat/client/netty/handler/NettyServerPermeateClientRealHandler.java

@@ -0,0 +1,98 @@
+package org.framework.lazy.cloud.network.heartbeat.client.netty.handler;
+
+
+import io.netty.channel.Channel;
+import io.netty.channel.ChannelHandlerContext;
+import io.netty.channel.ChannelOption;
+import io.netty.channel.SimpleChannelInboundHandler;
+import lombok.extern.slf4j.Slf4j;
+import org.framework.lazy.cloud.network.heartbeat.common.MessageType;
+import org.framework.lazy.cloud.network.heartbeat.common.NettyByteBuf;
+import org.framework.lazy.cloud.network.heartbeat.common.NettyCommunicationIdContext;
+import org.framework.lazy.cloud.network.heartbeat.common.NettyProxyMsg;
+import org.framework.lazy.cloud.network.heartbeat.common.utils.ChannelAttributeKeyUtils;
+import org.wu.framework.core.utils.ObjectUtils;
+
+/**
+ * 来自客户端 真实服务器返回的数据请求
+ */
+@Slf4j
+public class NettyServerPermeateClientRealHandler extends SimpleChannelInboundHandler<NettyByteBuf> {
+
+
+    @Override
+    public void channelRead0(ChannelHandlerContext ctx,NettyByteBuf nettyByteBuf) {
+
+        byte[] bytes = nettyByteBuf.getData();
+        log.debug("bytes.length:{}",bytes.length);
+        log.debug("接收客户端真实服务数据:{}", new String(bytes));
+        String visitorId = ChannelAttributeKeyUtils.getVisitorId(ctx.channel());
+        Integer visitorPort = ChannelAttributeKeyUtils.getVisitorPort(ctx.channel());
+        String clientId = ChannelAttributeKeyUtils.getClientId(ctx.channel());
+        // 访客通信通道 上报服务端代理完成
+        Channel visitorChannel = NettyCommunicationIdContext.getVisitor(visitorId);
+        NettyProxyMsg returnMessage = new NettyProxyMsg();
+        returnMessage.setType(MessageType.REPORT_CLIENT_TRANSFER);
+        returnMessage.setVisitorId(visitorId);
+        returnMessage.setClientId(clientId);
+        returnMessage.setVisitorPort(visitorPort);
+        returnMessage.setData(bytes);
+
+        visitorChannel.writeAndFlush(returnMessage);
+    }
+
+
+    @Override
+    public void channelActive(ChannelHandlerContext ctx) throws Exception {
+        super.channelActive(ctx);
+    }
+
+    @Override
+    public void channelInactive(ChannelHandlerContext ctx) throws Exception {
+        String clientId = ChannelAttributeKeyUtils.getClientId(ctx.channel());
+        String visitorId = ChannelAttributeKeyUtils.getVisitorId(ctx.channel());
+        //  客户端真实通信通道
+        Channel visitor = NettyCommunicationIdContext.getVisitor(visitorId);
+        if (visitor != null) {
+            // 上报关闭这个客户端的访客通道
+            NettyProxyMsg closeVisitorMsg = new NettyProxyMsg();
+            closeVisitorMsg.setType(MessageType.REPORT_SINGLE_CLIENT_CLOSE_VISITOR);
+            closeVisitorMsg.setVisitorId(visitorId);
+            visitor.writeAndFlush(closeVisitorMsg);
+        }
+
+        super.channelInactive(ctx);
+    }
+
+    @Override
+    public void channelWritabilityChanged(ChannelHandlerContext ctx) throws Exception {
+
+//        String vid = ctx.channel().attr(Constant.VID).get();
+//        if (StringUtil.isNullOrEmpty(vid)) {
+//            super.channelWritabilityChanged(ctx);
+//            return;
+//        }
+//        Channel proxyChannel = Constant.vpc.get(vid);
+//        if (proxyChannel != null) {
+//            proxyChannel.config().setOption(ChannelOption.AUTO_READ, ctx.channel().isWritable());
+//        }
+
+        // 获取访客的传输通道
+        String visitorId = ChannelAttributeKeyUtils.getVisitorId(ctx.channel());
+        if(ObjectUtils.isEmpty(visitorId)) {
+            super.channelWritabilityChanged(ctx);
+            return;
+        }
+        Channel visitorCommunicationChannel = NettyCommunicationIdContext.getVisitor(visitorId);
+        if (visitorCommunicationChannel != null) {
+            log.debug("visitorId:{} transfer AUTO_READ:{} ",visitorId,ctx.channel().isWritable());
+            visitorCommunicationChannel.config().setOption(ChannelOption.AUTO_READ, ctx.channel().isWritable());
+        }
+
+    }
+
+    @Override
+    public void exceptionCaught(ChannelHandlerContext ctx, Throwable cause) throws Exception {
+        super.exceptionCaught(ctx, cause);
+    }
+}

wu-lazy-cloud-heartbeat-client/src/main/java/org/framework/lazy/cloud/network/heartbeat/client/netty/socket/NettyClientPermeateClientRealSocket.java

@@ -0,0 +1,89 @@
+package org.framework.lazy.cloud.network.heartbeat.client.netty.socket;
+
+
+import io.netty.bootstrap.Bootstrap;
+import io.netty.channel.*;
+import io.netty.channel.nio.NioEventLoopGroup;
+import io.netty.channel.socket.nio.NioSocketChannel;
+import lombok.extern.slf4j.Slf4j;
+import org.framework.lazy.cloud.network.heartbeat.client.config.NettyClientProperties;
+import org.framework.lazy.cloud.network.heartbeat.client.netty.filter.NettyClientPermeateClientRealFilter;
+import org.framework.lazy.cloud.network.heartbeat.client.netty.filter.NettyClientVisitorRealFilter;
+import org.framework.lazy.cloud.network.heartbeat.client.netty.filter.NettyServerPermeateClientRealFilter;
+import org.framework.lazy.cloud.network.heartbeat.common.*;
+import org.framework.lazy.cloud.network.heartbeat.common.adapter.ChannelTypeAdapter;
+import org.framework.lazy.cloud.network.heartbeat.common.advanced.HandleChannelTypeAdvanced;
+import org.framework.lazy.cloud.network.heartbeat.common.utils.ChannelAttributeKeyUtils;
+
+import java.util.List;
+import java.util.concurrent.TimeUnit;
+
+/**
+ * 客户端连接真实服务
+ */
+@Slf4j
+public class NettyClientPermeateClientRealSocket {
+    static EventLoopGroup eventLoopGroup = new NioEventLoopGroup();
+
+
+    /**
+     * @param internalNetworkPenetrationRealClient 访客信息
+     * @param nettyClientProperties                服务端地址信息
+     */
+    public static void buildRealServer(InternalNetworkPenetrationRealClient internalNetworkPenetrationRealClient,
+                                           NettyClientProperties nettyClientProperties,
+                                           List<HandleChannelTypeAdvanced> handleChannelTypeAdvancedList) {
+        try {
+            String clientId = internalNetworkPenetrationRealClient.getClientId();
+            String clientTargetIp = internalNetworkPenetrationRealClient.getClientTargetIp();
+            Integer clientTargetPort = internalNetworkPenetrationRealClient.getClientTargetPort();
+            Integer visitorPort = internalNetworkPenetrationRealClient.getVisitorPort();
+            String visitorId = internalNetworkPenetrationRealClient.getVisitorId();
+            Bootstrap bootstrap = new Bootstrap();
+            bootstrap.group(eventLoopGroup).channel(NioSocketChannel.class)
+//                     设置读缓冲区为2M
+                    .option(ChannelOption.SO_RCVBUF, 2048 * 1024)
+//                     设置写缓冲区为1M
+                    .option(ChannelOption.SO_SNDBUF, 1024 * 1024)
+//                    .option(ChannelOption.TCP_NODELAY, false)
+                    .option(ChannelOption.CONNECT_TIMEOUT_MILLIS, 1000 * 60)//连接超时时间设置为 60 秒
+//                    .option(ChannelOption.SO_BACKLOG, 128)//务端接受连接的队列长度 默认128
+//                    .option(ChannelOption.RCVBUF_ALLOCATOR, new NettyRecvByteBufAllocator(1024 * 1024))//用于Channel分配接受Buffer的分配器 默认AdaptiveRecvByteBufAllocator.DEFAULT
+                    .option(ChannelOption.WRITE_BUFFER_WATER_MARK, new WriteBufferWaterMark(1024 * 1024, 1024 * 1024 * 2))
+                    .handler(new NettyClientPermeateClientRealFilter())
+
+            ;
+
+
+            bootstrap.connect(clientTargetIp, clientTargetPort).addListener((ChannelFutureListener) future -> {
+                if (future.isSuccess()) {
+                    // 客户端链接真实服务成功 设置自动读写false 等待访客连接成功后设置成true
+                    Channel realChannel = future.channel();
+                    realChannel.config().setOption(ChannelOption.AUTO_READ, false);
+
+                    log.info("访客通过 客户端:【{}】,绑定本地服务,IP:{},端口:{} 新建通道成功", clientId, clientTargetIp, clientTargetPort);
+                    // 客户端真实通道
+                    NettyRealIdContext.pushReal(realChannel, visitorId);
+                    // 绑定访客ID到当前真实通道属性
+                    ChannelAttributeKeyUtils.buildVisitorId(realChannel, visitorId);
+                    ChannelAttributeKeyUtils.buildClientId(realChannel, clientId);
+                    ChannelAttributeKeyUtils.buildVisitorPort(realChannel, visitorPort);
+                    // 通知服务端访客连接成功
+
+
+
+                    // 是否等 服务端相应访客通道已经可以自动读写
+//                    realChannel.config().setOption(ChannelOption.AUTO_READ, true);
+
+                } else {
+                    log.error("客户：【{}】,无法连接当前网络内的目标IP：【{}】,目标端口:【{}】", clientId, clientTargetIp, clientTargetPort);
+                }
+            });
+        } catch (Exception e) {
+            e.printStackTrace();
+        }
+    }
+
+
+
+}

wu-lazy-cloud-heartbeat-client/src/main/java/org/framework/lazy/cloud/network/heartbeat/client/netty/socket/NettyClientPermeateClientVisitorSocket.java

@@ -0,0 +1,274 @@
+package org.framework.lazy.cloud.network.heartbeat.client.netty.socket;
+
+import io.netty.bootstrap.ServerBootstrap;
+import io.netty.channel.*;
+import io.netty.channel.nio.NioEventLoopGroup;
+import io.netty.channel.socket.nio.NioServerSocketChannel;
+import lombok.Getter;
+import lombok.extern.slf4j.Slf4j;
+import org.framework.lazy.cloud.network.heartbeat.client.config.NettyClientProperties;
+import org.framework.lazy.cloud.network.heartbeat.client.netty.InternalNetworkPermeateServerVisitor;
+import org.framework.lazy.cloud.network.heartbeat.client.netty.filter.NettyClientPermeateClientVisitorFilter;
+import org.framework.lazy.cloud.network.heartbeat.client.netty.filter.NettyClientPermeateServerVisitorFilter;
+import org.framework.lazy.cloud.network.heartbeat.common.NettyClientVisitorContext;
+import org.framework.lazy.cloud.network.heartbeat.common.NettyVisitorPortContext;
+import org.framework.lazy.cloud.network.heartbeat.common.adapter.ChannelFlowAdapter;
+import org.framework.lazy.cloud.network.heartbeat.common.advanced.HandleChannelTypeAdvanced;
+import org.framework.lazy.cloud.network.heartbeat.common.socket.PermeateVisitorSocket;
+
+import java.util.List;
+
+/**
+ * 内网穿透 客户端渗透客户端通道
+ *
+ * @see NettyVisitorPortContext
+ * @see NettyClientVisitorContext
+ */
+@Slf4j
+public class NettyClientPermeateClientVisitorSocket implements PermeateVisitorSocket {
+    private final EventLoopGroup bossGroup = new NioEventLoopGroup();
+    private final EventLoopGroup workerGroup = new NioEventLoopGroup();
+    private final NettyClientPermeateClientVisitorFilter nettyClientPermeateClientVisitorFilter;
+    @Getter
+    private final String clientId;
+    @Getter
+    private final int visitorPort;
+
+    public NettyClientPermeateClientVisitorSocket(NettyClientPermeateClientVisitorFilter nettyClientPermeateClientVisitorFilter, String clientId, int visitorPort) {
+        this.nettyClientPermeateClientVisitorFilter = nettyClientPermeateClientVisitorFilter;
+        this.clientId = clientId;
+        this.visitorPort = visitorPort;
+    }
+
+    /**
+     * 启动客户端本地端口渗透到服务端端口
+     *
+     */
+    @Override
+    public void start()  {
+
+        Channel visitor = NettyVisitorPortContext.getVisitorChannel(visitorPort);
+        if (visitor == null) {
+            ServerBootstrap bootstrap = new ServerBootstrap();
+            bootstrap
+                    .group(bossGroup, workerGroup)
+                    .channel(NioServerSocketChannel.class)
+
+
+                    // 设置读缓冲区为2M
+                    .childOption(ChannelOption.SO_RCVBUF, 2048 * 1024)
+                    // 设置写缓冲区为1M
+                    .childOption(ChannelOption.SO_SNDBUF, 1024 * 1024)
+
+
+                    .childOption(ChannelOption.SO_KEEPALIVE, true)
+//                    .childOption(ChannelOption.TCP_NODELAY, false)
+                    .childOption(ChannelOption.CONNECT_TIMEOUT_MILLIS, 1000 * 60)//连接超时时间设置为 60 秒
+//                    .childOption(ChannelOption.RCVBUF_ALLOCATOR, new NettyRecvByteBufAllocator(1024 * 1024))//用于Channel分配接受Buffer的分配器 默认 AdaptiveRecvByteBufAllocator.DEFAULT
+                    .childOption(ChannelOption.WRITE_BUFFER_WATER_MARK, new WriteBufferWaterMark(1024 * 1024, 1024 * 1024 * 2))
+
+
+                    .childHandler(nettyClientPermeateClientVisitorFilter);
+
+            try {
+                 bootstrap.bind(visitorPort).sync().addListener((ChannelFutureListener) future -> {
+                    if (future.isSuccess()) {
+                        // 这里时异步处理
+                        log.info("客户端:[{}]访客端口:[{}] 开启", clientId, visitorPort);
+                        NettyVisitorPortContext.pushVisitorChannel(visitorPort, future.channel());
+
+                    } else {
+                        log.error("客户端:[{}]访客端口:[{}]绑定失败", clientId, visitorPort);
+                    }
+                });
+                NettyVisitorPortContext.pushVisitorSocket(visitorPort, this);
+            } catch (InterruptedException e) {
+                throw new RuntimeException(e);
+            }
+        } else {
+            log.warn("客户端渗透服务端:[{}]访客端口:[{}] 重复启动", clientId, visitorPort);
+        }
+
+    }
+    @Override
+    public void close()  {
+        if (!bossGroup.isShutdown()) {
+            bossGroup.shutdownGracefully();
+        }
+        if (!workerGroup.isShutdown()) {
+            workerGroup.shutdownGracefully();
+        }
+        Channel visitor = NettyVisitorPortContext.getVisitorChannel(visitorPort);
+        if (visitor != null) {
+
+            // close channel
+            visitor.close();
+            // remove visitor
+            NettyVisitorPortContext.removeVisitorChannel(visitorPort);
+            // remove client this
+            NettyVisitorPortContext.removeVisitorSocket(visitorPort);
+            log.warn("关闭客户端 :【{}】 访客户端口:【{}】", clientId, visitorPort);
+        } else {
+            log.warn("关闭访客端口失败 未找到客户端通道 客户端 :【{}】 访客户端口:【{}】", clientId, visitorPort);
+        }
+    }
+
+
+    public static final class NettyVisitorSocketBuilder {
+
+        /**
+         * 客户端ID
+         */
+        private String clientId;
+
+        /**
+         * 客户端目标地址
+         */
+        private String clientTargetIp;
+
+        /**
+         * 客户端目标端口
+         */
+        private Integer clientTargetPort;
+
+
+        /**
+         * 访问端口
+         */
+        private Integer visitorPort;
+        /**
+         * 访客ID
+         */
+        private String visitorId;
+
+        /**
+         * 流量适配器
+         */
+        private ChannelFlowAdapter channelFlowAdapter;
+        /**
+         * 服务端地址信息
+         */
+        private NettyClientProperties nettyClientProperties;
+
+        /**
+         * 处理器
+         */
+        private List<HandleChannelTypeAdvanced> handleChannelTypeAdvancedList;
+
+        public static NettyVisitorSocketBuilder builder() {
+            return new NettyVisitorSocketBuilder();
+        }
+
+        /**
+         * 填充客户端
+         *
+         * @param clientId 客户端
+         * @return 返回当前对象
+         */
+        public NettyVisitorSocketBuilder builderClientId(String clientId) {
+            this.clientId = clientId;
+            return this;
+        }
+
+        /**
+         * 绑定客户端目标IP
+         *
+         * @param clientTargetIp 客户端目标IP
+         * @return 当前对象
+         */
+        public NettyVisitorSocketBuilder builderClientTargetIp(String clientTargetIp) {
+            this.clientTargetIp = clientTargetIp;
+            return this;
+        }
+
+        /**
+         * 绑定客户端目标端口
+         *
+         * @param clientTargetPort 客户端目标端口
+         * @return 当前对象
+         */
+        public NettyVisitorSocketBuilder builderClientTargetPort(Integer clientTargetPort) {
+            this.clientTargetPort = clientTargetPort;
+            return this;
+        }
+
+        /**
+         * 绑定访客端口
+         *
+         * @param visitorPort 访客端口
+         * @return 当前对象
+         */
+        public NettyVisitorSocketBuilder builderVisitorPort(Integer visitorPort) {
+            this.visitorPort = visitorPort;
+            return this;
+        }
+
+        /**
+         * 绑定流量适配器
+         *
+         * @param channelFlowAdapter 流量适配器
+         * @return 当前对象
+         */
+        public NettyVisitorSocketBuilder builderChannelFlowAdapter(ChannelFlowAdapter channelFlowAdapter) {
+            this.channelFlowAdapter = channelFlowAdapter;
+            return this;
+        }        /**
+         * 绑定流量适配器
+         *
+         * @param handleChannelTypeAdvancedList 流量适配器
+         * @return 当前对象
+         */
+        public NettyVisitorSocketBuilder builderHandleChannelTypeAdvancedList(List<HandleChannelTypeAdvanced> handleChannelTypeAdvancedList) {
+            this.handleChannelTypeAdvancedList = handleChannelTypeAdvancedList;
+            return this;
+        }
+        /**
+         * 服务端地址信息
+         *
+         * @param nettyClientProperties 客户服务端地址配置属性
+         * @return 返回当前对象
+         */
+        public NettyVisitorSocketBuilder builderNettyClientProperties(NettyClientProperties nettyClientProperties) {
+            this.nettyClientProperties = nettyClientProperties;
+            return this;
+        }
+
+        /**
+         * 绑定访客ID
+         *
+         * @param visitorId 访客ID
+         * @return 当前对象
+         */
+        public NettyVisitorSocketBuilder builderVisitorId(String visitorId) {
+            this.visitorId = visitorId;
+            return this;
+        }
+
+        public NettyClientPermeateClientVisitorSocket build() {
+            if (clientTargetIp == null) {
+                throw new IllegalArgumentException("clientTargetIp must not null");
+            }
+            if (clientTargetPort == null) {
+                throw new IllegalArgumentException("clientTargetPort must not null");
+            }
+            if (visitorPort == null) {
+                throw new IllegalArgumentException("visitorPort must not null");
+            }
+            InternalNetworkPermeateServerVisitor internalNetworkPermeateServerVisitor = new InternalNetworkPermeateServerVisitor();
+
+            internalNetworkPermeateServerVisitor.setTargetIp(clientTargetIp);
+            internalNetworkPermeateServerVisitor.setTargetPort(clientTargetPort);
+            internalNetworkPermeateServerVisitor.setVisitorPort(visitorPort);
+            internalNetworkPermeateServerVisitor.setNettyClientProperties(nettyClientProperties);
+            internalNetworkPermeateServerVisitor.setChannelFlowAdapter(channelFlowAdapter);
+            internalNetworkPermeateServerVisitor.setHandleChannelTypeAdvancedList(handleChannelTypeAdvancedList);
+
+
+            NettyClientPermeateClientVisitorFilter visitorFilter = new NettyClientPermeateClientVisitorFilter(internalNetworkPermeateServerVisitor);
+            return new NettyClientPermeateClientVisitorSocket(visitorFilter, clientId, visitorPort);
+        }
+
+
+    }
+
+}

wu-lazy-cloud-heartbeat-client/src/main/java/org/framework/lazy/cloud/network/heartbeat/client/netty/socket/NettyClientTransferClientSocket.java

@@ -0,0 +1,113 @@
+package org.framework.lazy.cloud.network.heartbeat.client.netty.socket;
+
+
+import io.netty.bootstrap.Bootstrap;
+import io.netty.channel.*;
+import io.netty.channel.nio.NioEventLoopGroup;
+import io.netty.channel.socket.nio.NioSocketChannel;
+import lombok.extern.slf4j.Slf4j;
+import org.framework.lazy.cloud.network.heartbeat.client.config.NettyClientProperties;
+import org.framework.lazy.cloud.network.heartbeat.client.netty.InternalNetworkPermeateServerVisitor;
+import org.framework.lazy.cloud.network.heartbeat.client.netty.filter.NettyClientPermeateTransferFilter;
+import org.framework.lazy.cloud.network.heartbeat.common.MessageType;
+import org.framework.lazy.cloud.network.heartbeat.common.NettyCommunicationIdContext;
+import org.framework.lazy.cloud.network.heartbeat.common.NettyProxyMsg;
+import org.framework.lazy.cloud.network.heartbeat.common.NettyRealIdContext;
+import org.framework.lazy.cloud.network.heartbeat.common.adapter.ChannelTypeAdapter;
+import org.framework.lazy.cloud.network.heartbeat.common.utils.ChannelAttributeKeyUtils;
+
+import java.util.concurrent.TimeUnit;
+
+/**
+ * 客户端渗透服务端传输通道
+ */
+@Slf4j
+public class NettyClientTransferClientSocket {
+    static EventLoopGroup eventLoopGroup = new NioEventLoopGroup();
+
+    /**
+     * 连接服务端通信通道
+     */
+    public static void buildTransferServer(InternalNetworkPermeateServerVisitor internalNetworkPermeateServerVisitor) {
+        newTransferConnect2Server(internalNetworkPermeateServerVisitor);
+    }
+
+
+    /**
+     * 连接服务端通信通道
+     * <p>
+     * internalNetworkPermeateServerVisitor
+     */
+    protected static void newTransferConnect2Server(InternalNetworkPermeateServerVisitor internalNetworkPermeateServerVisitor) {
+
+        Bootstrap bootstrap = new Bootstrap();
+        bootstrap.group(eventLoopGroup)
+                .channel(NioSocketChannel.class)
+                .option(ChannelOption.SO_KEEPALIVE, true)
+                // 设置读缓冲区为2M
+                .option(ChannelOption.SO_RCVBUF, 2048 * 1024)
+                // 设置写缓冲区为1M
+                .option(ChannelOption.SO_SNDBUF, 1024 * 1024)
+//                .option(ChannelOption.TCP_NODELAY, false)
+                .option(ChannelOption.CONNECT_TIMEOUT_MILLIS, 1000 * 60)//连接超时时间设置为 60 秒
+//                .option(ChannelOption.SO_BACKLOG, 256)//务端接受连接的队列长度 默认128
+//                .option(ChannelOption.RCVBUF_ALLOCATOR, new NettyRecvByteBufAllocator(1024 * 1024))//用于Channel分配接受Buffer的分配器 默认AdaptiveRecvByteBufAllocator.DEFAULT
+
+                .option(ChannelOption.WRITE_BUFFER_WATER_MARK, new WriteBufferWaterMark(1024 * 1024, 1024 * 1024 * 2))
+
+                .handler(new NettyClientPermeateTransferFilter(new ChannelTypeAdapter(internalNetworkPermeateServerVisitor.getHandleChannelTypeAdvancedList())))
+        ;
+        NettyClientProperties nettyClientProperties = internalNetworkPermeateServerVisitor.getNettyClientProperties();
+        String inetHost = nettyClientProperties.getInetHost();
+        int inetPort = nettyClientProperties.getInetPort();
+        // local client id
+
+        String clientId = nettyClientProperties.getClientId();
+
+        String targetIp = internalNetworkPermeateServerVisitor.getTargetIp();
+        Integer targetPort = internalNetworkPermeateServerVisitor.getTargetPort();
+
+        String visitorId = internalNetworkPermeateServerVisitor.getVisitorId();
+        Integer visitorPort = internalNetworkPermeateServerVisitor.getVisitorPort();
+
+        // 客户端新建访客通道 连接服务端IP:{},连接服务端端口:{}
+        log.info("Client creates a new visitor channel to connect to server IP: {}, connecting to server port: {}", inetHost, inetPort);
+        ChannelFuture future = bootstrap.connect(inetHost, inetPort);
+
+        // 使用的客户端ID:{}
+        log.info("Client ID used: {}", clientId);
+        future.addListener((ChannelFutureListener) futureListener -> {
+            Channel channel = futureListener.channel();
+            if (futureListener.isSuccess()) {
+
+                NettyProxyMsg myMsg = new NettyProxyMsg();
+                myMsg.setType(MessageType.REPORT_CLIENT_TRANSFER_CLIENT_PERMEATE_CHANNEL_CONNECTION_SUCCESSFUL);
+                // other clientId
+                myMsg.setClientId(clientId);
+                myMsg.setVisitorPort(visitorPort);
+                myMsg.setClientTargetIp(targetIp);
+                myMsg.setClientTargetPort(targetPort);
+
+                myMsg.setVisitorId(visitorId);
+                channel.writeAndFlush(myMsg);
+                // 绑定客户端真实通信通道
+                NettyCommunicationIdContext.pushVisitor(channel, visitorId);
+                ChannelAttributeKeyUtils.buildVisitorId(channel, visitorId);
+                ChannelAttributeKeyUtils.buildClientId(channel, clientId);
+                // 传输通道打开后自动读取
+                Channel visitor = NettyRealIdContext.getReal(visitorId);
+
+                ChannelAttributeKeyUtils.buildNextChannel(visitor, channel);
+                ChannelAttributeKeyUtils.buildNextChannel(channel, visitor);
+
+
+            } else {
+                log.info("每隔2s重连....");
+                // 离线
+                channel.eventLoop().schedule(() -> {
+                    newTransferConnect2Server(internalNetworkPermeateServerVisitor);
+                }, 2, TimeUnit.SECONDS);
+            }
+        });
+    }
+}

wu-lazy-cloud-heartbeat-client/src/main/java/org/framework/lazy/cloud/network/heartbeat/client/netty/socket/NettyServerPermeateClientRealSocket.java

@@ -7,7 +7,7 @@ import io.netty.channel.nio.NioEventLoopGroup;
 import io.netty.channel.socket.nio.NioSocketChannel;
 import lombok.extern.slf4j.Slf4j;
 import org.framework.lazy.cloud.network.heartbeat.client.config.NettyClientProperties;
-import org.framework.lazy.cloud.network.heartbeat.client.netty.filter.NettyClientRealFilter;
+import org.framework.lazy.cloud.network.heartbeat.client.netty.filter.NettyServerPermeateClientRealFilter;
 import org.framework.lazy.cloud.network.heartbeat.client.netty.filter.NettyClientVisitorRealFilter;
 import org.framework.lazy.cloud.network.heartbeat.common.*;
 import org.framework.lazy.cloud.network.heartbeat.common.adapter.ChannelTypeAdapter;
@@ -21,7 +21,7 @@ import java.util.concurrent.TimeUnit;
  * 客户端连接真实服务
  */
 @Slf4j
-public class NettyClientRealSocket {
+public class NettyServerPermeateClientRealSocket {
     static EventLoopGroup eventLoopGroup = new NioEventLoopGroup();
 
     /**
@@ -62,7 +62,7 @@ public class NettyClientRealSocket {
 //                    .option(ChannelOption.SO_BACKLOG, 128)//务端接受连接的队列长度 默认128
 //                    .option(ChannelOption.RCVBUF_ALLOCATOR, new NettyRecvByteBufAllocator(1024 * 1024))//用于Channel分配接受Buffer的分配器 默认AdaptiveRecvByteBufAllocator.DEFAULT
                     .option(ChannelOption.WRITE_BUFFER_WATER_MARK, new WriteBufferWaterMark(1024 * 1024, 1024 * 1024 * 2))
-                    .handler(new NettyClientRealFilter())
+                    .handler(new NettyServerPermeateClientRealFilter())
 
             ;
 

wu-lazy-cloud-heartbeat-common/src/main/java/org/framework/lazy/cloud/network/heartbeat/common/MessageType.java

@@ -4,8 +4,6 @@ import org.framework.lazy.cloud.network.heartbeat.common.advanced.AbstractHandle
 import org.framework.lazy.cloud.network.heartbeat.common.advanced.client.*;
 import org.framework.lazy.cloud.network.heartbeat.common.advanced.server.*;
 import org.framework.lazy.cloud.network.heartbeat.common.enums.MessageTypeEnums;
-import org.framework.lazy.cloud.network.heartbeat.common.advanced.client.*;
-import org.framework.lazy.cloud.network.heartbeat.common.advanced.server.*;
 
 /**
  * @see MessageTypeEnums
@@ -119,6 +117,15 @@ public class MessageType {
      * @see AbstractHandleReportClientPermeateServerCloseTypeAdvanced
      */
     public static final byte REPORT_CLIENT_PERMEATE_SERVER_CLOSE = 0X14;
+
+    /**
+     * 上报 客户端渗透客户端数据传输通道连接成功
+     *
+     * @see MessageTypeEnums#REPORT_CLIENT_TRANSFER_CLIENT_PERMEATE_CHANNEL_CONNECTION_SUCCESSFUL
+     * @see AbstractHandleReportClientTransferClientPermeateChannelConnectionSuccessfulTypeAdvanced
+     * @see MessageType#DISTRIBUTE_CLIENT_TRANSFER_CLIENT_PERMEATE_CHANNEL_CONNECTION_SUCCESSFUL
+     */
+    public static final byte REPORT_CLIENT_TRANSFER_CLIENT_PERMEATE_CHANNEL_CONNECTION_SUCCESSFUL = 0X15;
     /**
      * 下发 客户端接收连接成功通知
      *
@@ -227,4 +234,13 @@ public class MessageType {
      * @see AbstractHandleDistributeClientPermeateServerCloseTypeAdvanced
      */
     public static final byte DISTRIBUTE_CLIENT_PERMEATE_SERVER_CLOSE = -0X14;
+
+    /**
+     * 下发 客户端渗透客户端数据传输通道连接成功
+     *
+     * @see MessageTypeEnums#DISTRIBUTE_CLIENT_TRANSFER_CLIENT_PERMEATE_CHANNEL_CONNECTION_SUCCESSFUL
+     * @see AbstractHandleDistributeClientTransferClientPermeateChannelConnectionSuccessfulTypeAdvanced
+     * @see MessageType#REPORT_CLIENT_TRANSFER_CLIENT_PERMEATE_CHANNEL_CONNECTION_SUCCESSFUL
+     */
+    public static final byte DISTRIBUTE_CLIENT_TRANSFER_CLIENT_PERMEATE_CHANNEL_CONNECTION_SUCCESSFUL = -0X15;
 }

wu-lazy-cloud-heartbeat-common/src/main/java/org/framework/lazy/cloud/network/heartbeat/common/advanced/client/AbstractHandleDistributeClientTransferClientPermeateChannelConnectionSuccessfulTypeAdvanced.java

@@ -0,0 +1,28 @@
+package org.framework.lazy.cloud.network.heartbeat.common.advanced.client;
+
+
+import org.framework.lazy.cloud.network.heartbeat.common.NettyProxyMsg;
+import org.framework.lazy.cloud.network.heartbeat.common.advanced.AbstractHandleChannelTypeAdvanced;
+import org.framework.lazy.cloud.network.heartbeat.common.advanced.HandleChannelTypeAdvanced;
+import org.framework.lazy.cloud.network.heartbeat.common.enums.MessageTypeEnums;
+
+
+/**
+ * 下发 客户端渗透客户端数据传输通道连接成功
+ *
+ * @see MessageTypeEnums#DISTRIBUTE_CLIENT_TRANSFER_CLIENT_PERMEATE_CHANNEL_CONNECTION_SUCCESSFUL
+ */
+public abstract class AbstractHandleDistributeClientTransferClientPermeateChannelConnectionSuccessfulTypeAdvanced<MSG> extends AbstractHandleChannelTypeAdvanced<NettyProxyMsg> implements HandleChannelTypeAdvanced {
+
+
+    /**
+     * 是否支持当前类型
+     *
+     * @param msg 通道数据
+     * @return 布尔类型 是、否
+     */
+    @Override
+    public boolean doSupport(NettyProxyMsg msg) {
+        return MessageTypeEnums.DISTRIBUTE_CLIENT_TRANSFER_CLIENT_PERMEATE_CHANNEL_CONNECTION_SUCCESSFUL.getTypeByte() == msg.getType();
+    }
+}

wu-lazy-cloud-heartbeat-common/src/main/java/org/framework/lazy/cloud/network/heartbeat/common/advanced/server/AbstractHandleReportClientTransferClientPermeateChannelConnectionSuccessfulTypeAdvanced.java

@@ -0,0 +1,27 @@
+package org.framework.lazy.cloud.network.heartbeat.common.advanced.server;
+
+
+import org.framework.lazy.cloud.network.heartbeat.common.NettyProxyMsg;
+import org.framework.lazy.cloud.network.heartbeat.common.advanced.AbstractHandleChannelTypeAdvanced;
+import org.framework.lazy.cloud.network.heartbeat.common.advanced.HandleChannelTypeAdvanced;
+import org.framework.lazy.cloud.network.heartbeat.common.enums.MessageTypeEnums;
+
+
+/**
+ * 上报 客户端渗透客户端数据传输通道连接成功
+ * REPORT_CLIENT_TRANSFER_CLIENT_PERMEATE_CHANNEL_CONNECTION_SUCCESSFUL
+ */
+public abstract class AbstractHandleReportClientTransferClientPermeateChannelConnectionSuccessfulTypeAdvanced<MSG> extends AbstractHandleChannelTypeAdvanced<NettyProxyMsg> implements HandleChannelTypeAdvanced {
+
+
+    /**
+     * 是否支持当前类型
+     *
+     * @param msg 通道数据
+     * @return 布尔类型 是、否
+     */
+    @Override
+    public boolean doSupport(NettyProxyMsg msg) {
+        return MessageTypeEnums.REPORT_CLIENT_TRANSFER_CLIENT_PERMEATE_CHANNEL_CONNECTION_SUCCESSFUL.getTypeByte() == msg.getType();
+    }
+}

wu-lazy-cloud-heartbeat-common/src/main/java/org/framework/lazy/cloud/network/heartbeat/common/enums/MessageTypeEnums.java

@@ -71,6 +71,11 @@ public enum MessageTypeEnums {
      * @see AbstractHandleReportClientPermeateServerCloseTypeAdvanced
      */
     REPORT_CLIENT_PERMEATE_SERVER_CLOSE(MessageType.REPORT_CLIENT_PERMEATE_SERVER_CLOSE, "上报 客户端渗透服务端init close 信息"),
+    /**
+     * 上报 客户端渗透客户端数据传输通道连接成功
+     * @see AbstractHandleReportClientTransferClientPermeateChannelConnectionSuccessfulTypeAdvanced
+     */
+    REPORT_CLIENT_TRANSFER_CLIENT_PERMEATE_CHANNEL_CONNECTION_SUCCESSFUL(MessageType.REPORT_CLIENT_TRANSFER_CLIENT_PERMEATE_CHANNEL_CONNECTION_SUCCESSFUL, "上报 客户端渗透客户端数据传输通道连接成功"),
     /**
      * @see AbstractHandleDistributeConnectSuccessNotificationTypeAdvancedHandle
      */
@@ -131,6 +136,10 @@ public enum MessageTypeEnums {
      * @see AbstractHandleDistributeClientPermeateServerCloseTypeAdvanced
      */
     DISTRIBUTE_CLIENT_PERMEATE_SERVER_CLOSE(MessageType.DISTRIBUTE_CLIENT_PERMEATE_SERVER_CLOSE, "下发 客户端渗透服务端init close信息"),
+    /**
+     * @see AbstractHandleDistributeClientTransferClientPermeateChannelConnectionSuccessfulTypeAdvanced
+     */
+    DISTRIBUTE_CLIENT_TRANSFER_CLIENT_PERMEATE_CHANNEL_CONNECTION_SUCCESSFUL(MessageType.DISTRIBUTE_CLIENT_TRANSFER_CLIENT_PERMEATE_CHANNEL_CONNECTION_SUCCESSFUL, "下发 客户端渗透客户端数据传输通道连接成功"),
     ;
 
     private final byte typeByte;

wu-lazy-cloud-heartbeat-server/src/main/java/org/framework/lazy/cloud/network/heartbeat/server/netty/advanced/ServerHandleReportClientTransferClientPermeateChannelConnectionSuccessfulTypeAdvanced.java

@@ -0,0 +1,48 @@
+package org.framework.lazy.cloud.network.heartbeat.server.netty.advanced;
+
+import io.netty.channel.Channel;
+import org.framework.lazy.cloud.network.heartbeat.common.ChannelContext;
+import org.framework.lazy.cloud.network.heartbeat.common.MessageType;
+import org.framework.lazy.cloud.network.heartbeat.common.NettyProxyMsg;
+import org.framework.lazy.cloud.network.heartbeat.common.advanced.server.AbstractHandleReportClientTransferClientPermeateChannelConnectionSuccessfulTypeAdvanced;
+import org.framework.lazy.cloud.network.heartbeat.common.advanced.server.AbstractHandleReportClientTransferServerPermeateChannelConnectionSuccessfulTypeAdvanced;
+import org.framework.lazy.cloud.network.heartbeat.server.netty.socket.NettyClientPermeateServerConnectRealSocket;
+import org.springframework.stereotype.Component;
+
+/**
+ * 上报 客户端渗透客户端数据传输通道连接成功
+ */
+@Component
+public class ServerHandleReportClientTransferClientPermeateChannelConnectionSuccessfulTypeAdvanced extends AbstractHandleReportClientTransferClientPermeateChannelConnectionSuccessfulTypeAdvanced<NettyProxyMsg> {
+    /**
+     * 处理当前数据
+     *
+     * @param channel       当前通道
+     * @param nettyProxyMsg 通道数据
+     */
+    @Override
+    protected void doHandler(Channel channel, NettyProxyMsg nettyProxyMsg) {
+        // 创建目标地址连接
+        byte[] msgVisitorId = nettyProxyMsg.getVisitorId();
+        byte[] msgVisitorPort = nettyProxyMsg.getVisitorPort();
+        byte[] msgClientTargetIp = nettyProxyMsg.getClientTargetIp();
+        byte[] msgClientTargetPort = nettyProxyMsg.getClientTargetPort();
+        byte[] clientId = nettyProxyMsg.getClientId();
+        //
+        ChannelContext.ClientChannel clientChannel = ChannelContext.get(clientId);
+
+        NettyProxyMsg clientConnectTagetNettyProxyMsg = new NettyProxyMsg();
+        clientConnectTagetNettyProxyMsg.setVisitorId(msgVisitorId);
+        clientConnectTagetNettyProxyMsg.setVisitorPort(msgVisitorPort);
+        clientConnectTagetNettyProxyMsg.setClientTargetIp(msgClientTargetIp);
+        clientConnectTagetNettyProxyMsg.setClientTargetPort(msgClientTargetPort);
+        clientConnectTagetNettyProxyMsg.setClientId(clientId);
+        clientConnectTagetNettyProxyMsg.setType(MessageType.DISTRIBUTE_CLIENT_TRANSFER_CLIENT_PERMEATE_CHANNEL_CONNECTION_SUCCESSFUL);
+        if (clientChannel != null) {
+            clientChannel.getChannel().writeAndFlush(clientConnectTagetNettyProxyMsg);
+        }
+
+
+
+    }
+}