CRM/Utils/System.php

   1 <?php
   2 /*
   3  +--------------------------------------------------------------------+
   4  | CiviCRM version 4.6                                                |
   5  +--------------------------------------------------------------------+
   6  | Copyright CiviCRM LLC (c) 2004-2015                                |
   7  +--------------------------------------------------------------------+
   8  | This file is a part of CiviCRM.                                    |
   9  |                                                                    |
  10  | CiviCRM is free software; you can copy, modify, and distribute it  |
  11  | under the terms of the GNU Affero General Public License           |
  12  | Version 3, 19 November 2007 and the CiviCRM Licensing Exception.   |
  13  |                                                                    |
  14  | CiviCRM is distributed in the hope that it will be useful, but     |
  15  | WITHOUT ANY WARRANTY; without even the implied warranty of         |
  16  | MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.               |
  17  | See the GNU Affero General Public License for more details.        |
  18  |                                                                    |
  19  | You should have received a copy of the GNU Affero General Public   |
  20  | License and the CiviCRM Licensing Exception along                  |
  21  | with this program; if not, contact CiviCRM LLC                     |
  22  | at info[AT]civicrm[DOT]org. If you have questions about the        |
  23  | GNU Affero General Public License or the licensing of CiviCRM,     |
  24  | see the CiviCRM license FAQ at http://civicrm.org/licensing        |
  25  +--------------------------------------------------------------------+
  26  */
  27
  28 /**
  29  *
  30  * @package CRM
  31  * @copyright CiviCRM LLC (c) 2004-2015
  32  * $Id$
  33  *
  34  */
  35
  36 /**
  37  * System wide utilities.
  38  *
  39  */
  40 class CRM_Utils_System {
  41
  42   static $_callbacks = NULL;
  43
  44   /**
  45    * @var string Page title
  46    */
  47   static $title = '';
  48
  49   /**
  50    * Compose a new URL string from the current URL string.
  51    *
  52    * Used by all the framework components, specifically,
  53    * pager, sort and qfc
  54    *
  55    * @param string $urlVar
  56    *   The url variable being considered (i.e. crmPageID, crmSortID etc).
  57    * @param bool $includeReset
  58    *   (optional) Whether to include the reset GET string (if present).
  59    * @param bool $includeForce
  60    *   (optional) Whether to include the force GET string (if present).
  61    * @param string $path
  62    *   (optional) The path to use for the new url.
  63    * @param bool|string $absolute
  64    *   (optional) Whether to return an absolute URL.
  65    *
  66    * @return string
  67    *   The URL fragment.
  68    */
  69   public static function makeURL($urlVar, $includeReset = FALSE, $includeForce = TRUE, $path = NULL, $absolute = FALSE) {
  70     if (empty($path)) {
  71       $config = CRM_Core_Config::singleton();
  72       $path = CRM_Utils_Array::value($config->userFrameworkURLVar, $_GET);
  73       if (empty($path)) {
  74         return '';
  75       }
  76     }
  77
  78     return
  79       self::url(
  80         $path,
  81         CRM_Utils_System::getLinksUrl($urlVar, $includeReset, $includeForce),
  82         $absolute
  83       );
  84   }
  85
  86   /**
  87    * Get the query string and clean it up.
  88    *
  89    * Strips some variables that should not be propagated, specifically variables
  90    * like 'reset'. Also strips any side-affect actions (e.g. export).
  91    *
  92    * This function is copied mostly verbatim from Pager.php (_getLinksUrl)
  93    *
  94    * @param string $urlVar
  95    *   The URL variable being considered (e.g. crmPageID, crmSortID etc).
  96    * @param bool $includeReset
  97    *   (optional) By default this is FALSE, meaning that the reset parameter
  98    *   is skipped. Set to TRUE to leave the reset parameter as-is.
  99    * @param bool $includeForce
 100    *   (optional)
 101    * @param bool $skipUFVar
 102    *   (optional)
 103    *
 104    * @return string
 105    */
 106   public static function getLinksUrl($urlVar, $includeReset = FALSE, $includeForce = TRUE, $skipUFVar = TRUE) {
 107     // Sort out query string to prevent messy urls
 108     $querystring = array();
 109     $qs = array();
 110     $arrays = array();
 111
 112     if (!empty($_SERVER['QUERY_STRING'])) {
 113       $qs = explode('&', str_replace('&amp;', '&', $_SERVER['QUERY_STRING']));
 114       for ($i = 0, $cnt = count($qs); $i < $cnt; $i++) {
 115         // check first if exist a pair
 116         if (strstr($qs[$i], '=') !== FALSE) {
 117           list($name, $value) = explode('=', $qs[$i]);
 118           if ($name != $urlVar) {
 119             $name = rawurldecode($name);
 120             //check for arrays in parameters: site.php?foo[]=1&foo[]=2&foo[]=3
 121             if ((strpos($name, '[') !== FALSE) &&
 122               (strpos($name, ']') !== FALSE)
 123             ) {
 124               $arrays[] = $qs[$i];
 125             }
 126             else {
 127               $qs[$name] = $value;
 128             }
 129           }
 130         }
 131         else {
 132           $qs[$qs[$i]] = '';
 133         }
 134         unset($qs[$i]);
 135       }
 136     }
 137
 138     if ($includeForce) {
 139       $qs['force'] = 1;
 140     }
 141
 142     // Ok this is a big assumption but usually works
 143     // If we are in snippet mode, retain the 'section' param, if not, get rid
 144     // of it.
 145     if (!empty($qs['snippet'])) {
 146       unset($qs['snippet']);
 147     }
 148     else {
 149       unset($qs['section']);
 150     }
 151
 152     if ($skipUFVar) {
 153       $config = CRM_Core_Config::singleton();
 154       unset($qs[$config->userFrameworkURLVar]);
 155     }
 156
 157     foreach ($qs as $name => $value) {
 158       if ($name != 'reset' || $includeReset) {
 159         $querystring[] = $name . '=' . $value;
 160       }
 161     }
 162
 163     $querystring = array_merge($querystring, array_unique($arrays));
 164
 165     $url = implode('&', $querystring);
 166     if ($urlVar) {
 167       $url .= (!empty($querystring) ? '&' : '') . $urlVar . '=';
 168     }
 169
 170     return $url;
 171   }
 172
 173   /**
 174    * If we are using a theming system, invoke theme, else just print the
 175    * content.
 176    *
 177    * @param string $content
 178    *   The content that will be themed.
 179    * @param bool $print
 180    *   (optional) Are we displaying to the screen or bypassing theming?
 181    * @param bool $maintenance
 182    *   (optional) For maintenance mode.
 183    *
 184    * @return string
 185    */
 186   public static function theme(
 187     &$content,
 188     $print = FALSE,
 189     $maintenance = FALSE
 190   ) {
 191     $config = &CRM_Core_Config::singleton();
 192     return $config->userSystem->theme($content, $print, $maintenance);
 193   }
 194
 195   /**
 196    * Generate a query string if input is an array.
 197    *
 198    * @param array|string $query
 199    * @return string
 200    */
 201   public static function makeQueryString($query) {
 202     if (is_array($query)) {
 203       $buf = '';
 204       foreach ($query as $key => $value) {
 205         $buf .= ($buf ? '&' : '') . urlencode($key) . '=' . urlencode($value);
 206       }
 207       $query = $buf;
 208     }
 209     return $query;
 210   }
 211
 212   /**
 213    * Generate an internal CiviCRM URL.
 214    *
 215    * @param string $path
 216    *   The path being linked to, such as "civicrm/add".
 217    * @param array|string $query
 218    *   A query string to append to the link, or an array of key-value pairs.
 219    * @param bool $absolute
 220    *   Whether to force the output to be an absolute link (beginning with a
 221    *   URI-scheme such as 'http:'). Useful for links that will be displayed
 222    *   outside the site, such as in an RSS feed.
 223    * @param string $fragment
 224    *   A fragment identifier (named anchor) to append to the link.
 225    *
 226    * @param bool $htmlize
 227    * @param bool $frontend
 228    * @param bool $forceBackend
 229    * @return string
 230    *   An HTML string containing a link to the given path.
 231    */
 232   public static function url(
 233     $path = NULL,
 234     $query = NULL,
 235     $absolute = FALSE,
 236     $fragment = NULL,
 237     $htmlize = TRUE,
 238     $frontend = FALSE,
 239     $forceBackend = FALSE
 240   ) {
 241     $query = self::makeQueryString($query);
 242
 243     // we have a valid query and it has not yet been transformed
 244     if ($htmlize && !empty($query) && strpos($query, '&amp;') === FALSE) {
 245       $query = htmlentities($query);
 246     }
 247
 248     $config = CRM_Core_Config::singleton();
 249     return $config->userSystem->url($path, $query, $absolute, $fragment, $htmlize, $frontend, $forceBackend);
 250   }
 251
 252   /**
 253    * @param $text
 254    * @param null $path
 255    * @param null $query
 256    * @param bool $absolute
 257    * @param null $fragment
 258    * @param bool $htmlize
 259    * @param bool $frontend
 260    * @param bool $forceBackend
 261    *
 262    * @return string
 263    */
 264   public static function href(
 265     $text, $path = NULL, $query = NULL, $absolute = TRUE,
 266     $fragment = NULL, $htmlize = TRUE, $frontend = FALSE, $forceBackend = FALSE
 267   ) {
 268     $url = self::url($path, $query, $absolute, $fragment, $htmlize, $frontend, $forceBackend);
 269     return "<a href=\"$url\">$text</a>";
 270   }
 271
 272   /**
 273    * @return mixed
 274    */
 275   public static function permissionDenied() {
 276     $config = CRM_Core_Config::singleton();
 277     return $config->userSystem->permissionDenied();
 278   }
 279
 280   /**
 281    * @return mixed
 282    */
 283   public static function logout() {
 284     $config = CRM_Core_Config::singleton();
 285     return $config->userSystem->logout();
 286   }
 287
 288   /**
 289    * this is a very drupal specific function for now.
 290    */
 291   public static function updateCategories() {
 292     $config = CRM_Core_Config::singleton();
 293     if ($config->userSystem->is_drupal) {
 294       $config->userSystem->updateCategories();
 295     }
 296   }
 297
 298   /**
 299    * What menu path are we currently on. Called for the primary tpl
 300    *
 301    * @return string
 302    *   the current menu path
 303    */
 304   public static function currentPath() {
 305     $config = CRM_Core_Config::singleton();
 306     return trim(CRM_Utils_Array::value($config->userFrameworkURLVar, $_GET), '/');
 307   }
 308
 309   /**
 310    * called from a template to compose a url.
 311    *
 312    * @param array $params
 313    *   List of parameters.
 314    *
 315    * @return string
 316    *   url
 317    */
 318   public static function crmURL($params) {
 319     $p = CRM_Utils_Array::value('p', $params);
 320     if (!isset($p)) {
 321       $p = self::currentPath();
 322     }
 323
 324     return self::url(
 325       $p,
 326       CRM_Utils_Array::value('q', $params),
 327       CRM_Utils_Array::value('a', $params, FALSE),
 328       CRM_Utils_Array::value('f', $params),
 329       CRM_Utils_Array::value('h', $params, TRUE),
 330       CRM_Utils_Array::value('fe', $params, FALSE),
 331       CRM_Utils_Array::value('fb', $params, FALSE)
 332     );
 333   }
 334
 335   /**
 336    * Sets the title of the page.
 337    *
 338    * @param string $title
 339    * @param string $pageTitle
 340    */
 341   public static function setTitle($title, $pageTitle = NULL) {
 342     self::$title = $title;
 343     $config = CRM_Core_Config::singleton();
 344     return $config->userSystem->setTitle($title, $pageTitle);
 345   }
 346
 347   /**
 348    * Figures and sets the userContext.
 349    *
 350    * Uses the referer if valid else uses the default.
 351    *
 352    * @param array $names
 353    *   Refererer should match any str in this array.
 354    * @param string $default
 355    *   (optional) The default userContext if no match found.
 356    */
 357   public static function setUserContext($names, $default = NULL) {
 358     $url = $default;
 359
 360     $session = CRM_Core_Session::singleton();
 361     $referer = CRM_Utils_Array::value('HTTP_REFERER', $_SERVER);
 362
 363     if ($referer && !empty($names)) {
 364       foreach ($names as $name) {
 365         if (strstr($referer, $name)) {
 366           $url = $referer;
 367           break;
 368         }
 369       }
 370     }
 371
 372     if ($url) {
 373       $session->pushUserContext($url);
 374     }
 375   }
 376
 377   /**
 378    * Gets a class name for an object.
 379    *
 380    * @param object $object
 381    *   Object whose class name is needed.
 382    *
 383    * @return string
 384    *   The class name of the object.
 385    */
 386   public static function getClassName($object) {
 387     return get_class($object);
 388   }
 389
 390   /**
 391    * Redirect to another URL.
 392    *
 393    * @param string $url
 394    *   The URL to provide to the browser via the Location header.
 395    */
 396   public static function redirect($url = NULL) {
 397     if (!$url) {
 398       $url = self::url('civicrm/dashboard', 'reset=1');
 399     }
 400
 401     // replace the &amp; characters with &
 402     // this is kinda hackish but not sure how to do it right
 403     $url = str_replace('&amp;', '&', $url);
 404
 405     // If we are in a json context, respond appropriately
 406     if (CRM_Utils_Array::value('snippet', $_GET) === 'json') {
 407       CRM_Core_Page_AJAX::returnJsonResponse(array(
 408         'status' => 'redirect',
 409         'userContext' => $url,
 410       ));
 411     }
 412
 413     header('Location: ' . $url);
 414     self::civiExit();
 415   }
 416
 417   /**
 418    * Redirect to another URL using JavaScript.
 419    *
 420    * Use an html based file with javascript embedded to redirect to another url
 421    * This prevent the too many redirect errors emitted by various browsers
 422    *
 423    * @param string $url
 424    *   (optional) The destination URL.
 425    * @param string $title
 426    *   (optional) The page title to use for the redirect page.
 427    * @param string $message
 428    *   (optional) The message to provide in the body of the redirect page.
 429    */
 430   public static function jsRedirect(
 431     $url = NULL,
 432     $title = NULL,
 433     $message = NULL
 434   ) {
 435     if (!$url) {
 436       $url = self::url('civicrm/dashboard', 'reset=1');
 437     }
 438
 439     if (!$title) {
 440       $title = ts('CiviCRM task in progress');
 441     }
 442
 443     if (!$message) {
 444       $message = ts('A long running CiviCRM task is currently in progress. This message will be refreshed till the task is completed');
 445     }
 446
 447     // replace the &amp; characters with &
 448     // this is kinda hackish but not sure how to do it right
 449     $url = str_replace('&amp;', '&', $url);
 450
 451     $template = CRM_Core_Smarty::singleton();
 452     $template->assign('redirectURL', $url);
 453     $template->assign('title', $title);
 454     $template->assign('message', $message);
 455
 456     $html = $template->fetch('CRM/common/redirectJS.tpl');
 457
 458     echo $html;
 459
 460     self::civiExit();
 461   }
 462
 463   /**
 464    * Append an additional breadcrumb tag to the existing breadcrumbs.
 465    *
 466    * @param $breadCrumbs
 467    */
 468   public static function appendBreadCrumb($breadCrumbs) {
 469     $config = CRM_Core_Config::singleton();
 470     return $config->userSystem->appendBreadCrumb($breadCrumbs);
 471   }
 472
 473   /**
 474    * Reset an additional breadcrumb tag to the existing breadcrumb.
 475    */
 476   public static function resetBreadCrumb() {
 477     $config = CRM_Core_Config::singleton();
 478     return $config->userSystem->resetBreadCrumb();
 479   }
 480
 481   /**
 482    * Append a string to the head of the HTML file.
 483    *
 484    * @param string $bc
 485    */
 486   public static function addHTMLHead($bc) {
 487     $config = CRM_Core_Config::singleton();
 488     return $config->userSystem->addHTMLHead($bc);
 489   }
 490
 491   /**
 492    * Determine the post URL for a form.
 493    *
 494    * @param $action
 495    *   The default action if one is pre-specified.
 496    *
 497    * @return string
 498    *   The URL to post the form.
 499    */
 500   public static function postURL($action) {
 501     $config = CRM_Core_Config::singleton();
 502     return $config->userSystem->postURL($action);
 503   }
 504
 505   /**
 506    * Rewrite various system URLs to https.
 507    */
 508   public static function mapConfigToSSL() {
 509     $config = CRM_Core_Config::singleton();
 510     $config->userFrameworkResourceURL = str_replace('http://', 'https://', $config->userFrameworkResourceURL);
 511     $config->resourceBase = $config->userFrameworkResourceURL;
 512
 513     if (!empty($config->extensionsURL)) {
 514       $config->extensionsURL = str_replace('http://', 'https://', $config->extensionsURL);
 515     }
 516
 517     return $config->userSystem->mapConfigToSSL();
 518   }
 519
 520   /**
 521    * Get the base URL of the system.
 522    *
 523    * @return string
 524    */
 525   public static function baseURL() {
 526     $config = CRM_Core_Config::singleton();
 527     return $config->userFrameworkBaseURL;
 528   }
 529
 530   /**
 531    */
 532   public static function authenticateAbort($message, $abort) {
 533     if ($abort) {
 534       echo $message;
 535       self::civiExit(0);
 536     }
 537     else {
 538       return FALSE;
 539     }
 540   }
 541
 542   /**
 543    * @param bool $abort
 544    *   (optional) Whether to exit; defaults to true.
 545    *
 546    * @return bool
 547    */
 548   public static function authenticateKey($abort = TRUE) {
 549     // also make sure the key is sent and is valid
 550     $key = trim(CRM_Utils_Array::value('key', $_REQUEST));
 551
 552     $docAdd = "More info at:" . CRM_Utils_System::docURL2("Managing Scheduled Jobs", TRUE, NULL, NULL, NULL, "wiki");
 553
 554     if (!$key) {
 555       return self::authenticateAbort(
 556         "ERROR: You need to send a valid key to execute this file. " . $docAdd . "\n",
 557         $abort
 558       );
 559     }
 560
 561     $siteKey = defined('CIVICRM_SITE_KEY') ? CIVICRM_SITE_KEY : NULL;
 562
 563     if (!$siteKey || empty($siteKey)) {
 564       return self::authenticateAbort(
 565         "ERROR: You need to set a valid site key in civicrm.settings.php. " . $docAdd . "\n",
 566         $abort
 567       );
 568     }
 569
 570     if (strlen($siteKey) < 8) {
 571       return self::authenticateAbort(
 572         "ERROR: Site key needs to be greater than 7 characters in civicrm.settings.php. " . $docAdd . "\n",
 573         $abort
 574       );
 575     }
 576
 577     if ($key !== $siteKey) {
 578       return self::authenticateAbort(
 579         "ERROR: Invalid key value sent. " . $docAdd . "\n",
 580         $abort
 581       );
 582     }
 583
 584     return TRUE;
 585   }
 586
 587   /**
 588    * @param bool $abort
 589    * @param null $name
 590    * @param null $pass
 591    * @param bool $storeInSession
 592    * @param bool $loadCMSBootstrap
 593    * @param bool $requireKey
 594    *
 595    * @return bool
 596    */
 597   public static function authenticateScript($abort = TRUE, $name = NULL, $pass = NULL, $storeInSession = TRUE, $loadCMSBootstrap = TRUE, $requireKey = TRUE) {
 598     // auth to make sure the user has a login/password to do a shell operation
 599     // later on we'll link this to acl's
 600     if (!$name) {
 601       $name = trim(CRM_Utils_Array::value('name', $_REQUEST));
 602       $pass = trim(CRM_Utils_Array::value('pass', $_REQUEST));
 603     }
 604
 605     // its ok to have an empty password
 606     if (!$name) {
 607       return self::authenticateAbort(
 608         "ERROR: You need to send a valid user name and password to execute this file\n",
 609         $abort
 610       );
 611     }
 612
 613     if ($requireKey && !self::authenticateKey($abort)) {
 614       return FALSE;
 615     }
 616
 617     $result = CRM_Utils_System::authenticate($name, $pass, $loadCMSBootstrap);
 618     if (!$result) {
 619       return self::authenticateAbort(
 620         "ERROR: Invalid username and/or password\n",
 621         $abort
 622       );
 623     }
 624     elseif ($storeInSession) {
 625       // lets store contact id and user id in session
 626       list($userID, $ufID, $randomNumber) = $result;
 627       if ($userID && $ufID) {
 628         $config = CRM_Core_Config::singleton();
 629         $config->userSystem->setUserSession(array($userID, $ufID));
 630       }
 631       else {
 632         return self::authenticateAbort(
 633           "ERROR: Unexpected error, could not match userID and contactID",
 634           $abort
 635         );
 636       }
 637     }
 638
 639     return $result;
 640   }
 641
 642   /**
 643    * Authenticate the user against the uf db.
 644    *
 645    * In case of successful authentication, returns an array consisting of
 646    * (contactID, ufID, unique string). Returns FALSE if authentication is
 647    * unsuccessful.
 648    *
 649    * @param string $name
 650    *   The username.
 651    * @param string $password
 652    *   The password.
 653    * @param bool $loadCMSBootstrap
 654    * @param $realPath
 655    *
 656    * @return false|array
 657    */
 658   public static function authenticate($name, $password, $loadCMSBootstrap = FALSE, $realPath = NULL) {
 659     $config = CRM_Core_Config::singleton();
 660
 661     /* Before we do any loading, let's start the session and write to it.
 662      * We typically call authenticate only when we need to bootstrap the CMS
 663      * directly via Civi and hence bypass the normal CMS auth and bootstrap
 664      * process typically done in CLI and cron scripts. See: CRM-12648
 665      *
 666      * Q: Can we move this to the userSystem class so that it can be tuned
 667      * per-CMS? For example, when dealing with UnitTests UF, there's no
 668      * userFrameworkDSN.
 669      */
 670     $session = CRM_Core_Session::singleton();
 671     $session->set('civicrmInitSession', TRUE);
 672
 673     if ($config->userFrameworkDSN) {
 674       $dbDrupal = DB::connect($config->userFrameworkDSN);
 675     }
 676     return $config->userSystem->authenticate($name, $password, $loadCMSBootstrap, $realPath);
 677   }
 678
 679   /**
 680    * Set a message in the UF to display to a user.
 681    *
 682    * @param string $message
 683    *   The message to set.
 684    */
 685   public static function setUFMessage($message) {
 686     $config = CRM_Core_Config::singleton();
 687     return $config->userSystem->setMessage($message);
 688   }
 689
 690
 691   /**
 692    * Determine whether a value is null-ish.
 693    *
 694    * @param $value
 695    *   The value to check for null.
 696    * @return bool
 697    */
 698   public static function isNull($value) {
 699     // FIXME: remove $value = 'null' string test when we upgrade our DAO code to handle passing null in a better way.
 700     if (!isset($value) || $value === NULL || $value === '' || $value === 'null') {
 701       return TRUE;
 702     }
 703     if (is_array($value)) {
 704       // @todo Reuse of the $value variable = asking for trouble.
 705       foreach ($value as $key => $value) {
 706         if (!self::isNull($value)) {
 707           return FALSE;
 708         }
 709       }
 710       return TRUE;
 711     }
 712     return FALSE;
 713   }
 714
 715   /**
 716    * Obscure all but the last few digits of a credit card number.
 717    *
 718    * @param string $number
 719    *   The credit card number to obscure.
 720    * @param int $keep
 721    *   (optional) The number of digits to preserve unmodified.
 722    * @return string
 723    *   The obscured credit card number.
 724    */
 725   public static function mungeCreditCard($number, $keep = 4) {
 726     $number = trim($number);
 727     if (empty($number)) {
 728       return NULL;
 729     }
 730     $replace = str_repeat('*', strlen($number) - $keep);
 731     return substr_replace($number, $replace, 0, -$keep);
 732   }
 733
 734   /**
 735    * Determine which PHP modules are loaded.
 736    *
 737    * @return array
 738    */
 739   public static function parsePHPModules() {
 740     ob_start();
 741     phpinfo(INFO_MODULES);
 742     $s = ob_get_contents();
 743     ob_end_clean();
 744
 745     $s = strip_tags($s, '<h2><th><td>');
 746     $s = preg_replace('/<th[^>]*>([^<]+)<\/th>/', "<info>\\1</info>", $s);
 747     $s = preg_replace('/<td[^>]*>([^<]+)<\/td>/', "<info>\\1</info>", $s);
 748     $vTmp = preg_split('/(<h2>[^<]+<\/h2>)/', $s, -1, PREG_SPLIT_DELIM_CAPTURE);
 749     $vModules = array();
 750     for ($i = 1; $i < count($vTmp); $i++) {
 751       if (preg_match('/<h2>([^<]+)<\/h2>/', $vTmp[$i], $vMat)) {
 752         $vName = trim($vMat[1]);
 753         $vTmp2 = explode("\n", $vTmp[$i + 1]);
 754         foreach ($vTmp2 as $vOne) {
 755           $vPat = '<info>([^<]+)<\/info>';
 756           $vPat3 = "/$vPat\s*$vPat\s*$vPat/";
 757           $vPat2 = "/$vPat\s*$vPat/";
 758           // 3cols
 759           if (preg_match($vPat3, $vOne, $vMat)) {
 760             $vModules[$vName][trim($vMat[1])] = array(trim($vMat[2]), trim($vMat[3]));
 761             // 2cols
 762           }
 763           elseif (preg_match($vPat2, $vOne, $vMat)) {
 764             $vModules[$vName][trim($vMat[1])] = trim($vMat[2]);
 765           }
 766         }
 767       }
 768     }
 769     return $vModules;
 770   }
 771
 772   /**
 773    * Get a setting from a loaded PHP module.
 774    */
 775   public static function getModuleSetting($pModuleName, $pSetting) {
 776     $vModules = self::parsePHPModules();
 777     return $vModules[$pModuleName][$pSetting];
 778   }
 779
 780   /**
 781    * @param $title
 782    *   (optional)
 783    *
 784    * @return mixed|string
 785    */
 786   public static function memory($title = NULL) {
 787     static $pid = NULL;
 788     if (!$pid) {
 789       $pid = posix_getpid();
 790     }
 791
 792     $memory = str_replace("\n", '', shell_exec("ps -p" . $pid . " -o rss="));
 793     $memory .= ", " . time();
 794     if ($title) {
 795       CRM_Core_Error::debug_var($title, $memory);
 796     }
 797     return $memory;
 798   }
 799
 800   /**
 801    * @param string $name
 802    * @param string $mimeType
 803    * @param $buffer
 804    * @param string $ext
 805    * @param bool $output
 806    * @param string $disposition
 807    */
 808   public static function download(
 809     $name, $mimeType, &$buffer,
 810     $ext = NULL,
 811     $output = TRUE,
 812     $disposition = 'attachment'
 813   ) {
 814     $now = gmdate('D, d M Y H:i:s') . ' GMT';
 815
 816     header('Content-Type: ' . $mimeType);
 817     header('Expires: ' . $now);
 818
 819     // lem9 & loic1: IE need specific headers
 820     $isIE = strstr($_SERVER['HTTP_USER_AGENT'], 'MSIE');
 821     if ($ext) {
 822       $fileString = "filename=\"{$name}.{$ext}\"";
 823     }
 824     else {
 825       $fileString = "filename=\"{$name}\"";
 826     }
 827     if ($isIE) {
 828       header("Content-Disposition: inline; $fileString");
 829       header('Cache-Control: must-revalidate, post-check=0, pre-check=0');
 830       header('Pragma: public');
 831     }
 832     else {
 833       header("Content-Disposition: $disposition; $fileString");
 834       header('Pragma: no-cache');
 835     }
 836
 837     if ($output) {
 838       print $buffer;
 839       self::civiExit();
 840     }
 841   }
 842
 843   /**
 844    * Gather and print (and possibly log) amount of used memory.
 845    *
 846    * @param string $title
 847    * @param bool $log
 848    *   (optional) Whether to log the memory usage information.
 849    */
 850   public static function xMemory($title = NULL, $log = FALSE) {
 851     $mem = (float ) xdebug_memory_usage() / (float ) (1024);
 852     $mem = number_format($mem, 5) . ", " . time();
 853     if ($log) {
 854       echo "<p>$title: $mem<p>";
 855       flush();
 856       CRM_Core_Error::debug_var($title, $mem);
 857     }
 858     else {
 859       echo "<p>$title: $mem<p>";
 860       flush();
 861     }
 862   }
 863
 864   /**
 865    * Take a URL (or partial URL) and make it better.
 866    *
 867    * Currently, URLs pass straight through unchanged unless they are "seriously
 868    * malformed" (see http://us2.php.net/parse_url).
 869    *
 870    * @param string $url
 871    *   The URL to operate on.
 872    * @return string
 873    *   The fixed URL.
 874    */
 875   public static function fixURL($url) {
 876     $components = parse_url($url);
 877
 878     if (!$components) {
 879       return NULL;
 880     }
 881
 882     // at some point we'll add code here to make sure the url is not
 883     // something that will mess up up, so we need to clean it up here
 884     return $url;
 885   }
 886
 887   /**
 888    * Make sure a callback is valid in the current context.
 889    *
 890    * @param string $callback
 891    *   Name of the function to check.
 892    *
 893    * @return bool
 894    */
 895   public static function validCallback($callback) {
 896     if (self::$_callbacks === NULL) {
 897       self::$_callbacks = array();
 898     }
 899
 900     if (!array_key_exists($callback, self::$_callbacks)) {
 901       if (strpos($callback, '::') !== FALSE) {
 902         list($className, $methodName) = explode('::', $callback);
 903         $fileName = str_replace('_', DIRECTORY_SEPARATOR, $className) . '.php';
 904         // ignore errors if any
 905         @include_once $fileName;
 906         if (!class_exists($className)) {
 907           self::$_callbacks[$callback] = FALSE;
 908         }
 909         else {
 910           // instantiate the class
 911           $object = new $className();
 912           if (!method_exists($object, $methodName)) {
 913             self::$_callbacks[$callback] = FALSE;
 914           }
 915           else {
 916             self::$_callbacks[$callback] = TRUE;
 917           }
 918         }
 919       }
 920       else {
 921         self::$_callbacks[$callback] = function_exists($callback);
 922       }
 923     }
 924     return self::$_callbacks[$callback];
 925   }
 926
 927   /**
 928    * Like PHP's built-in explode(), but always return an array of $limit items.
 929    *
 930    * This serves as a wrapper to the PHP explode() function. In the event that
 931    * PHP's explode() returns an array with fewer than $limit elements, pad
 932    * the end of the array with NULLs.
 933    *
 934    * @param string $separator
 935    * @param string $string
 936    * @param int $limit
 937    * @return string[]
 938    */
 939   public static function explode($separator, $string, $limit) {
 940     $result = explode($separator, $string, $limit);
 941     for ($i = count($result); $i < $limit; $i++) {
 942       $result[$i] = NULL;
 943     }
 944     return $result;
 945   }
 946
 947   /**
 948    * @param string $url
 949    *   The URL to check.
 950    * @param bool $addCookie
 951    *   (optional)
 952    *
 953    * @return mixed
 954    */
 955   public static function checkURL($url, $addCookie = FALSE) {
 956     // make a GET request to $url
 957     $ch = curl_init($url);
 958     if ($addCookie) {
 959       curl_setopt($ch, CURLOPT_COOKIE, http_build_query($_COOKIE));
 960     }
 961     // it's quite alright to use a self-signed cert
 962     curl_setopt($ch, CURLOPT_SSL_VERIFYPEER, 0);
 963
 964     // lets capture the return stuff rather than echo
 965     curl_setopt($ch, CURLOPT_RETURNTRANSFER, TRUE);
 966
 967     // CRM-13227, CRM-14744: only return the SSL error status
 968     return (curl_exec($ch) !== FALSE);
 969   }
 970
 971   /**
 972    * Assert that we are running on a particular PHP version.
 973    *
 974    * @param int $ver
 975    *   The major version of PHP that is required.
 976    * @param bool $abort
 977    *   (optional) Whether to fatally abort if the version requirement is not
 978    *   met. Defaults to TRUE.
 979    * @return bool
 980    *   Returns TRUE if the requirement is met, FALSE if the requirement is not
 981    *   met and we're not aborting due to the failed requirement. If $abort is
 982    *   TRUE and the requirement fails, this function does not return.
 983    */
 984   public static function checkPHPVersion($ver = 5, $abort = TRUE) {
 985     $phpVersion = substr(PHP_VERSION, 0, 1);
 986     if ($phpVersion >= $ver) {
 987       return TRUE;
 988     }
 989
 990     if ($abort) {
 991       CRM_Core_Error::fatal(ts('This feature requires PHP Version %1 or greater',
 992         array(1 => $ver)
 993       ));
 994     }
 995     return FALSE;
 996   }
 997
 998   /**
 999    * @param $string
1000    * @param bool $encode
1001    *
1002    * @return string
1003    */
1004   public static function formatWikiURL($string, $encode = FALSE) {
1005     $items = explode(' ', trim($string), 2);
1006     if (count($items) == 2) {
1007       $title = $items[1];
1008     }
1009     else {
1010       $title = $items[0];
1011     }
1012
1013     // fix for CRM-4044
1014     $url = $encode ? self::urlEncode($items[0]) : $items[0];
1015     return "<a href=\"$url\">$title</a>";
1016   }
1017
1018   /**
1019    * @param string $url
1020    *
1021    * @return null|string
1022    */
1023   public static function urlEncode($url) {
1024     $items = parse_url($url);
1025     if ($items === FALSE) {
1026       return NULL;
1027     }
1028
1029     if (empty($items['query'])) {
1030       return $url;
1031     }
1032
1033     $items['query'] = urlencode($items['query']);
1034
1035     $url = $items['scheme'] . '://';
1036     if (!empty($items['user'])) {
1037       $url .= "{$items['user']}:{$items['pass']}@";
1038     }
1039
1040     $url .= $items['host'];
1041     if (!empty($items['port'])) {
1042       $url .= ":{$items['port']}";
1043     }
1044
1045     $url .= "{$items['path']}?{$items['query']}";
1046     if (!empty($items['fragment'])) {
1047       $url .= "#{$items['fragment']}";
1048     }
1049
1050     return $url;
1051   }
1052
1053   /**
1054    * Return the running civicrm version.
1055    *
1056    * @return string
1057    *   civicrm version
1058    */
1059   public static function version() {
1060     static $version;
1061
1062     if (!$version) {
1063       $verFile = implode(DIRECTORY_SEPARATOR,
1064         array(dirname(__FILE__), '..', '..', 'civicrm-version.php')
1065       );
1066       if (file_exists($verFile)) {
1067         require_once $verFile;
1068         if (function_exists('civicrmVersion')) {
1069           $info = civicrmVersion();
1070           $version = $info['version'];
1071         }
1072       }
1073       else {
1074         // svn installs don't have version.txt by default. In that case version.xml should help -
1075         $verFile = implode(DIRECTORY_SEPARATOR,
1076           array(dirname(__FILE__), '..', '..', 'xml', 'version.xml')
1077         );
1078         if (file_exists($verFile)) {
1079           $str = file_get_contents($verFile);
1080           $xmlObj = simplexml_load_string($str);
1081           $version = (string) $xmlObj->version_no;
1082         }
1083       }
1084
1085       // pattern check
1086       if (!CRM_Utils_System::isVersionFormatValid($version)) {
1087         CRM_Core_Error::fatal('Unknown codebase version.');
1088       }
1089     }
1090
1091     return $version;
1092   }
1093
1094   /**
1095    * Determines whether a string is a valid CiviCRM version string.
1096    *
1097    * @param string $version
1098    *   Version string to be checked.
1099    * @return bool
1100    */
1101   public static function isVersionFormatValid($version) {
1102     return preg_match("/^(\d{1,2}\.){2,3}(\d{1,2}|(alpha|beta)\d{1,2})(\.upgrade)?$/", $version);
1103   }
1104
1105   /**
1106    * Wraps or emulates PHP's getallheaders() function.
1107    */
1108   public static function getAllHeaders() {
1109     if (function_exists('getallheaders')) {
1110       return getallheaders();
1111     }
1112
1113     // emulate get all headers
1114     // http://www.php.net/manual/en/function.getallheaders.php#66335
1115     $headers = array();
1116     foreach ($_SERVER as $name => $value) {
1117       if (substr($name, 0, 5) == 'HTTP_') {
1118         $headers[str_replace(' ',
1119           '-',
1120           ucwords(strtolower(str_replace('_',
1121               ' ',
1122               substr($name, 5)
1123             )
1124           ))
1125         )] = $value;
1126       }
1127     }
1128     return $headers;
1129   }
1130
1131   /**
1132    */
1133   public static function getRequestHeaders() {
1134     if (function_exists('apache_request_headers')) {
1135       return apache_request_headers();
1136     }
1137     else {
1138       return $_SERVER;
1139     }
1140   }
1141
1142   /**
1143    * Determine whether this is an SSL request.
1144    *
1145    * Note that we inline this function in install/civicrm.php, so if you change
1146    * this function, please go and change the code in the install script as well.
1147    */
1148   public static function isSSL() {
1149     return
1150       (isset($_SERVER['HTTPS']) &&
1151         !empty($_SERVER['HTTPS']) &&
1152         strtolower($_SERVER['HTTPS']) != 'off') ? TRUE : FALSE;
1153   }
1154
1155   /**
1156    */
1157   public static function redirectToSSL($abort = FALSE) {
1158     $config = CRM_Core_Config::singleton();
1159     $req_headers = self::getRequestHeaders();
1160     // FIXME: Shouldn't the X-Forwarded-Proto check be part of CRM_Utils_System::isSSL()?
1161     if (CRM_Core_BAO_Setting::getItem(CRM_Core_BAO_Setting::SYSTEM_PREFERENCES_NAME, 'enableSSL') &&
1162       !self::isSSL() &&
1163       strtolower(CRM_Utils_Array::value('X_FORWARDED_PROTO', $req_headers)) != 'https'
1164     ) {
1165       // ensure that SSL is enabled on a civicrm url (for cookie reasons etc)
1166       $url = "https://{$_SERVER['HTTP_HOST']}{$_SERVER['REQUEST_URI']}";
1167       if (!self::checkURL($url, TRUE)) {
1168         if ($abort) {
1169           CRM_Core_Error::fatal('HTTPS is not set up on this machine');
1170         }
1171         else {
1172           CRM_Core_Session::setStatus(ts('HTTPS is not set up on this machine'), ts('Warning'), 'alert');
1173           // admin should be the only one following this
1174           // since we dont want the user stuck in a bad place
1175           return;
1176         }
1177       }
1178       CRM_Utils_System::redirect($url);
1179     }
1180   }
1181
1182   /**
1183    * Get logged in user's IP address.
1184    *
1185    * Get IP address from HTTP REMOTE_ADDR header. If the CMS is Drupal then use
1186    * the Drupal function as this also handles reverse proxies (based on proper
1187    * configuration in settings.php)
1188    *
1189    * @param bool $strictIPV4
1190    *   (optional) Whether to return only IPv4 addresses.
1191    *
1192    * @return string
1193    *   IP address of logged in user.
1194    */
1195   public static function ipAddress($strictIPV4 = TRUE) {
1196     $address = CRM_Utils_Array::value('REMOTE_ADDR', $_SERVER);
1197
1198     $config = CRM_Core_Config::singleton();
1199     if ($config->userSystem->is_drupal && function_exists('ip_address')) {
1200       //drupal function handles the server being behind a proxy securely. We still have legacy ipn methods
1201       // that reach this point without bootstrapping hence the check that the fn exists
1202       $address = ip_address();
1203     }
1204
1205     // hack for safari
1206     if ($address == '::1') {
1207       $address = '127.0.0.1';
1208     }
1209
1210     // when we need to have strictly IPV4 ip address
1211     // convert ipV6 to ipV4
1212     if ($strictIPV4) {
1213       // this converts 'IPV4 mapped IPV6 address' to IPV4
1214       if (filter_var($address, FILTER_VALIDATE_IP, FILTER_FLAG_IPV6) && strstr($address, '::ffff:')) {
1215         $address = ltrim($address, '::ffff:');
1216       }
1217     }
1218
1219     return $address;
1220   }
1221
1222   /**
1223    * Get the referring / previous page URL.
1224    *
1225    * @return string
1226    *   The previous page URL
1227    */
1228   public static function refererPath() {
1229     return CRM_Utils_Array::value('HTTP_REFERER', $_SERVER);
1230   }
1231
1232   /**
1233    * Get the documentation base URL.
1234    *
1235    * @return string
1236    *   Base URL of the CRM documentation.
1237    */
1238   public static function getDocBaseURL() {
1239     // FIXME: move this to configuration at some stage
1240     return 'http://book.civicrm.org/';
1241   }
1242
1243   /**
1244    * Returns wiki (alternate) documentation URL base.
1245    *
1246    * @return string
1247    *   documentation url
1248    */
1249   public static function getWikiBaseURL() {
1250     // FIXME: move this to configuration at some stage
1251     return 'http://wiki.civicrm.org/confluence/display/CRMDOC/';
1252   }
1253
1254   /**
1255    * Returns URL or link to documentation page, based on provided parameters.
1256    *
1257    * For use in PHP code.
1258    * WARNING: Always returns URL, if ts function is not defined ($URLonly has
1259    * no effect).
1260    *
1261    * @param string $page
1262    *   Title of documentation wiki page.
1263    * @param bool $URLonly
1264    *   (optional) Whether to return URL only or full HTML link (default).
1265    * @param string $text
1266    *   (optional) Text of HTML link (no effect if $URLonly = false).
1267    * @param string $title
1268    *   (optional) Tooltip text for HTML link (no effect if $URLonly = false)
1269    * @param string $style
1270    *   (optional) Style attribute value for HTML link (no effect if $URLonly = false)
1271    *
1272    * @param null $resource
1273    *
1274    * @return string
1275    *   URL or link to documentation page, based on provided parameters.
1276    */
1277   public static function docURL2($page, $URLonly = FALSE, $text = NULL, $title = NULL, $style = NULL, $resource = NULL) {
1278     // if ts function doesn't exist, it means that CiviCRM hasn't been fully initialised yet -
1279     // return just the URL, no matter what other parameters are defined
1280     if (!function_exists('ts')) {
1281       if ($resource == 'wiki') {
1282         $docBaseURL = self::getWikiBaseURL();
1283       }
1284       else {
1285         $docBaseURL = self::getDocBaseURL();
1286       }
1287       return $docBaseURL . str_replace(' ', '+', $page);
1288     }
1289     else {
1290       $params = array(
1291         'page' => $page,
1292         'URLonly' => $URLonly,
1293         'text' => $text,
1294         'title' => $title,
1295         'style' => $style,
1296         'resource' => $resource,
1297       );
1298       return self::docURL($params);
1299     }
1300   }
1301
1302   /**
1303    * Returns URL or link to documentation page, based on provided parameters.
1304    *
1305    * For use in templates code.
1306    *
1307    * @param array $params
1308    *   An array of parameters (see CRM_Utils_System::docURL2 method for names)
1309    *
1310    * @return void|string
1311    *   URL or link to documentation page, based on provided parameters.
1312    */
1313   public static function docURL($params) {
1314
1315     if (!isset($params['page'])) {
1316       return NULL;
1317     }
1318
1319     if (CRM_Utils_Array::value('resource', $params) == 'wiki') {
1320       $docBaseURL = self::getWikiBaseURL();
1321     }
1322     else {
1323       $docBaseURL = self::getDocBaseURL();
1324     }
1325
1326     if (!isset($params['title']) or $params['title'] === NULL) {
1327       $params['title'] = ts('Opens documentation in a new window.');
1328     }
1329
1330     if (!isset($params['text']) or $params['text'] === NULL) {
1331       $params['text'] = ts('(learn more...)');
1332     }
1333
1334     if (!isset($params['style']) || $params['style'] === NULL) {
1335       $style = '';
1336     }
1337     else {
1338       $style = "style=\"{$params['style']}\"";
1339     }
1340
1341     $link = $docBaseURL . str_replace(' ', '+', $params['page']);
1342
1343     if (isset($params['URLonly']) && $params['URLonly'] == TRUE) {
1344       return $link;
1345     }
1346     else {
1347       return "<a href=\"{$link}\" $style target=\"_blank\" class=\"crm-doc-link no-popup\" title=\"{$params['title']}\">{$params['text']}</a>";
1348     }
1349   }
1350
1351   /**
1352    * Get the locale set in the hosting CMS.
1353    *
1354    * @return string
1355    *   The used locale or null for none.
1356    */
1357   public static function getUFLocale() {
1358     $config = CRM_Core_Config::singleton();
1359     return $config->userSystem->getUFLocale();
1360   }
1361
1362   /**
1363    * Execute external or internal URLs and return server response.
1364    *
1365    * @param string $url
1366    *   Request URL.
1367    * @param bool $addCookie
1368    *   Whether to provide a cookie. Should be true to access internal URLs.
1369    *
1370    * @return string
1371    *   Response from URL.
1372    */
1373   public static function getServerResponse($url, $addCookie = TRUE) {
1374     CRM_Core_TemporaryErrorScope::ignoreException();
1375     require_once 'HTTP/Request.php';
1376     $request = new HTTP_Request($url);
1377
1378     if ($addCookie) {
1379       foreach ($_COOKIE as $name => $value) {
1380         $request->addCookie($name, $value);
1381       }
1382     }
1383
1384     if (isset($_SERVER['AUTH_TYPE'])) {
1385       $request->setBasicAuth($_SERVER['PHP_AUTH_USER'], $_SERVER['PHP_AUTH_PW']);
1386     }
1387
1388     $config = CRM_Core_Config::singleton();
1389     if ($config->userFramework == 'WordPress') {
1390       session_write_close();
1391     }
1392
1393     $request->sendRequest();
1394     $response = $request->getResponseBody();
1395
1396     return $response;
1397   }
1398
1399   /**
1400    * Exit with provided exit code.
1401    *
1402    * @param int $status
1403    *   (optional) Code with which to exit.
1404    */
1405   public static function civiExit($status = 0) {
1406     // move things to CiviCRM cache as needed
1407     CRM_Core_Session::storeSessionObjects();
1408
1409     exit($status);
1410   }
1411
1412   /**
1413    * Reset the various system caches and some important static variables.
1414    */
1415   public static function flushCache() {
1416     // flush out all cache entries so we can reload new data
1417     // a bit aggressive, but livable for now
1418     $cache = CRM_Utils_Cache::singleton();
1419     $cache->flush();
1420
1421     // also reset the various static memory caches
1422
1423     // reset the memory or array cache
1424     CRM_Core_BAO_Cache::deleteGroup('contact fields', NULL, FALSE);
1425
1426     // reset ACL cache
1427     CRM_ACL_BAO_Cache::resetCache();
1428
1429     // reset various static arrays used here
1430     CRM_Contact_BAO_Contact::$_importableFields = CRM_Contact_BAO_Contact::$_exportableFields
1431       = CRM_Contribute_BAO_Contribution::$_importableFields
1432         = CRM_Contribute_BAO_Contribution::$_exportableFields
1433           = CRM_Pledge_BAO_Pledge::$_exportableFields = CRM_Contribute_BAO_Query::$_contributionFields
1434             = CRM_Core_BAO_CustomField::$_importFields
1435               = CRM_Core_BAO_Cache::$_cache = CRM_Core_DAO::$_dbColumnValueCache = NULL;
1436
1437     CRM_Core_OptionGroup::flushAll();
1438     CRM_Utils_PseudoConstant::flushAll();
1439   }
1440
1441   /**
1442    * Load CMS bootstrap.
1443    *
1444    * @param array $params
1445    *   Array with uid name and pass
1446    * @param bool $loadUser
1447    *   Boolean load user or not.
1448    * @param bool $throwError
1449    * @param $realPath
1450    */
1451   public static function loadBootStrap($params = array(), $loadUser = TRUE, $throwError = TRUE, $realPath = NULL) {
1452     if (!is_array($params)) {
1453       $params = array();
1454     }
1455     $config = CRM_Core_Config::singleton();
1456     return $config->userSystem->loadBootStrap($params, $loadUser, $throwError, $realPath);
1457   }
1458
1459   /**
1460    * Check if user is logged in.
1461    *
1462    * @return bool
1463    */
1464   public static function isUserLoggedIn() {
1465     $config = CRM_Core_Config::singleton();
1466     return $config->userSystem->isUserLoggedIn();
1467   }
1468
1469   /**
1470    * Get current logged in user id.
1471    *
1472    * @return int
1473    *   ufId, currently logged in user uf id.
1474    */
1475   public static function getLoggedInUfID() {
1476     $config = CRM_Core_Config::singleton();
1477     return $config->userSystem->getLoggedInUfID();
1478   }
1479
1480   /**
1481    */
1482   public static function baseCMSURL() {
1483     static $_baseURL = NULL;
1484     if (!$_baseURL) {
1485       $config = CRM_Core_Config::singleton();
1486       $_baseURL = $userFrameworkBaseURL = $config->userFrameworkBaseURL;
1487
1488       if ($config->userFramework == 'Joomla') {
1489         // gross hack
1490         // we need to remove the administrator/ from the end
1491         $_baseURL = str_replace("/administrator/", "/", $userFrameworkBaseURL);
1492       }
1493       else {
1494         // Drupal setting
1495         global $civicrm_root;
1496         if (strpos($civicrm_root,
1497             DIRECTORY_SEPARATOR . 'sites' .
1498             DIRECTORY_SEPARATOR . 'all' .
1499             DIRECTORY_SEPARATOR . 'modules'
1500           ) === FALSE
1501         ) {
1502           $startPos = strpos($civicrm_root,
1503             DIRECTORY_SEPARATOR . 'sites' . DIRECTORY_SEPARATOR
1504           );
1505           $endPos = strpos($civicrm_root,
1506             DIRECTORY_SEPARATOR . 'modules' . DIRECTORY_SEPARATOR
1507           );
1508           if ($startPos && $endPos) {
1509             // if component is in sites/SITENAME/modules
1510             $siteName = substr($civicrm_root,
1511               $startPos + 7,
1512               $endPos - $startPos - 7
1513             );
1514
1515             $_baseURL = $userFrameworkBaseURL . "sites/$siteName/";
1516           }
1517         }
1518       }
1519     }
1520     return $_baseURL;
1521   }
1522
1523   /**
1524    * Given a URL, return a relative URL if possible.
1525    *
1526    * @param string $url
1527    * @return string
1528    */
1529   public static function relativeURL($url) {
1530     // check if url is relative, if so return immediately
1531     if (substr($url, 0, 4) != 'http') {
1532       return $url;
1533     }
1534
1535     // make everything relative from the baseFilePath
1536     $baseURL = self::baseCMSURL();
1537
1538     // check if baseURL is a substr of $url, if so
1539     // return rest of string
1540     if (substr($url, 0, strlen($baseURL)) == $baseURL) {
1541       return substr($url, strlen($baseURL));
1542     }
1543
1544     // return the original value
1545     return $url;
1546   }
1547
1548   /**
1549    * Produce an absolute URL from a possibly-relative URL.
1550    *
1551    * @param string $url
1552    * @param bool $removeLanguagePart
1553    *
1554    * @return string
1555    */
1556   public static function absoluteURL($url, $removeLanguagePart = FALSE) {
1557     // check if url is already absolute, if so return immediately
1558     if (substr($url, 0, 4) == 'http') {
1559       return $url;
1560     }
1561
1562     // make everything absolute from the baseFileURL
1563     $baseURL = self::baseCMSURL();
1564
1565     //CRM-7622: drop the language from the URL if requested (and it’s there)
1566     $config = CRM_Core_Config::singleton();
1567     if ($removeLanguagePart) {
1568       $baseURL = self::languageNegotiationURL($baseURL, FALSE, TRUE);
1569     }
1570
1571     return $baseURL . $url;
1572   }
1573
1574   /**
1575    * Clean url, replaces first '&' with '?'
1576    *
1577    * @param string $url
1578    *
1579    * @return string
1580    *   , clean url
1581    */
1582   public static function cleanUrl($url) {
1583     if (!$url) {
1584       return NULL;
1585     }
1586
1587     if ($pos = strpos($url, '&')) {
1588       $url = substr_replace($url, '?', $pos, 1);
1589     }
1590
1591     return $url;
1592   }
1593
1594   /**
1595    * Format the url as per language Negotiation.
1596    *
1597    * @param string $url
1598    *
1599    * @param bool $addLanguagePart
1600    * @param bool $removeLanguagePart
1601    *
1602    * @return string
1603    *   , formatted url.
1604    */
1605   public static function languageNegotiationURL(
1606     $url,
1607     $addLanguagePart = TRUE,
1608     $removeLanguagePart = FALSE
1609   ) {
1610     $config = &CRM_Core_Config::singleton();
1611     return $config->userSystem->languageNegotiationURL($url, $addLanguagePart, $removeLanguagePart);
1612   }
1613
1614   /**
1615    * Append the contents of an 'extra' smarty template file if it is present in
1616    * the custom template directory. This does not work if there are
1617    * multiple custom template directories
1618    *
1619    * @param string $fileName
1620    *   The name of the tpl file that we are processing.
1621    * @param string $content
1622    *   The current content string. May be modified by this function.
1623    * @param string $overideFileName
1624    *   (optional) Sent by contribution/event reg/profile pages which uses a id
1625    *   specific extra file name if present.
1626    */
1627   public static function appendTPLFile(
1628     $fileName,
1629     &$content,
1630     $overideFileName = NULL
1631   ) {
1632     $template = CRM_Core_Smarty::singleton();
1633     if ($overideFileName) {
1634       $additionalTPLFile = $overideFileName;
1635     }
1636     else {
1637       $additionalTPLFile = str_replace('.tpl', '.extra.tpl', $fileName);
1638     }
1639
1640     if ($template->template_exists($additionalTPLFile)) {
1641       $content .= $template->fetch($additionalTPLFile);
1642     }
1643   }
1644
1645   /**
1646    * Get a list of all files that are found within the directories
1647    * that are the result of appending the provided relative path to
1648    * each component of the PHP include path.
1649    *
1650    * @author Ken Zalewski
1651    *
1652    * @param string $relpath
1653    *   A relative path, typically pointing to a directory with multiple class
1654    *   files.
1655    *
1656    * @return array
1657    *   An array of files that exist in one or more of the directories that are
1658    *   referenced by the relative path when appended to each element of the PHP
1659    *   include path.
1660    */
1661   public static function listIncludeFiles($relpath) {
1662     $file_list = array();
1663     $inc_dirs = explode(PATH_SEPARATOR, get_include_path());
1664     foreach ($inc_dirs as $inc_dir) {
1665       $target_dir = $inc_dir . DIRECTORY_SEPARATOR . $relpath;
1666       if (is_dir($target_dir)) {
1667         $cur_list = scandir($target_dir);
1668         foreach ($cur_list as $fname) {
1669           if ($fname != '.' && $fname != '..') {
1670             $file_list[$fname] = $fname;
1671           }
1672         }
1673       }
1674     }
1675     return $file_list;
1676   }
1677   // listIncludeFiles()
1678
1679   /**
1680    * Get a list of all "plugins" (PHP classes that implement a piece of
1681    * functionality using a well-defined interface) that are found in a
1682    * particular CiviCRM directory (both custom and core are searched).
1683    *
1684    * @author Ken Zalewski
1685    *
1686    * @param string $relpath
1687    *   A relative path referencing a directory that contains one or more
1688    *   plugins.
1689    * @param string $fext
1690    *   (optional) Only files with this extension will be considered to be
1691    *   plugins.
1692    * @param array $skipList
1693    *   (optional) List of files to skip.
1694    *
1695    * @return array
1696    *   List of plugins, where the plugin name is both the key and the value of
1697    *   each element.
1698    */
1699   public static function getPluginList($relpath, $fext = '.php', $skipList = array()) {
1700     $fext_len = strlen($fext);
1701     $plugins = array();
1702     $inc_files = CRM_Utils_System::listIncludeFiles($relpath);
1703     foreach ($inc_files as $inc_file) {
1704       if (substr($inc_file, 0 - $fext_len) == $fext) {
1705         $plugin_name = substr($inc_file, 0, 0 - $fext_len);
1706         if (!in_array($plugin_name, $skipList)) {
1707           $plugins[$plugin_name] = $plugin_name;
1708         }
1709       }
1710     }
1711     return $plugins;
1712   }
1713   // getPluginList()
1714
1715   /**
1716    */
1717   public static function executeScheduledJobs() {
1718     $facility = new CRM_Core_JobManager();
1719     $facility->execute(FALSE);
1720
1721     $redirectUrl = self::url('civicrm/admin/job', 'reset=1');
1722
1723     CRM_Core_Session::setStatus(
1724       ts('Scheduled jobs have been executed according to individual timing settings. Please check log for messages.'),
1725       ts('Complete'), 'success');
1726
1727     CRM_Utils_System::redirect($redirectUrl);
1728   }
1729
1730   /**
1731    * Evaluate any tokens in a URL.
1732    *
1733    * @param string|FALSE $url
1734    * @return string|FALSE
1735    */
1736   public static function evalUrl($url) {
1737     if ($url === FALSE) {
1738       return FALSE;
1739     }
1740     else {
1741       $config = CRM_Core_Config::singleton();
1742       $vars = array(
1743         '{ver}' => CRM_Utils_System::version(),
1744         '{uf}' => $config->userFramework,
1745         '{php}' => phpversion(),
1746         '{sid}' => md5('sid_' . (defined('CIVICRM_SITE_KEY') ? CIVICRM_SITE_KEY : '') . '_' . $config->userFrameworkBaseURL),
1747         '{baseUrl}' => $config->userFrameworkBaseURL,
1748         '{lang}' => $config->lcMessages,
1749         '{co}' => $config->defaultContactCountry,
1750       );
1751       foreach (array_keys($vars) as $k) {
1752         $vars[$k] = urlencode($vars[$k]);
1753       }
1754       return strtr($url, $vars);
1755     }
1756   }
1757
1758
1759   /**
1760    * Determine whether this is a developmental system.
1761    *
1762    * @return bool
1763    */
1764   public static function isDevelopment() {
1765     static $cache = NULL;
1766     if ($cache === NULL) {
1767       global $civicrm_root;
1768       $cache = file_exists("{$civicrm_root}/.svn") || file_exists("{$civicrm_root}/.git");
1769     }
1770     return $cache;
1771   }
1772
1773   /**
1774    * @return bool
1775    */
1776   public static function isInUpgradeMode() {
1777     $args = explode('/', $_GET['q']);
1778     $upgradeInProcess = CRM_Core_Session::singleton()->get('isUpgradePending');
1779     if ((isset($args[1]) && $args[1] == 'upgrade') || $upgradeInProcess) {
1780       return TRUE;
1781     }
1782     else {
1783       return FALSE;
1784     }
1785   }
1786
1787   /**
1788    * Determine the standard URL for viewing or editing the specified link.
1789    *
1790    * This function delegates the decision-making to (a) the hook system and
1791    * (b) the BAO system.
1792    *
1793    * @param array $crudLinkSpec
1794    *   With keys:.
1795    *   - action: int, CRM_Core_Action::UPDATE or CRM_Core_Action::VIEW [default: VIEW]
1796    *   - entity_table: string, eg "civicrm_contact"
1797    *   - entity_id: int
1798    * @return array|NULL
1799    *   NULL if unavailable, or an array. array has keys:
1800    *   - path: string
1801    *   - query: array
1802    *   - title: string
1803    *   - url: string
1804    */
1805   public static function createDefaultCrudLink($crudLinkSpec) {
1806     $crudLinkSpec['action'] = CRM_Utils_Array::value('action', $crudLinkSpec, CRM_Core_Action::VIEW);
1807     $daoClass = CRM_Core_DAO_AllCoreTables::getClassForTable($crudLinkSpec['entity_table']);
1808     if (!$daoClass) {
1809       return NULL;
1810     }
1811
1812     $baoClass = str_replace('_DAO_', '_BAO_', $daoClass);
1813     if (!class_exists($baoClass)) {
1814       return NULL;
1815     }
1816
1817     $bao = new $baoClass();
1818     $bao->id = $crudLinkSpec['entity_id'];
1819     if (!$bao->find(TRUE)) {
1820       return NULL;
1821     }
1822
1823     $link = array();
1824     CRM_Utils_Hook::crudLink($crudLinkSpec, $bao, $link);
1825     if (empty($link) && is_callable(array($bao, 'createDefaultCrudLink'))) {
1826       $link = $bao->createDefaultCrudLink($crudLinkSpec);
1827     }
1828
1829     if (!empty($link)) {
1830       if (!isset($link['url'])) {
1831         $link['url'] = self::url($link['path'], $link['query'], TRUE, NULL, FALSE);
1832       }
1833       return $link;
1834     }
1835
1836     return NULL;
1837   }
1838
1839 }