Suo5Server.java

import com.sun.net.httpserver.HttpExchange;
import com.sun.net.httpserver.HttpHandler;
import com.sun.net.httpserver.HttpServer;

import javax.net.ssl.HostnameVerifier;
import javax.net.ssl.HttpsURLConnection;
import javax.net.ssl.SSLContext;
import javax.net.ssl.SSLSession;
import javax.net.ssl.TrustManager;
import javax.net.ssl.X509TrustManager;
import java.io.ByteArrayInputStream;
import java.io.ByteArrayOutputStream;
import java.io.FilterOutputStream;
import java.io.IOException;
import java.io.InputStream;
import java.io.OutputStream;
import java.net.HttpURLConnection;
import java.net.InetAddress;
import java.net.InetSocketAddress;
import java.net.NetworkInterface;
import java.net.Socket;
import java.net.SocketTimeoutException;
import java.net.URL;
import java.nio.ByteBuffer;
import java.nio.channels.SocketChannel;
import java.security.cert.CertificateException;
import java.security.cert.X509Certificate;
import java.util.ArrayList;
import java.util.Enumeration;
import java.util.HashMap;
import java.util.Hashtable;
import java.util.List;
import java.util.Random;
import java.util.concurrent.BlockingQueue;
import java.util.concurrent.Executors;
import java.util.concurrent.LinkedBlockingQueue;
import java.util.concurrent.TimeUnit;

public final class Suo5Server {
    private Suo5Server() {
    }

    public static void main(String[] args) throws Exception {
        Config config = Config.parse(args);
        InetSocketAddress address = new InetSocketAddress(config.host, config.port);
        HttpServer server = HttpServer.create(address, 128);
        server.createContext(config.path, new Suo5Handler(config));
        server.setExecutor(Executors.newCachedThreadPool());
        server.start();
    }

    private static final class Config {
        private String host = "0.0.0.0";
        private int port = 1098;
        private String path = "/s5";
        private String header = "X-Authorization";
        private String token = "";

        private static Config parse(String[] args) {
            Config config = new Config();
            for (int i = 0; i < args.length; i++) {
                String arg = args[i];
                if ("-l".equals(arg) && i + 1 < args.length) {
                    config.host = args[++i];
                } else if ("-p".equals(arg) && i + 1 < args.length) {
                    config.port = Integer.parseInt(args[++i]);
                } else if ("-P".equals(arg) && i + 1 < args.length) {
                    config.path = normalizePath(args[++i]);
                } else if ("-t".equals(arg) && i + 1 < args.length) {
                    config.token = args[++i];
                } else if ("-k".equals(arg) && i + 1 < args.length) {
                    config.header = args[++i];
                } else {
                    throw new IllegalArgumentException("unknown or incomplete argument: " + arg);
                }
            }
            return config;
        }

        private static String normalizePath(String path) {
            if (path == null || path.length() == 0) {
                return "/s5";
            }
            return path.startsWith("/") ? path : "/" + path;
        }
    }

    private static final class Suo5Handler implements HttpHandler {
        private final Config config;

        private Suo5Handler(Config config) {
            this.config = config;
        }

        public void handle(HttpExchange exchange) throws IOException {
            if (!isAuthorized(exchange)) {
                byte[] body = "unauthorized".getBytes("UTF-8");
                exchange.getResponseHeaders().set("Content-Type", "text/plain; charset=utf-8");
                exchange.sendResponseHeaders(401, body.length);
                OutputStream out = exchange.getResponseBody();
                out.write(body);
                out.close();
                return;
            }

            SimpleRequest request = new SimpleRequest(exchange);
            SimpleResponse response = new SimpleResponse(exchange);
            try {
                new Suo5().process(request, response);
            } finally {
                try {
                    response.closeIfNeeded();
                } catch (IOException ignored) {
                }
            }
        }

        private boolean isAuthorized(HttpExchange exchange) {
            if (config.token == null || config.token.length() == 0) {
                return true;
            }
            String headerToken = exchange.getRequestHeaders().getFirst(config.header);
            if (config.token.equals(headerToken)) {
                return true;
            }
            String query = exchange.getRequestURI().getRawQuery();
            if (query == null || query.length() == 0) {
                return false;
            }
            String[] pairs = query.split("&");
            for (int i = 0; i < pairs.length; i++) {
                String pair = pairs[i];
                int idx = pair.indexOf('=');
                if (idx > 0 && "token".equals(pair.substring(0, idx)) && config.token.equals(pair.substring(idx + 1))) {
                    return true;
                }
            }
            return false;
        }
    }

    private static final class SimpleRequest {
        private final HttpExchange exchange;

        private SimpleRequest(HttpExchange exchange) {
            this.exchange = exchange;
        }

        private InputStream getInputStream() {
            return exchange.getRequestBody();
        }

        private String getMethod() {
            return exchange.getRequestMethod();
        }

        private int getLocalPort() {
            return exchange.getLocalAddress().getPort();
        }

        private int getServerPort() {
            return getLocalPort();
        }

        private Enumeration<String> getHeaderNames() {
            List<String> names = new ArrayList<String>(exchange.getRequestHeaders().keySet());
            return java.util.Collections.enumeration(names);
        }

        private String getHeader(String name) {
            return exchange.getRequestHeaders().getFirst(name);
        }
    }

    private static final class SimpleResponse {
        private final HttpExchange exchange;
        private final OutputStream body;
        private int status = 200;
        private long contentLength = Long.MIN_VALUE;
        private boolean headersSent;

        private SimpleResponse(HttpExchange exchange) {
            this.exchange = exchange;
            this.body = new FilterOutputStream(exchange.getResponseBody()) {
                public void write(int b) throws IOException {
                    ensureHeadersSent();
                    out.write(b);
                }

                public void write(byte[] b, int off, int len) throws IOException {
                    ensureHeadersSent();
                    out.write(b, off, len);
                }

                public void flush() throws IOException {
                    ensureHeadersSent();
                    out.flush();
                }

                public void close() throws IOException {
                    ensureHeadersSent();
                    out.close();
                }
            };
        }

        private void setBufferSize(int size) {
        }

        private void setHeader(String name, String value) {
            if (!headersSent) {
                exchange.getResponseHeaders().set(name, value);
            }
        }

        private void setStatus(int status) {
            if (!headersSent) {
                this.status = status;
            }
        }

        private void setContentLength(int length) {
            if (!headersSent) {
                this.contentLength = length;
                exchange.getResponseHeaders().set("Content-Length", String.valueOf(length));
            }
        }

        private OutputStream getOutputStream() {
            return body;
        }

        private void flushBuffer() throws IOException {
            ensureHeadersSent();
            body.flush();
        }

        private void closeIfNeeded() throws IOException {
            body.close();
        }

        private void ensureHeadersSent() throws IOException {
            if (headersSent) {
                return;
            }
            headersSent = true;
            long length = contentLength == Long.MIN_VALUE ? 0 : contentLength;
            exchange.sendResponseHeaders(status, length);
        }
    }

    public static class Suo5 implements Runnable, HostnameVerifier, X509TrustManager {
        private static HashMap addrs = collectAddr();
        private static Hashtable ctx = new Hashtable();

        private final String CHARACTERS = "abcdefghijklmnopqrstuvwxyz0123456789";
        private final int CHARACTERS_LENGTH = CHARACTERS.length();
        private final int BUF_SIZE = 1024 * 16;

        private InputStream gInStream;
        private OutputStream gOutStream;
        private String gtunId;
        private int mode = 0;

        public Suo5() {
        }

        public Suo5(InputStream in, OutputStream out, String tunId) {
            this.gInStream = in;
            this.gOutStream = out;
            this.gtunId = tunId;
        }

        public Suo5(String tunId, int mode) {
            this.gtunId = tunId;
            this.mode = mode;
        }

        private void process(SimpleRequest req, SimpleResponse resp) {
            String sid = null;
            byte[] bodyPrefix = new byte[0];
            try {
                InputStream reqInputStream = req.getInputStream();
                HashMap dataMap = unmarshalBase64(reqInputStream);

                byte[] modeData = (byte[]) dataMap.get("m");
                byte[] actionData = (byte[]) dataMap.get("ac");
                byte[] tunIdData = (byte[]) dataMap.get("id");
                byte[] sidData = (byte[]) dataMap.get("sid");
                if (actionData == null || actionData.length != 1 || tunIdData == null || tunIdData.length == 0 || modeData == null || modeData.length == 0) {
                    return;
                }
                if (sidData != null && sidData.length > 0) {
                    sid = new String(sidData);
                }

                String tunId = new String(tunIdData);
                byte mode = modeData[0];
                switch (mode) {
                    case 0x00:
                        sid = randomString(16);
                        processHandshake(req, resp, dataMap, tunId, sid);
                        break;
                    case 0x01:
                        setBypassHeader(resp);
                        processFullStream(req, resp, dataMap, tunId);
                        break;
                    case 0x02:
                        setBypassHeader(resp);
                    case 0x03:
                        byte[] bodyContent = toByteArray(reqInputStream);
                        if (processRedirect(req, resp, dataMap, bodyPrefix, bodyContent)) {
                            break;
                        }

                        if (sidData == null || sidData.length == 0 || getKey(new String(sidData)) == null) {
                            resp.setStatus(403);
                            return;
                        }

                        InputStream bodyStream = new ByteArrayInputStream(bodyContent);
                        int dirySize = getDirtySize(sid);

                        if (mode == 0x02) {
                            writeAndFlush(resp, processTemplateStart(resp, new String(sidData)), dirySize);
                            do {
                                processHalfStream(req, resp, dataMap, tunId, dirySize);
                                try {
                                    dataMap = unmarshalBase64(bodyStream);
                                    if (dataMap.isEmpty()) {
                                        break;
                                    }
                                    tunId = new String((byte[]) dataMap.get("id"));
                                } catch (Exception e) {
                                    break;
                                }
                            } while (true);
                            writeAndFlush(resp, processTemplateEnd(sid), dirySize);
                        } else {
                            ByteArrayOutputStream baos = new ByteArrayOutputStream();
                            baos.write(processTemplateStart(resp, new String(sidData)));

                            do {
                                processClassic(req, baos, dataMap, tunId);
                                try {
                                    dataMap = unmarshalBase64(bodyStream);
                                    if (dataMap.isEmpty()) {
                                        break;
                                    }
                                    tunId = new String((byte[]) dataMap.get("id"));
                                } catch (Exception e) {
                                    break;
                                }
                            } while (true);

                            baos.write(processTemplateEnd(sid));
                            resp.setContentLength(baos.size());
                            writeAndFlush(resp, baos.toByteArray(), 0);
                        }
                        break;
                    default:
                }
            } catch (Throwable e) {
            } finally {
                try {
                    OutputStream out = resp.getOutputStream();
                    out.flush();
                    out.close();
                } catch (Throwable ignored) {
                }
            }
        }

        private void setBypassHeader(SimpleResponse resp) {
            resp.setBufferSize(BUF_SIZE);
            resp.setHeader("X-Accel-Buffering", "no");
        }

        private byte[] processTemplateStart(SimpleResponse resp, String sid) throws Exception {
            byte[] data = new byte[0];
            Object o = getKey(sid);
            if (o == null) {
                return data;
            }
            String[] tplParts = (String[]) o;
            if (tplParts.length != 3) {
                return data;
            }

            resp.setHeader("Content-Type", tplParts[0]);
            return tplParts[1].getBytes();
        }

        private byte[] processTemplateEnd(String sid) {
            byte[] data = new byte[0];
            Object o = getKey(sid);
            if (o == null) {
                return data;
            }
            String[] tplParts = (String[]) o;
            if (tplParts.length != 3) {
                return data;
            }

            return tplParts[2].getBytes();
        }

        private int getDirtySize(String sid) {
            Object o = getKey(sid + "_jk");
            if (o == null) {
                return 0;
            }
            return (Integer) o;
        }

        private boolean processRedirect(SimpleRequest req, SimpleResponse resp, HashMap dataMap, byte[] bodyPrefix, byte[] bodyContent) throws Exception {
            byte[] redirectData = (byte[]) dataMap.get("r");
            dataMap.remove("r");
            boolean needRedirect = redirectData != null && redirectData.length > 0;
            if (needRedirect && !isLocalAddr(new String(redirectData))) {
                HttpURLConnection conn = null;
                try {
                    ByteArrayOutputStream baos = new ByteArrayOutputStream();
                    baos.write(bodyPrefix);
                    baos.write(marshalBase64(dataMap));
                    baos.write(bodyContent);
                    byte[] newBody = baos.toByteArray();
                    conn = redirect(req, new String(redirectData), newBody);
                    resp.setStatus(conn.getResponseCode());
                    pipeStream(conn.getInputStream(), resp.getOutputStream(), resp, false);
                } finally {
                    if (conn != null) {
                        conn.disconnect();
                    }
                }
                return true;
            }
            return false;
        }

        private void processHandshake(SimpleRequest req, SimpleResponse resp, HashMap dataMap, String tunId, String sid) throws Exception {
            byte[] redirectData = (byte[]) dataMap.get("r");
            boolean needRedirect = redirectData != null && redirectData.length > 0;
            if (needRedirect && !isLocalAddr(new String(redirectData))) {
                resp.setStatus(403);
                return;
            }

            byte[] tplData = (byte[]) dataMap.get("tpl");
            byte[] contentTypeData = (byte[]) dataMap.get("ct");
            if (tplData != null && tplData.length > 0 && contentTypeData != null && contentTypeData.length > 0) {
                String tpl = new String(tplData);
                String[] parts = tpl.split("#data#", 2);
                putKey(sid, new String[]{new String(contentTypeData), parts[0], parts[1]});
            } else {
                putKey(sid, new String[0]);
            }

            byte[] dirtySizeData = (byte[]) dataMap.get("jk");
            if (dirtySizeData != null && dirtySizeData.length > 0) {
                int dirtySize = 0;
                try {
                    dirtySize = Integer.parseInt(new String(dirtySizeData));
                } catch (NumberFormatException e) {
                }
                if (dirtySize < 0) {
                    dirtySize = 0;
                }
                putKey(sid + "_jk", dirtySize);
            }

            byte[] isAutoData = (byte[]) dataMap.get("a");
            boolean isAuto = isAutoData != null && isAutoData.length > 0 && isAutoData[0] == 0x01;
            if (isAuto) {
                setBypassHeader(resp);
                writeAndFlush(resp, processTemplateStart(resp, sid), 0);
                writeAndFlush(resp, marshalBase64(newData(tunId, (byte[]) dataMap.get("dt"))), 0);
                Thread.sleep(2000);
                writeAndFlush(resp, marshalBase64(newData(tunId, sid.getBytes())), 0);
                writeAndFlush(resp, processTemplateEnd(sid), 0);
            } else {
                ByteArrayOutputStream baos = new ByteArrayOutputStream();
                baos.write(processTemplateStart(resp, sid));
                baos.write(marshalBase64(newData(tunId, (byte[]) dataMap.get("dt"))));
                baos.write(marshalBase64(newData(tunId, sid.getBytes())));
                baos.write(processTemplateEnd(sid));
                resp.setContentLength(baos.size());
                writeAndFlush(resp, baos.toByteArray(), 0);
            }
        }

        private void processFullStream(SimpleRequest req, SimpleResponse resp, HashMap dataMap, String tunId) throws Exception {
            InputStream reqInputStream = req.getInputStream();
            String host = new String((byte[]) dataMap.get("h"));
            int port = Integer.parseInt(new String((byte[]) dataMap.get("p")));
            if (port == 0) {
                port = getServerPort(req);
            }

            Socket socket = null;
            try {
                socket = new Socket();
                socket.setTcpNoDelay(true);
                socket.setReceiveBufferSize(128 * 1024);
                socket.setSendBufferSize(128 * 1024);
                socket.connect(new InetSocketAddress(host, port), 5000);
                writeAndFlush(resp, marshalBase64(newStatus(tunId, (byte) 0x00)), 0);
            } catch (Exception e) {
                if (socket != null) {
                    socket.close();
                }
                writeAndFlush(resp, marshalBase64(newStatus(tunId, (byte) 0x01)), 0);
                return;
            }

            Thread t = null;
            boolean sendClose = true;
            final OutputStream scOutStream = socket.getOutputStream();
            final InputStream scInStream = socket.getInputStream();
            final OutputStream respOutputStream = resp.getOutputStream();

            try {
                Suo5 p = new Suo5(scInStream, respOutputStream, tunId);
                t = new Thread(p);
                t.start();

                while (true) {
                    HashMap newData = unmarshalBase64(reqInputStream);
                    if (newData.isEmpty()) {
                        break;
                    }
                    byte action = ((byte[]) newData.get("ac"))[0];
                    switch (action) {
                        case 0x00:
                        case 0x02:
                            sendClose = false;
                            break;
                        case 0x01:
                            byte[] data = (byte[]) newData.get("dt");
                            if (data.length != 0) {
                                scOutStream.write(data);
                                scOutStream.flush();
                            }
                            break;
                        case 0x10:
                            writeAndFlush(resp, marshalBase64(newHeartbeat(tunId)), 0);
                            break;
                        default:
                    }
                }
            } catch (Exception ignored) {
            } finally {
                try {
                    socket.close();
                } catch (Exception ignored) {
                }

                if (sendClose) {
                    writeAndFlush(resp, marshalBase64(newDel(tunId)), 0);
                }

                if (t != null) {
                    t.join();
                }
            }
        }

        private void processHalfStream(SimpleRequest req, SimpleResponse resp, HashMap dataMap, String tunId, int dirtySize) throws Exception {
            boolean newThread = false;
            boolean sendClose = true;

            try {
                byte action = ((byte[]) dataMap.get("ac"))[0];
                switch (action) {
                    case 0x00:
                        byte[] createData = performCreate(req, dataMap, tunId, newThread);
                        writeAndFlush(resp, createData, dirtySize);

                        Object[] objs = (Object[]) getKey(tunId);
                        if (objs == null) {
                            throw new IOException("tunnel not found");
                        }
                        SocketChannel sc = (SocketChannel) objs[0];
                        ByteBuffer buffer = ByteBuffer.allocate(BUF_SIZE);
                        while (true) {
                            try {
                                byte[] data = readSocketChannel(sc, buffer);
                                if (data.length == 0) {
                                    break;
                                }
                                writeAndFlush(resp, marshalBase64(newData(tunId, data)), dirtySize);
                            } catch (Exception e) {
                                break;
                            }
                        }
                        break;
                    case 0x01:
                        performWrite(dataMap, tunId, newThread);
                        break;
                    case 0x02:
                        sendClose = false;
                        performDelete(tunId);
                        break;
                    case 0x10:
                        writeAndFlush(resp, marshalBase64(newHeartbeat(tunId)), dirtySize);
                        break;
                    default:
                }
            } catch (Exception e) {
                performDelete(tunId);
                if (sendClose) {
                    writeAndFlush(resp, marshalBase64(newDel(tunId)), dirtySize);
                }
            }
        }

        private void processClassic(SimpleRequest req, ByteArrayOutputStream respBodyStream, HashMap dataMap, String tunId) throws Exception {
            boolean sendClose = true;
            boolean newThread = true;

            try {
                byte action = ((byte[]) dataMap.get("ac"))[0];
                switch (action) {
                    case 0x00:
                        byte[] createData = performCreate(req, dataMap, tunId, newThread);
                        respBodyStream.write(createData);
                        break;
                    case 0x01:
                        performWrite(dataMap, tunId, newThread);
                        byte[] readData = performRead(tunId);
                        respBodyStream.write(readData);
                        break;
                    case 0x02:
                        sendClose = false;
                        performDelete(tunId);
                        break;
                    default:
                }
            } catch (Exception e) {
                performDelete(tunId);
                if (sendClose) {
                    respBodyStream.write(marshalBase64(newDel(tunId)));
                }
            }
        }

        private void writeAndFlush(SimpleResponse resp, byte[] data, int dirtySize) throws Exception {
            if (data == null || data.length == 0) {
                return;
            }
            OutputStream out = resp.getOutputStream();
            out.write(data);
            if (dirtySize != 0) {
                out.write(marshalBase64(newDirtyChunk(dirtySize)));
            }
            out.flush();
            resp.flushBuffer();
        }

        private byte[] performCreate(SimpleRequest request, HashMap dataMap, String tunId, boolean newThread) throws Exception {
            String host = new String((byte[]) dataMap.get("h"));
            int port = Integer.parseInt(new String((byte[]) dataMap.get("p")));
            if (port == 0) {
                port = getServerPort(request);
            }

            ByteArrayOutputStream baos = new ByteArrayOutputStream();
            SocketChannel socketChannel = null;
            HashMap resultData;
            try {
                socketChannel = SocketChannel.open();
                socketChannel.socket().setTcpNoDelay(true);
                socketChannel.socket().setReceiveBufferSize(128 * 1024);
                socketChannel.socket().setSendBufferSize(128 * 1024);
                socketChannel.socket().connect(new InetSocketAddress(host, port), 3000);
                socketChannel.configureBlocking(true);
                resultData = newStatus(tunId, (byte) 0x00);
                BlockingQueue<byte[]> readQueue = new LinkedBlockingQueue<byte[]>(100);
                BlockingQueue<byte[]> writeQueue = new LinkedBlockingQueue<byte[]>();
                putKey(tunId, new Object[]{socketChannel, readQueue, writeQueue});
                if (newThread) {
                    new Thread(new Suo5(tunId, 1)).start();
                    new Thread(new Suo5(tunId, 2)).start();
                }
            } catch (Exception e) {
                if (socketChannel != null) {
                    try {
                        socketChannel.close();
                    } catch (Exception ignore) {
                    }
                }
                resultData = newStatus(tunId, (byte) 0x01);
            }
            baos.write(marshalBase64(resultData));
            return baos.toByteArray();
        }

        private void performWrite(HashMap dataMap, String tunId, boolean newThread) throws Exception {
            Object[] objs = (Object[]) getKey(tunId);
            if (objs == null) {
                throw new IOException("tunnel not found");
            }
            SocketChannel sc = (SocketChannel) objs[0];
            if (!sc.isOpen()) {
                return;
            }

            byte[] data = (byte[]) dataMap.get("dt");
            if (data.length != 0) {
                if (newThread) {
                    BlockingQueue<byte[]> writeQueue = (BlockingQueue<byte[]>) objs[2];
                    writeQueue.put(data);
                } else {
                    ByteBuffer buf = ByteBuffer.wrap(data);
                    while (buf.hasRemaining()) {
                        sc.write(buf);
                    }
                }
            }
        }

        private byte[] performRead(String tunId) throws Exception {
            Object[] objs = (Object[]) getKey(tunId);
            if (objs == null) {
                throw new IOException("tunnel not found");
            }
            SocketChannel sc = (SocketChannel) objs[0];
            BlockingQueue<byte[]> readQueue = (BlockingQueue<byte[]>) objs[1];
            ByteArrayOutputStream baos = new ByteArrayOutputStream();
            int maxSize = 512 * 1024;
            int written = 0;
            while (true) {
                byte[] data = readQueue.poll();
                if (data != null) {
                    written += data.length;
                    baos.write(marshalBase64(newData(tunId, data)));
                    if (written >= maxSize) {
                        break;
                    }
                } else {
                    break;
                }
            }

            if (!sc.isOpen() && readQueue.isEmpty()) {
                performDelete(tunId);
                baos.write(marshalBase64(newDel(tunId)));
            }

            return baos.toByteArray();
        }

        private void performDelete(String tunId) {
            Object[] objs = (Object[]) getKey(tunId);
            if (objs != null) {
                removeKey(tunId);
                SocketChannel sc = (SocketChannel) objs[0];
                BlockingQueue<byte[]> writeQueue = (BlockingQueue<byte[]>) objs[2];
                try {
                    writeQueue.put(new byte[0]);
                    sc.close();
                } catch (Exception ignore) {
                }
            }
        }

        private int getServerPort(SimpleRequest request) {
            return request.getLocalPort();
        }

        private void pipeStream(InputStream inputStream, OutputStream outputStream, SimpleResponse resp, boolean needMarshal) throws Exception {
            try {
                byte[] readBuf = new byte[1024 * 8];
                while (true) {
                    int n = inputStream.read(readBuf);
                    if (n <= 0) {
                        break;
                    }
                    byte[] dataTmp = copyOfRange(readBuf, 0, n);
                    if (needMarshal) {
                        dataTmp = marshalBase64(newData(this.gtunId, dataTmp));
                    }
                    outputStream.write(dataTmp);
                    outputStream.flush();
                    if (resp != null) {
                        resp.flushBuffer();
                    }
                }
            } finally {
                if (inputStream != null) {
                    try {
                        inputStream.close();
                    } catch (Exception ignore) {
                    }
                }
            }
        }

        private byte[] readSocketChannel(SocketChannel socketChannel, ByteBuffer buffer) throws IOException {
            buffer.clear();
            int bytesRead = socketChannel.read(buffer);
            if (bytesRead <= 0) {
                return new byte[0];
            }

            buffer.flip();
            byte[] data = new byte[buffer.remaining()];
            buffer.get(data);
            return data;
        }

        private static HashMap collectAddr() {
            HashMap addrs = new HashMap();
            try {
                Enumeration nifs = NetworkInterface.getNetworkInterfaces();
                while (nifs.hasMoreElements()) {
                    NetworkInterface nif = (NetworkInterface) nifs.nextElement();
                    Enumeration addresses = nif.getInetAddresses();
                    while (addresses.hasMoreElements()) {
                        InetAddress addr = (InetAddress) addresses.nextElement();
                        String s = addr.getHostAddress();
                        if (s != null) {
                            int ifaceIndex = s.indexOf('%');
                            if (ifaceIndex != -1) {
                                s = s.substring(0, ifaceIndex);
                            }
                            addrs.put(s, Boolean.TRUE);
                        }
                    }
                }
            } catch (Exception e) {
            }
            return addrs;
        }

        private boolean isLocalAddr(String url) throws Exception {
            String ip = (new URL(url)).getHost();
            return addrs.containsKey(ip);
        }

        private HttpURLConnection redirect(SimpleRequest request, String rUrl, byte[] body) throws Exception {
            String method = request.getMethod();
            URL u = new URL(rUrl);
            HttpURLConnection conn = (HttpURLConnection) u.openConnection();
            conn.setRequestMethod(method);
            conn.setConnectTimeout(3000);
            conn.setReadTimeout(0);
            conn.setDoOutput(true);
            conn.setDoInput(true);

            if (HttpsURLConnection.class.isInstance(conn)) {
                ((HttpsURLConnection) conn).setHostnameVerifier(this);
                SSLContext sslCtx = SSLContext.getInstance("SSL");
                sslCtx.init(null, new TrustManager[]{this}, null);
                ((HttpsURLConnection) conn).setSSLSocketFactory(sslCtx.getSocketFactory());
            }

            Enumeration headers = request.getHeaderNames();
            while (headers.hasMoreElements()) {
                String k = (String) headers.nextElement();
                if (k.equalsIgnoreCase("Content-Length")) {
                    conn.setRequestProperty(k, String.valueOf(body.length));
                } else if (k.equalsIgnoreCase("Host")) {
                    conn.setRequestProperty(k, u.getHost());
                } else if (k.equalsIgnoreCase("Connection")) {
                    conn.setRequestProperty(k, "close");
                } else if (k.equalsIgnoreCase("Content-Encoding") || k.equalsIgnoreCase("Transfer-Encoding")) {
                    continue;
                } else {
                    conn.setRequestProperty(k, request.getHeader(k));
                }
            }

            OutputStream rout = conn.getOutputStream();
            rout.write(body);
            rout.flush();
            rout.close();
            conn.getResponseCode();
            return conn;
        }

        private byte[] toByteArray(InputStream in) {
            try {
                ByteArrayOutputStream baos = new ByteArrayOutputStream();
                byte[] buffer = new byte[4096];
                int len;
                while ((len = in.read(buffer)) != -1) {
                    baos.write(buffer, 0, len);
                }
                return baos.toByteArray();
            } catch (IOException var5) {
                return new byte[0];
            }
        }

        private void readFull(InputStream is, byte[] b) throws IOException {
            int bufferOffset = 0;
            while (bufferOffset < b.length) {
                int readLength = b.length - bufferOffset;
                int readResult = is.read(b, bufferOffset, readLength);
                if (readResult == -1) {
                    throw new IOException("stream EOF");
                }
                bufferOffset += readResult;
            }
        }

        public HashMap newDirtyChunk(int size) {
            HashMap m = new HashMap();
            m.put("ac", new byte[]{0x11});
            if (size > 0) {
                byte[] data = new byte[size];
                new Random().nextBytes(data);
                m.put("d", data);
            }
            return m;
        }

        private HashMap newData(String tunId, byte[] data) {
            HashMap m = new HashMap();
            m.put("ac", new byte[]{0x01});
            m.put("dt", data);
            m.put("id", tunId.getBytes());
            return m;
        }

        private HashMap newDel(String tunId) {
            HashMap m = new HashMap();
            m.put("ac", new byte[]{0x02});
            m.put("id", tunId.getBytes());
            return m;
        }

        private HashMap newStatus(String tunId, byte b) {
            HashMap m = new HashMap();
            m.put("ac", new byte[]{0x03});
            m.put("s", new byte[]{b});
            m.put("id", tunId.getBytes());
            return m;
        }

        private HashMap newHeartbeat(String tunId) {
            HashMap m = new HashMap();
            m.put("ac", new byte[]{0x10});
            m.put("id", tunId.getBytes());
            return m;
        }

        private byte[] u32toBytes(int i) {
            byte[] result = new byte[4];
            result[0] = (byte) (i >> 24);
            result[1] = (byte) (i >> 16);
            result[2] = (byte) (i >> 8);
            result[3] = (byte) i;
            return result;
        }

        private int bytesToU32(byte[] bytes) {
            return ((bytes[0] & 0xFF) << 24)
                    | ((bytes[1] & 0xFF) << 16)
                    | ((bytes[2] & 0xFF) << 8)
                    | (bytes[3] & 0xFF);
        }

        private void putKey(String k, Object v) {
            ctx.put(k, v);
        }

        private Object getKey(String k) {
            return ctx.get(k);
        }

        private void removeKey(String k) {
            ctx.remove(k);
        }

        private byte[] copyOfRange(byte[] original, int from, int to) {
            int newLength = to - from;
            if (newLength < 0) {
                throw new IllegalArgumentException(from + " > " + to);
            }
            byte[] copy = new byte[newLength];
            int copyLength = Math.min(original.length - from, newLength);
            for (int i = 0; i < copyLength; i++) {
                copy[i] = original[from + i];
            }
            return copy;
        }

        private String base64UrlEncode(byte[] bs) throws Exception {
            Class base64;
            String value = null;
            try {
                base64 = Class.forName("java.util.Base64");
                Object encoder = base64.getMethod("getEncoder", new Class[0]).invoke(base64, new Object[0]);
                value = (String) encoder.getClass().getMethod("encodeToString", new Class[]{byte[].class}).invoke(encoder, new Object[]{bs});
            } catch (Exception e) {
                try {
                    base64 = Class.forName("sun.misc.BASE64Encoder");
                    Object encoder = base64.newInstance();
                    value = (String) encoder.getClass().getMethod("encode", new Class[]{byte[].class}).invoke(encoder, new Object[]{bs});
                    value = value.replaceAll("\\s+", "");
                } catch (Exception e2) {
                }
            }
            if (value != null) {
                value = value.replace('+', '-').replace('/', '_');
                while (value.endsWith("=")) {
                    value = value.substring(0, value.length() - 1);
                }
            }
            return value;
        }

        private byte[] base64UrlDecode(String bs) throws Exception {
            if (bs == null) {
                return null;
            }
            bs = bs.replace('-', '+').replace('_', '/');
            while (bs.length() % 4 != 0) {
                bs += "=";
            }

            Class base64;
            byte[] value = null;
            try {
                base64 = Class.forName("java.util.Base64");
                Object decoder = base64.getMethod("getDecoder", new Class[0]).invoke(base64, new Object[0]);
                value = (byte[]) decoder.getClass().getMethod("decode", new Class[]{String.class}).invoke(decoder, new Object[]{bs});
            } catch (Exception e) {
                try {
                    base64 = Class.forName("sun.misc.BASE64Decoder");
                    Object decoder = base64.newInstance();
                    value = (byte[]) decoder.getClass().getMethod("decodeBuffer", new Class[]{String.class}).invoke(decoder, new Object[]{bs});
                } catch (Exception e2) {
                }
            }
            return value;
        }

        private byte[] marshalBase64(HashMap m) throws Exception {
            Random random = new Random();
            int junkSize = random.nextInt(32);
            if (junkSize > 0) {
                byte[] junk = new byte[junkSize];
                random.nextBytes(junk);
                m.put("_", junk);
            }

            ByteArrayOutputStream buf = new ByteArrayOutputStream();
            Object[] keys = m.keySet().toArray();
            for (int i = 0; i < keys.length; i++) {
                String key = (String) keys[i];
                byte[] value = (byte[]) m.get(key);
                buf.write((byte) key.length());
                buf.write(key.getBytes());
                buf.write(u32toBytes(value.length));
                buf.write(value);
            }

            byte[] key = new byte[2];
            key[0] = (byte) ((Math.random() * 255) + 1);
            key[1] = (byte) ((Math.random() * 255) + 1);

            byte[] data = buf.toByteArray();
            for (int i = 0; i < data.length; i++) {
                data[i] = (byte) (data[i] ^ key[i % 2]);
            }
            data = base64UrlEncode(data).getBytes();

            ByteBuffer dbuf = ByteBuffer.allocate(6);
            dbuf.put(key);
            dbuf.putInt(data.length);
            byte[] headerData = dbuf.array();
            for (int i = 2; i < 6; i++) {
                headerData[i] = (byte) (headerData[i] ^ key[i % 2]);
            }
            headerData = base64UrlEncode(headerData).getBytes();
            dbuf = ByteBuffer.allocate(8 + data.length);
            dbuf.put(headerData);
            dbuf.put(data);
            return dbuf.array();
        }

        private HashMap unmarshalBase64(InputStream in) throws Exception {
            HashMap m = new HashMap();
            byte[] header = new byte[8];
            readFull(in, header);
            header = base64UrlDecode(new String(header));
            if (header == null || header.length == 0) {
                return m;
            }
            byte[] xor = new byte[]{header[0], header[1]};
            for (int i = 2; i < 6; i++) {
                header[i] = (byte) (header[i] ^ xor[i % 2]);
            }
            ByteBuffer bb = ByteBuffer.wrap(header, 2, 4);
            int len = bb.getInt();
            if (len > 1024 * 1024 * 32) {
                throw new IOException("invalid len");
            }
            byte[] bs = new byte[len];
            readFull(in, bs);
            bs = base64UrlDecode(new String(bs));
            for (int i = 0; i < bs.length; i++) {
                bs[i] = (byte) (bs[i] ^ xor[i % 2]);
            }

            byte[] buf;
            for (int i = 0; i < bs.length; ) {
                int kLen = bs[i] & 0xFF;
                i += 1;
                if (i + kLen > bs.length) {
                    throw new Exception("key len error");
                }
                buf = copyOfRange(bs, i, i + kLen);
                String key = new String(buf);
                i += kLen;

                if (i + 4 > bs.length) {
                    throw new Exception("value len error");
                }
                buf = copyOfRange(bs, i, i + 4);
                int vLen = bytesToU32(buf);
                i += 4;
                if (vLen < 0) {
                    throw new Exception("value error");
                }

                if (i + vLen > bs.length) {
                    throw new Exception("value error");
                }
                byte[] value = copyOfRange(bs, i, i + vLen);
                i += vLen;

                m.put(key, value);
            }
            return m;
        }

        private String randomString(int length) {
            if (length <= 0) {
                return "";
            }
            Random random = new Random();
            char[] randomChars = new char[length];
            for (int i = 0; i < length; i++) {
                int randomIndex = random.nextInt(CHARACTERS_LENGTH);
                randomChars[i] = CHARACTERS.charAt(randomIndex);
            }
            return new String(randomChars);
        }

        public boolean verify(String hostname, SSLSession session) {
            return true;
        }

        public void checkClientTrusted(X509Certificate[] chain, String authType) throws CertificateException {
        }

        public void checkServerTrusted(X509Certificate[] chain, String authType) throws CertificateException {
        }

        public X509Certificate[] getAcceptedIssuers() {
            return new X509Certificate[0];
        }

        public void run() {
            if (this.mode == 0) {
                try {
                    pipeStream(gInStream, gOutStream, null, true);
                } catch (Exception ignore) {
                }
                return;
            }

            Object[] objs = (Object[]) getKey(this.gtunId);
            if (objs == null || objs.length != 3) {
                return;
            }
            SocketChannel sc = (SocketChannel) objs[0];
            BlockingQueue<byte[]> readQueue = (BlockingQueue<byte[]>) objs[1];
            BlockingQueue<byte[]> writeQueue = (BlockingQueue<byte[]>) objs[2];
            boolean selfClean = false;

            try {
                if (mode == 1) {
                    ByteBuffer buffer = ByteBuffer.allocate(BUF_SIZE);
                    while (true) {
                        byte[] data = readSocketChannel(sc, buffer);
                        if (data.length == 0) {
                            break;
                        }
                        if (!readQueue.offer(data, 60, TimeUnit.SECONDS)) {
                            selfClean = true;
                            break;
                        }
                    }
                } else {
                    while (true) {
                        byte[] data = writeQueue.poll(300, TimeUnit.SECONDS);
                        if (data == null) {
                            selfClean = true;
                            break;
                        }
                        if (data.length == 0) {
                            byte[] signal = writeQueue.poll(10, TimeUnit.SECONDS);
                            if (signal == null) {
                                selfClean = true;
                            }
                            break;
                        }
                        ByteBuffer buf = ByteBuffer.wrap(data);
                        while (buf.hasRemaining()) {
                            sc.write(buf);
                        }
                    }
                }
            } catch (SocketTimeoutException e) {
                selfClean = true;
            } catch (Exception e) {
            } finally {
                if (selfClean) {
                    removeKey(this.gtunId);
                    readQueue.clear();
                }
                writeQueue.clear();
                try {
                    writeQueue.put(new byte[0]);
                    sc.close();
                } catch (Exception ignore) {
                }
            }
        }
    }
}