[tor-commits] [orbot/master] some missing files added to git repo
n8fr8 at torproject.org
n8fr8 at torproject.org
Fri Apr 3 17:04:03 UTC 2015
commit 1472b4e35d19bce33aef84e26cdcb7ae9ee45050
Author: SandroB <supp.sandrob at gmail.com>
Date: Sun Jan 25 11:42:15 2015 +0100
some missing files added to git repo
---
external/Makefile | 2 +-
jni/Application.mk | 3 +
src/com/runjva/sourceforge/jsocks/main/SOCKS.java | 269 ++++++++
.../runjva/sourceforge/jsocks/main/SocksEcho.gif | Bin 0 -> 926 bytes
.../jsocks/protocol/Authentication.java | 35 +
.../jsocks/protocol/AuthenticationNone.java | 22 +
.../sourceforge/jsocks/protocol/InetRange.java | 492 ++++++++++++++
.../sourceforge/jsocks/protocol/ProxyMessage.java | 118 ++++
.../sourceforge/jsocks/protocol/ProxyServer.java | 669 ++++++++++++++++++++
.../sourceforge/jsocks/protocol/Socks4Message.java | 167 +++++
.../sourceforge/jsocks/protocol/Socks4Proxy.java | 144 +++++
.../jsocks/protocol/Socks5DatagramSocket.java | 485 ++++++++++++++
.../sourceforge/jsocks/protocol/Socks5Message.java | 330 ++++++++++
.../sourceforge/jsocks/protocol/Socks5Proxy.java | 295 +++++++++
.../jsocks/protocol/SocksException.java | 111 ++++
.../jsocks/protocol/SocksProxyBase.java | 543 ++++++++++++++++
.../jsocks/protocol/SocksServerSocket.java | 238 +++++++
.../sourceforge/jsocks/protocol/SocksSocket.java | 389 ++++++++++++
.../jsocks/protocol/UDPEncapsulation.java | 33 +
.../jsocks/protocol/UDPRelayServer.java | 231 +++++++
.../protocol/UserPasswordAuthentication.java | 91 +++
.../runjva/sourceforge/jsocks/server/Ident.java | 176 +++++
.../jsocks/server/IdentAuthenticator.java | 182 ++++++
.../jsocks/server/ServerAuthenticator.java | 126 ++++
.../jsocks/server/ServerAuthenticatorBase.java | 187 ++++++
.../jsocks/server/ServerAuthenticatorNone.java | 16 +
.../jsocks/server/UserPasswordAuthenticator.java | 82 +++
.../sourceforge/jsocks/server/UserValidation.java | 24 +
src/org/sandroproxy/ony/OrbotApp.java | 69 ++
29 files changed, 5528 insertions(+), 1 deletion(-)
diff --git a/external/Makefile b/external/Makefile
index df7de72..8e0e082 100644
--- a/external/Makefile
+++ b/external/Makefile
@@ -52,7 +52,7 @@ STRIP := $(NDK_TOOLCHAIN_BASE)/bin/$(HOST)-strip \
--strip-unneeded -R .note -R .comment
# PIEFLAGS for SDK 16/Android L must be set to -fPIE -pie
-PIEFLAGS? =
+PIEFLAGS = -fPIE -pie
CFLAGS = -DANDROID $(TARGET_CFLAGS) $(PIEFLAGS)
LDFLAGS = -llog $(TARGET_LDFLAGS) $(PIEFLAGS)
diff --git a/jni/Application.mk b/jni/Application.mk
new file mode 100644
index 0000000..0cfcc0f
--- /dev/null
+++ b/jni/Application.mk
@@ -0,0 +1,3 @@
+APP_OPTIM := release
+APP_ABI := all #armeabi armeabi-v7a mips x86
+APP_PLATFORM := android-14
diff --git a/src/com/runjva/sourceforge/jsocks/main/SOCKS.java b/src/com/runjva/sourceforge/jsocks/main/SOCKS.java
new file mode 100644
index 0000000..9135f87
--- /dev/null
+++ b/src/com/runjva/sourceforge/jsocks/main/SOCKS.java
@@ -0,0 +1,269 @@
+package com.runjva.sourceforge.jsocks.main;
+
+import java.io.FileInputStream;
+import java.io.IOException;
+import java.io.InputStream;
+import java.net.InetAddress;
+import java.net.UnknownHostException;
+import java.util.Hashtable;
+import java.util.Properties;
+import java.util.StringTokenizer;
+
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+
+import com.runjva.sourceforge.jsocks.protocol.InetRange;
+import com.runjva.sourceforge.jsocks.protocol.ProxyServer;
+import com.runjva.sourceforge.jsocks.protocol.SocksProxyBase;
+import com.runjva.sourceforge.jsocks.server.IdentAuthenticator;
+
+public class SOCKS {
+
+ private static final int DEFAULT_LISTENING_PORT = 1080;
+ final private static Logger log = LoggerFactory.getLogger(SOCKS.class);
+
+ static public void usage() {
+ System.out.println("Usage: java SOCKS [inifile1 inifile2 ...]\n"
+ + "If none inifile is given, uses socks.properties.\n");
+ }
+
+ static public void main(String[] args) {
+
+ String[] file_names;
+ int port = DEFAULT_LISTENING_PORT;
+ String logFile = null;
+ String host = null;
+
+ final IdentAuthenticator auth = new IdentAuthenticator();
+
+ InetAddress localIP = null;
+
+ if (args.length == 0) {
+ file_names = new String[] { "socks.properties" };
+ } else {
+ file_names = args;
+ }
+
+ inform("Loading properties");
+ for (int i = 0; i < file_names.length; ++i) {
+
+ inform("Reading file " + file_names[i]);
+
+ final Properties pr = loadProperties(file_names[i]);
+ if (pr == null) {
+ System.err.println("Loading of properties from "
+ + file_names[i] + "failed.");
+ usage();
+ return;
+ }
+ if (!addAuth(auth, pr)) {
+ System.err.println("Error in file " + file_names[i] + ".");
+ usage();
+ return;
+ }
+ // First file should contain all global settings,
+ // like port and host and log.
+ if (i == 0) {
+ final String port_s = (String) pr.get("port");
+ if (port_s != null) {
+ try {
+ port = Integer.parseInt(port_s);
+ } catch (final NumberFormatException nfe) {
+ System.err.println("Can't parse port: " + port_s);
+ return;
+ }
+ }
+
+ serverInit(pr);
+ logFile = (String) pr.get("log");
+ host = (String) pr.get("host");
+ }
+
+ // inform("Props:"+pr);
+ }
+
+ if (logFile != null) {
+ System.err.println("log property not supported anymore.");
+ }
+ if (host != null) {
+ try {
+ localIP = InetAddress.getByName(host);
+ } catch (final UnknownHostException uhe) {
+ System.err.println("Can't resolve local ip: " + host);
+ return;
+ }
+ }
+
+ inform("Using Ident Authentication scheme: " + auth);
+ final ProxyServer server = new ProxyServer(auth);
+ server.start(port, 5, localIP);
+ }
+
+ static Properties loadProperties(String file_name) {
+
+ final Properties pr = new Properties();
+
+ try {
+ final InputStream fin = new FileInputStream(file_name);
+ pr.load(fin);
+ fin.close();
+ } catch (final IOException ioe) {
+ return null;
+ }
+ return pr;
+ }
+
+ static boolean addAuth(IdentAuthenticator ident, Properties pr) {
+
+ InetRange irange;
+
+ final String range = (String) pr.get("range");
+ if (range == null) {
+ return false;
+ }
+ irange = parseInetRange(range);
+
+ final String users = (String) pr.get("users");
+
+ if (users == null) {
+ ident.add(irange, null);
+ return true;
+ }
+
+ final Hashtable<String, String> uhash = new Hashtable<String, String>();
+
+ final StringTokenizer st = new StringTokenizer(users, ";");
+ while (st.hasMoreTokens()) {
+ uhash.put(st.nextToken(), "");
+ }
+
+ ident.add(irange, uhash);
+ return true;
+ }
+
+ /**
+ * Does server initialisation.
+ */
+ static void serverInit(Properties props) {
+ int val;
+ val = readInt(props, "iddleTimeout");
+ if (val >= 0) {
+ ProxyServer.setIddleTimeout(val);
+ inform("Setting iddle timeout to " + val + " ms.");
+ }
+ val = readInt(props, "acceptTimeout");
+ if (val >= 0) {
+ ProxyServer.setAcceptTimeout(val);
+ inform("Setting accept timeout to " + val + " ms.");
+ }
+ val = readInt(props, "udpTimeout");
+ if (val >= 0) {
+ ProxyServer.setUDPTimeout(val);
+ inform("Setting udp timeout to " + val + " ms.");
+ }
+
+ val = readInt(props, "datagramSize");
+ if (val >= 0) {
+ ProxyServer.setDatagramSize(val);
+ inform("Setting datagram size to " + val + " bytes.");
+ }
+
+ proxyInit(props);
+
+ }
+
+ /**
+ * Initialises proxy, if any specified.
+ */
+ static void proxyInit(Properties props) {
+ String proxy_list;
+ SocksProxyBase proxy = null;
+ StringTokenizer st;
+
+ proxy_list = (String) props.get("proxy");
+ if (proxy_list == null) {
+ return;
+ }
+
+ st = new StringTokenizer(proxy_list, ";");
+ while (st.hasMoreTokens()) {
+ final String proxy_entry = st.nextToken();
+
+ final SocksProxyBase p = SocksProxyBase.parseProxy(proxy_entry);
+
+ if (p == null) {
+ exit("Can't parse proxy entry:" + proxy_entry);
+ }
+
+ inform("Adding Proxy:" + p);
+
+ if (proxy != null) {
+ p.setChainProxy(proxy);
+ }
+
+ proxy = p;
+
+ }
+ if (proxy == null) {
+ return; // Empty list
+ }
+
+ final String direct_hosts = (String) props.get("directHosts");
+ if (direct_hosts != null) {
+ final InetRange ir = parseInetRange(direct_hosts);
+ inform("Setting direct hosts:" + ir);
+ proxy.setDirect(ir);
+ }
+
+ ProxyServer.setProxy(proxy);
+ }
+
+ /**
+ * Inits range from the string of semicolon separated ranges.
+ */
+ static InetRange parseInetRange(String source) {
+ final InetRange irange = new InetRange();
+
+ final StringTokenizer st = new StringTokenizer(source, ";");
+ while (st.hasMoreTokens()) {
+ irange.add(st.nextToken());
+ }
+
+ return irange;
+ }
+
+ /**
+ * Integer representaion of the property named name, or -1 if one is not
+ * found.
+ */
+ static int readInt(Properties props, String name) {
+ int result = -1;
+ final String val = (String) props.get(name);
+ if (val == null) {
+ return -1;
+ }
+ final StringTokenizer st = new StringTokenizer(val);
+ if (!st.hasMoreElements()) {
+ return -1;
+ }
+ try {
+ result = Integer.parseInt(st.nextToken());
+ } catch (final NumberFormatException nfe) {
+ inform("Bad value for " + name + ":" + val);
+ }
+ return result;
+ }
+
+ // Display functions
+ // /////////////////
+
+ static void inform(String s) {
+ log.info(s);
+ }
+
+ static void exit(String msg) {
+ System.err.println("Error:" + msg);
+ System.err.println("Aborting operation");
+ System.exit(0);
+ }
+}
diff --git a/src/com/runjva/sourceforge/jsocks/main/SocksEcho.gif b/src/com/runjva/sourceforge/jsocks/main/SocksEcho.gif
new file mode 100644
index 0000000..701d39a
Binary files /dev/null and b/src/com/runjva/sourceforge/jsocks/main/SocksEcho.gif differ
diff --git a/src/com/runjva/sourceforge/jsocks/protocol/Authentication.java b/src/com/runjva/sourceforge/jsocks/protocol/Authentication.java
new file mode 100644
index 0000000..70d0a94
--- /dev/null
+++ b/src/com/runjva/sourceforge/jsocks/protocol/Authentication.java
@@ -0,0 +1,35 @@
+package com.runjva.sourceforge.jsocks.protocol;
+
+/**
+ * The Authentication interface provides for performing method specific
+ * authentication for SOCKS5 connections.
+ */
+public interface Authentication {
+ /**
+ * This method is called when SOCKS5 server have selected a particular
+ * authentication method, for whch an implementaion have been registered.
+ *
+ * <p>
+ * This method should return an array {inputstream,outputstream
+ * [,UDPEncapsulation]}. The reason for that is that SOCKS5 protocol allows
+ * to have method specific encapsulation of data on the socket for purposes
+ * of integrity or security. And this encapsulation should be performed by
+ * those streams returned from the method. It is also possible to
+ * encapsulate datagrams. If authentication method supports such
+ * encapsulation an instance of the UDPEncapsulation interface should be
+ * returned as third element of the array, otherwise either null should be
+ * returned as third element, or array should contain only 2 elements.
+ *
+ * @param methodId
+ * Authentication method selected by the server.
+ * @param proxySocket
+ * Socket used to conect to the proxy.
+ * @return Two or three element array containing Input/Output streams which
+ * should be used on this connection. Third argument is optional and
+ * should contain an instance of UDPEncapsulation. It should be
+ * provided if the authentication method used requires any
+ * encapsulation to be done on the datagrams.
+ */
+ Object[] doSocksAuthentication(int methodId, java.net.Socket proxySocket)
+ throws java.io.IOException;
+}
diff --git a/src/com/runjva/sourceforge/jsocks/protocol/AuthenticationNone.java b/src/com/runjva/sourceforge/jsocks/protocol/AuthenticationNone.java
new file mode 100644
index 0000000..e682154
--- /dev/null
+++ b/src/com/runjva/sourceforge/jsocks/protocol/AuthenticationNone.java
@@ -0,0 +1,22 @@
+package com.runjva.sourceforge.jsocks.protocol;
+
+import java.io.InputStream;
+import java.io.OutputStream;
+
+/**
+ * SOCKS5 none authentication. Dummy class does almost nothing.
+ */
+public class AuthenticationNone implements Authentication {
+
+ public Object[] doSocksAuthentication(final int methodId,
+ final java.net.Socket proxySocket) throws java.io.IOException {
+
+ if (methodId != 0) {
+ return null;
+ }
+
+ InputStream in = proxySocket.getInputStream();
+ OutputStream out = proxySocket.getOutputStream();
+ return new Object[] { in, out };
+ }
+}
diff --git a/src/com/runjva/sourceforge/jsocks/protocol/InetRange.java b/src/com/runjva/sourceforge/jsocks/protocol/InetRange.java
new file mode 100644
index 0000000..fae1358
--- /dev/null
+++ b/src/com/runjva/sourceforge/jsocks/protocol/InetRange.java
@@ -0,0 +1,492 @@
+package com.runjva.sourceforge.jsocks.protocol;
+
+import java.net.InetAddress;
+import java.net.UnknownHostException;
+import java.util.Enumeration;
+import java.util.Hashtable;
+import java.util.StringTokenizer;
+import java.util.Vector;
+
+/**
+ * Class InetRange provides the means of defining the range of inetaddresses.
+ * It's used by Proxy class to store and look up addresses of machines, that
+ * should be contacted directly rather then through the proxy.
+ * <P>
+ * InetRange provides several methods to add either standalone addresses, or
+ * ranges (e.g. 100.200.300.0:100.200.300.255, which covers all addresses on on
+ * someones local network). It also provides methods for checking wether given
+ * address is in this range. Any number of ranges and standalone addresses can
+ * be added to the range.
+ */
+public class InetRange implements Cloneable {
+
+ Hashtable<String, Object[]> host_names;
+ Vector<Object[]> all;
+ Vector<String> end_names;
+
+ boolean useSeparateThread = true;
+
+ /**
+ * Creates the empty range.
+ */
+ public InetRange() {
+ all = new Vector<Object[]>();
+ host_names = new Hashtable<String, Object[]>();
+ end_names = new Vector<String>();
+ }
+
+ /**
+ * Adds another host or range to this range. The String can be one of those:
+ * <UL>
+ * <li>Host name. eg.(Athena.myhost.com or 45.54.56.65)
+ *
+ * <li>Range in the form .myhost.net.au <BR>
+ * In which case anything that ends with .myhost.net.au will be considered
+ * in the range.
+ *
+ * <li>Range in the form ddd.ddd.ddd. <BR>
+ * This will be treated as range ddd.ddd.ddd.0 to ddd.ddd.ddd.255. It is not
+ * necessary to specify 3 first bytes you can use just one or two. For
+ * example 130. will cover address between 130.0.0.0 and 13.255.255.255.
+ *
+ * <li>Range in the form host_from[: \t\n\r\f]host_to. <br>
+ * That is two hostnames or ips separated by either whitespace or colon.
+ * </UL>
+ */
+ public synchronized boolean add(final String s0) {
+ if (s0 == null) {
+ return false;
+ }
+
+ String s = s0.trim();
+ if (s.length() == 0) {
+ return false;
+ }
+
+ Object[] entry;
+
+ if (s.endsWith(".")) {
+ // thing like: 111.222.33.
+ // it is being treated as range 111.222.33.000 - 111.222.33.255
+
+ final int[] addr = ip2intarray(s);
+ long from, to;
+ from = to = 0;
+
+ if (addr == null) {
+ return false;
+ }
+ for (int i = 0; i < 4; i++) {
+ if (addr[i] >= 0) {
+ from += (((long) addr[i]) << 8 * (3 - i));
+ } else {
+ to = from;
+ while (i < 4) {
+ to += 255l << 8 * (3 - i++);
+ }
+ break;
+ }
+ }
+ entry = new Object[] { s, null, new Long(from), new Long(to) };
+ all.addElement(entry);
+
+ } else if (s.startsWith(".")) {
+ // Thing like: .myhost.com
+
+ end_names.addElement(s);
+ all.addElement(new Object[] { s, null, null, null });
+ } else {
+ final StringTokenizer tokens = new StringTokenizer(s, " \t\r\n\f:");
+ if (tokens.countTokens() > 1) {
+ entry = new Object[] { s, null, null, null };
+ resolve(entry, tokens.nextToken(), tokens.nextToken());
+ all.addElement(entry);
+ } else {
+ entry = new Object[] { s, null, null, null };
+ all.addElement(entry);
+ host_names.put(s, entry);
+ resolve(entry);
+ }
+
+ }
+
+ return true;
+ }
+
+ /**
+ * Adds another ip for this range.
+ *
+ * @param ip
+ * IP os the host which should be added to this range.
+ */
+ public synchronized void add(final InetAddress ip) {
+ long from, to;
+ from = to = ip2long(ip);
+ all.addElement(new Object[] { ip.getHostName(), ip, new Long(from),
+ new Long(to) });
+ }
+
+ /**
+ * Adds another range of ips for this range.Any host with ip address greater
+ * than or equal to the address of from and smaller than or equal to the
+ * address of to will be included in the range.
+ *
+ * @param from
+ * IP from where range starts(including).
+ * @param to
+ * IP where range ends(including).
+ */
+ public synchronized void add(final InetAddress from, final InetAddress to) {
+ all.addElement(new Object[] {
+ from.getHostAddress() + ":" + to.getHostAddress(), null,
+ new Long(ip2long(from)), new Long(ip2long(to)) });
+ }
+
+ /**
+ * Checks wether the givan host is in the range. Attempts to resolve host
+ * name if required.
+ *
+ * @param host
+ * Host name to check.
+ * @return true If host is in the range, false otherwise.
+ * @see InetRange#contains(String,boolean)
+ */
+ public synchronized boolean contains(final String host) {
+ return contains(host, true);
+ }
+
+ /**
+ * Checks wether the given host is in the range.
+ * <P>
+ * Algorithm: <BR>
+ * <ol>
+ * <li>Look up if the hostname is in the range (in the Hashtable).
+ * <li>Check if it ends with one of the speciefied endings.
+ * <li>Check if it is ip(eg.130.220.35.98). If it is check if it is in the
+ * range.
+ * <li>If attemptResolve is true, host is name, rather than ip, and all
+ * previous attempts failed, try to resolve the hostname, and check wether
+ * the ip associated with the host is in the range.It also repeats all
+ * previos steps with the hostname obtained from InetAddress, but the name
+ * is not allways the full name,it is quite likely to be the same. Well it
+ * was on my machine.
+ * </ol>
+ *
+ * @param host
+ * Host name to check.
+ * @param attemptResolve
+ * Wether to lookup ip address which corresponds to the host,if
+ * required.
+ * @return true If host is in the range, false otherwise.
+ */
+ public synchronized boolean contains(final String host0,
+ final boolean attemptResolve) {
+ if (all.size() == 0) {
+ return false; // Empty range
+ }
+
+ String host = host0.trim();
+ if (host.length() == 0) {
+ return false;
+ }
+
+ if (checkHost(host)) {
+ return true;
+ }
+ if (checkHostEnding(host)) {
+ return true;
+ }
+
+ final long l = host2long(host);
+ if (l >= 0) {
+ return contains(l);
+ }
+
+ if (!attemptResolve) {
+ return false;
+ }
+
+ try {
+ final InetAddress ip = InetAddress.getByName(host);
+ return contains(ip);
+ } catch (final UnknownHostException uhe) {
+
+ }
+
+ return false;
+ }
+
+ /**
+ * Checks wether the given ip is in the range.
+ *
+ * @param ip
+ * Address of the host to check.
+ * @return true If host is in the range, false otherwise.
+ */
+ public synchronized boolean contains(final InetAddress ip) {
+ if (checkHostEnding(ip.getHostName())) {
+ return true;
+ }
+ if (checkHost(ip.getHostName())) {
+ return true;
+ }
+ return contains(ip2long(ip));
+ }
+
+ /**
+ * Get all entries in the range as strings. <BR>
+ * These strings can be used to delete entries from the range with remove
+ * function.
+ *
+ * @return Array of entries as strings.
+ * @see InetRange#remove(String)
+ */
+ public synchronized String[] getAll() {
+ final int size = all.size();
+ Object entry[];
+ final String all_names[] = new String[size];
+
+ for (int i = 0; i < size; ++i) {
+ entry = all.elementAt(i);
+ all_names[i] = (String) entry[0];
+ }
+ return all_names;
+ }
+
+ /**
+ * Removes an entry from this range.<BR>
+ *
+ * @param s
+ * Entry to remove.
+ * @return true if successfull.
+ */
+ public synchronized boolean remove(final String s) {
+ final Enumeration<Object[]> enumx = all.elements();
+ while (enumx.hasMoreElements()) {
+ final Object[] entry = enumx.nextElement();
+ if (s.equals(entry[0])) {
+ all.removeElement(entry);
+ end_names.removeElement(s);
+ host_names.remove(s);
+ return true;
+ }
+ }
+ return false;
+ }
+
+ /** Get string representaion of this Range. */
+ public String toString() {
+ final String all[] = getAll();
+ if (all.length == 0) {
+ return "";
+ }
+
+ String s = all[0];
+ for (int i = 1; i < all.length; ++i) {
+ s += "; " + all[i];
+ }
+ return s;
+ }
+
+ /** Creates a clone of this Object */
+
+ @SuppressWarnings("unchecked")
+ public Object clone() {
+ final InetRange new_range = new InetRange();
+ new_range.all = (Vector<Object[]>) all.clone();
+ new_range.end_names = (Vector<String>) end_names.clone();
+ new_range.host_names = (Hashtable<String, Object[]>) host_names.clone();
+ return new_range;
+ }
+
+ // Private methods
+ // ///////////////
+ /**
+ * Same as previous but used internally, to avoid unnecessary convertion of
+ * IPs, when checking subranges
+ */
+ private synchronized boolean contains(final long ip) {
+ final Enumeration<Object[]> enumx = all.elements();
+ while (enumx.hasMoreElements()) {
+ final Object[] obj = enumx.nextElement();
+ final Long from = obj[2] == null ? null : (Long) obj[2];
+ final Long to = obj[3] == null ? null : (Long) obj[3];
+ if ((from != null) && (from.longValue() <= ip)
+ && (to.longValue() >= ip)) {
+ return true;
+ }
+
+ }
+ return false;
+ }
+
+ private boolean checkHost(final String host) {
+ return host_names.containsKey(host);
+ }
+
+ private boolean checkHostEnding(final String host) {
+ final Enumeration<String> enumx = end_names.elements();
+ while (enumx.hasMoreElements()) {
+ if (host.endsWith(enumx.nextElement())) {
+ return true;
+ }
+ }
+ return false;
+ }
+
+ private void resolve(final Object[] entry) {
+ // First check if it's in the form ddd.ddd.ddd.ddd.
+ final long ip = host2long((String) entry[0]);
+ if (ip >= 0) {
+ entry[2] = entry[3] = new Long(ip);
+ } else {
+ final InetRangeResolver res = new InetRangeResolver(entry);
+ res.resolve(useSeparateThread);
+ }
+ }
+
+ private void resolve(final Object[] entry, final String from,
+ final String to) {
+ long f, t;
+ if (((f = host2long(from)) >= 0) && ((t = host2long(to)) >= 0)) {
+ entry[2] = new Long(f);
+ entry[3] = new Long(t);
+ } else {
+ final InetRangeResolver res = new InetRangeResolver(entry, from, to);
+ res.resolve(useSeparateThread);
+ }
+ }
+
+ // Class methods
+ // /////////////
+
+ // Converts ipv4 to long value(unsigned int)
+ // /////////////////////////////////////////
+ static long ip2long(final InetAddress ip) {
+ long l = 0;
+ final byte[] addr = ip.getAddress();
+
+ if (addr.length == 4) { // IPV4
+ for (int i = 0; i < 4; ++i) {
+ l += (((long) addr[i] & 0xFF) << 8 * (3 - i));
+ }
+ } else { // IPV6
+ return 0; // Have no idea how to deal with those
+ }
+ return l;
+ }
+
+ long host2long(final String host) {
+ long ip = 0;
+
+ // check if it's ddd.ddd.ddd.ddd
+ if (!Character.isDigit(host.charAt(0))) {
+ return -1;
+ }
+
+ final int[] addr = ip2intarray(host);
+ if (addr == null) {
+ return -1;
+ }
+
+ for (int i = 0; i < addr.length; ++i) {
+ ip += ((long) (addr[i] >= 0 ? addr[i] : 0)) << 8 * (3 - i);
+ }
+
+ return ip;
+ }
+
+ static int[] ip2intarray(final String host) {
+ final int[] address = { -1, -1, -1, -1 };
+ int i = 0;
+ final StringTokenizer tokens = new StringTokenizer(host, ".");
+ if (tokens.countTokens() > 4) {
+ return null;
+ }
+ while (tokens.hasMoreTokens()) {
+ try {
+ address[i++] = Integer.parseInt(tokens.nextToken()) & 0xFF;
+ } catch (final NumberFormatException nfe) {
+ return null;
+ }
+
+ }
+ return address;
+ }
+
+ /*
+ * //* This was the test main function //**********************************
+ *
+ * public static void main(String args[])throws UnknownHostException{ int i;
+ *
+ * InetRange ir = new InetRange();
+ *
+ *
+ * for(i=0;i<args.length;++i){ System.out.println("Adding:" + args[i]);
+ * ir.add(args[i]); }
+ *
+ * String host; java.io.DataInputStream din = new
+ * java.io.DataInputStream(System.in); try{ host = din.readLine();
+ * while(host!=null){ if(ir.contains(host)){
+ * System.out.println("Range contains ip:"+host); }else{
+ * System.out.println(host+" is not in the range"); } host = din.readLine();
+ * } }catch(java.io.IOException io_ex){ io_ex.printStackTrace(); } }
+ * ******************
+ */
+
+}
+
+class InetRangeResolver implements Runnable {
+
+ Object[] entry;
+
+ String from;
+ String to;
+
+ InetRangeResolver(final Object[] entry) {
+ this.entry = entry;
+ from = null;
+ to = null;
+ }
+
+ InetRangeResolver(final Object[] entry, final String from, final String to) {
+ this.entry = entry;
+ this.from = from;
+ this.to = to;
+ }
+
+ public final void resolve() {
+ resolve(true);
+ }
+
+ public final void resolve(final boolean inSeparateThread) {
+ if (inSeparateThread) {
+ final Thread t = new Thread(this);
+ t.start();
+ } else {
+ run();
+ }
+
+ }
+
+ public void run() {
+ try {
+ if (from == null) {
+ final InetAddress ip = InetAddress.getByName((String) entry[0]);
+ entry[1] = ip;
+ final Long l = new Long(InetRange.ip2long(ip));
+ entry[2] = l;
+ entry[3] = l;
+ } else {
+ final InetAddress f = InetAddress.getByName(from);
+ final InetAddress t = InetAddress.getByName(to);
+ entry[2] = new Long(InetRange.ip2long(f));
+ entry[3] = new Long(InetRange.ip2long(t));
+
+ }
+ } catch (final UnknownHostException uhe) {
+ // System.err.println("Resolve failed for "+from+','+to+','+entry[0]);
+ }
+ }
+
+}
diff --git a/src/com/runjva/sourceforge/jsocks/protocol/ProxyMessage.java b/src/com/runjva/sourceforge/jsocks/protocol/ProxyMessage.java
new file mode 100644
index 0000000..6eb3a59
--- /dev/null
+++ b/src/com/runjva/sourceforge/jsocks/protocol/ProxyMessage.java
@@ -0,0 +1,118 @@
+package com.runjva.sourceforge.jsocks.protocol;
+
+import java.io.IOException;
+import java.io.InputStream;
+import java.io.OutputStream;
+import java.net.InetAddress;
+import java.net.UnknownHostException;
+
+/**
+ * Abstract class which describes SOCKS4/5 response/request.
+ */
+public abstract class ProxyMessage {
+
+ /** Host as an IP address */
+ public InetAddress ip = null;
+
+ /** SOCKS version, or version of the response for SOCKS4 */
+ public int version;
+
+ /** Port field of the request/response */
+ public int port;
+
+ /** Request/response code as an int */
+ public int command;
+
+ /** Host as string. */
+ public String host = null;
+
+ /** User field for SOCKS4 request messages */
+ public String user = null;
+
+ ProxyMessage(int command, InetAddress ip, int port) {
+ this.command = command;
+ this.ip = ip;
+ this.port = port;
+ }
+
+ ProxyMessage() {
+ }
+
+ /**
+ * Initialises Message from the stream. Reads server response from given
+ * stream.
+ *
+ * @param in
+ * Input stream to read response from.
+ * @throws SocksException
+ * If server response code is not SOCKS_SUCCESS(0), or if any
+ * error with protocol occurs.
+ * @throws IOException
+ * If any error happens with I/O.
+ */
+ public abstract void read(InputStream in) throws SocksException,
+ IOException;
+
+ /**
+ * Initialises Message from the stream. Reads server response or client
+ * request from given stream.
+ *
+ * @param in
+ * Input stream to read response from.
+ * @param clinetMode
+ * If true read server response, else read client request.
+ * @throws SocksException
+ * If server response code is not SOCKS_SUCCESS(0) and reading
+ * in client mode, or if any error with protocol occurs.
+ * @throws IOException
+ * If any error happens with I/O.
+ */
+ public abstract void read(InputStream in, boolean client_mode)
+ throws SocksException, IOException;
+
+ /**
+ * Writes the message to the stream.
+ *
+ * @param out
+ * Output stream to which message should be written.
+ */
+ public abstract void write(OutputStream out) throws SocksException,
+ IOException;
+
+ /**
+ * Get the Address field of this message as InetAddress object.
+ *
+ * @return Host address or null, if one can't be determined.
+ */
+ public InetAddress getInetAddress() throws UnknownHostException {
+ return ip;
+ }
+
+ /**
+ * Get string representaion of this message.
+ *
+ * @return string representation of this message.
+ */
+ public String toString() {
+ return "Proxy Message:\n" + "Version:" + version + "\n" + "Command:"
+ + command + "\n" + "IP: " + ip + "\n" + "Port: " + port
+ + "\n" + "User: " + user + "\n";
+ }
+
+ // Package methods
+ // ////////////////
+
+ static final String bytes2IPV4(byte[] addr, int offset) {
+ String hostName = "" + (addr[offset] & 0xFF);
+ for (int i = offset + 1; i < offset + 4; i++) {
+ hostName += "." + (addr[i] & 0xFF);
+ }
+ return hostName;
+ }
+
+ static final String bytes2IPV6(byte[] addr, int offset) {
+ // Have no idea how they look like!
+ return null;
+ }
+
+}
diff --git a/src/com/runjva/sourceforge/jsocks/protocol/ProxyServer.java b/src/com/runjva/sourceforge/jsocks/protocol/ProxyServer.java
new file mode 100644
index 0000000..a672bfa
--- /dev/null
+++ b/src/com/runjva/sourceforge/jsocks/protocol/ProxyServer.java
@@ -0,0 +1,669 @@
+package com.runjva.sourceforge.jsocks.protocol;
+
+import java.io.EOFException;
+import java.io.IOException;
+import java.io.InputStream;
+import java.io.InterruptedIOException;
+import java.io.OutputStream;
+import java.io.PushbackInputStream;
+import java.net.ConnectException;
+import java.net.InetAddress;
+import java.net.InetSocketAddress;
+import java.net.NoRouteToHostException;
+import java.net.ServerSocket;
+import java.net.Socket;
+import java.net.SocketAddress;
+import java.nio.channels.SocketChannel;
+
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+
+import android.net.VpnService;
+
+import com.runjva.sourceforge.jsocks.server.ServerAuthenticator;
+
+/**
+ * SOCKS4 and SOCKS5 proxy, handles both protocols simultaniously. Implements
+ * all SOCKS commands, including UDP relaying.
+ * <p>
+ * In order to use it you will need to implement ServerAuthenticator interface.
+ * There is an implementation of this interface which does no authentication
+ * ServerAuthenticatorNone, but it is very dangerous to use, as it will give
+ * access to your local network to anybody in the world. One should never use
+ * this authentication scheme unless one have pretty good reason to do so. There
+ * is a couple of other authentication schemes in socks.server package.
+ *
+ * @see socks.server.ServerAuthenticator
+ */
+public class ProxyServer implements Runnable {
+
+ ServerAuthenticator auth;
+ ProxyMessage msg = null;
+
+ Socket sock = null, remote_sock = null;
+ ServerSocket ss = null;
+ UDPRelayServer relayServer = null;
+ InputStream in, remote_in;
+ OutputStream out, remote_out;
+
+ int mode;
+ static final int START_MODE = 0;
+ static final int ACCEPT_MODE = 1;
+ static final int PIPE_MODE = 2;
+ static final int ABORT_MODE = 3;
+
+ static final int BUF_SIZE = 8192;
+
+ Thread pipe_thread1, pipe_thread2;
+ long lastReadTime;
+
+ static int iddleTimeout = 180000; // 3 minutes
+ static int acceptTimeout = 180000; // 3 minutes
+
+ static Logger log = LoggerFactory.getLogger(ProxyServer.class);
+ static SocksProxyBase proxy;
+
+ static VpnService vpnService;
+
+ // Public Constructors
+ // ///////////////////
+
+ /**
+ * Creates a proxy server with given Authentication scheme.
+ *
+ * @param auth
+ * Authentication scheme to be used.
+ */
+ public ProxyServer(final ServerAuthenticator auth) {
+ this.auth = auth;
+ }
+
+ // Other constructors
+ // //////////////////
+
+ ProxyServer(final ServerAuthenticator auth, final Socket s) {
+ this.auth = auth;
+ this.sock = s;
+ this.mode = START_MODE;
+ }
+
+ // Public methods
+ // ///////////////
+
+ /**
+ * Set proxy.
+ * <p>
+ * Allows Proxy chaining so that one Proxy server is connected to another
+ * and so on. If proxy supports SOCKSv4, then only some SOCKSv5 requests can
+ * be handled, UDP would not work, however CONNECT and BIND will be
+ * translated.
+ *
+ * @param p
+ * Proxy which should be used to handle user requests.
+ */
+ public static void setProxy(final SocksProxyBase p) {
+ proxy = p;
+ // FIXME: Side effect.
+ UDPRelayServer.proxy = proxy;
+ }
+
+ public static void setVpnService (final VpnService v)
+ {
+ vpnService = v;
+ }
+ /**
+ * Get proxy.
+ *
+ * @return Proxy wich is used to handle user requests.
+ */
+ public static SocksProxyBase getProxy() {
+ return proxy;
+ }
+
+ /**
+ * Sets the timeout for connections, how long shoud server wait for data to
+ * arrive before dropping the connection.<br>
+ * Zero timeout implies infinity.<br>
+ * Default timeout is 3 minutes.
+ */
+ public static void setIddleTimeout(final int timeout) {
+ iddleTimeout = timeout;
+ }
+
+ /**
+ * Sets the timeout for BIND command, how long the server should wait for
+ * the incoming connection.<br>
+ * Zero timeout implies infinity.<br>
+ * Default timeout is 3 minutes.
+ */
+ public static void setAcceptTimeout(final int timeout) {
+ acceptTimeout = timeout;
+ }
+
+ /**
+ * Sets the timeout for UDPRelay server.<br>
+ * Zero timeout implies infinity.<br>
+ * Default timeout is 3 minutes.
+ */
+ public static void setUDPTimeout(final int timeout) {
+ UDPRelayServer.setTimeout(timeout);
+ }
+
+ /**
+ * Sets the size of the datagrams used in the UDPRelayServer.<br>
+ * Default size is 64K, a bit more than maximum possible size of the
+ * datagram.
+ */
+ public static void setDatagramSize(final int size) {
+ UDPRelayServer.setDatagramSize(size);
+ }
+
+ /**
+ * Start the Proxy server at given port.<br>
+ * This methods blocks.
+ */
+ public void start(final int port) {
+ start(port, 5, null);
+ }
+
+ /**
+ * Create a server with the specified port, listen backlog, and local IP
+ * address to bind to. The localIP argument can be used on a multi-homed
+ * host for a ServerSocket that will only accept connect requests to one of
+ * its addresses. If localIP is null, it will default accepting connections
+ * on any/all local addresses. The port must be between 0 and 65535,
+ * inclusive. <br>
+ * This methods blocks.
+ */
+ public void start(final int port, final int backlog,
+ final InetAddress localIP) {
+ try {
+ ss = new ServerSocket(port, backlog, localIP);
+ final String address = ss.getInetAddress().getHostAddress();
+ final int localPort = ss.getLocalPort();
+ log.info("Starting SOCKS Proxy on: {}:{}", address, localPort);
+
+ while (true) {
+ final Socket s = ss.accept();
+ final String hostName = s.getInetAddress().getHostName();
+ final int port2 = s.getPort();
+ log.info("Accepted from:{}:{}", hostName, port2);
+
+ final ProxyServer ps = new ProxyServer(auth, s);
+ (new Thread(ps)).start();
+ }
+ } catch (final IOException ioe) {
+ ioe.printStackTrace();
+ } finally {
+ }
+ }
+
+ /**
+ * Stop server operation.It would be wise to interrupt thread running the
+ * server afterwards.
+ */
+ public void stop() {
+ try {
+ if (ss != null) {
+ ss.close();
+ }
+ } catch (final IOException ioe) {
+ }
+ }
+
+ // Runnable interface
+ // //////////////////
+ public void run() {
+ switch (mode) {
+ case START_MODE:
+ try {
+ startSession();
+ } catch (final IOException ioe) {
+ handleException(ioe);
+ // ioe.printStackTrace();
+ } finally {
+ abort();
+ if (auth != null) {
+ auth.endSession();
+ }
+ log.info("Main thread(client->remote)stopped.");
+ }
+ break;
+ case ACCEPT_MODE:
+ try {
+ doAccept();
+ mode = PIPE_MODE;
+ pipe_thread1.interrupt(); // Tell other thread that connection
+ // have
+ // been accepted.
+ pipe(remote_in, out);
+ } catch (final IOException ioe) {
+ // log("Accept exception:"+ioe);
+ handleException(ioe);
+ } finally {
+ abort();
+ log.info("Accept thread(remote->client) stopped");
+ }
+ break;
+ case PIPE_MODE:
+ try {
+ pipe(remote_in, out);
+ } catch (final IOException ioe) {
+ } finally {
+ abort();
+ log.info("Support thread(remote->client) stopped");
+ }
+ break;
+ case ABORT_MODE:
+ break;
+ default:
+ log.warn("Unexpected MODE " + mode);
+ }
+ }
+
+ // Private methods
+ // ///////////////
+ private void startSession() throws IOException {
+ sock.setSoTimeout(iddleTimeout);
+
+ try {
+ auth = auth.startSession(sock);
+ } catch (final IOException ioe) {
+ log.warn("Auth throwed exception:", ioe);
+ auth = null;
+ return;
+ }
+
+ if (auth == null) { // Authentication failed
+ log.info("Authentication failed");
+ return;
+ }
+
+ in = auth.getInputStream();
+ out = auth.getOutputStream();
+
+ msg = readMsg(in);
+ handleRequest(msg);
+ }
+
+ private void handleRequest(final ProxyMessage msg) throws IOException {
+ if (!auth.checkRequest(msg)) {
+ throw new SocksException(SocksProxyBase.SOCKS_FAILURE);
+ }
+
+ if (msg.ip == null) {
+ if (msg instanceof Socks5Message) {
+ msg.ip = InetAddress.getByName(msg.host);
+ } else {
+ throw new SocksException(SocksProxyBase.SOCKS_FAILURE);
+ }
+ }
+ log(msg);
+
+ switch (msg.command) {
+ case SocksProxyBase.SOCKS_CMD_CONNECT:
+ onConnect(msg);
+ break;
+ case SocksProxyBase.SOCKS_CMD_BIND:
+ onBind(msg);
+ break;
+ case SocksProxyBase.SOCKS_CMD_UDP_ASSOCIATE:
+ onUDP(msg);
+ break;
+ default:
+ throw new SocksException(SocksProxyBase.SOCKS_CMD_NOT_SUPPORTED);
+ }
+ }
+
+ private void handleException(final IOException ioe) {
+ // If we couldn't read the request, return;
+ if (msg == null) {
+ return;
+ }
+ // If have been aborted by other thread
+ if (mode == ABORT_MODE) {
+ return;
+ }
+ // If the request was successfully completed, but exception happened
+ // later
+ if (mode == PIPE_MODE) {
+ return;
+ }
+
+ int error_code = SocksProxyBase.SOCKS_FAILURE;
+
+ if (ioe instanceof SocksException) {
+ error_code = ((SocksException) ioe).errCode;
+ } else if (ioe instanceof NoRouteToHostException) {
+ error_code = SocksProxyBase.SOCKS_HOST_UNREACHABLE;
+ } else if (ioe instanceof ConnectException) {
+ error_code = SocksProxyBase.SOCKS_CONNECTION_REFUSED;
+ } else if (ioe instanceof InterruptedIOException) {
+ error_code = SocksProxyBase.SOCKS_TTL_EXPIRE;
+ }
+
+ if ((error_code > SocksProxyBase.SOCKS_ADDR_NOT_SUPPORTED)
+ || (error_code < 0)) {
+ error_code = SocksProxyBase.SOCKS_FAILURE;
+ }
+
+ sendErrorMessage(error_code);
+ }
+
+ private void onConnect(final ProxyMessage msg) throws IOException {
+ Socket s;
+
+ if (proxy == null) {
+ //s = new Socket(msg.ip, msg.port);
+
+ s= SocketChannel.open().socket();
+ if ((null != s) && (null != vpnService)) {
+ vpnService.protect(s);
+ }
+
+ s.connect(new InetSocketAddress(msg.ip,msg.port));
+
+ } else {
+ s = new SocksSocket(proxy, msg.ip, msg.port);
+ }
+
+ if (vpnService != null)
+ vpnService.protect(s);
+
+ log.info("Connected to " + s.getInetAddress() + ":" + s.getPort());
+
+ ProxyMessage response = null;
+ final InetAddress localAddress = s.getLocalAddress();
+ final int localPort = s.getLocalPort();
+
+ if (msg instanceof Socks5Message) {
+ final int cmd = SocksProxyBase.SOCKS_SUCCESS;
+ response = new Socks5Message(cmd, localAddress, localPort);
+ } else {
+ final int cmd = Socks4Message.REPLY_OK;
+ response = new Socks4Message(cmd, localAddress, localPort);
+
+ }
+ response.write(out);
+ startPipe(s);
+ }
+
+ private void onBind(final ProxyMessage msg) throws IOException {
+ ProxyMessage response = null;
+
+ if (proxy == null) {
+ ss = new ServerSocket(0);
+ } else {
+ ss = new SocksServerSocket(proxy, msg.ip, msg.port);
+ }
+
+ ss.setSoTimeout(acceptTimeout);
+
+ final InetAddress inetAddress = ss.getInetAddress();
+ final int localPort = ss.getLocalPort();
+ log.info("Trying accept on {}:{}", inetAddress, localPort);
+
+ if (msg.version == 5) {
+ final int cmd = SocksProxyBase.SOCKS_SUCCESS;
+ response = new Socks5Message(cmd, inetAddress, localPort);
+ } else {
+ final int cmd = Socks4Message.REPLY_OK;
+ response = new Socks4Message(cmd, inetAddress, localPort);
+ }
+ response.write(out);
+
+ mode = ACCEPT_MODE;
+
+ pipe_thread1 = Thread.currentThread();
+ pipe_thread2 = new Thread(this);
+ pipe_thread2.start();
+
+ // Make timeout infinit.
+ sock.setSoTimeout(0);
+ int eof = 0;
+
+ try {
+ while ((eof = in.read()) >= 0) {
+ if (mode != ACCEPT_MODE) {
+ if (mode != PIPE_MODE) {
+ return;// Accept failed
+ }
+
+ remote_out.write(eof);
+ break;
+ }
+ }
+ } catch (final EOFException e) {
+ log.debug("Connection closed while we were trying to accept", e);
+ return;
+ } catch (final InterruptedIOException e) {
+ log.debug("Interrupted by unsucessful accept thread", e);
+ if (mode != PIPE_MODE) {
+ return;
+ }
+ } finally {
+ // System.out.println("Finnaly!");
+ }
+
+ if (eof < 0) {
+ return;
+ }
+
+ // Do not restore timeout, instead timeout is set on the
+ // remote socket. It does not make any difference.
+
+ pipe(in, remote_out);
+ }
+
+ private void onUDP(final ProxyMessage msg) throws IOException {
+ if (msg.ip.getHostAddress().equals("0.0.0.0")) {
+ msg.ip = sock.getInetAddress();
+ }
+ log.info("Creating UDP relay server for {}:{}", msg.ip, msg.port);
+
+ relayServer = new UDPRelayServer(msg.ip, msg.port,
+ Thread.currentThread(), sock, auth);
+
+ ProxyMessage response;
+
+ response = new Socks5Message(SocksProxyBase.SOCKS_SUCCESS,
+ relayServer.relayIP, relayServer.relayPort);
+
+ response.write(out);
+
+ relayServer.start();
+
+ // Make timeout infinit.
+ sock.setSoTimeout(0);
+ try {
+ while (in.read() >= 0) {
+ /* do nothing */;
+ // FIXME: Consider a slight delay here?
+ }
+ } catch (final EOFException eofe) {
+ }
+ }
+
+ // Private methods
+ // ////////////////
+
+ private void doAccept() throws IOException {
+ Socket s = null;
+ final long startTime = System.currentTimeMillis();
+
+ while (true) {
+ s = ss.accept();
+ if (s.getInetAddress().equals(msg.ip)) {
+ // got the connection from the right host
+ // Close listenning socket.
+ ss.close();
+ break;
+ } else if (ss instanceof SocksServerSocket) {
+ // We can't accept more then one connection
+ s.close();
+ ss.close();
+ throw new SocksException(SocksProxyBase.SOCKS_FAILURE);
+ } else {
+ if (acceptTimeout != 0) { // If timeout is not infinit
+ final long passed = System.currentTimeMillis() - startTime;
+ final int newTimeout = acceptTimeout - (int) passed;
+
+ if (newTimeout <= 0) {
+ throw new InterruptedIOException("newTimeout <= 0");
+ }
+ ss.setSoTimeout(newTimeout);
+ }
+ s.close(); // Drop all connections from other hosts
+ }
+ }
+
+ // Accepted connection
+ remote_sock = s;
+ remote_in = s.getInputStream();
+ remote_out = s.getOutputStream();
+
+ // Set timeout
+ remote_sock.setSoTimeout(iddleTimeout);
+
+ final InetAddress inetAddress = s.getInetAddress();
+ final int port = s.getPort();
+ log.info("Accepted from {}:{}", s.getInetAddress(), port);
+
+ ProxyMessage response;
+
+ if (msg.version == 5) {
+ final int cmd = SocksProxyBase.SOCKS_SUCCESS;
+ response = new Socks5Message(cmd, inetAddress, port);
+ } else {
+ final int cmd = Socks4Message.REPLY_OK;
+ response = new Socks4Message(cmd, inetAddress, port);
+ }
+ response.write(out);
+ }
+
+ private ProxyMessage readMsg(final InputStream in) throws IOException {
+ PushbackInputStream push_in;
+ if (in instanceof PushbackInputStream) {
+ push_in = (PushbackInputStream) in;
+ } else {
+ push_in = new PushbackInputStream(in);
+ }
+
+ final int version = push_in.read();
+ push_in.unread(version);
+
+ ProxyMessage msg;
+
+ if (version == 5) {
+ msg = new Socks5Message(push_in, false);
+ } else if (version == 4) {
+ msg = new Socks4Message(push_in, false);
+ } else {
+ throw new SocksException(SocksProxyBase.SOCKS_FAILURE);
+ }
+ return msg;
+ }
+
+ private void startPipe(final Socket s) {
+ mode = PIPE_MODE;
+ remote_sock = s;
+ try {
+ remote_in = s.getInputStream();
+ remote_out = s.getOutputStream();
+ pipe_thread1 = Thread.currentThread();
+ pipe_thread2 = new Thread(this);
+ pipe_thread2.start();
+ pipe(in, remote_out);
+ } catch (final IOException ioe) {
+ }
+ }
+
+ private void sendErrorMessage(final int error_code) {
+ ProxyMessage err_msg;
+ if (msg instanceof Socks4Message) {
+ err_msg = new Socks4Message(Socks4Message.REPLY_REJECTED);
+ } else {
+ err_msg = new Socks5Message(error_code);
+ }
+ try {
+ err_msg.write(out);
+ } catch (final IOException ioe) {
+ }
+ }
+
+ private synchronized void abort() {
+ if (mode == ABORT_MODE) {
+ return;
+ }
+ mode = ABORT_MODE;
+ try {
+ log.info("Aborting operation");
+ if (remote_sock != null) {
+ remote_sock.close();
+ }
+ if (sock != null) {
+ sock.close();
+ }
+ if (relayServer != null) {
+ relayServer.stop();
+ }
+ if (ss != null) {
+ ss.close();
+ }
+ if (pipe_thread1 != null) {
+ pipe_thread1.interrupt();
+ }
+ if (pipe_thread2 != null) {
+ pipe_thread2.interrupt();
+ }
+ } catch (final IOException ioe) {
+ }
+ }
+
+ static final void log(final ProxyMessage msg) {
+ log.debug("Request version: {}, Command: ", msg.version,
+ command2String(msg.command));
+
+ final String user = msg.version == 4 ? ", User:" + msg.user : "";
+ log.debug("IP:" + msg.ip + ", Port:" + msg.port + user);
+ }
+
+ private void pipe(final InputStream in, final OutputStream out)
+ throws IOException {
+ lastReadTime = System.currentTimeMillis();
+ final byte[] buf = new byte[BUF_SIZE];
+ int len = 0;
+ while (len >= 0) {
+ try {
+ if (len != 0) {
+ out.write(buf, 0, len);
+ out.flush();
+ }
+ len = in.read(buf);
+ lastReadTime = System.currentTimeMillis();
+ } catch (final InterruptedIOException iioe) {
+ if (iddleTimeout == 0) {
+ return;// Other thread interrupted us.
+ }
+ final long timeSinceRead = System.currentTimeMillis()
+ - lastReadTime;
+
+ if (timeSinceRead >= iddleTimeout - 1000) {
+ return;
+ }
+ len = 0;
+
+ }
+ }
+ }
+
+ static final String command_names[] = { "CONNECT", "BIND", "UDP_ASSOCIATE" };
+
+ static final String command2String(int cmd) {
+ if ((cmd > 0) && (cmd < 4)) {
+ return command_names[cmd - 1];
+ } else {
+ return "Unknown Command " + cmd;
+ }
+ }
+}
diff --git a/src/com/runjva/sourceforge/jsocks/protocol/Socks4Message.java b/src/com/runjva/sourceforge/jsocks/protocol/Socks4Message.java
new file mode 100644
index 0000000..484ad96
--- /dev/null
+++ b/src/com/runjva/sourceforge/jsocks/protocol/Socks4Message.java
@@ -0,0 +1,167 @@
+package com.runjva.sourceforge.jsocks.protocol;
+
+import java.io.DataInputStream;
+import java.io.IOException;
+import java.io.InputStream;
+import java.io.OutputStream;
+import java.net.InetAddress;
+import java.net.UnknownHostException;
+
+/**
+ * SOCKS4 Reply/Request message.
+ */
+
+class Socks4Message extends ProxyMessage {
+
+ private byte[] msgBytes;
+ private int msgLength;
+
+ /**
+ * Server failed reply, cmd command for failed request
+ */
+ public Socks4Message(final int cmd) {
+ super(cmd, null, 0);
+ this.user = null;
+
+ msgLength = 2;
+ msgBytes = new byte[2];
+
+ msgBytes[0] = (byte) 0;
+ msgBytes[1] = (byte) command;
+ }
+
+ /**
+ * Server successfull reply
+ */
+ public Socks4Message(final int cmd, final InetAddress ip, final int port) {
+ this(0, cmd, ip, port, null);
+ }
+
+ /**
+ * Client request
+ */
+ public Socks4Message(final int cmd, final InetAddress ip, final int port,
+ final String user) {
+ this(SOCKS_VERSION, cmd, ip, port, user);
+ }
+
+ /**
+ * Most general constructor
+ */
+ public Socks4Message(final int version, final int cmd,
+ final InetAddress ip, final int port, final String user) {
+
+ super(cmd, ip, port);
+ this.user = user;
+ this.version = version;
+
+ msgLength = user == null ? 8 : 9 + user.length();
+ msgBytes = new byte[msgLength];
+
+ msgBytes[0] = (byte) version;
+ msgBytes[1] = (byte) command;
+ msgBytes[2] = (byte) (port >> 8);
+ msgBytes[3] = (byte) port;
+
+ byte[] addr;
+
+ if (ip != null) {
+ addr = ip.getAddress();
+ } else {
+ addr = new byte[4];
+ addr[0] = addr[1] = addr[2] = addr[3] = 0;
+ }
+ System.arraycopy(addr, 0, msgBytes, 4, 4);
+
+ if (user != null) {
+ final byte[] buf = user.getBytes();
+ System.arraycopy(buf, 0, msgBytes, 8, buf.length);
+ msgBytes[msgBytes.length - 1] = 0;
+ }
+ }
+
+ /**
+ * Initialise from the stream If clientMode is true attempts to read a
+ * server response otherwise reads a client request see read for more detail
+ */
+ public Socks4Message(final InputStream in, final boolean clientMode)
+ throws IOException {
+ msgBytes = null;
+ read(in, clientMode);
+ }
+
+ public void read(final InputStream in) throws IOException {
+ read(in, true);
+ }
+
+ public void read(final InputStream in, final boolean clientMode)
+ throws IOException {
+ final DataInputStream d_in = new DataInputStream(in);
+ version = d_in.readUnsignedByte();
+ command = d_in.readUnsignedByte();
+ if (clientMode && (command != REPLY_OK)) {
+ String errMsg;
+ // FIXME: Range should be replaced with cases.
+ if ((command > REPLY_OK) && (command < REPLY_BAD_IDENTD)) {
+ errMsg = replyMessage[command - REPLY_OK];
+ } else {
+ errMsg = "Unknown Reply Code";
+ }
+ throw new SocksException(command, errMsg);
+ }
+ port = d_in.readUnsignedShort();
+ final byte[] addr = new byte[4];
+ d_in.readFully(addr);
+ ip = bytes2IP(addr);
+ host = ip.getHostName();
+ if (!clientMode) {
+ int b = in.read();
+ // FIXME: Hope there are no idiots with user name bigger than this
+ final byte[] userBytes = new byte[256];
+ int i = 0;
+ for (i = 0; (i < userBytes.length) && (b > 0); ++i) {
+ userBytes[i] = (byte) b;
+ b = in.read();
+ }
+ user = new String(userBytes, 0, i);
+ }
+ }
+
+ public void write(final OutputStream out) throws IOException {
+ if (msgBytes == null) {
+ final Socks4Message msg;
+ msg = new Socks4Message(version, command, ip, port, user);
+ msgBytes = msg.msgBytes;
+ msgLength = msg.msgLength;
+ }
+ out.write(msgBytes);
+ }
+
+ // Class methods
+ static InetAddress bytes2IP(final byte[] addr) {
+ final String s = bytes2IPV4(addr, 0);
+ try {
+ return InetAddress.getByName(s);
+ } catch (final UnknownHostException uh_ex) {
+ return null;
+ }
+ }
+
+ // Constants
+
+ static final String[] replyMessage = { "Request Granted",
+ "Request Rejected or Failed",
+ "Failed request, can't connect to Identd",
+ "Failed request, bad user name" };
+
+ static final int SOCKS_VERSION = 4;
+
+ public final static int REQUEST_CONNECT = 1;
+ public final static int REQUEST_BIND = 2;
+
+ public final static int REPLY_OK = 90;
+ public final static int REPLY_REJECTED = 91;
+ public final static int REPLY_NO_CONNECT = 92;
+ public final static int REPLY_BAD_IDENTD = 93;
+
+}
diff --git a/src/com/runjva/sourceforge/jsocks/protocol/Socks4Proxy.java b/src/com/runjva/sourceforge/jsocks/protocol/Socks4Proxy.java
new file mode 100644
index 0000000..ac4363b
--- /dev/null
+++ b/src/com/runjva/sourceforge/jsocks/protocol/Socks4Proxy.java
@@ -0,0 +1,144 @@
+package com.runjva.sourceforge.jsocks.protocol;
+
+import java.io.IOException;
+import java.io.InputStream;
+import java.net.InetAddress;
+import java.net.UnknownHostException;
+
+/**
+ * Proxy which describes SOCKS4 proxy.
+ */
+
+public class Socks4Proxy extends SocksProxyBase implements Cloneable {
+
+ // Data members
+ String user;
+
+ // Public Constructors
+ // ====================
+
+ /**
+ * Creates the SOCKS4 proxy
+ *
+ * @param p
+ * Proxy to use to connect to this proxy, allows proxy chaining.
+ * @param proxyHost
+ * Address of the proxy server.
+ * @param proxyPort
+ * Port of the proxy server
+ * @param user
+ * User name to use for identification purposes.
+ * @throws UnknownHostException
+ * If proxyHost can't be resolved.
+ */
+ public Socks4Proxy(SocksProxyBase p, String proxyHost, int proxyPort,
+ String user) throws UnknownHostException {
+ super(p, proxyHost, proxyPort);
+ this.user = new String(user);
+ version = 4;
+ }
+
+ /**
+ * Creates the SOCKS4 proxy
+ *
+ * @param proxyHost
+ * Address of the proxy server.
+ * @param proxyPort
+ * Port of the proxy server
+ * @param user
+ * User name to use for identification purposes.
+ * @throws UnknownHostException
+ * If proxyHost can't be resolved.
+ */
+ public Socks4Proxy(String proxyHost, int proxyPort, String user)
+ throws UnknownHostException {
+ this(null, proxyHost, proxyPort, user);
+ }
+
+ /**
+ * Creates the SOCKS4 proxy
+ *
+ * @param p
+ * Proxy to use to connect to this proxy, allows proxy chaining.
+ * @param proxyIP
+ * Address of the proxy server.
+ * @param proxyPort
+ * Port of the proxy server
+ * @param user
+ * User name to use for identification purposes.
+ */
+ public Socks4Proxy(SocksProxyBase p, InetAddress proxyIP, int proxyPort,
+ String user) {
+ super(p, proxyIP, proxyPort);
+ this.user = new String(user);
+ version = 4;
+ }
+
+ /**
+ * Creates the SOCKS4 proxy
+ *
+ * @param proxyIP
+ * Address of the proxy server.
+ * @param proxyPort
+ * Port of the proxy server
+ * @param user
+ * User name to use for identification purposes.
+ */
+ public Socks4Proxy(InetAddress proxyIP, int proxyPort, String user) {
+ this(null, proxyIP, proxyPort, user);
+ }
+
+ // Public instance methods
+ // ========================
+
+ /**
+ * Creates a clone of this proxy. Changes made to the clone should not
+ * affect this object.
+ */
+ public Object clone() {
+ final Socks4Proxy newProxy = new Socks4Proxy(proxyIP, proxyPort, user);
+ newProxy.directHosts = (InetRange) directHosts.clone();
+ newProxy.chainProxy = chainProxy;
+ return newProxy;
+ }
+
+ // Public Static(Class) Methods
+ // ==============================
+
+ // Protected Methods
+ // =================
+
+ protected SocksProxyBase copy() {
+ final Socks4Proxy copy = new Socks4Proxy(proxyIP, proxyPort, user);
+ copy.directHosts = this.directHosts;
+ copy.chainProxy = chainProxy;
+ return copy;
+ }
+
+ protected ProxyMessage formMessage(int cmd, InetAddress ip, int port) {
+ switch (cmd) {
+ case SOCKS_CMD_CONNECT:
+ cmd = Socks4Message.REQUEST_CONNECT;
+ break;
+ case SOCKS_CMD_BIND:
+ cmd = Socks4Message.REQUEST_BIND;
+ break;
+ default:
+ return null;
+ }
+ return new Socks4Message(cmd, ip, port, user);
+ }
+
+ protected ProxyMessage formMessage(int cmd, String host, int port)
+ throws UnknownHostException {
+
+ return formMessage(cmd, InetAddress.getByName(host), port);
+ }
+
+ protected ProxyMessage formMessage(InputStream in) throws SocksException,
+ IOException {
+
+ return new Socks4Message(in, true);
+ }
+
+}
diff --git a/src/com/runjva/sourceforge/jsocks/protocol/Socks5DatagramSocket.java b/src/com/runjva/sourceforge/jsocks/protocol/Socks5DatagramSocket.java
new file mode 100644
index 0000000..6dcaf44
--- /dev/null
+++ b/src/com/runjva/sourceforge/jsocks/protocol/Socks5DatagramSocket.java
@@ -0,0 +1,485 @@
+package com.runjva.sourceforge.jsocks.protocol;
+
+import java.io.ByteArrayInputStream;
+import java.io.IOException;
+import java.io.InterruptedIOException;
+import java.net.DatagramPacket;
+import java.net.DatagramSocket;
+import java.net.InetAddress;
+
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+
+/**
+ * Datagram socket to interract through the firewall.<BR>
+ * Can be used same way as the normal DatagramSocket. One should be carefull
+ * though with the datagram sizes used, as additional data is present in both
+ * incomming and outgoing datagrams.
+ * <p>
+ * SOCKS5 protocol allows to send host address as either:
+ * <ul>
+ * <li>IPV4, normal 4 byte address. (10 bytes header size)
+ * <li>IPV6, version 6 ip address (not supported by Java as for now). 22 bytes
+ * header size.
+ * <li>Host name,(7+length of the host name bytes header size).
+ * </ul>
+ * As with other Socks equivalents, direct addresses are handled transparently,
+ * that is data will be send directly when required by the proxy settings.
+ * <p>
+ * <b>NOTE:</b><br>
+ * Unlike other SOCKS Sockets, it <b>does not</b> support proxy chaining, and
+ * will throw an exception if proxy has a chain proxy attached. The reason for
+ * that is not my laziness, but rather the restrictions of the SOCKSv5 protocol.
+ * Basicaly SOCKSv5 proxy server, needs to know from which host:port datagrams
+ * will be send for association, and returns address to which datagrams should
+ * be send by the client, but it does not inform client from which host:port it
+ * is going to send datagrams, in fact there is even no guarantee they will be
+ * send at all and from the same address each time.
+ */
+public class Socks5DatagramSocket extends DatagramSocket {
+
+ InetAddress relayIP;
+ int relayPort;
+ Socks5Proxy proxy;
+ private boolean server_mode = false;
+ UDPEncapsulation encapsulation;
+
+ private Logger log = LoggerFactory.getLogger(Socks5DatagramSocket.class);
+
+ /**
+ * Construct Datagram socket for communication over SOCKS5 proxy server.
+ * This constructor uses default proxy, the one set with
+ * Proxy.setDefaultProxy() method. If default proxy is not set or it is set
+ * to version4 proxy, which does not support datagram forwarding, throws
+ * SocksException.
+ */
+ public Socks5DatagramSocket() throws SocksException, IOException {
+ this(SocksProxyBase.defaultProxy, 0, null);
+ }
+
+ /**
+ * Construct Datagram socket for communication over SOCKS5 proxy server. And
+ * binds it to the specified local port. This constructor uses default
+ * proxy, the one set with Proxy.setDefaultProxy() method. If default proxy
+ * is not set or it is set to version4 proxy, which does not support
+ * datagram forwarding, throws SocksException.
+ */
+ public Socks5DatagramSocket(int port) throws SocksException, IOException {
+ this(SocksProxyBase.defaultProxy, port, null);
+ }
+
+ /**
+ * Construct Datagram socket for communication over SOCKS5 proxy server. And
+ * binds it to the specified local port and address. This constructor uses
+ * default proxy, the one set with Proxy.setDefaultProxy() method. If
+ * default proxy is not set or it is set to version4 proxy, which does not
+ * support datagram forwarding, throws SocksException.
+ */
+ public Socks5DatagramSocket(int port, InetAddress ip)
+ throws SocksException, IOException {
+ this(SocksProxyBase.defaultProxy, port, ip);
+ }
+
+ /**
+ * Constructs datagram socket for communication over specified proxy. And
+ * binds it to the given local address and port. Address of null and port of
+ * 0, signify any availabale port/address. Might throw SocksException, if:
+ * <ol>
+ * <li>Given version of proxy does not support UDP_ASSOCIATE.
+ * <li>Proxy can't be reached.
+ * <li>Authorization fails.
+ * <li>Proxy does not want to perform udp forwarding, for any reason.
+ * </ol>
+ * Might throw IOException if binding datagram socket to given address/port
+ * fails. See java.net.DatagramSocket for more details.
+ */
+ public Socks5DatagramSocket(SocksProxyBase p, int port, InetAddress ip)
+ throws SocksException, IOException {
+
+ super(port, ip);
+
+ if (p == null) {
+ throw new SocksException(SocksProxyBase.SOCKS_NO_PROXY);
+ }
+
+ if (!(p instanceof Socks5Proxy)) {
+ final String s = "Datagram Socket needs Proxy version 5";
+ throw new SocksException(-1, s);
+ }
+
+ if (p.chainProxy != null) {
+ final String s = "Datagram Sockets do not support proxy chaining.";
+ throw new SocksException(SocksProxyBase.SOCKS_JUST_ERROR, s);
+ }
+
+ proxy = (Socks5Proxy) p.copy();
+
+ final ProxyMessage msg = proxy.udpAssociate(super.getLocalAddress(),
+ super.getLocalPort());
+
+ relayIP = msg.ip;
+ if (relayIP.getHostAddress().equals("0.0.0.0")) {
+ // FIXME: What happens here?
+ relayIP = proxy.proxyIP;
+ }
+ relayPort = msg.port;
+
+ encapsulation = proxy.udp_encapsulation;
+
+ log.debug("Datagram Socket:{}:{}", getLocalAddress(), getLocalPort());
+ log.debug("Socks5Datagram: {}:{}", relayIP, relayPort);
+ }
+
+ /**
+ * Used by UDPRelayServer.
+ */
+ Socks5DatagramSocket(boolean server_mode, UDPEncapsulation encapsulation,
+ InetAddress relayIP, int relayPort) throws IOException {
+ super();
+ this.server_mode = server_mode;
+ this.relayIP = relayIP;
+ this.relayPort = relayPort;
+ this.encapsulation = encapsulation;
+ this.proxy = null;
+ }
+
+ /**
+ * Sends the Datagram either through the proxy or directly depending on
+ * current proxy settings and destination address. <BR>
+ *
+ * <B> NOTE: </B> DatagramPacket size should be at least 10 bytes less than
+ * the systems limit.
+ *
+ * <P>
+ * See documentation on java.net.DatagramSocket for full details on how to
+ * use this method.
+ *
+ * @param dp
+ * Datagram to send.
+ * @throws IOException
+ * If error happens with I/O.
+ */
+ public void send(DatagramPacket dp) throws IOException {
+ // If the host should be accessed directly, send it as is.
+ if (!server_mode && proxy.isDirect(dp.getAddress())) {
+ super.send(dp);
+ log.debug("Sending datagram packet directly:");
+ return;
+ }
+
+ final byte[] head = formHeader(dp.getAddress(), dp.getPort());
+ byte[] buf = new byte[head.length + dp.getLength()];
+ final byte[] data = dp.getData();
+
+ // Merge head and data
+ System.arraycopy(head, 0, buf, 0, head.length);
+ // System.arraycopy(data,dp.getOffset(),buf,head.length,dp.getLength());
+ System.arraycopy(data, 0, buf, head.length, dp.getLength());
+
+ if (encapsulation != null) {
+ buf = encapsulation.udpEncapsulate(buf, true);
+ }
+
+ super.send(new DatagramPacket(buf, buf.length, relayIP, relayPort));
+ }
+
+ /**
+ * This method allows to send datagram packets with address type DOMAINNAME.
+ * SOCKS5 allows to specify host as names rather than ip addresses.Using
+ * this method one can send udp datagrams through the proxy, without having
+ * to know the ip address of the destination host.
+ * <p>
+ * If proxy specified for that socket has an option resolveAddrLocally set
+ * to true host will be resolved, and the datagram will be send with address
+ * type IPV4, if resolve fails, UnknownHostException is thrown.
+ *
+ * @param dp
+ * Datagram to send, it should contain valid port and data
+ * @param host
+ * Host name to which datagram should be send.
+ * @throws IOException
+ * If error happens with I/O, or the host can't be resolved when
+ * proxy settings say that hosts should be resolved locally.
+ * @see Socks5Proxy#resolveAddrLocally(boolean)
+ */
+ public void send(DatagramPacket dp, String host) throws IOException {
+ if (proxy.isDirect(host)) {
+ dp.setAddress(InetAddress.getByName(host));
+ super.send(dp);
+ return;
+ }
+
+ if ((proxy).resolveAddrLocally) {
+ dp.setAddress(InetAddress.getByName(host));
+ }
+
+ final byte[] head = formHeader(host, dp.getPort());
+ byte[] buf = new byte[head.length + dp.getLength()];
+ final byte[] data = dp.getData();
+ // Merge head and data
+ System.arraycopy(head, 0, buf, 0, head.length);
+ // System.arraycopy(data,dp.getOffset(),buf,head.length,dp.getLength());
+ System.arraycopy(data, 0, buf, head.length, dp.getLength());
+
+ if (encapsulation != null) {
+ buf = encapsulation.udpEncapsulate(buf, true);
+ }
+
+ super.send(new DatagramPacket(buf, buf.length, relayIP, relayPort));
+ }
+
+ /**
+ * Receives udp packet. If packet have arrived from the proxy relay server,
+ * it is processed and address and port of the packet are set to the address
+ * and port of sending host.<BR>
+ * If the packet arrived from anywhere else it is not changed.<br>
+ * <B> NOTE: </B> DatagramPacket size should be at least 10 bytes bigger
+ * than the largest packet you expect (this is for IPV4 addresses). For
+ * hostnames and IPV6 it is even more.
+ *
+ * @param dp
+ * Datagram in which all relevent information will be copied.
+ */
+ public void receive(DatagramPacket dp) throws IOException {
+ super.receive(dp);
+
+ if (server_mode) {
+ // Drop all datagrams not from relayIP/relayPort
+ final int init_length = dp.getLength();
+ final int initTimeout = getSoTimeout();
+ final long startTime = System.currentTimeMillis();
+
+ while (!relayIP.equals(dp.getAddress())
+ || (relayPort != dp.getPort())) {
+
+ // Restore datagram size
+ dp.setLength(init_length);
+
+ // If there is a non-infinit timeout on this socket
+ // Make sure that it happens no matter how often unexpected
+ // packets arrive.
+ if (initTimeout != 0) {
+ final long passed = System.currentTimeMillis() - startTime;
+ final int newTimeout = initTimeout - (int) passed;
+
+ if (newTimeout <= 0) {
+ throw new InterruptedIOException(
+ "In Socks5DatagramSocket->receive()");
+ }
+ setSoTimeout(newTimeout);
+ }
+
+ super.receive(dp);
+ }
+
+ // Restore timeout settings
+ if (initTimeout != 0) {
+ setSoTimeout(initTimeout);
+ }
+
+ } else if (!relayIP.equals(dp.getAddress())
+ || (relayPort != dp.getPort())) {
+ return; // Recieved direct packet
+ // If the datagram is not from the relay server, return it it as is.
+ }
+
+ byte[] data;
+ data = dp.getData();
+
+ if (encapsulation != null) {
+ data = encapsulation.udpEncapsulate(data, false);
+ }
+
+ // FIXME: What is this?
+ final int offset = 0; // Java 1.1
+ // int offset = dp.getOffset(); //Java 1.2
+
+ final ByteArrayInputStream bIn = new ByteArrayInputStream(data, offset,
+ dp.getLength());
+
+ final ProxyMessage msg = new Socks5Message(bIn);
+ dp.setPort(msg.port);
+ dp.setAddress(msg.getInetAddress());
+
+ // what wasn't read by the Message is the data
+ final int data_length = bIn.available();
+ // Shift data to the left
+ System.arraycopy(data, offset + dp.getLength() - data_length, data,
+ offset, data_length);
+
+ dp.setLength(data_length);
+ }
+
+ /**
+ * Returns port assigned by the proxy, to which datagrams are relayed. It is
+ * not the same port to which other party should send datagrams.
+ *
+ * @return Port assigned by socks server to which datagrams are send for
+ * association.
+ */
+ public int getLocalPort() {
+ if (server_mode) {
+ return super.getLocalPort();
+ }
+ return relayPort;
+ }
+
+ /**
+ * Address assigned by the proxy, to which datagrams are send for relay. It
+ * is not necesseraly the same address, to which other party should send
+ * datagrams.
+ *
+ * @return Address to which datagrams are send for association.
+ */
+ public InetAddress getLocalAddress() {
+ if (server_mode) {
+ return super.getLocalAddress();
+ }
+ return relayIP;
+ }
+
+ /**
+ * Closes datagram socket, and proxy connection.
+ */
+ public void close() {
+ if (!server_mode) {
+ proxy.endSession();
+ }
+ super.close();
+ }
+
+ /**
+ * This method checks wether proxy still runs udp forwarding service for
+ * this socket.
+ * <p>
+ * This methods checks wether the primary connection to proxy server is
+ * active. If it is, chances are that proxy continues to forward datagrams
+ * being send from this socket. If it was closed, most likely datagrams are
+ * no longer being forwarded by the server.
+ * <p>
+ * Proxy might decide to stop forwarding datagrams, in which case it should
+ * close primary connection. This method allows to check, wether this have
+ * been done.
+ * <p>
+ * You can specify timeout for which we should be checking EOF condition on
+ * the primary connection. Timeout is in milliseconds. Specifying 0 as
+ * timeout implies infinity, in which case method will block, until
+ * connection to proxy is closed or an error happens, and then return false.
+ * <p>
+ * One possible scenario is to call isProxyactive(0) in separate thread, and
+ * once it returned notify other threads about this event.
+ *
+ * @param timeout
+ * For how long this method should block, before returning.
+ * @return true if connection to proxy is active, false if eof or error
+ * condition have been encountered on the connection.
+ */
+ public boolean isProxyAlive(int timeout) {
+ if (server_mode) {
+ return false;
+ }
+ if (proxy != null) {
+ try {
+ proxy.proxySocket.setSoTimeout(timeout);
+
+ final int eof = proxy.in.read();
+ if (eof < 0) {
+ return false; // EOF encountered.
+ } else {
+ log.warn("This really should not happen");
+ return true; // This really should not happen
+ }
+
+ } catch (final InterruptedIOException iioe) {
+ return true; // read timed out.
+ } catch (final IOException ioe) {
+ return false;
+ }
+ }
+ return false;
+ }
+
+ // PRIVATE METHODS
+ // ////////////////
+
+ private byte[] formHeader(InetAddress ip, int port) {
+ final Socks5Message request = new Socks5Message(0, ip, port);
+ request.data[0] = 0;
+ return request.data;
+ }
+
+ private byte[] formHeader(String host, int port) {
+ final Socks5Message request = new Socks5Message(0, host, port);
+ request.data[0] = 0;
+ return request.data;
+ }
+
+ /*
+ * ======================================================================
+ *
+ * //Mainly Test functions //////////////////////
+ *
+ * private String bytes2String(byte[] b){ String s=""; char[] hex_digit = {
+ * '0','1','2','3','4','5','6','7','8','9', 'A','B','C','D','E','F'};
+ * for(int i=0;i<b.length;++i){ int i1 = (b[i] & 0xF0) >> 4; int i2 = b[i] &
+ * 0xF; s+=hex_digit[i1]; s+=hex_digit[i2]; s+=" "; } return s; } private
+ * static final void debug(String s){ if(DEBUG) System.out.print(s); }
+ *
+ * private static final boolean DEBUG = true;
+ *
+ *
+ * public static void usage(){ System.err.print(
+ * "Usage: java Socks.SocksDatagramSocket host port [socksHost socksPort]\n"
+ * ); }
+ *
+ * static final int defaultProxyPort = 1080; //Default Port static final
+ * String defaultProxyHost = "www-proxy"; //Default proxy
+ *
+ * public static void main(String args[]){ int port; String host; int
+ * proxyPort; String proxyHost; InetAddress ip;
+ *
+ * if(args.length > 1 && args.length < 5){ try{
+ *
+ * host = args[0]; port = Integer.parseInt(args[1]);
+ *
+ * proxyPort =(args.length > 3)? Integer.parseInt(args[3]) :
+ * defaultProxyPort;
+ *
+ * host = args[0]; ip = InetAddress.getByName(host);
+ *
+ * proxyHost =(args.length > 2)? args[2] : defaultProxyHost;
+ *
+ * Proxy.setDefaultProxy(proxyHost,proxyPort); Proxy p =
+ * Proxy.getDefaultProxy(); p.addDirect("lux");
+ *
+ *
+ * DatagramSocket ds = new Socks5DatagramSocket();
+ *
+ *
+ * BufferedReader in = new BufferedReader( new
+ * InputStreamReader(System.in)); String s;
+ *
+ * System.out.print("Enter line:"); s = in.readLine();
+ *
+ * while(s != null){ byte[] data = (s+"\r\n").getBytes(); DatagramPacket dp
+ * = new DatagramPacket(data,0,data.length, ip,port);
+ * System.out.println("Sending to: "+ip+":"+port); ds.send(dp); dp = new
+ * DatagramPacket(new byte[1024],1024);
+ *
+ * System.out.println("Trying to recieve on port:"+ ds.getLocalPort());
+ * ds.receive(dp); System.out.print("Recieved:\n"+
+ * "From:"+dp.getAddress()+":"+dp.getPort()+ "\n\n"+ new
+ * String(dp.getData(),dp.getOffset(),dp.getLength())+"\n" );
+ * System.out.print("Enter line:"); s = in.readLine();
+ *
+ * } ds.close(); System.exit(1);
+ *
+ * }catch(SocksException s_ex){ System.err.println("SocksException:"+s_ex);
+ * s_ex.printStackTrace(); System.exit(1); }catch(IOException io_ex){
+ * io_ex.printStackTrace(); System.exit(1); }catch(NumberFormatException
+ * num_ex){ usage(); num_ex.printStackTrace(); System.exit(1); }
+ *
+ * }else{ usage(); } }
+ */
+
+}
diff --git a/src/com/runjva/sourceforge/jsocks/protocol/Socks5Message.java b/src/com/runjva/sourceforge/jsocks/protocol/Socks5Message.java
new file mode 100644
index 0000000..0f24715
--- /dev/null
+++ b/src/com/runjva/sourceforge/jsocks/protocol/Socks5Message.java
@@ -0,0 +1,330 @@
+package com.runjva.sourceforge.jsocks.protocol;
+
+import java.io.DataInputStream;
+import java.io.IOException;
+import java.io.InputStream;
+import java.io.OutputStream;
+import java.net.InetAddress;
+import java.net.UnknownHostException;
+
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+
+/**
+ * SOCKS5 request/response message.
+ */
+
+class Socks5Message extends ProxyMessage {
+ /** Address type of given message */
+ public int addrType;
+
+ byte[] data;
+
+ private Logger log = LoggerFactory.getLogger(Socks5Message.class);
+
+ /**
+ * Server error response.
+ *
+ * @param cmd
+ * Error code.
+ */
+ public Socks5Message(int cmd) {
+ super(cmd, null, 0);
+ data = new byte[3];
+ data[0] = SOCKS_VERSION; // Version.
+ data[1] = (byte) cmd; // Reply code for some kind of failure.
+ data[2] = 0; // Reserved byte.
+ }
+
+ /**
+ * Construct client request or server response.
+ *
+ * @param cmd
+ * - Request/Response code.
+ * @param ip
+ * - IP field.
+ * @paarm port - port field.
+ */
+ public Socks5Message(int cmd, InetAddress ip, int port) {
+ super(cmd, ip, port);
+
+ if (ip == null) {
+ this.host = "0.0.0.0";
+ } else {
+ this.host = ip.getHostName();
+ }
+
+ this.version = SOCKS_VERSION;
+
+ byte[] addr;
+
+ if (ip == null) {
+ addr = new byte[4];
+ addr[0] = addr[1] = addr[2] = addr[3] = 0;
+ } else {
+ addr = ip.getAddress();
+ }
+
+ if (addr.length == 4) {
+ addrType = SOCKS_ATYP_IPV4;
+ } else {
+ addrType = SOCKS_ATYP_IPV6;
+ }
+
+ data = new byte[6 + addr.length];
+ data[0] = (byte) SOCKS_VERSION; // Version
+ data[1] = (byte) command; // Command
+ data[2] = (byte) 0; // Reserved byte
+ data[3] = (byte) addrType; // Address type
+
+ // Put Address
+ System.arraycopy(addr, 0, data, 4, addr.length);
+ // Put port
+ data[data.length - 2] = (byte) (port >> 8);
+ data[data.length - 1] = (byte) (port);
+ }
+
+ /**
+ * Construct client request or server response.
+ *
+ * @param cmd
+ * - Request/Response code.
+ * @param hostName
+ * - IP field as hostName, uses ADDR_TYPE of HOSTNAME.
+ * @paarm port - port field.
+ */
+ public Socks5Message(int cmd, String hostName, int port) {
+ super(cmd, null, port);
+ this.host = hostName;
+ this.version = SOCKS_VERSION;
+
+ log.debug("Doing ATYP_DOMAINNAME");
+
+ addrType = SOCKS_ATYP_DOMAINNAME;
+ final byte addr[] = hostName.getBytes();
+
+ data = new byte[7 + addr.length];
+ data[0] = (byte) SOCKS_VERSION; // Version
+ data[1] = (byte) command; // Command
+ data[2] = (byte) 0; // Reserved byte
+ data[3] = (byte) SOCKS_ATYP_DOMAINNAME; // Address type
+ data[4] = (byte) addr.length; // Length of the address
+
+ // Put Address
+ System.arraycopy(addr, 0, data, 5, addr.length);
+ // Put port
+ data[data.length - 2] = (byte) (port >> 8);
+ data[data.length - 1] = (byte) (port);
+ }
+
+ /**
+ * Initialises Message from the stream. Reads server response from given
+ * stream.
+ *
+ * @param in
+ * Input stream to read response from.
+ * @throws SocksException
+ * If server response code is not SOCKS_SUCCESS(0), or if any
+ * error with protocol occurs.
+ * @throws IOException
+ * If any error happens with I/O.
+ */
+ public Socks5Message(InputStream in) throws SocksException, IOException {
+ this(in, true);
+ }
+
+ /**
+ * Initialises Message from the stream. Reads server response or client
+ * request from given stream.
+ *
+ * @param in
+ * Input stream to read response from.
+ * @param clinetMode
+ * If true read server response, else read client request.
+ * @throws SocksException
+ * If server response code is not SOCKS_SUCCESS(0) and reading
+ * in client mode, or if any error with protocol occurs.
+ * @throws IOException
+ * If any error happens with I/O.
+ */
+ public Socks5Message(InputStream in, boolean clientMode)
+ throws SocksException, IOException {
+
+ read(in, clientMode);
+ }
+
+ /**
+ * Initialises Message from the stream. Reads server response from given
+ * stream.
+ *
+ * @param in
+ * Input stream to read response from.
+ * @throws SocksException
+ * If server response code is not SOCKS_SUCCESS(0), or if any
+ * error with protocol occurs.
+ * @throws IOException
+ * If any error happens with I/O.
+ */
+ public void read(InputStream in) throws SocksException, IOException {
+ read(in, true);
+ }
+
+ /**
+ * Initialises Message from the stream. Reads server response or client
+ * request from given stream.
+ *
+ * @param in
+ * Input stream to read response from.
+ * @param clinetMode
+ * If true read server response, else read client request.
+ * @throws SocksException
+ * If server response code is not SOCKS_SUCCESS(0) and reading
+ * in client mode, or if any error with protocol occurs.
+ * @throws IOException
+ * If any error happens with I/O.
+ */
+ public void read(InputStream in, boolean clientMode) throws SocksException,
+ IOException {
+
+ data = null;
+ ip = null;
+
+ final DataInputStream di = new DataInputStream(in);
+
+ version = di.readUnsignedByte();
+ command = di.readUnsignedByte();
+
+ if (clientMode && (command != 0)) {
+ throw new SocksException(command);
+ }
+
+ di.readUnsignedByte();
+ addrType = di.readUnsignedByte();
+
+ byte addr[];
+
+ switch (addrType) {
+ case SOCKS_ATYP_IPV4:
+ addr = new byte[4];
+ di.readFully(addr);
+ host = bytes2IPV4(addr, 0);
+ break;
+ case SOCKS_ATYP_IPV6:
+ addr = new byte[SOCKS_IPV6_LENGTH];// I believe it is 16 bytes,huge!
+ di.readFully(addr);
+ host = bytes2IPV6(addr, 0);
+ break;
+ case SOCKS_ATYP_DOMAINNAME:
+ log.debug("Reading ATYP_DOMAINNAME");
+ addr = new byte[di.readUnsignedByte()];// Next byte shows the length
+ di.readFully(addr);
+ host = new String(addr);
+ break;
+ default:
+ throw (new SocksException(SocksProxyBase.SOCKS_JUST_ERROR));
+ }
+
+ port = di.readUnsignedShort();
+
+ if ((addrType != SOCKS_ATYP_DOMAINNAME) && doResolveIP) {
+ try {
+ ip = InetAddress.getByName(host);
+ } catch (final UnknownHostException uh_ex) {
+ }
+ }
+ }
+
+ /**
+ * Writes the message to the stream.
+ *
+ * @param out
+ * Output stream to which message should be written.
+ */
+ public void write(OutputStream out) throws SocksException, IOException {
+ if (data == null) {
+ Socks5Message msg;
+
+ if (addrType == SOCKS_ATYP_DOMAINNAME) {
+ msg = new Socks5Message(command, host, port);
+ } else {
+ if (ip == null) {
+ try {
+ ip = InetAddress.getByName(host);
+ } catch (final UnknownHostException uh_ex) {
+ throw new SocksException(
+ SocksProxyBase.SOCKS_JUST_ERROR);
+ }
+ }
+ msg = new Socks5Message(command, ip, port);
+ }
+ data = msg.data;
+ }
+ out.write(data);
+ }
+
+ /**
+ * Returns IP field of the message as IP, if the message was created with
+ * ATYP of HOSTNAME, it will attempt to resolve the hostname, which might
+ * fail.
+ *
+ * @throws UnknownHostException
+ * if host can't be resolved.
+ */
+ public InetAddress getInetAddress() throws UnknownHostException {
+ if (ip != null) {
+ return ip;
+ }
+
+ return (ip = InetAddress.getByName(host));
+ }
+
+ /**
+ * Returns string representation of the message.
+ */
+ public String toString() {
+ // FIXME: Single line version, please.
+ final String s = "Socks5Message:" + "\n" + "VN " + version + "\n"
+ + "CMD " + command + "\n" + "ATYP " + addrType + "\n"
+ + "ADDR " + host + "\n" + "PORT " + port + "\n";
+ return s;
+ }
+
+ /**
+ *Wether to resolve hostIP returned from SOCKS server that is wether to
+ * create InetAddress object from the hostName string
+ */
+ static public boolean resolveIP() {
+ return doResolveIP;
+ }
+
+ /**
+ *Wether to resolve hostIP returned from SOCKS server that is wether to
+ * create InetAddress object from the hostName string
+ *
+ * @param doResolve
+ * Wether to resolve hostIP from SOCKS server.
+ *@return Previous value.
+ */
+ static public boolean resolveIP(boolean doResolve) {
+ final boolean old = doResolveIP;
+ doResolveIP = doResolve;
+ return old;
+ }
+
+ /*
+ * private static final void debug(String s){ if(DEBUG) System.out.print(s);
+ * } private static final boolean DEBUG = false;
+ */
+
+ // SOCKS5 constants
+ public static final int SOCKS_VERSION = 5;
+
+ public static final int SOCKS_ATYP_IPV4 = 0x1; // Where is 2??
+ public static final int SOCKS_ATYP_DOMAINNAME = 0x3; // !!!!rfc1928
+ public static final int SOCKS_ATYP_IPV6 = 0x4;
+
+ public static final int SOCKS_IPV6_LENGTH = 16;
+
+ static boolean doResolveIP = true;
+
+}
diff --git a/src/com/runjva/sourceforge/jsocks/protocol/Socks5Proxy.java b/src/com/runjva/sourceforge/jsocks/protocol/Socks5Proxy.java
new file mode 100644
index 0000000..7400aa6
--- /dev/null
+++ b/src/com/runjva/sourceforge/jsocks/protocol/Socks5Proxy.java
@@ -0,0 +1,295 @@
+package com.runjva.sourceforge.jsocks.protocol;
+
+import java.io.IOException;
+import java.io.InputStream;
+import java.io.OutputStream;
+import java.net.InetAddress;
+import java.net.Socket;
+import java.net.SocketException;
+import java.net.UnknownHostException;
+import java.util.Enumeration;
+import java.util.Hashtable;
+
+/**
+ * SOCKS5 Proxy.
+ */
+
+public class Socks5Proxy extends SocksProxyBase implements Cloneable {
+
+ // Data members
+ private Hashtable<Integer, Authentication> authMethods = new Hashtable<Integer, Authentication>();
+ private int selectedMethod;
+
+ boolean resolveAddrLocally = true;
+ UDPEncapsulation udp_encapsulation = null;
+
+ // Public Constructors
+ // ====================
+
+ /**
+ * Creates SOCKS5 proxy.
+ *
+ * @param p
+ * Proxy to use to connect to this proxy, allows proxy chaining.
+ * @param proxyHost
+ * Host on which a Proxy server runs.
+ * @param proxyPort
+ * Port on which a Proxy server listens for connections.
+ * @throws UnknownHostException
+ * If proxyHost can't be resolved.
+ */
+ public Socks5Proxy(SocksProxyBase p, String proxyHost, int proxyPort)
+ throws UnknownHostException {
+
+ super(p, proxyHost, proxyPort);
+ version = 5;
+ setAuthenticationMethod(0, new AuthenticationNone());
+ }
+
+ /**
+ * Creates SOCKS5 proxy.
+ *
+ * @param proxyHost
+ * Host on which a Proxy server runs.
+ * @param proxyPort
+ * Port on which a Proxy server listens for connections.
+ * @throws UnknownHostException
+ * If proxyHost can't be resolved.
+ */
+ public Socks5Proxy(String proxyHost, int proxyPort)
+ throws UnknownHostException {
+ this(null, proxyHost, proxyPort);
+ }
+
+ /**
+ * Creates SOCKS5 proxy.
+ *
+ * @param p
+ * Proxy to use to connect to this proxy, allows proxy chaining.
+ * @param proxyIP
+ * Host on which a Proxy server runs.
+ * @param proxyPort
+ * Port on which a Proxy server listens for connections.
+ */
+ public Socks5Proxy(SocksProxyBase p, InetAddress proxyIP, int proxyPort) {
+ super(p, proxyIP, proxyPort);
+ version = 5;
+ setAuthenticationMethod(0, new AuthenticationNone());
+ }
+
+ /**
+ * Creates SOCKS5 proxy.
+ *
+ * @param proxyIP
+ * Host on which a Proxy server runs.
+ * @param proxyPort
+ * Port on which a Proxy server listens for connections.
+ */
+ public Socks5Proxy(InetAddress proxyIP, int proxyPort) {
+ this(null, proxyIP, proxyPort);
+ }
+
+ // Public instance methods
+ // ========================
+
+ /**
+ * Wether to resolve address locally or to let proxy do so.
+ * <p>
+ * SOCKS5 protocol allows to send host names rather then IPs in the
+ * requests, this option controls wether the hostnames should be send to the
+ * proxy server as names, or should they be resolved locally.
+ *
+ * @param doResolve
+ * Wether to perform resolution locally.
+ * @return Previous settings.
+ */
+ public boolean resolveAddrLocally(boolean doResolve) {
+ final boolean old = resolveAddrLocally;
+ resolveAddrLocally = doResolve;
+ return old;
+ }
+
+ /**
+ * Get current setting on how the addresses should be handled.
+ *
+ * @return Current setting for address resolution.
+ * @see Socks5Proxy#resolveAddrLocally(boolean doResolve)
+ */
+ public boolean resolveAddrLocally() {
+ return resolveAddrLocally;
+ }
+
+ /**
+ * Adds another authentication method.
+ *
+ * @param methodId
+ * Authentication method id, see rfc1928
+ * @param method
+ * Implementation of Authentication
+ * @see Authentication
+ */
+ public boolean setAuthenticationMethod(int methodId, Authentication method) {
+ if ((methodId < 0) || (methodId > 255)) {
+ return false;
+ }
+ if (method == null) {
+ // Want to remove a particular method
+ return (authMethods.remove(new Integer(methodId)) != null);
+ } else {// Add the method, or rewrite old one
+ authMethods.put(new Integer(methodId), method);
+ }
+ return true;
+ }
+
+ /**
+ * Get authentication method, which corresponds to given method id
+ *
+ * @param methodId
+ * Authentication method id.
+ * @return Implementation for given method or null, if one was not set.
+ */
+ public Authentication getAuthenticationMethod(int methodId) {
+ final Object method = authMethods.get(new Integer(methodId));
+ if (method == null) {
+ return null;
+ }
+ return (Authentication) method;
+ }
+
+ /**
+ * Creates a clone of this Proxy. clone() returns an
+ */
+ @SuppressWarnings("unchecked")
+ public Object clone() {
+ final Socks5Proxy newProxy = new Socks5Proxy(proxyIP, proxyPort);
+
+ final Object o = this.authMethods.clone();
+ newProxy.authMethods = (Hashtable<Integer, Authentication>) o;
+
+ newProxy.directHosts = (InetRange) directHosts.clone();
+ newProxy.resolveAddrLocally = resolveAddrLocally;
+ newProxy.chainProxy = chainProxy;
+ return newProxy;
+ }
+
+ // Public Static(Class) Methods
+ // ==============================
+
+ // Protected Methods
+ // =================
+
+ protected SocksProxyBase copy() {
+ final Socks5Proxy copy = new Socks5Proxy(proxyIP, proxyPort);
+
+ copy.authMethods = this.authMethods; // same Hash, no copy
+ copy.directHosts = this.directHosts;
+ copy.chainProxy = this.chainProxy;
+ copy.resolveAddrLocally = this.resolveAddrLocally;
+ return copy;
+ }
+
+ /**
+ *
+ *
+ */
+ protected void startSession() throws SocksException {
+ super.startSession();
+ Authentication auth;
+ final Socket ps = proxySocket; // The name is too long
+
+ try {
+
+ final byte nMethods = (byte) authMethods.size(); // Number of
+ // methods
+
+ final byte[] buf = new byte[2 + nMethods]; // 2 is for VER,NMETHODS
+ buf[0] = (byte) version;
+ buf[1] = nMethods; // Number of methods
+ int i = 2;
+
+ final Enumeration<Integer> ids = authMethods.keys();
+ while (ids.hasMoreElements()) {
+ buf[i++] = (byte) ids.nextElement().intValue();
+ }
+
+ out.write(buf);
+ out.flush();
+
+ final int versionNumber = in.read();
+ selectedMethod = in.read();
+
+ if ((versionNumber < 0) || (selectedMethod < 0)) {
+ // EOF condition was reached
+ endSession();
+ final String s = "Connection to proxy lost.";
+ throw new SocksException(SOCKS_PROXY_IO_ERROR, s);
+ }
+
+ if (versionNumber < version) {
+ // What should we do??
+ }
+
+ if (selectedMethod == 0xFF) { // No method selected
+ ps.close();
+ throw (new SocksException(SOCKS_AUTH_NOT_SUPPORTED));
+ }
+
+ auth = getAuthenticationMethod(selectedMethod);
+ if (auth == null) {
+ // This shouldn't happen, unless method was removed by other
+ // thread, or the server stuffed up
+ final String s = "Specified Authentication not found!";
+ throw new SocksException(SOCKS_JUST_ERROR, s);
+ }
+
+ final Object[] in_out;
+ in_out = auth.doSocksAuthentication(selectedMethod, ps);
+
+ if (in_out == null) {
+ // Authentication failed by some reason
+ throw (new SocksException(SOCKS_AUTH_FAILURE));
+ }
+
+ /*
+ * Most authentication methods are expected to return simply the
+ * input/output streams associated with the socket. However if the
+ * auth. method requires some kind of encryption/decryption being
+ * done on the connection it should provide classes to handle I/O.
+ */
+
+ in = (InputStream) in_out[0];
+ out = (OutputStream) in_out[1];
+ if (in_out.length > 2) {
+ udp_encapsulation = (UDPEncapsulation) in_out[2];
+ }
+
+ } catch (final SocksException s_ex) {
+ throw s_ex;
+ } catch (final UnknownHostException uh_ex) {
+ throw new SocksException(SOCKS_PROXY_NO_CONNECT, uh_ex);
+ } catch (final SocketException so_ex) {
+ throw new SocksException(SOCKS_PROXY_NO_CONNECT, so_ex);
+ } catch (final IOException io_ex) {
+ throw new SocksException(SOCKS_PROXY_IO_ERROR, io_ex);
+ }
+ }
+
+ protected ProxyMessage formMessage(int cmd, InetAddress ip, int port) {
+ return new Socks5Message(cmd, ip, port);
+ }
+
+ protected ProxyMessage formMessage(int cmd, String host, int port)
+ throws UnknownHostException {
+ if (resolveAddrLocally) {
+ return formMessage(cmd, InetAddress.getByName(host), port);
+ } else {
+ return new Socks5Message(cmd, host, port);
+ }
+ }
+
+ protected ProxyMessage formMessage(InputStream in) throws SocksException,
+ IOException {
+ return new Socks5Message(in);
+ }
+
+}
diff --git a/src/com/runjva/sourceforge/jsocks/protocol/SocksException.java b/src/com/runjva/sourceforge/jsocks/protocol/SocksException.java
new file mode 100644
index 0000000..a651597
--- /dev/null
+++ b/src/com/runjva/sourceforge/jsocks/protocol/SocksException.java
@@ -0,0 +1,111 @@
+package com.runjva.sourceforge.jsocks.protocol;
+
+/**
+ * Exception thrown by various socks classes to indicate errors with protocol or
+ * unsuccessfull server responses.
+ */
+public class SocksException extends java.io.IOException {
+ /**
+ *
+ */
+ private static final long serialVersionUID = 1L;
+
+ /**
+ * Construct a SocksException with given errorcode.
+ * <p>
+ * Tries to look up message which corresponds to this error code.
+ *
+ * @param errCode
+ * Error code for this exception.
+ */
+ public SocksException(int errCode) {
+ this.errCode = errCode;
+ lookupErrorString(errCode);
+ }
+
+ private void lookupErrorString(int errCode) {
+ if ((errCode >> 16) == 0) {
+ if (errCode <= serverReplyMessage.length) {
+ errString = serverReplyMessage[errCode];
+ } else {
+ errString = UNASSIGNED_ERROR_MESSAGE;
+ }
+ } else {
+ // Local error
+ errCode = (errCode >> 16) - 1;
+ if (errCode <= localErrorMessage.length) {
+ errString = localErrorMessage[errCode];
+ } else {
+ errString = UNASSIGNED_ERROR_MESSAGE;
+ }
+ }
+ }
+
+ /**
+ * Construct a SocksException with given error code, and a Throwable cause
+ *
+ * @param errCode
+ * @param t
+ * Nested exception for debugging purposes.
+ */
+ public SocksException(int errCode, Throwable t) {
+ super(t); // Java 1.6+
+ this.errCode = errCode;
+ lookupErrorString(errCode);
+ }
+
+ /**
+ * Constructs a SocksException with given error code and message.
+ *
+ * @param errCode
+ * Error code.
+ * @param errString
+ * Error Message.
+ */
+ public SocksException(int errCode, String errString) {
+ this.errCode = errCode;
+ this.errString = errString;
+ }
+
+ public SocksException(int errCode, String string, Throwable t) {
+ super(string, t); // Java 1.6+
+ this.errCode = errCode;
+ this.errString = string;
+ }
+
+ /**
+ * Get the error code associated with this exception.
+ *
+ * @return Error code associated with this exception.
+ */
+ public int getErrorCode() {
+ return errCode;
+ }
+
+ /**
+ * Get human readable representation of this exception.
+ *
+ * @return String represntation of this exception.
+ */
+ public String toString() {
+ return errString;
+ }
+
+ static final String UNASSIGNED_ERROR_MESSAGE = "Unknown error message";
+
+ static final String serverReplyMessage[] = { "Succeeded",
+ "General SOCKS server failure",
+ "Connection not allowed by ruleset", "Network unreachable",
+ "Host unreachable", "Connection refused", "TTL expired",
+ "Command not supported", "Address type not supported" };
+
+ static final String localErrorMessage[] = { "SOCKS server not specified",
+ "Unable to contact SOCKS server", "IO error",
+ "None of Authentication methods are supported",
+ "Authentication failed", "General SOCKS fault" };
+
+ String errString;
+ int errCode;
+
+}// End of SocksException class
+
diff --git a/src/com/runjva/sourceforge/jsocks/protocol/SocksProxyBase.java b/src/com/runjva/sourceforge/jsocks/protocol/SocksProxyBase.java
new file mode 100644
index 0000000..c4ce565
--- /dev/null
+++ b/src/com/runjva/sourceforge/jsocks/protocol/SocksProxyBase.java
@@ -0,0 +1,543 @@
+package com.runjva.sourceforge.jsocks.protocol;
+
+import java.io.IOException;
+import java.io.InputStream;
+import java.io.InterruptedIOException;
+import java.io.OutputStream;
+import java.net.InetAddress;
+import java.net.Socket;
+import java.net.UnknownHostException;
+
+/**
+ * Abstract class Proxy, base for classes Socks4Proxy and Socks5Proxy. Defines
+ * methods for specifying default proxy, to be used by all classes of this
+ * package.
+ */
+
+public abstract class SocksProxyBase {
+
+ // Data members
+ protected InetRange directHosts = new InetRange();
+
+ protected InetAddress proxyIP = null;
+ protected String proxyHost = null;
+ protected int proxyPort;
+ protected Socket proxySocket = null;
+
+ protected InputStream in;
+ protected OutputStream out;
+
+ protected int version;
+
+ protected SocksProxyBase chainProxy = null;
+
+ // Protected static/class variables
+ protected static SocksProxyBase defaultProxy = null;
+
+ // Constructors
+ // ====================
+ SocksProxyBase(SocksProxyBase chainProxy, String proxyHost, int proxyPort)
+ throws UnknownHostException {
+ this.chainProxy = chainProxy;
+ this.proxyHost = proxyHost;
+
+ if (chainProxy == null) {
+ this.proxyIP = InetAddress.getByName(proxyHost);
+ }
+
+ this.proxyPort = proxyPort;
+ }
+
+ SocksProxyBase(String proxyHost, int proxyPort) throws UnknownHostException {
+ this(null, proxyHost, proxyPort);
+ }
+
+ SocksProxyBase(SocksProxyBase chainProxy, InetAddress proxyIP, int proxyPort) {
+ this.chainProxy = chainProxy;
+ this.proxyIP = proxyIP;
+ this.proxyPort = proxyPort;
+ }
+
+ SocksProxyBase(InetAddress proxyIP, int proxyPort) {
+ this(null, proxyIP, proxyPort);
+ }
+
+ SocksProxyBase(SocksProxyBase p) {
+ this.proxyIP = p.proxyIP;
+ this.proxyPort = p.proxyPort;
+ this.version = p.version;
+ this.directHosts = p.directHosts;
+ }
+
+ // Public instance methods
+ // ========================
+
+ /**
+ * Get the port on which proxy server is running.
+ *
+ * @return Proxy port.
+ */
+ public int getPort() {
+ return proxyPort;
+ }
+
+ /**
+ * Get the ip address of the proxy server host.
+ *
+ * @return Proxy InetAddress.
+ */
+ public InetAddress getInetAddress() {
+ return proxyIP;
+ }
+
+ /**
+ * Adds given ip to the list of direct addresses. This machine will be
+ * accessed without using proxy.
+ */
+ public void addDirect(InetAddress ip) {
+ directHosts.add(ip);
+ }
+
+ /**
+ * Adds host to the list of direct addresses. This machine will be accessed
+ * without using proxy.
+ */
+ public boolean addDirect(String host) {
+ return directHosts.add(host);
+ }
+
+ /**
+ * Adds given range of addresses to the lsit of direct addresses, machines
+ * within this range will be accessed without using proxy.
+ */
+ public void addDirect(InetAddress from, InetAddress to) {
+ directHosts.add(from, to);
+ }
+
+ /**
+ * Sets given InetRange as the list of direct address, previous list will be
+ * discarded, any changes done previously with addDirect(Inetaddress) will
+ * be lost. The machines in this range will be accessed without using proxy.
+ *
+ * @param ir
+ * InetRange which should be used to look up direct addresses.
+ * @see InetRange
+ */
+ public void setDirect(InetRange ir) {
+ directHosts = ir;
+ }
+
+ /**
+ * Get the list of direct hosts.
+ *
+ * @return Current range of direct address as InetRange object.
+ * @see InetRange
+ */
+ public InetRange getDirect() {
+ return directHosts;
+ }
+
+ /**
+ * Check wether the given host is on the list of direct address.
+ *
+ * @param host
+ * Host name to check.
+ * @return true if the given host is specified as the direct addresses.
+ */
+ public boolean isDirect(String host) {
+ return directHosts.contains(host);
+ }
+
+ /**
+ * Check wether the given host is on the list of direct addresses.
+ *
+ * @param host
+ * Host address to check.
+ * @return true if the given host is specified as the direct address.
+ */
+ public boolean isDirect(InetAddress host) {
+ return directHosts.contains(host);
+ }
+
+ /**
+ * Set the proxy which should be used to connect to given proxy.
+ *
+ * @param chainProxy
+ * Proxy to use to connect to this proxy.
+ */
+ public void setChainProxy(SocksProxyBase chainProxy) {
+ this.chainProxy = chainProxy;
+ }
+
+ /**
+ * Get proxy which is used to connect to this proxy.
+ *
+ * @return Proxy which is used to connect to this proxy, or null if proxy is
+ * to be contacted directly.
+ */
+ public SocksProxyBase getChainProxy() {
+ return chainProxy;
+ }
+
+ /**
+ * Get string representation of this proxy.
+ *
+ * @returns string in the form:proxyHost:proxyPort \t Version versionNumber
+ */
+ public String toString() {
+ return ("" + proxyIP.getHostName() + ":" + proxyPort + "\tVersion " + version);
+ }
+
+ // Public Static(Class) Methods
+ // ==============================
+
+ /**
+ * Sets SOCKS4 proxy as default.
+ *
+ * @param hostName
+ * Host name on which SOCKS4 server is running.
+ * @param port
+ * Port on which SOCKS4 server is running.
+ * @param user
+ * Username to use for communications with proxy.
+ */
+ public static void setDefaultProxy(String hostName, int port, String user)
+ throws UnknownHostException {
+ defaultProxy = new Socks4Proxy(hostName, port, user);
+ }
+
+ /**
+ * Sets SOCKS4 proxy as default.
+ *
+ * @param ipAddress
+ * Host address on which SOCKS4 server is running.
+ * @param port
+ * Port on which SOCKS4 server is running.
+ * @param user
+ * Username to use for communications with proxy.
+ */
+ public static void setDefaultProxy(InetAddress ipAddress, int port,
+ String user) {
+ defaultProxy = new Socks4Proxy(ipAddress, port, user);
+ }
+
+ /**
+ * Sets SOCKS5 proxy as default. Default proxy only supports
+ * no-authentication.
+ *
+ * @param hostName
+ * Host name on which SOCKS5 server is running.
+ * @param port
+ * Port on which SOCKS5 server is running.
+ */
+ public static void setDefaultProxy(String hostName, int port)
+ throws UnknownHostException {
+ defaultProxy = new Socks5Proxy(hostName, port);
+ }
+
+ /**
+ * Sets SOCKS5 proxy as default. Default proxy only supports
+ * no-authentication.
+ *
+ * @param ipAddress
+ * Host address on which SOCKS5 server is running.
+ * @param port
+ * Port on which SOCKS5 server is running.
+ */
+ public static void setDefaultProxy(InetAddress ipAddress, int port) {
+ defaultProxy = new Socks5Proxy(ipAddress, port);
+ }
+
+ /**
+ * Sets default proxy.
+ *
+ * @param p
+ * Proxy to use as default proxy.
+ */
+ public static void setDefaultProxy(SocksProxyBase p) {
+ defaultProxy = p;
+ }
+
+ /**
+ * Get current default proxy.
+ *
+ * @return Current default proxy, or null if none is set.
+ */
+ public static SocksProxyBase getDefaultProxy() {
+ return defaultProxy;
+ }
+
+ /**
+ * Parses strings in the form: host[:port:user:password], and creates proxy
+ * from information obtained from parsing.
+ * <p>
+ * Defaults: port = 1080.<br>
+ * If user specified but not password, creates Socks4Proxy, if user not
+ * specified creates Socks5Proxy, if both user and password are speciefied
+ * creates Socks5Proxy with user/password authentication.
+ *
+ * @param proxy_entry
+ * String in the form host[:port:user:password]
+ * @return Proxy created from the string, null if entry was somehow
+ * invalid(host unknown for example, or empty string)
+ */
+ public static SocksProxyBase parseProxy(String proxy_entry) {
+
+ String proxy_host;
+ int proxy_port = 1080;
+ String proxy_user = null;
+ String proxy_password = null;
+ SocksProxyBase proxy;
+
+ final java.util.StringTokenizer st = new java.util.StringTokenizer(
+ proxy_entry, ":");
+ if (st.countTokens() < 1) {
+ return null;
+ }
+
+ proxy_host = st.nextToken();
+ if (st.hasMoreTokens()) {
+ try {
+ proxy_port = Integer.parseInt(st.nextToken().trim());
+ } catch (final NumberFormatException nfe) {
+ }
+ }
+
+ if (st.hasMoreTokens()) {
+ proxy_user = st.nextToken();
+ }
+
+ if (st.hasMoreTokens()) {
+ proxy_password = st.nextToken();
+ }
+
+ try {
+ if (proxy_user == null) {
+ proxy = new Socks5Proxy(proxy_host, proxy_port);
+ } else if (proxy_password == null) {
+ proxy = new Socks4Proxy(proxy_host, proxy_port, proxy_user);
+ } else {
+ proxy = new Socks5Proxy(proxy_host, proxy_port);
+ final UserPasswordAuthentication upa = new UserPasswordAuthentication(
+ proxy_user, proxy_password);
+
+ ((Socks5Proxy) proxy).setAuthenticationMethod(
+ UserPasswordAuthentication.METHOD_ID, upa);
+ }
+ } catch (final UnknownHostException uhe) {
+ return null;
+ }
+
+ return proxy;
+ }
+
+ // Protected Methods
+ // =================
+
+ protected void startSession() throws SocksException {
+ try {
+ if (chainProxy == null) {
+ proxySocket = new Socket(proxyIP, proxyPort);
+ } else if (proxyIP != null) {
+ proxySocket = new SocksSocket(chainProxy, proxyIP, proxyPort);
+ } else {
+ proxySocket = new SocksSocket(chainProxy, proxyHost, proxyPort);
+ }
+
+ in = proxySocket.getInputStream();
+ out = proxySocket.getOutputStream();
+ } catch (final SocksException se) {
+ throw se;
+ } catch (final IOException io_ex) {
+ throw new SocksException(SOCKS_PROXY_IO_ERROR, "" + io_ex);
+ }
+ }
+
+ /**
+ * Create a copy of this proxy for use by individual threads.
+ *
+ * @return proxy
+ */
+ protected abstract SocksProxyBase copy();
+
+ protected abstract ProxyMessage formMessage(int cmd, InetAddress ip,
+ int port);
+
+ protected abstract ProxyMessage formMessage(int cmd, String host, int port)
+ throws UnknownHostException;
+
+ protected abstract ProxyMessage formMessage(InputStream in)
+ throws SocksException, IOException;
+
+ protected ProxyMessage connect(InetAddress ip, int port)
+ throws SocksException {
+ try {
+ startSession();
+ final ProxyMessage request = formMessage(SOCKS_CMD_CONNECT, ip,
+ port);
+ return exchange(request);
+ } catch (final SocksException se) {
+ endSession();
+ throw se;
+ }
+ }
+
+ protected ProxyMessage connect(String host, int port)
+ throws UnknownHostException, SocksException {
+ try {
+ startSession();
+ final ProxyMessage request = formMessage(SOCKS_CMD_CONNECT, host,
+ port);
+ return exchange(request);
+ } catch (final SocksException se) {
+ endSession();
+ throw se;
+ }
+ }
+
+ protected ProxyMessage bind(InetAddress ip, int port) throws SocksException {
+ try {
+ startSession();
+ final ProxyMessage request = formMessage(SOCKS_CMD_BIND, ip, port);
+ return exchange(request);
+ } catch (final SocksException se) {
+ endSession();
+ throw se;
+ }
+ }
+
+ protected ProxyMessage bind(String host, int port)
+ throws UnknownHostException, SocksException {
+ try {
+ startSession();
+ final ProxyMessage request = formMessage(SOCKS_CMD_BIND, host, port);
+ return exchange(request);
+ } catch (final SocksException se) {
+ endSession();
+ throw se;
+ }
+ }
+
+ protected ProxyMessage accept() throws IOException, SocksException {
+ ProxyMessage msg;
+ try {
+ msg = formMessage(in);
+ } catch (final InterruptedIOException iioe) {
+ throw iioe;
+ } catch (final IOException io_ex) {
+ endSession();
+ throw new SocksException(SOCKS_PROXY_IO_ERROR,
+ "While Trying accept:" + io_ex);
+ }
+ return msg;
+ }
+
+ protected ProxyMessage udpAssociate(InetAddress ip, int port)
+ throws SocksException {
+ try {
+ startSession();
+ final ProxyMessage request = formMessage(SOCKS_CMD_UDP_ASSOCIATE,
+ ip, port);
+ if (request != null) {
+ return exchange(request);
+ }
+ } catch (final SocksException se) {
+ endSession();
+ throw se;
+ }
+ // Only get here if request was null
+ endSession();
+ throw new SocksException(SOCKS_METHOD_NOTSUPPORTED,
+ "This version of proxy does not support UDP associate, use version 5");
+ }
+
+ protected ProxyMessage udpAssociate(String host, int port)
+ throws UnknownHostException, SocksException {
+ try {
+ startSession();
+ final ProxyMessage request = formMessage(SOCKS_CMD_UDP_ASSOCIATE,
+ host, port);
+ if (request != null) {
+ return exchange(request);
+ }
+ } catch (final SocksException se) {
+ endSession();
+ throw se;
+ }
+ // Only get here if request was null
+ endSession();
+ throw new SocksException(SOCKS_METHOD_NOTSUPPORTED,
+ "This version of proxy does not support UDP associate, use version 5");
+ }
+
+ protected void endSession() {
+ try {
+ if (proxySocket != null) {
+ proxySocket.close();
+ }
+ proxySocket = null;
+ } catch (final IOException io_ex) {
+ }
+ }
+
+ /**
+ *Sends the request to SOCKS server
+ */
+ protected void sendMsg(ProxyMessage msg) throws SocksException, IOException {
+ msg.write(out);
+ }
+
+ /**
+ * Reads the reply from the SOCKS server
+ */
+ protected ProxyMessage readMsg() throws SocksException, IOException {
+ return formMessage(in);
+ }
+
+ /**
+ *Sends the request reads reply and returns it throws exception if
+ * something wrong with IO or the reply code is not zero
+ */
+ protected ProxyMessage exchange(ProxyMessage request) throws SocksException {
+ ProxyMessage reply;
+ try {
+ request.write(out);
+ reply = formMessage(in);
+ } catch (final SocksException s_ex) {
+ throw s_ex;
+ } catch (final IOException ioe) {
+ throw (new SocksException(SOCKS_PROXY_IO_ERROR, "" + ioe));
+ }
+ return reply;
+ }
+
+ // Private methods
+ // ===============
+
+ // Constants
+
+ public static final int SOCKS_SUCCESS = 0;
+ public static final int SOCKS_FAILURE = 1;
+ public static final int SOCKS_BADCONNECT = 2;
+ public static final int SOCKS_BADNETWORK = 3;
+ public static final int SOCKS_HOST_UNREACHABLE = 4;
+ public static final int SOCKS_CONNECTION_REFUSED = 5;
+ public static final int SOCKS_TTL_EXPIRE = 6;
+ public static final int SOCKS_CMD_NOT_SUPPORTED = 7;
+ public static final int SOCKS_ADDR_NOT_SUPPORTED = 8;
+
+ public static final int SOCKS_NO_PROXY = 1 << 16;
+ public static final int SOCKS_PROXY_NO_CONNECT = 2 << 16;
+ public static final int SOCKS_PROXY_IO_ERROR = 3 << 16;
+ public static final int SOCKS_AUTH_NOT_SUPPORTED = 4 << 16;
+ public static final int SOCKS_AUTH_FAILURE = 5 << 16;
+ public static final int SOCKS_JUST_ERROR = 6 << 16;
+
+ public static final int SOCKS_DIRECT_FAILED = 7 << 16;
+ public static final int SOCKS_METHOD_NOTSUPPORTED = 8 << 16;
+
+ static final int SOCKS_CMD_CONNECT = 0x1;
+ static final int SOCKS_CMD_BIND = 0x2;
+ static final int SOCKS_CMD_UDP_ASSOCIATE = 0x3;
+
+}
diff --git a/src/com/runjva/sourceforge/jsocks/protocol/SocksServerSocket.java b/src/com/runjva/sourceforge/jsocks/protocol/SocksServerSocket.java
new file mode 100644
index 0000000..6d812f2
--- /dev/null
+++ b/src/com/runjva/sourceforge/jsocks/protocol/SocksServerSocket.java
@@ -0,0 +1,238 @@
+package com.runjva.sourceforge.jsocks.protocol;
+
+import java.io.IOException;
+import java.net.InetAddress;
+import java.net.ServerSocket;
+import java.net.Socket;
+import java.net.SocketException;
+import java.net.UnknownHostException;
+
+/**
+ * SocksServerSocket allows to accept connections from one particular host
+ * through the SOCKS4 or SOCKS5 proxy.
+ */
+public class SocksServerSocket extends ServerSocket {
+ // Data members
+ protected SocksProxyBase proxy;
+ protected String localHost;
+ protected InetAddress localIP;
+ protected int localPort;
+
+ boolean doing_direct = false;
+ InetAddress remoteAddr;
+
+ /**
+ * Creates ServerSocket capable of accepting one connection through the
+ * firewall, uses default Proxy.
+ *
+ * @param host
+ * Host from which the connection should be recieved.
+ *@param port
+ * Port number of the primary connection.
+ */
+ public SocksServerSocket(String host, int port) throws SocksException,
+ UnknownHostException, IOException {
+ this(SocksProxyBase.defaultProxy, host, port);
+ }
+
+ /**
+ *Creates ServerSocket capable of accepting one connection through the
+ * firewall, uses given proxy.
+ *
+ * @param p
+ * Proxy object to use.
+ *@param host
+ * Host from which the connection should be recieved.
+ *@param port
+ * Port number of the primary connection.
+ */
+ public SocksServerSocket(SocksProxyBase p, String host, int port)
+ throws SocksException, UnknownHostException, IOException {
+
+ super(0);
+ if (p == null) {
+ throw new SocksException(SocksProxyBase.SOCKS_NO_PROXY);
+ }
+ // proxy=p;
+ proxy = p.copy();
+ if (proxy.isDirect(host)) {
+ remoteAddr = InetAddress.getByName(host);
+ proxy = null;
+ doDirect();
+ } else {
+ processReply(proxy.bind(host, port));
+ }
+ }
+
+ /**
+ * Creates ServerSocket capable of accepting one connection through the
+ * firewall, uses default Proxy.
+ *
+ * @param ip
+ * Host from which the connection should be recieved.
+ *@param port
+ * Port number of the primary connection.
+ */
+ public SocksServerSocket(InetAddress ip, int port) throws SocksException,
+ IOException {
+ this(SocksProxyBase.defaultProxy, ip, port);
+ }
+
+ /**
+ *Creates ServerSocket capable of accepting one connection through the
+ * firewall, uses given proxy.
+ *
+ * @param p
+ * Proxy object to use.
+ *@param ip
+ * Host from which the connection should be recieved.
+ *@param port
+ * Port number of the primary connection.
+ */
+ public SocksServerSocket(SocksProxyBase p, InetAddress ip, int port)
+ throws SocksException, IOException {
+ super(0);
+
+ if (p == null) {
+ throw new SocksException(SocksProxyBase.SOCKS_NO_PROXY);
+ }
+ this.proxy = p.copy();
+
+ if (proxy.isDirect(ip)) {
+ remoteAddr = ip;
+ doDirect();
+ } else {
+ processReply(proxy.bind(ip, port));
+ }
+ }
+
+ /**
+ * Accepts the incoming connection.
+ */
+ public Socket accept() throws IOException {
+ Socket s;
+
+ if (!doing_direct) {
+ if (proxy == null) {
+ return null;
+ }
+
+ final ProxyMessage msg = proxy.accept();
+ s = msg.ip == null ? new SocksSocket(msg.host, msg.port, proxy)
+ : new SocksSocket(msg.ip, msg.port, proxy);
+ // Set timeout back to 0
+ proxy.proxySocket.setSoTimeout(0);
+ if (ProxyServer.vpnService != null)
+ ProxyServer.vpnService.protect(proxy.proxySocket);
+
+ } else { // Direct Connection
+
+ // Mimic the proxy behaviour,
+ // only accept connections from the speciefed host.
+ while (true) {
+ s = super.accept();
+ if (s.getInetAddress().equals(remoteAddr)) {
+ // got the connection from the right host
+ // Close listenning socket.
+ break;
+ } else {
+ s.close(); // Drop all connections from other hosts
+ }
+ }
+
+ }
+ proxy = null;
+ // Return accepted socket
+ return s;
+ }
+
+ /**
+ * Closes the connection to proxy if socket have not been accepted, if the
+ * direct connection is used, closes direct ServerSocket. If the client
+ * socket have been allready accepted, does nothing.
+ */
+ public void close() throws IOException {
+ super.close();
+ if (proxy != null) {
+ proxy.endSession();
+ }
+ proxy = null;
+ }
+
+ /**
+ * Get the name of the host proxy is using to listen for incoming
+ * connection.
+ * <P>
+ * Usefull when address is returned by proxy as the hostname.
+ *
+ * @return the hostname of the address proxy is using to listen for incoming
+ * connection.
+ */
+ public String getHost() {
+ return localHost;
+ }
+
+ /**
+ * Get address assigned by proxy to listen for incomming connections, or the
+ * local machine address if doing direct connection.
+ */
+ public InetAddress getInetAddress() {
+ if (localIP == null) {
+ try {
+ localIP = InetAddress.getByName(localHost);
+ } catch (final UnknownHostException e) {
+ return null;
+ }
+ }
+ return localIP;
+ }
+
+ /**
+ * Get port assigned by proxy to listen for incoming connections, or the
+ * port chosen by local system, if accepting directly.
+ */
+ public int getLocalPort() {
+ return localPort;
+ }
+
+ /**
+ * Set Timeout.
+ *
+ * @param timeout
+ * Amount of time in milliseconds, accept should wait for
+ * incoming connection before failing with exception. Zero
+ * timeout implies infinity.
+ */
+ public void setSoTimeout(int timeout) throws SocketException {
+ super.setSoTimeout(timeout);
+ if (!doing_direct) {
+ proxy.proxySocket.setSoTimeout(timeout);
+ }
+ }
+
+ // Private Methods
+ // ////////////////
+
+ private void processReply(ProxyMessage reply) throws SocksException {
+ localPort = reply.port;
+ /*
+ * If the server have assigned same host as it was contacted on it might
+ * return an address of all zeros
+ */
+ if (reply.host.equals("0.0.0.0")) {
+ localIP = proxy.proxyIP;
+ localHost = localIP.getHostName();
+ } else {
+ localHost = reply.host;
+ localIP = reply.ip;
+ }
+ }
+
+ private void doDirect() {
+ doing_direct = true;
+ localPort = super.getLocalPort();
+ localIP = super.getInetAddress();
+ localHost = localIP.getHostName();
+ }
+
+}
diff --git a/src/com/runjva/sourceforge/jsocks/protocol/SocksSocket.java b/src/com/runjva/sourceforge/jsocks/protocol/SocksSocket.java
new file mode 100644
index 0000000..fd626ec
--- /dev/null
+++ b/src/com/runjva/sourceforge/jsocks/protocol/SocksSocket.java
@@ -0,0 +1,389 @@
+package com.runjva.sourceforge.jsocks.protocol;
+
+import java.io.IOException;
+import java.io.InputStream;
+import java.io.OutputStream;
+import java.net.InetAddress;
+import java.net.Socket;
+import java.net.SocketException;
+import java.net.UnknownHostException;
+
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+
+/**
+ * SocksSocket tryies to look very similar to normal Socket, while allowing
+ * connections through the SOCKS4 or 5 proxy. To use this class you will have to
+ * identify proxy you need to use, Proxy class allows you to set default proxy,
+ * which will be used by all Socks aware sockets. You can also create either
+ * Socks4Proxy or Socks5Proxy, and use them by passing to the appropriate
+ * constructors.
+ * <P>
+ * Using Socks package can be as easy as that:
+ *
+ * <pre>
+ * <tt>
+ *
+ * import Socks.*;
+ * ....
+ *
+ * try{
+ * //Specify SOCKS5 proxy
+ * Proxy.setDefaultProxy("socks-proxy",1080);
+ *
+ * //OR you still use SOCKS4
+ * //Code below uses SOCKS4 proxy
+ * //Proxy.setDefaultProxy("socks-proxy",1080,userName);
+ *
+ * Socket s = SocksSocket("some.host.of.mine",13);
+ * readTimeFromSock(s);
+ * }catch(SocksException sock_ex){
+ * //Usually it will turn in more or less meaningfull message
+ * System.err.println("SocksException:"+sock_ex);
+ * }
+ *
+ * </tt>
+ * </pre>
+ *<P>
+ * However if the need exist for more control, like resolving addresses
+ * remotely, or using some non-trivial authentication schemes, it can be done.
+ */
+
+public class SocksSocket extends Socket {
+ // Data members
+ protected SocksProxyBase proxy;
+ protected String localHost, remoteHost;
+ protected InetAddress localIP, remoteIP;
+ protected int localPort, remotePort;
+
+ private Socket directSock = null;
+ private Logger log = LoggerFactory.getLogger(SocksSocket.class);
+
+ /**
+ * Tryies to connect to given host and port using default proxy. If no
+ * default proxy speciefied it throws SocksException with error code
+ * SOCKS_NO_PROXY.
+ *
+ * @param host
+ * Machine to connect to.
+ * @param port
+ * Port to which to connect.
+ * @see SocksSocket#SocksSocket(SocksProxyBase,String,int)
+ * @see Socks5Proxy#resolveAddrLocally
+ */
+ public SocksSocket(String host, int port) throws SocksException,
+ UnknownHostException {
+ this(SocksProxyBase.defaultProxy, host, port);
+ }
+
+ /**
+ * Connects to host port using given proxy server.
+ *
+ * @param p
+ * Proxy to use.
+ * @param host
+ * Machine to connect to.
+ * @param port
+ * Port to which to connect.
+ * @throws UnknownHostException
+ * If one of the following happens:
+ * <ol>
+ *
+ * <li>Proxy settings say that address should be resolved
+ * locally, but this fails.
+ * <li>Proxy settings say that the host should be contacted
+ * directly but host name can't be resolved.
+ * </ol>
+ * @throws SocksException
+ * If one of the following happens:
+ * <ul>
+ * <li>Proxy is is null.
+ * <li>Proxy settings say that the host should be contacted
+ * directly but this fails.
+ * <li>Socks Server can't be contacted.
+ * <li>Authentication fails.
+ * <li>Connection is not allowed by the SOCKS proxy.
+ * <li>SOCKS proxy can't establish the connection.
+ * <li>Any IO error occured.
+ * <li>Any protocol error occured.
+ * </ul>
+ * @throws IOexception
+ * if anything is wrong with I/O.
+ * @see Socks5Proxy#resolveAddrLocally
+ */
+ public SocksSocket(SocksProxyBase p, String host, int port)
+ throws SocksException, UnknownHostException {
+
+ if (p == null) {
+ throw new SocksException(SocksProxyBase.SOCKS_NO_PROXY);
+ }
+ // proxy=p;
+ proxy = p.copy();
+ remoteHost = host;
+ remotePort = port;
+ if (proxy.isDirect(host)) {
+ remoteIP = InetAddress.getByName(host);
+ doDirect();
+ } else {
+ processReply(proxy.connect(host, port));
+ }
+ }
+
+ /**
+ * Tryies to connect to given ip and port using default proxy. If no default
+ * proxy speciefied it throws SocksException with error code SOCKS_NO_PROXY.
+ *
+ * @param ip
+ * Machine to connect to.
+ * @param port
+ * Port to which to connect.
+ * @see SocksSocket#SocksSocket(SocksProxyBase,String,int)
+ */
+ public SocksSocket(InetAddress ip, int port) throws SocksException {
+ this(SocksProxyBase.defaultProxy, ip, port);
+ }
+
+ /**
+ * Connects to given ip and port using given Proxy server.
+ *
+ * @param p
+ * Proxy to use.
+ * @param ip
+ * Machine to connect to.
+ * @param port
+ * Port to which to connect.
+ */
+ public SocksSocket(SocksProxyBase p, InetAddress ip, int port)
+ throws SocksException {
+ if (p == null) {
+ throw new SocksException(SocksProxyBase.SOCKS_NO_PROXY);
+ }
+ this.proxy = p.copy();
+ this.remoteIP = ip;
+ this.remotePort = port;
+ this.remoteHost = ip.getHostName();
+ if (proxy.isDirect(remoteIP)) {
+ doDirect();
+ } else {
+ processReply(proxy.connect(ip, port));
+ }
+ }
+
+ /**
+ * These 2 constructors are used by the SocksServerSocket. This socket
+ * simply overrides remoteHost, remotePort
+ */
+ protected SocksSocket(String host, int port, SocksProxyBase proxy) {
+ this.remotePort = port;
+ this.proxy = proxy;
+ this.localIP = proxy.proxySocket.getLocalAddress();
+ this.localPort = proxy.proxySocket.getLocalPort();
+ this.remoteHost = host;
+ }
+
+ protected SocksSocket(InetAddress ip, int port, SocksProxyBase proxy) {
+ remoteIP = ip;
+ remotePort = port;
+ this.proxy = proxy;
+ this.localIP = proxy.proxySocket.getLocalAddress();
+ this.localPort = proxy.proxySocket.getLocalPort();
+ remoteHost = remoteIP.getHostName();
+ }
+
+ /**
+ * Same as Socket
+ */
+ public void close() throws IOException {
+ if (proxy != null) {
+ proxy.endSession();
+ }
+ proxy = null;
+ }
+
+ /**
+ * Same as Socket
+ */
+ public InputStream getInputStream() {
+ return proxy.in;
+ }
+
+ /**
+ * Same as Socket
+ */
+ public OutputStream getOutputStream() {
+ return proxy.out;
+ }
+
+ /**
+ * Same as Socket
+ */
+ public int getPort() {
+ return remotePort;
+ }
+
+ /**
+ * Returns remote host name, it is usefull in cases when addresses are
+ * resolved by proxy, and we can't create InetAddress object.
+ *
+ * @return The name of the host this socket is connected to.
+ */
+ public String getHost() {
+ return remoteHost;
+ }
+
+ /**
+ * Get remote host as InetAddress object, might return null if addresses are
+ * resolved by proxy, and it is not possible to resolve it locally
+ *
+ * @return Ip address of the host this socket is connected to, or null if
+ * address was returned by the proxy as DOMAINNAME and can't be
+ * resolved locally.
+ */
+ public InetAddress getInetAddress() {
+ if (remoteIP == null) {
+ try {
+ remoteIP = InetAddress.getByName(remoteHost);
+ } catch (final UnknownHostException e) {
+ return null;
+ }
+ }
+ return remoteIP;
+ }
+
+ /**
+ * Get the port assigned by the proxy for the socket, not the port on locall
+ * machine as in Socket.
+ *
+ * @return Port of the socket used on the proxy server.
+ */
+ public int getLocalPort() {
+ return localPort;
+ }
+
+ /**
+ * Get address assigned by proxy to make a remote connection, it might be
+ * different from the host specified for the proxy. Can return null if socks
+ * server returned this address as hostname and it can't be resolved
+ * locally, use getLocalHost() then.
+ *
+ * @return Address proxy is using to make a connection.
+ */
+ public InetAddress getLocalAddress() {
+ if (localIP == null) {
+ try {
+ localIP = InetAddress.getByName(localHost);
+ } catch (final UnknownHostException e) {
+ return null;
+ }
+ }
+ return localIP;
+ }
+
+ /**
+ * Get name of the host, proxy has assigned to make a remote connection for
+ * this socket. This method is usefull when proxy have returned address as
+ * hostname, and we can't resolve it on this machine.
+ *
+ * @return The name of the host proxy is using to make a connection.
+ */
+ public String getLocalHost() {
+ return localHost;
+ }
+
+ /**
+ * Same as socket.
+ */
+ public void setSoLinger(boolean on, int val) throws SocketException {
+ proxy.proxySocket.setSoLinger(on, val);
+ }
+
+ /**
+ * Same as socket.
+ */
+ public int getSoLinger(int timeout) throws SocketException {
+ return proxy.proxySocket.getSoLinger();
+ }
+
+ /**
+ * Same as socket.
+ */
+ public void setSoTimeout(int timeout) throws SocketException {
+ proxy.proxySocket.setSoTimeout(timeout);
+ }
+
+ /**
+ * Same as socket.
+ */
+ public int getSoTimeout(int timeout) throws SocketException {
+ return proxy.proxySocket.getSoTimeout();
+ }
+
+ /**
+ * Same as socket.
+ */
+ public void setTcpNoDelay(boolean on) throws SocketException {
+ proxy.proxySocket.setTcpNoDelay(on);
+ }
+
+ /**
+ * Same as socket.
+ */
+ public boolean getTcpNoDelay() throws SocketException {
+ return proxy.proxySocket.getTcpNoDelay();
+ }
+
+ /**
+ * Get string representation of the socket.
+ */
+ public String toString() {
+ if (directSock != null) {
+ return "Direct connection:" + directSock;
+ }
+ StringBuffer sb = new StringBuffer();
+ sb.append("Proxy:");
+ sb.append(proxy);
+ sb.append(";");
+ sb.append("addr:");
+ sb.append(remoteHost);
+ sb.append(",port:");
+ sb.append(remotePort);
+ sb.append(",localport:");
+ sb.append(localPort);
+ return sb.toString();
+
+ }
+
+ // Private Methods
+ // ////////////////
+
+ private void processReply(ProxyMessage reply) throws SocksException {
+ localPort = reply.port;
+ /*
+ * If the server have assigned same host as it was contacted on it might
+ * return an address of all zeros
+ */
+ if (reply.host.equals("0.0.0.0")) {
+ localIP = proxy.proxyIP;
+ localHost = localIP.getHostName();
+ } else {
+ localHost = reply.host;
+ localIP = reply.ip;
+ }
+ }
+
+ private void doDirect() throws SocksException {
+ try {
+ log.debug("IP: {}_{}", remoteIP, remotePort);
+ directSock = new Socket(remoteIP, remotePort);
+ proxy.out = directSock.getOutputStream();
+ proxy.in = directSock.getInputStream();
+ proxy.proxySocket = directSock;
+ localIP = directSock.getLocalAddress();
+ localPort = directSock.getLocalPort();
+ } catch (final IOException io_ex) {
+ final int errCode = SocksProxyBase.SOCKS_DIRECT_FAILED;
+ throw new SocksException(errCode, "Direct connect failed:", io_ex);
+ }
+ }
+
+}
diff --git a/src/com/runjva/sourceforge/jsocks/protocol/UDPEncapsulation.java b/src/com/runjva/sourceforge/jsocks/protocol/UDPEncapsulation.java
new file mode 100644
index 0000000..913bb31
--- /dev/null
+++ b/src/com/runjva/sourceforge/jsocks/protocol/UDPEncapsulation.java
@@ -0,0 +1,33 @@
+package com.runjva.sourceforge.jsocks.protocol;
+
+/**
+ * This interface provides for datagram encapsulation for SOCKSv5 protocol.
+ * <p>
+ * SOCKSv5 allows for datagrams to be encapsulated for purposes of integrity
+ * and/or authenticity. How it should be done is aggreed during the
+ * authentication stage, and is authentication dependent. This interface is
+ * provided to allow this encapsulation.
+ *
+ * @see Authentication
+ */
+public interface UDPEncapsulation {
+
+ /**
+ * This method should provide any authentication depended transformation on
+ * datagrams being send from/to the client.
+ *
+ * @param data
+ * Datagram data (including any SOCKS related bytes), to be
+ * encapsulated/decapsulated.
+ * @param out
+ * Wether the data is being send out. If true method should
+ * encapsulate/encrypt data, otherwise it should decapsulate/
+ * decrypt data.
+ * @throw IOException if for some reason data can be transformed correctly.
+ * @return Should return byte array containing data after transformation. It
+ * is possible to return same array as input, if transformation only
+ * involves bit mangling, and no additional data is being added or
+ * removed.
+ */
+ byte[] udpEncapsulate(byte[] data, boolean out) throws java.io.IOException;
+}
diff --git a/src/com/runjva/sourceforge/jsocks/protocol/UDPRelayServer.java b/src/com/runjva/sourceforge/jsocks/protocol/UDPRelayServer.java
new file mode 100644
index 0000000..14599c7
--- /dev/null
+++ b/src/com/runjva/sourceforge/jsocks/protocol/UDPRelayServer.java
@@ -0,0 +1,231 @@
+package com.runjva.sourceforge.jsocks.protocol;
+
+import java.io.IOException;
+import java.io.InterruptedIOException;
+import java.net.DatagramPacket;
+import java.net.DatagramSocket;
+import java.net.InetAddress;
+import java.net.Socket;
+import java.net.UnknownHostException;
+
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+
+import com.runjva.sourceforge.jsocks.server.ServerAuthenticator;
+
+/**
+ * UDP Relay server, used by ProxyServer to perform udp forwarding.
+ */
+class UDPRelayServer implements Runnable {
+
+ DatagramSocket client_sock;
+ DatagramSocket remote_sock;
+
+ Socket controlConnection;
+
+ int relayPort;
+ InetAddress relayIP;
+
+ Thread pipe_thread1, pipe_thread2;
+ Thread master_thread;
+
+ ServerAuthenticator auth;
+
+ long lastReadTime;
+
+ static Logger log = LoggerFactory.getLogger(UDPRelayServer.class);
+ static SocksProxyBase proxy = null;
+ static int datagramSize = 0xFFFF;// 64K, a bit more than max udp size
+ static int iddleTimeout = 180000;// 3 minutes
+
+ /**
+ * Constructs UDP relay server to communicate with client on given ip and
+ * port.
+ *
+ * @param clientIP
+ * Address of the client from whom datagrams will be recieved and
+ * to whom they will be forwarded.
+ * @param clientPort
+ * Clients port.
+ * @param master_thread
+ * Thread which will be interrupted, when UDP relay server
+ * stoppes for some reason.
+ * @param controlConnection
+ * Socket which will be closed, before interrupting the master
+ * thread, it is introduced due to a bug in windows JVM which
+ * does not throw InterruptedIOException in threads which block
+ * in I/O operation.
+ */
+ public UDPRelayServer(InetAddress clientIP, int clientPort,
+ Thread master_thread, Socket controlConnection,
+ ServerAuthenticator auth) throws IOException {
+
+ this.master_thread = master_thread;
+ this.controlConnection = controlConnection;
+ this.auth = auth;
+
+ client_sock = new Socks5DatagramSocket(true,
+ auth.getUdpEncapsulation(), clientIP, clientPort);
+
+ relayPort = client_sock.getLocalPort();
+ relayIP = client_sock.getLocalAddress();
+
+ if (relayIP.getHostAddress().equals("0.0.0.0")) {
+ relayIP = InetAddress.getLocalHost();
+ }
+
+ if (proxy == null) {
+ remote_sock = new DatagramSocket();
+ } else {
+ remote_sock = new Socks5DatagramSocket(proxy, 0, null);
+ }
+ }
+
+ // Public methods
+ // ///////////////
+
+ /**
+ * Sets the timeout for UDPRelay server.<br>
+ * Zero timeout implies infinity.<br>
+ * Default timeout is 3 minutes.
+ */
+
+ static public void setTimeout(int timeout) {
+ iddleTimeout = timeout;
+ }
+
+ /**
+ * Sets the size of the datagrams used in the UDPRelayServer.<br>
+ * Default size is 64K, a bit more than maximum possible size of the
+ * datagram.
+ */
+ static public void setDatagramSize(int size) {
+ datagramSize = size;
+ }
+
+ /**
+ * Port to which client should send datagram for association.
+ */
+ public int getRelayPort() {
+ return relayPort;
+ }
+
+ /**
+ * IP address to which client should send datagrams for association.
+ */
+ public InetAddress getRelayIP() {
+ return relayIP;
+ }
+
+ /**
+ * Starts udp relay server. Spawns two threads of execution and returns.
+ */
+ public void start() throws IOException {
+ remote_sock.setSoTimeout(iddleTimeout);
+ client_sock.setSoTimeout(iddleTimeout);
+
+ log.info("Starting UDP relay server on {}:{}", relayIP, relayPort);
+ log.info("Remote socket {}:{}", remote_sock.getLocalAddress(),
+ remote_sock.getLocalPort());
+
+ pipe_thread1 = new Thread(this, "pipe1");
+ pipe_thread2 = new Thread(this, "pipe2");
+
+ lastReadTime = System.currentTimeMillis();
+
+ pipe_thread1.start();
+ pipe_thread2.start();
+ }
+
+ /**
+ * Stops Relay server.
+ * <p>
+ * Does not close control connection, does not interrupt master_thread.
+ */
+ public synchronized void stop() {
+ master_thread = null;
+ controlConnection = null;
+ abort();
+ }
+
+ // Runnable interface
+ // //////////////////
+ public void run() {
+ try {
+ if (Thread.currentThread().getName().equals("pipe1")) {
+ pipe(remote_sock, client_sock, false);
+ } else {
+ pipe(client_sock, remote_sock, true);
+ }
+ } catch (final IOException ioe) {
+ } finally {
+ abort();
+ log.info("UDP Pipe thread " + Thread.currentThread().getName()
+ + " stopped.");
+ }
+
+ }
+
+ // Private methods
+ // ///////////////
+ private synchronized void abort() {
+ if (pipe_thread1 == null) {
+ return;
+ }
+
+ log.info("Aborting UDP Relay Server");
+
+ remote_sock.close();
+ client_sock.close();
+
+ if (controlConnection != null) {
+ try {
+ controlConnection.close();
+ } catch (final IOException ioe) {
+ }
+ }
+
+ if (master_thread != null) {
+ master_thread.interrupt();
+ }
+
+ pipe_thread1.interrupt();
+ pipe_thread2.interrupt();
+
+ pipe_thread1 = null;
+ }
+
+ private void pipe(DatagramSocket from, DatagramSocket to, boolean out)
+ throws IOException {
+ final byte[] data = new byte[datagramSize];
+ final DatagramPacket dp = new DatagramPacket(data, data.length);
+
+ while (true) {
+ try {
+ from.receive(dp);
+ lastReadTime = System.currentTimeMillis();
+
+ if (auth.checkRequest(dp, out)) {
+ to.send(dp);
+ }
+
+ } catch (final UnknownHostException uhe) {
+ log.info("Dropping datagram for unknown host");
+ } catch (final InterruptedIOException iioe) {
+ // log("Interrupted: "+iioe);
+ // If we were interrupted by other thread.
+ if (iddleTimeout == 0) {
+ return;
+ }
+
+ // If last datagram was received, long time ago, return.
+ final long timeSinceRead = System.currentTimeMillis()
+ - lastReadTime;
+ if (timeSinceRead >= iddleTimeout - 100) {
+ return;
+ }
+ }
+ dp.setLength(data.length);
+ }
+ }
+}
diff --git a/src/com/runjva/sourceforge/jsocks/protocol/UserPasswordAuthentication.java b/src/com/runjva/sourceforge/jsocks/protocol/UserPasswordAuthentication.java
new file mode 100644
index 0000000..c161d33
--- /dev/null
+++ b/src/com/runjva/sourceforge/jsocks/protocol/UserPasswordAuthentication.java
@@ -0,0 +1,91 @@
+package com.runjva.sourceforge.jsocks.protocol;
+
+/**
+ * SOCKS5 User Password authentication scheme.
+ */
+public class UserPasswordAuthentication implements Authentication {
+
+ /** SOCKS ID for User/Password authentication method */
+ public final static int METHOD_ID = 2;
+
+ String userName, password;
+ byte[] request;
+
+ /**
+ * Create an instance of UserPasswordAuthentication.
+ *
+ * @param userName
+ * User Name to send to SOCKS server.
+ * @param password
+ * Password to send to SOCKS server.
+ */
+ public UserPasswordAuthentication(String userName, String password) {
+ this.userName = userName;
+ this.password = password;
+ formRequest();
+ }
+
+ /**
+ * Get the user name.
+ *
+ * @return User name.
+ */
+ public String getUser() {
+ return userName;
+ }
+
+ /**
+ * Get password
+ *
+ * @return Password
+ */
+ public String getPassword() {
+ return password;
+ }
+
+ /**
+ * Does User/Password authentication as defined in rfc1929.
+ *
+ * @return An array containnig in, out streams, or null if authentication
+ * fails.
+ */
+ public Object[] doSocksAuthentication(int methodId,
+ java.net.Socket proxySocket) throws java.io.IOException {
+
+ if (methodId != METHOD_ID) {
+ return null;
+ }
+
+ final java.io.InputStream in = proxySocket.getInputStream();
+ final java.io.OutputStream out = proxySocket.getOutputStream();
+
+ out.write(request);
+ final int version = in.read();
+ if (version < 0) {
+ return null; // Server closed connection
+ }
+ final int status = in.read();
+ if (status != 0) {
+ return null; // Server closed connection, or auth failed.
+ }
+
+ return new Object[] { in, out };
+ }
+
+ // Private methods
+ // ////////////////
+
+ /** Convert UserName password in to binary form, ready to be send to server */
+ private void formRequest() {
+ final byte[] user_bytes = userName.getBytes();
+ final byte[] password_bytes = password.getBytes();
+
+ request = new byte[3 + user_bytes.length + password_bytes.length];
+ request[0] = (byte) 1;
+ request[1] = (byte) user_bytes.length;
+ System.arraycopy(user_bytes, 0, request, 2, user_bytes.length);
+ request[2 + user_bytes.length] = (byte) password_bytes.length;
+ System.arraycopy(password_bytes, 0, request, 3 + user_bytes.length,
+ password_bytes.length);
+ }
+}
diff --git a/src/com/runjva/sourceforge/jsocks/server/Ident.java b/src/com/runjva/sourceforge/jsocks/server/Ident.java
new file mode 100644
index 0000000..7193f79
--- /dev/null
+++ b/src/com/runjva/sourceforge/jsocks/server/Ident.java
@@ -0,0 +1,176 @@
+package com.runjva.sourceforge.jsocks.server;
+
+import java.io.BufferedReader;
+import java.io.IOException;
+import java.io.InputStreamReader;
+import java.io.InterruptedIOException;
+import java.net.ConnectException;
+import java.net.Socket;
+import java.util.StringTokenizer;
+
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+
+/**
+ * Class Ident provides means to obtain user name of the owner of the socket on
+ * remote machine, providing remote machine runs identd daemon.
+ * <p>
+ * To use it: <tt><pre>
+ Socket s = ss.accept();
+ Ident id = new Ident(s);
+ if(id.successful) goUseUser(id.userName);
+ else handleIdentError(id.errorCode,id.errorMessage)
+ </pre></tt>
+ */
+public class Ident {
+
+ Logger log = LoggerFactory.getLogger(Ident.class);
+
+ /** Error Message can be null. */
+ public String errorMessage;
+
+ /** Host type as returned by daemon, can be null, if error happened */
+ public String hostType;
+
+ /** User name as returned by the identd daemon, or null, if it failed */
+ public String userName;
+
+ /**
+ * If this is true then userName and hostType contain valid values. Else
+ * errorCode contain the error code, and errorMessage contains the
+ * corresponding message.
+ */
+ public boolean successful;
+
+ /** Error code */
+ public int errorCode;
+
+ /** Identd on port 113 can't be contacted */
+ public static final int ERR_NO_CONNECT = 1;
+
+ /** Connection timed out */
+ public static final int ERR_TIMEOUT = 2;
+
+ /**
+ * Identd daemon responded with ERROR, in this case errorMessage contains
+ * the string explanation, as send by the daemon.
+ */
+ public static final int ERR_PROTOCOL = 3;
+
+ /**
+ * When parsing server response protocol error happened.
+ */
+ public static final int ERR_PROTOCOL_INCORRECT = 4;
+
+ /**
+ * Maximum amount of time we should wait before dropping the connection to
+ * identd server.Setting it to 0 implies infinit timeout.
+ */
+ public static final int connectionTimeout = 10000;
+
+ /**
+ * Constructor tries to connect to Identd daemon on the host of the given
+ * socket, and retrieve user name of the owner of given socket connection on
+ * remote machine. After constructor returns public fields are initialised
+ * to whatever the server returned.
+ * <p>
+ * If user name was successfully retrieved successful is set to true, and
+ * userName and hostType are set to whatever server returned. If however for
+ * some reason user name was not obtained, successful is set to false and
+ * errorCode contains the code explaining the reason of failure, and
+ * errorMessage contains human readable explanation.
+ * <p>
+ * Constructor may block, for a while.
+ *
+ * @param s
+ * Socket whose ownership on remote end should be obtained.
+ */
+ public Ident(Socket s) {
+ Socket sock = null;
+ successful = false; // We are pessimistic
+
+ try {
+ sock = new Socket(s.getInetAddress(), 113);
+ sock.setSoTimeout(connectionTimeout);
+ final byte[] request = ("" + s.getPort() + " , " + s.getLocalPort() + "\r\n")
+ .getBytes();
+
+ sock.getOutputStream().write(request);
+
+ final BufferedReader in = new BufferedReader(new InputStreamReader(
+ sock.getInputStream()));
+
+ parseResponse(in.readLine());
+
+ } catch (final InterruptedIOException iioe) {
+ errorCode = ERR_TIMEOUT;
+ errorMessage = "Connection to identd timed out.";
+ } catch (final ConnectException ce) {
+ errorCode = ERR_NO_CONNECT;
+ errorMessage = "Connection to identd server failed.";
+
+ } catch (final IOException ioe) {
+ errorCode = ERR_NO_CONNECT;
+ errorMessage = "" + ioe;
+ } finally {
+ try {
+ if (sock != null) {
+ sock.close();
+ }
+ } catch (final IOException ioe) {
+ log.warn("Could not close socket", ioe);
+ }
+ }
+ }
+
+ private void parseResponse(String response) {
+ if (response == null) {
+ errorCode = ERR_PROTOCOL_INCORRECT;
+ errorMessage = "Identd server closed connection.";
+ return;
+ }
+
+ final StringTokenizer st = new StringTokenizer(response, ":");
+ if (st.countTokens() < 3) {
+ errorCode = ERR_PROTOCOL_INCORRECT;
+ errorMessage = "Can't parse server response.";
+ return;
+ }
+
+ st.nextToken(); // Discard first token, it's basically what we have send
+ final String command = st.nextToken().trim().toUpperCase();
+
+ if (command.equals("USERID") && (st.countTokens() >= 2)) {
+ successful = true;
+ hostType = st.nextToken().trim();
+ userName = st.nextToken("").substring(1);// Get all that is left
+ } else if (command.equals("ERROR")) {
+ errorCode = ERR_PROTOCOL;
+ errorMessage = st.nextToken();
+ } else {
+ errorCode = ERR_PROTOCOL_INCORRECT;
+ System.out.println("Opa!");
+ errorMessage = "Can't parse server response.";
+ }
+
+ }
+
+ // /////////////////////////////////////////////
+ // USED for Testing
+ /*
+ * public static void main(String[] args) throws IOException{
+ *
+ * Socket s = null; s = new Socket("gp101-16", 1391);
+ *
+ * Ident id = new Ident(s); if(id.successful){
+ * System.out.println("User: "+id.userName);
+ * System.out.println("HostType: "+id.hostType); }else{
+ * System.out.println("ErrorCode: "+id.errorCode);
+ * System.out.println("ErrorMessage: "+id.errorMessage);
+ *
+ * }
+ *
+ * if(s!= null) s.close(); } //
+ */
+
+}
diff --git a/src/com/runjva/sourceforge/jsocks/server/IdentAuthenticator.java b/src/com/runjva/sourceforge/jsocks/server/IdentAuthenticator.java
new file mode 100644
index 0000000..da040f5
--- /dev/null
+++ b/src/com/runjva/sourceforge/jsocks/server/IdentAuthenticator.java
@@ -0,0 +1,182 @@
+package com.runjva.sourceforge.jsocks.server;
+
+import java.io.IOException;
+import java.io.InputStream;
+import java.io.OutputStream;
+import java.net.InetAddress;
+import java.net.Socket;
+import java.util.Enumeration;
+import java.util.Hashtable;
+import java.util.Vector;
+
+import com.runjva.sourceforge.jsocks.protocol.InetRange;
+import com.runjva.sourceforge.jsocks.protocol.ProxyMessage;
+
+/**
+ * An implementation of socks.ServerAuthentication which provides simple
+ * authentication based on the host from which the connection is made and the
+ * name of the user on the remote machine, as reported by identd daemon on the
+ * remote machine.
+ * <p>
+ * It can also be used to provide authentication based only on the contacting
+ * host address.
+ */
+
+public class IdentAuthenticator extends ServerAuthenticatorBase {
+ /** Vector of InetRanges */
+ Vector<InetRange> hosts;
+
+ /** Vector of user hashes */
+ Vector<Hashtable<?, ?>> users;
+
+ String user;
+
+ /**
+ * Constructs empty IdentAuthenticator.
+ */
+ public IdentAuthenticator() {
+ hosts = new Vector<InetRange>();
+ users = new Vector<Hashtable<?, ?>>();
+ }
+
+ /**
+ * Used to create instances returned from startSession.
+ *
+ * @param in
+ * Input stream.
+ * @param out
+ * OutputStream.
+ * @param user
+ * Username associated with this connection,could be null if name
+ * was not required.
+ */
+ IdentAuthenticator(InputStream in, OutputStream out, String user) {
+ super(in, out);
+ this.user = user;
+ }
+
+ /**
+ * Adds range of addresses from which connection is allowed. Hashtable users
+ * should contain user names as keys and anything as values (value is not
+ * used and will be ignored).
+ *
+ * @param hostRange
+ * Range of ip addresses from which connection is allowed.
+ * @param users
+ * Hashtable of users for whom connection is allowed, or null to
+ * indicate that anybody is allowed to connect from the hosts
+ * within given range.
+ */
+ public synchronized void add(InetRange hostRange, Hashtable<?, ?> users) {
+ this.hosts.addElement(hostRange);
+ this.users.addElement(users);
+ }
+
+ /**
+ * Grants permission only to those users, who connect from one of the hosts
+ * registered with add(InetRange,Hashtable) and whose names, as reported by
+ * identd daemon, are listed for the host the connection came from.
+ */
+ public ServerAuthenticator startSession(Socket s) throws IOException {
+
+ final int ind = getRangeIndex(s.getInetAddress());
+ String user = null;
+
+ // System.out.println("getRangeReturned:"+ind);
+
+ if (ind < 0) {
+ return null; // Host is not on the list.
+ }
+
+ final ServerAuthenticator serverAuthenticator = super.startSession(s);
+ final ServerAuthenticatorBase auth = (ServerAuthenticatorBase) serverAuthenticator;
+
+ // System.out.println("super.startSession() returned:"+auth);
+ if (auth == null) {
+ return null;
+ }
+
+ // do the authentication
+
+ final Hashtable<?, ?> user_names = users.elementAt(ind);
+
+ if (user_names != null) { // If need to do authentication
+ Ident ident;
+ ident = new Ident(s);
+ // If can't obtain user name, fail
+ if (!ident.successful) {
+ return null;
+ }
+ // If user name is not listed for this address, fail
+ if (!user_names.containsKey(ident.userName)) {
+ return null;
+ }
+ user = ident.userName;
+ }
+ return new IdentAuthenticator(auth.in, auth.out, user);
+
+ }
+
+ /**
+ * For SOCKS5 requests allways returns true. For SOCKS4 requests checks
+ * wether the user name supplied in the request corresponds to the name
+ * obtained from the ident daemon.
+ */
+ public boolean checkRequest(ProxyMessage msg, java.net.Socket s) {
+ // If it's version 5 request, or if anybody is permitted, return true;
+ if ((msg.version == 5) || (user == null)) {
+ return true;
+ }
+
+ if (msg.version != 4) {
+ return false; // Who knows?
+ }
+
+ return user.equals(msg.user);
+ }
+
+ /** Get String representaion of the IdentAuthenticator. */
+ public String toString() {
+ String s = "";
+
+ for (int i = 0; i < hosts.size(); ++i) {
+ s += "(Range:" + hosts.elementAt(i) + "," + //
+ " Users:" + userNames(i) + ") ";
+ }
+ return s;
+ }
+
+ // Private Methods
+ // ////////////////
+ private int getRangeIndex(InetAddress ip) {
+ int index = 0;
+ final Enumeration<InetRange> enumx = hosts.elements();
+ while (enumx.hasMoreElements()) {
+ final InetRange ir = enumx.nextElement();
+ if (ir.contains(ip)) {
+ return index;
+ }
+ index++;
+ }
+ return -1; // Not found
+ }
+
+ private String userNames(int i) {
+ if (users.elementAt(i) == null) {
+ return "Everybody is permitted.";
+ }
+
+ final Enumeration<?> enumx = ((Hashtable<?, ?>) users.elementAt(i))
+ .keys();
+ if (!enumx.hasMoreElements()) {
+ return "";
+ }
+ String s = enumx.nextElement().toString();
+ while (enumx.hasMoreElements()) {
+ s += "; " + enumx.nextElement();
+ }
+
+ return s;
+ }
+
+}
diff --git a/src/com/runjva/sourceforge/jsocks/server/ServerAuthenticator.java b/src/com/runjva/sourceforge/jsocks/server/ServerAuthenticator.java
new file mode 100644
index 0000000..c2451ac
--- /dev/null
+++ b/src/com/runjva/sourceforge/jsocks/server/ServerAuthenticator.java
@@ -0,0 +1,126 @@
+package com.runjva.sourceforge.jsocks.server;
+
+import java.io.IOException;
+import java.io.InputStream;
+import java.io.OutputStream;
+import java.net.DatagramPacket;
+import java.net.Socket;
+
+import com.runjva.sourceforge.jsocks.protocol.ProxyMessage;
+import com.runjva.sourceforge.jsocks.protocol.UDPEncapsulation;
+
+/**
+ * Classes implementing this interface should provide socks server with
+ * authentication and authorization of users.
+ **/
+public interface ServerAuthenticator {
+
+ /**
+ * This method is called when a new connection accepted by the server.
+ * <p>
+ * At this point no data have been extracted from the connection. It is
+ * responsibility of this method to ensure that the next byte in the stream
+ * after this method have been called is the first byte of the socks request
+ * message. For SOCKSv4 there is no authentication data and the first byte
+ * in the stream is part of the request. With SOCKSv5 however there is an
+ * authentication data first. It is expected that implementaions will
+ * process this authentication data.
+ * <p>
+ * If authentication was successful an instance of ServerAuthentication
+ * should be returned, it later will be used by the server to perform
+ * authorization and some other things. If authentication fails null should
+ * be returned, or an exception may be thrown.
+ *
+ * @param s
+ * Accepted Socket.
+ * @return An instance of ServerAuthenticator to be used for this connection
+ * or null
+ */
+ ServerAuthenticator startSession(Socket s) throws IOException;
+
+ /**
+ * This method should return input stream which should be used on the
+ * accepted socket.
+ * <p>
+ * SOCKSv5 allows to have multiple authentication methods, and these methods
+ * might require some kind of transformations being made on the data.
+ * <p>
+ * This method is called on the object returned from the startSession
+ * function.
+ */
+ InputStream getInputStream();
+
+ /**
+ * This method should return output stream to use to write to the accepted
+ * socket.
+ * <p>
+ * SOCKSv5 allows to have multiple authentication methods, and these methods
+ * might require some kind of transformations being made on the data.
+ * <p>
+ * This method is called on the object returned from the startSession
+ * function.
+ */
+ OutputStream getOutputStream();
+
+ /**
+ * This method should return UDPEncapsulation, which should be used on the
+ * datagrams being send in/out.
+ * <p>
+ * If no transformation should be done on the datagrams, this method should
+ * return null.
+ * <p>
+ * This method is called on the object returned from the startSession
+ * function.
+ */
+
+ UDPEncapsulation getUdpEncapsulation();
+
+ /**
+ * This method is called when a request have been read.
+ * <p>
+ * Implementation should decide wether to grant request or not. Returning
+ * true implies granting the request, false means request should be
+ * rejected.
+ * <p>
+ * This method is called on the object returned from the startSession
+ * function.
+ *
+ * @param msg
+ * Request message.
+ * @return true to grant request, false to reject it.
+ */
+ boolean checkRequest(ProxyMessage msg);
+
+ /**
+ * This method is called when datagram is received by the server.
+ * <p>
+ * Implementaions should decide wether it should be forwarded or dropped. It
+ * is expecteed that implementation will use datagram address and port
+ * information to make a decision, as well as anything else. Address and
+ * port of the datagram are always correspond to remote machine. It is
+ * either destination or source address. If out is true address is
+ * destination address, else it is a source address, address of the machine
+ * from which datagram have been received for the client.
+ * <p>
+ * Implementaions should return true if the datagram is to be forwarded, and
+ * false if the datagram should be dropped.
+ * <p>
+ * This method is called on the object returned from the startSession
+ * function.
+ *
+ * @param out
+ * If true the datagram is being send out(from the client),
+ * otherwise it is an incoming datagram.
+ * @return True to forward datagram false drop it silently.
+ */
+ boolean checkRequest(DatagramPacket dp, boolean out);
+
+ /**
+ * This method is called when session is completed. Either due to normal
+ * termination or due to any error condition.
+ * <p>
+ * This method is called on the object returned from the startSession
+ * function.
+ */
+ void endSession();
+}
diff --git a/src/com/runjva/sourceforge/jsocks/server/ServerAuthenticatorBase.java b/src/com/runjva/sourceforge/jsocks/server/ServerAuthenticatorBase.java
new file mode 100644
index 0000000..c67a89f
--- /dev/null
+++ b/src/com/runjva/sourceforge/jsocks/server/ServerAuthenticatorBase.java
@@ -0,0 +1,187 @@
+package com.runjva.sourceforge.jsocks.server;
+
+import java.io.IOException;
+import java.io.InputStream;
+import java.io.OutputStream;
+import java.io.PushbackInputStream;
+import java.net.Socket;
+
+import com.runjva.sourceforge.jsocks.protocol.ProxyMessage;
+import com.runjva.sourceforge.jsocks.protocol.UDPEncapsulation;
+
+/**
+ * An implementation of ServerAuthenticator, which does <b>not</b> do any
+ * authentication.
+ * <P>
+ * <FONT size="+3" color ="FF0000"> Warning!!</font><br>
+ * Should not be used on machines which are not behind the firewall.
+ * <p>
+ * It is only provided to make implementing other authentication schemes easier.
+ * <br>
+ * For Example: <tt><pre>
+ class MyAuth extends socks.server.ServerAuthenticator{
+ ...
+ public ServerAuthenticator startSession(java.net.Socket s){
+ if(!checkHost(s.getInetAddress()) return null;
+ return super.startSession(s);
+ }
+
+ boolean checkHost(java.net.Inetaddress addr){
+ boolean allow;
+ //Do it somehow
+ return allow;
+ }
+ }
+</pre></tt>
+ */
+public abstract class ServerAuthenticatorBase implements ServerAuthenticator {
+
+ static final byte[] socks5response = { 5, 0 };
+
+ InputStream in;
+ OutputStream out;
+
+ /**
+ * Creates new instance of the ServerAuthenticatorNone.
+ */
+ public ServerAuthenticatorBase() {
+ this.in = null;
+ this.out = null;
+ }
+
+ /**
+ * Constructs new ServerAuthenticatorNone object suitable for returning from
+ * the startSession function.
+ *
+ * @param in
+ * Input stream to return from getInputStream method.
+ * @param out
+ * Output stream to return from getOutputStream method.
+ */
+ public ServerAuthenticatorBase(InputStream in, OutputStream out) {
+ this.in = in;
+ this.out = out;
+ }
+
+ /**
+ * Grants access to everyone.Removes authentication related bytes from the
+ * stream, when a SOCKS5 connection is being made, selects an authentication
+ * NONE.
+ */
+ public ServerAuthenticator startSession(Socket s) throws IOException {
+
+ final PushbackInputStream in = new PushbackInputStream(s
+ .getInputStream());
+ final OutputStream out = s.getOutputStream();
+
+ final int version = in.read();
+ if (version == 5) {
+ if (!selectSocks5Authentication(in, out, 0)) {
+ return null;
+ }
+ } else if (version == 4) {
+ // Else it is the request message already, version 4
+ in.unread(version);
+ } else {
+ return null;
+ }
+
+ return new ServerAuthenticatorNone(in, out);
+ }
+
+ /**
+ * Get input stream.
+ *
+ * @return Input stream speciefied in the constructor.
+ */
+ public InputStream getInputStream() {
+ return in;
+ }
+
+ /**
+ * Get output stream.
+ *
+ * @return Output stream speciefied in the constructor.
+ */
+ public OutputStream getOutputStream() {
+ return out;
+ }
+
+ /**
+ * Allways returns null.
+ *
+ * @return null
+ */
+ public UDPEncapsulation getUdpEncapsulation() {
+ return null;
+ }
+
+ /**
+ * Allways returns true.
+ */
+ public boolean checkRequest(ProxyMessage msg) {
+ return true;
+ }
+
+ /**
+ * Allways returns true.
+ */
+ public boolean checkRequest(java.net.DatagramPacket dp, boolean out) {
+ return true;
+ }
+
+ /**
+ * Does nothing.
+ */
+ public void endSession() {
+ }
+
+ /**
+ * Convinience routine for selecting SOCKSv5 authentication.
+ * <p>
+ * This method reads in authentication methods that client supports, checks
+ * wether it supports given method. If it does, the notification method is
+ * written back to client, that this method have been chosen for
+ * authentication. If given method was not found, authentication failure
+ * message is send to client ([5,FF]).
+ *
+ * @param in
+ * Input stream, version byte should be removed from the stream
+ * before calling this method.
+ * @param out
+ * Output stream.
+ * @param methodId
+ * Method which should be selected.
+ * @return true if methodId was found, false otherwise.
+ */
+ static public boolean selectSocks5Authentication(InputStream in,
+ OutputStream out, int methodId) throws IOException {
+
+ final int num_methods = in.read();
+ if (num_methods <= 0) {
+ return false;
+ }
+ final byte method_ids[] = new byte[num_methods];
+ final byte response[] = new byte[2];
+ boolean found = false;
+
+ response[0] = (byte) 5; // SOCKS version
+ response[1] = (byte) 0xFF; // Not found, we are pessimistic
+
+ int bread = 0; // bytes read so far
+ while (bread < num_methods) {
+ bread += in.read(method_ids, bread, num_methods - bread);
+ }
+
+ for (int i = 0; i < num_methods; ++i) {
+ if (method_ids[i] == methodId) {
+ found = true;
+ response[1] = (byte) methodId;
+ break;
+ }
+ }
+
+ out.write(response);
+ return found;
+ }
+}
diff --git a/src/com/runjva/sourceforge/jsocks/server/ServerAuthenticatorNone.java b/src/com/runjva/sourceforge/jsocks/server/ServerAuthenticatorNone.java
new file mode 100644
index 0000000..0e97677
--- /dev/null
+++ b/src/com/runjva/sourceforge/jsocks/server/ServerAuthenticatorNone.java
@@ -0,0 +1,16 @@
+package com.runjva.sourceforge.jsocks.server;
+
+import java.io.InputStream;
+import java.io.OutputStream;
+
+/**
+ * Simplest possible ServerAuthenticator implementation. Extends common base.
+ *
+ */
+public class ServerAuthenticatorNone extends ServerAuthenticatorBase {
+
+ public ServerAuthenticatorNone(InputStream in, OutputStream out) {
+ super(in, out);
+ }
+
+}
diff --git a/src/com/runjva/sourceforge/jsocks/server/UserPasswordAuthenticator.java b/src/com/runjva/sourceforge/jsocks/server/UserPasswordAuthenticator.java
new file mode 100644
index 0000000..7d54b45
--- /dev/null
+++ b/src/com/runjva/sourceforge/jsocks/server/UserPasswordAuthenticator.java
@@ -0,0 +1,82 @@
+package com.runjva.sourceforge.jsocks.server;
+
+import java.io.IOException;
+import java.io.InputStream;
+import java.io.OutputStream;
+import java.net.Socket;
+
+/**
+ * This class implements SOCKS5 User/Password authentication scheme as defined
+ * in rfc1929,the server side of it. (see docs/rfc1929.txt)
+ */
+public class UserPasswordAuthenticator extends ServerAuthenticatorBase {
+
+ static final int METHOD_ID = 2;
+
+ UserValidation validator;
+
+ /**
+ * Construct a new UserPasswordAuthentication object, with given
+ * UserVlaidation scheme.
+ *
+ * @param v
+ * UserValidation to use for validating users.
+ */
+ public UserPasswordAuthenticator(UserValidation validator) {
+ this.validator = validator;
+ }
+
+ public ServerAuthenticator startSession(Socket s) throws IOException {
+ final InputStream in = s.getInputStream();
+ final OutputStream out = s.getOutputStream();
+
+ if (in.read() != 5) {
+ return null; // Drop non version 5 messages.
+ }
+
+ if (!selectSocks5Authentication(in, out, METHOD_ID)) {
+ return null;
+ }
+ if (!doUserPasswordAuthentication(s, in, out)) {
+ return null;
+ }
+
+ return new ServerAuthenticatorNone(in, out);
+ }
+
+ // Private Methods
+ // ////////////////
+
+ private boolean doUserPasswordAuthentication(Socket s, InputStream in,
+ OutputStream out) throws IOException {
+ final int version = in.read();
+ if (version != 1) {
+ return false;
+ }
+
+ final int ulen = in.read();
+ if (ulen < 0) {
+ return false;
+ }
+
+ final byte[] user = new byte[ulen];
+ in.read(user);
+ final int plen = in.read();
+ if (plen < 0) {
+ return false;
+ }
+ final byte[] password = new byte[plen];
+ in.read(password);
+
+ if (validator.isUserValid(new String(user), new String(password), s)) {
+ // System.out.println("user valid");
+ out.write(new byte[] { 1, 0 });
+ } else {
+ // System.out.println("user invalid");
+ out.write(new byte[] { 1, 1 });
+ return false;
+ }
+
+ return true;
+ }
+}
diff --git a/src/com/runjva/sourceforge/jsocks/server/UserValidation.java b/src/com/runjva/sourceforge/jsocks/server/UserValidation.java
new file mode 100644
index 0000000..d0b5229
--- /dev/null
+++ b/src/com/runjva/sourceforge/jsocks/server/UserValidation.java
@@ -0,0 +1,24 @@
+package com.runjva.sourceforge.jsocks.server;
+
+/**
+ * Interface which provides for user validation, based on user name password and
+ * where it connects from.
+ */
+public interface UserValidation {
+ /**
+ * Implementations of this interface are expected to use some or all of the
+ * information provided plus any information they can extract from other
+ * sources to decide wether given user should be allowed access to SOCKS
+ * server, or whatever you use it for.
+ *
+ * @return true to indicate user is valid, false otherwise.
+ * @param username
+ * User whom implementation should validate.
+ * @param password
+ * Password this user provided.
+ * @param connection
+ * Socket which user used to connect to the server.
+ */
+ boolean isUserValid(String username, String password,
+ java.net.Socket connection);
+}
diff --git a/src/org/sandroproxy/ony/OrbotApp.java b/src/org/sandroproxy/ony/OrbotApp.java
new file mode 100644
index 0000000..fdc3b89
--- /dev/null
+++ b/src/org/sandroproxy/ony/OrbotApp.java
@@ -0,0 +1,69 @@
+package org.sandroproxy.ony;
+
+import java.util.Locale;
+
+import org.torproject.android.TorConstants;
+import org.torproject.android.service.TorServiceUtils;
+
+import android.app.Application;
+import android.content.SharedPreferences;
+import android.content.res.Configuration;
+import android.preference.PreferenceManager;
+
+public class OrbotApp extends Application implements TorConstants
+{
+
+ private Locale locale;
+ private final static String DEFAULT_LOCALE = "en";
+ private SharedPreferences settings;
+
+ @Override
+ public void onCreate() {
+ super.onCreate();
+
+ settings = TorServiceUtils.getSharedPrefs(getApplicationContext());
+
+ Configuration config = getResources().getConfiguration();
+
+ String lang = settings.getString(PREF_DEFAULT_LOCALE, DEFAULT_LOCALE);
+
+ if (! "".equals(lang) && ! config.locale.getLanguage().equals(lang))
+ {
+ if (lang.equals("xx"))
+ {
+ locale = Locale.getDefault();
+
+ }
+ else
+ locale = new Locale(lang);
+
+ Locale.setDefault(locale);
+
+ Configuration myConfig = new Configuration(config);
+ myConfig.locale = locale;
+
+ getResources().updateConfiguration(myConfig, getResources().getDisplayMetrics());
+ }
+
+
+ }
+
+ @Override
+ public void onConfigurationChanged(Configuration newConfig)
+ {
+ super.onConfigurationChanged(newConfig);
+
+ String lang = settings.getString(PREF_DEFAULT_LOCALE, DEFAULT_LOCALE);
+
+ if (! "".equals(lang) && ! newConfig.locale.getLanguage().equals(lang))
+ {
+ locale = new Locale(lang);
+ Locale.setDefault(locale);
+
+ Configuration myConfig = new Configuration(newConfig);
+ myConfig.locale = locale;
+
+ getResources().updateConfiguration(myConfig, getResources().getDisplayMetrics());
+ }
+ }
+}
More information about the tor-commits
mailing list