Newer
Older
/**
* @file
* Functions that need to be loaded on every Drupal request.
*/
/**
* Indicates that the item should never be removed unless explicitly told to
* using cache_clear_all() with a cache ID.
*/
/**
* Indicates that the item should be removed at the next general cache wipe.
*/
/**
* Indicates that page caching is disabled.
*/
/**
* Indicates that page caching is enabled, using "normal" mode.
*/
define('CACHE_NORMAL', 1);
/**
* Indicates that page caching is using "aggressive" mode. This bypasses
* loading any modules for additional speed, which may break functionality in
* modules that expect to be run on each page load.
*/
define('CACHE_AGGRESSIVE', 2);
Dries Buytaert
committed
*
* Severity levels, as defined in RFC 3164 http://www.faqs.org/rfcs/rfc3164.html
Gábor Hojtsy
committed
* @see watchdog()
* @see watchdog_severity_levels()
Dries Buytaert
committed
define('WATCHDOG_EMERG', 0); // Emergency: system is unusable
define('WATCHDOG_ALERT', 1); // Alert: action must be taken immediately
define('WATCHDOG_CRITICAL', 2); // Critical: critical conditions
define('WATCHDOG_ERROR', 3); // Error: error conditions
define('WATCHDOG_WARNING', 4); // Warning: warning conditions
define('WATCHDOG_NOTICE', 5); // Notice: normal but significant condition
define('WATCHDOG_INFO', 6); // Informational: informational messages
define('WATCHDOG_DEBUG', 7); // Debug: debug-level messages
/**
* First bootstrap phase: initialize configuration.
*/
define('DRUPAL_BOOTSTRAP_CONFIGURATION', 0);
/**
* Second bootstrap phase: try to call a non-database cache
* fetch routine.
*/
define('DRUPAL_BOOTSTRAP_EARLY_PAGE_CACHE', 1);
/**
* Third bootstrap phase: initialize database layer.
*/
define('DRUPAL_BOOTSTRAP_DATABASE', 2);
/**
* Fourth bootstrap phase: identify and reject banned hosts.
*/
Dries Buytaert
committed
define('DRUPAL_BOOTSTRAP_ACCESS', 3);
/**
* Fifth bootstrap phase: initialize session handling.
*/
Dries Buytaert
committed
define('DRUPAL_BOOTSTRAP_SESSION', 4);
/**
* Sixth bootstrap phase: load bootstrap.inc and module.inc, start
* the variable system and try to serve a page from the cache.
*/
Dries Buytaert
committed
define('DRUPAL_BOOTSTRAP_LATE_PAGE_CACHE', 5);
* Seventh bootstrap phase: find out language of the page.
define('DRUPAL_BOOTSTRAP_LANGUAGE', 6);
/**
* Eighth bootstrap phase: set $_GET['q'] to Drupal path of request.
*/
define('DRUPAL_BOOTSTRAP_PATH', 7);
/**
* Final bootstrap phase: Drupal is fully loaded; validate and fix
* input data.
*/
define('DRUPAL_BOOTSTRAP_FULL', 8);
/**
* Role ID for anonymous users; should match what's in the "role" table.
*/
Dries Buytaert
committed
define('DRUPAL_ANONYMOUS_RID', 1);
/**
* Role ID for authenticated users; should match what's in the "role" table.
*/
Dries Buytaert
committed
define('DRUPAL_AUTHENTICATED_RID', 2);
/**
* No language negotiation. The default language is used.
*/
define('LANGUAGE_NEGOTIATION_NONE', 0);
/**
* Path based negotiation with fallback to default language
* if no defined path prefix identified.
*/
define('LANGUAGE_NEGOTIATION_PATH_DEFAULT', 1);
/**
* Path based negotiation with fallback to user preferences
* and browser language detection if no defined path prefix
* identified.
*/
define('LANGUAGE_NEGOTIATION_PATH', 2);
/**
* Domain based negotiation with fallback to default language
* if no language identified by domain.
*/
define('LANGUAGE_NEGOTIATION_DOMAIN', 3);
* Start the timer with the specified name. If you start and stop
* the same timer multiple times, the measured intervals will be
* accumulated.
*
* @param name
* The name of the timer.
*/
function timer_start($name) {
global $timers;
list($usec, $sec) = explode(' ', microtime());
$timers[$name]['start'] = (float)$usec + (float)$sec;
$timers[$name]['count'] = isset($timers[$name]['count']) ? ++$timers[$name]['count'] : 1;
}
/**
* Read the current timer value without stopping the timer.
*
* @param name
* The name of the timer.
* @return
* The current timer value in ms.
*/
function timer_read($name) {
global $timers;
if (isset($timers[$name]['start'])) {
list($usec, $sec) = explode(' ', microtime());
$stop = (float)$usec + (float)$sec;
$diff = round(($stop - $timers[$name]['start']) * 1000, 2);
if (isset($timers[$name]['time'])) {
$diff += $timers[$name]['time'];
}
return $diff;
}
/**
* Stop the timer with the specified name.
*
* @param name
* The name of the timer.
* @return
* A timer array. The array contains the number of times the
* timer has been started and stopped (count) and the accumulated
* timer value in ms (time).
*/
function timer_stop($name) {
global $timers;
Dries Buytaert
committed
$timers[$name]['time'] = timer_read($name);
* Find the appropriate configuration directory.
* Try finding a matching configuration directory by stripping the website's
* hostname from left to right and pathname from right to left. The first
* configuration file found will be used; the remaining will ignored. If no
* configuration file is found, return a default value '$confdir/default'.
Dries Buytaert
committed
* Example for a fictitious site installed at
* http://www.drupal.org:8080/mysite/test/ the 'settings.php' is searched in
* the following directories:
* 1. $confdir/8080.www.drupal.org.mysite.test
* 2. $confdir/www.drupal.org.mysite.test
* 3. $confdir/drupal.org.mysite.test
* 4. $confdir/org.mysite.test
* 5. $confdir/8080.www.drupal.org.mysite
* 6. $confdir/www.drupal.org.mysite
* 7. $confdir/drupal.org.mysite
* 8. $confdir/org.mysite
* 9. $confdir/8080.www.drupal.org
* 10. $confdir/www.drupal.org
* 11. $confdir/drupal.org
* 12. $confdir/org
* 13. $confdir/default
*
* @param $require_settings
* 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.
* @param reset
* Force a full search for matching directories even if one had been
* found previously.
* @return
* The path of the matching directory.
function conf_path($require_settings = TRUE, $reset = FALSE) {
if ($conf && !$reset) {
$uri = explode('/', $_SERVER['SCRIPT_NAME'] ? $_SERVER['SCRIPT_NAME'] : $_SERVER['SCRIPT_FILENAME']);
$server = explode('.', implode('.', array_reverse(explode(':', rtrim($_SERVER['HTTP_HOST'], '.')))));
for ($i = count($uri) - 1; $i > 0; $i--) {
for ($j = count($server); $j > 0; $j--) {
$dir = implode('.', array_slice($server, -$j)) . implode('.', array_slice($uri, 0, $i));
if (file_exists("$confdir/$dir/settings.php") || (!$require_settings && file_exists("$confdir/$dir"))) {
$conf = "$confdir/$dir";
return $conf;
}
$conf = "$confdir/default";
return $conf;
Gerhard Killesreiter
committed
/**
* Unsets all disallowed global variables. See $allowed for what's allowed.
*/
function drupal_unset_globals() {
if (ini_get('register_globals')) {
$allowed = array('_ENV' => 1, '_GET' => 1, '_POST' => 1, '_COOKIE' => 1, '_FILES' => 1, '_SERVER' => 1, '_REQUEST' => 1, 'GLOBALS' => 1);
foreach ($GLOBALS as $key => $value) {
Gerhard Killesreiter
committed
if (!isset($allowed[$key])) {
unset($GLOBALS[$key]);
}
}
}
}
Dries Buytaert
committed
* Loads the configuration and sets the base URL, cookie domain, and
* session name correctly.
*/
function conf_init() {
global $base_url, $base_path, $base_root;
// Export the following settings.php variables to the global namespace
Gábor Hojtsy
committed
global $db_url, $db_prefix, $cookie_domain, $conf, $installed_profile, $update_free_access;
Dries Buytaert
committed
if (file_exists('./'. conf_path() .'/settings.php')) {
include_once './'. conf_path() .'/settings.php';
}
Gábor Hojtsy
committed
// Ignore the placeholder url from default.settings.php.
if (isset($db_url) && $db_url == 'mysql://username:password@localhost/databasename') {
$db_url = '';
}
if (isset($base_url)) {
// Parse fixed base URL from settings.php.
$parts = parse_url($base_url);
Neil Drumm
committed
if (!isset($parts['path'])) {
$parts['path'] = '';
}
Dries Buytaert
committed
$base_path = $parts['path'] .'/';
// Build $base_root (everything until first slash after "scheme://").
$base_root = substr($base_url, 0, strlen($base_url) - strlen($parts['path']));
}
else {
// Create base URL
$base_root = (isset($_SERVER['HTTPS']) && $_SERVER['HTTPS'] == 'on') ? 'https' : 'http';
// As $_SERVER['HTTP_HOST'] is user input, ensure it only contains
// characters allowed in hostnames.
$base_url = $base_root .= '://'. preg_replace('/[^a-z0-9-:._]/i', '', $_SERVER['HTTP_HOST']);
// $_SERVER['SCRIPT_NAME'] can, in contrast to $_SERVER['PHP_SELF'], not
// be modified by a visitor.
if ($dir = trim(dirname($_SERVER['SCRIPT_NAME']), '\,/')) {
$base_path = "/$dir";
$base_url .= $base_path;
$base_path .= '/';
}
else {
$base_path = '/';
}
}
Dries Buytaert
committed
if ($cookie_domain) {
// If the user specifies the cookie domain, also use it for session name.
$session_name = $cookie_domain;
}
else {
Gábor Hojtsy
committed
// Otherwise use $base_url as session name, without the protocol
// to use the same session identifiers across http and https.
list( , $session_name) = explode('://', $base_url, 2);
// We escape the hostname because it can be modified by a visitor.
Dries Buytaert
committed
if (!empty($_SERVER['HTTP_HOST'])) {
$cookie_domain = check_plain($_SERVER['HTTP_HOST']);
Dries Buytaert
committed
}
}
Dries Buytaert
committed
// To prevent session cookies from being hijacked, a user can configure the
// SSL version of their website to only transfer session cookies via SSL by
// using PHP's session.cookie_secure setting. The browser will then use two
// separate session cookies for the HTTPS and HTTP versions of the site. So we
// must use different session identifiers for HTTPS and HTTP to prevent a
// cookie collision.
if (ini_get('session.cookie_secure')) {
$session_name .= 'SSL';
}
Dries Buytaert
committed
// Strip leading periods, www., and port numbers from cookie domain.
$cookie_domain = ltrim($cookie_domain, '.');
if (strpos($cookie_domain, 'www.') === 0) {
$cookie_domain = substr($cookie_domain, 4);
}
$cookie_domain = explode(':', $cookie_domain);
Gábor Hojtsy
committed
$cookie_domain = '.'. $cookie_domain[0];
Dries Buytaert
committed
// Per RFC 2109, cookie domains must contain at least one dot other than the
// first. For hosts such as 'localhost' or IP Addresses we don't set a cookie domain.
if (count(explode('.', $cookie_domain)) > 2 && !is_numeric(str_replace('.', '', $cookie_domain))) {
ini_set('session.cookie_domain', $cookie_domain);
}
session_name('SESS'. md5($session_name));
/**
* Returns and optionally sets the filename for a system item (module,
* theme, etc.). The filename, whether provided, cached, or retrieved
* from the database, is only returned if the file exists.
*
* 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
* configuration. For example, a module 'foo' may legally be be located
* in any of these three places:
*
* modules/foo/foo.module
* sites/all/modules/foo/foo.module
* sites/example.com/modules/foo/foo.module
*
* Calling drupal_get_filename('module', 'foo') will give you one of
* the above, depending on where the module is located.
*
* @param $type
* The type of the item (i.e. theme, theme_engine, module).
* @param $name
* The name of the item for which the filename is requested.
* @param $filename
* The filename of the item if it is to be set explicitly rather
* than by consulting the database.
*
* @return
* The filename of the requested item.
*/
function drupal_get_filename($type, $name, $filename = NULL) {
if (!isset($files[$type])) {
if (!empty($filename) && file_exists($filename)) {
elseif (isset($files[$type][$name])) {
// Verify that we have an active database connection, before querying
// the database. This is required because this function is called both
// before we have a database connection (i.e. during installation) and
// when a database connection fails.
elseif (db_is_active() && (($file = db_result(db_query("SELECT filename FROM {system} WHERE name = '%s' AND type = '%s'", $name, $type))) && file_exists($file))) {
$files[$type][$name] = $file;
}
else {
// Fallback to searching the filesystem if the database connection is
// not established or the requested file is not found.
$dir = (($type == 'theme_engine') ? 'themes/engines' : "${type}s");
foreach (array("$config/$dir/$file", "$config/$dir/$name/$file", "$dir/$file", "$dir/$name/$file") as $file) {
if (file_exists($file)) {
$files[$type][$name] = $file;
break;
}
}
}
Steven Wittens
committed
if (isset($files[$type][$name])) {
return $files[$type][$name];
}
/**
* Load the persistent variable table.
*
* The variable table is composed of values that have been saved in the table
* with variable_set() as well as those explicitly specified in the configuration
* file.
*/
// NOTE: caching the variables improves performance by 20% when serving cached pages.
if ($cached = cache_get('variables', 'cache')) {
Dries Buytaert
committed
$variables = $cached->data;
}
else {
$result = db_query('SELECT * FROM {variable}');
while ($variable = db_fetch_object($result)) {
$variables[$variable->name] = unserialize($variable->value);
Dries Buytaert
committed
cache_set('variables', $variables);
}
foreach ($conf as $name => $value) {
$variables[$name] = $value;
/**
* Return a persistent variable.
*
* @param $name
* The name of the variable to return.
* @param $default
* The default value to use if this variable has never been set.
* @return
* The value of the variable.
*/
function variable_get($name, $default) {
global $conf;
return isset($conf[$name]) ? $conf[$name] : $default;
}
/**
* Set a persistent variable.
*
* @param $name
* The name of the variable to set.
* @param $value
* The value to set. This can be any PHP data type; these functions take care
* of serialization as necessary.
*/
$serialized_value = serialize($value);
db_query("UPDATE {variable} SET value = '%s' WHERE name = '%s'", $serialized_value, $name);
if (!db_affected_rows()) {
@db_query("INSERT INTO {variable} (name, value) VALUES ('%s', '%s')", $name, $serialized_value);
}
cache_clear_all('variables', 'cache');
/**
* Unset a persistent variable.
*
* @param $name
* The name of the variable to undefine.
*/
function variable_del($name) {
global $conf;
db_query("DELETE FROM {variable} WHERE name = '%s'", $name);
cache_clear_all('variables', 'cache');
* Note: we do not serve cached pages when status messages are waiting (from
Gábor Hojtsy
committed
*
* @param $status_only
* When set to TRUE, retrieve the status of the page cache only
* (whether it was started in this request or not).
Gábor Hojtsy
committed
function page_get_cache($status_only = FALSE) {
static $status = FALSE;
global $user, $base_root;
Gábor Hojtsy
committed
if ($status_only) {
return $status;
}
Dries Buytaert
committed
Steven Wittens
committed
if (!$user->uid && $_SERVER['REQUEST_METHOD'] == 'GET' && count(drupal_set_message()) == 0) {
$cache = cache_get($base_root . request_uri(), 'cache_page');
Gábor Hojtsy
committed
$status = TRUE;
Gábor Hojtsy
committed
return $cache;
/**
* Call all init or exit hooks without including all modules.
*
* @param $hook
* The name of the bootstrap hook we wish to invoke.
*/
function bootstrap_invoke_all($hook) {
Dries Buytaert
committed
foreach (module_list(TRUE, TRUE) as $module) {
module_invoke($module, $hook);
Gábor Hojtsy
committed
}
* Includes a file with the provided type and name. This prevents
* including a theme, engine, module, etc., more than once.
*
* @param $type
* The type of item to load (i.e. theme, theme_engine, module).
* @param $name
* The name of the item to load.
*
* @return
* TRUE if the item is loaded or has already been loaded.
*/
function drupal_load($type, $name) {
static $files = array();
if (isset($files[$type][$name])) {
return TRUE;
}
$filename = drupal_get_filename($type, $name);
if ($filename) {
include_once "./$filename";
$files[$type][$name] = TRUE;
return TRUE;
}
return FALSE;
}
Dries Buytaert
committed
* Authenticated users are always given a 'no-cache' header, and will
* fetch a fresh page on every request. This prevents authenticated
* users seeing locally cached pages that show them as logged out.
*
Gábor Hojtsy
committed
* @see page_set_cache()
header("Expires: Sun, 19 Nov 1978 05:00:00 GMT");
Dries Buytaert
committed
header("Last-Modified: ". gmdate("D, d M Y H:i:s") ." GMT");
header("Cache-Control: store, no-cache, must-revalidate");
header("Cache-Control: post-check=0, pre-check=0", FALSE);
}
/**
* Set HTTP headers in preparation for a cached page response.
*
* The general approach here is that anonymous users can keep a local
* cache of the page, but must revalidate it on every request. Then,
* they are given a '304 Not Modified' response as long as they stay
* logged out and the page has not been modified.
*
*/
function drupal_page_cache_header($cache) {
// Set default values:
$last_modified = gmdate('D, d M Y H:i:s', $cache->created) .' GMT';
Dries Buytaert
committed
$etag = '"'. md5($last_modified) .'"';
// See if the client has provided the required HTTP headers:
$if_modified_since = isset($_SERVER['HTTP_IF_MODIFIED_SINCE']) ? stripslashes($_SERVER['HTTP_IF_MODIFIED_SINCE']) : FALSE;
$if_none_match = isset($_SERVER['HTTP_IF_NONE_MATCH']) ? stripslashes($_SERVER['HTTP_IF_NONE_MATCH']) : FALSE;
if ($if_modified_since && $if_none_match
&& $if_none_match == $etag // etag must match
&& $if_modified_since == $last_modified) { // if-modified-since must match
header('HTTP/1.1 304 Not Modified');
// All 304 responses must send an etag if the 200 response for the same object contained an etag
header("Etag: $etag");
return;
Dries Buytaert
committed
// Send appropriate response:
header("Last-Modified: $last_modified");
header("ETag: $etag");
// The following headers force validation of cache:
header("Expires: Sun, 19 Nov 1978 05:00:00 GMT");
header("Cache-Control: must-revalidate");
Dries Buytaert
committed
if (variable_get('page_compression', TRUE)) {
// Determine if the browser accepts gzipped data.
if (@strpos($_SERVER['HTTP_ACCEPT_ENCODING'], 'gzip') === FALSE && function_exists('gzencode')) {
// Strip the gzip header and run uncompress.
$cache->data = gzinflate(substr(substr($cache->data, 10), 0, -8));
}
elseif (function_exists('gzencode')) {
header('Content-Encoding: gzip');
}
// Send the original request's headers. We send them one after
// another so PHP's header() function can deal with duplicate
// headers.
$headers = explode("\n", $cache->headers);
foreach ($headers as $header) {
header($header);
}
print $cache->data;
/**
* Define the critical hooks that force modules to always be loaded.
*/
Dries Buytaert
committed
return array('boot', 'exit');
/**
* Unserializes and appends elements from a serialized string.
*
* @param $obj
* The object to which the elements are appended.
* @param $field
* The attribute of $obj whose value should be unserialized.
*/
function drupal_unpack($obj, $field = 'data') {
if ($obj->$field && $data = unserialize($obj->$field)) {
foreach ($data as $key => $value) {
if (!isset($obj->$key)) {
$obj->$key = $value;
}
}
}
return $obj;
}
Steven Wittens
committed
if (isset($_SERVER['HTTP_REFERER'])) {
return $_SERVER['HTTP_REFERER'];
/**
* Encode special characters in a plain-text string for display as HTML.
*
* Uses drupal_validate_utf8 to prevent cross site scripting attacks on
* Internet Explorer 6.
696
697
698
699
700
701
702
703
704
705
706
707
708
709
710
711
712
713
714
715
716
717
718
719
720
721
722
723
724
725
726
727
728
729
730
731
732
return drupal_validate_utf8($text) ? htmlspecialchars($text, ENT_QUOTES) : '';
}
/**
* 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.
*
* This function exploits preg_match behaviour (since PHP 4.3.5) when used
* with the u modifier, as a fast way to find invalid UTF-8. When the matched
* string contains an invalid byte sequence, it will fail silently.
*
* preg_match may not fail on 4 and 5 octet sequences, even though they
* are not supported by the specification.
*
* The specific preg_match behaviour is present since PHP 4.3.5.
*
* @param $text
* The text to check.
* @return
* TRUE if the text is valid UTF-8, FALSE if not.
*/
function drupal_validate_utf8($text) {
if (strlen($text) == 0) {
return TRUE;
}
return (preg_match('/^./us', $text) == 1);
* Since $_SERVER['REQUEST_URI'] is only available on Apache, we
* generate an equivalent using other environment variables.
if (isset($_SERVER['REQUEST_URI'])) {
$uri = $_SERVER['REQUEST_URI'];
}
else {
if (isset($_SERVER['argv'])) {
$uri = $_SERVER['SCRIPT_NAME'] .'?'. $_SERVER['argv'][0];
elseif (isset($_SERVER['QUERY_STRING'])) {
$uri = $_SERVER['SCRIPT_NAME'] .'?'. $_SERVER['QUERY_STRING'];
else {
$uri = $_SERVER['SCRIPT_NAME'];
}
Dries Buytaert
committed
return $uri;
/**
* Log a system message.
*
* @param $type
* The category to which this message belongs.
* @param $message
* The message to store in the log. See t() for documentation
* on how $message and $variables interact. Keep $message
* translatable by not concatenating dynamic values into it!
* @param $variables
* Array of variables to replace in the message on display or
* NULL if message is already translated or not possible to
* translate.
* @param $severity
Dries Buytaert
committed
* The severity of the message, as per RFC 3164
Dries Buytaert
committed
*
Gábor Hojtsy
committed
* @see watchdog_severity_levels()
function watchdog($type, $message, $variables = array(), $severity = WATCHDOG_NOTICE, $link = NULL) {
global $user, $base_root;
Gerhard Killesreiter
committed
Dries Buytaert
committed
// Prepare the fields to be logged
$log_message = array(
'type' => $type,
'message' => $message,
'variables' => $variables,
Dries Buytaert
committed
'severity' => $severity,
'link' => $link,
'user' => $user,
'request_uri' => $base_root . request_uri(),
'referer' => referer_uri(),
Dries Buytaert
committed
'ip' => ip_address(),
Dries Buytaert
committed
'timestamp' => time(),
);
// Call the logging hooks to log/process the message
foreach (module_implements('watchdog', TRUE) as $module) {
module_invoke($module, 'watchdog', $log_message);
Gerhard Killesreiter
committed
}
* Set a message which reflects the status of the performed operation.
* If the function is called with no arguments, this function returns all set
* messages without clearing them.
* @param $message
* The message should begin with a capital letter and always ends with a
* period '.'.
* @param $type
* The type of the message. One of the following values are possible:
* - 'status'
* - 'error'
Gábor Hojtsy
committed
* @param $repeat
* If this is FALSE and the message is already set, then the message won't
* be repeated.
Gábor Hojtsy
committed
function drupal_set_message($message = NULL, $type = 'status', $repeat = TRUE) {
Dries Buytaert
committed
if ($message) {
if (!isset($_SESSION['messages'])) {
$_SESSION['messages'] = array();
}
if (!isset($_SESSION['messages'][$type])) {
$_SESSION['messages'][$type] = array();
}
Gábor Hojtsy
committed
if ($repeat || !in_array($message, $_SESSION['messages'][$type])) {
$_SESSION['messages'][$type][] = $message;
}
Steven Wittens
committed
}
// messages not set when DB connection fails
return isset($_SESSION['messages']) ? $_SESSION['messages'] : NULL;
Steven Wittens
committed
}
Dries Buytaert
committed
* @param $type
* (optional) Only return messages of this type.
* @param $clear_queue
* (optional) Set to FALSE if you do not want to clear the messages queue
Dries Buytaert
committed
* @return
* An associative array, the key is the message type, the value an array
* of messages. If the $type parameter is passed, you get only that type,
* or an empty array if there are no such messages. If $type is not passed,
* all message types are returned, or an empty array if none exist.
function drupal_get_messages($type = NULL, $clear_queue = TRUE) {
if ($messages = drupal_set_message()) {
Dries Buytaert
committed
if ($type) {
if ($clear_queue) {
Gábor Hojtsy
committed
unset($_SESSION['messages'][$type]);
Dries Buytaert
committed
if (isset($messages[$type])) {
return array($type => $messages[$type]);
}
Dries Buytaert
committed
}
else {
if ($clear_queue) {
Gábor Hojtsy
committed
unset($_SESSION['messages']);
Dries Buytaert
committed
return $messages;
}
Dries Buytaert
committed
return array();
Steven Wittens
committed
}
* Perform an access check for a given mask and rule type. Rules are usually
* created via admin/user/rules page.
*
* If any allow rule matches, access is allowed. Otherwise, if any deny rule
* matches, access is denied. If no rule matches, access is allowed.
*
* @param $type string
* Type of access to check: Allowed values are:
* - 'host': host name or IP address
* - 'mail': e-mail address
* - 'user': username
* @param $mask string
* String or mask to test: '_' matches any character, '%' matches any
* number of characters.
* @return bool
* TRUE if access is denied, FALSE if access is allowed.
Dries Buytaert
committed
function drupal_is_denied($type, $mask) {
// Because this function is called for every page request, both cached
// and non-cached pages, we tried to optimize it as much as possible.
// We deny access if the only matching records in the {access} table have
Gábor Hojtsy
committed
// status 0 (deny). If any have status 1 (allow), or if there are no
// matching records, we allow access.
$sql = "SELECT 1 FROM {access} WHERE type = '%s' AND LOWER('%s') LIKE LOWER(mask) AND status = %d";
return db_result(db_query_range($sql, $type, $mask, 0, 0, 1)) && !db_result(db_query_range($sql, $type, $mask, 1, 0, 1));
Dries Buytaert
committed
/**
* Generates a default anonymous $user object.
Dries Buytaert
committed
*
* @return Object - the user object.
*/
function drupal_anonymous_user($session = '') {
Dries Buytaert
committed
$user = new stdClass();
$user->uid = 0;
Dries Buytaert
committed
$user->hostname = ip_address();
Dries Buytaert
committed
$user->roles = array();
$user->roles[DRUPAL_ANONYMOUS_RID] = 'anonymous user';
$user->session = $session;
Dries Buytaert
committed
$user->cache = 0;
Dries Buytaert
committed
return $user;
}
/**
* A string describing a phase of Drupal to load. Each phase adds to the
* previous one, so invoking a later phase automatically runs the earlier
* phases too. The most important usage is that if you want to access the
* Drupal database from a script without loading anything else, you can
* include bootstrap.inc, and call drupal_bootstrap(DRUPAL_BOOTSTRAP_DATABASE).
*
* @param $phase
* A constant. Allowed values are:
* DRUPAL_BOOTSTRAP_CONFIGURATION: initialize configuration.
* DRUPAL_BOOTSTRAP_EARLY_PAGE_CACHE: try to call a non-database cache fetch routine.
* DRUPAL_BOOTSTRAP_DATABASE: initialize database layer.
Dries Buytaert
committed
* DRUPAL_BOOTSTRAP_ACCESS: identify and reject banned hosts.
* DRUPAL_BOOTSTRAP_SESSION: initialize session handling.
* DRUPAL_BOOTSTRAP_LATE_PAGE_CACHE: load bootstrap.inc and module.inc, start
* the variable system and try to serve a page from the cache.
* DRUPAL_BOOTSTRAP_LANGUAGE: identify the language used on the page.
Dries Buytaert
committed
* DRUPAL_BOOTSTRAP_PATH: set $_GET['q'] to Drupal path of request.
* DRUPAL_BOOTSTRAP_FULL: Drupal is fully loaded, validate and fix input data.
*/
function drupal_bootstrap($phase) {
Gábor Hojtsy
committed
static $phases = array(DRUPAL_BOOTSTRAP_CONFIGURATION, DRUPAL_BOOTSTRAP_EARLY_PAGE_CACHE, DRUPAL_BOOTSTRAP_DATABASE, DRUPAL_BOOTSTRAP_ACCESS, DRUPAL_BOOTSTRAP_SESSION, DRUPAL_BOOTSTRAP_LATE_PAGE_CACHE, DRUPAL_BOOTSTRAP_LANGUAGE, DRUPAL_BOOTSTRAP_PATH, DRUPAL_BOOTSTRAP_FULL), $phase_index = 0;
Dries Buytaert
committed
while ($phase >= $phase_index && isset($phases[$phase_index])) {
Gábor Hojtsy
committed
$current_phase = $phases[$phase_index];
Dries Buytaert
committed
unset($phases[$phase_index++]);
_drupal_bootstrap($current_phase);
}
}
function _drupal_bootstrap($phase) {
global $conf;
switch ($phase) {
case DRUPAL_BOOTSTRAP_CONFIGURATION:
Gerhard Killesreiter
committed
drupal_unset_globals();
Gábor Hojtsy
committed
// Start a page timer:
timer_start('page');
// Initialize the configuration
conf_init();
break;
case DRUPAL_BOOTSTRAP_EARLY_PAGE_CACHE:
Gábor Hojtsy
committed
// Allow specifying special cache handlers in settings.php, like
// using memcached or files for storing cache information.
require_once variable_get('cache_inc', './includes/cache.inc');
// If the page_cache_fastpath is set to TRUE in settings.php and
// page_cache_fastpath (implemented in the special implementation of
// cache.inc) printed the page and indicated this with a returned TRUE
// then we are done.
if (variable_get('page_cache_fastpath', FALSE) && page_cache_fastpath()) {
exit;
}
break;
case DRUPAL_BOOTSTRAP_DATABASE:
// Initialize the default database.
require_once './includes/database.inc';
db_set_active();
break;
Dries Buytaert
committed
case DRUPAL_BOOTSTRAP_ACCESS:
// Deny access to hosts which were banned - t() is not yet available.
Dries Buytaert
committed
if (drupal_is_denied('host', ip_address())) {
Dries Buytaert
committed
header('HTTP/1.1 403 Forbidden');
Steven Wittens
committed
print 'Sorry, '. check_plain(ip_address()) .' has been banned.';
Dries Buytaert
committed
exit();
}
break;
case DRUPAL_BOOTSTRAP_SESSION:
require_once variable_get('session_inc', './includes/session.inc');
Dries Buytaert
committed
session_set_save_handler('sess_open', 'sess_close', 'sess_read', 'sess_write', 'sess_destroy_sid', 'sess_gc');
session_start();
break;
case DRUPAL_BOOTSTRAP_LATE_PAGE_CACHE:
// Initialize configuration variables, using values from settings.php if available.
$conf = variable_init(isset($conf) ? $conf : array());
Gábor Hojtsy
committed
// Load module handling.
require_once './includes/module.inc';
$cache_mode = variable_get('cache', CACHE_DISABLED);
// Get the page from the cache.
$cache = $cache_mode == CACHE_DISABLED ? '' : page_get_cache();