import okhttp3.internal.Internal; //导入依赖的package包/类
/**
 * Extracts OkHttp headers from the supplied {@link Map}. Only real headers are extracted. Any
 * entry (one with a {@code null} key) is discarded.
 */
// @VisibleForTesting
static Headers extractOkHeaders(Map<String, List<String>> javaHeaders) {
  Headers.Builder okHeadersBuilder = new Headers.Builder();
  for (Map.Entry<String, List<String>> javaHeader : javaHeaders.entrySet()) {
    String name = javaHeader.getKey();
    if (name == null) {
      // The Java API uses the null key to store the status line in responses.
      // Earlier versions of OkHttp would use the null key to store the "request line" in
      // requests. e.g. "GET / HTTP 1.1". Although this is no longer the case it must be
      // explicitly ignored because Headers.Builder does not support null keys.
      continue;
    }
    for (String value : javaHeader.getValue()) {
      Internal.instance.addLenient(okHeadersBuilder, name, value);
    }
  }
  return okHeadersBuilder.build();
}
 

import okhttp3.internal.Internal; //导入依赖的package包/类
/**
 * Prunes any leaked allocations and then returns the number of remaining live allocations on
 * {@code connection}. Allocations are leaked if the connection is tracking them but the
 * application code has abandoned them. Leak detection is imprecise and relies on garbage
 * collection.
 */
private int pruneAndGetAllocationCount(RealConnection connection, long now) {
  List<Reference<StreamAllocation>> references = connection.allocations;
  for (int i = 0; i < references.size(); ) {
    Reference<StreamAllocation> reference = references.get(i);

    if (reference.get() != null) {
      i++;
      continue;
    }

    // We've discovered a leaked allocation. This is an application bug.
    Internal.logger.warning("A connection to " + connection.route().address().url()
        + " was leaked. Did you forget to close a response body?");
    references.remove(i);
    connection.noNewStreams = true;

    // If this was the last allocation, the connection is eligible for immediate eviction.
    if (references.isEmpty()) {
      connection.idleAtNanos = now - keepAliveDurationNs;
      return 0;
    }
  }

  return references.size();
}
 

import okhttp3.internal.Internal; //导入依赖的package包/类
private void maybeCache() throws IOException {
  InternalCache responseCache = Internal.instance.internalCache(client);
  if (responseCache == null) return;

  // Should we cache this response for this request?
  if (!CacheStrategy.isCacheable(userResponse, networkRequest)) {
    if (HttpMethod.invalidatesCache(networkRequest.method())) {
      try {
        responseCache.remove(networkRequest);
      } catch (IOException ignored) {
        // The cache cannot be written.
      }
    }
    return;
  }

  // Offer this request to the cache.
  storeRequest = responseCache.put(stripBody(userResponse));
}
 

import okhttp3.internal.Internal; //导入依赖的package包/类
/** Returns headers for a name value block containing an HTTP/2 response. */
public static Response.Builder readHttp2HeadersList(List<Header> headerBlock) throws IOException {
  String status = null;

  Headers.Builder headersBuilder = new Headers.Builder();
  for (int i = 0, size = headerBlock.size(); i < size; i++) {
    ByteString name = headerBlock.get(i).name;

    String value = headerBlock.get(i).value.utf8();
    if (name.equals(RESPONSE_STATUS)) {
      status = value;
    } else if (!HTTP_2_SKIPPED_RESPONSE_HEADERS.contains(name)) {
      Internal.instance.addLenient(headersBuilder, name.utf8(), value);
    }
  }
  if (status == null) throw new ProtocolException("Expected ':status' header not present");

  StatusLine statusLine = StatusLine.parse("HTTP/1.1 " + status);
  return new Response.Builder()
      .protocol(Protocol.HTTP_2)
      .code(statusLine.code)
      .message(statusLine.message)
      .headers(headersBuilder.build());
}
 

import okhttp3.internal.Internal; //导入依赖的package包/类
/**
 * Returns headers for the header names and values in the {@link Map}.
 */
private static Headers createHeaders(Map<String, List<String>> headers) {
  Headers.Builder builder = new Headers.Builder();
  for (Map.Entry<String, List<String>> header : headers.entrySet()) {
    if (header.getKey() == null || header.getValue() == null) {
      continue;
    }
    String name = header.getKey().trim();
    for (String value : header.getValue()) {
      String trimmedValue = value.trim();
      Internal.instance.addLenient(builder, name, trimmedValue);
    }
  }
  return builder.build();
}
 

import okhttp3.internal.Internal; //导入依赖的package包/类
private static Headers varyHeaders(URLConnection urlConnection, Headers responseHeaders) {
  if (HttpHeaders.hasVaryAll(responseHeaders)) {
    // "*" means that this will be treated as uncacheable anyway.
    return null;
  }
  Set<String> varyFields = HttpHeaders.varyFields(responseHeaders);
  if (varyFields.isEmpty()) {
    return new Headers.Builder().build();
  }

  // This probably indicates another HTTP stack is trying to use the shared ResponseCache.
  // We cannot guarantee this case will work properly because we cannot reliably extract *all*
  // the request header values, and we can't get multiple Vary request header values.
  // We also can't be sure about the Accept-Encoding behavior of other stacks.
  if (!(urlConnection instanceof CacheHttpURLConnection
      || urlConnection instanceof CacheHttpsURLConnection)) {
    return null;
  }

  // This is the case we expect: The URLConnection is from a call to
  // JavaApiConverter.createJavaUrlConnection() and we have access to the user's request headers.
  Map<String, List<String>> requestProperties = urlConnection.getRequestProperties();
  Headers.Builder result = new Headers.Builder();
  for (String fieldName : varyFields) {
    List<String> fieldValues = requestProperties.get(fieldName);
    if (fieldValues == null) {
      if (fieldName.equals("Accept-Encoding")) {
        // Accept-Encoding is special. If OkHttp sees Accept-Encoding is unset it will add
        // "gzip". We don't have access to the request that was actually made so we must do the
        // same.
        result.add("Accept-Encoding", "gzip");
      }
    } else {
      for (String fieldValue : fieldValues) {
        Internal.instance.addLenient(result, fieldName, fieldValue);
      }
    }
  }
  return result.build();
}
 

import okhttp3.internal.Internal; //导入依赖的package包/类
/**
 * Extracts OkHttp headers from the supplied {@link Map}. Only real headers are extracted. Any
 * entry (one with a {@code null} key) is discarded. Special internal headers used to track cache
 * metadata are omitted from the result and added to {@code okResponseBuilder} instead.
 */
// @VisibleForTesting
static Headers extractOkHeaders(
    Map<String, List<String>> javaHeaders, Response.Builder okResponseBuilder) {
  Headers.Builder okHeadersBuilder = new Headers.Builder();
  for (Map.Entry<String, List<String>> javaHeader : javaHeaders.entrySet()) {
    String name = javaHeader.getKey();
    if (name == null) {
      // The Java API uses the null key to store the status line in responses.
      // Earlier versions of OkHttp would use the null key to store the "request line" in
      // requests. e.g. "GET / HTTP 1.1". Although this is no longer the case it must be
      // explicitly ignored because Headers.Builder does not support null keys.
      continue;
    }
    if (okResponseBuilder != null && javaHeader.getValue().size() == 1) {
      if (name.equals(SENT_MILLIS)) {
        okResponseBuilder.sentRequestAtMillis(Long.valueOf(javaHeader.getValue().get(0)));
        continue;
      }
      if (name.equals(RECEIVED_MILLIS)) {
        okResponseBuilder.receivedResponseAtMillis(Long.valueOf(javaHeader.getValue().get(0)));
        continue;
      }
    }
    for (String value : javaHeader.getValue()) {
      Internal.instance.addLenient(okHeadersBuilder, name, value);
    }
  }
  return okHeadersBuilder.build();
}
 

import okhttp3.internal.Internal; //导入依赖的package包/类
@Test public void emptyResponseHeaderNameFromCacheIsLenient() throws Exception {
  Headers.Builder headers = new Headers.Builder()
      .add("Cache-Control: max-age=120");
  Internal.instance.addLenient(headers, ": A");
  server.enqueue(new MockResponse()
      .setHeaders(headers.build())
      .setBody("body"));

  HttpURLConnection connection = openConnection(server.url("/").url());
  assertEquals("A", connection.getHeaderField(""));
}
 

import okhttp3.internal.Internal; //导入依赖的package包/类
/** Reads headers or trailers. */
public Headers readHeaders() throws IOException {
  Headers.Builder headers = new Headers.Builder();
  // parse the result headers until the first blank line
  for (String line; (line = source.readUtf8LineStrict()).length() != 0; ) {
    Internal.instance.addLenient(headers, line);
  }
  return headers.build();
}
 

import okhttp3.internal.Internal; //导入依赖的package包/类
@Override public Response.Builder readResponseHeaders(boolean expectContinue) throws IOException {
  List<Header> headers = stream.takeResponseHeaders();
  Response.Builder responseBuilder = readHttp2HeadersList(headers);
  if (expectContinue && Internal.instance.code(responseBuilder) == HTTP_CONTINUE) {
    return null;
  }
  return responseBuilder;
}
 

import okhttp3.internal.Internal; //导入依赖的package包/类
/** Returns headers for a name value block containing an HTTP/2 response. */
public static Response.Builder readHttp2HeadersList(List<Header> headerBlock) throws IOException {
  StatusLine statusLine = null;
  Headers.Builder headersBuilder = new Headers.Builder();
  for (int i = 0, size = headerBlock.size(); i < size; i++) {
    Header header = headerBlock.get(i);

    // If there were multiple header blocks they will be delimited by nulls. Discard existing
    // header blocks if the existing header block is a '100 Continue' intermediate response.
    if (header == null) {
      if (statusLine != null && statusLine.code == HTTP_CONTINUE) {
        statusLine = null;
        headersBuilder = new Headers.Builder();
      }
      continue;
    }

    ByteString name = header.name;
    String value = header.value.utf8();
    if (name.equals(RESPONSE_STATUS)) {
      statusLine = StatusLine.parse("HTTP/1.1 " + value);
    } else if (!HTTP_2_SKIPPED_RESPONSE_HEADERS.contains(name)) {
      Internal.instance.addLenient(headersBuilder, name.utf8(), value);
    }
  }
  if (statusLine == null) throw new ProtocolException("Expected ':status' header not present");

  return new Response.Builder()
      .protocol(Protocol.HTTP_2)
      .code(statusLine.code)
      .message(statusLine.message)
      .headers(headersBuilder.build());
}
 

import okhttp3.internal.Internal; //导入依赖的package包/类
/**
 * Configures the supplied {@link SSLSocket} to connect to the specified host using an appropriate
 * {@link ConnectionSpec}. Returns the chosen {@link ConnectionSpec}, never {@code null}.
 *
 * @throws IOException if the socket does not support any of the TLS modes available
 */
public ConnectionSpec configureSecureSocket(SSLSocket sslSocket) throws IOException {
  ConnectionSpec tlsConfiguration = null;
  for (int i = nextModeIndex, size = connectionSpecs.size(); i < size; i++) {
    ConnectionSpec connectionSpec = connectionSpecs.get(i);
    if (connectionSpec.isCompatible(sslSocket)) {
      tlsConfiguration = connectionSpec;
      nextModeIndex = i + 1;
      break;
    }
  }

  if (tlsConfiguration == null) {
    // This may be the first time a connection has been attempted and the socket does not support
    // any the required protocols, or it may be a retry (but this socket supports fewer
    // protocols than was suggested by a prior socket).
    throw new UnknownServiceException(
        "Unable to find acceptable protocols. isFallback=" + isFallback
            + ", modes=" + connectionSpecs
            + ", supported protocols=" + Arrays.toString(sslSocket.getEnabledProtocols()));
  }

  isFallbackPossible = isFallbackPossible(sslSocket);

  Internal.instance.apply(tlsConfiguration, sslSocket, isFallback);

  return tlsConfiguration;
}
 

import okhttp3.internal.Internal; //导入依赖的package包/类
/**
 * Releases resources held by this allocation. If sufficient resources are allocated, the
 * connection will be detached or closed. Callers must be synchronized on the connection pool.
 *
 * <p>Returns a closeable that the caller should pass to {@link Util#closeQuietly} upon completion
 * of the synchronized block. (We don't do I/O while synchronized on the connection pool.)
 */
private Socket deallocate(boolean noNewStreams, boolean released, boolean streamFinished) {
  assert (Thread.holdsLock(connectionPool));

  if (streamFinished) {
    this.codec = null;
  }
  if (released) {
    this.released = true;
  }
  Socket socket = null;
  if (connection != null) {
    if (noNewStreams) {
      connection.noNewStreams = true;
    }
    if (this.codec == null && (this.released || connection.noNewStreams)) {
      release(connection);
      if (connection.allocations.isEmpty()) {
        connection.idleAtNanos = System.nanoTime();
        if (Internal.instance.connectionBecameIdle(connectionPool, connection)) {
          socket = connection.socket();
        }
      }
      connection = null;
    }
  }
  return socket;
}
 

import okhttp3.internal.Internal; //导入依赖的package包/类
@Test public void emptyResponseHeaderNameFromCacheIsLenient() throws Exception {
  Headers.Builder headers = new Headers.Builder()
      .add("Cache-Control: max-age=120");
  Internal.instance.addLenient(headers, ": A");
  server.enqueue(new MockResponse()
      .setHeaders(headers.build())
      .setBody("body"));

  Response response = get(server.url("/"));
  assertEquals("A", response.header(""));
  assertEquals("body", response.body().string());
}
 

import okhttp3.internal.Internal; //导入依赖的package包/类
@Test public void emptyResponseHeaderNameIsLenient() throws Exception {
  Headers.Builder headers = new Headers.Builder();
  Internal.instance.addLenient(headers, ":A");
  server.enqueue(new MockResponse().setHeaders(headers.build()).setBody("body"));
  connection = urlFactory.open(server.url("/").url());
  connection.getResponseCode();
  assertEquals("A", connection.getHeaderField(""));
  connection.getInputStream().close();
}
 

import okhttp3.internal.Internal; //导入依赖的package包/类
@Test public void emptyResponseHeaderNameFromCacheIsLenient() throws Exception {
  Headers.Builder headers = new Headers.Builder()
      .add("Cache-Control: max-age=120");
  Internal.instance.addLenient(headers, ": A");
  server.enqueue(new MockResponse().setHeaders(headers.build()).setBody("body"));

  HttpURLConnection connection = urlFactory.open(server.url("/").url());
  assertEquals("A", connection.getHeaderField(""));
  assertEquals("body", readAscii(connection));
}
 

import okhttp3.internal.Internal; //导入依赖的package包/类
/** Reads headers or trailers. */
public Headers readHeaders() throws IOException {
  Headers.Builder headers = new Headers.Builder();
  // parse the result headers until the first blank line
  for (String line; (line = readHeaderLine()).length() != 0; ) {
    Internal.instance.addLenient(headers, line);
  }
  return headers.build();
}
 

import okhttp3.internal.Internal; //导入依赖的package包/类
private static Headers varyHeaders(URLConnection urlConnection, Headers responseHeaders) {
  if (OkHeaders.hasVaryAll(responseHeaders)) {
    // "*" means that this will be treated as uncacheable anyway.
    return null;
  }
  Set<String> varyFields = OkHeaders.varyFields(responseHeaders);
  if (varyFields.isEmpty()) {
    return new Headers.Builder().build();
  }

  // This probably indicates another HTTP stack is trying to use the shared ResponseCache.
  // We cannot guarantee this case will work properly because we cannot reliably extract *all*
  // the request header values, and we can't get multiple Vary request header values.
  // We also can't be sure about the Accept-Encoding behavior of other stacks.
  if (!(urlConnection instanceof CacheHttpURLConnection
      || urlConnection instanceof CacheHttpsURLConnection)) {
    return null;
  }

  // This is the case we expect: The URLConnection is from a call to
  // JavaApiConverter.createJavaUrlConnection() and we have access to the user's request headers.
  Map<String, List<String>> requestProperties = urlConnection.getRequestProperties();
  Headers.Builder result = new Headers.Builder();
  for (String fieldName : varyFields) {
    List<String> fieldValues = requestProperties.get(fieldName);
    if (fieldValues == null) {
      if (fieldName.equals("Accept-Encoding")) {
        // Accept-Encoding is special. If OkHttp sees Accept-Encoding is unset it will add
        // "gzip". We don't have access to the request that was actually made so we must do the
        // same.
        result.add("Accept-Encoding", "gzip");
      }
    } else {
      for (String fieldValue : fieldValues) {
        Internal.instance.addLenient(result, fieldName, fieldValue);
      }
    }
  }
  return result.build();
}
 

import okhttp3.internal.Internal; //导入依赖的package包/类
private void createWebSocket(Response response, WebSocketListener listener) throws IOException {
  if (response.code() != 101) {
    Util.closeQuietly(response.body());
    throw new ProtocolException("Expected HTTP 101 response but was '"
        + response.code()
        + " "
        + response.message()
        + "'");
  }

  String headerConnection = response.header("Connection");
  if (!"Upgrade".equalsIgnoreCase(headerConnection)) {
    throw new ProtocolException(
        "Expected 'Connection' header value 'Upgrade' but was '" + headerConnection + "'");
  }
  String headerUpgrade = response.header("Upgrade");
  if (!"websocket".equalsIgnoreCase(headerUpgrade)) {
    throw new ProtocolException(
        "Expected 'Upgrade' header value 'websocket' but was '" + headerUpgrade + "'");
  }
  String headerAccept = response.header("Sec-WebSocket-Accept");
  String acceptExpected = Util.shaBase64(key + WebSocketProtocol.ACCEPT_MAGIC);
  if (!acceptExpected.equals(headerAccept)) {
    throw new ProtocolException("Expected 'Sec-WebSocket-Accept' header value '"
        + acceptExpected
        + "' but was '"
        + headerAccept
        + "'");
  }

  StreamAllocation streamAllocation = Internal.instance.callEngineGetStreamAllocation(call);
  RealWebSocket webSocket = StreamWebSocket.create(
      streamAllocation, response, random, listener);

  listener.onOpen(webSocket, response);

  while (webSocket.readMessage()) {
  }
}
 

import okhttp3.internal.Internal; //导入依赖的package包/类
/**
 * Releases resources held by this allocation. If sufficient resources are allocated, the
 * connection will be detached or closed.
 */
private void deallocate(boolean noNewStreams, boolean released, boolean streamFinished) {
  RealConnection connectionToClose = null;
  synchronized (connectionPool) {
    if (streamFinished) {
      this.stream = null;
    }
    if (released) {
      this.released = true;
    }
    if (connection != null) {
      if (noNewStreams) {
        connection.noNewStreams = true;
      }
      if (this.stream == null && (this.released || connection.noNewStreams)) {
        release(connection);
        if (connection.allocations.isEmpty()) {
          connection.idleAtNanos = System.nanoTime();
          if (Internal.instance.connectionBecameIdle(connectionPool, connection)) {
            connectionToClose = connection;
          }
        }
        connection = null;
      }
    }
  }
  if (connectionToClose != null) {
    Util.closeQuietly(connectionToClose.socket());
  }
}