From b7f099d3a46d15420ab7f149d1cf77c55799eac7 Mon Sep 17 00:00:00 2001 From: wujiawei <12345678> Date: Sat, 3 May 2025 22:36:21 +0800 Subject: [PATCH] =?UTF-8?q?=E3=80=90fix=E3=80=91=E6=96=B0=E5=A2=9E?= =?UTF-8?q?=E6=9C=AC=E5=9C=B0socks=E4=BB=A3=E7=90=86=E6=9C=8D=E5=8A=A1?= =?UTF-8?q?=E7=AB=AF?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- .../config/ClientAutoConfiguration.java | 29 +++++ ...NettyHttpClientProxyClientProxySocket.java | 3 +- .../socks/NettySocksClientProxyServer.java | 48 +++++++++ ...yServerConnectionTransferFailAdvanced.java | 26 +++++ ...rConnectionTransferSuccessfulAdvanced.java | 51 +++++++++ ...lientProxyServerTransferCloseAdvanced.java | 25 +++++ ...erverTransferTransferResponseAdvanced.java | 38 +++++++ ...leSocketClientProxyServerTypeAdvanced.java | 75 +++++++++++++ ...ySocksClientProxyServerTransferFilter.java | 43 ++++++++ ...lientProxyServerVisitorInboundHandler.java | 73 +++++++++++++ ...SocksClientProxyServerTransferHandler.java | 70 ++++++++++++ .../NettySocksClientProxyServerSocket.java | 98 +++++++++++++++++ ...leSocketClientProxyServerTypeAdvanced.java | 21 ++++ ...verConnectionTransferFailTypeAdvanced.java | 21 ++++ ...ConnectionTransferSuccessTypeAdvanced.java | 21 ++++ ...tProxyServerTransferCloseTypeAdvanced.java | 21 ++++ ...oxyServerTransferResponseTypeAdvanced.java | 21 ++++ ...yServerConnectionTransferTypeAdvanced.java | 21 ++++ ...tProxyServerTransferCloseTypeAdvanced.java | 21 ++++ ...roxyServerTransferRequestTypeAdvanced.java | 21 ++++ .../common/constant/ProxyMessageType.java | 69 +++++++++++- .../common/enums/ProxyMessageTypeEnums.java | 82 +++++++++++++- .../utils/ChannelAttributeKeyUtils.java | 20 ++++ .../config/ServerAutoConfiguration.java | 19 ++++ ...roxyServerConnectTransferTypeAdvanced.java | 101 ++++++++++++++++++ ...tProxyServerTransferCloseTypeAdvanced.java | 36 +++++++ ...roxyServerTransferRequestTypeAdvanced.java | 48 +++++++++ ...ettySocksClientProxyServerRealHandler.java | 68 ++++++++++++ 28 files changed, 1185 insertions(+), 5 deletions(-) create mode 100644 wu-lazy-cloud-heartbeat-client/src/main/java/org/framework/lazy/cloud/network/heartbeat/client/netty/proxy/socks/NettySocksClientProxyServer.java create mode 100644 wu-lazy-cloud-heartbeat-client/src/main/java/org/framework/lazy/cloud/network/heartbeat/client/netty/proxy/socks/advanced/ClientHandleDistributeSocksClientProxyServerConnectionTransferFailAdvanced.java create mode 100644 wu-lazy-cloud-heartbeat-client/src/main/java/org/framework/lazy/cloud/network/heartbeat/client/netty/proxy/socks/advanced/ClientHandleDistributeSocksClientProxyServerConnectionTransferSuccessfulAdvanced.java create mode 100644 wu-lazy-cloud-heartbeat-client/src/main/java/org/framework/lazy/cloud/network/heartbeat/client/netty/proxy/socks/advanced/ClientHandleDistributeSocksClientProxyServerTransferCloseAdvanced.java create mode 100644 wu-lazy-cloud-heartbeat-client/src/main/java/org/framework/lazy/cloud/network/heartbeat/client/netty/proxy/socks/advanced/ClientHandleDistributeSocksClientProxyServerTransferTransferResponseAdvanced.java create mode 100644 wu-lazy-cloud-heartbeat-client/src/main/java/org/framework/lazy/cloud/network/heartbeat/client/netty/proxy/socks/advanced/NettySocketProtocolHandleSocketClientProxyServerTypeAdvanced.java create mode 100644 wu-lazy-cloud-heartbeat-client/src/main/java/org/framework/lazy/cloud/network/heartbeat/client/netty/proxy/socks/filter/NettySocksClientProxyServerTransferFilter.java create mode 100644 wu-lazy-cloud-heartbeat-client/src/main/java/org/framework/lazy/cloud/network/heartbeat/client/netty/proxy/socks/handler/NettyClientProxyServerVisitorInboundHandler.java create mode 100644 wu-lazy-cloud-heartbeat-client/src/main/java/org/framework/lazy/cloud/network/heartbeat/client/netty/proxy/socks/handler/NettySocksClientProxyServerTransferHandler.java create mode 100644 wu-lazy-cloud-heartbeat-client/src/main/java/org/framework/lazy/cloud/network/heartbeat/client/netty/proxy/socks/socket/NettySocksClientProxyServerSocket.java create mode 100644 wu-lazy-cloud-heartbeat-common/src/main/java/org/framework/lazy/cloud/network/heartbeat/common/advanced/proxy/socket/client/AbstractHandleSocketClientProxyServerTypeAdvanced.java create mode 100644 wu-lazy-cloud-heartbeat-common/src/main/java/org/framework/lazy/cloud/network/heartbeat/common/advanced/proxy/socket/client/AbstractHandleSocksDistributeClientProxyServerConnectionTransferFailTypeAdvanced.java create mode 100644 wu-lazy-cloud-heartbeat-common/src/main/java/org/framework/lazy/cloud/network/heartbeat/common/advanced/proxy/socket/client/AbstractHandleSocksDistributeClientProxyServerConnectionTransferSuccessTypeAdvanced.java create mode 100644 wu-lazy-cloud-heartbeat-common/src/main/java/org/framework/lazy/cloud/network/heartbeat/common/advanced/proxy/socket/client/AbstractHandleSocksDistributeClientProxyServerTransferCloseTypeAdvanced.java create mode 100644 wu-lazy-cloud-heartbeat-common/src/main/java/org/framework/lazy/cloud/network/heartbeat/common/advanced/proxy/socket/client/AbstractHandleSocksDistributeClientProxyServerTransferResponseTypeAdvanced.java create mode 100644 wu-lazy-cloud-heartbeat-common/src/main/java/org/framework/lazy/cloud/network/heartbeat/common/advanced/proxy/socket/server/AbstractHandleSocksReportClientProxyServerConnectionTransferTypeAdvanced.java create mode 100644 wu-lazy-cloud-heartbeat-common/src/main/java/org/framework/lazy/cloud/network/heartbeat/common/advanced/proxy/socket/server/AbstractHandleSocksReportClientProxyServerTransferCloseTypeAdvanced.java create mode 100644 wu-lazy-cloud-heartbeat-common/src/main/java/org/framework/lazy/cloud/network/heartbeat/common/advanced/proxy/socket/server/AbstractHandleSocksReportClientProxyServerTransferRequestTypeAdvanced.java create mode 100644 wu-lazy-cloud-heartbeat-server/src/main/java/org/framework/lazy/cloud/network/heartbeat/server/netty/proxy/socks/advanced/ServerHandleSocksReportClientProxyServerConnectTransferTypeAdvanced.java create mode 100644 wu-lazy-cloud-heartbeat-server/src/main/java/org/framework/lazy/cloud/network/heartbeat/server/netty/proxy/socks/advanced/ServerHandleSocksReportClientProxyServerTransferCloseTypeAdvanced.java create mode 100644 wu-lazy-cloud-heartbeat-server/src/main/java/org/framework/lazy/cloud/network/heartbeat/server/netty/proxy/socks/advanced/ServerHandleSocksReportClientProxyServerTransferRequestTypeAdvanced.java create mode 100644 wu-lazy-cloud-heartbeat-server/src/main/java/org/framework/lazy/cloud/network/heartbeat/server/netty/proxy/socks/handler/NettySocksClientProxyServerRealHandler.java diff --git a/wu-lazy-cloud-heartbeat-client/src/main/java/org/framework/lazy/cloud/network/heartbeat/client/config/ClientAutoConfiguration.java b/wu-lazy-cloud-heartbeat-client/src/main/java/org/framework/lazy/cloud/network/heartbeat/client/config/ClientAutoConfiguration.java index a4fd4f8..f0a5cfb 100644 --- a/wu-lazy-cloud-heartbeat-client/src/main/java/org/framework/lazy/cloud/network/heartbeat/client/config/ClientAutoConfiguration.java +++ b/wu-lazy-cloud-heartbeat-client/src/main/java/org/framework/lazy/cloud/network/heartbeat/client/config/ClientAutoConfiguration.java @@ -6,6 +6,7 @@ import org.framework.lazy.cloud.network.heartbeat.client.netty.permeate.event.Cl import org.framework.lazy.cloud.network.heartbeat.client.netty.permeate.tcp.advanced.*; import org.framework.lazy.cloud.network.heartbeat.client.netty.permeate.udp.advanced.*; import org.framework.lazy.cloud.network.heartbeat.client.netty.proxy.http.advanced.*; +import org.framework.lazy.cloud.network.heartbeat.client.netty.proxy.socks.advanced.*; import org.springframework.beans.factory.config.BeanDefinition; import org.springframework.boot.autoconfigure.condition.ConditionalOnProperty; import org.springframework.context.annotation.Bean; @@ -383,4 +384,32 @@ public class ClientAutoConfiguration { return new ClientHandleDistributeHttpServerProxyClientTransferRequestAdvanced(); } } + + @Configuration + static class SocksProxyConfiguration { + @Bean + public NettySocketProtocolHandleSocketClientProxyServerTypeAdvanced nettySocketProtocolHandleSocketClientProxyServerTypeAdvanced() { + return new NettySocketProtocolHandleSocketClientProxyServerTypeAdvanced(); + } + + @Bean + public ClientHandleDistributeSocksClientProxyServerConnectionTransferSuccessfulAdvanced clientHandleDistributeSocksClientProxyServerConnectionTransferSuccessfulAdvanced() { + return new ClientHandleDistributeSocksClientProxyServerConnectionTransferSuccessfulAdvanced(); + } + + @Bean + public ClientHandleDistributeSocksClientProxyServerConnectionTransferFailAdvanced clientHandleDistributeSocksClientProxyServerConnectionTransferFailAdvanced() { + return new ClientHandleDistributeSocksClientProxyServerConnectionTransferFailAdvanced(); + } + + @Bean + public ClientHandleDistributeSocksClientProxyServerTransferTransferResponseAdvanced clientHandleDistributeSocksClientProxyServerTransferTransferResponseAdvanced() { + return new ClientHandleDistributeSocksClientProxyServerTransferTransferResponseAdvanced(); + } + + @Bean + public ClientHandleDistributeSocksClientProxyServerTransferCloseAdvanced clientHandleDistributeSocksClientProxyServerTransferCloseAdvanced() { + return new ClientHandleDistributeSocksClientProxyServerTransferCloseAdvanced(); + } + } } diff --git a/wu-lazy-cloud-heartbeat-client/src/main/java/org/framework/lazy/cloud/network/heartbeat/client/netty/proxy/http/socket/NettyHttpClientProxyClientProxySocket.java b/wu-lazy-cloud-heartbeat-client/src/main/java/org/framework/lazy/cloud/network/heartbeat/client/netty/proxy/http/socket/NettyHttpClientProxyClientProxySocket.java index 6f270af..ac084e3 100644 --- a/wu-lazy-cloud-heartbeat-client/src/main/java/org/framework/lazy/cloud/network/heartbeat/client/netty/proxy/http/socket/NettyHttpClientProxyClientProxySocket.java +++ b/wu-lazy-cloud-heartbeat-client/src/main/java/org/framework/lazy/cloud/network/heartbeat/client/netty/proxy/http/socket/NettyHttpClientProxyClientProxySocket.java @@ -12,6 +12,7 @@ import org.framework.lazy.cloud.network.heartbeat.client.netty.proxy.http.filter import org.framework.lazy.cloud.network.heartbeat.common.constant.ProxyMessageType; import org.framework.lazy.cloud.network.heartbeat.common.advanced.payload.NettyProxyMsg; import org.framework.lazy.cloud.network.heartbeat.common.adapter.ChannelTypeAdapter; +import org.framework.lazy.cloud.network.heartbeat.common.factory.EventLoopGroupFactory; import org.framework.lazy.cloud.network.heartbeat.common.utils.ChannelAttributeKeyUtils; import java.util.concurrent.TimeUnit; @@ -21,13 +22,13 @@ import java.util.concurrent.TimeUnit; */ @Slf4j public class NettyHttpClientProxyClientProxySocket { - static EventLoopGroup eventLoopGroup = new NioEventLoopGroup(); /** * 连接服务端通信通道 */ public static void buildTransferServer(NettyHttpClientProxyClient nettyHttpClientProxyClient, Channel visitorChannel) { + EventLoopGroup eventLoopGroup = EventLoopGroupFactory.createClientWorkGroup(); Bootstrap bootstrap = new Bootstrap(); bootstrap.group(eventLoopGroup) .channel(NioSocketChannel.class) diff --git a/wu-lazy-cloud-heartbeat-client/src/main/java/org/framework/lazy/cloud/network/heartbeat/client/netty/proxy/socks/NettySocksClientProxyServer.java b/wu-lazy-cloud-heartbeat-client/src/main/java/org/framework/lazy/cloud/network/heartbeat/client/netty/proxy/socks/NettySocksClientProxyServer.java new file mode 100644 index 0000000..67b2c39 --- /dev/null +++ b/wu-lazy-cloud-heartbeat-client/src/main/java/org/framework/lazy/cloud/network/heartbeat/client/netty/proxy/socks/NettySocksClientProxyServer.java @@ -0,0 +1,48 @@ +package org.framework.lazy.cloud.network.heartbeat.client.netty.proxy.socks; + +import io.netty.handler.codec.socksx.v5.Socks5AddressType; +import lombok.Data; +import lombok.NoArgsConstructor; +import org.framework.lazy.cloud.network.heartbeat.client.config.NettyClientProperties; +import org.framework.lazy.cloud.network.heartbeat.common.advanced.HandleChannelTypeAdvanced; + +import java.util.List; + + +/** + * 客户端代理服务端配置信息 + */ +@NoArgsConstructor +@Data +public class NettySocksClientProxyServer { + + /** + * 目标地址 + */ + private String targetIp; + + /** + * 目标端口 + */ + private Integer targetPort; + + /** + * 服务端地址信息 + */ + private NettyClientProperties nettyClientProperties; + + /** + * 通道处理器 + */ + private List handleChannelTypeAdvancedList; + + /** + * 是否是ssl + */ + private boolean isSsl; + /** + * 地址类型 + */ + private Socks5AddressType socks5AddressType; + +} diff --git a/wu-lazy-cloud-heartbeat-client/src/main/java/org/framework/lazy/cloud/network/heartbeat/client/netty/proxy/socks/advanced/ClientHandleDistributeSocksClientProxyServerConnectionTransferFailAdvanced.java b/wu-lazy-cloud-heartbeat-client/src/main/java/org/framework/lazy/cloud/network/heartbeat/client/netty/proxy/socks/advanced/ClientHandleDistributeSocksClientProxyServerConnectionTransferFailAdvanced.java new file mode 100644 index 0000000..8025aa2 --- /dev/null +++ b/wu-lazy-cloud-heartbeat-client/src/main/java/org/framework/lazy/cloud/network/heartbeat/client/netty/proxy/socks/advanced/ClientHandleDistributeSocksClientProxyServerConnectionTransferFailAdvanced.java @@ -0,0 +1,26 @@ +package org.framework.lazy.cloud.network.heartbeat.client.netty.proxy.socks.advanced; + +import lombok.extern.slf4j.Slf4j; +import org.framework.lazy.cloud.network.heartbeat.common.advanced.payload.NettyChannelContext; +import org.framework.lazy.cloud.network.heartbeat.common.advanced.payload.NettyProxyMsg; +import org.framework.lazy.cloud.network.heartbeat.common.advanced.proxy.socket.client.AbstractHandleSocksDistributeClientProxyServerConnectionTransferFailTypeAdvanced; + + +@Slf4j +public class ClientHandleDistributeSocksClientProxyServerConnectionTransferFailAdvanced extends + AbstractHandleSocksDistributeClientProxyServerConnectionTransferFailTypeAdvanced { + + + /** + * 处理当前数据 + * + * @param nettyChannelContext 当前通道 + * @param nettyProxyMsg 通道数据 + */ + @Override + protected void doHandler(NettyChannelContext nettyChannelContext, NettyProxyMsg nettyProxyMsg) { + + // 传输通道关闭 + + } +} diff --git a/wu-lazy-cloud-heartbeat-client/src/main/java/org/framework/lazy/cloud/network/heartbeat/client/netty/proxy/socks/advanced/ClientHandleDistributeSocksClientProxyServerConnectionTransferSuccessfulAdvanced.java b/wu-lazy-cloud-heartbeat-client/src/main/java/org/framework/lazy/cloud/network/heartbeat/client/netty/proxy/socks/advanced/ClientHandleDistributeSocksClientProxyServerConnectionTransferSuccessfulAdvanced.java new file mode 100644 index 0000000..5b3c63c --- /dev/null +++ b/wu-lazy-cloud-heartbeat-client/src/main/java/org/framework/lazy/cloud/network/heartbeat/client/netty/proxy/socks/advanced/ClientHandleDistributeSocksClientProxyServerConnectionTransferSuccessfulAdvanced.java @@ -0,0 +1,51 @@ +package org.framework.lazy.cloud.network.heartbeat.client.netty.proxy.socks.advanced; + +import io.netty.channel.Channel; +import io.netty.handler.codec.socksx.v5.DefaultSocks5CommandResponse; +import io.netty.handler.codec.socksx.v5.Socks5AddressType; +import io.netty.handler.codec.socksx.v5.Socks5CommandRequestDecoder; +import io.netty.handler.codec.socksx.v5.Socks5CommandStatus; +import lombok.extern.slf4j.Slf4j; +import org.framework.lazy.cloud.network.heartbeat.client.netty.proxy.socks.handler.NettyClientProxyServerVisitorInboundHandler; +import org.framework.lazy.cloud.network.heartbeat.common.advanced.payload.NettyChannelContext; +import org.framework.lazy.cloud.network.heartbeat.common.advanced.payload.NettyProxyMsg; +import org.framework.lazy.cloud.network.heartbeat.common.advanced.proxy.socket.client.AbstractHandleSocksDistributeClientProxyServerConnectionTransferSuccessTypeAdvanced; +import org.framework.lazy.cloud.network.heartbeat.common.decoder.TransferDecoder; +import org.framework.lazy.cloud.network.heartbeat.common.utils.ChannelAttributeKeyUtils; +import org.framework.lazy.cloud.network.heartbeat.protocol.handler.NettySocks5CommandRequestHandler; + + +@Slf4j +public class ClientHandleDistributeSocksClientProxyServerConnectionTransferSuccessfulAdvanced extends + AbstractHandleSocksDistributeClientProxyServerConnectionTransferSuccessTypeAdvanced { + + + /** + * 处理当前数据 + * + * @param nettyChannelContext 当前通道 + * @param nettyProxyMsg 通道数据 + */ + @Override + protected void doHandler(NettyChannelContext nettyChannelContext, NettyProxyMsg nettyProxyMsg) { + + // 传输通道 + Channel transferChannel = nettyChannelContext.channel(); + + // 根据传输通道获取代理通道 + Channel nextChannel = ChannelAttributeKeyUtils.getNextChannel(transferChannel); + + Byte socks5AddressTypeByte = ChannelAttributeKeyUtils.getSocks5AddressType(nextChannel); + Socks5AddressType socks5AddressType = Socks5AddressType.valueOf(socks5AddressTypeByte); + //添加客户端转发请求到服务端的Handler + // TODO bug fix + nextChannel.pipeline().addLast(new TransferDecoder(Integer.MAX_VALUE, 1024 * 1024*10)); + // 请求数据开始上报 + nextChannel.pipeline().addLast(new NettyClientProxyServerVisitorInboundHandler(transferChannel)); + DefaultSocks5CommandResponse commandResponse = + new DefaultSocks5CommandResponse(Socks5CommandStatus.SUCCESS, socks5AddressType); + nextChannel.writeAndFlush(commandResponse); + nextChannel.pipeline().remove(NettySocks5CommandRequestHandler.class); + nextChannel.pipeline().remove(Socks5CommandRequestDecoder.class); + } +} diff --git a/wu-lazy-cloud-heartbeat-client/src/main/java/org/framework/lazy/cloud/network/heartbeat/client/netty/proxy/socks/advanced/ClientHandleDistributeSocksClientProxyServerTransferCloseAdvanced.java b/wu-lazy-cloud-heartbeat-client/src/main/java/org/framework/lazy/cloud/network/heartbeat/client/netty/proxy/socks/advanced/ClientHandleDistributeSocksClientProxyServerTransferCloseAdvanced.java new file mode 100644 index 0000000..3401141 --- /dev/null +++ b/wu-lazy-cloud-heartbeat-client/src/main/java/org/framework/lazy/cloud/network/heartbeat/client/netty/proxy/socks/advanced/ClientHandleDistributeSocksClientProxyServerTransferCloseAdvanced.java @@ -0,0 +1,25 @@ +package org.framework.lazy.cloud.network.heartbeat.client.netty.proxy.socks.advanced; + +import lombok.extern.slf4j.Slf4j; +import org.framework.lazy.cloud.network.heartbeat.common.advanced.payload.NettyChannelContext; +import org.framework.lazy.cloud.network.heartbeat.common.advanced.payload.NettyProxyMsg; +import org.framework.lazy.cloud.network.heartbeat.common.advanced.proxy.socket.client.AbstractHandleSocksDistributeClientProxyServerTransferCloseTypeAdvanced; + + +@Slf4j +public class ClientHandleDistributeSocksClientProxyServerTransferCloseAdvanced extends + AbstractHandleSocksDistributeClientProxyServerTransferCloseTypeAdvanced { + + + /** + * 处理当前数据 + * + * @param nettyChannelContext 当前通道 + * @param nettyProxyMsg 通道数据 + */ + @Override + protected void doHandler(NettyChannelContext nettyChannelContext, NettyProxyMsg nettyProxyMsg) { + + + } +} diff --git a/wu-lazy-cloud-heartbeat-client/src/main/java/org/framework/lazy/cloud/network/heartbeat/client/netty/proxy/socks/advanced/ClientHandleDistributeSocksClientProxyServerTransferTransferResponseAdvanced.java b/wu-lazy-cloud-heartbeat-client/src/main/java/org/framework/lazy/cloud/network/heartbeat/client/netty/proxy/socks/advanced/ClientHandleDistributeSocksClientProxyServerTransferTransferResponseAdvanced.java new file mode 100644 index 0000000..3d8716e --- /dev/null +++ b/wu-lazy-cloud-heartbeat-client/src/main/java/org/framework/lazy/cloud/network/heartbeat/client/netty/proxy/socks/advanced/ClientHandleDistributeSocksClientProxyServerTransferTransferResponseAdvanced.java @@ -0,0 +1,38 @@ +package org.framework.lazy.cloud.network.heartbeat.client.netty.proxy.socks.advanced; + +import io.netty.buffer.ByteBuf; +import io.netty.channel.Channel; +import lombok.extern.slf4j.Slf4j; +import org.framework.lazy.cloud.network.heartbeat.common.advanced.payload.NettyChannelContext; +import org.framework.lazy.cloud.network.heartbeat.common.advanced.payload.NettyProxyMsg; +import org.framework.lazy.cloud.network.heartbeat.common.advanced.proxy.socket.client.AbstractHandleSocksDistributeClientProxyServerTransferResponseTypeAdvanced; +import org.framework.lazy.cloud.network.heartbeat.common.utils.ChannelAttributeKeyUtils; +import org.wu.framework.core.utils.ObjectUtils; + + +@Slf4j +public class ClientHandleDistributeSocksClientProxyServerTransferTransferResponseAdvanced extends + AbstractHandleSocksDistributeClientProxyServerTransferResponseTypeAdvanced { + + + /** + * 处理当前数据 + * + * @param nettyChannelContext 当前通道 + * @param nettyProxyMsg 通道数据 + */ + @Override + protected void doHandler(NettyChannelContext nettyChannelContext, NettyProxyMsg nettyProxyMsg) { + // 数据直接下发 + Channel channel = nettyChannelContext.channel(); + Channel nextChannel = ChannelAttributeKeyUtils.getNextChannel(channel); + if(ObjectUtils.isNotEmpty(nextChannel)&&nextChannel.isActive()){ + ByteBuf buf = nextChannel.config().getAllocator().buffer(nettyProxyMsg.getData().length); + buf.writeBytes(nettyProxyMsg.getData()); + nextChannel.writeAndFlush(buf); + }else { + log.error("客户端代理服务端socks，本地通道已关闭！"); + } + + } +} diff --git a/wu-lazy-cloud-heartbeat-client/src/main/java/org/framework/lazy/cloud/network/heartbeat/client/netty/proxy/socks/advanced/NettySocketProtocolHandleSocketClientProxyServerTypeAdvanced.java b/wu-lazy-cloud-heartbeat-client/src/main/java/org/framework/lazy/cloud/network/heartbeat/client/netty/proxy/socks/advanced/NettySocketProtocolHandleSocketClientProxyServerTypeAdvanced.java new file mode 100644 index 0000000..6b812e0 --- /dev/null +++ b/wu-lazy-cloud-heartbeat-client/src/main/java/org/framework/lazy/cloud/network/heartbeat/client/netty/proxy/socks/advanced/NettySocketProtocolHandleSocketClientProxyServerTypeAdvanced.java @@ -0,0 +1,75 @@ +package org.framework.lazy.cloud.network.heartbeat.client.netty.proxy.socks.advanced; + +import io.netty.bootstrap.Bootstrap; +import io.netty.channel.*; +import io.netty.channel.socket.SocketChannel; +import io.netty.channel.socket.nio.NioSocketChannel; +import io.netty.handler.codec.socksx.v5.DefaultSocks5CommandResponse; +import io.netty.handler.codec.socksx.v5.Socks5AddressType; +import io.netty.handler.codec.socksx.v5.Socks5CommandRequestDecoder; +import io.netty.handler.codec.socksx.v5.Socks5CommandStatus; +import lombok.extern.slf4j.Slf4j; +import org.framework.lazy.cloud.network.heartbeat.client.config.NettyClientProperties; +import org.framework.lazy.cloud.network.heartbeat.client.netty.proxy.socks.NettySocksClientProxyServer; +import org.framework.lazy.cloud.network.heartbeat.client.netty.proxy.socks.socket.NettySocksClientProxyServerSocket; +import org.framework.lazy.cloud.network.heartbeat.common.advanced.HandleChannelTypeAdvanced; +import org.framework.lazy.cloud.network.heartbeat.common.advanced.payload.NettyChannelContext; +import org.framework.lazy.cloud.network.heartbeat.common.advanced.payload.NettyProxyMsg; +import org.framework.lazy.cloud.network.heartbeat.common.advanced.payload.NettySocketChannelContext; +import org.framework.lazy.cloud.network.heartbeat.common.advanced.proxy.socket.client.AbstractHandleSocketClientProxyServerTypeAdvanced; +import org.framework.lazy.cloud.network.heartbeat.common.factory.EventLoopGroupFactory; +import org.framework.lazy.cloud.network.heartbeat.protocol.handler.NettyProxy2RealInboundHandler; +import org.framework.lazy.cloud.network.heartbeat.protocol.handler.NettySocketBackendHandler; +import org.framework.lazy.cloud.network.heartbeat.protocol.handler.NettySocks5CommandRequestHandler; +import org.springframework.stereotype.Component; +import org.wu.framework.spring.utils.SpringContextHolder; + +import java.net.InetSocketAddress; +import java.util.ArrayList; +import java.util.List; + +@Slf4j +@Component +public class NettySocketProtocolHandleSocketClientProxyServerTypeAdvanced + extends AbstractHandleSocketClientProxyServerTypeAdvanced { + /** + * 处理当前数据 + * + * @param nettyChannelContext 当前通道 + * @param nettyProxyMsg 通道数据 + */ + @Override + protected void doHandler(NettyChannelContext nettyChannelContext, NettyProxyMsg nettyProxyMsg) { + + + NettySocketChannelContext nettySocketChannelContext = (NettySocketChannelContext) nettyChannelContext; + Channel channel = nettySocketChannelContext.channel(); + ChannelHandlerContext channelHandlerContext = nettySocketChannelContext.channelHandlerContext(); + EventLoopGroup group = EventLoopGroupFactory.createClientWorkGroup(); + String host = nettyProxyMsg.getTargetIpString(); + Integer port = Integer.parseInt(nettyProxyMsg.getTargetPortString()); + Bootstrap b = new Bootstrap(); + Socks5AddressType socks5AddressType = nettySocketChannelContext.getSocks5AddressType(); + + + List handleChannelTypeAdvancedList = new ArrayList<>(SpringContextHolder.getApplicationContext().getBeansOfType(HandleChannelTypeAdvanced.class).values()); + NettyClientProperties nettyClientProperties = SpringContextHolder.getBean(NettyClientProperties.class); + + + NettySocksClientProxyServer nettySocksClientProxyServer = new NettySocksClientProxyServer(); + nettySocksClientProxyServer.setSsl(false); + nettySocksClientProxyServer.setTargetIp(host); + nettySocksClientProxyServer.setTargetPort(Integer.parseInt(String.valueOf(port))); + nettySocksClientProxyServer.setSocks5AddressType(socks5AddressType); + + + nettySocksClientProxyServer.setHandleChannelTypeAdvancedList(handleChannelTypeAdvancedList); + nettySocksClientProxyServer.setNettyClientProperties(nettyClientProperties); + + // 创建连接 + NettySocksClientProxyServerSocket.buildTransferServer(nettySocksClientProxyServer, channel); + + + + } +} diff --git a/wu-lazy-cloud-heartbeat-client/src/main/java/org/framework/lazy/cloud/network/heartbeat/client/netty/proxy/socks/filter/NettySocksClientProxyServerTransferFilter.java b/wu-lazy-cloud-heartbeat-client/src/main/java/org/framework/lazy/cloud/network/heartbeat/client/netty/proxy/socks/filter/NettySocksClientProxyServerTransferFilter.java new file mode 100644 index 0000000..894d6b2 --- /dev/null +++ b/wu-lazy-cloud-heartbeat-client/src/main/java/org/framework/lazy/cloud/network/heartbeat/client/netty/proxy/socks/filter/NettySocksClientProxyServerTransferFilter.java @@ -0,0 +1,43 @@ +package org.framework.lazy.cloud.network.heartbeat.client.netty.proxy.socks.filter; + +import io.netty.channel.Channel; +import io.netty.channel.ChannelHandlerContext; +import io.netty.channel.ChannelPipeline; +import io.netty.channel.socket.SocketChannel; +import io.netty.handler.timeout.IdleStateHandler; +import org.framework.lazy.cloud.network.heartbeat.client.netty.proxy.socks.handler.NettySocksClientProxyServerTransferHandler; +import org.framework.lazy.cloud.network.heartbeat.common.adapter.ChannelTypeAdapter; +import org.framework.lazy.cloud.network.heartbeat.common.decoder.NettyProxyMsgDecoder; +import org.framework.lazy.cloud.network.heartbeat.common.encoder.NettyProxyMsgEncoder; +import org.framework.lazy.cloud.network.heartbeat.common.filter.DebugChannelInitializer; + +/** + * netty 客户端代理服务端数据传输通道 + */ +public class NettySocksClientProxyServerTransferFilter extends DebugChannelInitializer { + private final ChannelTypeAdapter channelTypeAdapter; + + public NettySocksClientProxyServerTransferFilter(ChannelTypeAdapter channelTypeAdapter) { + this.channelTypeAdapter = channelTypeAdapter; + } + + /** + * 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 IdleStateHandler(0, 4, 0)); + + pipeline.addLast(new NettyProxyMsgDecoder(Integer.MAX_VALUE, 0, 4, -4, 0)); + pipeline.addLast(new NettyProxyMsgEncoder()); + pipeline.addLast(new NettySocksClientProxyServerTransferHandler(channelTypeAdapter)); + } +} diff --git a/wu-lazy-cloud-heartbeat-client/src/main/java/org/framework/lazy/cloud/network/heartbeat/client/netty/proxy/socks/handler/NettyClientProxyServerVisitorInboundHandler.java b/wu-lazy-cloud-heartbeat-client/src/main/java/org/framework/lazy/cloud/network/heartbeat/client/netty/proxy/socks/handler/NettyClientProxyServerVisitorInboundHandler.java new file mode 100644 index 0000000..2bb8293 --- /dev/null +++ b/wu-lazy-cloud-heartbeat-client/src/main/java/org/framework/lazy/cloud/network/heartbeat/client/netty/proxy/socks/handler/NettyClientProxyServerVisitorInboundHandler.java @@ -0,0 +1,73 @@ +package org.framework.lazy.cloud.network.heartbeat.client.netty.proxy.socks.handler; + + +import io.netty.buffer.Unpooled; +import io.netty.channel.*; +import io.netty.util.ReferenceCountUtil; +import lombok.extern.slf4j.Slf4j; +import org.framework.lazy.cloud.network.heartbeat.common.NettyByteBuf; +import org.framework.lazy.cloud.network.heartbeat.common.advanced.payload.NettyProxyMsg; +import org.framework.lazy.cloud.network.heartbeat.common.constant.ProxyMessageType; +import org.framework.lazy.cloud.network.heartbeat.common.utils.ChannelAttributeKeyUtils; + + +@Slf4j +public class NettyClientProxyServerVisitorInboundHandler extends SimpleChannelInboundHandler { + + private final Channel transferChannel; + + public NettyClientProxyServerVisitorInboundHandler(Channel transferChannel) { + this.transferChannel = transferChannel; + } + + + @Override + public void channelActive(ChannelHandlerContext ctx) { + ctx.writeAndFlush(Unpooled.EMPTY_BUFFER); + } + + @Override + public void channelRead0(ChannelHandlerContext ctx, NettyByteBuf nettyByteBuf) throws Exception { + log.info("转发客户端的请求到代理服务器"); + // 结果下发 + Channel channel = ctx.channel(); + byte[] bytes = nettyByteBuf.getData(); + log.debug("bytes.length:{}",bytes.length); + log.debug("客户端代理服务端,本地接收请求数据:{}", new String(bytes)); + Channel nextChannel = ChannelAttributeKeyUtils.getNextChannel(channel); + + if (nextChannel.isActive()) { + // 上传数据到服务端 + NettyProxyMsg nettyProxyMsg = new NettyProxyMsg(); + nettyProxyMsg.setType(ProxyMessageType.SOCKS_REPORT_CLIENT_PROXY_SERVER_TRANSFER_REQUEST_); + + nettyProxyMsg.setData(nettyByteBuf.getData()); + nextChannel.writeAndFlush(nettyProxyMsg); + } else { + log.info("释放内存"); + ReferenceCountUtil.release(nettyByteBuf); + } + } + + @Override + public void channelInactive(ChannelHandlerContext ctx) throws Exception { + log.info("客户端与代理服务器的连接已经断开，即将断开代理服务器和目标服务器的连接"); + Channel channel = ctx.channel(); + Channel nextChannel = ChannelAttributeKeyUtils.getNextChannel(channel); + if (nextChannel.isActive()) { + // 上报断开链接 + NettyProxyMsg nettyProxyMsgTransferClose = new NettyProxyMsg(); + nettyProxyMsgTransferClose.setType(ProxyMessageType.SOCKS_REPORT_CLIENT_PROXY_SERVER_TRANSFER_CLOSE_); + nextChannel.writeAndFlush(nettyProxyMsgTransferClose); + if (ctx.channel().isActive()) { + ctx.channel().writeAndFlush(Unpooled.EMPTY_BUFFER).addListener(ChannelFutureListener.CLOSE); + } + } + } + + @Override + public void exceptionCaught(ChannelHandlerContext ctx, Throwable cause) throws Exception { + log.error("NettyClientProxyServerVisitorInboundHandler exception", cause); + ctx.close(); + } +} diff --git a/wu-lazy-cloud-heartbeat-client/src/main/java/org/framework/lazy/cloud/network/heartbeat/client/netty/proxy/socks/handler/NettySocksClientProxyServerTransferHandler.java b/wu-lazy-cloud-heartbeat-client/src/main/java/org/framework/lazy/cloud/network/heartbeat/client/netty/proxy/socks/handler/NettySocksClientProxyServerTransferHandler.java new file mode 100644 index 0000000..59bf729 --- /dev/null +++ b/wu-lazy-cloud-heartbeat-client/src/main/java/org/framework/lazy/cloud/network/heartbeat/client/netty/proxy/socks/handler/NettySocksClientProxyServerTransferHandler.java @@ -0,0 +1,70 @@ +package org.framework.lazy.cloud.network.heartbeat.client.netty.proxy.socks.handler; + + +import io.netty.channel.Channel; +import io.netty.channel.ChannelHandlerContext; +import io.netty.channel.SimpleChannelInboundHandler; +import lombok.extern.slf4j.Slf4j; +import org.framework.lazy.cloud.network.heartbeat.common.adapter.ChannelTypeAdapter; +import org.framework.lazy.cloud.network.heartbeat.common.advanced.payload.NettyProxyMsg; +import org.framework.lazy.cloud.network.heartbeat.common.constant.ProxyMessageType; +import org.framework.lazy.cloud.network.heartbeat.common.utils.ChannelAttributeKeyUtils; + +/** + * 客户端访客通信通道 处理器 + */ +@Slf4j +public class NettySocksClientProxyServerTransferHandler extends SimpleChannelInboundHandler { + private final ChannelTypeAdapter channelTypeAdapter; + + public NettySocksClientProxyServerTransferHandler(ChannelTypeAdapter channelTypeAdapter) { + this.channelTypeAdapter = channelTypeAdapter; + } + + @Override + public void channelActive(ChannelHandlerContext ctx) throws Exception { + super.channelActive(ctx); + } + + @Override + public void channelRead0(ChannelHandlerContext ctx, NettyProxyMsg nettyProxyMsg) throws Exception { + Channel channel = ctx.channel(); + channelTypeAdapter.handler(ctx, nettyProxyMsg); + + } + + @Override + public void channelInactive(ChannelHandlerContext ctx) throws Exception { + + String clientId = ChannelAttributeKeyUtils.getClientId(ctx.channel()); + String visitorId = ChannelAttributeKeyUtils.getVisitorId(ctx.channel()); + // 关闭访客 + Channel nextChannel = ChannelAttributeKeyUtils.getNextChannel(ctx.channel()); + if (nextChannel != null) { + // 上报关闭这个客户端的访客通道 + NettyProxyMsg closeVisitorMsg = new NettyProxyMsg(); + closeVisitorMsg.setType(ProxyMessageType.SOCKS_REPORT_CLIENT_PROXY_SERVER_TRANSFER_CLOSE_); + closeVisitorMsg.setVisitorId(visitorId); + nextChannel.writeAndFlush(closeVisitorMsg); + } + + super.channelInactive(ctx); + } + + @Override + public void channelWritabilityChanged(ChannelHandlerContext ctx) throws Exception { + if (ctx.channel().isWritable()) { + log.debug("Channel is writable again"); + // 恢复之前暂停的操作，如写入数据 + } else { + log.debug("Channel is not writable"); + // 暂停写入操作，等待可写状态 + } + log.info("channelWritabilityChanged!"); + } + + @Override + public void exceptionCaught(ChannelHandlerContext ctx, Throwable cause) throws Exception { + super.exceptionCaught(ctx, cause); + } +} \ No newline at end of file diff --git a/wu-lazy-cloud-heartbeat-client/src/main/java/org/framework/lazy/cloud/network/heartbeat/client/netty/proxy/socks/socket/NettySocksClientProxyServerSocket.java b/wu-lazy-cloud-heartbeat-client/src/main/java/org/framework/lazy/cloud/network/heartbeat/client/netty/proxy/socks/socket/NettySocksClientProxyServerSocket.java new file mode 100644 index 0000000..0bd86a0 --- /dev/null +++ b/wu-lazy-cloud-heartbeat-client/src/main/java/org/framework/lazy/cloud/network/heartbeat/client/netty/proxy/socks/socket/NettySocksClientProxyServerSocket.java @@ -0,0 +1,98 @@ +package org.framework.lazy.cloud.network.heartbeat.client.netty.proxy.socks.socket; + + +import io.netty.bootstrap.Bootstrap; +import io.netty.channel.*; +import io.netty.channel.socket.nio.NioSocketChannel; +import io.netty.handler.codec.socksx.v5.Socks5AddressType; +import lombok.extern.slf4j.Slf4j; +import org.framework.lazy.cloud.network.heartbeat.client.config.NettyClientProperties; +import org.framework.lazy.cloud.network.heartbeat.client.netty.proxy.socks.NettySocksClientProxyServer; +import org.framework.lazy.cloud.network.heartbeat.client.netty.proxy.socks.filter.NettySocksClientProxyServerTransferFilter; +import org.framework.lazy.cloud.network.heartbeat.common.adapter.ChannelTypeAdapter; +import org.framework.lazy.cloud.network.heartbeat.common.advanced.payload.NettyProxyMsg; +import org.framework.lazy.cloud.network.heartbeat.common.constant.ProxyMessageType; +import org.framework.lazy.cloud.network.heartbeat.common.factory.EventLoopGroupFactory; +import org.framework.lazy.cloud.network.heartbeat.common.utils.ChannelAttributeKeyUtils; + +import java.util.concurrent.TimeUnit; + +/** + * 客户端代理服务端 + */ +@Slf4j +public class NettySocksClientProxyServerSocket { + + /** + * 连接服务端通信通道 + */ + public static void buildTransferServer(NettySocksClientProxyServer nettySocksClientProxyServer, Channel visitorChannel) { + + EventLoopGroup eventLoopGroup = EventLoopGroupFactory.createClientWorkGroup(); + 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.CONNECT_TIMEOUT_MILLIS, 1000 * 60)//连接超时时间设置为 60 秒 + .option(ChannelOption.WRITE_BUFFER_WATER_MARK, new WriteBufferWaterMark(1024 * 1024, 1024 * 1024 * 2)) + .handler(new NettySocksClientProxyServerTransferFilter(new ChannelTypeAdapter(nettySocksClientProxyServer.getHandleChannelTypeAdvancedList()))) + ; + NettyClientProperties nettyClientProperties = nettySocksClientProxyServer.getNettyClientProperties(); + String inetHost = nettyClientProperties.getInetHost(); + int inetPort = nettyClientProperties.getInetPort(); + // local client id + String clientId = nettyClientProperties.getClientId(); + + String targetIp = nettySocksClientProxyServer.getTargetIp(); + Integer targetPort = nettySocksClientProxyServer.getTargetPort(); + Socks5AddressType socks5AddressType = nettySocksClientProxyServer.getSocks5AddressType(); + byte socks5AddressTypeByteValue = socks5AddressType.byteValue(); + + String visitorId = ChannelAttributeKeyUtils.getVisitorId(visitorChannel); + + + + // 客户端链接服务端 + log.info("Client creates a new proxy channel to connect to server IP: {}, connecting to server port: {} with clientId:【{}】 & visitorId:【{}】", + inetHost, inetPort, clientId, visitorId); + ChannelFuture future = bootstrap.connect(inetHost, inetPort); + + // 使用的客户端ID:{} + future.addListener((ChannelFutureListener) futureListener -> { + Channel transferChannel = futureListener.channel(); + if (futureListener.isSuccess()) { + + NettyProxyMsg nettyProxyMsg = new NettyProxyMsg(); + nettyProxyMsg.setType(ProxyMessageType.SOCKS_REPORT_CLIENT_PROXY_SERVER_TRANSFER_CONNECTION_); + // other clientId + nettyProxyMsg.setClientTargetIp(targetIp); + nettyProxyMsg.setClientTargetPort(targetPort); + + nettyProxyMsg.setVisitorId(visitorId); + nettyProxyMsg.setData(new byte[]{socks5AddressTypeByteValue}); + transferChannel.writeAndFlush(nettyProxyMsg); + // 绑定客户端真实通信通道 + ChannelAttributeKeyUtils.buildVisitorId(transferChannel, visitorId); + ChannelAttributeKeyUtils.buildClientId(transferChannel, clientId); + // 传输通道 + ChannelAttributeKeyUtils.buildNextChannel(visitorChannel, transferChannel); + ChannelAttributeKeyUtils.buildNextChannel(transferChannel, visitorChannel); + + + } else { + log.info("无法连接到服务端...."); + eventLoopGroup.schedule(() -> { + try { + buildTransferServer(nettySocksClientProxyServer, visitorChannel); + } catch (Exception e) { + e.printStackTrace(); + } + }, 2, TimeUnit.SECONDS); + } + }); + } +} \ No newline at end of file diff --git a/wu-lazy-cloud-heartbeat-common/src/main/java/org/framework/lazy/cloud/network/heartbeat/common/advanced/proxy/socket/client/AbstractHandleSocketClientProxyServerTypeAdvanced.java b/wu-lazy-cloud-heartbeat-common/src/main/java/org/framework/lazy/cloud/network/heartbeat/common/advanced/proxy/socket/client/AbstractHandleSocketClientProxyServerTypeAdvanced.java new file mode 100644 index 0000000..5a8b67d --- /dev/null +++ b/wu-lazy-cloud-heartbeat-common/src/main/java/org/framework/lazy/cloud/network/heartbeat/common/advanced/proxy/socket/client/AbstractHandleSocketClientProxyServerTypeAdvanced.java @@ -0,0 +1,21 @@ +package org.framework.lazy.cloud.network.heartbeat.common.advanced.proxy.socket.client; + +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.advanced.payload.NettyProxyMsg; +import org.framework.lazy.cloud.network.heartbeat.common.enums.ProxyMessageTypeEnums; + +public abstract class AbstractHandleSocketClientProxyServerTypeAdvanced extends AbstractHandleChannelTypeAdvanced implements HandleChannelTypeAdvanced { + + + /** + * 是否支持当前类型 + * + * @param nettyProxyMsg 通道数据 + * @return 布尔类型 是、否 + */ + @Override + protected boolean doSupport(NettyProxyMsg nettyProxyMsg) { + return ProxyMessageTypeEnums.SOCKET_CLIENT_PROXY_SERVER_.getTypeByte() == nettyProxyMsg.getType(); + } +} diff --git a/wu-lazy-cloud-heartbeat-common/src/main/java/org/framework/lazy/cloud/network/heartbeat/common/advanced/proxy/socket/client/AbstractHandleSocksDistributeClientProxyServerConnectionTransferFailTypeAdvanced.java b/wu-lazy-cloud-heartbeat-common/src/main/java/org/framework/lazy/cloud/network/heartbeat/common/advanced/proxy/socket/client/AbstractHandleSocksDistributeClientProxyServerConnectionTransferFailTypeAdvanced.java new file mode 100644 index 0000000..0792451 --- /dev/null +++ b/wu-lazy-cloud-heartbeat-common/src/main/java/org/framework/lazy/cloud/network/heartbeat/common/advanced/proxy/socket/client/AbstractHandleSocksDistributeClientProxyServerConnectionTransferFailTypeAdvanced.java @@ -0,0 +1,21 @@ +package org.framework.lazy.cloud.network.heartbeat.common.advanced.proxy.socket.client; + +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.advanced.payload.NettyProxyMsg; +import org.framework.lazy.cloud.network.heartbeat.common.enums.ProxyMessageTypeEnums; + +public abstract class AbstractHandleSocksDistributeClientProxyServerConnectionTransferFailTypeAdvanced extends AbstractHandleChannelTypeAdvanced implements HandleChannelTypeAdvanced { + + + /** + * 是否支持当前类型 + * + * @param nettyProxyMsg 通道数据 + * @return 布尔类型 是、否 + */ + @Override + protected boolean doSupport(NettyProxyMsg nettyProxyMsg) { + return ProxyMessageTypeEnums.SOCKS_DISTRIBUTE_CLIENT_PROXY_SERVER_TRANSFER_CONNECTION_FAIL_.getTypeByte() == nettyProxyMsg.getType(); + } +} diff --git a/wu-lazy-cloud-heartbeat-common/src/main/java/org/framework/lazy/cloud/network/heartbeat/common/advanced/proxy/socket/client/AbstractHandleSocksDistributeClientProxyServerConnectionTransferSuccessTypeAdvanced.java b/wu-lazy-cloud-heartbeat-common/src/main/java/org/framework/lazy/cloud/network/heartbeat/common/advanced/proxy/socket/client/AbstractHandleSocksDistributeClientProxyServerConnectionTransferSuccessTypeAdvanced.java new file mode 100644 index 0000000..1063f86 --- /dev/null +++ b/wu-lazy-cloud-heartbeat-common/src/main/java/org/framework/lazy/cloud/network/heartbeat/common/advanced/proxy/socket/client/AbstractHandleSocksDistributeClientProxyServerConnectionTransferSuccessTypeAdvanced.java @@ -0,0 +1,21 @@ +package org.framework.lazy.cloud.network.heartbeat.common.advanced.proxy.socket.client; + +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.advanced.payload.NettyProxyMsg; +import org.framework.lazy.cloud.network.heartbeat.common.enums.ProxyMessageTypeEnums; + +public abstract class AbstractHandleSocksDistributeClientProxyServerConnectionTransferSuccessTypeAdvanced extends AbstractHandleChannelTypeAdvanced implements HandleChannelTypeAdvanced { + + + /** + * 是否支持当前类型 + * + * @param nettyProxyMsg 通道数据 + * @return 布尔类型 是、否 + */ + @Override + protected boolean doSupport(NettyProxyMsg nettyProxyMsg) { + return ProxyMessageTypeEnums.SOCKS_DISTRIBUTE_CLIENT_PROXY_SERVER_TRANSFER_CONNECTION_SUCCESS_.getTypeByte() == nettyProxyMsg.getType(); + } +} diff --git a/wu-lazy-cloud-heartbeat-common/src/main/java/org/framework/lazy/cloud/network/heartbeat/common/advanced/proxy/socket/client/AbstractHandleSocksDistributeClientProxyServerTransferCloseTypeAdvanced.java b/wu-lazy-cloud-heartbeat-common/src/main/java/org/framework/lazy/cloud/network/heartbeat/common/advanced/proxy/socket/client/AbstractHandleSocksDistributeClientProxyServerTransferCloseTypeAdvanced.java new file mode 100644 index 0000000..18e8670 --- /dev/null +++ b/wu-lazy-cloud-heartbeat-common/src/main/java/org/framework/lazy/cloud/network/heartbeat/common/advanced/proxy/socket/client/AbstractHandleSocksDistributeClientProxyServerTransferCloseTypeAdvanced.java @@ -0,0 +1,21 @@ +package org.framework.lazy.cloud.network.heartbeat.common.advanced.proxy.socket.client; + +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.advanced.payload.NettyProxyMsg; +import org.framework.lazy.cloud.network.heartbeat.common.enums.ProxyMessageTypeEnums; + +public abstract class AbstractHandleSocksDistributeClientProxyServerTransferCloseTypeAdvanced extends AbstractHandleChannelTypeAdvanced implements HandleChannelTypeAdvanced { + + + /** + * 是否支持当前类型 + * + * @param nettyProxyMsg 通道数据 + * @return 布尔类型 是、否 + */ + @Override + protected boolean doSupport(NettyProxyMsg nettyProxyMsg) { + return ProxyMessageTypeEnums.SOCKS_DISTRIBUTE_CLIENT_PROXY_SERVER_TRANSFER_CLOSE_.getTypeByte() == nettyProxyMsg.getType(); + } +} diff --git a/wu-lazy-cloud-heartbeat-common/src/main/java/org/framework/lazy/cloud/network/heartbeat/common/advanced/proxy/socket/client/AbstractHandleSocksDistributeClientProxyServerTransferResponseTypeAdvanced.java b/wu-lazy-cloud-heartbeat-common/src/main/java/org/framework/lazy/cloud/network/heartbeat/common/advanced/proxy/socket/client/AbstractHandleSocksDistributeClientProxyServerTransferResponseTypeAdvanced.java new file mode 100644 index 0000000..ba5829c --- /dev/null +++ b/wu-lazy-cloud-heartbeat-common/src/main/java/org/framework/lazy/cloud/network/heartbeat/common/advanced/proxy/socket/client/AbstractHandleSocksDistributeClientProxyServerTransferResponseTypeAdvanced.java @@ -0,0 +1,21 @@ +package org.framework.lazy.cloud.network.heartbeat.common.advanced.proxy.socket.client; + +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.advanced.payload.NettyProxyMsg; +import org.framework.lazy.cloud.network.heartbeat.common.enums.ProxyMessageTypeEnums; + +public abstract class AbstractHandleSocksDistributeClientProxyServerTransferResponseTypeAdvanced extends AbstractHandleChannelTypeAdvanced implements HandleChannelTypeAdvanced { + + + /** + * 是否支持当前类型 + * + * @param nettyProxyMsg 通道数据 + * @return 布尔类型 是、否 + */ + @Override + protected boolean doSupport(NettyProxyMsg nettyProxyMsg) { + return ProxyMessageTypeEnums.SOCKS_DISTRIBUTE_CLIENT_PROXY_SERVER_TRANSFER_RESPONSE_.getTypeByte() == nettyProxyMsg.getType(); + } +} \ No newline at end of file diff --git a/wu-lazy-cloud-heartbeat-common/src/main/java/org/framework/lazy/cloud/network/heartbeat/common/advanced/proxy/socket/server/AbstractHandleSocksReportClientProxyServerConnectionTransferTypeAdvanced.java b/wu-lazy-cloud-heartbeat-common/src/main/java/org/framework/lazy/cloud/network/heartbeat/common/advanced/proxy/socket/server/AbstractHandleSocksReportClientProxyServerConnectionTransferTypeAdvanced.java new file mode 100644 index 0000000..08d823b --- /dev/null +++ b/wu-lazy-cloud-heartbeat-common/src/main/java/org/framework/lazy/cloud/network/heartbeat/common/advanced/proxy/socket/server/AbstractHandleSocksReportClientProxyServerConnectionTransferTypeAdvanced.java @@ -0,0 +1,21 @@ +package org.framework.lazy.cloud.network.heartbeat.common.advanced.proxy.socket.server; + +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.advanced.payload.NettyProxyMsg; +import org.framework.lazy.cloud.network.heartbeat.common.enums.ProxyMessageTypeEnums; + +public abstract class AbstractHandleSocksReportClientProxyServerConnectionTransferTypeAdvanced extends AbstractHandleChannelTypeAdvanced implements HandleChannelTypeAdvanced { + + + /** + * 是否支持当前类型 + * + * @param nettyProxyMsg 通道数据 + * @return 布尔类型 是、否 + */ + @Override + protected boolean doSupport(NettyProxyMsg nettyProxyMsg) { + return ProxyMessageTypeEnums.SOCKS_REPORT_CLIENT_PROXY_SERVER_TRANSFER_CONNECTION_.getTypeByte() == nettyProxyMsg.getType(); + } +} \ No newline at end of file diff --git a/wu-lazy-cloud-heartbeat-common/src/main/java/org/framework/lazy/cloud/network/heartbeat/common/advanced/proxy/socket/server/AbstractHandleSocksReportClientProxyServerTransferCloseTypeAdvanced.java b/wu-lazy-cloud-heartbeat-common/src/main/java/org/framework/lazy/cloud/network/heartbeat/common/advanced/proxy/socket/server/AbstractHandleSocksReportClientProxyServerTransferCloseTypeAdvanced.java new file mode 100644 index 0000000..5f21320 --- /dev/null +++ b/wu-lazy-cloud-heartbeat-common/src/main/java/org/framework/lazy/cloud/network/heartbeat/common/advanced/proxy/socket/server/AbstractHandleSocksReportClientProxyServerTransferCloseTypeAdvanced.java @@ -0,0 +1,21 @@ +package org.framework.lazy.cloud.network.heartbeat.common.advanced.proxy.socket.server; + +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.advanced.payload.NettyProxyMsg; +import org.framework.lazy.cloud.network.heartbeat.common.enums.ProxyMessageTypeEnums; + +public abstract class AbstractHandleSocksReportClientProxyServerTransferCloseTypeAdvanced extends AbstractHandleChannelTypeAdvanced implements HandleChannelTypeAdvanced { + + + /** + * 是否支持当前类型 + * + * @param nettyProxyMsg 通道数据 + * @return 布尔类型 是、否 + */ + @Override + protected boolean doSupport(NettyProxyMsg nettyProxyMsg) { + return ProxyMessageTypeEnums.SOCKS_REPORT_CLIENT_PROXY_SERVER_TRANSFER_CLOSE_.getTypeByte() == nettyProxyMsg.getType(); + } +} \ No newline at end of file diff --git a/wu-lazy-cloud-heartbeat-common/src/main/java/org/framework/lazy/cloud/network/heartbeat/common/advanced/proxy/socket/server/AbstractHandleSocksReportClientProxyServerTransferRequestTypeAdvanced.java b/wu-lazy-cloud-heartbeat-common/src/main/java/org/framework/lazy/cloud/network/heartbeat/common/advanced/proxy/socket/server/AbstractHandleSocksReportClientProxyServerTransferRequestTypeAdvanced.java new file mode 100644 index 0000000..3820363 --- /dev/null +++ b/wu-lazy-cloud-heartbeat-common/src/main/java/org/framework/lazy/cloud/network/heartbeat/common/advanced/proxy/socket/server/AbstractHandleSocksReportClientProxyServerTransferRequestTypeAdvanced.java @@ -0,0 +1,21 @@ +package org.framework.lazy.cloud.network.heartbeat.common.advanced.proxy.socket.server; + +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.advanced.payload.NettyProxyMsg; +import org.framework.lazy.cloud.network.heartbeat.common.enums.ProxyMessageTypeEnums; + +public abstract class AbstractHandleSocksReportClientProxyServerTransferRequestTypeAdvanced extends AbstractHandleChannelTypeAdvanced implements HandleChannelTypeAdvanced { + + + /** + * 是否支持当前类型 + * + * @param nettyProxyMsg 通道数据 + * @return 布尔类型 是、否 + */ + @Override + protected boolean doSupport(NettyProxyMsg nettyProxyMsg) { + return ProxyMessageTypeEnums.SOCKS_REPORT_CLIENT_PROXY_SERVER_TRANSFER_REQUEST_.getTypeByte() == nettyProxyMsg.getType(); + } +} \ No newline at end of file diff --git a/wu-lazy-cloud-heartbeat-common/src/main/java/org/framework/lazy/cloud/network/heartbeat/common/constant/ProxyMessageType.java b/wu-lazy-cloud-heartbeat-common/src/main/java/org/framework/lazy/cloud/network/heartbeat/common/constant/ProxyMessageType.java index 070f79c..0fdd489 100644 --- a/wu-lazy-cloud-heartbeat-common/src/main/java/org/framework/lazy/cloud/network/heartbeat/common/constant/ProxyMessageType.java +++ b/wu-lazy-cloud-heartbeat-common/src/main/java/org/framework/lazy/cloud/network/heartbeat/common/constant/ProxyMessageType.java @@ -6,6 +6,12 @@ import org.framework.lazy.cloud.network.heartbeat.common.advanced.proxy.http.Abs import org.framework.lazy.cloud.network.heartbeat.common.advanced.proxy.http.client.*; import org.framework.lazy.cloud.network.heartbeat.common.advanced.proxy.http.server.*; import org.framework.lazy.cloud.network.heartbeat.common.advanced.proxy.socket.AbstractHandleSocketLocalProxyTypeAdvanced; +import org.framework.lazy.cloud.network.heartbeat.common.advanced.proxy.socket.client.AbstractHandleSocksDistributeClientProxyServerConnectionTransferSuccessTypeAdvanced; +import org.framework.lazy.cloud.network.heartbeat.common.advanced.proxy.socket.client.AbstractHandleSocksDistributeClientProxyServerTransferResponseTypeAdvanced; +import org.framework.lazy.cloud.network.heartbeat.common.advanced.proxy.socket.client.AbstractHandleSocksDistributeClientProxyServerTransferCloseTypeAdvanced; +import org.framework.lazy.cloud.network.heartbeat.common.advanced.proxy.socket.server.AbstractHandleSocksReportClientProxyServerConnectionTransferTypeAdvanced; +import org.framework.lazy.cloud.network.heartbeat.common.advanced.proxy.socket.server.AbstractHandleSocksReportClientProxyServerTransferRequestTypeAdvanced; +import org.framework.lazy.cloud.network.heartbeat.common.advanced.proxy.socket.server.AbstractHandleSocksReportClientProxyServerTransferCloseTypeAdvanced; import org.framework.lazy.cloud.network.heartbeat.common.enums.ProxyMessageTypeEnums; /** @@ -150,13 +156,74 @@ public class ProxyMessageType { */ public static final byte SOCKET_CLIENT_PROXY_SERVER_ = SOCKET_CLIENT_PROXY_CLIENT_ + 1; + + /** + * socket 上报客户端代理服务端传输通道连接成功 + * + * @see ProxyMessageTypeEnums#SOCKS_REPORT_CLIENT_PROXY_SERVER_TRANSFER_CONNECTION_ + * @see AbstractHandleSocksReportClientProxyServerConnectionTransferTypeAdvanced + */ + public static final byte SOCKS_REPORT_CLIENT_PROXY_SERVER_TRANSFER_CONNECTION_ = SOCKET_CLIENT_PROXY_SERVER_ + 1; + + /** + * socket 下发客户端代理服务端传输通道连接成功 + * + * @see ProxyMessageTypeEnums#SOCKS_DISTRIBUTE_CLIENT_PROXY_SERVER_TRANSFER_CONNECTION_SUCCESS_ + * @see AbstractHandleSocksDistributeClientProxyServerConnectionTransferSuccessTypeAdvanced + */ + public static final byte SOCKS_DISTRIBUTE_CLIENT_PROXY_SERVER_TRANSFER_CONNECTION_SUCCESS_ = SOCKS_REPORT_CLIENT_PROXY_SERVER_TRANSFER_CONNECTION_ + 1; + + + /** + * socket 下发客户端代理服务端传输通道连接失败 + * + * @see ProxyMessageTypeEnums#SOCKS_DISTRIBUTE_CLIENT_PROXY_SERVER_TRANSFER_CONNECTION_FAIL_ + * @see AbstractHandleSocksDistributeClientProxyServerConnectionTransferSuccessTypeAdvanced + */ + public static final byte SOCKS_DISTRIBUTE_CLIENT_PROXY_SERVER_TRANSFER_CONNECTION_FAIL_ = SOCKS_DISTRIBUTE_CLIENT_PROXY_SERVER_TRANSFER_CONNECTION_SUCCESS_ + 1; + + + /** + * socket 上报客户端代理服务端请求 + * + * @see ProxyMessageTypeEnums#SOCKS_REPORT_CLIENT_PROXY_SERVER_TRANSFER_REQUEST_ + * @see AbstractHandleSocksReportClientProxyServerTransferRequestTypeAdvanced + */ + public static final byte SOCKS_REPORT_CLIENT_PROXY_SERVER_TRANSFER_REQUEST_ = SOCKS_DISTRIBUTE_CLIENT_PROXY_SERVER_TRANSFER_CONNECTION_FAIL_ + 1; + + + /** + * socket 下发客户端代理服务端数据返回 + * + * @see ProxyMessageTypeEnums#SOCKS_DISTRIBUTE_CLIENT_PROXY_SERVER_TRANSFER_RESPONSE_ + * @see AbstractHandleSocksDistributeClientProxyServerTransferResponseTypeAdvanced + */ + public static final byte SOCKS_DISTRIBUTE_CLIENT_PROXY_SERVER_TRANSFER_RESPONSE_ = SOCKS_REPORT_CLIENT_PROXY_SERVER_TRANSFER_REQUEST_ + 1; + + /** + * socket 上报客户端代理服务端传输通道关闭 + * + * @see ProxyMessageTypeEnums#SOCKS_REPORT_CLIENT_PROXY_SERVER_TRANSFER_CLOSE_ + * @see AbstractHandleSocksReportClientProxyServerTransferCloseTypeAdvanced + */ + public static final byte SOCKS_REPORT_CLIENT_PROXY_SERVER_TRANSFER_CLOSE_ = SOCKS_DISTRIBUTE_CLIENT_PROXY_SERVER_TRANSFER_RESPONSE_ + 1; + + /** + * socket 下发客户端代理服务端传输通道关闭 + * + * @see ProxyMessageTypeEnums#SOCKS_DISTRIBUTE_CLIENT_PROXY_SERVER_TRANSFER_CLOSE_ + * @see AbstractHandleSocksDistributeClientProxyServerTransferCloseTypeAdvanced + */ + public static final byte SOCKS_DISTRIBUTE_CLIENT_PROXY_SERVER_TRANSFER_CLOSE_ = SOCKS_REPORT_CLIENT_PROXY_SERVER_TRANSFER_CLOSE_ + 1; + + /** * socket 服务端代理客户端 * * @see ProxyMessageTypeEnums#SOCKET_SERVER_PROXY_CLIENT_ * @see AbstractHandleSocketServerProxyClientTypeAdvanced */ - public static final byte SOCKET_SERVER_PROXY_CLIENT_ = SOCKET_CLIENT_PROXY_SERVER_ + 1; + public static final byte SOCKET_SERVER_PROXY_CLIENT_ = SOCKS_DISTRIBUTE_CLIENT_PROXY_SERVER_TRANSFER_CLOSE_ + 1; public static final byte HTTP_DISTRIBUTE_PROXY = -96; diff --git a/wu-lazy-cloud-heartbeat-common/src/main/java/org/framework/lazy/cloud/network/heartbeat/common/enums/ProxyMessageTypeEnums.java b/wu-lazy-cloud-heartbeat-common/src/main/java/org/framework/lazy/cloud/network/heartbeat/common/enums/ProxyMessageTypeEnums.java index 211708a..5e22b84 100644 --- a/wu-lazy-cloud-heartbeat-common/src/main/java/org/framework/lazy/cloud/network/heartbeat/common/enums/ProxyMessageTypeEnums.java +++ b/wu-lazy-cloud-heartbeat-common/src/main/java/org/framework/lazy/cloud/network/heartbeat/common/enums/ProxyMessageTypeEnums.java @@ -2,15 +2,16 @@ package org.framework.lazy.cloud.network.heartbeat.common.enums; import lombok.AllArgsConstructor; import lombok.Getter; -import org.framework.lazy.cloud.network.heartbeat.common.advanced.permeate.tcp.AbstractTcpHandleChannelHeartbeatTypeAdvanced; -import org.framework.lazy.cloud.network.heartbeat.common.advanced.permeate.tcp.client.*; -import org.framework.lazy.cloud.network.heartbeat.common.advanced.permeate.tcp.server.*; import org.framework.lazy.cloud.network.heartbeat.common.advanced.proxy.http.AbstractHttpClientProxyClientTypeAdvanced; import org.framework.lazy.cloud.network.heartbeat.common.advanced.proxy.http.AbstractHttpClientProxyServerTypeAdvanced; import org.framework.lazy.cloud.network.heartbeat.common.advanced.proxy.http.AbstractHttpLocalProxyTypeAdvanced; import org.framework.lazy.cloud.network.heartbeat.common.advanced.proxy.http.client.*; import org.framework.lazy.cloud.network.heartbeat.common.advanced.proxy.http.server.*; import org.framework.lazy.cloud.network.heartbeat.common.advanced.proxy.socket.AbstractHandleSocketLocalProxyTypeAdvanced; +import org.framework.lazy.cloud.network.heartbeat.common.advanced.proxy.socket.client.*; +import org.framework.lazy.cloud.network.heartbeat.common.advanced.proxy.socket.server.AbstractHandleSocksReportClientProxyServerConnectionTransferTypeAdvanced; +import org.framework.lazy.cloud.network.heartbeat.common.advanced.proxy.socket.server.AbstractHandleSocksReportClientProxyServerTransferRequestTypeAdvanced; +import org.framework.lazy.cloud.network.heartbeat.common.advanced.proxy.socket.server.AbstractHandleSocksReportClientProxyServerTransferCloseTypeAdvanced; import org.framework.lazy.cloud.network.heartbeat.common.constant.ProxyMessageType; import org.framework.lazy.cloud.network.heartbeat.common.constant.TcpMessageType; @@ -156,6 +157,81 @@ public enum ProxyMessageTypeEnums { * @see AbstractHandleSocketLocalProxyTypeAdvanced */ SOCKET_LOCAL_PROXY(ProxyMessageType.SOCKET_LOCAL_PROXY, "socket本地代理"), + /** + * socket 客户端代理客户端 + * + * @see ProxyMessageTypeEnums#SOCKET_CLIENT_PROXY_CLIENT_ + * @see AbstractHandleSocketClientProxyClietnTypeAdvanced + */ + SOCKET_CLIENT_PROXY_CLIENT_(ProxyMessageType.SOCKET_CLIENT_PROXY_CLIENT_, "socket 客户端代理客户端"), + /** + * socket 客户端代理服务端 + * + * @see ProxyMessageTypeEnums#SOCKET_CLIENT_PROXY_SERVER_ + * @see AbstractHandleSocketClientProxyServerTypeAdvanced + */ + SOCKET_CLIENT_PROXY_SERVER_(ProxyMessageType.SOCKET_CLIENT_PROXY_SERVER_, "socket 客户端代理服务端"), + + /** + * socket 上报客户端代理服务端传输通道连接成功 + * + * @see ProxyMessageTypeEnums#SOCKS_REPORT_CLIENT_PROXY_SERVER_TRANSFER_CONNECTION_ + * @see AbstractHandleSocksReportClientProxyServerConnectionTransferTypeAdvanced + */ + SOCKS_REPORT_CLIENT_PROXY_SERVER_TRANSFER_CONNECTION_(ProxyMessageType.SOCKS_REPORT_CLIENT_PROXY_SERVER_TRANSFER_CONNECTION_, "socket 上报客户端代理服务端传输通道连接成功"), + /** + * socket 下发客户端代理服务端传输通道连接成功 + * + * @see ProxyMessageTypeEnums#SOCKS_DISTRIBUTE_CLIENT_PROXY_SERVER_TRANSFER_CONNECTION_SUCCESS_ + * @see AbstractHandleSocksDistributeClientProxyServerConnectionTransferSuccessTypeAdvanced + */ + SOCKS_DISTRIBUTE_CLIENT_PROXY_SERVER_TRANSFER_CONNECTION_SUCCESS_(ProxyMessageType.SOCKS_DISTRIBUTE_CLIENT_PROXY_SERVER_TRANSFER_CONNECTION_SUCCESS_, "socket 下发客户端代理服务端传输通道连接成功"), + + /** + * socket 下发客户端代理服务端传输通道连接失败 + * + * @see ProxyMessageTypeEnums#SOCKS_DISTRIBUTE_CLIENT_PROXY_SERVER_TRANSFER_CONNECTION_FAIL_ + * @see AbstractHandleSocksDistributeClientProxyServerConnectionTransferFailTypeAdvanced + */ + SOCKS_DISTRIBUTE_CLIENT_PROXY_SERVER_TRANSFER_CONNECTION_FAIL_(ProxyMessageType.SOCKS_DISTRIBUTE_CLIENT_PROXY_SERVER_TRANSFER_CONNECTION_FAIL_, "socket 下发客户端代理服务端传输通道连接成功"), + + /** + * socket 上报客户端代理服务端请求 + * + * @see ProxyMessageTypeEnums#SOCKS_REPORT_CLIENT_PROXY_SERVER_TRANSFER_REQUEST_ + * @see AbstractHandleSocksReportClientProxyServerTransferRequestTypeAdvanced + */ + SOCKS_REPORT_CLIENT_PROXY_SERVER_TRANSFER_REQUEST_(ProxyMessageType.SOCKS_REPORT_CLIENT_PROXY_SERVER_TRANSFER_REQUEST_, "socket 上报客户端代理服务端请求"), + /** + * socket 下发客户端代理服务端数据返回 + * + * @see ProxyMessageTypeEnums#SOCKS_DISTRIBUTE_CLIENT_PROXY_SERVER_TRANSFER_RESPONSE_ + * @see AbstractHandleSocksDistributeClientProxyServerTransferResponseTypeAdvanced + */ + SOCKS_DISTRIBUTE_CLIENT_PROXY_SERVER_TRANSFER_RESPONSE_(ProxyMessageType.SOCKS_DISTRIBUTE_CLIENT_PROXY_SERVER_TRANSFER_RESPONSE_, "socket 下发客户端代理服务端数据返回"), + /** + * socket 上报客户端代理服务端传输通道关闭 + * + * @see ProxyMessageTypeEnums#SOCKS_REPORT_CLIENT_PROXY_SERVER_TRANSFER_CLOSE_ + * @see AbstractHandleSocksReportClientProxyServerTransferCloseTypeAdvanced + */ + SOCKS_REPORT_CLIENT_PROXY_SERVER_TRANSFER_CLOSE_(ProxyMessageType.SOCKS_REPORT_CLIENT_PROXY_SERVER_TRANSFER_CLOSE_, "socket 上报客户端代理服务端传输通道关闭"), + /** + * socket 下发客户端代理服务端传输通道关闭 + * + * @see ProxyMessageTypeEnums#SOCKS_DISTRIBUTE_CLIENT_PROXY_SERVER_TRANSFER_CLOSE_ + * @see AbstractHandleSocksDistributeClientProxyServerTransferCloseTypeAdvanced + */ + SOCKS_DISTRIBUTE_CLIENT_PROXY_SERVER_TRANSFER_CLOSE_(ProxyMessageType.SOCKS_DISTRIBUTE_CLIENT_PROXY_SERVER_TRANSFER_CLOSE_, "socket 下发客户端代理服务端传输通道关闭"), + + + /** + * socket 服务端代理客户端 + * + * @see ProxyMessageTypeEnums#SOCKET_SERVER_PROXY_CLIENT_ + * @see AbstractHandleSocketServerProxyClientTypeAdvanced + */ + SOCKET_SERVER_PROXY_CLIENT_(ProxyMessageType.SOCKET_SERVER_PROXY_CLIENT_, "socket 服务端代理客户端"), ; diff --git a/wu-lazy-cloud-heartbeat-common/src/main/java/org/framework/lazy/cloud/network/heartbeat/common/utils/ChannelAttributeKeyUtils.java b/wu-lazy-cloud-heartbeat-common/src/main/java/org/framework/lazy/cloud/network/heartbeat/common/utils/ChannelAttributeKeyUtils.java index 9a09bd5..4d11351 100644 --- a/wu-lazy-cloud-heartbeat-common/src/main/java/org/framework/lazy/cloud/network/heartbeat/common/utils/ChannelAttributeKeyUtils.java +++ b/wu-lazy-cloud-heartbeat-common/src/main/java/org/framework/lazy/cloud/network/heartbeat/common/utils/ChannelAttributeKeyUtils.java @@ -21,6 +21,7 @@ public class ChannelAttributeKeyUtils { private static final AttributeKey NEXT_CHANNEL = AttributeKey.newInstance("nextChannel"); private static final AttributeKey TRANSFER_NEXT_CHANNEL = AttributeKey.newInstance("transferNextChannel"); private static final AttributeKey NETTY_BYTE_BUF_DATA = AttributeKey.newInstance("nettyByteBufData"); + private static final AttributeKey NETTY_SOCKS5_ADDRESS_TYPE = AttributeKey.newInstance("socks5AddressType"); /** @@ -256,4 +257,23 @@ public class ChannelAttributeKeyUtils { public static String getOriginalIp(Channel channel) { return channel.attr(ORIGINAL_IP).get(); } + + /** + * 为通道绑定 请求地址类型 + * + * @param channel 通道 + * @param socks5AddressType 地址类型 + */ + public static void buildSocks5AddressType(Channel channel, Byte socks5AddressType) { + channel.attr(NETTY_SOCKS5_ADDRESS_TYPE).set(socks5AddressType); + } + + /** + * 获取 通道中 请求地址类型 + * + * @param channel 通道 + */ + public static Byte getSocks5AddressType(Channel channel) { + return channel.attr(NETTY_SOCKS5_ADDRESS_TYPE).get(); + } } diff --git a/wu-lazy-cloud-heartbeat-server/src/main/java/org/framework/lazy/cloud/network/heartbeat/server/config/ServerAutoConfiguration.java b/wu-lazy-cloud-heartbeat-server/src/main/java/org/framework/lazy/cloud/network/heartbeat/server/config/ServerAutoConfiguration.java index 8795ef8..5248896 100644 --- a/wu-lazy-cloud-heartbeat-server/src/main/java/org/framework/lazy/cloud/network/heartbeat/server/config/ServerAutoConfiguration.java +++ b/wu-lazy-cloud-heartbeat-server/src/main/java/org/framework/lazy/cloud/network/heartbeat/server/config/ServerAutoConfiguration.java @@ -5,6 +5,9 @@ import org.framework.lazy.cloud.network.heartbeat.common.adapter.ChannelFlowAdap import org.framework.lazy.cloud.network.heartbeat.server.netty.permeate.tcp.advanced.*; import org.framework.lazy.cloud.network.heartbeat.server.netty.permeate.udp.advanced.*; import org.framework.lazy.cloud.network.heartbeat.server.netty.proxy.http.advanced.*; +import org.framework.lazy.cloud.network.heartbeat.server.netty.proxy.socks.advanced.ServerHandleSocksReportClientProxyServerConnectTransferTypeAdvanced; +import org.framework.lazy.cloud.network.heartbeat.server.netty.proxy.socks.advanced.ServerHandleSocksReportClientProxyServerTransferCloseTypeAdvanced; +import org.framework.lazy.cloud.network.heartbeat.server.netty.proxy.socks.advanced.ServerHandleSocksReportClientProxyServerTransferRequestTypeAdvanced; import org.framework.lazy.cloud.network.heartbeat.server.properties.ServerNodeProperties; import org.framework.lazy.cloud.network.heartbeat.server.standalone.application.*; import org.springframework.beans.factory.config.BeanDefinition; @@ -248,4 +251,20 @@ public class ServerAutoConfiguration { return new ServerHandleHttpReportServerProxyClientTransferCloseTypeAdvanced(); } } + @Configuration + static class ServerSocksProxyConfiguration{ + + @Bean + public ServerHandleSocksReportClientProxyServerConnectTransferTypeAdvanced serverHandleSocksReportClientProxyServerConnectTransferTypeAdvanced(){ + return new ServerHandleSocksReportClientProxyServerConnectTransferTypeAdvanced(); + } + @Bean + public ServerHandleSocksReportClientProxyServerTransferCloseTypeAdvanced serverHandleSocksReportClientProxyServerTransferCloseTypeAdvanced(){ + return new ServerHandleSocksReportClientProxyServerTransferCloseTypeAdvanced(); + } + @Bean + public ServerHandleSocksReportClientProxyServerTransferRequestTypeAdvanced serverHandleSocksReportClientProxyServerTransferRequestTypeAdvanced(){ + return new ServerHandleSocksReportClientProxyServerTransferRequestTypeAdvanced(); + } + } } diff --git a/wu-lazy-cloud-heartbeat-server/src/main/java/org/framework/lazy/cloud/network/heartbeat/server/netty/proxy/socks/advanced/ServerHandleSocksReportClientProxyServerConnectTransferTypeAdvanced.java b/wu-lazy-cloud-heartbeat-server/src/main/java/org/framework/lazy/cloud/network/heartbeat/server/netty/proxy/socks/advanced/ServerHandleSocksReportClientProxyServerConnectTransferTypeAdvanced.java new file mode 100644 index 0000000..8e78016 --- /dev/null +++ b/wu-lazy-cloud-heartbeat-server/src/main/java/org/framework/lazy/cloud/network/heartbeat/server/netty/proxy/socks/advanced/ServerHandleSocksReportClientProxyServerConnectTransferTypeAdvanced.java @@ -0,0 +1,101 @@ +package org.framework.lazy.cloud.network.heartbeat.server.netty.proxy.socks.advanced; + + +import io.netty.bootstrap.Bootstrap; +import io.netty.channel.*; +import io.netty.channel.socket.SocketChannel; +import io.netty.channel.socket.nio.NioSocketChannel; +import io.netty.handler.codec.socksx.v5.DefaultSocks5CommandResponse; +import io.netty.handler.codec.socksx.v5.Socks5AddressType; +import io.netty.handler.codec.socksx.v5.Socks5CommandStatus; +import lombok.extern.slf4j.Slf4j; +import org.framework.lazy.cloud.network.heartbeat.common.NettyTransferChannelContext; +import org.framework.lazy.cloud.network.heartbeat.common.advanced.payload.NettyChannelContext; +import org.framework.lazy.cloud.network.heartbeat.common.advanced.payload.NettyProxyMsg; +import org.framework.lazy.cloud.network.heartbeat.common.advanced.proxy.socket.server.AbstractHandleSocksReportClientProxyServerConnectionTransferTypeAdvanced; +import org.framework.lazy.cloud.network.heartbeat.common.constant.ProxyMessageType; +import org.framework.lazy.cloud.network.heartbeat.common.decoder.TransferDecoder; +import org.framework.lazy.cloud.network.heartbeat.common.factory.EventLoopGroupFactory; +import org.framework.lazy.cloud.network.heartbeat.common.utils.ChannelAttributeKeyUtils; +import org.framework.lazy.cloud.network.heartbeat.server.netty.proxy.socks.handler.NettySocksClientProxyServerRealHandler; +import org.springframework.beans.factory.config.BeanDefinition; +import org.springframework.context.annotation.Role; +import org.springframework.stereotype.Component; + +import java.net.InetSocketAddress; + + +@Role(BeanDefinition.ROLE_INFRASTRUCTURE) +@Slf4j +@Component +public class ServerHandleSocksReportClientProxyServerConnectTransferTypeAdvanced + extends AbstractHandleSocksReportClientProxyServerConnectionTransferTypeAdvanced { + + + /** + * 处理当前数据 + * + * @param nettyChannelContext 当前通道 + * @param nettyProxyMsg 通道数据 + */ + @Override + public void doHandler(NettyChannelContext nettyChannelContext, NettyProxyMsg nettyProxyMsg) { + Channel transferChannel = nettyChannelContext.channel(); + + + String host = nettyProxyMsg.getTargetIpString(); + Integer port = Integer.parseInt(nettyProxyMsg.getTargetPortString()); + byte[] data = nettyProxyMsg.getData(); + byte[] visitorId = nettyProxyMsg.getVisitorId(); + byte[] clientId = nettyProxyMsg.getClientId(); + String msgVisitorId = new String(visitorId); + ChannelAttributeKeyUtils.buildClientId(transferChannel, clientId); + ChannelAttributeKeyUtils.buildVisitorId(transferChannel, msgVisitorId); + + NettyTransferChannelContext.pushVisitor(transferChannel, msgVisitorId); + Socks5AddressType socks5AddressType = Socks5AddressType.valueOf(data[0]); + + // 创建真实代理链接 + EventLoopGroup group = EventLoopGroupFactory.createClientWorkGroup(); + Bootstrap b = new Bootstrap(); + b.group(group) + .channel(NioSocketChannel.class) + .option(ChannelOption.TCP_NODELAY, true) + .handler(new ChannelInitializer() { + @Override + protected void initChannel(SocketChannel ch) { + ch.pipeline().addLast(new TransferDecoder(Integer.MAX_VALUE, 1024 * 1024 * 10)); + ch.pipeline().addLast(new NettySocksClientProxyServerRealHandler()); + } + }); + log.info("准备连接目标服务器，ip = {},port = {}", host, port); + ChannelFuture f = b.connect(new InetSocketAddress(host, port)); + f.addListener((ChannelFutureListener) future -> { + Channel realChannel = future.channel(); + if (future.isSuccess()) { + + log.info("目标服务器连接成功"); + // 通道相互绑定 + ChannelAttributeKeyUtils.buildNextChannel(transferChannel, realChannel); + ChannelAttributeKeyUtils.buildNextChannel(realChannel, transferChannel); + + // 传输通道连接成功下发 + NettyProxyMsg transferNettyProxyMsg = new NettyProxyMsg(); + + transferNettyProxyMsg.setType(ProxyMessageType.SOCKS_DISTRIBUTE_CLIENT_PROXY_SERVER_TRANSFER_CONNECTION_SUCCESS_); + transferChannel.writeAndFlush(transferNettyProxyMsg); + + } else { + log.error("连接目标服务器失败,address={},port={}", host, port); + DefaultSocks5CommandResponse commandResponse = new DefaultSocks5CommandResponse(Socks5CommandStatus.FAILURE, socks5AddressType); + transferChannel.writeAndFlush(commandResponse); + realChannel.close(); + } + + }); + + // TODO 下发 连接真实服务成功、客户端可以采集数据了 + + } + +} diff --git a/wu-lazy-cloud-heartbeat-server/src/main/java/org/framework/lazy/cloud/network/heartbeat/server/netty/proxy/socks/advanced/ServerHandleSocksReportClientProxyServerTransferCloseTypeAdvanced.java b/wu-lazy-cloud-heartbeat-server/src/main/java/org/framework/lazy/cloud/network/heartbeat/server/netty/proxy/socks/advanced/ServerHandleSocksReportClientProxyServerTransferCloseTypeAdvanced.java new file mode 100644 index 0000000..7d65918 --- /dev/null +++ b/wu-lazy-cloud-heartbeat-server/src/main/java/org/framework/lazy/cloud/network/heartbeat/server/netty/proxy/socks/advanced/ServerHandleSocksReportClientProxyServerTransferCloseTypeAdvanced.java @@ -0,0 +1,36 @@ +package org.framework.lazy.cloud.network.heartbeat.server.netty.proxy.socks.advanced; + + +import io.netty.channel.*; +import lombok.extern.slf4j.Slf4j; +import org.framework.lazy.cloud.network.heartbeat.common.advanced.payload.NettyChannelContext; +import org.framework.lazy.cloud.network.heartbeat.common.advanced.payload.NettyProxyMsg; +import org.framework.lazy.cloud.network.heartbeat.common.advanced.proxy.socket.server.AbstractHandleSocksReportClientProxyServerTransferCloseTypeAdvanced; +import org.springframework.beans.factory.config.BeanDefinition; +import org.springframework.context.annotation.Role; +import org.springframework.stereotype.Component; + + +@Role(BeanDefinition.ROLE_INFRASTRUCTURE) +@Slf4j +@Component +public class ServerHandleSocksReportClientProxyServerTransferCloseTypeAdvanced + extends AbstractHandleSocksReportClientProxyServerTransferCloseTypeAdvanced { + + + /** + * 处理当前数据 + * + * @param nettyChannelContext 当前通道 + * @param nettyProxyMsg 通道数据 + */ + @Override + public void doHandler(NettyChannelContext nettyChannelContext, NettyProxyMsg nettyProxyMsg) { + Channel transferChannel = nettyChannelContext.channel(); + + + + + } + +} diff --git a/wu-lazy-cloud-heartbeat-server/src/main/java/org/framework/lazy/cloud/network/heartbeat/server/netty/proxy/socks/advanced/ServerHandleSocksReportClientProxyServerTransferRequestTypeAdvanced.java b/wu-lazy-cloud-heartbeat-server/src/main/java/org/framework/lazy/cloud/network/heartbeat/server/netty/proxy/socks/advanced/ServerHandleSocksReportClientProxyServerTransferRequestTypeAdvanced.java new file mode 100644 index 0000000..869af33 --- /dev/null +++ b/wu-lazy-cloud-heartbeat-server/src/main/java/org/framework/lazy/cloud/network/heartbeat/server/netty/proxy/socks/advanced/ServerHandleSocksReportClientProxyServerTransferRequestTypeAdvanced.java @@ -0,0 +1,48 @@ +package org.framework.lazy.cloud.network.heartbeat.server.netty.proxy.socks.advanced; + + +import io.netty.buffer.ByteBuf; +import io.netty.channel.Channel; +import lombok.extern.slf4j.Slf4j; +import org.framework.lazy.cloud.network.heartbeat.common.advanced.payload.NettyChannelContext; +import org.framework.lazy.cloud.network.heartbeat.common.advanced.payload.NettyProxyMsg; +import org.framework.lazy.cloud.network.heartbeat.common.advanced.proxy.socket.server.AbstractHandleSocksReportClientProxyServerTransferRequestTypeAdvanced; +import org.framework.lazy.cloud.network.heartbeat.common.utils.ChannelAttributeKeyUtils; +import org.framework.lazy.cloud.network.heartbeat.server.netty.proxy.socks.handler.NettySocksClientProxyServerRealHandler; +import org.springframework.beans.factory.config.BeanDefinition; +import org.springframework.context.annotation.Role; +import org.springframework.stereotype.Component; +import org.wu.framework.core.utils.ObjectUtils; + + +@Role(BeanDefinition.ROLE_INFRASTRUCTURE) +@Slf4j +@Component +public class ServerHandleSocksReportClientProxyServerTransferRequestTypeAdvanced + extends AbstractHandleSocksReportClientProxyServerTransferRequestTypeAdvanced { + + + /** + * 处理当前数据 + * + * @param nettyChannelContext 当前通道 + * @param nettyProxyMsg 通道数据 + * @see NettySocksClientProxyServerRealHandler + */ + @Override + public void doHandler(NettyChannelContext nettyChannelContext, NettyProxyMsg nettyProxyMsg) { + Channel transferChannel = nettyChannelContext.channel(); + // 目标通道 + Channel nextChannel = ChannelAttributeKeyUtils.getNextChannel(transferChannel); + // 目标数据发送 + if (ObjectUtils.isNotEmpty(nextChannel) && nextChannel.isActive()) { + ByteBuf buf = nextChannel.config().getAllocator().buffer(nettyProxyMsg.getData().length); + buf.writeBytes(nettyProxyMsg.getData()); + nextChannel.writeAndFlush(buf); + } else { + log.error("当前目标通道已经关闭或者不存在"); + } + + } + +} diff --git a/wu-lazy-cloud-heartbeat-server/src/main/java/org/framework/lazy/cloud/network/heartbeat/server/netty/proxy/socks/handler/NettySocksClientProxyServerRealHandler.java b/wu-lazy-cloud-heartbeat-server/src/main/java/org/framework/lazy/cloud/network/heartbeat/server/netty/proxy/socks/handler/NettySocksClientProxyServerRealHandler.java new file mode 100644 index 0000000..b0fe028 --- /dev/null +++ b/wu-lazy-cloud-heartbeat-server/src/main/java/org/framework/lazy/cloud/network/heartbeat/server/netty/proxy/socks/handler/NettySocksClientProxyServerRealHandler.java @@ -0,0 +1,68 @@ +package org.framework.lazy.cloud.network.heartbeat.server.netty.proxy.socks.handler; + +import io.netty.buffer.Unpooled; +import io.netty.channel.Channel; +import io.netty.channel.ChannelFutureListener; +import io.netty.channel.ChannelHandlerContext; +import io.netty.channel.SimpleChannelInboundHandler; +import io.netty.util.ReferenceCountUtil; +import lombok.extern.slf4j.Slf4j; +import org.framework.lazy.cloud.network.heartbeat.common.NettyByteBuf; +import org.framework.lazy.cloud.network.heartbeat.common.advanced.payload.NettyProxyMsg; +import org.framework.lazy.cloud.network.heartbeat.common.constant.ProxyMessageType; +import org.framework.lazy.cloud.network.heartbeat.common.utils.ChannelAttributeKeyUtils; + + +@Slf4j +public class NettySocksClientProxyServerRealHandler extends SimpleChannelInboundHandler { + + + + @Override + public void channelActive(ChannelHandlerContext ctx) { + ctx.writeAndFlush(Unpooled.EMPTY_BUFFER); + } + + @Override + public void channelRead0(ChannelHandlerContext ctx, NettyByteBuf nettyByteBuf) throws Exception { + log.trace("开始写回客户端数据"); + // 结果下发 + Channel channel = ctx.channel(); + byte[] bytes = nettyByteBuf.getData(); + log.debug("bytes.length:{}", bytes.length); + log.debug("客户端socks代理服务端接收服务端真实服务数据:{}", new String(bytes)); + Channel nextChannel = ChannelAttributeKeyUtils.getNextChannel(channel); + if (nextChannel.isActive()) { + // 将数据返回给客户端 + NettyProxyMsg nettyProxyMsgResponse = new NettyProxyMsg(); + nettyProxyMsgResponse.setType(ProxyMessageType.SOCKS_DISTRIBUTE_CLIENT_PROXY_SERVER_TRANSFER_RESPONSE_); + nettyProxyMsgResponse.setData(bytes); + + nextChannel.writeAndFlush(nettyProxyMsgResponse); + } else { + log.info("释放内存"); + ReferenceCountUtil.release(nettyByteBuf); + } + } + + @Override + public void channelInactive(ChannelHandlerContext ctx) throws Exception { + log.trace("代理服务器和目标服务器的连接已经断开，即将断开客户端和代理服务器的连接"); + Channel channel = ctx.channel(); + Channel nextChannel = ChannelAttributeKeyUtils.getNextChannel(channel); + if (nextChannel.isActive()) { + // 下发关闭请求 + NettyProxyMsg nettyProxyMsgClose = new NettyProxyMsg(); + nettyProxyMsgClose.setType(ProxyMessageType.SOCKS_DISTRIBUTE_CLIENT_PROXY_SERVER_TRANSFER_CLOSE_); + nextChannel.writeAndFlush(nettyProxyMsgClose); + + nextChannel.writeAndFlush(Unpooled.EMPTY_BUFFER).addListener(ChannelFutureListener.CLOSE); + } + } + + @Override + public void exceptionCaught(ChannelHandlerContext ctx, Throwable cause) throws Exception { + log.error("NettySocksClientProxyServerRealHandler exception", cause); + ctx.close(); + } +}