/**
* Unwatches an event.
*
* @param name event name
* @throws IOException I/O exception
*/
public void unwatch(final String name) throws IOException {
out.write(11);
send(name);
info = receive();
if (!ok()) throw new IOException(info);
notifiers.remove(name);
}
public static void copyStream(InputStream in, OutputStream out) throws IOException {
byte[] data = new byte[BUFFER];
int currentByte;
while ((currentByte = in.read(data, 0, BUFFER)) != -1) {
out.write(data, 0, currentByte);
}
}
String[] getMedkit(
String[] availableResources,
String[] requiredResources,
String[] missions,
double P,
double C) {
try {
Runtime rt = Runtime.getRuntime();
Process proc = rt.exec(exec);
OutputStream os = proc.getOutputStream();
InputStream is = proc.getInputStream();
new ErrorReader(proc.getErrorStream()).start();
StringBuffer sb = new StringBuffer();
append(sb, availableResources);
append(sb, requiredResources);
append(sb, missions);
sb.append(P).append('\n');
sb.append(C).append('\n');
os.write(sb.toString().getBytes());
BufferedReader br = new BufferedReader(new InputStreamReader(is));
int N = Integer.parseInt(br.readLine().trim());
String[] ret = new String[N];
for (int i = 0; i < N; i++) ret[i] = br.readLine().trim();
return ret;
} catch (Exception e) {
System.err.println("An error occurred while executing your program");
e.printStackTrace();
return null;
}
}
void handleRequest(InputStream in, OutputStream out) throws IOException {
boolean newline = false;
StringBuilder sb = new StringBuilder();
while (true) {
int ch = in.read();
if (ch < 0) {
throw new EOFException();
}
sb.append((char) ch);
if (ch == '\r') {
// empty
} else if (ch == '\n') {
if (newline) {
// 2nd newline in a row, end of request
break;
}
newline = true;
} else {
newline = false;
}
}
String request = sb.toString();
if (request.startsWith("GET / HTTP/1.") == false) {
throw new IOException("Invalid request: " + request);
}
out.write("HTTP/1.0 200 OK\r\n\r\n".getBytes());
}
public void run() {
try {
InputStream in;
OutputStream out;
try {
in = sk.getInputStream();
out = sk.getOutputStream();
} catch (IOException e) {
throw (new RuntimeException(e));
}
while (true) {
try {
int len = Utils.int32d(read(in, 4), 0);
if (!auth && (len > 256)) return;
Message msg = new MessageBuf(read(in, len));
String cmd = msg.string();
Object[] args = msg.list();
Object[] reply;
if (auth) {
Command cc = commands.get(cmd);
if (cc != null) reply = cc.run(this, args);
else reply = new Object[] {"nocmd"};
} else {
if (cmd.equals("nonce")) {
reply = new Object[] {nonce};
} else if (cmd.equals("auth")) {
if (Arrays.equals((byte[]) args[0], ckey)) {
reply = new Object[] {"ok"};
auth = true;
} else {
reply = new Object[] {"no"};
}
} else {
return;
}
}
MessageBuf rb = new MessageBuf();
rb.addlist(reply);
byte[] rbuf = new byte[4 + rb.size()];
Utils.uint32e(rb.size(), rbuf, 0);
rb.fin(rbuf, 4);
out.write(rbuf);
} catch (IOException e) {
return;
}
}
} catch (InterruptedException e) {
} finally {
try {
sk.close();
} catch (IOException e) {
throw (new RuntimeException(e));
}
}
}
/**
* Watches an event.
*
* @param name event name
* @param notifier event notification
* @throws IOException I/O exception
*/
public void watch(final String name, final EventNotifier notifier) throws IOException {
out.write(10);
if (esocket == null) {
final int eport = Integer.parseInt(receive());
// initialize event socket
esocket = new Socket();
esocket.connect(new InetSocketAddress(ehost, eport), 5000);
final OutputStream os = esocket.getOutputStream();
receive(in, os);
os.write(0);
os.flush();
final InputStream is = esocket.getInputStream();
is.read();
listen(is);
}
send(name);
info = receive();
if (!ok()) throw new IOException(info);
notifiers.put(name, notifier);
}
/**
* Uses a cipher to transform the bytes in an input stream and sends the transformed bytes to an
* output stream.
*
* @param in the input stream
* @param out the output stream
* @param cipher the cipher that transforms the bytes
*/
public static void crypt(InputStream in, OutputStream out, Cipher cipher)
throws IOException, GeneralSecurityException {
int blockSize = cipher.getBlockSize();
int outputSize = cipher.getOutputSize(blockSize);
byte[] inBytes = new byte[blockSize];
byte[] outBytes = new byte[outputSize];
int inLength = 0;
;
boolean more = true;
while (more) {
inLength = in.read(inBytes);
if (inLength == blockSize) {
int outLength = cipher.update(inBytes, 0, blockSize, outBytes);
out.write(outBytes, 0, outLength);
} else more = false;
}
if (inLength > 0) outBytes = cipher.doFinal(inBytes, 0, inLength);
else outBytes = cipher.doFinal();
out.write(outBytes);
}
void doTest(SSLSocket sslSocket) throws Exception {
InputStream sslIS = sslSocket.getInputStream();
OutputStream sslOS = sslSocket.getOutputStream();
System.out.println(" Writing");
sslOS.write(280);
sslOS.flush();
System.out.println(" Reading");
sslIS.read();
sslSocket.close();
}
private void doManifest(
Jar jar, String[] digestNames, MessageDigest[] algorithms, OutputStream out)
throws Exception {
for (Map.Entry<String, Resource> entry : jar.getResources().entrySet()) {
String name = entry.getKey();
if (!METAINFDIR.matcher(name).matches()) {
out.write("\r\n".getBytes("UTF-8"));
out.write("Name: ".getBytes("UTF-8"));
out.write(name.getBytes("UTF-8"));
out.write("\r\n".getBytes("UTF-8"));
digest(algorithms, entry.getValue());
for (int a = 0; a < algorithms.length; a++) {
if (algorithms[a] != null) {
byte[] digest = algorithms[a].digest();
String header = digestNames[a] + "-Digest: " + new Base64(digest) + "\r\n";
out.write(header.getBytes("UTF-8"));
}
}
}
}
}
void sendRequest(InputStream in, OutputStream out) throws IOException {
out.write("GET / HTTP/1.0\r\n\r\n".getBytes());
out.flush();
StringBuilder sb = new StringBuilder();
while (true) {
int ch = in.read();
if (ch < 0) {
break;
}
sb.append((char) ch);
}
String response = sb.toString();
if (response.startsWith("HTTP/1.0 200 ") == false) {
throw new IOException("Invalid response: " + response);
}
}
@Override
protected void engineSetSeed(byte[] bytes) {
try {
OutputStream out;
synchronized (sLock) {
out = getUrandomOutputStream();
}
out.write(bytes);
out.flush();
} catch (IOException e) {
// On a small fraction of devices /dev/urandom is not writable.
// Log and ignore.
Log.w(PRNGFixes.class.getSimpleName(), "Failed to mix seed into " + URANDOM_FILE);
} finally {
mSeeded = true;
}
}
public void run() {
try {
URL url = new URL(protocol + "://localhost:" + port + "/test1/" + f);
HttpURLConnection urlc = (HttpURLConnection) url.openConnection();
if (urlc instanceof HttpsURLConnection) {
HttpsURLConnection urlcs = (HttpsURLConnection) urlc;
urlcs.setHostnameVerifier(
new HostnameVerifier() {
public boolean verify(String s, SSLSession s1) {
return true;
}
});
urlcs.setSSLSocketFactory(ctx.getSocketFactory());
}
byte[] buf = new byte[4096];
if (fixedLen) {
urlc.setRequestProperty("XFixed", "yes");
}
InputStream is = urlc.getInputStream();
File temp = File.createTempFile("Test1", null);
temp.deleteOnExit();
OutputStream fout = new BufferedOutputStream(new FileOutputStream(temp));
int c, count = 0;
while ((c = is.read(buf)) != -1) {
count += c;
fout.write(buf, 0, c);
}
is.close();
fout.close();
if (count != size) {
throw new RuntimeException("wrong amount of data returned");
}
String orig = root + "/" + f;
compare(new File(orig), temp);
temp.delete();
} catch (Exception e) {
e.printStackTrace();
fail = true;
}
}
/**
* Sends a string to the server.
*
* @param s string to be sent
* @throws IOException I/O exception
*/
void send(final String s) throws IOException {
out.write((s + '\0').getBytes(UTF8));
}
/*
* Define the server side of the test.
*
* If the server prematurely exits, serverReady will be set to true
* to avoid infinite hangs.
*/
void doServerSide() throws Exception {
KeyStore ks = KeyStore.getInstance("JKS");
com.sun.net.ssl.SSLContext ctx = com.sun.net.ssl.SSLContext.getInstance("TLS");
com.sun.net.ssl.KeyManagerFactory kmf =
com.sun.net.ssl.KeyManagerFactory.getInstance("SunX509");
ks.load(new FileInputStream(keyFilename), cpasswd);
kmf.init(ks, cpasswd);
com.sun.net.ssl.TrustManager[] tms =
new com.sun.net.ssl.TrustManager[] {new MyComX509TrustManager()};
ctx.init(kmf.getKeyManagers(), tms, null);
SSLServerSocketFactory sslssf = (SSLServerSocketFactory) ctx.getServerSocketFactory();
SSLServerSocket sslServerSocket = (SSLServerSocket) sslssf.createServerSocket(serverPort);
serverPort = sslServerSocket.getLocalPort();
sslServerSocket.setNeedClientAuth(true);
/*
* Create using the other type.
*/
SSLContext ctx1 = SSLContext.getInstance("TLS");
KeyManagerFactory kmf1 = KeyManagerFactory.getInstance("SunX509");
TrustManager[] tms1 = new TrustManager[] {new MyJavaxX509TrustManager()};
kmf1.init(ks, cpasswd);
ctx1.init(kmf1.getKeyManagers(), tms1, null);
sslssf = (SSLServerSocketFactory) ctx1.getServerSocketFactory();
SSLServerSocket sslServerSocket1 = (SSLServerSocket) sslssf.createServerSocket(serverPort1);
serverPort1 = sslServerSocket1.getLocalPort();
sslServerSocket1.setNeedClientAuth(true);
/*
* Signal Client, we're ready for his connect.
*/
serverReady = true;
SSLSocket sslSocket = (SSLSocket) sslServerSocket.accept();
sslServerSocket.close();
serverReady = false;
InputStream sslIS = sslSocket.getInputStream();
OutputStream sslOS = sslSocket.getOutputStream();
sslIS.read();
sslOS.write(85);
sslOS.flush();
sslSocket.close();
sslSocket = (SSLSocket) sslServerSocket1.accept();
sslIS = sslSocket.getInputStream();
sslOS = sslSocket.getOutputStream();
sslIS.read();
sslOS.write(85);
sslOS.flush();
sslSocket.close();
System.out.println("Server exiting!");
System.out.flush();
}
/**
* Receives a string and writes it to the specified output stream.
*
* @param is input stream
* @param os output stream
* @throws IOException I/O exception
*/
static void receive(final InputStream is, final OutputStream os) throws IOException {
for (int b; (b = is.read()) > 0; ) {
// read next byte if 0xFF is received
os.write(b == 0xFF ? is.read() : b);
}
}
/**
* Sends a command, argument, and input.
*
* @param cmd command
* @param path path to document
* @param input xml input
* @throws IOException I/O exception
*/
private void send(final int cmd, final String path, final InputStream input) throws IOException {
out.write(cmd);
send(path);
send(input);
}
/** Unpacks a resource to a temp. file */
public static File unpackInstaller(String resourceName) {
// Array to hold all results (this code is slightly more
// generally that it needs to be)
File[] results = new File[1];
URL[] urls = new URL[1];
// Determine size of download
ClassLoader cl = Main.class.getClassLoader();
urls[0] = cl.getResource(Config.getInstallerResource());
if (urls[0] == null) {
Config.trace("Could not find resource: " + Config.getInstallerResource());
return null;
}
int totalSize = 0;
int totalRead = 0;
for (int i = 0; i < urls.length; i++) {
if (urls[i] != null) {
try {
URLConnection connection = urls[i].openConnection();
totalSize += connection.getContentLength();
} catch (IOException ioe) {
Config.trace("Got exception: " + ioe);
return null;
}
}
}
// Unpack each file
for (int i = 0; i < urls.length; i++) {
if (urls[i] != null) {
// Create temp. file to store unpacked file in
InputStream in = null;
OutputStream out = null;
try {
// Use extension from URL (important for dll files)
String extension = new File(urls[i].getFile()).getName();
int lastdotidx = (extension != null) ? extension.lastIndexOf('.') : -1;
if (lastdotidx == -1) {
extension = ".dat";
} else {
extension = extension.substring(lastdotidx);
}
// Create output stream
results[i] = File.createTempFile("jre", extension);
results[i].deleteOnExit();
out = new FileOutputStream(results[i]);
// Create inputstream
URLConnection connection = urls[i].openConnection();
in = connection.getInputStream();
int read = 0;
byte[] buf = new byte[BUFFER_SIZE];
while ((read = in.read(buf)) != -1) {
out.write(buf, 0, read);
// Notify delegate
totalRead += read;
if (totalRead > totalSize && totalSize != 0) totalSize = totalRead;
// Update UI
if (totalSize != 0) {
int percent = (100 * totalRead) / totalSize;
setStepText(STEP_UNPACK, Config.getWindowStepProgress(STEP_UNPACK, percent));
}
}
} catch (IOException ie) {
Config.trace("Got exception while downloading resource: " + ie);
for (int j = 0; j < results.length; j++) {
if (results[j] != null) results[j].delete();
}
return null;
} finally {
try {
if (in != null) in.close();
if (out != null) out.close();
} catch (IOException io) {
/* ignore */
}
}
}
}
setStepText(STEP_UNPACK, Config.getWindowStep(STEP_UNPACK));
return results[0];
}