/**
* Start this server. If we manage an own HttpServer, then the HttpServer will be started as well.
*/
public void start() {
// URL as configured takes precedence
String configUrl =
NetworkUtil.replaceExpression(config.getJolokiaConfig().get(ConfigKey.DISCOVERY_AGENT_URL));
jolokiaHttpHandler.start(
lazy, configUrl != null ? configUrl : url, config.getAuthenticator() != null);
if (httpServer != null) {
// Starting our own server in an own thread group with a fixed name
// so that the cleanup thread can recognize it.
ThreadGroup threadGroup = new ThreadGroup("jolokia");
threadGroup.setDaemon(false);
Thread starterThread =
new Thread(
threadGroup,
new Runnable() {
@Override
public void run() {
httpServer.start();
}
});
starterThread.start();
cleaner = new CleanupThread(httpServer, threadGroup);
cleaner.start();
}
}
@Override
/** {@inheritDoc} */
public Thread newThread(Runnable r) {
Thread t = new Thread(r);
t.setDaemon(true);
return t;
}
@Override
public void run() {
try {
preSetup();
while (!shutdown) {
try {
LOGGER.debug("|| waiting for connections...\n");
final Socket socket = serverSocket.accept();
ConnectionHandler ch = new ConnectionHandler(socket);
Thread t = new Thread(ch);
t.start();
} catch (Exception ex) {
LOGGER.debug(ex.getLocalizedMessage(), ex);
}
}
} catch (IOException ex) {
LOGGER.debug(ex.getLocalizedMessage(), ex);
} finally {
try {
if (serverSocket != null) {
serverSocket.close();
serverSocket = null;
}
} catch (IOException e) {
}
LOGGER.info("|| shutdown complete");
}
}
/*
* Primary constructor, used to drive remainder of the test.
*
* Fork off the other side, then do your work.
*/
JavaxHTTPSConnection() throws Exception {
if (separateServerThread) {
startServer(true);
startClient(false);
} else {
startClient(true);
startServer(false);
}
/*
* Wait for other side to close down.
*/
if (separateServerThread) {
serverThread.join();
} else {
clientThread.join();
}
/*
* When we get here, the test is pretty much over.
*
* If the main thread excepted, that propagates back
* immediately. If the other thread threw an exception, we
* should report back.
*/
if (serverException != null) {
System.out.print("Server Exception:");
throw serverException;
}
if (clientException != null) {
System.out.print("Client Exception:");
throw clientException;
}
}
public SSLResult fingerprint() throws IOException, FingerprintError {
SSLConfigCollector scc;
scc = new SSLConfigCollector(host, port, si);
scc.setCertValidator(cv);
startDate = new Date();
sslSupport = SSLResult.UNKNOWN;
// If a delay is set, wait some time, except for
// the first request
if (!initial && (delay > 0)) {
if (Debug.get(Debug.Delay)) {
System.err.println("Delaying request.");
}
try {
Thread.sleep(delay);
} catch (InterruptedException e) {
Thread.currentThread().interrupt();
}
}
initial = false;
try {
scc.probe();
sslSupport = SSLResult.SUPPORTED;
sslSupportReason = null;
} catch (NoSSLException e) {
// This exception is thrown when the protocol support
// for ssl is not available
sslSupport = SSLResult.UNSUPPORTED;
sslSupportReason = e.toString();
} catch (FingerprintException e) {
sslSupport = SSLResult.UNSUPPORTED;
sslSupportReason = e.toString();
} catch (IOException e) {
sslSupport = SSLResult.UNKNOWN;
sslSupportReason = e.toString();
}
endDate = new Date();
protos = scc.getSupportedProtos();
ProbeResult pres =
new ProbeResult(
host,
port,
startDate,
endDate,
sslSupport,
sslSupportReason,
scc.getServerCertificates(),
scc.serverCertificateVerifies(),
scc.serverCertNameMatch());
pres.setProtosResult(protos);
return pres;
}
void startServer(boolean newThread) throws Exception {
if (newThread) {
serverThread =
new Thread() {
public void run() {
try {
doServerSide();
} catch (Exception e) {
/*
* Our server thread just died.
*
* Release the client, if not active already...
*/
System.err.println("Server died...");
System.err.println(e);
serverReady = true;
serverException = e;
}
}
};
serverThread.start();
} else {
doServerSide();
}
}
/*
* Define the client side of the test.
*
* If the server prematurely exits, serverReady will be set to true
* to avoid infinite hangs.
*/
void doClientSide() throws Exception {
/*
* Wait for server to get started.
*/
while (!serverReady) {
Thread.sleep(50);
}
SSLSocketFactory sslsf = (SSLSocketFactory) SSLSocketFactory.getDefault();
SSLSocket sslSocket = (SSLSocket) sslsf.createSocket("localhost", serverPort);
InputStream sslIS = sslSocket.getInputStream();
OutputStream sslOS = sslSocket.getOutputStream();
for (int i = 0; i < 10; i++) {
sslOS.write(280);
sslOS.flush();
sslIS.read();
}
for (int i = 0; i < 10; i++) {
sslOS.write(280);
sslOS.flush();
sslIS.read();
}
sslSocket.close();
}
/*
* Define the client side of the test.
*
* If the server prematurely exits, serverReady will be set to true
* to avoid infinite hangs.
*/
void doClientSide() throws Exception {
/*
* Wait for server to get started.
*/
while (!serverReady) {
Thread.sleep(50);
}
// Send HTTP POST request to server
URL url = new URL("https://localhost:" + serverPort);
HttpsURLConnection.setDefaultHostnameVerifier(new NameVerifier());
HttpsURLConnection http = (HttpsURLConnection) url.openConnection();
http.setDoOutput(true);
http.setRequestMethod("POST");
PrintStream ps = new PrintStream(http.getOutputStream());
try {
ps.println(postMsg);
ps.flush();
if (http.getResponseCode() != 200) {
throw new RuntimeException("test Failed");
}
} finally {
ps.close();
http.disconnect();
closeReady = true;
}
}
/*
* Define the client side of the test.
*
* If the server prematurely exits, serverReady will be set to true
* to avoid infinite hangs.
*/
void doClientSide() throws Exception {
// create SSLEngine.
SSLEngine ssle = createSSLEngine(true);
/*
* Wait for server to get started.
*/
while (!serverReady) {
Thread.sleep(50);
}
// Create a non-blocking socket channel.
SocketChannel sc = SocketChannel.open();
sc.configureBlocking(false);
InetSocketAddress isa = new InetSocketAddress(InetAddress.getLocalHost(), serverPort);
sc.connect(isa);
// Complete connection.
while (!sc.finishConnect()) {
// waiting for the connection completed.
}
// handshaking
handshaking(ssle, sc, null);
// send out application data
deliver(ssle, sc);
// receive application data
receive(ssle, sc);
// close the socket channel.
sc.close();
}
/*
* Primary constructor, used to drive remainder of the test.
*
* Fork off the other side, then do your work.
*/
InvalidateServerSessionRenegotiate() throws Exception {
if (separateServerThread) {
startServer(true);
startClient(false);
} else {
startClient(true);
startServer(false);
}
/*
* Wait for other side to close down.
*/
if (separateServerThread) {
serverThread.join();
} else {
clientThread.join();
}
/*
* When we get here, the test is pretty much over.
*
* If the main thread excepted, that propagates back
* immediately. If the other thread threw an exception, we
* should report back.
*/
if (serverException != null) {
System.out.print("Server Exception:");
throw serverException;
}
if (clientException != null) {
System.out.print("Client Exception:");
throw clientException;
}
/*
* Give the Handshaker Thread a chance to run
*/
Thread.sleep(1000);
synchronized (this) {
if (handshakesCompleted != 2) {
throw new Exception("Didn't see 2 handshake completed events.");
}
}
}
void requestAccountList() {
prog =
ProgressDialog.show(
this,
null,
getString(R.string.account_list_progress),
false,
true,
new DialogInterface.OnCancelListener() {
public void onCancel(DialogInterface dialog) {
cancel();
}
});
queryThread = new Thread(this, "Requestor Thread");
queryThread.setDaemon(true);
queryThread.start();
}
public static void main(PeerFactory peerFactory, KeyStore keyStore, String[] args)
throws Exception {
long time = System.currentTimeMillis();
String relPath;
if ((args != null) && (args.length > 0) && args[0].equals("sh")) {
relPath = pathToStoresSH;
} else {
relPath = pathToStores;
}
PATH = new File(System.getProperty("test.src", "."), relPath);
CipherTest.peerFactory = peerFactory;
System.out.print("Initializing test '" + peerFactory.getName() + "'...");
// secureRandom = new SecureRandom();
// secureRandom.nextInt();
// trustStore = readKeyStore(trustStoreFile);
CipherTest.keyStore = keyStore;
// keyStore = readKeyStore(keyStoreFile);
KeyManagerFactory keyFactory =
KeyManagerFactory.getInstance(KeyManagerFactory.getDefaultAlgorithm());
keyFactory.init(keyStore, "test12".toCharArray());
keyManager = (X509ExtendedKeyManager) keyFactory.getKeyManagers()[0];
TrustManagerFactory tmf =
TrustManagerFactory.getInstance(TrustManagerFactory.getDefaultAlgorithm());
tmf.init(keyStore);
trustManager = (X509TrustManager) tmf.getTrustManagers()[0];
// trustManager = new AlwaysTrustManager();
SSLContext context = SSLContext.getInstance("TLS");
context.init(new KeyManager[] {keyManager}, new TrustManager[] {trustManager}, null);
SSLContext.setDefault(context);
CipherTest cipherTest = new CipherTest(peerFactory);
Thread serverThread = new Thread(peerFactory.newServer(cipherTest), "Server");
serverThread.setDaemon(true);
serverThread.start();
System.out.println("Done");
cipherTest.run();
time = System.currentTimeMillis() - time;
System.out.println("Done. (" + time + " ms)");
}
/*
* Define the client side of the test.
*
* If the server prematurely exits, serverReady will be set to true
* to avoid infinite hangs.
*/
void doClientSide() throws Exception {
/*
* Wait for server to get started.
*/
while (!serverReady) {
Thread.sleep(50);
}
/*
* See if an unknown keystore actually gets checked ok.
*/
System.out.println("==============");
System.out.println("Starting test0");
KeyStore uks = KeyStore.getInstance("JKS");
SSLContext ctx = SSLContext.getInstance("TLS");
KeyManagerFactory kmf = KeyManagerFactory.getInstance("SunX509");
uks.load(new FileInputStream(unknownFilename), cpasswd);
kmf.init(uks, cpasswd);
TrustManager[] tms = new TrustManager[] {new MyJavaxX509TrustManager()};
ctx.init(kmf.getKeyManagers(), tms, null);
SSLSocketFactory sslsf = (SSLSocketFactory) ctx.getSocketFactory();
System.out.println("Trying first socket " + serverPort);
SSLSocket sslSocket = (SSLSocket) sslsf.createSocket("localhost", serverPort);
doTest(sslSocket);
/*
* Now try the other way.
*/
com.sun.net.ssl.SSLContext ctx1 = com.sun.net.ssl.SSLContext.getInstance("TLS");
com.sun.net.ssl.KeyManagerFactory kmf1 =
com.sun.net.ssl.KeyManagerFactory.getInstance("SunX509");
kmf1.init(uks, cpasswd);
com.sun.net.ssl.TrustManager[] tms1 =
new com.sun.net.ssl.TrustManager[] {new MyComX509TrustManager()};
ctx1.init(kmf1.getKeyManagers(), tms1, null);
sslsf = (SSLSocketFactory) ctx1.getSocketFactory();
System.out.println("Trying second socket " + serverPort1);
sslSocket = (SSLSocket) sslsf.createSocket("localhost", serverPort1);
doTest(sslSocket);
System.out.println("Completed test1");
}
public static void main(String[] args) throws Exception {
if (args.length == 5 && args[4].equalsIgnoreCase("BC")) {
Security.removeProvider("SunPKCS11-NSS");
Security.removeProvider("SunEC");
Security.insertProviderAt(new BouncyCastleProvider(), 1);
System.out.println("Using BC provider");
}
for (Provider p : Security.getProviders()) {
System.out.println(p);
}
System.setProperty("java.security.debug", "ssl");
String path;
String password;
String protocol;
int port;
if (args.length == 4 || args.length == 5) {
path = args[0];
password = args[1];
protocol = args[2];
port = Integer.parseInt(args[3]);
} else if (args.length == 0) {
path = PATH_TO_JKS;
password = JKS_PASSWORD;
protocol = PROTOCOL;
port = PORT;
} else {
System.out.println(
"Usage (run with): java -jar [name].jar [jks-path] "
+ "[password] [protocol] [port] \n (set [protocol] to TLS)");
return;
}
KeyStore keyStore = readKeyStore(path, password);
TLSServer server = new TLSServer(keyStore, password, protocol, port);
Thread t = new Thread(server);
t.start();
}
private static TrustManager[] createTrustManagers() throws GeneralSecurityException, IOException {
InputStream keyStoreStream =
Thread.currentThread().getContextClassLoader().getResourceAsStream("ssltest-keystore.jks");
char[] keyStorePassword = "******".toCharArray();
KeyStore ks = KeyStore.getInstance("JKS");
ks.load(keyStoreStream, keyStorePassword);
assert (ks.size() > 0);
TrustManagerFactory tmf =
TrustManagerFactory.getInstance(TrustManagerFactory.getDefaultAlgorithm());
tmf.init(ks);
return tmf.getTrustManagers();
}
private static KeyManager[] createKeyManagers() throws GeneralSecurityException, IOException {
InputStream keyStoreStream =
Thread.currentThread().getContextClassLoader().getResourceAsStream("ssltest-cacerts.jks");
char[] keyStorePassword = "******".toCharArray();
KeyStore ks = KeyStore.getInstance("JKS");
ks.load(keyStoreStream, keyStorePassword);
assert (ks.size() > 0);
// Set up key manager factory to use our key store
char[] certificatePassword = "******".toCharArray();
KeyManagerFactory kmf = KeyManagerFactory.getInstance("SunX509");
kmf.init(ks, certificatePassword);
// Initialize the SSLContext to work with our key managers.
return kmf.getKeyManagers();
}
public static File getClasspathFile(String file) throws FileNotFoundException {
ClassLoader cl = null;
try {
cl = Thread.currentThread().getContextClassLoader();
} catch (Throwable ex) {
}
if (cl == null) {
cl = TestUtils.class.getClassLoader();
}
URL resourceUrl = cl.getResource(file);
try {
return new File(new URI(resourceUrl.toString()).getSchemeSpecificPart());
} catch (URISyntaxException e) {
throw new FileNotFoundException(file);
}
}
void startClient(boolean newThread) throws Exception {
if (newThread) {
clientThread =
new Thread() {
public void run() {
try {
doClientSide();
} catch (Exception e) {
/*
* Our client thread just died.
*/
System.err.println("Client died...");
clientException = e;
}
}
};
clientThread.start();
} else {
doClientSide();
}
}
/*
* 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 {
SSLServerSocketFactory sslssf = (SSLServerSocketFactory) SSLServerSocketFactory.getDefault();
SSLServerSocket sslServerSocket = (SSLServerSocket) sslssf.createServerSocket(serverPort);
serverPort = sslServerSocket.getLocalPort();
/*
* Signal Client, we're ready for his connect.
*/
serverReady = true;
SSLSocket sslSocket = (SSLSocket) sslServerSocket.accept();
try {
InputStream sslIS = sslSocket.getInputStream();
OutputStream sslOS = sslSocket.getOutputStream();
BufferedReader br = new BufferedReader(new InputStreamReader(sslIS));
PrintStream ps = new PrintStream(sslOS);
// process HTTP POST request from client
System.out.println("status line: " + br.readLine());
String msg = null;
while ((msg = br.readLine()) != null && msg.length() > 0) ;
msg = br.readLine();
if (msg.equals(postMsg)) {
ps.println("HTTP/1.1 200 OK\n\n");
} else {
ps.println("HTTP/1.1 500 Not OK\n\n");
}
ps.flush();
// close the socket
while (!closeReady) {
Thread.sleep(50);
}
} finally {
sslSocket.close();
sslServerSocket.close();
}
}
/*
* Define the client side of the test.
*
* If the server prematurely exits, serverReady will be set to true
* to avoid infinite hangs.
*/
void doClientSide() throws Exception {
/*
* Wait for server to get started.
*/
while (!serverReady) {
Thread.sleep(50);
}
System.setProperty("java.protocol.handler.pkgs", "com.sun.net.ssl.internal.www.protocol");
HttpsURLConnection.setDefaultHostnameVerifier(new NameVerifier());
URL url = new URL("https://" + "localhost:" + serverPort + "/etc/hosts");
URLConnection urlc = url.openConnection();
if (!(urlc instanceof com.sun.net.ssl.HttpsURLConnection)) {
throw new Exception("URLConnection ! instanceof " + "com.sun.net.ssl.HttpsURLConnection");
}
BufferedReader in = null;
try {
in = new BufferedReader(new InputStreamReader(urlc.getInputStream()));
String inputLine;
System.out.print("Client reading... ");
while ((inputLine = in.readLine()) != null) System.out.println(inputLine);
System.out.println("Cipher Suite: " + ((HttpsURLConnection) urlc).getCipherSuite());
X509Certificate[] certs = ((HttpsURLConnection) urlc).getServerCertificateChain();
for (int i = 0; i < certs.length; i++) {
System.out.println(certs[0]);
}
in.close();
} catch (SSLException e) {
if (in != null) in.close();
throw e;
}
System.out.println("Client reports: SUCCESS");
}
private void handshake() throws IOException {
if (handshakeCompleted) {
return;
}
if (DEBUG) {
log("Starting handshake...");
}
synchronized (this) {
if (handshakeCompleted) {
if (DEBUG) {
log("Handshake already completed...");
}
return;
}
int counter = 0;
if (DEBUG) {
log("Begin handshake");
}
sslEngine.beginHandshake();
writeInternal(emptyBuffer);
while (counter++ < 250
&& sslEngineResult.getHandshakeStatus() != SSLEngineResult.HandshakeStatus.FINISHED) {
if (DEBUG) {
log("Handshake status: " + sslEngineResult.getHandshakeStatus());
}
if (sslEngineResult.getHandshakeStatus() == SSLEngineResult.HandshakeStatus.NEED_UNWRAP) {
if (DEBUG) {
log("Begin UNWRAP");
}
netInBuffer.clear();
while (socketChannel.read(netInBuffer) < 1) {
try {
if (DEBUG) {
log("Spinning on channel read...");
}
Thread.sleep(50);
} catch (InterruptedException e) {
throw new IOException(e);
}
}
netInBuffer.flip();
unwrap(netInBuffer);
if (DEBUG) {
log("Done UNWRAP: " + sslEngineResult.getHandshakeStatus());
}
if (sslEngineResult.getHandshakeStatus() != SSLEngineResult.HandshakeStatus.FINISHED) {
emptyBuffer.clear();
writeInternal(emptyBuffer);
if (DEBUG) {
log("Done WRAP after UNWRAP: " + sslEngineResult.getHandshakeStatus());
}
}
} else if (sslEngineResult.getHandshakeStatus()
== SSLEngineResult.HandshakeStatus.NEED_WRAP) {
if (DEBUG) {
log("Begin WRAP");
}
emptyBuffer.clear();
writeInternal(emptyBuffer);
if (DEBUG) {
log("Done WRAP: " + sslEngineResult.getHandshakeStatus());
}
} else {
try {
if (DEBUG) {
log("Sleeping... Status: " + sslEngineResult.getHandshakeStatus());
}
Thread.sleep(500);
} catch (InterruptedException e) {
throw new IOException(e);
}
}
}
if (sslEngineResult.getHandshakeStatus() != SSLEngineResult.HandshakeStatus.FINISHED) {
throw new SSLHandshakeException(
"SSL handshake failed after "
+ counter
+ " trials! -> "
+ sslEngineResult.getHandshakeStatus());
}
if (DEBUG) {
log("Handshake completed!");
}
in.clear();
in.flip();
handshakeCompleted = true;
}
}
public Thread newThread(Runnable r) {
Thread t = DEFAULT.newThread(r);
t.setDaemon(true);
return t;
}
@Override
public void run() {
_init();
Thread thread = Thread.currentThread();
thread.setName("ExcellerisController" + "[" + thread.getId() + "]");
logger.debug("Running [" + thread.getName() + "]");
Node rootTag = null;
String messageCount = null;
String messageFormat = null;
String messageVersion = null;
// NamedNodeMap nodemap = null;
// Document response = null;
// Node code = null;
String ackReturnCode = null;
setLastFileCount(0);
if (hostLogin()) {
try {
// fetch data
logger.info("Fetching Excelleris labs from " + FETCH);
getLabConnection().fetch(FETCH);
} catch (SocketTimeoutException e) {
handleError(
"Connection timeout occured while attempting to fetch lab files. Check internet connectivity. ",
e,
ERROR);
} catch (IOException e) {
handleError("Expedius has failed to fetch lab files. Contact support. ", e, ERROR);
} /*catch (ParserConfigurationException e) {
handleError("There was a problem with parsing the server response while fetching lab files.", e, ERROR);
} */ finally {
// for maintenance.
close();
}
// save data
if (getLabConnection().getResponseCode() == HttpsURLConnection.HTTP_OK) {
if (getLabConnection().hasResponse()) {
rootTag = getDocumentHandler().getRoot();
if (NODE_HL7MESSAGES.equalsIgnoreCase(rootTag.getNodeName())) {
messageCount = getDocumentHandler().getNodeAttributeValue(NODE_MESSAGECOUNT, rootTag);
messageFormat = getDocumentHandler().getNodeAttributeValue(NODE_MESSAGEFORMAT, rootTag);
messageVersion = getDocumentHandler().getNodeAttributeValue(NODE_VERSION, rootTag);
logger.info(NODE_MESSAGECOUNT + ": " + messageCount);
logger.info(NODE_MESSAGEFORMAT + ": " + messageFormat);
logger.info(NODE_VERSION + ": " + messageVersion);
}
}
if (getLastFileCount() > 0) {
getLabHandler().setLabType(EXCELLERIS_LAB_TYPE);
super.processResults(getDocumentHandler().getDocument(), labType);
}
}
// response = getLabConnection().getResponse();
// rootTag = response.getDocumentElement();
//
// if(rootTag.getNodeName().equalsIgnoreCase(NODE_HL7MESSAGES)) {
//
// nodemap = rootTag.getAttributes();
//
// if(nodemap.getLength() > 0) {
//
// messageCount = nodemap.getNamedItem(NODE_MESSAGECOUNT).getNodeValue();
// messageFormat = nodemap.getNamedItem(NODE_MESSAGEFORMAT).getNodeValue();
// messageVersion = nodemap.getNamedItem(NODE_VERSION).getNodeValue();
//
// logger.info(NODE_MESSAGECOUNT + ": " + messageCount);
// logger.info(NODE_MESSAGEFORMAT + ": " + messageFormat);
// logger.info(NODE_VERSION + ": " + messageVersion);
//
// if(messageCount != null) {
// setLastFileCount(Integer.parseInt(messageCount));
// logger.info( messageCount + " Excelleris labs downloaded");
// }
//
// }
//
// } else {
// logger.error("Error: No, or incorrect, content from server. Root Tag:
// "+rootTag.toString());
// }
// }
// }
// CAUTION - disable acknowledge for testing. You will loose all your test labs.
if ((ACKNOWLEDGE_DOWNLOADS.equalsIgnoreCase("true"))
&& (getLabHandler().getResponseCode() == HttpsURLConnection.HTTP_OK)) {
try {
getLabConnection().acknowledge(ACKNOWLEDGE);
} catch (SocketTimeoutException e) {
handleError(
"Connection timeout occured while attempting to fetch lab files. Check internet connectivity. ",
e,
ERROR);
} catch (IOException e) {
handleError("Expedius has failed to fetch lab files. Contact support. ", e, ERROR);
}
if (getLabConnection().hasResponse()) {
ackReturnCode =
getDocumentHandler()
.getNodeAttributeValue(NODE_RETURNCODE, getDocumentHandler().getRoot());
if (ACK_RETURN_CODE.equalsIgnoreCase(ackReturnCode)) {
logger.info("All Labs Acknowledged: " + ackReturnCode);
} else {
handleError(
"Expedius has failed to acknowledge the last lab download. "
+ "This could result in multiple copies of the same lab. Excelleris server acknowledge return code was "
+ ackReturnCode
+ "If this error does not resolve in 24 hours, contact support.",
null,
DISMISSABLE_ERROR);
}
}
}
//
// rootTag = getLabConnection().getResponse().getDocumentElement();
// nodemap = rootTag.getAttributes();
//
// if(nodemap.getLength() > 0) {
//
// code = nodemap.getNamedItem(NODE_RETURNCODE);
//
// if(Integer.parseInt(code.getNodeValue().toString()) == 0) {
//
// } else {
// logger.error(rootTag.toString() + " Invalid response code");
// }
//
// } else {
//
// }
// }
//
// } else {
//
// }
//
// } else {
// logger.info("Acknowledge not enabled. This lab file will be downloaded again.");
// }
// catch all server response codes.
processServerResponse(getLabConnection().getResponseCode());
// } catch (SocketTimeoutException e) {
// handleError("Connection timeout occured while attempting to fetch lab files. Check
// internet connectivity. ", e, ERROR);
// } catch (IOException e) {
// handleError("Expedius has failed to fetch lab files. Contact support. ", e, ERROR);
// } catch (ParserConfigurationException e) {
// handleError("There was a problem with parsing the server response while fetching lab
// files.", e, ERROR);
// } finally {
// close();
// }
}
}
public void runSupport() {
try {
new URL(url_str); // determine if this is already a proper URL
} catch (Throwable t) { // it's not
// //check if the string is just a base32/hex-encoded torrent infohash
//
// String magnet_uri = UrlUtils.normaliseMagnetURI( url_str );
//
// if ( magnet_uri != null ){
//
// url_str = magnet_uri;
// }
}
try {
url = AddressUtils.adjustURL(new URL(url_str));
String protocol = url.getProtocol().toLowerCase();
// hack here - the magnet download process requires an additional paramter to cause it to
// stall on error so the error can be reported
// if ( protocol.equals( "magnet" ) || protocol.equals( "dht" )){
//
// url = AddressUtils.adjustURL( new URL(url_str+"&pause_on_error=true"));
// }
for (int i = 0; i < 2; i++) {
try {
// if ( protocol.equals("https")){
//
// // see ConfigurationChecker for SSL client defaults
//
// HttpsURLConnection ssl_con = (HttpsURLConnection)url.openConnection();
//
// // allow for certs that contain IP addresses rather than dns names
//
// ssl_con.setHostnameVerifier(
// new HostnameVerifier()
// {
// public boolean
// verify(
// String host,
// SSLSession session )
// {
// return( true );
// }
// });
//
// con = ssl_con;
//
// }else{
//
con = (HttpURLConnection) url.openConnection();
// }
con.setRequestProperty(
"User-Agent", Constants.AZUREUS_NAME + " " + Constants.AZUREUS_VERSION);
if (referrer != null && referrer.length() > 0) {
con.setRequestProperty("Referer", referrer);
}
if (request_properties != null) {
Iterator it = request_properties.entrySet().iterator();
while (it.hasNext()) {
Map.Entry entry = (Map.Entry) it.next();
String key = (String) entry.getKey();
String value = (String) entry.getValue();
// currently this code doesn't support gzip/deflate...
if (!key.equalsIgnoreCase("Accept-Encoding")) {
con.setRequestProperty(key, value);
}
}
}
this.con.connect();
break;
// }catch( SSLException e ){
//
// if ( i == 0 ){
//
// if ( SESecurityManager.installServerCertificates( url ) != null ){
//
// // certificate has been installed
//
// continue; // retry with new certificate
// }
// }
//
// throw( e );
//
} catch (IOException e) {
if (i == 0) {
URL retry_url = UrlUtils.getIPV4Fallback(url);
if (retry_url != null) {
url = retry_url;
} else {
throw (e);
}
}
}
}
int response = this.con.getResponseCode();
if (!ignoreReponseCode) {
if ((response != HttpURLConnection.HTTP_ACCEPTED)
&& (response != HttpURLConnection.HTTP_OK)) {
this.error(response, Integer.toString(response) + ": " + this.con.getResponseMessage());
return;
}
}
/*
Map headerFields = this.con.getHeaderFields();
System.out.println("Header of download of " + url_str);
for (Iterator iter = headerFields.keySet().iterator(); iter.hasNext();) {
String s = (String) iter.next();
System.out.println(s + ":" + headerFields.get(s));
}
*/
filename = this.con.getHeaderField("Content-Disposition");
if ((filename != null)
&& filename
.toLowerCase()
.matches(".*attachment.*")) // Some code to handle b0rked servers.
while (filename.toLowerCase().charAt(0) != 'a') filename = filename.substring(1);
if ((filename == null)
|| !filename.toLowerCase().startsWith("attachment")
|| (filename.indexOf('=') == -1)) {
String tmp = this.url.getFile();
if (tmp.length() == 0 || tmp.equals("/")) {
filename = url.getHost();
} else if (tmp.startsWith("?")) {
// probably a magnet URI - use the hash
// magnet:?xt=urn:sha1:VGC53ZWCUXUWVGX7LQPVZIYF4L6RXSU6
String query = tmp.toUpperCase();
int pos = query.indexOf("XT=URN:SHA1:");
if (pos == -1) {
pos = query.indexOf("XT=URN:BTIH:");
}
if (pos != -1) {
pos += 12;
int p2 = query.indexOf("&", pos);
if (p2 == -1) {
filename = query.substring(pos);
} else {
filename = query.substring(pos, p2);
}
} else {
filename = "Torrent" + (long) (Math.random() * Long.MAX_VALUE);
}
filename += ".tmp";
} else {
if (tmp.lastIndexOf('/') != -1) tmp = tmp.substring(tmp.lastIndexOf('/') + 1);
// remove any params in the url
int param_pos = tmp.indexOf('?');
if (param_pos != -1) {
tmp = tmp.substring(0, param_pos);
}
filename = URLDecoder.decode(tmp, Constants.DEFAULT_ENCODING);
}
} else {
filename = filename.substring(filename.indexOf('=') + 1);
if (filename.startsWith("\"") && filename.endsWith("\""))
filename = filename.substring(1, filename.lastIndexOf('\"'));
filename = URLDecoder.decode(filename, Constants.DEFAULT_ENCODING);
// not sure of this piece of logic here but I'm not changing it at the moment
File temp = new File(filename);
filename = temp.getName();
}
filename = FileUtil.convertOSSpecificChars(filename, false);
// directoryname =
// COConfigurationManager.getDirectoryParameter("General_sDefaultTorrent_Directory");
// boolean useTorrentSave = COConfigurationManager.getBooleanParameter("Save Torrent
// Files");
directoryname = "D:\\Development\\testDownloads\\";
boolean useTorrentSave = true;
if (file_str != null) {
// not completely sure about the whole logic in this block
File temp = new File(file_str);
// if we're not using a default torrent save dir
if (!useTorrentSave || directoryname.length() == 0) {
// if it's already a dir
if (temp.isDirectory()) {
// use it
directoryname = temp.getCanonicalPath();
}
// it's a file
else {
// so use its parent dir
directoryname = temp.getCanonicalFile().getParent();
}
}
// if it's a file
if (!temp.isDirectory()) {
// set the file name
filename = temp.getName();
}
}
// what would happen here if directoryname == null and file_str == null??
this.state = STATE_INIT;
this.notifyListener();
} catch (java.net.MalformedURLException e) {
this.error(0, "Exception while parsing URL '" + url + "':" + e.getMessage());
} catch (java.net.UnknownHostException e) {
this.error(
0,
"Exception while initializing download of '"
+ url
+ "': Unknown Host '"
+ e.getMessage()
+ "'");
} catch (java.io.IOException ioe) {
this.error(0, "I/O Exception while initializing download of '" + url + "':" + ioe.toString());
} catch (Throwable e) {
this.error(0, "Exception while initializing download of '" + url + "':" + e.toString());
}
if (this.state == STATE_ERROR) {
return;
}
try {
final boolean status_reader_run[] = {true};
this.state = STATE_START;
notifyListener();
this.state = STATE_DOWNLOADING;
notifyListener();
Thread status_reader =
new AEThread("TorrentDownloader:statusreader") {
public void runSupport() {
boolean changed_status = false;
while (true) {
try {
Thread.sleep(100);
try {
this_mon.enter();
if (!status_reader_run[0]) {
break;
}
} finally {
this_mon.exit();
}
String s = con.getResponseMessage();
if (!s.equals(getStatus())) {
if (!s.toLowerCase().startsWith("error:")) {
if (s.toLowerCase().indexOf("alive") != -1) {
if (percentDone < 10) {
percentDone++;
}
}
int pos = s.indexOf('%');
if (pos != -1) {
int i;
for (i = pos - 1; i >= 0; i--) {
char c = s.charAt(i);
if (!Character.isDigit(c) && c != ' ') {
i++;
break;
}
}
try {
percentDone = Integer.parseInt(s.substring(i, pos).trim());
} catch (Throwable e) {
}
}
setStatus(s);
} else {
error(con.getResponseCode(), s.substring(6));
}
changed_status = true;
}
} catch (Throwable e) {
break;
}
}
if (changed_status) {
setStatus("");
}
}
};
status_reader.setDaemon(true);
status_reader.start();
InputStream in;
try {
in = this.con.getInputStream();
} catch (FileNotFoundException e) {
if (ignoreReponseCode) {
in = this.con.getErrorStream();
} else {
throw e;
}
} finally {
try {
this_mon.enter();
status_reader_run[0] = false;
} finally {
this_mon.exit();
}
}
// handle some servers that return gzip'd torrents even though we don't request it!
String encoding = con.getHeaderField("content-encoding");
if (encoding != null) {
if (encoding.equalsIgnoreCase("gzip")) {
in = new GZIPInputStream(in);
} else if (encoding.equalsIgnoreCase("deflate")) {
in = new InflaterInputStream(in);
}
}
if (this.state != STATE_ERROR) {
this.file = new File(this.directoryname, filename);
boolean useTempFile = false;
try {
this.file.createNewFile();
useTempFile = !this.file.exists();
} catch (Throwable t) {
useTempFile = true;
}
if (useTempFile) {
this.file = File.createTempFile("AZU", ".torrent", new File(this.directoryname));
this.file.createNewFile();
}
FileOutputStream fileout = new FileOutputStream(this.file, false);
bufBytes = 0;
int size = (int) UrlUtils.getContentLength(con);
this.percentDone = -1;
do {
if (this.cancel) {
break;
}
try {
bufBytes = in.read(buf);
this.readTotal += bufBytes;
if (size != 0) {
this.percentDone = (100 * this.readTotal) / size;
}
notifyListener();
} catch (IOException e) {
}
if (bufBytes > 0) {
fileout.write(buf, 0, bufBytes);
}
} while (bufBytes > 0);
in.close();
fileout.flush();
fileout.close();
if (this.cancel) {
this.state = STATE_CANCELLED;
if (deleteFileOnCancel) {
this.cleanUpFile();
}
} else {
if (this.readTotal <= 0) {
this.error(0, "No data contained in '" + this.url.toString() + "'");
return;
}
// if the file has come down with a not-so-useful name then we try to rename
// it to something more useful
try {
if (!filename.toLowerCase().endsWith(".torrent")) {
TOTorrent torrent = TorrentUtils.readFromFile(file, false);
String name = TorrentUtils.getLocalisedName(torrent) + ".torrent";
File new_file = new File(directoryname, name);
if (file.renameTo(new_file)) {
filename = name;
file = new_file;
}
}
} catch (Throwable e) {
Debug.printStackTrace(e);
}
// TorrentUtils.setObtainedFrom( file, original_url );
this.state = STATE_FINISHED;
}
this.notifyListener();
}
} catch (Exception e) {
if (!cancel) {
Debug.out("'" + this.directoryname + "' '" + filename + "'", e);
}
this.error(0, "Exception while downloading '" + this.url.toString() + "':" + e.getMessage());
}
}
public static StackTraceElement getCallerStackTraceElement() {
return Thread.currentThread().getStackTrace()[4];
}