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);

}

}

$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;

// 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 . '/' . 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';

$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, if necessary. We need to run this at the

// beginning of the page request to avoid a different theme accidentally

// getting set.

if ($install_state['interactive']) {

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;

// Since previous versions of Drupal stored database connection information

// in the 'db_url' variable, we should never let an installation proceed if

// this variable is defined and the settings file was not verified above

// (otherwise we risk installing over an existing site whose settings file

// has not yet been updated).

if (!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);

// 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']);

}

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'])) {

drupal_install_initialize_database();

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;

$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());

drupal_form_submit($function, $form_state, $install_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);

}

// 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;

// 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 install 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'])) {

$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 (is_file($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;

$displayed_tasks = array();

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

if ($task['display']) {

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

}

}

return $displayed_tasks;

drupal_page_header();

// 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_state['database_tables_exist'] ? 'maintenance_page' : 'install_page', array('content' => $output));

exit;

// 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 ($severity == REQUIREMENT_ERROR) {

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' => request_uri()));

return $status_report;

}

else {

// Throw an exception showing all unmet requirements.

$failures = array();

foreach ($requirements as $requirement) {

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

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

}

}

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

}

}

// Install system.module.

drupal_install_system();

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

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

// Drupal is bootstrapped.

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

// The install 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;

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;

}

global $db_prefix, $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;

global $databases, $db_prefix;

$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_detect_database_types();

if (!$drivers) {

// There is no point submitting the form if there are no database drivers

// at all, so throw an exception here.

throw new Exception(st('Your web server does not appear to support any common database types. Check with your hosting provider to see if they offer any databases that <a href="@drupal-databases">Drupal supports</a>.', array('@drupal-databases' => 'http://drupal.org/node/270#database')));

}

else {

$form['driver'] = array(

'#type' => 'radios',

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

'#required' => TRUE,

'#options' => $drivers,

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

'#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 the %driver database type so it has been automatically selected.', array('%driver' => current($drivers)));

}

// Database name

$form['database'] = array(

'#type' => 'textfield',

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

'#default_value' => empty($database['database']) ? '' : $database['database'],

'#size' => 45,

'#required' => TRUE,

'#description' => st('The name of the database your @drupal data will be stored in. It must exist on your server before @drupal can be installed.', array('@drupal' => drupal_install_profile_distribution_name())),

);

// Database username

$form['username'] = array(

'#type' => 'textfield',

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

'#default_value' => empty($database['username']) ? '' : $database['username'],

'#size' => 45,

);

// Database password

$form['password'] = array(

'#type' => 'password',

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

'#default_value' => empty($database['password']) ? '' : $database['password'],

'#size' => 45,

);

$form['advanced_options'] = array(

'#type' => 'fieldset',

'#title' => st('Advanced options'),

'#collapsible' => TRUE,

'#collapsed' => TRUE,

'#description' => st("These options are only necessary for some sites. If you're not sure what you should enter here, leave the default settings or check with your hosting provider.")

);

// Database host

$form['advanced_options']['host'] = array(

'#type' => 'textfield',

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

'#default_value' => empty($database['host']) ? 'localhost' : $database['host'],

'#size' => 45,

// Hostnames can be 255 characters long.

'#maxlength' => 255,

'#required' => TRUE,

'#description' => st('If your database is located on a different server, change this.'),

);

// Database port

$form['advanced_options']['port'] = array(

'#type' => 'textfield',

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

'#default_value' => empty($database['port']) ? '' : $database['port'],

'#size' => 45,

// The maximum port number is 65536, 5 digits.

'#maxlength' => 5,

'#description' => st('If your database server is listening to a non-standard port, enter its number.'),

);

// Table prefix

$db_prefix = ($profile == 'standard') ? 'drupal_' : $profile . '_';

$form['advanced_options']['db_prefix'] = array(

'#type' => 'textfield',

'#title' => st('Table prefix'),

'#default_value' => '',

'#size' => 45,

'#description' => st('If more than one application will be sharing this database, enter a table prefix such as %prefix for your @drupal site here.', array('@drupal' => drupal_install_profile_distribution_name(), '%prefix' => $db_prefix)),

);

$form['actions'] = array('#type' => 'container', '#attributes' => array('class' => array('form-actions')));

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

'#type' => 'submit',

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

);

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

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

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

}

return $form;

form_set_value($form['_database'], $form_state['values'], $form_state);

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

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

form_set_error($name, $message);

}

global $databases;

$errors = array();

// Verify the table prefix

if (!empty($database['db_prefix']) && is_string($database['db_prefix']) && !preg_match('/^[A-Za-z0-9_.]+$/', $database['db_prefix'])) {

$errors['db_prefix'] = st('The database table prefix you have entered, %db_prefix, is invalid. The table prefix can only contain alphanumeric characters, periods, or underscores.', array('%db_prefix' => $database['db_prefix']));

}

if (!empty($database['port']) && !is_numeric($database['port'])) {

$errors['db_port'] = st('Database port must be a number.');

}

// Check database type

$database_types = drupal_detect_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' => $database['driver']));

}

else {

// 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($database['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[] = $e->getMessage();

}

}

return $errors;

global $install_state;

$database = array_intersect_key($form_state['values']['_database'], array_flip(array('driver', 'database', 'username', 'password', 'host', 'port')));

// Update global settings array and save

$settings['databases'] = array(

'value' => array('default' => array('default' => $database)),

'required' => TRUE,

);