bootstrap.inc 37.7 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\Html;
11
use Drupal\Component\Utility\SafeMarkup;
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\Render\SafeString;
17
use Drupal\Core\Session\AccountInterface;
18
use Drupal\Core\Site\Settings;
19
use Drupal\Core\Utility\Error;
20
use Symfony\Component\ClassLoader\ApcClassLoader;
21
use Symfony\Component\HttpFoundation\Request;
22
use Symfony\Component\HttpFoundation\Response;
23
use Drupal\Core\Language\LanguageInterface;
24

25
26
/**
 * Minimum supported version of PHP.
27
 */
28
const DRUPAL_MINIMUM_PHP = '5.5.9';
29
30
31

/**
 * Minimum recommended value of PHP memory_limit.
32
 *
33
34
35
 * 64M was chosen as a minimum requirement in order to allow for additional
 * contributed modules to be installed prior to hitting the limit. However,
 * 40M is the target for the Standard installation profile.
36
 */
37
const DRUPAL_MINIMUM_PHP_MEMORY_LIMIT = '64M';
38

39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
/**
 * 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';

59
60
/**
 * Role ID for anonymous users; should match what's in the "role" table.
61
62
63
64
 *
 * @deprecated in Drupal 8.0.0, will be removed before Drupal 9.0.0.
 *   Use Drupal\Core\Session\AccountInterface::ANONYMOUS_ROLE or
 *   \Drupal\user\RoleInterface::ANONYMOUS_ID instead.
65
 */
66
const DRUPAL_ANONYMOUS_RID = AccountInterface::ANONYMOUS_ROLE;
67
68
69

/**
 * Role ID for authenticated users; should match what's in the "role" table.
70
71
72
73
 *
 * @deprecated in Drupal 8.0.0, will be removed before Drupal 9.0.0.
 *   Use Drupal\Core\Session\AccountInterface::AUTHENTICATED_ROLE or
 *   \Drupal\user\RoleInterface::AUTHENTICATED_ID instead.
74
 */
75
const DRUPAL_AUTHENTICATED_RID = AccountInterface::AUTHENTICATED_ROLE;
76

77
78
79
80
81
/**
 * The maximum number of characters in a module or theme name.
 */
const DRUPAL_EXTENSION_NAME_MAX_LENGTH = 50;

82
/**
83
 * Time of the current request in seconds elapsed since the Unix Epoch.
84
 *
85
86
87
88
89
90
 * 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
91
 */
92
define('REQUEST_TIME', (int) $_SERVER['REQUEST_TIME']);
93

94
95
96
/**
 * Regular expression to match PHP function names.
 *
97
 * @see http://php.net/manual/language.functions.php
98
 */
99
const DRUPAL_PHP_FUNCTION_PATTERN = '[a-zA-Z_\x7f-\xff][a-zA-Z0-9_\x7f-\xff]*';
100

101
102
103
/**
 * $config_directories key for active directory.
 *
104
 * @see config_get_config_directory()
105
106
107
 *
 * @deprecated in Drupal 8.0.x and will be removed before 9.0.0. Drupal core no
 *   longer creates an active directory.
108
109
110
111
112
113
 */
const CONFIG_ACTIVE_DIRECTORY = 'active';

/**
 * $config_directories key for staging directory.
 *
114
 * @see config_get_config_directory()
115
116
117
 */
const CONFIG_STAGING_DIRECTORY = 'staging';

118
119
120
121
122
123
124
/**
 * 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
125
/**
126
 * Returns the appropriate configuration directory.
Dries's avatar
   
Dries committed
127
 *
128
 * @param bool $require_settings
129
130
131
132
 *   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.
133
 * @param bool $reset
134
 *   Force a full search for matching directories even if one had been
135
 *   found previously. Defaults to FALSE.
136
137
138
 * @param \Symfony\Component\HttpFoundation\Request $request
 *   (optional) The current request. Defaults to \Drupal::request() or a new
 *   request created from globals.
139
 *
140
141
 * @return string
 *   The path of the matching directory.@see default.settings.php
142
 *
143
144
145
146
147
148
149
150
151
152
153
154
155
156
 * @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();
    }
157
  }
158
159
  if (\Drupal::hasService('kernel')) {
    $site_path = \Drupal::service('kernel')->getSitePath();
160
  }
161
162
  if (!isset($site_path) || empty($site_path)) {
    $site_path = DrupalKernel::findSitePath($request, $require_settings);
Dries's avatar
 
Dries committed
163
  }
164
  return $site_path;
Dries's avatar
 
Dries committed
165
}
166
/**
167
168
 * Returns the path of a configuration directory.
 *
169
170
171
 * Configuration directories are configured using $config_directories in
 * settings.php.
 *
172
 * @param string $type
173
174
 *   The type of config directory to return. Drupal core provides the
 *   CONFIG_STAGING_DIRECTORY constant to access the staging directory.
175
176
177
 *
 * @return string
 *   The configuration directory path.
178
179
 *
 * @throws \Exception
180
 */
181
function config_get_config_directory($type) {
182
  global $config_directories;
183

184
  if (!empty($config_directories[$type])) {
185
    return $config_directories[$type];
186
  }
187
  throw new \Exception("The configuration directory type '$type' does not exist");
188
189
}

Dries's avatar
Dries committed
190
/**
191
192
193
194
 * 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
195
 *
Dries's avatar
Dries committed
196
197
 * 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
198
 * configuration. For example, a module 'foo' may legally be located
Dries's avatar
Dries committed
199
200
 * in any of these three places:
 *
201
202
203
 * core/modules/foo/foo.info.yml
 * modules/foo/foo.info.yml
 * sites/example.com/modules/foo/foo.info.yml
Dries's avatar
Dries committed
204
205
206
207
 *
 * 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
208
 * @param $type
209
210
 *   The type of the item; one of 'core', 'profile', 'module', 'theme', or
 *   'theme_engine'.
Dries's avatar
Dries committed
211
 * @param $name
212
213
 *   The name of the item for which the filename is requested. Ignored for
 *   $type 'core'.
Dries's avatar
Dries committed
214
215
216
217
218
 * @param $filename
 *   The filename of the item if it is to be set explicitly rather
 *   than by consulting the database.
 *
 * @return
219
 *   The filename of the requested item or NULL if the item is not found.
Dries's avatar
Dries committed
220
 */
Dries's avatar
Dries committed
221
function drupal_get_filename($type, $name, $filename = NULL) {
222
223
  // The location of files will not change during the request, so do not use
  // drupal_static().
224
  static $files = array();
Dries's avatar
Dries committed
225

226
227
228
229
230
231
232
233
  // 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';
  }

234
235
236
  // Profiles are converted into modules in system_rebuild_module_data().
  // @todo Remove false-exposure of profiles as modules.
  $original_type = $type;
237
  if ($type == 'profile') {
238
    $type = 'module';
239
  }
240
  if (!isset($files[$type])) {
Dries's avatar
Dries committed
241
242
243
    $files[$type] = array();
  }

244
  if (isset($filename)) {
Dries's avatar
Dries committed
245
246
    $files[$type][$name] = $filename;
  }
247
248
249
250
251
252
  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')) {
253
254
255
      foreach (\Drupal::moduleHandler()->getModuleList() as $module_name => $module) {
        $files[$type][$module_name] = $module->getPathname();
      }
256
257
    }
    // If still unknown, retrieve the file list prepared in state by
258
259
    // system_rebuild_module_data() and
    // \Drupal\Core\Extension\ThemeHandlerInterface::rebuildThemeData().
260
261
    if (!isset($files[$type][$name]) && \Drupal::hasService('state')) {
      $files[$type] += \Drupal::state()->get('system.' . $type . '.files', array());
262
    }
263
    // If still unknown, create a user-level error message.
264
    if (!isset($files[$type][$name])) {
265
      trigger_error(SafeMarkup::format('The following @type is missing from the file system: @name', array('@type' => $type, '@name' => $name)), E_USER_WARNING);
Dries's avatar
Dries committed
266
267
268
    }
  }

269
270
271
  if (isset($files[$type][$name])) {
    return $files[$type][$name];
  }
Dries's avatar
Dries committed
272
273
}

274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
/**
 * 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));
}

291
/**
292
 * Translates a string to the current language or to a given language.
293
 *
294
295
296
 * 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
297
298
299
300
301
 * 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
302
 * @link https://www.drupal.org/node/322729 Localization API @endlink pages for
303
304
305
 * more information, including recommendations on how to break up or not
 * break up strings for translation.
 *
306
 * @section sec_translating_vars Translating Variables
307
308
309
310
311
312
313
314
315
 * You should never use t() to translate variables, such as calling t($text)
 * 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 t($user_text) 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:
316
 * @code
317
 * $text = t("@name's blog", array('@name' => $account->getDisplayName()));
318
 * @endcode
319
 * Basically, you can put variables like @name into your string, and t() will
320
321
 * substitute their sanitized values at translation time. (See the
 * Localization API pages referenced above and the documentation of
322
323
324
325
 * \Drupal\Component\Utility\SafeMarkup::format() 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").
326
327
328
329
 *
 * @param $string
 *   A string containing the English string to translate.
 * @param $args
330
331
 *   An associative array of replacements to make after translation. Based
 *   on the first character of the key, the value is escaped and/or themed.
332
 *   See \Drupal\Component\Utility\SafeMarkup::format() for details.
333
 * @param $options
334
335
336
337
338
 *   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.
339
 *
340
341
 * @return
 *   The translated string.
342
 *
343
 * @see \Drupal\Component\Utility\SafeMarkup::format()
344
 * @ingroup sanitization
345
346
 */
function t($string, array $args = array(), array $options = array()) {
347
  return \Drupal::translation()->translate($string, $args, $options);
348
349
350
}

/**
351
352
 * Formats a string for HTML display by replacing variable placeholders.
 *
353
 * @see \Drupal\Component\Utility\SafeMarkup::format()
354
355
 * @see t()
 * @ingroup sanitization
356
357
358
 *
 * @deprecated in Drupal 8.0.0, will be removed before Drupal 9.0.0.
 *   Use \Drupal\Component\Utility\SafeMarkup::format().
359
 */
360
function format_string($string, array $args) {
361
  return SafeMarkup::format($string, $args);
362
363
}

Gábor Hojtsy's avatar
Gábor Hojtsy committed
364
365
366
367
368
369
370
371
372
373
374
375
376
377
378
/**
 * 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.
 *
379
380
 * 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
381
382
383
 *
 * @param $text
 *   The text to check.
384
 *
Gábor Hojtsy's avatar
Gábor Hojtsy committed
385
386
 * @return
 *   TRUE if the text is valid UTF-8, FALSE if not.
387
388
 *
 * @see \Drupal\Component\Utility\Unicode::validateUtf8()
389
390
391
 *
 * @deprecated in Drupal 8.0.0, will be removed before Drupal 9.0.0.
 *   Use \Drupal\Component\Utility\Unicode::validateUtf8().
Gábor Hojtsy's avatar
Gábor Hojtsy committed
392
393
 */
function drupal_validate_utf8($text) {
394
  return Unicode::validateUtf8($text);
Dries's avatar
Dries committed
395
396
}

397
/**
398
 * Logs an exception.
399
 *
400
 * This is a wrapper logging function which automatically decodes an exception.
401
402
403
404
405
406
407
 *
 * @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
408
 *   information about the passed-in exception is used.
409
 * @param $variables
410
411
412
 *   Array of variables to replace in the message on display or
 *   NULL if message is already translated or not possible to
 *   translate.
413
414
415
416
417
 * @param $severity
 *   The severity of the message, as per RFC 3164.
 * @param $link
 *   A link to associate with the message.
 *
418
 * @see \Drupal\Core\Utility\Error::decodeException()
419
 */
420
function watchdog_exception($type, Exception $exception, $message = NULL, $variables = array(), $severity = RfcLogLevel::ERROR, $link = NULL) {
421

422
423
  // Use a default value if $message is not set.
  if (empty($message)) {
424
    $message = '%type: @message in %function (line %line of %file).';
425
426
427
428
429
430
431
432
433
  }

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

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

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

Dries's avatar
   
Dries committed
436
/**
437
 * Sets a message to display to the user.
Dries's avatar
   
Dries committed
438
 *
439
440
 * Messages are stored in a session variable and displayed in the page template
 * via the $messages theme variable.
Dries's avatar
   
Dries committed
441
 *
442
443
444
445
446
 * Example usage:
 * @code
 * drupal_set_message(t('An error occurred and processing did not complete.'), 'error');
 * @endcode
 *
447
 * @param string|\Drupal\Component\Utility\SafeStringInterface $message
448
449
450
451
452
453
 *   (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:
454
 *   - 'status'
455
 *   - 'warning'
456
 *   - 'error'
457
458
 * @param bool $repeat
 *   (optional) If this is FALSE and the message is already set, then the
459
 *   message won't be repeated. Defaults to FALSE.
460
461
462
 *
 * @return array|null
 *   A multidimensional array with keys corresponding to the set message types.
463
464
465
466
467
468
469
470
471
472
473
474
475
476
477
478
479
480
481
482
483
 *   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.
484
485
 *
 * @see drupal_get_messages()
486
 * @see status-messages.html.twig
Dries's avatar
   
Dries committed
487
 */
488
function drupal_set_message($message = NULL, $type = 'status', $repeat = FALSE) {
489
  if (isset($message)) {
Dries's avatar
   
Dries committed
490
491
492
493
    if (!isset($_SESSION['messages'][$type])) {
      $_SESSION['messages'][$type] = array();
    }

494
495
496
    // Convert strings which are safe to the simplest SafeString objects.
    if (!($message instanceof SafeString) && SafeMarkup::isSafe($message)) {
      $message = SafeString::create((string) $message);
497
498
499
500
501
502
    }

    // Do not use strict type checking so that equivalent string and
    // SafeStringInterface objects are detected.
    if ($repeat || !in_array($message, $_SESSION['messages'][$type])) {
      $_SESSION['messages'][$type][] = $message;
503
    }
504

505
    // Mark this page as being uncacheable.
506
    \Drupal::service('page_cache_kill_switch')->trigger();
507
508
  }

509
  // Messages not set when DB connection fails.
510
  return isset($_SESSION['messages']) ? $_SESSION['messages'] : NULL;
511
512
}

Dries's avatar
   
Dries committed
513
/**
514
 * Returns all messages that have been set with drupal_set_message().
Dries's avatar
   
Dries committed
515
 *
516
517
518
519
520
521
522
523
524
525
526
 * @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.
527
 *
528
 * @return array
529
530
531
532
 *   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
533
 *   drupal_set_message() for the array structure of individual messages.
534
535
 *
 * @see drupal_set_message()
536
 * @see status-messages.html.twig
Dries's avatar
   
Dries committed
537
 */
538
function drupal_get_messages($type = NULL, $clear_queue = TRUE) {
539
  if ($messages = drupal_set_message()) {
540
    if ($type) {
541
      if ($clear_queue) {
542
        unset($_SESSION['messages'][$type]);
543
      }
544
545
546
      if (isset($messages[$type])) {
        return array($type => $messages[$type]);
      }
547
548
    }
    else {
549
      if ($clear_queue) {
550
        unset($_SESSION['messages']);
551
      }
552
553
      return $messages;
    }
554
  }
555
  return array();
556
557
}

558
/**
559
 * Returns the time zone of the current user.
560
561
 */
function drupal_get_user_timezone() {
562
  $user = \Drupal::currentUser();
563
  $config = \Drupal::config('system.date');
564

565
  if ($user && $config->get('timezone.user.configurable') && $user->isAuthenticated() && $user->getTimezone()) {
566
    return $user->getTimezone();
567
568
  }
  else {
569
570
    // Ignore PHP strict notice if time zone has not yet been set in the php.ini
    // configuration.
571
    $config_data_default_timezone = $config->get('timezone.default');
572
    return !empty($config_data_default_timezone) ? $config_data_default_timezone : @date_default_timezone_get();
573
574
575
  }
}

576
/**
577
 * Provides custom PHP error handling.
578
579
580
581
582
583
584
585
586
587
 *
 * @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
588
589
 *   An array that points to the active symbol table at the point the error
 *   occurred.
590
591
 */
function _drupal_error_handler($error_level, $message, $filename, $line, $context) {
592
  require_once __DIR__ . '/errors.inc';
593
594
595
596
  _drupal_error_handler_real($error_level, $message, $filename, $line, $context);
}

/**
597
 * Provides custom PHP exception handling.
598
599
600
601
602
 *
 * 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.
 *
603
 * @param \Exception|\Throwable $exception
604
605
606
 *   The exception object that was thrown.
 */
function _drupal_exception_handler($exception) {
607
  require_once __DIR__ . '/errors.inc';
608
609
610

  try {
    // Log the message to the watchdog and return an error page to the user.
611
    _drupal_log_error(Error::decodeException($exception), TRUE);
612
  }
613
614
615
616
  // PHP 7 introduces Throwable, which covers both Error and
  // Exception throwables.
  catch (\Throwable $error) {
    _drupal_exception_handler_additional($exception, $error);
617
618
  }
  // In order to be compatibile with PHP 5 we also catch regular Exceptions.
619
  catch (\Exception $exception2) {
620
621
622
623
624
625
626
    _drupal_exception_handler_additional($exception, $exception2);
  }
}

/**
 * Displays any additional errors caught while handling an exception.
 *
627
 * @param \Exception|\Throwable $exception
628
 *   The first exception object that was thrown.
629
 * @param \Exception|\Throwable $exception2
630
631
632
633
634
635
636
637
638
639
 *   The second exception object that was thrown.
 */
function _drupal_exception_handler_additional($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.
  if (error_displayable()) {
    print '<h1>Additional uncaught exception thrown while handling exception.</h1>';
    print '<h2>Original</h2><p>' . Error::renderExceptionSafe($exception) . '</p>';
    print '<h2>Additional</h2><p>' . Error::renderExceptionSafe($exception2) . '</p><hr />';
640
  }
641
642
}

643
/**
644
 * Returns the test prefix if this is an internal request from SimpleTest.
645
 *
646
 * @param string $new_prefix
647
 *   Internal use only. A new prefix to be stored.
648
 *
649
 * @return string|FALSE
650
651
652
 *   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.
653
 */
654
function drupal_valid_test_ua($new_prefix = NULL) {
655
656
  static $test_prefix;

657
658
659
  if (isset($new_prefix)) {
    $test_prefix = $new_prefix;
  }
660
661
662
  if (isset($test_prefix)) {
    return $test_prefix;
  }
663
664
665
  // Unless the below User-Agent and HMAC validation succeeds, we are not in
  // a test environment.
  $test_prefix = FALSE;
666

667
668
669
670
671
672
  // A valid Simpletest request will contain a hashed and salted authentication
  // code. Check if this code is present in a cookie or custom user agent
  // string.
  $http_user_agent = isset($_SERVER['HTTP_USER_AGENT']) ? $_SERVER['HTTP_USER_AGENT'] : NULL;
  $user_agent = isset($_COOKIE['SIMPLETEST_USER_AGENT']) ? $_COOKIE['SIMPLETEST_USER_AGENT'] : $http_user_agent;
  if (isset($user_agent) && preg_match("/^(simpletest\d+);(.+);(.+);(.+)$/", $user_agent, $matches)) {
673
674
    list(, $prefix, $time, $salt, $hmac) = $matches;
    $check_string =  $prefix . ';' . $time . ';' . $salt;
675
676
677
678
679
680
681
682
683
684
685
686
687
    // 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__);
688
    $time_diff = REQUEST_TIME - $time;
689
    $test_hmac = Crypt::hmacBase64($check_string, $key);
690
691
    // Since we are making a local request a 5 second time window is allowed,
    // and the HMAC must match.
692
    if ($time_diff >= 0 && $time_diff <= 5 && $hmac === $test_hmac) {
693
694
695
      $test_prefix = $prefix;
    }
  }
696
  return $test_prefix;
697
698
699
}

/**
700
 * Generates a user agent string with a HMAC and timestamp for simpletest.
701
702
 */
function drupal_generate_test_ua($prefix) {
703
704
705
706
707
708
709
710
711
712
713
714
715
716
717
718
719
720
721
722
  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.
723
      $private_key = Crypt::randomBytesBase64(55);
724
725
726
727
      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__);
728
  }
729
730
731
  // Generate a moderately secure HMAC based on the database credentials.
  $salt = uniqid('', TRUE);
  $check_string = $prefix . ';' . time() . ';' . $salt;
732
  return $check_string . ';' . Crypt::hmacBase64($check_string, $key);
733
734
}

735
/**
736
737
738
 * Enables use of the theme system without requiring database access.
 *
 * Loads and initializes the theme system for site installs, updates and when
739
 * the site is in maintenance mode. This also applies when the database fails.
740
741
 *
 * @see _drupal_maintenance_theme()
742
743
 */
function drupal_maintenance_theme() {
744
  require_once __DIR__ . '/theme.maintenance.inc';
745
  _drupal_maintenance_theme();
746
}
747

748
/**
749
 * Returns TRUE if a Drupal installation is currently being attempted.
750
751
 */
function drupal_installation_attempted() {
752
753
754
755
756
757
  // 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']);
758
759
}

760
761
762
763
764
765
766
767
768
769
770
771
772
773
774
775
776
777
778
779
780
781
782
783
784
785
786
787
788
789
790
791
792
/**
 * 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;
}

793
794
795
796
797
798
799
800
801
/**
 * 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) {
802
  $loader = \Drupal::service('class_loader');
803
  $loader->addPsr4('Drupal\\' . $name . '\\', \Drupal::root() . '/' . $path . '/src');
804
805
}

806
/**
807
 * Provides central static variable storage.
808
 *
809
810
811
812
813
814
815
816
817
 * 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
818
819
820
 * function example_list($field = 'default') {
 *   $examples = &drupal_static(__FUNCTION__);
 *   if (!isset($examples)) {
821
822
 *     // If this function is being called for the first time after a reset,
 *     // query the database and execute any other code needed to retrieve
823
 *     // information.
824
825
 *     ...
 *   }
826
 *   if (!isset($examples[$field])) {
827
828
 *     // If this function is being called for the first time for a particular
 *     // index field, then execute code needed to index the information already
829
 *     // available in $examples by the desired field.
830
831
832
833
834
 *     ...
 *   }
 *   // Subsequent invocations of this function for a particular index field
 *   // skip the above two code blocks and quickly return the already indexed
 *   // information.
835
 *   return $examples[$field];
836
 * }
837
838
839
840
 * function examples_admin_overview() {
 *   // When building the content for the overview page, make sure to get
 *   // completely fresh information.
 *   drupal_static_reset('example_list');
841
842
843
844
845
846
847
848
849
850
851
852
853
854
 *   ...
 * }
 * @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
855
856
857
858
 * function mymodule_log_stream_handle($new_handle = NULL) {
 *   static $handle;
 *   if (isset($new_handle)) {
 *     $handle = $new_handle;
859
 *   }
860
 *   return $handle;
861
862
863
864
865
866
867
 * }
 * @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
868
869
870
871
872
873
874
875
876
877
878
879
880
 * 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
881
 * variables to be initialized by literal values, and does not allow static
882
 * variables to be assigned to references.
883
884
 * - http://php.net/manual/language.variables.scope.php#language.variables.scope.static
 * - http://php.net/manual/language.variables.scope.php#language.variables.scope.references
885
 * The example below shows the syntax needed to work around both limitations.
886
 * For benchmarks and more information, see https://www.drupal.org/node/619666.
887
888
889
 *
 * Example:
 * @code
890
 * function example_default_format_type() {
891
 *   // Use the advanced drupal_static() pattern, since this is called very often.
892
893
 *   static $drupal_static_fast;
 *   if (!isset($drupal_static_fast)) {
894
 *     $drupal_static_fast['format_type'] = &drupal_static(__FUNCTION__);
895
 *   }
896
 *   $format_type = &$drupal_static_fast['format_type'];
897
898
899
900
 *   ...
 * }
 * @endcode
 *
901
902
903
 * @param $name
 *   Globally unique name for the variable. For a function with only one static,
 *   variable, the function name (e.g. via the PHP magic __FUNCTION__ constant)
904
 *   is recommended. For a function with multiple static variables add a
905
906
907
908
 *   distinguishing suffix to the function name for each one.
 * @param $default_value
 *   Optional default value.
 * @param $reset
909
910
911
 *   TRUE to reset one or all variables(s). This parameter is only used
 *   internally and should not be passed in; use drupal_static_reset() instead.
 *   (This function's return value should not be used when TRUE is passed in.)
912
913
 *
 * @return
914
 *   Returns a variable by reference.
915
916
 *
 * @see drupal_static_reset()
917
918
 */
function &drupal_static($name, $default_value = NULL, $reset = FALSE) {
919
  static $data = array(), $default = array();
920
921
922
923
924
  // First check if dealing with a previously defined static variable.
  if (isset($data[$name]) || array_key_exists($name, $data)) {
    // Non-NULL $name and both $data[$name] and $default[$name] statics exist.
    if ($reset) {
      // Reset pre-existing static variable to its default value.
925
      $data[$name] = $default[$name];
926
    }
927
928
929
930
931
    return $data[$name];
  }
  // Neither $data[$name] nor $default[$name] static variables exist.
  if (isset($name)) {
    if ($reset) {
932
933
934
      // Reset was called before a default is set and yet a variable must be
      // returned.
      return $data;
935
    }
936
    // First call with new non-NULL $name. Initialize a new static variable.
937
    $default[$name] = $data[$name] = $default_value;
938
939
940
941
942
943
944
    return $data[$name];
  }
  // Reset all: ($name == NULL). This needs to be done one at a time so that
  // references returned by earlier invocations of drupal_static() also get
  // reset.
  foreach ($default as $name => $value) {
    $data[$name] = $value;
945
  }
946
947
948
  // As the function returns a reference, the return should always be a
  // variable.
  return $data;
949
950
951
}

/**
952
 * Resets one or all centrally stored static variable(s).
953
954
955
 *
 * @param $name
 *   Name of the static variable to reset. Omit to reset all variables.
956
957
 *   Resetting all variables should only be used, for example, for running
 *   unit tests with a clean environment.
958
959
960
961
 */
function drupal_static_reset($name = NULL) {
  drupal_static($name, NULL, TRUE);
}
962

963
964
/**
 * Formats text for emphasized display in a placeholder inside a sentence.
965
 *
966
967
968
969
970
971
972
 * @deprecated in Drupal 8.0.0, will be removed before Drupal 9.0.0. Use
 *   \Drupal\Component\Utility\SafeMarkup::format() or Twig's "placeholder"
 *   filter instead. Note this method should not be used to simply emphasize a
 *   string and therefore has few valid use-cases. Note also, that this method
 *   does not mark the string as safe.
 *
 * @see \Drupal\Component\Utility\SafeMarkup::format()
973
 */
974
function drupal_placeholder($text) {
975
  return '<em class="placeholder">' . Html::escape($text) . '</em>';
976
}
977
978

/**
979
 * Registers a function for execution on shutdown.
980
 *
981
982
 * Wrapper for register_shutdown_function() that catches thrown exceptions to
 * avoid "Exception thrown without a stack frame in Unknown".
983
984
985
 *
 * @param $callback
 *   The shutdown function to register.
986
987
988
 * @param ...
 *   Additional arguments to pass to the shutdown function.
 *
989
990
991
992
 * @return
 *   Array of shutdown functions to be executed.
 *
 * @see register_shutdown_function()
993
 * @ingroup php_wrappers
994
 */
995
996
997
function &drupal_register_shutdown_function($callback = NULL) {
  // We cannot use drupal_static() here because the static cache is reset during
  // batch processing, which breaks batch handling.
998
999
1000
  static $callbacks = array();

  if (isset($callback)) {