/** * Calls the corresponding function in the block and executes the data retrieval function. * @return \SimpleXMLElement The XML data tree */ public final function callMemcacheBlock() { $callback = $this->getCallback(); $db = $this->getDatabase(); $mem = new \System\Cache\Memcache\Memcache(); $xml = null; if ($mem->keyExists($this->key)) { $xmlString = $mem->get($this->key); if ($xmlString) { //suppress warning here in case of malformed xml $xml = @simplexml_load_string($xmlString); if ($xml instanceof \SimpleXMLElement) { return $xml; } else { $errorLogger = \System\Log\ErrorLogger::getInstance(); $errorLogger->out('[MemcacheBlock] Could not read memcache key ' . $this->key . ' as XML. Regenerating.', \System\Log\LoggerLevel::LEVEL_WARNING); } } } if (is_callable($callback)) { $xml = call_user_func($callback, $this); $mem->store($this->key, $xml->asXML(), $this->timeout); } else { throw new \System\Error\Exception\InvalidMethodException('The given callback cannot be called. Does it exist and is it public?'); } return $xml; }
/** * The constructor initializes the session and sends the session headers * The session will be based on the given session handler. The session handler can be overridden by setting the SESSION_HANDLER definition. * Do note: if a handler fails to initialize, it will default to the DEFAULT_HANDLER. */ public final function __construct() { if (!self::$headersSend) { //apply the session handler directive to our system if (!defined('SESSION_HANDLER')) { throw new \System\Error\Exception\SystemException('Invalid session handler given. Set to HANDLER_FILES; HANDLER_MEMCACHE; or a SessionHandler class'); } self::$currentHandler = SESSION_HANDLER; switch (self::$currentHandler) { case SessionHandler::HANDLER_MEMCACHE: //initialize memcache and establish a connection. This makes sure the MEMCACHE_* settings are defined and correct. $memcache = new \System\Cache\Memcache\Memcache(); //if we are not connected, we do a fallthrough to regular files. if ($memcache->isConnected()) { ini_set('session.save_handler', 'memcache'); $hosts = $ports = array(); \System\Cache\Memcache\Memcache::getServers($hosts, $ports); $connectArray = array(); foreach ($hosts as $index => $host) { $connectArray[] = 'tcp://' . $host . ':' . $ports[$index]; } //the save path expects something like 'tcp://IP:PORT' ini_set('session.save_path', implode(',', $connectArray)); break; } //we do a fallthrough if the memcache is not connected and revert to files self::$currentHandler = SessionHandler::HANDLER_FILES; case SessionHandler::HANDLER_FILES: if (session_save_path() == '') { session_save_path(PATH_TEMP); //we use the temporary folder for this. } break; default: if (class_exists(self::$currentHandler) && in_array('SessionHandlerInterface', class_implements(self::$currentHandler, true))) { self::$customHandler = new self::$currentHandler(); session_set_save_handler(self::$customHandler, true); } else { throw new \System\Error\Exception\SystemException('Invalid session handler given: ' . self::$currentHandler); } } //this implicitly sends a few headers session_cache_limiter('nocache'); session_cache_expire(180); //this is the default, but we set it explicitly session_name(SITE_IDENTIFIER . '_session'); session_start(); //we should only set our headers once self::$headersSend = true; } }
/** * Provides functionality to check if a given IP is blocked by a common blacklist * Do note this system requires the use of the PERMABAN_* directives * @param string The IP Address to check. * @return bool True if the IP is allowed, false otherwise */ public static final function isIPAllowed($ipAddress) { //if there is an explicit empty PERMABAN, we accept everything if (PERMABAN_HOST == '') { return true; } $allowed = true; $mc = new \System\Cache\Memcache\Memcache(); $key = self::MEMCACHE_KEY . $ipAddress; //we get the value from the memcache, and only recheck if the blocked user is on it. if (!($allowed = $mc->get($key))) { $db = \System\Db\Database::getConnection(PERMABAN_HOST, PERMABAN_USER, PERMABAN_PASS, PERMABAN_NAME, PERMABAN_PORT); $query = new \System\Db\Query($db, \System\HTTP\Visitor\PermaBan\SQL_PERMABAN_CHECK_PERMABAN); $query->bind($ipAddress, \System\Db\QueryType::TYPE_STRING); $results = $db->query($query); $allowed = $results->count() == 0; $mc->store($key, $allowed); } return $allowed; }
/** * Stores a value from the LUTCache to the LUTCacheCache to relieve strain. * @param string The key to use for the LUT. Max 255 chars. * @param mixed The value to store. If the value is NULL, the entry is unset. */ private static final function setLUTCacheCache($key, $value = null) { switch (LUTCACHE_CACHE) { case Types::CACHE_MEMCACHE: $mc = new \System\Cache\Memcache\Memcache(); if ($value === null) { unset($mc->{$key}); } else { $mc->store($key, $value, self::CACHE_CACHE_MEMCACHE_TIMEOUT); } break; case Types::CACHE_APC: $apc = new \System\Cache\APCCache\APCCache(); if ($value === null) { unset($apc->{$key}); } else { $apc->{$key} = $value; } break; case Types::CACHE_NONE: default: break; } }