Club Drupal

<?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.

 * @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';

      $output = _batch_page();

      // The task is complete when we try to access the batch page and receive

      // FALSE in return, since this means we are at a URL where we are no

      // longer requesting a batch ID.

      if ($output === FALSE) {

        // Return nothing so the next task will run in the same request.

        variable_del('install_current_batch');

        return;

      }

      else {

        // We need to force the page request to end if the task is not

        // complete, since the batch API sometimes prints JSON output

        // rather than returning a themed page.

        $install_state['task_not_complete'] = $install_state['stop_page_request'] = TRUE;

        return $output;

      }

    }

  }

  else {

    // For normal tasks, just return the function result, whatever it is.

    return $function($install_state);

  }

}

/**

 * Returns a list of tasks to perform during the current installation request.

 *

 * Note that the list of tasks can change based on the installation state as

 * the page request evolves (for example, if an installation profile hasn't

 * been selected yet, we don't yet know which profile tasks need to be run).

 *

 * @param $install_state

 *   An array of information about the current installation state.

 *

 * @return

 *   A list of tasks to be performed, with associated metadata.

 */

function install_tasks_to_perform($install_state) {

  // Start with a list of all currently available tasks.

  $tasks = install_tasks($install_state);

  foreach ($tasks as $name => $task) {

    // Remove any tasks that were already performed or that never should run.

    // Also, if we started this page request with an indication of the last

    // task that was completed, skip that task and all those that come before

    // it, unless they are marked as always needing to run.

    if ($task['run'] == INSTALL_TASK_SKIP || in_array($name, $install_state['tasks_performed']) || (!empty($install_state['completed_task']) && empty($completed_task_found) && $task['run'] != INSTALL_TASK_RUN_IF_REACHED)) {

      unset($tasks[$name]);

    }

    if (!empty($install_state['completed_task']) && $name == $install_state['completed_task']) {

      $completed_task_found = TRUE;

    }

  }

  return $tasks;

}

/**

 * Returns a list of all tasks the installer currently knows about.

 *

 * This function will return tasks regardless of whether or not they are

 * intended to run on the current page request. However, the list can change

 * based on the installation state (for example, if an installation profile

 * hasn't been selected yet, we don't yet know which profile tasks will be

 * available).

 *

 * @param $install_state

 *   An array of information about the current installation state.

 *

 * @return

 *   A list of tasks, with associated metadata.

 */

function install_tasks($install_state) {

  // Determine whether translation import tasks will need to be performed.

  $needs_translations = count($install_state['locales']) > 1 && !empty($install_state['parameters']['locale']) && $install_state['parameters']['locale'] != 'en';

  // Start with the core installation tasks that run before handing control

  // to the installation profile.

  $tasks = array(

    'install_select_profile' => array(

      'display_name' => st('Choose profile'),

      'display' => count($install_state['profiles']) != 1,

      'run' => INSTALL_TASK_RUN_IF_REACHED,

    ),

    'install_select_locale' => array(

      'display_name' => st('Choose language'),

      'run' => INSTALL_TASK_RUN_IF_REACHED,

    ),

    'install_load_profile' => array(

      'run' => INSTALL_TASK_RUN_IF_REACHED,

    ),

    'install_verify_requirements' => array(

      'display_name' => st('Verify requirements'),

    ),

    'install_settings_form' => array(

      'display_name' => st('Set up database'),

      'type' => 'form',

      'run' => $install_state['settings_verified'] ? INSTALL_TASK_SKIP : INSTALL_TASK_RUN_IF_NOT_COMPLETED,

    ),

    'install_system_module' => array(

    ),

    'install_bootstrap_full' => array(

      'run' => INSTALL_TASK_RUN_IF_REACHED,

    ),

    'install_profile_modules' => array(

      'display_name' => count($install_state['profiles']) == 1 ? st('Install site') : st('Install profile'),

      'type' => 'batch',

    ),

    'install_import_locales' => array(

      'display_name' => st('Set up translations'),

      'display' => $needs_translations,

      'type' => 'batch',

      'run' => $needs_translations ? INSTALL_TASK_RUN_IF_NOT_COMPLETED : INSTALL_TASK_SKIP,

    ),

    'install_configure_form' => array(

      'display_name' => st('Configure site'),

      'type' => 'form',

    ),

  );

  // Now add any tasks defined by the installation profile.

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

    // Load the profile install file, because it is not always loaded when

    // hook_install_tasks() is invoked (e.g. batch processing).

    $profile_install_file = DRUPAL_ROOT . '/profiles/' . $install_state['parameters']['profile'] . '/' . $install_state['parameters']['profile'] . '.install';

    if (file_exists($profile_install_file)) {

      include_once $profile_install_file;

    }

    $function = $install_state['parameters']['profile'] . '_install_tasks';

    if (function_exists($function)) {

      $result = $function($install_state);

      if (is_array($result)) {

        $tasks += $result;

      }

    }

  }

  // Finish by adding the remaining core tasks.

  $tasks += array(

    'install_import_locales_remaining' => array(

      'display_name' => st('Finish translations'),

      'display' => $needs_translations,

      'type' => 'batch',

      'run' => $needs_translations ? INSTALL_TASK_RUN_IF_NOT_COMPLETED : INSTALL_TASK_SKIP,

    ),

    'install_finished' => array(

      'display_name' => st('Finished'),

    ),

  );

  // Allow the installation profile to modify the full list of tasks.

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

    $profile_file = DRUPAL_ROOT . '/profiles/' . $install_state['parameters']['profile'] . '/' . $install_state['parameters']['profile'] . '.profile';

    if (file_exists($profile_file)) {

      include_once $profile_file;

      $function = $install_state['parameters']['profile'] . '_install_tasks_alter';

      if (function_exists($function)) {

        $function($tasks, $install_state);

      }

    }

  }

  // Fill in default parameters for each task before returning the list.

  foreach ($tasks as $task_name => &$task) {

    $task += array(

      'display_name' => NULL,

      'display' => !empty($task['display_name']),

      'type' => 'normal',

      'run' => INSTALL_TASK_RUN_IF_NOT_COMPLETED,

      'function' => $task_name,

    );

  }

  return $tasks;

}

/**

 * Returns a list of tasks that should be displayed to the end user.

 *

 * The output of this function is a list suitable for sending to

 * theme_task_list().

 *

 * @param $install_state

 *   An array of information about the current installation state.

 *

 * @return

 *   A list of tasks, with keys equal to the machine-readable task name and

 *   values equal to the name that should be displayed.

 *

 * @see theme_task_list()

 */

function install_tasks_to_display($install_state) {

  $displayed_tasks = array();

  foreach (install_tasks($install_state) as $name => $task) {

    if ($task['display']) {

      $displayed_tasks[$name] = $task['display_name'];

    }

  }

  return $displayed_tasks;

}

/**

 * Returns the URL that should be redirected to during an installation request.

 *

 * The output of this function is suitable for sending to install_goto().

 *

 * @param $install_state

 *   An array of information about the current installation state.

 *

 * @return

 *   The URL to redirect to.

 *

 * @see install_full_redirect_url()

 */

function install_redirect_url($install_state) {

  return 'install.php?' . drupal_http_build_query($install_state['parameters']);

}

/**

 * Returns the complete URL redirected to during an installation request.

 *

 * @param $install_state

 *   An array of information about the current installation state.

 *

 * @return

 *   The complete URL to redirect to.

 *

 * @see install_redirect_url()

 */

function install_full_redirect_url($install_state) {

  global $base_url;

  return $base_url . '/' . install_redirect_url($install_state);

}

/**

 * Displays themed installer output and ends the page request.

 *

 * Installation tasks should use drupal_set_title() to set the desired page

 * title, but otherwise this function takes care of theming the overall page

 * output during every step of the installation.

 *

 * @param $output

 *   The content to display on the main part of the page.

 * @param $install_state

 *   An array of information about the current installation state.

 */

function install_display_output($output, $install_state) {

  drupal_page_header();

  // Prevent install.php from being indexed when installed in a sub folder.

  // robots.txt rules are not read if the site is within domain.com/subfolder

  // resulting in /subfolder/install.php being found through search engines.

  // When settings.php is writeable this can be used via an external database

  // leading a malicious user to gain php access to the server.

  $noindex_meta_tag = array(

    '#tag' => 'meta',

    '#attributes' => array(

      'name' => 'robots',

      'content' => 'noindex, nofollow',

    ),

  );

  drupal_add_html_head($noindex_meta_tag, 'install_meta_robots');

  // Only show the task list if there is an active task; otherwise, the page

  // request has ended before tasks have even been started, so there is nothing

  // meaningful to show.

  if (isset($install_state['active_task'])) {

    // Let the theming function know when every step of the installation has

    // been completed.

    $active_task = $install_state['installation_finished'] ? NULL : $install_state['active_task'];

    drupal_add_region_content('sidebar_first', theme('task_list', array('items' => install_tasks_to_display($install_state), 'active' => $active_task)));

  }

  print theme('install_page', array('content' => $output));

  exit;

}

/**

 * Verifies the requirements for installing Drupal.

 *

 * @param $install_state

 *   An array of information about the current installation state.

 *

 * @return

 *   A themed status report, or an exception if there are requirement errors.

 *   If there are only requirement warnings, a themed status report is shown

 *   initially, but the user is allowed to bypass it by providing 'continue=1'

 *   in the URL. Otherwise, no output is returned, so that the next task can be

 *   run in the same page request.

 */

function install_verify_requirements(&$install_state) {

  // Check the installation requirements for Drupal and this profile.

  $requirements = install_check_requirements($install_state);

  // Verify existence of all required modules.

  $requirements += drupal_verify_profile($install_state);

  // Check the severity of the requirements reported.

  $severity = drupal_requirements_severity($requirements);

  // If there are errors, always display them. If there are only warnings, skip

  // them if the user has provided a URL parameter acknowledging the warnings

  // and indicating a desire to continue anyway. See drupal_requirements_url().

  if ($severity == REQUIREMENT_ERROR || ($severity == REQUIREMENT_WARNING && empty($install_state['parameters']['continue']))) {

    if ($install_state['interactive']) {

      drupal_set_title(st('Requirements problem'));

      $status_report = theme('status_report', array('requirements' => $requirements));

      $status_report .= st('Check the error messages and <a href="!url">proceed with the installation</a>.', array('!url' => check_url(drupal_requirements_url($severity))));

      return $status_report;

    }

    else {

      // Throw an exception showing any unmet requirements.

      $failures = array();

      foreach ($requirements as $requirement) {

        // Skip warnings altogether for non-interactive installations; these

        // proceed in a single request so there is no good opportunity (and no

        // good method) to warn the user anyway.

        if (isset($requirement['severity']) && $requirement['severity'] == REQUIREMENT_ERROR) {

          $failures[] = $requirement['title'] . ': ' . $requirement['value'] . "\n\n" . $requirement['description'];

        }

      }

      if (!empty($failures)) {

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

      }

    }

  }

}

/**

 * Installation task; install the Drupal system module.

 *

 * @param $install_state

 *   An array of information about the current installation state.

 */

function install_system_module(&$install_state) {

  // Install system.module.

  drupal_install_system();

  // Call file_ensure_htaccess() to ensure that all of Drupal's standard

  // directories (e.g., the public and private files directories) have

  // appropriate .htaccess files. These directories will have already been

  // created by this point in the installer, since Drupal creates them during

  // the install_verify_requirements() task. Note that we cannot call

  // file_ensure_htaccess() any earlier than this, since it relies on

  // system.module in order to work.

  file_ensure_htaccess();

  // Enable the user module so that sessions can be recorded during the

  // upcoming bootstrap step.

  module_enable(array('user'), FALSE);

  // Save the list of other modules to install for the upcoming tasks.

  // variable_set() can be used now that system.module is installed.

  $modules = $install_state['profile_info']['dependencies'];

  // The installation profile is also a module, which needs to be installed

  // after all the dependencies have been installed.

  $modules[] = drupal_get_profile();

  variable_set('install_profile_modules', array_diff($modules, array('system')));

  $install_state['database_tables_exist'] = TRUE;

}

/**

 * Verifies and returns the last installation task that was completed.

 *

 * @return

 *   The last completed task, if there is one. An exception is thrown if Drupal

 *   is already installed.

 */

function install_verify_completed_task() {

  try {

    if ($result = db_query("SELECT value FROM {variable} WHERE name = :name", array('name' => 'install_task'))) {

      $task = unserialize($result->fetchField());

    }

  }

  // Do not trigger an error if the database query fails, since the database

  // might not be set up yet.

  catch (Exception $e) {

  }

  if (isset($task)) {

    if ($task == 'done') {

      throw new Exception(install_already_done_error());

    }

    return $task;

  }

}

/**

 * Verifies the existing settings in settings.php.

 */

function install_verify_settings() {

  global $databases;

  // Verify existing settings (if any).

  if (!empty($databases) && install_verify_pdo()) {

    $database = $databases['default']['default'];

    drupal_static_reset('conf_path');

    $settings_file = './' . conf_path(FALSE) . '/settings.php';

    $errors = install_database_errors($database, $settings_file);

    if (empty($errors)) {

      return TRUE;

    }

  }

  return FALSE;

}

/**

 * Verifies the PDO library.

 */

function install_verify_pdo() {

  // PDO was moved to PHP core in 5.2.0, but the old extension (targeting 5.0

  // and 5.1) is still available from PECL, and can still be built without

  // errors. To verify that the correct version is in use, we check the

  // PDO::ATTR_DEFAULT_FETCH_MODE constant, which is not available in the

  // PECL extension.

  return extension_loaded('pdo') && defined('PDO::ATTR_DEFAULT_FETCH_MODE');

}

/**

 * Form constructor for a form to configure and rewrite settings.php.

 *

 * @param $install_state

 *   An array of information about the current installation state.

 *

 * @see install_settings_form_validate()

 * @see install_settings_form_submit()

 * @ingroup forms

 */

function install_settings_form($form, &$form_state, &$install_state) {

  global $databases;

  $profile = $install_state['parameters']['profile'];

  $install_locale = $install_state['parameters']['locale'];

  drupal_static_reset('conf_path');

  $conf_path = './' . conf_path(FALSE);

  $settings_file = $conf_path . '/settings.php';

  $database = isset($databases['default']['default']) ? $databases['default']['default'] : array();

  drupal_set_title(st('Database configuration'));

  $drivers = drupal_get_database_types();

  $drivers_keys = array_keys($drivers);

  $form['driver'] = array(

    '#type' => 'radios',

    '#title' => st('Database type'),

    '#required' => TRUE,

    '#default_value' => !empty($database['driver']) ? $database['driver'] : current($drivers_keys),

    '#description' => st('The type of database your @drupal data will be stored in.', array('@drupal' => drupal_install_profile_distribution_name())),

  );

  if (count($drivers) == 1) {

    $form['driver']['#disabled'] = TRUE;

    $form['driver']['#description'] .= ' ' . st('Your PHP configuration only supports a single database type, so it has been automatically selected.');

  }

  // Add driver specific configuration options.

  foreach ($drivers as $key => $driver) {

    $form['driver']['#options'][$key] = $driver->name();

    $form['settings'][$key] = $driver->getFormOptions($database);

    $form['settings'][$key]['#prefix'] = '<h2 class="js-hide">' . st('@driver_name settings', array('@driver_name' => $driver->name())) . '</h2>';

    $form['settings'][$key]['#type'] = 'container';

    $form['settings'][$key]['#tree'] = TRUE;

    $form['settings'][$key]['advanced_options']['#parents'] = array($key);

    $form['settings'][$key]['#states'] = array(

      'visible' => array(

        ':input[name=driver]' => array('value' => $key),

      )

    );

  }

  $form['actions'] = array('#type' => 'actions');

  $form['actions']['save'] = array(

    '#type' => 'submit',

    '#value' => st('Save and continue'),

    '#limit_validation_errors' => array(

      array('driver'),

      array(isset($form_state['input']['driver']) ? $form_state['input']['driver'] : current($drivers_keys)),

    ),

    '#submit' => array('install_settings_form_submit'),

  );

  $form['errors'] = array();

  $form['settings_file'] = array('#type' => 'value', '#value' => $settings_file);

  return $form;

}

/**

 * Form validation handler for install_settings_form().

 *

 * @see install_settings_form_submit()

 */

function install_settings_form_validate($form, &$form_state) {

  $driver = $form_state['values']['driver'];

  $database = $form_state['values'][$driver];

  $database['driver'] = $driver;

  // TODO: remove when PIFR will be updated to use 'db_prefix' instead of

  // 'prefix' in the database settings form.

  $database['prefix'] = $database['db_prefix'];

  unset($database['db_prefix']);

  $form_state['storage']['database'] = $database;

  $errors = install_database_errors($database, $form_state['values']['settings_file']);

  foreach ($errors as $name => $message) {

    form_set_error($name, $message);

  }

}

/**

 * Checks a database connection and returns any errors.

 */

function install_database_errors($database, $settings_file) {

  global $databases;

  $errors = array();

  // Check database type.

  $database_types = drupal_get_database_types();

  $driver = $database['driver'];

  if (!isset($database_types[$driver])) {

    $errors['driver'] = st("In your %settings_file file you have configured @drupal to use a %driver server, however your PHP installation currently does not support this database type.", array('%settings_file' => $settings_file, '@drupal' => drupal_install_profile_distribution_name(), '%driver' => $driver));

  }

  else {

    // Run driver specific validation

    $errors += $database_types[$driver]->validateDatabaseSettings($database);

    // Run tasks associated with the database type. Any errors are caught in the

    // calling function.

    $databases['default']['default'] = $database;

    // Just changing the global doesn't get the new information processed.

    // We tell tell the Database class to re-parse $databases.

    Database::parseConnectionInfo();

    try {

      db_run_tasks($driver);

    }

    catch (DatabaseTaskException $e) {

      // These are generic errors, so we do not have any specific key of the

      // database connection array to attach them to; therefore, we just put

      // them in the error array with standard numeric keys.

      $errors[$driver . '][0'] = $e->getMessage();

    }

  }

  return $errors;

}

/**

 * Form submission handler for install_settings_form().

 *

 * @see install_settings_form_validate()

 */

function install_settings_form_submit($form, &$form_state) {

  global $install_state;

  // Update global settings array and save.

  $settings['databases'] = array(

    'value'    => array('default' => array('default' => $form_state['storage']['database'])),

    'required' => TRUE,

  );

  $settings['drupal_hash_salt'] = array(

    'value'    => drupal_random_key(),

    'required' => TRUE,

  );

  drupal_rewrite_settings($settings);

  // Indicate that the settings file has been verified, and check the database

  // for the last completed task, now that we have a valid connection. This

  // last step is important since we want to trigger an error if the new

  // database already has Drupal installed.

  $install_state['settings_verified'] = TRUE;

  $install_state['completed_task'] = install_verify_completed_task();

}

/**

 * Finds all .profile files.

 */

function install_find_profiles() {

  return file_scan_directory('./profiles', '/\.profile$/', array('key' => 'name'));

}

/**

 * Selects which profile to install.

 *

 * @param $install_state

 *   An array of information about the current installation state. The chosen

 *   profile will be added here, if it was not already selected previously, as

 *   will a list of all available profiles.

 *

 * @return

 *   For interactive installations, a form allowing the profile to be selected,

 *   if the user has a choice that needs to be made. Otherwise, an exception is

 *   thrown if a profile cannot be chosen automatically.

 */

function install_select_profile(&$install_state) {

  $install_state['profiles'] += install_find_profiles();

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

    // Try to find a profile.

    $profile = _install_select_profile($install_state['profiles']);

    if (empty($profile)) {

      // We still don't have a profile, so display a form for selecting one.

      // Only do this in the case of interactive installations, since this is

      // not a real form with submit handlers (the database isn't even set up

      // yet), rather just a convenience method for setting parameters in the

      // URL.

      if ($install_state['interactive']) {

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

        drupal_set_title(st('Select an installation profile'));

        $form = drupal_get_form('install_select_profile_form', $install_state['profiles']);

        return drupal_render($form);

      }

      else {

        throw new Exception(install_no_profile_error());

      }

    }

    else {

      $install_state['parameters']['profile'] = $profile;

    }

  }

}

/**

 * Selects an installation profile.

 *

 * A profile will be selected if:

 * - Only one profile is available,

 * - A profile was submitted through $_POST,

 * - Exactly one of the profiles is marked as "exclusive".

 * If multiple profiles are marked as "exclusive" then no profile will be

 * selected.

 *

 * @param array $profiles

 *   An associative array of profiles with the machine-readable names as keys.

 *

 * @return

 *   The machine-readable name of the selected profile or NULL if no profile was

 *   selected.

 */

function _install_select_profile($profiles) {

  if (sizeof($profiles) == 0) {

    throw new Exception(install_no_profile_error());

  }

  // Don't need to choose profile if only one available.

  if (sizeof($profiles) == 1) {

    $profile = array_pop($profiles);

    // TODO: is this right?

    require_once DRUPAL_ROOT . '/' . $profile->uri;

    return $profile->name;

  }

  else {

    foreach ($profiles as $profile) {

      if (!empty($_POST['profile']) && ($_POST['profile'] == $profile->name)) {

        return $profile->name;

      }

    }

  }

  // Check for a profile marked as "exclusive" and ensure that only one

  // profile is marked as such.

  $exclusive_profile = NULL;

  foreach ($profiles as $profile) {

    $profile_info = install_profile_info($profile->name);

    if (!empty($profile_info['exclusive'])) {

      if (empty($exclusive_profile)) {

        $exclusive_profile = $profile->name;

      }

      else {

        // We found a second "exclusive" profile. There's no way to choose

        // between them, so we ignore the property.

        return;

      }

    }

  }

  return $exclusive_profile;

}

/**

 * Form constructor for the profile selection form.

 *

 * @param $form_state

 *   Array of metadata about state of form processing.