最近在做的项目，需要自己搭建一个socks代理。netty4.0附带了一个socks代理的样例，但是3.x就没有这个东西了，碰巧使用的又是3.7，就只能自己摸索并实现一遍，也算是对netty和socks协议的一个熟悉。socks代理涉及到协议解析、server、client等功能，是一个比较复杂的网络程序，对于学习netty的使用也是非常好的例子。

socks是在传输层之上的一层协议，主要功能是提供代理认证等功能。socks协议虽然是应用层协议(在TCP/IP4层协议栈里)，本身可以理解为一个信道，可以传输任何TCP/UDP内容。例如著名的科学上网软件就是基于socks协议，对通信内容进行加密实现的。

TCP/IP协议栈的结构中，下层协议总会在上层协议内容之前加上自己的头。而socks协议稍微不同，其实它对比TCP协议，仅仅是多了验证部分，验证之后，完全是使用TCP来进行传输，而没有socks报文头。socks协议的具体内容可以参考rfc1928。这一点来说，其实将socks理解成与其他应用层协议平级也没什么问题。

一个最基本的socks连接流程是这样的： 

那么我们开始netty之旅吧。

首先我们需要建立一个server：

public void run() {

    // 新建线程池
    Executor executor = Executors.newCachedThreadPool();
    Executor executorWorker = Executors.newCachedThreadPool();
    ServerBootstrap sb = new ServerBootstrap(
            new NioServerSocketChannelFactory(executor, executorWorker));

    // 初始化代理部分使用的client
    ClientSocketChannelFactory cf =
            new NioClientSocketChannelFactory(executor, executorWorker);

    //设置处理逻辑
    sb.setPipelineFactory(
            new SocksProxyPipelineFactory(cf));

    // Start up the server.
    sb.bind(new InetSocketAddress(1080));
}

如你所见，主要的处理逻辑以SocksProxyPipelineFactory的形式提供。SocksProxyPipelineFactory的代码包括几部分：

public class SocksProxyPipelineFactory implements ChannelPipelineFactory {

    private final ClientSocketChannelFactory cf;

    public SocksProxyPipelineFactory(ClientSocketChannelFactory cf) {
        this.cf = cf;
    }

    @Override
    public ChannelPipeline getPipeline() throws Exception {
        ChannelPipeline pipeline = Channels.pipeline();
        pipeline.addLast(SocksInitRequestDecoder.getName(),new SocksInitRequestDecoder());
        pipeline.addLast(SocksMessageEncoder.getName(),new SocksMessageEncoder());
        pipeline.addLast(SocksServerHandler.getName(),new SocksServerHandler(cf));
        return pipeline;
    }
}    

这里要详细解释一下几个handler的作用：

ChannelUpstreamHandler用于接收之后的处理，而ChannelDownstreamHandler则相反，用于写入数据之后的处理。这两个都可以附加到ChannelPipeline中。偷个懒，直接附上netty的ChannelPipeline中的一段很有爱的javadoc：

                                      I/O Request
                                    via {@link Channel} or
                                {@link ChannelHandlerContext}
                                          |
 +----------------------------------------+---------------+
 |                  ChannelPipeline       |               |
 |                                       \|/              |
 |  +----------------------+  +-----------+------------+  |
 |  | Upstream Handler  N  |  | Downstream Handler  1  |  |
 |  +----------+-----------+  +-----------+------------+  |
 |            /|\                         |               |
 |             |                         \|/              |
 |  +----------+-----------+  +-----------+------------+  |
 |  | Upstream Handler N-1 |  | Downstream Handler  2  |  |
 |  +----------+-----------+  +-----------+------------+  |
 |            /|\                         .               |
 |             .                          .               |
 |     [ sendUpstream() ]        [ sendDownstream() ]     |
 |     [ + INBOUND data ]        [ + OUTBOUND data  ]     |
 |             .                          .               |
 |             .                         \|/              |
 |  +----------+-----------+  +-----------+------------+  |
 |  | Upstream Handler  2  |  | Downstream Handler M-1 |  |
 |  +----------+-----------+  +-----------+------------+  |
 |            /|\                         |               |
 |             |                         \|/              |
 |  +----------+-----------+  +-----------+------------+  |
 |  | Upstream Handler  1  |  | Downstream Handler  M  |  |
 |  +----------+-----------+  +-----------+------------+  |
 |            /|\                         |               |
 +-------------+--------------------------+---------------+
               |                         \|/
 +-------------+--------------------------+---------------+
 |             |                          |               |
 |     [ Socket.read() ]          [ Socket.write() ]      |
 |                                                        |
 |  Netty Internal I/O Threads (Transport Implementation) |
 +--------------------------------------------------------+

SocksInitRequestDecoder用于对socks的请求进行解码。你可能会说，为什么没有SocksCmdRequest的解码？别急，netty的handler是可以动态添加的，这里我们先解码一个初始化的请求。SocksInitRequestDecoder是一个ChannelUpstreamHandler，即接收流的处理器。

SocksMessageEncoder是一个ChannelDownstreamHandler，即输出时的编码器，有了它，我们可以很开心的在channel.write()里直接传入一个对象，而无需自己去写buffer了。

SocksServerHandler是处理的重头。这里会根据请求的不同类型，做不同的处理。

public void messageReceived(ChannelHandlerContext ctx, MessageEvent e) throws Exception {
    SocksRequest socksRequest = (SocksRequest) e.getMessage();
    switch (socksRequest.getSocksRequestType()) {
    case INIT:
        //添加cmd解码器
        ctx.getPipeline().addFirst(SocksCmdRequestDecoder.getName(), new SocksCmdRequestDecoder());
        //简单起见，无需认证
        ctx.getChannel().write(new SocksInitResponse(SocksMessage.AuthScheme.NO_AUTH));
        break;
    case AUTH:
        ctx.getPipeline().addFirst(SocksCmdRequestDecoder.getName(), new SocksCmdRequestDecoder());
        //直接成功
        ctx.getChannel().write(new SocksAuthResponse(SocksMessage.AuthStatus.SUCCESS));
        break;
    case CMD:
        SocksCmdRequest req = (SocksCmdRequest) socksRequest;
        if (req.getCmdType() == SocksMessage.CmdType.CONNECT) {
            //添加处理连接的handler
            ctx.getPipeline().addLast(SocksServerConnectHandler.getName(), new SocksServerConnectHandler(cf));
            ctx.getPipeline().remove(this);
        } else {
            ctx.getChannel().close();
        }
        break;
    case UNKNOWN:
        break;
    }
    super.messageReceived(ctx, e);
}

前面两种INIT和AUTH就不做赘述了，后面当CMD为Connect时，添加一个处理连接的SocksServerConnectHandler，它会起到client与外部server的桥梁作用。

这里我们先实现一个纯转发的handler-OutboundHandler:

private class OutboundHandler extends SimpleChannelUpstreamHandler {

    private final Channel inboundChannel;

    OutboundHandler(Channel inboundChannel) {
        this.inboundChannel = inboundChannel;
    }

    @Override
    public void messageReceived(ChannelHandlerContext ctx, final MessageEvent e) throws Exception {
        final ChannelBuffer msg = (ChannelBuffer) e.getMessage();
        synchronized (trafficLock) {
            inboundChannel.write(msg);

        }
    }
}    

它会把收到的内容，写入到inboundChannel中，其他转发的作用。最后就是我们的SocksServerConnectHandler了:

public class SocksServerConnectHandler extends SimpleChannelUpstreamHandler {

    private final ClientSocketChannelFactory cf;

    private volatile Channel outboundChannel;

    final Object trafficLock = new Object();

    public SocksServerConnectHandler(ClientSocketChannelFactory cf) {
        this.cf = cf;
    }

    @Override
    public void messageReceived(ChannelHandlerContext ctx, MessageEvent e) throws Exception {
        final SocksCmdRequest socksCmdRequest = (SocksCmdRequest) e.getMessage();
        final Channel inboundChannel = e.getChannel();
        inboundChannel.setReadable(false);

        // Start the connection attempt.
        final ClientBootstrap cb = new ClientBootstrap(cf);
        cb.setOption("keepAlive", true);
        cb.setOption("tcpNoDelay", true);
        cb.setPipelineFactory(new ChannelPipelineFactory() {
            @Override
            public ChannelPipeline getPipeline() throws Exception {
                ChannelPipeline pipeline = Channels.pipeline();
                // 外部server数据转发到client
                pipeline.addLast("outboundChannel", new OutboundHandler(inboundChannel, "out"));
                return pipeline;
            }
        });

        ChannelFuture f = cb.connect(new InetSocketAddress(socksCmdRequest.getHost(), socksCmdRequest.getPort()));

        outboundChannel = f.getChannel();
        ctx.getPipeline().remove(getName());
        f.addListener(new ChannelFutureListener() {
            public void operationComplete(ChannelFuture future) throws Exception {
                if (future.isSuccess()) {
                    // client数据转发到外部server
                    inboundChannel.getPipeline().addLast("inboundChannel", new OutboundHandler(outboundChannel, "in"));
                    inboundChannel.write(new SocksCmdResponse(SocksMessage.CmdStatus.SUCCESS, socksCmdRequest
                            .getAddressType()));
                    inboundChannel.setReadable(true);
                } else {
                    inboundChannel.write(new SocksCmdResponse(SocksMessage.CmdStatus.FAILURE, socksCmdRequest
                            .getAddressType()));
                    inboundChannel.close();
                }
            }
        });
    }
}

好了，完工！输入curl --socks5 127.0.0.1:1080 http://www.oschina.net/测试一下吧？但是测试时发现，怎么老是无法接收到响应？

使用wiredshark抓包之后，发现对外请求完全正常，但是对客户端的响应，则完全没有http响应部分？

一步步debug下去，才发现SocksMessageEncoder出了问题！

@Override
protected Object encode(ChannelHandlerContext ctx, Channel channel, Object msg) throws Exception {
    ChannelBuffer buffer = null;
    if (msg instanceof SocksMessage) {
        buffer = ChannelBuffers.buffer(DEFAULT_ENCODER_BUFFER_SIZE);
        ((SocksMessage) msg).encodeAsByteBuf(buffer);
    } 
    return buffer;
}

这里只有SocksMessage才会被处理，其他的message全部被丢掉了！于是我们加上一行:

@Override
protected Object encode(ChannelHandlerContext ctx, Channel channel, Object msg) throws Exception {
    ChannelBuffer buffer = null;
    if (msg instanceof SocksMessage) {
        buffer = ChannelBuffers.buffer(DEFAULT_ENCODER_BUFFER_SIZE);
        ((SocksMessage) msg).encodeAsByteBuf(buffer);
    } else if (msg instanceof ChannelBuffer) {
        //直接转发是ChannelBuffer类型
        buffer = (ChannelBuffer) msg;
    }
    return buffer;
}

至此，一个代理完成！点这里查看代码：https://github.com/code4craft/netty-learning/tree/master/learning-src/socksproxy