PortConnect.java

Go to the documentation of this file.

import java.net.InetSocketAddress;
import java.net.Socket;

/**
 *  Encapsulates port scanning worker thread. The thread retrieves end-points
 *  (to be scanned) from the owner's pool and reports with a call-back what
 *  was found on the end-point. 
 *  
 *  @author Mikica B Kocic
 */
public class PortConnect extends Thread 
{
    /**
     *  InetSocketAddress pool context where socket addresses (end-points) 
     *  are retrieved from and where information about end-points are posted to. 
     */
    public interface Context
    {
        /**
         *  Gets next socket address from the context.
         */
        public abstract InetSocketAddress getNextSocketAddress ();

        /**
         *  Reports information that worker thread has found about
         *  socket address (end-point)
         */
        public abstract void onPortConnected( long threadId, InetSocketAddress addr,
                boolean ok, String error, int timeMillis );
        
        /**
         *  Worker thread reports it is alive
         */
        public abstract void workerThreadSignIn( long threadId );
        
        /**
         *  Worker thread reports it is dead
         */
        public abstract void workerThreadSignOut( long threadId );
    }

    /**
     *  The timeout value to be used when connecting sockets in milliseconds 
     */
    private int timeoutMillis;
    
    /**
     *  Worker thread's socket address pool context
     */
    private Context context;

    /**
     *  Creates instance of the worker thread.
     *  
     *  @param context        worker thread's presentation and status context
     *  @param timeoutMillis  the timeout value to be used in milliseconds 
     */
    public PortConnect( Context context, int timeoutMillis )
    {
        this.context  = context;
        this.timeoutMillis  = timeoutMillis;
    }

    /**
     *  Connects to socket address to check if there is service running on server
     *  
     *  @param endpoint - the socket address (IP address + port)
     */
    public void reportConnectionStatus( InetSocketAddress endpoint )
    {
        boolean portStatus = false; // port dead by default
        String error = "Failed";

        /* Try to connect...
         */
        Socket socket = null;
        long startTime = System.nanoTime ();
        
        try  {
            socket = new Socket ();
            socket.connect( endpoint, timeoutMillis );
            error = "Connected";
            portStatus = true;
        } catch( Exception e ) {
            /* don't care */
            error = e.toString ();
        }

        if ( socket != null && ! socket.isClosed () ) {
            try {
                socket.close ();
            } catch( Exception e ) {
                /* don't care */
            }
        }

        /* ... then call-back the context with port status report.
         */
        this.context.onPortConnected( 
                getId(), endpoint, portStatus, error, 
                (int) ( ( System.nanoTime () - startTime ) / 1000000l ) );
    }
    
    /**
     *  Worker thread:
     *  1) retrieves next end-point to be checked from the parent's context,
     *  2) detects whether remote end-points is alive or dead,
     *  3) reports what's found to the parent.
     */
    @Override
    public void run()
    {
        context.workerThreadSignIn( getId () );

        while( true )
        {
            InetSocketAddress endpoint = context.getNextSocketAddress ();
            
            /* If the parent's end-points are depleted, quit thread.
             */
            if ( endpoint == null ) {
                break;
            }
            
            /* Detect whether server on the end-point is dead or alive,
             * then report what's found.
             */
            reportConnectionStatus( endpoint );
        }

        context.workerThreadSignOut( getId () );
        
        /* Block until killed
         */
        try {
            Thread.sleep( 365 * 86400 * 1000 );
        } catch( InterruptedException e ) {
            /* ignored */
        }
    }
}