Coverage report

  %line %branch
org.apache.commons.net.ntp.NtpV3Impl
0% 
0% 

 1  
 package org.apache.commons.net.ntp;
 2  
 /*
 3  
  * Copyright 2001-2005 The Apache Software Foundation
 4  
  *
 5  
  * Licensed under the Apache License, Version 2.0 (the "License");
 6  
  * you may not use this file except in compliance with the License.
 7  
  * You may obtain a copy of the License at
 8  
  *
 9  
  *     http://www.apache.org/licenses/LICENSE-2.0
 10  
  *
 11  
  * Unless required by applicable law or agreed to in writing, software
 12  
  * distributed under the License is distributed on an "AS IS" BASIS,
 13  
  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 14  
  * See the License for the specific language governing permissions and
 15  
  * limitations under the License.
 16  
  */
 17  
 import java.net.DatagramPacket;
 18  
 
 19  
 /***
 20  
  * Implementation of NtpV3Packet with methods converting Java objects to/from
 21  
  * the Network Time Protocol (NTP) data message header format described in RFC-1305.
 22  
  *
 23  
  * @author Naz Irizarry, MITRE Corp
 24  
  * @author Jason Mathews, MITRE Corp
 25  
  *
 26  
  * @version $Revision: 165675 $ $Date: 2005-05-02 15:09:55 -0500 (Mon, 02 May 2005) $
 27  
  */
 28  
 public class NtpV3Impl implements NtpV3Packet
 29  
 {
 30  
 
 31  
     private static final int MODE_INDEX = 0;
 32  
     private static final int MODE_SHIFT = 0;
 33  
 
 34  
     private static final int VERSION_INDEX = 0;
 35  
     private static final int VERSION_SHIFT = 3;
 36  
 
 37  
     private static final int LI_INDEX = 0;
 38  
     private static final int LI_SHIFT = 6;
 39  
 
 40  
     private static final int STRATUM_INDEX = 1;
 41  
     private static final int POLL_INDEX = 2;
 42  
     private static final int PRECISION_INDEX = 3;
 43  
 
 44  
     private static final int ROOT_DELAY_INDEX = 4;
 45  
     private static final int ROOT_DISPERSION_INDEX = 8;
 46  
     private static final int REFERENCE_ID_INDEX = 12;
 47  
 
 48  
     private static final int REFERENCE_TIMESTAMP_INDEX = 16;
 49  
     private static final int ORIGINATE_TIMESTAMP_INDEX = 24;
 50  
     private static final int RECEIVE_TIMESTAMP_INDEX = 32;
 51  
     private static final int TRANSMIT_TIMESTAMP_INDEX = 40;
 52  
 
 53  
     private static final int KEY_IDENTIFIER_INDEX = 48;
 54  
     private static final int MESSAGE_DIGEST = 54; /* len 16 bytes */
 55  
 
 56  0
     private byte[] buf = new byte[48];
 57  
 
 58  
     private DatagramPacket dp;
 59  
 
 60  
     /** Creates a new instance of NtpV3Impl */
 61  
     public NtpV3Impl()
 62  0
     {
 63  0
     }
 64  
 
 65  
     /***
 66  
      * Returns mode as defined in RFC-1305 which is a 3-bit integer
 67  
      * whose value is indicated by the MODE_xxx parameters.
 68  
      *
 69  
      * @return mode as defined in RFC-1305.
 70  
      */
 71  
     public int getMode()
 72  
     {
 73  0
         return (ui(buf[MODE_INDEX]) >> MODE_SHIFT) & 0x7;
 74  
     }
 75  
 
 76  
     /***
 77  
      * Return human-readable name of message mode type as described in
 78  
      * RFC 1305.
 79  
      * @return mode name as string.
 80  
      */
 81  
     public String getModeName()
 82  
     {
 83  0
         return NtpUtils.getModeName(getMode());
 84  
     }
 85  
 
 86  
     /***
 87  
      * Set mode as defined in RFC-1305.
 88  
      * @param mode
 89  
      */
 90  
     public void setMode(int mode)
 91  
     {
 92  0
         buf[MODE_INDEX] = (byte) (buf[MODE_INDEX] & 0xF8 | mode & 0x7);
 93  0
     }
 94  
 
 95  
     /***
 96  
      * Returns leap indicator as defined in RFC-1305 which is a two-bit code:
 97  
      *	0=no warning
 98  
      *	1=last minute has 61 seconds
 99  
      *	2=last minute has 59 seconds
 100  
      *	3=alarm condition (clock not synchronized)
 101  
      *
 102  
      * @return leap indicator as defined in RFC-1305.
 103  
      */
 104  
     public int getLeapIndicator()
 105  
     {
 106  0
         return (ui(buf[LI_INDEX]) >> LI_SHIFT) & 0x3;
 107  
     }
 108  
 
 109  
     /***
 110  
      * Set leap indicator as defined in RFC-1305.
 111  
      * @param li leap indicator.
 112  
      */
 113  
     public void setLeapIndicator(int li)
 114  
     {
 115  0
         buf[LI_INDEX] = (byte) (buf[LI_INDEX] & 0x3F | ((li & 0x3) << LI_SHIFT));
 116  0
     }
 117  
 
 118  
     /***
 119  
      * Returns poll interval as defined in RFC-1305, which is an eight-bit
 120  
      * signed integer indicating the maximum interval between successive
 121  
      * messages, in seconds to the nearest power of two (e.g. value of six
 122  
      * indicates an interval of 64 seconds. The values that can appear in
 123  
      * this field range from NTP_MINPOLL to NTP_MAXPOLL inclusive.
 124  
      *
 125  
      * @return poll interval as defined in RFC-1305.
 126  
      */
 127  
     public int getPoll()
 128  
     {
 129  0
         return (int) (buf[POLL_INDEX]);
 130  
     }
 131  
 
 132  
     /***
 133  
      * Set poll interval as defined in RFC-1305.
 134  
      *
 135  
      * @param poll poll interval.
 136  
      */
 137  
     public void setPoll(int poll)
 138  
     {
 139  0
         buf[POLL_INDEX] = (byte) (poll & 0xFF);
 140  0
     }
 141  
 
 142  
     /***
 143  
      * Returns precision as defined in RFC-1305 encoded as an 8-bit signed
 144  
      * integer (seconds to nearest power of two).
 145  
      * Values normally range from -6 to -20.
 146  
      *
 147  
      * @return precision as defined in RFC-1305.
 148  
      */
 149  
     public int getPrecision()
 150  
     {
 151  0
         return (int) buf[PRECISION_INDEX];
 152  
     }
 153  
 
 154  
     /***
 155  
      * Set precision as defined in RFC-1305.
 156  
      * @param precision
 157  
      */
 158  
     public void setPrecision(int precision)
 159  
     {
 160  0
         buf[PRECISION_INDEX] = (byte) (precision & 0xFF);
 161  0
     }
 162  
 
 163  
     /***
 164  
      * Returns NTP version number as defined in RFC-1305.
 165  
      *
 166  
      * @return NTP version number.
 167  
      */
 168  
     public int getVersion()
 169  
     {
 170  0
         return (ui(buf[VERSION_INDEX]) >> VERSION_SHIFT) & 0x7;
 171  
     }
 172  
 
 173  
     /***
 174  
      * Set NTP version as defined in RFC-1305.
 175  
      *
 176  
      * @param version NTP version.
 177  
      */
 178  
     public void setVersion(int version)
 179  
     {
 180  0
         buf[VERSION_INDEX] = (byte) (buf[VERSION_INDEX] & 0xC7 | ((version & 0x7) << VERSION_SHIFT));
 181  0
     }
 182  
 
 183  
     /***
 184  
      * Returns Stratum as defined in RFC-1305, which indicates the stratum level
 185  
      * of the local clock, with values defined as follows: 0=unspecified,
 186  
      * 1=primary ref clock, and all others a secondary reference (via NTP).
 187  
      *
 188  
      * @return Stratum level as defined in RFC-1305.
 189  
      */
 190  
     public int getStratum()
 191  
     {
 192  0
         return ui(buf[STRATUM_INDEX]);
 193  
     }
 194  
 
 195  
     /***
 196  
      * Set stratum level as defined in RFC-1305.
 197  
      *
 198  
      * @param stratum stratum level.
 199  
      */
 200  
     public void setStratum(int stratum)
 201  
     {
 202  0
         buf[STRATUM_INDEX] = (byte) (stratum & 0xFF);
 203  0
     }
 204  
 
 205  
     /***
 206  
      * Return root delay as defined in RFC-1305, which is the total roundtrip delay
 207  
      * to the primary reference source, in seconds. Values can take positive and
 208  
      * negative values, depending on clock precision and skew.
 209  
      *
 210  
      * @return root delay as defined in RFC-1305.
 211  
      */
 212  
     public int getRootDelay()
 213  
     {
 214  0
         return getInt(ROOT_DELAY_INDEX);
 215  
     }
 216  
 
 217  
     /***
 218  
      * Return root delay as defined in RFC-1305 in milliseconds, which is
 219  
      * the total roundtrip delay to the primary reference source, in
 220  
      * seconds. Values can take positive and negative values, depending
 221  
      * on clock precision and skew.
 222  
      *
 223  
      * @return root delay in milliseconds
 224  
      */
 225  
     public double getRootDelayInMillisDouble()
 226  
     {
 227  0
         double l = getRootDelay();
 228  0
         return l / 65.536;
 229  
     }
 230  
 
 231  
     /***
 232  
      * Returns root dispersion as defined in RFC-1305.
 233  
      * @return root dispersion.
 234  
      */
 235  
     public int getRootDispersion()
 236  
     {
 237  0
         return getInt(ROOT_DISPERSION_INDEX);
 238  
     }
 239  
 
 240  
     /***
 241  
      * Returns root dispersion (as defined in RFC-1305) in milliseconds.
 242  
      *
 243  
      * @return root dispersion in milliseconds
 244  
      */
 245  
     public long getRootDispersionInMillis()
 246  
     {
 247  0
         long l = getRootDispersion();
 248  0
         return (l * 1000) / 65536L;
 249  
     }
 250  
 
 251  
     /***
 252  
      * Returns root dispersion (as defined in RFC-1305) in milliseconds
 253  
      * as double precision value.
 254  
      *
 255  
      * @return root dispersion in milliseconds
 256  
      */
 257  
     public double getRootDispersionInMillisDouble()
 258  
     {
 259  0
         double l = getRootDispersion();
 260  0
         return l / 65.536;
 261  
     }
 262  
 
 263  
     /***
 264  
      * Set reference clock identifier field with 32-bit unsigned integer value.
 265  
      * See RFC-1305 for description.
 266  
      *
 267  
      * @param refId reference clock identifier.
 268  
      */
 269  
     public void setReferenceId(int refId)
 270  
     {
 271  0
         for (int i = 3; i >= 0; i--) {
 272  0
             buf[REFERENCE_ID_INDEX + i] = (byte) (refId & 0xff);
 273  0
             refId >>>= 8; // shift right one-byte
 274  
         }
 275  0
     }
 276  
 
 277  
     /***
 278  
      * Returns the reference id as defined in RFC-1305, which is
 279  
      * a 32-bit integer whose value is dependent on several criteria.
 280  
      *
 281  
      * @return the reference id as defined in RFC-1305.
 282  
      */
 283  
     public int getReferenceId()
 284  
     {
 285  0
         return getInt(REFERENCE_ID_INDEX);
 286  
     }
 287  
 
 288  
     /***
 289  
      * Returns the reference id string. String cannot be null but
 290  
      * value is dependent on the version of the NTP spec supported
 291  
      * and stratum level. Value can be an empty string, clock type string,
 292  
      * IP address, or a hex string.
 293  
      *
 294  
      * @return the reference id string.
 295  
      */
 296  
     public String getReferenceIdString()
 297  
     {
 298  0
         int version = getVersion();
 299  0
         int stratum = getStratum();
 300  0
         if (version == VERSION_3 || version == VERSION_4) {
 301  0
             if (stratum == 0 || stratum == 1) {
 302  0
                 return idAsString(); // 4-character ASCII string (e.g. GPS, USNO)
 303  
             }
 304  
             // in NTPv4 servers this is latest transmit timestamp of ref source
 305  0
             if (version == VERSION_4)
 306  0
                 return idAsHex();
 307  
         }
 308  
 
 309  
         // Stratum 2 and higher this is a four-octet IPv4 address
 310  
         // of the primary reference host.
 311  0
         if (stratum >= 2) {
 312  0
             return idAsIPAddress();
 313  
         }
 314  0
         return idAsHex();
 315  
     }
 316  
 
 317  
     /***
 318  
      * Returns Reference id as dotted IP address.
 319  
      * @return refId as IP address string.
 320  
      */
 321  
     private String idAsIPAddress()
 322  
     {
 323  0
         return ui(buf[REFERENCE_ID_INDEX]) + "." +
 324  
                 ui(buf[REFERENCE_ID_INDEX + 1]) + "." +
 325  
                 ui(buf[REFERENCE_ID_INDEX + 2]) + "." +
 326  
                 ui(buf[REFERENCE_ID_INDEX + 3]);
 327  
     }
 328  
 
 329  
     private String idAsString()
 330  
     {
 331  0
         String id = "";
 332  0
         for (int i = 0; i <= 3; i++) {
 333  0
             char c = (class="keyword">char) buf[REFERENCE_ID_INDEX + i];
 334  0
             if (c == 0) break; // 0-terminated string
 335  0
             id = id + c;
 336  
         }
 337  0
         return id;
 338  
     }
 339  
 
 340  
     private String idAsHex()
 341  
     {
 342  0
         return Integer.toHexString(getReferenceId());
 343  
     }
 344  
 
 345  
     /***
 346  
      * Returns the transmit timestamp as defined in RFC-1305.
 347  
      *
 348  
      * @return the transmit timestamp as defined in RFC-1305.
 349  
      * Never returns a null object.
 350  
      */
 351  
     public TimeStamp getTransmitTimeStamp()
 352  
     {
 353  0
         return getTimestamp(TRANSMIT_TIMESTAMP_INDEX);
 354  
     }
 355  
 
 356  
     /***
 357  
      * Set transmit time with NTP timestamp.
 358  
      * If <code>ts</code> is null then zero time is used.
 359  
      *
 360  
      * @param ts NTP timestamp
 361  
      */
 362  
     public void setTransmitTime(TimeStamp ts)
 363  
     {
 364  0
         setTimestamp(TRANSMIT_TIMESTAMP_INDEX, ts);
 365  0
     }
 366  
 
 367  
     /***
 368  
      * Set originate timestamp given NTP TimeStamp object.
 369  
      * If <code>ts</code> is null then zero time is used.
 370  
      *
 371  
      * @param ts NTP timestamp
 372  
      */
 373  
     public void setOriginateTimeStamp(TimeStamp ts)
 374  
     {
 375  0
         setTimestamp(ORIGINATE_TIMESTAMP_INDEX, ts);
 376  0
     }
 377  
 
 378  
     /***
 379  
      * Returns the originate time as defined in RFC-1305.
 380  
      *
 381  
      * @return the originate time.
 382  
      * Never returns null.
 383  
      */
 384  
     public TimeStamp getOriginateTimeStamp()
 385  
     {
 386  0
         return getTimestamp(ORIGINATE_TIMESTAMP_INDEX);
 387  
     }
 388  
 
 389  
     /***
 390  
      * Returns the reference time as defined in RFC-1305.
 391  
      *
 392  
      * @return the reference time as <code>TimeStamp</code> object.
 393  
      * Never returns null.
 394  
      */
 395  
     public TimeStamp getReferenceTimeStamp()
 396  
     {
 397  0
         return getTimestamp(REFERENCE_TIMESTAMP_INDEX);
 398  
     }
 399  
 
 400  
     /***
 401  
      * Set Reference time with NTP timestamp. If <code>ts</code> is null
 402  
      * then zero time is used.
 403  
      *
 404  
      * @param ts NTP timestamp
 405  
      */
 406  
     public void setReferenceTime(TimeStamp ts)
 407  
     {
 408  0
         setTimestamp(REFERENCE_TIMESTAMP_INDEX, ts);
 409  0
     }
 410  
 
 411  
     /***
 412  
      * Returns receive timestamp as defined in RFC-1305.
 413  
      *
 414  
      * @return the receive time.
 415  
      * Never returns null.
 416  
      */
 417  
     public TimeStamp getReceiveTimeStamp()
 418  
     {
 419  0
         return getTimestamp(RECEIVE_TIMESTAMP_INDEX);
 420  
     }
 421  
 
 422  
     /***
 423  
      * Set receive timestamp given NTP TimeStamp object.
 424  
      * If <code>ts</code> is null then zero time is used.
 425  
      *
 426  
      * @param ts timestamp
 427  
      */
 428  
     public void setReceiveTimeStamp(TimeStamp ts)
 429  
     {
 430  0
         setTimestamp(RECEIVE_TIMESTAMP_INDEX, ts);
 431  0
     }
 432  
 
 433  
     /***
 434  
      * Return type of time packet. The values (e.g. NTP, TIME, ICMP, ...)
 435  
      * correspond to the protocol used to obtain the timing information.
 436  
      *
 437  
      * @return packet type string identifier which in this case is "NTP".
 438  
      */
 439  
     public String getType()
 440  
     {
 441  0
         return "NTP";
 442  
     }
 443  
 
 444  
     /***
 445  
      * @return 4 bytes as 32-bit int
 446  
      */
 447  
     private int getInt(class="keyword">int index)
 448  
     {
 449  0
         int i = ui(buf[index]) << 24 |
 450  
                 ui(buf[index + 1]) << 16 |
 451  
                 ui(buf[index + 2]) << 8 |
 452  
                 ui(buf[index + 3]);
 453  
 
 454  0
         return i;
 455  
     }
 456  
 
 457  
     /***
 458  
      * Get NTP Timestamp at specified starting index.
 459  
      *
 460  
      * @param index index into data array
 461  
      * @return TimeStamp object for 64 bits starting at index
 462  
      */
 463  
     private TimeStamp getTimestamp(int index)
 464  
     {
 465  0
         return new TimeStamp(getLong(index));
 466  
     }
 467  
 
 468  
     /***
 469  
      * Get Long value represented by bits starting at specified index.
 470  
      *
 471  
      * @return 8 bytes as 64-bit long
 472  
      */
 473  
     private long getLong(int index)
 474  
     {
 475  0
         long i = ul(buf[index]) << 56 |
 476  
                 ul(buf[index + 1]) << 48 |
 477  
                 ul(buf[index + 2]) << 40 |
 478  
                 ul(buf[index + 3]) << 32 |
 479  
                 ul(buf[index + 4]) << 24 |
 480  
                 ul(buf[index + 5]) << 16 |
 481  
                 ul(buf[index + 6]) << 8 |
 482  
                 ul(buf[index + 7]);
 483  0
         return i;
 484  
     }
 485  
 
 486  
     /***
 487  
      * Sets the NTP timestamp at the given array index.
 488  
      *
 489  
      * @param index index into the byte array.
 490  
      * @param t TimeStamp.
 491  
      */
 492  
     private void setTimestamp(int index, TimeStamp t)
 493  
     {
 494  0
         long ntpTime = (t == null) ? 0 : t.ntpValue();
 495  
         // copy 64-bits from Long value into 8 x 8-bit bytes of array
 496  
         // one byte at a time shifting 8-bits for each position.
 497  0
         for (int i = 7; i >= 0; i--) {
 498  0
             buf[index + i] = (byte) (ntpTime & 0xFF);
 499  0
             ntpTime >>>= 8; // shift to next byte
 500  
         }
 501  
         // buf[index] |= 0x80;  // only set if 1900 baseline....
 502  0
     }
 503  
 
 504  
     /***
 505  
      * Returns the datagram packet with the NTP details already filled in.
 506  
      *
 507  
      * @return a datagram packet.
 508  
      */
 509  
     public DatagramPacket getDatagramPacket()
 510  
     {
 511  0
         if (dp == null)
 512  0
             synchronized(this) {
 513  0
                 if (dp == null) {
 514  0
                     dp = new DatagramPacket(buf, buf.length);
 515  0
                     dp.setPort(NTP_PORT);
 516  
                 }
 517  0
             }
 518  0
         return dp;
 519  
     }
 520  
 
 521  
     /***
 522  
      * Set the contents of this object from source datagram packet.
 523  
      *
 524  
      * @param srcDp source DatagramPacket to copy contents from.
 525  
      */
 526  
     public void setDatagramPacket(DatagramPacket srcDp)
 527  
     {
 528  0
         byte[] incomingBuf = srcDp.getData();
 529  0
         int len = srcDp.getLength();
 530  0
         if (len > buf.length)
 531  0
             len = buf.length;
 532  
 
 533  0
         System.arraycopy(incomingBuf, 0, buf, 0, len);
 534  0
     }
 535  
 
 536  
     /***
 537  
      * Convert byte to unsigned integer.
 538  
      * Java only has signed types so we have to do
 539  
      * more work to get unsigned ops.
 540  
      *
 541  
      * @param b
 542  
      * @return unsigned int value of byte
 543  
      */
 544  
     protected final static int ui(byte b)
 545  
     {
 546  0
         int i = b & 0xFF;
 547  0
         return i;
 548  
     }
 549  
 
 550  
     /***
 551  
      * Convert byte to unsigned long.
 552  
      * Java only has signed types so we have to do
 553  
      * more work to get unsigned ops
 554  
      *
 555  
      * @param b
 556  
      * @return unsigned long value of byte
 557  
      */
 558  
     protected final static long ul(byte b)
 559  
     {
 560  0
         long i = b & 0xFF;
 561  0
         return i;
 562  
     }
 563  
 
 564  
     /***
 565  
      * Returns details of NTP packet as a string.
 566  
      *
 567  
      * @return details of NTP packet as a string.
 568  
      */
 569  
     public String toString()
 570  
     {
 571  0
         return "[" +
 572  
                 "version:" + getVersion() +
 573  
                 ", mode:" + getMode() +
 574  
                 ", poll:" + getPoll() +
 575  
                 ", precision:" + getPrecision() +
 576  
                 ", delay:" + getRootDelay() +
 577  
                 ", dispersion(ms):" + getRootDispersionInMillisDouble() +
 578  
                 ", id:" + getReferenceIdString() +
 579  
                 ", xmitTime:" + getTransmitTimeStamp().toDateString() +
 580  
                 " ]";
 581  
     }
 582  
 
 583  
 }

This report is generated by jcoverage, Maven and Maven JCoverage Plugin.