Java Network Programming (3rd ed) [Electronic resources] نسخه متنی

2.3 IP, TCP, and UDP

IP, the Internet protocol, has a
number of advantages over competing protocols such as AppleTalk and
IPX, most stemming from its history. It was developed with military
sponsorship during the Cold War, and ended up with a lot of features
that the military was interested in. First, it had to be robust. The
entire network couldn't stop functioning if the
Soviets nuked a router in Cleveland; all messages still had to get
through to their intended destinations (except those going to
Cleveland, of course). Therefore IP was designed to allow multiple
routes between any two points and to route packets of data around
damaged routers.

Second, the military had many different kinds of computers, and all
of them had to be able to talk to each other. Therefore the IP had to
be open and platform-independent; it wasn't good
enough to have one protocol for IBM mainframes and another for
PDP-11s. The IBM mainframes needed to talk to the PDP-11s and any
other strange computers that might be lying around.

Since there are multiple routes between two points, and since the
quickest path between two points may change over time as a function
of network traffic and other factors (such as the existence of
Cleveland), the packets that make up a particular data stream may not
all take the same route. Furthermore, they may not arrive in the
order they were sent, if they even arrive at all. To improve on the
basic scheme, TCP was layered
on top of IP to give each end of a connection the ability to
acknowledge receipt of IP packets and request retransmission of lost
or corrupted packets. Furthermore, TCP allows the packets to be put
back together on the receiving end in the same order they were sent.

TCP, however, carries a fair amount of overhead. Therefore, if the
order of the data isn't particularly important and
if the loss of individual packets won't completely
corrupt the data stream, packets are sometimes sent without the
guarantees that TCP provides. This is accomplished through the use of
the UDP protocol. UDP is an
unreliable protocol that does not guarantee that packets will arrive
at their destination or that they will arrive in the same order they
were sent. Although this would be a problem for uses such as file
transfer, it is perfectly acceptable for applications where the loss
of some data would go unnoticed by the end user. For example, losing
a few bits from a video or audio signal won't cause
much degradation; it would be a bigger problem if you had to wait for
a protocol like TCP to request a retransmission of missing data.
Furthermore, error-correcting codes can be built into UDP data
streams at the application level to account for missing data.

A number of other protocols can run on top of IP. The most commonly
requested is ICMP, the Internet Control Message Protocol, which uses
raw IP datagrams to relay error messages between hosts. The
best-known use of this protocol is in the ping program. Java does not
support ICMP nor does it allow the sending of raw IP datagrams (as
opposed to TCP segments or UDP datagrams). The only protocols Java
supports are TCP and UDP, and application layer protocols built on
top of these. All other transport layer, internet layer, and lower
layer protocols such as ICMP, IGMP, ARP, RARP, RSVP, and others can
only be implemented in Java programs by using native code.

2.3.1 IP Addresses and Domain Names

As a Java
programmer, you don't need to worry about the inner
workings of IP, but you do need to know about addressing. Every
computer on an IPv4 network is identified by a four-byte
number. This is normally written in a dotted
quad format like 199.1.32.90, where each of the four numbers
is one unsigned byte ranging in value from 0 to 255. Every computer
attached to an IPv4 network has a unique four-byte address. When data
is transmitted across the network, the packet's
header includes the address of the machine for which the packet is
intended (the destination address) and the address of the machine
that sent the packet (the source address). Routers along the way
choose the best route to send the packet along by inspecting the
destination address. The source address is included so the recipient
will know who to reply to.

There are a little more than four billion possible IP addresses, not
even one for every person on the planet, much less for every
computer. To make matters worse, the addresses
aren't allocated very efficiently. A slow transition
is under way to IPv6, which will use 16-byte addresses. This provides
enough IP addresses to identify every person, every computer, and
indeed every atom on the planet. IPv6 addresses are customarily
written in eight blocks of four hexadecimal digits separated by
colons, such as FEDC:BA98:7654:3210:FEDC:BA98:7654:3210.
Leading zeros do not need to be written. A double colon, at most one
of which may appear in any address, indicates multiple zero blocks.
For example, FEDC:0000:0000:0000:00DC:0000:7076:0010 could
be written more compactly as FEDC::DC:0:7076:10. In mixed networks of IPv6
and IPv4, the last four bytes of the IPv6 address are sometimes
written as an IPv4 dotted quad address. For example, FEDC:BA98:7654:3210:FEDC:BA98:7654:3210 could
be written as FEDC:BA98:7654:3210:FEDC:BA98:118.84.50.16.
IPv6 is only supported in Java 1.4 and later. Java 1.3
and earlier only support four-byte addresses.

Although computers are very comfortable with numbers, human beings
aren't very good at remembering them. Therefore the
Domain Name System (DNS) was developed
to translate hostnames that humans can remember (like www.oreilly.com) into numeric Internet
addresses (like 208.201.239.37).
When Java programs access the network, they need to process both
these numeric addresses and their corresponding hostnames. Methods
for doing this are provided by the
java.net.InetAddress class, which is discussed in
Chapter 6.

Some computers, especially servers, have fixed addresses. Others,
especially clients on local area networks and dial-up connections,
receive a different address every time they boot up, often provided
by a DHCP server or a PPP server. This is not especially relevant to
your Java programs. Mostly you just need to remember that IP
addresses may change over time, and not write any code that relies on
a system having the same IP address. For instance,
don't serialize the local IP address when saving
application state. Instead, look it up fresh each time your program
starts. It's also possible, although less likely,
for an IP address to change while the program is running (for
instance, if a dialup connection hangs up and then reconnects), so
you may want to check the current IP address every time you need it
rather than caching it. Otherwise, the difference between a
dynamically and manually assigned address is not significant to Java
programs.

2.3.2 Ports

Addresses would be all you needed
if each computer did no more than one thing at a time. However,
modern computers do many different things at once. Email needs to be
separated from FTP requests, which need to be separated from web
traffic. This is accomplished through ports.
Each computer with an IP address has several thousand logical ports
(65,535 per transport layer protocol, to be precise). These are
purely abstractions in the computer's memory and do
not represent anything physical, like a serial or parallel port. Each
port is identified by a number between 1 and 65,535. Each port can be
allocated to a particular service.

For example, HTTP, the underlying protocol of the Web, generally uses
port 80. We say that a web server listens on
port 80 for incoming connections. When data is sent to a web server
on a particular machine at a particular IP address, it is also sent
to a particular port (usually port 80) on that machine. The receiver
checks each packet it sees for the port and sends the data to any
programs that are listening to the specified port. This is how
different types of traffic are sorted out.

Port numbers between 1 and 1,023 are reserved for well-known services
like finger, FTP, HTTP, and IMAP. On Unix systems, including Linux
and Mac OS X, only programs running as root can receive data from
these ports, but all programs may send data to them. On Windows and
Mac OS 9, any program may use these ports without special privileges.
Table 2-1 shows the well-known ports for the
protocols that are discussed in this book. These assignments are not
absolutely guaranteed; in particular, web servers often run on ports
other than 80, either because multiple servers need to run on the
same machine or because the person who installed the server
doesn't have the root privileges needed to run it on
port 80. On Unix systems, a fairly complete listing of assigned ports
is stored in the file /etc/services.