package com.seewo.vcommons.utils.clone;

import android.content.Context;
import android.net.ConnectivityManager;
import android.net.DhcpInfo;
import android.net.IpConfiguration;
import android.net.LinkAddress;
import android.net.NetworkInfo;
import android.net.NetworkUtils;
import android.net.ProxyInfo;
import android.net.StaticIpConfiguration;
import android.net.Uri;
import android.net.wifi.ScanResult;
import android.net.wifi.WifiConfiguration;
import android.net.wifi.WifiInfo;
import android.net.wifi.WifiManager;
import android.text.TextUtils;
import android.util.Log;
import com.google.gson.Gson;
import com.ifpdos.mcusdk.McuCommandList;
import com.seewo.libsvendors.utils.IEthernetConstant;
import com.seewo.libsvendors.vendor.seewo.ehternet.SeewoEthernet;
import com.seewo.vcommons.constants.Platform;
import com.seewo.vcommons.data.PreferencesUtils;
import com.seewo.vcommons.helper.NetHelper;
import com.seewo.vcommons.utils.BoardTypeUtils;
import com.seewo.vcommons.utils.RLog;
import com.seewo.vcommons.utils.ShellCommandUtils;
import com.seewo.vcommons.utils.clone.IpAssignmentConfig;
import com.seewo.vcommons.utils.clone.ProxySettingsConfig;
import com.seewo.vcommons.utils.reflect.Reflect;
import io.reactivex.annotations.SchedulerSupport;
import java.io.BufferedReader;
import java.io.IOException;
import java.io.StringReader;
import java.net.Inet4Address;
import java.net.InetAddress;
import java.util.ArrayList;
import java.util.Iterator;
import java.util.List;

/* JADX INFO: loaded from: classes.dex */
public class WifiConfigHelper {
    static final /* synthetic */ boolean $assertionsDisabled = false;
    public static final String NONE = "<unknown ssid>";
    private static final int SECURITY_EAP = 3;
    private static final int SECURITY_NONE = 0;
    private static final int SECURITY_PSK = 2;
    private static final int SECURITY_WEP = 1;
    private static final String TAG = "WifiConfigHelper";
    private int mEthernetStatus;
    private boolean mIsWifiEnable;
    private SeewoEthernet mSeewoEthernet;
    private WifiManager mWifiManager;
    private static final byte[] MAIN_CONTENT_KEY = {28, 90, 13, 54, -65, 24, 78, 9, -112, McuCommandList.MAIN_MCU_P_VERSION, -107, -122, 112, -59, 50, -39};
    private static final byte[] IV_CONTENT_KEY = {-39, -28, 22, 11, -121, 11, 65, 75, -100, 14, -31, -61, McuCommandList.MAIN_SEND_MCU_VERSION_NEW, 124, -116, 18};

    private void init(Context context) {
        this.mWifiManager = (WifiManager) context.getApplicationContext().getSystemService("wifi");
        this.mSeewoEthernet = SeewoEthernet.getInstance(context);
        recordStatus();
        closeEthernet();
        NetHelper.stopNativeHotSpot(context);
        openWifi(context);
    }

    private void recordStatus() {
        this.mEthernetStatus = this.mSeewoEthernet.getEnableState();
        int wifiState = this.mWifiManager.getWifiState();
        if (wifiState == 3 || wifiState == 2) {
            this.mIsWifiEnable = true;
        }
    }

    private void recoverStatus() {
        this.mSeewoEthernet.setEnable(this.mEthernetStatus == IEthernetConstant.ETHERNET_STATE_ENABLED);
        this.mWifiManager.setWifiEnabled(this.mIsWifiEnable);
    }

    private void openWifi(Context context) {
        if (PreferencesUtils.getHiWifiStatus(context)) {
            this.mWifiManager.setWifiEnabled(true);
        }
    }

    private void closeEthernet() {
        this.mSeewoEthernet.setEnable(false);
    }

    public boolean connectWifiWithMessage(Context context, String str) {
        WifiConfigMessage wifiConfigMessage;
        IpConfiguration.IpAssignment ipAssignment;
        StaticIpConfiguration staticIpConfiguration;
        IpConfiguration.ProxySettings proxySettings;
        ProxyInfo proxyInfo;
        if (TextUtils.isEmpty(str) || !PreferencesUtils.getHiWifiStatus(context) || (wifiConfigMessage = (WifiConfigMessage) new Gson().fromJson(str, WifiConfigMessage.class)) == null) {
            return false;
        }
        init(context);
        WifiConfiguration wifiConfiguration = new WifiConfiguration();
        wifiConfiguration.allowedAuthAlgorithms.clear();
        wifiConfiguration.allowedGroupCiphers.clear();
        wifiConfiguration.allowedKeyManagement.clear();
        wifiConfiguration.allowedPairwiseCiphers.clear();
        wifiConfiguration.allowedProtocols.clear();
        if (Platform.VERSION == 3 || wifiConfigMessage.getSsid().startsWith("\"")) {
            wifiConfiguration.SSID = wifiConfigMessage.getSsid();
        } else {
            wifiConfiguration.SSID = "\"" + wifiConfigMessage.getSsid() + "\"";
        }
        WifiConfiguration wifiConfigurationIsExistSSID = isExistSSID(wifiConfigMessage.getSsid());
        if (wifiConfigurationIsExistSSID != null) {
            this.mWifiManager.removeNetwork(wifiConfigurationIsExistSSID.networkId);
        }
        if (wifiConfigMessage.getSecurityType() == 0) {
            wifiConfiguration.allowedKeyManagement.set(0);
        } else if (wifiConfigMessage.getSecurityType() == 1) {
            wifiConfigMessage.setPassword(getDecryptPassword(wifiConfigMessage.getPassword()));
            wifiConfiguration.hiddenSSID = true;
            int length = wifiConfigMessage.getPassword().length();
            if ((length == 10 || length == 26 || length == 58) && wifiConfigMessage.getPassword().matches("[0-9A-Fa-f]*")) {
                wifiConfiguration.wepKeys[0] = wifiConfigMessage.getPassword();
            } else {
                wifiConfiguration.wepKeys[0] = "\"" + wifiConfigMessage.getPassword() + '\"';
            }
            wifiConfiguration.allowedAuthAlgorithms.set(0);
            wifiConfiguration.allowedAuthAlgorithms.set(1);
            wifiConfiguration.allowedKeyManagement.set(0);
            wifiConfiguration.wepTxKeyIndex = 0;
        } else if (wifiConfigMessage.getSecurityType() == 2) {
            wifiConfigMessage.setPassword(getDecryptPassword(wifiConfigMessage.getPassword()));
            if (wifiConfigMessage.getPassword().matches("[0-9A-Fa-f]{64}") || isCloneWifiInSeLinux()) {
                wifiConfiguration.preSharedKey = wifiConfigMessage.getPassword();
            } else {
                wifiConfiguration.preSharedKey = "\"" + wifiConfigMessage.getPassword() + '\"';
            }
            wifiConfiguration.hiddenSSID = true;
            wifiConfiguration.allowedAuthAlgorithms.set(0);
            wifiConfiguration.allowedGroupCiphers.set(2);
            wifiConfiguration.allowedKeyManagement.set(1);
            wifiConfiguration.allowedPairwiseCiphers.set(1);
            wifiConfiguration.allowedGroupCiphers.set(3);
            wifiConfiguration.allowedPairwiseCiphers.set(2);
            wifiConfiguration.status = 2;
        }
        if (wifiConfigMessage.getIpAssignmentConfig().getIpAssignment().equals(IpAssignmentConfig.IpAssignment.STATIC.name())) {
            ipAssignment = IpConfiguration.IpAssignment.STATIC;
            staticIpConfiguration = new StaticIpConfiguration();
            staticIpConfiguration.ipAddress = (LinkAddress) Reflect.on((Class<?>) LinkAddress.class).create(getIPv4Address(wifiConfigMessage.getIpAssignmentConfig().getIpAddress()), Integer.valueOf(wifiConfigMessage.getIpAssignmentConfig().getPrefixLength())).get();
            staticIpConfiguration.gateway = getIPv4Address(wifiConfigMessage.getIpAssignmentConfig().getGateway());
            for (int i = 0; i < wifiConfigMessage.getIpAssignmentConfig().getDnsNum(); i++) {
                staticIpConfiguration.dnsServers.add(getIPv4Address(wifiConfigMessage.getIpAssignmentConfig().getDns()[i]));
            }
        } else {
            ipAssignment = IpConfiguration.IpAssignment.DHCP;
            staticIpConfiguration = null;
        }
        if (wifiConfigMessage.getProxySettingsConfig().getProxySettings().equals(ProxySettingsConfig.ProxySettings.STATIC.name())) {
            proxySettings = IpConfiguration.ProxySettings.STATIC;
            proxyInfo = (ProxyInfo) Reflect.on((Class<?>) ProxyInfo.class).create(wifiConfigMessage.getProxySettingsConfig().getProxyHostName(), Integer.valueOf(wifiConfigMessage.getProxySettingsConfig().getProxyPort()), wifiConfigMessage.getProxySettingsConfig().getProxyExclusionList()).get();
        } else if (wifiConfigMessage.getProxySettingsConfig().getProxySettings().equals(ProxySettingsConfig.ProxySettings.PAC.name())) {
            proxySettings = IpConfiguration.ProxySettings.PAC;
            proxyInfo = (ProxyInfo) Reflect.on((Class<?>) ProxyInfo.class).create(Uri.parse(wifiConfigMessage.getProxySettingsConfig().getProxyPac())).get();
        } else {
            proxySettings = IpConfiguration.ProxySettings.NONE;
            proxyInfo = null;
        }
        Reflect.on(wifiConfiguration).call("setIpConfiguration", new IpConfiguration(ipAssignment, proxySettings, staticIpConfiguration, proxyInfo)).get();
        if (this.mWifiManager.enableNetwork(this.mWifiManager.addNetwork(wifiConfiguration), true)) {
            return true;
        }
        recoverStatus();
        return false;
    }

    private Inet4Address getIPv4Address(String str) {
        try {
            return (Inet4Address) NetworkUtils.numericToInetAddress(str);
        } catch (Exception unused) {
            return null;
        }
    }

    private WifiConfiguration isExistSSID(String str) {
        List<WifiConfiguration> configuredNetworks = this.mWifiManager.getConfiguredNetworks();
        if (configuredNetworks == null) {
            return null;
        }
        for (WifiConfiguration wifiConfiguration : configuredNetworks) {
            if (wifiConfiguration.SSID.equals(str)) {
                return wifiConfiguration;
            }
        }
        return null;
    }

    public static String getWifiConfig(Context context) {
        WifiConfigMessage wifiConfigMessage = getWifiConfigMessage(context);
        return wifiConfigMessage != null ? new Gson().toJson(wifiConfigMessage) : "";
    }

    private static WifiConfigMessage getWifiIpConfiguration(Context context, String str, int i, String str2) {
        WifiManager wifiManager = (WifiManager) context.getApplicationContext().getSystemService("wifi");
        WifiConfigMessage wifiConfigMessage = new WifiConfigMessage();
        wifiConfigMessage.setSsid(str);
        wifiConfigMessage.setSecurityType(i);
        wifiConfigMessage.setPassword(str2);
        if (wifiManager == null) {
            return wifiConfigMessage;
        }
        List<WifiConfiguration> configuredNetworks = wifiManager.getConfiguredNetworks();
        int i2 = 0;
        int i3 = 0;
        while (true) {
            if (i3 >= configuredNetworks.size()) {
                break;
            }
            if (str.equals(configuredNetworks.get(i3).SSID)) {
                WifiConfiguration wifiConfiguration = configuredNetworks.get(i3);
                IpConfiguration.IpAssignment ipAssignment = (IpConfiguration.IpAssignment) Reflect.on(wifiConfiguration).call("getIpAssignment").get();
                IpAssignmentConfig ipAssignmentConfig = new IpAssignmentConfig(ipAssignment.name());
                if (ipAssignment.name().equals(IpConfiguration.IpAssignment.STATIC.name())) {
                    StaticIpConfiguration staticIpConfiguration = (StaticIpConfiguration) Reflect.on(wifiConfiguration).call("getStaticIpConfiguration").get();
                    ipAssignmentConfig.setIpAddress(staticIpConfiguration.ipAddress.getAddress().getHostAddress());
                    ipAssignmentConfig.setPrefixLength(staticIpConfiguration.ipAddress.getNetworkPrefixLength());
                    ipAssignmentConfig.setGateway(staticIpConfiguration.gateway.getHostAddress());
                    Iterator it = staticIpConfiguration.dnsServers.iterator();
                    ArrayList arrayList = new ArrayList();
                    if (it.hasNext()) {
                        arrayList.add(((InetAddress) it.next()).getHostAddress());
                        i2 = 1;
                    }
                    if (it.hasNext()) {
                        arrayList.add(((InetAddress) it.next()).getHostAddress());
                        i2++;
                    }
                    ipAssignmentConfig.setDnsNum(i2);
                    ipAssignmentConfig.setDns((String[]) arrayList.toArray(new String[i2]));
                }
                wifiConfigMessage.setIpAssignmentConfig(ipAssignmentConfig);
                IpConfiguration.ProxySettings proxySettings = (IpConfiguration.ProxySettings) Reflect.on(wifiConfiguration).call("getProxySettings").get();
                ProxySettingsConfig proxySettingsConfig = new ProxySettingsConfig(proxySettings.name());
                if (!proxySettings.name().equals(ProxySettingsConfig.ProxySettings.NONE.name())) {
                    ProxyInfo proxyInfo = (ProxyInfo) Reflect.on(wifiConfiguration).call("getHttpProxy").get();
                    proxySettingsConfig.setProxyHostName(proxyInfo.getHost());
                    proxySettingsConfig.setProxyPort(proxyInfo.getPort());
                    proxySettingsConfig.setProxyPac(proxyInfo.getPacFileUrl().toString());
                    proxySettingsConfig.setProxyExclusionList(proxyInfo.getExclusionListAsString());
                }
                wifiConfigMessage.setProxySettingsConfig(proxySettingsConfig);
            } else {
                i3++;
            }
        }
        return wifiConfigMessage;
    }

    private static WifiConfiguration getWifiConfigurationForNetworkId(WifiInfo wifiInfo, List<WifiConfiguration> list) {
        if (list == null) {
            return null;
        }
        for (WifiConfiguration wifiConfiguration : list) {
            if (wifiInfo != null && wifiInfo.getNetworkId() == wifiConfiguration.networkId) {
                return wifiConfiguration;
            }
        }
        return null;
    }

    private static WifiConfigMessage getWifiConfigFromSaveData(Context context) {
        WifiManager wifiManager = (WifiManager) context.getApplicationContext().getSystemService("wifi");
        List<WifiConfiguration> configuredNetworks = wifiManager.getConfiguredNetworks();
        WifiInfo connectionInfo = wifiManager.getConnectionInfo();
        if (connectionInfo == null) {
            return null;
        }
        WifiConfiguration wifiConfigurationForNetworkId = getWifiConfigurationForNetworkId(connectionInfo, configuredNetworks);
        boolean z = wifiConfigurationForNetworkId.allowedKeyManagement.get(0);
        int i = 1;
        boolean z2 = z && wifiConfigurationForNetworkId.allowedAuthAlgorithms.get(0) && wifiConfigurationForNetworkId.allowedAuthAlgorithms.get(1);
        boolean z3 = wifiConfigurationForNetworkId.allowedKeyManagement.get(1);
        boolean z4 = wifiConfigurationForNetworkId.allowedKeyManagement.get(2);
        if (z3) {
            i = 2;
        } else if (!z2) {
            i = (!z && z4) ? 3 : 0;
        }
        String stringAsUser = PreferencesUtils.getStringAsUser(context, getWifiKey(wifiConfigurationForNetworkId.SSID, i), 0);
        RLog.i(TAG, "clone ssid:" + wifiConfigurationForNetworkId.SSID + "  psw:" + stringAsUser + " security:" + i);
        return getWifiIpConfiguration(context, wifiConfigurationForNetworkId.SSID, i, stringAsUser);
    }

    public static String getWifiKey(String str, int i) {
        return "key_wifi_" + str + "_" + i + "_psw";
    }

    private static boolean isCloneWifiInSeLinux() {
        return Platform.VERSION == 8 || BoardTypeUtils.isSupportSELinux();
    }

    public static WifiConfigMessage getWifiConfigMessage(Context context) {
        WifiConfigMessage wifiConfigMessage;
        if (isCloneWifiInSeLinux()) {
            return getWifiConfigFromSaveData(context);
        }
        WifiManager wifiManager = (WifiManager) context.getApplicationContext().getSystemService("wifi");
        if (wifiManager == null) {
            return null;
        }
        if (Platform.VERSION < 5) {
            WifiInfo connectionInfo = wifiManager.getConnectionInfo();
            DhcpInfo dhcpInfo = wifiManager.getDhcpInfo();
            if (connectionInfo != null && dhcpInfo != null && wifiManager.isWifiEnabled()) {
                String ssid = connectionInfo.getSSID();
                boolean zIsNoneTypeWifi = isNoneTypeWifi(context, ssid);
                if (!ssid.equals(NONE) && (wifiConfigMessage = getWifiConfigMessage(ssid, zIsNoneTypeWifi)) != null) {
                    return getWifiIpConfiguration(context, ssid, wifiConfigMessage.getSecurityType(), wifiConfigMessage.getPassword());
                }
            }
        } else {
            ConnectivityManager connectivityManager = (ConnectivityManager) context.getSystemService("connectivity");
            if (connectivityManager == null) {
                return null;
            }
            NetworkInfo activeNetworkInfo = connectivityManager.getActiveNetworkInfo();
            if (activeNetworkInfo == null) {
                Log.e(TAG, "networkInfo is null");
                return null;
            }
            String extraInfo = activeNetworkInfo.getExtraInfo();
            RLog.d(TAG, "ssid:" + extraInfo);
            boolean zIsNoneTypeWifi2 = isNoneTypeWifi(context, extraInfo);
            if (!TextUtils.isEmpty(extraInfo) && extraInfo.startsWith("\"")) {
                String strSubstring = extraInfo.trim().substring(1, extraInfo.length() - 1);
                RLog.d(TAG, "wifiName:" + strSubstring);
                WifiConfigMessage wifiConfigMessageInNew = getWifiConfigMessageInNew(strSubstring, zIsNoneTypeWifi2);
                RLog.d(TAG, "wifimessage:" + wifiConfigMessageInNew);
                return wifiConfigMessageInNew;
            }
        }
        return null;
    }

    private static boolean isNoneTypeWifi(Context context, String str) {
        String strSubstring;
        List<ScanResult> scanResults = ((WifiManager) context.getApplicationContext().getSystemService("wifi")).getScanResults();
        if (str.startsWith("\"") && str.endsWith("\"")) {
            strSubstring = str.substring(1, str.length() - 1);
        } else {
            strSubstring = "";
        }
        if (scanResults == null) {
            return false;
        }
        for (ScanResult scanResult : scanResults) {
            String str2 = scanResult.capabilities;
            if (str.trim().equals(scanResult.SSID.trim()) || strSubstring.trim().equals(scanResult.SSID.trim())) {
                if (str2.trim().equals("[ESS]")) {
                    return true;
                }
            }
        }
        return false;
    }

    private static WifiConfigMessage getWifiConfigMessageInNew(String str, boolean z) {
        boolean wifiPsw;
        if (TextUtils.isEmpty(str)) {
            return null;
        }
        WifiConfigMessage wifiConfigMessage = new WifiConfigMessage();
        wifiConfigMessage.setSsid(str);
        ShellCommandUtils.CommandResult commandResultExecuteCommand = ShellCommandUtils.executeCommand("cat data/misc/wifi/WifiConfigStore.xml");
        if (commandResultExecuteCommand.result != 0) {
            return null;
        }
        BufferedReader bufferedReader = new BufferedReader(new StringReader(commandResultExecuteCommand.successMsg));
        try {
            String line = bufferedReader.readLine();
            while (true) {
                wifiPsw = false;
                if (line == null) {
                    break;
                }
                if (line.trim().startsWith("<string name=\"ConfigKey\">&quot;") && CloneUtils.getStringWithoutEscape(line.trim().substring("<string name=\"ConfigKey\">&quot;".length(), line.lastIndexOf("&quot;"))).equals(str)) {
                    if (line.trim().endsWith("WPA_PSK</string>")) {
                        wifiConfigMessage.setSecurityType(2);
                        if (!z) {
                            break;
                        }
                        line = bufferedReader.readLine();
                    } else if (line.trim().endsWith("NONE</string>")) {
                        wifiConfigMessage.setPassword(SchedulerSupport.NONE);
                        wifiConfigMessage.setSecurityType(0);
                        if (z) {
                            break;
                        }
                        line = bufferedReader.readLine();
                    } else {
                        wifiConfigMessage.setSecurityType(1);
                        if (!z) {
                            break;
                        }
                        line = bufferedReader.readLine();
                    }
                } else {
                    line = bufferedReader.readLine();
                }
            }
            for (String line2 = bufferedReader.readLine(); line2 != null; line2 = bufferedReader.readLine()) {
                String strTrim = line2.trim();
                if (!wifiPsw) {
                    wifiPsw = readWifiPsw(wifiConfigMessage, strTrim);
                }
                if (readWifiIpConfiguration(bufferedReader, wifiConfigMessage, strTrim).trim().startsWith("</Network>")) {
                    break;
                }
            }
            return wifiConfigMessage;
        } catch (IOException e) {
            Log.e(TAG, "", e);
            return null;
        }
    }

    private static String readWifiIpConfiguration(BufferedReader bufferedReader, WifiConfigMessage wifiConfigMessage, String str) {
        if (!str.trim().startsWith("<IpConfiguration>")) {
            return str;
        }
        try {
            str = bufferedReader.readLine();
            while (str != null) {
                str = str.trim();
                if (!str.trim().startsWith("<string name=\"IpAssignment\">")) {
                    if (str.trim().startsWith("<string name=\"ProxySettings\">")) {
                        String strSubstring = str.trim().substring("<string name=\"ProxySettings\">".length(), str.lastIndexOf("</string>"));
                        wifiConfigMessage.setProxySettingsConfig(new ProxySettingsConfig(strSubstring));
                        if (!strSubstring.equals(ProxySettingsConfig.ProxySettings.NONE.name())) {
                            str = readWifiProxy(bufferedReader, wifiConfigMessage, str);
                        }
                    }
                } else {
                    String strSubstring2 = str.trim().substring("<string name=\"IpAssignment\">".length(), str.lastIndexOf("</string>"));
                    wifiConfigMessage.setIpAssignmentConfig(new IpAssignmentConfig(strSubstring2));
                    if (strSubstring2.equals(IpAssignmentConfig.IpAssignment.STATIC.name())) {
                        str = readWifiIpAssignment(bufferedReader, wifiConfigMessage, str);
                    }
                }
                if (str != null && str.trim().startsWith("</IpConfiguration>")) {
                    return str;
                }
                str = bufferedReader.readLine();
            }
        } catch (IOException e) {
            Log.e(TAG, e.getMessage(), e);
        }
        return str;
    }

    private static String readWifiIpAssignment(BufferedReader bufferedReader, WifiConfigMessage wifiConfigMessage, String str) {
        try {
            IpAssignmentConfig ipAssignmentConfig = wifiConfigMessage.getIpAssignmentConfig();
            str = bufferedReader.readLine();
            while (str != null) {
                String strTrim = str.trim();
                if (strTrim.trim().startsWith("<string name=\"LinkAddress\">")) {
                    ipAssignmentConfig.setIpAddress(strTrim.trim().substring("<string name=\"LinkAddress\">".length(), strTrim.lastIndexOf("</string>")));
                } else if (strTrim.trim().startsWith("<int name=\"LinkPrefixLength\" value=\"")) {
                    ipAssignmentConfig.setPrefixLength(Integer.parseInt(strTrim.trim().substring("<int name=\"LinkPrefixLength\" value=\"".length(), strTrim.lastIndexOf("\""))));
                } else if (strTrim.trim().startsWith("<string name=\"GatewayAddress\">")) {
                    ipAssignmentConfig.setGateway(strTrim.trim().substring("<string name=\"GatewayAddress\">".length(), strTrim.lastIndexOf("</string>")));
                } else {
                    if (!strTrim.trim().startsWith("<string-array name=\"DNSServers\" num=\"")) {
                        return strTrim;
                    }
                    int i = Integer.parseInt(strTrim.trim().substring("<string-array name=\"DNSServers\" num=\"".length(), strTrim.lastIndexOf("\"")));
                    ipAssignmentConfig.setDnsNum(i);
                    String[] strArr = new String[i];
                    for (int i2 = 0; i2 < i; i2++) {
                        String line = bufferedReader.readLine();
                        if (line != null) {
                            if (line.trim().startsWith("<item value=\"")) {
                                strArr[i2] = line.trim().substring("<item value=\"".length(), line.lastIndexOf("\""));
                            }
                            if (i2 == i - 1) {
                                ipAssignmentConfig.setDns(strArr);
                                return line;
                            }
                        } else {
                            ipAssignmentConfig.setDns(strArr);
                            return "";
                        }
                    }
                }
                str = bufferedReader.readLine();
            }
        } catch (IOException e) {
            Log.e(TAG, e.getMessage(), e);
        }
        return str;
    }

    private static String readWifiProxy(BufferedReader bufferedReader, WifiConfigMessage wifiConfigMessage, String str) {
        try {
            ProxySettingsConfig proxySettingsConfig = wifiConfigMessage.getProxySettingsConfig();
            str = bufferedReader.readLine();
            while (str != null) {
                str = str.trim();
                if (str.trim().startsWith("<string name=\"ProxyHost\">")) {
                    proxySettingsConfig.setProxyHostName(str.trim().substring("<string name=\"ProxyHost\">".length(), str.lastIndexOf("</string>")));
                } else if (str.trim().startsWith("<int name=\"ProxyPort\" value=\"")) {
                    proxySettingsConfig.setProxyPort(Integer.parseInt(str.trim().substring("<int name=\"ProxyPort\" value=\"".length(), str.lastIndexOf("\""))));
                } else if (!str.trim().startsWith("<string name=\"ProxyExclusionList\">")) {
                    if (!str.trim().startsWith("<string name=\"ProxyPac\">")) {
                        return str;
                    }
                    proxySettingsConfig.setProxyPac(str.trim().substring("<string name=\"ProxyPac\">".length(), str.lastIndexOf("</string>")));
                } else {
                    proxySettingsConfig.setProxyExclusionList(str.trim().substring("<string name=\"ProxyExclusionList\">".length(), str.lastIndexOf("</string>")));
                }
                str = bufferedReader.readLine();
            }
        } catch (Exception e) {
            Log.e(TAG, e.getMessage(), e);
        }
        return str;
    }

    private static boolean readWifiPsw(WifiConfigMessage wifiConfigMessage, String str) {
        int securityType = wifiConfigMessage.getSecurityType();
        if (securityType != 0) {
            if (securityType != 1) {
                if (securityType != 2 || !str.startsWith("<string name=\"PreSharedKey\">&quot;")) {
                    return false;
                }
                wifiConfigMessage.setPassword(getEncryptPassword(CloneUtils.getStringWithoutEscape(str.substring(str.indexOf("<string name=\"PreSharedKey\">&quot;") + "<string name=\"PreSharedKey\">&quot;".length(), str.lastIndexOf("&quot;")))));
                return true;
            }
            wifiConfigMessage.setPassword(getEncryptPassword(CloneUtils.getStringWithoutEscape(str.substring(str.indexOf("\"") + 1, str.lastIndexOf("\"")))));
        }
        return true;
    }

    private static WifiConfigMessage getWifiConfigMessage(String str, boolean z) {
        if (TextUtils.isEmpty(str)) {
            return null;
        }
        WifiConfigMessage wifiConfigMessage = new WifiConfigMessage();
        wifiConfigMessage.setSsid(str);
        ShellCommandUtils.CommandResult commandResultExecuteCommand = ShellCommandUtils.executeCommand("cat data/misc/wifi/wpa_supplicant.conf");
        if (commandResultExecuteCommand.result != 0) {
            return null;
        }
        String hexStringFromBytes = (str.startsWith("\"") && str.endsWith("\"")) ? CloneUtils.toHexStringFromBytes(str.substring(1, str.length() - 1).getBytes()) : "";
        BufferedReader bufferedReader = new BufferedReader(new StringReader(commandResultExecuteCommand.successMsg));
        try {
            for (String line = bufferedReader.readLine(); line != null && (!line.trim().startsWith("ssid=") || (!line.trim().equals("ssid=" + str) && !line.trim().equals("ssid=" + hexStringFromBytes))); line = bufferedReader.readLine()) {
            }
            for (String line2 = bufferedReader.readLine(); line2 != null; line2 = bufferedReader.readLine()) {
                String strTrim = line2.trim();
                if (strTrim.startsWith("psk=\"")) {
                    wifiConfigMessage.setPassword(getEncryptPassword(strTrim.substring(strTrim.indexOf("psk=\"") + 5, strTrim.lastIndexOf("\""))));
                } else if ("key_mgmt=NONE".equals(strTrim)) {
                    wifiConfigMessage.setPassword(SchedulerSupport.NONE);
                    wifiConfigMessage.setSecurityType(0);
                    if (!z) {
                        findNextSsid(bufferedReader, str, hexStringFromBytes);
                    }
                } else if ("key_mgmt=WPA-PSK".equals(strTrim)) {
                    wifiConfigMessage.setSecurityType(2);
                    if (z) {
                        findNextSsid(bufferedReader, str, hexStringFromBytes);
                    }
                } else if (strTrim.startsWith("wep_key0")) {
                    wifiConfigMessage.setPassword(getEncryptPassword(strTrim.substring(strTrim.indexOf("\"") + 1, strTrim.lastIndexOf("\""))));
                    wifiConfigMessage.setSecurityType(1);
                    if (z) {
                        findNextSsid(bufferedReader, str, hexStringFromBytes);
                    }
                }
                if ("}".equals(strTrim)) {
                    return wifiConfigMessage;
                }
            }
        } catch (IOException e) {
            Log.e(TAG, "", e);
        }
        return null;
    }

    private static void findNextSsid(BufferedReader bufferedReader, String str, String str2) throws IOException {
        String line = bufferedReader.readLine();
        while (line != null) {
            if (line.trim().startsWith("ssid=") && (line.trim().equals("ssid=" + str) || line.trim().equals("ssid=" + str2))) {
                Log.d(TAG, "found next same Ssid");
                return;
            }
            line = bufferedReader.readLine();
        }
    }

    public static String getEncryptPassword(String str) {
        return new String(AESUtils.encryptAES2Base64(str.getBytes(), MAIN_CONTENT_KEY, IV_CONTENT_KEY));
    }

    private String getDecryptPassword(String str) {
        return new String(AESUtils.decryptBase64AES(str.getBytes(), MAIN_CONTENT_KEY, IV_CONTENT_KEY));
    }
}