package com.ronsoft.books.nio.channels;
import java.nio.ByteBuffer;
import java.nio.ByteOrder;
import java.nio.channels.DatagramChannel;
import java.net.InetSocketAddress;
import java.util.Date;
import java.util.List;
import java.util.LinkedList;
import java.util.Iterator;
// This code is deprecated, see TimeClient and TimeServer
/**
* Request and/or provide time service, per RFC 868. RFC 868
* (http://www.ietf.org/rfc/rfc0868.txt) is a very simple time protocol
* whereby one system can request the current time from another system.
* It's a very simple protocol, specified nearly 20 years ago, which
* does not take into account packet transit time or precision of less
* than one second. The Network Time Protocol (NTP) is superior but
* far too complex for demonstration purposes.
* Most Linux, BSD and Solaris systems provide RFC 868 time service
* on port 37. This simple program will inter-operate with those.
* The National Institute of Standards and Technology (NIST) operates
* a public time server at time.nist.gov.
*
* This code also implements an RFC 868 listener to provide time
* service. On most unix systems, root privileges are required to
* bind to ports below 1024. You can either run this code as root
* or provide another port number with "-l port#". If you run this
* server on an alternate port, you can connect from another JVM
* by supplying the "-p" option to specify the alternate port for
* requests.
*
* Note: The familiar rdate command on unix will probably not work
* with this server. Most versions of rdate use TCP rather than UDP
* to request the time.
*
* When run, this program will issue time requests to each hostname
* given on the command line, then enter a loop to receive packets.
* If not acting as a server, it will exit when all expected replies
* have arrived. Note that some replies may be lost, which means
* this code may block forever. If acting as a server, time requests
* from remote systems will be dispatched as well, in the same loop.
*
* The RFC 868 protocol specifies a 32 bit unsigned value be sent,
* representing the number of seconds since Jan 1, 1900. The Java
* epoch begins on Jan 1, 1970 (same as unix) so an adjustment is
* made by adding or subtracting 2,208,988,800 as appropriate. To
* avoid casting shifting an masking, a four-byte slice of an
* eight-byte buffer is used send/recieve, but then get/putLong()
* is done on the full eight bytes to get a long value.
*
* Created: April 2002
* @author Ron Hitchens (ron@ronsoft.com)
* @version $Id: TimeService.java,v 1.4 2002/05/20 07:24:29 ron Exp $
*/
public class TimeService
{
private static final int DEFAULT_TIME_PORT = 37;
private static final long DIFF_1900 = 2208988800L;
// --------------------------------------------------------------
protected DatagramChannel channel;
protected boolean listening = false;
public TimeService (int port)
throws Exception
{
this.channel = DatagramChannel.open();
if (port != 0) {
System.out.println ("Listening on port " + port
+ " for time requests");
channel.socket().bind (new InetSocketAddress (port));
listening = true;
}
}
// this version never times out
protected InetSocketAddress receivePacket (DatagramChannel channel,
ByteBuffer buffer)
throws Exception
{
buffer.clear();
// receive a 32-bit, big-endian, unsigned value
return ((InetSocketAddress) channel.receive (buffer));
}
public void run (int expect)
throws Exception
{
// allocate a buffer to hold a long value
ByteBuffer longBuffer = ByteBuffer.allocate (8);
// assure big-endian (network) byte order
longBuffer.order (ByteOrder.BIG_ENDIAN);
// zero the whole buffer to be sure
longBuffer.putLong (0, 0);
// position to first byte of the low-order 32 bits
longBuffer.position (4);
// slice the buffer, gives view of the low-order 32 bits
ByteBuffer buffer = longBuffer.slice();
int replies = 0;
while (true) {
InetSocketAddress sa;
sa = receivePacket (channel, buffer);
if (sa == null) {
// only get here if receivePacket timed out
if (listening) {
continue;
}
System.out.println ("Time's up, "
+ (expect - replies)
+ " replies never arrived");
break;
}
buffer.flip();
if (buffer.remaining() == 0) {
// empty packet, someone requesting our time
System.out.println ("Time request from "
+ hostInfo (sa));
serveTimeRequest (sa);
} else {
// reply to a time request we sent
replies++;
printTime (longBuffer.getLong (0), sa);
}
if (expect == 0) {
// running as pure server, carry on
continue;
}
if (replies == expect) {
// all request were answered
System.out.println ("All packets answered");
expect = 0;
if ( ! listening) {
break;
}
} else {
// some haven't shown up yet
System.out.println ("Received " + replies
+ " of " + expect + " replies");
}
}
}
// send a time request to the given internet address
public void requestTime (InetSocketAddress sa)
throws Exception
{
ByteBuffer buffer = ByteBuffer.allocate (1);
buffer.flip(); // make it empty, see RFC868
// fire and forget
channel.send (buffer, sa);
}
// print info about a received time reply
protected void printTime (long remote1900, InetSocketAddress sa)
{
long remote = remote1900 - DIFF_1900;
long local = currentTimeSecs();
Date remoteDate = new Date (remote * 1000);
Date localDate = new Date (local * 1000);
long skew = remote - local;
System.out.println ("Reply from " + hostInfo (sa));
System.out.println (" there: " + remoteDate);
System.out.println (" here: " + localDate);
System.out.print (" skew: ");
if (skew == 0) {
System.out.println ("none");
} else {
System.out.println (skew + " seconds "
+ ((skew < 0) ? "behind" : "ahead"));
}
}
// send the local time to the remote requestor
protected void serveTimeRequest (InetSocketAddress sa)
throws Exception
{
ByteBuffer buffer = ByteBuffer.allocate (8);
buffer.clear();
buffer.putLong (0, currentTimeSecs() + DIFF_1900);
buffer.position (4); // low-order 32-bit int
this.channel.send (buffer, sa);
}
// get the local time as seconds since Jan 1, 1970
public static long currentTimeSecs()
{
return (System.currentTimeMillis() / 1000); // secs/1970
}
// convenience formatting method
public static String hostInfo (InetSocketAddress sa)
{
return (sa.getHostName() + ":" + sa.getPort());
}
// --------------------------------------------------------------
public static TimeService newInstance (int listenPort)
throws Exception
{
return (new TimeService (listenPort));
}
public static void main (String [] argv)
throws Exception
{
if (argv.length == 0) {
System.out.println ("Usage: [ -s | -l port ] [ -p port ] host ...");
return;
}
List hosts = new LinkedList();
int listenPort = 0;
int port = DEFAULT_TIME_PORT;
for (int i = 0; i < argv.length; i++) {
String arg = argv [i];
// listen as a server, on the default port
if (arg.equals ("-s")) {
listenPort = DEFAULT_TIME_PORT;
continue;
}
// listen as a server, on the given port
if (arg.equals ("-l")) {
i++;
listenPort = Integer.parseInt (argv [i]);
continue;
}
// send client requests to the given port
if (arg.equals ("-p")) {
i++;
port = Integer.parseInt (argv [i]);
continue;
}
// create an address object for the host name
InetSocketAddress sa = new InetSocketAddress (arg, port);
// validate that it has an address
if (sa.getAddress() == null) {
System.out.println ("Cannot resolve address: "
+ arg);
continue;
}
hosts.add (sa);
}
TimeService timeService = newInstance (listenPort);
// send time requests to all the supplied hosts
Iterator it = hosts.iterator();
while (it.hasNext()) {
InetSocketAddress sa = (InetSocketAddress) it.next();
System.out.println ("Requesting time from "
+ hostInfo (sa));
timeService.requestTime (sa);
}
System.out.println ("");
System.out.println ("Waiting for replies...");
timeService.run (hosts.size());
}
}
|
