org.rx.socks.tcp.TcpProxyServer Maven / Gradle / Ivy

package org.rx.socks.tcp;

import io.netty.bootstrap.Bootstrap;
import io.netty.bootstrap.ServerBootstrap;
import io.netty.channel.*;
import lombok.RequiredArgsConstructor;
import lombok.SneakyThrows;
import lombok.extern.slf4j.Slf4j;
import org.rx.core.Disposable;
import org.rx.socks.MemoryMode;
import org.rx.socks.Sockets;
import org.rx.util.function.BiFunc;

import java.net.InetSocketAddress;
import java.util.concurrent.ConcurrentLinkedQueue;

import static org.rx.core.Contract.require;

@Slf4j
public class TcpProxyServer extends Disposable {
    private class FrontendHandler extends ChannelInboundHandlerAdapter {
        @RequiredArgsConstructor
        private class BackendHandler extends ChannelInboundHandlerAdapter {
            private final ChannelHandlerContext inbound;

            @Override
            public void channelActive(ChannelHandlerContext ctx) {
                flushBackend();
            }

            @Override
            public void channelRead(ChannelHandlerContext outbound, Object msg) {
                if (!inbound.channel().isActive()) {
                    return;
                }
                inbound.writeAndFlush(msg);
            }

            @Override
            public void channelInactive(ChannelHandlerContext ctx) {
                if (!inbound.channel().isActive()) {
                    return;
                }
                Sockets.closeOnFlushed(inbound.channel());
            }

            @Override
            public void exceptionCaught(ChannelHandlerContext ctx, Throwable cause) {
                log.error("serverCaught {}", ctx.channel().remoteAddress(), cause);
                Sockets.closeOnFlushed(ctx.channel());
            }
        }

        private Channel outbound;
        private final ConcurrentLinkedQueue