updated student assignment source

assignments/src/MV3500Cohort2022MayJune/README.md

+## Student assignments: homework submission directories
+
+* [Homework 1 README](homework1/README.md) Netbeans, Wireshark, Telnet
+* [Homework 2 README](homework2/README.md) Client=Server Socket Connectons
+* [Homework 3 README](homework3/README.md) Example Simulation Program
+* [Homework 4 README](homework4/README.md) DIS Protocol Assesment
+* [Projects README](projects/README.md) Freeplay Opportunities
+
+Please see the [README.md](../../../README.md) in the parent
+[assignments](../../../../assignments) directory for detailed instructions.

assignments/src/MV3500Cohort2022MayJune/homework1/AllenTcpExample1Telnet1.java

+package MV3500Cohort2021JulySeptember.homework1;;
+
+import java.io.*;
+import java.net.*;
+import java.io.*;
+import java.net.*;
+import java.io.*;
+import java.net.*;
+import java.io.*;
+import java.net.*;
+
+/**
+ * The simplest possible TCP network program. It listens for
+ * a connection, from telnet (telnet localhost 2317) or a program
+ * you write, which we will do later. Right now the TcpExample simply
+ * writes a string in response to a connection.
+ * 
+ * Modifying his program is the basis for Assignment 1.
+ * 
+ * Testing the running server program from telnet looks like this:
+ * 
+ * it154916:projects mcgredo$ telnet localhost 2317
+ * Trying ::1...
+ * Connected to localhost.
+ * Escape character is '^]'.
+ * This was written by the server
+ * Connection closed by foreign host.
+ * 
+ * Notice that "This was written by the server" matches 
+ * what is written by the code below, over the output stream.
+ * 
+ * After this first connection the program below drops out
+ * the bottom of the program, and does not repeat itself.
+ * The program exits.
+ * 
+ * @author mcgredo
+ * @author brutzman
+ */
+public class AllenTcpExample1Telnet1 
+{
+    /**
+     * Program invocation, execution starts here
+     * @param args command-line arguments
+     */
+    public static void main(String[] args)
+    {
+        try
+        {
+            System.out.println("TcpExample1Telnet  has started and is waiting for a connection.");
+            System.out.println("  help: https://savage.nps.edu/Savage/developers.html#telnet");
+            System.out.println("  enter (telnet localhost 2317) or (nc localhost 2317)..." );
+			
+            // The ServerSocket waits for a connection from a client.
+            // It returns a Socket object when the connection occurs.
+            ServerSocket serverSocket = new ServerSocket(2317);
+            
+            // Use Java io classes to write text (as opposed to
+            // unknown bytes of some sort) to the client
+            
+            // The Socket object represents the connection between
+            // the server and client, including a full duplex connection
+            try (Socket clientConnection = serverSocket.accept()) // wait here for a client to connect
+            {
+                // OK we got something, time to respond!
+                // Use Java io classes to write text (as opposed to
+                // unknown bytes of some sort) to the client
+                OutputStream os = clientConnection.getOutputStream();
+                PrintStream ps = new PrintStream(os);
+                
+                        ps.println("This client response was written by John Allen ");  // to remote client
+                        ps.println("MOVES 2021 Cohort is well described by Johnny Smiles.");
+                System.out.println("This server response was written by John Allen " ); // to server console
+
+                // "flush()" in important in that it forces a write
+                // across what is in fact a slow connection
+                ps.flush();
+            }
+            System.out.println(" completed successfully.");
+        }
+        catch(IOException e)
+        {
+            System.err.println(" Pardon the interruption, networking issue"); // describe what is happening
+            System.err.println(e);
+            // Provide more helpful information to user if exception occurs due to running twice at one time
+            
+            // brute force exception checking, can be brittle if exception message changes
+            // if (e.getMessage().equals("Address already in use: NET_Bind")) 
+            if (e instanceof java.net.BindException)
+                System.err.println("*** Be sure to stop any other running instances of programs using this port!");
+        }
+    }
+}

assignments/src/MV3500Cohort2022MayJune/homework1/FisherTCPExample1Telnet.java

+package MV3500Cohort2021JulySeptember.homework1;
+
+
+import java.io.IOException;
+import java.io.OutputStream;
+import java.io.PrintStream;
+import java.net.ServerSocket;
+import java.net.Socket;
+
+/**
+ * homework assignment
+ * @author adfis
+ */
+
+
+public class FisherTCPExample1Telnet
+{
+    /** run the program
+     * @param args command-line arguments, string parameters (unused) */
+    public static void main(String[] args) 
+    {
+        try
+        {
+            System.out.println("TcpExample1Telnet has started and is waiting for a connection.");
+            System.out.println("  help: https://savage.nps.edu/Savage/developers.html#telnet");
+            System.out.println("  enter (telnet localhost 2317) or (nc localhost 2317)..." );
+			
+            // The ServerSocket waits for a connection from a client.
+            // It returns a Socket object when the connection occurs.
+            ServerSocket serverSocket = new ServerSocket(2317);
+            
+            // Use Java io classes to write text (as opposed to
+            // unknown bytes of some sort) to the client
+            
+            // The Socket object represents the connection between
+            // the server and client, including a full duplex connection
+            try (Socket clientConnection = serverSocket.accept()) {
+                // Use Java io classes to write text (as opposed to
+                // unknown bytes of some sort) to the client
+                OutputStream os = clientConnection.getOutputStream();
+                PrintStream ps = new PrintStream(os);
+                
+                ps.println("Client response was written by Alex' server TcpExample1."); // to remote clientnc
+                ps.println("We are crushing this assignment, good work.");
+                System.out.println("Server response was written by Alex' server TcpExample1."); // to server console
+                System.out.println("SUCCESS!");
+
+                // "flush()" in important in that it forces a write
+                // across what is in fact a slow connection
+                ps.flush();
+            }
+            System.out.println("FisherTCPExample1 completed successfully.");
+        }
+        catch(IOException e)
+        {
+            System.err.println("Problem with FisherTCPExample1Telnet networking:"); // describe what is happening
+            System.err.println("Error: " + e);
+            // Provide more helpful information to user if exception occurs due to running twice at one time
+            
+            // brute force exception checking, can be brittle if exception message changes
+            // if (e.getMessage().equals("Address already in use: NET_Bind")) 
+            if (e instanceof java.net.BindException)
+                System.err.println("*** Be sure to stop any other running instances of programs using this port!");
+        }
+    }
+}
+

assignments/src/MV3500Cohort2022MayJune/homework1/FrankTCPExample3Client.java

+package MV3500Cohort2021JulySeptember.homework1;
+
+import java.io.BufferedReader;
+import java.io.IOException;
+import java.io.InputStream;
+import java.io.InputStreamReader;
+import java.io.Reader;
+import java.net.Socket;
+
+/**
+ * homework assignment
+ * @author justi
+ */
+public class FrankTCPExample3Client {
+
+    /** IPv6 default */
+    public final static String LOCALHOST = "0:0:0:0:0:0:0:1";
+
+    /**
+     * Program invocation, execution starts here
+     * @param args command-line arguments
+     */
+    public static void main(String[] args)
+    {
+        // Local variables/fields
+        Socket socket = null;
+        InputStream is;
+        Reader isr;
+        BufferedReader br;
+        String serverMessage;
+        int clientLoopCount = 0;
+
+        try {
+            while (true) {
+                clientLoopCount++; // increment at beginning of loop for reliability
+                System.out.println(FrankTCPExample3Client.class.getName() + " creating socket...");
+
+                // We request an IP to connect to ("localhost") and
+                // port number at that IP (2317). This establishes
+                // a connection to that IP in the form of a Socket
+                // object; the server uses a ServerSocket to wait for
+                // connections.
+                socket = new Socket(LOCALHOST, 2318); // locohost?
+
+                // Now hook everything up (i.e. set up the streams), Java style:
+                is = socket.getInputStream();
+                isr = new InputStreamReader(is);
+                br = new BufferedReader(isr);
+
+                // Read a single line written by the server. We'd
+                // do things a bit differently if there were many lines to be read
+                // from the server instead of one only.
+                serverMessage = br.readLine();
+                System.out.println("==================================================");
+
+                System.out.print("Client loop " + clientLoopCount + ": ");
+                System.out.println("now we're talking!");
+                System.out.println("The message the server sent was: '" + serverMessage + "'");
+                // socket gets closed, either automatically/silently by this code (or possibly by the server)
+                if (serverMessage.equals("this is good bye message from the server")) { //if client recieved termanation message stop client
+                    break;
+                }
+                Thread.sleep(1000); // turned it down to 1 second
+
+            } // end while(true) // infinite loops are dangerous, be sure to kill this process!
+        } 
+        catch (IOException | InterruptedException e) 
+        {
+            System.err.println("Problem with " + FrankTCPExample3Client.class.getName() + " networking:"); // describe what is happening
+            System.err.println("Error: " + e);
+
+            // Provide more helpful information to user if exception occurs due to running twice at one time
+            if (e instanceof java.net.BindException) {
+                System.err.println("*** Be sure to stop any other running instances of programs using this port!");
+            }
+        } finally // occurs after any other activity when shutting down
+        {
+            try {
+                if (socket != null) {
+                    socket.close();
+                }
+            } catch (IOException e) {
+            }
+
+            // program exit: tell somebody about that happening.  Likely cause: server drops connection.
+            System.out.println();
+            System.out.println("FrankTCPExample3Client.class.getName() + exit");
+        }
+    }
+}

assignments/src/MV3500Cohort2022MayJune/homework1/FrankTCPExample3Server.java

+package MV3500Cohort2021JulySeptember.homework1;
+
+import java.io.*;
+import java.net.*;
+
+/**
+ * Very slightly more complex than example1, further modifying example2. The
+ * only thing this does differently is introduce a loop into the response, so
+ * you don't have to restart the program after one response. Also, it prints out
+ * the socket pair the server sees. Run the program via telnet several times and
+ * compare the socket pairs.
+ *
+ * telnet (nc) localhost 2318
+ *
+ * If you're sophisticated you can contact the instructor's computer while
+ * running this program.
+ *
+ * telnet (nc) [ipNumberOfServerLaptop] 2317
+ *
+ * and have the instructor display the socket pairs received.
+ *
+ * @author mcgredo
+ * @author brutzman
+ */
+public class FrankTCPExample3Server {
+
+    /**
+     * Program invocation, execution starts here If already compiled, can run
+     * using console in directory ../../build/classes/ by invoking \ java
+     * -classpath . TcpExamples.TcpExample3Server
+     *
+     * @param args command-line arguments
+     */
+    public static void main(String[] args)
+    {
+        try {
+
+            // ServerSocket waits for a connection from a client. 
+            // Notice that it is outside the loop; ServerSocket
+            // needs to be made only once.
+            System.out.println(FrankTCPExample3Server.class.getName() + " has started..."); // it helps debugging to put this on console first
+
+            ServerSocket serverSocket = new ServerSocket(2318); // changed from 2317 to 2318
+            OutputStream os;
+            PrintStream ps;
+            InetAddress localAddress, remoteAddress;
+            int localPort, remotePort;
+            int serverLoopCount = 0;
+
+            // Server is up and waiting (i.e. "blocked" or paused)
+            // Loop, infinitely, waiting for client connections.
+            // Stop the program somewhere else.
+            while (true) {
+
+                // block until connected to a client
+                try ( Socket clientConnectionSocket = serverSocket.accept()) {
+                    serverLoopCount++; // increment at beginning of loop for reliability
+
+                    // Now hook everything up (i.e. set up the streams), Java style:
+                    os = clientConnectionSocket.getOutputStream();
+                    ps = new PrintStream(os);
+                    if (serverLoopCount <= 20) { // checking if the loop count <= 20
+                        ps.println("This is response " + serverLoopCount + " produced by the server."); // this gets sent back to client!
+                    } else {
+                        ps.println("this is good bye message from the server"); // termination after 20 messages
+                        break; // Stop server
+                    }
+                    // Print some information locally about the Socket connection.
+                    // This includes the port and IP numbers on both sides (the socket pair).
+                    localAddress = clientConnectionSocket.getLocalAddress();
+                    remoteAddress = clientConnectionSocket.getInetAddress();
+                    localPort = clientConnectionSocket.getLocalPort();
+                    remotePort = clientConnectionSocket.getPort();
+
+                    System.out.print("Server loop " + serverLoopCount + ": ");
+
+                    // My socket pair connection looks like this, to localhost:
+                    // Socket pair: (( /0:0:0:0:0:0:0:1, 2317 ), ( /0:0:0:0:0:0:0:1, 54876 ))
+                    // Socket pair: (( /0:0:0:0:0:0:0:1, 2317 ), ( /0:0:0:0:0:0:0:1, 54881 ))
+                    // Why is the first IP/port the same, while the second set has different ports?
+                    System.out.println(FrankTCPExample3Server.class.getName() + " socket pair showing host name, address, port:");
+                    System.out.println("  (( "
+                            + localAddress.getHostName() + "=" + localAddress.getHostAddress() + ", " + localPort + " ), ( "
+                            + remoteAddress.getHostName() + "=" + remoteAddress.getHostAddress() + ", " + remotePort + " ))");
+
+                    if (localAddress.getHostName().equals(localAddress.getHostAddress())
+                            || remoteAddress.getHostName().equals(remoteAddress.getHostAddress())) {
+                        System.out.println("  note HostName matches address if host has no DNS name");
+                    }
+
+                    // Not/*i*/ce the use of flush() and try w/ resources. Without
+                    // the try w/ resources the Socket object may stay open for
+                    // a while after the client has stopped needing this
+                    // connection. try w/ resources explicitly ends the connection.
+                    ps.flush();
+                    // like it or not, you're outta here!
+                }
+            }
+        } catch (IOException e) {
+            System.err.println("Problem with " + FrankTCPExample3Server.class.getName() + " networking: " + e);
+
+            // Provide more helpful information to user if exception occurs due to running twice at one time
+            if (e instanceof java.net.BindException) {
+                System.err.println("*** Be sure to stop any other running instances of programs using this port!");
+            }
+        }
+    }
+}

assignments/src/MV3500Cohort2022MayJune/homework1/HittnerDomTcpExample1Telnet.java

+package MV3500Cohort2021JulySeptember.homework1;
+
+
+import java.io.IOException;
+import java.io.OutputStream;
+import java.io.PrintStream;
+import java.net.ServerSocket;
+import java.net.Socket;
+
+/**
+ * homework assignment
+ * @author adfis
+ */
+
+
+public class HittnerDomTcpExample1Telnet 
+{
+    /** run the program
+     * @param args command-line arguments, string parameters (unused) */
+    public static void main(String[] args) 
+    {
+        try
+        {
+            System.out.println("TcpExample1Telnet has started and is waiting for a connection.");
+            System.out.println("  help: https://savage.nps.edu/Savage/developers.html#telnet");
+            System.out.println("  enter (telnet localhost 2317) or (nc localhost 2317)..." );
+			
+            // The ServerSocket waits for a connection from a client.
+            // It returns a Socket object when the connection occurs.
+            ServerSocket serverSocket = new ServerSocket(2317);
+            
+            // Use Java io classes to write text (as opposed to
+            // unknown bytes of some sort) to the client
+            
+            // The Socket object represents the connection between
+            // the server and client, including a full duplex connection
+            try (Socket clientConnection = serverSocket.accept()) {
+                // Use Java io classes to write text (as opposed to
+                // unknown bytes of some sort) to the client
+                OutputStream os = clientConnection.getOutputStream();
+                PrintStream ps = new PrintStream(os);
+                
+                ps.println("Client response was brought to you by the Domo"); // to remote clientnc
+                ps.println("DomsaMom");
+                System.out.println("Client response was brought to you by the Domo"); // to server console
+                System.out.println("DomsaMom");
+
+                // "flush()" in important in that it forces a write
+                // across what is in fact a slow connection
+                ps.flush();
+            }
+            System.out.println("TcpExample1 completed successfully.");
+        }
+        catch(IOException e)
+        {
+            System.err.println("Problem with TcpExample1Telnet networking:"); // describe what is happening
+            System.err.println("Error: " + e);
+            // Provide more helpful information to user if exception occurs due to running twice at one time
+            
+            // brute force exception checking, can be brittle if exception message changes
+            // if (e.getMessage().equals("Address already in use: NET_Bind")) 
+            if (e instanceof java.net.BindException)
+                System.err.println("*** Be sure to stop any other running instances of programs using this port!");
+        }
+    }
+}

assignments/src/MV3500Cohort2022MayJune/homework1/HittnerNickTcpExample1Telnet.java

+package MV3500Cohort2021JulySeptember.homework1;
+
+
+import java.io.IOException;
+import java.io.OutputStream;
+import java.io.PrintStream;
+import java.net.ServerSocket;
+import java.net.Socket;
+
+/**
+ * homework assignment
+ * @author adfis
+ */
+
+
+public class HittnerNickTcpExample1Telnet
+{
+    /** run the program
+     * @param args command-line arguments, string parameters (unused) */
+    public static void main(String[] args) 
+    {
+        try
+        {
+            System.out.println("TcpExample1Telnet has started and is waiting for a connection.");
+            System.out.println("  help: https://savage.nps.edu/Savage/developers.html#telnet");
+            System.out.println("  enter (telnet localhost 2317) or (nc localhost 2317)..." );
+			
+            // The ServerSocket waits for a connection from a client.
+            // It returns a Socket object when the connection occurs.
+            ServerSocket serverSocket = new ServerSocket(2317);
+            
+            // Use Java io classes to write text (as opposed to
+            // unknown bytes of some sort) to the client
+            
+            // The Socket object represents the connection between
+            // the server and client, including a full duplex connection
+            try (Socket clientConnection = serverSocket.accept()) {
+                // Use Java io classes to write text (as opposed to
+                // unknown bytes of some sort) to the client
+                OutputStream os = clientConnection.getOutputStream();
+                PrintStream ps = new PrintStream(os);
+                
+                ps.println("Client response was brought to you by the Highlander"); // to remote clientnc
+                ps.println("There Can Be Only One");
+                System.out.println("Client response was brought to you by the Highlander"); // to server console
+                System.out.println("There Can be Only One");
+
+                // "flush()" in important in that it forces a write
+                // across what is in fact a slow connection
+                ps.flush();
+            }
+            System.out.println("TcpExample1 completed successfully.");
+        }
+        catch(IOException e)
+        {
+            System.err.println("Problem with TcpExample1Telnet networking:"); // describe what is happening
+            System.err.println("Error: " + e);
+            // Provide more helpful information to user if exception occurs due to running twice at one time
+            
+            // brute force exception checking, can be brittle if exception message changes
+            // if (e.getMessage().equals("Address already in use: NET_Bind")) 
+            if (e instanceof java.net.BindException)
+                System.err.println("*** Be sure to stop any other running instances of programs using this port!");
+        }
+    }
+}

assignments/src/MV3500Cohort2022MayJune/homework1/KeevenTCPExample3Client.java

+package MV3500Cohort2021JulySeptember.homework1;
+
+import java.io.*;
+import java.net.*;
+
+/**
+ * This is Assignment 1 where I have modified the given code from TCPExample3Client
+ * -sleep time has been extended to give more time in between loops
+ * -Initial print line has been altered to reflect assingnment 1
+ * -Loop only runs a finite number of times ,10.
+ * Before, we always used telnet (netcat) to connect to the server. Here we are 
+ * now writing our own program to do the connection.
+ *
+ * As you will see, when we run this after we start the server we will see the
+ * same string telnet printed, sent by the server. The output at the server will
+ * show different socket pairs for each time the loop iterates.
+ *
+ * @author mcgredo
+ * @author brutzman
+ */
+public class KeevenTCPExample3Client {
+
+    /** IPv6 String constant for localhost address, similarly IPv4 127.0.0.1
+     * @see <a href="https://en.wikipedia.org/wiki/localhost">https://en.wikipedia.org/wiki/localhost</a>
+     * @see <a href="https://en.wikipedia.org/wiki/IPv6_address">https://en.wikipedia.org/wiki/IPv6_address</a> 
+     */
+    public final static String LOCALHOST = "0:0:0:0:0:0:0:1";
+
+    /**
+     * Program invocation, execution starts here
+     * @param args command-line arguments
+     */
+    public static void main(String[] args)
+    {
+        
+        // Local variables/fields
+        Socket socket = null;
+        InputStream is;
+        Reader isr;
+        BufferedReader br;
+        String serverMessage;
+        int clientLoopCount = 0;
+        int numbLoops = 10;
+        
+        try {
+            while (clientLoopCount < numbLoops)
+            {
+                clientLoopCount++; // increment at beginning of loop for reliability
+                System.out.println(KeevenTCPExample3Client.class.getName() + " creating socket...");
+
+                // We request an IP to connect to ("localhost") and
+                // port number at that IP (2317). This establishes
+                // a connection to that IP in the form of a Socket
+                // object; the server uses a ServerSocket to wait for
+                // connections.
+                socket = new Socket(LOCALHOST, 2317); // locohost?
+
+                // Now hook everything up (i.e. set up the streams), Java style:
+                is  = socket.getInputStream();
+                isr = new InputStreamReader(is);
+                br  = new BufferedReader(isr);
+
+                // Read a single line written by the server. We'd
+                // do things a bit differently if there were many lines to be read
+                // from the server instead of one only.
+                serverMessage = br.readLine();
+                System.out.println("======================Assignment1===========================");
+                       
+                System.out.print  ("Client loop " + clientLoopCount + ": ");
+                System.out.println("now we're talking!");
+                System.out.println("The message the server sent was: '" + serverMessage + "'");
+                // socket gets closed, either automatically/silently by this code (or possibly by the server)
+                
+                Thread.sleep(800l); // slow things down, for example 500l (long) = 500 msec
+                
+            } // end while(true) // infinite loops are dangerous, be sure to kill this process!
+        } 
+        catch (IOException | InterruptedException e)
+        {
+            System.err.println("Problem with " + KeevenTCPExample3Client.class.getName() + " networking:"); // describe what is happening
+            System.err.println("Error: " + e);
+            
+            // Provide more helpful information to user if exception occurs due to running twice at one time
+            if (e instanceof java.net.BindException) {
+                System.err.println("*** Be sure to stop any other running instances of programs using this port!");
+            }
+        }
+        finally // occurs after any other activity when shutting down
+        {
+            try {
+                if (socket != null)
+                    socket.close();
+            } catch (IOException e) {}
+            
+            // program exit: tell somebody about that happening.  Likely cause: server drops connection.
+            System.out.println();
+            System.out.println(KeevenTCPExample3Client.class.getName() + " exit");
+        }
+    }
+}

assignments/src/MV3500Cohort2022MayJune/homework1/KeevenTCPExample3Server.java

+package MV3500Cohort2021JulySeptember.homework1;
+
+import java.io.*;
+import java.net.*;
+
+/**
+ * This is Assignment 1 where I have modified the given code from TCPExample3Server
+ *-server response message changed
+ * 
+ * Very slightly more complex than example1, further modifying example2. The
+ * only thing this does differently is introduce a loop into the response, so
+ * you don't have to restart the program after one response. Also, it prints out
+ * the socket pair the server sees. Run the program via telnet several times and
+ * compare the socket pairs.
+ *
+ * telnet (nc) localhost 2317
+ *
+ * If you're sophisticated you can contact the instructor's computer while
+ * running this program.
+ *
+ *      telnet (nc) [ipNumberOfServerLaptop] 2317
+ *
+ * and have the instructor display the socket pairs received.
+ *
+ * @author mcgredo
+ * @author brutzman
+ */
+public class KeevenTCPExample3Server {
+
+    /**
+     * Program invocation, execution starts here
+     * If already compiled, can run using console in directory ../../build/classes/ by invoking \
+     *      java -classpath . TcpExamples.TcpExample3Server
+     * @param args command-line arguments
+     */
+    public static void main(String[] args) {
+        try {
+            
+            // ServerSocket waits for a connection from a client. 
+            // Notice that it is outside the loop; ServerSocket
+            // needs to be made only once.
+            System.out.println(KeevenTCPExample3Server.class.getName() + " has started..."); // it helps debugging to put this on console first
+            
+            ServerSocket serverSocket = new ServerSocket(2317);
+            OutputStream os;
+            PrintStream ps;
+            InetAddress localAddress, remoteAddress;
+            int localPort, remotePort;
+            int serverLoopCount = 0;
+
+            // Server is up and waiting (i.e. "blocked" or paused)
+            // Loop, infinitely, waiting for client connections.
+            // Stop the program somewhere else.
+            while (true) { 
+                
+                // block until connected to a client
+                try (Socket clientConnectionSocket = serverSocket.accept())
+                {
+                    serverLoopCount++; // increment at beginning of loop for reliability
+                    
+                    // Now hook everything up (i.e. set up the streams), Java style:
+                    os = clientConnectionSocket.getOutputStream();
+                    ps = new PrintStream(os);
+                    ps.println("This is response " + serverLoopCount + " produced by the server, " 
+                            + KeevenTCPExample3Server.class.getName()); // this gets sent back to client!
+                    
+                    // Print some information locally about the Socket connection.
+                    // This includes the port and IP numbers on both sides (the socket pair).
+                     localAddress = clientConnectionSocket.getLocalAddress();
+                    remoteAddress = clientConnectionSocket.getInetAddress();
+                        localPort = clientConnectionSocket.getLocalPort();
+                       remotePort = clientConnectionSocket.getPort();
+                       
+                    System.out.print ("Server loop " + serverLoopCount + ": ");
+                    
+                    // My socket pair connection looks like this, to localhost:
+                    // Socket pair: (( /0:0:0:0:0:0:0:1, 2317 ), ( /0:0:0:0:0:0:0:1, 54876 ))
+                    // Socket pair: (( /0:0:0:0:0:0:0:1, 2317 ), ( /0:0:0:0:0:0:0:1, 54881 ))
+                    
+                    // Why is the first IP/port the same, while the second set has different ports?
+                    System.out.println(KeevenTCPExample3Server.class.getName() + " socket pair showing host name, address, port:");
+                    System.out.println("  (( " + 
+                         localAddress.getHostName() + "=" +  localAddress.getHostAddress() + ", " + localPort + " ), ( " + 
+                        remoteAddress.getHostName() + "=" + remoteAddress.getHostAddress() + ", " + remotePort + " ))");
+                    
+                    if ( localAddress.getHostName().equals( localAddress.getHostAddress()) ||
+                        remoteAddress.getHostName().equals(remoteAddress.getHostAddress()))
+                        System.out.println("  note HostName matches address if host has no DNS name");
+                    
+                    // Notice the use of flush() and try w/ resources. Without
+                    // the try w/ resources the Socket object may stay open for
+                    // a while after the client has stopped needing this
+                    // connection. try w/ resources explicitly ends the connection.
+                    ps.flush();
+                    // like it or not, you're outta here!
+                }
+            }
+        } catch (IOException e) {
+            System.err.println("Problem with " + KeevenTCPExample3Server.class.getName() + " networking: " + e);
+
+            // Provide more helpful information to user if exception occurs due to running twice at one time
+            if (e instanceof java.net.BindException) {
+                System.err.println("*** Be sure to stop any other running instances of programs using this port!");
+            }
+        }
+    }
+}

assignments/src/MV3500Cohort2022MayJune/homework1/LeckieTcpExample2.java

+package MV3500Cohort2021JulySeptember.homework1;
+
+import java.io.IOException;
+import java.io.OutputStream;
+import java.io.PrintStream;
+import java.net.InetAddress;
+import java.net.ServerSocket;
+import java.net.Socket;
+
+/**
+ * Very slightly more complex than example1. The only thing this does
+ * differently is introduce a loop into the response, so you don't
+ * have to restart the program after one response. Also, it prints
+ * out the socket pair the server sees. Run the program via telnet
+ * several times and compare the socket pairs.
+ * 
+ * <code>telnet localhost 2317</code>
+ * 
+ * If you're sophisticated you can contact the instructor's computer
+ * while running this program.
+ * 
+ * <code>telnet ipOfServersLaptop 2317</code>
+ * 
+ * And have that machine display the socket pairs received.
+ * @author mcgredo
+ * @author brutzman
+ * @author leckie
+ */
+public class LeckieTcpExample2 
+{
+    /**
+     * Program invocation, execution starts here
+     * @param args command-line arguments
+     */
+ public static void main(String[] args)
+    {
+        try
+        {
+            System.out.println("TcpExample2ConnectionCounting has started and is waiting for a connection.");
+            System.out.println("  help: https://savage.nps.edu/Savage/developers.html#telnet");
+            System.out.println("  enter (nc localhost 2317) or (telnet localhost 2317)..." );
+			
+            // ServerSocket waits for a connection from a client. 
+            // Notice that it is outside the loop; ServerSocket needs to be made only once.
+			
+            int connectionCount = 0; // state variable
+            int totalEntrantCount = 31; // spoofed entrants
+            
+            ServerSocket serverSocket = new ServerSocket(2317); // server decides here what port to listen on.
+			// of interest: often client doesn't care what port it uses locally when connecting to that server port.
+
+            // Loop, infinitely, waiting for client connections.
+            // Stop the program somewhere else.
+            while(true)
+            {
+                // blocks! then proceeds once a connection is "accept"ed
+                try (Socket clientConnection = serverSocket.accept()) {
+                    connectionCount++; // got another one!
+                    
+                    OutputStream os = clientConnection.getOutputStream();
+                    PrintStream ps = new PrintStream(os);
+                    
+                    ps.println("This client response was written by server " + LeckieTcpExample2.class.getName()); // to remote client
+                    System.out.println("This server response was written by server " + LeckieTcpExample2.class.getName()); // to server console
+                    
+                            ps.println("This is your lottery attempt number #" + connectionCount + ", you are aplicant number " + totalEntrantCount + " to try and win. Keep trying!");
+                    
+                    totalEntrantCount = (totalEntrantCount + 79);
+                    // Print some information locally about the Socket connection.
+                    // This includes the port and IP numbers on both sides (the socket pair.)
+                    
+                    InetAddress  localAddress = clientConnection.getLocalAddress();
+                    InetAddress remoteAddress = clientConnection.getInetAddress();
+                    
+                    int  localPort = clientConnection.getLocalPort();
+                    int remotePort = clientConnection.getPort();       // remember the prior question, why are 2 ports different?
+                    
+                    // My socket pair connection looks like this, to localhost:
+                    // Socket pair: (( /0:0:0:0:0:0:0:1, 2317 ), ( /0:0:0:0:0:0:0:1, 54876 )) note IPv6
+                    // Socket pair: (( /0:0:0:0:0:0:0:1, 2317 ), ( /0:0:0:0:0:0:0:1, 54881 ))
+                    //
+                    // Why is first IP/port the same, while the second set has different ports?
+                    
+                    System.out.println("Socket pair: (( " + localAddress.toString() + ", " + localPort + " ), ( " +
+                            remoteAddress.toString() + ", " + remotePort + " ))");
+                    
+                    System.out.println("got another connection, #" + connectionCount); // report progress
+                    
+                    // Notice the use of flush() and close(). Without
+                    // the close() to Socket object may stay open for
+                    // a while after the client has stopped needing this
+                    // connection. Close() explicitly ends the connection.
+                    ps.flush();
+                }
+            }
+       }
+        catch(IOException e)
+        {
+            System.err.println("Problem with  " + LeckieTcpExample2.class.getName() + " networking:"); // describe what is happening
+            System.err.println("Error: " + e);
+            // Provide more helpful information to user if exception occurs due to running twice at one time
+            if (e instanceof java.net.BindException)
+                System.err.println("*** Be sure to stop any other running instances of programs using this port!");
+        }
+    }
+    
+}

assignments/src/MV3500Cohort2022MayJune/homework1/McNeelyTCPExample2.java

+package MV3500Cohort2021JulySeptember.homework1;
+
+import java.io.IOException;
+import java.io.OutputStream;
+import java.io.PrintStream;
+import java.net.InetAddress;
+import java.net.ServerSocket;
+import java.net.Socket;
+
+/**
+ * Very slightly more complex than example1. The only thing this does
+ * differently is introduce a loop into the response, so you don't
+ * have to restart the program after one response. Also, it prints
+ * out the socket pair the server sees. Run the program via telnet
+ * several times and compare the socket pairs.
+ * 
+ * <code>telnet localhost 2317</code>
+ * 
+ * If you're sophisticated you can contact the instructor's computer
+ * while running this program.
+ * 
+ * <code>telnet ipOfServersLaptop 2317</code>
+ * 
+ * And have that machine display the socket pairs received.
+ * @author mcgredo
+ * @author brutzman
+ * @author McNeely
+ */
+public class McNeelyTCPExample2
+{
+    /** run the program
+     * @param args command-line arguments, string parameters (unused) */
+    public static void main(String[] args)
+    {
+        try
+        {
+            System.out.println("Justin McNeely's TcpExample2 has started and is waiting for a connection...");
+            System.out.println("  help: https://savage.nps.edu/Savage/developers.html#telnet");
+            System.out.println("  enter (nc localhost 2317) or (telnet localhost 2317) to win..." );
+			
+            // ServerSocket waits for a connection from a client. 
+            // Notice that it is outside the loop; ServerSocket needs to be made only once.
+			
+            int connectionCount = 0; // state variable
+            int totalEntrantCount = 31; // spoofed entrants
+            
+            ServerSocket serverSocket = new ServerSocket(2317); // server decides here what port to listen on.
+			// of interest: often client doesn't care what port it uses locally when connecting to that server port.
+
+            // Loop, infinitely, waiting for client connections.
+            // Stop the program somewhere else.
+            while(true)
+            {
+                // blocks! then proceeds once a connection is "accept"ed
+                try (Socket clientConnection = serverSocket.accept()) {
+                    connectionCount++; // got another one!
+                    
+                    OutputStream os = clientConnection.getOutputStream();
+                    PrintStream ps = new PrintStream(os);
+                    
+                    ps.println("This client response was written by server " + McNeelyTCPExample2.class.getName()); // to remote client
+                    System.out.println("This server response was written by server " + McNeelyTCPExample2.class.getName()); // to server console
+                    
+                            ps.println("You have attempted " + connectionCount + " times, you are now aplicant number " + totalEntrantCount + " to win. Keep trying!");
+                    
+                    totalEntrantCount = (totalEntrantCount + 24);
+                    // Print some information locally about the Socket connection.
+                    // This includes the port and IP numbers on both sides (the socket pair.)
+                    
+                    InetAddress  localAddress = clientConnection.getLocalAddress();
+                    InetAddress remoteAddress = clientConnection.getInetAddress();
+                    
+                    int  localPort = clientConnection.getLocalPort();
+                    int remotePort = clientConnection.getPort();       // remember the prior question, why are 2 ports different?
+                    
+                    // My socket pair connection looks like this, to localhost:
+                    // Socket pair: (( /0:0:0:0:0:0:0:1, 2317 ), ( /0:0:0:0:0:0:0:1, 54876 )) note IPv6
+                    // Socket pair: (( /0:0:0:0:0:0:0:1, 2317 ), ( /0:0:0:0:0:0:0:1, 54881 ))
+                    //
+                    // Why is first IP/port the same, while the second set has different ports?
+                    
+                    System.out.println("Socket pair: (( " + localAddress.toString() + ", " + localPort + " ), ( " +
+                            remoteAddress.toString() + ", " + remotePort + " ))");
+                    
+                    System.out.println("got another connection! WINNING!, #" + connectionCount); // report progress
+                    
+                    // Notice the use of flush() and close(). Without
+                    // the close() to Socket object may stay open for
+                    // a while after the client has stopped needing this
+                    // connection. Close() explicitly ends the connection.
+                    ps.flush();
+                }
+            }
+       }
+        catch(IOException e)
+        {
+            System.err.println("Problem with  " + McNeelyTCPExample2.class.getName() + " networking:"); // describe what is happening
+            System.err.println("Error: " + e);
+            // Provide more helpful information to user if exception occurs due to running twice at one time
+            if (e instanceof java.net.BindException)
+                System.err.println("*** Be sure to stop any other running instances of programs using this port!");
+        }
+    }
+    
+}

assignments/src/MV3500Cohort2022MayJune/homework1/MorrisTcpExample1Telnet.java

+package MV3500Cohort2021JulySeptember.homework1;;
+
+import java.io.*;
+import java.net.*;
+
+/**
+ * The simplest possible TCP network program. It listens for
+ * a connection, from telnet (telnet localhost 2317) or a program
+ * you write, which we will do later. Right now the TcpExample simply
+ * writes a string in response to a connection.
+ * 
+ * Modifying his program is the basis for Assignment 1.
+ * 
+ * Testing the running server program from telnet looks like this:
+ * 
+ * it154916:projects mcgredo$ telnet localhost 2317
+ * Trying ::1...
+ * Connected to localhost.
+ * Escape character is '^]'.
+ * This was written by the server
+ * Connection closed by foreign host.
+ * 
+ * Notice that "This was written by the server" matches 
+ * what is written by the code below, over the output stream.
+ * 
+ * After this first connection the program below drops out
+ * the bottom of the program, and does not repeat itself.
+ * The program exits.
+ * 
+ * @author mcgredo
+ * @author brutzman
+ */
+public class MorrisTcpExample1Telnet 
+{
+    /**
+     * Program invocation, execution starts here
+     * @param args command-line arguments
+     */
+    public static void main(String[] args)
+    {
+        try
+        {
+            System.out.println("TcpExample1Telnet  has started and is waiting for a connection.");
+            System.out.println("  help: https://savage.nps.edu/Savage/developers.html#telnet");
+            System.out.println("  enter (telnet localhost 2317) or (nc localhost 2317)..." );
+			
+            // The ServerSocket waits for a connection from a client.
+            // It returns a Socket object when the connection occurs.
+            ServerSocket serverSocket = new ServerSocket(2317);
+            
+            // Use Java io classes to write text (as opposed to
+            // unknown bytes of some sort) to the client
+            
+            // The Socket object represents the connection between
+            // the server and client, including a full duplex connection
+            try (Socket clientConnection = serverSocket.accept()) // wait here for a client to connect
+            {
+                // OK we got something, time to respond!
+                // Use Java io classes to write text (as opposed to
+                // unknown bytes of some sort) to the client
+                OutputStream os = clientConnection.getOutputStream();
+                PrintStream ps = new PrintStream(os);
+                
+                        ps.println("This client response was written by Johnny Smiles ");  // to remote client
+                        ps.println("MOVES 2021 Cohort is full of badassery.");
+                System.out.println("This server response was written by Johnny Smiles " ); // to server console
+
+                // "flush()" in important in that it forces a write
+                // across what is in fact a slow connection
+                ps.flush();
+            }
+            System.out.println(" completed successfully.");
+        }
+        catch(IOException e)
+        {
+            System.err.println(" Pardon the interruption, networking issue"); // describe what is happening
+            System.err.println(e);
+            // Provide more helpful information to user if exception occurs due to running twice at one time
+            
+            // brute force exception checking, can be brittle if exception message changes
+            // if (e.getMessage().equals("Address already in use: NET_Bind")) 
+            if (e instanceof java.net.BindException)
+                System.err.println("*** Be sure to stop any other running instances of programs using this port!");
+        }
+    }
+}

assignments/src/MV3500Cohort2022MayJune/homework1/PughTcp2ConnectionCounting.java

+package MV3500Cohort2021JulySeptember.homework1;
+
+import java.io.*;
+import java.net.*;
+
+/**
+ * Very slightly more complex than example1. The only thing this does
+ * differently is introduce a loop into the response, so you don't have to
+ * restart the program after one response. Also, it prints out the socket pair
+ * the server sees. Run the program via telnet several times and compare the
+ * socket pairs.
+ *
+ * <code>telnet localhost 2317</code>
+ *
+ * If you're sophisticated you can contact the instructor's computer while
+ * running this program.
+ *
+ * <code>telnet ipOfServersLaptop 2317</code>
+ *
+ * And have that machine display the socket pairs received.
+ *
+ * @author pugh
+ * @author brutzman
+ */
+public class PughTcp2ConnectionCounting {
+
+    /**
+     * Program invocation, execution starts here
+     *
+     * @param args command-line arguments
+     */
+    public static void main(String[] args) {
+        try {
+            System.out.println("TcpExample2ConnectionCounting has started and is waiting for a connection.");
+            System.out.println("Get Ready To Network!!!");
+            System.out.println("  help: https://savage.nps.edu/Savage/developers.html#telnet");
+            System.out.println("  enter (nc localhost 2317) or (telnet localhost 2317)...");
+
+            // ServerSocket waits for a connection from a client. 
+            // Notice that it is outside the loop; ServerSocket needs to be made only once.
+            int connectionCount = 0; // state variable
+
+            ServerSocket serverSocket = new ServerSocket(2317); // server decides here what port to listen on.
+            // of interest: often client doesn't care what port it uses locally when connecting to that server port.
+
+            // Loop, infinitely, waiting for client connections.
+            // Stop the program somewhere else.
+            while (true) {
+                // blocks! then proceeds once a connection is "accept"ed
+                try ( Socket clientConnection = serverSocket.accept()) {
+                    
+
+                    OutputStream os = clientConnection.getOutputStream();
+                    PrintStream ps = new PrintStream(os);
+
+                    ps.println("This client response was written by server " + PughTcp2ConnectionCounting.class.getName()); // to remote client
+                    System.out.println("This server response was written by server " + PughTcp2ConnectionCounting.class.getName() + "\n"); // to server console
+                    if (connectionCount % 2 == 1) {
+                        System.out.println("Go\n");
+                    }
+                    if (connectionCount % 2 == 0 && connectionCount % 3 == 1) {
+                        System.out.println("Gators!");
+                    }
+                    if (connectionCount % 3 == 1 && connectionCount != 0) {
+                        System.out.println("O'Doyle Rules!!!");
+                    }
+                    ps.println("You were connection #" + connectionCount + ", by my count");
+
+                    // Print some information locally about the Socket connection.
+                    // This includes the port and IP numbers on both sides (the socket pair.)
+                    InetAddress localAddress = clientConnection.getLocalAddress();
+                    InetAddress remoteAddress = clientConnection.getInetAddress();
+
+                    int localPort = clientConnection.getLocalPort();
+                    int remotePort = clientConnection.getPort();       // remember the prior question, why are 2 ports different?
+
+                    // My socket pair connection looks like this, to localhost:
+                    // Socket pair: (( /0:0:0:0:0:0:0:1, 2317 ), ( /0:0:0:0:0:0:0:1, 54876 )) note IPv6
+                    // Socket pair: (( /0:0:0:0:0:0:0:1, 2317 ), ( /0:0:0:0:0:0:0:1, 54881 ))
+                    //
+                    // Why is first IP/port the same, while the second set has different ports?
+                    System.out.println("Socket pair: (( " + localAddress.toString() + ", " + localPort + " ), ( "
+                            + remoteAddress.toString() + ", " + remotePort + " ))");
+
+                    System.out.println("got another connection, #" + connectionCount); // report progress
+
+                    // Notice the use of flush() and close(). Without
+                    // the close() to Socket object may stay open for
+                    // a while after the client has stopped needing this
+                    // connection. Close() explicitly ends the connection.
+                    ps.flush();
+                    connectionCount++; // got another one!
+                }
+            }
+        } catch (IOException e) {
+            System.err.println("Problem with  " + PughTcp2ConnectionCounting.class.getName() + " networking:"); // describe what is happening
+            System.err.println("Error: " + e);
+            // Provide more helpful information to user if exception occurs due to running twice at one time
+            if (e instanceof java.net.BindException) {
+                System.err.println("*** Be sure to stop any other running instances of programs using this port!");
+            }
+        }
+    }
+}

assignments/src/MV3500Cohort2022MayJune/homework1/README.md

+## Homework 1: Unicast Networking
+
+Welcome everybody! This is where your homework goes.
+
+Deliverables:
+
+* Update unicast sockets sender/receiver, modifying provided code, test via telnet.
+* Demonstrate ability to build, run and document Java programs that perform networking tasks.
+
+Please see the [README.md](../../../README.md) in the parent
+[assignments](../../../../assignments) directory for detailed instructions.

assignments/src/MV3500Cohort2022MayJune/homework1/ReynoldsTcpExample1Telnet1.java

+package MV3500Cohort2021JulySeptember.homework1;
+
+
+import java.io.IOException;
+import java.io.OutputStream;
+import java.io.PrintStream;
+import java.net.ServerSocket;
+import java.net.Socket;
+
+/**
+ * homework assignment
+ * @author kReynolds
+ */
+
+
+public class ReynoldsTcpExample1Telnet1
+{
+    /** run the program
+     * @param args command-line arguments, string parameters (unused) */
+    public static void main(String[] args) 
+    {
+        try
+        {
+            System.out.println("TcpExample1Telnet has started and is waiting for a connection.");
+            System.out.println("  help: https://savage.nps.edu/Savage/developers.html#telnet");
+            System.out.println("  enter (telnet localhost 2317) or (nc localhost 2317)... \n" );
+			
+            // The ServerSocket waits for a connection from a client.
+            // It returns a Socket object when the connection occurs.
+            ServerSocket serverSocket = new ServerSocket(2317);
+            
+            // Use Java io classes to write text (as opposed to
+            // unknown bytes of some sort) to the client
+            
+            // The Socket object represents the connection between
+            // the server and client, including a full duplex connection
+            try (Socket clientConnection = serverSocket.accept()) {
+                // Use Java io classes to write text (as opposed to
+                // unknown bytes of some sort) to the client
+                OutputStream os = clientConnection.getOutputStream();
+                PrintStream ps = new PrintStream(os);
+                
+                ps.println("Initiating Client-side handshake... \n"); // to remote clientnc
+                ps.println("Requesting authentication...");
+                ps.println("Authentication granted \n");
+                
+                ps.println("Secret message sent to host \n");
+                ps.println("Disconnecting from host...");
+                
+                System.out.println("Conducting server-side handshake..."); // to server console
+                System.out.println("Granting authentication \n");
+                
+                System.out.println("Secret message recieved from client...");
+                System.out.println("Client sent 'hello' message \n");
+                System.out.println("Disconnecting connection to client... \n");
+
+                // "flush()" in important in that it forces a write
+                // across what is in fact a slow connection
+                ps.flush();
+            }
+            System.out.println("TcpExample1 completed successfully.");
+        }
+        catch(IOException e)
+        {
+            System.err.println("Problem with TcpExample1Telnet networking:"); // describe what is happening
+            System.err.println("Error: " + e);
+            // Provide more helpful information to user if exception occurs due to running twice at one time
+            
+            // brute force exception checking, can be brittle if exception message changes
+            // if (e.getMessage().equals("Address already in use: NET_Bind")) 
+            if (e instanceof java.net.BindException)
+                System.err.println("*** Be sure to stop any other running instances of programs using this port!");
+        }
+    }
+}

assignments/src/MV3500Cohort2022MayJune/homework1/RobinsonTcpExample1Telnet.java

+package MV3500Cohort2021JulySeptember.homework1;
+
+import java.io.IOException;
+import java.io.OutputStream;
+import java.io.PrintStream;
+import java.net.ServerSocket;
+import java.net.Socket;
+
+/**
+ * homework assignment
+ * @author mrobi
+ */
+public class RobinsonTcpExample1Telnet
+{
+    /** run the program
+     * @param args command-line arguments, string parameters (unused) */
+    public static void main(String[] args) 
+    {
+        try
+        {
+            System.out.println("TcpExample1Telnet has started and is waiting for a connection.");
+            System.out.println("  help: https://savage.nps.edu/Savage/developers.html#telnet");
+            System.out.println("  enter (telnet localhost 2317) or (nc localhost 2317)..." );
+			
+            // The ServerSocket waits for a connection from a client.
+            // It returns a Socket object when the connection occurs.
+            ServerSocket serverSocket = new ServerSocket(2317);
+            
+            // Use Java io classes to write text (as opposed to
+            // unknown bytes of some sort) to the client
+            
+            // The Socket object represents the connection between
+            // the server and client, including a full duplex connection
+            try (Socket clientConnection = serverSocket.accept()) {
+                // Use Java io classes to write text (as opposed to
+                // unknown bytes of some sort) to the client
+                OutputStream os = clientConnection.getOutputStream();
+                PrintStream ps = new PrintStream(os);
+                
+                ps.println("Client response was written by Matt's server TcpExample1."); // to remote clientnc
+                ps.println("Can you hear me?");
+                System.out.println("Client response was written by Matt's server TcpExample1."); // to server console
+                System.out.println("Yes");
+
+                // "flush()" in important in that it forces a write
+                // across what is in fact a slow connection
+                ps.flush();
+            }
+            System.out.println("TcpExample1 completed successfully.");
+        }
+        catch(IOException e)
+        {
+            System.err.println("Problem with FisherTCPExample1Telnet networking:"); // describe what is happening
+            System.err.println("Error: " + e);
+            // Provide more helpful information to user if exception occurs due to running twice at one time
+            
+            // brute force exception checking, can be brittle if exception message changes
+            // if (e.getMessage().equals("Address already in use: NET_Bind")) 
+            if (e instanceof java.net.BindException)
+                System.err.println("*** Be sure to stop any other running instances of programs using this port!");
+        }
+    }
+}

assignments/src/MV3500Cohort2022MayJune/homework1/SchlesselTcpExample1Telnet.java

+package MV3500Cohort2021JulySeptember.homework1;
+
+import java.io.*;
+import java.net.*;
+
+/**
+ * Homework 1
+ * 
+ * @author max schlessel
+ */
+public class SchlesselTcpExample1Telnet 
+{
+    /**
+     * Program invocation, execution starts here
+     * @param args command-line arguments
+     */
+    public static void main(String[] args)
+    {
+        try
+        {
+            System.out.println(SchlesselTcpExample1Telnet.class.getName() + " has started and is waiting for a connection.");
+            System.out.println("  help: https://savage.nps.edu/Savage/developers.html#telnet");
+            System.out.println("  enter (telnet localhost 2317) or (nc localhost 2317)..." );
+			
+            // The ServerSocket waits for a connection from a client.
+            // It returns a Socket object when the connection occurs.
+            ServerSocket serverSocket = new ServerSocket(2317);
+            
+            // Use Java io classes to write text (as opposed to
+            // unknown bytes of some sort) to the client
+            
+            // The Socket object represents the connection between
+            // the server and client, including a full duplex connection
+            try (Socket clientConnection = serverSocket.accept()) // wait here for a client to connect
+            {
+                // OK we got something, time to respond!
+                // Use Java io classes to write text (as opposed to
+                // unknown bytes of some sort) to the client
+                OutputStream os = clientConnection.getOutputStream();
+                PrintStream ps = new PrintStream(os);
+                
+                        ps.println("This client response was written by Max's client " + SchlesselTcpExample1Telnet.class.getName()); // to remote client
+                        ps.println("aka the shot heard round the world");
+                System.out.println("This server response was written by Max's server " + SchlesselTcpExample1Telnet.class.getName()); // to server console
+                System.out.println("boom");
+
+                // "flush()" in important in that it forces a write
+                // across what is in fact a slow connection
+                ps.flush();
+            }
+            System.out.println(SchlesselTcpExample1Telnet.class.getName() + " completed successfully.");
+        }
+        catch(IOException e)
+        {
+            System.err.println("Exception with " + SchlesselTcpExample1Telnet.class.getName() + " networking:"); // describe what is happening
+            System.err.println(e);
+            // Provide more helpful information to user if exception occurs due to running twice at one time
+            
+            // brute force exception checking, can be brittle if exception message changes
+            // if (e.getMessage().equals("Address already in use: NET_Bind")) 
+            if (e instanceof java.net.BindException)
+                System.err.println("*** Be sure to stop any other running instances of programs using this port!");
+        }
+    }
+}

assignments/src/MV3500Cohort2022MayJune/homework1/TcpExample2_Leckie_Mod_Hw1.java

+package MV3500Cohort2021JulySeptember.homework1;
+
+import java.io.IOException;
+import java.io.OutputStream;
+import java.io.PrintStream;
+import java.net.InetAddress;
+import java.net.ServerSocket;
+import java.net.Socket;
+
+/**
+ * Very slightly more complex than example1. The only thing this does
+ * differently is introduce a loop into the response, so you don't
+ * have to restart the program after one response. Also, it prints
+ * out the socket pair the server sees. Run the program via telnet
+ * several times and compare the socket pairs.
+ * 
+ * <code>telnet localhost 2317</code>
+ * 
+ * If you're sophisticated you can contact the instructor's computer
+ * while running this program.
+ * 
+ * <code>telnet ipOfServersLaptop 2317</code>
+ * 
+ * And have that machine display the socket pairs received.
+ * @author mcgredo
+ * @author brutzman
+ * @author leckie
+ */
+public class TcpExample2_Leckie_Mod_Hw1 
+{
+    /**
+     * Program invocation, execution starts here
+     * @param args command-line arguments
+     */
+ public static void main(String[] args)
+    {
+        try
+        {
+            System.out.println("TcpExample2ConnectionCounting has started and is waiting for a connection.");
+            System.out.println("  help: https://savage.nps.edu/Savage/developers.html#telnet");
+            System.out.println("  enter (nc localhost 2317) or (telnet localhost 2317)..." );
+			
+            // ServerSocket waits for a connection from a client. 
+            // Notice that it is outside the loop; ServerSocket needs to be made only once.
+			
+            int connectionCount = 0; // state variable
+            int totalEntrantCount = 31; // spoofed entrants
+            
+            ServerSocket serverSocket = new ServerSocket(2317); // server decides here what port to listen on.
+			// of interest: often client doesn't care what port it uses locally when connecting to that server port.
+
+            // Loop, infinitely, waiting for client connections.
+            // Stop the program somewhere else.
+            while(true)
+            {
+                // blocks! then proceeds once a connection is "accept"ed
+                try (Socket clientConnection = serverSocket.accept()) {
+                    connectionCount++; // got another one!
+                    
+                    OutputStream os = clientConnection.getOutputStream();
+                    PrintStream ps = new PrintStream(os);
+                    
+                    ps.println("This client response was written by server " + TcpExample2_Leckie_Mod_Hw1.class.getName()); // to remote client
+                    System.out.println("This server response was written by server " + TcpExample2_Leckie_Mod_Hw1.class.getName()); // to server console
+                    
+                            ps.println("This is your lottery attempt number #" + connectionCount + ", you are applicant number " + totalEntrantCount + " to try and win. Keep trying!");
+                    
+                    totalEntrantCount = (totalEntrantCount + 79);
+                    // Print some information locally about the Socket connection.
+                    // This includes the port and IP numbers on both sides (the socket pair.)
+                    
+                    InetAddress  localAddress = clientConnection.getLocalAddress();
+                    InetAddress remoteAddress = clientConnection.getInetAddress();
+                    
+                    int  localPort = clientConnection.getLocalPort();
+                    int remotePort = clientConnection.getPort();       // remember the prior question, why are 2 ports different?
+                    
+                    // My socket pair connection looks like this, to localhost:
+                    // Socket pair: (( /0:0:0:0:0:0:0:1, 2317 ), ( /0:0:0:0:0:0:0:1, 54876 )) note IPv6
+                    // Socket pair: (( /0:0:0:0:0:0:0:1, 2317 ), ( /0:0:0:0:0:0:0:1, 54881 ))
+                    //
+                    // Why is first IP/port the same, while the second set has different ports?
+                    
+                    System.out.println("Socket pair: (( " + localAddress.toString() + ", " + localPort + " ), ( " +
+                            remoteAddress.toString() + ", " + remotePort + " ))");
+                    
+                    System.out.println("got another connection, #" + connectionCount); // report progress
+                    
+                    // Notice the use of flush() and close(). Without
+                    // the close() to Socket object may stay open for
+                    // a while after the client has stopped needing this
+                    // connection. Close() explicitly ends the connection.
+                    ps.flush();
+                }
+            }
+       }
+        catch(IOException e)
+        {
+            System.err.println("Problem with  " + TcpExample2_Leckie_Mod_Hw1.class.getName() + " networking:"); // describe what is happening
+            System.err.println("Error: " + e);
+            // Provide more helpful information to user if exception occurs due to running twice at one time
+            if (e instanceof java.net.BindException)
+                System.err.println("*** Be sure to stop any other running instances of programs using this port!");
+        }
+    }
+    
+}