Core.inc.php

<?php
 
define('PKP_LIB_PATH', 'lib' . DIRECTORY_SEPARATOR . 'pkp');
define('COUNTER_USER_AGENTS_FILE', Core::getBaseDir() . DIRECTORY_SEPARATOR . PKP_LIB_PATH . DIRECTORY_SEPARATOR . 'lib' . DIRECTORY_SEPARATOR . 'counterBots' .  DIRECTORY_SEPARATOR . 'generated' . DIRECTORY_SEPARATOR . 'COUNTER_Robots_list.txt');
 
class Core {
 
   static $botRegexps = array();
 
   static function getBaseDir() {
      static $baseDir;
 
      if (!isset($baseDir)) {
         // Need to change if the index file moves
         $baseDir = dirname(INDEX_FILE_LOCATION);
      }
 
      return $baseDir;
   }
 
   static function cleanFileVar($var) {
      return PKPString::regexp_replace('/[^\w\-]/', '', $var);
   }
 
   static function getCurrentDate($ts = null) {
      return date('Y-m-d H:i:s', isset($ts) ? $ts : time());
   }
 
   static function microtime() {
      list($usec, $sec) = explode(' ', microtime());
      return (float)$sec + (float)$usec;
   }
 
   static function isWindows() {
      return strtolower_codesafe(substr(PHP_OS, 0, 3)) == 'win';
   }
 
   static function checkGeneralPHPModule($moduleName) {
      if (extension_loaded($moduleName)) {
         return true;
      }
      return false;
   }
 
   static function isUserAgentBot($userAgent, $botRegexpsFile = COUNTER_USER_AGENTS_FILE) {
      static $botRegexps;
      Registry::set('currentUserAgentsFile', $botRegexpsFile);
 
      if (!isset($botRegexps[$botRegexpsFile])) {
         $botFileCacheId = md5($botRegexpsFile);
         $cacheManager = CacheManager::getManager();
         $cache = $cacheManager->getCache('core', $botFileCacheId, array('Core', '_botFileListCacheMiss'), CACHE_TYPE_FILE);
         $botRegexps[$botRegexpsFile] = $cache->getContents();
      }
 
      foreach ($botRegexps[$botRegexpsFile] as $regexp) {
         // make the search case insensitive
         $regexp .= 'i';
         if (PKPString::regexp_match($regexp, $userAgent)) {
            return true;
         }
      }
 
      return false;
   }
 
   static function getContextPaths($urlInfo, $isPathInfo, $contextList = null, $contextDepth = null, $userVars = array()) {
      $contextPaths = array();
      $application = Application::get();
 
      if (!$contextList) {
         $contextList = $application->getContextList();
      }
      if (!$contextDepth) {
         $contextDepth = $application->getContextDepth();
      }
 
      // Handle context depth 0
      if (!$contextDepth) return $contextPaths;
 
      if ($isPathInfo) {
         // Split the path info into its constituents. Save all non-context
         // path info in $contextPaths[$contextDepth]
         // by limiting the explode statement.
         $contextPaths = explode('/', trim($urlInfo, '/'), $contextDepth + 1);
         // Remove the part of the path info that is not relevant for context (if present)
         unset($contextPaths[$contextDepth]);
      } else {
         // Retrieve context from url query string
         foreach($contextList as $key => $contextName) {
            $contextPaths[$key] = Core::_getUserVar($urlInfo, $contextName, $userVars);
         }
      }
 
      // Canonicalize and clean context paths
      for($key = 0; $key < $contextDepth; $key++) {
         $contextPaths[$key] = (
            isset($contextPaths[$key]) && !empty($contextPaths[$key]) ?
            $contextPaths[$key] : 'index'
         );
         $contextPaths[$key] = Core::cleanFileVar($contextPaths[$key]);
      }
 
      return $contextPaths;
   }
 
   static function getPage($urlInfo, $isPathInfo, $userVars = array()) {
      $page = Core::_getUrlComponents($urlInfo, $isPathInfo, 0, 'page', $userVars);
      return Core::cleanFileVar(is_null($page) ? '' : $page);
   }
 
   static function getOp($urlInfo, $isPathInfo, $userVars = array()) {
      $operation = Core::_getUrlComponents($urlInfo, $isPathInfo, 1, 'op', $userVars);
      return Core::cleanFileVar(empty($operation) ? 'index' : $operation);
   }
 
   static function getArgs($urlInfo, $isPathInfo, $userVars = array()) {
      return Core::_getUrlComponents($urlInfo, $isPathInfo, 2, 'path', $userVars);
   }
 
   function removeBaseUrl($url) {
      list($baseUrl, $contextPath) = Core::_getBaseUrlAndPath($url);
 
      if (!$baseUrl) return false;
 
      // Remove base url from url, if any.
      $url = str_replace($baseUrl, '', $url);
 
      // If url doesn't have the entire protocol and host part,
      // remove any possible base url path from url.
      $baseUrlPath = parse_url($baseUrl, PHP_URL_PATH);
      if ($baseUrlPath == $url) {
         // Access to the base url, no context, the entire
         // url is part of the base url and we can return empty.
         $url = '';
      } else {
         // Handle case where index.php was removed by rewrite rules,
         // and we have base url followed by the args.
         if (strpos($url, $baseUrlPath . '?') === 0) {
            $replacement = '?'; // Url path replacement.
            $baseSystemEscapedPath = preg_quote($baseUrlPath . '?', '/');
         } else {
            $replacement = '/'; // Url path replacement.
            $baseSystemEscapedPath = preg_quote($baseUrlPath . '/', '/');
         }
         $url = preg_replace('/^' . $baseSystemEscapedPath . '/', $replacement, $url);
 
         // Remove possible index.php page from url.
         $url = str_replace('/index.php', '', $url);
      }
 
      if ($contextPath) {
         // We found the contextPath using the base_url
         // config file settings. Check if the url starts
         // with the context path, if not, prepend it.
         if (strpos($url, '/' . $contextPath . '/') !== 0) {
            $url = '/' . $contextPath . $url;
         }
      }
 
      // Remove any possible trailing slashes.
      $url = rtrim($url, '/');
 
      return $url;
   }
 
   function _getBaseUrlAndPath($url) {
      $baseUrl = false;
      $contextPath = false;
 
      // Check for override base url settings.
      $contextBaseUrls = Config::getContextBaseUrls();
 
      if (empty($contextBaseUrls)) {
         $baseUrl = Config::getVar('general', 'base_url');
      } else {
         // We are just interested in context base urls, remove the index one.
         if (isset($contextBaseUrls['index'])) {
            unset($contextBaseUrls['index']);
         }
 
         // Arrange them in length order, so we make sure
         // we get the correct one, in case there's an overlaping
         // of contexts, eg.:
         // base_url[context1] = http://somesite.com/
         // base_url[context2] = http://somesite.com/context2
         $sortedBaseUrls = array_combine($contextBaseUrls, array_map('strlen', $contextBaseUrls));
         arsort($sortedBaseUrls);
 
         foreach (array_keys($sortedBaseUrls) as $workingBaseUrl) {
            $urlHost = parse_url($url, PHP_URL_HOST);
            if (is_null($urlHost)) {
               // Check the base url without the host part.
               $baseUrlHost = parse_url($workingBaseUrl, PHP_URL_HOST);
               if (is_null($baseUrlHost)) break;
               $baseUrlToSearch = substr($workingBaseUrl, strpos($workingBaseUrl, $baseUrlHost) + strlen($baseUrlHost));
               // Base url with only host part, add trailing slash
               // so it can be checked below.
               if (!$baseUrlToSearch) $baseUrlToSearch = '/';
            } else {
               $baseUrlToSearch = $workingBaseUrl;
            }
 
            $baseUrlCheck = Core::_checkBaseUrl($baseUrlToSearch, $url);
            if (is_null($baseUrlCheck)) {
               // Can't decide. Stop searching.
               break;
            } else if ($baseUrlCheck === true) {
               $contextPath = array_search($workingBaseUrl, $contextBaseUrls);
               $baseUrl = $workingBaseUrl;
               break;
            }
         }
      }
 
      return array($baseUrl, $contextPath);
   }
 
   function _checkBaseUrl($baseUrl, $url) {
      // Check if both base url and url have host
      // component or not.
      $baseUrlHasHost = (boolean) parse_url($baseUrl, PHP_URL_HOST);
      $urlHasHost = (boolean) parse_url($url, PHP_URL_HOST);
      if ($baseUrlHasHost !== $urlHasHost) return false;
 
      $contextBaseUrls =& Config::getContextBaseUrls();
 
      // If the base url is found inside the passed url,
      // then we might found the right context path.
      if (strpos($url, $baseUrl) === 0) {
         if (strpos($url, '/index.php') == strlen($baseUrl) - 1) {
            // index.php appears right after the base url,
            // no more possible paths.
            return true;
         } else {
            // Still have to check if there is no other context
            // base url that combined with it's context path is
            // equal to this base url. If it exists, we can't
            // tell which base url is contained in url.
            foreach ($contextBaseUrls as $contextPath => $workingBaseUrl) {
               $urlToCheck = $workingBaseUrl . '/' . $contextPath;
               if (!$baseUrlHasHost) $urlToCheck = parse_url($urlToCheck, PHP_URL_PATH);
               if ($baseUrl == $urlToCheck) {
                  return null;
               }
            }
 
            return true;
         }
      }
 
      return false;
   }
 
   static function _botFileListCacheMiss($cache) {
      $id = $cache->getCacheId();
      $filteredBotRegexps = array_filter(file(Registry::get('currentUserAgentsFile')),
         function ($regexp) {
            $regexp = trim($regexp);
            return !empty($regexp) && $regexp[0] != '#';
         }
      );
      $botRegexps = array_map(function ($regexp) {
            $delimiter = '/';
            $regexp = trim($regexp);
            if(strpos($regexp, $delimiter) !== 0) {
               // Make sure delimiters are in place.
               $regexp = $delimiter . $regexp . $delimiter;
            }
            return $regexp;
         },
         $filteredBotRegexps
      );
      $cache->setEntireCache($botRegexps);
      return $botRegexps;
   }
 
   private static function _getUserVar($url, $varName, $userVars = array()) {
      $returner = null;
      parse_str(parse_url($url, PHP_URL_QUERY), $userVarsFromUrl);
      if (isset($userVarsFromUrl[$varName])) $returner = $userVarsFromUrl[$varName];
 
      if (is_null($returner)) {
         // Try to retrieve from passed user vars, if any.
         if (!empty($userVars) && isset($userVars[$varName])) {
            $returner = $userVars[$varName];
         }
      }
 
      return $returner;
   }
 
   private static function _getUrlComponents($urlInfo, $isPathInfo, $offset, $varName = '', $userVars = array()) {
      $component = null;
 
      $isArrayComponent = false;
      if ($varName == 'path') {
         $isArrayComponent = true;
      }
      if ($isPathInfo) {
         $application = Application::get();
         $contextDepth = $application->getContextDepth();
 
         $vars = explode('/', trim($urlInfo, '/'));
         if (count($vars) > $contextDepth + $offset) {
            if ($isArrayComponent) {
               $component = array_slice($vars, $contextDepth + $offset);
            } else {
               $component = $vars[$contextDepth + $offset];
            }
         }
      } else {
         $component = Core::_getUserVar($urlInfo, $varName, $userVars);
      }
 
      if ($isArrayComponent) {
         if (empty($component)) $component = array();
         elseif (!is_array($component)) $component = array($component);
      }
 
      return $component;
   }
}