/**
* Process connection response data.
*
* @param conn connection to read response data from.
* @return assembled response as string.
* @throws IOException on I/O error
*/
private StringBuilder readResponse(URLConnection conn) throws IOException {
StringBuilder retval = new StringBuilder();
HttpURLConnection http = (HttpURLConnection) conn;
int resp = 200;
try {
resp = http.getResponseCode();
} catch (Throwable ex) {
}
if (resp >= 200 && resp < 300) {
BufferedReader input = null;
try {
input = new BufferedReader(new InputStreamReader(conn.getInputStream()));
} catch (Throwable ex) {
retval.append(ex.toString());
return retval;
}
String line = null;
while ((line = input.readLine()) != null) {
retval.append(line);
retval.append("\n");
}
input.close();
} else {
retval.append(http.getResponseMessage());
}
LogContext.getLogger().finer(String.format("<-- HTTP Response: %d: %s", resp, retval));
return retval;
}
/**
* Processes a packet read from either the multicast or unicast socket. Needs to be synchronized
* because mcast or unicast socket reads can be concurrent
*/
void handleIncomingUdpPacket(byte[] data) {
ByteArrayInputStream inp_stream;
ObjectInputStream inp;
Message msg = null;
List l; // used if bundling is enabled
try {
// skip the first n bytes (default: 4), this is the version info
inp_stream = new ByteArrayInputStream(data, VERSION_LENGTH, data.length - VERSION_LENGTH);
inp = new ObjectInputStream(inp_stream);
if (enable_bundling) {
l = new List();
l.readExternal(inp);
for (Enumeration en = l.elements(); en.hasMoreElements(); ) {
msg = (Message) en.nextElement();
try {
handleMessage(msg);
} catch (Throwable t) {
Trace.error("UDP.handleIncomingUdpPacket()", "failure: " + t.toString());
}
}
} else {
msg = new Message();
msg.readExternal(inp);
handleMessage(msg);
}
} catch (Throwable e) {
Trace.error("UDP.handleIncomingUdpPacket()", "exception=" + Trace.getStackTrace(e));
}
}
/**
* Returns an string array representation of the specified throwable.
*
* @param th throwable
* @return string array
*/
private static String[] toArray(final Throwable th) {
final StackTraceElement[] st = th.getStackTrace();
final String[] obj = new String[st.length + 1];
obj[0] = th.toString();
for (int i = 0; i < st.length; i++) obj[i + 1] = " " + st[i];
return obj;
}
public void run() {
Throwable t = null;
while (canRun()) {
Buffer data = null;
try {
data = send_queue.take();
if (data.hashCode() == termination.hashCode()) break;
} catch (InterruptedException e) {
t = e;
break;
}
if (data != null) {
try {
_send(data.getBuf(), 0, data.getLength(), false, send_queue.isEmpty());
} catch (Throwable ignored) {
t = ignored;
}
}
}
server.notifyConnectionClosed(
TcpConnection.this,
String.format(
"%s: %s", getClass().getSimpleName(), t != null ? t.toString() : "normal stop"));
}
/**
* Returns a more user-friendly error message for the specified exception.
*
* @param ex throwable reference
* @return error message
*/
public static String message(final Throwable ex) {
debug(ex);
if (ex instanceof BindException) return SRV_RUNNING;
if (ex instanceof LoginException) return ACCESS_DENIED;
if (ex instanceof ConnectException) return CONNECTION_ERROR;
if (ex instanceof SocketTimeoutException) return TIMEOUT_EXCEEDED;
if (ex instanceof SocketException) return CONNECTION_ERROR;
String msg = ex.getMessage();
if (msg == null || msg.isEmpty()) msg = ex.toString();
if (ex instanceof FileNotFoundException) return info(RES_NOT_FOUND_X, msg);
if (ex instanceof UnknownHostException) return info(UNKNOWN_HOST_X, msg);
return msg;
}
public void run() {
Throwable t = null;
while (canRun()) {
try {
int len = in.readInt();
if (buffer == null || buffer.length < len) buffer = new byte[len];
in.readFully(buffer, 0, len);
updateLastAccessed();
server.receive(peer_addr, buffer, 0, len);
} catch (OutOfMemoryError mem_ex) {
t = mem_ex;
break; // continue;
} catch (IOException io_ex) {
t = io_ex;
break;
} catch (Throwable e) {
}
}
server.notifyConnectionClosed(
TcpConnection.this,
String.format("%s: %s", getClass().getSimpleName(), t != null ? t.toString() : "n/a"));
}
/**
* Repeatedly receive a packet from the group, process it. No messages are sent from here.
* sendPacket().
*/
public void receiveGroupMessages() {
if (LOG.isDebugEnabled()) {
LOG.debug("Starting group receive loop for " + nodeId);
}
while (this.isRunning()) {
try {
final byte[] data = new byte[BUFFER_SIZE]; // set up an empty packet
final DatagramPacket packet = new DatagramPacket(data, data.length);
if (LOG.isDebugEnabled()) {
LOG.debug("Waiting for group message on " + groupSocket);
}
groupSocket.receive(packet); // wait for a packet
final String msg = toString(packet);
if (LOG.isDebugEnabled()) {
LOG.debug(
"Received group msg "
+ msg
+ " from "
+ packet.getAddress()
+ ":"
+ packet.getPort()
+ ".");
}
processGroupMessage(msg);
} catch (SocketTimeoutException e) {
if (LOG.isInfoEnabled()) {
LOG.info(BUNDLE_MARKER, "GroupSocket receive timed out.");
}
} catch (IOException e) {
LOG.error(BUNDLE_MARKER, e.toString(), e);
} catch (Throwable t) {
LOG.error(BUNDLE_MARKER, t.toString(), t);
}
}
if (LOG.isDebugEnabled()) {
LOG.debug("Group receive loop for " + nodeId + " was stopped.");
}
}
public void runSupport() {
byte[] input_buffer = new byte[request_dg.getLength()];
System.arraycopy(request_dg.getData(), 0, input_buffer, 0, input_buffer.length);
int packet_data_length = input_buffer.length;
String auth_user = null;
byte[] auth_user_bytes = null;
byte[] auth_hash = null;
if (server.isTrackerPasswordEnabled()) {
// auth detail should be attached to the packet. Auth details are 16
// bytes
if (input_buffer.length < 17) {
Logger.log(
new LogEvent(
LOGID,
LogEvent.LT_WARNING,
"TRTrackerServerProcessorUDP: " + "packet received but authorisation missing"));
return;
}
packet_data_length -= 16;
auth_user_bytes = new byte[8];
auth_hash = new byte[8];
System.arraycopy(input_buffer, packet_data_length, auth_user_bytes, 0, 8);
int user_len = 0;
while (user_len < 8 && auth_user_bytes[user_len] != 0) {
user_len++;
}
auth_user = new String(auth_user_bytes, 0, user_len);
System.arraycopy(input_buffer, packet_data_length + 8, auth_hash, 0, 8);
}
DataInputStream is =
new DataInputStream(new ByteArrayInputStream(input_buffer, 0, packet_data_length));
try {
String client_ip_address = request_dg.getAddress().getHostAddress();
PRUDPPacketRequest request = PRUDPPacketRequest.deserialiseRequest(null, is);
Logger.log(
new LogEvent(
LOGID, "TRTrackerServerProcessorUDP: packet received: " + request.getString()));
PRUDPPacket reply = null;
TRTrackerServerTorrentImpl torrent = null;
if (auth_user_bytes != null) {
// user name is irrelevant as we only have one at the moment
// <parg_home> so <new_packet> = <old_packet> + <user_padded_to_8_bytes> + <hash>
// <parg_home> where <hash> = first 8 bytes of sha1(<old_packet> + <user_padded_to_8> +
// sha1(pass))
// <XTF> Yes
byte[] sha1_pw = null;
if (server.hasExternalAuthorisation()) {
try {
URL resource = new URL("udp://" + server.getHost() + ":" + server.getPort() + "/");
sha1_pw = server.performExternalAuthorisation(resource, auth_user);
} catch (MalformedURLException e) {
Debug.printStackTrace(e);
}
if (sha1_pw == null) {
Logger.log(
new LogEvent(
LOGID,
LogEvent.LT_ERROR,
"TRTrackerServerProcessorUDP: auth fails for user '" + auth_user + "'"));
reply = new PRUDPPacketReplyError(request.getTransactionId(), "Access Denied");
}
} else {
sha1_pw = server.getPassword();
}
// if we haven't already failed then check the PW
if (reply == null) {
SHA1Hasher hasher = new SHA1Hasher();
hasher.update(input_buffer, 0, packet_data_length);
hasher.update(auth_user_bytes);
hasher.update(sha1_pw);
byte[] digest = hasher.getDigest();
for (int i = 0; i < auth_hash.length; i++) {
if (auth_hash[i] != digest[i]) {
Logger.log(
new LogEvent(
LOGID,
LogEvent.LT_ERROR,
"TRTrackerServerProcessorUDP: auth fails for user '" + auth_user + "'"));
reply = new PRUDPPacketReplyError(request.getTransactionId(), "Access Denied");
break;
}
}
}
}
int request_type = TRTrackerServerRequest.RT_UNKNOWN;
if (reply == null) {
if (server.isEnabled()) {
try {
int type = request.getAction();
if (type == PRUDPPacketTracker.ACT_REQUEST_CONNECT) {
reply = handleConnect(client_ip_address, request);
} else if (type == PRUDPPacketTracker.ACT_REQUEST_ANNOUNCE) {
Object[] x =
handleAnnounceAndScrape(
client_ip_address, request, TRTrackerServerRequest.RT_ANNOUNCE);
if (x == null) {
throw (new Exception("Connection ID mismatch"));
}
reply = (PRUDPPacket) x[0];
torrent = (TRTrackerServerTorrentImpl) x[1];
request_type = TRTrackerServerRequest.RT_ANNOUNCE;
} else if (type == PRUDPPacketTracker.ACT_REQUEST_SCRAPE) {
Object[] x =
handleAnnounceAndScrape(
client_ip_address, request, TRTrackerServerRequest.RT_SCRAPE);
if (x == null) {
throw (new Exception("Connection ID mismatch"));
}
reply = (PRUDPPacket) x[0];
torrent = (TRTrackerServerTorrentImpl) x[1];
request_type = TRTrackerServerRequest.RT_SCRAPE;
} else {
reply = new PRUDPPacketReplyError(request.getTransactionId(), "unsupported action");
}
} catch (Throwable e) {
// e.printStackTrace();
String error = e.getMessage();
if (error == null) {
error = e.toString();
}
reply = new PRUDPPacketReplyError(request.getTransactionId(), error);
}
} else {
System.out.println("UDP Tracker: replying 'disabled' to " + client_ip_address);
reply = new PRUDPPacketReplyError(request.getTransactionId(), "UDP Tracker disabled");
}
}
if (reply != null) {
InetAddress address = request_dg.getAddress();
ByteArrayOutputStream baos = new ByteArrayOutputStream();
DataOutputStream os = new DataOutputStream(baos);
reply.serialise(os);
byte[] output_buffer = baos.toByteArray();
DatagramPacket reply_packet =
new DatagramPacket(output_buffer, output_buffer.length, address, request_dg.getPort());
socket.send(reply_packet);
server.updateStats(request_type, torrent, input_buffer.length, output_buffer.length);
}
} catch (Throwable e) {
Logger.log(new LogEvent(LOGID, "TRTrackerServerProcessorUDP: processing fails", e));
} finally {
try {
is.close();
} catch (Throwable e) {
}
}
}
protected void recordError(String msg, Throwable t) {
log.error(msg, t);
errors.add(msg + ": " + t.toString());
}