FitzGerald J., Dennis A., Durcikova A. Business Data Communications and Networking

Подождите немного. Документ загружается.

HANDS-ON ACTIVITY 1B 35

FIGURE 1.8 Voice, video, and data in Yahoo Instant Messenger

HANDS-ON ACTIVITY 1B

Seeing the PDUs in Your Messages

We talked about how messages are transferred using lay-

ers and the different Protocol Data Units (PDUs) used at

each layer. The objective of this Activity is for you to

see the different PDUs in the messages that you send. To

do this, we’ll use Wireshark, which is one of the world’s

foremost network protocol analyzers, and is the de facto

standard that most professional and education institutions

use today. It is used for network troubleshooting, network

analysis, software and communications protocol develop-

ment, and general education about how networks work.

Wireshark enables you to see all messages sent by

your computer, as well as some or all of the messages

sent by other computers on your LAN, depending on how

your LAN is designed. Most modern LANs are designed

to prevent you from eavesdropping on other com-

puter’s messages, but some older ones still permit this.

Normally, your computer will ignore the messages that are

not addressed for your computer, but Wireshark enables

you to eavesdrop and read messages sent to and from

other computers.

Wireshark is free. Before you start this activity, down-

load and install it from www.wireshark.org.

1. Start Wireshark.

2. Click on Capture and then Interfaces. Click the

Start button next to the active interface (the one

that is receiving and sending packets). Your net-

work data will be captured from this moment on.

3. Open your browser and go to a Web page that

you have not visited recently (a good one is

www.iana.org).

36 CHAPTER 1 INTRODUCTION TO DATA COMMUNICATIONS

4. Once the Web page has loaded, go back to Wire-

shark and stop the packet capture by clicking on

Capture and then Stop (the hot key for this is

Ctrl + E).

5. You will see results similar to those in Figure 1.9.

There are three windows below the tool bar:

a. The top window is the Packet List. Each line

represents a single message or packet that

was captured by Wireshark. Different types

of packets will have different colors. For

example, HTTP packets are colored green.

Depending on how busy your network is,

you may see a small number of packets in

this window or a very large number of pack-

ets.

b. The middle window is the Packet Detail.

This will show the details for any packet

you click on in the top window.

c. The bottom window shows the actual con-

tents of the packet in hexadecimal format,

so it is usually hard to read. This window is

typically used by network programmers to

debug errors.

6. Let’s take a look at the packets that were used to

request the Web page and send it to your computer.

The application layer protocol used on the Web is

HTTP, so we’ll want to ﬁnd the HTTP packets. In

the Filter toolbar, type http and hit enter.

This is the Filter toolbar

FIGURE 1.9 Wireshark capture

7. This will highlight all the packets that contain

HTTP packets and will display the ﬁrst one in

Packet Detail window. Look at the Packet Detail

window in Figure 1.9 to see the PDUs in the mes-

sage we’ve highlighted. You’ll see that it contains

an Ethernet II Frame, an IP packet, a TCP seg-

ment, and an HTTP packet. You can see inside any

or all of these PDUs by clicking on the +box in

front of them. In Figure 1.9, you’ll see that we’ve

clicked the +box in front of the HTTP packet to

show you what’s inside it.

Deliverables

1. List the PDU at layers 2, 3, and 4 that were used

to transmit your HTTP GET packet.

a. Locate your HTTP Get packet in the Packet

List and click on it.

b. Look in the Packet Detail window to get the

PDU information.

2. How many different HTTP GET packets were sent

by your browser? Not all the HTTP packets are

GET packets, so you’ll have to look through them

to answer this question.

3. List at least ﬁve other protocols that Wireshark dis-

played in the Packet List window. You will need

to clear the ﬁlter by clicking on the ”Clear” icon

that is on the right of the Filter toolbar.

Part Two

FUNDAMENTAL CONCEPTS

Courtesy Cisco Systems, Inc. Unauthorized use not permitted.

Network switches from Cisco

Systems, Inc.

CHAPTER2

APPLICATION LAYER

The Three Faces of Networking

Fundamental Concepts Network Technologies

Network Management

ecurit

Application layer

Network layer

Data Link layer

Physical layer

LAN

WLAN

Backbone

WAN

Internet

Transport layer

CHAPTER OUTLINE 39

THE APPLICATION layer (also called layer 5) is the software

that enables the user to perform useful work. The software at the application

layer is the reason for having the network because it is this software that

provides the business value. This chapter examines the three fundamental

types of application architectures used at the application layer (host-based,

client-based, client-server). It then looks at the Internet and the primary

software application packages it enables: the Web, email, Telnet, and instant

messaging.

OBJECTIVES

▲

 Understand host-based, client-based, and client-server application architectures

 Understand how the Web works

 Understand how email works

 Be aware of how Telnet and instant messaging works

CHAPTER OUTLINE

▲

2.1 INTRODUCTION

2.2 APPLICATION ARCHITECTURES

2.2.1 Host-Based Architectures

2.2.2 Client-Based Architectures

2.2.3 Client-Server Architectures

2.2.4 Peer-to-Peer Architectures

2.2.5 Choosing Architectures

2.3 WORLD WIDE WEB

2.3.1 How the Web Works

2.3.2 Inside an HTTP Request

2.3.3 Inside an HTTP Response

2.4 ELECTRONIC MAIL

2.4.1 How Email Works

2.4.2 Inside an SMTP Packet

2.4.3 Attachments in Multipurpose

Internet Mail Extension

2.5 OTHER APPLICATIONS

2.5.1 Telnet

2.5.2 Instant Messaging

2.5.3 Videoconferencing

2.6 IMPLICATIONS FOR MANAGEMENT

40 CHAPTER 2 APPLICATION LAYER

2.1 INTRODUCTION

Network applications are the software packages that run in the application layer. You

should be quite familiar with many types of network software, because it is these applica-

tion packages that you use when you use the network. In many respects, the only reason

for having a network is to enable these applications.

In this chapter, we ﬁrst discuss three basic architectures for network applications

and how each of those architectures affects the design of networks. Because you prob-

ably have a good understanding of applications such as the Web and word processing,

we will use those as examples of different application architectures. We then examine

several common applications used on the Internet (e.g., Web, email) and use those

to explain how application software interacts with the networks. By the end of this

chapter, you should have a much better understanding of the application layer in the

network model and what exactly we meant when we used the term protocol data unit in

Chapter 1.

2.2 APPLICATION ARCHITECTURES

In Chapter 1, we discussed how the three basic components of a network (client computer,

server computer, and circuit) worked together. In this section, we will get a bit more

speciﬁc about how the client computer and the server computer can work together to

provide application software to the users. An application architecture is the way in

which the functions of the application layer software are spread among the clients and

servers in the network.

The work done by any application program can be divided into four general func-

tions. The ﬁrst is data storage. Most application programs require data to be stored and

retrieved, whether it is a small ﬁle such as a memo produced by a word processor or

a large database such as an organization’s accounting records. The second function is

data access logic, the processing required to access data, which often means database

queries in SQL (structured query language). The third function is the application logic

(sometimes called business logic), which also can be simple or complex, depending on the

application. The fourth function is the presentation logic, the presentation of information

to the user and the acceptance of the user’s commands. These four functions—data stor-

age, data access logic, application logic, and presentation logic—are the basic building

blocks of any application.

There are many ways in which these four functions can be allocated between the

client computers and the servers in a network. There are four fundamental application

architectures in use today. In host-based architectures, the server (or host computer)

performs virtually all of the work. In client-based architectures, the client computers

perform most of the work. In client-server architectures, the work is shared between

the servers and clients. In peer-to-peer architectures, computers are both clients and

servers and thus share the work. The client-server architecture is the dominant application

architecture.

2.2 APPLICATION ARCHITECTURES 41

2.1 CLIENTS AND SERVERS

TECHNICAL

FOCUS

There are many different types of clients and servers

that can be part of a network, and the distinc-

tions between them have become a bit more com-

plex over time. Generally speaking, there are four

types of computers that are commonly used as

servers:

•

A mainframe is a very large general-purpose com-

puter (usually costing millions of dollars) that is

capable of performing an immense number of

simultaneous functions, supporting an enormous

number of simultaneous users, and storing

huge

amounts of data.

•

A personal computer is the type of computer you

use. Personal computers used as servers can be

small, similar to a desktop one you might use, or

cost $20,000 or more.

•

A cluster is a group of computers linked together

so that they act as one computer. Requests arrive

at the cluster (e.g., Web requests) and are dis-

tributed among the computers so that no one

computer is overloaded. Each computer is sep-

arate, so that if one fails, the cluster simply

bypasses it. Clusters are more complex than

single servers because work must be quickly

coordinated and shared among the individual

computers. Clusters are very scalable because

one can always add one more computer to the

cluster.

•

A virtual server is one computer that acts as sev-

eral servers. Using special software, several oper-

ating systems are installed on the same physical

computer so that one physical computer appears

as several different servers to the network. These

virtual servers can perform the same or sepa-

rate functions (e.g., a printer server, Web server,

ﬁle server). This improves efﬁciency (when each

server is not fully used, there is no need to buy

separate physical computers) and may improve

effectiveness (if one virtual server crashes, it does

not crash the other servers on the same com-

puter).

There are ﬁve commonly used types of clients:

•

personal computer

is the most common type

of client today. This includes desktop and laptop

computers, as well as Tablet PCs that enable the

user to write with a pen-like stylus instead of

typing on a keyboard.

•

A terminal is a device with a monitor and key-

board but no central processing unit (CPU). Dumb

terminals, so named because they do not partic-

ipate in the processing of the data they display,

have the bare minimum required to operate

as input and output devices (a TV screen and

a keyboard). In most cases when a character

is typed on a dumb terminal, it transmits the

character through the circuit to the server for

processing. Every keystroke is processed by the

server, even simple activities such as the up

arrow.

•

A network computer is designed primarily to

communicate using Internet-based standards

(e.g., HTTP, Java) but has no hard disk. It has

only limited functionality.

•

A transaction terminal is designed to support

speciﬁc business transactions, such as the auto-

mated teller machines (ATM) used by banks.

Other examples of transaction terminals are

point-of-sale terminals in a supermarket.

•

A handheld computer, Personal Digital Assistant

(PDA), or mobile phone can also be used as a

network client.

2.2.1 Host-Based Architectures

The very ﬁrst data communications networks developed in the 1960s were host-based,

with the server (usually a large mainframe computer) performing all four functions.

The clients (usually terminals) enabled users to send and receive messages to and

42 CHAPTER 2 APPLICATION LAYER

from the host computer. The clients merely captured keystrokes, sent them to the

server for processing, and accepted instructions from the server on what to display

(see Figure 2.1).

This very simple architecture often works very well. Application software is devel-

oped and stored on the one server along with all data. If you’ve ever used a terminal,

you’ve used a host-based application. There is one point of control, because all messages

ﬂow through the one central server. In theory, there are economies of scale, because all

computer resources are centralized (but more on cost later).

There are two fundamental problems with host-based networks. First, the server

must process all messages. As the demands for more and more network applications

grow, many servers become overloaded and unable to quickly process all the users’

demands. Prioritizing users’ access becomes difﬁcult. Response time becomes slower,

and network managers are required to spend increasingly more money to upgrade the

server. Unfortunately, upgrades to the mainframes that usually are the servers in this

architecture are “lumpy.” That is, upgrades come in large increments and are expensive

(e.g., $500,000); it is difﬁcult to upgrade “a little.”

2.2.2 Client-Based Architectures

In the late 1980s, there was an explosion in the use of personal computers. Today, more

than 90 percent of most organizations’ total computer processing power now resides

on personal computers, not in centralized mainframe computers. Part of this expansion

was fueled by a number of low-cost, highly popular applications such as word proces-

sors, spreadsheets, and presentation graphics programs. It was also fueled in part by

managers’ frustrations with application software on host mainframe computers. Most

mainframe software is not as easy to use as personal computer software, is far more

expensive, and can take years to develop. In the late 1980s, many large organizations

had application development backlogs of two to three years; that is, getting any new

mainframe application program written would take years. New York City, for example,

had a six-year backlog. In contrast, managers could buy personal computer packages or

develop personal computer-based applications in a few months.

With client-based architectures, the clients are personal computers on a LAN, and

the server is usually another personal computer on the same network. The application

Client

(terminal)

Server

(mainframe computer)

Presentation logic

Application logic

Data access logic

Data storage

FIGURE 2.1 Host-based architecture

2.2 APPLICATION ARCHITECTURES 43

Client

(personal computer)

Server

(personal computer)

Data storage

Presentation logic

Application logic

Data access logic

FIGURE 2.2 Client-based architecture

software on the client computers is responsible for the presentation logic, the application

logic, and the data access logic; the server simply stores the data (Figure 2.2).

This simple architecture often works very well. If you’ve ever used a word pro-

cessor and stored your document ﬁle on a server (or written a program in Visual Basic

or C that runs on your computer but stores data on a server), you’ve used a client-based

architecture.

The fundamental problem in client-based networks is that all data on the server

must travel to the client for processing. For example, suppose the user wishes to display a

list of all employees with company life insurance. All the data in the database (or all the

indices) must travel from the server where the database is stored over the network circuit

to the client, which then examines each record to see if it matches the data requested

by the user. This can overload the network circuits because far more data is transmitted

from the server to the client than the client actually needs.

2.2.3 Client-Server Architectures

Most applications written today use client-server architectures. Client-server architectures

attempt to balance the processing between the client and the server by having both do

some of the logic. In these networks, the client is responsible for the presentation logic,

whereas the server is responsible for the data access logic and data storage. The applica-

tion logic may either reside on the client, reside on the server, or be split between both.

Figure 2.3 shows the simplest case, with the presentation logic and application

logic on the client and the data access logic and data storage on the server. In this case,

the client software accepts user requests and performs the application logic that produces

database requests that are transmitted to the server. The server software accepts the

database requests, performs the data access logic, and transmits the results to the client.

The client software accepts the results and presents them to the user. When you used

Client

(personal computer)

Server

(personal computer

or mainframe)

Data access logic

Data storage

Presentation logic

Application logic

FIGURE 2.3 Two-tier client-server

architecture

44 CHAPTER 2 APPLICATION LAYER

a Web browser to get pages from a Web server, you used a client-server architecture.

Likewise, if you’ve ever written a program that uses SQL to talk to a database on a

server, you’ve used a client-server architecture.

For example, if the user requests a list of all employees with company life insurance,

the client would accept the request, format it so that it could be understood by the server,

and transmit it to the server. On receiving the request, the server searches the database

for all requested records and then transmits only the matching records to the client, which

would then present them to the user. The same would be true for database updates; the

client accepts the request and sends it to the server. The server processes the update and

responds (either accepting the update or explaining why not) to the client, which displays

it to the user.

One of the strengths of client-server networks is that they enable software and

hardware from different vendors to be used together. But this is also one of their dis-

advantages, because it can be difﬁcult to get software from different vendors to work

together. One solution to this problem is middleware, software that sits between the appli-

cation software on the client and the application software on the server. Middleware does

two things. First, it provides a standard way of communicating that can translate between

software from different vendors. Many middleware tools began as translation utilities that

enabled messages sent from a speciﬁc client tool to be translated into a form understood

by a speciﬁc server tool.

The second function of middleware is to manage the message transfer from clients

to servers (and vice versa) so that clients need not know the speciﬁc server that contains

the application’s data. The application software on the client sends all messages to the

middleware, which forwards them to the correct server. The application software on the

client is therefore protected from any changes in the physical network. If the network

layout changes (e.g., a new server is added), only the middleware must be updated.

There are literally dozens of standards for middleware, each of which is

supported by different vendors and each of which provides different functions. Two

of the most important standards are Distributed Computing Environment (DCE) and

Common Object Request Broker Architecture (CORBA). Both of these standards

cover virtually all aspects of the client-server architecture but are quite different. Any

client or server software that conforms to one of these standards can communicate

with any other software that conforms to the same standard. Another important

standard is Open Database Connectivity (ODBC), which provides a standard for data

access logic.

Two-Tier, Three-Tier, and

-Tier Architectures There are many ways in which

the application logic can be partitioned between the client and the server. The example

in Figure 2.3 is one of the most common. In this case, the server is responsible for the

data and the client, the application and presentation. This is called a two-tier archi-

tecture, because it uses only two sets of computers, one set of clients and one set of

servers.

A three-tier architecture uses three sets of computers, as shown in Figure 2.4. In

this case, the software on the client computer is responsible for presentation logic, an

application server is responsible for the application logic, and a separate database server

is responsible for the data access logic and data storage.