Networking

package networking;

import java.net.InetAddress;
import java.net.UnknownHostException;
import java.util.Scanner;

/**
 *   Application to perform a lookup on the specified host.
 */
public class NodeLookup
{
  /**
   * Main entry point
   * @usage java networking.NodeLookup hostname
   * 
   * If no arguments provided, will prompt for hostname
   * 
   * @param args the command line arguments
   *             args[0] contains the hostname to look up
   */
  public static void main(String[] args)
  {
    String hostName;
    
    if (args.length < 1)
    {
      System.out.print("Hostname to look up: ");
      Scanner in = new Scanner(System.in);
      hostName = in.nextLine();
    }
    else
    {
      hostName = args[0]; // Use first argument for hostname
    }
    
    try
    {
      InetAddress host = InetAddress.getByName(hostName);
      System.out.println("Host name : " + host.getHostName());
      System.out.println("IP address: " + host.getHostAddress());
    }
    catch (UnknownHostException e)
    {
      System.out.println("Unknown host");
    }
  }
}

package networking;

import java.awt.BorderLayout;
import java.awt.Color;
import java.awt.EventQueue;
import java.awt.event.ActionEvent;
import java.awt.event.ActionListener;

import java.net.URL;
import javax.swing.BorderFactory;
import javax.swing.JButton;
import javax.swing.JEditorPane;
import javax.swing.JFrame;
import javax.swing.JPanel;
import javax.swing.JScrollPane;
import static javax.swing.WindowConstants.EXIT_ON_CLOSE;

/**
 *   Program to display a webpage, given its URL.
 *
 *   @author Bryan J. Higgs, 9 October 1999
 */
public class ShowDocument extends JFrame
{
  public static void main(String[] args)
  {
    EventQueue.invokeLater( new Runnable()
      {
        public void run()
        {
          ShowDocument frame = new ShowDocument();
          frame.setDefaultLookAndFeelDecorated(true);
          frame.setDefaultCloseOperation(EXIT_ON_CLOSE);
          frame.setTitle("Show Document");
          frame.setBounds(200, 200, 800, 500);
          frame.setVisible(true);
        }
      }
    );

  }
  
  public ShowDocument()
  {
    JPanel contentPane = (JPanel) getContentPane();
    contentPane.setLayout( new BorderLayout() );
    contentPane.add(m_button, BorderLayout.SOUTH);
    
    JScrollPane scrollPane = new JScrollPane();
    JEditorPane editorPane = new JEditorPane();
    editorPane.setEditable(false);
    scrollPane.setViewportView(editorPane);
    contentPane.add(scrollPane, BorderLayout.CENTER);
    
    m_button.addActionListener( new ActionListener()
    {
      public void actionPerformed(ActionEvent event)
      {
        // Postpone the work to add the URL contents
        // to the editor pane
        EventQueue.invokeLater(new Runnable()
        {
          public void run()
          {
              try
              {
                // Open the URL in the editor pane
                editorPane.setPage( new URL(m_urlToDisplay) );
              }
              catch (Exception ex)
              {
                  // Should never happen because we're
                  // hardcoding a valid URl.
                  ex.printStackTrace();
              }
          }
        }
        );
      }
    }
  );
 }
  
  //// Private data ////
  private static final String m_urlToDisplay 
     = "http://help.websiteos.com/websiteos/example_of_a_simple_html_page.htm";
  
  private JButton m_button  = new JButton("Click to display webpage");
}

package networking;

import java.net.URL;

import java.io.BufferedReader;
import java.io.InputStreamReader;
import java.util.Scanner;

/**
 *   Application to read text from a URL
 *   specified in the first command line argument.
 *   (Note that this is NOT a Reader, like BufferedReader.)
 */
public class URLReader
{
  /**
   * 
   * @usage java networking.NodeLookup urlstring
   * 
   * If no arguments provided, will prompt for urlstring
   * 
   * @param args the command line arguments
   *             args[0] contains the urlstring to read
   */
  public static void main(String[] args) throws Exception
  {
    String urlName;
    
    if (args.length < 1)
    {
      System.out.print("URL : ");
      Scanner in = new Scanner(System.in);
      urlName = in.nextLine();
    }
    else
    {
      urlName = args[0]; // Use first argument for hostname
    }    
    
    URL url = new URL(urlName);
    BufferedReader reader = new BufferedReader(
      new InputStreamReader( url.openStream() ) 
    );
    
    try
    {
      String line = null;
      while (true)
      {
        line = reader.readLine();
        if (line == null)
          break;
        System.out.println(line);
      }
    }
    finally
    {
      reader.close();
    }
  }
}

package networking;

import java.io.BufferedReader;
import java.io.InputStreamReader;
import java.io.IOException;

import java.net.Socket;
import java.util.Scanner;

/**
 *   Application to connect to a specified host and port
 *   and print the output text received from that connection.
 */
public class SocketTest
{
  /**
   * Main entry point
   * 
   * @param args the command line arguments:
   *             args[0] : host name
   *             args[1] : port number
   * 
   * If no command line arguments are provided, the program
   * will prompt for them
   */
  public static void main(String[] args)
  {
    String hostName = null;
    int port = -1;
    
    if (args.length < 2)
    {
      System.out.print("Hostname : ");
      Scanner in = new Scanner(System.in);
      hostName = in.nextLine();
      System.out.print("Port number : ");
      port = in.nextInt();
    }
    else
    {
      // First argument is hostname
      hostName = args[0];
      // Convert port string to integer
      port = Integer.parseInt(args[1]);
    }
      
    Socket socket = null;   
    try
    {
      // Open the socket
      socket = new Socket(hostName, port);
      // Read from the socket
      BufferedReader reader = new BufferedReader(
                                    new InputStreamReader(
                                        socket.getInputStream()
                                    )
                                );
        
      // Read line by line until the end
      while (true)
      {
        String line = reader.readLine();
        if (line == null)
          break;  // We hit the end
        System.out.println(line);
      }
    }
    catch (NumberFormatException e)
    {
      System.err.println("Invalid port : [" + port +"]");
    }
    catch (IOException e)
    {
      e.printStackTrace();
    }
  }
}

package networking;

import java.net.ServerSocket;
import java.net.Socket;

import java.io.BufferedReader;
import java.io.InputStreamReader;
import java.io.IOException;
import java.io.PrintWriter;
import java.util.Scanner;

/**
 *   Application to act as a 'Reverse' server.
 *   An application can connect to this server on the specified port
 *   and send it text.  The server will reverse the text and send it back.
 *
 *   @author Bryan J. Higgs, 10 October 1999
 */
public class ReverseServer
{
  /**
   *   Main entry point.
   * 
   *   @param args the command line arguments
   *               args[0] contains port to use
   * 
   * If there are no arguments, the program prompts for a port number
   */
  public static void main(String[] args)
  {
    int port = -1;
    
    if (args.length < 1)
    {
      System.out.print("Port to use: ");
      Scanner in = new Scanner(System.in);
      port = in.nextInt();
    }
    else
    {
      port = Integer.parseInt(args[0]);
    }
    
    ServerSocket socket = null;
    Socket incoming = null;
    BufferedReader in = null;
    PrintWriter out = null;
    try
    {
      socket = new ServerSocket(port);
      // Wait on server socket for connection requests
      incoming = socket.accept();
      // Connection requested; get the input stream
      in = new BufferedReader(
                new InputStreamReader(
                    incoming.getInputStream()));
      // Get the output stream
      out = new PrintWriter(incoming.getOutputStream(),
                            true        // autoflush
                           );
      
      // Output greeting
      out.println(
          "Welcome to the Reverse Server!" +
          " Enter an empty line to exit.");
      
      // Loop, reversing each line received.
      while (true)
      {
        String line = in.readLine();
        if (line == null || line.equals(""))
          break; // We are at the end
        // We read a line, so reverse it
        StringBuffer buffer = new StringBuffer(line);
        line = buffer.reverse().toString();
        // and return the result
        out.println(line);
      }
    }
    catch (Exception e)
    {
      e.printStackTrace();
    }
    finally
    {
      // Close everything necessary
      try
      {
        if (out != null)
          out.close();
        if (in != null)
          in.close();
        if (incoming != null)
          incoming.close();
        if (socket != null)
          socket.close();
      }
      catch (IOException e)
      {
        // Ignore any errors here
      }
    }
  }
}

package networking;

import java.io.BufferedReader;
import java.io.InputStreamReader;
import java.io.IOException;
import java.io.OutputStreamWriter;
import java.io.PrintWriter;

import java.net.Socket;
import java.net.UnknownHostException;
import java.util.Scanner;

/**
 *   Application to connect to a specified host and port
 *   and print the output text received from that connection.
 */
public class ReverseClient
{
  /**
   * Main entry point
   * 
   * @param args the command line arguments:
   *             args[0] : host name
   *             args[1] : port number
   * 
   * In the absence of arguments, the program will prompt for them
   */
  public static void main(String[] args)
  {
    String hostName = null;
    int port = -1;
    
    if (args.length < 2)
    {
      System.out.print("Hostname : ");
      Scanner in = new Scanner(System.in);
      hostName = in.nextLine();
      System.out.print("Port number : ");
      port = in.nextInt();
    }
    else
    {
      // First argument is hostname
      hostName = args[0];
      // Convert port string to integer
      port = Integer.parseInt(args[1]);
    }
    
    // Connect a BufferedReader to System.in
    BufferedReader inputReader = new BufferedReader(
                     new InputStreamReader(System.in) );
      
    Socket socket;
    try
    {
      socket = new Socket(hostName, port);
        
      // Connect a BufferedReader to read from the socket
      BufferedReader socketReader = new BufferedReader(
                       new InputStreamReader( socket.getInputStream() ) );
        
      // Connect a PrintWriter to write to the socket
      PrintWriter socketWriter = new PrintWriter(
            new OutputStreamWriter(socket.getOutputStream() ),
            true // autoflush
            );
      
      // Loop on input and server's response  
      while (true)
      {
        // Read the reverse server's response
        String line = socketReader.readLine();
        if (line == null)
          break;  // We hit the end
        System.out.println(line);
        // Prompt the user for another line
        System.err.print("> ");
        line = inputReader.readLine();
        if (line == null)
          line = "";  // Send an empty line for end of input
        socketWriter.println(line);
      }
    }
    catch (UnknownHostException ex)
    {
      ex.printStackTrace();
    }
    catch (IOException ex)
    {
      ex.printStackTrace();
    }
  }
}

package networking;

import java.net.ServerSocket;
import java.net.Socket;

import java.io.BufferedReader;
import java.io.InputStreamReader;
import java.io.IOException;
import java.io.PrintWriter;
import java.util.Scanner;

/**
 *   Application to act as a Reverse server for multiple clients.
 *   An application can connect to this server on the specified port
 *   and send it text.  The server will reverse the text and send it back.
 *
 *   @author Bryan J. Higgs, 10 October 1999
 */
public class MultiThreadedReverseServer
{
  /**
   *   Main entry point.
   * 
   *   @param args the command line arguments
   *               args[0] contains port to use
   * 
   * If there are no arguments, the program prompts for a port number
   */
  public static void main(String[] args)
  {
    int port = -1;
    
    if (args.length < 1)
    {
      System.out.print("Port to use: ");
      Scanner in = new Scanner(System.in);
      port = in.nextInt();
    }
    else
    {
      port = Integer.parseInt(args[0]);
    }
    
    ServerSocket socket = null;
    Socket incoming = null;
    int client = 0;
    try
    {
      socket = new ServerSocket(port);
      while (true)
      {
        // Wait on server socket for connection request
        incoming = socket.accept();
        // Create a handler thread for this request, and start it.
        new ReverseHandler(incoming, ++client).start();
      }
    }
    catch (Exception e)
    {
      e.printStackTrace();
    }
    finally
    {
      // Close the ServerSocket, regardless of success
      try
      {
        if (socket != null)
          socket.close();
      }
      catch (IOException e)
      {
        // Ignore any errors here
      }
    }
  }
}

/**
 *   Class to handle the connection request for a single client.
 */
class ReverseHandler extends Thread
{
  public ReverseHandler(Socket incoming, int client)
  {
    m_incoming = incoming;
    m_client = client;
    setName("ReverseHandler for client #" + m_client);
  }
  
  public void run()
  {
    BufferedReader in = null;
    PrintWriter out = null;
    
    try
    {
      // Get the connection input stream
      in = new BufferedReader(
              new InputStreamReader(
                  m_incoming.getInputStream() ) );
      // Get the connection output stream
      out = new PrintWriter(
                  m_incoming.getOutputStream(),
                  true        // autoflush
                );
      
      // Output greeting to client
      out.println(
          "Welcome to the Reverse Server!" +
          " You are client #" + m_client + "." +
          " Enter an empty line to exit.");
      
      // Loop, reversing each line received.
      while (true)
      {
        String line = in.readLine();
        if (line == null || line.equals(""))
          break;
        StringBuffer buffer = new StringBuffer(line);
        line = buffer.reverse().toString();
        out.println(line);
      }
    }
    catch (Exception e)
    {
      e.printStackTrace();
    }
    finally
    {
      // Close everything necessary
      try
      {
        if (out != null)
          out.close();
        if (in != null)
          in.close();
        if (m_incoming != null)
          m_incoming.close();
      }
      catch (IOException e)
      {
        // Ignore any errors here
      }
    }
  }
  
  //// Private data ////
  private Socket m_incoming;
  private int    m_client;
}

package networking;

import java.awt.BorderLayout;
import java.awt.EventQueue;
import java.awt.Font;
import java.awt.event.ActionEvent;
import java.awt.event.ActionListener;

import java.net.URL;
import java.net.MalformedURLException;

import java.util.Properties;

import javax.swing.JButton;
import javax.swing.JEditorPane;
import javax.swing.JFrame;
import javax.swing.JPanel;
import javax.swing.JScrollPane;
import static javax.swing.WindowConstants.EXIT_ON_CLOSE;

/**
 *   Program to perform a query against Google Maps.
 */
public class CGIQueryMapsExample extends JFrame
{
  /** 
   * Main entry point
   * 
   * @param args 
   */
  public static void main(String[] args)
  {
    EventQueue.invokeLater( new Runnable()
      {
        public void run()
        {
          CGIQueryMapsExample frame = new CGIQueryMapsExample();
          frame.setDefaultLookAndFeelDecorated(true);
          frame.setDefaultCloseOperation(EXIT_ON_CLOSE);
          frame.setTitle("CGI Query Google Maps");
          frame.setBounds(200, 200, 800, 500);
          frame.setVisible(true);
        }
      }
    );

  }  
  
  /**
   * Constructor
   */
  public CGIQueryMapsExample()
  {
    JPanel contentPane = (JPanel) getContentPane();
    contentPane.setLayout( new BorderLayout() );
    contentPane.add(m_button, BorderLayout.SOUTH);
    contentPane.add(m_browserButton, BorderLayout.NORTH);
    
    // Set attributes of the buttons
    m_button.setFont( new Font("SansSerif", Font.PLAIN, 14) );
    m_browserButton.setFont( new Font("SansSerif", Font.PLAIN, 14) );
    m_browserButton.setEnabled(false); // Disabled until query done
    
    JScrollPane scrollPane = new JScrollPane();
    m_editorPane = new JEditorPane();
    m_editorPane.setEditable(false);
    scrollPane.setViewportView(m_editorPane);
    contentPane.add(scrollPane, BorderLayout.CENTER);
    
    m_button.addActionListener( new ActionListener()
    {
      public void actionPerformed(ActionEvent e)
      {
        // Postpone the work to perform the query
        EventQueue.invokeLater(new Runnable()
        {
          public void run()
          {
            performQuery();
          }
        }
        );
      }
    }
    );
    
    m_browserButton.addActionListener( new ActionListener()
    {
      public void actionPerformed(ActionEvent e)
      {
        if (m_url != null)
        {
          BareBonesBrowserLaunch.openURL(m_url.toString());
        }
      }
    }
    );
  }
  
  /**
   *   Perform the query, firing up a new browser window.
   */
  private void performQuery()
  {
    try
    {
      // Create the base URL
      URL url = new URL("http://maps.google.com/maps");
      
      // Create the set of properties needed for the query
      Properties props = new Properties();
      props.put("f", "q");
      props.put("hl", "en");
      props.put("q", "Eiffel Tower, Paris France");
      props.put("ie", "UTF8");
      props.put("z", "12");
      props.put("om", "1");
      try
      {
        // Create the final query URL
        url = URLQuery.createQuery(url, props);
System.out.println("Showing document: " + url);
        // Open the URL in the editor pane
        m_editorPane.setPage(url);
        // Now we succeeded, set the class instance url field
        // and enable the browser button
        m_url = url;
        m_browserButton.setEnabled(true);
      } 
      catch (Exception ex)
      {
        ex.printStackTrace();
      } 
    }
    catch (MalformedURLException e)
    {
      e.printStackTrace();
    }
  }
  
  //// Private data ////
  private JEditorPane m_editorPane = null;
  private URL m_url = null;
  private JButton m_button = new JButton("Google Maps Query");
  private JButton m_browserButton = new JButton("Try it in a browser window");
}

package networking;

import java.io.UnsupportedEncodingException;
import java.net.URL;
import java.net.URLEncoder;
import java.net.MalformedURLException;

import java.util.Enumeration;
import java.util.Properties;

/**
 *   Class to create a URL to perform a CGI query against a web server.
 */
public class URLQuery
{
  /**
   *   Creates a URL query from the base URL and the set of properties.
   */
  public static URL createQuery(URL baseURL, Properties params)
      throws MalformedURLException, UnsupportedEncodingException
  {
    // Queries use the URL followed by a '?' character
    String file = baseURL.getFile() + "?";
    
    // And then append the query parameters to the URL string
    Enumeration e = params.propertyNames();
    int count = 0;
    while ( e.hasMoreElements() )
    {
      String propertyName = (String) e.nextElement();
      propertyName = URLEncoder.encode(propertyName, "UTF-8");
      if (count > 0)
        file += "&";        // Separate parameters with '&' character
      file += propertyName;
      String propertyValue = params.getProperty(propertyName);
      if (propertyValue != null)
      {
        propertyValue = URLEncoder.encode(propertyValue, "UTF-8");
        file += "=" + propertyValue;
      }
      count++;
    }
    
    return new URL(baseURL.getProtocol(), 
                   baseURL.getHost(),
                   baseURL.getPort(), 
                   file);
  }
  
  /**
   * Constructor disabled by making it private
   */
  private URLQuery()
  {
  }
}

package networking;

import java.net.URL;
import java.net.URLConnection;

import java.io.BufferedReader;
import java.io.InputStreamReader;
import java.util.Scanner;

/**
*   Application to read text from a URL specified in the 
*   first command line argument, using a URLConnection
*   (Note that this is NOT a Reader in the same sense as BufferedReader.)
*/
public class URLConnectionReader
{
  /**
   * Main entry point
   * 
   * @usage java networking.NodeLookup urlstring
   * 
   * If no arguments provided, will prompt for urlstring
   * 
   * @param args the command line arguments
   *             args[0] contains the urlstring to read
   */
   public static void main(String[] args) throws Exception
   {
     String urlName;
    
     if (args.length < 1)
     {
       System.out.print("URL : ");
       Scanner in = new Scanner(System.in);
       urlName = in.nextLine();
     }
     else
     {
       urlName = args[0]; // Use first argument for hostname
     }    
        
     URL url = new URL(urlName);
     URLConnection conn = url.openConnection();
     BufferedReader reader = new BufferedReader(
                                        new InputStreamReader(
                                                conn.getInputStream()));
     try
     {
        String line = null;
        while (true)
        {
          line = reader.readLine();
          if (line == null)
            break;
          System.out.println(line);
        }
     }
     finally
     {
        reader.close();
     }
   }
}

package networking;

import java.net.URL;
import java.net.URLConnection;
import java.net.URLEncoder;

import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.io.PrintWriter;
import java.net.MalformedURLException;
import java.nio.charset.Charset;
import java.util.Scanner;

public class ReverseCGIClient
{
    /**
    * Main entry point
    * 
    * @usage java networking.ReverseCGIClient string-to-reverse>
    * 
    * @param args
    * 
    */
    public static void main(String[] args)
    {
        String reverseMe;

        if (args.length < 1)
        {
        System.out.print("String to reverse : ");
        Scanner in = new Scanner(System.in);
        reverseMe = in.nextLine();
        }
        else
        {
        reverseMe = args[0]; // Use first argument for string to reverse
        }    

        // Translate into x-www-form-urlencoded format:
        reverseMe = URLEncoder.encode(reverseMe, Charset.defaultCharset());
        
        URLConnection conn = null;
        PrintWriter out = null;
        BufferedReader in = null;
        
        try
        {
            // Open connection to URL
            System.err.println("Accessing URL");
            URL url = new URL("http://java.sun.com/cgi-bin/backwards");
            System.err.println("Opening URL connection");
            conn = url.openConnection();
            // Set connection so it can do output
            conn.setDoOutput(true);
            
            // Provide input to server using the output stream.
            out = new PrintWriter(conn.getOutputStream());
            
            out.println("string=" + reverseMe);
            
            // Read response from server
            in = new BufferedReader( new InputStreamReader(
                                            conn.getInputStream()));
            String line = null;
            while (true)
            {
                line = in.readLine();
                if (line == null)
                    break;
                System.out.println(line);
            }
        }
        catch (MalformedURLException ex)
        {
            ex.printStackTrace();
        }
        catch (IOException ex)
        {
            ex.printStackTrace();
        }
        finally
        {
            out.close();
            try
            {
                in.close();
            }
            catch (IOException ex)
            {
                ex.printStackTrace();
            }
        }
    }
}

package networking;

import java.io.ByteArrayOutputStream;
import java.io.IOException;
import java.net.MalformedURLException;
import java.net.URL;
import java.net.URLConnection;
import java.util.List;
import java.util.Map;
import java.util.Scanner;

/**
 * Class to connect to a URL and display the response header 
 * data and first ten lines of the the requested data.
 *
 * (Based on the class supplied in Core Java 2, Vol II,
 *  Advanced Concepts, by Horstmann & Cornell, Prentice-Hall, 2005)
 */
public class URLConnectionTest
{
  /**
   * Main entry point
   * @param args the command line arguments
   *             args[0] contains the URL 
   *             args[1] & args[2] contain an optional
   *                     username and password.
   */
  public static void main(String[] args)
  {
    String urlString = null;
    String username = null;
    String password = null;
    
    if (args.length > 0)
    {
      urlString = args[0];
      
      if (args.length > 1)
      {
        username = args[1];
        
        if (args.length > 2)
        {
          password = args[2];
        }
      }
    }
    else
    {
      // No arguments supplied, so prompt for them
      Scanner in = new Scanner(System.in);
      System.out.print("URL : ");
      urlString = in.nextLine();
      System.out.print("Username (optional) : ");
      username = in.nextLine();
      if (username.isBlank())
        username = null;
      System.out.print("Password (optional) : ");
      password = in.nextLine();
      if (password.isBlank())
        password = null;
    }
    
    try
    {
        URL url = new URL(urlString);
        URLConnection connection = url.openConnection();

        if (username != null)
        {
          String input = username + ":" + password;
          String encoding = base64Encode(input);
          connection.setRequestProperty("Authorization", "Basic " + encoding);
        }

        System.out.println(">>>>");
        System.out.println("Connecting to: " + urlString);

        connection.connect();

        System.out.println("Connected...");

        // Print the Method line
        System.out.println("----------Method--------------");
        System.out.println("[0] " + connection.getHeaderField(0));

        // Print header fields
        System.out.println("----------Response Headers----");
        for (int line = 1; ; line++)
        {
          String header = connection.getHeaderField(line);
          if (header == null)
            break;
          System.out.println("[" + line + "] " + 
                               connection.getHeaderFieldKey(line) + ": " +
                               header
                              );
        }

        // Print how many header lines (subtract one for the 0th entry, 
        // which is the Method line).
        Map<String, List<String>> headers = connection.getHeaderFields();
        System.out.println("There were " + (headers.size() - 1) + " header lines");

        // Print convenience function outputs

        System.out.println("----------Convenience functions----");
        System.out.println("getContentType: " + connection.getContentType());
        System.out.println("getContentLength: " + connection.getContentLength());
        System.out.println("getContentEncoding: " + connection.getContentEncoding());
        System.out.println("getDate: " + connection.getDate());
        System.out.println("getExpiration: " + connection.getExpiration());
        System.out.println("getLastModified: " + connection.getLastModified());

        Scanner in = new Scanner(connection.getInputStream());

        // Print first ten lines of contents 

        System.out.println("----------Content--------");
        for (int line = 1; in.hasNextLine() && line <= 10; line++)
        {
          System.out.println("[" + line + "] " + in.nextLine());
        }
        if (in.hasNextLine())
        {
          System.out.println(". . .");
        }
    }
    catch (MalformedURLException ex)
    {
        ex.printStackTrace();
    }
    catch (IOException ex)
    {
        ex.printStackTrace();
    }
  }

  /**
   * Computes the Base64 encoding of a string
   * @param string the string
   * @return the Base64 encoding of string
   */
  public static String base64Encode(String string)
  {
    ByteArrayOutputStream bytesOut = new ByteArrayOutputStream();
    Base64OutputStream out = new Base64OutputStream(bytesOut);
    try
    {
      out.write(string.getBytes());
      out.flush();
    }
    catch (IOException ioe)
    {
      // Do nothing
    }
    return bytesOut.toString();
  }
}

package networking;

import java.io.FilterOutputStream;
import java.io.IOException;
import java.io.OutputStream;

/**
 * This class implements a stream filter that converts
 * a stream of bytes to their Base64 encoding.
 *
 * Base64 encoding encodes 3 bytes into 4 characters.
 * |11111122|22223333|444444|
 * Each set of 6 bits is encoded according to the m_toBase64 map.
 * If the number of input bytes is not a multiple of 3, then the 
 * last group of characters is padded with one or two = signs.
 * Each output line is at most 76 characters.
 *
 * (Based on the class supplied in Core Java 2, Vol II,
 *  Advanced Concepts, by Horstmann & Cornell, Prentice-Hall, 2005)
 */
public class Base64OutputStream extends FilterOutputStream
{
  /**
   * Constructor
   * @param out the stream to filter
   */
  public Base64OutputStream(OutputStream out)
  {
    super(out);
  }
  
  /**
   * Writes the specified <code>byte</code> to this output stream. 
   * <p>
   * @param      c the <code>byte</code>.
   */
  public void write(int c) throws IOException
  {
    m_inbuf[m_i] = c;
    m_i++;
    if (m_i == 3)
    {
      super.write( m_toBase64[(m_inbuf[0] & 0xFC) >> 2] );
      super.write( m_toBase64[((m_inbuf[0] & 0x03) << 4) |
                              ((m_inbuf[1] & 0xF0) >> 4)] );
      super.write( m_toBase64[((m_inbuf[1] & 0x0F) << 2) |
                              ((m_inbuf[2] & 0xC0) >> 6)] );
      super.write( m_toBase64[m_inbuf[2] & 0x3F] );
      m_col += 4;
      m_i = 0;
      if (m_col >= 76)
      {
        super.write('\n');
        m_col = 0;
      }
    }
  }
  
  /**
   * Flushes this output stream and forces any buffered output bytes 
   * to be written out to the stream. 
   */
  public void flush() throws IOException
  {
    if (m_i == 1)
    {
      super.write( m_toBase64[(m_inbuf[0] & 0xFC) >> 2] );
      super.write( m_toBase64[(m_inbuf[0] & 0x03) << 4] );
      super.write('=');
      super.write('=');
    }
    else if (m_i == 2)
    {
      super.write( m_toBase64[(m_inbuf[0] & 0xFC) >> 2] );
      super.write( m_toBase64[((m_inbuf[0] & 0x03) << 4) |
                              ((m_inbuf[1] & 0xF0) >> 4)] );
      super.write( m_toBase64[(m_inbuf[1] & 0x0F) << 2] );
      super.write('=');
    }
  }
  
  /////// Private data /////////
  private static char[] m_toBase64 =
  {
    'A', 'B', 'C', 'D', 'E', 'F', 'G', 'H', 'I', 'J', 
    'K', 'L', 'M', 'N', 'O', 'P', 'Q', 'R', 'S', 'T',
    'U', 'V', 'W', 'X', 'Y', 'Z',
    'a', 'b', 'c', 'd', 'e', 'f', 'g', 'h', 'i', 'j', 
    'k', 'l', 'm', 'n', 'o', 'p', 'q', 'r', 's', 't',
    'u', 'v', 'w', 'x', 'y', 'z',
    '0', '1', '2', '3', '4', '5', '6', '7', '8', '9',
    '+', '/'
  };

  public void write(byte[] b) throws IOException
  {
  }
  
  private int m_col = 0;
  private int m_i = 0;
  private int[] m_inbuf = new int[3];
}

package networking;

import java.awt.BorderLayout;
import java.awt.event.ActionEvent;
import java.awt.event.ActionListener;
import java.io.IOException;
import java.io.InputStream;
import java.io.PrintWriter;
import java.net.HttpURLConnection;
import java.net.URL;
import java.net.URLConnection;
import java.net.URLEncoder;
import java.util.HashMap;
import java.util.Map;
import java.util.Scanner;
import javax.swing.JButton;
import javax.swing.JComboBox;
import javax.swing.JFrame;
import javax.swing.JPanel;
import javax.swing.JScrollPane;
import javax.swing.JTextArea;

/**
 * This program demonstrates how to use the URLConnection class for a POST request.
 */
public class PostTest
{
  public static void main(String[] args)
  {
    JFrame frame = new PostTestFrame();
    frame.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
    frame.setVisible(true);
  }
}

class PostTestFrame extends JFrame
{
  /**
   * Makes a POST request and returns the server response.
   * @param urlString the URL to post to
   * @param nameValuePairs a map of name/value pairs to supply in the request.
   * @return the server reply (either from the input stream or the error stream)
   */
  public static String doPost(String urlString, Map<String, String> nameValuePairs)
                           throws IOException
  {
    System.out.println("Connecting to URL: " + urlString);

    URL url = new URL(urlString);
    URLConnection connection = url.openConnection();
    connection.setDoOutput(true);
    
    PrintWriter out = new PrintWriter(connection.getOutputStream());
    
    boolean first = true;
    
    System.out.print("Query String : ");
    for (Map.Entry<String, String> pair : nameValuePairs.entrySet())
    {
      if (first)
      {
        first = false;
      }
      else 
      {
        System.out.print('&');
        out.print('&'); // Output '&' separator
      }
      String name = pair.getKey();
      String value = pair.getValue();
      out.print(name);
      out.print('=');
      value = URLEncoder.encode(value, "UTF-8");
      out.print(value);
      System.out.print(name + '=' + value);
    }
    System.out.println();
    
    out.close();
    
    Scanner in;
    StringBuilder response = new StringBuilder();
    try
    {
      in = new Scanner(connection.getInputStream());
    }
    catch (IOException e)
    {
      if (!(connection instanceof HttpURLConnection)) 
        throw e;
      InputStream err
          = ((HttpURLConnection)connection).getErrorStream();
      if (err == null) 
        throw e;
      in = new Scanner(err);
    }
    while (in.hasNextLine())
    {
      response.append(in.nextLine());
      response.append("\n");
    }
    
    in.close();
    return response.toString();
  }
  
  /**
   * Constructor
   */
  public PostTestFrame()
  {
    setSize(DEFAULT_WIDTH, DEFAULT_HEIGHT);
    setTitle("PostTest");
    
    JPanel northPanel = new JPanel();
    add(northPanel, BorderLayout.NORTH);
    
    final JComboBox combo = new JComboBox();
    for (int i = 0; i < m_countries.length; i += 2)
      combo.addItem(m_countries[i]);
    northPanel.add(combo);
    
    final JTextArea result = new JTextArea();
    add(new JScrollPane(result));
    
    JButton getButton = new JButton("Get");
    northPanel.add(getButton);
    getButton.addActionListener(new ActionListener()
      {
        public void actionPerformed(ActionEvent event)
        {
          new Thread(new Runnable()
          {
            public void run()
            {
              final String SERVER_URL = "http://www.census.gov/cgi-bin/ipc/idbsprd";
              result.setText("");
              Map<String, String> post = new HashMap<String, String>();
              post.put("tbl", "001");
              post.put("cty", m_countries[2 * combo.getSelectedIndex() + 1]);
              post.put("optyr", "latest checked");
              try
              {
                // Do the POST to the server URL
                result.setText(doPost(SERVER_URL, post));
              }
              catch (IOException e)
              {
                result.setText("" + e);
              }
            }
          }).start();
        }
      }
    );
  }
  
  private static String[] m_countries = 
  {
    "Afghanistan", "AF", "Albania", "AL", "Algeria", "AG", "American Samoa", "AQ",
    "Andorra", "AN", "Angola", "AO", "Anguilla", "AV", "Antigua and Barbuda", "AC",
    "Argentina", "AR", "Armenia", "AM", "Aruba", "AA", "Australia", "AS", "Austria", "AU",
    "Azerbaijan", "AJ", "Bahamas, The", "BF", "Bahrain", "BA", "Bangladesh", "BG",
    "Barbados", "BB", "Belarus", "BO", "Belgium", "BE", "Belize", "BH", "Benin", "BN",
    "Bermuda", "BD", "Bhutan", "BT", "Bolivia", "BL", "Bosnia and Herzegovina", "BK",
    "Botswana", "BC", "Brazil", "BR", "Brunei", "BX", "Bulgaria", "BU", "Burkina Faso", "UV",
    "Burma", "BM", "Burundi", "BY", "Cambodia", "CB", "Cameroon", "CM", "Canada", "CA",
    "Cape Verde", "CV", "Cayman Islands", "CJ", "Central African Republic", "CT", "Chad", "CD",
    "Chile", "CI", "China", "CH", "Colombia", "CO", "Comoros", "CN", "Congo (Brazzaville", "CF",
    "Congo (Kinshasa)", "CG", "Cook Islands", "CW", "Costa Rica", "CS", "Cote d'Ivoire", "IV",
    "Croatia", "HR", "Cuba", "CU", "Cyprus", "CY", "Czech Republic", "EZ", "Denmark", "DA",
    "Djibouti", "DJ", "Dominica", "DO", "Dominican Republic", "DR", "East Timor", "TT",
    "Ecuador", "EC", "Egypt", "EG", "El Salvador", "ES", "Equatorial Guinea", "EK",
    "Eritrea", "ER", "Estonia", "EN", "Ethiopia", "ET", "Faroe Islands", "FO", "Fiji", "FJ",
    "Finland", "FI", "France", "FR", "French Guiana", "FG", "French Polynesia", "FP",
    "Gabon", "GB", "Gambia, The", "GA", "Gaza Strip", "GZ", "Georgia", "GG", "Germany", "GM",
    "Ghana", "GH", "Gibraltar", "GI", "Greece", "GR", "Greenland", "GL", "Grenada", "GJ",
    "Guadeloupe", "GP", "Guam", "GQ", "Guatemala", "GT", "Guernsey", "GK", "Guinea", "GV",
    "Guinea-Bissau", "PU", "Guyana", "GY", "Haiti", "HA", "Honduras", "HO",
    "Hong Kong S.A.R", "HK", "Hungary", "HU", "Iceland", "IC", "India", "IN", "Indonesia", "ID",
    "Iran", "IR", "Iraq", "IZ", "Ireland", "EI", "Israel", "IS", "Italy", "IT", "Jamaica", "JM",
    "Japan", "JA", "Jersey", "JE", "Jordan", "JO", "Kazakhstan", "KZ", "Kenya", "KE",
    "Kiribati", "KR", "Korea, North", "KN", "Korea, South", "KS", "Kuwait", "KU",
    "Kyrgyzstan", "KG", "Laos", "LA", "Latvia", "LG", "Lebanon", "LE", "Lesotho", "LT",
    "Liberia", "LI", "Libya", "LY", "Liechtenstein", "LS", "Lithuania", "LH", "Luxembourg", "LU",
    "Macau S.A.R", "MC", "Macedonia, The Former Yugo. Rep. of", "MK", "Madagascar", "MA",
    "Malawi", "MI", "Malaysia", "MY", "Maldives", "MV", "Mali", "ML", "Malta", "MT",
    "Man, Isle of", "IM", "Marshall Islands", "RM", "Martinique", "MB", "Mauritania", "MR",
    "Mauritius", "MP", "Mayotte", "MF", "Mexico", "MX", "Micronesia, Federated States of", "FM",
    "Moldova", "MD", "Monaco", "MN", "Mongolia", "MG", "Montserrat", "MH", "Morocco", "MO",
    "Mozambique", "MZ", "Namibia", "WA", "Nauru", "NR", "Nepal", "NP", "Netherlands", "NL",
    "Netherlands Antilles", "NT", "New Caledonia", "NC", "New Zealand", "NZ", "Nicaragua", "NU",
    "Niger", "NG", "Nigeria", "NI", "Northern Mariana Islands", "CQ", "Norway", "NO",
    "Oman", "MU", "Pakistan", "PK", "Palau", "PS", "Panama", "PM", "Papua New Guinea", "PP",
    "Paraguay", "PA", "Peru", "PE", "Philippines", "RP", "Poland", "PL", "Portugal", "PO",
    "Puerto Rico", "RQ", "Qatar", "QA", "Reunion", "RE", "Romania", "RO", "Russia", "RS",
    "Rwanda", "RW", "Saint Helena", "SH", "Saint Kitts and Nevis", "SC", "Saint Lucia", "ST",
    "Saint Pierre and Miquelon", "SB", "Saint Vincent and the Grenadines", "VC", "Samoa", "WS",
    "San Marino", "SM", "Sao Tome and Principe", "TP", "Saudi Arabia", "SA", "Senegal", "SG",
    "Serbia and Montenegro", "YI", "Seychelles", "SE", "Sierra Leone", "SL", "Singapore", "SN",
    "Slovakia", "LO", "Slovenia", "SI", "Solomon Islands", "BP", "Somalia", "SO",
    "South Africa", "SF", "Spain", "SP", "Sri Lanka", "CE", "Sudan", "SU", "Suriname", "NS",
    "Swaziland", "WZ", "Sweden", "SW", "Switzerland", "SZ", "Syria", "SY", "Taiwan", "TW",
    "Tajikistan", "TI", "Tanzania", "TZ", "Thailand", "TH", "Togo", "TO", "Tonga", "TN",
    "Trinidad and Tobago", "TD", "Tunisia", "TS", "Turkey", "TU", "Turkmenistan", "TX",
    "Turks and Caicos Islands", "TK", "Tuvalu", "TV", "Uganda", "UG", "Ukraine", "UP",
    "United Arab Emirates", "TC", "United Kingdom", "UK", "United States", "US", "Uruguay", "UY",
    "Uzbekistan", "UZ", "Vanuatu", "NH", "Venezuela", "VE", "Vietnam", "VM",
    "Virgin Islands", "VQ", "Virgin Islands, British", "VI", "Wallis and Futuna", "WF",
    "West Bank", "WE", "Western Sahara", "WI", "Yemen", "YM", "Zambia", "ZA", "Zimbabwe", "ZI"
  };
  
  public static final int DEFAULT_WIDTH = 400;
  public static final int DEFAULT_HEIGHT = 300;
}

package post;

import java.io.IOException;
import java.io.InputStream;
import java.io.PrintWriter;
import java.net.CookieHandler;
import java.net.CookieManager;
import java.net.CookiePolicy;
import java.net.HttpURLConnection;
import java.net.URL;
import java.net.URLEncoder;
import java.nio.charset.StandardCharsets;
import java.nio.file.Files;
import java.nio.file.Paths;
import java.util.Map;
import java.util.Properties;
import java.util.Scanner;

/**
 * This program demonstrates how to use the URLConnection class for a POST request.
 * 
 */
public class PostTest
{
   /**
    * Main entry point
    * @usage java properties-file
    * @param args
    * @throws IOException 
    */
   public static void main(String[] args) throws IOException
   {
      // Properties file default is post.properties
      String propsFilename = args.length > 0 ? args[0] : "post.properties"; 
      Properties props = new Properties();
      try (InputStream in = Files.newInputStream(Paths.get(propsFilename)))
      {
         props.load(in);
      }
      String urlString = props.remove("url").toString();
      Object userAgent = props.remove("User-Agent");
      Object redirects = props.remove("redirects");
      CookieHandler.setDefault(new CookieManager(null, CookiePolicy.ACCEPT_ALL));
      String result = doPost(new URL(urlString), props, 
         userAgent == null ? null : userAgent.toString(), 
         redirects == null ? -1 : Integer.parseInt(redirects.toString()));
      System.out.println(result);
   }   

   /**
    * Do an HTTP POST.
    * @param url the URL to post to
    * @param nameValuePairs the query parameters
    * @param userAgent the user agent to use, or null for the default user agent
    * @param redirects the number of redirects to follow manually, or -1 for automatic
    * redirects
    * @return the data returned from the server
    */
   public static String doPost(URL url, Map<Object, Object> nameValuePairs, 
                               String userAgent, int redirects) throws IOException
   {  
      System.out.println("Connecting to URL: " + url.toExternalForm());
      
      HttpURLConnection connection = (HttpURLConnection) url.openConnection();
      if (userAgent != null)
      {
         System.out.println("User-Agent : " + userAgent);
         connection.setRequestProperty("User-Agent", userAgent);
      }
      
      System.out.println("Redirects: " + redirects);
      
      if (redirects >= 0)
         connection.setInstanceFollowRedirects(false);
      
      connection.setDoOutput(true);
      
      try (var out = new PrintWriter(connection.getOutputStream()))
      {
         var first = true;
         System.out.print("Query String: ");
         for (Map.Entry<Object, Object> pair : nameValuePairs.entrySet())
         {
            if (first) 
                first = false;
            else
            {
                out.print('&');
                System.out.print('&');
            }
            String name = pair.getKey().toString();
            String value = pair.getValue().toString();
            out.print(name);
            out.print('=');
            value = URLEncoder.encode(value, StandardCharsets.UTF_8);
            out.print(value);
            System.out.print(name + '=' + value);
         }
         System.out.println();
      }      
      String encoding = connection.getContentEncoding();
      if (encoding == null) 
          encoding = "UTF-8";
            
      if (redirects > 0)
      {
         int responseCode = connection.getResponseCode();
         if (responseCode == HttpURLConnection.HTTP_MOVED_PERM 
               || responseCode == HttpURLConnection.HTTP_MOVED_TEMP
               || responseCode == HttpURLConnection.HTTP_SEE_OTHER) 
         {
            String location = connection.getHeaderField("Location");
            if (location != null)
            {
               URL base = connection.getURL();
               connection.disconnect();
               return doPost(new URL(base, location), nameValuePairs, userAgent, 
                     redirects - 1);
            }
         }
      }
      else if (redirects == 0)
      {
         throw new IOException("Too many redirects");
      }
         
      var response = new StringBuilder();
      try (var in = new Scanner(connection.getInputStream(), encoding))
      {
         while (in.hasNextLine())
         {
            response.append(in.nextLine());
            response.append("\n");
         }         
      }
      catch (IOException e)
      {
         InputStream err = connection.getErrorStream();
         if (err == null) 
             throw e;
         try (var in = new Scanner(err))
         {
            response.append(in.nextLine());
            response.append("\n");
         }
      }

      return response.toString();
   }
}