bootstrap.inc 37.8 KB
Newer Older
1
<?php
2 3 4 5
/**
 * @file
 * Functions that need to be loaded on every Drupal request.
 */
Dries's avatar
 
Dries committed
6

7
use Drupal\Component\Datetime\DateTimePlus;
8
use Drupal\Component\Utility\Crypt;
9
use Drupal\Component\Utility\Environment;
10
use Drupal\Component\Utility\SafeMarkup;
11
use Drupal\Component\Utility\String;
12
use Drupal\Component\Utility\Unicode;
13
use Drupal\Core\DrupalKernel;
14
use Drupal\Core\Extension\ExtensionDiscovery;
15
use Drupal\Core\Logger\RfcLogLevel;
16
use Drupal\Core\Site\Settings;
17
use Drupal\Core\Utility\Error;
18
use Symfony\Component\ClassLoader\ApcClassLoader;
19
use Symfony\Component\HttpFoundation\Request;
20
use Symfony\Component\HttpFoundation\Response;
21
use Drupal\Core\Language\LanguageInterface;
22

23 24
/**
 * Minimum supported version of PHP.
25
 */
26
const DRUPAL_MINIMUM_PHP = '5.4.5';
27 28 29

/**
 * Minimum recommended value of PHP memory_limit.
30 31 32
 *
 * @todo Reduce the memory required to install on some environments in
 *   https://www.drupal.org/node/2289201 and then decrease this limit.
33
 */
34
const DRUPAL_MINIMUM_PHP_MEMORY_LIMIT = '64M';
35

36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55
/**
 * Error reporting level: display no errors.
 */
const ERROR_REPORTING_HIDE = 'hide';

/**
 * Error reporting level: display errors and warnings.
 */
const ERROR_REPORTING_DISPLAY_SOME = 'some';

/**
 * Error reporting level: display all messages.
 */
const ERROR_REPORTING_DISPLAY_ALL = 'all';

/**
 * Error reporting level: display all messages, plus backtrace information.
 */
const ERROR_REPORTING_DISPLAY_VERBOSE = 'verbose';

56 57 58
/**
 * Role ID for anonymous users; should match what's in the "role" table.
 */
59
const DRUPAL_ANONYMOUS_RID = 'anonymous';
60 61 62 63

/**
 * Role ID for authenticated users; should match what's in the "role" table.
 */
64
const DRUPAL_AUTHENTICATED_RID = 'authenticated';
65

66 67 68 69 70
/**
 * The maximum number of characters in a module or theme name.
 */
const DRUPAL_EXTENSION_NAME_MAX_LENGTH = 50;

71
/**
72
 * Time of the current request in seconds elapsed since the Unix Epoch.
73
 *
74 75 76 77 78 79
 * This differs from $_SERVER['REQUEST_TIME'], which is stored as a float
 * since PHP 5.4.0. Float timestamps confuse most PHP functions
 * (including date_create()).
 *
 * @see http://php.net/manual/reserved.variables.server.php
 * @see http://php.net/manual/function.time.php
80
 */
81
define('REQUEST_TIME', (int) $_SERVER['REQUEST_TIME']);
82

83 84 85
/**
 * Regular expression to match PHP function names.
 *
86
 * @see http://php.net/manual/language.functions.php
87
 */
88
const DRUPAL_PHP_FUNCTION_PATTERN = '[a-zA-Z_\x7f-\xff][a-zA-Z0-9_\x7f-\xff]*';
89

90 91 92
/**
 * $config_directories key for active directory.
 *
93
 * @see config_get_config_directory()
94 95 96 97 98 99
 */
const CONFIG_ACTIVE_DIRECTORY = 'active';

/**
 * $config_directories key for staging directory.
 *
100
 * @see config_get_config_directory()
101 102 103
 */
const CONFIG_STAGING_DIRECTORY = 'staging';

104 105 106 107 108 109 110
/**
 * Defines the root directory of the Drupal installation.
 *
 * This strips two levels of directories off the current directory.
 */
define('DRUPAL_ROOT', dirname(dirname(__DIR__)));

Dries's avatar
 
Dries committed
111
/**
112
 * Returns the appropriate configuration directory.
Dries's avatar
 
Dries committed
113
 *
114
 * @param bool $require_settings
115 116 117 118
 *   Only configuration directories with an existing settings.php file
 *   will be recognized. Defaults to TRUE. During initial installation,
 *   this is set to FALSE so that Drupal can detect a matching directory,
 *   then create a new settings.php file in it.
119
 * @param bool $reset
120
 *   Force a full search for matching directories even if one had been
121
 *   found previously. Defaults to FALSE.
122 123 124
 * @param \Symfony\Component\HttpFoundation\Request $request
 *   (optional) The current request. Defaults to \Drupal::request() or a new
 *   request created from globals.
125
 *
126 127
 * @return string
 *   The path of the matching directory.@see default.settings.php
128
 *
129 130 131 132 133 134 135 136 137 138 139 140 141 142
 * @deprecated in Drupal 8.x-dev, will be removed before Drupal 8.0.
 *   Use \Drupal\Core\DrupalKernel::getSitePath() instead. If the kernel is
 *   unavailable or the site path needs to be recalculated then
 *   Drupal\Core\DrupalKernel::findSitePath() can be used.
 */
function conf_path($require_settings = TRUE, $reset = FALSE, Request $request = NULL) {
  if (!isset($request)) {
    if (\Drupal::hasRequest()) {
      $request = \Drupal::request();
    }
    // @todo Remove once external CLI scripts (Drush) are updated.
    else {
      $request = Request::createFromGlobals();
    }
143
  }
144 145
  if (\Drupal::hasService('kernel')) {
    $site_path = \Drupal::service('kernel')->getSitePath();
146
  }
147 148
  if (!isset($site_path) || empty($site_path)) {
    $site_path = DrupalKernel::findSitePath($request, $require_settings);
Dries's avatar
 
Dries committed
149
  }
150
  return $site_path;
Dries's avatar
 
Dries committed
151
}
152
/**
153 154 155 156 157
 * Returns the path of a configuration directory.
 *
 * @param string $type
 *   (optional) The type of config directory to return. Drupal core provides
 *   'active' and 'staging'. Defaults to CONFIG_ACTIVE_DIRECTORY.
158 159 160 161
 *
 * @return string
 *   The configuration directory path.
 */
162 163
function config_get_config_directory($type = CONFIG_ACTIVE_DIRECTORY) {
  global $config_directories;
164

165
  if (!empty($config_directories[$type])) {
166
    return $config_directories[$type];
167
  }
168
  throw new \Exception(format_string('The configuration directory type %type does not exist.', array('%type' => $type)));
169 170
}

Dries's avatar
Dries committed
171
/**
172 173 174 175
 * Returns and optionally sets the filename for a system resource.
 *
 * The filename, whether provided, cached, or retrieved from the database, is
 * only returned if the file exists.
Dries's avatar
Dries committed
176
 *
Dries's avatar
Dries committed
177 178
 * This function plays a key role in allowing Drupal's resources (modules
 * and themes) to be located in different places depending on a site's
179
 * configuration. For example, a module 'foo' may legally be located
Dries's avatar
Dries committed
180 181
 * in any of these three places:
 *
182 183 184
 * core/modules/foo/foo.info.yml
 * modules/foo/foo.info.yml
 * sites/example.com/modules/foo/foo.info.yml
Dries's avatar
Dries committed
185 186 187 188
 *
 * Calling drupal_get_filename('module', 'foo') will give you one of
 * the above, depending on where the module is located.
 *
Dries's avatar
Dries committed
189
 * @param $type
190 191
 *   The type of the item; one of 'core', 'profile', 'module', 'theme', or
 *   'theme_engine'.
Dries's avatar
Dries committed
192
 * @param $name
193 194
 *   The name of the item for which the filename is requested. Ignored for
 *   $type 'core'.
Dries's avatar
Dries committed
195 196 197 198 199
 * @param $filename
 *   The filename of the item if it is to be set explicitly rather
 *   than by consulting the database.
 *
 * @return
200
 *   The filename of the requested item or NULL if the item is not found.
Dries's avatar
Dries committed
201
 */
Dries's avatar
Dries committed
202
function drupal_get_filename($type, $name, $filename = NULL) {
203 204
  // The location of files will not change during the request, so do not use
  // drupal_static().
205
  static $files = array();
Dries's avatar
Dries committed
206

207 208 209 210 211 212 213 214
  // Type 'core' only exists to simplify application-level logic; it always maps
  // to the /core directory, whereas $name is ignored. It is only requested via
  // drupal_get_path(). /core/core.info.yml does not exist, but is required
  // since drupal_get_path() returns the dirname() of the returned pathname.
  if ($type === 'core') {
    return 'core/core.info.yml';
  }

215 216 217
  // Profiles are converted into modules in system_rebuild_module_data().
  // @todo Remove false-exposure of profiles as modules.
  $original_type = $type;
218
  if ($type == 'profile') {
219
    $type = 'module';
220
  }
221
  if (!isset($files[$type])) {
Dries's avatar
Dries committed
222 223 224
    $files[$type] = array();
  }

225
  if (isset($filename)) {
Dries's avatar
Dries committed
226 227
    $files[$type][$name] = $filename;
  }
228 229 230 231 232 233
  elseif (!isset($files[$type][$name])) {
    // If the pathname of the requested extension is not known, try to retrieve
    // the list of extension pathnames from various providers, checking faster
    // providers first.
    // Retrieve the current module list (derived from the service container).
    if ($type == 'module' && \Drupal::hasService('module_handler')) {
234 235 236
      foreach (\Drupal::moduleHandler()->getModuleList() as $module_name => $module) {
        $files[$type][$module_name] = $module->getPathname();
      }
237 238 239 240 241
    }
    // If still unknown, retrieve the file list prepared in state by
    // system_rebuild_module_data() and system_rebuild_theme_data().
    if (!isset($files[$type][$name]) && \Drupal::hasService('state')) {
      $files[$type] += \Drupal::state()->get('system.' . $type . '.files', array());
242
    }
243
    // If still unknown, perform a filesystem scan.
244
    if (!isset($files[$type][$name])) {
245
      $listing = new ExtensionDiscovery(DRUPAL_ROOT);
246 247 248
      // Prevent an infinite recursion by this legacy function.
      if ($original_type == 'profile') {
        $listing->setProfileDirectories(array());
249
      }
250
      foreach ($listing->scan($original_type) as $extension_name => $file) {
251
        $files[$type][$extension_name] = $file->getPathname();
Dries's avatar
Dries committed
252 253 254 255
      }
    }
  }

256 257 258
  if (isset($files[$type][$name])) {
    return $files[$type][$name];
  }
Dries's avatar
Dries committed
259 260
}

261 262 263 264 265 266 267 268 269 270 271 272 273 274 275 276 277
/**
 * Returns the path to a system item (module, theme, etc.).
 *
 * @param $type
 *   The type of the item; one of 'core', 'profile', 'module', 'theme', or
 *   'theme_engine'.
 * @param $name
 *   The name of the item for which the path is requested. Ignored for
 *   $type 'core'.
 *
 * @return
 *   The path to the requested item or an empty string if the item is not found.
 */
function drupal_get_path($type, $name) {
  return dirname(drupal_get_filename($type, $name));
}

278
/**
279
 * Sets an HTTP response header for the current page.
280 281 282 283 284
 *
 * Note: When sending a Content-Type header, always include a 'charset' type,
 * too. This is necessary to avoid security bugs (e.g. UTF-7 XSS).
 *
 * @param $name
285
 *   The HTTP header name, or the special 'Status' header name.
286
 * @param $value
287 288 289
 *   The HTTP header value; if equal to FALSE, the specified header is unset.
 *   If $name is 'Status', this is expected to be a status code followed by a
 *   reason phrase, e.g. "404 Not Found".
290 291
 * @param $append
 *   Whether to append the value to an existing header or to replace it.
292
 *
293 294 295
 * @deprecated in Drupal 8.x-dev, will be removed before Drupal 8.0.
 *   Use \Symfony\Component\HttpFoundation\Response->headers->set().
 *   See https://drupal.org/node/2181523.
296
 */
297
function _drupal_add_http_header($name, $value, $append = FALSE) {
298
  // The headers as name/value pairs.
299
  $headers = &drupal_static('drupal_http_headers', array());
300

301
  $name_lower = strtolower($name);
302
  _drupal_set_preferred_header_name($name);
303

304
  if ($value === FALSE) {
305
    $headers[$name_lower] = FALSE;
306
  }
307
  elseif (isset($headers[$name_lower]) && $append) {
308 309
    // Multiple headers with identical names may be combined using comma (RFC
    // 2616, section 4.2).
310
    $headers[$name_lower] .= ',' . $value;
311 312
  }
  else {
313
    $headers[$name_lower] = $value;
314 315 316 317
  }
}

/**
318
 * Gets the HTTP response headers for the current page.
319 320 321 322
 *
 * @param $name
 *   An HTTP header name. If omitted, all headers are returned as name/value
 *   pairs. If an array value is FALSE, the header has been unset.
323
 *
324 325 326
 * @return
 *   A string containing the header value, or FALSE if the header has been set,
 *   or NULL if the header has not been set.
327
 *
328 329 330
 * @deprecated in Drupal 8.x-dev, will be removed before Drupal 8.0.
 *   Use \Symfony\Component\HttpFoundation\Response->headers->get().
 *   See https://drupal.org/node/2181523.
331
 */
332
function drupal_get_http_header($name = NULL) {
333
  $headers = &drupal_static('drupal_http_headers', array());
334 335 336 337 338 339 340 341 342 343
  if (isset($name)) {
    $name = strtolower($name);
    return isset($headers[$name]) ? $headers[$name] : NULL;
  }
  else {
    return $headers;
  }
}

/**
344 345
 * Sets the preferred name for the HTTP header.
 *
346
 * Header names are case-insensitive, but for maximum compatibility they should
347 348
 * follow "common form" (see RFC 2616, section 4.2).
 *
349 350
 * @deprecated in Drupal 8.x-dev, will be removed before Drupal 8.0.
 *   See https://drupal.org/node/2181523.
351 352 353 354 355 356 357 358 359 360
 */
function _drupal_set_preferred_header_name($name = NULL) {
  static $header_names = array();

  if (!isset($name)) {
    return $header_names;
  }
  $header_names[strtolower($name)] = $name;
}

361
/**
362
 * Translates a string to the current language or to a given language.
363
 *
364 365 366
 * The t() function serves two purposes. First, at run-time it translates
 * user-visible text into the appropriate language. Second, various mechanisms
 * that figure out what text needs to be translated work off t() -- the text
367 368 369 370 371
 * inside t() calls is added to the database of strings to be translated.
 * These strings are expected to be in English, so the first argument should
 * always be in English. To enable a fully-translatable site, it is important
 * that all human-readable text that will be displayed on the site or sent to
 * a user is passed through the t() function, or a related function. See the
372 373 374 375
 * @link http://drupal.org/node/322729 Localization API @endlink pages for
 * more information, including recommendations on how to break up or not
 * break up strings for translation.
 *
376
 * @section sec_translating_vars Translating Variables
377 378 379 380 381 382 383 384 385
 * You should never use t() to translate variables, such as calling
 * @code t($text); @endcode, unless the text that the variable holds has been
 * passed through t() elsewhere (e.g., $text is one of several translated
 * literal strings in an array). It is especially important never to call
 * @code t($user_text); @endcode, where $user_text is some text that a user
 * entered - doing that can lead to cross-site scripting and other security
 * problems. However, you can use variable substitution in your string, to put
 * variable text such as user names or link URLs into translated text. Variable
 * substitution looks like this:
386
 * @code
387
 * $text = t("@name's blog", array('@name' => user_format_name($account)));
388
 * @endcode
389
 * Basically, you can put variables like @name into your string, and t() will
390 391
 * substitute their sanitized values at translation time. (See the
 * Localization API pages referenced above and the documentation of
392 393 394
 * format_string() for details about how to define variables in your string.)
 * Translators can then rearrange the string as necessary for the language
 * (e.g., in Spanish, it might be "blog de @name").
395 396 397 398
 *
 * @param $string
 *   A string containing the English string to translate.
 * @param $args
399 400 401
 *   An associative array of replacements to make after translation. Based
 *   on the first character of the key, the value is escaped and/or themed.
 *   See format_string() for details.
402
 * @param $options
403 404 405 406 407
 *   An associative array of additional options, with the following elements:
 *   - 'langcode' (defaults to the current language): The language code to
 *     translate to a language other than what is used to display the page.
 *   - 'context' (defaults to the empty context): The context the source string
 *     belongs to.
408
 *
409 410
 * @return
 *   The translated string.
411
 *
412
 * @see format_string()
413
 * @ingroup sanitization
414 415
 */
function t($string, array $args = array(), array $options = array()) {
416
  return \Drupal::translation()->translate($string, $args, $options);
417 418 419
}

/**
420 421
 * Formats a string for HTML display by replacing variable placeholders.
 *
422
 * @see \Drupal\Component\Utility\String::format()
423 424 425 426
 * @see t()
 * @ingroup sanitization
 */
function format_string($string, array $args = array()) {
427
  return String::format($string, $args);
428 429
}

Gábor Hojtsy's avatar
Gábor Hojtsy committed
430 431 432 433 434 435 436 437 438 439 440 441 442 443 444
/**
 * Checks whether a string is valid UTF-8.
 *
 * All functions designed to filter input should use drupal_validate_utf8
 * to ensure they operate on valid UTF-8 strings to prevent bypass of the
 * filter.
 *
 * When text containing an invalid UTF-8 lead byte (0xC0 - 0xFF) is presented
 * as UTF-8 to Internet Explorer 6, the program may misinterpret subsequent
 * bytes. When these subsequent bytes are HTML control characters such as
 * quotes or angle brackets, parts of the text that were deemed safe by filters
 * end up in locations that are potentially unsafe; An onerror attribute that
 * is outside of a tag, and thus deemed safe by a filter, can be interpreted
 * by the browser as if it were inside the tag.
 *
445 446
 * The function does not return FALSE for strings containing character codes
 * above U+10FFFF, even though these are prohibited by RFC 3629.
Gábor Hojtsy's avatar
Gábor Hojtsy committed
447 448 449
 *
 * @param $text
 *   The text to check.
450
 *
Gábor Hojtsy's avatar
Gábor Hojtsy committed
451 452
 * @return
 *   TRUE if the text is valid UTF-8, FALSE if not.
453 454
 *
 * @see \Drupal\Component\Utility\Unicode::validateUtf8()
Gábor Hojtsy's avatar
Gábor Hojtsy committed
455 456
 */
function drupal_validate_utf8($text) {
457
  return Unicode::validateUtf8($text);
Dries's avatar
Dries committed
458 459
}

460
/**
461
 * Logs an exception.
462
 *
463
 * This is a wrapper logging function which automatically decodes an exception.
464 465 466 467 468 469 470
 *
 * @param $type
 *   The category to which this message belongs.
 * @param $exception
 *   The exception that is going to be logged.
 * @param $message
 *   The message to store in the log. If empty, a text that contains all useful
471
 *   information about the passed-in exception is used.
472
 * @param $variables
473 474 475
 *   Array of variables to replace in the message on display or
 *   NULL if message is already translated or not possible to
 *   translate.
476 477 478 479 480
 * @param $severity
 *   The severity of the message, as per RFC 3164.
 * @param $link
 *   A link to associate with the message.
 *
481
 * @see \Drupal\Core\Utility\Error::decodeException()
482
 */
483
function watchdog_exception($type, Exception $exception, $message = NULL, $variables = array(), $severity = RfcLogLevel::ERROR, $link = NULL) {
484

485 486 487 488 489 490 491 492 493 494 495 496 497 498 499
  // Use a default value if $message is not set.
  if (empty($message)) {
    // The exception message is run through
    // \Drupal\Component\Utility\String::checkPlain() by
    // \Drupal\Core\Utility\Error:decodeException().
    $message = '%type: !message in %function (line %line of %file).';
  }

  if ($link) {
    $variables['link'] = $link;
  }

  $variables += Error::decodeException($exception);

  \Drupal::logger($type)->log($severity, $message, $variables);
500 501
}

Dries's avatar
 
Dries committed
502
/**
503
 * Sets a message to display to the user.
Dries's avatar
 
Dries committed
504
 *
505 506
 * Messages are stored in a session variable and displayed in the page template
 * via the $messages theme variable.
Dries's avatar
 
Dries committed
507
 *
508 509 510 511 512 513 514 515 516 517 518 519
 * Example usage:
 * @code
 * drupal_set_message(t('An error occurred and processing did not complete.'), 'error');
 * @endcode
 *
 * @param string $message
 *   (optional) The translated message to be displayed to the user. For
 *   consistency with other messages, it should begin with a capital letter and
 *   end with a period.
 * @param string $type
 *   (optional) The message's type. Defaults to 'status'. These values are
 *   supported:
520
 *   - 'status'
521
 *   - 'warning'
522
 *   - 'error'
523 524
 * @param bool $repeat
 *   (optional) If this is FALSE and the message is already set, then the
525
 *   message won't be repeated. Defaults to FALSE.
526 527 528
 *
 * @return array|null
 *   A multidimensional array with keys corresponding to the set message types.
529 530 531 532 533 534 535 536 537 538 539 540 541 542 543 544 545 546 547 548 549
 *   The indexed array values of each contain the set messages for that type,
 *   and each message is an associative array with the following format:
 *   - safe: Boolean indicating whether the message string has been marked as
 *     safe. Non-safe strings will be escaped automatically.
 *   - message: The message string.
 *   So, the following is an example of the full return array structure:
 *   @code
 *     array(
 *       'status' => array(
 *         array(
 *           'safe' => TRUE,
 *           'message' => 'A <em>safe</em> markup string.',
 *         ),
 *         array(
 *           'safe' => FALSE,
 *           'message' => "$arbitrary_user_input to escape.",
 *         ),
 *       ),
 *     );
 *   @endcode
 *   If there are no messages set, the function returns NULL.
550 551
 *
 * @see drupal_get_messages()
552
 * @see status-messages.html.twig
Dries's avatar
 
Dries committed
553
 */
554
function drupal_set_message($message = NULL, $type = 'status', $repeat = FALSE) {
555
  if (isset($message)) {
Dries's avatar
 
Dries committed
556 557 558 559
    if (!isset($_SESSION['messages'][$type])) {
      $_SESSION['messages'][$type] = array();
    }

560 561 562 563 564 565
    $new = array(
      'safe' => SafeMarkup::isSafe($message),
      'message' => $message,
    );
    if ($repeat || !in_array($new, $_SESSION['messages'][$type])) {
      $_SESSION['messages'][$type][] = $new;
566
    }
567

568
    // Mark this page as being uncacheable.
569
    \Drupal::service('page_cache_kill_switch')->trigger();
570 571
  }

572
  // Messages not set when DB connection fails.
573
  return isset($_SESSION['messages']) ? $_SESSION['messages'] : NULL;
574 575
}

Dries's avatar
 
Dries committed
576
/**
577
 * Returns all messages that have been set with drupal_set_message().
Dries's avatar
 
Dries committed
578
 *
579 580 581 582 583 584 585 586 587 588 589
 * @param string $type
 *   (optional) Limit the messages returned by type. Defaults to NULL, meaning
 *   all types. These values are supported:
 *   - NULL
 *   - 'status'
 *   - 'warning'
 *   - 'error'
 * @param bool $clear_queue
 *   (optional) If this is TRUE, the queue will be cleared of messages of the
 *   type specified in the $type parameter. Otherwise the queue will be left
 *   intact. Defaults to TRUE.
590
 *
591
 * @return array
592 593 594 595
 *   An associative, nested array of messages grouped by message type, with
 *   the top-level keys as the message type. The messages returned are
 *   limited to the type specified in the $type parameter, if any. If there
 *   are no messages of the specified type, an empty array is returned. See
596
 *   drupal_set_message() for the array structure of individual messages.
597 598
 *
 * @see drupal_set_message()
599
 * @see status-messages.html.twig
Dries's avatar
 
Dries committed
600
 */
601
function drupal_get_messages($type = NULL, $clear_queue = TRUE) {
602
  if ($messages = drupal_set_message()) {
603 604 605 606 607 608 609 610
    foreach ($messages as $message_type => $message_typed_messages) {
      foreach ($message_typed_messages as $key => $message) {
        if ($message['safe']) {
          $message['message'] = SafeMarkup::set($message['message']);
        }
        $messages[$message_type][$key] = $message['message'];
      }
    }
611
    if ($type) {
612
      if ($clear_queue) {
613
        unset($_SESSION['messages'][$type]);
614
      }
615 616 617
      if (isset($messages[$type])) {
        return array($type => $messages[$type]);
      }
618 619
    }
    else {
620
      if ($clear_queue) {
621
        unset($_SESSION['messages']);
622
      }
623 624
      return $messages;
    }
625
  }
626
  return array();
627 628
}

629
/**
630
 * Returns the time zone of the current user.
631 632
 */
function drupal_get_user_timezone() {
633
  $user = \Drupal::currentUser();
634
  $config = \Drupal::config('system.date');
635

636
  if ($user && $config->get('timezone.user.configurable') && $user->isAuthenticated() && $user->getTimezone()) {
637
    return $user->getTimezone();
638 639
  }
  else {
640 641
    // Ignore PHP strict notice if time zone has not yet been set in the php.ini
    // configuration.
642
    $config_data_default_timezone = $config->get('timezone.default');
643
    return !empty($config_data_default_timezone) ? $config_data_default_timezone : @date_default_timezone_get();
644 645 646
  }
}

647
/**
648
 * Provides custom PHP error handling.
649 650 651 652 653 654 655 656 657 658
 *
 * @param $error_level
 *   The level of the error raised.
 * @param $message
 *   The error message.
 * @param $filename
 *   The filename that the error was raised in.
 * @param $line
 *   The line number the error was raised at.
 * @param $context
659 660
 *   An array that points to the active symbol table at the point the error
 *   occurred.
661 662
 */
function _drupal_error_handler($error_level, $message, $filename, $line, $context) {
663
  require_once __DIR__ . '/errors.inc';
664 665 666 667
  _drupal_error_handler_real($error_level, $message, $filename, $line, $context);
}

/**
668
 * Provides custom PHP exception handling.
669 670 671 672 673 674 675 676 677
 *
 * Uncaught exceptions are those not enclosed in a try/catch block. They are
 * always fatal: the execution of the script will stop as soon as the exception
 * handler exits.
 *
 * @param $exception
 *   The exception object that was thrown.
 */
function _drupal_exception_handler($exception) {
678
  require_once __DIR__ . '/errors.inc';
679 680 681

  try {
    // Log the message to the watchdog and return an error page to the user.
682
    _drupal_log_error(Error::decodeException($exception), TRUE);
683 684 685 686
  }
  catch (Exception $exception2) {
    // Another uncaught exception was thrown while handling the first one.
    // If we are displaying errors, then do so with no possibility of a further uncaught exception being thrown.
687 688
    if (error_displayable()) {
      print '<h1>Additional uncaught exception thrown while handling exception.</h1>';
689 690
      print '<h2>Original</h2><p>' . Error::renderExceptionSafe($exception) . '</p>';
      print '<h2>Additional</h2><p>' . Error::renderExceptionSafe($exception2) . '</p><hr />';
691 692
    }
  }
693 694
}

695
/**
696
 * Returns the test prefix if this is an internal request from SimpleTest.
697
 *
698
 * @param string $new_prefix
699
 *   Internal use only. A new prefix to be stored.
700
 *
701
 * @return string|FALSE
702 703 704
 *   Either the simpletest prefix (the string "simpletest" followed by any
 *   number of digits) or FALSE if the user agent does not contain a valid
 *   HMAC and timestamp.
705
 */
706
function drupal_valid_test_ua($new_prefix = NULL) {
707 708
  static $test_prefix;

709 710 711
  if (isset($new_prefix)) {
    $test_prefix = $new_prefix;
  }
712 713 714
  if (isset($test_prefix)) {
    return $test_prefix;
  }
715 716 717
  // Unless the below User-Agent and HMAC validation succeeds, we are not in
  // a test environment.
  $test_prefix = FALSE;
718

719 720
  // Perform a basic check on the User-Agent HTTP request header first. Any
  // inbound request that uses the simpletest UA header needs to be validated.
721 722 723
  if (isset($_SERVER['HTTP_USER_AGENT']) && preg_match("/^(simpletest\d+);(.+);(.+);(.+)$/", $_SERVER['HTTP_USER_AGENT'], $matches)) {
    list(, $prefix, $time, $salt, $hmac) = $matches;
    $check_string =  $prefix . ';' . $time . ';' . $salt;
724 725 726 727 728 729 730 731 732 733 734 735 736
    // Read the hash salt prepared by drupal_generate_test_ua().
    // This function is called before settings.php is read and Drupal's error
    // handlers are set up. While Drupal's error handling may be properly
    // configured on production sites, the server's PHP error_reporting may not.
    // Ensure that no information leaks on production sites.
    $key_file = DRUPAL_ROOT . '/sites/simpletest/' . substr($prefix, 10) . '/.htkey';
    if (!is_readable($key_file)) {
      header($_SERVER['SERVER_PROTOCOL'] . ' 403 Forbidden');
      exit;
    }
    $private_key = file_get_contents($key_file);
    // The file properties add more entropy not easily accessible to others.
    $key = $private_key . filectime(__FILE__) . fileinode(__FILE__);
737
    $time_diff = REQUEST_TIME - $time;
738
    $test_hmac = Crypt::hmacBase64($check_string, $key);
739 740
    // Since we are making a local request a 5 second time window is allowed,
    // and the HMAC must match.
741
    if ($time_diff >= 0 && $time_diff <= 5 && $hmac === $test_hmac) {
742 743 744
      $test_prefix = $prefix;
    }
  }
745
  return $test_prefix;
746 747 748
}

/**
749
 * Generates a user agent string with a HMAC and timestamp for simpletest.
750 751
 */
function drupal_generate_test_ua($prefix) {
752 753 754 755 756 757 758 759 760 761 762 763 764 765 766 767 768 769 770 771
  static $key, $last_prefix;

  if (!isset($key) || $last_prefix != $prefix) {
    $last_prefix = $prefix;
    $key_file = DRUPAL_ROOT . '/sites/simpletest/' . substr($prefix, 10) . '/.htkey';
    // When issuing an outbound HTTP client request from within an inbound test
    // request, then the outbound request has to use the same User-Agent header
    // as the inbound request. A newly generated private key for the same test
    // prefix would invalidate all subsequent inbound requests.
    // @see \Drupal\Core\Http\Plugin\SimpletestHttpRequestSubscriber
    if (DRUPAL_TEST_IN_CHILD_SITE && $parent_prefix = drupal_valid_test_ua()) {
      if ($parent_prefix != $prefix) {
        throw new \RuntimeException("Malformed User-Agent: Expected '$parent_prefix' but got '$prefix'.");
      }
      // If the file is not readable, a PHP warning is expected in this case.
      $private_key = file_get_contents($key_file);
    }
    else {
      // Generate and save a new hash salt for a test run.
      // Consumed by drupal_valid_test_ua() before settings.php is loaded.
772
      $private_key = Crypt::randomBytesBase64(55);
773 774 775 776
      file_put_contents($key_file, $private_key);
    }
    // The file properties add more entropy not easily accessible to others.
    $key = $private_key . filectime(__FILE__) . fileinode(__FILE__);
777
  }
778 779 780
  // Generate a moderately secure HMAC based on the database credentials.
  $salt = uniqid('', TRUE);
  $check_string = $prefix . ';' . time() . ';' . $salt;
781
  return $check_string . ';' . Crypt::hmacBase64($check_string, $key);
782 783
}

784
/**
785 786 787
 * Enables use of the theme system without requiring database access.
 *
 * Loads and initializes the theme system for site installs, updates and when
788
 * the site is in maintenance mode. This also applies when the database fails.
789 790
 *
 * @see _drupal_maintenance_theme()
791 792
 */
function drupal_maintenance_theme() {
793
  require_once __DIR__ . '/theme.maintenance.inc';
794
  _drupal_maintenance_theme();
795
}
796

797
/**
798
 * Returns TRUE if a Drupal installation is currently being attempted.
799 800
 */
function drupal_installation_attempted() {
801 802 803 804 805 806
  // This cannot rely on the MAINTENANCE_MODE constant, since that would prevent
  // tests from using the non-interactive installer, in which case Drupal
  // only happens to be installed within the same request, but subsequently
  // executed code does not involve the installer at all.
  // @see install_drupal()
  return isset($GLOBALS['install_state']) && empty($GLOBALS['install_state']['installation_finished']);
807 808
}

809 810 811 812 813 814 815 816 817 818 819 820 821 822 823 824 825 826 827 828 829 830 831 832 833 834 835 836 837 838 839 840 841
/**
 * Gets the name of the currently active installation profile.
 *
 * When this function is called during Drupal's initial installation process,
 * the name of the profile that's about to be installed is stored in the global
 * installation state. At all other times, the "install_profile" setting will be
 * available in settings.php.
 *
 * @return string|null $profile
 *   The name of the installation profile or NULL if no installation profile is
 *   currently active. This is the case for example during the first steps of
 *   the installer or during unit tests.
 */
function drupal_get_profile() {
  global $install_state;

  if (drupal_installation_attempted()) {
    // If the profile has been selected return it.
    if (isset($install_state['parameters']['profile'])) {
      $profile = $install_state['parameters']['profile'];
    }
    else {
      $profile = NULL;
    }
  }
  else {
    // Fall back to NULL, if there is no 'install_profile' setting.
    $profile = Settings::get('install_profile');
  }

  return $profile;
}

842 843 844 845 846 847 848 849 850
/**
 * Registers an additional namespace.
 *
 * @param string $name
 *   The namespace component to register; e.g., 'node'.
 * @param string $path
 *   The relative path to the Drupal component in the filesystem.
 */
function drupal_classloader_register($name, $path) {
851
  $loader = \Drupal::service('class_loader');
852
  $loader->addPsr4('Drupal\\' . $name . '\\', \Drupal::root() . '/' . $path . '/src');
853 854
}

855
/**
856
 * Provides central static variable storage.
857
 *
858 859 860 861 862 863 864 865 866
 * All functions requiring a static variable to persist or cache data within
 * a single page request are encouraged to use this function unless it is
 * absolutely certain that the static variable will not need to be reset during
 * the page request. By centralizing static variable storage through this
 * function, other functions can rely on a consistent API for resetting any
 * other function's static variables.
 *
 * Example:
 * @code
867 868 869
 * function example_list($field = 'default') {
 *   $examples = &drupal_static(__FUNCTION__);
 *   if (!isset($examples)) {
870 871
 *     // If this function is being called for the first time after a reset,
 *     // query the database and execute any other code needed to retrieve
872
 *     // information.
873 874
 *     ...
 *   }
875
 *   if (!isset($examples[$field])) {
876 877
 *     // If this function is being called for the first time for a particular
 *     // index field, then execute code needed to index the information already
878
 *     // available in $examples by the desired field.
879 880 881 882 883
 *     ...
 *   }
 *   // Subsequent invocations of this function for a particular index field
 *   // skip the above two code blocks and quickly return the already indexed
 *   // information.
884
 *   return $examples[$field];
885
 * }
886 887 888 889
 * function examples_admin_overview() {
 *   // When building the content for the overview page, make sure to get
 *   // completely fresh information.
 *   drupal_static_reset('example_list');
890 891 892 893 894 895 896 897 898 899 900 901 902 903
 *   ...
 * }
 * @endcode
 *
 * In a few cases, a function can have certainty that there is no legitimate
 * use-case for resetting that function's static variable. This is rare,
 * because when writing a function, it's hard to forecast all the situations in
 * which it will be used. A guideline is that if a function's static variable
 * does not depend on any information outside of the function that might change
 * during a single page request, then it's ok to use the "static" keyword
 * instead of the drupal_static() function.
 *
 * Example:
 * @code
904 905 906 907
 * function mymodule_log_stream_handle($new_handle = NULL) {
 *   static $handle;
 *   if (isset($new_handle)) {
 *     $handle = $new_handle;
908
 *   }
909
 *   return $handle;
910 911 912 913 914 915 916
 * }
 * @endcode
 *
 * In a few cases, a function needs a resettable static variable, but the
 * function is called many times (100+) during a single page request, so
 * every microsecond of execution time that can be removed from the function
 * counts. These functions can use a more cumbersome, but faster variant of
917 918 919 920 921 922 923 924 925 926 927 928 929
 * calling drupal_static(). It works by storing the reference returned by
 * drupal_static() in the calling function's own static variable, thereby
 * removing the need to call drupal_static() for each iteration of the function.
 * Conceptually, it replaces:
 * @code
 * $foo = &drupal_static(__FUNCTION__);
 * @endcode
 * with:
 * @code
 * // Unfortunately, this does not work.
 * static $foo = &drupal_static(__FUNCTION__);
 * @endcode
 * However, the above line of code does not work, because PHP only allows static
930
 * variables to be initialized by literal values, and does not allow static
931
 * variables to be assigned to references.
932 933
 * - http://php.net/manual/language.variables.scope.php#language.variables.scope.static
 * - http://php.net/manual/language.variables.scope.php#language.variables.scope.references