<?php

/**

 * @file

 * API functions for installing Drupal.

 */

/**

 * Do not run the task during the current installation request.

 *

 * This can be used to skip running an installation task when certain

 * conditions are met, even though the task may still show on the list of

 * installation tasks presented to the user. For example, the Drupal installer

 * uses this flag to skip over the database configuration form when valid

 * database connection information is already available from settings.php. It

 * also uses this flag to skip language import tasks when the installation is

 * being performed in English.

 */

define('INSTALL_TASK_SKIP', 1);

/**

 * Run the task on each installation request until the database is set up.

 *

 * This is primarily used by the Drupal installer for bootstrap-related tasks.

 */

define('INSTALL_TASK_RUN_IF_REACHED', 2);

/**

 * Global flag to indicate that a task should be run on each installation

 * request that reaches it, until the database is set up and we are able to

 * record the fact that it already ran.

 *

 * This is the default method for running tasks and should be used for most

 * tasks that occur after the database is set up; these tasks will then run

 * once and be marked complete once they are successfully finished. For

 * example, the Drupal installer uses this flag for the batch installation of

 * modules on the new site, and also for the configuration form that collects

 * basic site information and sets up the site maintenance account.

 */

define('INSTALL_TASK_RUN_IF_NOT_COMPLETED', 3);

/**

 * Installs Drupal either interactively or via an array of passed-in settings.

 *

 * The Drupal installation happens in a series of steps, which may be spread

 * out over multiple page requests. Each request begins by trying to determine

 * the last completed installation step (also known as a "task"), if one is

 * available from a previous request. Control is then passed to the task

 * handler, which processes the remaining tasks that need to be run until (a)

 * an error is thrown, (b) a new page needs to be displayed, or (c) the

 * installation finishes (whichever happens first).

 *

 * @param $settings

 *   An optional array of installation settings. Leave this empty for a normal,

 *   interactive, browser-based installation intended to occur over multiple

 *   page requests. Alternatively, if an array of settings is passed in, the

 *   installer will attempt to use it to perform the installation in a single

 *   page request (optimized for the command line) and not send any output

 *   intended for the web browser. See install_state_defaults() for a list of

 *   elements that are allowed to appear in this array.

 *

 * @see install_state_defaults()

 */

function install_drupal($settings = array()) {

  global $install_state;

  // Initialize the installation state with the settings that were passed in,

  // as well as a boolean indicating whether or not this is an interactive

  // installation.

  $interactive = empty($settings);

  $install_state = $settings + array('interactive' => $interactive) + install_state_defaults();

  try {

    // Begin the page request. This adds information about the current state of

    // the Drupal installation to the passed-in array.

    install_begin_request($install_state);

    // Based on the installation state, run the remaining tasks for this page

    // request, and collect any output.

    $output = install_run_tasks($install_state);

  }

  catch (Exception $e) {

    // When an installation error occurs, either send the error to the web

    // browser or pass on the exception so the calling script can use it.

    if ($install_state['interactive']) {

      install_display_output($e->getMessage(), $install_state);

    }

    else {

      throw $e;

    }

  }

  // All available tasks for this page request are now complete. Interactive

  // installations can send output to the browser or redirect the user to the

  // next page.

  if ($install_state['interactive']) {

    if ($install_state['parameters_changed']) {

      // Redirect to the correct page if the URL parameters have changed.

      install_goto(install_redirect_url($install_state));

    }

    elseif (isset($output)) {

      // Display a page only if some output is available. Otherwise it is

      // possible that we are printing a JSON page and theme output should

      // not be shown.

      install_display_output($output, $install_state);

    }

  }

}

/**

 * Returns an array of default settings for the global installation state.

 *

 * The installation state is initialized with these settings at the beginning

 * of each page request. They may evolve during the page request, but they are

 * initialized again once the next request begins.

 *

 * Non-interactive Drupal installations can override some of these default

 * settings by passing in an array to the installation script, most notably

 * 'parameters' (which contains one-time parameters such as 'profile' and

 * 'locale' that are normally passed in via the URL) and 'forms' (which can

 * be used to programmatically submit forms during the installation; the keys

 * of each element indicate the name of the installation task that the form

 * submission is for, and the values are used as the $form_state['values']

 * array that is passed on to the form submission via drupal_form_submit()).

 *

 * @see drupal_form_submit()

 */

function install_state_defaults() {

  $defaults = array(

    // The current task being processed.

    'active_task' => NULL,

    // The last task that was completed during the previous installation

    // request.

    'completed_task' => NULL,

    // This becomes TRUE only when Drupal's system module is installed.

    'database_tables_exist' => FALSE,

    // An array of forms to be programmatically submitted during the

    // installation. The keys of each element indicate the name of the

    // installation task that the form submission is for, and the values are

    // used as the $form_state['values'] array that is passed on to the form

    // submission via drupal_form_submit().

    'forms' => array(),

    // This becomes TRUE only at the end of the installation process, after

    // all available tasks have been completed and Drupal is fully installed.

    // It is used by the installer to store correct information in the database

    // about the completed installation, as well as to inform theme functions

    // that all tasks are finished (so that the task list can be displayed

    // correctly).

    'installation_finished' => FALSE,

    // Whether or not this installation is interactive. By default this will

    // be set to FALSE if settings are passed in to install_drupal().

    'interactive' => TRUE,

    // An array of available languages for the installation.

    'locales' => array(),

    // An array of parameters for the installation, pre-populated by the URL

    // or by the settings passed in to install_drupal(). This is primarily

    // used to store 'profile' (the name of the chosen installation profile)

    // and 'locale' (the name of the chosen installation language), since

    // these settings need to persist from page request to page request before

    // the database is available for storage.

    'parameters' => array(),

    // Whether or not the parameters have changed during the current page

    // request. For interactive installations, this will trigger a page

    // redirect.

    'parameters_changed' => FALSE,

    // An array of information about the chosen installation profile. This will

    // be filled in based on the profile's .info file.

    'profile_info' => array(),

    // An array of available installation profiles.

    'profiles' => array(),

    // An array of server variables that will be substituted into the global

    // $_SERVER array via drupal_override_server_variables(). Used by

    // non-interactive installations only.

    'server' => array(),

    // This becomes TRUE only when a valid database connection can be

    // established.

    'settings_verified' => FALSE,

    // Installation tasks can set this to TRUE to force the page request to

    // end (even if there is no themable output), in the case of an interactive

    // installation. This is needed only rarely; for example, it would be used

    // by an installation task that prints JSON output rather than returning a

    // themed page. The most common example of this is during batch processing,

    // but the Drupal installer automatically takes care of setting this

    // parameter properly in that case, so that individual installation tasks

    // which implement the batch API do not need to set it themselves.

    'stop_page_request' => FALSE,

    // Installation tasks can set this to TRUE to indicate that the task should

    // be run again, even if it normally wouldn't be. This can be used, for

    // example, if a single task needs to be spread out over multiple page

    // requests, or if it needs to perform some validation before allowing

    // itself to be marked complete. The most common examples of this are batch

    // processing and form submissions, but the Drupal installer automatically

    // takes care of setting this parameter properly in those cases, so that

    // individual installation tasks which implement the batch API or form API

    // do not need to set it themselves.

    'task_not_complete' => FALSE,

    // A list of installation tasks which have already been performed during

    // the current page request.

    'tasks_performed' => array(),

  );

  return $defaults;

}

/**

 * Begins an installation request, modifying the installation state as needed.

 *

 * This function performs commands that must run at the beginning of every page

 * request. It throws an exception if the installation should not proceed.

 *

 * @param $install_state

 *   An array of information about the current installation state. This is

 *   modified with information gleaned from the beginning of the page request.

 */

function install_begin_request(&$install_state) {

  // Add any installation parameters passed in via the URL.

  $install_state['parameters'] += $_GET;

  // Validate certain core settings that are used throughout the installation.

  if (!empty($install_state['parameters']['profile'])) {

    $install_state['parameters']['profile'] = preg_replace('/[^a-zA-Z_0-9]/', '', $install_state['parameters']['profile']);

  }

  if (!empty($install_state['parameters']['locale'])) {

    $install_state['parameters']['locale'] = preg_replace('/[^a-zA-Z_0-9\-]/', '', $install_state['parameters']['locale']);

  }

  // Allow command line scripts to override server variables used by Drupal.

  require_once DRUPAL_ROOT . '/includes/bootstrap.inc';

  if (!$install_state['interactive']) {

    drupal_override_server_variables($install_state['server']);

  }

  // The user agent header is used to pass a database prefix in the request when

  // running tests. However, for security reasons, it is imperative that no

  // installation be permitted using such a prefix.

  if (isset($_SERVER['HTTP_USER_AGENT']) && strpos($_SERVER['HTTP_USER_AGENT'], "simpletest") !== FALSE) {

    header($_SERVER['SERVER_PROTOCOL'] . ' 403 Forbidden');

    exit;

  }

  drupal_bootstrap(DRUPAL_BOOTSTRAP_CONFIGURATION);

  // This must go after drupal_bootstrap(), which unsets globals!

  global $conf;

  require_once DRUPAL_ROOT . '/modules/system/system.install';

  require_once DRUPAL_ROOT . '/includes/common.inc';

  require_once DRUPAL_ROOT . '/includes/file.inc';

  require_once DRUPAL_ROOT . '/includes/install.inc';

  require_once DRUPAL_ROOT . '/' . variable_get('path_inc', 'includes/path.inc');

  // Load module basics (needed for hook invokes).

  include_once DRUPAL_ROOT . '/includes/module.inc';

  include_once DRUPAL_ROOT . '/includes/session.inc';

  // Set up $language, so t() caller functions will still work.

  drupal_language_initialize();

  include_once DRUPAL_ROOT . '/includes/entity.inc';

  require_once DRUPAL_ROOT . '/includes/ajax.inc';

  $module_list['system']['filename'] = 'modules/system/system.module';

  $module_list['user']['filename'] = 'modules/user/user.module';

  module_list(TRUE, FALSE, FALSE, $module_list);

  drupal_load('module', 'system');

  drupal_load('module', 'user');

  // Load the cache infrastructure using a "fake" cache implementation that

  // does not attempt to write to the database. We need this during the initial

  // part of the installer because the database is not available yet. We

  // continue to use it even when the database does become available, in order

  // to preserve consistency between interactive and command-line installations

  // (the latter complete in one page request and therefore are forced to

  // continue using the cache implementation they started with) and also

  // because any data put in the cache during the installer is inherently

  // suspect, due to the fact that Drupal is not fully set up yet.

  require_once DRUPAL_ROOT . '/includes/cache.inc';

  require_once DRUPAL_ROOT . '/includes/cache-install.inc';

  $conf['cache_default_class'] = 'DrupalFakeCache';

  // Prepare for themed output. We need to run this at the beginning of the

  // page request to avoid a different theme accidentally getting set. (We also

  // need to run it even in the case of command-line installations, to prevent

  // any code in the installer that happens to initialize the theme system from

  // accessing the database before it is set up yet.)

  drupal_maintenance_theme();

  // Check existing settings.php.

  $install_state['settings_verified'] = install_verify_settings();

  if ($install_state['settings_verified']) {

    // Initialize the database system. Note that the connection

    // won't be initialized until it is actually requested.

    require_once DRUPAL_ROOT . '/includes/database/database.inc';

    // Verify the last completed task in the database, if there is one.

    $task = install_verify_completed_task();

  }

  else {

    $task = NULL;

    // Do not install over a configured settings.php. Check the 'db_url'

    // variable in addition to 'databases', since previous versions of Drupal

    // used that (and we do not want to allow installations on an existing site

    // whose settings file has not yet been updated).

    if (!empty($GLOBALS['databases']) || !empty($GLOBALS['db_url'])) {

      throw new Exception(install_already_done_error());

    }

  }

  // Modify the installation state as appropriate.

  $install_state['completed_task'] = $task;

  $install_state['database_tables_exist'] = !empty($task);

}

/**

 * Runs all tasks for the current installation request.

 *

 * In the case of an interactive installation, all tasks will be attempted

 * until one is reached that has output which needs to be displayed to the

 * user, or until a page redirect is required. Otherwise, tasks will be

 * attempted until the installation is finished.

 *

 * @param $install_state

 *   An array of information about the current installation state. This is

 *   passed along to each task, so it can be modified if necessary.

 *

 * @return

 *   HTML output from the last completed task.

 */

function install_run_tasks(&$install_state) {

  do {

    // Obtain a list of tasks to perform. The list of tasks itself can be

    // dynamic (e.g., some might be defined by the installation profile,

    // which is not necessarily known until the earlier tasks have run),

    // so we regenerate the remaining tasks based on the installation state,

    // each time through the loop.

    $tasks_to_perform = install_tasks_to_perform($install_state);

    // Run the first task on the list.

    reset($tasks_to_perform);

    $task_name = key($tasks_to_perform);

    $task = array_shift($tasks_to_perform);

    $install_state['active_task'] = $task_name;

    $original_parameters = $install_state['parameters'];

    $output = install_run_task($task, $install_state);

    $install_state['parameters_changed'] = ($install_state['parameters'] != $original_parameters);

    // Store this task as having been performed during the current request,

    // and save it to the database as completed, if we need to and if the

    // database is in a state that allows us to do so. Also mark the

    // installation as 'done' when we have run out of tasks.

    if (!$install_state['task_not_complete']) {

      $install_state['tasks_performed'][] = $task_name;

      $install_state['installation_finished'] = empty($tasks_to_perform);

      if ($install_state['database_tables_exist'] && ($task['run'] == INSTALL_TASK_RUN_IF_NOT_COMPLETED || $install_state['installation_finished'])) {

        variable_set('install_task', $install_state['installation_finished'] ? 'done' : $task_name);

      }

    }

    // Stop when there are no tasks left. In the case of an interactive

    // installation, also stop if we have some output to send to the browser,

    // the URL parameters have changed, or an end to the page request was

    // specifically called for.

    $finished = empty($tasks_to_perform) || ($install_state['interactive'] && (isset($output) || $install_state['parameters_changed'] || $install_state['stop_page_request']));

  } while (!$finished);

  return $output;

}

/**

 * Runs an individual installation task.

 *

 * @param $task

 *   An array of information about the task to be run as returned by

 *   hook_install_tasks().

 * @param $install_state

 *   An array of information about the current installation state. This is

 *   passed in by reference so that it can be modified by the task.

 *

 * @return

 *   The output of the task function, if there is any.

 */

function install_run_task($task, &$install_state) {

  $function = $task['function'];

  if ($task['type'] == 'form') {

    require_once DRUPAL_ROOT . '/includes/form.inc';

    if ($install_state['interactive']) {

      // For interactive forms, build the form and ensure that it will not

      // redirect, since the installer handles its own redirection only after

      // marking the form submission task complete.

      $form_state = array(

        // We need to pass $install_state by reference in order for forms to

        // modify it, since the form API will use it in call_user_func_array(),

        // which requires that referenced variables be passed explicitly.

        'build_info' => array('args' => array(&$install_state)),

        'no_redirect' => TRUE,

      );

      $form = drupal_build_form($function, $form_state);

      // If a successful form submission did not occur, the form needs to be

      // rendered, which means the task is not complete yet.

      if (empty($form_state['executed'])) {

        $install_state['task_not_complete'] = TRUE;

        return drupal_render($form);

      }

      // Otherwise, return nothing so the next task will run in the same

      // request.

      return;

    }

    else {

      // For non-interactive forms, submit the form programmatically with the

      // values taken from the installation state. Throw an exception if any

      // errors were encountered.

      $form_state = array(

        'values' => !empty($install_state['forms'][$function]) ? $install_state['forms'][$function] : array(),

        // We need to pass $install_state by reference in order for forms to

        // modify it, since the form API will use it in call_user_func_array(),

        // which requires that referenced variables be passed explicitly.

        'build_info' => array('args' => array(&$install_state)),

      );

      drupal_form_submit($function, $form_state);

      $errors = form_get_errors();

      if (!empty($errors)) {

        throw new Exception(implode("\n", $errors));

      }

    }

  }

  elseif ($task['type'] == 'batch') {

    // Start a new batch based on the task function, if one is not running

    // already.

    $current_batch = variable_get('install_current_batch');

    if (!$install_state['interactive'] || !$current_batch) {

      $batch = $function($install_state);

      if (empty($batch)) {

        // If the task did some processing and decided no batch was necessary,

        // there is nothing more to do here.

        return;

      }

      batch_set($batch);

      // For interactive batches, we need to store the fact that this batch

      // task is currently running. Otherwise, we need to make sure the batch

      // will complete in one page request.

      if ($install_state['interactive']) {

        variable_set('install_current_batch', $function);

      }

      else {

        $batch =& batch_get();

        $batch['progressive'] = FALSE;

      }

      // Process the batch. For progressive batches, this will redirect.

      // Otherwise, the batch will complete.

      batch_process(install_redirect_url($install_state), install_full_redirect_url($install_state));

    }

    // If we are in the middle of processing this batch, keep sending back

    // any output from the batch process, until the task is complete.

    elseif ($current_batch == $function) {

      include_once DRUPAL_ROOT . '/includes/batch.inc';