VirtualTerminal

com.zframework.VirtualTerminal.java

package com.zframework;

import android.util.Log;
import com.zimperium.zanti.zcloud.ZantiZcloud.zanti_command_names;
import java.io.ByteArrayOutputStream;
import java.io.DataOutputStream;
import java.io.IOException;
import java.util.Arrays;

public class VirtualTerminal {
    public static VirtualTerminal mTerminal1;
    public static VirtualTerminal mTerminal2;
    DataOutputStream mDataOutputStream;  // c 
    final Object mObj1 = new Object();   // d
    final Object mObj2 = new Object();   // e
    ByteArrayOutputStream mByteArrayOutputStream1 = new ByteArrayOutputStream();
    ByteArrayOutputStream mByteArrayOutputStream2 = new ByteArrayOutputStream();
    MyThread MyThread1;
    MyThread MyThread2;
    boolean mIsShutdown;
    boolean mIsRoot;
    public CircularFifoBuffer l = new CircularFifoBuffer((int) zanti_command_names.COMMAND_SCAN_VALUE);
    private int m;

    public class BrokenPipeException extends Exception {
        private static final long serialVersionUID = 1;
        private String err;

        public BrokenPipeException(String str) {
            this.err = str;
        }

        public String getMessage() {
            return this.err;
        }
    }

    public static t a(String str, VirtualTerminal virtualTerminal) {
        return a(str, virtualTerminal, null);
    }

    public static synchronized t a(String str, boolean z) {
        t tVar = null;
        synchronized (VirtualTerminal.class) {
            int i = 0;
            while (i < 5) {
                VirtualTerminal virtualTerminal;
                if (z) {
                    try {
                        if (a == null || a.j) {
                            mTerminal1 = new VirtualTerminal(z);
                        }
                        virtualTerminal = a;
                    } catch (IOException e) {
                        e.printStackTrace();
                    } catch (InterruptedException e2) {
                        e2.printStackTrace();
                    }
                } else {
                    if (mTerminal2 == null || mTerminal2.mIsShutdown) {
                        mTerminal2 = new VirtualTerminal(z);
                    }
                    virtualTerminal = mTerminal2;
                }
                tVar = a(str, virtualTerminal, null);
            }
        }
        return tVar;
        i++;
    }

    public static t a(String str, VirtualTerminal virtualTerminal, s sVar) {
        virtualTerminal.m = 0;
        try {
            return mTerminal2(str, virtualTerminal, sVar);
        } catch (Exception e) {
            e.printStackTrace();
            return new t(Integer.valueOf(1), "", e.getLocalizedMessage());
        }
    }

    private static t b(String str, VirtualTerminal virtualTerminal, s sVar) {
        try {
            return virtualTerminal.a(str, sVar);
        } catch (BrokenPipeException e) {
            virtualTerminal.start();
            e.printStackTrace();
            virtualTerminal.m++;
            if (virtualTerminal.m > 5) {
                throw new Exception("Max retries for VirtualTerminal reached!");
            }
            Thread.sleep(500);
            return b(str, virtualTerminal, sVar);
        } catch (Throwable e2) {
            e2.printStackTrace();
            virtualTerminal.b();
            throw new Exception("Error in VirtualTerminal", e2);
        }
    }

    public boolean a() {
        return this.mIsShutdown;
    }

    public VirtualTerminal(boolean z) {
        Process exec;
        this.mIsRoot = z;
        // 若已经root
        if (z) {
            exec = Runtime.getRuntime().exec("su");
        } else {
            exec = Runtime.getRuntime().exec("sh");
        }
        synchronized (this.mObj1) {
            this.mDataOutputStream = new DataOutputStream(exec.getOutputStream());
            this.MyThread1 = new MyThread(this, exec.getInputStream(), this.mByteArrayOutputStream1);
            this.MyThread2 = new MyThread(this, exec.getErrorStream(), this.mByteArrayOutputStream2);
        }
        this.MyThread1.start();
        this.MyThread2.start();
    }

    private void start() {
        Process exec;
        b();
        this.mIsShutdown = false;
        if (this.mIsRoot) {
            exec = Runtime.getRuntime().exec("su");
        } else {
            exec = Runtime.getRuntime().exec("sh");
        }
        synchronized (this.mObj1) {
            this.mDataOutputStream = new DataOutputStream(exec.getOutputStream());
            this.MyThread1 = new MyThread(this, exec.getInputStream(), this.mByteArrayOutputStream1);
            this.MyThread2 = new MyThread(this, exec.getErrorStream(), this.mByteArrayOutputStream2);
        }
        this.MyThread1.start();
        this.MyThread2.start();
    }

    public t a(String str, s sVar) {
        int i = 1;
        if (this.mIsShutdown) {
            return new t(Integer.valueOf(1), "VirtalTerminal was already shutdown.", "VirtalTerminal was already shutdown.");
        }
        StringBuilder stringBuilder = new StringBuilder();
        StringBuilder stringBuilder2 = new StringBuilder();
        Log.i("VTC", str);
        synchronized (this.mObj2) {
            this.mByteArrayOutputStream1.reset();
            this.mByteArrayOutputStream2.reset();
        }
        this.l.add("<font color='#0000bb'>" + str + "</font><br />");
        this.mDataOutputStream.writeBytes(str + "; echo :RET=$?");
        this.mDataOutputStream.writeBytes("\n");
        this.mDataOutputStream.flush();
        while (!this.mIsShutdown) {
            synchronized (this.mObj1) {
                synchronized (this.mObj2) {
                    String str2 = new String(this.f.toByteArray());
                    Log.i("VTR", str2);
                    stringBuilder.append(str2);
                    this.mByteArrayOutputStream1.reset();
                    int i2 = !stringBuilder.toString().contains(":RET=") ? 1 : 0;
                    if (sVar != null) {
                        sVar.a(stringBuilder, stringBuilder2, this.mDataOutputStream);
                    }
                }
                if (i2 != 0) {
                    this.mObj1.wait();
                }
            }
            synchronized (this.mObj2) {
                byte[] toByteArray = this.mByteArrayOutputStream1.toByteArray();
                byte[] toByteArray2 = this.mByteArrayOutputStream2.toByteArray();
                str2 = new String(toByteArray);
                String str3 = new String(toByteArray2);
                Log.i("VTR", str2);
                stringBuilder.append(str2);
                this.mByteArrayOutputStream1.reset();
                stringBuilder2.append(str3);
                this.mByteArrayOutputStream2.reset();
                str3 = stringBuilder.toString();
                String stringBuilder3 = stringBuilder2.toString();
                if (sVar != null) {
                    sVar.a(stringBuilder, stringBuilder2, this.mDataOutputStream);
                }
                if (str3.contains(":RET=")) {
                    if (str3.contains(":RET=EOF") || stringBuilder3.contains(":RET=EOF")) {
                        throw new BrokenPipeException(stringBuilder3);
                    }
                    String substring;
                    if (str3.contains(":RET=0")) {
                        i = 0;
                    } else {
                        Log.i("VTR", stringBuilder3);
                    }
                    int indexOf = str3.indexOf(":RET=");
                    if (indexOf >= 0) {
                        substring = str3.substring(0, indexOf);
                    } else {
                        substring = str3;
                    }
                    a(substring, "#999999");
                    a(stringBuilder3, "#999999");
                    t tVar = new t(Integer.valueOf(i), substring, stringBuilder3);
                    return tVar;
                }
            }
        }
        return new t(Integer.valueOf(-1));
    }

    public void b() {
        this.mIsShutdown = true;
        this.MyThread1.interrupt();
        this.MyThread2.interrupt();
        try {
            this.mDataOutputStream.close();
            this.MyThread1.mTerminal1.close();
            this.MyThread2.a.close();
        } catch (Exception e) {
            e.printStackTrace();
        }
    }

    private void mTerminal1(String str, String str2) {
        for (String str3 : Arrays.asList(str.split("\n"))) {
            this.l.add("<font color='" + str2 + "'>" + str3 + "</font><br />");
        }
    }
}

com.zframework.r

package com.zframework;

import java.io.ByteArrayOutputStream;
import java.io.InputStream;

/* compiled from: VirtualTerminal */
public class MyThread extends Thread {
    InputStream mInputStream;
    ByteArrayOutputStream mOutputStream;
    final /* synthetic */ VirtualTerminal mVirtualTerminal;

    public MyThread(VirtualTerminal virtualTerminal, InputStream inputStream, ByteArrayOutputStream byteArrayOutputStream) {
        this.mVirtualTerminal = virtualTerminal;
        this.mInputStream = inputStream;
        this.mOutputStream = byteArrayOutputStream;
    }

    public void run() {
        try {
            byte[] bArr = new byte[1024];
            while (!this.mVirtualTerminal.j) {
                int read = this.mInputStream.read(bArr);
                if (read < 0) {
                    synchronized (this.mVirtualTerminal.e) {
                        this.mOutputStream.write(":RET=EOF".getBytes());
                    }
                    synchronized (this.mVirtualTerminal.mObj1) {
                        this.mVirtualTerminal.mObj1.notifyAll();
                    }
                    return;
                } else if (read > 0) {
                    synchronized (this.mVirtualTerminal.e) {
                        this.mOutputStream.write(bArr, 0, read);
                    }
                    synchronized (this.mVirtualTerminal.mObj1) {
                        this.mVirtualTerminal.mObj1.notifyAll();
                    }
                }
            }
        } catch (Exception e) {
            e.printStackTrace();
        }
    }
}