android-34/com/android/okhttp/internal/Platform.java - platform/prebuilts/fullsdk/sources - Git at Google

 /* GENERATED SOURCE. DO NOT MODIFY. */
 /*
  * Copyright (C) 2012 Square, Inc.
  * Copyright (C) 2012 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 com.android.okhttp.internal;

 import android.net.ssl.SSLSockets;
 import com.android.okhttp.Protocol;
 import com.android.okhttp.internal.tls.RealTrustRootIndex;
 import com.android.okhttp.internal.tls.TrustRootIndex;

 import java.io.IOException;
 import java.lang.reflect.Field;
 import java.net.InetSocketAddress;
 import java.net.Socket;
 import java.net.SocketException;
 import java.util.Collections;
 import java.util.List;
 import java.util.concurrent.atomic.AtomicReference;
 import javax.net.ssl.SNIHostName;
 import javax.net.ssl.SNIServerName;
 import javax.net.ssl.SSLParameters;
 import javax.net.ssl.SSLSocket;
 import javax.net.ssl.SSLSocketFactory;
 import javax.net.ssl.X509TrustManager;

 import dalvik.system.SocketTagger;
 import com.android.okhttp.okio.Buffer;

 /**
  * Access to proprietary Android APIs. Avoids use of reflection where possible.
  * @hide This class is not part of the Android public SDK API
  */
 // only tests should extend this class
 public class Platform {
     private static final AtomicReference<Platform> INSTANCE_HOLDER
             = new AtomicReference<>(new Platform());

     // only for private use and in tests
     protected Platform() {
     }

     @android.compat.annotation.UnsupportedAppUsage
     public static Platform get() {
         return INSTANCE_HOLDER.get();
     }

     /**
      * Atomically replaces the Platform instance returned by future
      * invocations of {@link #get()}, for use in tests.
      * Invocations of this method should typically be followed by
      * a try/finally block to reset the previous value:
      *
      * <pre>
      * Platform p = getAndSetForTest(...);
      * try {
      *   ...
      * } finally {
      *   getAndSetForTest(p);
      * }
      * </pre>
      *
      * @return the previous value of {@link #get()}.
      */
     public static Platform getAndSetForTest(Platform platform) {
         if (platform == null) {
             throw new NullPointerException();
         }
         return INSTANCE_HOLDER.getAndSet(platform);
     }

     // NOTE: Prior to Android Q, the standard way of accessing some Conscrypt features was to
     // use reflection to call hidden APIs.  Beginning in Q, there is public API for all of these
     // features.  We attempt to use the public API where possible, but also still call the
     // hidden versions to continue to support old versions of Conscrypt that might be bundled with
     // apps or third-party TLS providers that might have taken advantage of being able to
     // duck-type their way into compatibility.  For more background, see b/128280837.

     /** setUseSessionTickets(boolean) */
     private static final OptionalMethod<Socket> SET_USE_SESSION_TICKETS =
             new OptionalMethod<Socket>(null, "setUseSessionTickets", Boolean.TYPE);
     /** setHostname(String) */
     private static final OptionalMethod<Socket> SET_HOSTNAME =
             new OptionalMethod<Socket>(null, "setHostname", String.class);
     /** byte[] getAlpnSelectedProtocol() */
     private static final OptionalMethod<Socket> GET_ALPN_SELECTED_PROTOCOL =
             new OptionalMethod<Socket>(byte[].class, "getAlpnSelectedProtocol");
     /** setAlpnSelectedProtocol(byte[]) */
     private static final OptionalMethod<Socket> SET_ALPN_PROTOCOLS =
             new OptionalMethod<Socket>(null, "setAlpnProtocols", byte[].class );

     @android.compat.annotation.UnsupportedAppUsage
     public void logW(String warning) {
         System.logW(warning);
     }

     public void tagSocket(Socket socket) throws SocketException {
         SocketTagger.get().tag(socket);
     }

     public void untagSocket(Socket socket) throws SocketException {
         SocketTagger.get().untag(socket);
     }

     public void configureTlsExtensions(
             SSLSocket sslSocket, String hostname, List<Protocol> protocols) {
         // All extensions here use both public API and reflective calls, see note above.
         SSLParameters sslParams = sslSocket.getSSLParameters();
         if (hostname != null) {
             // Enable session tickets
             if (SSLSockets.isSupportedSocket(sslSocket)) {
                 SSLSockets.setUseSessionTickets(sslSocket, true);
             } else {
                 SET_USE_SESSION_TICKETS.invokeOptionalWithoutCheckedException(sslSocket, true);
             }
             try {
                 // Enable SNI
                 sslParams.setServerNames(
                     Collections.<SNIServerName>singletonList(new SNIHostName(hostname)));
             } catch (IllegalArgumentException ignored) {
                 // The hostname isn't a valid SNI value, so ignore the exception and don't set
                 // a server name, which results in no SNI extension being sent.
             }
             if (!isPlatformSocket(sslSocket)) {
                 SET_HOSTNAME.invokeOptionalWithoutCheckedException(sslSocket, hostname);
             }
         }

         // Enable ALPN, if necessary
         sslParams.setApplicationProtocols(getProtocolIds(protocols));

         if (!isPlatformSocket(sslSocket) && SET_ALPN_PROTOCOLS.isSupported(sslSocket)) {
             Object[] parameters = {concatLengthPrefixed(protocols)};
             SET_ALPN_PROTOCOLS.invokeWithoutCheckedException(sslSocket, parameters);
         }
         sslSocket.setSSLParameters(sslParams);
     }

     /**
      * Called after the TLS handshake to release resources allocated by {@link
      * #configureTlsExtensions}.
      */
     public void afterHandshake(SSLSocket sslSocket) {
     }

     public String getSelectedProtocol(SSLSocket socket) {
         // This API was added in Android Q
         try {
             return socket.getApplicationProtocol();
         } catch (UnsupportedOperationException ignored) {
             // The socket doesn't support this API, try the old reflective method
         }
         // This method was used through Android P, see note above
         boolean alpnSupported = GET_ALPN_SELECTED_PROTOCOL.isSupported(socket);
         if (!alpnSupported) {
             return null;
         }

         byte[] alpnResult =
                 (byte[]) GET_ALPN_SELECTED_PROTOCOL.invokeWithoutCheckedException(socket);
         if (alpnResult != null) {
             return new String(alpnResult, Util.UTF_8);
         }
         return null;
     }

     public void connectSocket(Socket socket, InetSocketAddress address,
               int connectTimeout) throws IOException {
         socket.connect(address, connectTimeout);
     }

     /** Prefix used on custom headers. */
     public String getPrefix() {
         return "X-Android";
     }

     /**
      * Stripped down/adapted from OkHttp's {@code Platform.Android.trustManager()}.
      * OkHttp 2.7.5 uses this only for certificate pinning logic that we don't use
      * on Android, so this method should never be called outside of OkHttp's tests.
      * This method has been stripped down to the minimum for OkHttp's tests to pass.
      */
     public X509TrustManager trustManager(SSLSocketFactory sslSocketFactory) {
         Class sslParametersClass;
         try {
             sslParametersClass = Class.forName("com.android.org.conscrypt.SSLParametersImpl");
         } catch (ClassNotFoundException e) {
             throw new RuntimeException(e);
         }
         Object context = readFieldOrNull(sslSocketFactory, sslParametersClass, "sslParameters");
         return readFieldOrNull(context, X509TrustManager.class, "x509TrustManager");
     }

     /**
      * Stripped down from OkHttp's implementation to the minimum to get OkHttp's tests
      * to pass. OkHttp 2.7.5 uses this for certificate pinning logic which is unused
      * in Android. This method should never be called outside of OkHttp's tests.
      */
     public TrustRootIndex trustRootIndex(X509TrustManager trustManager) {
         return new RealTrustRootIndex(trustManager.getAcceptedIssuers());
     }

     // Helper method from OkHttp's Platform.java
     private static <T> T readFieldOrNull(Object instance, Class<T> fieldType, String fieldName) {
         for (Class<?> c = instance.getClass(); c != Object.class; c = c.getSuperclass()) {
             try {
                 Field field = c.getDeclaredField(fieldName);
                 field.setAccessible(true);
                 Object value = field.get(instance);
                 if (value == null || !fieldType.isInstance(value)) return null;
                 return fieldType.cast(value);
             } catch (NoSuchFieldException ignored) {
             } catch (IllegalAccessException e) {
                 throw new AssertionError();
             }
         }

         // Didn't find the field we wanted. As a last gasp attempt, try to find the value on a delegate.
         if (!fieldName.equals("delegate")) {
             Object delegate = readFieldOrNull(instance, Object.class, "delegate");
             if (delegate != null) return readFieldOrNull(delegate, fieldType, fieldName);
         }

         return null;
     }

     private static boolean isPlatformSocket(SSLSocket socket) {
         return socket.getClass().getName().startsWith("com.android.org.conscrypt");
     }

     private static String[] getProtocolIds(List<Protocol> protocols) {
         String[] result = new String[protocols.size()];
         for (int i = 0; i < protocols.size(); i++) {
             result[i] = protocols.get(i).toString();
         }
         return result;
     }

     /**
      * Returns the concatenation of 8-bit, length prefixed protocol names.
      * http://tools.ietf.org/html/draft-agl-tls-nextprotoneg-04#page-4
      */
     static byte[] concatLengthPrefixed(List<Protocol> protocols) {
         Buffer result = new Buffer();
         for (int i = 0, size = protocols.size(); i < size; i++) {
             Protocol protocol = protocols.get(i);
             if (protocol == Protocol.HTTP_1_0) continue; // No HTTP/1.0 for ALPN.
             result.writeByte(protocol.toString().length());
             result.writeUtf8(protocol.toString());
         }
         return result.readByteArray();
     }
 }
	/* GENERATED SOURCE. DO NOT MODIFY. */
	/*
	* Copyright (C) 2012 Square, Inc.
	* Copyright (C) 2012 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 com.android.okhttp.internal;

	import android.net.ssl.SSLSockets;
	import com.android.okhttp.Protocol;
	import com.android.okhttp.internal.tls.RealTrustRootIndex;
	import com.android.okhttp.internal.tls.TrustRootIndex;

	import java.io.IOException;
	import java.lang.reflect.Field;
	import java.net.InetSocketAddress;
	import java.net.Socket;
	import java.net.SocketException;
	import java.util.Collections;
	import java.util.List;
	import java.util.concurrent.atomic.AtomicReference;
	import javax.net.ssl.SNIHostName;
	import javax.net.ssl.SNIServerName;
	import javax.net.ssl.SSLParameters;
	import javax.net.ssl.SSLSocket;
	import javax.net.ssl.SSLSocketFactory;
	import javax.net.ssl.X509TrustManager;

	import dalvik.system.SocketTagger;
	import com.android.okhttp.okio.Buffer;

	/**
	* Access to proprietary Android APIs. Avoids use of reflection where possible.
	* @hide This class is not part of the Android public SDK API
	*/
	// only tests should extend this class
	public class Platform {
	private static final AtomicReference<Platform> INSTANCE_HOLDER
	= new AtomicReference<>(new Platform());

	// only for private use and in tests
	protected Platform() {
	}

	@android.compat.annotation.UnsupportedAppUsage
	public static Platform get() {
	return INSTANCE_HOLDER.get();
	}

	/**
	* Atomically replaces the Platform instance returned by future
	* invocations of {@link #get()}, for use in tests.
	* Invocations of this method should typically be followed by
	* a try/finally block to reset the previous value:
	*
	* <pre>
	* Platform p = getAndSetForTest(...);
	* try {
	* ...
	* } finally {
	* getAndSetForTest(p);
	* }
	* </pre>
	*
	* @return the previous value of {@link #get()}.
	*/
	public static Platform getAndSetForTest(Platform platform) {
	if (platform == null) {
	throw new NullPointerException();
	}
	return INSTANCE_HOLDER.getAndSet(platform);
	}

	// NOTE: Prior to Android Q, the standard way of accessing some Conscrypt features was to
	// use reflection to call hidden APIs. Beginning in Q, there is public API for all of these
	// features. We attempt to use the public API where possible, but also still call the
	// hidden versions to continue to support old versions of Conscrypt that might be bundled with
	// apps or third-party TLS providers that might have taken advantage of being able to
	// duck-type their way into compatibility. For more background, see b/128280837.

	/** setUseSessionTickets(boolean) */
	private static final OptionalMethod<Socket> SET_USE_SESSION_TICKETS =
	new OptionalMethod<Socket>(null, "setUseSessionTickets", Boolean.TYPE);
	/** setHostname(String) */
	private static final OptionalMethod<Socket> SET_HOSTNAME =
	new OptionalMethod<Socket>(null, "setHostname", String.class);
	/** byte[] getAlpnSelectedProtocol() */
	private static final OptionalMethod<Socket> GET_ALPN_SELECTED_PROTOCOL =
	new OptionalMethod<Socket>(byte[].class, "getAlpnSelectedProtocol");
	/** setAlpnSelectedProtocol(byte[]) */
	private static final OptionalMethod<Socket> SET_ALPN_PROTOCOLS =
	new OptionalMethod<Socket>(null, "setAlpnProtocols", byte[].class );

	@android.compat.annotation.UnsupportedAppUsage
	public void logW(String warning) {
	System.logW(warning);
	}

	public void tagSocket(Socket socket) throws SocketException {
	SocketTagger.get().tag(socket);
	}

	public void untagSocket(Socket socket) throws SocketException {
	SocketTagger.get().untag(socket);
	}

	public void configureTlsExtensions(
	SSLSocket sslSocket, String hostname, List<Protocol> protocols) {
	// All extensions here use both public API and reflective calls, see note above.
	SSLParameters sslParams = sslSocket.getSSLParameters();
	if (hostname != null) {
	// Enable session tickets
	if (SSLSockets.isSupportedSocket(sslSocket)) {
	SSLSockets.setUseSessionTickets(sslSocket, true);
	} else {
	SET_USE_SESSION_TICKETS.invokeOptionalWithoutCheckedException(sslSocket, true);
	}
	try {
	// Enable SNI
	sslParams.setServerNames(
	Collections.<SNIServerName>singletonList(new SNIHostName(hostname)));
	} catch (IllegalArgumentException ignored) {
	// The hostname isn't a valid SNI value, so ignore the exception and don't set
	// a server name, which results in no SNI extension being sent.
	}
	if (!isPlatformSocket(sslSocket)) {
	SET_HOSTNAME.invokeOptionalWithoutCheckedException(sslSocket, hostname);
	}
	}

	// Enable ALPN, if necessary
	sslParams.setApplicationProtocols(getProtocolIds(protocols));

	if (!isPlatformSocket(sslSocket) && SET_ALPN_PROTOCOLS.isSupported(sslSocket)) {
	Object[] parameters = {concatLengthPrefixed(protocols)};
	SET_ALPN_PROTOCOLS.invokeWithoutCheckedException(sslSocket, parameters);
	}
	sslSocket.setSSLParameters(sslParams);
	}

	/**
	* Called after the TLS handshake to release resources allocated by {@link
	* #configureTlsExtensions}.
	*/
	public void afterHandshake(SSLSocket sslSocket) {
	}

	public String getSelectedProtocol(SSLSocket socket) {
	// This API was added in Android Q
	try {
	return socket.getApplicationProtocol();
	} catch (UnsupportedOperationException ignored) {
	// The socket doesn't support this API, try the old reflective method
	}
	// This method was used through Android P, see note above
	boolean alpnSupported = GET_ALPN_SELECTED_PROTOCOL.isSupported(socket);
	if (!alpnSupported) {
	return null;
	}

	byte[] alpnResult =
	(byte[]) GET_ALPN_SELECTED_PROTOCOL.invokeWithoutCheckedException(socket);
	if (alpnResult != null) {
	return new String(alpnResult, Util.UTF_8);
	}
	return null;
	}

	public void connectSocket(Socket socket, InetSocketAddress address,
	int connectTimeout) throws IOException {
	socket.connect(address, connectTimeout);
	}

	/** Prefix used on custom headers. */
	public String getPrefix() {
	return "X-Android";
	}

	/**
	* Stripped down/adapted from OkHttp's {@code Platform.Android.trustManager()}.
	* OkHttp 2.7.5 uses this only for certificate pinning logic that we don't use
	* on Android, so this method should never be called outside of OkHttp's tests.
	* This method has been stripped down to the minimum for OkHttp's tests to pass.
	*/
	public X509TrustManager trustManager(SSLSocketFactory sslSocketFactory) {
	Class sslParametersClass;
	try {
	sslParametersClass = Class.forName("com.android.org.conscrypt.SSLParametersImpl");
	} catch (ClassNotFoundException e) {
	throw new RuntimeException(e);
	}
	Object context = readFieldOrNull(sslSocketFactory, sslParametersClass, "sslParameters");
	return readFieldOrNull(context, X509TrustManager.class, "x509TrustManager");
	}

	/**
	* Stripped down from OkHttp's implementation to the minimum to get OkHttp's tests
	* to pass. OkHttp 2.7.5 uses this for certificate pinning logic which is unused
	* in Android. This method should never be called outside of OkHttp's tests.
	*/
	public TrustRootIndex trustRootIndex(X509TrustManager trustManager) {
	return new RealTrustRootIndex(trustManager.getAcceptedIssuers());
	}

	// Helper method from OkHttp's Platform.java
	private static <T> T readFieldOrNull(Object instance, Class<T> fieldType, String fieldName) {
	for (Class<?> c = instance.getClass(); c != Object.class; c = c.getSuperclass()) {
	try {
	Field field = c.getDeclaredField(fieldName);
	field.setAccessible(true);
	Object value = field.get(instance);
	if (value == null \|\| !fieldType.isInstance(value)) return null;
	return fieldType.cast(value);
	} catch (NoSuchFieldException ignored) {
	} catch (IllegalAccessException e) {
	throw new AssertionError();
	}
	}

	// Didn't find the field we wanted. As a last gasp attempt, try to find the value on a delegate.
	if (!fieldName.equals("delegate")) {
	Object delegate = readFieldOrNull(instance, Object.class, "delegate");
	if (delegate != null) return readFieldOrNull(delegate, fieldType, fieldName);
	}

	return null;
	}

	private static boolean isPlatformSocket(SSLSocket socket) {
	return socket.getClass().getName().startsWith("com.android.org.conscrypt");
	}

	private static String[] getProtocolIds(List<Protocol> protocols) {
	String[] result = new String[protocols.size()];
	for (int i = 0; i < protocols.size(); i++) {
	result[i] = protocols.get(i).toString();
	}
	return result;
	}

	/**
	* Returns the concatenation of 8-bit, length prefixed protocol names.
	* http://tools.ietf.org/html/draft-agl-tls-nextprotoneg-04#page-4
	*/
	static byte[] concatLengthPrefixed(List<Protocol> protocols) {
	Buffer result = new Buffer();
	for (int i = 0, size = protocols.size(); i < size; i++) {
	Protocol protocol = protocols.get(i);
	if (protocol == Protocol.HTTP_1_0) continue; // No HTTP/1.0 for ALPN.
	result.writeByte(protocol.toString().length());
	result.writeUtf8(protocol.toString());
	}
	return result.readByteArray();
	}
	}