Protocols: Understanding Network Software

The goal is for you to understand the core concepts in the three core network protocols: (1) datalink layer protocol, (2) network layer protocol, (3) transport layer protocol.

Before we start, let's identify a few major themes and also clarify what we are not going to cover:

• Network programmming. This is something we are not going to cover here. It refers to how you write code that uses an existing network infrastructure. The most commonly used programming abstraction is a socket, for example:

        // Open a socket to a remote server, which initiates a
        // "connection" to that server.
        Socket socket = new Socket ("www.yahoo.com", 80);
        // Send stuff.
        PrintWriter pw = new PrintWriter (socket.getOutputStream());
        pw.println ("Hello there");
    

  Instead, our goal is to understand how the string "Hello there" (a bunch of bits, really) gets from the application program (above) to the other machine.

• What's a "protocol" anyway, and how is it different from an "algorithm"? In general, a protocol is an agreed upon set of rules to facilitate communication or to coordinate actions amongst otherwise indepedent entities. If that sounds vague, it is. Think of a protocol as implementing an "algorithm" at each network entity so that the algorithms work in concert to achieve something. So, is a protocol an algorithm? In the broadest sense, because a protocol is about computation, it is fair to say a protocol is a sort of distributed algorithm.

• Major theme #1: standardization. If there weren't worldwide agreement on standardizing interfaces, we would have the same tower-of-Babel problem we now have with, say, power adapters where every manufacturer has their own cables and power specs. Luckily, there is a single standard for local networks (ethernet) and one for the internet.

• Major theme #2: stuff gets lost. A lot of agonizing will go into worrying about data that gets corrupted or lost. It may be hard to believe, but it does happen. People step on cables, electronic equipment does malfunction, and wireless links can experience "electrical storms".

• Major theme #3: minimize the need to know. Not for secrecy, but for simplicity. There two aspects to reducing the need to know.
  • The first has to do with software engineering: if one piece of the code interacts with another, it shouldn't have to know the internals of the other, and should only interact via a well-defined interface. As we will see, the three main "pieces" are going to be arranged in a simple top-to-bottom layered fashion.
  • The second has to do with complexity. We don't want a router to have to "know" the whole network, or even a substantial part of it. Ideally, routers only know their immediate neighbors. As we'll learn, actual implementations are less ideal.

• Major theme #4: the Connection. One could design networks (the UDP protocol, for instance) in which an application merely dumps bits at one end of a network expecting those bits to arrive at the other end. However, modern networks go a step further in supporting a useful programming abstraction called a connection (the Socket above). Once a connection is established between two programs, one program can "pour" bits into the connection and expect those bits to be properly delivered into the receiving program.

• Major theme #6: the Packet. When you send a (large) file across the internet, the file is actually broken down into smaller pieces (packets) that then wind their way independently to the destination where they are reassembled into the file. The packet is also the unit of communication between the layers of software that implement network protocols. As we'll see, a packet at a lower level of software contains a higher-level packet inside it.

• Major theme #7: efficiency. A network needs to be efficient in several ways:
  • It should spread the load of carrying data. If only a few cables carried everything, there could be waiting delays and a single point of failure.
  • Some kinds of data (e.g., video) are more time-critical than others. A network should be smart about prioritizing.
  • As much as possible of the routine maintenance should be done in parallel rather than by a few machines.

• Security. These days, one expects security to be an important theme, but we are not going to discuss security. As it turns out, network security is a topic unto itself that is still evolving.

Warning:

• We are going to greatly simplify matters by abstracting away detail. As a result, do not expect everything we say to be "the ground truth" about the internet. However, at the end of this module (and your assignment), you will be in a good position to delve into practical details.
• One important pedagogically motivated simplification: we'll use Java (whereas most network protocol code is written in C).
• Also, rather than tell you what each protocol does in detail, we'll focus on what each protocol is responsible for. This way, you can exercise creativity in implementing the functionality yourself.

Life after this module: If you want the next level of detail (or skill), we'll have some suggested-next-steps recommendations at the end.

Meet the players: the key components that make up a network

public interface TransportLayer {

    // An application says: "I want to create a connection to destination dest"
    // The transport layer returns a connection ID that the application can use to 
    // refer to this connection in further interactions.
    public int openConnection (int dest);

    // Connection set up may take time, so an application calls this 
    // repeatedly to find out whether the connection is set up.
    public boolean isReady (int connID);

    // Send a packet of data over the connection.
    public void sendPacket (TransportPacket packet);

    // This method will be called by the layer below to tell the 
    // transport layer, "Hey, a packet has arrived for you".
    public void receivePacket (TransportPacket packet);

    // Close a particular connection when done.
    public void closeConnection (int connID);
}
  

  int connID = transport.openConnection (destNodeID);
  while (! transport.isReady (connID)) {
     // ... sleep a little ...
  }
  TransportPacket packet = new TransportPacket (" ... some data ...");
  transport.sendPacket (packet);
  

public interface NetworkLayer {

    // This method is called by the transport layer above when
    // that layer has a packet to send. The packet is assumed to
    // contain information about the destination. This method is
    // only called at the end hosts.
    public void sendPacket (NetworkPacket packet);

    // The network layer receives a packet from below (datalink layer).
    // This packet could be destined for this node (an end host) or
    // needs to be forwarded along according to the dictates of the routing table.
    public void receivePacket (NetworkPacket packet);

    // This will be called by the independent process that's doing
    // the link measurement to update the stats for the link to
    // a particular neighbor. Here is where a routing computation
    // is initiated.
    public void updateLinkStatus (int neighbor, LinkStatus status);
}
  

public interface DatalinkLayer {

    // The network layer calls this to send a packet across. It's
    // assumed that the packet contains the destination (neighbor) ID.
    public void sendPacket (DatalinkPacket packet);

    // This method is called by the physical layer when a packet has come in.
    // The datalink layer sends it up to the network layer.
    public void receivePacket (DatalinkPacket packet);
}