Skip to content

Instantly share code, notes, and snippets.

Embed
What would you like to do?
Traceroute in Java
@RestController
@ConditionalOnExpression("${my.controller.enabled:false}")
@RequestMapping(value = "foo", produces = "application/json;charset=UTF-8")
public class MyController {
@RequestMapping(value = "bar")
public ResponseEntity<String> bar(
return new ResponseEntity<>("Hello world", HttpStatus.OK);
}
}
import java.io.IOException;
import java.net.Inet4Address;
import java.net.InetAddress;
import java.net.MalformedURLException;
import java.net.URL;
import java.net.UnknownHostException;
import java.util.Arrays;
import jpcap.JpcapCaptor;
import jpcap.JpcapSender;
import jpcap.NetworkInterface;
import jpcap.NetworkInterfaceAddress;
import jpcap.packet.EthernetPacket;
import jpcap.packet.ICMPPacket;
import jpcap.packet.IPPacket;
import jpcap.packet.Packet;
import jpcap.packet.TCPPacket;
/**
* Encapsulates ICMP interface that can be used to ping or trace route remote
* hosts.
*
* @author Mikica B Kocic
*
*/
public class Traceroute implements Runnable
{
/**
* Provides message presentation context to instance of <code>Traceroute</code>.
*/
public interface Context
{
/**
* Logs new line
*/
public abstract void logNewLine ();
/**
* Logs message, with optional timestamp
*
* @param str message that will be logged
* @param timestamp indicates whether to put timestamp in front
*/
public abstract void logMessage( String str, boolean timestamp );
/**
* Changed status
*/
public abstract void onTracerouteCompleted ();
}
//////////////////////////////////////////////////////////////////////////////////////
/**
* Instance of the thread that sends ICMP packets
*/
private Thread tracingThread;
/**
* Indicates if thread is (or should be) running
*/
private volatile boolean running = false;
/**
* Indicates that thread has been completed
*/
private volatile boolean completed;
/**
* Jpcap <code>NetworkInterface</code> device count.
*/
private int deviceCount = 0;
/**
* Instance of the Jpcap capturing class
*/
private JpcapCaptor captor = null;
/**
* Instance of the Jpcap network interface used for sending and
* receiving ICMP packets
*/
private NetworkInterface device = null;
/**
* Local IP address
*/
private InetAddress localIP = null;
/**
* Indicates whether to resolve addresses to names or not. By default
* disabled, because resolving will slow down trace route presentation.
*/
private boolean resolveNames = false;
/**
* Host name or IP address to ping
*/
private String hostName;
/**
* Initial TTL (time to live or hop count). When set to 0, thread will do
* trace route. When set to e.g. 64, thread will do ping.
*/
private int initialTTL;
/**
* Presentation context for messages
*/
private Context context;
//////////////////////////////////////////////////////////////////////////////////////
/**
* Creates new instance of <code>Traceroute</code>
*
* @param context where to log messages
*/
public Traceroute( Context context )
{
this.context = context;
this.running = false;
this.completed = true;
this.tracingThread = null;
deviceCount = JpcapCaptor.getDeviceList ().length;
}
/**
* Prints line to log area prefixed with timestamp
*/
private void println( String str )
{
context.logMessage( str, /*timestamp*/ true );
context.logNewLine ();
}
/**
* Advances to new line in log area
*/
private void println ()
{
context.logNewLine ();
}
/**
* Prints characters to log area optionally prefixed with timestamp
*
* @param str message to log
* @param timestamp whether to prefix message with timestamp or not
*/
private void print( String str, boolean timestamp )
{
context.logMessage( str,timestamp );
}
/**
* Starts thread that will trace route to given host. The instance is
* locked in the mean time, so other trace routes could not start in parallel.
* To start trace-route <code>initialTTL</code> must be set to 0. To start
* ping instead, set <code>initialTTL</code> to 64.
*
* @param deviceNo network interface on which to start pinging
* @param hostName target host address or host name
* @param initialTTL initial hop limit (or time-to-live)
*/
public void startPinging( int deviceNo, String hostName, int initialTTL )
{
synchronized( this )
{
if ( ! completed ) { // Allows only one thread per instance
return;
}
/* Set thread parameters
*/
openDeviceOnInterface( deviceNo );
this.hostName = hostName;
this.initialTTL = initialTTL;
/* Enable thread
*/
running = true;
completed = false;
/* Start thread
*/
tracingThread = new Thread( this );
tracingThread.start ();
}
}
/**
* Stops on-going trace route or ping
*/
public void stopTrace ()
{
synchronized( this )
{
running = false; // signal thread to exit
this.notifyAll (); // interrupt any sleep
}
print( " <interrupt> ", /*timestamp*/ false );
}
/**
* Returns if IDLE, i.e. if tracing thread does not exist or previous thread has
* been completed.
*/
public boolean isIdle ()
{
return completed;
}
/**
* Dumps details about particular Jpcap network interface into log area
*
* @param title title line
* @param ni network interface to show
*/
public void dumpInterfaceInfo( String title, NetworkInterface ni )
{
println( title );
println( " Desc: " + ni.description );
println( " Name: " + ni.name );
for( NetworkInterfaceAddress na : ni.addresses )
{
println( " Addr: " + na.address );
}
}
/**
* Gets array of interface descriptions (suitable for the JComboBox)
*
* @return array of strings with descriptions
*/
public String[] getInterfaceList ()
{
this.deviceCount = JpcapCaptor.getDeviceList ().length;
String[] devList = new String[ this.deviceCount ];
int ni_index = 0;
for( NetworkInterface ni : JpcapCaptor.getDeviceList () )
{
String ourDescription = ni.description;
for( NetworkInterfaceAddress addr : ni.addresses )
{
if( addr.address instanceof Inet4Address ) {
ourDescription = addr.address.toString () + " -- " + ni.description;
break;
}
}
devList[ ni_index ] = " iface" + ni_index + " -- " + ourDescription;
dumpInterfaceInfo( "Interface " + (ni_index++), ni );
}
return devList;
}
/*
* Open Jpcap device to send/receive on particular network interface
*
* @param deviceNo device index (e.g., 0, 1..)
*/
private void openDeviceOnInterface( int deviceNo )
{
// Open specified device from the list
//
device = JpcapCaptor.getDeviceList()[ deviceNo ];
localIP = null;
captor = null;
try
{
captor = JpcapCaptor.openDevice( device,
/*MTU*/ 2000, /*promiscuous*/ false, /*timeout*/ 1 );
// captor.setNonBlockingMode( true );
// captor.setPacketReadTimeout( 1000 );
for( NetworkInterfaceAddress addr : device.addresses )
{
if( addr.address instanceof Inet4Address ) {
localIP = addr.address;
break;
}
}
}
catch ( IOException e )
{
device = null;
localIP = null;
captor = null;
}
}
/**
* Interruptible sleep (replacement for <code>Thread.sleep</code>).
*
* @param millis - the length of time to sleep in milliseconds.
*/
private void interruptibleSleep( int millis )
{
synchronized( this )
{
try {
this.wait( millis );
}
catch( InterruptedException ie ) {
running = false; // kills the thread
}
}
}
/**
* Obtains MAC address of the default gateway for captor interface.
*
* @return MAC address as byte array
*/
private byte[] obtainDefaultGatewayMac( String httpHostToCheck )
{
print( "Obtaining default gateway MAC address... ", true );
byte[] gatewayMAC = null;
if ( captor != null ) try
{
InetAddress hostAddr = InetAddress.getByName( httpHostToCheck );
captor.setFilter( "tcp and dst host " + hostAddr.getHostAddress(), true );
int timeoutTimer = 0;
new URL("http://" + httpHostToCheck ).openStream().close();
while( running )
{
Packet ping = captor.getPacket ();
if( ping == null )
{
if ( timeoutTimer < 20 ) { // max 2 sec
interruptibleSleep( 100 /*millis*/ );
++timeoutTimer;
continue;
}
/* else: Timeout exceeded
*/
print( "<timeout>", /*timestamp*/ false );
println( "ERROR: Cannot obtain MAC address for default gateway." );
println( "Maybe there is no default gateway on selected interface?" );
return gatewayMAC;
}
byte[] destinationMAC = ((EthernetPacket)ping.datalink).dst_mac;
if( ! Arrays.equals( destinationMAC, device.mac_address ) ) {
gatewayMAC = destinationMAC;
break;
}
timeoutTimer = 0; // restart timer
new URL("http://" + httpHostToCheck ).openStream().close();
}
}
catch( MalformedURLException e )
{
println( "Invalid URL: " + e.toString () );
}
catch( UnknownHostException e )
{
println( "Unknown host: " + httpHostToCheck );
}
catch( IOException e )
{
println( "ERROR: " + e.toString () );
}
print( " OK.", /*timestamp*/ false );
println ();
return gatewayMAC;
}
/**
* Scan TCP ports
*
* @throws UnknownHostException
*/
public boolean tcpPortScan ( int localPort, String remoteHost, int rp1, int rp2 )
throws UnknownHostException, IOException
{
println( "-------------------------------------------------" );
print( "Looking up " + hostName + "...", /*timestamp*/ true );
InetAddress remoteIP = InetAddress.getByName( remoteHost );
print( " " + remoteIP.getHostAddress (), /*timestamp*/ false );
println ();
byte[] defaultGatewayMAC = obtainDefaultGatewayMac( "dsv.su.se" );
if ( defaultGatewayMAC == null )
{
running = false;
completed = true;
context.onTracerouteCompleted ();
return running;
}
TCPPacket tcp = new TCPPacket(
localPort, // int src_port
0, // int dst_port
701, // long sequence
0, // long ack_num
false, // boolean urg
false, // boolean ack
false, // boolean psh
false, // boolean rst
true, // boolean syn
false, // boolean fin
true, // boolean rsv1
true, // boolean rsv2
10, // int window
10 // int urgent
);
tcp.setIPv4Parameter(
0, // int priority - Priority
false, // boolean: IP flag bit: Delay
false, // boolean: IP flag bit: Through
false, // boolean: IP flag bit: Reliability
0, // int: Type of Service (TOS)
false, // boolean: Fragmentation Reservation flag
false, // boolean: Don't fragment flag
false, // boolean: More fragment flag
0, // int: Offset
(int)(Math.random () * 65000), // int: Identifier
100, // int: Time To Live
IPPacket.IPPROTO_TCP, // Protocol
localIP, // Source IP address
remoteIP // Destination IP address
);
tcp.data=("").getBytes();
EthernetPacket ether = new EthernetPacket ();
ether.frametype = EthernetPacket.ETHERTYPE_IP;
ether.src_mac = device.mac_address;
ether.dst_mac = defaultGatewayMAC;
tcp.datalink = ether;
/* Send TCP packets...
*/
JpcapSender sender = captor.getJpcapSenderInstance ();
captor.setFilter( "tcp and dst port " + localPort
+ " and dst host " + localIP.getHostAddress(),
true );
for ( int remotePort = rp1; remotePort <= rp2; ++remotePort ) {
tcp.src_port = localPort;
tcp.dst_port = remotePort;
sender.sendPacket( tcp );
//println( "SENT: " + tcp );
}
while( running )
{
TCPPacket p = (TCPPacket)captor.getPacket ();
if( p == null ) // TIMEOUT
{
interruptibleSleep( 100 );
continue;
}
/* We are here because we got some ICMP packet... resolve name first.
*/
String hopID = p.src_ip.getHostAddress ();
if ( resolveNames ) {
p.src_ip.getHostName ();
hopID = p.src_ip.toString ();
}
// println( "---------------------------------------------------------" );
// println( "RECEIVED: " + p.toString () );
if ( ! p.rst ) {
if ( p.ack_num == 702 ) {
println( "---- " + hopID + " : " + p.src_port );
}
tcp.dst_port = p.src_port;
tcp.fin = p.ack_num == 702 ? true : false;
tcp.ack = true;
tcp.rst = false;
tcp.syn = false;
tcp.sequence = p.ack_num;
tcp.ack_num = p.sequence + 1;
sender.sendPacket( tcp );
//println( "SENT: " + tcp );
}
// running = false;
}
return running;
}
/**
* Traces route to given host. The instance is locked during in the mean time
* so other trace routes could not start (completed == false suppresses other
* threads).
*/
@Override
public void run ()
{
/* Release instance to other threads
*/
if ( ! running ) {
completed = true;
context.onTracerouteCompleted ();
return;
}
/* Make sure that capturing device is configured
*/
if ( captor == null ) {
println( "Capturing device is not configured..." );
running = false;
completed = true;
context.onTracerouteCompleted ();
return;
}
/* Starts sending ICMP packets and tracing route...
*/
try
{
/*
if ( ! tcpPortScan( 15000, hostName, 1, 1000 ) ) {
completed = true;
context.onTracerouteCompleted ();
return;
}
*/
println( "-------------------------------------------------" );
print( "Looking up " + hostName + "...", /*timestamp*/ true );
InetAddress remoteIP = InetAddress.getByName( hostName );
print( " " + remoteIP.getHostAddress (), /*timestamp*/ false );
println ();
byte[] defaultGatewayMAC = obtainDefaultGatewayMac( "dsv.su.se" );
if ( defaultGatewayMAC == null )
{
running = false;
completed = true;
context.onTracerouteCompleted ();
return;
}
if ( initialTTL == 0 ) {
println( "Tracing route to " + remoteIP + "..." );
} else {
println( "Pinging host " + remoteIP + "..." );
}
/* Create ICMP packet
*/
ICMPPacket icmp = new ICMPPacket ();
icmp.type = ICMPPacket.ICMP_ECHO;
icmp.seq = 100;
icmp.id = 0;
icmp.data = "data".getBytes ();
icmp.setIPv4Parameter(
0, // int priority - Priority
false, // boolean: IP flag bit: Delay
false, // boolean: IP flag bit: Through
false, // boolean: IP flag bit: Reliability
0, // int: Type of Service (TOS)
false, // boolean: Fragmentation Reservation flag
false, // boolean: Don't fragment flag
false, // boolean: More fragment flag
0, // int: Offset
0, // int: Identifier
0, // int: Time To Live
IPPacket.IPPROTO_ICMP, // Protocol
localIP, // Source IP address
remoteIP // Destination IP address
);
EthernetPacket ether = new EthernetPacket ();
ether.frametype = EthernetPacket.ETHERTYPE_IP;
ether.src_mac = device.mac_address;
ether.dst_mac = defaultGatewayMAC;
icmp.datalink = ether;
/* Send ICMP packets...
*/
JpcapSender sender = captor.getJpcapSenderInstance ();
captor.setFilter( "icmp and dst host " + localIP.getHostAddress(), true );
icmp.hop_limit = (short)initialTTL;
print( icmp.hop_limit + ": ", /*timestamp*/ true );
int timeoutTimer = 0;
int timeoutCounter = 0;
long tStart = System.nanoTime ();
sender.sendPacket( icmp );
while( running )
{
ICMPPacket p = (ICMPPacket)captor.getPacket ();
int tDelay = (int)( ( System.nanoTime () - tStart ) / 1000000l );
if( p == null ) // TIMEOUT
{
/* Continue waiting until ~2 sec elapses
*/
if ( timeoutTimer < 30 )
{
interruptibleSleep( timeoutTimer < 10 ? 1 : 100 );
++timeoutTimer;
if ( timeoutTimer >= 10 ) {
print( ".", /*timestamp*/ false );
}
continue;
}
/* Increase timeout counter and either retry or advance Hop limit
*/
++timeoutCounter;
print( " Timeout #" + timeoutCounter, /*timestamp*/ false );
if ( timeoutCounter < 3 ) // Retry send to the same Hop
{
print( icmp.hop_limit + ": ", /*timestamp*/ true );
tStart = System.nanoTime ();
timeoutTimer = 0;
sender.sendPacket( icmp );
}
else // Advance Hop limit and send to next hop
{
++icmp.hop_limit;
print( icmp.hop_limit + ": ", /*timestamp*/ true );
timeoutTimer = 0;
timeoutCounter = 0;
tStart = System.nanoTime ();
sender.sendPacket( icmp );
}
continue;
}
/* We are here because we got some ICMP packet... resolve name first.
*/
String hopID = p.src_ip.getHostAddress ();
if ( resolveNames ) {
p.src_ip.getHostName ();
hopID = p.src_ip.toString ();
}
/* Now, in case if we received 'time exceeded' packet we should advance
* to the next Hop limit. Otherwise if host is either unreachable or
* we got echo reply, we should quit.
*/
if( p.type == ICMPPacket.ICMP_TIMXCEED ) // Time exceeded
{
print( hopID + ", " + tDelay + " ms", /*ts*/ false );
++icmp.hop_limit;
print( icmp.hop_limit + ": ", /*timestamp*/ true );
timeoutTimer = 0;
timeoutCounter = 0;
tStart = System.nanoTime ();
sender.sendPacket( icmp );
}
else if( p.type == ICMPPacket.ICMP_UNREACH ) // Host unreachable
{
print( hopID + " unreachable", /*ts*/ false );
running = false;
}
else if( p.type == ICMPPacket.ICMP_ECHOREPLY ) // Echo reply (pong)
{
print( hopID + ", " + tDelay + " ms", /*ts*/ false );
if ( initialTTL != 0 ) {
println( hopID + " is alive." );
}
running = false;
}
}
}
catch( UnknownHostException e )
{
println( "Unknown host: " + hostName );
completed = true;
context.onTracerouteCompleted ();
return;
}
catch( IOException e )
{
println( "ERROR: " + e.toString () );
completed = true;
context.onTracerouteCompleted ();
return;
}
/* Release instance to other threads
*/
println( initialTTL == 0 ? "Traceroute completed." : "Ping completed." );
completed = true;
context.onTracerouteCompleted ();
}
}
Sign up for free to join this conversation on GitHub. Already have an account? Sign in to comment