любовь v1.0.6 - HttpStack.java 源代码

package com.ding.rtc.http;

import android.os.Build;
import android.text.TextUtils;
import android.util.Log;
import com.ding.rtc.task.SimpleTask;
import com.ding.rtc.task.TaskExecutor;
import java.io.BufferedInputStream;
import java.io.BufferedOutputStream;
import java.io.ByteArrayOutputStream;
import java.io.Closeable;
import java.io.File;
import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.io.IOException;
import java.io.InputStream;
import java.io.OutputStream;
import java.net.HttpURLConnection;
import java.net.MalformedURLException;
import java.net.URL;
import java.util.Map;
import java.util.zip.GZIPOutputStream;
import javax.net.ssl.HostnameVerifier;
import javax.net.ssl.HttpsURLConnection;
import javax.net.ssl.SSLContext;
import javax.net.ssl.SSLSession;
import org.webrtc.mozi.Logging;

public class HttpStack {
    private static final String ALIYUN_DNS_HOST = "203.107.1.1";
    private static final String TAG = "HttpStack";

    private static void closeQuietly(Closeable closeable) {
        if (closeable == null) {
            return;
        }
        try {
            closeable.close();
        } catch (IOException e) {
        }
    }

    static boolean isIP(String host) {
        String[] parts = host.split("\\.");
        if (parts.length != 4) {
            return false;
        }
        for (String part : parts) {
            try {
                int num = Integer.parseInt(part);
                if (num < 0 || num > 255) {
                    return false;
                }
            } catch (NumberFormatException e) {
                return false;
            }
        }
        return true;
    }

    private static HttpURLConnection createConnection(URL url) throws IOException {
        HttpURLConnection connection = (HttpURLConnection) url.openConnection();
        connection.setInstanceFollowRedirects(HttpURLConnection.getFollowRedirects());
        return connection;
    }

    private static HttpURLConnection openConnection(URL url, String method, Map<String, String> headers, byte[] body, int timeoutMs) throws IOException {
        HttpURLConnection connection = createConnection(url);
        connection.setRequestMethod(method);
        connection.setConnectTimeout(timeoutMs);
        connection.setReadTimeout(timeoutMs);
        connection.setUseCaches(false);
        connection.setDoInput(true);
        configHttps(connection, null);
        if (headers != null) {
            for (Map.Entry<String, String> entry : headers.entrySet()) {
                connection.setRequestProperty(entry.getKey(), entry.getValue());
            }
        }
        if (body != null && body.length > 0) {
            connection.setDoOutput(true);
            OutputStream os = connection.getOutputStream();
            if (headers != null && "gzip".equals(headers.get(HttpHeaders.CONTENT_ENCODING))) {
                os = new GZIPOutputStream(new BufferedOutputStream(os));
            }
            os.write(body);
            os.flush();
            closeQuietly(os);
        }
        return connection;
    }

    private static HttpURLConnection openConnection(URL url, String method, Map<String, String> headers, int timeoutMs) throws IOException {
        HttpURLConnection connection = createConnection(url);
        connection.setRequestMethod(method);
        connection.setConnectTimeout(timeoutMs);
        connection.setReadTimeout(timeoutMs);
        connection.setUseCaches(false);
        connection.setDoInput(true);
        configHttps(connection, null);
        if (headers != null) {
            for (Map.Entry<String, String> entry : headers.entrySet()) {
                connection.setRequestProperty(entry.getKey(), entry.getValue());
            }
        }
        return connection;
    }

    public static HttpStackResponse doPostSNI(String path, Map<String, String> headers, byte[] body, int timeoutMs, String ip, String host) {
        return doHttpMethod(path, headers, body, timeoutMs, ip, host, "POST");
    }

    public static HttpStackResponse doGetSNI(String path, Map<String, String> headers, byte[] body, int timeoutMs, String ip, String host) {
        return doHttpMethod(path, headers, body, timeoutMs, ip, host, "GET");
    }

    public static boolean doAsyncGetUpload(final String url, final Map<String, String> headers, final String filePath, final int timeoutMs, final HttpAsyncResponse response) {
        if (TextUtils.isEmpty(url) || response == null) {
            return false;
        }
        TaskExecutor.execute(new SimpleTask() {
            @Override
            public void run() {
                HttpStackResponse httpStackResponse = HttpStack.doGet(url, headers, HttpStack.getFileBytes(filePath), timeoutMs, filePath);
                response.onHttpResult(httpStackResponse);
            }
        });
        return true;
    }

    public static boolean doAsyncGet(final String url, final Map<String, String> headers, final byte[] body, final int timeoutMs, final String filePath, final HttpAsyncResponse response) {
        if (TextUtils.isEmpty(url) || response == null) {
            return false;
        }
        TaskExecutor.execute(new SimpleTask() {
            @Override
            public void run() {
                HttpStackResponse httpStackResponse = HttpStack.doGet(url, headers, body, timeoutMs, filePath);
                response.onHttpResult(httpStackResponse);
            }
        });
        return true;
    }

    public static com.ding.rtc.http.HttpStackResponse doGet(java.lang.String r20, java.util.Map<java.lang.String, java.lang.String> r21, byte[] r22, int r23, java.lang.String r24) {
        throw new UnsupportedOperationException("Method not decompiled: com.ding.rtc.http.HttpStack.doGet(java.lang.String, java.util.Map, byte[], int, java.lang.String):com.ding.rtc.http.HttpStackResponse");
    }

    public static boolean doAsyncPostUpload(final String url, final Map<String, String> headers, final String filePath, final int timeoutMs, final HttpAsyncResponse response) {
        if (TextUtils.isEmpty(url) || response == null) {
            return false;
        }
        TaskExecutor.execute(new SimpleTask() {
            @Override
            public void run() {
                HttpStackResponse httpStackResponse = HttpStack.doPost(url, headers, HttpStack.getFileBytes(filePath), timeoutMs, filePath);
                response.onHttpResult(httpStackResponse);
            }
        });
        return true;
    }

    public static boolean doAsyncPost(final String url, final Map<String, String> headers, final byte[] body, final int timeoutMs, final String filePath, final HttpAsyncResponse response) {
        if (TextUtils.isEmpty(url) || response == null) {
            return false;
        }
        TaskExecutor.execute(new SimpleTask() {
            @Override
            public void run() {
                HttpStackResponse httpStackResponse = new HttpStackResponse();
                String newUrl = url;
                try {
                    URL address = new URL(newUrl);
                    String host = address.getHost();
                    boolean isIPHost = HttpStack.isIP(host);
                    boolean isHttps = url.startsWith("https");
                    if (isIPHost && isHttps && headers.containsKey("Host")) {
                        String header_host = (String) headers.get("Host");
                        response.onHttpResult(HttpStack.doPostSNI(newUrl.replaceFirst(host, header_host), headers, body, timeoutMs, host, header_host));
                    } else {
                        response.onHttpResult(HttpStack.doPost(url, headers, body, timeoutMs, filePath));
                    }
                } catch (MalformedURLException e) {
                    httpStackResponse.code = -1;
                    httpStackResponse.result = "url wrong, malformed exception".getBytes();
                    response.onHttpResult(httpStackResponse);
                }
            }
        });
        return true;
    }

    public static com.ding.rtc.http.HttpStackResponse doPost(java.lang.String r20, java.util.Map<java.lang.String, java.lang.String> r21, byte[] r22, int r23, java.lang.String r24) {
        throw new UnsupportedOperationException("Method not decompiled: com.ding.rtc.http.HttpStack.doPost(java.lang.String, java.util.Map, byte[], int, java.lang.String):com.ding.rtc.http.HttpStackResponse");
    }

    public static com.ding.rtc.http.HttpStackResponse multipartPost(java.lang.String r9, java.lang.String r10, java.lang.String r11, java.util.Map<java.lang.String, java.lang.String> r12, com.ding.rtc.http.MultipartWriter r13) {
        throw new UnsupportedOperationException("Method not decompiled: com.ding.rtc.http.HttpStack.multipartPost(java.lang.String, java.lang.String, java.lang.String, java.util.Map, com.ding.rtc.http.MultipartWriter):com.ding.rtc.http.HttpStackResponse");
    }

    private static byte[] readFully(InputStream inputStream) throws IOException {
        if (inputStream == null) {
            return new byte[0];
        }
        BufferedInputStream bufferedInputStream = null;
        try {
            bufferedInputStream = new BufferedInputStream(inputStream);
            ByteArrayOutputStream byteArrayOutputStream = new ByteArrayOutputStream();
            byte[] buffer = new byte[1024];
            while (true) {
                int available = bufferedInputStream.read(buffer);
                if (available >= 0) {
                    byteArrayOutputStream.write(buffer, 0, available);
                } else {
                    return byteArrayOutputStream.toByteArray();
                }
            }
        } finally {
            closeQuietly(bufferedInputStream);
        }
    }

    public static byte[] getFileBytes(String filePath) {
        File file = new File(filePath);
        if (!file.exists()) {
            return null;
        }
        FileInputStream fis = null;
        try {
            fis = new FileInputStream(file);
            byte[] buffer = new byte[1024];
            ByteArrayOutputStream byteArrayOutputStream = new ByteArrayOutputStream();
            while (true) {
                int available = fis.read(buffer);
                if (available < 0) {
                    byte[] result = byteArrayOutputStream.toByteArray();
                    return result;
                }
                byteArrayOutputStream.write(buffer, 0, available);
            }
        } catch (Exception e) {
            e.printStackTrace();
            return null;
        } finally {
            closeQuietly(fis);
        }
    }

    private static void saveFile(InputStream inputStream, String filePath) {
        if (inputStream == null || TextUtils.isEmpty(filePath)) {
            return;
        }
        FileOutputStream fos = null;
        try {
            try {
                FileUtil.createFilePath(null, filePath);
                File file = new File(filePath);
                fos = new FileOutputStream(file);
                byte[] buffer = new byte[1024];
                while (true) {
                    int available = inputStream.read(buffer);
                    if (available < 0) {
                        break;
                    } else {
                        fos.write(buffer, 0, available);
                    }
                }
            } catch (Exception e) {
                e.printStackTrace();
            }
        } finally {
            closeQuietly(fos);
            closeQuietly(inputStream);
        }
    }

    private static void configHttps(HttpURLConnection urlConnection, final String verifyHost) {
        if (Build.VERSION.SDK_INT < 22) {
            configHttpsOnPreLollipop(urlConnection, verifyHost);
            return;
        }
        if (!(urlConnection instanceof HttpsURLConnection)) {
            return;
        }
        HttpsURLConnection conn = (HttpsURLConnection) urlConnection;
        try {
            SSLContext sslcontext = SSLContext.getInstance("TLS");
            sslcontext.init(null, null, null);
            conn.setSSLSocketFactory(sslcontext.getSocketFactory());
            HostnameVerifier hostnameVerifier = new HostnameVerifier() {
                @Override
                public boolean verify(String hostname, SSLSession session) {
                    HostnameVerifier defaultHostVerifier = HttpsURLConnection.getDefaultHostnameVerifier();
                    if (defaultHostVerifier.verify(HttpStack.ALIYUN_DNS_HOST, session)) {
                        return true;
                    }
                    if (TextUtils.isEmpty(verifyHost)) {
                        return defaultHostVerifier.verify(hostname, session);
                    }
                    return verifyHost.equals(hostname) || defaultHostVerifier.verify(verifyHost, session);
                }
            };
            conn.setHostnameVerifier(hostnameVerifier);
        } catch (Exception e) {
            e.printStackTrace();
            Logging.e(TAG, "configHttps error:" + Log.getStackTraceString(e));
        }
    }

    private static void configHttpsOnPreLollipop(HttpURLConnection urlConnection, final String verifyHost) {
        if (!(urlConnection instanceof HttpsURLConnection) || Build.VERSION.SDK_INT >= 22) {
            return;
        }
        HttpsURLConnection conn = (HttpsURLConnection) urlConnection;
        try {
            conn.setSSLSocketFactory(new PreLollipopTLSSocketFactory());
            HostnameVerifier hostnameVerifier = new HostnameVerifier() {
                @Override
                public boolean verify(String hostname, SSLSession session) {
                    HostnameVerifier defaultHostVerifier = HttpsURLConnection.getDefaultHostnameVerifier();
                    if (defaultHostVerifier.verify(HttpStack.ALIYUN_DNS_HOST, session)) {
                        return true;
                    }
                    if (TextUtils.isEmpty(verifyHost)) {
                        return defaultHostVerifier.verify(hostname, session);
                    }
                    return verifyHost.equals(hostname) || defaultHostVerifier.verify(verifyHost, session);
                }
            };
            conn.setHostnameVerifier(hostnameVerifier);
        } catch (Exception exc) {
            Logging.e(TAG, "Error while setting TLS 1.2" + Log.getStackTraceString(exc));
        }
    }

    private static com.ding.rtc.http.HttpStackResponse doHttpMethod(java.lang.String r25, java.util.Map<java.lang.String, java.lang.String> r26, byte[] r27, int r28, java.lang.String r29, java.lang.String r30, java.lang.String r31) {
        throw new UnsupportedOperationException("Method not decompiled: com.ding.rtc.http.HttpStack.doHttpMethod(java.lang.String, java.util.Map, byte[], int, java.lang.String, java.lang.String, java.lang.String):com.ding.rtc.http.HttpStackResponse");
    }

    private static boolean needRedirect(int code) {
        return code >= 300 && code < 400;
    }
}