package com.cvte.dss.ups.router.mt76x;

import android.util.Log;
import c.n.a;
import com.google.gson.Gson;
import com.google.gson.GsonBuilder;
import com.google.gson.annotations.SerializedName;
import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStream;
import java.io.OutputStream;
import java.io.StringReader;
import java.math.BigInteger;
import java.net.Socket;
import java.security.MessageDigest;
import java.util.Arrays;
import java.util.Collections;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
import okhttp3.MediaType;
import okhttp3.OkHttpClient;
import okhttp3.Request;
import okhttp3.RequestBody;
import okhttp3.Response;
import okhttp3.ResponseBody;

/* JADX INFO: loaded from: classes.dex */
public class RouterProxy {
    private static final String METHOD_COMMIT = "commit";
    private static final String METHOD_EXEC = "exec";
    private static final String METHOD_LOGIN = "login";
    private static final String METHOD_SET = "set";
    private static final String RPC_TYPE_SYS = "sys";
    private static final String RPC_TYPE_UCI = "uci";
    private static final String SERVER_IP = "192.168.153.1";
    private static final int UPLOAD_SERVER_PORT = 12345;
    private static final String URL_AUTH = "https://192.168.153.1/cgi-bin/luci/rpc/auth";
    private static final String URL_BASE = "https://192.168.153.1";
    private static final String URL_TEMPLATE_RPC = "https://192.168.153.1/cgi-bin/luci/rpc/%s?auth=%s";
    private final OkHttpClient mClient;
    private String mToken;
    private static final MediaType MEDIA_TYPE_JSON = MediaType.parse("application/json;charset=utf-8");
    private static final Gson GSON = new GsonBuilder().disableHtmlEscaping().create();
    private String mSysRpcUrl = null;
    private String mUciRpcUrl = null;
    private String mUploadRemoteFile = null;

    public static final class RequestData {

        @SerializedName("method")
        public String method;

        @SerializedName("params")
        public List<String> params;

        public RequestData(String str, List<String> list) {
            this.method = str;
            this.params = list;
        }
    }

    public static final class ResponseData {

        @SerializedName("result")
        public String result;

        private ResponseData() {
        }
    }

    public static final class WirelessList {
        public Map<String, Map<String, String>> ifaces = new HashMap();
        public Map<String, Map<String, String>> devices = new HashMap();
    }

    public RouterProxy(OkHttpClient okHttpClient) {
        this.mClient = okHttpClient;
    }

    private synchronized String execCmd(String str) {
        if (this.mToken == null) {
            Log.e(Plugin.TAG, "execCmd error : mToken == null");
            return null;
        }
        return sendRequest(this.mSysRpcUrl, METHOD_EXEC, Collections.singletonList(str));
    }

    private String getRemoteFileMd5(String str) {
        return execCmd(String.format("md5sum %s | cut -d ' ' -f1", str));
    }

    private String getResultFromResponse(Response response) throws IOException {
        ResponseBody responseBodyBody = response.body();
        if (responseBodyBody == null) {
            return null;
        }
        return ((ResponseData) GSON.fromJson(responseBodyBody.string(), ResponseData.class)).result.trim();
    }

    private String getSysRpcUrl(String str) {
        return String.format(URL_TEMPLATE_RPC, RPC_TYPE_SYS, str);
    }

    private String getToken() {
        return sendRequest(URL_AUTH, METHOD_LOGIN, Arrays.asList("root", "menu1379"));
    }

    private String getUciRpcUrl(String str) {
        return String.format(URL_TEMPLATE_RPC, RPC_TYPE_UCI, str);
    }

    private WirelessList parseWirelessList(String str) {
        if (str == null) {
            return new WirelessList();
        }
        WirelessList wirelessList = new WirelessList();
        BufferedReader bufferedReader = new BufferedReader(new StringReader(str));
        String line = readLine(bufferedReader);
        while (line != null) {
            parseWirelessListLine(wirelessList, line);
            line = readLine(bufferedReader);
        }
        return wirelessList;
    }

    private void parseWirelessListLine(WirelessList wirelessList, String str) {
        String[] strArrSplit = removeWirelessPrefix(str).split("=");
        if (strArrSplit.length < 2) {
            return;
        }
        String str2 = strArrSplit[0];
        String strRemoveSurroundedQuotes = removeSurroundedQuotes(strArrSplit[1]);
        if ("wifi-iface".equals(strRemoveSurroundedQuotes)) {
            wirelessList.ifaces.put(str2, new HashMap());
            return;
        }
        if ("wifi-device".equals(strRemoveSurroundedQuotes)) {
            wirelessList.devices.put(str2, new HashMap());
            return;
        }
        String[] strArrSplit2 = str2.split("\\.");
        if (strArrSplit2.length < 2) {
            return;
        }
        String str3 = strArrSplit2[0];
        String str4 = strArrSplit2[1];
        Map<String, String> map = wirelessList.devices.get(str3);
        if (map != null) {
            map.put(str4, strRemoveSurroundedQuotes);
            return;
        }
        Map<String, String> map2 = wirelessList.ifaces.get(str3);
        if (map2 != null) {
            map2.put(str4, strRemoveSurroundedQuotes);
        }
    }

    private String readLine(BufferedReader bufferedReader) {
        try {
            return bufferedReader.readLine();
        } catch (IOException unused) {
            return null;
        }
    }

    private String removeSurroundedQuotes(String str) {
        if (str.isEmpty()) {
            return str;
        }
        int length = str.length();
        int i2 = str.charAt(0) == '\'' ? 1 : 0;
        if (str.charAt(str.length() - 1) == '\'') {
            length--;
        }
        return str.substring(i2, length);
    }

    private String removeWirelessPrefix(String str) {
        return str.startsWith("wireless.") ? str.substring(9) : str;
    }

    private String sendRequest(String str, String str2, List<String> list) {
        try {
            String json = GSON.toJson(new RequestData(str2, list));
            String resultFromResponse = getResultFromResponse(this.mClient.newCall(new Request.Builder().url(str).post(RequestBody.create(json, MEDIA_TYPE_JSON)).build()).execute());
            Log.d(Plugin.TAG, str + ", " + json + "--->" + resultFromResponse);
            return resultFromResponse;
        } catch (Exception e2) {
            Log.e(Plugin.TAG, "sendRequest error : " + str, e2);
            return null;
        }
    }

    private boolean stringNotEmpty(String str) {
        return (str == null || str.isEmpty()) ? false : true;
    }

    public synchronized boolean commitWireless() {
        if (this.mToken == null) {
            return false;
        }
        return Boolean.valueOf(sendRequest(this.mUciRpcUrl, METHOD_COMMIT, Collections.singletonList("wireless"))).booleanValue();
    }

    public synchronized void connectRouter() {
        String token = getToken();
        this.mToken = token;
        if (token != null) {
            this.mSysRpcUrl = getSysRpcUrl(token);
            this.mUciRpcUrl = getUciRpcUrl(this.mToken);
        }
    }

    public String getOtaKey() {
        return execCmd("cat /etc/otakey");
    }

    public String getVersion() {
        return execCmd("cat /etc/router.version | grep version | cut -d '=' -f2");
    }

    public WirelessList getWirelessList() {
        return parseWirelessList(execCmd("uci show wireless"));
    }

    public boolean is24GAvailable() {
        String strExecCmd = execCmd("lspci -km | grep 7603 | cut -d ' ' -f5");
        return (strExecCmd == null || strExecCmd.isEmpty()) ? false : true;
    }

    public boolean is5GAvailable() {
        String strExecCmd = execCmd("lspci -km | grep 7663 | cut -d ' ' -f5");
        return (strExecCmd == null || strExecCmd.isEmpty()) ? false : true;
    }

    public synchronized boolean isConnectRouter() {
        return this.mToken != null;
    }

    public boolean reloadWireless() {
        return stringNotEmpty(execCmd("wifi reload"));
    }

    public void removeFile(String str) {
        execCmd(String.format("rm %s", str));
    }

    public void routerUpgrade(String str) {
        execCmd(String.format("/sbin/sysupgrade -n %s", str));
        this.mToken = null;
    }

    public synchronized boolean setWirelessProp(String str, String str2, String str3) {
        if (this.mToken == null) {
            return false;
        }
        return Boolean.valueOf(sendRequest(this.mUciRpcUrl, METHOD_SET, Arrays.asList("wireless", str, str2, str3))).booleanValue();
    }

    public void startUploadServer(String str) {
        this.mUploadRemoteFile = str;
        execCmd(String.format("nc -l -p %s > %s &", Integer.valueOf(UPLOAD_SERVER_PORT), str));
    }

    public boolean uploadFile(InputStream inputStream) throws Throwable {
        Socket socket;
        if (this.mUploadRemoteFile == null) {
            Log.e(Plugin.TAG, "uploadFile error : mUploadRemoteFile == null");
            return false;
        }
        OutputStream outputStream = null;
        try {
            try {
                MessageDigest messageDigest = MessageDigest.getInstance("MD5");
                socket = new Socket(SERVER_IP, UPLOAD_SERVER_PORT);
                try {
                    outputStream = socket.getOutputStream();
                    byte[] bArr = new byte[1024];
                    while (true) {
                        int i2 = inputStream.read(bArr, 0, 1024);
                        if (i2 == -1) {
                            a.O(outputStream);
                            a.O(socket);
                            return new BigInteger(1, messageDigest.digest()).toString(16).equals(getRemoteFileMd5(this.mUploadRemoteFile));
                        }
                        outputStream.write(bArr, 0, i2);
                        messageDigest.update(bArr, 0, i2);
                    }
                } catch (Exception e2) {
                    e = e2;
                    Log.e(Plugin.TAG, "uploadFile error :", e);
                    a.O(outputStream);
                    a.O(socket);
                    return false;
                }
            } catch (Throwable th) {
                th = th;
                a.O(null);
                a.O(null);
                throw th;
            }
        } catch (Exception e3) {
            e = e3;
            socket = null;
        } catch (Throwable th2) {
            th = th2;
            a.O(null);
            a.O(null);
            throw th;
        }
    }
}