@Override
protected void decode(ChannelHandlerContext ctx, ByteBuf in, List<Object> out) throws Exception {
    try {
        switch (state()) {
        case INIT: {
            final byte version = in.readByte();
            if (version != SocksVersion.SOCKS5.byteValue()) {
                throw new DecoderException(
                        "unsupported version: " + version + " (expected: " + SocksVersion.SOCKS5.byteValue() + ')');
            }
            final Socks5CommandStatus status = Socks5CommandStatus.valueOf(in.readByte());
            in.skipBytes(1); // Reserved
            final Socks5AddressType addrType = Socks5AddressType.valueOf(in.readByte());
            final String addr = addressDecoder.decodeAddress(addrType, in);
            final int port = in.readUnsignedShort();

            out.add(new DefaultSocks5CommandResponse(status, addrType, addr, port));
            checkpoint(State.SUCCESS);
        }
        case SUCCESS: {
            int readableBytes = actualReadableBytes();
            if (readableBytes > 0) {
                out.add(in.readRetainedSlice(readableBytes));
            }
            break;
        }
        case FAILURE: {
            in.skipBytes(actualReadableBytes());
            break;
        }
        }
    } catch (Exception e) {
        fail(out, e);
    }
}
 

@Override
protected void decode(ChannelHandlerContext ctx, ByteBuf in, List<Object> out) throws Exception {
    try {
        switch (state()) {
        case INIT: {
            final byte version = in.readByte();
            if (version != SocksVersion.SOCKS5.byteValue()) {
                throw new DecoderException(
                        "unsupported version: " + version + " (expected: " + SocksVersion.SOCKS5.byteValue() + ')');
            }

            final int authMethodCnt = in.readUnsignedByte();
            if (actualReadableBytes() < authMethodCnt) {
                break;
            }

            final Socks5AuthMethod[] authMethods = new Socks5AuthMethod[authMethodCnt];
            for (int i = 0; i < authMethodCnt; i++) {
                authMethods[i] = Socks5AuthMethod.valueOf(in.readByte());
            }

            out.add(new DefaultSocks5InitialRequest(authMethods));
            checkpoint(State.SUCCESS);
        }
        case SUCCESS: {
            int readableBytes = actualReadableBytes();
            if (readableBytes > 0) {
                out.add(in.readRetainedSlice(readableBytes));
            }
            break;
        }
        case FAILURE: {
            in.skipBytes(actualReadableBytes());
            break;
        }
        }
    } catch (Exception e) {
        fail(out, e);
    }
}
 

@Override
protected void decode(ChannelHandlerContext ctx, ByteBuf in, List<Object> out) throws Exception {
    try {
        switch (state()) {
        case INIT: {
            final byte version = in.readByte();
            if (version != SocksVersion.SOCKS5.byteValue()) {
                throw new DecoderException(
                        "unsupported version: " + version + " (expected: " + SocksVersion.SOCKS5.byteValue() + ')');
            }

            final Socks5CommandType type = Socks5CommandType.valueOf(in.readByte());
            in.skipBytes(1); // RSV
            final Socks5AddressType dstAddrType = Socks5AddressType.valueOf(in.readByte());
            final String dstAddr = addressDecoder.decodeAddress(dstAddrType, in);
            final int dstPort = in.readUnsignedShort();

            out.add(new DefaultSocks5CommandRequest(type, dstAddrType, dstAddr, dstPort));
            checkpoint(State.SUCCESS);
        }
        case SUCCESS: {
            int readableBytes = actualReadableBytes();
            if (readableBytes > 0) {
                out.add(in.readRetainedSlice(readableBytes));
            }
            break;
        }
        case FAILURE: {
            in.skipBytes(actualReadableBytes());
            break;
        }
        }
    } catch (Exception e) {
        fail(out, e);
    }
}
 

@Override
protected void decode(ChannelHandlerContext ctx, ByteBuf in, List<Object> out) throws Exception {
    try {
        switch (state()) {
        case INIT: {
            final byte version = in.readByte();
            if (version != SocksVersion.SOCKS5.byteValue()) {
                throw new DecoderException(
                        "unsupported version: " + version + " (expected: " + SocksVersion.SOCKS5.byteValue() + ')');
            }

            final Socks5AuthMethod authMethod = Socks5AuthMethod.valueOf(in.readByte());
            out.add(new DefaultSocks5InitialResponse(authMethod));
            checkpoint(State.SUCCESS);
        }
        case SUCCESS: {
            int readableBytes = actualReadableBytes();
            if (readableBytes > 0) {
                out.add(in.readRetainedSlice(readableBytes));
            }
            break;
        }
        case FAILURE: {
            in.skipBytes(actualReadableBytes());
            break;
        }
        }
    } catch (Exception e) {
        fail(out, e);
    }
}
 

@Override
public final SocksVersion version() {
    return SocksVersion.SOCKS4a;
}
 

@Override
protected void decode(ChannelHandlerContext ctx, ByteBuf in, List<Object> out) throws Exception {
    try {
        switch (state()) {
        case START: {
            final int version = in.readUnsignedByte();
            if (version != SocksVersion.SOCKS4a.byteValue()) {
                throw new DecoderException("unsupported protocol version: " + version);
            }

            type = Socks4CommandType.valueOf(in.readByte());
            dstPort = in.readUnsignedShort();
            dstAddr = NetUtil.intToIpAddress(in.readInt());
            checkpoint(State.READ_USERID);
        }
        case READ_USERID: {
            userId = readString("userid", in);
            checkpoint(State.READ_DOMAIN);
        }
        case READ_DOMAIN: {
            // Check for Socks4a protocol marker 0.0.0.x
            if (!"0.0.0.0".equals(dstAddr) && dstAddr.startsWith("0.0.0.")) {
                dstAddr = readString("dstAddr", in);
            }
            out.add(new DefaultSocks4CommandRequest(type, dstAddr, dstPort, userId));
            checkpoint(State.SUCCESS);
        }
        case SUCCESS: {
            int readableBytes = actualReadableBytes();
            if (readableBytes > 0) {
                out.add(in.readRetainedSlice(readableBytes));
            }
            break;
        }
        case FAILURE: {
            in.skipBytes(actualReadableBytes());
            break;
        }
        }
    } catch (Exception e) {
        fail(out, e);
    }
}
 

@Override
public final SocksVersion version() {
    return SocksVersion.SOCKS5;
}