CarrotChat v2.8.80.240429版本的 MD5 值为：fdf98761f01e715a89df24b85b0d206e

以下内容为反编译后的 HttpURLTools.java 源代码，内容仅作参考

package ak.im.utils;

import ak.im.BuildConfig;
import ak.im.module.AkeyChatX509PrivateCA;
import ak.im.sdk.manager.XMPPConnectionManager;
import ak.im.uitls.AKCAppConfiguration;
import android.os.Build;
import android.os.SystemClock;
import android.text.TextUtils;
import com.alibaba.fastjson.JSON;
import com.alibaba.fastjson.JSONObject;
import com.qiniu.android.dns.NetworkInfo;
import com.zerotier.libzt.ZeroTierSocketFactory;
import java.io.BufferedReader;
import java.io.File;
import java.io.IOException;
import java.io.InputStream;
import java.io.InputStreamReader;
import java.io.PrintWriter;
import java.net.HttpURLConnection;
import java.net.InetAddress;
import java.net.MalformedURLException;
import java.net.Socket;
import java.net.URL;
import java.net.URLConnection;
import java.net.UnknownHostException;
import java.security.KeyManagementException;
import java.security.KeyStore;
import java.security.KeyStoreException;
import java.security.NoSuchAlgorithmException;
import java.security.SecureRandom;
import java.security.UnrecoverableKeyException;
import java.security.cert.CertificateException;
import java.security.cert.X509Certificate;
import java.util.Arrays;
import java.util.HashMap;
import java.util.HashSet;
import java.util.Iterator;
import java.util.List;
import java.util.Map;
import java.util.concurrent.TimeUnit;
import javax.net.ssl.HostnameVerifier;
import javax.net.ssl.HttpsURLConnection;
import javax.net.ssl.KeyManager;
import javax.net.ssl.KeyManagerFactory;
import javax.net.ssl.SSLContext;
import javax.net.ssl.SSLSession;
import javax.net.ssl.SSLSocket;
import javax.net.ssl.SSLSocketFactory;
import javax.net.ssl.TrustManager;
import javax.net.ssl.TrustManagerFactory;
import javax.net.ssl.X509TrustManager;
import okhttp3.logging.HttpLoggingInterceptor;
import okhttp3.m;
import okhttp3.o;
import org.apache.http.protocol.HTTP;
import org.conscrypt.OpenSSLContextImpl;
import org.jivesoftware.smack.AbstractXMPPConnection;
import org.jivesoftware.smack.SmackException;
import org.jivesoftware.smack.util.TLSUtils;
import org.jivesoftware.smackx.ping.PingManager;

public class HttpURLTools {

    private static Map<String, AkeyChatX509PrivateCA> f10132b;

    public static HostnameVerifier f10131a = new HostnameVerifier() {
        @Override
        public final boolean verify(String str, SSLSession sSLSession) {
            boolean e10;
            e10 = HttpURLTools.e(str, sSLSession);
            return e10;
        }
    };

    private static int f10133c = 0;

    static X509TrustManager f10134d = new b();

    private static okhttp3.f f10135e = new okhttp3.f(3, 10000, TimeUnit.MILLISECONDS);

    public static HashSet<String> f10136f = new HashSet<>();

    public static HashSet<String> f10137g = new HashSet<>();

    public static HashSet<String> f10138h = new HashSet<>();

    public enum UrlType {
        PublicNetworkInternalUrl,
        PublicNetworkExternalUrl,
        BoxNetNetworkInternalUrl
    }

    class a implements ye.c {

        final a1.u f10140a;

        final String f10141b;

        final String f10142c;

        a(a1.u uVar, String str, String str2) {
            this.f10140a = uVar;
            this.f10141b = str;
            this.f10142c = str2;
        }

        @Override
        public void onFailure(okhttp3.c cVar, IOException iOException) {
            a1.u uVar = this.f10140a;
            if (uVar != null) {
                uVar.onRecvResult(false, this.f10141b, null);
            }
            AkeyChatUtils.logException(iOException);
        }

        @Override
        public void onResponse(okhttp3.c cVar, okhttp3.p pVar) throws IOException {
            Log.i("HttpURLTools", "lwxdownload response code is " + pVar.code());
            int code = pVar.code();
            String str = null;
            if (code != 200) {
                if (code == 403) {
                    try {
                        JSONObject parseObject = JSON.parseObject(new String(pVar.body().bytes()));
                        if (parseObject.containsKey("return_code") && parseObject.getInteger("return_code").intValue() == 50332419 && parseObject.containsKey("description")) {
                            str = parseObject.getString("description");
                        }
                    } catch (Exception e10) {
                        e10.printStackTrace();
                    }
                }
                a1.u uVar = this.f10140a;
                if (uVar != null) {
                    uVar.onRecvResult(false, this.f10141b, str);
                    return;
                }
                return;
            }
            try {
                if (this.f10140a != null) {
                    Log.i("HttpURLTools", "lwxdownload start");
                    InputStream byteStream = pVar.body().byteStream();
                    if (FileUtil.isVaultPath(this.f10142c)) {
                        System.out.println("downloading and save to vault file system.");
                        FileUtil.createVaultDirByFilePath(this.f10142c);
                        String path = FileUtil.f10114a.getPath(this.f10142c);
                        FileUtil.deleteFile(path);
                        String str2 = FileUtil.getGlobalCachePath() + "temp" + o3.getRightTime();
                        File file = new File(str2);
                        if (file.exists()) {
                            file.delete();
                        }
                        FileUtil.copyFile(byteStream, str2);
                        FileUtil.f10114a.encryptFile(str2, path, (m0.b) null);
                    } else {
                        FileUtil.createDir(new File(this.f10142c).getParentFile());
                        FileUtil.write(new File(this.f10142c), byteStream);
                    }
                    Log.i("HttpURLTools", "lwxdownload success");
                    this.f10140a.onRecvResult(true, this.f10141b, null);
                }
            } catch (Throwable th) {
                th.printStackTrace();
                Log.e("HttpURLTools", "lwxdownload onResponse failed,error is " + th.getMessage());
                a1.u uVar2 = this.f10140a;
                if (uVar2 != null) {
                    uVar2.onRecvResult(false, this.f10141b, null);
                }
            }
        }
    }

    class b implements X509TrustManager {
        b() {
        }

        @Override
        public void checkClientTrusted(X509Certificate[] x509CertificateArr, String str) {
        }

        @Override
        public void checkServerTrusted(X509Certificate[] x509CertificateArr, String str) {
        }

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

    public static class c implements X509TrustManager {

        private X509TrustManager f10143a;

        private X509TrustManager f10144b;

        public c(X509TrustManager x509TrustManager) throws NoSuchAlgorithmException, KeyStoreException {
            TrustManagerFactory trustManagerFactory = TrustManagerFactory.getInstance(TrustManagerFactory.getDefaultAlgorithm());
            trustManagerFactory.init((KeyStore) null);
            this.f10143a = HttpURLTools.c(trustManagerFactory.getTrustManagers());
            this.f10144b = x509TrustManager;
        }

        @Override
        public void checkClientTrusted(X509Certificate[] x509CertificateArr, String str) throws CertificateException {
        }

        @Override
        public void checkServerTrusted(X509Certificate[] x509CertificateArr, String str) throws CertificateException {
            try {
                this.f10143a.checkServerTrusted(x509CertificateArr, str);
            } catch (CertificateException unused) {
                X509TrustManager x509TrustManager = this.f10144b;
                if (x509TrustManager != null) {
                    x509TrustManager.checkServerTrusted(x509CertificateArr, str);
                }
            }
        }

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

    public static class d implements ye.i {

        y9.a f10145b = new y9.a(NetworkInfo.f30671d, new y9.c[]{new z9.e("223.5.5.5"), new z9.e("8.8.8.8"), new z9.f("https://dns.alidns.com/dns-query")});

        @Override
        public List<InetAddress> lookup(String str) throws UnknownHostException {
            try {
                Long valueOf = Long.valueOf(System.currentTimeMillis());
                List<InetAddress> asList = Arrays.asList(this.f10145b.queryInetAdress(new y9.b(str)));
                Log.e("OkHttpDns", "inetAddresses:" + asList + ", for " + str + ", elapsed " + String.valueOf(System.currentTimeMillis() - valueOf.longValue()));
                return asList;
            } catch (IOException e10) {
                e10.printStackTrace();
                return ye.i.f49362a.lookup(str);
            }
        }
    }

    public static class e {

        public SSLSocketFactory f10146a;

        public X509TrustManager f10147b;
    }

    public static class g implements X509TrustManager {
        @Override
        public void checkClientTrusted(X509Certificate[] x509CertificateArr, String str) throws CertificateException {
        }

        @Override
        public void checkServerTrusted(X509Certificate[] x509CertificateArr, String str) throws CertificateException {
        }

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

    public static X509TrustManager c(TrustManager[] trustManagerArr) {
        for (TrustManager trustManager : trustManagerArr) {
            if (trustManager instanceof X509TrustManager) {
                return (X509TrustManager) trustManager;
            }
        }
        return null;
    }

    public static boolean canOpenUrl() {
        XMPPConnectionManager.Companion companion = XMPPConnectionManager.INSTANCE;
        AbstractXMPPConnection connection = companion.getInstance().getConnection();
        if (connection == null || !connection.isConnected() || !connection.isAuthenticated()) {
            return false;
        }
        try {
            return PingManager.getInstanceFor(companion.getInstance().getConnection()).pingMyServer(false, 5000L);
        } catch (InterruptedException e10) {
            e10.printStackTrace();
            return false;
        } catch (SmackException.NotConnectedException e11) {
            e11.printStackTrace();
            return false;
        }
    }

    public static UrlType checkHttpUrlType(String str) {
        boolean z10;
        if (q5.isEmptyString(str)) {
            return UrlType.PublicNetworkExternalUrl;
        }
        if (f10137g.size() == 0) {
            initOssServerHosts(null);
        }
        boolean z11 = false;
        try {
            String host = new URL(str).getHost();
            Log.i("HttpURLTools", "check host " + host + " with main servers: " + f10136f + ", oss servers: " + f10137g + ", id nodes: " + f10138h);
            z10 = f10136f.contains(host);
            try {
                if (!f10137g.contains(host)) {
                }
                z11 = true;
            } catch (MalformedURLException e10) {
                e = e10;
                AkeyChatUtils.logException(e);
                if (!z11) {
                }
            }
        } catch (MalformedURLException e11) {
            e = e11;
            z10 = false;
        }
        if (!z11) {
            return UrlType.PublicNetworkInternalUrl;
        }
        if (z10) {
            return UrlType.PublicNetworkInternalUrl;
        }
        return UrlType.PublicNetworkExternalUrl;
    }

    private static AkeyChatX509PrivateCA d(URL url) {
        if (f10132b == null) {
            f10132b = new HashMap();
        }
        String host = url.getHost();
        Log.i("HttpURLTools", "x509 key:" + host + " url:" + url);
        AkeyChatX509PrivateCA akeyChatX509PrivateCA = f10132b.get(host);
        if (akeyChatX509PrivateCA == null) {
            try {
                akeyChatX509PrivateCA = new AkeyChatX509PrivateCA(url);
            } catch (CertificateException e10) {
                e10.printStackTrace();
            }
            f10132b.put(host, akeyChatX509PrivateCA);
        } else {
            StringBuilder sb2 = new StringBuilder();
            sb2.append("we save one:");
            int i10 = f10133c;
            f10133c = i10 + 1;
            sb2.append(i10);
            Log.i("HttpURLTools", sb2.toString());
        }
        return akeyChatX509PrivateCA;
    }

    public static boolean e(String str, SSLSession sSLSession) {
        return true;
    }

    public static byte[] getBytesFromHttpsUrl(String str, int i10, String str2, String str3) {
        return getBytesFromOkHttpsUrl(str, i10, null, str2, str3);
    }

    public static byte[] getBytesFromOkHttpsUrl(String str, int i10, a1.u uVar, String str2, String str3) {
        SystemClock.uptimeMillis();
        try {
            m.b okHttpClientBuilder = getOkHttpClientBuilder(str, str2, false);
            if (uVar != null) {
                Iterator<okhttp3.l> it = okHttpClientBuilder.interceptors().iterator();
                while (it.hasNext()) {
                    if (it.next() instanceof u0.n) {
                        it.remove();
                    }
                }
                okHttpClientBuilder.addInterceptor(new u0.n(uVar, str));
            }
            m.b readTimeout = okHttpClientBuilder.retryOnConnectionFailure(true).connectTimeout(10L, TimeUnit.SECONDS).readTimeout(i10, TimeUnit.MILLISECONDS);
            if (AKCAppConfiguration.f9925a.CanDnsResolve()) {
                readTimeout.dns(new d());
            }
            okhttp3.p execute = readTimeout.build().newCall(setHeadIfSeaweed(str, new o.a().url(str), str3)).execute();
            if (uVar != null) {
                uVar.onRecvResult(true, str, null);
            }
            Log.i("HttpURLTools", "response code is " + execute.code());
            execute.body().contentLength();
            if (execute.code() != 200) {
                return null;
            }
            return execute.body().bytes();
        } catch (Exception e10) {
            AkeyChatUtils.logException(e10);
            return null;
        }
    }

    public static void getBytesFromOkHttpsUrlAsync(String str, String str2, int i10, a1.u uVar, String str3, String str4) {
        SystemClock.uptimeMillis();
        m.b okHttpClientBuilder = getOkHttpClientBuilder(str2, str4, false);
        try {
            List<okhttp3.l> interceptors = okHttpClientBuilder.interceptors();
            Iterator<okhttp3.l> it = okHttpClientBuilder.networkInterceptors().iterator();
            Iterator<okhttp3.l> it2 = interceptors.iterator();
            while (it2.hasNext()) {
                okhttp3.l next = it2.next();
                if ((next instanceof u0.n) || (next instanceof HttpLoggingInterceptor)) {
                    it2.remove();
                }
            }
            while (it.hasNext()) {
                okhttp3.l next2 = it.next();
                if ((next2 instanceof u0.n) || (next2 instanceof HttpLoggingInterceptor)) {
                    it.remove();
                }
            }
            if (uVar != null) {
                okHttpClientBuilder.addNetworkInterceptor(new u0.n(uVar, str2));
            }
        } catch (Exception e10) {
            e10.printStackTrace();
        }
        m.b readTimeout = okHttpClientBuilder.retryOnConnectionFailure(true).connectTimeout(10L, TimeUnit.SECONDS).readTimeout(i10, TimeUnit.MILLISECONDS);
        if (AKCAppConfiguration.f9925a.CanDnsResolve()) {
            readTimeout.dns(new d());
        }
        readTimeout.build().newCall(setHeadIfSeaweed(str2, new o.a().url(str2), str)).enqueue(new a(uVar, str2, str3));
    }

    public static InputStream getInputStreamFromOkHttpsUrl(String str, int i10, String str2, String str3) {
        try {
            m.b readTimeout = getOkHttpClientBuilder(str, str2, false).retryOnConnectionFailure(true).connectTimeout(10L, TimeUnit.SECONDS).readTimeout(i10, TimeUnit.MILLISECONDS);
            if (AKCAppConfiguration.f9925a.CanDnsResolve()) {
                readTimeout.dns(new d());
            }
            okhttp3.p execute = readTimeout.build().newCall(setHeadIfSeaweed(str, new o.a().url(str), str3)).execute();
            Log.i("HttpURLTools", "response code is " + execute.code());
            if (execute.code() == 200) {
                return execute.body().byteStream();
            }
            return null;
        } catch (Exception e10) {
            AkeyChatUtils.logException(e10);
            return null;
        }
    }

    public static SSLContext getNormalSSLContext(TrustManager trustManager) {
        try {
            TrustManager[] trustManagerArr = {trustManager};
            SSLContext sSLContext = SSLContext.getInstance(TLSUtils.PROTO_TLSV1_2);
            sSLContext.init(null, trustManagerArr, new SecureRandom());
            return sSLContext;
        } catch (KeyManagementException | NoSuchAlgorithmException e10) {
            e10.printStackTrace();
            return null;
        }
    }

    public static SSLSocketFactory getNormalSSLSocketFactory(TrustManager trustManager) {
        try {
            return getNormalSSLContext(trustManager).getSocketFactory();
        } catch (Exception e10) {
            e10.printStackTrace();
            return null;
        }
    }

    public static m.b getOkHttpClientBuilder(String str, String str2, boolean z10, boolean z11) {
        URL url;
        boolean z12;
        e eVar;
        List<okhttp3.l> interceptors;
        u0.b languageInterceptor;
        m.b connectionPool = new m.b().connectionPool(f10135e);
        if (z10) {
            url = null;
        } else {
            try {
                url = new URL(str);
            } catch (Exception e10) {
                AkeyChatUtils.logException(e10);
            }
        }
        UrlType checkHttpUrlType = checkHttpUrlType(str);
        StringBuilder sb2 = new StringBuilder();
        sb2.append("build url ");
        sb2.append(str);
        sb2.append(", type ");
        sb2.append(checkHttpUrlType);
        sb2.append(z10 ? ", skip server cert verification" : "");
        Log.i("HttpURLTools", sb2.toString());
        if (!z10 && AkeyChatUtils.oemNeedServerCertificateVerify()) {
            z12 = false;
            eVar = new e();
            if (!z11 && checkHttpUrlType != UrlType.PublicNetworkInternalUrl && checkHttpUrlType != UrlType.BoxNetNetworkInternalUrl) {
                eVar.f10147b = !z12 ? new g() : new c(null);
                eVar.f10146a = new f(getNormalSSLSocketFactory(eVar.f10147b));
                connectionPool.sslSocketFactory(eVar.f10146a, eVar.f10147b).hostnameVerifier(f10131a);
                interceptors = connectionPool.interceptors();
                languageInterceptor = u0.b.getLanguageInterceptor();
                if (interceptors != null || !interceptors.contains(languageInterceptor)) {
                    connectionPool.addInterceptor(languageInterceptor);
                }
                if (!TextUtils.isEmpty(str2)) {
                    u0.c accessTokenInterceptor = u0.c.getAccessTokenInterceptor(str2);
                    if (interceptors == null || !interceptors.contains(accessTokenInterceptor)) {
                        connectionPool.addInterceptor(accessTokenInterceptor);
                    }
                }
                if (ak.im.sdk.manager.f1.getInstance().getServer() != null) {
                    String enterpriseId = ak.im.sdk.manager.f1.getInstance().getServer().getEnterpriseId();
                    if (!TextUtils.isEmpty(enterpriseId)) {
                        Log.i("HttpURLTools", "ADD X-AK-Server-ID:" + enterpriseId);
                        u0.a xServerIDInterceptor = u0.a.getXServerIDInterceptor(enterpriseId);
                        if (interceptors == null || !interceptors.contains(xServerIDInterceptor)) {
                            connectionPool.addInterceptor(xServerIDInterceptor);
                        }
                    }
                }
                if (str != null && ((str.contains(ak.im.sdk.manager.f1.getInstance().getOssCenterHost()) || str.contains(ak.im.sdk.manager.f1.getCountServerURL())) && AKCAppConfiguration.f9925a.CanDnsResolve())) {
                    connectionPool.dns(new d());
                }
                return connectionPool;
            }
            X509TrustManager d10 = d(url);
            eVar.f10147b = d10;
            OpenSSLContextImpl.TLSv13 tLSv13 = new OpenSSLContextImpl.TLSv13();
            tLSv13.engineInit(null, new TrustManager[]{eVar.f10147b}, null);
            eVar.f10146a = tLSv13.engineGetSocketFactory();
            if (checkHttpUrlType == UrlType.BoxNetNetworkInternalUrl) {
                connectionPool.socketFactory(new ZeroTierSocketFactory(false));
            }
            connectionPool.sslSocketFactory(eVar.f10146a, eVar.f10147b).hostnameVerifier(f10131a);
            interceptors = connectionPool.interceptors();
            languageInterceptor = u0.b.getLanguageInterceptor();
            if (interceptors != null) {
            }
            connectionPool.addInterceptor(languageInterceptor);
            if (!TextUtils.isEmpty(str2)) {
            }
            if (ak.im.sdk.manager.f1.getInstance().getServer() != null) {
            }
            if (str != null) {
                connectionPool.dns(new d());
            }
            return connectionPool;
        }
        z12 = true;
        eVar = new e();
        if (!z11) {
            eVar.f10147b = !z12 ? new g() : new c(null);
            eVar.f10146a = new f(getNormalSSLSocketFactory(eVar.f10147b));
            connectionPool.sslSocketFactory(eVar.f10146a, eVar.f10147b).hostnameVerifier(f10131a);
            interceptors = connectionPool.interceptors();
            languageInterceptor = u0.b.getLanguageInterceptor();
            if (interceptors != null) {
            }
            connectionPool.addInterceptor(languageInterceptor);
            if (!TextUtils.isEmpty(str2)) {
            }
            if (ak.im.sdk.manager.f1.getInstance().getServer() != null) {
            }
            if (str != null) {
            }
            return connectionPool;
        }
        X509TrustManager d102 = d(url);
        eVar.f10147b = d102;
        OpenSSLContextImpl.TLSv13 tLSv132 = new OpenSSLContextImpl.TLSv13();
        tLSv132.engineInit(null, new TrustManager[]{eVar.f10147b}, null);
        eVar.f10146a = tLSv132.engineGetSocketFactory();
        if (checkHttpUrlType == UrlType.BoxNetNetworkInternalUrl) {
        }
        connectionPool.sslSocketFactory(eVar.f10146a, eVar.f10147b).hostnameVerifier(f10131a);
        interceptors = connectionPool.interceptors();
        languageInterceptor = u0.b.getLanguageInterceptor();
        if (interceptors != null) {
        }
        connectionPool.addInterceptor(languageInterceptor);
        if (!TextUtils.isEmpty(str2)) {
        }
        if (ak.im.sdk.manager.f1.getInstance().getServer() != null) {
        }
        if (str != null) {
        }
        return connectionPool;
    }

    public static SSLContext getSSLContext(String str, boolean z10) {
        URL url;
        boolean z11;
        SSLContext sSLContext;
        TrustManager[] trustManagerArr;
        try {
            if (!TextUtils.isEmpty(str)) {
                url = new URL(str);
            } else {
                url = null;
            }
            if (z10 && !AkeyChatUtils.isNeedVerifyCertificate(url)) {
                z11 = false;
                if (z11) {
                    trustManagerArr = new TrustManager[]{f10134d};
                    sSLContext = SSLContext.getInstance(TLSUtils.TLS);
                } else {
                    sSLContext = SSLContext.getInstance(TLSUtils.PROTO_TLSV1_2);
                    trustManagerArr = new TrustManager[]{d(url)};
                }
                sSLContext.init(null, trustManagerArr, new SecureRandom());
                return sSLContext;
            }
            z11 = true;
            if (z11) {
            }
            sSLContext.init(null, trustManagerArr, new SecureRandom());
            return sSLContext;
        } catch (MalformedURLException e10) {
            e10.printStackTrace();
            return null;
        } catch (KeyManagementException e11) {
            e11.printStackTrace();
            return null;
        } catch (NoSuchAlgorithmException e12) {
            e12.printStackTrace();
            return null;
        }
    }

    public static SSLSocketFactory getSSLSocketFactory(String str) {
        try {
            return getSSLContext(str, false).getSocketFactory();
        } catch (Exception e10) {
            e10.printStackTrace();
            return null;
        }
    }

    public static void initIdNodeHosts(String str) {
        if (q5.isEmptyString(str)) {
            return;
        }
        f10138h.add(str);
        Log.i("HttpURLTools", "id nodes updated: " + f10138h);
    }

    public static void initMainServerHosts(String str) {
        if (q5.isEmptyString(str)) {
            return;
        }
        f10136f.add(str);
        Log.i("HttpURLTools", "main servers updated: " + f10136f);
    }

    public static void initOssServerHosts(String str) {
        f10137g.add("enterprise.akeychat.cn:20443".split(":")[0]);
        f10137g.add(BuildConfig.OSS_CENTER_HOST.split(":")[0]);
        f10137g.add("statistical.akeychat.cn");
        f10137g.add("teststatistical.akeychat.cn");
        HashSet<String> hashSet = f10137g;
        AKCAppConfiguration aKCAppConfiguration = AKCAppConfiguration.f9925a;
        hashSet.add(aKCAppConfiguration.stats());
        String stats2 = aKCAppConfiguration.stats2();
        HashSet<String> hashSet2 = f10137g;
        if (stats2.contains(":")) {
            stats2 = stats2.split(":")[0];
        }
        hashSet2.add(stats2);
        f10137g.add(aKCAppConfiguration.oss());
        if (str != null) {
            f10137g.add(str);
        }
        Log.i("HttpURLTools", "oss servers updated: " + f10137g);
    }

    public static KeyManager[] prepareKeyManager(InputStream inputStream, String str) {
        if (inputStream != null && str != null) {
            try {
                KeyStore keyStore = KeyStore.getInstance("BKS");
                keyStore.load(inputStream, str.toCharArray());
                KeyManagerFactory keyManagerFactory = KeyManagerFactory.getInstance(KeyManagerFactory.getDefaultAlgorithm());
                keyManagerFactory.init(keyStore, str.toCharArray());
                return keyManagerFactory.getKeyManagers();
            } catch (IOException e10) {
                e10.printStackTrace();
            } catch (KeyStoreException e11) {
                e11.printStackTrace();
            } catch (NoSuchAlgorithmException e12) {
                e12.printStackTrace();
            } catch (UnrecoverableKeyException e13) {
                e13.printStackTrace();
            } catch (CertificateException e14) {
                e14.printStackTrace();
            } catch (Exception e15) {
                e15.printStackTrace();
            }
        }
        return null;
    }

    public static String printResponse(HttpURLConnection httpURLConnection) {
        StringBuilder sb2 = new StringBuilder();
        try {
            BufferedReader bufferedReader = new BufferedReader(new InputStreamReader(httpURLConnection.getInputStream()));
            while (true) {
                String readLine = bufferedReader.readLine();
                if (readLine == null) {
                    break;
                }
                sb2.append("\n" + readLine);
            }
        } catch (IOException e10) {
            e10.printStackTrace();
        }
        return sb2.toString();
    }

    public static String sendHttpsPost(String str, String str2) {
        ?? url;
        BufferedReader bufferedReader;
        Log.i("HttpURLTools", "https post url:" + str);
        Log.i("HttpURLTools", "https post data:" + ((String) str2));
        String str3 = "";
        PrintWriter printWriter = null;
        r1 = null;
        r1 = null;
        r1 = null;
        StringBuilder sb2 = null;
        printWriter = null;
        try {
            try {
                url = new URL(str);
            } catch (IOException e10) {
                e10.printStackTrace();
            }
        } catch (Exception e11) {
            e = e11;
            str2 = 0;
        } catch (Throwable th) {
            th = th;
            str2 = 0;
        }
        try {
            try {
                if (str.startsWith("https")) {
                    d(url);
                    HttpsURLConnection.setDefaultSSLSocketFactory(getSSLContext(str, false).getSocketFactory());
                    HttpsURLConnection httpsURLConnection = (HttpsURLConnection) url.openConnection();
                    httpsURLConnection.setRequestProperty("accept", "*/*");
                    httpsURLConnection.setRequestProperty("connection", HTTP.CONN_KEEP_ALIVE);
                    httpsURLConnection.setRequestProperty("user-agent", "Mozilla/4.0 (compatible; MSIE 6.0; Windows NT 5.1;SV1)");
                    httpsURLConnection.setDoOutput(true);
                    httpsURLConnection.setDoInput(true);
                    url = new PrintWriter(httpsURLConnection.getOutputStream());
                    url.print(str2);
                    url.flush();
                    bufferedReader = new BufferedReader(new InputStreamReader(httpsURLConnection.getInputStream()));
                    while (true) {
                        String readLine = bufferedReader.readLine();
                        if (readLine == null) {
                            break;
                        }
                        sb2 = new StringBuilder();
                        sb2.append(str3);
                        sb2.append(readLine);
                        str3 = sb2.toString();
                    }
                } else {
                    URLConnection openConnection = url.openConnection();
                    openConnection.setRequestProperty("accept", "*/*");
                    openConnection.setRequestProperty("connection", HTTP.CONN_KEEP_ALIVE);
                    openConnection.setRequestProperty("user-agent", "Mozilla/4.0 (compatible; MSIE 6.0; Windows NT 5.1;SV1)");
                    openConnection.setDoOutput(true);
                    openConnection.setDoInput(true);
                    url = new PrintWriter(openConnection.getOutputStream());
                    url.print(str2);
                    url.flush();
                    bufferedReader = new BufferedReader(new InputStreamReader(openConnection.getInputStream()));
                    while (true) {
                        String readLine2 = bufferedReader.readLine();
                        if (readLine2 == null) {
                            break;
                        }
                        sb2 = new StringBuilder();
                        sb2.append(str3);
                        sb2.append(readLine2);
                        str3 = sb2.toString();
                    }
                }
                url.close();
                bufferedReader.close();
            } catch (Exception e12) {
                e = e12;
                printWriter = url;
                str2 = str2;
                try {
                    e.printStackTrace();
                    if (printWriter != null) {
                        printWriter.close();
                    }
                    if (str2 != 0) {
                        str2.close();
                    }
                    return str3;
                } catch (Throwable th2) {
                    th = th2;
                    if (printWriter != null) {
                        try {
                            printWriter.close();
                        } catch (IOException e13) {
                            e13.printStackTrace();
                            throw th;
                        }
                    }
                    if (str2 != 0) {
                        str2.close();
                    }
                    throw th;
                }
            } catch (Throwable th3) {
                th = th3;
                printWriter = url;
                if (printWriter != null) {
                }
                if (str2 != 0) {
                }
                throw th;
            }
        } catch (Exception e14) {
            e = e14;
            str2 = sb2;
            printWriter = url;
            str2 = str2;
            e.printStackTrace();
            if (printWriter != null) {
            }
            if (str2 != 0) {
            }
            return str3;
        } catch (Throwable th4) {
            th = th4;
            str2 = sb2;
            printWriter = url;
            if (printWriter != null) {
            }
            if (str2 != 0) {
            }
            throw th;
        }
        return str3;
    }

    public static okhttp3.o setHeadIfSeaweed(String str, o.a aVar, String str2) {
        if (!TextUtils.isEmpty(str) && str.contains("/app/seaweedfsdownload") && !TextUtils.isEmpty(str2)) {
            aVar.header("X-Server-Id", str2);
            aVar.header("X-Authentication-Id", ak.im.sdk.manager.f1.getInstance().getServer().getEnterpriseId());
        }
        return aVar.build();
    }

    public static class f extends SSLSocketFactory {

        private static String[] f10148b;

        final SSLSocketFactory f10149a;

        static {
            if (Build.VERSION.SDK_INT >= 26) {
                f10148b = new String[]{TLSUtils.PROTO_TLSV1, TLSUtils.PROTO_TLSV1_1, TLSUtils.PROTO_TLSV1_2};
            } else {
                f10148b = new String[]{TLSUtils.PROTO_SSL3, TLSUtils.PROTO_TLSV1, TLSUtils.PROTO_TLSV1_1, TLSUtils.PROTO_TLSV1_2};
            }
        }

        public f(SSLSocketFactory sSLSocketFactory) {
            this.f10149a = sSLSocketFactory;
        }

        private Socket a(Socket socket) {
            if (socket instanceof SSLSocket) {
                ((SSLSocket) socket).setEnabledProtocols(f10148b);
            }
            return socket;
        }

        @Override
        public Socket createSocket(Socket socket, String str, int i10, boolean z10) throws IOException {
            Log.w("Tls12SocketFactory", "create socket " + socket + " sock type " + socket.getClass() + ", connected " + socket.isConnected() + ", " + str + ", " + i10 + ", " + z10);
            return a(this.f10149a.createSocket(socket, str, i10, z10));
        }

        @Override
        public String[] getDefaultCipherSuites() {
            return this.f10149a.getDefaultCipherSuites();
        }

        @Override
        public String[] getSupportedCipherSuites() {
            return this.f10149a.getSupportedCipherSuites();
        }

        @Override
        public Socket createSocket(String str, int i10) throws IOException, UnknownHostException {
            Log.w("Tls12SocketFactory", "1create socket " + str + ", " + i10);
            return a(this.f10149a.createSocket(str, i10));
        }

        @Override
        public Socket createSocket(String str, int i10, InetAddress inetAddress, int i11) throws IOException, UnknownHostException {
            Log.w("Tls12SocketFactory", "create socket " + str + ", " + i10 + ", " + inetAddress + ", " + i11);
            return a(this.f10149a.createSocket(str, i10, inetAddress, i11));
        }

        @Override
        public Socket createSocket(InetAddress inetAddress, int i10) throws IOException {
            Log.w("Tls12SocketFactory", "create socket " + inetAddress + ", " + i10);
            return a(this.f10149a.createSocket(inetAddress, i10));
        }

        @Override
        public Socket createSocket(InetAddress inetAddress, int i10, InetAddress inetAddress2, int i11) throws IOException {
            Log.w("Tls12SocketFactory", "create socket " + inetAddress + ", " + i10 + ", " + inetAddress2 + ", " + i11);
            return a(this.f10149a.createSocket(inetAddress, i10, inetAddress2, i11));
        }
    }

    public static m.b getOkHttpClientBuilder(String str, String str2, boolean z10) {
        return getOkHttpClientBuilder(str, str2, z10, false);
    }
}