Identifying a machine

Bruce Eckel’s Thinking in Java Contents | Prev | Next

  1. The
    familiar
    DNS
    (Domain Name Service) form. My domain name is
    bruceeckel.com,
    so suppose I have a computer called
    Opus
    in my domain. Its domain name would be
    Opus.bruceeckel.com.
    This is exactly the kind of name that you use when you send email to people,
    and is often incorporated into a World-Wide-Web address.
  2. Alternatively,
    you can use the “
    dotted
    quad” form, which is four numbers separated by dots, such as
    123.255.28.120.
In
both cases, the IP address is represented internally as a 32-bit number
[63]
(so each of the quad numbers cannot exceed 255), and you can get a special Java
object to represent this number from either of the forms above by using the
static
InetAddress.getByName( )
method that’s in
java.net.
The result is an object of type
InetAddress
that you can use to build a “socket” as you will see later.

As
a simple example of using
InetAddress.getByName( ),
consider what happens if you have a dial-up Internet service provider (ISP).
Each time you dial up, you are assigned a temporary IP address. But while
you’re connected, your IP address has the same validity as any other IP
address on the Internet. If someone connects to your machine using your IP
address then they can connect to a Web server or FTP server that you have
running on your machine. Of course, they need to know your IP address, and
since it’s assigned each time you dial up, how can you find out what it is?

The
following program uses
InetAddress.getByName( )
to produce your IP address. To use it, you must know the name of your computer.
It has been tested only on Windows 95, but there you can go to
“Settings,” “Control Panel,” “Network,” and
then select the “Identification” tab. “Computer name”
is the name to put on the command line.

//: WhoAmI.java
// Finds out your network address when you're 
// connected to the Internet.
package c15;
import java.net.*;
 
public class WhoAmI {
  public static void main(String[] args)
      throws Exception {
    if(args.length != 1) {
      System.err.println(
        "Usage: WhoAmI MachineName");
      System.exit(1);
    }
    InetAddress a =
      InetAddress.getByName(args[0]);
    System.out.println(a);
  }
} ///:~ 

In
my case, the machine is called “Colossus” (from the movie of the
same name, because I keep putting bigger disks on it). So, once I’ve
connected to my ISP I run the program:

java
WhoAmI Colossus

I
get back a message like this (of course, the address is different each time):

Colossus/199.190.87.75

If
I tell my friend this address, he can log onto my personal Web server by going
to the URL
http://199.190.87.75
(only as long as I continue to stay connected during that session). This can
sometimes be a handy way to distribute information to someone else or to test
out a Web site configuration before posting it to a “real” server.

Servers
and clients

The
whole point of a network is to allow two machines to connect and talk to each
other. Once the two machines have found each other they can have a nice,
two-way conversation. But how do they find each other? It’s like getting
lost in an amusement park: one machine has to stay in one place and listen
while the other machine says, “Hey, where are you?”

So
the job of the server is to listen for a connection, and that’s performed
by the special server object that you create. The job of the client is to try
to make a connection to a server, and this is performed by the special client
object you create. Once the connection is made, you’ll see that at both
server and client ends, the connection is just magically turned into an IO
stream object, and from then on you can treat the connection as if you were
reading from and writing to a file. Thus, after the connection is made you will
just use the familiar IO commands from Chapter 10. This is one of the nice
features of Java networking.


Testing
programs without a network

InetAddress
addr = InetAddress.getByName(null);

If
you hand
getByName( )
a
null,
it defaults to using the
localhost.
The
InetAddress
is what you use to refer to the particular machine, and you must produce this
before you can go any further. You can’t manipulate the contents of an
InetAddress
(but
you can print them out, as you’ll see in the next example). The only way
you can create an
InetAddress
is through one of that class’s
static
member methods
getByName( )
(which is what you’ll usually use),
getAllByName( ),
or
getLocalHost( ).

You
can also produce the local loopback address by handing it the string
localhost:

InetAddress.getByName("localhost");

or
by using its dotted quad form to name the reserved IP number for the loopback:

InetAddress.getByName("127.0.0.1");

Port:
a unique place

within
the machine

The
port is not a physical location in a machine, but a software abstraction
(mainly for bookkeeping purposes). The client program knows how to connect to
the machine via its IP address, but how does it connect to a desired service
(potentially one of many on that machine)? That’s where the port numbers
come in as second level of addressing. The idea is that if you ask for a
particular port, you’re requesting the service that’s associated
with the port number. The time of day is a simple example of a service.
Typically, each service is associated with a unique port number on a given
server machine. It’s up to the client to know ahead of time which port
number the desired service is running on.


[63]
This means a maximum of just over four billion numbers, which is rapidly
running out. The new standard for IP addresses will use a 128-bit number, which
should produce enough unique IP addresses for the foreseeable future.

More by Author

Must Read