package com.mbridge.msdk.thrid.okhttp.internal.connection; import com.mbridge.msdk.thrid.okhttp.Address; import com.mbridge.msdk.thrid.okhttp.Call; import com.mbridge.msdk.thrid.okhttp.CertificatePinner; import com.mbridge.msdk.thrid.okhttp.Connection; import com.mbridge.msdk.thrid.okhttp.ConnectionPool; import com.mbridge.msdk.thrid.okhttp.ConnectionSpec; import com.mbridge.msdk.thrid.okhttp.EventListener; import com.mbridge.msdk.thrid.okhttp.Handshake; import com.mbridge.msdk.thrid.okhttp.HttpUrl; import com.mbridge.msdk.thrid.okhttp.Interceptor; import com.mbridge.msdk.thrid.okhttp.OkHttpClient; import com.mbridge.msdk.thrid.okhttp.Protocol; import com.mbridge.msdk.thrid.okhttp.Request; import com.mbridge.msdk.thrid.okhttp.Response; import com.mbridge.msdk.thrid.okhttp.Route; import com.mbridge.msdk.thrid.okhttp.internal.Internal; import com.mbridge.msdk.thrid.okhttp.internal.Util; import com.mbridge.msdk.thrid.okhttp.internal.Version; import com.mbridge.msdk.thrid.okhttp.internal.http.HttpCodec; import com.mbridge.msdk.thrid.okhttp.internal.http.HttpHeaders; import com.mbridge.msdk.thrid.okhttp.internal.http1.Http1Codec; import com.mbridge.msdk.thrid.okhttp.internal.http2.ErrorCode; import com.mbridge.msdk.thrid.okhttp.internal.http2.Http2Codec; import com.mbridge.msdk.thrid.okhttp.internal.http2.Http2Connection; import com.mbridge.msdk.thrid.okhttp.internal.http2.Http2Stream; import com.mbridge.msdk.thrid.okhttp.internal.platform.Platform; import com.mbridge.msdk.thrid.okhttp.internal.tls.OkHostnameVerifier; import com.mbridge.msdk.thrid.okhttp.internal.ws.RealWebSocket; import com.mbridge.msdk.thrid.okio.BufferedSink; import com.mbridge.msdk.thrid.okio.BufferedSource; import com.mbridge.msdk.thrid.okio.Okio; import com.mbridge.msdk.thrid.okio.Source; import java.io.IOException; import java.lang.ref.Reference; import java.net.ConnectException; import java.net.ProtocolException; import java.net.Proxy; import java.net.Socket; import java.net.SocketException; import java.net.SocketTimeoutException; import java.net.UnknownServiceException; import java.security.cert.Certificate; import java.security.cert.X509Certificate; import java.util.ArrayList; import java.util.List; import java.util.concurrent.TimeUnit; import javax.annotation.Nullable; import javax.net.ssl.SSLPeerUnverifiedException; import javax.net.ssl.SSLSession; import javax.net.ssl.SSLSocket; public final class RealConnection extends Http2Connection.Listener implements Connection { private static final int MAX_TUNNEL_ATTEMPTS = 21; private static final String NPE_THROW_WITH_NULL = "throw with null exception"; public int allocationLimit = 1; public final List<Reference<StreamAllocation>> allocations = new ArrayList(); private final ConnectionPool connectionPool; private Handshake handshake; private Http2Connection http2Connection; public long idleAtNanos = Long.MAX_VALUE; public boolean noNewStreams; private Protocol protocol; private Socket rawSocket; private final Route route; private BufferedSink sink; private Socket socket; private BufferedSource source; public int successCount; public RealConnection(ConnectionPool connectionPool2, Route route2) { this.connectionPool = connectionPool2; this.route = route2; } public static RealConnection testConnection(ConnectionPool connectionPool2, Route route2, Socket socket2, long j) { RealConnection realConnection = new RealConnection(connectionPool2, route2); realConnection.socket = socket2; realConnection.idleAtNanos = j; return realConnection; } /* JADX WARNING: Removed duplicated region for block: B:18:0x0090 A[Catch:{ IOException -> 0x00f9 }] */ /* JADX WARNING: Removed duplicated region for block: B:21:0x00a9 */ /* JADX WARNING: Removed duplicated region for block: B:29:0x00ce */ /* JADX WARNING: Removed duplicated region for block: B:35:0x00e4 */ /* JADX WARNING: Removed duplicated region for block: B:51:0x012f */ /* JADX WARNING: Removed duplicated region for block: B:52:0x0135 */ /* JADX WARNING: Removed duplicated region for block: B:65:? A[ORIG_RETURN, RETURN, SYNTHETIC] */ public void connect(int i, int i2, int i3, int i4, boolean z, Call call, EventListener eventListener) { IOException e; if (this.protocol == null) { List<ConnectionSpec> connectionSpecs = this.route.address().connectionSpecs(); ConnectionSpecSelector connectionSpecSelector = new ConnectionSpecSelector(connectionSpecs); if (this.route.address().sslSocketFactory() == null) { if (connectionSpecs.contains(ConnectionSpec.CLEARTEXT)) { String host = this.route.address().url().host(); if (!Platform.get().isCleartextTrafficPermitted(host)) { throw new RouteException(new UnknownServiceException("CLEARTEXT communication to " + host + " not permitted by network security policy")); } } else { throw new RouteException(new UnknownServiceException("CLEARTEXT communication not enabled for client")); } } else if (this.route.address().protocols().contains(Protocol.H2_PRIOR_KNOWLEDGE)) { throw new RouteException(new UnknownServiceException("H2_PRIOR_KNOWLEDGE cannot be used with HTTPS")); } RouteException routeException = null; do { try { if (!this.route.requiresTunnel()) { connectTunnel(i, i2, i3, call, eventListener); if (this.rawSocket == null) { if (!this.route.requiresTunnel() && this.rawSocket == null) { throw new RouteException(new ProtocolException("Too many tunnel connections attempted: 21")); } else if (this.http2Connection != null) { synchronized (this.connectionPool) { this.allocationLimit = this.http2Connection.maxConcurrentStreams(); } return; } else { return; } } } else { try { connectSocket(i, i2, call, eventListener); } catch (IOException e2) { e = e2; Util.closeQuietly(this.socket); Util.closeQuietly(this.rawSocket); this.socket = null; this.rawSocket = null; this.source = null; this.sink = null; this.handshake = null; this.protocol = null; this.http2Connection = null; eventListener.connectFailed(call, this.route.socketAddress(), this.route.proxy(), null, e); if (routeException != null) { } throw routeException; } } try { establishProtocol(connectionSpecSelector, i4, call, eventListener); eventListener.connectEnd(call, this.route.socketAddress(), this.route.proxy(), this.protocol); if (!this.route.requiresTunnel()) { } if (this.http2Connection != null) { } } catch (IOException e3) { e = e3; } } catch (IOException e4) { e = e4; Util.closeQuietly(this.socket); Util.closeQuietly(this.rawSocket); this.socket = null; this.rawSocket = null; this.source = null; this.sink = null; this.handshake = null; this.protocol = null; this.http2Connection = null; eventListener.connectFailed(call, this.route.socketAddress(), this.route.proxy(), null, e); if (routeException != null) { routeException = new RouteException(e); } else { routeException.addConnectException(e); } if (!z || connectionSpecSelector.connectionFailed(e)) { throw routeException; } do { if (!this.route.requiresTunnel()) { } establishProtocol(connectionSpecSelector, i4, call, eventListener); eventListener.connectEnd(call, this.route.socketAddress(), this.route.proxy(), this.protocol); if (!this.route.requiresTunnel()) { } if (this.http2Connection != null) { } } while (connectionSpecSelector.connectionFailed(e)); throw routeException; } } while (connectionSpecSelector.connectionFailed(e)); throw routeException; } throw new IllegalStateException("already connected"); } private void connectTunnel(int i, int i2, int i3, Call call, EventListener eventListener) throws IOException { Request createTunnelRequest = createTunnelRequest(); HttpUrl url = createTunnelRequest.url(); for (int i4 = 0; i4 < 21; i4++) { connectSocket(i, i2, call, eventListener); createTunnelRequest = createTunnel(i2, i3, createTunnelRequest, url); if (createTunnelRequest != null) { Util.closeQuietly(this.rawSocket); this.rawSocket = null; this.sink = null; this.source = null; eventListener.connectEnd(call, this.route.socketAddress(), this.route.proxy(), null); } else { return; } } } private void connectSocket(int i, int i2, Call call, EventListener eventListener) throws IOException { Proxy proxy = this.route.proxy(); this.rawSocket = (proxy.type() == Proxy.Type.DIRECT || proxy.type() == Proxy.Type.HTTP) ? this.route.address().socketFactory().createSocket() : new Socket(proxy); eventListener.connectStart(call, this.route.socketAddress(), proxy); this.rawSocket.setSoTimeout(i2); try { Platform.get().connectSocket(this.rawSocket, this.route.socketAddress(), i); try { this.source = Okio.buffer(Okio.source(this.rawSocket)); this.sink = Okio.buffer(Okio.sink(this.rawSocket)); } catch (NullPointerException e) { if (NPE_THROW_WITH_NULL.equals(e.getMessage())) { throw new IOException(e); } } } catch (ConnectException e2) { ConnectException connectException = new ConnectException("Failed to connect to " + this.route.socketAddress()); connectException.initCause(e2); throw connectException; } } private void establishProtocol(ConnectionSpecSelector connectionSpecSelector, int i, Call call, EventListener eventListener) throws IOException { if (this.route.address().sslSocketFactory() != null) { eventListener.secureConnectStart(call); connectTls(connectionSpecSelector); eventListener.secureConnectEnd(call, this.handshake); if (this.protocol == Protocol.HTTP_2) { startHttp2(i); } } else if (this.route.address().protocols().contains(Protocol.H2_PRIOR_KNOWLEDGE)) { this.socket = this.rawSocket; this.protocol = Protocol.H2_PRIOR_KNOWLEDGE; startHttp2(i); } else { this.socket = this.rawSocket; this.protocol = Protocol.HTTP_1_1; } } private void startHttp2(int i) throws IOException { this.socket.setSoTimeout(0); Http2Connection build = new Http2Connection.Builder(true).socket(this.socket, this.route.address().url().host(), this.source, this.sink).listener(this).pingIntervalMillis(i).build(); this.http2Connection = build; build.start(); } /* JADX WARNING: Removed duplicated region for block: B:35:0x0137 A[Catch:{ all -> 0x012e }] */ /* JADX WARNING: Removed duplicated region for block: B:37:0x013d A[Catch:{ all -> 0x012e }] */ /* JADX WARNING: Removed duplicated region for block: B:39:0x0140 */ private void connectTls(ConnectionSpecSelector connectionSpecSelector) throws IOException { Throwable th; AssertionError e; Address address = this.route.address(); SSLSocket sSLSocket = null; String str = null; try { SSLSocket sSLSocket2 = (SSLSocket) address.sslSocketFactory().createSocket(this.rawSocket, address.url().host(), address.url().port(), true); try { ConnectionSpec configureSecureSocket = connectionSpecSelector.configureSecureSocket(sSLSocket2); if (configureSecureSocket.supportsTlsExtensions()) { Platform.get().configureTlsExtensions(sSLSocket2, address.url().host(), address.protocols()); } sSLSocket2.startHandshake(); SSLSession session = sSLSocket2.getSession(); Handshake handshake2 = Handshake.get(session); if (!address.hostnameVerifier().verify(address.url().host(), session)) { List<Certificate> peerCertificates = handshake2.peerCertificates(); if (!peerCertificates.isEmpty()) { X509Certificate x509Certificate = (X509Certificate) peerCertificates.get(0); throw new SSLPeerUnverifiedException("Hostname " + address.url().host() + " not verified:\n certificate: " + CertificatePinner.pin(x509Certificate) + "\n DN: " + x509Certificate.getSubjectDN().getName() + "\n subjectAltNames: " + OkHostnameVerifier.allSubjectAltNames(x509Certificate)); } throw new SSLPeerUnverifiedException("Hostname " + address.url().host() + " not verified (no certificates)"); } address.certificatePinner().check(address.url().host(), handshake2.peerCertificates()); if (configureSecureSocket.supportsTlsExtensions()) { str = Platform.get().getSelectedProtocol(sSLSocket2); } this.socket = sSLSocket2; this.source = Okio.buffer(Okio.source(sSLSocket2)); this.sink = Okio.buffer(Okio.sink(this.socket)); this.handshake = handshake2; this.protocol = str != null ? Protocol.get(str) : Protocol.HTTP_1_1; if (sSLSocket2 != null) { Platform.get().afterHandshake(sSLSocket2); } } catch (AssertionError e2) { e = e2; sSLSocket = sSLSocket2; try { if (!Util.isAndroidGetsocknameError(e)) { } } catch (Throwable th2) { th = th2; if (sSLSocket != null) { } Util.closeQuietly((Socket) sSLSocket); throw th; } } catch (Throwable th3) { th = th3; sSLSocket = sSLSocket2; if (sSLSocket != null) { Platform.get().afterHandshake(sSLSocket); } Util.closeQuietly((Socket) sSLSocket); throw th; } } catch (AssertionError e3) { e = e3; if (!Util.isAndroidGetsocknameError(e)) { throw new IOException(e); } throw e; } } private Request createTunnel(int i, int i2, Request request, HttpUrl httpUrl) throws IOException { String str = "CONNECT " + Util.hostHeader(httpUrl, true) + " HTTP/1.1"; while (true) { Http1Codec http1Codec = new Http1Codec(null, null, this.source, this.sink); this.source.timeout().timeout((long) i, TimeUnit.MILLISECONDS); this.sink.timeout().timeout((long) i2, TimeUnit.MILLISECONDS); http1Codec.writeRequest(request.headers(), str); http1Codec.finishRequest(); Response build = http1Codec.readResponseHeaders(false).request(request).build(); long contentLength = HttpHeaders.contentLength(build); if (contentLength == -1) { contentLength = 0; } Source newFixedLengthSource = http1Codec.newFixedLengthSource(contentLength); Util.skipAll(newFixedLengthSource, Integer.MAX_VALUE, TimeUnit.MILLISECONDS); newFixedLengthSource.close(); int code = build.code(); if (code != 200) { if (code == 407) { Request authenticate = this.route.address().proxyAuthenticator().authenticate(this.route, build); if (authenticate == null) { throw new IOException("Failed to authenticate with proxy"); } else if ("close".equalsIgnoreCase(build.header("Connection"))) { return authenticate; } else { request = authenticate; } } else { throw new IOException("Unexpected response code for CONNECT: " + build.code()); } } else if (this.source.buffer().exhausted() && this.sink.buffer().exhausted()) { return null; } else { throw new IOException("TLS tunnel buffered too many bytes!"); } } } private Request createTunnelRequest() throws IOException { Request build = new Request.Builder().url(this.route.address().url()).method("CONNECT", null).header("Host", Util.hostHeader(this.route.address().url(), true)).header("Proxy-Connection", "Keep-Alive").header("User-Agent", Version.userAgent()).build(); Request authenticate = this.route.address().proxyAuthenticator().authenticate(this.route, new Response.Builder().request(build).protocol(Protocol.HTTP_1_1).code(407).message("Preemptive Authenticate").body(Util.EMPTY_RESPONSE).sentRequestAtMillis(-1).receivedResponseAtMillis(-1).header("Proxy-Authenticate", "OkHttp-Preemptive").build()); return authenticate != null ? authenticate : build; } public boolean isEligible(Address address, @Nullable Route route2) { if (this.allocations.size() >= this.allocationLimit || this.noNewStreams || !Internal.instance.equalsNonHost(this.route.address(), address)) { return false; } if (address.url().host().equals(route().address().url().host())) { return true; } if (this.http2Connection == null || route2 == null || route2.proxy().type() != Proxy.Type.DIRECT || this.route.proxy().type() != Proxy.Type.DIRECT || !this.route.socketAddress().equals(route2.socketAddress()) || route2.address().hostnameVerifier() != OkHostnameVerifier.INSTANCE || !supportsUrl(address.url())) { return false; } try { address.certificatePinner().check(address.url().host(), handshake().peerCertificates()); return true; } catch (SSLPeerUnverifiedException unused) { return false; } } public boolean supportsUrl(HttpUrl httpUrl) { if (httpUrl.port() != this.route.address().url().port()) { return false; } if (httpUrl.host().equals(this.route.address().url().host())) { return true; } if (this.handshake == null || !OkHostnameVerifier.INSTANCE.verify(httpUrl.host(), (X509Certificate) this.handshake.peerCertificates().get(0))) { return false; } return true; } public HttpCodec newCodec(OkHttpClient okHttpClient, Interceptor.Chain chain, StreamAllocation streamAllocation) throws SocketException { if (this.http2Connection != null) { return new Http2Codec(okHttpClient, chain, streamAllocation, this.http2Connection); } this.socket.setSoTimeout(chain.readTimeoutMillis()); this.source.timeout().timeout((long) chain.readTimeoutMillis(), TimeUnit.MILLISECONDS); this.sink.timeout().timeout((long) chain.writeTimeoutMillis(), TimeUnit.MILLISECONDS); return new Http1Codec(okHttpClient, streamAllocation, this.source, this.sink); } public RealWebSocket.Streams newWebSocketStreams(final StreamAllocation streamAllocation) { return new RealWebSocket.Streams(true, this.source, this.sink) { /* class com.mbridge.msdk.thrid.okhttp.internal.connection.RealConnection.AnonymousClass1 */ @Override // java.io.Closeable, java.lang.AutoCloseable public void close() throws IOException { StreamAllocation streamAllocation = streamAllocation; streamAllocation.streamFinished(true, streamAllocation.codec(), -1, null); } }; } @Override // com.mbridge.msdk.thrid.okhttp.Connection public Route route() { return this.route; } public void cancel() { Util.closeQuietly(this.rawSocket); } @Override // com.mbridge.msdk.thrid.okhttp.Connection public Socket socket() { return this.socket; } /* JADX INFO: finally extract failed */ public boolean isHealthy(boolean z) { if (this.socket.isClosed() || this.socket.isInputShutdown() || this.socket.isOutputShutdown()) { return false; } Http2Connection http2Connection2 = this.http2Connection; if (http2Connection2 != null) { return http2Connection2.isHealthy(System.nanoTime()); } if (z) { try { int soTimeout = this.socket.getSoTimeout(); try { this.socket.setSoTimeout(1); if (this.source.exhausted()) { this.socket.setSoTimeout(soTimeout); return false; } this.socket.setSoTimeout(soTimeout); return true; } catch (Throwable th) { this.socket.setSoTimeout(soTimeout); throw th; } } catch (SocketTimeoutException unused) { } catch (IOException unused2) { return false; } } return true; } @Override // com.mbridge.msdk.thrid.okhttp.internal.http2.Http2Connection.Listener public void onStream(Http2Stream http2Stream) throws IOException { http2Stream.close(ErrorCode.REFUSED_STREAM); } @Override // com.mbridge.msdk.thrid.okhttp.internal.http2.Http2Connection.Listener public void onSettings(Http2Connection http2Connection2) { synchronized (this.connectionPool) { this.allocationLimit = http2Connection2.maxConcurrentStreams(); } } @Override // com.mbridge.msdk.thrid.okhttp.Connection public Handshake handshake() { return this.handshake; } public boolean isMultiplexed() { return this.http2Connection != null; } @Override // com.mbridge.msdk.thrid.okhttp.Connection public Protocol protocol() { return this.protocol; } public String toString() { StringBuilder sb = new StringBuilder(); sb.append("Connection{"); sb.append(this.route.address().url().host()); sb.append(":"); sb.append(this.route.address().url().port()); sb.append(", proxy="); sb.append(this.route.proxy()); sb.append(" hostAddress="); sb.append(this.route.socketAddress()); sb.append(" cipherSuite="); Handshake handshake2 = this.handshake; sb.append(handshake2 != null ? handshake2.cipherSuite() : "none"); sb.append(" protocol="); sb.append(this.protocol); sb.append('}'); return sb.toString(); } }