package nu.fw.jeti.plugins.filetransfer.socks5.jsocks;
import java.net.*;
import java.io.*;
/**
Datagram socket to interract through the firewall.
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.
SOCKS5 protocol allows to send host address as either:
NOTE:
Unlike other SOCKS Sockets, it does not 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;
/**
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(Proxy.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(Proxy.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(Proxy.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:
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); //debug("Sending directly:"); return; } byte[] head = formHeader(dp.getAddress(),dp.getPort()); byte[] buf = new byte[head.length + dp.getLength()]; 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.
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(((Socks5Proxy)proxy).resolveAddrLocally){
dp.setAddress(InetAddress.getByName(host));
}
byte[] head = formHeader(host,dp.getPort());
byte[] buf = new byte[head.length + dp.getLength()];
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.
* If the packet arrived from anywhere else it is not changed.
* NOTE: 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
int init_length = dp.getLength();
int initTimeout = getSoTimeout();
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){
int newTimeout = initTimeout - (int)(System.currentTimeMillis() -
startTime);
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);
int offset = 0; //Java 1.1
//int offset = dp.getOffset(); //Java 1.2
ByteArrayInputStream bIn = new ByteArrayInputStream(data,offset,
dp.getLength());
ProxyMessage msg = new Socks5Message(bIn);
dp.setPort(msg.port);
dp.setAddress(msg.getInetAddress());
//what wasn't read by the Message is the data
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.
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.
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.
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.
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);
int eof = proxy.in.read();
if(eof < 0) return false; // EOF encountered.
else return true; // This really should not happen
}catch(InterruptedIOException iioe){
return true; // read timed out.
}catch(IOException ioe){
return false;
}
}
return false;
}
//PRIVATE METHODS
//////////////////
private byte[] formHeader(InetAddress ip, int port){
Socks5Message request = new Socks5Message(0,ip,port);
request.data[0] = 0;
return request.data;
}
private byte[] formHeader(String host,int port){
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