Network Architecture

Last week, we described how networks need to provide general, cost-effective, fair, robost connectivity among a large number of computers.
They also must be able to evolve to handle changing technologies.
To help organize the problem of creating such networks, designers use general blueprints called network architectures to help guide the design and implementation of networks.
We will now spend a moment to look at some of these architectures in more detail.

Layering Protocols

To decompose the problem of building a network into manageable components, we split the network into layers, each of which is designed to handle some particular aspect of network communication.
The abstract objects that make up the layers of a network system are called: protocols.
Lower layers will provide services to higher layers through a service interface. For example, a request/reply protocol would support operations by which an application can send and receive messages.
A protocol defines a peer interface on another machine. This is the interface through which the same layer on two different machines communicate.

Except at the hardware level where peers directly communicate with each other over a link, peer-to-peer communication is indirect -- each protocol communicates with its peer by passing messages to some lower-level protocol, which in turn delivers the message to its peer.
There might be more that one protocol at a given level. For instance, request/reply protocol, message stream protocol.
We therefore represent the suites of protocols that make up a network system with a protocol graph. Edges in the graph represent depends on relations.

Which of the following is most commonly used to connect several independent networks?

In the protocol graph slide, we assume the RRP protocol does not know anything about the data given to it by a File Application or Digital Library Application.
So it gets an uninterpreted string of bytes.
In order to tell its peer RRP process what to do with the message it prepends a few byte data structure called a header in front of the message. Sometimes one also appends a data structure called a trailer.
The rest of the message excluding headers and trailers, is called the body or payload.
We say the application's data is encapsulated in the new message created by protocol RRP.
This kind of header encapsulation might go on at each layer in the protocol stack. So the actual data sent over hardware in our case might look like: HHP header, RRP header, Data.

Multiplexing/Demultiplexing is used in protocol stacks.
For instance, two different applications might have their messages multiplexed over the channel provided by the RRP protocol.
The RRP peer on the remote machine must demultiplex these message and pass them to the corresponding application.
In order to know which application the RRP peer should send a given message to, a demultiplexing (demux) key is used. So this string must be part of the RRP header.

ISO (International Organization for Standardization) was one of the first organizations to formally define a common way to connect computers called Open Systems Interconnection (OSI).
It defines a partitioning of network functionality into seven layers.
ISO usually in conjunction with the International Telecommunications Union publishes a series of protocols specifications based on the OSI architecture. This series is sometimes called the "X-dot" series as the protocols have names like: X.25, X.400, X.500.

Layer 1 (Physical Layer) -- concerned with transmitting 0s and 1s over the network. Design issues deal with mechanical, electrical, and timing interfaces as well as physical transmission medium.
Layer 2 (Data Link) -- transforms a raw transmission facility into a line that appears free from undetected transmission errors and makes this available to the network layer. It breaks up the input data into data frames. If the service is reliable, the receiver acknowledges correct receipt of each frame with an acknowledgment frame.
Layer 3 (Network Layer) -- controls operation of the subnet. It needs to be able to route messages from the source to destination. Routes can be either static or dynamic.
Layer 4 (Transport Layer) -- receives data, split it into smaller units for the network layer. It adds sequencing information so that the original data can be reassembled at the other end.
Layer 5 (Session Layer) -- provides a name space that is used to tie together potentially different transport streams that are part of a single application. For example, an audio or video stream that being combined into a teleconferencing application
Layer 6 (Presentation Layer) -- used to specify the syntax of the data to be transmitted. You can think of this data as like specifying an XML language.
Layer 7 (Application Layer) -- contains a variety of protocols which are needed by the end user. For example, FTP, HTTP, POP mail, etc

OSI serves as a useful reference model.
The actual Internet Architecture is like the four layered picture above.
It is often called Transmission Control Protocol/ Internet Protocol (TCP/IP) architecture.
The transport layer contains two protocols TCP and UDP (User Datagram Protocol).
TCP provides a reliable byte-stream channel; UDP provides an unreliable datagram delivery channel.

One of the keys to the internet's success is that it is relatively easy to write new application programs that make use of it.
Most operating systems provide an interface to the networking sub-system often called the network application programming interface (API).
Most networking APIs these days are based on the socket interface originally by the Berkeley distribution of Unix.
We will next look at this interface as it is exposed in Java...

In using sockets we imagine we have two machines on the internet: a client that wants to open a connection to a given application server.
The server typically provides some kind of application service: network time, ftp, etc.
A given machine might have several application services running on it. So in order for a client to connect to a server it needs to provide both the servers address and the port number of the particular service desired. For example port 80 for HTTP.
In setting up a server one needs a mechanism for binding oneself to a particular port.
Threads also need to be used, to handle more that one request at a time.

To use sockets you should import the following packages:
```
import java.io.*;
import java.net.*;
```
To bind your application to a port in a try block you might create a ServerSocket object:
```
ServerSocket server = new ServerSocket(SERVERPORT);
Socket socket;
```
this might throw an exception if someone else is already bound to ServerPort.
In a while loop one could have the line:
```
socket = server.accept();
```
which could be used to set up one connection with a client; typically, one would then spawn a thread.
A socket has methods getInputStream() and getOutputStream() for actually reading and writing data from the socket.

The client also uses Socket objects. To connect to a particular address on a particular port, a client might use a line like:
```
Socket socket = new Socket("eniac.cs.sjsu.edu", SERVERPORT);
```
Again, the socket has methods getInputStream() and getOutputStream() which are then used for actually reading and writing data from the socket.