NioClient.java

/*
 * Copyright (c) 2017 int08h LLC. All rights reserved.
 *
 * int08h LLC licenses Nearenough (the "Software") to you under the Apache License, version 2.0
 * (the "License"); you may not use this Software except in compliance with the License. You may
 * obtain a copy of the License from the LICENSE file included with the Software or at:
 *
 *   http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software distributed under the
 * License is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND,
 * either express or implied. See the License for the specific language governing permissions and
 * limitations under the License.
 */
package nearenough.examples;

import static nearenough.util.BytesUtil.hexToBytes;

import io.netty.buffer.ByteBuf;

import java.io.IOException;
import java.net.InetSocketAddress;
import java.net.StandardProtocolFamily;
import java.nio.ByteBuffer;
import java.nio.channels.DatagramChannel;
import java.time.Instant;
import nearenough.client.RoughtimeClient;
import nearenough.protocol.RtMessage;
import nearenough.protocol.RtWire;

/**
 * Use Java NIO to send a request to the given Roughtime server and dump the response (if any)
 */
public final class NioClient {

  // Hostname and port of the public int08h.com Roughtime server
  private static final String INT08H_SERVER_HOST = "roughtime.int08h.com";
  private static final int INT08H_SERVER_PORT = 2002;

  // Long-term public key of the public int08h.com Roughtime server
  private static final byte[] INT08H_SERVER_PUBKEY = hexToBytes(
      "016e6e0284d24c37c6e4d7d8d5b4e1d3c1949ceaa545bf875616c9dce0c9bec1"
  );

  @SuppressWarnings("Duplicates")
  public static void main(String[] args) throws IOException, InterruptedException {
    InetSocketAddress addr = new InetSocketAddress(INT08H_SERVER_HOST, INT08H_SERVER_PORT);
    System.out.printf("Sending request to %s\n", addr);

    // Nonblocking NIO UDP channel for the remote Roughtime server
    DatagramChannel channel = DatagramChannel.open(StandardProtocolFamily.INET);
    channel.configureBlocking(false);

    // Create a new RoughtimeClient instance
    RoughtimeClient client = new RoughtimeClient(INT08H_SERVER_PUBKEY);

    // Create a request message
    RtMessage request = client.createRequest();

    // Encode for transmission
    ByteBuf encodedRequest = RtWire.toWire(request);

    // Send the message
    channel.send(encodedRequest.nioBuffer(), addr);
    int bytesWritten = channel.send(encodedRequest.nioBuffer(), addr);

    // Ensure the message was sent
    if (bytesWritten != encodedRequest.readableBytes()) {
      throw new RuntimeException("failed to fully write request");
    }

    // Space for receiving the reply
    ByteBuffer recvBuf = ByteBuffer.allocate(4096);
    int attempts = 50;

    // Simple loop to look for the first response. Wait for max 5 seconds.
    while (--attempts > 0) {
      recvBuf.clear();
      channel.receive(recvBuf);
      recvBuf.flip();
      if (recvBuf.hasRemaining()) {
        break;
      }
      Thread.sleep(100L);
    }

    if (recvBuf.hasRemaining()) {
      // A reply from the server has been received
      System.out.printf("Read message of %d bytes from %s:\n", recvBuf.remaining(), addr);

      // Parse the response
      RtMessage response = RtMessage.fromByteBuffer(recvBuf);
      System.out.println(response);

      // Validate the response. Checks that the message is well-formed, all signatures are valid,
      // and our nonce is present in the response.
      client.processResponse(response);

      if (client.isResponseValid()) {
        // Validation passed, the response is good

        // The "midpoint" is the Roughtime server's reported timestamp (in microseconds). And the
        // "radius" is a span of uncertainty around that midpoint. A Roughtime server asserts that
        // its "true time" lies within the span.
        Instant midpoint = Instant.ofEpochMilli(client.midpoint() / 1_000L);
        int radiusSec = client.radius() / 1_000_000;
        System.out.println("midpoint    : " + midpoint + " (radius " + radiusSec + " sec)");

        // For comparison, also print the local clock. If the midpoint and your local time
        // are widely different, check your local machine's time sync!
        Instant local = Instant.now();
        System.out.println("local clock : " + local);

      } else {
        // Validation failed. Print out the reason why.
        System.out.println("Response INVALID: " + client.invalidResponseCause().getMessage());
      }

    } else {
      // No reply within five seconds
      System.out.println("No response from " + addr);
    }

    System.exit(0);
  }
}