Network Programming

Introduction: Network Protocols

• Layered stack of protocol standards
  • HTTP | FTP | SMTP | NNTP
  • TCP | UDP
  • IP Layer -- packet routing
  • Transport layer (Etherner, PPP)
• Transport layer - point to point delivery of packets, over single network.
• Internet Protocol Layer : Internet packet transport.
  • Deals with routing packets though connected networks to final destination.
  • Supports Internet addressing scheme, 4 byte addresses
  • Not reliable. No packet delivery guarantees
• TCP
  • Implements reliable stream semantics (usually on top of IP)
  • Resends dropped packets, deals with buffering, timeouts.

Sockets

• Sockets are a common abstraction for dealing with TCP connections. Originally developed at Berkeley for UNIX, now supported by Windows, Linux, Java.
• Client/server paradigm
  • Client - opens a connection to remote application
  • Server - listens for open requests from clients. Completes connection and services client.
• Once connection is established either side can send data (full duplex connection).

Internet Addresses

• Client refers to remote application through hostname:port pair.
• Hostname
  • Internet addresses: 4-byte addresses usually represented as dotted tuple eg. 205.0.20.1
  • Address 127.0.0.1 is special loopback address. Always refers to host machine
  • Domain addresses: familiar dotted strings. Resolved to IP addresses through DNS service and protocol. Domain names registered by a number of conpanies.
  • Port number. Small integer indicating application. By convention, standard application listen on standard ports. Ex HTTP on port 80, telnet on port 25. Ports under 1000 require root premission on UNIX.

Java Sockets

• Java Implementation of Sockets. Somewhat easier to use use than the usual C interface. Hides many details.
• As always, implemented with objects
  • Socket - Basic connection object
  • ServerSocket object - server side listener

Client-side programming

• Ex:

  Socket s = new Socket("www.arsdigita.com",80);
  

• Translates domain name to IP address.
• Attempts to open connection. Throws exception on error.
• Application must catch exceptions. What can go wrong:
  • No IP address for domain names
  • Connection refused
  • Connection request times out, host doesn't respond.
  • Depends on host OS for timeout params, network services
• Constructors block until connection completes or times out. If responsiveness is important. Use separate thread to establish connection.
• Once socket is established, use getInputStream(), getOutputStream() to get stream objects. These connect with the normal I/O stream zoo.
• Use setTimeout() to set connection timeouts.

Network Protocols

• There are a variety of paradigms for network programming and applications. A discussion of network architecures and distributed programming is outside the scope of this lecture. It is, howver, worth mentioning one paradigm common on the Internet: client-server applications
• In a client-server architecture, server machines perform the main application functions, maintain the database, perform transactions, etc. Client processes connect to the server machines and make requests or issues commands to the server. Typically the client manages the user interface. Most of the common internet applications fall into this catagory. For example, the Web, News, FTP, and networked file systems, are all client server architecture. [Note: Client-server means different things to different people. Some would reserve it for system with a specialized and complex client and would disagree that Web applications are examples of client-server architectures. They are entitles to their opinion.]
• In order for any network application to succeed, the programs involved, whether clients or servers must communicate in some way. This communication standard or "protocol" is generally published and represents the external interface of the clients and servers over the network. It is an interface in the sense that it specifes the behavior of the client and server independent of their implementation.
• Netowkr protocols differ from the types of interface we have seen in Java in that they are not defined in terms of method calls, but in terms of messages.
• A typical network protocol consists of a set of transactions or operations that the protocol will support. Each operation is broken down into a sequence of messages sent between the interacting computers. The protocol specification shoudl describe in detail the sequence, usage, and format of each of these messages.
• Message formats can be binary or text. In a binary format, the protocol specification must describe the content and meaning of each byte send over the network.
• Many of the common Internet protocols are text-based including HTTP, the protocol behind the Web.
• Netowrk protocols for internet application are usual published as RFC's (Request for Comment). Many of these were developed by individuals or small groups in the early days of the internal. Increasingly, for better or worse, international standards bodies are responsible for developing protocols.
• Below is an example of an interaction between client and server using the protocol behind Usenet News. The protocol is known as NNTP, Network News Transfer Protocol. (RFC 977). Each line following the C: or S: represents exactly what the client or server sends over the network. (Port 119 is the standard port for NNTP service.)

                      S:      (listens at TCP port 119)
  
                      C:      (requests connection on TCP port 119)
                      S:      200 wombatvax news server ready - posting ok
  
                      (client asks for a current newsgroup list)
                      C:      LIST
                      S:      215 list of newsgroups follows
                      S:      net.wombats 00543 00501 y
                      S:      net.unix-wizards 10125 10011 y
                              (more information here)
                      S:      net.idiots 00100 00001 n
                      S:      .
  
                      (client selects a newsgroup)
                      C:      GROUP net.unix-wizards
                      S:      211 104 10011 10125 net.unix-wizards group selected
                              (there are 104 articles on file, from 10011 to 10125)
  
                      (client selects an article to read)
                      C:      STAT 10110
                      S:      223 10110 <23445@sdcsvax.ARPA> article retrieved - statistics
                              only (article 10110 selected, its message-id is
                              <23445@sdcsvax.ARPA>)
  
                      (client examines the header)
                      C:      HEAD
                      S:      221 10110 <23445@sdcsvax.ARPA> article retrieved - head
                              follows (text of the header appears here)
                      S:      .
  
                      (client wants to see the text body of the article)
                      C:      BODY
                      S:      222 10110 <23445@sdcsvax.ARPA> article retrieved - body
                              follows (body text here)
                      S:      .
  
                      (client selects next article in group)
  
                      C:      NEXT
                      S:      223 10113 <21495@nudebch.uucp> article retrieved - statistics
                              only (article 10113 was next in group)
  
                      (client finishes session)
                      C:      QUIT
                      S:      205 goodbye.
  

• Other common Internet protocols (with application, RFC, and default port) are:
  • HTTP - WWW protocol - RFC2068 - port 80
  • NNTP - Net News - RFC977 - port 119
  • SMTP - mail transfer - RFC821 - port 25
  • FTP - file transfer - RFC959 - port 21
  • Telnet - remote connection - RFC854 - 23
  • Finger - system users info - RFC 1288 - port 79
• HTTP servers usually operate on port 80. To access a file on an HTTP server, a program opens a socket on port 80 then sends the line

  GET /path/to/file.html HTTP/1.0
  followed by 2 newline characters '\n'. (Of course /path/to/file.html is
  the actual file path including any query string info).
   Below is a sample program that requests a page from a site and path
  specified on the command line.
  import java.io.*;
  import java.net.*;
  class Download{
  
      public static void main(String[] args){
  	Socket s = null;
  	PrintWriter fout;
  	BufferedReader fin;
  	try{
  	    s = new Socket(args[0],80);
  	    System.out.println("connected");
  	    fout = new PrintWriter(
                          new OutputStreamWriter(s.getOutputStream()));
  	    fin = new BufferedReader(
                        new InputStreamReader(s.getInputStream()));
  	    String path = "GET " + args[1] +  " HTTP/1.0\n\n";
  	    // send GET
  	    fout.print(path);
  	    // Must flush or command never gets sent!!
  	    fout.flush();
  	    //read response
  	    String line;
  	    System.out.println("sent request");
  	    while((line = fin.readLine()) != null){
  		System.out.println(line);
  	    }
  	    s.close();
  	}
  	catch(IOException e){
  	    System.out.println("Cannot connect");
  	}
      }
  
  }
  
   Server-side programming
  Programming the server-side of a socket app is a little different if
  just as straightforward. The server listens on a port until some client
  makes a connection. It then accepts the connection (in the form of a socket).
  The normal Input and Output streams are set up and communication can
  commence.
  
  Ex: 
  // Create listener on port 2000
  ServerSocket ss = new ServerSocket(2000);
  // Starts listening on server socket. THis call block until a client
  //  connects. It returns with the connected socket. The server socket
  //  remains alive, but will not accept more connections until another 
  //  call to accept().
  Socket s = ss.accept();
  // get Input and Output streams on s, and perform server app.
  
  
  
   ServerSocket stops listening after accept() returns.
   If server want to service more than one connection, use separate
  thread to call accept() on ServerSocket. Create new thread for each
  established connection. Original thread should call accept() again
  and wait for new connection.
  
  InetAddress class
  Java provides a useful class for dealing with Internet Addresses. This class
  has methods to convert from domain names to IP addresses and back. It can
  also be used to get the local host address.
  
  Below is a short program which prints out the host name and IP address
  of the machine on which it is run. 
  import java.io.*;
  import java.net.*;
  
  class MyAddr{
  
      public static void main(String[] args){
  	try{
  	    InetAddress in = InetAddress.getLocalHost();
  	    System.out.println(in.getHostName());
  	    System.out.println(in.getHostAddress());
  	}
  	catch(IOException e){
  	}
      }
  
  }
  
  URL support classes