installed plugin W3 Total Cache version 2.3.2

wp-content/plugins/w3-total-cache/lib/Google/Cache/Abstract.php

@@ -0,0 +1,53 @@
+<?php
+/*
+ * Copyright 2008 Google Inc.
+ *
+ * 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.
+ */
+
+/**
+ * Abstract storage class
+ *
+ * @author Chris Chabot <chabotc@google.com>
+ */
+abstract class W3TCG_Google_Cache_Abstract
+{
+  
+  abstract public function __construct(W3TCG_Google_Client $client);
+
+  /**
+   * Retrieves the data for the given key, or false if they
+   * key is unknown or expired
+   *
+   * @param String $key The key who's data to retrieve
+   * @param boolean|int $expiration Expiration time in seconds
+   *
+   */
+  abstract public function get($key, $expiration = false);
+
+  /**
+   * Store the key => $value set. The $value is serialized
+   * by this function so can be of any type
+   *
+   * @param string $key Key of the data
+   * @param string $value data
+   */
+  abstract public function set($key, $value);
+
+  /**
+   * Removes the key/data pair for the given $key
+   *
+   * @param String $key
+   */
+  abstract public function delete($key);
+}

wp-content/plugins/w3-total-cache/lib/Google/Cache/Apc.php

@@ -0,0 +1,70 @@
+<?php
+/*
+ * Copyright 2010 Google Inc.
+ *
+ * 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.
+ */
+ 
+/**
+ * A persistent storage class based on the APC cache, which is not
+ * really very persistent, as soon as you restart your web server
+ * the storage will be wiped, however for debugging and/or speed
+ * it can be useful, and cache is a lot cheaper then storage.
+ *
+ * @author Chris Chabot <chabotc@google.com>
+ */
+class W3TCG_Google_Cache_Apc extends W3TCG_Google_Cache_Abstract
+{
+  public function __construct(W3TCG_Google_Client $client)
+  {
+    if (! function_exists('apc_add') ) {
+      throw new W3TCG_Google_Cache_Exception("Apc functions not available");
+    }
+  }
+
+   /**
+   * @inheritDoc
+   */
+  public function get($key, $expiration = false)
+  {
+    $ret = apc_fetch($key);
+    if ($ret === false) {
+      return false;
+    }
+    if (is_numeric($expiration) && (time() - $ret['time'] > $expiration)) {
+      $this->delete($key);
+      return false;
+    }
+    return $ret['data'];
+  }
+
+  /**
+   * @inheritDoc
+   */
+  public function set($key, $value)
+  {
+    $rc = apc_store($key, array('time' => time(), 'data' => $value));
+    if ($rc == false) {
+      throw new W3TCG_Google_Cache_Exception("Couldn't store data");
+    }
+  }
+
+  /**
+   * @inheritDoc
+   * @param String $key
+   */
+  public function delete($key)
+  {
+    apc_delete($key);
+  }
+}

wp-content/plugins/w3-total-cache/lib/Google/Cache/Exception.php

@@ -0,0 +1,20 @@
+<?php
+/*
+ * Copyright 2013 Google Inc.
+ *
+ * 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.
+ */
+
+class W3TCG_Google_Cache_Exception extends W3TCG_Google_Exception
+{
+}

wp-content/plugins/w3-total-cache/lib/Google/Cache/File.php

@@ -0,0 +1,142 @@
+<?php
+/*
+ * Copyright 2008 Google Inc.
+ *
+ * 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.
+ */
+
+/*
+ * This class implements a basic on disk storage. While that does
+ * work quite well it's not the most elegant and scalable solution.
+ * It will also get you into a heap of trouble when you try to run
+ * this in a clustered environment.
+ *
+ * @author Chris Chabot <chabotc@google.com>
+ */
+class W3TCG_Google_Cache_File extends W3TCG_Google_Cache_Abstract
+{
+  const MAX_LOCK_RETRIES = 10;
+  private $path;
+  private $fh;
+
+  public function __construct(W3TCG_Google_Client $client)
+  {
+    $this->path = $client->getClassConfig($this, 'directory');
+  }
+  
+  public function get($key, $expiration = false)
+  {
+    $storageFile = $this->getCacheFile($key);
+    $data = false;
+    
+    if (!file_exists($storageFile)) {
+      return false;
+    }
+
+    if ($expiration) {
+      $mtime = filemtime($storageFile);
+      if ((time() - $mtime) >= $expiration) {
+        $this->delete($key);
+        return false;
+      }
+    }
+
+    if ($this->acquireReadLock($storageFile)) {
+      $data = fread($this->fh, filesize($storageFile));
+      $data =  unserialize($data);
+      $this->unlock($storageFile);
+    }
+
+    return $data;
+  }
+
+  public function set($key, $value)
+  {
+    $storageFile = $this->getWriteableCacheFile($key);
+    if ($this->acquireWriteLock($storageFile)) {
+      // We serialize the whole request object, since we don't only want the
+      // responseContent but also the postBody used, headers, size, etc.
+      $data = serialize($value);
+      $result = fwrite($this->fh, $data);
+      $this->unlock($storageFile);
+    }
+  }
+
+  public function delete($key)
+  {
+    $file = $this->getCacheFile($key);
+    if (file_exists($file) && !unlink($file)) {
+      throw new W3TCG_Google_Cache_Exception("Cache file could not be deleted");
+    }
+  }
+  
+  private function getWriteableCacheFile($file)
+  {
+    return $this->getCacheFile($file, true);
+  }
+
+  private function getCacheFile($file, $forWrite = false)
+  {
+    return $this->getCacheDir($file, $forWrite) . '/' . md5($file);
+  }
+  
+  private function getCacheDir($file, $forWrite)
+  {
+    // use the first 2 characters of the hash as a directory prefix
+    // this should prevent slowdowns due to huge directory listings
+    // and thus give some basic amount of scalability
+    $storageDir = $this->path . '/' . substr(md5($file), 0, 2);
+    if ($forWrite && ! is_dir($storageDir)) {
+      if (! mkdir($storageDir, 0755, true)) {
+        throw new W3TCG_Google_Cache_Exception("Could not create storage directory: $storageDir");
+      }
+    }
+    return $storageDir;
+  }
+  
+  private function acquireReadLock($storageFile)
+  {
+    return $this->acquireLock(LOCK_SH, $storageFile);
+  }
+  
+  private function acquireWriteLock($storageFile)
+  {
+    $rc = $this->acquireLock(LOCK_EX, $storageFile);
+    if (!$rc) {
+      $this->delete($storageFile);
+    }
+    return $rc;
+  }
+  
+  private function acquireLock($type, $storageFile)
+  {
+    $mode = $type == LOCK_EX ? "w" : "r";
+    $this->fh = fopen($storageFile, $mode);
+    $count = 0;
+    while (!flock($this->fh, $type | LOCK_NB)) {
+      // Sleep for 10ms.
+      usleep(10000);
+      if (++$count < self::MAX_LOCK_RETRIES) {
+        return false;
+      }
+    }
+    return true;
+  }
+  
+  public function unlock($storageFile)
+  {
+    if ($this->fh) {
+      flock($this->fh, LOCK_UN);
+    }
+  }
+}

wp-content/plugins/w3-total-cache/lib/Google/Cache/Memcache.php

@@ -0,0 +1,134 @@
+<?php
+/*
+ * Copyright 2008 Google Inc.
+ *
+ * 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.
+ */
+
+/**
+ * A persistent storage class based on the memcache, which is not
+ * really very persistent, as soon as you restart your memcache daemon
+ * the storage will be wiped.
+ *
+ * Will use either the memcache or memcached extensions, preferring
+ * memcached.
+ *
+ * @author Chris Chabot <chabotc@google.com>
+ */
+class W3TCG_Google_Cache_Memcache extends W3TCG_Google_Cache_Abstract
+{
+  private $connection = false;
+  private $mc = false;
+  private $host;
+  private $port;
+
+  public function __construct(W3TCG_Google_Client $client)
+  {
+    if (!function_exists('memcache_connect') && !class_exists("Memcached")) {
+      throw new W3TCG_Google_Cache_Exception("Memcache functions not available");
+    }
+    if ($client->isAppEngine()) {
+      // No credentials needed for GAE.
+      $this->mc = new Memcached();
+      $this->connection = true;
+    } else {
+      $this->host = $client->getClassConfig($this, 'host');
+      $this->port = $client->getClassConfig($this, 'port');
+      if (empty($this->host) || (empty($this->port) && (string) $this->port != "0")) {
+        throw new W3TCG_Google_Cache_Exception("You need to supply a valid memcache host and port");
+      }
+    }
+  }
+  
+  /**
+   * @inheritDoc
+   */
+  public function get($key, $expiration = false)
+  {
+    $this->connect();
+    $ret = false;
+    if ($this->mc) {
+      $ret = $this->mc->get($key);
+    } else {
+      $ret = memcache_get($this->connection, $key);
+    }
+    if ($ret === false) {
+      return false;
+    }
+    if (is_numeric($expiration) && (time() - $ret['time'] > $expiration)) {
+      $this->delete($key);
+      return false;
+    }
+    return $ret['data'];
+  }
+
+  /**
+   * @inheritDoc
+   * @param string $key
+   * @param string $value
+   * @throws W3TCG_Google_Cache_Exception
+   */
+  public function set($key, $value)
+  {
+    $this->connect();
+    // we store it with the cache_time default expiration so objects will at
+    // least get cleaned eventually.
+    $data = array('time' => time(), 'data' => $value);
+    $rc = false;
+    if ($this->mc) {
+      $rc = $this->mc->set($key, $data);
+    } else {
+      $rc = memcache_set($this->connection, $key, $data, false);
+    }
+    if ($rc == false) {
+      throw new W3TCG_Google_Cache_Exception("Couldn't store data in cache");
+    }
+  }
+
+  /**
+   * @inheritDoc
+   * @param String $key
+   */
+  public function delete($key)
+  {
+    $this->connect();
+    if ($this->mc) {
+      $this->mc->delete($key, 0);
+    } else {
+      memcache_delete($this->connection, $key, 0);
+    }
+  }
+
+  /**
+   * Lazy initialiser for memcache connection. Uses pconnect for to take 
+   * advantage of the persistence pool where possible. 
+   */
+  private function connect()
+  {
+    if ($this->connection) {
+      return;
+    }
+
+    if (class_exists("Memcached")) {
+      $this->mc = new Memcached();
+      $this->mc->addServer($this->host, $this->port);
+       $this->connection = true;
+    } else {
+      $this->connection = memcache_pconnect($this->host, $this->port);
+    }
+    
+    if (! $this->connection) {
+      throw new W3TCG_Google_Cache_Exception("Couldn't connect to memcache server");
+    }
+  }
+}

wp-content/plugins/w3-total-cache/lib/Google/Cache/Null.php

@@ -0,0 +1,53 @@
+<?php
+/*
+ * Copyright 2014 Google Inc.
+ *
+ * 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.
+ */
+
+/**
+ * A blank storage class, for cases where caching is not
+ * required.
+ */
+class W3TCG_Google_Cache_Null extends W3TCG_Google_Cache_Abstract
+{
+  public function __construct(W3TCG_Google_Client $client)
+  {
+
+  }
+
+   /**
+   * @inheritDoc
+   */
+  public function get($key, $expiration = false)
+  {
+    return false;
+  }
+
+  /**
+   * @inheritDoc
+   */
+  public function set($key, $value)
+  {
+    // Nop.
+  }
+
+  /**
+   * @inheritDoc
+   * @param String $key
+   */
+  public function delete($key)
+  {
+    // Nop.
+  }
+}