Example #1
0
  /**
   * Queries the given timeserver <code>hostname</code> and returns the time in milliseconds.
   *
   * @param hostname the timeserver to query
   * @return the time in milliseconds or the current time of the system if an error occurs.
   */
  protected static long getTime(String hostname) {

    try {
      NTPUDPClient timeClient = new NTPUDPClient();
      timeClient.setDefaultTimeout(NTP_TIMEOUT);
      InetAddress inetAddress = InetAddress.getByName(hostname);
      TimeInfo timeInfo = timeClient.getTime(inetAddress);

      return timeInfo.getReturnTime();
    } catch (UnknownHostException uhe) {
      logger.warn(
          "the given hostname '{}' of the timeserver is unknown -> returning current sytem time instead",
          hostname);
    } catch (IOException ioe) {
      logger.warn(
          "couldn't establish network connection [host '{}'] -> returning current sytem time instead",
          hostname);
    }

    return System.currentTimeMillis();
  }
  private void logStuff(TimeInfo info, NtpV3Packet message) {
    if (!log.isDebugEnabled()) {
      return;
    }
    TimeStamp refNtpTime = message.getReferenceTimeStamp();
    log.debug("Reference Timestamp:\t" + refNtpTime.toDateString());

    // Originate Time is time request sent by client (t1)
    TimeStamp origNtpTime = message.getOriginateTimeStamp();
    log.debug("Originate Timestamp:\t" + origNtpTime.toDateString());

    // Receive Time is time request received by server (t2)
    TimeStamp rcvNtpTime = message.getReceiveTimeStamp();
    log.debug("Receive Timestamp:\t" + rcvNtpTime.toDateString());

    // Transmit time is time reply sent by server (t3)
    TimeStamp xmitNtpTime = message.getTransmitTimeStamp();
    log.debug("Transmit Timestamp:\t" + xmitNtpTime.toDateString());

    // Destination time is time reply received by client (t4)
    TimeStamp destNtpTime = TimeStamp.getNtpTime(info.getReturnTime());
    log.debug("Destination Timestamp:\t" + destNtpTime.toDateString());
  }
Example #3
0
  /**
   * Process <code>TimeInfo</code> object and print its details.
   *
   * @param info <code>TimeInfo</code> object.
   */
  public static void processResponse(TimeInfo info) {
    NtpV3Packet message = info.getMessage();
    int stratum = message.getStratum();
    String refType;
    if (stratum <= 0) {
      refType = "(Unspecified or Unavailable)";
    } else if (stratum == 1) {
      refType = "(Primary Reference; e.g., GPS)"; // GPS, radio clock, etc.
    } else {
      refType = "(Secondary Reference; e.g. via NTP or SNTP)";
    }
    // stratum should be 0..15...
    System.out.println(" Stratum: " + stratum + " " + refType);
    int version = message.getVersion();
    int li = message.getLeapIndicator();
    System.out.println(
        " leap=" + li + ", version=" + version + ", precision=" + message.getPrecision());

    System.out.println(" mode: " + message.getModeName() + " (" + message.getMode() + ")");
    int poll = message.getPoll();
    // poll value typically btwn MINPOLL (4) and MAXPOLL (14)
    System.out.println(
        " poll: "
            + (poll <= 0 ? 1 : (int) Math.pow(2, poll))
            + " seconds"
            + " (2 ** "
            + poll
            + ")");
    double disp = message.getRootDispersionInMillisDouble();
    System.out.println(
        " rootdelay="
            + numberFormat.format(message.getRootDelayInMillisDouble())
            + ", rootdispersion(ms): "
            + numberFormat.format(disp));

    int refId = message.getReferenceId();
    String refAddr = NtpUtils.getHostAddress(refId);
    String refName = null;
    if (refId != 0) {
      if (refAddr.equals("127.127.1.0")) {
        refName = "LOCAL"; // This is the ref address for the Local Clock
      } else if (stratum >= 2) {
        // If reference id has 127.127 prefix then it uses its own reference clock
        // defined in the form 127.127.clock-type.unit-num (e.g. 127.127.8.0 mode 5
        // for GENERIC DCF77 AM; see refclock.htm from the NTP software distribution.
        if (!refAddr.startsWith("127.127")) {
          try {
            InetAddress addr = InetAddress.getByName(refAddr);
            String name = addr.getHostName();
            if (name != null && !name.equals(refAddr)) {
              refName = name;
            }
          } catch (UnknownHostException e) {
            // some stratum-2 servers sync to ref clock device but fudge stratum level higher...
            // (e.g. 2)
            // ref not valid host maybe it's a reference clock name?
            // otherwise just show the ref IP address.
            refName = NtpUtils.getReferenceClock(message);
          }
        }
      } else if (version >= 3 && (stratum == 0 || stratum == 1)) {
        refName = NtpUtils.getReferenceClock(message);
        // refname usually have at least 3 characters (e.g. GPS, WWV, LCL, etc.)
      }
      // otherwise give up on naming the beast...
    }
    if (refName != null && refName.length() > 1) {
      refAddr += " (" + refName + ")";
    }
    System.out.println(" Reference Identifier:\t" + refAddr);

    TimeStamp refNtpTime = message.getReferenceTimeStamp();
    System.out.println(" Reference Timestamp:\t" + refNtpTime + "  " + refNtpTime.toDateString());

    // Originate Time is time request sent by client (t1)
    TimeStamp origNtpTime = message.getOriginateTimeStamp();
    System.out.println(" Originate Timestamp:\t" + origNtpTime + "  " + origNtpTime.toDateString());

    long destTime = info.getReturnTime();
    // Receive Time is time request received by server (t2)
    TimeStamp rcvNtpTime = message.getReceiveTimeStamp();
    System.out.println(" Receive Timestamp:\t" + rcvNtpTime + "  " + rcvNtpTime.toDateString());

    // Transmit time is time reply sent by server (t3)
    TimeStamp xmitNtpTime = message.getTransmitTimeStamp();
    System.out.println(" Transmit Timestamp:\t" + xmitNtpTime + "  " + xmitNtpTime.toDateString());

    // Destination time is time reply received by client (t4)
    TimeStamp destNtpTime = TimeStamp.getNtpTime(destTime);
    System.out.println(
        " Destination Timestamp:\t" + destNtpTime + "  " + destNtpTime.toDateString());

    info.computeDetails(); // compute offset/delay if not already done
    Long offsetValue = info.getOffset();
    Long delayValue = info.getDelay();
    String delay = (delayValue == null) ? "N/A" : delayValue.toString();
    String offset = (offsetValue == null) ? "N/A" : offsetValue.toString();

    System.out.println(
        " Roundtrip delay(ms)=" + delay + ", clock offset(ms)=" + offset); // offset in ms
  }