Java on bradleycarey.com

Simple Java *nix shell (Proof of Concept)

Thu, 23 Aug 2012 22:26:54 -0400

This is a very simple shell interface with a built-in history feature for use in your favorite *nix environment. This small project comes from a project in my Operating Systems class at Marshall University in which we were studying message passing models in modern OSs.

It should work fine with any program that is defined in your system $PATH variable (usually /usr/bin, etc). If you type !!, it will re-run the previous command. Or n!, where n is the number of the previous command. To get a list of these previous commands and their corresponding numbers, use the ‘history’ command which will show you all of your previous entries.

Apache Commons JSP Web Implementation

Tue, 24 Jan 2012 00:03:02 -0400

If you are a Java developer then you are very familiar with The Apache Commons. This web app is just basically a web implementation of the commons’ Math library. Here is an excerpt from the Commons’ website about Commons Math:

Commons Math is a library of lightweight, self-contained mathematics and statistics components addressing the most common problems not available in the Java programming language or Commons Lang.

Page Replacement Algorithm Benchmarker – Memsim

Mon, 23 Jan 2012 23:11:15 -0400

This Java program simulates three common page replacement algorithms and displays benchmarks such as number of faults (and more). Also provided in the *.rar file is trace files which were captured in Linux and can be loaded into the program via command line to test either LRU, FIFO, or Random algorithms for comparison.

Download memsim.rar

Simple Multithread Java Webserver (proof of concept)

Thu, 25 Aug 2011 22:20:38 -0400

This project was nothing more than a proof-of-concept and should not be put into usage (get apache instead). It is a simple webserver written in Java that can take simultaneous requests via multithreading, parse the request, and properly respond. This program served as my forray into multithreading as well as the gritty details to what happens behind the scenes in a webserver.

/**
 * web server and client
 * @author Bradley Carey
 */

import java.io.*;
import java.net.*;
import java.util.*;

public final class WebServer
{
    public static void main(String argv[]) throws Exception
    {
        //set port number
        int port = 8080;
        ServerSocket myServerSocket = null;

        //establish listen socket
        try {
            myServerSocket = new ServerSocket(port);
        } catch (IOException e) {
            System.out.println("Could not listen on port # " + port);
            System.exit(-1);
        }

        //process http service requests in infinite loop
        while(true)
        {
            //listen for tcp connection requests
            Socket clientSocket = null;
            try {
                clientSocket = myServerSocket.accept();
            } catch (IOException e) {
                System.out.println("Accept failed on port # " + port);
                System.exit(-1);
            }

            HttpRequest request = new HttpRequest(clientSocket);
            Thread thread = new Thread(request);
            thread.start();
        }
    }
}

final class HttpRequest implements Runnable
{
    final static String CRLF = "\r\n";
    Socket socket;

    public HttpRequest(Socket socket) throws Exception
    {
        this.socket = socket;
    }

    public void run()
    {
        try
        {
            processRequest();
        } catch (Exception e) {
            System.out.println(e);
        }
        //throw new UnsupportedOperationException("Not supported yet.");
    }

    private void processRequest() throws Exception
    {
        //get reference to socket's input & output streams and setup filters
        InputStream is = socket.getInputStream();
        InputStreamReader isr = new InputStreamReader(is);
        OutputStream os = socket.getOutputStream();
        DataOutputStream dos = new DataOutputStream(os);
        BufferedReader br = new BufferedReader(isr);

        String requestLine = br.readLine();
        System.out.println(requestLine);

        String headerLine = null;
        while ((headerLine = br.readLine()).length() != 0) {
            System.out.println(headerLine);
        }

        StringTokenizer tokens = new StringTokenizer(requestLine);
        tokens.nextToken();
        String fileName = tokens.nextToken();

        if (fileName.equals("/"))
                fileName = "/default.htm";

        fileName = "." + fileName;

        System.out.println("\nfileName:" + fileName);

        FileInputStream fis = null;
        boolean fileExists = true;
        try {
            fis = new FileInputStream(fileName);
        } catch (FileNotFoundException e) {
            fileExists = false;
        }

        String statusLine = null;
        String contentTypeLine = null;
        String entityBody = null;
        if (fileExists) {
            statusLine = "HTTP/1.1 202 Accepted" + CRLF;
            contentTypeLine = "Content-type: " + contentType(fileName) + CRLF;
        } else {
            statusLine = "HTTP/1.1 404 Not Found" + CRLF;
            contentTypeLine = "text/html" + CRLF;
            entityBody = "<HTML>"
              + "<HEAD><TITLE>Not Found</TITLE></HEAD>"
              + "<BODY>404 Not Found</BODY></HTML>";
        }

        //Send the status line
        dos.writeBytes(statusLine);
        System.out.println("statusLine: " + statusLine);

        //Send the content type line
        dos.writeBytes(contentTypeLine);
        System.out.println("contentTypeLine: " + contentTypeLine);
        System.out.println("entityBody: " + entityBody);

        //Send a blank line to indicate the end of the header line
        dos.writeBytes(CRLF);

        //Send the entity body
        if (fileExists) {
          sendBytes(fis, os);
          fis.close();
        } else {
          os.write(entityBody.getBytes());
        }

        dos.close();
        os.close();
        br.close();
        socket.close();
    }

    private static void sendBytes(FileInputStream fis, OutputStream os) throws Exception
    {
        byte[] buffer = new byte[1024];
        int bytes = 0;

        while((bytes = fis.read(buffer)) != -1) {
            os.write(buffer, 0, bytes);
        }
    }

    private static String contentType(String fileName)
    {
        if (fileName.endsWith(".htm") || fileName.endsWith(".html"))
            return "text/html";
        if(fileName.endsWith(".gif"))
            return "image/gif";
        if(fileName.endsWith(".jpg"))
            return "image/jpg";

        return "application/octet-stream";
    }
}

Simple Java websocket currency exchanger (Proof of Concept)

Tue, 23 Aug 2011 23:07:45 -0400

This program is a simple client/server websocket program. The client sends a currency amount, type, and type to convert it to and the server responds with the correct conversion. Conversion factors are way out of date since this program was written in 2009.

Client source code:

/**
 * Client for currency exchange server
 * @author Bradley Carey
 */
import java.io.*;
import java.net.*;

public class ExchangeClient
{
    public static void main(String[] args) throws Exception
    {
        String hostname = args[0];
        String amount = args[1];
        String from = args[2];
        String to = args[3];
        String toSend = amount + "?" + from + "?" + to;
        Socket mySocket = new Socket(hostname, 52719);

        OutputStream myOS = mySocket.getOutputStream();
        DataOutputStream myDOS = new DataOutputStream(myOS);

        InputStream myIS = mySocket.getInputStream();
        InputStreamReader myISR = new InputStreamReader(myIS);
        BufferedReader myBR = new BufferedReader(myISR);
        myDOS.writeBytes(toSend + '\n');
        toSend = myBR.readLine();

        System.out.println(toSend);
        mySocket.close();
    }
}

Server source code:

XOR Encryption with Brute Force methods for decryption (proof of concept)

Wed, 23 Feb 2011 22:25:43 -0400

This project evolved from my time in the Cyber Security class at Marshall University. The goal was to create an implementation of a simple encryption scheme as well as brute force methods for decrypting the ciphertext without the original key. To use it:

Select a text file as the active file for encryption/decryption.
Enter your choice of operation.
If the file has been previously encrypted, you can decrypt it as long as you know the key.
If you don’t know the key to an encrypted file, select the brute force method to have the program try all possible combinations to detemine which key was originally used to decrypt the file.

This program uses a wordlist of more than 58,000 words from the English language when brute forcing, which is parsed into a java TreeSet for maximum speed. As such, a text file containing words to match it to is required. I’ve used the one found at this link: Corncob Wordlist

Simple UDP Fortune Client/Server (Proof of Concept)

Tue, 02 Nov 2010 23:09:37 -0400

This program is a simple client/server UDP/Datagram network program. The client sends a random number which is then used to display a random fortune on the client’s screen.

#Client

/**
 * Fortune Cookie Client. Sends random number to specified host via UDP and prints reply.
 * @author Bradley Carey
 * @version November 2, 2010
 */

import java.io.*;
import java.net.*;
import java.util.*;

public class FortuneClient
{
    public static void main(String[] args) throws Exception
    {
        if (args.length<= 1)
        {
            System.out.println("You must specify a valid hostname and port number.");
            System.exit(0);
        }
        String hostname = args[0];
        String port = args[1];

        InetAddress destination = InetAddress.getByName(hostname);

        Random myRandom = new Random();
        int requestNo = myRandom.nextInt(10);
        String toSend = "" + requestNo;

        DatagramSocket mySocket = new DatagramSocket();
        mySocket.setSoTimeout(2000);
        byte[] os = toSend.getBytes();
        DatagramPacket sendThis = new DatagramPacket(os, os.length, destination, Integer.parseInt(port));
        mySocket.send(sendThis);

        try
        {
            DatagramPacket replyPacket = new DatagramPacket(new byte[1024], 1024);
            mySocket.receive(replyPacket);
            String recvMsg = new String(replyPacket.getData());
            recvMsg = recvMsg.replaceAll("\n","");
            System.out.println("Fortune: " + recvMsg);
        }
        catch (SocketTimeoutException e)
        {
            System.out.println("Error: Timeout!");
        }

        System.out.println(toSend);
        mySocket.close();
    }
}

#Server

Finding square roots using Newton’s Method (Proof of Concept)

Fri, 16 Oct 2009 23:15:06 -0400

This program uses the famous method by Isaac Newton to iteratively find the square root of a number. It relies upon an inital guess which is then improved until the answer is accurate within 0.000001.

/**
 * Computes square root of a number (Newton's Method)
 * @author Bradley Carey
 * @version 16-Oct-2009
 */
import java.util.Scanner;
public class NewtonsMethod
{
    public static void main(String[] args)
    {
        Scanner myScanner = new Scanner(System.in);
        boolean done = false;
        double guess=0.0;
        while (true)
        {
            done = false;
            System.out.print("\nEnter the number to take the square root of: ");
            String answer = myScanner.nextLine();
            double x = Double.parseDouble(answer);

            if (x<=0)
            {
                System.out.print("Error: only positive inputs are valid.\n");
                return;
            }
            else
            {
                System.out.print("Enter a guess for the square root: ");
                answer = myScanner.nextLine();
                guess = Double.parseDouble(answer);
            }

            while (!done)
            {
                double newGuess = guess-(guess*guess-x)/(2*guess);
                System.out.print("newGuess = " + newGuess + "\n");

                if (Math.abs(guess-newGuess)<0.00001)
                {
                    System.out.print("To within .000001, The square root of " + x + " is " + newGuess);
                    System.out.print("\nDo another? y/n  ");
                    answer = myScanner.nextLine();
                    done=true;

                    if(answer.equals("n"))
                    {
                        System.out.print("Good Bye!!\n");
                        System.exit(0);
                    }
                }
                else
                {
                    guess = newGuess;
                }
            }
        }
    }
}