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