Application Protocol Design
In Chapter7,
we'll discuss the advantages of breaking complicated applications up
into cooperating processes speaking an application-specific command
set or protocol with each other. All the good reasons for data file
formats to be textual apply to these application-specific protocols as
well.
When your application protocol is textual and easily parsed
by eyeball, many good things become easier. Transaction dumps become
much easier to interpret. Test loads become easier to write.
Server processes are often invoked by harness programs such as
inetd(8)
in such a way that the server sees commands on standard input and
ships responses to standard output. We describe this “CLI
server” pattern in more detail in Chapter11.
A CLI server with a command set that is designed for simplicity has
the valuable property that a human tester will be able to type
commands direct to the server process to probe the software's
behavior.
Another issue to bear in mind is the end-to-end design
principle. Every protocol designer should read the classic
End-to-End Arguments in System Design [Saltzer]. There are often serious questions about which
level of the protocol stack should handle features like security and
authentication; this paper provides some good conceptual tools for
thinking about them. Yet a third issue is designing application
protocols for good performance. We'll cover that issue in more detail
in Chapter12.
The traditions of Internet application protocol design evolved
separately from Unix before 1980.[54]
But since the 1980s these traditions have become thoroughly
naturalized into Unix practice.
We'll illustrate the Internet style by looking at three
application protocols that are both among the most heavily used, and
are widely regarded among Internet hackers as paradigmatic: SMTP,
POP3, and IMAP. All three address different aspects of mail transport
(one of the net's two most important applications, along with the
World Wide Web), but the problems they address (passing messages,
setting remote state, indicating error conditions) are generic to
non-email application protocols as well and are normally addressed
using similar techniques.
Case Study: SMTP, the Simple Mail Transfer Protocol
Example5.7 is an example transaction in SMTP
(Simple Mail Transfer Protocol), which is described by RFC 2821. In
the example,
C:
lines are sent by a mail
transport agent (MTA) sending mail, and
S:
lines
are returned by the MTA receiving it. Text
emphasized like
this
is comments, not part of the actual
transaction.
Example5.7.An SMTP session example.
C: <client connects to service port 25>
C:
HELO snark.thyrsus.com
sending host identifies self
S:
250 OK Hello snark, glad to meet you
receiver acknowledges
C:
MAIL FROM: <esr@thyrsus.com>
identify sending user
S:
250 <esr@thyrsus.com>... Sender ok
receiver acknowledges
C:
RCPT TO: cor@cpmy.com
identify target user
S:
250 root... Recipient ok
receiver acknowledges
C:
DATA
S:
354 Enter mail, end with "." on a line by itself
C:
Scratch called. He wants to share
C:
a room with us at Balticon.
C:
.
end of multiline send
S:
250 WAA01865 Message accepted for delivery
C:
QUIT
sender signs off
S:
221 cpmy.com closing connection
receiver disconnects
C: <client hangs up>
This is how mail is passed among Internet machines. Note the
following features: command-argument format of the requests, responses
consisting of a status code followed by an informational message, the
fact that the payload of the DATA command is terminated by a line
consisting of a single dot.
SMTP is one of the two or three oldest application protocols
still in use on the Internet. It is simple, effective, and has
withstood the test of time. The traits we have called out here are
tropes that recur frequently in other Internet protocols. If there is
any single archetype of what a well-designed Internet application
protocol looks like, SMTP is it.
[an error occurred while processing this directive]