From fe3adeee03fac9a0360c07cdfd952b3571f8772e Mon Sep 17 00:00:00 2001 From: wujiawei <12345678> Date: Wed, 7 May 2025 17:47:23 +0800 Subject: [PATCH] =?UTF-8?q?=E3=80=90fix=E3=80=91=E6=B7=BB=E5=8A=A0=20@Role?= =?UTF-8?q?(BeanDefinition.ROLE=5FINFRASTRUCTURE)?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- .../config/ClientAutoConfiguration.java | 12 ++ ...ProxyClientConnectionInitTypeAdvanced.java | 73 ++++++++ ...eServerProxyClientRequestTypeAdvanced.java | 43 +++++ ...erverProxyClientTransferCloseAdvanced.java | 34 ++++ ...NettySocksServerProxyClientRealFilter.java | 28 +++ ...ySocksServerProxyClientTransferFilter.java | 44 +++++ ...erverProxyClientVisitorInboundHandler.java | 72 ++++++++ ...ettySocksClientProxyClientRealHandler.java | 2 +- ...ettySocksServerProxyClientRealHandler.java | 82 +++++++++ ...SocksServerProxyClientTransferHandler.java | 70 ++++++++ ...NettySocksServerProxyClientRealSocket.java | 166 ++++++++++++++++++ ...ProxyClientConnectionInitTypeAdvanced.java | 21 +++ ...eServerProxyClientRequestTypeAdvanced.java | 21 +++ ...erverProxyClientTransferCloseAdvanced.java | 21 +++ ...xyClientConnectionSuccessTypeAdvanced.java | 21 +++ ...ServerProxyClientResponseTypeAdvanced.java | 21 +++ ...rProxyClientTransferCloseTypeAdvanced.java | 21 +++ ...sReportServerProxyClientTypeAdvanced.java} | 2 +- .../common/constant/ProxyMessageType.java | 46 ++++- .../common/enums/ProxyMessageTypeEnums.java | 44 ++++- .../utils/ChannelAttributeKeyUtils.java | 8 +- .../config/ServerAutoConfiguration.java | 17 +- ...roxyClientConnectTransferTypeAdvanced.java | 45 ----- ...xyClientConnectionSuccessTypeAdvanced.java | 67 +++++++ ...ServerProxyClientResponseTypeAdvanced.java | 47 +++++ ...rProxyClientTransferCloseTypeAdvanced.java | 39 ++++ ...ksReportServerProxyClientTypeAdvanced.java | 73 ++++++++ ...dleSocksServerProxyClientTypeAdvanced.java | 123 ------------- 28 files changed, 1086 insertions(+), 177 deletions(-) create mode 100644 wu-lazy-cloud-heartbeat-client/src/main/java/org/framework/lazy/cloud/network/heartbeat/client/netty/proxy/socks/advanced/ClientHandleSocksDistributeServerProxyClientConnectionInitTypeAdvanced.java create mode 100644 wu-lazy-cloud-heartbeat-client/src/main/java/org/framework/lazy/cloud/network/heartbeat/client/netty/proxy/socks/advanced/ClientHandleSocksDistributeServerProxyClientRequestTypeAdvanced.java create mode 100644 wu-lazy-cloud-heartbeat-client/src/main/java/org/framework/lazy/cloud/network/heartbeat/client/netty/proxy/socks/advanced/ClientHandleSocksDistributeServerProxyClientTransferCloseAdvanced.java create mode 100644 wu-lazy-cloud-heartbeat-client/src/main/java/org/framework/lazy/cloud/network/heartbeat/client/netty/proxy/socks/filter/NettySocksServerProxyClientRealFilter.java create mode 100644 wu-lazy-cloud-heartbeat-client/src/main/java/org/framework/lazy/cloud/network/heartbeat/client/netty/proxy/socks/filter/NettySocksServerProxyClientTransferFilter.java create mode 100644 wu-lazy-cloud-heartbeat-client/src/main/java/org/framework/lazy/cloud/network/heartbeat/client/netty/proxy/socks/handler/NettyServerProxyClientVisitorInboundHandler.java create mode 100644 wu-lazy-cloud-heartbeat-client/src/main/java/org/framework/lazy/cloud/network/heartbeat/client/netty/proxy/socks/handler/NettySocksServerProxyClientRealHandler.java create mode 100644 wu-lazy-cloud-heartbeat-client/src/main/java/org/framework/lazy/cloud/network/heartbeat/client/netty/proxy/socks/handler/NettySocksServerProxyClientTransferHandler.java create mode 100644 wu-lazy-cloud-heartbeat-client/src/main/java/org/framework/lazy/cloud/network/heartbeat/client/netty/proxy/socks/socket/NettySocksServerProxyClientRealSocket.java create mode 100644 wu-lazy-cloud-heartbeat-common/src/main/java/org/framework/lazy/cloud/network/heartbeat/common/advanced/proxy/socks/client/AbstractHandleSocksDistributeServerProxyClientConnectionInitTypeAdvanced.java create mode 100644 wu-lazy-cloud-heartbeat-common/src/main/java/org/framework/lazy/cloud/network/heartbeat/common/advanced/proxy/socks/client/AbstractHandleSocksDistributeServerProxyClientRequestTypeAdvanced.java create mode 100644 wu-lazy-cloud-heartbeat-common/src/main/java/org/framework/lazy/cloud/network/heartbeat/common/advanced/proxy/socks/client/AbstractHandleSocksDistributeServerProxyClientTransferCloseAdvanced.java create mode 100644 wu-lazy-cloud-heartbeat-common/src/main/java/org/framework/lazy/cloud/network/heartbeat/common/advanced/proxy/socks/server/AbstractHandleSocksReportServerProxyClientConnectionSuccessTypeAdvanced.java create mode 100644 wu-lazy-cloud-heartbeat-common/src/main/java/org/framework/lazy/cloud/network/heartbeat/common/advanced/proxy/socks/server/AbstractHandleSocksReportServerProxyClientResponseTypeAdvanced.java create mode 100644 wu-lazy-cloud-heartbeat-common/src/main/java/org/framework/lazy/cloud/network/heartbeat/common/advanced/proxy/socks/server/AbstractHandleSocksReportServerProxyClientTransferCloseTypeAdvanced.java rename wu-lazy-cloud-heartbeat-common/src/main/java/org/framework/lazy/cloud/network/heartbeat/common/advanced/proxy/socks/server/{AbstractHandleSocksServerProxyClientTypeAdvanced.java => AbstractHandleSocksReportServerProxyClientTypeAdvanced.java} (81%) create mode 100644 wu-lazy-cloud-heartbeat-server/src/main/java/org/framework/lazy/cloud/network/heartbeat/server/netty/proxy/socks/advanced/ServerHandleSocksReportServerProxyClientConnectionSuccessTypeAdvanced.java create mode 100644 wu-lazy-cloud-heartbeat-server/src/main/java/org/framework/lazy/cloud/network/heartbeat/server/netty/proxy/socks/advanced/ServerHandleSocksReportServerProxyClientResponseTypeAdvanced.java create mode 100644 wu-lazy-cloud-heartbeat-server/src/main/java/org/framework/lazy/cloud/network/heartbeat/server/netty/proxy/socks/advanced/ServerHandleSocksReportServerProxyClientTransferCloseTypeAdvanced.java create mode 100644 wu-lazy-cloud-heartbeat-server/src/main/java/org/framework/lazy/cloud/network/heartbeat/server/netty/proxy/socks/advanced/ServerHandleSocksReportServerProxyClientTypeAdvanced.java delete mode 100644 wu-lazy-cloud-heartbeat-server/src/main/java/org/framework/lazy/cloud/network/heartbeat/server/netty/proxy/socks/advanced/ServerHandleSocksServerProxyClientTypeAdvanced.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 8a8e994..9829370 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 @@ -443,5 +443,17 @@ public class ClientAutoConfiguration { public ClientHandleDistributeSocksClientProxyClientTransferTransferRequestAdvanced clientHandleDistributeSocksClientProxyClientTransferTransferRequestAdvanced(){ return new ClientHandleDistributeSocksClientProxyClientTransferTransferRequestAdvanced(); } + @Bean + public ClientHandleSocksDistributeServerProxyClientConnectionInitTypeAdvanced clientHandleSocksDistributeServerProxyClientConnectionInitTypeAdvanced(){ + return new ClientHandleSocksDistributeServerProxyClientConnectionInitTypeAdvanced(); + } + @Bean + public ClientHandleSocksDistributeServerProxyClientRequestTypeAdvanced clientHandleSocksDistributeServerProxyClientRequestTypeAdvanced(){ + return new ClientHandleSocksDistributeServerProxyClientRequestTypeAdvanced(); + } + @Bean + public ClientHandleSocksDistributeServerProxyClientTransferCloseAdvanced clientHandleSocksDistributeServerProxyClientTransferCloseAdvanced(){ + return new ClientHandleSocksDistributeServerProxyClientTransferCloseAdvanced(); + } } } diff --git a/wu-lazy-cloud-heartbeat-client/src/main/java/org/framework/lazy/cloud/network/heartbeat/client/netty/proxy/socks/advanced/ClientHandleSocksDistributeServerProxyClientConnectionInitTypeAdvanced.java b/wu-lazy-cloud-heartbeat-client/src/main/java/org/framework/lazy/cloud/network/heartbeat/client/netty/proxy/socks/advanced/ClientHandleSocksDistributeServerProxyClientConnectionInitTypeAdvanced.java new file mode 100644 index 0000000..1343a90 --- /dev/null +++ b/wu-lazy-cloud-heartbeat-client/src/main/java/org/framework/lazy/cloud/network/heartbeat/client/netty/proxy/socks/advanced/ClientHandleSocksDistributeServerProxyClientConnectionInitTypeAdvanced.java @@ -0,0 +1,73 @@ +package org.framework.lazy.cloud.network.heartbeat.client.netty.proxy.socks.advanced; + +import io.netty.channel.Channel; +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.NettySocksClientProxyClient; +import org.framework.lazy.cloud.network.heartbeat.client.netty.proxy.socks.socket.NettySocksServerProxyClientRealSocket; +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.proxy.socks.client.AbstractHandleSocksDistributeServerProxyClientConnectionInitTypeAdvanced; +import org.framework.lazy.cloud.network.heartbeat.common.utils.ChannelAttributeKeyUtils; +import org.springframework.beans.factory.config.BeanDefinition; +import org.springframework.context.annotation.Role; +import org.wu.framework.spring.utils.SpringContextHolder; + +import java.util.ArrayList; +import java.util.List; + +@Role(BeanDefinition.ROLE_INFRASTRUCTURE) +@Slf4j +public class ClientHandleSocksDistributeServerProxyClientConnectionInitTypeAdvanced extends + AbstractHandleSocksDistributeServerProxyClientConnectionInitTypeAdvanced { + + + /** + * 处理当前数据 + * + * @param nettyChannelContext 当前通道 + * @param nettyProxyMsg 通道数据 + */ + @Override + protected void doHandler(NettyChannelContext nettyChannelContext, NettyProxyMsg nettyProxyMsg) { + + // 创建传输通道 + // 绑定真实通道 + + Channel channel = nettyChannelContext.channel(); + String clientId = nettyProxyMsg.getClientIdString(); + byte[] visitorId = nettyProxyMsg.getVisitorId(); + String targetIp = nettyProxyMsg.getTargetIpString(); + Integer targetPort = Integer.parseInt(nettyProxyMsg.getTargetPortString()); + + byte[] data = nettyProxyMsg.getData(); + byte socks5AddressType = data[0]; + + + List handleChannelTypeAdvancedList = new ArrayList<>(SpringContextHolder.getApplicationContext().getBeansOfType(HandleChannelTypeAdvanced.class).values()); + NettyClientProperties nettyClientProperties = SpringContextHolder.getBean(NettyClientProperties.class); + + NettySocksClientProxyClient nettySocksClientProxyClient = new NettySocksClientProxyClient(); + nettySocksClientProxyClient.setTargetClientId(clientId); + nettySocksClientProxyClient.setNettyClientProperties(nettyClientProperties); + nettySocksClientProxyClient.setHandleChannelTypeAdvancedList(handleChannelTypeAdvancedList); + nettySocksClientProxyClient.setTargetIp(targetIp); + nettySocksClientProxyClient.setTargetPort(targetPort); + + ChannelAttributeKeyUtils.buildVisitorId(channel, visitorId); + ChannelAttributeKeyUtils.buildSocks5AddressType(channel,socks5AddressType); + + // 创建真实通道 + NettySocksServerProxyClientRealSocket.buildRealServer( + clientId, + targetIp, + targetPort, + new String(visitorId), + nettyClientProperties, + handleChannelTypeAdvancedList + ); + + } +} diff --git a/wu-lazy-cloud-heartbeat-client/src/main/java/org/framework/lazy/cloud/network/heartbeat/client/netty/proxy/socks/advanced/ClientHandleSocksDistributeServerProxyClientRequestTypeAdvanced.java b/wu-lazy-cloud-heartbeat-client/src/main/java/org/framework/lazy/cloud/network/heartbeat/client/netty/proxy/socks/advanced/ClientHandleSocksDistributeServerProxyClientRequestTypeAdvanced.java new file mode 100644 index 0000000..811e63b --- /dev/null +++ b/wu-lazy-cloud-heartbeat-client/src/main/java/org/framework/lazy/cloud/network/heartbeat/client/netty/proxy/socks/advanced/ClientHandleSocksDistributeServerProxyClientRequestTypeAdvanced.java @@ -0,0 +1,43 @@ +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.client.netty.proxy.socks.handler.NettySocksServerProxyClientRealHandler; +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.socks.client.AbstractHandleSocksDistributeServerProxyClientRequestTypeAdvanced; +import org.framework.lazy.cloud.network.heartbeat.common.utils.ChannelAttributeKeyUtils; +import org.springframework.beans.factory.config.BeanDefinition; +import org.springframework.context.annotation.Role; +import org.wu.framework.core.utils.ObjectUtils; + +/** + * @see NettySocksServerProxyClientRealHandler + */ +@Role(BeanDefinition.ROLE_INFRASTRUCTURE) +@Slf4j +public class ClientHandleSocksDistributeServerProxyClientRequestTypeAdvanced extends + AbstractHandleSocksDistributeServerProxyClientRequestTypeAdvanced { + + + /** + * 处理当前数据 + * + * @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/ClientHandleSocksDistributeServerProxyClientTransferCloseAdvanced.java b/wu-lazy-cloud-heartbeat-client/src/main/java/org/framework/lazy/cloud/network/heartbeat/client/netty/proxy/socks/advanced/ClientHandleSocksDistributeServerProxyClientTransferCloseAdvanced.java new file mode 100644 index 0000000..6eb735c --- /dev/null +++ b/wu-lazy-cloud-heartbeat-client/src/main/java/org/framework/lazy/cloud/network/heartbeat/client/netty/proxy/socks/advanced/ClientHandleSocksDistributeServerProxyClientTransferCloseAdvanced.java @@ -0,0 +1,34 @@ +package org.framework.lazy.cloud.network.heartbeat.client.netty.proxy.socks.advanced; + +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.socks.client.AbstractHandleSocksDistributeServerProxyClientRequestTypeAdvanced; +import org.framework.lazy.cloud.network.heartbeat.common.advanced.proxy.socks.client.AbstractHandleSocksDistributeServerProxyClientTransferCloseAdvanced; +import org.framework.lazy.cloud.network.heartbeat.common.utils.ChannelAttributeKeyUtils; +import org.springframework.beans.factory.config.BeanDefinition; +import org.springframework.context.annotation.Role; + +@Role(BeanDefinition.ROLE_INFRASTRUCTURE) +@Slf4j +public class ClientHandleSocksDistributeServerProxyClientTransferCloseAdvanced extends + AbstractHandleSocksDistributeServerProxyClientTransferCloseAdvanced { + + + /** + * 处理当前数据 + * + * @param nettyChannelContext 当前通道 + * @param nettyProxyMsg 通道数据 + */ + @Override + protected void doHandler(NettyChannelContext nettyChannelContext, NettyProxyMsg nettyProxyMsg) { + // + Channel channel = nettyChannelContext.channel(); + Channel nextChannel = ChannelAttributeKeyUtils.getNextChannel(channel); + channel.close(); + nextChannel.close(); + + } +} diff --git a/wu-lazy-cloud-heartbeat-client/src/main/java/org/framework/lazy/cloud/network/heartbeat/client/netty/proxy/socks/filter/NettySocksServerProxyClientRealFilter.java b/wu-lazy-cloud-heartbeat-client/src/main/java/org/framework/lazy/cloud/network/heartbeat/client/netty/proxy/socks/filter/NettySocksServerProxyClientRealFilter.java new file mode 100644 index 0000000..6c34a3c --- /dev/null +++ b/wu-lazy-cloud-heartbeat-client/src/main/java/org/framework/lazy/cloud/network/heartbeat/client/netty/proxy/socks/filter/NettySocksServerProxyClientRealFilter.java @@ -0,0 +1,28 @@ +package org.framework.lazy.cloud.network.heartbeat.client.netty.proxy.socks.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.proxy.socks.handler.NettySocksClientProxyClientRealHandler; +import org.framework.lazy.cloud.network.heartbeat.client.netty.proxy.socks.handler.NettySocksServerProxyClientRealHandler; +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 NettySocksServerProxyClientRealFilter extends DebugChannelInitializer { + /** + * 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 NettySocksServerProxyClientRealHandler()); + + } +} diff --git a/wu-lazy-cloud-heartbeat-client/src/main/java/org/framework/lazy/cloud/network/heartbeat/client/netty/proxy/socks/filter/NettySocksServerProxyClientTransferFilter.java b/wu-lazy-cloud-heartbeat-client/src/main/java/org/framework/lazy/cloud/network/heartbeat/client/netty/proxy/socks/filter/NettySocksServerProxyClientTransferFilter.java new file mode 100644 index 0000000..56f08b4 --- /dev/null +++ b/wu-lazy-cloud-heartbeat-client/src/main/java/org/framework/lazy/cloud/network/heartbeat/client/netty/proxy/socks/filter/NettySocksServerProxyClientTransferFilter.java @@ -0,0 +1,44 @@ +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.NettySocksServerProxyClientTransferHandler; +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 NettySocksServerProxyClientTransferFilter extends DebugChannelInitializer { + private final ChannelTypeAdapter channelTypeAdapter; + + public NettySocksServerProxyClientTransferFilter(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 NettySocksServerProxyClientTransferHandler(channelTypeAdapter)); + } +} diff --git a/wu-lazy-cloud-heartbeat-client/src/main/java/org/framework/lazy/cloud/network/heartbeat/client/netty/proxy/socks/handler/NettyServerProxyClientVisitorInboundHandler.java b/wu-lazy-cloud-heartbeat-client/src/main/java/org/framework/lazy/cloud/network/heartbeat/client/netty/proxy/socks/handler/NettyServerProxyClientVisitorInboundHandler.java new file mode 100644 index 0000000..e59cf37 --- /dev/null +++ b/wu-lazy-cloud-heartbeat-client/src/main/java/org/framework/lazy/cloud/network/heartbeat/client/netty/proxy/socks/handler/NettyServerProxyClientVisitorInboundHandler.java @@ -0,0 +1,72 @@ +package org.framework.lazy.cloud.network.heartbeat.client.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 NettyServerProxyClientVisitorInboundHandler extends SimpleChannelInboundHandler { + + + + + @Override + public void channelActive(ChannelHandlerContext ctx) { + ctx.writeAndFlush(Unpooled.EMPTY_BUFFER); + } + + @Override + public void channelRead0(ChannelHandlerContext ctx, NettyByteBuf nettyByteBuf) throws Exception { + log.info("【socks】转发客户端的请求到代理服务器"); + // 结果下发 + 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 nettyProxyMsg = new NettyProxyMsg(); + nettyProxyMsg.setType(ProxyMessageType.SOCKS_DISTRIBUTE_SERVER_PROXY_CLIENT_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("【socks】客户端与代理服务器的连接已经断开，即将断开代理服务器和目标服务器的连接"); + Channel channel = ctx.channel(); + Channel nextChannel = ChannelAttributeKeyUtils.getNextChannel(channel); + if (nextChannel.isActive()) { + // 下发断开链接 + NettyProxyMsg nettyProxyMsgTransferClose = new NettyProxyMsg(); + nettyProxyMsgTransferClose.setType(ProxyMessageType.SOCKS_DISTRIBUTE_SERVER_PROXY_CLIENT_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("【socks】NettyServerProxyClientVisitorInboundHandler 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/NettySocksClientProxyClientRealHandler.java b/wu-lazy-cloud-heartbeat-client/src/main/java/org/framework/lazy/cloud/network/heartbeat/client/netty/proxy/socks/handler/NettySocksClientProxyClientRealHandler.java index 21c6bfa..fd968d5 100644 --- a/wu-lazy-cloud-heartbeat-client/src/main/java/org/framework/lazy/cloud/network/heartbeat/client/netty/proxy/socks/handler/NettySocksClientProxyClientRealHandler.java +++ b/wu-lazy-cloud-heartbeat-client/src/main/java/org/framework/lazy/cloud/network/heartbeat/client/netty/proxy/socks/handler/NettySocksClientProxyClientRealHandler.java @@ -53,7 +53,7 @@ public class NettySocksClientProxyClientRealHandler extends SimpleChannelInbound if (nextChannel != null) { // 上报关闭这个客户端的访客通道 NettyProxyMsg closeVisitorMsg = new NettyProxyMsg(); - closeVisitorMsg.setType(TcpMessageType.TCP_REPORT_CLIENT_PERMEATE_CLIENT_TRANSFER_CLOSE); + closeVisitorMsg.setType(ProxyMessageType.SOCKS_REPORT_CLIENT_PROXY_CLIENT_TRANSFER_CLOSE_); closeVisitorMsg.setVisitorId(visitorId); nextChannel.writeAndFlush(closeVisitorMsg); } diff --git a/wu-lazy-cloud-heartbeat-client/src/main/java/org/framework/lazy/cloud/network/heartbeat/client/netty/proxy/socks/handler/NettySocksServerProxyClientRealHandler.java b/wu-lazy-cloud-heartbeat-client/src/main/java/org/framework/lazy/cloud/network/heartbeat/client/netty/proxy/socks/handler/NettySocksServerProxyClientRealHandler.java new file mode 100644 index 0000000..2e7491e --- /dev/null +++ b/wu-lazy-cloud-heartbeat-client/src/main/java/org/framework/lazy/cloud/network/heartbeat/client/netty/proxy/socks/handler/NettySocksServerProxyClientRealHandler.java @@ -0,0 +1,82 @@ +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.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.constant.TcpMessageType; +import org.framework.lazy.cloud.network.heartbeat.common.utils.ChannelAttributeKeyUtils; + +/** + * 来自客户端 真实服务器返回的数据请求 + */ +@Slf4j +public class NettySocksServerProxyClientRealHandler extends SimpleChannelInboundHandler { + + + @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 nextChannel = ChannelAttributeKeyUtils.getNextChannel(ctx.channel()); + NettyProxyMsg returnMessage = new NettyProxyMsg(); + returnMessage.setType(ProxyMessageType.SOCKS_REPORT_SERVER_PROXY_CLIENT_TRANSFER_RESPONSE_); + returnMessage.setVisitorId(visitorId); + returnMessage.setClientId(clientId); + returnMessage.setVisitorPort(visitorPort); + returnMessage.setData(bytes); + + nextChannel.writeAndFlush(returnMessage); + } + + + @Override + public void channelActive(ChannelHandlerContext ctx) throws Exception { + super.channelActive(ctx); + } + + @Override + public void channelInactive(ChannelHandlerContext ctx) throws Exception { + String visitorId = ChannelAttributeKeyUtils.getVisitorId(ctx.channel()); + // 客户端真实通信通道 + Channel nextChannel = ChannelAttributeKeyUtils.getNextChannel(ctx.channel()); + if (nextChannel != null) { + // 上报关闭这个客户端的访客通道 + NettyProxyMsg closeVisitorMsg = new NettyProxyMsg(); + closeVisitorMsg.setType(ProxyMessageType.SOCKS_REPORT_SERVER_PROXY_CLIENT_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/handler/NettySocksServerProxyClientTransferHandler.java b/wu-lazy-cloud-heartbeat-client/src/main/java/org/framework/lazy/cloud/network/heartbeat/client/netty/proxy/socks/handler/NettySocksServerProxyClientTransferHandler.java new file mode 100644 index 0000000..88009db --- /dev/null +++ b/wu-lazy-cloud-heartbeat-client/src/main/java/org/framework/lazy/cloud/network/heartbeat/client/netty/proxy/socks/handler/NettySocksServerProxyClientTransferHandler.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 NettySocksServerProxyClientTransferHandler extends SimpleChannelInboundHandler { + private final ChannelTypeAdapter channelTypeAdapter; + + public NettySocksServerProxyClientTransferHandler(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 { + 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()); + log.warn("close client permeate client transfer real clientId:{} visitorId:{}", clientId, visitorId); + // 关闭访客 + if (nextChannel != null) { + + // 上报关闭这个客户端的访客通道 + NettyProxyMsg closeVisitorMsg = new NettyProxyMsg(); + closeVisitorMsg.setType(ProxyMessageType.SOCKS_REPORT_SERVER_PROXY_CLIENT_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/NettySocksServerProxyClientRealSocket.java b/wu-lazy-cloud-heartbeat-client/src/main/java/org/framework/lazy/cloud/network/heartbeat/client/netty/proxy/socks/socket/NettySocksServerProxyClientRealSocket.java new file mode 100644 index 0000000..4dacebb --- /dev/null +++ b/wu-lazy-cloud-heartbeat-client/src/main/java/org/framework/lazy/cloud/network/heartbeat/client/netty/proxy/socks/socket/NettySocksServerProxyClientRealSocket.java @@ -0,0 +1,166 @@ +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 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.filter.NettySocksClientProxyClientRealFilter; +import org.framework.lazy.cloud.network.heartbeat.client.netty.proxy.socks.filter.NettySocksClientProxyClientTransferFilter; +import org.framework.lazy.cloud.network.heartbeat.client.netty.proxy.socks.filter.NettySocksServerProxyClientRealFilter; +import org.framework.lazy.cloud.network.heartbeat.client.netty.proxy.socks.filter.NettySocksServerProxyClientTransferFilter; +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.advanced.HandleChannelTypeAdvanced; +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.List; +import java.util.concurrent.TimeUnit; + + +@Slf4j +public class NettySocksServerProxyClientRealSocket { + + + public static void buildRealServer(String clientId, + String targetIp, + Integer targetPort, + String visitorId, + NettyClientProperties nettyClientProperties, + List handleChannelTypeAdvancedList) { + + try { + EventLoopGroup eventLoopGroup = EventLoopGroupFactory.createClientWorkGroup(); + + Bootstrap bootstrap = new Bootstrap(); + bootstrap + .group(eventLoopGroup) + .channel(NioSocketChannel.class) + .option(ChannelOption.TCP_NODELAY, 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 NettySocksServerProxyClientRealFilter()) + ; + + + bootstrap.connect(targetIp, targetPort).addListener((ChannelFutureListener) future -> { + if (future.isSuccess()) { + // 客户端链接真实服务成功 设置自动读写false 等待访客连接成功后设置成true + Channel realChannel = future.channel(); + realChannel.config().setOption(ChannelOption.AUTO_READ, false); + + log.info("访客通过 客户端:【{}】,visitorId:{},绑定本地服务,IP:{},端口:{} 新建通道成功", clientId, visitorId, targetIp, targetPort); + // 客户端真实通道 + NettyRealIdContext.pushReal(realChannel, visitorId); + // 绑定访客ID到当前真实通道属性 + ChannelAttributeKeyUtils.buildVisitorId(realChannel, visitorId); + ChannelAttributeKeyUtils.buildClientId(realChannel, clientId); + + // 连接服务端 然后绑定通道 + // 新建一个通道处理 + newVisitorConnect2Server( + clientId, + targetIp, + targetPort, + visitorId, + realChannel, + nettyClientProperties, + handleChannelTypeAdvancedList + ); + } else { + log.error("客户：【{}】,无法连接当前网络内的目标IP：【{}】,目标端口:【{}】", clientId, targetIp, targetPort); + // DefaultSocks5CommandResponse commandResponse = new DefaultSocks5CommandResponse(Socks5CommandStatus.FAILURE, socks5AddressType); + // transferChannel.writeAndFlush(commandResponse); + // realChannel.close(); + } + }); + } catch (Exception e) { + e.printStackTrace(); + } + } + + /** + * 创建访客连接服务端 + * + * @param nettyClientProperties 服务端配置信息 + * @param handleChannelTypeAdvancedList 处理器适配器 + * @throws InterruptedException 异常 + */ + protected static void newVisitorConnect2Server(String clientId, + String targetIp, + Integer targetPort, + String visitorId, + Channel realChannel, + NettyClientProperties nettyClientProperties, + List handleChannelTypeAdvancedList) throws InterruptedException { + 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.TCP_NODELAY, false) + .option(ChannelOption.CONNECT_TIMEOUT_MILLIS, 1000 * 60)//连接超时时间设置为 60 秒 + .option(ChannelOption.WRITE_BUFFER_WATER_MARK, new WriteBufferWaterMark(1024 * 1024, 1024 * 1024 * 2)) + + .handler(new NettySocksServerProxyClientTransferFilter(new ChannelTypeAdapter(handleChannelTypeAdvancedList))) + ; + + String inetHost = nettyClientProperties.getInetHost(); + int inetPort = nettyClientProperties.getInetPort(); + // local client id + + + // 客户端新建访客通道 连接服务端IP:{},连接服务端端口:{} + log.info("client creates a new visitor channel to connect to server IP: {}, connecting to server port: {} with visitorId:{} & clientId:{}", inetHost, inetPort, visitorId, clientId); + ChannelFuture future = bootstrap.connect(inetHost, inetPort); + + future.addListener((ChannelFutureListener) futureListener -> { + Channel transferChannel = futureListener.channel(); + if (futureListener.isSuccess()) { + realChannel.config().setOption(ChannelOption.AUTO_READ, true); + // 通知服务端访客连接成功 + NettyProxyMsg nettyProxyMsg = new NettyProxyMsg(); + nettyProxyMsg.setVisitorId(visitorId); + nettyProxyMsg.setClientId(clientId); + nettyProxyMsg.setClientTargetIp(targetIp); + nettyProxyMsg.setClientTargetPort(targetPort); + nettyProxyMsg.setType(ProxyMessageType.SOCKS_REPORT_SERVER_PROXY_CLIENT_CONNECTION_SUCCESS_); + transferChannel.writeAndFlush(nettyProxyMsg); + + ChannelAttributeKeyUtils.buildNextChannel(transferChannel, realChannel); + ChannelAttributeKeyUtils.buildNextChannel(realChannel, transferChannel); + + // 绑定客户端真实通信通道 + ChannelAttributeKeyUtils.buildVisitorId(transferChannel, visitorId); + ChannelAttributeKeyUtils.buildClientId(transferChannel, clientId); + + + } else { + log.info("无法连接到服务端...."); + eventLoopGroup.schedule(() -> { + try { + newVisitorConnect2Server(clientId, + targetIp, + targetPort, + visitorId, realChannel, nettyClientProperties, handleChannelTypeAdvancedList); + } 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/socks/client/AbstractHandleSocksDistributeServerProxyClientConnectionInitTypeAdvanced.java b/wu-lazy-cloud-heartbeat-common/src/main/java/org/framework/lazy/cloud/network/heartbeat/common/advanced/proxy/socks/client/AbstractHandleSocksDistributeServerProxyClientConnectionInitTypeAdvanced.java new file mode 100644 index 0000000..02d2382 --- /dev/null +++ b/wu-lazy-cloud-heartbeat-common/src/main/java/org/framework/lazy/cloud/network/heartbeat/common/advanced/proxy/socks/client/AbstractHandleSocksDistributeServerProxyClientConnectionInitTypeAdvanced.java @@ -0,0 +1,21 @@ +package org.framework.lazy.cloud.network.heartbeat.common.advanced.proxy.socks.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 AbstractHandleSocksDistributeServerProxyClientConnectionInitTypeAdvanced extends AbstractHandleChannelTypeAdvanced implements HandleChannelTypeAdvanced { + + + /** + * 是否支持当前类型 + * + * @param nettyProxyMsg 通道数据 + * @return 布尔类型 是、否 + */ + @Override + protected boolean doSupport(NettyProxyMsg nettyProxyMsg) { + return ProxyMessageTypeEnums.SOCKS_DISTRIBUTE_SERVER_PROXY_CLIENT_CONNECTION_INIT_.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/socks/client/AbstractHandleSocksDistributeServerProxyClientRequestTypeAdvanced.java b/wu-lazy-cloud-heartbeat-common/src/main/java/org/framework/lazy/cloud/network/heartbeat/common/advanced/proxy/socks/client/AbstractHandleSocksDistributeServerProxyClientRequestTypeAdvanced.java new file mode 100644 index 0000000..f406d7d --- /dev/null +++ b/wu-lazy-cloud-heartbeat-common/src/main/java/org/framework/lazy/cloud/network/heartbeat/common/advanced/proxy/socks/client/AbstractHandleSocksDistributeServerProxyClientRequestTypeAdvanced.java @@ -0,0 +1,21 @@ +package org.framework.lazy.cloud.network.heartbeat.common.advanced.proxy.socks.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 AbstractHandleSocksDistributeServerProxyClientRequestTypeAdvanced extends AbstractHandleChannelTypeAdvanced implements HandleChannelTypeAdvanced { + + + /** + * 是否支持当前类型 + * + * @param nettyProxyMsg 通道数据 + * @return 布尔类型 是、否 + */ + @Override + protected boolean doSupport(NettyProxyMsg nettyProxyMsg) { + return ProxyMessageTypeEnums.SOCKS_DISTRIBUTE_SERVER_PROXY_CLIENT_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/advanced/proxy/socks/client/AbstractHandleSocksDistributeServerProxyClientTransferCloseAdvanced.java b/wu-lazy-cloud-heartbeat-common/src/main/java/org/framework/lazy/cloud/network/heartbeat/common/advanced/proxy/socks/client/AbstractHandleSocksDistributeServerProxyClientTransferCloseAdvanced.java new file mode 100644 index 0000000..280c6e9 --- /dev/null +++ b/wu-lazy-cloud-heartbeat-common/src/main/java/org/framework/lazy/cloud/network/heartbeat/common/advanced/proxy/socks/client/AbstractHandleSocksDistributeServerProxyClientTransferCloseAdvanced.java @@ -0,0 +1,21 @@ +package org.framework.lazy.cloud.network.heartbeat.common.advanced.proxy.socks.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 AbstractHandleSocksDistributeServerProxyClientTransferCloseAdvanced extends AbstractHandleChannelTypeAdvanced implements HandleChannelTypeAdvanced { + + + /** + * 是否支持当前类型 + * + * @param nettyProxyMsg 通道数据 + * @return 布尔类型 是、否 + */ + @Override + protected boolean doSupport(NettyProxyMsg nettyProxyMsg) { + return ProxyMessageTypeEnums.SOCKS_DISTRIBUTE_SERVER_PROXY_CLIENT_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/socks/server/AbstractHandleSocksReportServerProxyClientConnectionSuccessTypeAdvanced.java b/wu-lazy-cloud-heartbeat-common/src/main/java/org/framework/lazy/cloud/network/heartbeat/common/advanced/proxy/socks/server/AbstractHandleSocksReportServerProxyClientConnectionSuccessTypeAdvanced.java new file mode 100644 index 0000000..278e7f7 --- /dev/null +++ b/wu-lazy-cloud-heartbeat-common/src/main/java/org/framework/lazy/cloud/network/heartbeat/common/advanced/proxy/socks/server/AbstractHandleSocksReportServerProxyClientConnectionSuccessTypeAdvanced.java @@ -0,0 +1,21 @@ +package org.framework.lazy.cloud.network.heartbeat.common.advanced.proxy.socks.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 AbstractHandleSocksReportServerProxyClientConnectionSuccessTypeAdvanced extends AbstractHandleChannelTypeAdvanced implements HandleChannelTypeAdvanced { + + + /** + * 是否支持当前类型 + * + * @param nettyProxyMsg 通道数据 + * @return 布尔类型 是、否 + */ + @Override + protected boolean doSupport(NettyProxyMsg nettyProxyMsg) { + return ProxyMessageTypeEnums.SOCKS_REPORT_SERVER_PROXY_CLIENT_CONNECTION_SUCCESS_.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/socks/server/AbstractHandleSocksReportServerProxyClientResponseTypeAdvanced.java b/wu-lazy-cloud-heartbeat-common/src/main/java/org/framework/lazy/cloud/network/heartbeat/common/advanced/proxy/socks/server/AbstractHandleSocksReportServerProxyClientResponseTypeAdvanced.java new file mode 100644 index 0000000..82e8d1b --- /dev/null +++ b/wu-lazy-cloud-heartbeat-common/src/main/java/org/framework/lazy/cloud/network/heartbeat/common/advanced/proxy/socks/server/AbstractHandleSocksReportServerProxyClientResponseTypeAdvanced.java @@ -0,0 +1,21 @@ +package org.framework.lazy.cloud.network.heartbeat.common.advanced.proxy.socks.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 AbstractHandleSocksReportServerProxyClientResponseTypeAdvanced extends AbstractHandleChannelTypeAdvanced implements HandleChannelTypeAdvanced { + + + /** + * 是否支持当前类型 + * + * @param nettyProxyMsg 通道数据 + * @return 布尔类型 是、否 + */ + @Override + protected boolean doSupport(NettyProxyMsg nettyProxyMsg) { + return ProxyMessageTypeEnums.SOCKS_REPORT_SERVER_PROXY_CLIENT_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/socks/server/AbstractHandleSocksReportServerProxyClientTransferCloseTypeAdvanced.java b/wu-lazy-cloud-heartbeat-common/src/main/java/org/framework/lazy/cloud/network/heartbeat/common/advanced/proxy/socks/server/AbstractHandleSocksReportServerProxyClientTransferCloseTypeAdvanced.java new file mode 100644 index 0000000..030353c --- /dev/null +++ b/wu-lazy-cloud-heartbeat-common/src/main/java/org/framework/lazy/cloud/network/heartbeat/common/advanced/proxy/socks/server/AbstractHandleSocksReportServerProxyClientTransferCloseTypeAdvanced.java @@ -0,0 +1,21 @@ +package org.framework.lazy.cloud.network.heartbeat.common.advanced.proxy.socks.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 AbstractHandleSocksReportServerProxyClientTransferCloseTypeAdvanced extends AbstractHandleChannelTypeAdvanced implements HandleChannelTypeAdvanced { + + + /** + * 是否支持当前类型 + * + * @param nettyProxyMsg 通道数据 + * @return 布尔类型 是、否 + */ + @Override + protected boolean doSupport(NettyProxyMsg nettyProxyMsg) { + return ProxyMessageTypeEnums.SOCKS_REPORT_SERVER_PROXY_CLIENT_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/socks/server/AbstractHandleSocksServerProxyClientTypeAdvanced.java b/wu-lazy-cloud-heartbeat-common/src/main/java/org/framework/lazy/cloud/network/heartbeat/common/advanced/proxy/socks/server/AbstractHandleSocksReportServerProxyClientTypeAdvanced.java similarity index 81% rename from wu-lazy-cloud-heartbeat-common/src/main/java/org/framework/lazy/cloud/network/heartbeat/common/advanced/proxy/socks/server/AbstractHandleSocksServerProxyClientTypeAdvanced.java rename to wu-lazy-cloud-heartbeat-common/src/main/java/org/framework/lazy/cloud/network/heartbeat/common/advanced/proxy/socks/server/AbstractHandleSocksReportServerProxyClientTypeAdvanced.java index 63c6600..3bf41b1 100644 --- a/wu-lazy-cloud-heartbeat-common/src/main/java/org/framework/lazy/cloud/network/heartbeat/common/advanced/proxy/socks/server/AbstractHandleSocksServerProxyClientTypeAdvanced.java +++ b/wu-lazy-cloud-heartbeat-common/src/main/java/org/framework/lazy/cloud/network/heartbeat/common/advanced/proxy/socks/server/AbstractHandleSocksReportServerProxyClientTypeAdvanced.java @@ -5,7 +5,7 @@ import org.framework.lazy.cloud.network.heartbeat.common.advanced.HandleChannelT import org.framework.lazy.cloud.network.heartbeat.common.advanced.payload.NettyProxyMsg; import org.framework.lazy.cloud.network.heartbeat.common.enums.ProxyMessageTypeEnums; -public abstract class AbstractHandleSocksServerProxyClientTypeAdvanced extends AbstractHandleChannelTypeAdvanced implements HandleChannelTypeAdvanced { +public abstract class AbstractHandleSocksReportServerProxyClientTypeAdvanced extends AbstractHandleChannelTypeAdvanced implements HandleChannelTypeAdvanced { /** 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 0264597..647a65b 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 @@ -239,10 +239,54 @@ public class ProxyMessageType { * socket 服务端代理客户端 * * @see ProxyMessageTypeEnums#SOCKS_SERVER_PROXY_CLIENT_ - * @see AbstractHandleSocksServerProxyClientTypeAdvanced + * @see AbstractHandleSocksReportServerProxyClientTypeAdvanced */ public static final byte SOCKS_SERVER_PROXY_CLIENT_ = SOCKS_REPORT_CLIENT_PROXY_CLIENT_TRANSFER_CLOSE_ + 1; + /** + * socket 下发客户端代理服务端连接初始化 + * + * @see ProxyMessageTypeEnums#SOCKS_DISTRIBUTE_SERVER_PROXY_CLIENT_CONNECTION_INIT_ + * @see AbstractHandleSocksDistributeServerProxyClientConnectionInitTypeAdvanced + */ + public static final byte SOCKS_DISTRIBUTE_SERVER_PROXY_CLIENT_CONNECTION_INIT_ = SOCKS_SERVER_PROXY_CLIENT_ - 1; + /** + * socket 上报客户端代理服务端连接初始化成功 + * + * @see ProxyMessageTypeEnums#SOCKS_REPORT_SERVER_PROXY_CLIENT_CONNECTION_SUCCESS_ + * @see AbstractHandleSocksReportServerProxyClientConnectionSuccessTypeAdvanced + */ + public static final byte SOCKS_REPORT_SERVER_PROXY_CLIENT_CONNECTION_SUCCESS_ = SOCKS_DISTRIBUTE_SERVER_PROXY_CLIENT_CONNECTION_INIT_ - 1; + + /** + * socket 下发客户端代理服务端 请求数据 + * + * @see ProxyMessageTypeEnums#SOCKS_DISTRIBUTE_SERVER_PROXY_CLIENT_TRANSFER_REQUEST_ + * @see AbstractHandleSocksDistributeServerProxyClientRequestTypeAdvanced + */ + public static final byte SOCKS_DISTRIBUTE_SERVER_PROXY_CLIENT_TRANSFER_REQUEST_ = SOCKS_REPORT_SERVER_PROXY_CLIENT_CONNECTION_SUCCESS_ - 1; + /** + * socket 上报客户端代理服务端 结果返回 + * + * @see ProxyMessageTypeEnums#SOCKS_REPORT_SERVER_PROXY_CLIENT_TRANSFER_RESPONSE_ + * @see AbstractHandleSocksReportServerProxyClientResponseTypeAdvanced + */ + public static final byte SOCKS_REPORT_SERVER_PROXY_CLIENT_TRANSFER_RESPONSE_ = SOCKS_DISTRIBUTE_SERVER_PROXY_CLIENT_TRANSFER_REQUEST_ - 1; + /** + * socket 下发客户端代理服务端 传输通道关闭 + * + * @see ProxyMessageTypeEnums#SOCKS_DISTRIBUTE_SERVER_PROXY_CLIENT_TRANSFER_CLOSE_ + * @see AbstractHandleSocksDistributeServerProxyClientTransferCloseAdvanced + */ + public static final byte SOCKS_DISTRIBUTE_SERVER_PROXY_CLIENT_TRANSFER_CLOSE_ = SOCKS_REPORT_SERVER_PROXY_CLIENT_TRANSFER_RESPONSE_ - 1; + /** + * socket 上报客户端代理服务端 传输通道关闭 + * + * @see ProxyMessageTypeEnums#SOCKS_REPORT_SERVER_PROXY_CLIENT_TRANSFER_CLOSE_ + * @see AbstractHandleSocksReportServerProxyClientTransferCloseTypeAdvanced + */ + public static final byte SOCKS_REPORT_SERVER_PROXY_CLIENT_TRANSFER_CLOSE_ = SOCKS_DISTRIBUTE_SERVER_PROXY_CLIENT_TRANSFER_CLOSE_ - 1; + 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 5d32ebb..2f54936 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 @@ -320,9 +320,51 @@ public enum ProxyMessageTypeEnums { * socket 服务端代理客户端 * * @see ProxyMessageTypeEnums#SOCKS_SERVER_PROXY_CLIENT_ - * @see AbstractHandleSocksServerProxyClientTypeAdvanced + * @see AbstractHandleSocksReportServerProxyClientTypeAdvanced */ SOCKS_SERVER_PROXY_CLIENT_(ProxyMessageType.SOCKS_SERVER_PROXY_CLIENT_, "socket 服务端代理客户端"), + /** + * socket 下发客户端代理服务端连接初始化 + * + * @see ProxyMessageTypeEnums#SOCKS_DISTRIBUTE_SERVER_PROXY_CLIENT_CONNECTION_INIT_ + * @see AbstractHandleSocksDistributeServerProxyClientConnectionInitTypeAdvanced + */ + SOCKS_DISTRIBUTE_SERVER_PROXY_CLIENT_CONNECTION_INIT_(ProxyMessageType.SOCKS_DISTRIBUTE_SERVER_PROXY_CLIENT_CONNECTION_INIT_, "socket 下发客户端代理服务端连接初始化"), + /** + * socket 上报客户端代理服务端连接初始化成功 + * + * @see ProxyMessageTypeEnums#SOCKS_REPORT_SERVER_PROXY_CLIENT_CONNECTION_SUCCESS_ + * @see AbstractHandleSocksReportServerProxyClientConnectionSuccessTypeAdvanced + */ + SOCKS_REPORT_SERVER_PROXY_CLIENT_CONNECTION_SUCCESS_(ProxyMessageType.SOCKS_REPORT_SERVER_PROXY_CLIENT_CONNECTION_SUCCESS_, "socket 上报客户端代理服务端连接初始化成功"), + /** + * socket 下发客户端代理服务端 请求数据 + * + * @see ProxyMessageTypeEnums#SOCKS_DISTRIBUTE_SERVER_PROXY_CLIENT_TRANSFER_REQUEST_ + * @see AbstractHandleSocksDistributeServerProxyClientRequestTypeAdvanced + */ + SOCKS_DISTRIBUTE_SERVER_PROXY_CLIENT_TRANSFER_REQUEST_(ProxyMessageType.SOCKS_DISTRIBUTE_SERVER_PROXY_CLIENT_TRANSFER_REQUEST_, "socket 下发客户端代理服务端 请求数据"), + /** + * socket 上报客户端代理服务端 结果返回 + * + * @see ProxyMessageTypeEnums#SOCKS_REPORT_SERVER_PROXY_CLIENT_TRANSFER_RESPONSE_ + * @see AbstractHandleSocksReportServerProxyClientResponseTypeAdvanced + */ + SOCKS_REPORT_SERVER_PROXY_CLIENT_TRANSFER_RESPONSE_(ProxyMessageType.SOCKS_REPORT_SERVER_PROXY_CLIENT_TRANSFER_RESPONSE_, "socket 上报客户端代理服务端 结果返回"), + /** + * socket 下发客户端代理服务端 传输通道关闭 + * + * @see ProxyMessageTypeEnums#SOCKS_DISTRIBUTE_SERVER_PROXY_CLIENT_TRANSFER_CLOSE_ + * @see AbstractHandleSocksDistributeServerProxyClientTransferCloseAdvanced + */ + SOCKS_DISTRIBUTE_SERVER_PROXY_CLIENT_TRANSFER_CLOSE_(ProxyMessageType.SOCKS_DISTRIBUTE_SERVER_PROXY_CLIENT_TRANSFER_CLOSE_, "socket 下发客户端代理服务端 传输通道关闭"), + /** + * socket 上报客户端代理服务端 传输通道关闭 + * + * @see ProxyMessageTypeEnums#SOCKS_REPORT_SERVER_PROXY_CLIENT_TRANSFER_CLOSE_ + * @see AbstractHandleSocksReportServerProxyClientTransferCloseTypeAdvanced + */ + SOCKS_REPORT_SERVER_PROXY_CLIENT_TRANSFER_CLOSE_(ProxyMessageType.SOCKS_REPORT_SERVER_PROXY_CLIENT_TRANSFER_CLOSE_, "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 4d11351..cde78e4 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 @@ -1,6 +1,7 @@ package org.framework.lazy.cloud.network.heartbeat.common.utils; import io.netty.channel.Channel; +import io.netty.handler.codec.socksx.v5.Socks5AddressType; import io.netty.util.AttributeKey; import org.framework.lazy.cloud.network.heartbeat.common.NettyByteBuf; @@ -262,10 +263,11 @@ public class ChannelAttributeKeyUtils { * 为通道绑定 请求地址类型 * * @param channel 通道 - * @param socks5AddressType 地址类型 + * @param socks5AddressTypeByte 地址类型 + * @see Socks5AddressType#valueOf(byte) */ - public static void buildSocks5AddressType(Channel channel, Byte socks5AddressType) { - channel.attr(NETTY_SOCKS5_ADDRESS_TYPE).set(socks5AddressType); + public static void buildSocks5AddressType(Channel channel, Byte socks5AddressTypeByte) { + channel.attr(NETTY_SOCKS5_ADDRESS_TYPE).set(socks5AddressTypeByte); } /** 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 7392f35..19d6af2 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 @@ -290,9 +290,22 @@ public class ServerAutoConfiguration { } @Bean - public ServerHandleSocksServerProxyClientTypeAdvanced serverHandleSocksServerProxyClientTypeAdvanced() { - return new ServerHandleSocksServerProxyClientTypeAdvanced(); + public ServerHandleSocksReportServerProxyClientTypeAdvanced serverHandleSocksServerProxyClientTypeAdvanced() { + return new ServerHandleSocksReportServerProxyClientTypeAdvanced(); } + + @Bean + public ServerHandleSocksReportServerProxyClientConnectionSuccessTypeAdvanced serverHandleSocksReportServerProxyClientConnectionSuccessTypeAdvanced(){ + return new ServerHandleSocksReportServerProxyClientConnectionSuccessTypeAdvanced(); + } + @Bean + public ServerHandleSocksReportServerProxyClientResponseTypeAdvanced serverHandleSocksReportServerProxyClientResponseTypeAdvanced(){ + return new ServerHandleSocksReportServerProxyClientResponseTypeAdvanced(); + } + @Bean + public ServerHandleSocksReportServerProxyClientTransferCloseTypeAdvanced serverHandleSocksReportServerProxyClientTransferCloseTypeAdvanced(){ + return new ServerHandleSocksReportServerProxyClientTransferCloseTypeAdvanced(); + } } } diff --git a/wu-lazy-cloud-heartbeat-server/src/main/java/org/framework/lazy/cloud/network/heartbeat/server/netty/proxy/socks/advanced/ServerHandleSocksReportClientProxyClientConnectTransferTypeAdvanced.java b/wu-lazy-cloud-heartbeat-server/src/main/java/org/framework/lazy/cloud/network/heartbeat/server/netty/proxy/socks/advanced/ServerHandleSocksReportClientProxyClientConnectTransferTypeAdvanced.java index 05e9eb9..fa71fa1 100644 --- a/wu-lazy-cloud-heartbeat-server/src/main/java/org/framework/lazy/cloud/network/heartbeat/server/netty/proxy/socks/advanced/ServerHandleSocksReportClientProxyClientConnectTransferTypeAdvanced.java +++ b/wu-lazy-cloud-heartbeat-server/src/main/java/org/framework/lazy/cloud/network/heartbeat/server/netty/proxy/socks/advanced/ServerHandleSocksReportClientProxyClientConnectTransferTypeAdvanced.java @@ -73,51 +73,6 @@ public class ServerHandleSocksReportClientProxyClientConnectTransferTypeAdvanced } - - - 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_CLIENT_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/ServerHandleSocksReportServerProxyClientConnectionSuccessTypeAdvanced.java b/wu-lazy-cloud-heartbeat-server/src/main/java/org/framework/lazy/cloud/network/heartbeat/server/netty/proxy/socks/advanced/ServerHandleSocksReportServerProxyClientConnectionSuccessTypeAdvanced.java new file mode 100644 index 0000000..ba740d8 --- /dev/null +++ b/wu-lazy-cloud-heartbeat-server/src/main/java/org/framework/lazy/cloud/network/heartbeat/server/netty/proxy/socks/advanced/ServerHandleSocksReportServerProxyClientConnectionSuccessTypeAdvanced.java @@ -0,0 +1,67 @@ +package org.framework.lazy.cloud.network.heartbeat.server.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.NettyClientProxyClientVisitorInboundHandler; +import org.framework.lazy.cloud.network.heartbeat.client.netty.proxy.socks.handler.NettyServerProxyClientVisitorInboundHandler; +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.socks.server.AbstractHandleSocksReportServerProxyClientConnectionSuccessTypeAdvanced; +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; +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; + + +@Role(BeanDefinition.ROLE_INFRASTRUCTURE) +@Slf4j +@Component +public class ServerHandleSocksReportServerProxyClientConnectionSuccessTypeAdvanced + extends AbstractHandleSocksReportServerProxyClientConnectionSuccessTypeAdvanced { + + + /** + * 处理当前数据 + * + * @param nettyChannelContext 当前通道 + * @param nettyProxyMsg 通道数据 + * @see NettySocksClientProxyServerRealHandler + */ + @Override + public void doHandler(NettyChannelContext nettyChannelContext, NettyProxyMsg nettyProxyMsg) { + // 打开访客通道获取访问数据 + byte[] visitorId = nettyProxyMsg.getVisitorId(); + Channel visitorChannel = NettyTransferChannelContext.getVisitor(visitorId); + // 传输通道 + Channel transferChannel = nettyChannelContext.channel(); + ChannelAttributeKeyUtils.buildNextChannel(transferChannel,visitorChannel); + ChannelAttributeKeyUtils.buildNextChannel(visitorChannel,transferChannel); + + + // 根据传输通道获取代理通道 + 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 NettyServerProxyClientVisitorInboundHandler()); + 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-server/src/main/java/org/framework/lazy/cloud/network/heartbeat/server/netty/proxy/socks/advanced/ServerHandleSocksReportServerProxyClientResponseTypeAdvanced.java b/wu-lazy-cloud-heartbeat-server/src/main/java/org/framework/lazy/cloud/network/heartbeat/server/netty/proxy/socks/advanced/ServerHandleSocksReportServerProxyClientResponseTypeAdvanced.java new file mode 100644 index 0000000..5fd5e54 --- /dev/null +++ b/wu-lazy-cloud-heartbeat-server/src/main/java/org/framework/lazy/cloud/network/heartbeat/server/netty/proxy/socks/advanced/ServerHandleSocksReportServerProxyClientResponseTypeAdvanced.java @@ -0,0 +1,47 @@ +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.socks.server.AbstractHandleSocksReportServerProxyClientResponseTypeAdvanced; +import org.framework.lazy.cloud.network.heartbeat.common.constant.ProxyMessageType; +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 ServerHandleSocksReportServerProxyClientResponseTypeAdvanced + extends AbstractHandleSocksReportServerProxyClientResponseTypeAdvanced { + + + /** + * 处理当前数据 + * + * @param nettyChannelContext 当前通道 + * @param nettyProxyMsg 通道数据 + * @see NettySocksClientProxyServerRealHandler + */ + @Override + public 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-server/src/main/java/org/framework/lazy/cloud/network/heartbeat/server/netty/proxy/socks/advanced/ServerHandleSocksReportServerProxyClientTransferCloseTypeAdvanced.java b/wu-lazy-cloud-heartbeat-server/src/main/java/org/framework/lazy/cloud/network/heartbeat/server/netty/proxy/socks/advanced/ServerHandleSocksReportServerProxyClientTransferCloseTypeAdvanced.java new file mode 100644 index 0000000..6ed84d9 --- /dev/null +++ b/wu-lazy-cloud-heartbeat-server/src/main/java/org/framework/lazy/cloud/network/heartbeat/server/netty/proxy/socks/advanced/ServerHandleSocksReportServerProxyClientTransferCloseTypeAdvanced.java @@ -0,0 +1,39 @@ +package org.framework.lazy.cloud.network.heartbeat.server.netty.proxy.socks.advanced; + + +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.socks.server.AbstractHandleSocksReportServerProxyClientTransferCloseTypeAdvanced; +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; + + +@Role(BeanDefinition.ROLE_INFRASTRUCTURE) +@Slf4j +@Component +public class ServerHandleSocksReportServerProxyClientTransferCloseTypeAdvanced + extends AbstractHandleSocksReportServerProxyClientTransferCloseTypeAdvanced { + + + /** + * 处理当前数据 + * + * @param nettyChannelContext 当前通道 + * @param nettyProxyMsg 通道数据 + * @see NettySocksClientProxyServerRealHandler + */ + @Override + public void doHandler(NettyChannelContext nettyChannelContext, NettyProxyMsg nettyProxyMsg) { + Channel channel = nettyChannelContext.channel(); + Channel nextChannel = ChannelAttributeKeyUtils.getNextChannel(channel); + channel.close(); + nextChannel.close(); + + } + +} diff --git a/wu-lazy-cloud-heartbeat-server/src/main/java/org/framework/lazy/cloud/network/heartbeat/server/netty/proxy/socks/advanced/ServerHandleSocksReportServerProxyClientTypeAdvanced.java b/wu-lazy-cloud-heartbeat-server/src/main/java/org/framework/lazy/cloud/network/heartbeat/server/netty/proxy/socks/advanced/ServerHandleSocksReportServerProxyClientTypeAdvanced.java new file mode 100644 index 0000000..5e99a16 --- /dev/null +++ b/wu-lazy-cloud-heartbeat-server/src/main/java/org/framework/lazy/cloud/network/heartbeat/server/netty/proxy/socks/advanced/ServerHandleSocksReportServerProxyClientTypeAdvanced.java @@ -0,0 +1,73 @@ +package org.framework.lazy.cloud.network.heartbeat.server.netty.proxy.socks.advanced; + + +import io.netty.channel.*; +import io.netty.handler.codec.socksx.v5.Socks5AddressType; +import lombok.extern.slf4j.Slf4j; +import org.framework.lazy.cloud.network.heartbeat.common.ChannelContext; +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.socks.server.AbstractHandleSocksReportServerProxyClientTypeAdvanced; +import org.framework.lazy.cloud.network.heartbeat.common.constant.ProxyMessageType; +import org.framework.lazy.cloud.network.heartbeat.common.utils.ChannelAttributeKeyUtils; +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 ServerHandleSocksReportServerProxyClientTypeAdvanced + extends AbstractHandleSocksReportServerProxyClientTypeAdvanced { + + + /** + * 处理当前数据 + * + * @param nettyChannelContext 当前通道 + * @param nettyProxyMsg 通道数据 + */ + @Override + public void doHandler(NettyChannelContext nettyChannelContext, NettyProxyMsg nettyProxyMsg) { + Channel visitorrChannel = nettyChannelContext.channel(); + + String host = nettyProxyMsg.getTargetIpString(); + Integer port = Integer.parseInt(nettyProxyMsg.getTargetPortString()); + byte[] data = nettyProxyMsg.getData(); + byte[] visitorId = nettyProxyMsg.getVisitorId(); + byte[] targetClientId = nettyProxyMsg.getClientId(); + + byte socks5AddressTypeByte = data[0]; + + + String msgVisitorId = new String(visitorId); + ChannelAttributeKeyUtils.buildVisitorId(visitorrChannel, msgVisitorId); + NettyTransferChannelContext.pushVisitor(visitorrChannel, msgVisitorId); + ChannelAttributeKeyUtils.buildSocks5AddressType(visitorrChannel,socks5AddressTypeByte); + + // 客户端连接客户端传输通道 + Channel loadBalance = ChannelContext.getLoadBalance(targetClientId); + if(ObjectUtils.isNotEmpty(loadBalance)) { + // 下发创建新链接指令 + NettyProxyMsg otherClientConnectServer = new NettyProxyMsg(); + // data ---》Socks5AddressType + otherClientConnectServer.setData(data); + otherClientConnectServer.setClientTargetIp(host); + otherClientConnectServer.setClientTargetPort(port); + otherClientConnectServer.setVisitorId(visitorId); + otherClientConnectServer.setClientId(targetClientId); + otherClientConnectServer.setType(ProxyMessageType.SOCKS_DISTRIBUTE_SERVER_PROXY_CLIENT_CONNECTION_INIT_); + loadBalance.writeAndFlush(otherClientConnectServer); + + }else { + log.error("无法通过客户端ID获取当前客户端通道"); + } + + + + } + +} diff --git a/wu-lazy-cloud-heartbeat-server/src/main/java/org/framework/lazy/cloud/network/heartbeat/server/netty/proxy/socks/advanced/ServerHandleSocksServerProxyClientTypeAdvanced.java b/wu-lazy-cloud-heartbeat-server/src/main/java/org/framework/lazy/cloud/network/heartbeat/server/netty/proxy/socks/advanced/ServerHandleSocksServerProxyClientTypeAdvanced.java deleted file mode 100644 index 779cc52..0000000 --- a/wu-lazy-cloud-heartbeat-server/src/main/java/org/framework/lazy/cloud/network/heartbeat/server/netty/proxy/socks/advanced/ServerHandleSocksServerProxyClientTypeAdvanced.java +++ /dev/null @@ -1,123 +0,0 @@ -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.ChannelContext; -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.socks.server.AbstractHandleSocksServerProxyClientTypeAdvanced; -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 org.wu.framework.core.utils.ObjectUtils; - -import java.net.InetSocketAddress; - - -@Role(BeanDefinition.ROLE_INFRASTRUCTURE) -@Slf4j -@Component -public class ServerHandleSocksServerProxyClientTypeAdvanced - extends AbstractHandleSocksServerProxyClientTypeAdvanced { - - - /** - * 处理当前数据 - * - * @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[] targetClientId = nettyProxyMsg.getClientId(); - String msgVisitorId = new String(visitorId); - ChannelAttributeKeyUtils.buildClientId(transferChannel, targetClientId); - ChannelAttributeKeyUtils.buildVisitorId(transferChannel, msgVisitorId); - - NettyTransferChannelContext.pushVisitor(transferChannel, msgVisitorId); - - // 客户端连接客户端传输通道 - Channel loadBalance = ChannelContext.getLoadBalance(targetClientId); - if(ObjectUtils.isNotEmpty(loadBalance)) { - // 下发创建新链接指令 - NettyProxyMsg otherClientConnectServer = new NettyProxyMsg(); - otherClientConnectServer.setData(data); - otherClientConnectServer.setClientTargetIp(host); - otherClientConnectServer.setClientTargetPort(port); - otherClientConnectServer.setVisitorId(visitorId); - otherClientConnectServer.setClientId(targetClientId); - otherClientConnectServer.setType(ProxyMessageType.SOCKS_DISTRIBUTE_CLIENT_PROXY_CLIENT_OTHER_TRANSFER_CONNECTION_); - loadBalance.writeAndFlush(otherClientConnectServer); - - }else { - log.error("无法通过客户端ID获取当前客户端通道"); - } - - - - - 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_CLIENT_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 下发 连接真实服务成功、客户端可以采集数据了 - - } - -}