Merge changes I6d3584f3,Ifdaada39 (f637a0d6) · Commits · e / os / android_frameworks_base

core/java/android/net/SntpClient.java

+137 −84

Original line number	Diff line number	Diff line
		@@ -17,16 +17,26 @@
		package android.net;

		import android.compat.annotation.UnsupportedAppUsage;
		import android.net.sntp.Duration64;
		import android.net.sntp.Timestamp64;
		import android.os.SystemClock;
		import android.util.Log;
		import android.util.Slog;

		import com.android.internal.annotations.VisibleForTesting;
		import com.android.internal.util.TrafficStatsConstants;

		import java.net.DatagramPacket;
		import java.net.DatagramSocket;
		import java.net.InetAddress;
		import java.net.UnknownHostException;
		import java.util.Arrays;
		import java.security.NoSuchAlgorithmException;
		import java.security.SecureRandom;
		import java.time.Duration;
		import java.time.Instant;
		import java.util.Objects;
		import java.util.Random;
		import java.util.function.Supplier;

		/**
		* {@hide}
		@@ -60,17 +70,21 @@ public class SntpClient {
		private static final int NTP_STRATUM_DEATH = 0;
		private static final int NTP_STRATUM_MAX = 15;

		// Number of seconds between Jan 1, 1900 and Jan 1, 1970
		// 70 years plus 17 leap days
		private static final long OFFSET_1900_TO_1970 = ((365L * 70L) + 17L) * 24L * 60L * 60L;
		// The source of the current system clock time, replaceable for testing.
		private final Supplier<Instant> mSystemTimeSupplier;

		// system time computed from NTP server response
		private final Random mRandom;

		// The last offset calculated from an NTP server response
		private long mClockOffset;

		// The last system time computed from an NTP server response
		private long mNtpTime;

		// value of SystemClock.elapsedRealtime() corresponding to mNtpTime
		// The value of SystemClock.elapsedRealtime() corresponding to mNtpTime / mClockOffset
		private long mNtpTimeReference;

		// round trip time in milliseconds
		// The round trip (network) time in milliseconds
		private long mRoundTripTime;

		private static class InvalidServerReplyException extends Exception {
		@@ -81,6 +95,13 @@ public class SntpClient {

		@UnsupportedAppUsage
		public SntpClient() {
		this(Instant::now, defaultRandom());
		}

		@VisibleForTesting
		public SntpClient(Supplier<Instant> systemTimeSupplier, Random random) {
		mSystemTimeSupplier = Objects.requireNonNull(systemTimeSupplier);
		mRandom = Objects.requireNonNull(random);
		}

		/**
		@@ -126,9 +147,13 @@ public class SntpClient {
		buffer[0] = NTP_MODE_CLIENT \| (NTP_VERSION << 3);

		// get current time and write it to the request packet
		final long requestTime = System.currentTimeMillis();
		final Instant requestTime = mSystemTimeSupplier.get();
		final Timestamp64 requestTimestamp = Timestamp64.fromInstant(requestTime);

		final Timestamp64 randomizedRequestTimestamp =
		requestTimestamp.randomizeSubMillis(mRandom);
		final long requestTicks = SystemClock.elapsedRealtime();
		writeTimeStamp(buffer, TRANSMIT_TIME_OFFSET, requestTime);
		writeTimeStamp(buffer, TRANSMIT_TIME_OFFSET, randomizedRequestTimestamp);

		socket.send(request);

		@@ -136,42 +161,44 @@ public class SntpClient {
		DatagramPacket response = new DatagramPacket(buffer, buffer.length);
		socket.receive(response);
		final long responseTicks = SystemClock.elapsedRealtime();
		final long responseTime = requestTime + (responseTicks - requestTicks);
		final Instant responseTime = requestTime.plusMillis(responseTicks - requestTicks);
		final Timestamp64 responseTimestamp = Timestamp64.fromInstant(responseTime);

		// extract the results
		final byte leap = (byte) ((buffer[0] >> 6) & 0x3);
		final byte mode = (byte) (buffer[0] & 0x7);
		final int stratum = (int) (buffer[1] & 0xff);
		final long originateTime = readTimeStamp(buffer, ORIGINATE_TIME_OFFSET);
		final long receiveTime = readTimeStamp(buffer, RECEIVE_TIME_OFFSET);
		final long transmitTime = readTimeStamp(buffer, TRANSMIT_TIME_OFFSET);
		final long referenceTime = readTimeStamp(buffer, REFERENCE_TIME_OFFSET);
		final Timestamp64 referenceTimestamp = readTimeStamp(buffer, REFERENCE_TIME_OFFSET);
		final Timestamp64 originateTimestamp = readTimeStamp(buffer, ORIGINATE_TIME_OFFSET);
		final Timestamp64 receiveTimestamp = readTimeStamp(buffer, RECEIVE_TIME_OFFSET);
		final Timestamp64 transmitTimestamp = readTimeStamp(buffer, TRANSMIT_TIME_OFFSET);

		/* Do validation according to RFC */
		// TODO: validate originateTime == requestTime.
		checkValidServerReply(leap, mode, stratum, transmitTime, referenceTime);

		long roundTripTime = responseTicks - requestTicks - (transmitTime - receiveTime);
		// receiveTime = originateTime + transit + skew
		// responseTime = transmitTime + transit - skew
		// clockOffset = ((receiveTime - originateTime) + (transmitTime - responseTime))/2
		// = ((originateTime + transit + skew - originateTime) +
		// (transmitTime - (transmitTime + transit - skew)))/2
		// = ((transit + skew) + (transmitTime - transmitTime - transit + skew))/2
		// = (transit + skew - transit + skew)/2
		// = (2 * skew)/2 = skew
		long clockOffset = ((receiveTime - originateTime) + (transmitTime - responseTime))/2;
		EventLogTags.writeNtpSuccess(address.toString(), roundTripTime, clockOffset);
		checkValidServerReply(leap, mode, stratum, transmitTimestamp, referenceTimestamp,
		randomizedRequestTimestamp, originateTimestamp);

		long totalTransactionDurationMillis = responseTicks - requestTicks;
		long serverDurationMillis =
		Duration64.between(receiveTimestamp, transmitTimestamp).toDuration().toMillis();
		long roundTripTimeMillis = totalTransactionDurationMillis - serverDurationMillis;

		Duration clockOffsetDuration = calculateClockOffset(requestTimestamp,
		receiveTimestamp, transmitTimestamp, responseTimestamp);
		long clockOffsetMillis = clockOffsetDuration.toMillis();

		EventLogTags.writeNtpSuccess(
		address.toString(), roundTripTimeMillis, clockOffsetMillis);
		if (DBG) {
		Log.d(TAG, "round trip: " + roundTripTime + "ms, " +
		"clock offset: " + clockOffset + "ms");
		Log.d(TAG, "round trip: " + roundTripTimeMillis + "ms, "
		+ "clock offset: " + clockOffsetMillis + "ms");
		}

		// save our results - use the times on this side of the network latency
		// (response rather than request time)
		mNtpTime = responseTime + clockOffset;
		mClockOffset = clockOffsetMillis;
		mNtpTime = responseTime.plus(clockOffsetDuration).toEpochMilli();
		mNtpTimeReference = responseTicks;
		mRoundTripTime = roundTripTime;
		mRoundTripTime = roundTripTimeMillis;
		} catch (Exception e) {
		EventLogTags.writeNtpFailure(address.toString(), e.toString());
		if (DBG) Log.d(TAG, "request time failed: " + e);
		@@ -186,6 +213,28 @@ public class SntpClient {
		return true;
		}

		/** Performs the NTP clock offset calculation. */
		@VisibleForTesting
		public static Duration calculateClockOffset(Timestamp64 clientRequestTimestamp,
		Timestamp64 serverReceiveTimestamp, Timestamp64 serverTransmitTimestamp,
		Timestamp64 clientResponseTimestamp) {
		// According to RFC4330:
		// t is the system clock offset (the adjustment we are trying to find)
		// t = ((T2 - T1) + (T3 - T4)) / 2
		//
		// Which is:
		// t = (([server]receiveTimestamp - [client]requestTimestamp)
		// + ([server]transmitTimestamp - [client]responseTimestamp)) / 2
		//
		// See the NTP spec and tests: the numeric types used are deliberate:
		// + Duration64.between() uses 64-bit arithmetic (32-bit for the seconds).
		// + plus() / dividedBy() use Duration, which isn't the double precision floating point
		// used in NTPv4, but is good enough.
		return Duration64.between(clientRequestTimestamp, serverReceiveTimestamp)
		.plus(Duration64.between(clientResponseTimestamp, serverTransmitTimestamp))
		.dividedBy(2);
		}

		@Deprecated
		@UnsupportedAppUsage
		public boolean requestTime(String host, int timeout) {
		@@ -193,6 +242,14 @@ public class SntpClient {
		return false;
		}

		/**
		* Returns the offset calculated to apply to the client clock to arrive at {@link #getNtpTime()}
		*/
		@VisibleForTesting
		public long getClockOffset() {
		return mClockOffset;
		}

		/**
		* Returns the time computed from the NTP transaction.
		*
		@@ -225,8 +282,9 @@ public class SntpClient {
		}

		private static void checkValidServerReply(
		byte leap, byte mode, int stratum, long transmitTime, long referenceTime)
		throws InvalidServerReplyException {
		byte leap, byte mode, int stratum, Timestamp64 transmitTimestamp,
		Timestamp64 referenceTimestamp, Timestamp64 randomizedRequestTimestamp,
		Timestamp64 originateTimestamp) throws InvalidServerReplyException {
		if (leap == NTP_LEAP_NOSYNC) {
		throw new InvalidServerReplyException("unsynchronized server");
		}
		@@ -236,73 +294,68 @@ public class SntpClient {
		if ((stratum == NTP_STRATUM_DEATH) \|\| (stratum > NTP_STRATUM_MAX)) {
		throw new InvalidServerReplyException("untrusted stratum: " + stratum);
		}
		if (transmitTime == 0) {
		throw new InvalidServerReplyException("zero transmitTime");
		if (!randomizedRequestTimestamp.equals(originateTimestamp)) {
		throw new InvalidServerReplyException(
		"originateTimestamp != randomizedRequestTimestamp");
		}
		if (transmitTimestamp.equals(Timestamp64.ZERO)) {
		throw new InvalidServerReplyException("zero transmitTimestamp");
		}
		if (referenceTime == 0) {
		throw new InvalidServerReplyException("zero reference timestamp");
		if (referenceTimestamp.equals(Timestamp64.ZERO)) {
		throw new InvalidServerReplyException("zero referenceTimestamp");
		}
		}

		/**
		* Reads an unsigned 32 bit big endian number from the given offset in the buffer.
		*/
		private long read32(byte[] buffer, int offset) {
		byte b0 = buffer[offset];
		byte b1 = buffer[offset+1];
		byte b2 = buffer[offset+2];
		byte b3 = buffer[offset+3];

		// convert signed bytes to unsigned values
		int i0 = ((b0 & 0x80) == 0x80 ? (b0 & 0x7F) + 0x80 : b0);
		int i1 = ((b1 & 0x80) == 0x80 ? (b1 & 0x7F) + 0x80 : b1);
		int i2 = ((b2 & 0x80) == 0x80 ? (b2 & 0x7F) + 0x80 : b2);
		int i3 = ((b3 & 0x80) == 0x80 ? (b3 & 0x7F) + 0x80 : b3);

		return ((long)i0 << 24) + ((long)i1 << 16) + ((long)i2 << 8) + (long)i3;
		private long readUnsigned32(byte[] buffer, int offset) {
		int i0 = buffer[offset++] & 0xFF;
		int i1 = buffer[offset++] & 0xFF;
		int i2 = buffer[offset++] & 0xFF;
		int i3 = buffer[offset] & 0xFF;

		int bits = (i0 << 24) \| (i1 << 16) \| (i2 << 8) \| i3;
		return bits & 0xFFFF_FFFFL;
		}

		/**
		* Reads the NTP time stamp at the given offset in the buffer and returns
		* it as a system time (milliseconds since January 1, 1970).
		* Reads the NTP time stamp from the given offset in the buffer.
		*/
		private long readTimeStamp(byte[] buffer, int offset) {
		long seconds = read32(buffer, offset);
		long fraction = read32(buffer, offset + 4);
		// Special case: zero means zero.
		if (seconds == 0 && fraction == 0) {
		return 0;
		}
		return ((seconds - OFFSET_1900_TO_1970) * 1000) + ((fraction * 1000L) / 0x100000000L);
		private Timestamp64 readTimeStamp(byte[] buffer, int offset) {
		long seconds = readUnsigned32(buffer, offset);
		int fractionBits = (int) readUnsigned32(buffer, offset + 4);
		return Timestamp64.fromComponents(seconds, fractionBits);
		}

		/**
		* Writes system time (milliseconds since January 1, 1970) as an NTP time stamp
		* at the given offset in the buffer.
		* Writes the NTP time stamp at the given offset in the buffer.
		*/
		private void writeTimeStamp(byte[] buffer, int offset, long time) {
		// Special case: zero means zero.
		if (time == 0) {
		Arrays.fill(buffer, offset, offset + 8, (byte) 0x00);
		return;
		}

		long seconds = time / 1000L;
		long milliseconds = time - seconds * 1000L;
		seconds += OFFSET_1900_TO_1970;

		private void writeTimeStamp(byte[] buffer, int offset, Timestamp64 timestamp) {
		long seconds = timestamp.getEraSeconds();
		// write seconds in big endian format
		buffer[offset++] = (byte)(seconds >> 24);
		buffer[offset++] = (byte)(seconds >> 16);
		buffer[offset++] = (byte)(seconds >> 8);
		buffer[offset++] = (byte)(seconds >> 0);
		buffer[offset++] = (byte) (seconds >>> 24);
		buffer[offset++] = (byte) (seconds >>> 16);
		buffer[offset++] = (byte) (seconds >>> 8);
		buffer[offset++] = (byte) (seconds);

		long fraction = milliseconds * 0x100000000L / 1000L;
		int fractionBits = timestamp.getFractionBits();
		// write fraction in big endian format
		buffer[offset++] = (byte)(fraction >> 24);
		buffer[offset++] = (byte)(fraction >> 16);
		buffer[offset++] = (byte)(fraction >> 8);
		// low order bits should be random data
		buffer[offset++] = (byte)(Math.random() * 255.0);
		buffer[offset++] = (byte) (fractionBits >>> 24);
		buffer[offset++] = (byte) (fractionBits >>> 16);
		buffer[offset++] = (byte) (fractionBits >>> 8);
		buffer[offset] = (byte) (fractionBits);
		}

		private static Random defaultRandom() {
		Random random;
		try {
		random = SecureRandom.getInstanceStrong();
		} catch (NoSuchAlgorithmException e) {
		// This should never happen.
		Slog.wtf(TAG, "Unable to access SecureRandom", e);
		random = new Random(System.currentTimeMillis());
		}
		return random;
		}
		}

core/java/android/net/sntp/Duration64.java

0 → 100644

+141 −0

Original line number	Diff line number	Diff line
		/*
		* Copyright (C) 2021 The Android Open Source Project
		*
		* Licensed under the Apache License, Version 2.0 (the "License");
		* you may not use this file except in compliance with the License.
		* You may obtain a copy of the License 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 android.net.sntp;

		import java.time.Duration;

		/**
		* A type similar to {@link Timestamp64} but used when calculating the difference between two
		* timestamps. As such, it is a signed type, but still uses 64-bits in total and so can only
		* represent half the magnitude of {@link Timestamp64}.
		*
		* <p>See <a href="https://www.eecis.udel.edu/~mills/time.html">4. Time Difference Calculations</a>.
		*
		* @hide
		*/
		public class Duration64 {

		public static final Duration64 ZERO = new Duration64(0);
		private final long mBits;

		private Duration64(long bits) {
		this.mBits = bits;
		}

		/**
		* Returns the difference between two 64-bit NTP timestamps as a {@link Duration64}, as
		* described in the NTP spec. The times represented by the timestamps have to be within {@link
		* Timestamp64#MAX_SECONDS_IN_ERA} (~68 years) of each other for the calculation to produce a
		* correct answer.
		*/
		public static Duration64 between(Timestamp64 startInclusive, Timestamp64 endExclusive) {
		long oneBits = (startInclusive.getEraSeconds() << 32)
		\| (startInclusive.getFractionBits() & 0xFFFF_FFFFL);
		long twoBits = (endExclusive.getEraSeconds() << 32)
		\| (endExclusive.getFractionBits() & 0xFFFF_FFFFL);
		long resultBits = twoBits - oneBits;
		return new Duration64(resultBits);
		}

		/**
		* Add two {@link Duration64} instances together. This performs the calculation in {@link
		* Duration} and returns a {@link Duration} to increase the magnitude of accepted arguments,
		* since {@link Duration64} only supports signed 32-bit seconds. The use of {@link Duration}
		* limits precision to nanoseconds.
		*/
		public Duration plus(Duration64 other) {
		// From https://www.eecis.udel.edu/~mills/time.html:
		// "The offset and delay calculations require sums and differences of these raw timestamp
		// differences that can span no more than from 34 years in the future to 34 years in the
		// past without overflow. This is a fundamental limitation in 64-bit integer calculations.
		//
		// In the NTPv4 reference implementation, all calculations involving offset and delay values
		// use 64-bit floating double arithmetic, with the exception of raw timestamp subtraction,
		// as mentioned above. The raw timestamp differences are then converted to 64-bit floating
		// double format without loss of precision or chance of overflow in subsequent
		// calculations."
		//
		// Here, we use Duration instead, which provides sufficient range, but loses precision below
		// nanos.
		return this.toDuration().plus(other.toDuration());
		}

		/**
		* Returns a {@link Duration64} equivalent of the supplied duration, if the magnitude can be
		* represented. Because {@link Duration64} uses a fixed point type for sub-second values it
		* cannot represent all nanosecond values precisely and so the conversion can be lossy.
		*
		* @throws IllegalArgumentException if the supplied duration is too big to be represented
		*/
		public static Duration64 fromDuration(Duration duration) {
		long seconds = duration.getSeconds();
		if (seconds < Integer.MIN_VALUE \|\| seconds > Integer.MAX_VALUE) {
		throw new IllegalArgumentException();
		}
		long bits = (seconds << 32)
		\| (Timestamp64.nanosToFractionBits(duration.getNano()) & 0xFFFF_FFFFL);
		return new Duration64(bits);
		}

		/**
		* Returns a {@link Duration} equivalent of this duration. Because {@link Duration64} uses a
		* fixed point type for sub-second values it can values smaller than nanosecond precision and so
		* the conversion can be lossy.
		*/
		public Duration toDuration() {
		int seconds = getSeconds();
		int nanos = getNanos();
		return Duration.ofSeconds(seconds, nanos);
		}

		@Override
		public boolean equals(Object o) {
		if (this == o) {
		return true;
		}
		if (o == null \|\| getClass() != o.getClass()) {
		return false;
		}
		Duration64 that = (Duration64) o;
		return mBits == that.mBits;
		}

		@Override
		public int hashCode() {
		return java.util.Objects.hash(mBits);
		}

		@Override
		public String toString() {
		Duration duration = toDuration();
		return Long.toHexString(mBits)
		+ "(" + duration.getSeconds() + "s " + duration.getNano() + "ns)";
		}

		/**
		* Returns the <em>signed</em> seconds in this duration.
		*/
		public int getSeconds() {
		return (int) (mBits >> 32);
		}

		/**
		* Returns the <em>unsigned</em> nanoseconds in this duration (truncated).
		*/
		public int getNanos() {
		return Timestamp64.fractionBitsToNanos((int) (mBits & 0xFFFF_FFFFL));
		}
		}

core/java/android/net/sntp/Timestamp64.java

0 → 100644

+186 −0

File added.

Preview size limit exceeded, changes collapsed.

core/tests/coretests/src/android/net/SntpClientTest.java

+284 −25

File changed.

Preview size limit exceeded, changes collapsed.

core/tests/coretests/src/android/net/sntp/Duration64Test.java

0 → 100644

+264 −0

File added.

Preview size limit exceeded, changes collapsed.