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

import android.util.Log;
import com.cvte.udi.utils.CommonUtils;
import g.e.b.a0;
import g.e.b.c;
import g.e.b.f0.b;
import g.e.b.g0.g0.d;
import g.e.b.g0.s;
import g.e.b.h0.a;
import g.e.b.j;
import g.e.b.y;
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.ArrayList;
import java.util.Arrays;
import java.util.Collections;
import java.util.HashMap;
import java.util.LinkedList;
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;
import okhttp3.n0.connection.RealCall;

/* JADX INFO: loaded from: classes.dex */
public class RouterProxy {
    private static final j GSON;
    private static final MediaType MEDIA_TYPE_JSON = MediaType.c("application/json;charset=utf-8");
    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 String mSysRpcUrl = null;
    private String mUciRpcUrl = null;
    private String mUploadRemoteFile = null;

    public static final class RequestData {

        @b("method")
        public String method;

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

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

    public static final class ResponseData {

        @b("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();
    }

    static {
        s sVar = s.f4134f;
        y yVar = y.f4221f;
        c cVar = c.f4025f;
        HashMap map = new HashMap();
        ArrayList arrayList = new ArrayList();
        ArrayList arrayList2 = new ArrayList();
        a<?> aVar = j.a;
        a0 a0Var = a0.f4020f;
        a0 a0Var2 = a0.f4021m;
        LinkedList linkedList = new LinkedList();
        ArrayList arrayList3 = new ArrayList(arrayList2.size() + arrayList.size() + 3);
        arrayList3.addAll(arrayList);
        Collections.reverse(arrayList3);
        ArrayList arrayList4 = new ArrayList(arrayList2);
        Collections.reverse(arrayList4);
        arrayList3.addAll(arrayList4);
        boolean z2 = d.a;
        GSON = new j(sVar, cVar, new HashMap(map), false, false, false, false, false, false, false, true, yVar, null, 2, 2, new ArrayList(arrayList), new ArrayList(arrayList2), arrayList3, a0Var, a0Var2, new ArrayList(linkedList));
    }

    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) {
        ResponseBody responseBody = response.f9647r;
        if (responseBody == null) {
            return null;
        }
        return ((ResponseData) GSON.b(responseBody.g(), 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));
        while (true) {
            String line = readLine(bufferedReader);
            if (line == null) {
                return wirelessList;
            }
            parseWirelessListLine(wirelessList, line);
        }
    }

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

    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 strG = GSON.g(new RequestData(str2, list));
            Request.a aVar = new Request.a();
            aVar.f(str);
            aVar.d(RequestBody.create(strG, MEDIA_TYPE_JSON));
            String resultFromResponse = getResultFromResponse(((RealCall) this.mClient.b(aVar.a())).j());
            Log.d(Plugin.TAG, str + ", " + strG + "--->" + 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) {
                            CommonUtils.safeClose(outputStream);
                            CommonUtils.safeClose(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);
                    CommonUtils.safeClose(outputStream);
                    CommonUtils.safeClose(socket);
                    return false;
                }
            } catch (Throwable th) {
                th = th;
                CommonUtils.safeClose(null);
                CommonUtils.safeClose(null);
                throw th;
            }
        } catch (Exception e3) {
            e = e3;
            socket = null;
        } catch (Throwable th2) {
            th = th2;
            CommonUtils.safeClose(null);
            CommonUtils.safeClose(null);
            throw th;
        }
    }
}