static void readConfig() {
tracker_ip = COConfigurationManager.getStringParameter("Tracker IP", "");
tracker_ip = UrlUtils.expandIPV6Host(tracker_ip);
String override_ips = COConfigurationManager.getStringParameter("Override Ip", "");
StringTokenizer tok = new StringTokenizer(override_ips, ";");
Map new_override_map = new HashMap();
while (tok.hasMoreTokens()) {
String ip = tok.nextToken().trim();
if (ip.length() > 0) {
new_override_map.put(AENetworkClassifier.categoriseAddress(ip), ip);
}
}
override_map = new_override_map;
InetAddress bad = NetworkAdmin.getSingleton().getSingleHomedServiceBindAddress();
if (bad == null || bad.isAnyLocalAddress()) {
bind_ip = "";
} else {
bind_ip = bad.getHostAddress();
}
}
/** Block datagrams from given source if a memory to receive all datagrams. */
void block(MembershipKeyImpl key, InetAddress source) throws IOException {
assert key.channel() == this;
assert key.sourceAddress() == null;
synchronized (stateLock) {
if (!key.isValid()) throw new IllegalStateException("key is no longer valid");
if (source.isAnyLocalAddress())
throw new IllegalArgumentException("Source address is a wildcard address");
if (source.isMulticastAddress())
throw new IllegalArgumentException("Source address is multicast address");
if (source.getClass() != key.group().getClass())
throw new IllegalArgumentException("Source address is different type to group");
int n;
if (key instanceof MembershipKeyImpl.Type6) {
MembershipKeyImpl.Type6 key6 = (MembershipKeyImpl.Type6) key;
n = Net.block6(fd, key6.groupAddress(), key6.index(), Net.inet6AsByteArray(source));
} else {
MembershipKeyImpl.Type4 key4 = (MembershipKeyImpl.Type4) key;
n = Net.block4(fd, key4.groupAddress(), key4.interfaceAddress(), Net.inet4AsInt(source));
}
if (n == IOStatus.UNAVAILABLE) {
// ancient kernel
throw new UnsupportedOperationException();
}
}
}
/**
* Returns an InetAddress instance that represents the localhost, and that a socket can bind upon
* or distribute to peers as a contact address.
*
* @param intendedDestination the destination that we'd like to use the localhost address with.
* @return an InetAddress instance representing the local host, and that a socket can bind upon or
* distribute to peers as a contact address.
*/
public synchronized InetAddress getLocalHost(InetAddress intendedDestination) {
// no point in making sure that the localHostFinderSocket is initialized.
// better let it through a NullPointerException.
InetAddress localHost = null;
localHostFinderSocket.connect(intendedDestination, this.RANDOM_ADDR_DISC_PORT);
localHost = localHostFinderSocket.getLocalAddress();
localHostFinderSocket.disconnect();
// windows socket implementations return the any address so we need to
// find something else here ... InetAddress.getLocalHost seems to work
// better on windows so lets hope it'll do the trick.
if (localHost.isAnyLocalAddress()) {
try {
// all that's inside the if is an ugly IPv6 hack
// (good ol' IPv6 - always causing more problems than it solves.)
if (intendedDestination instanceof Inet6Address) {
// return the first globally routable ipv6 address we find
// on the machine (and hope it's a good one)
Enumeration interfaces = NetworkInterface.getNetworkInterfaces();
while (interfaces.hasMoreElements()) {
NetworkInterface iface = (NetworkInterface) interfaces.nextElement();
Enumeration addresses = iface.getInetAddresses();
while (addresses.hasMoreElements()) {
InetAddress address = (InetAddress) addresses.nextElement();
if (address instanceof Inet6Address) {
if (!address.isAnyLocalAddress()
&& !address.isLinkLocalAddress()
&& !address.isSiteLocalAddress()
&& !address.isLoopbackAddress()) {
return address;
}
}
}
}
} else localHost = InetAddress.getLocalHost();
/** @todo test on windows for ipv6 cases */
} catch (Exception ex) {
// sigh ... ok return 0.0.0.0
logger.warn("Failed to get localhost ", ex);
}
}
return localHost;
}
/** Joins channel's socket to the given group/interface and optional source address. */
private MembershipKey innerJoin(InetAddress group, NetworkInterface interf, InetAddress source)
throws IOException {
if (!group.isMulticastAddress())
throw new IllegalArgumentException("Group not a multicast address");
// check multicast address is compatible with this socket
if (group instanceof Inet4Address) {
if (family == StandardProtocolFamily.INET6 && !Net.canIPv6SocketJoinIPv4Group())
throw new IllegalArgumentException("IPv6 socket cannot join IPv4 multicast group");
} else if (group instanceof Inet6Address) {
if (family != StandardProtocolFamily.INET6)
throw new IllegalArgumentException("Only IPv6 sockets can join IPv6 multicast group");
} else {
throw new IllegalArgumentException("Address type not supported");
}
// check source address
if (source != null) {
if (source.isAnyLocalAddress())
throw new IllegalArgumentException("Source address is a wildcard address");
if (source.isMulticastAddress())
throw new IllegalArgumentException("Source address is multicast address");
if (source.getClass() != group.getClass())
throw new IllegalArgumentException("Source address is different type to group");
}
SecurityManager sm = System.getSecurityManager();
if (sm != null) sm.checkMulticast(group);
synchronized (stateLock) {
if (!isOpen()) throw new ClosedChannelException();
// check the registry to see if we are already a member of the group
if (registry == null) {
registry = new MembershipRegistry();
} else {
// return existing membership key
MembershipKey key = registry.checkMembership(group, interf, source);
if (key != null) return key;
}
MembershipKeyImpl key;
if ((family == StandardProtocolFamily.INET6)
&& ((group instanceof Inet6Address) || Net.canJoin6WithIPv4Group())) {
int index = interf.getIndex();
if (index == -1) throw new IOException("Network interface cannot be identified");
// need multicast and source address as byte arrays
byte[] groupAddress = Net.inet6AsByteArray(group);
byte[] sourceAddress = (source == null) ? null : Net.inet6AsByteArray(source);
// join the group
int n = Net.join6(fd, groupAddress, index, sourceAddress);
if (n == IOStatus.UNAVAILABLE) throw new UnsupportedOperationException();
key =
new MembershipKeyImpl.Type6(
this, group, interf, source, groupAddress, index, sourceAddress);
} else {
// need IPv4 address to identify interface
Inet4Address target = Net.anyInet4Address(interf);
if (target == null) throw new IOException("Network interface not configured for IPv4");
int groupAddress = Net.inet4AsInt(group);
int targetAddress = Net.inet4AsInt(target);
int sourceAddress = (source == null) ? 0 : Net.inet4AsInt(source);
// join the group
int n = Net.join4(fd, groupAddress, targetAddress, sourceAddress);
if (n == IOStatus.UNAVAILABLE) throw new UnsupportedOperationException();
key =
new MembershipKeyImpl.Type4(
this, group, interf, source, groupAddress, targetAddress, sourceAddress);
}
registry.add(key);
return key;
}
}
public PasswordAuthentication getAuthentication(
String realm, String protocol, String host, int port) {
try {
this_mon.enter();
String tracker = protocol + "://" + host + ":" + port + "/";
InetAddress bind_ip = NetworkAdmin.getSingleton().getSingleHomedServiceBindAddress();
String self_addr;
// System.out.println( "auth req for " + realm + " - " + tracker );
if (bind_ip == null || bind_ip.isAnyLocalAddress()) {
self_addr = "127.0.0.1";
} else {
self_addr = bind_ip.getHostAddress();
}
// when the tracker is connected to internally we don't want to prompt
// for the password. Here we return a special user and the password hash
// which is picked up in the tracker auth code - search for "<internal>"!
// also include the tracker IP as well as for scrapes these can occur on
// a raw torrent which hasn't been modified to point to localhost
if (host.equals(self_addr)
|| host.equals(COConfigurationManager.getStringParameter("Tracker IP", ""))) {
try {
byte[] pw = COConfigurationManager.getByteParameter("Tracker Password", new byte[0]);
String str_pw = new String(Base64.encode(pw));
return (new PasswordAuthentication("<internal>", str_pw.toCharArray()));
} catch (Throwable e) {
Debug.printStackTrace(e);
}
}
String auth_key = realm + ":" + tracker;
authCache cache = (authCache) auth_cache.get(auth_key);
if (cache != null) {
PasswordAuthentication auth = cache.getAuth();
if (auth != null) {
return (auth);
}
}
String[] res = getAuthenticationDialog(realm, tracker);
if (res == null) {
return (null);
} else {
PasswordAuthentication auth = new PasswordAuthentication(res[0], res[1].toCharArray());
boolean save_pw = res[2].equals("true");
boolean old_entry_existed =
auth_cache.put(auth_key, new authCache(auth_key, auth, save_pw)) != null;
if (save_pw || old_entry_existed) {
saveAuthCache();
}
return (auth);
}
} finally {
this_mon.exit();
}
}
